ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: StarMemClass.star_coe_eq
File: Mathlib/Algebra/Star/Pointwise.lean

Proof steps:
state_before: S : Type u_1
α : Type u_2
inst✝² : InvolutiveStar α
inst✝¹ : SetLike S α
inst✝ : StarMemClass S α
s : S
⊢ star ↑s = ↑s
state_after: case h
S : Type u_1
α : Type u_2
inst✝² : InvolutiveStar α
inst✝¹ : SetLike S α
inst✝ : StarMemClass S α
s : S
x : α
⊢ x ∈ star ↑s ↔ x ∈ ↑s
tactic: ext x
state_before: case h
S : Type u_1
α : Type u_2
inst✝² : InvolutiveStar α
inst✝¹ : SetLike S α
inst✝ : StarMemClass S α
s : S
x : α
⊢ x ∈ star ↑s ↔ x ∈ ↑s
state_after: case h
S : Type u_1
α : Type u_2
inst✝² : InvolutiveStar α
inst✝¹ : SetLike S α
inst✝ : StarMemClass S α
s : S
x : α
⊢ star x ∈ s ↔ x ∈ s
tactic: simp only [Set.mem_star, SetLike.mem_coe]
state_before: case h
S : Type u_1
α : Type u_2
inst✝² : InvolutiveStar α
inst✝¹ : SetLike S α
inst✝ : StarMemClass S α
s : S
x : α
⊢ star x ∈ s ↔ x ∈ s
state_after: no goals
tactic: exact ⟨by simpa only [star_star] using star_mem (s := s) (r := star x), star_mem⟩
Theorem: TopologicalSpace.Clopens.exists_finset_eq_sup_prod
File: Mathlib/Topology/ClopenBox.lean

Proof steps:
state_before: X : Type u_1
Y : Type u_2
inst✝³ : TopologicalSpace X
inst✝² : TopologicalSpace Y
inst✝¹ : CompactSpace Y
inst✝ : CompactSpace X
W : Clopens (X × Y)
⊢ ∃ I, W = I.sup fun i => i.1 ×ˢ i.2
state_after: X : Type u_1
Y : Type u_2
inst✝³ : TopologicalSpace X
inst✝² : TopologicalSpace Y
inst✝¹ : CompactSpace Y
inst✝ : CompactSpace X
W : Clopens (X × Y)
U : X × Y → Clopens X
hxU : ∀ x ∈ W, x.1 ∈ U x
V : X × Y → Clopens Y
hxV : ∀ x ∈ W, x.2 ∈ V x
hUV : ∀ x ∈ W, U x ×ˢ V x ≤ W
⊢ ∃ I, W = I.sup fun i => i.1 ×ˢ i.2
tactic: choose! U hxU V hxV hUV using fun x ↦ W.exists_prod_subset (a := x)
state_before: X : Type u_1
Y : Type u_2
inst✝³ : TopologicalSpace X
inst✝² : TopologicalSpace Y
inst✝¹ : CompactSpace Y
inst✝ : CompactSpace X
W : Clopens (X × Y)
U : X × Y → Clopens X
hxU : ∀ x ∈ W, x.1 ∈ U x
V : X × Y → Clopens Y
hxV : ∀ x ∈ W, x.2 ∈ V x
hUV : ∀ x ∈ W, U x ×ˢ V x ≤ W
⊢ ∃ I, W = I.sup fun i => i.1 ×ˢ i.2
state_after: case intro.intro
X : Type u_1
Y : Type u_2
inst✝³ : TopologicalSpace X
inst✝² : TopologicalSpace Y
inst✝¹ : CompactSpace Y
inst✝ : CompactSpace X
W : Clopens (X × Y)
U : X × Y → Clopens X
hxU : ∀ x ∈ W, x.1 ∈ U x
V : X × Y → Clopens Y
hxV : ∀ x ∈ W, x.2 ∈ V x
hUV : ∀ x ∈ W, U x ×ˢ V x ≤ W
I : Finset (X × Y)
hIW : ∀ x ∈ I, x ∈ W.carrier
hWI : W.carrier ⊆ ⋃ x ∈ I, ↑(U x) ×ˢ ↑(V x)
⊢ ∃ I, W = I.sup fun i => i.1 ×ˢ i.2
tactic: rcases W.2.1.isCompact.elim_nhds_subcover (fun x ↦ U x ×ˢ V x) (fun x hx ↦
    (U x ×ˢ V x).2.isOpen.mem_nhds ⟨hxU x hx, hxV x hx⟩) with ⟨I, hIW, hWI⟩
Theorem: CategoryTheory.Functor.reflectsEpimorphisms.of_iso
File: Mathlib/CategoryTheory/Functor/EpiMono.lean

