ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- ProbabilityTheory.Kernel.integral_integral_add
theorem Kernel.integral_integral_add ⦃f g : β × γ → E⦄ (hf : Integrable f ((κ ⊗ₖ η) a))
    (hg : Integrable g ((κ ⊗ₖ η) a)) :
    ∫ x, ∫ y, f (x, y) + g (x, y) ∂η (a, x) ∂κ a =
      ∫ x, ∫ y, f (x, y) ∂η (a, x) ∂κ a + ∫ x, ∫ y, g (x, y) ∂η (a, x) ∂κ a 
Arguments: {α : Type u_1} {β : Type u_2} {γ : Type u_3} {E : Type u_4} {mα : MeasurableSpace α} {mβ : MeasurableSpace β} {mγ : MeasurableSpace γ} [NormedAddCommGroup E] {κ : ProbabilityTheory.Kernel α β} [ProbabilityTheory.IsSFiniteKernel κ] {η : ProbabilityTheory.Kernel (α × β) γ} [ProbabilityTheory.IsSFiniteKernel η] {a : α} [NormedSpace ℝ E] ⦃f g : β × γ → E⦄ (hf : MeasureTheory.Integrable f ((κ ⊗ₖ η) a)) (hg : MeasureTheory.Integrable g ((κ ⊗ₖ η) a))
Goal: ∫ (x : β), ∫ (y : γ), f (x, y) + g (x, y) ∂η (a, x) ∂κ a =
  ∫ (x : β), ∫ (y : γ), f (x, y) ∂η (a, x) ∂κ a + ∫ (x : β), ∫ (y : γ), g (x, y) ∂η (a, x) ∂κ a
-- ProbabilityTheory.Kernel.integral_integral_add'
theorem Kernel.integral_integral_add' ⦃f g : β × γ → E⦄ (hf : Integrable f ((κ ⊗ₖ η) a))
    (hg : Integrable g ((κ ⊗ₖ η) a)) :
    ∫ x, ∫ y, (f + g) (x, y) ∂η (a, x) ∂κ a =
      ∫ x, ∫ y, f (x, y) ∂η (a, x) ∂κ a + ∫ x, ∫ y, g (x, y) ∂η (a, x) ∂κ a 
Arguments: {α : Type u_1} {β : Type u_2} {γ : Type u_3} {E : Type u_4} {mα : MeasurableSpace α} {mβ : MeasurableSpace β} {mγ : MeasurableSpace γ} [NormedAddCommGroup E] {κ : ProbabilityTheory.Kernel α β} [ProbabilityTheory.IsSFiniteKernel κ] {η : ProbabilityTheory.Kernel (α × β) γ} [ProbabilityTheory.IsSFiniteKernel η] {a : α} [NormedSpace ℝ E] ⦃f g : β × γ → E⦄ (hf : MeasureTheory.Integrable f ((κ ⊗ₖ η) a)) (hg : MeasureTheory.Integrable g ((κ ⊗ₖ η) a))
Goal: ∫ (x : β), ∫ (y : γ), (f + g) (x, y) ∂η (a, x) ∂κ a =
  ∫ (x : β), ∫ (y : γ), f (x, y) ∂η (a, x) ∂κ a + ∫ (x : β), ∫ (y : γ), g (x, y) ∂η (a, x) ∂κ a
-- ProbabilityTheory.Kernel.integral_integral_sub
theorem Kernel.integral_integral_sub ⦃f g : β × γ → E⦄ (hf : Integrable f ((κ ⊗ₖ η) a))
    (hg : Integrable g ((κ ⊗ₖ η) a)) :
    ∫ x, ∫ y, f (x, y) - g (x, y) ∂η (a, x) ∂κ a =
      ∫ x, ∫ y, f (x, y) ∂η (a, x) ∂κ a - ∫ x, ∫ y, g (x, y) ∂η (a, x) ∂κ a 
Arguments: {α : Type u_1} {β : Type u_2} {γ : Type u_3} {E : Type u_4} {mα : MeasurableSpace α} {mβ : MeasurableSpace β} {mγ : MeasurableSpace γ} [NormedAddCommGroup E] {κ : ProbabilityTheory.Kernel α β} [ProbabilityTheory.IsSFiniteKernel κ] {η : ProbabilityTheory.Kernel (α × β) γ} [ProbabilityTheory.IsSFiniteKernel η] {a : α} [NormedSpace ℝ E] ⦃f g : β × γ → E⦄ (hf : MeasureTheory.Integrable f ((κ ⊗ₖ η) a)) (hg : MeasureTheory.Integrable g ((κ ⊗ₖ η) a))
Goal: ∫ (x : β), ∫ (y : γ), f (x, y) - g (x, y) ∂η (a, x) ∂κ a =
  ∫ (x : β), ∫ (y : γ), f (x, y) ∂η (a, x) ∂κ a - ∫ (x : β), ∫ (y : γ), g (x, y) ∂η (a, x) ∂κ a
