ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: CancelDenoms.mul_subst
File: Mathlib/Tactic/CancelDenoms/Core.lean

Proof steps:
state_before: α : Type u_1
inst✝ : CommRing α
n1 n2 k e1 e2 t1 t2 : α
h1 : n1 * e1 = t1
h2 : n2 * e2 = t2
h3 : n1 * n2 = k
⊢ k * (e1 * e2) = t1 * t2
state_after: no goals
tactic: rw [← h3, mul_comm n1, mul_assoc n2, ← mul_assoc n1, h1,
      ← mul_assoc n2, mul_comm n2, mul_assoc, h2]
Theorem: CategoryTheory.braiding_inv_tensorUnit_left
File: Mathlib/CategoryTheory/Monoidal/Braided/Basic.lean

Proof steps:
state_before: C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
inst✝ : BraidedCategory C
X : C
⊢ (β_ (𝟙_ C) X).inv = (ρ_ X).hom ≫ (λ_ X).inv
state_after: C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
inst✝ : BraidedCategory C
X : C
⊢ (β_ (𝟙_ C) X).hom ≫ (ρ_ X).hom ≫ (λ_ X).inv = 𝟙 (𝟙_ C ⊗ X)
tactic: rw [Iso.inv_ext]
state_before: C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
inst✝ : BraidedCategory C
X : C
⊢ (β_ (𝟙_ C) X).hom ≫ (ρ_ X).hom ≫ (λ_ X).inv = 𝟙 (𝟙_ C ⊗ X)
state_after: C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
inst✝ : BraidedCategory C
X : C
⊢ ((λ_ X).hom ≫ (ρ_ X).inv) ≫ (ρ_ X).hom ≫ (λ_ X).inv = 𝟙 (𝟙_ C ⊗ X)
tactic: rw [braiding_tensorUnit_left]
state_before: C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
inst✝ : BraidedCategory C
X : C
⊢ ((λ_ X).hom ≫ (ρ_ X).inv) ≫ (ρ_ X).hom ≫ (λ_ X).inv = 𝟙 (𝟙_ C ⊗ X)
state_after: no goals
tactic: coherence
Theorem: IsLocalizedModule.mk'_add_mk'
File: Mathlib/Algebra/Module/LocalizedModule.lean

Proof steps:
state_before: R : Type u_1
inst✝¹² : CommSemiring R
S : Submonoid R
M : Type u_2
M' : Type u_3
M'' : Type u_4
inst✝¹¹ : AddCommMonoid M
inst✝¹⁰ : AddCommMonoid M'
inst✝⁹ : AddCommMonoid M''
A : Type u_5
inst✝⁸ : CommSemiring A
inst✝⁷ : Algebra R A
inst✝⁶ : Module A M'
inst✝⁵ : IsLocalization S A
inst✝⁴ : Module R M
inst✝³ : Module R M'
inst✝² : Module R M''
inst✝¹ : IsScalarTower R A M'
f : M →ₗ[R] M'
g : M →ₗ[R] M''
inst✝ : IsLocalizedModule S f
m₁ m₂ : M
s₁ s₂ : ↥S
⊢ mk' f m₁ s₁ + mk' f m₂ s₂ = mk' f (s₂ • m₁ + s₁ • m₂) (s₁ * s₂)
state_after: R : Type u_1
inst✝¹² : CommSemiring R
S : Submonoid R
M : Type u_2
M' : Type u_3
M'' : Type u_4
inst✝¹¹ : AddCommMonoid M
inst✝¹⁰ : AddCommMonoid M'
inst✝⁹ : AddCommMonoid M''
A : Type u_5
inst✝⁸ : CommSemiring A
inst✝⁷ : Algebra R A
inst✝⁶ : Module A M'
inst✝⁵ : IsLocalization S A
inst✝⁴ : Module R M
inst✝³ : Module R M'
inst✝² : Module R M''
inst✝¹ : IsScalarTower R A M'
f : M →ₗ[R] M'
g : M →ₗ[R] M''
inst✝ : IsLocalizedModule S f
m₁ m₂ : M
s₁ s₂ : ↥S
⊢ (fromLocalizedModule S f) (LocalizedModule.mk m₁ s₁) + (fromLocalizedModule S f) (LocalizedModule.mk m₂ s₂) =
    (fromLocalizedModule S f) (LocalizedModule.mk (s₂ • m₁ + s₁ • m₂) (s₁ * s₂))