Proof steps:
state_before: C : Type u₁
inst✝³ : Category.{v₁, u₁} C
D : Type u₂
inst✝² : Category.{v₂, u₂} D
E : Type u₃
inst✝¹ : Category.{v₃, u₃} E
F G : C ⥤ D
inst✝ : F.ReflectsEpimorphisms
α : F ≅ G
X Y : C
f : X ⟶ Y
h : Epi (G.map f)
⊢ Epi f
state_after: C : Type u₁
inst✝³ : Category.{v₁, u₁} C
D : Type u₂
inst✝² : Category.{v₂, u₂} D
E : Type u₃
inst✝¹ : Category.{v₃, u₃} E
F G : C ⥤ D
inst✝ : F.ReflectsEpimorphisms
α : F ≅ G
X Y : C
f : X ⟶ Y
h : Epi (G.map f)
⊢ Epi (F.map f)
tactic: apply F.epi_of_epi_map
state_before: C : Type u₁
inst✝³ : Category.{v₁, u₁} C
D : Type u₂
inst✝² : Category.{v₂, u₂} D
E : Type u₃
inst✝¹ : Category.{v₃, u₃} E
F G : C ⥤ D
inst✝ : F.ReflectsEpimorphisms
α : F ≅ G
X Y : C
f : X ⟶ Y
h : Epi (G.map f)
⊢ Epi (F.map f)
state_after: C : Type u₁
inst✝³ : Category.{v₁, u₁} C
D : Type u₂
inst✝² : Category.{v₂, u₂} D
E : Type u₃
inst✝¹ : Category.{v₃, u₃} E
F G : C ⥤ D
inst✝ : F.ReflectsEpimorphisms
α : F ≅ G
X Y : C
f : X ⟶ Y
h : Epi (G.map f)
this : Epi (G.map f ≫ (α.app Y).inv)
⊢ Epi (F.map f)
tactic: haveI : Epi (G.map f ≫ (α.app Y).inv) := epi_comp _ _
state_before: C : Type u₁
inst✝³ : Category.{v₁, u₁} C
D : Type u₂
inst✝² : Category.{v₂, u₂} D
E : Type u₃
inst✝¹ : Category.{v₃, u₃} E
F G : C ⥤ D
inst✝ : F.ReflectsEpimorphisms
α : F ≅ G
X Y : C
f : X ⟶ Y
h : Epi (G.map f)
this : Epi (G.map f ≫ (α.app Y).inv)
⊢ Epi (F.map f)
state_after: case h.e'_5
C : Type u₁
inst✝³ : Category.{v₁, u₁} C
D : Type u₂
inst✝² : Category.{v₂, u₂} D
E : Type u₃
inst✝¹ : Category.{v₃, u₃} E
F G : C ⥤ D
inst✝ : F.ReflectsEpimorphisms
α : F ≅ G
X Y : C
f : X ⟶ Y
h : Epi (G.map f)
this : Epi (G.map f ≫ (α.app Y).inv)
⊢ F.map f = (α.app X).hom ≫ G.map f ≫ (α.app Y).inv
tactic: convert (epi_comp _ _ : Epi ((α.app X).hom ≫ G.map f ≫ (α.app Y).inv))
state_before: case h.e'_5
C : Type u₁
inst✝³ : Category.{v₁, u₁} C
D : Type u₂
inst✝² : Category.{v₂, u₂} D
E : Type u₃
inst✝¹ : Category.{v₃, u₃} E
F G : C ⥤ D
inst✝ : F.ReflectsEpimorphisms
α : F ≅ G
X Y : C
f : X ⟶ Y
h : Epi (G.map f)
this : Epi (G.map f ≫ (α.app Y).inv)
⊢ F.map f = (α.app X).hom ≫ G.map f ≫ (α.app Y).inv
state_after: no goals
tactic: rw [← Category.assoc, Iso.eq_comp_inv, Iso.app_hom, Iso.app_hom, NatTrans.naturality]
Theorem: Filter.tendsto_iff_rtendsto
File: Mathlib/Order/Filter/Partial.lean

Proof steps:
state_before: α : Type u
β : Type v
γ : Type w
l₁ : Filter α
l₂ : Filter β
f : α → β
⊢ Tendsto f l₁ l₂ ↔ RTendsto (Function.graph f) l₁ l₂
state_after: no goals
tactic: simp [tendsto_def, Function.graph, rtendsto_def, Rel.core, Set.preimage]
Theorem: Matrix.eta_fin_three
File: Mathlib/Data/Matrix/Notation.lean

