ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: FiniteField.card_image_polynomial_eval
File: Mathlib/FieldTheory/Finite/Basic.lean

Proof steps:
state_before: K : Type u_1
R : Type u_2
inst✝³ : CommRing R
inst✝² : IsDomain R
inst✝¹ : DecidableEq R
inst✝ : Fintype R
p : R[X]
hp : 0 < p.degree
a : R
x✝ : a ∈ image (fun x => eval x p) univ
⊢ filter (fun x => eval x p = a) univ = (p - C a).roots.toFinset
state_after: no goals
tactic: simp [Finset.ext_iff, ← mem_roots_sub_C hp]
Theorem: Finset.image₂_inter_union_subset
File: Mathlib/Data/Finset/NAry.lean

Proof steps:
state_before: α : Type u_1
α' : Type u_2
β : Type u_3
β' : Type u_4
γ : Type u_5
γ' : Type u_6
δ : Type u_7
δ' : Type u_8
ε : Type u_9
ε' : Type u_10
ζ : Type u_11
ζ' : Type u_12
ν : Type u_13
inst✝⁹ : DecidableEq α'
inst✝⁸ : DecidableEq β'
inst✝⁷ : DecidableEq γ
inst✝⁶ : DecidableEq γ'
inst✝⁵ : DecidableEq δ
inst✝⁴ : DecidableEq δ'
inst✝³ : DecidableEq ε
inst✝² : DecidableEq ε'
f✝ f' : α → β → γ
g g' : α → β → γ → δ
s✝ s' : Finset α
t✝ t' : Finset β
u u' : Finset γ
a a' : α
b b' : β
c : γ
inst✝¹ : DecidableEq α
inst✝ : DecidableEq β
f : α → α → β
s t : Finset α
hf : ∀ (a b : α), f a b = f b a
⊢ ↑(image₂ f (s ∩ t) (s ∪ t)) ⊆ ↑(image₂ f s t)
state_after: α : Type u_1
α' : Type u_2
β : Type u_3
β' : Type u_4
γ : Type u_5
γ' : Type u_6
δ : Type u_7
δ' : Type u_8
ε : Type u_9
ε' : Type u_10
ζ : Type u_11
ζ' : Type u_12
ν : Type u_13
inst✝⁹ : DecidableEq α'
inst✝⁸ : DecidableEq β'
inst✝⁷ : DecidableEq γ
inst✝⁶ : DecidableEq γ'
inst✝⁵ : DecidableEq δ
inst✝⁴ : DecidableEq δ'
inst✝³ : DecidableEq ε
inst✝² : DecidableEq ε'
f✝ f' : α → β → γ
g g' : α → β → γ → δ
s✝ s' : Finset α
t✝ t' : Finset β
u u' : Finset γ
a a' : α
b b' : β
c : γ
inst✝¹ : DecidableEq α
inst✝ : DecidableEq β
f : α → α → β
s t : Finset α
hf : ∀ (a b : α), f a b = f b a
⊢ image2 f (↑s ∩ ↑t) (↑s ∪ ↑t) ⊆ image2 f ↑s ↑t
tactic: push_cast
state_before: α : Type u_1
α' : Type u_2
β : Type u_3
β' : Type u_4
γ : Type u_5
γ' : Type u_6
δ : Type u_7
δ' : Type u_8
ε : Type u_9
ε' : Type u_10
ζ : Type u_11
ζ' : Type u_12
ν : Type u_13
inst✝⁹ : DecidableEq α'
inst✝⁸ : DecidableEq β'
inst✝⁷ : DecidableEq γ
inst✝⁶ : DecidableEq γ'
inst✝⁵ : DecidableEq δ
inst✝⁴ : DecidableEq δ'
inst✝³ : DecidableEq ε
inst✝² : DecidableEq ε'
f✝ f' : α → β → γ
g g' : α → β → γ → δ
s✝ s' : Finset α
t✝ t' : Finset β
u u' : Finset γ
a a' : α
b b' : β
c : γ
inst✝¹ : DecidableEq α
inst✝ : DecidableEq β
f : α → α → β
s t : Finset α
hf : ∀ (a b : α), f a b = f b a
⊢ image2 f (↑s ∩ ↑t) (↑s ∪ ↑t) ⊆ image2 f ↑s ↑t
state_after: no goals
tactic: exact image2_inter_union_subset hf
Theorem: CategoryTheory.GrothendieckTopology.arrow_intersect
File: Mathlib/CategoryTheory/Sites/Grothendieck.lean

Proof steps:
state_before: C : Type u
inst✝ : Category.{v, u} C
X Y : C
S✝ R✝ : Sieve X
J : GrothendieckTopology C
f : Y ⟶ X
S R : Sieve X
hS : J.Covers S f
hR : J.Covers R f
⊢ J.Covers (S ⊓ R) f
state_after: no goals
tactic: simpa [covers_iff] using And.intro hS hR
Theorem: Filter.mem_iff_ultrafilter
File: Mathlib/Order/Filter/Ultrafilter.lean