tactic: delta mk'
state_before: R : Type u_1
inst✝¹² : CommSemiring R
S : Submonoid R
M : Type u_2
M' : Type u_3
M'' : Type u_4
inst✝¹¹ : AddCommMonoid M
inst✝¹⁰ : AddCommMonoid M'
inst✝⁹ : AddCommMonoid M''
A : Type u_5
inst✝⁸ : CommSemiring A
inst✝⁷ : Algebra R A
inst✝⁶ : Module A M'
inst✝⁵ : IsLocalization S A
inst✝⁴ : Module R M
inst✝³ : Module R M'
inst✝² : Module R M''
inst✝¹ : IsScalarTower R A M'
f : M →ₗ[R] M'
g : M →ₗ[R] M''
inst✝ : IsLocalizedModule S f
m₁ m₂ : M
s₁ s₂ : ↥S
⊢ (fromLocalizedModule S f) (LocalizedModule.mk m₁ s₁) + (fromLocalizedModule S f) (LocalizedModule.mk m₂ s₂) =
    (fromLocalizedModule S f) (LocalizedModule.mk (s₂ • m₁ + s₁ • m₂) (s₁ * s₂))
state_after: no goals
tactic: rw [← map_add, LocalizedModule.mk_add_mk]
Theorem: Turing.BlankExtends.trans
File: Mathlib/Computability/TuringMachine.lean

Proof steps:
state_before: Γ : Type u_1
inst✝ : Inhabited Γ
l₁ l₂ l₃ : List Γ
⊢ BlankExtends l₁ l₂ → BlankExtends l₂ l₃ → BlankExtends l₁ l₃
state_after: case intro.intro
Γ : Type u_1
inst✝ : Inhabited Γ
l₁ : List Γ
i j : ℕ
⊢ BlankExtends l₁ (l₁ ++ List.replicate i default ++ List.replicate j default)
tactic: rintro ⟨i, rfl⟩ ⟨j, rfl⟩
state_before: case intro.intro
Γ : Type u_1
inst✝ : Inhabited Γ
l₁ : List Γ
i j : ℕ
⊢ BlankExtends l₁ (l₁ ++ List.replicate i default ++ List.replicate j default)
state_after: no goals
tactic: exact ⟨i + j, by simp⟩
Theorem: ProbabilityTheory.Kernel.deterministic_comp_eq_map
File: Mathlib/Probability/Kernel/Composition.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
γ : Type u_4
mγ : MeasurableSpace γ
f : β → γ
g : γ → α
hf : Measurable f
κ : Kernel α β
⊢ deterministic f hf ∘ₖ κ = κ.map f hf
state_after: case h.h
α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
γ : Type u_4
mγ : MeasurableSpace γ
f : β → γ
g : γ → α
hf : Measurable f
κ : Kernel α β
a : α
s : Set γ
hs : MeasurableSet s
⊢ ((deterministic f hf ∘ₖ κ) a) s = ((κ.map f hf) a) s
tactic: ext a s hs
state_before: case h.h
α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
γ : Type u_4
mγ : MeasurableSpace γ
f : β → γ
g : γ → α
hf : Measurable f
κ : Kernel α β
a : α
s : Set γ
hs : MeasurableSet s
⊢ ((deterministic f hf ∘ₖ κ) a) s = ((κ.map f hf) a) s
state_after: no goals
tactic: simp_rw [map_apply' _ _ _ hs, comp_apply' _ _ _ hs, deterministic_apply' hf _ hs,
    lintegral_indicator_const_comp hf hs, one_mul]
Theorem: ContinuousMap.hasSum_apply
File: Mathlib/Topology/ContinuousFunction/Algebra.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
inst✝³ : TopologicalSpace α
inst✝² : TopologicalSpace β
γ : Type u_3
inst✝¹ : AddCommMonoid β
inst✝ : ContinuousAdd β
f : γ → C(α, β)
g : C(α, β)
hf : HasSum f g
x : α
⊢ HasSum (fun i => (f i) x) (g x)
state_after: α : Type u_1
β : Type u_2
inst✝³ : TopologicalSpace α
inst✝² : TopologicalSpace β
γ : Type u_3
inst✝¹ : AddCommMonoid β
inst✝ : ContinuousAdd β
f : γ → C(α, β)
g : C(α, β)
hf : HasSum f g
x : α
ev : C(α, β) →+ β := (Pi.evalAddMonoidHom (fun a => β) x).comp coeFnAddMonoidHom
⊢ HasSum (fun i => (f i) x) (g x)
tactic: let ev : C(α, β) →+ β := (Pi.evalAddMonoidHom _ x).comp coeFnAddMonoidHom
state_before: α : Type u_1
β : Type u_2
inst✝³ : TopologicalSpace α
inst✝² : TopologicalSpace β
γ : Type u_3
inst✝¹ : AddCommMonoid β
inst✝ : ContinuousAdd β
f : γ → C(α, β)
g : C(α, β)
hf : HasSum f g
x : α
ev : C(α, β) →+ β := (Pi.evalAddMonoidHom (fun a => β) x).comp coeFnAddMonoidHom
⊢ HasSum (fun i => (f i) x) (g x)
state_after: no goals
tactic: exact hf.map ev (ContinuousMap.continuous_eval_const x)
Theorem: Rat.zero_divInt
File: .lake/packages/batteries/Batteries/Data/Rat/Lemmas.lean