Proof steps:
state_before: α : Type u
o n m : ℕ
m' : Type uₘ
n' : Type uₙ
o' : Type uₒ
a b : ℕ
A : Matrix (Fin 3) (Fin 3) α
⊢ A = !![A 0 0, A 0 1, A 0 2; A 1 0, A 1 1, A 1 2; A 2 0, A 2 1, A 2 2]
state_after: case a
α : Type u
o n m : ℕ
m' : Type uₘ
n' : Type uₙ
o' : Type uₒ
a b : ℕ
A : Matrix (Fin 3) (Fin 3) α
i j : Fin 3
⊢ A i j = !![A 0 0, A 0 1, A 0 2; A 1 0, A 1 1, A 1 2; A 2 0, A 2 1, A 2 2] i j
tactic: ext i j
state_before: case a
α : Type u
o n m : ℕ
m' : Type uₘ
n' : Type uₙ
o' : Type uₒ
a b : ℕ
A : Matrix (Fin 3) (Fin 3) α
i j : Fin 3
⊢ A i j = !![A 0 0, A 0 1, A 0 2; A 1 0, A 1 1, A 1 2; A 2 0, A 2 1, A 2 2] i j
state_after: no goals
tactic: fin_cases i <;> fin_cases j <;> rfl
Theorem: LinearMap.separatingRight_iff_flip_ker_eq_bot
File: Mathlib/LinearAlgebra/SesquilinearForm.lean

Proof steps:
state_before: R : Type u_1
R₁ : Type u_2
R₂ : Type u_3
R₃ : Type u_4
M : Type u_5
M₁ : Type u_6
M₂ : Type u_7
M₃ : Type u_8
Mₗ₁ : Type u_9
Mₗ₁' : Type u_10
Mₗ₂ : Type u_11
Mₗ₂' : Type u_12
K : Type u_13
K₁ : Type u_14
K₂ : Type u_15
V : Type u_16
V₁ : Type u_17
V₂ : Type u_18
n : Type u_19
inst✝⁸ : CommSemiring R
inst✝⁷ : AddCommMonoid M
inst✝⁶ : Module R M
inst✝⁵ : CommSemiring R₁
inst✝⁴ : AddCommMonoid M₁
inst✝³ : Module R₁ M₁
inst✝² : CommSemiring R₂
inst✝¹ : AddCommMonoid M₂
inst✝ : Module R₂ M₂
I₁ : R₁ →+* R
I₂ : R₂ →+* R
I₁' : R₁ →+* R
B : M₁ →ₛₗ[I₁] M₂ →ₛₗ[I₂] M
⊢ B.SeparatingRight ↔ ker B.flip = ⊥
state_after: no goals
tactic: rw [← flip_separatingLeft, separatingLeft_iff_ker_eq_bot]
Theorem: AddSubgroupClass.subset_union
File: Mathlib/Algebra/Group/Subgroup/Basic.lean

Proof steps:
state_before: G : Type u_1
G' : Type u_2
G'' : Type u_3
inst✝⁷ : Group G
inst✝⁶ : Group G'
inst✝⁵ : Group G''
A : Type u_4
inst✝⁴ : AddGroup A
M : Type u_5
S : Type u_6
inst✝³ : DivInvMonoid M
inst✝² : SetLike S M
hSM : SubgroupClass S M
H✝ K✝ : S
inst✝¹ : SetLike S G
inst✝ : SubgroupClass S G
H K L : S
h : ↑H ⊆ ↑K ∪ ↑L
⊢ H ≤ K ∨ H ≤ L
state_after: G : Type u_1
G' : Type u_2
G'' : Type u_3
inst✝⁷ : Group G
inst✝⁶ : Group G'
inst✝⁵ : Group G''
A : Type u_4
inst✝⁴ : AddGroup A
M : Type u_5
S : Type u_6
inst✝³ : DivInvMonoid M
inst✝² : SetLike S M
hSM : SubgroupClass S M
H✝ K✝ : S
inst✝¹ : SetLike S G
inst✝ : SubgroupClass S G
H K L : S
h : ↑H ⊆ ↑K ∪ ↑L
⊢ (∃ x ∈ H, x ∉ K) → H ≤ L
tactic: rw [or_iff_not_imp_left, SetLike.not_le_iff_exists]
Theorem: Polynomial.integralNormalization_coeff_degree
File: Mathlib/RingTheory/Polynomial/IntegralNormalization.lean

Proof steps:
state_before: R : Type u
S : Type v
a b : R
m n : ℕ
ι : Type y
inst✝ : Semiring R
f : R[X]
i : ℕ
hi : f.degree = ↑i
⊢ f.integralNormalization.coeff i = 1
state_after: no goals
tactic: rw [integralNormalization_coeff, if_pos hi]
Theorem: gauge_lt_one_of_mem_of_isOpen
File: Mathlib/Analysis/Convex/Gauge.lean

Proof steps:
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
inst✝³ : AddCommGroup E
inst✝² : Module ℝ E
s t : Set E
x✝ : E
a : ℝ
inst✝¹ : TopologicalSpace E
inst✝ : ContinuousSMul ℝ E
hs₂ : IsOpen s
x : E
hx : x ∈ s
⊢ x ∈ interior s
state_after: no goals
tactic: rwa [hs₂.interior_eq]
Theorem: DirichletCharacter.convolution_twist_vonMangoldt
File: Mathlib/NumberTheory/LSeries/Dirichlet.lean