Proof steps:
state_before: α : Type u
β : Type v
γ : Type u_1
f : Filter α
s : Set α
a : α
⊢ s ∈ f ↔ ∀ (g : Ultrafilter α), ↑g ≤ f → s ∈ g
state_after: α : Type u
β : Type v
γ : Type u_1
f : Filter α
s : Set α
a : α
H : ∀ (g : Ultrafilter α), ↑g ≤ f → s ∈ g
hf : s ∉ f
⊢ False
tactic: refine ⟨fun hf g hg => hg hf, fun H => by_contra fun hf => ?_⟩
state_before: α : Type u
β : Type v
γ : Type u_1
f : Filter α
s : Set α
a : α
H : ∀ (g : Ultrafilter α), ↑g ≤ f → s ∈ g
hf : s ∉ f
⊢ False
state_after: α : Type u
β : Type v
γ : Type u_1
f : Filter α
s : Set α
a : α
H : ∀ (g : Ultrafilter α), ↑g ≤ f → s ∈ g
hf : s ∉ f
g : Filter ↑sᶜ := comap Subtype.val f
⊢ False
tactic: set g : Filter (sᶜ : Set α) := comap (↑) f
state_before: α : Type u
β : Type v
γ : Type u_1
f : Filter α
s : Set α
a : α
H : ∀ (g : Ultrafilter α), ↑g ≤ f → s ∈ g
hf : s ∉ f
g : Filter ↑sᶜ := comap Subtype.val f
⊢ False
state_after: α : Type u
β : Type v
γ : Type u_1
f : Filter α
s : Set α
a : α
H : ∀ (g : Ultrafilter α), ↑g ≤ f → s ∈ g
hf : s ∉ f
g : Filter ↑sᶜ := comap Subtype.val f
this : g.NeBot
⊢ False
tactic: haveI : NeBot g := comap_neBot_iff_compl_range.2 (by simpa [compl_setOf] )
state_before: α : Type u
β : Type v
γ : Type u_1
f : Filter α
s : Set α
a : α
H : ∀ (g : Ultrafilter α), ↑g ≤ f → s ∈ g
hf : s ∉ f
g : Filter ↑sᶜ := comap Subtype.val f
this : g.NeBot
⊢ False
state_after: no goals
tactic: simpa using H ((of g).map (↑)) (map_le_iff_le_comap.mpr (of_le g))
Theorem: Multiset.disjoint_iff_ne
File: Mathlib/Data/Multiset/Basic.lean

Proof steps:
state_before: α : Type u_1
β : Type v
γ : Type u_2
s t : Multiset α
⊢ s.Disjoint t ↔ ∀ a ∈ s, ∀ b ∈ t, a ≠ b
state_after: no goals
tactic: simp [disjoint_left, imp_not_comm]
Theorem: Matrix.star_dotProduct
File: Mathlib/Data/Matrix/Basic.lean

Proof steps:
state_before: l : Type u_1
m : Type u_2
n : Type u_3
o : Type u_4
m' : o → Type u_5
n' : o → Type u_6
R : Type u_7
S : Type u_8
α : Type v
β : Type w
γ : Type u_9
inst✝³ : Fintype m
inst✝² : Fintype n
inst✝¹ : NonUnitalSemiring α
inst✝ : StarRing α
v w : m → α
⊢ star v ⬝ᵥ w = star (star w ⬝ᵥ v)
state_after: no goals
tactic: simp [dotProduct]
Theorem: Polynomial.Separable.isCoprime
File: Mathlib/FieldTheory/Separable.lean

Proof steps:
state_before: R : Type u
inst✝¹ : CommSemiring R
S : Type v
inst✝ : CommSemiring S
f g : R[X]
h : (f * g).Separable
⊢ IsCoprime f g
state_after: R : Type u
inst✝¹ : CommSemiring R
S : Type v
inst✝ : CommSemiring S
f g : R[X]
h : (f * g).Separable
this : IsCoprime f (derivative (f * g))
⊢ IsCoprime f g
tactic: have := h.of_mul_left_left
state_before: R : Type u
inst✝¹ : CommSemiring R
S : Type v
inst✝ : CommSemiring S
f g : R[X]
h : (f * g).Separable
this : IsCoprime f (derivative (f * g))
⊢ IsCoprime f g
state_after: R : Type u
inst✝¹ : CommSemiring R
S : Type v
inst✝ : CommSemiring S
f g : R[X]
h : (f * g).Separable
this : IsCoprime f (derivative f * g + f * derivative g)
⊢ IsCoprime f g
tactic: rw [derivative_mul] at this
state_before: R : Type u
inst✝¹ : CommSemiring R
S : Type v
inst✝ : CommSemiring S
f g : R[X]
h : (f * g).Separable
this : IsCoprime f (derivative f * g + f * derivative g)
⊢ IsCoprime f g
state_after: no goals
tactic: exact IsCoprime.of_mul_right_right (IsCoprime.of_add_mul_left_right this)
Theorem: one_div_lt_of_neg
File: Mathlib/Algebra/Order/Field/Basic.lean