Proof steps:
state_before: n : Int
⊢ 0 /. n = 0
state_after: no goals
tactic: cases n <;> simp [divInt]
Theorem: pairwiseDisjoint_unique
File: Mathlib/Data/Set/Pairwise/Lattice.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
ι' : Type u_5
κ : Sort u_6
r p q : α → α → Prop
f : ι → Set α
s t : Set ι
y : α
h_disjoint : s.PairwiseDisjoint f
hy : y ∈ ⋃ i ∈ s, f i
⊢ ∃! i, i ∈ s ∧ y ∈ f i
state_after: case ex
α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
ι' : Type u_5
κ : Sort u_6
r p q : α → α → Prop
f : ι → Set α
s t : Set ι
y : α
h_disjoint : s.PairwiseDisjoint f
hy : y ∈ ⋃ i ∈ s, f i
⊢ ∃ x ∈ s, y ∈ f x

case unique
α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
ι' : Type u_5
κ : Sort u_6
r p q : α → α → Prop
f : ι → Set α
s t : Set ι
y : α
h_disjoint : s.PairwiseDisjoint f
hy : y ∈ ⋃ i ∈ s, f i
⊢ ∀ (y₁ y₂ : ι), y₁ ∈ s ∧ y ∈ f y₁ → y₂ ∈ s ∧ y ∈ f y₂ → y₁ = y₂
tactic: refine exists_unique_of_exists_of_unique ?ex ?unique
Theorem: Submodule.mapQ_pow
File: Mathlib/LinearAlgebra/Quotient.lean

Proof steps:
state_before: R : Type u_1
M : Type u_2
r : R
x y : M
inst✝⁵ : Ring R
inst✝⁴ : AddCommGroup M
inst✝³ : Module R M
p p' : Submodule R M
R₂ : Type u_3
M₂ : Type u_4
inst✝² : Ring R₂
inst✝¹ : AddCommGroup M₂
inst✝ : Module R₂ M₂
τ₁₂ : R →+* R₂
q : Submodule R₂ M₂
f : M →ₗ[R] M
h : p ≤ comap f p
k : ℕ
h' : optParam (p ≤ comap (f ^ k) p) ⋯
⊢ p.mapQ p (f ^ k) h' = p.mapQ p f h ^ k
state_after: case zero
R : Type u_1
M : Type u_2
r : R
x y : M
inst✝⁵ : Ring R
inst✝⁴ : AddCommGroup M
inst✝³ : Module R M
p p' : Submodule R M
R₂ : Type u_3
M₂ : Type u_4
inst✝² : Ring R₂
inst✝¹ : AddCommGroup M₂
inst✝ : Module R₂ M₂
τ₁₂ : R →+* R₂
q : Submodule R₂ M₂
f : M →ₗ[R] M
h : p ≤ comap f p
h' : optParam (p ≤ comap (f ^ 0) p) ⋯
⊢ p.mapQ p (f ^ 0) h' = p.mapQ p f h ^ 0

