ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: CategoryTheory.Limits.coyonedaOpColimitIsoLimitCoyoneda'_inv_comp_π
File: Mathlib/CategoryTheory/Limits/IndYoneda.lean

Proof steps:
state_before: C : Type u₁
inst✝² : Category.{u₂, u₁} C
I : Type v₁
inst✝¹ : Category.{v₂, v₁} I
F : Iᵒᵖ ⥤ C
inst✝ : HasColimit F
i : I
⊢ (coyonedaOpColimitIsoLimitCoyoneda' F).inv ≫ coyoneda.map (colimit.ι F (op i)).op = limit.π (F.rightOp ⋙ coyoneda) i
state_after: no goals
tactic: rw [← coyonedaOpColimitIsoLimitCoyoneda'_hom_comp_π, ← Category.assoc,
    Iso.inv_hom_id, Category.id_comp]
Theorem: IsGroupHom.one_ker_inv'
File: Mathlib/Deprecated/Subgroup.lean

Proof steps:
state_before: G : Type u_1
H : Type u_2
A : Type u_3
a✝ a₁ a₂ b✝ c : G
inst✝¹ : Group G
inst✝ : Group H
f : G → H
hf : IsGroupHom f
a b : G
h : f (a⁻¹ * b) = 1
⊢ f a = f b
state_after: G : Type u_1
H : Type u_2
A : Type u_3
a✝ a₁ a₂ b✝ c : G
inst✝¹ : Group G
inst✝ : Group H
f : G → H
hf : IsGroupHom f
a b : G
h : (f a)⁻¹ * f b = 1
⊢ f a = f b
tactic: rw [hf.map_mul, hf.map_inv] at h
state_before: G : Type u_1
H : Type u_2
A : Type u_3
a✝ a₁ a₂ b✝ c : G
inst✝¹ : Group G
inst✝ : Group H
f : G → H
hf : IsGroupHom f
a b : G
h : (f a)⁻¹ * f b = 1
⊢ f a = f b
state_after: case a
G : Type u_1
H : Type u_2
A : Type u_3
a✝ a₁ a₂ b✝ c : G
inst✝¹ : Group G
inst✝ : Group H
f : G → H
hf : IsGroupHom f
a b : G
h : (f a)⁻¹ * f b = 1
⊢ (f a)⁻¹ = (f b)⁻¹
tactic: apply inv_injective
state_before: case a
G : Type u_1
H : Type u_2
A : Type u_3
a✝ a₁ a₂ b✝ c : G
inst✝¹ : Group G
inst✝ : Group H
f : G → H
hf : IsGroupHom f
a b : G
h : (f a)⁻¹ * f b = 1
⊢ (f a)⁻¹ = (f b)⁻¹
state_after: no goals
tactic: rw [eq_inv_of_mul_eq_one_left h]
Theorem: Function.Antiperiodic.odd_nsmul_antiperiodic
File: Mathlib/Algebra/Periodic.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
f g : α → β
c c₁ c₂ x✝ : α
inst✝¹ : AddMonoid α
inst✝ : InvolutiveNeg β
h : Antiperiodic f c
n : ℕ
x : α
⊢ f (x + (2 * n + 1) • c) = -f x
state_after: no goals
tactic: rw [add_nsmul, one_nsmul, ← add_assoc, h, h.even_nsmul_periodic]
Theorem: MeasureTheory.measurePreserving_sumPiEquivProdPi_symm
File: Mathlib/MeasureTheory/Constructions/Pi.lean

Proof steps:
state_before: ι : Type u_1
ι' : Type u_2
α : ι → Type u_3
inst✝³ : Fintype ι
m✝¹ : (i : ι) → OuterMeasure (α i)
m✝ : (i : ι) → MeasurableSpace (α i)
μ✝ : (i : ι) → Measure (α i)
inst✝² : ∀ (i : ι), SigmaFinite (μ✝ i)
inst✝¹ : Fintype ι'
π : ι ⊕ ι' → Type u_4
m : (i : ι ⊕ ι') → MeasurableSpace (π i)
μ : (i : ι ⊕ ι') → Measure (π i)
inst✝ : ∀ (i : ι ⊕ ι'), SigmaFinite (μ i)
⊢ Measure.map (⇑(MeasurableEquiv.sumPiEquivProdPi π).symm)
      ((Measure.pi fun i => μ (Sum.inl i)).prod (Measure.pi fun i => μ (Sum.inr i))) =
    Measure.pi μ
state_after: ι : Type u_1
ι' : Type u_2
α : ι → Type u_3
inst✝³ : Fintype ι
m✝¹ : (i : ι) → OuterMeasure (α i)
m✝ : (i : ι) → MeasurableSpace (α i)
μ✝ : (i : ι) → Measure (α i)
inst✝² : ∀ (i : ι), SigmaFinite (μ✝ i)
inst✝¹ : Fintype ι'
π : ι ⊕ ι' → Type u_4
m : (i : ι ⊕ ι') → MeasurableSpace (π i)
μ : (i : ι ⊕ ι') → Measure (π i)
inst✝ : ∀ (i : ι ⊕ ι'), SigmaFinite (μ i)
s : (i : ι ⊕ ι') → Set (π i)
x✝ : ∀ (i : ι ⊕ ι'), MeasurableSet (s i)
⊢ (Measure.map (⇑(MeasurableEquiv.sumPiEquivProdPi π).symm)
        ((Measure.pi fun i => μ (Sum.inl i)).prod (Measure.pi fun i => μ (Sum.inr i))))
      (univ.pi s) =
    ∏ i : ι ⊕ ι', (μ i) (s i)
tactic: refine (pi_eq fun s _ => ?_).symm
state_before: ι : Type u_1
ι' : Type u_2
α : ι → Type u_3
inst✝³ : Fintype ι
m✝¹ : (i : ι) → OuterMeasure (α i)
m✝ : (i : ι) → MeasurableSpace (α i)
μ✝ : (i : ι) → Measure (α i)
inst✝² : ∀ (i : ι), SigmaFinite (μ✝ i)
inst✝¹ : Fintype ι'
π : ι ⊕ ι' → Type u_4
m : (i : ι ⊕ ι') → MeasurableSpace (π i)
μ : (i : ι ⊕ ι') → Measure (π i)
inst✝ : ∀ (i : ι ⊕ ι'), SigmaFinite (μ i)
s : (i : ι ⊕ ι') → Set (π i)
x✝ : ∀ (i : ι ⊕ ι'), MeasurableSet (s i)
⊢ (Measure.map (⇑(MeasurableEquiv.sumPiEquivProdPi π).symm)
        ((Measure.pi fun i => μ (Sum.inl i)).prod (Measure.pi fun i => μ (Sum.inr i))))
      (univ.pi s) =
    ∏ i : ι ⊕ ι', (μ i) (s i)
state_after: no goals
tactic: simp_rw [MeasurableEquiv.map_apply, MeasurableEquiv.coe_sumPiEquivProdPi_symm,
      Equiv.sumPiEquivProdPi_symm_preimage_univ_pi, Measure.prod_prod, Measure.pi_pi,
      Fintype.prod_sum_type]
Theorem: String.contains_iff
File: .lake/packages/batteries/Batteries/Data/String/Lemmas.lean

Proof steps:
state_before: s : String
c : Char
⊢ s.contains c = true ↔ c ∈ s.data
state_after: no goals
tactic: simp [contains, any_iff]
Theorem: Int.ceil_eq_iff
File: Mathlib/Algebra/Order/Floor.lean

Proof steps:
state_before: F : Type u_1
α : Type u_2
β : Type u_3
inst✝¹ : LinearOrderedRing α
inst✝ : FloorRing α
z : ℤ
a : α
⊢ ⌈a⌉ = z ↔ ↑z - 1 < a ∧ a ≤ ↑z
state_after: no goals
tactic: rw [← ceil_le, ← Int.cast_one, ← Int.cast_sub, ← lt_ceil, Int.sub_one_lt_iff, le_antisymm_iff,
    and_comm]
Theorem: FractionalIdeal.isFractional_of_le_one
File: Mathlib/RingTheory/FractionalIdeal/Basic.lean

Proof steps:
state_before: R : Type u_1
inst✝² : CommRing R
S : Submonoid R
P : Type u_2
inst✝¹ : CommRing P
inst✝ : Algebra R P
loc : IsLocalization S P
I : Submodule R P
h : I ≤ 1
⊢ IsFractional S I
state_after: case right
R : Type u_1
inst✝² : CommRing R
S : Submonoid R
P : Type u_2
inst✝¹ : CommRing P
inst✝ : Algebra R P
loc : IsLocalization S P
I : Submodule R P
h : I ≤ 1
⊢ ∀ b ∈ I, IsInteger R (1 • b)
tactic: use 1, S.one_mem
state_before: case right
R : Type u_1
inst✝² : CommRing R
S : Submonoid R
P : Type u_2
inst✝¹ : CommRing P
inst✝ : Algebra R P
loc : IsLocalization S P
I : Submodule R P
h : I ≤ 1
⊢ ∀ b ∈ I, IsInteger R (1 • b)
state_after: case right
R : Type u_1
inst✝² : CommRing R
S : Submonoid R
P : Type u_2
inst✝¹ : CommRing P
inst✝ : Algebra R P
loc : IsLocalization S P
I : Submodule R P
h : I ≤ 1
b : P
hb : b ∈ I
⊢ IsInteger R (1 • b)
tactic: intro b hb
state_before: case right
R : Type u_1
inst✝² : CommRing R
S : Submonoid R
P : Type u_2
inst✝¹ : CommRing P
inst✝ : Algebra R P
loc : IsLocalization S P
I : Submodule R P
h : I ≤ 1
b : P
hb : b ∈ I
⊢ IsInteger R (1 • b)
state_after: case right
R : Type u_1
inst✝² : CommRing R
S : Submonoid R
P : Type u_2
inst✝¹ : CommRing P
inst✝ : Algebra R P
loc : IsLocalization S P
I : Submodule R P
h : I ≤ 1
b : P
hb : b ∈ I
⊢ IsInteger R b
tactic: rw [one_smul]
state_before: case right
R : Type u_1
inst✝² : CommRing R
S : Submonoid R
P : Type u_2
inst✝¹ : CommRing P
inst✝ : Algebra R P
loc : IsLocalization S P
I : Submodule R P
h : I ≤ 1
b : P
hb : b ∈ I
⊢ IsInteger R b
state_after: case right.intro.refl
R : Type u_1
inst✝² : CommRing R
S : Submonoid R
P : Type u_2
inst✝¹ : CommRing P
inst✝ : Algebra R P
loc : IsLocalization S P
I : Submodule R P
h : I ≤ 1
b' : R
hb : (Algebra.linearMap R P) b' ∈ I
⊢ IsInteger R ((Algebra.linearMap R P) b')
tactic: obtain ⟨b', b'_mem, rfl⟩ := h hb
state_before: case right.intro.refl
R : Type u_1
inst✝² : CommRing R
S : Submonoid R
P : Type u_2
inst✝¹ : CommRing P
inst✝ : Algebra R P
loc : IsLocalization S P
I : Submodule R P
h : I ≤ 1
b' : R
hb : (Algebra.linearMap R P) b' ∈ I
⊢ IsInteger R ((Algebra.linearMap R P) b')
state_after: no goals
tactic: exact Set.mem_range_self b'
Theorem: rank_submodule_le_one_iff
File: Mathlib/LinearAlgebra/Dimension/FreeAndStrongRankCondition.lean

Proof steps:
state_before: K : Type u
V : Type v
inst✝⁴ : Ring K
inst✝³ : StrongRankCondition K
inst✝² : AddCommGroup V
inst✝¹ : Module K V
s : Submodule K V
inst✝ : Module.Free K ↥s
⊢ Module.rank K ↥s ≤ 1 ↔ ∃ v₀ ∈ s, s ≤ span K {v₀}
state_after: K : Type u
V : Type v
inst✝⁴ : Ring K
inst✝³ : StrongRankCondition K
inst✝² : AddCommGroup V
inst✝¹ : Module K V
s : Submodule K V
inst✝ : Module.Free K ↥s
⊢ (∃ v₀, ∀ (v : ↥s), ∃ r, r • v₀ = v) ↔ ∃ v₀ ∈ s, ∀ v ∈ s, ∃ r, r • v₀ = v
tactic: simp_rw [rank_le_one_iff, le_span_singleton_iff]
state_before: K : Type u
V : Type v
inst✝⁴ : Ring K
inst✝³ : StrongRankCondition K
inst✝² : AddCommGroup V
inst✝¹ : Module K V
s : Submodule K V
inst✝ : Module.Free K ↥s
⊢ (∃ v₀, ∀ (v : ↥s), ∃ r, r • v₀ = v) ↔ ∃ v₀ ∈ s, ∀ v ∈ s, ∃ r, r • v₀ = v
state_after: case mp
K : Type u
V : Type v
inst✝⁴ : Ring K
inst✝³ : StrongRankCondition K
inst✝² : AddCommGroup V
inst✝¹ : Module K V
s : Submodule K V
inst✝ : Module.Free K ↥s
⊢ (∃ v₀, ∀ (v : ↥s), ∃ r, r • v₀ = v) → ∃ v₀ ∈ s, ∀ v ∈ s, ∃ r, r • v₀ = v

case mpr
K : Type u
V : Type v
inst✝⁴ : Ring K
inst✝³ : StrongRankCondition K
inst✝² : AddCommGroup V
inst✝¹ : Module K V
s : Submodule K V
inst✝ : Module.Free K ↥s
⊢ (∃ v₀ ∈ s, ∀ v ∈ s, ∃ r, r • v₀ = v) → ∃ v₀, ∀ (v : ↥s), ∃ r, r • v₀ = v
tactic: constructor
Theorem: SimpleGraph.Walk.concat_ne_nil
File: Mathlib/Combinatorics/SimpleGraph/Walk.lean

Proof steps:
state_before: V : Type u
V' : Type v
V'' : Type w
G : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
u v : V
p : G.Walk u v
h : G.Adj v u
⊢ p.concat h ≠ nil
state_after: no goals
tactic: cases p <;> simp [concat]
Theorem: Filter.map_inf
File: Mathlib/Order/Filter/Basic.lean

Proof steps:
state_before: α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
l f g : Filter α
m : α → β
h : Injective m
⊢ map m (f ⊓ g) = map m f ⊓ map m g
state_after: α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
l f g : Filter α
m : α → β
h : Injective m
⊢ map m f ⊓ map m g ≤ map m (f ⊓ g)
tactic: refine map_inf_le.antisymm ?_
state_before: α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
l f g : Filter α
m : α → β
h : Injective m
⊢ map m f ⊓ map m g ≤ map m (f ⊓ g)
state_after: case intro.intro.intro.intro
α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
l f g : Filter α
m : α → β
h : Injective m
t : Set β
s₁ : Set α
hs₁ : s₁ ∈ f
s₂ : Set α
hs₂ : s₂ ∈ g
ht : m ⁻¹' t = s₁ ∩ s₂
⊢ t ∈ map m f ⊓ map m g
tactic: rintro t ⟨s₁, hs₁, s₂, hs₂, ht : m ⁻¹' t = s₁ ∩ s₂⟩
state_before: case intro.intro.intro.intro
α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
l f g : Filter α
m : α → β
h : Injective m
t : Set β
s₁ : Set α
hs₁ : s₁ ∈ f
s₂ : Set α
hs₂ : s₂ ∈ g
ht : m ⁻¹' t = s₁ ∩ s₂
⊢ t ∈ map m f ⊓ map m g
state_after: case intro.intro.intro.intro
α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
l f g : Filter α
m : α → β
h : Injective m
t : Set β
s₁ : Set α
hs₁ : s₁ ∈ f
s₂ : Set α
hs₂ : s₂ ∈ g
ht : m ⁻¹' t = s₁ ∩ s₂
⊢ m '' s₁ ∩ m '' s₂ ⊆ t
tactic: refine mem_inf_of_inter (image_mem_map hs₁) (image_mem_map hs₂) ?_
state_before: case intro.intro.intro.intro
α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
l f g : Filter α
m : α → β
h : Injective m
t : Set β
s₁ : Set α
hs₁ : s₁ ∈ f
s₂ : Set α
hs₂ : s₂ ∈ g
ht : m ⁻¹' t = s₁ ∩ s₂
⊢ m '' s₁ ∩ m '' s₂ ⊆ t
state_after: no goals
tactic: rw [← image_inter h, image_subset_iff, ht]
Theorem: Orientation.oangle_map_complex
File: Mathlib/Geometry/Euclidean/Angle/Oriented/Basic.lean

Proof steps:
state_before: V : Type u_1
V' : Type u_2
inst✝⁵ : NormedAddCommGroup V
inst✝⁴ : NormedAddCommGroup V'
inst✝³ : InnerProductSpace ℝ V
inst✝² : InnerProductSpace ℝ V'
inst✝¹ : Fact (finrank ℝ V = 2)
inst✝ : Fact (finrank ℝ V' = 2)
o : Orientation ℝ V (Fin 2)
f : V ≃ₗᵢ[ℝ] ℂ
hf : (map (Fin 2) f.toLinearEquiv) o = Complex.orientation
x y : V
⊢ o.oangle x y = ↑((starRingEnd ℂ) (f x) * f y).arg
state_after: V : Type u_1
V' : Type u_2
inst✝⁵ : NormedAddCommGroup V
inst✝⁴ : NormedAddCommGroup V'
inst✝³ : InnerProductSpace ℝ V
inst✝² : InnerProductSpace ℝ V'
inst✝¹ : Fact (finrank ℝ V = 2)
inst✝ : Fact (finrank ℝ V' = 2)
o : Orientation ℝ V (Fin 2)
f : V ≃ₗᵢ[ℝ] ℂ
hf : (map (Fin 2) f.toLinearEquiv) o = Complex.orientation
x y : V
⊢ o.oangle x y = o.oangle (f.symm (f x)) (f.symm (f y))
tactic: rw [← Complex.oangle, ← hf, o.oangle_map]
state_before: V : Type u_1
V' : Type u_2
inst✝⁵ : NormedAddCommGroup V
inst✝⁴ : NormedAddCommGroup V'
inst✝³ : InnerProductSpace ℝ V
inst✝² : InnerProductSpace ℝ V'
inst✝¹ : Fact (finrank ℝ V = 2)
inst✝ : Fact (finrank ℝ V' = 2)
o : Orientation ℝ V (Fin 2)
f : V ≃ₗᵢ[ℝ] ℂ
hf : (map (Fin 2) f.toLinearEquiv) o = Complex.orientation
x y : V
⊢ o.oangle x y = o.oangle (f.symm (f x)) (f.symm (f y))
state_after: no goals
tactic: iterate 2 rw [LinearIsometryEquiv.symm_apply_apply]
Theorem: Real.cos_zero
File: Mathlib/Data/Complex/Exponential.lean

Proof steps:
state_before: x y : ℝ
⊢ cos 0 = 1
state_after: no goals
tactic: simp [cos]
Theorem: Nat.add_factorial_succ_lt_factorial_add_succ
File: Mathlib/Data/Nat/Factorial/Basic.lean

Proof steps:
state_before: m n✝ i n : ℕ
hi : 2 ≤ i
⊢ i + (n + 1)! < (i + n + 1)!
state_after: m n✝ i n : ℕ
hi : 2 ≤ i
⊢ i + (n + 1)! < (i + n) * (i + n)! + (i + n)!
tactic: rw [factorial_succ (i + _), Nat.add_mul, Nat.one_mul]
state_before: m n✝ i n : ℕ
hi : 2 ≤ i
⊢ i + (n + 1)! < (i + n) * (i + n)! + (i + n)!
state_after: m n✝ i n : ℕ
hi : 2 ≤ i
this : i + n ≤ (i + n)!
⊢ i + (n + 1)! < (i + n) * (i + n)! + (i + n)!
tactic: have := (i + n).self_le_factorial
state_before: m n✝ i n : ℕ
hi : 2 ≤ i
this : i + n ≤ (i + n)!
⊢ i + (n + 1)! < (i + n) * (i + n)! + (i + n)!
state_after: no goals
tactic: refine Nat.add_lt_add_of_lt_of_le (Nat.lt_of_le_of_lt ?_ ((Nat.lt_mul_iff_one_lt_right ?_).2 ?_))
    (factorial_le ?_) <;> omega
Theorem: ArithmeticFunction.LSeries_zeta_ne_zero_of_one_lt_re
File: Mathlib/NumberTheory/LSeries/Dirichlet.lean

Proof steps:
state_before: s : ℂ
hs : 1 < s.re
h : L (fun n => ↑(ζ n)) s = 0
⊢ False
state_after: no goals
tactic: simpa only [h, zero_mul, zero_ne_one] using LSeries_zeta_mul_Lseries_moebius hs
Theorem: Nat.unpair_right_le
File: Mathlib/Data/Nat/Pairing.lean

Proof steps:
state_before: n : ℕ
⊢ (unpair n).2 ≤ n
state_after: no goals
tactic: simpa using right_le_pair n.unpair.1 n.unpair.2
Theorem: intrinsicFrontier_empty
File: Mathlib/Analysis/Convex/Intrinsic.lean

Proof steps:
state_before: 𝕜 : Type u_1
V : Type u_2
W : Type u_3
Q : Type u_4
P : Type u_5
inst✝⁴ : Ring 𝕜
inst✝³ : AddCommGroup V
inst✝² : Module 𝕜 V
inst✝¹ : TopologicalSpace P
inst✝ : AddTorsor V P
s t : Set P
x : P
⊢ intrinsicFrontier 𝕜 ∅ = ∅
state_after: no goals
tactic: simp [intrinsicFrontier]
Theorem: Finset.max'_eq_sorted_last
File: Mathlib/Data/Finset/Sort.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
inst✝ : LinearOrder α
s : Finset α
h : s.Nonempty
⊢ (sort (fun x x_1 => x ≤ x_1) s).length - 1 < (sort (fun x x_1 => x ≤ x_1) s).length
state_after: no goals
tactic: simpa using Nat.sub_lt (card_pos.mpr h) Nat.zero_lt_one
Theorem: CategoryTheory.Iso.homCongr_refl
File: Mathlib/CategoryTheory/HomCongr.lean

Proof steps:
state_before: C : Type u
inst✝ : Category.{v, u} C
X Y : C
f : X ⟶ Y
⊢ ((refl X).homCongr (refl Y)) f = f
state_after: no goals
tactic: simp
Theorem: Algebraic.countable
File: Mathlib/Algebra/AlgebraicCard.lean

Proof steps:
state_before: R : Type u
A : Type v
inst✝⁵ : CommRing R
inst✝⁴ : CommRing A
inst✝³ : IsDomain A
inst✝² : Algebra R A
inst✝¹ : NoZeroSMulDivisors R A
inst✝ : Countable R
⊢ {x | IsAlgebraic R x}.Countable
state_after: R : Type u
A : Type v
inst✝⁵ : CommRing R
inst✝⁴ : CommRing A
inst✝³ : IsDomain A
inst✝² : Algebra R A
inst✝¹ : NoZeroSMulDivisors R A
inst✝ : Countable R
⊢ lift.{?u.23919, v} #↑{x | IsAlgebraic R x} ≤ ℵ₀
tactic: rw [← le_aleph0_iff_set_countable, ← lift_le_aleph0]
state_before: R : Type u
A : Type v
inst✝⁵ : CommRing R
inst✝⁴ : CommRing A
inst✝³ : IsDomain A
inst✝² : Algebra R A
inst✝¹ : NoZeroSMulDivisors R A
inst✝ : Countable R
⊢ lift.{?u.23919, v} #↑{x | IsAlgebraic R x} ≤ ℵ₀
state_after: R : Type u
A : Type v
inst✝⁵ : CommRing R
inst✝⁴ : CommRing A
inst✝³ : IsDomain A
inst✝² : Algebra R A
inst✝¹ : NoZeroSMulDivisors R A
inst✝ : Countable R
⊢ max (lift.{v, u} #R) ℵ₀ ≤ ℵ₀
tactic: apply (cardinal_mk_lift_le_max R A).trans
state_before: R : Type u
A : Type v
inst✝⁵ : CommRing R
inst✝⁴ : CommRing A
inst✝³ : IsDomain A
inst✝² : Algebra R A
inst✝¹ : NoZeroSMulDivisors R A
inst✝ : Countable R
⊢ max (lift.{v, u} #R) ℵ₀ ≤ ℵ₀
state_after: no goals
tactic: simp
Theorem: HurwitzZeta.differentiableAt_hurwitzZetaEven_sub_one_div
File: Mathlib/NumberTheory/LSeries/HurwitzZetaEven.lean

Proof steps:
state_before: a : UnitAddCircle
⊢ DifferentiableAt ℂ (fun s => hurwitzZetaEven a s - 1 / (s - 1) / s.Gammaℝ) 1
state_after: a : UnitAddCircle
⊢ DifferentiableAt ℂ (fun s => completedHurwitzZetaEven a s / s.Gammaℝ - 1 / (s - 1) / s.Gammaℝ) 1
tactic: suffices DifferentiableAt ℂ
      (fun s ↦ completedHurwitzZetaEven a s / Gammaℝ s - 1 / (s - 1) / Gammaℝ s) 1 by
    apply this.congr_of_eventuallyEq
    filter_upwards [eventually_ne_nhds one_ne_zero] with x hx
    rw [hurwitzZetaEven, Function.update_noteq hx]
state_before: a : UnitAddCircle
⊢ DifferentiableAt ℂ (fun s => completedHurwitzZetaEven a s / s.Gammaℝ - 1 / (s - 1) / s.Gammaℝ) 1
state_after: a : UnitAddCircle
⊢ DifferentiableAt ℂ (fun s => (completedHurwitzZetaEven a s - 1 / (s - 1)) * s.Gammaℝ⁻¹) 1
tactic: simp_rw [← sub_div, div_eq_mul_inv _ (Gammaℝ _)]
state_before: a : UnitAddCircle
⊢ DifferentiableAt ℂ (fun s => (completedHurwitzZetaEven a s - 1 / (s - 1)) * s.Gammaℝ⁻¹) 1
state_after: a : UnitAddCircle
⊢ DifferentiableAt ℂ (fun s => completedHurwitzZetaEven a s - 1 / (s - 1)) 1
tactic: refine DifferentiableAt.mul ?_ differentiable_Gammaℝ_inv.differentiableAt
state_before: a : UnitAddCircle
⊢ DifferentiableAt ℂ (fun s => completedHurwitzZetaEven a s - 1 / (s - 1)) 1
state_after: a : UnitAddCircle
⊢ DifferentiableAt ℂ
    (fun s => completedHurwitzZetaEven₀ a s - ((if a = 0 then 1 else 0) / s + (1 / (1 - s) + 1 / (s - 1)))) 1
tactic: simp_rw [completedHurwitzZetaEven_eq, sub_sub, add_assoc]
state_before: a : UnitAddCircle
⊢ DifferentiableAt ℂ
    (fun s => completedHurwitzZetaEven₀ a s - ((if a = 0 then 1 else 0) / s + (1 / (1 - s) + 1 / (s - 1)))) 1
state_after: a : UnitAddCircle
⊢ DifferentiableAt ℂ (fun s => completedHurwitzZetaEven₀ a s - (if a = 0 then 1 else 0) / s) 1
tactic: conv => enter [2, s, 2]; rw [← neg_sub, div_neg, neg_add_self, add_zero]
state_before: a : UnitAddCircle
⊢ DifferentiableAt ℂ (fun s => completedHurwitzZetaEven₀ a s - (if a = 0 then 1 else 0) / s) 1
state_after: no goals
tactic: exact (differentiable_completedHurwitzZetaEven₀ a _).sub
    <| (differentiableAt_const _).div differentiableAt_id one_ne_zero
Theorem: irreducible_mul_units
File: Mathlib/Algebra/Associated/Basic.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝ : Monoid α
a : αˣ
b : α
⊢ Irreducible (b * ↑a) ↔ Irreducible b
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝ : Monoid α
a : αˣ
b : α
⊢ ¬IsUnit b →
    ((∀ (a_2 b_1 : α), b * ↑a = a_2 * b_1 → IsUnit a_2 ∨ IsUnit b_1) ↔
      ∀ (a b_1 : α), b = a * b_1 → IsUnit a ∨ IsUnit b_1)
tactic: simp only [irreducible_iff, Units.isUnit_mul_units, and_congr_right_iff]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝ : Monoid α
a : αˣ
b : α
⊢ ¬IsUnit b →
    ((∀ (a_2 b_1 : α), b * ↑a = a_2 * b_1 → IsUnit a_2 ∨ IsUnit b_1) ↔
      ∀ (a b_1 : α), b = a * b_1 → IsUnit a ∨ IsUnit b_1)
state_after: case refine_1
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝ : Monoid α
a : αˣ
b : α
x✝ : ¬IsUnit b
h : ∀ (a_1 b_1 : α), b * ↑a = a_1 * b_1 → IsUnit a_1 ∨ IsUnit b_1
A B : α
HAB : b = A * B
⊢ IsUnit A ∨ IsUnit B

case refine_2
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝ : Monoid α
a : αˣ
b : α
x✝ : ¬IsUnit b
h : ∀ (a b_1 : α), b = a * b_1 → IsUnit a ∨ IsUnit b_1
A B : α
HAB : b * ↑a = A * B
⊢ IsUnit A ∨ IsUnit B
tactic: refine fun _ => ⟨fun h A B HAB => ?_, fun h A B HAB => ?_⟩
Theorem: List.asString_inj
File: Mathlib/Data/String/Basic.lean

Proof steps:
state_before: l l' : List Char
h : l.asString = l'.asString
⊢ l = l'
state_after: no goals
tactic: rw [← toList_asString l, ← toList_asString l', toList_inj, h]
Theorem: UniqueMul.mulHom_preimage
File: Mathlib/Algebra/Group/UniqueProds.lean

Proof steps:
state_before: G : Type u_1
H : Type u_2
inst✝¹ : Mul G
inst✝ : Mul H
A✝ B✝ : Finset G
a0✝ b0✝ : G
f : G →ₙ* H
hf : Function.Injective ⇑f
a0 b0 : G
A B : Finset H
u : UniqueMul A B (f a0) (f b0)
⊢ UniqueMul (A.preimage ⇑f ⋯) (B.preimage ⇑f ⋯) a0 b0
state_after: G : Type u_1
H : Type u_2
inst✝¹ : Mul G
inst✝ : Mul H
A✝ B✝ : Finset G
a0✝ b0✝ : G
f : G →ₙ* H
hf : Function.Injective ⇑f
a0 b0 : G
A B : Finset H
u : UniqueMul A B (f a0) (f b0)
a b : G
ha : a ∈ A.preimage ⇑f ⋯
hb : b ∈ B.preimage ⇑f ⋯
ab : a * b = a0 * b0
⊢ a = a0 ∧ b = b0
tactic: intro a b ha hb ab
state_before: G : Type u_1
H : Type u_2
inst✝¹ : Mul G
inst✝ : Mul H
A✝ B✝ : Finset G
a0✝ b0✝ : G
f : G →ₙ* H
hf : Function.Injective ⇑f
a0 b0 : G
A B : Finset H
u : UniqueMul A B (f a0) (f b0)
a b : G
ha : a ∈ A.preimage ⇑f ⋯
hb : b ∈ B.preimage ⇑f ⋯
ab : a * b = a0 * b0
⊢ a = a0 ∧ b = b0
state_after: G : Type u_1
H : Type u_2
inst✝¹ : Mul G
inst✝ : Mul H
A✝ B✝ : Finset G
a0✝ b0✝ : G
f : G →ₙ* H
hf : Function.Injective ⇑f
a0 b0 : G
A B : Finset H
u : UniqueMul A B (f a0) (f b0)
a b : G
ha : a ∈ A.preimage ⇑f ⋯
hb : b ∈ B.preimage ⇑f ⋯
ab : f a * f b = f a0 * f b0
⊢ f a = f a0 ∧ f b = f b0
tactic: simp only [← hf.eq_iff, map_mul] at ab ⊢
state_before: G : Type u_1
H : Type u_2
inst✝¹ : Mul G
inst✝ : Mul H
A✝ B✝ : Finset G
a0✝ b0✝ : G
f : G →ₙ* H
hf : Function.Injective ⇑f
a0 b0 : G
A B : Finset H
u : UniqueMul A B (f a0) (f b0)
a b : G
ha : a ∈ A.preimage ⇑f ⋯
hb : b ∈ B.preimage ⇑f ⋯
ab : f a * f b = f a0 * f b0
⊢ f a = f a0 ∧ f b = f b0
state_after: no goals
tactic: exact u (Finset.mem_preimage.mp ha) (Finset.mem_preimage.mp hb) ab
Theorem: LieSubalgebra.self_mem_engel
File: Mathlib/Algebra/Lie/EngelSubalgebra.lean

Proof steps:
state_before: R : Type u_1
L : Type u_2
M : Type u_3
inst✝⁶ : CommRing R
inst✝⁵ : LieRing L
inst✝⁴ : LieAlgebra R L
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : LieRingModule L M
inst✝ : LieModule R L M
x : L
⊢ x ∈ engel R x
state_after: R : Type u_1
L : Type u_2
M : Type u_3
inst✝⁶ : CommRing R
inst✝⁵ : LieRing L
inst✝⁴ : LieAlgebra R L
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : LieRingModule L M
inst✝ : LieModule R L M
x : L
⊢ ∃ n, ((ad R L) x ^ n) x = 0
tactic: simp only [mem_engel_iff]
state_before: R : Type u_1
L : Type u_2
M : Type u_3
inst✝⁶ : CommRing R
inst✝⁵ : LieRing L
inst✝⁴ : LieAlgebra R L
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : LieRingModule L M
inst✝ : LieModule R L M
x : L
⊢ ∃ n, ((ad R L) x ^ n) x = 0
state_after: no goals
tactic: exact ⟨1, by simp⟩
Theorem: Finset.prod_apply_ite_of_true
File: Mathlib/Algebra/BigOperators/Group/Finset.lean

Proof steps:
state_before: ι : Type u_1
κ : Type u_2
α : Type u_3
β : Type u_4
γ : Type u_5
s s₁ s₂ : Finset α
a : α
f✝ g✝ : α → β
inst✝ : CommMonoid β
p : α → Prop
hp : DecidablePred p
f g : α → γ
k : γ → β
h : ∀ x ∈ s, p x
⊢ ∏ x ∈ s, k (if p x then f x else g x) = ∏ x ∈ s, k (f x)
state_after: ι : Type u_1
κ : Type u_2
α : Type u_3
β : Type u_4
γ : Type u_5
s s₁ s₂ : Finset α
a : α
f✝ g✝ : α → β
inst✝ : CommMonoid β
p : α → Prop
hp : DecidablePred p
f g : α → γ
k : γ → β
h : ∀ x ∈ s, p x
⊢ (∏ x ∈ s, if p x then k (f x) else k (g x)) = ∏ x ∈ s, k (f x)
tactic: simp_rw [apply_ite k]
state_before: ι : Type u_1
κ : Type u_2
α : Type u_3
β : Type u_4
γ : Type u_5
s s₁ s₂ : Finset α
a : α
f✝ g✝ : α → β
inst✝ : CommMonoid β
p : α → Prop
hp : DecidablePred p
f g : α → γ
k : γ → β
h : ∀ x ∈ s, p x
⊢ (∏ x ∈ s, if p x then k (f x) else k (g x)) = ∏ x ∈ s, k (f x)
state_after: no goals
tactic: exact prod_ite_of_true h _ _
Theorem: CategoryTheory.MonoidalClosed.pre_id
File: Mathlib/CategoryTheory/Closed/Monoidal.lean

Proof steps:
state_before: C : Type u
inst✝⁴ : Category.{v, u} C
inst✝³ : MonoidalCategory C
A✝ B X X' Y Y' Z : C
inst✝² : Closed A✝
inst✝¹ : Closed B
A : C
inst✝ : Closed A
⊢ pre (𝟙 A) = 𝟙 (ihom A)
state_after: C : Type u
inst✝⁴ : Category.{v, u} C
inst✝³ : MonoidalCategory C
A✝ B X X' Y Y' Z : C
inst✝² : Closed A✝
inst✝¹ : Closed B
A : C
inst✝ : Closed A
⊢ (conjugateEquiv (ihom.adjunction A) (ihom.adjunction A)) (𝟙 ((tensoringLeft C).obj A)) = 𝟙 (ihom A)
tactic: rw [pre, Functor.map_id]
state_before: C : Type u
inst✝⁴ : Category.{v, u} C
inst✝³ : MonoidalCategory C
A✝ B X X' Y Y' Z : C
inst✝² : Closed A✝
inst✝¹ : Closed B
A : C
inst✝ : Closed A
⊢ (conjugateEquiv (ihom.adjunction A) (ihom.adjunction A)) (𝟙 ((tensoringLeft C).obj A)) = 𝟙 (ihom A)
state_after: no goals
tactic: apply conjugateEquiv_id