Proof steps:
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
inst✝ : LinearOrderedField α
a b c d : α
n : ℤ
ha : a < 0
hb : b < 0
⊢ 1 / a < b ↔ 1 / b < a
state_after: no goals
tactic: simpa using inv_lt_of_neg ha hb
Theorem: CategoryTheory.hasExt_of_hasDerivedCategory
File: Mathlib/Algebra/Homology/DerivedCategory/Ext.lean

Proof steps:
state_before: C : Type u
inst✝² : Category.{v, u} C
inst✝¹ : Abelian C
inst✝ : HasDerivedCategory C
⊢ HasExt C
state_after: C : Type u
inst✝² : Category.{v, u} C
inst✝¹ : Abelian C
inst✝ : HasDerivedCategory C
⊢ ∀ (X Y : C) (n : ℤ),
    Small.{w, w}
      ((DerivedCategory.singleFunctor C 0).obj X ⟶
        (shiftFunctor (DerivedCategory C) n).obj ((DerivedCategory.singleFunctor C 0).obj Y))
tactic: rw [hasExt_iff.{w}]
state_before: C : Type u
inst✝² : Category.{v, u} C
inst✝¹ : Abelian C
inst✝ : HasDerivedCategory C
⊢ ∀ (X Y : C) (n : ℤ),
    Small.{w, w}
      ((DerivedCategory.singleFunctor C 0).obj X ⟶
        (shiftFunctor (DerivedCategory C) n).obj ((DerivedCategory.singleFunctor C 0).obj Y))
state_after: no goals
tactic: infer_instance
Theorem: List.toFinset_filter
File: Mathlib/Data/Finset/Basic.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
inst✝ : DecidableEq α
l l' : List α
a : α
s : List α
p : α → Bool
⊢ (filter p s).toFinset = Finset.filter (fun x => p x = true) s.toFinset
state_after: case a
α : Type u_1
β : Type u_2
γ : Type u_3
inst✝ : DecidableEq α
l l' : List α
a : α
s : List α
p : α → Bool
a✝ : α
⊢ a✝ ∈ (filter p s).toFinset ↔ a✝ ∈ Finset.filter (fun x => p x = true) s.toFinset
tactic: ext
state_before: case a
α : Type u_1
β : Type u_2
γ : Type u_3
inst✝ : DecidableEq α
l l' : List α
a : α
s : List α
p : α → Bool
a✝ : α
⊢ a✝ ∈ (filter p s).toFinset ↔ a✝ ∈ Finset.filter (fun x => p x = true) s.toFinset
state_after: no goals
tactic: simp [List.mem_filter]
Theorem: ProbabilityTheory.condIndepFun_iff_condIndep
File: Mathlib/Probability/Independence/Conditional.lean

Proof steps:
state_before: Ω : Type u_1
ι : Type u_2
m' mΩ : MeasurableSpace Ω
inst✝² : StandardBorelSpace Ω
inst✝¹ : Nonempty Ω
hm' : m' ≤ mΩ
β : Type u_3
γ : Type u_4
mβ : MeasurableSpace β
mγ : MeasurableSpace γ
f : Ω → β
g : Ω → γ
μ : Measure Ω
inst✝ : IsFiniteMeasure μ
⊢ CondIndepFun m' hm' f g μ ↔ CondIndep m' (MeasurableSpace.comap f mβ) (MeasurableSpace.comap g mγ) hm' μ
state_after: no goals
tactic: simp only [CondIndepFun, CondIndep, Kernel.IndepFun]
Theorem: MeasureTheory.unifIntegrable_subsingleton
File: Mathlib/MeasureTheory/Function/UniformIntegrable.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
ι : Type u_3
m : MeasurableSpace α
μ : Measure α
inst✝¹ : NormedAddCommGroup β
p : ℝ≥0∞
f✝ : α → β
inst✝ : Subsingleton ι
hp_one : 1 ≤ p
hp_top : p ≠ ⊤
f : ι → α → β
hf : ∀ (i : ι), Memℒp (f i) p μ
⊢ UnifIntegrable f p μ
state_after: α : Type u_1
β : Type u_2
ι : Type u_3
m : MeasurableSpace α
μ : Measure α
inst✝¹ : NormedAddCommGroup β
p : ℝ≥0∞
f✝ : α → β
inst✝ : Subsingleton ι
hp_one : 1 ≤ p
hp_top : p ≠ ⊤
f : ι → α → β
hf : ∀ (i : ι), Memℒp (f i) p μ
ε : ℝ
hε : 0 < ε
⊢ ∃ δ,
    ∃ (_ : 0 < δ),
      ∀ (i : ι) (s : Set α),
        MeasurableSet s → μ s ≤ ENNReal.ofReal δ → eLpNorm (s.indicator (f i)) p μ ≤ ENNReal.ofReal ε