Proof steps:
state_before: N : ℕ
χ : DirichletCharacter ℂ N
⊢ (((fun n => χ ↑n) * fun n => ↑(Λ n)) ⍟ fun n => χ ↑n) = (fun n => χ ↑n) * fun n => Complex.log ↑n
state_after: no goals
tactic: rw [← convolution_vonMangoldt_const_one, ← χ.mul_convolution_distrib, mul_one]
Theorem: Complex.abs_add_mul_I
File: Mathlib/Data/Complex/Abs.lean

Proof steps:
state_before: x y : ℝ
⊢ abs (↑x + ↑y * I) = √(x ^ 2 + y ^ 2)
state_after: x y : ℝ
⊢ abs (↑x + ↑y * I) = √(normSq (↑x + ↑y * I))
tactic: rw [← normSq_add_mul_I]
state_before: x y : ℝ
⊢ abs (↑x + ↑y * I) = √(normSq (↑x + ↑y * I))
state_after: no goals
tactic: rfl
Theorem: Monoid.CoprodI.of_injective
File: Mathlib/GroupTheory/CoprodI.lean

Proof steps:
state_before: ι : Type u_1
M : ι → Type u_2
inst✝¹ : (i : ι) → Monoid (M i)
N : Type u_3
inst✝ : Monoid N
i : ι
⊢ Function.Injective ⇑of
state_after: no goals
tactic: classical exact (of_leftInverse i).injective
Theorem: Finset.Colex.singleton_lt_singleton
File: Mathlib/Combinatorics/Colex.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
inst✝¹ : PartialOrder α
inst✝ : PartialOrder β
f : α → β
𝒜 𝒜₁ 𝒜₂ : Finset (Finset α)
s t u : Finset α
a b : α
⊢ { ofColex := {a} } < { ofColex := {b} } ↔ a < b
state_after: no goals
tactic: simp [toColex_lt_singleton]
Theorem: CategoryTheory.ShortComplex.Exact.unop
File: Mathlib/Algebra/Homology/ShortComplex/Exact.lean

Proof steps:
state_before: C : Type u_1
D : Type u_2
inst✝³ : Category.{u_3, u_1} C
inst✝² : Category.{?u.18276, u_2} D
inst✝¹ : HasZeroMorphisms C
inst✝ : HasZeroMorphisms D
S✝ S₁ S₂ : ShortComplex C
S : ShortComplex Cᵒᵖ
h : S.Exact
⊢ S.unop.Exact
state_after: case mk.intro
C : Type u_1
D : Type u_2
inst✝³ : Category.{u_3, u_1} C
inst✝² : Category.{?u.18276, u_2} D
inst✝¹ : HasZeroMorphisms C
inst✝ : HasZeroMorphisms D
S✝ S₁ S₂ : ShortComplex C
S : ShortComplex Cᵒᵖ
h : S.HomologyData
z : IsZero h.left.H
⊢ S.unop.Exact
tactic: obtain ⟨h, z⟩ := h
state_before: case mk.intro
C : Type u_1
D : Type u_2
inst✝³ : Category.{u_3, u_1} C
inst✝² : Category.{?u.18276, u_2} D
inst✝¹ : HasZeroMorphisms C
inst✝ : HasZeroMorphisms D
S✝ S₁ S₂ : ShortComplex C
S : ShortComplex Cᵒᵖ
h : S.HomologyData
z : IsZero h.left.H
⊢ S.unop.Exact
state_after: no goals
tactic: exact ⟨⟨h.unop, (IsZero.of_iso z h.iso.symm).unop⟩⟩
Theorem: Submonoid.bot_prod_bot
File: Mathlib/Algebra/Group/Submonoid/Operations.lean

Proof steps:
state_before: M : Type u_1
N : Type u_2
P : Type u_3
inst✝³ : MulOneClass M
inst✝² : MulOneClass N
inst✝¹ : MulOneClass P
S : Submonoid M
A : Type u_4
inst✝ : SetLike A M
hA : SubmonoidClass A M
S' : A
⊢ ↑(⊥.prod ⊥) = ↑⊥
state_after: no goals
tactic: simp [coe_prod, Prod.one_eq_mk]
Theorem: Cardinal.lift_le_aleph0
File: Mathlib/SetTheory/Cardinal/Basic.lean

Proof steps:
state_before: α β : Type u
c : Cardinal.{u}
⊢ lift.{v, u} c ≤ ℵ₀ ↔ c ≤ ℵ₀
state_after: no goals
tactic: rw [← lift_aleph0.{v, u}, lift_le]
Theorem: Matrix.TransvectionStruct.toMatrix_reindexEquiv_prod
File: Mathlib/LinearAlgebra/Matrix/Transvection.lean

