File: Mathlib/Combinatorics/SimpleGraph/Regularity/Bound.lean

full_name: SzemerediRegularity.stepBound
code: /-- Auxiliary function for Szemerédi's regularity lemma. Blowing up a partition of size `n` during
the induction results in a partition of size at most `stepBound n`. -/
def stepBound (n : ℕ) : ℕ 
goal: ℕ

full_name: SzemerediRegularity.le_stepBound
code: theorem le_stepBound : id ≤ stepBound 
goal: id ≤ SzemerediRegularity.stepBound

full_name: SzemerediRegularity.stepBound_mono
code: theorem stepBound_mono : Monotone stepBound 
goal: Monotone SzemerediRegularity.stepBound

full_name: SzemerediRegularity.stepBound_pos_iff
code: theorem stepBound_pos_iff {n : ℕ} : 0 < stepBound n ↔ 0 < n 
goal: 0 < SzemerediRegularity.stepBound n ↔ 0 < n

full_name: SzemerediRegularity.coe_stepBound
code: @[norm_cast] lemma coe_stepBound {α : Type*} [Semiring α] (n : ℕ) :
    (stepBound n : α) = n * 4 ^ n 
goal: ↑(SzemerediRegularity.stepBound n) = ↑n * 4 ^ n

full_name: _aux_Mathlib_Combinatorics_SimpleGraph_Regularity_Bound___macroRules_termM_1
code: local notation3 "m" => (card α / stepBound P.parts.card : ℕ)
goal: Lean.Macro

full_name: _aux_Mathlib_Combinatorics_SimpleGraph_Regularity_Bound___macroRules_termA_1
code: local notation3 "a" => (card α / P.parts.card - m * 4 ^ P.parts.card : ℕ)
goal: Lean.Macro

full_name: _private.Mathlib.Combinatorics.SimpleGraph.Regularity.Bound.0.SzemerediRegularity.Positivity.eps_pos
code: private theorem eps_pos {ε : ℝ} {n : ℕ} (h : 100 ≤ (4 : ℝ) ^ n * ε ^ 5) : 0 < ε 
goal: 0 < ε

full_name: _private.Mathlib.Combinatorics.SimpleGraph.Regularity.Bound.0.SzemerediRegularity.Positivity.m_pos
code: private theorem m_pos [Nonempty α] (hPα : P.parts.card * 16 ^ P.parts.card ≤ card α) : 0 < m 
goal: 0 < m

full_name: SzemerediRegularity.Positivity.tacticSz_positivity
code: macro "sz_positivity" : tactic =>
  `(tactic|
      { try have := m_pos ‹_›
        try have := eps_pos ‹_›
        positivity })
goal: Lean.ParserDescr

full_name: SzemerediRegularity.Positivity._aux_Mathlib_Combinatorics_SimpleGraph_Regularity_Bound___macroRules_SzemerediRegularity_Positivity_tacticSz_positivity_1
code: macro "sz_positivity" : tactic =>
  `(tactic|
      { try have := m_pos ‹_›
        try have := eps_pos ‹_›
        positivity })
goal: Lean.Macro

full_name: SzemerediRegularity.m_pos
code: theorem m_pos [Nonempty α] (hPα : P.parts.card * 16 ^ P.parts.card ≤ card α) : 0 < m 
goal: 0 < m

full_name: SzemerediRegularity.coe_m_add_one_pos
code: theorem coe_m_add_one_pos : 0 < (m : ℝ) + 1 
goal: 0 < ↑m + 1

full_name: SzemerediRegularity.one_le_m_coe
code: theorem one_le_m_coe [Nonempty α] (hPα : P.parts.card * 16 ^ P.parts.card ≤ card α) : (1 : ℝ) ≤ m 
goal: 1 ≤ ↑m

full_name: SzemerediRegularity.eps_pow_five_pos
code: theorem eps_pow_five_pos (hPε : 100 ≤ (4 : ℝ) ^ P.parts.card * ε ^ 5) : ↑0 < ε ^ 5 
goal: 0 < ε ^ 5

full_name: SzemerediRegularity.eps_pos
code: theorem eps_pos (hPε : 100 ≤ (4 : ℝ) ^ P.parts.card * ε ^ 5) : 0 < ε 
goal: 0 < ε

full_name: SzemerediRegularity.hundred_div_ε_pow_five_le_m
code: theorem hundred_div_ε_pow_five_le_m [Nonempty α] (hPα : P.parts.card * 16 ^ P.parts.card ≤ card α)
    (hPε : 100 ≤ (4 : ℝ) ^ P.parts.card * ε ^ 5) : 100 / ε ^ 5 ≤ m 
goal: 100 / ε ^ 5 ≤ ↑m

full_name: SzemerediRegularity.hundred_le_m
code: theorem hundred_le_m [Nonempty α] (hPα : P.parts.card * 16 ^ P.parts.card ≤ card α)
    (hPε : 100 ≤ (4 : ℝ) ^ P.parts.card * ε ^ 5) (hε : ε ≤ 1) : 100 ≤ m 
goal: 100 ≤ m