tactic: intro ε hε
state_before: α : Type u_1
β : Type u_2
ι : Type u_3
m : MeasurableSpace α
μ : Measure α
inst✝¹ : NormedAddCommGroup β
p : ℝ≥0∞
f✝ : α → β
inst✝ : Subsingleton ι
hp_one : 1 ≤ p
hp_top : p ≠ ⊤
f : ι → α → β
hf : ∀ (i : ι), Memℒp (f i) p μ
ε : ℝ
hε : 0 < ε
⊢ ∃ δ,
    ∃ (_ : 0 < δ),
      ∀ (i : ι) (s : Set α),
        MeasurableSet s → μ s ≤ ENNReal.ofReal δ → eLpNorm (s.indicator (f i)) p μ ≤ ENNReal.ofReal ε
state_after: case pos
α : Type u_1
β : Type u_2
ι : Type u_3
m : MeasurableSpace α
μ : Measure α
inst✝¹ : NormedAddCommGroup β
p : ℝ≥0∞
f✝ : α → β
inst✝ : Subsingleton ι
hp_one : 1 ≤ p
hp_top : p ≠ ⊤
f : ι → α → β
hf : ∀ (i : ι), Memℒp (f i) p μ
ε : ℝ
hε : 0 < ε
hι : Nonempty ι
⊢ ∃ δ,
    ∃ (_ : 0 < δ),
      ∀ (i : ι) (s : Set α),
        MeasurableSet s → μ s ≤ ENNReal.ofReal δ → eLpNorm (s.indicator (f i)) p μ ≤ ENNReal.ofReal ε

case neg
α : Type u_1
β : Type u_2
ι : Type u_3
m : MeasurableSpace α
μ : Measure α
inst✝¹ : NormedAddCommGroup β
p : ℝ≥0∞
f✝ : α → β
inst✝ : Subsingleton ι
hp_one : 1 ≤ p
hp_top : p ≠ ⊤
f : ι → α → β
hf : ∀ (i : ι), Memℒp (f i) p μ
ε : ℝ
hε : 0 < ε
hι : ¬Nonempty ι
⊢ ∃ δ,
    ∃ (_ : 0 < δ),
      ∀ (i : ι) (s : Set α),
        MeasurableSet s → μ s ≤ ENNReal.ofReal δ → eLpNorm (s.indicator (f i)) p μ ≤ ENNReal.ofReal ε
tactic: by_cases hι : Nonempty ι
Theorem: TopologicalSpace.IsSeparable.image
File: Mathlib/Topology/Bases.lean

Proof steps:
state_before: α : Type u
β✝ : Type u_1
t : TopologicalSpace α
B : Set (Set α)
s✝ : Set α
β : Type u_2
inst✝ : TopologicalSpace β
s : Set α
hs : IsSeparable s
f : α → β
hf : Continuous f
⊢ IsSeparable (f '' s)
state_after: case intro.intro
α : Type u
β✝ : Type u_1
t : TopologicalSpace α
B : Set (Set α)
s✝ : Set α
β : Type u_2
inst✝ : TopologicalSpace β
s : Set α
f : α → β
hf : Continuous f
c : Set α
c_count : c.Countable
hc : s ⊆ closure c
⊢ IsSeparable (f '' s)
tactic: rcases hs with ⟨c, c_count, hc⟩
state_before: case intro.intro
α : Type u
β✝ : Type u_1
t : TopologicalSpace α
B : Set (Set α)
s✝ : Set α
β : Type u_2
inst✝ : TopologicalSpace β
s : Set α
f : α → β
hf : Continuous f
c : Set α
c_count : c.Countable
hc : s ⊆ closure c
⊢ IsSeparable (f '' s)
state_after: case intro.intro
α : Type u
β✝ : Type u_1
t : TopologicalSpace α
B : Set (Set α)
s✝ : Set α
β : Type u_2
inst✝ : TopologicalSpace β
s : Set α
f : α → β
hf : Continuous f
c : Set α
c_count : c.Countable
hc : s ⊆ closure c
⊢ f '' s ⊆ closure (f '' c)
tactic: refine ⟨f '' c, c_count.image _, ?_⟩
state_before: case intro.intro
α : Type u
β✝ : Type u_1
t : TopologicalSpace α
B : Set (Set α)
s✝ : Set α
β : Type u_2
inst✝ : TopologicalSpace β
s : Set α
f : α → β
hf : Continuous f
c : Set α
c_count : c.Countable
hc : s ⊆ closure c
⊢ f '' s ⊆ closure (f '' c)
state_after: case intro.intro
α : Type u
β✝ : Type u_1
t : TopologicalSpace α
B : Set (Set α)
s✝ : Set α
β : Type u_2
inst✝ : TopologicalSpace β
s : Set α
f : α → β
hf : Continuous f
c : Set α
c_count : c.Countable
hc : s ⊆ closure c
⊢ s ⊆ f ⁻¹' closure (f '' c)
tactic: rw [image_subset_iff]
state_before: case intro.intro
α : Type u
β✝ : Type u_1
t : TopologicalSpace α
B : Set (Set α)
s✝ : Set α
β : Type u_2
inst✝ : TopologicalSpace β
s : Set α
f : α → β
hf : Continuous f
c : Set α
c_count : c.Countable
hc : s ⊆ closure c
⊢ s ⊆ f ⁻¹' closure (f '' c)
state_after: no goals
tactic: exact hc.trans (closure_subset_preimage_closure_image hf)
Theorem: inv_div_left
File: Mathlib/Algebra/Group/Basic.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
G : Type u_3
M : Type u_4
inst✝ : DivisionMonoid α
a b c d : α
⊢ a⁻¹ / b = (b * a)⁻¹
state_after: no goals
tactic: simp
Theorem: Polynomial.degree_X_pow_add_C
File: Mathlib/Algebra/Polynomial/Degree/Definitions.lean