Proof steps:
state_before: n : Type u_1
p : Type u_2
R : Type u₂
𝕜 : Type u_3
inst✝⁵ : Field 𝕜
inst✝⁴ : DecidableEq n
inst✝³ : DecidableEq p
inst✝² : CommRing R
i j : n
inst✝¹ : Fintype n
inst✝ : Fintype p
e : n ≃ p
L : List (TransvectionStruct n R)
⊢ (List.map (toMatrix ∘ reindexEquiv e) L).prod = (reindexAlgEquiv R R e) (List.map toMatrix L).prod
state_after: case nil
n : Type u_1
p : Type u_2
R : Type u₂
𝕜 : Type u_3
inst✝⁵ : Field 𝕜
inst✝⁴ : DecidableEq n
inst✝³ : DecidableEq p
inst✝² : CommRing R
i j : n
inst✝¹ : Fintype n
inst✝ : Fintype p
e : n ≃ p
⊢ (List.map (toMatrix ∘ reindexEquiv e) []).prod = (reindexAlgEquiv R R e) (List.map toMatrix []).prod

case cons
n : Type u_1
p : Type u_2
R : Type u₂
𝕜 : Type u_3
inst✝⁵ : Field 𝕜
inst✝⁴ : DecidableEq n
inst✝³ : DecidableEq p
inst✝² : CommRing R
i j : n
inst✝¹ : Fintype n
inst✝ : Fintype p
e : n ≃ p
t : TransvectionStruct n R
L : List (TransvectionStruct n R)
IH : (List.map (toMatrix ∘ reindexEquiv e) L).prod = (reindexAlgEquiv R R e) (List.map toMatrix L).prod
⊢ (List.map (toMatrix ∘ reindexEquiv e) (t :: L)).prod = (reindexAlgEquiv R R e) (List.map toMatrix (t :: L)).prod
tactic: induction' L with t L IH
Theorem: Multiset.toEnumFinset_filter_eq
File: Mathlib/Data/Multiset/Fintype.lean

Proof steps:
state_before: α : Type u_1
inst✝ : DecidableEq α
m✝ m : Multiset α
a : α
⊢ Finset.filter (fun x => x.1 = a) m.toEnumFinset = {a} ×ˢ Finset.range (count a m)
state_after: no goals
tactic: aesop
Theorem: sSup_atoms_le_eq
File: Mathlib/Order/Atoms.lean

Proof steps:
state_before: ι : Sort u_1
α : Type u_2
β : Type u_3
inst✝¹ : CompleteLattice α
inst✝ : IsAtomistic α
b : α
⊢ sSup {a | IsAtom a ∧ a ≤ b} = b
state_after: case intro.intro
ι : Sort u_1
α : Type u_2
β : Type u_3
inst✝¹ : CompleteLattice α
inst✝ : IsAtomistic α
s : Set α
hs : ∀ a ∈ s, IsAtom a
⊢ sSup {a | IsAtom a ∧ a ≤ sSup s} = sSup s
tactic: rcases eq_sSup_atoms b with ⟨s, rfl, hs⟩
state_before: case intro.intro
ι : Sort u_1
α : Type u_2
β : Type u_3
inst✝¹ : CompleteLattice α
inst✝ : IsAtomistic α
s : Set α
hs : ∀ a ∈ s, IsAtom a
⊢ sSup {a | IsAtom a ∧ a ≤ sSup s} = sSup s
state_after: no goals
tactic: exact le_antisymm (sSup_le fun _ => And.right) (sSup_le_sSup fun a ha => ⟨hs a ha, le_sSup ha⟩)
Theorem: Subgroup.prod_top
File: Mathlib/Algebra/Group/Subgroup/Basic.lean

Proof steps:
state_before: G : Type u_1
G' : Type u_2
G'' : Type u_3
inst✝⁵ : Group G
inst✝⁴ : Group G'
inst✝³ : Group G''
A : Type u_4
inst✝² : AddGroup A
H K✝ : Subgroup G
k : Set G
N : Type u_5
inst✝¹ : Group N
P : Type u_6
inst✝ : Group P
K : Subgroup G
x : G × N
⊢ x ∈ K.prod ⊤ ↔ x ∈ comap (MonoidHom.fst G N) K
state_after: no goals
tactic: simp [mem_prod, MonoidHom.coe_fst]
Theorem: Polynomial.degree_eq_card_roots
File: Mathlib/Algebra/Polynomial/Splits.lean