case succ
R : Type u_1
M : Type u_2
r : R
x y : M
inst✝⁵ : Ring R
inst✝⁴ : AddCommGroup M
inst✝³ : Module R M
p p' : Submodule R M
R₂ : Type u_3
M₂ : Type u_4
inst✝² : Ring R₂
inst✝¹ : AddCommGroup M₂
inst✝ : Module R₂ M₂
τ₁₂ : R →+* R₂
q : Submodule R₂ M₂
f : M →ₗ[R] M
h : p ≤ comap f p
k : ℕ
ih : ∀ (h' : optParam (p ≤ comap (f ^ k) p) ⋯), p.mapQ p (f ^ k) h' = p.mapQ p f h ^ k
h' : optParam (p ≤ comap (f ^ (k + 1)) p) ⋯
⊢ p.mapQ p (f ^ (k + 1)) h' = p.mapQ p f h ^ (k + 1)
tactic: induction' k with k ih
Theorem: Nat.mul_self_inj
File: Mathlib/Data/Nat/Defs.lean

Proof steps:
state_before: a b c d m n k : ℕ
p q : ℕ → Prop
⊢ m * m = n * n ↔ m = n
state_after: no goals
tactic: simp [Nat.le_antisymm_iff, mul_self_le_mul_self_iff]
Theorem: PNat.factorMultiset_mul
File: Mathlib/Data/PNat/Factors.lean

Proof steps:
state_before: n m : ℕ+
⊢ (n * m).factorMultiset = n.factorMultiset + m.factorMultiset
state_after: n m : ℕ+
u : PrimeMultiset := n.factorMultiset
⊢ (n * m).factorMultiset = n.factorMultiset + m.factorMultiset
tactic: let u := factorMultiset n
state_before: n m : ℕ+
u : PrimeMultiset := n.factorMultiset
⊢ (n * m).factorMultiset = n.factorMultiset + m.factorMultiset
state_after: n m : ℕ+
u : PrimeMultiset := n.factorMultiset
v : PrimeMultiset := m.factorMultiset
⊢ (n * m).factorMultiset = n.factorMultiset + m.factorMultiset
tactic: let v := factorMultiset m
state_before: n m : ℕ+
u : PrimeMultiset := n.factorMultiset
v : PrimeMultiset := m.factorMultiset
⊢ (n * m).factorMultiset = n.factorMultiset + m.factorMultiset
state_after: n m : ℕ+
u : PrimeMultiset := n.factorMultiset
v : PrimeMultiset := m.factorMultiset
this : n = u.prod
⊢ (n * m).factorMultiset = n.factorMultiset + m.factorMultiset
tactic: have : n = u.prod := (prod_factorMultiset n).symm
state_before: n m : ℕ+
u : PrimeMultiset := n.factorMultiset
v : PrimeMultiset := m.factorMultiset
this : n = u.prod
⊢ (n * m).factorMultiset = n.factorMultiset + m.factorMultiset
state_after: n m : ℕ+
u : PrimeMultiset := n.factorMultiset
v : PrimeMultiset := m.factorMultiset
this : n = u.prod
⊢ (u.prod * m).factorMultiset = u.prod.factorMultiset + m.factorMultiset
tactic: rw [this]
state_before: n m : ℕ+
u : PrimeMultiset := n.factorMultiset
v : PrimeMultiset := m.factorMultiset
this : n = u.prod
⊢ (u.prod * m).factorMultiset = u.prod.factorMultiset + m.factorMultiset
state_after: n m : ℕ+
u : PrimeMultiset := n.factorMultiset
v : PrimeMultiset := m.factorMultiset
this✝ : n = u.prod
this : m = v.prod
⊢ (u.prod * m).factorMultiset = u.prod.factorMultiset + m.factorMultiset
tactic: have : m = v.prod := (prod_factorMultiset m).symm
state_before: n m : ℕ+
u : PrimeMultiset := n.factorMultiset
v : PrimeMultiset := m.factorMultiset
this✝ : n = u.prod
this : m = v.prod
⊢ (u.prod * m).factorMultiset = u.prod.factorMultiset + m.factorMultiset
state_after: n m : ℕ+
u : PrimeMultiset := n.factorMultiset
v : PrimeMultiset := m.factorMultiset
this✝ : n = u.prod
this : m = v.prod
⊢ (u.prod * v.prod).factorMultiset = u.prod.factorMultiset + v.prod.factorMultiset
tactic: rw [this]
state_before: n m : ℕ+
u : PrimeMultiset := n.factorMultiset
v : PrimeMultiset := m.factorMultiset
this✝ : n = u.prod
this : m = v.prod
⊢ (u.prod * v.prod).factorMultiset = u.prod.factorMultiset + v.prod.factorMultiset
state_after: n m : ℕ+
u : PrimeMultiset := n.factorMultiset
v : PrimeMultiset := m.factorMultiset
this✝ : n = u.prod
this : m = v.prod
⊢ (u + v).prod.factorMultiset = u.prod.factorMultiset + v.prod.factorMultiset
tactic: rw [← PrimeMultiset.prod_add]
state_before: n m : ℕ+
u : PrimeMultiset := n.factorMultiset
v : PrimeMultiset := m.factorMultiset
this✝ : n = u.prod
this : m = v.prod
⊢ (u + v).prod.factorMultiset = u.prod.factorMultiset + v.prod.factorMultiset
state_after: no goals
tactic: repeat' rw [PrimeMultiset.factorMultiset_prod]
Theorem: Finset.card_le_mul_card_image_of_maps_to
File: Mathlib/Algebra/Order/BigOperators/Group/Finset.lean

Proof steps:
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
M : Type u_4
N : Type u_5
G : Type u_6
k : Type u_7
R : Type u_8
inst✝ : DecidableEq β
f : α → β
s : Finset α
t : Finset β
Hf : ∀ a ∈ s, f a ∈ t
n : ℕ
hn : ∀ a ∈ t, (filter (fun x => f x = a) s).card ≤ n
⊢ ∑ _a ∈ t, n = n * t.card
state_after: no goals
tactic: simp [mul_comm]
Theorem: mem_skewAdjointMatricesSubmodule'
File: Mathlib/LinearAlgebra/Matrix/BilinearForm.lean

Proof steps:
state_before: R : Type u_1
M : Type u_2
inst✝¹⁶ : CommSemiring R
inst✝¹⁵ : AddCommMonoid M
inst✝¹⁴ : Module R M
R₁ : Type u_3
M₁ : Type u_4
inst✝¹³ : CommRing R₁
inst✝¹² : AddCommGroup M₁
inst✝¹¹ : Module R₁ M₁
R₂ : Type u_5
M₂ : Type u_6
inst✝¹⁰ : CommSemiring R₂
inst✝⁹ : AddCommMonoid M₂
inst✝⁸ : Module R₂ M₂
R₃ : Type u_7
M₃ : Type u_8
inst✝⁷ : CommRing R₃
inst✝⁶ : AddCommGroup M₃
inst✝⁵ : Module R₃ M₃
V : Type u_9
K : Type u_10
inst✝⁴ : Field K
inst✝³ : AddCommGroup V
inst✝² : Module K V
B : BilinForm R M
B₁ : BilinForm R₁ M₁
B₂ : BilinForm R₂ M₂
n : Type u_11
inst✝¹ : Fintype n
b : Basis n R₃ M₃
J J₃ A A' : Matrix n n R₃
inst✝ : DecidableEq n
⊢ A ∈ skewAdjointMatricesSubmodule J ↔ J.IsSkewAdjoint A
state_after: no goals
tactic: simp only [mem_skewAdjointMatricesSubmodule]
Theorem: Int.Ico_filter_dvd_card
File: Mathlib/Data/Int/CardIntervalMod.lean

Proof steps:
state_before: a b r : ℤ
hr : 0 < r
⊢ ↑(filter (fun x => r ∣ x) (Ico a b)).card = max (⌈↑b / ↑r⌉ - ⌈↑a / ↑r⌉) 0
state_after: no goals
tactic: rw [Ico_filter_dvd_eq _ _ hr, card_map, card_Ico, toNat_eq_max]
Theorem: HurwitzZeta.completedSinZeta_neg
File: Mathlib/NumberTheory/LSeries/HurwitzZetaOdd.lean

Proof steps:
state_before: a : UnitAddCircle
s : ℂ
⊢ completedSinZeta (-a) s = -completedSinZeta a s
state_after: a : UnitAddCircle
s : ℂ
⊢ (∫ (t : ℝ) in Ioi 0, -(↑t ^ ((s + 1) / 2 - 1) • ↑(sinKernel a t))) / 2 =
    -((∫ (t : ℝ) in Ioi 0, ↑t ^ ((s + 1) / 2 - 1) • ↑(sinKernel a t)) / 2)
tactic: simp only [completedSinZeta, StrongFEPair.Λ, mellin, StrongFEPair.symm, WeakFEPair.symm,
    hurwitzOddFEPair, Function.comp_def, sinKernel_neg, ofReal_neg, smul_neg]
state_before: a : UnitAddCircle
s : ℂ
⊢ (∫ (t : ℝ) in Ioi 0, -(↑t ^ ((s + 1) / 2 - 1) • ↑(sinKernel a t))) / 2 =
    -((∫ (t : ℝ) in Ioi 0, ↑t ^ ((s + 1) / 2 - 1) • ↑(sinKernel a t)) / 2)
state_after: no goals
tactic: rw [integral_neg, neg_div]
Theorem: hasFDerivAt_tsum_of_isPreconnected
File: Mathlib/Analysis/Calculus/SmoothSeries.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
𝕜 : Type u_3
E : Type u_4
F : Type u_5
inst✝⁵ : RCLike 𝕜
inst✝⁴ : NormedAddCommGroup E
inst✝³ : NormedSpace 𝕜 E
inst✝² : NormedAddCommGroup F
inst✝¹ : CompleteSpace F
u : α → ℝ
inst✝ : NormedSpace 𝕜 F
f : α → E → F
f' : α → E → E →L[𝕜] F
g g' : α → 𝕜 → F
v : ℕ → α → ℝ
s : Set E
t : Set 𝕜
x₀ x : E
y₀ y : 𝕜
N : ℕ∞
hu : Summable u
hs : IsOpen s
h's : IsPreconnected s
hf : ∀ (n : α), ∀ x ∈ s, HasFDerivAt (f n) (f' n x) x
hf' : ∀ (n : α), ∀ x ∈ s, ‖f' n x‖ ≤ u n
hx₀ : x₀ ∈ s
hf0 : Summable fun n => f n x₀
hx : x ∈ s
⊢ HasFDerivAt (fun y => ∑' (n : α), f n y) (∑' (n : α), f' n x) x
state_after: no goals
tactic: classical
    have A :
      ∀ x : E, x ∈ s → Tendsto (fun t : Finset α => ∑ n ∈ t, f n x) atTop (𝓝 (∑' n, f n x)) := by
      intro y hy
      apply Summable.hasSum
      exact summable_of_summable_hasFDerivAt_of_isPreconnected hu hs h's hf hf' hx₀ hf0 hy
    refine hasFDerivAt_of_tendstoUniformlyOn hs (tendstoUniformlyOn_tsum hu hf')
      (fun t y hy => ?_) A _ hx
    exact HasFDerivAt.sum fun n _ => hf n y hy
Theorem: ValuationRing.of_integers
File: Mathlib/RingTheory/Valuation/ValuationRing.lean

Proof steps:
state_before: 𝒪 : Type u
K : Type v
Γ : Type w
inst✝⁴ : CommRing 𝒪
inst✝³ : IsDomain 𝒪
inst✝² : Field K
inst✝¹ : Algebra 𝒪 K
inst✝ : LinearOrderedCommGroupWithZero Γ
v : Valuation K Γ
hh : v.Integers 𝒪
⊢ ValuationRing 𝒪
state_after: case cond'
𝒪 : Type u
K : Type v
Γ : Type w
inst✝⁴ : CommRing 𝒪
inst✝³ : IsDomain 𝒪
inst✝² : Field K
inst✝¹ : Algebra 𝒪 K
inst✝ : LinearOrderedCommGroupWithZero Γ
v : Valuation K Γ
hh : v.Integers 𝒪
⊢ ∀ (a b : 𝒪), ∃ c, a * c = b ∨ b * c = a
tactic: constructor
state_before: case cond'
𝒪 : Type u
K : Type v
Γ : Type w
inst✝⁴ : CommRing 𝒪
inst✝³ : IsDomain 𝒪
inst✝² : Field K
inst✝¹ : Algebra 𝒪 K
inst✝ : LinearOrderedCommGroupWithZero Γ
v : Valuation K Γ
hh : v.Integers 𝒪
⊢ ∀ (a b : 𝒪), ∃ c, a * c = b ∨ b * c = a
state_after: case cond'
𝒪 : Type u
K : Type v
Γ : Type w
inst✝⁴ : CommRing 𝒪
inst✝³ : IsDomain 𝒪
inst✝² : Field K
inst✝¹ : Algebra 𝒪 K
inst✝ : LinearOrderedCommGroupWithZero Γ
v : Valuation K Γ
hh : v.Integers 𝒪
a b : 𝒪
⊢ ∃ c, a * c = b ∨ b * c = a
tactic: intro a b
state_before: case cond'
𝒪 : Type u
K : Type v
Γ : Type w
inst✝⁴ : CommRing 𝒪
inst✝³ : IsDomain 𝒪
inst✝² : Field K
inst✝¹ : Algebra 𝒪 K
inst✝ : LinearOrderedCommGroupWithZero Γ
v : Valuation K Γ
hh : v.Integers 𝒪
a b : 𝒪
⊢ ∃ c, a * c = b ∨ b * c = a
state_after: case cond'.inl
𝒪 : Type u
K : Type v
Γ : Type w
inst✝⁴ : CommRing 𝒪
inst✝³ : IsDomain 𝒪
inst✝² : Field K
inst✝¹ : Algebra 𝒪 K
inst✝ : LinearOrderedCommGroupWithZero Γ
v : Valuation K Γ
hh : v.Integers 𝒪
a b : 𝒪
h : v ((algebraMap 𝒪 K) a) ≤ v ((algebraMap 𝒪 K) b)
⊢ ∃ c, a * c = b ∨ b * c = a

case cond'.inr
𝒪 : Type u
K : Type v
Γ : Type w
inst✝⁴ : CommRing 𝒪
inst✝³ : IsDomain 𝒪
inst✝² : Field K
inst✝¹ : Algebra 𝒪 K
inst✝ : LinearOrderedCommGroupWithZero Γ
v : Valuation K Γ
hh : v.Integers 𝒪
a b : 𝒪
h : v ((algebraMap 𝒪 K) b) ≤ v ((algebraMap 𝒪 K) a)
⊢ ∃ c, a * c = b ∨ b * c = a
tactic: rcases le_total (v (algebraMap 𝒪 K a)) (v (algebraMap 𝒪 K b)) with h | h
Theorem: CategoryTheory.Presheaf.isLocallyInjective_presheafToSheaf_map_iff
File: Mathlib/CategoryTheory/Sites/LocallyBijective.lean

Proof steps:
state_before: C : Type u
inst✝⁴ : Category.{v, u} C
J : GrothendieckTopology C
A : Type u'
inst✝³ : Category.{v', u'} A
inst✝² : ConcreteCategory A
inst✝¹ : HasWeakSheafify J A
inst✝ : J.WEqualsLocallyBijective A
P Q : Cᵒᵖ ⥤ A
φ : P ⟶ Q
⊢ Sheaf.IsLocallyInjective ((presheafToSheaf J A).map φ) ↔ IsLocallyInjective J φ
state_after: no goals
tactic: rw [← Sheaf.isLocallyInjective_sheafToPresheaf_map_iff,
    ← isLocallyInjective_comp_iff J _ (toSheafify J Q),
    ← comp_isLocallyInjective_iff J (toSheafify J P),
    toSheafify_naturality, sheafToPresheaf_map]
Theorem: Matrix.conjTranspose_conjTranspose
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✝ : InvolutiveStar α
M : Matrix m n α
⊢ ∀ (i : m) (j : n), Mᴴᴴ i j = M i j
state_after: no goals
tactic: simp
Theorem: Real.sinh_two_mul
File: Mathlib/Data/Complex/Exponential.lean

Proof steps:
state_before: x y : ℝ
⊢ sinh (2 * x) = 2 * sinh x * cosh x
state_after: x y : ℝ
⊢ ↑(sinh (2 * x)) = ↑(2 * sinh x * cosh x)
tactic: rw [← ofReal_inj]
state_before: x y : ℝ
⊢ ↑(sinh (2 * x)) = ↑(2 * sinh x * cosh x)
state_after: no goals
tactic: simp [sinh_two_mul]
Theorem: CategoryTheory.Limits.limit.pre_π
File: Mathlib/CategoryTheory/Limits/HasLimits.lean

Proof steps:
state_before: J : Type u₁
inst✝⁴ : Category.{v₁, u₁} J
K : Type u₂
inst✝³ : Category.{v₂, u₂} K
C : Type u
inst✝² : Category.{v, u} C
F : J ⥤ C
inst✝¹ : HasLimit F
E : K ⥤ J
inst✝ : HasLimit (E ⋙ F)
k : K
⊢ pre F E ≫ π (E ⋙ F) k = π F (E.obj k)
state_after: J : Type u₁
inst✝⁴ : Category.{v₁, u₁} J
K : Type u₂
inst✝³ : Category.{v₂, u₂} K
C : Type u
inst✝² : Category.{v, u} C
F : J ⥤ C
inst✝¹ : HasLimit F
E : K ⥤ J
inst✝ : HasLimit (E ⋙ F)
k : K
⊢ (Cone.whisker E (cone F)).π.app k = π F (E.obj k)
tactic: erw [IsLimit.fac]
state_before: J : Type u₁
inst✝⁴ : Category.{v₁, u₁} J
K : Type u₂
inst✝³ : Category.{v₂, u₂} K
C : Type u
inst✝² : Category.{v, u} C
F : J ⥤ C
inst✝¹ : HasLimit F
E : K ⥤ J
inst✝ : HasLimit (E ⋙ F)
k : K
⊢ (Cone.whisker E (cone F)).π.app k = π F (E.obj k)
state_after: no goals
tactic: rfl
Theorem: ZMod.minOrder_of_prime
File: Mathlib/GroupTheory/Order/Min.lean

Proof steps:
state_before: α : Type u_1
p : ℕ
hp : Nat.Prime p
⊢ minOrder (ZMod p) = ↑p
state_after: no goals
tactic: rw [ZMod.minOrder hp.ne_zero hp.ne_one, hp.minFac_eq]
Theorem: Multipliable.tendsto_atTop_one
File: Mathlib/Topology/Algebra/InfiniteSum/NatInt.lean

Proof steps:
state_before: M : Type u_1
inst✝⁴ : CommMonoid M
inst✝³ : TopologicalSpace M
m m' : M
G : Type u_2
inst✝² : CommGroup G
g g' : G
inst✝¹ : TopologicalSpace G
inst✝ : TopologicalGroup G
f : ℕ → G
hf : Multipliable f
⊢ Tendsto f atTop (𝓝 1)
state_after: M : Type u_1
inst✝⁴ : CommMonoid M
inst✝³ : TopologicalSpace M
m m' : M
G : Type u_2
inst✝² : CommGroup G
g g' : G
inst✝¹ : TopologicalSpace G
inst✝ : TopologicalGroup G
f : ℕ → G
hf : Multipliable f
⊢ Tendsto f cofinite (𝓝 1)
tactic: rw [← Nat.cofinite_eq_atTop]
state_before: M : Type u_1
inst✝⁴ : CommMonoid M
inst✝³ : TopologicalSpace M
m m' : M
G : Type u_2
inst✝² : CommGroup G
g g' : G
inst✝¹ : TopologicalSpace G
inst✝ : TopologicalGroup G
f : ℕ → G
hf : Multipliable f
⊢ Tendsto f cofinite (𝓝 1)
state_after: no goals
tactic: exact hf.tendsto_cofinite_one
Theorem: IsAdjoinRoot.repr_add_sub_repr_add_repr_mem_span
File: Mathlib/RingTheory/IsAdjoinRoot.lean

Proof steps:
state_before: R : Type u
S : Type v
inst✝² : CommRing R
inst✝¹ : Ring S
f : R[X]
inst✝ : Algebra R S
h : IsAdjoinRoot S f
x y : S
⊢ h.repr (x + y) - (h.repr x + h.repr y) ∈ Ideal.span {f}
state_after: no goals
tactic: rw [← h.ker_map, RingHom.mem_ker, map_sub, h.map_repr, map_add, h.map_repr, h.map_repr, sub_self]
Theorem: MeasureTheory.withDensityᵥ_smul
File: Mathlib/MeasureTheory/Measure/WithDensityVectorMeasure.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
m : MeasurableSpace α
μ ν : Measure α
E : Type u_3
inst✝⁵ : NormedAddCommGroup E
inst✝⁴ : NormedSpace ℝ E
inst✝³ : CompleteSpace E
f✝ g : α → E
𝕜 : Type u_4
inst✝² : NontriviallyNormedField 𝕜
inst✝¹ : NormedSpace 𝕜 E
inst✝ : SMulCommClass ℝ 𝕜 E
f : α → E
r : 𝕜
⊢ μ.withDensityᵥ (r • f) = r • μ.withDensityᵥ f
state_after: case pos
α : Type u_1
β : Type u_2
m : MeasurableSpace α
μ ν : Measure α
E : Type u_3
inst✝⁵ : NormedAddCommGroup E
inst✝⁴ : NormedSpace ℝ E
inst✝³ : CompleteSpace E
f✝ g : α → E
𝕜 : Type u_4
inst✝² : NontriviallyNormedField 𝕜
inst✝¹ : NormedSpace 𝕜 E
inst✝ : SMulCommClass ℝ 𝕜 E
f : α → E
r : 𝕜
hf : Integrable f μ
⊢ μ.withDensityᵥ (r • f) = r • μ.withDensityᵥ f

case neg
α : Type u_1
β : Type u_2
m : MeasurableSpace α
μ ν : Measure α
E : Type u_3
inst✝⁵ : NormedAddCommGroup E
inst✝⁴ : NormedSpace ℝ E
inst✝³ : CompleteSpace E
f✝ g : α → E
𝕜 : Type u_4
inst✝² : NontriviallyNormedField 𝕜
inst✝¹ : NormedSpace 𝕜 E
inst✝ : SMulCommClass ℝ 𝕜 E
f : α → E
r : 𝕜
hf : ¬Integrable f μ
⊢ μ.withDensityᵥ (r • f) = r • μ.withDensityᵥ f
tactic: by_cases hf : Integrable f μ
Theorem: UpperSet.symm_map
File: Mathlib/Order/UpperLower/Basic.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
κ : ι → Sort u_5
inst✝² : Preorder α
inst✝¹ : Preorder β
inst✝ : Preorder γ
f✝ : α ≃o β
s✝ t : UpperSet α
a : α
b : β
f : α ≃o β
s : UpperSet β
⊢ ↑((map f).symm s) = ↑((map f.symm) s)
state_after: no goals
tactic: convert Set.preimage_equiv_eq_image_symm s f.toEquiv
Theorem: disjoint_nhdsSet_principal
File: Mathlib/Topology/NhdsSet.lean

Proof steps:
state_before: X : Type u_1
Y : Type u_2
inst✝¹ : TopologicalSpace X
inst✝ : TopologicalSpace Y
f : Filter X
s t s₁ s₂ t₁ t₂ : Set X
x : X
⊢ Disjoint (𝓝ˢ s) (𝓟 t) ↔ Disjoint s (closure t)
state_after: no goals
tactic: rw [disjoint_comm, disjoint_principal_nhdsSet, disjoint_comm]