Proof steps:
state_before: R : Type u
S : Type v
a✝ b c d : R
n✝ m : ℕ
inst✝¹ : Nontrivial R
inst✝ : Semiring R
n : ℕ
hn : 0 < n
a : R
⊢ (X ^ n + C a).degree = ↑n
state_after: R : Type u
S : Type v
a✝ b c d : R
n✝ m : ℕ
inst✝¹ : Nontrivial R
inst✝ : Semiring R
n : ℕ
hn : 0 < n
a : R
this : (C a).degree < (X ^ n).degree
⊢ (X ^ n + C a).degree = ↑n
tactic: have : degree (C a) < degree ((X : R[X]) ^ n) := degree_C_le.trans_lt <| by
    rwa [degree_X_pow, Nat.cast_pos]
state_before: R : Type u
S : Type v
a✝ b c d : R
n✝ m : ℕ
inst✝¹ : Nontrivial R
inst✝ : Semiring R
n : ℕ
hn : 0 < n
a : R
this : (C a).degree < (X ^ n).degree
⊢ (X ^ n + C a).degree = ↑n
state_after: no goals
tactic: rw [degree_add_eq_left_of_degree_lt this, degree_X_pow]
Theorem: CategoryTheory.ComposableArrows.scMapIso_inv
File: Mathlib/Algebra/Homology/ExactSequence.lean

Proof steps:
state_before: C : Type u_1
inst✝¹ : Category.{?u.53009, u_1} C
inst✝ : HasZeroMorphisms C
n : ℕ
S S₁ S₂ : ComposableArrows C n
e : S₁ ≅ S₂
h₁ : S₁.IsComplex
h₂ : S₂.IsComplex
i : ℕ
hi : autoParam (i + 2 ≤ n) _auto✝
⊢ scMap e.hom h₁ h₂ i ⋯ ≫ scMap e.inv h₂ h₁ i ⋯ = 𝟙 (S₁.sc h₁ i ⋯)
state_after: no goals
tactic: ext <;> dsimp <;> simp
state_before: C : Type u_1
inst✝¹ : Category.{?u.53009, u_1} C
inst✝ : HasZeroMorphisms C
n : ℕ
S S₁ S₂ : ComposableArrows C n
e : S₁ ≅ S₂
h₁ : S₁.IsComplex
h₂ : S₂.IsComplex
i : ℕ
hi : autoParam (i + 2 ≤ n) _auto✝
⊢ scMap e.inv h₂ h₁ i ⋯ ≫ scMap e.hom h₁ h₂ i ⋯ = 𝟙 (S₂.sc h₂ i ⋯)
state_after: no goals
tactic: ext <;> dsimp <;> simp
Theorem: PartENat.lt_coe_iff
File: Mathlib/Data/Nat/PartENat.lean