Proof steps:
state_before: R : Type u_1
F : Type u
K : Type v
L : Type w
inst✝³ : CommRing R
inst✝² : Field K
inst✝¹ : Field L
inst✝ : Field F
i✝ : K →+* L
p : K[X]
i : K →+* L
p_ne_zero : p ≠ 0
hsplit : Splits i p
⊢ p.degree = ↑(Multiset.card (map i p).roots)
state_after: no goals
tactic: rw [degree_eq_natDegree p_ne_zero, natDegree_eq_card_roots hsplit]
Theorem: List.rotate'_zero
File: Mathlib/Data/List/Rotate.lean

Proof steps:
state_before: α : Type u
l : List α
⊢ l.rotate' 0 = l
state_after: no goals
tactic: cases l <;> rfl
Theorem: Multiset.inter_replicate
File: Mathlib/Data/Multiset/Basic.lean

Proof steps:
state_before: α : Type u_1
β : Type v
γ : Type u_2
inst✝ : DecidableEq α
s✝ s : Multiset α
n : ℕ
x : α
⊢ s ∩ replicate n x = replicate (min (count x s) n) x
state_after: no goals
tactic: rw [inter_comm, replicate_inter, min_comm]
Theorem: ContDiffBump.pos_of_mem_ball
File: Mathlib/Analysis/Calculus/BumpFunction/Basic.lean

Proof steps:
state_before: E : Type u_1
X : Type u_2
inst✝⁴ : NormedAddCommGroup E
inst✝³ : NormedSpace ℝ E
inst✝² : NormedAddCommGroup X
inst✝¹ : NormedSpace ℝ X
inst✝ : HasContDiffBump E
c : E
f : ContDiffBump c
x : E
n : ℕ∞
hx : x ∈ ball c f.rOut
⊢ ↑f x ≠ 0
state_after: no goals
tactic: rwa [← support_eq, mem_support] at hx
Theorem: ENNReal.mul_left_strictMono
File: Mathlib/Data/ENNReal/Operations.lean

Proof steps:
state_before: a b c d : ℝ≥0∞
r p q : ℝ≥0
h0 : a ≠ 0
hinf : a ≠ ⊤
⊢ StrictMono fun x => a * x
state_after: case intro
b c d : ℝ≥0∞
r p q a : ℝ≥0
h0 : ↑a ≠ 0
⊢ StrictMono fun x => ↑a * x
tactic: lift a to ℝ≥0 using hinf
state_before: case intro
b c d : ℝ≥0∞
r p q a : ℝ≥0
h0 : ↑a ≠ 0
⊢ StrictMono fun x => ↑a * x
state_after: case intro
b c d : ℝ≥0∞
r p q a : ℝ≥0
h0 : a ≠ 0
⊢ StrictMono fun x => ↑a * x
tactic: rw [coe_ne_zero] at h0
state_before: case intro
b c d : ℝ≥0∞
r p q a : ℝ≥0
h0 : a ≠ 0
⊢ StrictMono fun x => ↑a * x
state_after: case intro
b c d : ℝ≥0∞
r p q a : ℝ≥0
h0 : a ≠ 0
x y : ℝ≥0∞
h : x < y
⊢ (fun x => ↑a * x) x < (fun x => ↑a * x) y
tactic: intro x y h
state_before: case intro
b c d : ℝ≥0∞
r p q a : ℝ≥0
h0 : a ≠ 0
x y : ℝ≥0∞
h : x < y
⊢ (fun x => ↑a * x) x < (fun x => ↑a * x) y
state_after: case intro
b c d : ℝ≥0∞
r p q a : ℝ≥0
h0 : a ≠ 0
x y : ℝ≥0∞
h : ↑a * y ≤ ↑a * x
⊢ y ≤ x
tactic: contrapose! h
state_before: case intro
b c d : ℝ≥0∞
r p q a : ℝ≥0
h0 : a ≠ 0
x y : ℝ≥0∞
h : ↑a * y ≤ ↑a * x
⊢ y ≤ x
state_after: no goals
tactic: simpa only [← mul_assoc, ← coe_mul, inv_mul_cancel h0, coe_one, one_mul]
    using mul_le_mul_left' h (↑a⁻¹)
Theorem: Ordinal.nmul_le_iff₃'
File: Mathlib/SetTheory/Ordinal/NaturalOps.lean

Proof steps:
state_before: a b c d : Ordinal.{u}
⊢ a ⨳ (b ⨳ c) ≤ d ↔
    ∀ a' < a,
      ∀ b' < b,
        ∀ c' < c,
          a' ⨳ (b ⨳ c) ♯ a ⨳ (b' ⨳ c) ♯ a ⨳ (b ⨳ c') ♯ a' ⨳ (b' ⨳ c') <
            d ♯ a' ⨳ (b' ⨳ c) ♯ a' ⨳ (b ⨳ c') ♯ a ⨳ (b' ⨳ c')
