Documentation

LeanPool.PebblingLean.UpperBoundRecurrence

Recurrence bridge for the upper bound #

This file connects the probabilistic high-demand construction to the deterministic product recursion. It is still parameterized by the numerical annulus estimates; once those are instantiated, this theorem is the formal recursion step used in the upper bound.

Ordinary upper-bound target for optimal pebbling of hypercubes: for each dimension n, there is a solvable distribution on Q_n of size at most costBound n.

Equations
Instances For
    theorem PebblingLean.Hypercube.hasHypercubePebblingUpperBound_of_highDemandDistribution {costBound minPile : } (h : ∀ (n : ), HasHighDemandDistribution n 1 (costBound n) (minPile n)) :

    Forget the strengthened high-demand invariant and retain only the ordinary one-pebble solvability upper bound.

    theorem PebblingLean.Hypercube.highDemandDistribution_of_recursive_step {costBound minPile : } {n0 : } (hbase : n < n0, HasHighDemandDistribution n 1 (costBound n) (minPile n)) (hstep : ∀ (n : ), n0 n(∀ m < n, HasHighDemandDistribution m 1 (costBound m) (minPile m))HasHighDemandDistribution n 1 (costBound n) (minPile n)) (n : ) :
    HasHighDemandDistribution n 1 (costBound n) (minPile n)

    Abstract strong-induction wrapper for recursive high-demand constructions. The actual upper bound will instantiate costBound and minPile with the chosen recursive dimension split and parameter estimates.

    theorem PebblingLean.Hypercube.hasHighDemandDistribution_constant_base {n costBound minPile : } (hcost : 2 ^ n costBound) (hminPile : minPile 1) :
    HasHighDemandDistribution n 1 costBound minPile

    Base-case helper: the trivial distribution with one pebble on every vertex solves demand 1, and can be weakened to any larger cost bound and any minimum-pile lower bound at most 1.

    theorem PebblingLean.Hypercube.hasHighDemandDistribution_constant_base_with_minPile {n S costBound minPile : } (hS : 1 S) (hcost : 2 ^ n * S costBound) (hminPile : minPile S) :
    HasHighDemandDistribution n 1 costBound minPile

    Base-case helper with large occupied piles: putting S pebbles on every vertex gives ordinary solvability when S ≥ 1, while retaining any requested minimum-pile lower bound at most S.

    theorem PebblingLean.Hypercube.hasSolvableAtMostSize_split_product_of_optimized_chord {a m N rIn rOut Tbase K : } {gap : } (hTbase : 1 Tbase) (hgap_pos : 0 < gap) (hmean : Tbase + gap N * (annulusMean m rIn rOut)) (hlog : ↑(m + 1) * Real.log 2 gap ^ 2 / (4 * 2 ^ (rOut - rIn) * (N * (annulusMean m rIn rOut)))) (hfiber : Pebbling.HasSolvableAtMostSize (graph a) (N * 2 ^ rOut) (2 ^ rOut * K)) :
    Pebbling.HasSolvableAtMostSize (graph (a + m)) 1 (N * 2 ^ rOut * K)

    One formal recursion step from the optimized chord high-demand construction.

    The probabilistic construction supplies a Tbase-solvable distribution on Q_m of size at most N * 2^rOut, with occupied piles of size at least 2^rOut. If Q_a can solve demand N * 2^rOut at cost 2^rOut * K, then the product step gives a solvable distribution on Q_(a+m) of cost (N * 2^rOut) * K.

    theorem PebblingLean.Hypercube.hasHighDemandDistribution_split_product_of_optimized_chord_fiber {a m Tbase costBound S K N rIn rOut : } {gap : } (hTbase : 1 Tbase) (hbase : HasHighDemandDistribution m Tbase costBound S) (hgap_pos : 0 < gap) (hmean : costBound + gap N * (annulusMean a rIn rOut)) (hlog : ↑(a + 1) * Real.log 2 gap ^ 2 / (4 * 2 ^ (rOut - rIn) * (N * (annulusMean a rIn rOut)))) (hfiberCost : N * 2 ^ rOut S * K) :
    HasHighDemandDistribution (a + m) 1 (costBound * K) (2 ^ rOut)

    Recursive high-demand step with an optimized-chord fiber construction.

    An existing high-demand construction on Q_m supplies the demands. The optimized-chord construction on Q_a solves the largest possible demand costBound, with fiber cost bounded by S * K; occupied-pile compression then gives a high-demand distribution on Q_(a+m) with cost costBound * K and new minimum pile size 2^rOut.

    theorem PebblingLean.Hypercube.hasHighDemandDistribution_split_product_of_optimized_chord_fiber_min {a m Tbase costBound S K N rIn rOut minNext : } {gap : } (hTbase : 1 Tbase) (hbase : HasHighDemandDistribution m Tbase costBound S) (hgap_pos : 0 < gap) (hmean : costBound + gap N * (annulusMean a rIn rOut)) (hlog : ↑(a + 1) * Real.log 2 gap ^ 2 / (4 * 2 ^ (rOut - rIn) * (N * (annulusMean a rIn rOut)))) (hfiberCost : N * 2 ^ rOut S * K) (hminNext : minNext 2 ^ rOut) :
    HasHighDemandDistribution (a + m) 1 (costBound * K) minNext

    Same recursive high-demand step, with the new pile-size invariant weakened to any specified lower bound below 2^rOut.

    theorem PebblingLean.Hypercube.hasHighDemandDistribution_split_product_of_optimized_chord_fiber_variable_min {a m Tbase costBound S K rIn rOut minNext : } {N : } {gap : } (hTbase : 1 Tbase) (hbase : HasHighDemandDistribution m Tbase costBound S) (hgap_pos : ∀ (t : ), S t0 < gap t) (hmean : ∀ (t : ), S tt + gap t (N t) * (annulusMean a rIn rOut)) (hlog : ∀ (t : ), S t↑(a + 1) * Real.log 2 gap t ^ 2 / (4 * 2 ^ (rOut - rIn) * ((N t) * (annulusMean a rIn rOut)))) (hfiberCost : ∀ (t : ), S tN t * 2 ^ rOut t * K) (hminNext : minNext 2 ^ rOut) :
    HasHighDemandDistribution (a + m) 1 (costBound * K) minNext

    Variable-demand version of the optimized-chord product step.

    For every occupied pile size t ≥ S in the recursive Q_m distribution, the optimized-chord construction supplies a t-solvable fiber in Q_a of cost t*K. This is the recurrence used in the paper: costs add as ∑_z E z * K = |E|*K, rather than paying for a worst-case demand in every occupied fiber.

    theorem PebblingLean.Hypercube.highDemandDistribution_of_recursive_split_schedule {costBound minPile splitA splitM K N rIn rOut : } {gap : } {n0 : } (hbase : n < n0, HasHighDemandDistribution n 1 (costBound n) (minPile n)) (hsplit : ∀ (n : ), n0 nsplitA n + splitM n = n) (hsmaller : ∀ (n : ), n0 nsplitM n < n) (hgap_pos : ∀ (n : ), n0 n0 < gap n) (hmean : ∀ (n : ), n0 n(costBound (splitM n)) + gap n (N n) * (annulusMean (splitA n) (rIn n) (rOut n))) (hlog : ∀ (n : ), n0 n↑(splitA n + 1) * Real.log 2 gap n ^ 2 / (4 * 2 ^ (rOut n - rIn n) * ((N n) * (annulusMean (splitA n) (rIn n) (rOut n))))) (hfiberCost : ∀ (n : ), n0 nN n * 2 ^ rOut n minPile (splitM n) * K n) (hcost : ∀ (n : ), n0 ncostBound (splitM n) * K n costBound n) (hminPile : ∀ (n : ), n0 nminPile n 2 ^ rOut n) (n : ) :
    HasHighDemandDistribution n 1 (costBound n) (minPile n)

    Abstract recursive split schedule for the upper bound.

    For every large dimension n, the schedule chooses a split Q_n ≃ Q_{splitA n} □ Q_{splitM n}. The inductive hypothesis supplies the base high-demand distribution on Q_{splitM n}; the optimized-chord annulus construction supplies the fiber distribution on Q_{splitA n} for demand costBound (splitM n). The hypotheses here are exactly the numerical conditions that remain after all graph-theoretic, probabilistic, and product bookkeeping has been formalized.

    theorem PebblingLean.Hypercube.highDemandDistribution_of_recursive_split_schedule_variable {costBound minPile splitA splitM K rIn rOut : } {N : } {gap : } {n0 : } (hbase : n < n0, HasHighDemandDistribution n 1 (costBound n) (minPile n)) (hsplit : ∀ (n : ), n0 nsplitA n + splitM n = n) (hsmaller : ∀ (n : ), n0 nsplitM n < n) (hgap_pos : ∀ (n : ), n0 n∀ (t : ), minPile (splitM n) t0 < gap n t) (hmean : ∀ (n : ), n0 n∀ (t : ), minPile (splitM n) tt + gap n t (N n t) * (annulusMean (splitA n) (rIn n) (rOut n))) (hlog : ∀ (n : ), n0 n∀ (t : ), minPile (splitM n) t↑(splitA n + 1) * Real.log 2 gap n t ^ 2 / (4 * 2 ^ (rOut n - rIn n) * ((N n t) * (annulusMean (splitA n) (rIn n) (rOut n))))) (hfiberCost : ∀ (n : ), n0 n∀ (t : ), minPile (splitM n) tN n t * 2 ^ rOut n t * K n) (hcost : ∀ (n : ), n0 ncostBound (splitM n) * K n costBound n) (hminPile : ∀ (n : ), n0 nminPile n 2 ^ rOut n) (n : ) :
    HasHighDemandDistribution n 1 (costBound n) (minPile n)

    Paper-accurate recursive split schedule with variable fiber demand.

    The fixed-demand schedule above asks the Q_a fiber construction to solve the maximum possible pile size in every occupied fiber. The paper instead applies the high-demand lemma separately to each occupied pile size t; this theorem packages that sharper recurrence.

    theorem PebblingLean.Hypercube.highDemandDistribution_of_recursive_split_schedule_constant_base {costBound minPile splitA splitM K N rIn rOut : } {gap : } {n0 : } (hbase_cost : n < n0, 2 ^ n costBound n) (hbase_minPile : n < n0, minPile n 1) (hsplit : ∀ (n : ), n0 nsplitA n + splitM n = n) (hsmaller : ∀ (n : ), n0 nsplitM n < n) (hgap_pos : ∀ (n : ), n0 n0 < gap n) (hmean : ∀ (n : ), n0 n(costBound (splitM n)) + gap n (N n) * (annulusMean (splitA n) (rIn n) (rOut n))) (hlog : ∀ (n : ), n0 n↑(splitA n + 1) * Real.log 2 gap n ^ 2 / (4 * 2 ^ (rOut n - rIn n) * ((N n) * (annulusMean (splitA n) (rIn n) (rOut n))))) (hfiberCost : ∀ (n : ), n0 nN n * 2 ^ rOut n minPile (splitM n) * K n) (hcost : ∀ (n : ), n0 ncostBound (splitM n) * K n costBound n) (hminPile : ∀ (n : ), n0 nminPile n 2 ^ rOut n) (n : ) :
    HasHighDemandDistribution n 1 (costBound n) (minPile n)

    Same recursive split schedule, with the finite base range discharged by the constant one-pebble-per-vertex distribution.

    theorem PebblingLean.Hypercube.highDemandDistribution_of_recursive_split_schedule_large_constant_base {costBound minPile splitA splitM K N rIn rOut : } {gap : } {n0 : } (hbase_minPile_pos : n < n0, 1 minPile n) (hbase_cost : n < n0, 2 ^ n * minPile n costBound n) (hsplit : ∀ (n : ), n0 nsplitA n + splitM n = n) (hsmaller : ∀ (n : ), n0 nsplitM n < n) (hgap_pos : ∀ (n : ), n0 n0 < gap n) (hmean : ∀ (n : ), n0 n(costBound (splitM n)) + gap n (N n) * (annulusMean (splitA n) (rIn n) (rOut n))) (hlog : ∀ (n : ), n0 n↑(splitA n + 1) * Real.log 2 gap n ^ 2 / (4 * 2 ^ (rOut n - rIn n) * ((N n) * (annulusMean (splitA n) (rIn n) (rOut n))))) (hfiberCost : ∀ (n : ), n0 nN n * 2 ^ rOut n minPile (splitM n) * K n) (hcost : ∀ (n : ), n0 ncostBound (splitM n) * K n costBound n) (hminPile : ∀ (n : ), n0 nminPile n 2 ^ rOut n) (n : ) :
    HasHighDemandDistribution n 1 (costBound n) (minPile n)

    Same recursive split schedule, with finite base cases discharged by the constant distribution having exactly the requested minimum pile size on every vertex. This is the base-case form used by the paper recursion, where the large-pile invariant is maintained even below the cutoff dimension.

    theorem PebblingLean.Hypercube.highDemandDistribution_of_recursive_split_schedule_variable_large_constant_base {costBound minPile splitA splitM K rIn rOut : } {N : } {gap : } {n0 : } (hbase_minPile_pos : n < n0, 1 minPile n) (hbase_cost : n < n0, 2 ^ n * minPile n costBound n) (hsplit : ∀ (n : ), n0 nsplitA n + splitM n = n) (hsmaller : ∀ (n : ), n0 nsplitM n < n) (hgap_pos : ∀ (n : ), n0 n∀ (t : ), minPile (splitM n) t0 < gap n t) (hmean : ∀ (n : ), n0 n∀ (t : ), minPile (splitM n) tt + gap n t (N n t) * (annulusMean (splitA n) (rIn n) (rOut n))) (hlog : ∀ (n : ), n0 n∀ (t : ), minPile (splitM n) t↑(splitA n + 1) * Real.log 2 gap n t ^ 2 / (4 * 2 ^ (rOut n - rIn n) * ((N n t) * (annulusMean (splitA n) (rIn n) (rOut n))))) (hfiberCost : ∀ (n : ), n0 n∀ (t : ), minPile (splitM n) tN n t * 2 ^ rOut n t * K n) (hcost : ∀ (n : ), n0 ncostBound (splitM n) * K n costBound n) (hminPile : ∀ (n : ), n0 nminPile n 2 ^ rOut n) (n : ) :
    HasHighDemandDistribution n 1 (costBound n) (minPile n)

    Variable-demand recursive split schedule, with finite base cases discharged by the constant distribution having the requested minimum pile size on every vertex.

    theorem PebblingLean.Hypercube.hasHypercubePebblingUpperBound_of_recursive_split_schedule_constant_base {costBound minPile splitA splitM K N rIn rOut : } {gap : } {n0 : } (hbase_cost : n < n0, 2 ^ n costBound n) (hbase_minPile : n < n0, minPile n 1) (hsplit : ∀ (n : ), n0 nsplitA n + splitM n = n) (hsmaller : ∀ (n : ), n0 nsplitM n < n) (hgap_pos : ∀ (n : ), n0 n0 < gap n) (hmean : ∀ (n : ), n0 n(costBound (splitM n)) + gap n (N n) * (annulusMean (splitA n) (rIn n) (rOut n))) (hlog : ∀ (n : ), n0 n↑(splitA n + 1) * Real.log 2 gap n ^ 2 / (4 * 2 ^ (rOut n - rIn n) * ((N n) * (annulusMean (splitA n) (rIn n) (rOut n))))) (hfiberCost : ∀ (n : ), n0 nN n * 2 ^ rOut n minPile (splitM n) * K n) (hcost : ∀ (n : ), n0 ncostBound (splitM n) * K n costBound n) (hminPile : ∀ (n : ), n0 nminPile n 2 ^ rOut n) :

    Ordinary upper-bound form of the recursive split schedule with constant base cases.

    theorem PebblingLean.Hypercube.hasHypercubePebblingUpperBound_of_recursive_split_schedule_large_constant_base {costBound minPile splitA splitM K N rIn rOut : } {gap : } {n0 : } (hbase_minPile_pos : n < n0, 1 minPile n) (hbase_cost : n < n0, 2 ^ n * minPile n costBound n) (hsplit : ∀ (n : ), n0 nsplitA n + splitM n = n) (hsmaller : ∀ (n : ), n0 nsplitM n < n) (hgap_pos : ∀ (n : ), n0 n0 < gap n) (hmean : ∀ (n : ), n0 n(costBound (splitM n)) + gap n (N n) * (annulusMean (splitA n) (rIn n) (rOut n))) (hlog : ∀ (n : ), n0 n↑(splitA n + 1) * Real.log 2 gap n ^ 2 / (4 * 2 ^ (rOut n - rIn n) * ((N n) * (annulusMean (splitA n) (rIn n) (rOut n))))) (hfiberCost : ∀ (n : ), n0 nN n * 2 ^ rOut n minPile (splitM n) * K n) (hcost : ∀ (n : ), n0 ncostBound (splitM n) * K n costBound n) (hminPile : ∀ (n : ), n0 nminPile n 2 ^ rOut n) :

    Ordinary upper-bound form of the recursive split schedule with large-pile constant base cases.

    theorem PebblingLean.Hypercube.hasHypercubePebblingUpperBound_of_recursive_split_schedule_variable_large_constant_base {costBound minPile splitA splitM K rIn rOut : } {N : } {gap : } {n0 : } (hbase_minPile_pos : n < n0, 1 minPile n) (hbase_cost : n < n0, 2 ^ n * minPile n costBound n) (hsplit : ∀ (n : ), n0 nsplitA n + splitM n = n) (hsmaller : ∀ (n : ), n0 nsplitM n < n) (hgap_pos : ∀ (n : ), n0 n∀ (t : ), minPile (splitM n) t0 < gap n t) (hmean : ∀ (n : ), n0 n∀ (t : ), minPile (splitM n) tt + gap n t (N n t) * (annulusMean (splitA n) (rIn n) (rOut n))) (hlog : ∀ (n : ), n0 n∀ (t : ), minPile (splitM n) t↑(splitA n + 1) * Real.log 2 gap n t ^ 2 / (4 * 2 ^ (rOut n - rIn n) * ((N n t) * (annulusMean (splitA n) (rIn n) (rOut n))))) (hfiberCost : ∀ (n : ), n0 n∀ (t : ), minPile (splitM n) tN n t * 2 ^ rOut n t * K n) (hcost : ∀ (n : ), n0 ncostBound (splitM n) * K n costBound n) (hminPile : ∀ (n : ), n0 nminPile n 2 ^ rOut n) :

    Ordinary upper-bound form of the variable-demand recursive split schedule with large-pile constant base cases.