full_name: SzemerediRegularity.a_add_one_le_four_pow_parts_card
code: theorem a_add_one_le_four_pow_parts_card : a + 1 ≤ 4 ^ P.parts.card 
goal: a + 1 ≤ 4 ^ P.parts.card

full_name: SzemerediRegularity.card_aux₁
code: theorem card_aux₁ (hucard : u.card = m * 4 ^ P.parts.card + a) :
    (4 ^ P.parts.card - a) * m + a * (m + 1) = u.card 
goal: (4 ^ P.parts.card - a) * m + a * (m + 1) = u.card

full_name: SzemerediRegularity.card_aux₂
code: theorem card_aux₂ (hP : P.IsEquipartition) (hu : u ∈ P.parts)
    (hucard : ¬u.card = m * 4 ^ P.parts.card + a) :
    (4 ^ P.parts.card - (a + 1)) * m + (a + 1) * (m + 1) = u.card 
goal: (4 ^ P.parts.card - (a + 1)) * m + (a + 1) * (m + 1) = u.card

full_name: SzemerediRegularity.pow_mul_m_le_card_part
code: theorem pow_mul_m_le_card_part (hP : P.IsEquipartition) (hu : u ∈ P.parts) :
    (4 : ℝ) ^ P.parts.card * m ≤ u.card 
goal: 4 ^ P.parts.card * ↑m ≤ ↑u.card

full_name: SzemerediRegularity.initialBound
code: /-- Auxiliary function for Szemerédi's regularity lemma. The size of the partition by which we start
blowing. -/
noncomputable def initialBound : ℕ 
goal: ℕ

full_name: SzemerediRegularity.le_initialBound
code: theorem le_initialBound : l ≤ initialBound ε l 
goal: l ≤ SzemerediRegularity.initialBound ε l

full_name: SzemerediRegularity.seven_le_initialBound
code: theorem seven_le_initialBound : 7 ≤ initialBound ε l 
goal: 7 ≤ SzemerediRegularity.initialBound ε l

full_name: SzemerediRegularity.initialBound_pos
code: theorem initialBound_pos : 0 < initialBound ε l 
goal: 0 < SzemerediRegularity.initialBound ε l

full_name: SzemerediRegularity.hundred_lt_pow_initialBound_mul
code: theorem hundred_lt_pow_initialBound_mul {ε : ℝ} (hε : 0 < ε) (l : ℕ) :
    100 < ↑4 ^ initialBound ε l * ε ^ 5 
goal: 100 < 4 ^ SzemerediRegularity.initialBound ε l * ε ^ 5

full_name: SzemerediRegularity.bound
code: /-- An explicit bound on the size of the equipartition whose existence is given by Szemerédi's
regularity lemma. -/
noncomputable def bound : ℕ 
goal: ℕ

full_name: SzemerediRegularity.initialBound_le_bound
code: theorem initialBound_le_bound : initialBound ε l ≤ bound ε l 
goal: SzemerediRegularity.initialBound ε l ≤ SzemerediRegularity.bound ε l

full_name: SzemerediRegularity.le_bound
code: theorem le_bound : l ≤ bound ε l 
goal: l ≤ SzemerediRegularity.bound ε l

full_name: SzemerediRegularity.bound_pos
code: theorem bound_pos : 0 < bound ε l 
goal: 0 < SzemerediRegularity.bound ε l

full_name: SzemerediRegularity.mul_sq_le_sum_sq
code: theorem mul_sq_le_sum_sq (hst : s ⊆ t) (f : ι → 𝕜) (hs : x ^ 2 ≤ ((∑ i ∈ s, f i) / s.card) ^ 2)
    (hs' : (s.card : 𝕜) ≠ 0) : (s.card : 𝕜) * x ^ 2 ≤ ∑ i ∈ t, f i ^ 2 
goal: ↑s.card * x ^ 2 ≤ ∑ i ∈ t, f i ^ 2

full_name: SzemerediRegularity.add_div_le_sum_sq_div_card
code: theorem add_div_le_sum_sq_div_card (hst : s ⊆ t) (f : ι → 𝕜) (d : 𝕜) (hx : 0 ≤ x)
    (hs : x ≤ |(∑ i ∈ s, f i) / s.card - (∑ i ∈ t, f i) / t.card|)
    (ht : d ≤ ((∑ i ∈ t, f i) / t.card) ^ 2) :
    d + s.card / t.card * x ^ 2 ≤ (∑ i ∈ t, f i ^ 2) / t.card 
goal: d + ↑s.card / ↑t.card * x ^ 2 ≤ (∑ i ∈ t, f i ^ 2) / ↑t.card

full_name: Mathlib.Meta.Positivity.evalInitialBound
code: /-- Extension for the `positivity` tactic: `SzemerediRegularity.initialBound` is always positive. -/
@[positivity SzemerediRegularity.initialBound _ _]
def evalInitialBound : PositivityExt 
goal: Mathlib.Meta.Positivity.PositivityExt

full_name: Mathlib.Meta.Positivity.evalBound
code: /-- Extension for the `positivity` tactic: `SzemerediRegularity.bound` is always positive. -/
@[positivity SzemerediRegularity.bound _ _]
def evalBound : PositivityExt 
goal: Mathlib.Meta.Positivity.PositivityExt