-- ProbabilityTheory.Kernel.integral_integral_sub'
theorem Kernel.integral_integral_sub' ⦃f g : β × γ → E⦄ (hf : Integrable f ((κ ⊗ₖ η) a))
    (hg : Integrable g ((κ ⊗ₖ η) a)) :
    ∫ x, ∫ y, (f - g) (x, y) ∂η (a, x) ∂κ a =
      ∫ x, ∫ y, f (x, y) ∂η (a, x) ∂κ a - ∫ x, ∫ y, g (x, y) ∂η (a, x) ∂κ a 
Arguments: {α : Type u_1} {β : Type u_2} {γ : Type u_3} {E : Type u_4} {mα : MeasurableSpace α} {mβ : MeasurableSpace β} {mγ : MeasurableSpace γ} [NormedAddCommGroup E] {κ : ProbabilityTheory.Kernel α β} [ProbabilityTheory.IsSFiniteKernel κ] {η : ProbabilityTheory.Kernel (α × β) γ} [ProbabilityTheory.IsSFiniteKernel η] {a : α} [NormedSpace ℝ E] ⦃f g : β × γ → E⦄ (hf : MeasureTheory.Integrable f ((κ ⊗ₖ η) a)) (hg : MeasureTheory.Integrable g ((κ ⊗ₖ η) a))
Goal: ∫ (x : β), ∫ (y : γ), (f - g) (x, y) ∂η (a, x) ∂κ a =
  ∫ (x : β), ∫ (y : γ), f (x, y) ∂η (a, x) ∂κ a - ∫ (x : β), ∫ (y : γ), g (x, y) ∂η (a, x) ∂κ a
-- ProbabilityTheory.Kernel.continuous_integral_integral
theorem Kernel.continuous_integral_integral :
    -- Continuous fun f : α × β →₁[(κ ⊗ₖ η) a] E => ∫ x, ∫ y, f (x, y) ∂η (a, x) ∂κ a := by
    Continuous fun f : (MeasureTheory.Lp (α := β × γ) E 1 (((κ ⊗ₖ η) a) : Measure (β × γ))) =>
        ∫ x, ∫ y, f (x, y) ∂η (a, x) ∂κ a 
Arguments: {α : Type u_1} {β : Type u_2} {γ : Type u_3} {E : Type u_4} {mα : MeasurableSpace α} {mβ : MeasurableSpace β} {mγ : MeasurableSpace γ} [NormedAddCommGroup E] {κ : ProbabilityTheory.Kernel α β} [ProbabilityTheory.IsSFiniteKernel κ] {η : ProbabilityTheory.Kernel (α × β) γ} [ProbabilityTheory.IsSFiniteKernel η] {a : α} [NormedSpace ℝ E]
Goal: Continuous fun f => ∫ (x : β), ∫ (y : γ), ↑↑f (x, y) ∂η (a, x) ∂κ a
-- ProbabilityTheory.integral_compProd
theorem integral_compProd :
    ∀ {f : β × γ → E} (_ : Integrable f ((κ ⊗ₖ η) a)),
      ∫ z, f z ∂(κ ⊗ₖ η) a = ∫ x, ∫ y, f (x, y) ∂η (a, x) ∂κ a 
Arguments: {α : Type u_1} {β : Type u_2} {γ : Type u_3} {E : Type u_4} {mα : MeasurableSpace α} {mβ : MeasurableSpace β} {mγ : MeasurableSpace γ} [NormedAddCommGroup E] {κ : ProbabilityTheory.Kernel α β} [ProbabilityTheory.IsSFiniteKernel κ] {η : ProbabilityTheory.Kernel (α × β) γ} [ProbabilityTheory.IsSFiniteKernel η] {a : α} [NormedSpace ℝ E] {f : β × γ → E}
Goal: MeasureTheory.Integrable f ((κ ⊗ₖ η) a) → ∫ (z : β × γ), f z ∂(κ ⊗ₖ η) a = ∫ (x : β), ∫ (y : γ), f (x, y) ∂η (a, x) ∂κ a
-- ProbabilityTheory.setIntegral_compProd
theorem setIntegral_compProd {f : β × γ → E} {s : Set β} {t : Set γ} (hs : MeasurableSet s)
    (ht : MeasurableSet t) (hf : IntegrableOn f (s ×ˢ t) ((κ ⊗ₖ η) a)) :
    ∫ z in s ×ˢ t, f z ∂(κ ⊗ₖ η) a = ∫ x in s, ∫ y in t, f (x, y) ∂η (a, x) ∂κ a 