Proof steps:
state_before: x : PartENat
n : ℕ
⊢ x < ↑n ↔ ∃ (h : x.Dom), x.get h < n
state_after: no goals
tactic: simp only [lt_def, forall_prop_of_true, get_natCast', dom_natCast]
Theorem: Subgroup.card_eq_iff_eq_top
File: Mathlib/Algebra/Group/Subgroup/Finite.lean

Proof steps:
state_before: G : Type u_1
inst✝² : Group G
A : Type u_2
inst✝¹ : AddGroup A
H K : Subgroup G
inst✝ : Finite ↥H
h : H = ⊤
⊢ Nat.card ↥H = Nat.card G
state_after: no goals
tactic: simpa only [h] using card_top
Theorem: AnalyticOn.eqOn_of_preconnected_of_frequently_eq
File: Mathlib/Analysis/Analytic/IsolatedZeros.lean

Proof steps:
state_before: 𝕜 : Type u_1
inst✝² : NontriviallyNormedField 𝕜
E : Type u_2
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace 𝕜 E
s : E
p q : FormalMultilinearSeries 𝕜 𝕜 E
f g : 𝕜 → E
n : ℕ
z z₀ : 𝕜
U : Set 𝕜
hf : AnalyticOn 𝕜 f U
hg : AnalyticOn 𝕜 g U
hU : IsPreconnected U
h₀ : z₀ ∈ U
hfg : ∃ᶠ (z : 𝕜) in 𝓝[≠] z₀, f z = g z
⊢ EqOn f g U
state_after: 𝕜 : Type u_1
inst✝² : NontriviallyNormedField 𝕜
E : Type u_2
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace 𝕜 E
s : E
p q : FormalMultilinearSeries 𝕜 𝕜 E
f g : 𝕜 → E
n : ℕ
z z₀ : 𝕜
U : Set 𝕜
hf : AnalyticOn 𝕜 f U
hg : AnalyticOn 𝕜 g U
hU : IsPreconnected U
h₀ : z₀ ∈ U
hfg : ∃ᶠ (z : 𝕜) in 𝓝[≠] z₀, f z = g z
hfg' : ∃ᶠ (z : 𝕜) in 𝓝[≠] z₀, (f - g) z = 0
⊢ EqOn f g U
tactic: have hfg' : ∃ᶠ z in 𝓝[≠] z₀, (f - g) z = 0 :=
    hfg.mono fun z h => by rw [Pi.sub_apply, h, sub_self]
state_before: 𝕜 : Type u_1
inst✝² : NontriviallyNormedField 𝕜
E : Type u_2
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace 𝕜 E
s : E
p q : FormalMultilinearSeries 𝕜 𝕜 E
f g : 𝕜 → E
n : ℕ
z z₀ : 𝕜
U : Set 𝕜
hf : AnalyticOn 𝕜 f U
hg : AnalyticOn 𝕜 g U
hU : IsPreconnected U
h₀ : z₀ ∈ U
hfg : ∃ᶠ (z : 𝕜) in 𝓝[≠] z₀, f z = g z
hfg' : ∃ᶠ (z : 𝕜) in 𝓝[≠] z₀, (f - g) z = 0
⊢ EqOn f g U
state_after: no goals
tactic: simpa [sub_eq_zero] using fun z hz =>
    (hf.sub hg).eqOn_zero_of_preconnected_of_frequently_eq_zero hU h₀ hfg' hz
Theorem: Int.card_fintype_Ico_of_le
File: Mathlib/Data/Int/Interval.lean

Proof steps:
state_before: a b : ℤ
h : a ≤ b
⊢ ↑(Fintype.card ↑(Set.Ico a b)) = b - a
state_after: no goals
tactic: rw [card_fintype_Ico, toNat_sub_of_le h]
Theorem: Nat.le_mul_self
File: Mathlib/Data/Nat/Defs.lean

Proof steps:
state_before: a b c d m n✝ k : ℕ
p q : ℕ → Prop
n : ℕ
⊢ n + 1 ≤ (n + 1) * (n + 1)
state_after: no goals
tactic: simp [Nat.mul_add]
Theorem: HomologicalComplex₂.flipEquivalenceCounitIso_hom_app_f_f
File: Mathlib/Algebra/Homology/HomologicalBicomplex.lean

Proof steps:
state_before: C : Type u_1
inst✝¹ : Category.{?u.33164, u_1} C
inst✝ : HasZeroMorphisms C
I₁ : Type u_2
I₂ : Type u_3
c₁ : ComplexShape I₁
c₂ : ComplexShape I₂
K : HomologicalComplex₂ C c₂ c₁
i₂ : I₂
⊢ ∀ (i j : I₁),
    c₁.Rel i j →
      ((fun i₁ => Iso.refl ((((flipFunctor C c₂ c₁ ⋙ flipFunctor C c₁ c₂).obj K).X i₂).X i₁)) i).hom ≫
          (((𝟭 (HomologicalComplex₂ C c₂ c₁)).obj K).X i₂).d i j =
        (((flipFunctor C c₂ c₁ ⋙ flipFunctor C c₁ c₂).obj K).X i₂).d i j ≫
          ((fun i₁ => Iso.refl ((((flipFunctor C c₂ c₁ ⋙ flipFunctor C c₁ c₂).obj K).X i₂).X i₁)) j).hom
state_after: no goals
tactic: aesop_cat
state_before: C : Type u_1
inst✝¹ : Category.{?u.33164, u_1} C
inst✝ : HasZeroMorphisms C
I₁ : Type u_2
I₂ : Type u_3
c₁ : ComplexShape I₁
c₂ : ComplexShape I₂
K : HomologicalComplex₂ C c₂ c₁
⊢ ∀ (i j : I₂),
    c₂.Rel i j →
      ((fun i₂ =>
                Hom.isoOfComponents
                  (fun i₁ => Iso.refl ((((flipFunctor C c₂ c₁ ⋙ flipFunctor C c₁ c₂).obj K).X i₂).X i₁)) ⋯)
              i).hom ≫
          ((𝟭 (HomologicalComplex₂ C c₂ c₁)).obj K).d i j =
        ((flipFunctor C c₂ c₁ ⋙ flipFunctor C c₁ c₂).obj K).d i j ≫
          ((fun i₂ =>
                Hom.isoOfComponents
                  (fun i₁ => Iso.refl ((((flipFunctor C c₂ c₁ ⋙ flipFunctor C c₁ c₂).obj K).X i₂).X i₁)) ⋯)
              j).hom
state_after: no goals
tactic: aesop_cat
state_before: C : Type u_1
inst✝¹ : Category.{?u.33164, u_1} C
inst✝ : HasZeroMorphisms C
I₁ : Type u_2
I₂ : Type u_3
c₁ : ComplexShape I₁
c₂ : ComplexShape I₂
⊢ ∀ {X Y : HomologicalComplex₂ C c₂ c₁} (f : X ⟶ Y),
    (flipFunctor C c₂ c₁ ⋙ flipFunctor C c₁ c₂).map f ≫
        ((fun K =>
              Hom.isoOfComponents
                (fun i₂ =>
                  Hom.isoOfComponents
                    (fun i₁ => Iso.refl ((((flipFunctor C c₂ c₁ ⋙ flipFunctor C c₁ c₂).obj K).X i₂).X i₁)) ⋯)
                ⋯)
            Y).hom =
      ((fun K =>
              Hom.isoOfComponents
                (fun i₂ =>
                  Hom.isoOfComponents
                    (fun i₁ => Iso.refl ((((flipFunctor C c₂ c₁ ⋙ flipFunctor C c₁ c₂).obj K).X i₂).X i₁)) ⋯)
                ⋯)
            X).hom ≫
        (𝟭 (HomologicalComplex₂ C c₂ c₁)).map f
state_after: no goals
tactic: aesop_cat
Theorem: AlgebraicTopology.DoldKan.N₁Γ₀_hom_app
File: Mathlib/AlgebraicTopology/DoldKan/GammaCompN.lean

Proof steps:
state_before: C : Type u_1
inst✝² : Category.{u_2, u_1} C
inst✝¹ : Preadditive C
inst✝ : HasFiniteCoproducts C
K : ChainComplex C ℕ
⊢ N₁Γ₀.hom.app K =
    (Γ₀.splitting K).toKaroubiNondegComplexIsoN₁.inv ≫ (toKaroubi (ChainComplex C ℕ)).map (Γ₀NondegComplexIso K).hom
state_after: C : Type u_1
inst✝² : Category.{u_2, u_1} C
inst✝¹ : Preadditive C
inst✝ : HasFiniteCoproducts C
K : ChainComplex C ℕ
⊢ (N₁Γ₀.app K).hom =
    (Γ₀.splitting K).toKaroubiNondegComplexIsoN₁.inv ≫ (toKaroubi (ChainComplex C ℕ)).map (Γ₀NondegComplexIso K).hom
tactic: change (N₁Γ₀.app K).hom = _
state_before: C : Type u_1
inst✝² : Category.{u_2, u_1} C
inst✝¹ : Preadditive C
inst✝ : HasFiniteCoproducts C
K : ChainComplex C ℕ
⊢ (N₁Γ₀.app K).hom =
    (Γ₀.splitting K).toKaroubiNondegComplexIsoN₁.inv ≫ (toKaroubi (ChainComplex C ℕ)).map (Γ₀NondegComplexIso K).hom
state_after: C : Type u_1
inst✝² : Category.{u_2, u_1} C
inst✝¹ : Preadditive C
inst✝ : HasFiniteCoproducts C
K : ChainComplex C ℕ
⊢ ((Γ₀.splitting K).toKaroubiNondegComplexIsoN₁.symm ≪≫
        (toKaroubi (ChainComplex C ℕ)).mapIso (Γ₀NondegComplexIso K)).hom =
    (Γ₀.splitting K).toKaroubiNondegComplexIsoN₁.inv ≫ (toKaroubi (ChainComplex C ℕ)).map (Γ₀NondegComplexIso K).hom
tactic: simp only [N₁Γ₀_app]
state_before: C : Type u_1
inst✝² : Category.{u_2, u_1} C
inst✝¹ : Preadditive C
inst✝ : HasFiniteCoproducts C
K : ChainComplex C ℕ
⊢ ((Γ₀.splitting K).toKaroubiNondegComplexIsoN₁.symm ≪≫
        (toKaroubi (ChainComplex C ℕ)).mapIso (Γ₀NondegComplexIso K)).hom =
    (Γ₀.splitting K).toKaroubiNondegComplexIsoN₁.inv ≫ (toKaroubi (ChainComplex C ℕ)).map (Γ₀NondegComplexIso K).hom
state_after: no goals
tactic: rfl
Theorem: AlgebraicTopology.DoldKan.Γ₂N₂ToKaroubiIso_hom_app
File: Mathlib/AlgebraicTopology/DoldKan/NCompGamma.lean

Proof steps:
state_before: C : Type u_1
inst✝² : Category.{u_2, u_1} C
inst✝¹ : Preadditive C
inst✝ : HasFiniteCoproducts C
X : SimplicialObject C
⊢ Γ₂N₂ToKaroubiIso.hom.app X = Γ₂.map (toKaroubiCompN₂IsoN₁.hom.app X)
state_after: no goals
tactic: simp [Γ₂N₂ToKaroubiIso]
Theorem: ProbabilityTheory.meas_ge_le_evariance_div_sq
File: Mathlib/Probability/Variance.lean

Proof steps:
state_before: Ω : Type u_1
m : MeasurableSpace Ω
X✝ : Ω → ℝ
μ : Measure Ω
inst✝ : MeasureSpace Ω
X : Ω → ℝ
hX : AEStronglyMeasurable X ℙ
c : ℝ≥0
hc : c ≠ 0
⊢ ℙ {ω | ↑c ≤ |X ω - ∫ (a : Ω), X a|} ≤ evariance X ℙ / ↑c ^ 2
state_after: Ω : Type u_1
m : MeasurableSpace Ω
X✝ : Ω → ℝ
μ : Measure Ω
inst✝ : MeasureSpace Ω
X : Ω → ℝ
hX : AEStronglyMeasurable X ℙ
c : ℝ≥0
hc : c ≠ 0
A : ↑c ≠ 0
⊢ ℙ {ω | ↑c ≤ |X ω - ∫ (a : Ω), X a|} ≤ evariance X ℙ / ↑c ^ 2
tactic: have A : (c : ℝ≥0∞) ≠ 0 := by rwa [Ne, ENNReal.coe_eq_zero]
state_before: Ω : Type u_1
m : MeasurableSpace Ω
X✝ : Ω → ℝ
μ : Measure Ω
inst✝ : MeasureSpace Ω
X : Ω → ℝ
hX : AEStronglyMeasurable X ℙ
c : ℝ≥0
hc : c ≠ 0
A : ↑c ≠ 0
⊢ ℙ {ω | ↑c ≤ |X ω - ∫ (a : Ω), X a|} ≤ evariance X ℙ / ↑c ^ 2
state_after: Ω : Type u_1
m : MeasurableSpace Ω
X✝ : Ω → ℝ
μ : Measure Ω
inst✝ : MeasureSpace Ω
X : Ω → ℝ
hX : AEStronglyMeasurable X ℙ
c : ℝ≥0
hc : c ≠ 0
A : ↑c ≠ 0
B : AEStronglyMeasurable (fun x => ∫ (a : Ω), X a) ℙ
⊢ ℙ {ω | ↑c ≤ |X ω - ∫ (a : Ω), X a|} ≤ evariance X ℙ / ↑c ^ 2
tactic: have B : AEStronglyMeasurable (fun _ : Ω => 𝔼[X]) ℙ := aestronglyMeasurable_const
state_before: Ω : Type u_1
m : MeasurableSpace Ω
X✝ : Ω → ℝ
μ : Measure Ω
inst✝ : MeasureSpace Ω
X : Ω → ℝ
hX : AEStronglyMeasurable X ℙ
c : ℝ≥0
hc : c ≠ 0
A : ↑c ≠ 0
B : AEStronglyMeasurable (fun x => ∫ (a : Ω), X a) ℙ
⊢ ℙ {ω | ↑c ≤ |X ω - ∫ (a : Ω), X a|} ≤ evariance X ℙ / ↑c ^ 2
state_after: case h.e'_3
Ω : Type u_1
m : MeasurableSpace Ω
X✝ : Ω → ℝ
μ : Measure Ω
inst✝ : MeasureSpace Ω
X : Ω → ℝ
hX : AEStronglyMeasurable X ℙ
c : ℝ≥0
hc : c ≠ 0
A : ↑c ≠ 0
B : AEStronglyMeasurable (fun x => ∫ (a : Ω), X a) ℙ
⊢ ℙ {ω | ↑c ≤ |X ω - ∫ (a : Ω), X a|} = ℙ {x | ↑c ≤ ↑‖(X - fun x => ∫ (a : Ω), X a) x‖₊}

case h.e'_4
Ω : Type u_1
m : MeasurableSpace Ω
X✝ : Ω → ℝ
μ : Measure Ω
inst✝ : MeasureSpace Ω
X : Ω → ℝ
hX : AEStronglyMeasurable X ℙ
c : ℝ≥0
hc : c ≠ 0
A : ↑c ≠ 0
B : AEStronglyMeasurable (fun x => ∫ (a : Ω), X a) ℙ
⊢ evariance X ℙ / ↑c ^ 2 = (↑c)⁻¹ ^ ENNReal.toReal 2 * eLpNorm (X - fun x => ∫ (a : Ω), X a) 2 ℙ ^ ENNReal.toReal 2
tactic: convert meas_ge_le_mul_pow_eLpNorm ℙ two_ne_zero ENNReal.two_ne_top (hX.sub B) A using 1