state_after: a b c d : Ordinal.{u}
⊢ ¬a ⨳ (b ⨳ c) ≤ d ↔
    ¬∀ a' < a,
        ∀ b' < b,
          ∀ c' < c,
            a' ⨳ (b ⨳ c) ♯ a ⨳ (b' ⨳ c) ♯ a ⨳ (b ⨳ c') ♯ a' ⨳ (b' ⨳ c') <
              d ♯ a' ⨳ (b' ⨳ c) ♯ a' ⨳ (b ⨳ c') ♯ a ⨳ (b' ⨳ c')
tactic: rw [← not_iff_not]
state_before: a b c d : Ordinal.{u}
⊢ ¬a ⨳ (b ⨳ c) ≤ d ↔
    ¬∀ a' < a,
        ∀ b' < b,
          ∀ c' < c,
            a' ⨳ (b ⨳ c) ♯ a ⨳ (b' ⨳ c) ♯ a ⨳ (b ⨳ c') ♯ a' ⨳ (b' ⨳ c') <
              d ♯ a' ⨳ (b' ⨳ c) ♯ a' ⨳ (b ⨳ c') ♯ a ⨳ (b' ⨳ c')
state_after: no goals
tactic: simp [lt_nmul_iff₃']
Theorem: MeasureTheory.setLIntegral_tilted'
File: Mathlib/MeasureTheory/Measure/Tilted.lean

Proof steps:
state_before: α : Type u_1
mα : MeasurableSpace α
μ : Measure α
f✝ f : α → ℝ
g : α → ℝ≥0∞
s : Set α
hs : MeasurableSet s
⊢ ∫⁻ (x : α) in s, g x ∂μ.tilted f = ∫⁻ (x : α) in s, ENNReal.ofReal (rexp (f x) / ∫ (x : α), rexp (f x) ∂μ) * g x ∂μ
state_after: case pos
α : Type u_1
mα : MeasurableSpace α
μ : Measure α
f✝ f : α → ℝ
g : α → ℝ≥0∞
s : Set α
hs : MeasurableSet s
hf : AEMeasurable f μ
⊢ ∫⁻ (x : α) in s, g x ∂μ.tilted f = ∫⁻ (x : α) in s, ENNReal.ofReal (rexp (f x) / ∫ (x : α), rexp (f x) ∂μ) * g x ∂μ

case neg
α : Type u_1
mα : MeasurableSpace α
μ : Measure α
f✝ f : α → ℝ
g : α → ℝ≥0∞
s : Set α
hs : MeasurableSet s
hf : ¬AEMeasurable f μ
⊢ ∫⁻ (x : α) in s, g x ∂μ.tilted f = ∫⁻ (x : α) in s, ENNReal.ofReal (rexp (f x) / ∫ (x : α), rexp (f x) ∂μ) * g x ∂μ
tactic: by_cases hf : AEMeasurable f μ
Theorem: Filter.comap_comm
File: Mathlib/Order/Filter/Basic.lean

Proof steps:
state_before: α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
l f f₁ f₂ : Filter α
g g₁ g₂ : Filter β
m : α → β
m' : β → γ
s : Set α
t : Set β
φ : α → β
θ : α → γ
ψ : β → δ
ρ : γ → δ
H : ψ ∘ φ = ρ ∘ θ
G : Filter δ
⊢ comap φ (comap ψ G) = comap θ (comap ρ G)
state_after: no goals
tactic: rw [Filter.comap_comap, H, ← Filter.comap_comap]
Theorem: cmp_eq_cmp_symm
File: Mathlib/Order/Compare.lean

Proof steps:
state_before: α : Type u_1
β✝ : Type u_2
inst✝¹ : LinearOrder α
x y : α
β : Type u_3
inst✝ : LinearOrder β
x' y' : β
h : cmp x y = cmp x' y'
⊢ cmp y x = cmp y' x'
state_after: no goals
tactic: rwa [← cmp_swap x', ← cmp_swap, swap_inj]
state_before: α : Type u_1
β✝ : Type u_2
inst✝¹ : LinearOrder α
x y : α
β : Type u_3
inst✝ : LinearOrder β
x' y' : β
h : cmp y x = cmp y' x'
⊢ cmp x y = cmp x' y'
state_after: no goals
tactic: rwa [← cmp_swap y', ← cmp_swap, swap_inj]
Theorem: IsRelPrime.of_dvd_left
File: Mathlib/Algebra/Divisibility/Units.lean

Proof steps:
state_before: α : Type u_1
inst✝ : CommMonoid α
x y z : α
h : IsRelPrime y z
dvd : x ∣ y
⊢ IsRelPrime x z
state_after: case intro
α : Type u_1
inst✝ : CommMonoid α
x z d : α
h : IsRelPrime (x * d) z
⊢ IsRelPrime x z
tactic: obtain ⟨d, rfl⟩ := dvd
state_before: case intro
α : Type u_1
inst✝ : CommMonoid α
x z d : α
h : IsRelPrime (x * d) z
⊢ IsRelPrime x z
state_after: no goals
tactic: exact IsRelPrime.of_mul_left_left h
Theorem: BoxIntegral.Prepartition.IsPartition.exists_splitMany_le
File: Mathlib/Analysis/BoxIntegral/Partition/Split.lean

Proof steps:
state_before: ι : Type u_1
M : Type u_2
n : ℕ
I✝ J : Box ι
i : ι
x : ℝ
inst✝ : Finite ι
I : Box ι
π : Prepartition I
h : π.IsPartition
⊢ ∃ s, splitMany I s ≤ π
state_after: ι : Type u_1
M : Type u_2
n : ℕ
I✝ J : Box ι
i : ι
x : ℝ
inst✝ : Finite ι
I : Box ι
π : Prepartition I
h : π.IsPartition
s : Finset (ι × ℝ)
hs : π ⊓ splitMany I s = (splitMany I s).filter fun J => ↑J ⊆ π.iUnion
⊢ splitMany I s ≤ π
tactic: refine (eventually_splitMany_inf_eq_filter π).exists.imp fun s hs => ?_
state_before: ι : Type u_1
M : Type u_2
n : ℕ
I✝ J : Box ι
i : ι
x : ℝ
inst✝ : Finite ι
I : Box ι
π : Prepartition I
h : π.IsPartition
s : Finset (ι × ℝ)
hs : π ⊓ splitMany I s = (splitMany I s).filter fun J => ↑J ⊆ π.iUnion
⊢ splitMany I s ≤ π
state_after: case hp
ι : Type u_1
M : Type u_2
n : ℕ
I✝ J : Box ι
i : ι
x : ℝ
inst✝ : Finite ι
I : Box ι
π : Prepartition I
h : π.IsPartition
s : Finset (ι × ℝ)
hs : π ⊓ splitMany I s = (splitMany I s).filter fun J => ↑J ⊆ ↑I
⊢ ∀ J ∈ splitMany I s, ↑J ⊆ ↑I
tactic: rwa [h.iUnion_eq, filter_of_true, inf_eq_right] at hs
state_before: case hp
ι : Type u_1
M : Type u_2
n : ℕ
I✝ J : Box ι
i : ι
x : ℝ
inst✝ : Finite ι
I : Box ι
π : Prepartition I
h : π.IsPartition
s : Finset (ι × ℝ)
hs : π ⊓ splitMany I s = (splitMany I s).filter fun J => ↑J ⊆ ↑I
⊢ ∀ J ∈ splitMany I s, ↑J ⊆ ↑I
state_after: no goals
tactic: exact fun J hJ => le_of_mem _ hJ
Theorem: List.sum_reverse_noncomm
File: Mathlib/Algebra/BigOperators/Group/List.lean

Proof steps:
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
M : Type u_4
N : Type u_5
P : Type u_6
G : Type u_7
inst✝ : Group G
⊢ ∀ (L : List G), L.reverse.prod = (map (fun x => x⁻¹) L).prod⁻¹
state_after: no goals
tactic: simp [prod_inv_reverse]
Theorem: OrthonormalBasis.orthogonalProjection_eq_sum
File: Mathlib/Analysis/InnerProductSpace/PiL2.lean

Proof steps:
state_before: ι : Type u_1
ι' : Type u_2
𝕜 : Type u_3
inst✝¹⁰ : _root_.RCLike 𝕜
E : Type u_4
inst✝⁹ : NormedAddCommGroup E
inst✝⁸ : InnerProductSpace 𝕜 E
E' : Type u_5
inst✝⁷ : NormedAddCommGroup E'
inst✝⁶ : InnerProductSpace 𝕜 E'
F : Type u_6
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : InnerProductSpace ℝ F
F' : Type u_7
inst✝³ : NormedAddCommGroup F'
inst✝² : InnerProductSpace ℝ F'
inst✝¹ : Fintype ι
U : Submodule 𝕜 E
inst✝ : CompleteSpace ↥U
b : OrthonormalBasis ι 𝕜 ↥U
x : E
⊢ (orthogonalProjection U) x = ∑ i : ι, ⟪↑(b i), x⟫_𝕜 • b i
state_after: no goals
tactic: simpa only [b.repr_apply_apply, inner_orthogonalProjection_eq_of_mem_left] using
    (b.sum_repr (orthogonalProjection U x)).symm
Theorem: SimpleGraph.singletonSubgraph_fst_le_subgraphOfAdj
File: Mathlib/Combinatorics/SimpleGraph/Subgraph.lean

Proof steps:
state_before: ι : Sort u_1
V : Type u
W : Type v
G : SimpleGraph V
G' : SimpleGraph W
u v : V
h : G.Adj u v
⊢ G.singletonSubgraph u ≤ G.subgraphOfAdj h
state_after: no goals
tactic: simp