Arguments: {α : Type u_1} {β : Type u_2} {γ : Type u_3} {E : Type u_4} {mα : MeasurableSpace α} {mβ : MeasurableSpace β} {mγ : MeasurableSpace γ} [NormedAddCommGroup E] {κ : ProbabilityTheory.Kernel α β} [ProbabilityTheory.IsSFiniteKernel κ] {η : ProbabilityTheory.Kernel (α × β) γ} [ProbabilityTheory.IsSFiniteKernel η] {a : α} [NormedSpace ℝ E] {f : β × γ → E} {s : Set β} {t : Set γ} (hs : MeasurableSet s) (ht : MeasurableSet t) (hf : MeasureTheory.IntegrableOn f (s ×ˢ t) ((κ ⊗ₖ η) a))
Goal: ∫ (z : β × γ) in s ×ˢ t, f z ∂(κ ⊗ₖ η) a = ∫ (x : β) in s, ∫ (y : γ) in t, f (x, y) ∂η (a, x) ∂κ a
-- ProbabilityTheory.setIntegral_compProd_univ_right
theorem setIntegral_compProd_univ_right (f : β × γ → E) {s : Set β} (hs : MeasurableSet s)
    (hf : IntegrableOn f (s ×ˢ univ) ((κ ⊗ₖ η) a)) :
    ∫ z in s ×ˢ univ, f z ∂(κ ⊗ₖ η) a = ∫ x in s, ∫ y, f (x, y) ∂η (a, x) ∂κ a 
Arguments: {α : Type u_1} {β : Type u_2} {γ : Type u_3} {E : Type u_4} {mα : MeasurableSpace α} {mβ : MeasurableSpace β} {mγ : MeasurableSpace γ} [NormedAddCommGroup E] {κ : ProbabilityTheory.Kernel α β} [ProbabilityTheory.IsSFiniteKernel κ] {η : ProbabilityTheory.Kernel (α × β) γ} [ProbabilityTheory.IsSFiniteKernel η] {a : α} [NormedSpace ℝ E] (f : β × γ → E) {s : Set β} (hs : MeasurableSet s) (hf : MeasureTheory.IntegrableOn f (s ×ˢ Set.univ) ((κ ⊗ₖ η) a))
Goal: ∫ (z : β × γ) in s ×ˢ Set.univ, f z ∂(κ ⊗ₖ η) a = ∫ (x : β) in s, ∫ (y : γ), f (x, y) ∂η (a, x) ∂κ a
-- ProbabilityTheory.setIntegral_compProd_univ_left
theorem setIntegral_compProd_univ_left (f : β × γ → E) {t : Set γ} (ht : MeasurableSet t)
    (hf : IntegrableOn f (univ ×ˢ t) ((κ ⊗ₖ η) a)) :
    ∫ z in univ ×ˢ t, f z ∂(κ ⊗ₖ η) a = ∫ x, ∫ y in t, f (x, y) ∂η (a, x) ∂κ a 
Arguments: {α : Type u_1} {β : Type u_2} {γ : Type u_3} {E : Type u_4} {mα : MeasurableSpace α} {mβ : MeasurableSpace β} {mγ : MeasurableSpace γ} [NormedAddCommGroup E] {κ : ProbabilityTheory.Kernel α β} [ProbabilityTheory.IsSFiniteKernel κ] {η : ProbabilityTheory.Kernel (α × β) γ} [ProbabilityTheory.IsSFiniteKernel η] {a : α} [NormedSpace ℝ E] (f : β × γ → E) {t : Set γ} (ht : MeasurableSet t) (hf : MeasureTheory.IntegrableOn f (Set.univ ×ˢ t) ((κ ⊗ₖ η) a))
Goal: ∫ (z : β × γ) in Set.univ ×ˢ t, f z ∂(κ ⊗ₖ η) a = ∫ (x : β), ∫ (y : γ) in t, f (x, y) ∂η (a, x) ∂κ a
-- MeasureTheory.Filtration.le'
structure Filtration {Ω : Type*} (ι : Type*) [Preorder ι] (m : MeasurableSpace Ω) where
  seq : ι → MeasurableSpace Ω
  mono' : Monotone seq
  le' : ∀ i : ι, seq i ≤ m
Arguments: {Ω : Type u_1} {ι : Type u_2} [Preorder ι] {m : MeasurableSpace Ω} (self : MeasureTheory.Filtration ι m) (i : ι)
Goal: ↑self i ≤ m
-- MeasureTheory.Filtration.mono'
structure Filtration {Ω : Type*} (ι : Type*) [Preorder ι] (m : MeasurableSpace Ω) where
  seq : ι → MeasurableSpace Ω
  mono' : Monotone seq
  le' : ∀ i : ι, seq i ≤ m
Arguments: {Ω : Type u_1} {ι : Type u_2} [Preorder ι] {m : MeasurableSpace Ω} (self : MeasureTheory.Filtration ι m)
Goal: Monotone ↑self
-- MeasureTheory.Filtration.mono
protected theorem mono {i j : ι} (f : Filtration ι m) (hij : i ≤ j) : f i ≤ f j 
Arguments: {Ω : Type u_1} {ι : Type u_3} {m : MeasurableSpace Ω} [Preorder ι] {i j : ι} (f : MeasureTheory.Filtration ι m) (hij : i ≤ j)
Goal: ↑f i ≤ ↑f j
-- MeasureTheory.Filtration.le
protected theorem le (f : Filtration ι m) (i : ι) : f i ≤ m 
Arguments: {Ω : Type u_1} {ι : Type u_3} {m : MeasurableSpace Ω} [Preorder ι] (f : MeasureTheory.Filtration ι m) (i : ι)
Goal: ↑f i ≤ m
-- MeasureTheory.Filtration.ext
@[ext]
protected theorem ext {f g : Filtration ι m} (h : (f : ι → MeasurableSpace Ω) = g) : f = g 
Arguments: {Ω : Type u_1} {ι : Type u_3} {m : MeasurableSpace Ω} [Preorder ι] {f g : MeasureTheory.Filtration ι m} (h : ↑f = ↑g)
Goal: f = g
-- MeasureTheory.Filtration.const_apply
@[simp]
theorem const_apply {m' : MeasurableSpace Ω} {hm' : m' ≤ m} (i : ι) : const ι m' hm' i = m' 
Arguments: {Ω : Type u_1} {ι : Type u_3} {m : MeasurableSpace Ω} [Preorder ι] {m' : MeasurableSpace Ω} {hm' : m' ≤ m} (i : ι)
Goal: ↑(MeasureTheory.Filtration.const ι m' hm') i = m'
-- MeasureTheory.Filtration.coeFn_sup
@[norm_cast]
theorem coeFn_sup {f g : Filtration ι m} : ⇑(f ⊔ g) = ⇑f ⊔ ⇑g 
Arguments: {Ω : Type u_1} {ι : Type u_3} {m : MeasurableSpace Ω} [Preorder ι] {f g : MeasureTheory.Filtration ι m}
Goal: ↑(f ⊔ g) = ↑f ⊔ ↑g
-- MeasureTheory.Filtration.coeFn_inf
@[norm_cast]
theorem coeFn_inf {f g : Filtration ι m} : ⇑(f ⊓ g) = ⇑f ⊓ ⇑g 
Arguments: {Ω : Type u_1} {ι : Type u_3} {m : MeasurableSpace Ω} [Preorder ι] {f g : MeasureTheory.Filtration ι m}
Goal: ↑(f ⊓ g) = ↑f ⊓ ↑g
-- MeasureTheory.Filtration.sSup_def
theorem sSup_def (s : Set (Filtration ι m)) (i : ι) :
    sSup s i = sSup ((fun f : Filtration ι m => f i) '' s) 
Arguments: {Ω : Type u_1} {ι : Type u_3} {m : MeasurableSpace Ω} [Preorder ι] (s : Set (MeasureTheory.Filtration ι m)) (i : ι)
Goal: ↑(sSup s) i = sSup ((fun f => ↑f i) '' s)
-- MeasureTheory.Filtration.sInf_def
theorem sInf_def (s : Set (Filtration ι m)) (i : ι) :
    sInf s i = if Set.Nonempty s then sInf ((fun f : Filtration ι m => f i) '' s) else m 
Arguments: {Ω : Type u_1} {ι : Type u_3} {m : MeasurableSpace Ω} [Preorder ι] (s : Set (MeasureTheory.Filtration ι m)) (i : ι)
Goal: ↑(sInf s) i = if s.Nonempty then sInf ((fun f => ↑f i) '' s) else m
-- MeasureTheory.measurableSet_of_filtration
theorem measurableSet_of_filtration [Preorder ι] {f : Filtration ι m} {s : Set Ω} {i : ι}
    (hs : MeasurableSet[f i] s) : MeasurableSet[m] s 
Arguments: {Ω : Type u_1} {ι : Type u_3} {m : MeasurableSpace Ω} [Preorder ι] {f : MeasureTheory.Filtration ι m} {s : Set Ω} {i : ι} (hs : MeasurableSet s)
Goal: MeasurableSet s
-- MeasureTheory.SigmaFiniteFiltration.SigmaFinite
class SigmaFiniteFiltration [Preorder ι] (μ : Measure Ω) (f : Filtration ι m) : Prop where
  SigmaFinite : ∀ i : ι, SigmaFinite (μ.trim (f.le i))
Arguments: {Ω : Type u_1} {ι : Type u_3} {m : MeasurableSpace Ω} [Preorder ι] {μ : MeasureTheory.Measure Ω} {f : MeasureTheory.Filtration ι m} [self : MeasureTheory.SigmaFiniteFiltration μ f] (i : ι)
Goal: MeasureTheory.SigmaFinite (μ.trim ⋯)
-- MeasureTheory.Integrable.uniformIntegrable_condexp_filtration
theorem Integrable.uniformIntegrable_condexp_filtration [Preorder ι] {μ : Measure Ω}
    [IsFiniteMeasure μ] {f : Filtration ι m} {g : Ω → ℝ} (hg : Integrable g μ) :
    UniformIntegrable (fun i => μ[g|f i]) 1 μ 
Arguments: {Ω : Type u_1} {ι : Type u_3} {m : MeasurableSpace Ω} [Preorder ι] {μ : MeasureTheory.Measure Ω} [MeasureTheory.IsFiniteMeasure μ] {f : MeasureTheory.Filtration ι m} {g : Ω → ℝ} (hg : MeasureTheory.Integrable g μ)
Goal: MeasureTheory.UniformIntegrable (fun i => μ[g|↑f i]) 1 μ
-- MeasureTheory.measurableSet_filtrationOfSet
theorem measurableSet_filtrationOfSet {s : ι → Set Ω} (hsm : ∀ i, MeasurableSet[m] (s i)) (i : ι)
    {j : ι} (hj : j ≤ i) : MeasurableSet[filtrationOfSet hsm i] (s j) 
Arguments: {Ω : Type u_1} {ι : Type u_3} {m : MeasurableSpace Ω} [Preorder ι] {s : ι → Set Ω} (hsm : ∀ (i : ι), MeasurableSet (s i)) (i : ι) {j : ι} (hj : j ≤ i)
Goal: MeasurableSet (s j)
-- MeasureTheory.measurableSet_filtrationOfSet'
theorem measurableSet_filtrationOfSet' {s : ι → Set Ω} (hsm : ∀ n, MeasurableSet[m] (s n))
    (i : ι) : MeasurableSet[filtrationOfSet hsm i] (s i) 
Arguments: {Ω : Type u_1} {ι : Type u_3} {m : MeasurableSpace Ω} [Preorder ι] {s : ι → Set Ω} (hsm : ∀ (n : ι), MeasurableSet (s n)) (i : ι)
Goal: MeasurableSet (s i)
-- MeasureTheory.Filtration.filtrationOfSet_eq_natural
theorem filtrationOfSet_eq_natural [MulZeroOneClass β] [Nontrivial β] {s : ι → Set Ω}
    (hsm : ∀ i, MeasurableSet[m] (s i)) :
    filtrationOfSet hsm = natural (fun i => (s i).indicator (fun _ => 1 : Ω → β)) fun i =>
      stronglyMeasurable_one.indicator (hsm i) 
Arguments: {Ω : Type u_1} {β : Type u_2} {ι : Type u_3} {m : MeasurableSpace Ω} [TopologicalSpace β] [TopologicalSpace.MetrizableSpace β] [mβ : MeasurableSpace β] [BorelSpace β] [Preorder ι] [MulZeroOneClass β] [Nontrivial β] {s : ι → Set Ω} (hsm : ∀ (i : ι), MeasurableSet (s i))
Goal: MeasureTheory.filtrationOfSet hsm = MeasureTheory.Filtration.natural (fun i => (s i).indicator fun x => 1) ⋯
-- MeasureTheory.Filtration.stronglyMeasurable_limitProcess
theorem stronglyMeasurable_limitProcess : StronglyMeasurable[⨆ n, ℱ n] (limitProcess f ℱ μ) 
Arguments: {Ω : Type u_1} {ι : Type u_3} {m : MeasurableSpace Ω} [Preorder ι] {E : Type u_4} [Zero E] [TopologicalSpace E] {ℱ : MeasureTheory.Filtration ι m} {f : ι → Ω → E} {μ : MeasureTheory.Measure Ω}
Goal: MeasureTheory.StronglyMeasurable (MeasureTheory.Filtration.limitProcess f ℱ μ)
-- MeasureTheory.Filtration.stronglyMeasurable_limit_process'
theorem stronglyMeasurable_limit_process' : StronglyMeasurable[m] (limitProcess f ℱ μ) 
Arguments: {Ω : Type u_1} {ι : Type u_3} {m : MeasurableSpace Ω} [Preorder ι] {E : Type u_4} [Zero E] [TopologicalSpace E] {ℱ : MeasureTheory.Filtration ι m} {f : ι → Ω → E} {μ : MeasureTheory.Measure Ω}
Goal: MeasureTheory.StronglyMeasurable (MeasureTheory.Filtration.limitProcess f ℱ μ)
-- MeasureTheory.Filtration.memℒp_limitProcess_of_eLpNorm_bdd
theorem memℒp_limitProcess_of_eLpNorm_bdd {R : ℝ≥0} {p : ℝ≥0∞} {F : Type*} [NormedAddCommGroup F]
    {ℱ : Filtration ℕ m} {f : ℕ → Ω → F} (hfm : ∀ n, AEStronglyMeasurable (f n) μ)
    (hbdd : ∀ n, eLpNorm (f n) p μ ≤ R) : Memℒp (limitProcess f ℱ μ) p μ 
Arguments: {Ω : Type u_1} {m : MeasurableSpace Ω} {μ : MeasureTheory.Measure Ω} {R : ℝ≥0} {p : ℝ≥0∞} {F : Type u_5} [NormedAddCommGroup F] {ℱ : MeasureTheory.Filtration ℕ m} {f : ℕ → Ω → F} (hfm : ∀ (n : ℕ), MeasureTheory.AEStronglyMeasurable (f n) μ) (hbdd : ∀ (n : ℕ), MeasureTheory.eLpNorm (f n) p μ ≤ ↑R)
Goal: MeasureTheory.Memℒp (MeasureTheory.Filtration.limitProcess f ℱ μ) p μ
-- AkraBazziRecurrence.GrowsPolynomially.congr_of_eventuallyEq
lemma congr_of_eventuallyEq {f g : ℝ → ℝ} (hfg : f =ᶠ[atTop] g) (hg : GrowsPolynomially g) :
    GrowsPolynomially f 
Arguments: {f g : ℝ → ℝ} (hfg : f =ᶠ[Filter.atTop] g) (hg : AkraBazziRecurrence.GrowsPolynomially g)
Goal: AkraBazziRecurrence.GrowsPolynomially f
-- AkraBazziRecurrence.GrowsPolynomially.iff_eventuallyEq
lemma iff_eventuallyEq {f g : ℝ → ℝ} (h : f =ᶠ[atTop] g) :
    GrowsPolynomially f ↔ GrowsPolynomially g 
Arguments: {f g : ℝ → ℝ} (h : f =ᶠ[Filter.atTop] g)
Goal: AkraBazziRecurrence.GrowsPolynomially f ↔ AkraBazziRecurrence.GrowsPolynomially g
-- AkraBazziRecurrence.GrowsPolynomially.eventually_atTop_le
lemma eventually_atTop_le {b : ℝ} (hb : b ∈ Set.Ioo 0 1) (hf : GrowsPolynomially f) :
    ∃ c > 0, ∀ᶠ x in atTop, ∀ u ∈ Set.Icc (b * x) x, f u ≤ c * f x 
Arguments: {f : ℝ → ℝ} {b : ℝ} (hb : b ∈ Set.Ioo 0 1) (hf : AkraBazziRecurrence.GrowsPolynomially f)
Goal: ∃ c > 0, ∀ᶠ (x : ℝ) in Filter.atTop, ∀ u ∈ Set.Icc (b * x) x, f u ≤ c * f x
-- AkraBazziRecurrence.GrowsPolynomially.eventually_atTop_le_nat
lemma eventually_atTop_le_nat {b : ℝ} (hb : b ∈ Set.Ioo 0 1) (hf : GrowsPolynomially f) :
    ∃ c > 0, ∀ᶠ (n : ℕ) in atTop, ∀ u ∈ Set.Icc (b * n) n, f u ≤ c * f n 
Arguments: {f : ℝ → ℝ} {b : ℝ} (hb : b ∈ Set.Ioo 0 1) (hf : AkraBazziRecurrence.GrowsPolynomially f)
Goal: ∃ c > 0, ∀ᶠ (n : ℕ) in Filter.atTop, ∀ u ∈ Set.Icc (b * ↑n) ↑n, f u ≤ c * f ↑n
-- AkraBazziRecurrence.GrowsPolynomially.eventually_atTop_ge
lemma eventually_atTop_ge {b : ℝ} (hb : b ∈ Set.Ioo 0 1) (hf : GrowsPolynomially f) :
    ∃ c > 0, ∀ᶠ x in atTop, ∀ u ∈ Set.Icc (b * x) x, c * f x ≤ f u 
Arguments: {f : ℝ → ℝ} {b : ℝ} (hb : b ∈ Set.Ioo 0 1) (hf : AkraBazziRecurrence.GrowsPolynomially f)
Goal: ∃ c > 0, ∀ᶠ (x : ℝ) in Filter.atTop, ∀ u ∈ Set.Icc (b * x) x, c * f x ≤ f u
-- AkraBazziRecurrence.GrowsPolynomially.eventually_atTop_ge_nat
lemma eventually_atTop_ge_nat {b : ℝ} (hb : b ∈ Set.Ioo 0 1) (hf : GrowsPolynomially f) :
    ∃ c > 0, ∀ᶠ (n : ℕ) in atTop, ∀ u ∈ Set.Icc (b * n) n, c * f n ≤ f u 
Arguments: {f : ℝ → ℝ} {b : ℝ} (hb : b ∈ Set.Ioo 0 1) (hf : AkraBazziRecurrence.GrowsPolynomially f)
Goal: ∃ c > 0, ∀ᶠ (n : ℕ) in Filter.atTop, ∀ u ∈ Set.Icc (b * ↑n) ↑n, c * f ↑n ≤ f u
-- AkraBazziRecurrence.GrowsPolynomially.eventually_zero_of_frequently_zero
lemma eventually_zero_of_frequently_zero (hf : GrowsPolynomially f) (hf' : ∃ᶠ x in atTop, f x = 0) :
    ∀ᶠ x in atTop, f x = 0 
Arguments: {f : ℝ → ℝ} (hf : AkraBazziRecurrence.GrowsPolynomially f) (hf' : ∃ᶠ (x : ℝ) in Filter.atTop, f x = 0)
Goal: ∀ᶠ (x : ℝ) in Filter.atTop, f x = 0
-- AkraBazziRecurrence.GrowsPolynomially.eventually_atTop_nonneg_or_nonpos
lemma eventually_atTop_nonneg_or_nonpos (hf : GrowsPolynomially f) :
    (∀ᶠ x in atTop, 0 ≤ f x) ∨ (∀ᶠ x in atTop, f x ≤ 0) 
Arguments: {f : ℝ → ℝ} (hf : AkraBazziRecurrence.GrowsPolynomially f)
Goal: (∀ᶠ (x : ℝ) in Filter.atTop, 0 ≤ f x) ∨ ∀ᶠ (x : ℝ) in Filter.atTop, f x ≤ 0
-- AkraBazziRecurrence.GrowsPolynomially.eventually_atTop_zero_or_pos_or_neg
lemma eventually_atTop_zero_or_pos_or_neg (hf : GrowsPolynomially f) :
    (∀ᶠ x in atTop, f x = 0) ∨ (∀ᶠ x in atTop, 0 < f x) ∨ (∀ᶠ x in atTop, f x < 0) 
Arguments: {f : ℝ → ℝ} (hf : AkraBazziRecurrence.GrowsPolynomially f)
Goal: (∀ᶠ (x : ℝ) in Filter.atTop, f x = 0) ∨ (∀ᶠ (x : ℝ) in Filter.atTop, 0 < f x) ∨ ∀ᶠ (x : ℝ) in Filter.atTop, f x < 0
-- AkraBazziRecurrence.GrowsPolynomially.neg
protected lemma neg {f : ℝ → ℝ} (hf : GrowsPolynomially f) : GrowsPolynomially (-f) 
Arguments: {f : ℝ → ℝ} (hf : AkraBazziRecurrence.GrowsPolynomially f)
Goal: AkraBazziRecurrence.GrowsPolynomially (-f)
-- AkraBazziRecurrence.GrowsPolynomially.neg_iff
protected lemma neg_iff {f : ℝ → ℝ} : GrowsPolynomially f ↔ GrowsPolynomially (-f) 
Arguments: {f : ℝ → ℝ}
Goal: AkraBazziRecurrence.GrowsPolynomially f ↔ AkraBazziRecurrence.GrowsPolynomially (-f)
-- AkraBazziRecurrence.GrowsPolynomially.abs
protected lemma abs (hf : GrowsPolynomially f) : GrowsPolynomially (fun x => |f x|) 
Arguments: {f : ℝ → ℝ} (hf : AkraBazziRecurrence.GrowsPolynomially f)
Goal: AkraBazziRecurrence.GrowsPolynomially fun x => |f x|
-- AkraBazziRecurrence.GrowsPolynomially.norm
protected lemma norm (hf : GrowsPolynomially f) : GrowsPolynomially (fun x => ‖f x‖) 
Arguments: {f : ℝ → ℝ} (hf : AkraBazziRecurrence.GrowsPolynomially f)
Goal: AkraBazziRecurrence.GrowsPolynomially fun x => ‖f x‖
-- AkraBazziRecurrence.growsPolynomially_const
lemma growsPolynomially_const {c : ℝ} : GrowsPolynomially (fun _ => c) 
Arguments: {c : ℝ}
Goal: AkraBazziRecurrence.GrowsPolynomially fun x => c
-- AkraBazziRecurrence.growsPolynomially_id
lemma growsPolynomially_id : GrowsPolynomially (fun x => x) 
Goal: AkraBazziRecurrence.GrowsPolynomially fun x => x
-- AkraBazziRecurrence.GrowsPolynomially.mul
protected lemma GrowsPolynomially.mul {f g : ℝ → ℝ} (hf : GrowsPolynomially f)
    (hg : GrowsPolynomially g) : GrowsPolynomially fun x => f x * g x 
Arguments: {f g : ℝ → ℝ} (hf : AkraBazziRecurrence.GrowsPolynomially f) (hg : AkraBazziRecurrence.GrowsPolynomially g)
Goal: AkraBazziRecurrence.GrowsPolynomially fun x => f x * g x
-- AkraBazziRecurrence.GrowsPolynomially.const_mul
lemma GrowsPolynomially.const_mul {f : ℝ → ℝ} {c : ℝ} (hf : GrowsPolynomially f) :
    GrowsPolynomially fun x => c * f x 
Arguments: {f : ℝ → ℝ} {c : ℝ} (hf : AkraBazziRecurrence.GrowsPolynomially f)
Goal: AkraBazziRecurrence.GrowsPolynomially fun x => c * f x
-- AkraBazziRecurrence.GrowsPolynomially.add
protected lemma GrowsPolynomially.add {f g : ℝ → ℝ} (hf : GrowsPolynomially f)
    (hg : GrowsPolynomially g) (hf' : 0 ≤ᶠ[atTop] f) (hg' : 0 ≤ᶠ[atTop] g) :
    GrowsPolynomially fun x => f x + g x 
Arguments: {f g : ℝ → ℝ} (hf : AkraBazziRecurrence.GrowsPolynomially f) (hg : AkraBazziRecurrence.GrowsPolynomially g) (hf' : 0 ≤ᶠ[Filter.atTop] f) (hg' : 0 ≤ᶠ[Filter.atTop] g)
Goal: AkraBazziRecurrence.GrowsPolynomially fun x => f x + g x
-- AkraBazziRecurrence.GrowsPolynomially.add_isLittleO
lemma GrowsPolynomially.add_isLittleO {f g : ℝ → ℝ} (hf : GrowsPolynomially f)
    (hfg : g =o[atTop] f) : GrowsPolynomially fun x => f x + g x 
Arguments: {f g : ℝ → ℝ} (hf : AkraBazziRecurrence.GrowsPolynomially f) (hfg : g =o[Filter.atTop] f)
Goal: AkraBazziRecurrence.GrowsPolynomially fun x => f x + g x
-- AkraBazziRecurrence.GrowsPolynomially.inv
protected lemma GrowsPolynomially.inv {f : ℝ → ℝ} (hf : GrowsPolynomially f) :
    GrowsPolynomially fun x => (f x)⁻¹ 
Arguments: {f : ℝ → ℝ} (hf : AkraBazziRecurrence.GrowsPolynomially f)
Goal: AkraBazziRecurrence.GrowsPolynomially fun x => (f x)⁻¹
-- AkraBazziRecurrence.GrowsPolynomially.div
protected lemma GrowsPolynomially.div {f g : ℝ → ℝ} (hf : GrowsPolynomially f)
    (hg : GrowsPolynomially g) : GrowsPolynomially fun x => f x / g x 
Arguments: {f g : ℝ → ℝ} (hf : AkraBazziRecurrence.GrowsPolynomially f) (hg : AkraBazziRecurrence.GrowsPolynomially g)
Goal: AkraBazziRecurrence.GrowsPolynomially fun x => f x / g x
-- AkraBazziRecurrence.GrowsPolynomially.rpow
protected lemma GrowsPolynomially.rpow (p : ℝ) (hf : GrowsPolynomially f)
    (hf_nonneg : ∀ᶠ x in atTop, 0 ≤ f x) : GrowsPolynomially fun x => (f x) ^ p 
Arguments: {f : ℝ → ℝ} (p : ℝ) (hf : AkraBazziRecurrence.GrowsPolynomially f) (hf_nonneg : ∀ᶠ (x : ℝ) in Filter.atTop, 0 ≤ f x)
Goal: AkraBazziRecurrence.GrowsPolynomially fun x => f x ^ p
-- AkraBazziRecurrence.GrowsPolynomially.pow
protected lemma GrowsPolynomially.pow (p : ℕ) (hf : GrowsPolynomially f)
    (hf_nonneg : ∀ᶠ x in atTop, 0 ≤ f x) : GrowsPolynomially fun x => (f x) ^ p 
Arguments: {f : ℝ → ℝ} (p : ℕ) (hf : AkraBazziRecurrence.GrowsPolynomially f) (hf_nonneg : ∀ᶠ (x : ℝ) in Filter.atTop, 0 ≤ f x)
Goal: AkraBazziRecurrence.GrowsPolynomially fun x => f x ^ p
-- AkraBazziRecurrence.GrowsPolynomially.zpow
protected lemma GrowsPolynomially.zpow (p : ℤ) (hf : GrowsPolynomially f)
    (hf_nonneg : ∀ᶠ x in atTop, 0 ≤ f x) : GrowsPolynomially fun x => (f x) ^ p 
Arguments: {f : ℝ → ℝ} (p : ℤ) (hf : AkraBazziRecurrence.GrowsPolynomially f) (hf_nonneg : ∀ᶠ (x : ℝ) in Filter.atTop, 0 ≤ f x)
Goal: AkraBazziRecurrence.GrowsPolynomially fun x => f x ^ p
-- AkraBazziRecurrence.growsPolynomially_rpow
lemma growsPolynomially_rpow (p : ℝ) : GrowsPolynomially fun x => x ^ p 
Arguments: (p : ℝ)
Goal: AkraBazziRecurrence.GrowsPolynomially fun x => x ^ p
-- AkraBazziRecurrence.growsPolynomially_pow
lemma growsPolynomially_pow (p : ℕ) : GrowsPolynomially fun x => x ^ p 
Arguments: (p : ℕ)
Goal: AkraBazziRecurrence.GrowsPolynomially fun x => x ^ p
-- AkraBazziRecurrence.growsPolynomially_zpow
lemma growsPolynomially_zpow (p : ℤ) : GrowsPolynomially fun x => x ^ p 
Arguments: (p : ℤ)
Goal: AkraBazziRecurrence.GrowsPolynomially fun x => x ^ p
-- AkraBazziRecurrence.growsPolynomially_log
lemma growsPolynomially_log : GrowsPolynomially Real.log 
Goal: AkraBazziRecurrence.GrowsPolynomially Real.log
-- AkraBazziRecurrence.GrowsPolynomially.of_isTheta
lemma GrowsPolynomially.of_isTheta {f g : ℝ → ℝ} (hg : GrowsPolynomially g) (hf : f =Θ[atTop] g)
    (hf' : ∀ᶠ x in atTop, 0 ≤ f x) : GrowsPolynomially f 
Arguments: {f g : ℝ → ℝ} (hg : AkraBazziRecurrence.GrowsPolynomially g) (hf : f =Θ[Filter.atTop] g) (hf' : ∀ᶠ (x : ℝ) in Filter.atTop, 0 ≤ f x)
Goal: AkraBazziRecurrence.GrowsPolynomially f