ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: tsum_dirichletSummand
File: Mathlib/NumberTheory/EulerProduct/DirichletLSeries.lean

Proof steps:
state_before: s : ℂ
N : ℕ
χ : DirichletCharacter ℂ N
hs : 1 < s.re
⊢ ∑' (n : ℕ), (dirichletSummandHom χ ⋯) n = L (fun n => χ ↑n) s
state_after: s : ℂ
N : ℕ
χ : DirichletCharacter ℂ N
hs : 1 < s.re
⊢ ∑' (n : ℕ), { toFun := fun n => χ ↑n * ↑n ^ (-s), map_zero' := ⋯, map_one' := ⋯, map_mul' := ⋯ } n =
    ∑' (n : ℕ), if n = 0 then 0 else χ ↑n / ↑n ^ s
tactic: simp only [LSeries, LSeries.term, dirichletSummandHom]
state_before: s : ℂ
N : ℕ
χ : DirichletCharacter ℂ N
hs : 1 < s.re
⊢ ∑' (n : ℕ), { toFun := fun n => χ ↑n * ↑n ^ (-s), map_zero' := ⋯, map_one' := ⋯, map_mul' := ⋯ } n =
    ∑' (n : ℕ), if n = 0 then 0 else χ ↑n / ↑n ^ s
state_after: s : ℂ
N : ℕ
χ : DirichletCharacter ℂ N
hs : 1 < s.re
n : ℕ
⊢ { toFun := fun n => χ ↑n * ↑n ^ (-s), map_zero' := ⋯, map_one' := ⋯, map_mul' := ⋯ } n =
    if n = 0 then 0 else χ ↑n / ↑n ^ s
tactic: refine tsum_congr (fun n ↦ ?_)
state_before: s : ℂ
N : ℕ
χ : DirichletCharacter ℂ N
hs : 1 < s.re
n : ℕ
⊢ { toFun := fun n => χ ↑n * ↑n ^ (-s), map_zero' := ⋯, map_one' := ⋯, map_mul' := ⋯ } n =
    if n = 0 then 0 else χ ↑n / ↑n ^ s
state_after: case inl
s : ℂ
N : ℕ
χ : DirichletCharacter ℂ N
hs : 1 < s.re
⊢ { toFun := fun n => χ ↑n * ↑n ^ (-s), map_zero' := ⋯, map_one' := ⋯, map_mul' := ⋯ } 0 =
    if 0 = 0 then 0 else χ ↑0 / ↑0 ^ s

case inr
s : ℂ
N : ℕ
χ : DirichletCharacter ℂ N
hs : 1 < s.re
n : ℕ
hn : n ≠ 0
⊢ { toFun := fun n => χ ↑n * ↑n ^ (-s), map_zero' := ⋯, map_one' := ⋯, map_mul' := ⋯ } n =
    if n = 0 then 0 else χ ↑n / ↑n ^ s
tactic: rcases eq_or_ne n 0 with rfl | hn
Theorem: StarConvex.sub
File: Mathlib/Analysis/Convex/Star.lean

Proof steps:
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
inst✝⁴ : OrderedRing 𝕜
inst✝³ : AddCommGroup E
inst✝² : AddCommGroup F
inst✝¹ : Module 𝕜 E
inst✝ : Module 𝕜 F
x y : E
s t : Set E
hs : StarConvex 𝕜 x s
ht : StarConvex 𝕜 y t
⊢ StarConvex 𝕜 (x - y) (s - t)
state_after: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
inst✝⁴ : OrderedRing 𝕜
inst✝³ : AddCommGroup E
inst✝² : AddCommGroup F
inst✝¹ : Module 𝕜 E
inst✝ : Module 𝕜 F
x y : E
s t : Set E
hs : StarConvex 𝕜 x s
ht : StarConvex 𝕜 y t
⊢ StarConvex 𝕜 (x + -y) (s + -t)
tactic: simp_rw [sub_eq_add_neg]
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
inst✝⁴ : OrderedRing 𝕜
inst✝³ : AddCommGroup E
inst✝² : AddCommGroup F
inst✝¹ : Module 𝕜 E
inst✝ : Module 𝕜 F
x y : E
s t : Set E
hs : StarConvex 𝕜 x s
ht : StarConvex 𝕜 y t
⊢ StarConvex 𝕜 (x + -y) (s + -t)
state_after: no goals
tactic: exact hs.add ht.neg
Theorem: preimage_map_fst_pullbackDiagonal
File: Mathlib/Data/Set/Prod.lean

Proof steps:
state_before: X : Type u_2
Y : Sort u_3
Z : Type u_1
f : X → Y
g : Z → Y
⊢ map_fst ⁻¹' pullbackDiagonal f = pullbackDiagonal snd
state_after: case h.mk.mk
X : Type u_2
Y : Sort u_3
Z : Type u_1
f : X → Y
g : Z → Y
p₁ p₂ : Pullback f g
he : (p₁, p₂).1.snd = (p₁, p₂).2.snd
⊢ ⟨(p₁, p₂), he⟩ ∈ map_fst ⁻¹' pullbackDiagonal f ↔ ⟨(p₁, p₂), he⟩ ∈ pullbackDiagonal snd
tactic: ext ⟨⟨p₁, p₂⟩, he⟩
state_before: case h.mk.mk
X : Type u_2
Y : Sort u_3
Z : Type u_1
f : X → Y
g : Z → Y
p₁ p₂ : Pullback f g
he : (p₁, p₂).1.snd = (p₁, p₂).2.snd
⊢ ⟨(p₁, p₂), he⟩ ∈ map_fst ⁻¹' pullbackDiagonal f ↔ ⟨(p₁, p₂), he⟩ ∈ pullbackDiagonal snd
state_after: case h.mk.mk
X : Type u_2
Y : Sort u_3
Z : Type u_1
f : X → Y
g : Z → Y
p₁ p₂ : Pullback f g
he : (p₁, p₂).1.snd = (p₁, p₂).2.snd
⊢ ⟨(p₁, p₂), he⟩ ∈ map_fst ⁻¹' {p | p.fst = p.snd} ↔
    (↑(fst ⟨(p₁, p₂), he⟩)).1 = (↑(snd ⟨(p₁, p₂), he⟩)).1 ∧ (↑(fst ⟨(p₁, p₂), he⟩)).2 = (↑(snd ⟨(p₁, p₂), he⟩)).2
tactic: simp_rw [pullbackDiagonal, mem_setOf, Subtype.ext_iff, Prod.ext_iff]
state_before: case h.mk.mk
X : Type u_2
Y : Sort u_3
Z : Type u_1
f : X → Y
g : Z → Y
p₁ p₂ : Pullback f g
he : (p₁, p₂).1.snd = (p₁, p₂).2.snd
⊢ ⟨(p₁, p₂), he⟩ ∈ map_fst ⁻¹' {p | p.fst = p.snd} ↔
    (↑(fst ⟨(p₁, p₂), he⟩)).1 = (↑(snd ⟨(p₁, p₂), he⟩)).1 ∧ (↑(fst ⟨(p₁, p₂), he⟩)).2 = (↑(snd ⟨(p₁, p₂), he⟩)).2
state_after: no goals
tactic: exact (and_iff_left he).symm
Theorem: Option.casesOn'_none_coe
File: Mathlib/Data/Option/Basic.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
f : Option α → β
o : Option α
⊢ o.casesOn' (f none) (f ∘ fun a => some a) = f o
state_after: no goals
tactic: cases o <;> rfl
Theorem: Cardinal.le_powerlt
File: Mathlib/SetTheory/Cardinal/Basic.lean

Proof steps:
state_before: α β : Type u
c✝ : Cardinal.{?u.245881}
b c a : Cardinal.{u}
h : c < b
⊢ a ^ c ≤ a ^< b
state_after: α β : Type u
c✝ : Cardinal.{?u.245881}
b c a : Cardinal.{u}
h : c < b
⊢ BddAbove (range fun y => a ^ ↑y)
tactic: refine le_ciSup (f := fun y : Iio b => a ^ (y : Cardinal)) ?_ ⟨c, h⟩
state_before: α β : Type u
c✝ : Cardinal.{?u.245881}
b c a : Cardinal.{u}
h : c < b
⊢ BddAbove (range fun y => a ^ ↑y)
state_after: α β : Type u
c✝ : Cardinal.{?u.245881}
b c a : Cardinal.{u}
h : c < b
⊢ BddAbove (HPow.hPow a '' Iio b)
tactic: rw [← image_eq_range]
state_before: α β : Type u
c✝ : Cardinal.{?u.245881}
b c a : Cardinal.{u}
h : c < b
⊢ BddAbove (HPow.hPow a '' Iio b)
state_after: no goals
tactic: exact bddAbove_image.{u, u} _ bddAbove_Iio
Theorem: ValuationSubring.principalUnitGroup_le_principalUnitGroup
File: Mathlib/RingTheory/Valuation/ValuationSubring.lean

Proof steps:
state_before: K : Type u
inst✝ : Field K
A✝ A B : ValuationSubring K
⊢ B.principalUnitGroup ≤ A.principalUnitGroup ↔ A ≤ B
state_after: case mp
K : Type u
inst✝ : Field K
A✝ A B : ValuationSubring K
⊢ B.principalUnitGroup ≤ A.principalUnitGroup → A ≤ B

case mpr
K : Type u
inst✝ : Field K
A✝ A B : ValuationSubring K
⊢ A ≤ B → B.principalUnitGroup ≤ A.principalUnitGroup
tactic: constructor
Theorem: SimpleGraph.Walk.toSubgraph_append
File: Mathlib/Combinatorics/SimpleGraph/Connectivity/Subgraph.lean

Proof steps:
state_before: V : Type u
V' : Type v
G : SimpleGraph V
G' : SimpleGraph V'
u v w : V
p : G.Walk u v
q : G.Walk v w
⊢ (p.append q).toSubgraph = p.toSubgraph ⊔ q.toSubgraph
state_after: no goals
tactic: induction p <;> simp [*, sup_assoc]
Theorem: RCLike.normSq_pos
File: Mathlib/Analysis/RCLike/Basic.lean

Proof steps:
state_before: K : Type u_1
E : Type u_2
inst✝ : RCLike K
z✝ z : K
⊢ 0 < normSq z ↔ z ≠ 0
state_after: K : Type u_1
E : Type u_2
inst✝ : RCLike K
z✝ z : K
⊢ 0 ≤ normSq z ∧ ¬normSq z = 0 ↔ z ≠ 0
tactic: rw [lt_iff_le_and_ne, Ne, eq_comm]
state_before: K : Type u_1
E : Type u_2
inst✝ : RCLike K
z✝ z : K
⊢ 0 ≤ normSq z ∧ ¬normSq z = 0 ↔ z ≠ 0
state_after: no goals
tactic: simp [normSq_nonneg]
Theorem: AddCommGroup.modEq_iff_eq_add_zsmul
File: Mathlib/Algebra/ModEq.lean

Proof steps:
state_before: α : Type u_1
inst✝ : AddCommGroup α
p a a₁ a₂ b b₁ b₂ c : α
n : ℕ
z : ℤ
⊢ a ≡ b [PMOD p] ↔ ∃ z, b = a + z • p
state_after: no goals
tactic: simp_rw [ModEq, sub_eq_iff_eq_add']
Theorem: CategoryTheory.Functor.mapBicone_π
File: Mathlib/CategoryTheory/Limits/Preserves/Shapes/Biproducts.lean

Proof steps:
state_before: C : Type u₁
inst✝⁴ : Category.{v₁, u₁} C
D : Type u₂
inst✝³ : Category.{v₂, u₂} D
inst✝² : HasZeroMorphisms C
inst✝¹ : HasZeroMorphisms D
F : C ⥤ D
inst✝ : F.PreservesZeroMorphisms
J : Type w₁
f : J → C
b : Bicone f
j j' : J
⊢ (fun j => F.map (b.ι j)) j ≫ (fun j => F.map (b.π j)) j' = if h : j = j' then eqToHom ⋯ else 0
state_after: C : Type u₁
inst✝⁴ : Category.{v₁, u₁} C
D : Type u₂
inst✝³ : Category.{v₂, u₂} D
inst✝² : HasZeroMorphisms C
inst✝¹ : HasZeroMorphisms D
F : C ⥤ D
inst✝ : F.PreservesZeroMorphisms
J : Type w₁
f : J → C
b : Bicone f
j j' : J
⊢ F.map (b.ι j ≫ b.π j') = if h : j = j' then eqToHom ⋯ else 0
tactic: rw [← F.map_comp]
state_before: C : Type u₁
inst✝⁴ : Category.{v₁, u₁} C
D : Type u₂
inst✝³ : Category.{v₂, u₂} D
inst✝² : HasZeroMorphisms C
inst✝¹ : HasZeroMorphisms D
F : C ⥤ D
inst✝ : F.PreservesZeroMorphisms
J : Type w₁
f : J → C
b : Bicone f
j j' : J
⊢ F.map (b.ι j ≫ b.π j') = if h : j = j' then eqToHom ⋯ else 0
state_after: case pos
C : Type u₁
inst✝⁴ : Category.{v₁, u₁} C
D : Type u₂
inst✝³ : Category.{v₂, u₂} D
inst✝² : HasZeroMorphisms C
inst✝¹ : HasZeroMorphisms D
F : C ⥤ D
inst✝ : F.PreservesZeroMorphisms
J : Type w₁
f : J → C
b : Bicone f
j j' : J
h : j = j'
⊢ F.map (b.ι j ≫ b.π j') = eqToHom ⋯

case neg
C : Type u₁
inst✝⁴ : Category.{v₁, u₁} C
D : Type u₂
inst✝³ : Category.{v₂, u₂} D
inst✝² : HasZeroMorphisms C
inst✝¹ : HasZeroMorphisms D
F : C ⥤ D
inst✝ : F.PreservesZeroMorphisms
J : Type w₁
f : J → C
b : Bicone f
j j' : J
h : ¬j = j'
⊢ F.map (b.ι j ≫ b.π j') = 0
tactic: split_ifs with h
Theorem: Function.extend_nonneg
File: Mathlib/Algebra/Order/Pi.lean

Proof steps:
state_before: ι : Type u_1
I : Type u_2
α : Type u_3
β : Type u_4
γ : Type u_5
f✝ : I → Type u_6
x y : (i : I) → f✝ i
i : I
inst✝¹ : One γ
inst✝ : LE γ
f : α → β
g : α → γ
e : β → γ
hg : 1 ≤ g
he : 1 ≤ e
_b : β
⊢ 1 _b ≤ extend f g e _b
state_after: no goals
tactic: classical exact one_le_dite (fun _ ↦ hg _) (fun _ ↦ he _)
Theorem: Submodule.pow_toAddSubmonoid
File: Mathlib/Algebra/Algebra/Operations.lean

Proof steps:
state_before: ι : Sort uι
R : Type u
inst✝² : CommSemiring R
A : Type v
inst✝¹ : Semiring A
inst✝ : Algebra R A
S T : Set A
M N P Q : Submodule R A
m n✝ : A
n : ℕ
h : n ≠ 0
⊢ (M ^ n).toAddSubmonoid = M.toAddSubmonoid ^ n
state_after: case zero
ι : Sort uι
R : Type u
inst✝² : CommSemiring R
A : Type v
inst✝¹ : Semiring A
inst✝ : Algebra R A
S T : Set A
M N P Q : Submodule R A
m n : A
h : 0 ≠ 0
⊢ (M ^ 0).toAddSubmonoid = M.toAddSubmonoid ^ 0

case succ
ι : Sort uι
R : Type u
inst✝² : CommSemiring R
A : Type v
inst✝¹ : Semiring A
inst✝ : Algebra R A
S T : Set A
M N P Q : Submodule R A
m n✝ : A
n : ℕ
ih : n ≠ 0 → (M ^ n).toAddSubmonoid = M.toAddSubmonoid ^ n
h : n + 1 ≠ 0
⊢ (M ^ (n + 1)).toAddSubmonoid = M.toAddSubmonoid ^ (n + 1)
tactic: induction' n with n ih
Theorem: Polynomial.mkDerivation_one_eq_derivative'
File: Mathlib/Algebra/Polynomial/Derivation.lean

Proof steps:
state_before: R : Type u_1
A : Type u_2
inst✝⁴ : CommSemiring R
inst✝³ : AddCommMonoid A
inst✝² : Module R A
inst✝¹ : Module R[X] A
inst✝ : IsScalarTower R R[X] A
⊢ (mkDerivation R) 1 = derivative'
state_after: case h
R : Type u_1
A : Type u_2
inst✝⁴ : CommSemiring R
inst✝³ : AddCommMonoid A
inst✝² : Module R A
inst✝¹ : Module R[X] A
inst✝ : IsScalarTower R R[X] A
⊢ ((mkDerivation R) 1) X = derivative' X
tactic: ext : 1
state_before: case h
R : Type u_1
A : Type u_2
inst✝⁴ : CommSemiring R
inst✝³ : AddCommMonoid A
inst✝² : Module R A
inst✝¹ : Module R[X] A
inst✝ : IsScalarTower R R[X] A
⊢ ((mkDerivation R) 1) X = derivative' X
state_after: no goals
tactic: simp [derivative']
Theorem: Real.tendsto_tan_pi_div_two
File: Mathlib/Analysis/SpecialFunctions/Trigonometric/Basic.lean

Proof steps:
state_before: ⊢ Tendsto tan (𝓝[<] (π / 2)) atTop
state_after: case h.e'_3

⊢ tan = fun x => cos⁻¹ x * sin x
tactic: convert tendsto_cos_pi_div_two.inv_tendsto_zero.atTop_mul zero_lt_one tendsto_sin_pi_div_two
    using 1
state_before: case h.e'_3

⊢ tan = fun x => cos⁻¹ x * sin x
state_after: no goals
tactic: simp only [Pi.inv_apply, ← div_eq_inv_mul, ← tan_eq_sin_div_cos]
Theorem: WeierstrassCurve.Jacobian.negAddY_of_Z_eq_zero_left
File: Mathlib/AlgebraicGeometry/EllipticCurve/Jacobian.lean

Proof steps:
state_before: R : Type u
inst✝¹ : CommRing R
W' : Jacobian R
F : Type v
inst✝ : Field F
W : Jacobian F
P Q : Fin 3 → R
hP : W'.Equation P
hPz : P z = 0
⊢ W'.negAddY P Q = (P x * Q z) ^ 3 * W'.negY Q
state_after: no goals
tactic: linear_combination (norm := (rw [negAddY, negY, hPz]; ring1))
    (W'.negY Q - Q y) * Q z ^ 3 * (equation_of_Z_eq_zero hPz).mp hP
Theorem: CategoryTheory.regularTopology.isSheafFor_regular_of_projective
File: Mathlib/CategoryTheory/Sites/Coherent/RegularSheaves.lean

Proof steps:
state_before: C : Type u_1
D : Type u_2
E : Type u_3
inst✝⁴ : Category.{u_5, u_1} C
inst✝³ : Category.{?u.127674, u_2} D
inst✝² : Category.{?u.127678, u_3} E
X : C
S : Presieve X
inst✝¹ : S.regular
inst✝ : Projective X
F : Cᵒᵖ ⥤ Type u_4
⊢ IsSheafFor F S
state_after: case intro.intro.intro
C : Type u_1
D : Type u_2
E : Type u_3
inst✝⁴ : Category.{u_5, u_1} C
inst✝³ : Category.{?u.127674, u_2} D
inst✝² : Category.{?u.127678, u_3} E
X : C
inst✝¹ : Projective X
F : Cᵒᵖ ⥤ Type u_4
Y : C
f : Y ⟶ X
hf : EffectiveEpi f
inst✝ : (ofArrows (fun x => Y) fun x => f).regular
⊢ IsSheafFor F (ofArrows (fun x => Y) fun x => f)
tactic: obtain ⟨Y, f, rfl, hf⟩ := Presieve.regular.single_epi (R := S)
state_before: case intro.intro.intro
C : Type u_1
D : Type u_2
E : Type u_3
inst✝⁴ : Category.{u_5, u_1} C
inst✝³ : Category.{?u.127674, u_2} D
inst✝² : Category.{?u.127678, u_3} E
X : C
inst✝¹ : Projective X
F : Cᵒᵖ ⥤ Type u_4
Y : C
f : Y ⟶ X
hf : EffectiveEpi f
inst✝ : (ofArrows (fun x => Y) fun x => f).regular
⊢ IsSheafFor F (ofArrows (fun x => Y) fun x => f)
state_after: case intro.intro.intro
C : Type u_1
D : Type u_2
E : Type u_3
inst✝⁴ : Category.{u_5, u_1} C
inst✝³ : Category.{?u.127674, u_2} D
inst✝² : Category.{?u.127678, u_3} E
X : C
inst✝¹ : Projective X
F : Cᵒᵖ ⥤ Type u_4
Y : C
f : Y ⟶ X
hf : EffectiveEpi f
inst✝ : (ofArrows (fun x => Y) fun x => f).regular
⊢ ∀ (x : Unit → F.obj (op Y)), Arrows.Compatible F (fun x => f) x → ∃! t, ∀ (i : Unit), F.map f.op t = x i
tactic: rw [isSheafFor_arrows_iff]
state_before: case intro.intro.intro
C : Type u_1
D : Type u_2
E : Type u_3
inst✝⁴ : Category.{u_5, u_1} C
inst✝³ : Category.{?u.127674, u_2} D
inst✝² : Category.{?u.127678, u_3} E
X : C
inst✝¹ : Projective X
F : Cᵒᵖ ⥤ Type u_4
Y : C
f : Y ⟶ X
hf : EffectiveEpi f
inst✝ : (ofArrows (fun x => Y) fun x => f).regular
⊢ ∀ (x : Unit → F.obj (op Y)), Arrows.Compatible F (fun x => f) x → ∃! t, ∀ (i : Unit), F.map f.op t = x i
state_after: case intro.intro.intro.refine_1
C : Type u_1
D : Type u_2
E : Type u_3
inst✝⁴ : Category.{u_5, u_1} C
inst✝³ : Category.{?u.127674, u_2} D
inst✝² : Category.{?u.127678, u_3} E
X : C
inst✝¹ : Projective X
F : Cᵒᵖ ⥤ Type u_4
Y : C
f : Y ⟶ X
hf : EffectiveEpi f
inst✝ : (ofArrows (fun x => Y) fun x => f).regular
x : Unit → F.obj (op Y)
hx : Arrows.Compatible F (fun x => f) x
x✝ : Unit
⊢ F.map f.op (F.map (Projective.factorThru (𝟙 X) f).op (x ())) = x x✝

case intro.intro.intro.refine_2
C : Type u_1
D : Type u_2
E : Type u_3
inst✝⁴ : Category.{u_5, u_1} C
inst✝³ : Category.{?u.127674, u_2} D
inst✝² : Category.{?u.127678, u_3} E
X : C
inst✝¹ : Projective X
F : Cᵒᵖ ⥤ Type u_4
Y : C
f : Y ⟶ X
hf : EffectiveEpi f
inst✝ : (ofArrows (fun x => Y) fun x => f).regular
x : Unit → F.obj (op Y)
hx : Arrows.Compatible F (fun x => f) x
y : F.obj (op X)
h : (fun t => ∀ (i : Unit), F.map f.op t = x i) y
⊢ y = F.map (Projective.factorThru (𝟙 X) f).op (x ())
tactic: refine fun x hx ↦ ⟨F.map (Projective.factorThru (𝟙 _) f).op <| x (), fun _ ↦ ?_, fun y h ↦ ?_⟩
Theorem: Polynomial.coeff_pow_of_natDegree_le
File: Mathlib/Algebra/Polynomial/Degree/Lemmas.lean

Proof steps:
state_before: R : Type u
S : Type v
ι : Type w
a b : R
m n : ℕ
inst✝ : Semiring R
p q r : R[X]
pn : p.natDegree ≤ n
⊢ (p ^ m).coeff (m * n) = p.coeff n ^ m
state_after: case zero
R : Type u
S : Type v
ι : Type w
a b : R
m n : ℕ
inst✝ : Semiring R
p q r : R[X]
pn : p.natDegree ≤ n
⊢ (p ^ 0).coeff (0 * n) = p.coeff n ^ 0

case succ
R : Type u
S : Type v
ι : Type w
a b : R
m✝ n : ℕ
inst✝ : Semiring R
p q r : R[X]
pn : p.natDegree ≤ n
m : ℕ
hm : (p ^ m).coeff (m * n) = p.coeff n ^ m
⊢ (p ^ (m + 1)).coeff ((m + 1) * n) = p.coeff n ^ (m + 1)
tactic: induction' m with m hm
Theorem: Int.preimage_Ioi
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 : α
⊢ Int.cast ⁻¹' Ioi a = Ioi ⌊a⌋
state_after: case h
F : Type u_1
α : Type u_2
β : Type u_3
inst✝¹ : LinearOrderedRing α
inst✝ : FloorRing α
z : ℤ
a : α
x✝ : ℤ
⊢ x✝ ∈ Int.cast ⁻¹' Ioi a ↔ x✝ ∈ Ioi ⌊a⌋
tactic: ext
state_before: case h
F : Type u_1
α : Type u_2
β : Type u_3
inst✝¹ : LinearOrderedRing α
inst✝ : FloorRing α
z : ℤ
a : α
x✝ : ℤ
⊢ x✝ ∈ Int.cast ⁻¹' Ioi a ↔ x✝ ∈ Ioi ⌊a⌋
state_after: no goals
tactic: simp [floor_lt]
Theorem: Cycle.formPerm_eq_self_of_not_mem
File: Mathlib/GroupTheory/Perm/Cycle/Concrete.lean

Proof steps:
state_before: α : Type u_1
inst✝ : DecidableEq α
s✝ s' s : Cycle α
h : s.Nodup
x : α
hx : x ∉ s
⊢ (s.formPerm h) x = x
state_after: case h
α : Type u_1
inst✝ : DecidableEq α
s s' : Cycle α
x : α
a✝ : List α
h : Nodup (Quot.mk Setoid.r a✝)
hx : x ∉ Quot.mk Setoid.r a✝
⊢ (formPerm (Quot.mk Setoid.r a✝) h) x = x
tactic: induction s using Quot.inductionOn
state_before: case h
α : Type u_1
inst✝ : DecidableEq α
s s' : Cycle α
x : α
a✝ : List α
h : Nodup (Quot.mk Setoid.r a✝)
hx : x ∉ Quot.mk Setoid.r a✝
⊢ (formPerm (Quot.mk Setoid.r a✝) h) x = x
state_after: no goals
tactic: simpa using List.formPerm_eq_self_of_not_mem _ _ hx
Theorem: MulActionHom.id_comp
File: Mathlib/GroupTheory/GroupAction/Hom.lean

Proof steps:
state_before: M' : Type u_1
M : Type u_2
N : Type u_3
P : Type u_4
φ : M → N
ψ : N → P
χ : M → P
X : Type u_5
inst✝⁴ : SMul M X
inst✝³ : SMul M' X
Y : Type u_6
inst✝² : SMul N Y
inst✝¹ : SMul M' Y
Z : Type u_7
inst✝ : SMul P Z
f : X →ₑ[φ] Y
x : X
⊢ ((MulActionHom.id N).comp f) x = f x
state_after: no goals
tactic: rw [comp_apply, id_apply]
Theorem: dist_triangle_left
File: Mathlib/Topology/MetricSpace/Pseudo/Defs.lean

Proof steps:
state_before: α : Type u
β : Type v
X : Type u_1
ι : Type u_2
inst✝ : PseudoMetricSpace α
x y z : α
⊢ dist x y ≤ dist z x + dist z y
state_after: α : Type u
β : Type v
X : Type u_1
ι : Type u_2
inst✝ : PseudoMetricSpace α
x y z : α
⊢ dist x y ≤ dist x z + dist z y
tactic: rw [dist_comm z]
state_before: α : Type u
β : Type v
X : Type u_1
ι : Type u_2
inst✝ : PseudoMetricSpace α
x y z : α
⊢ dist x y ≤ dist x z + dist z y
state_after: no goals
tactic: apply dist_triangle
Theorem: Finsupp.comapDomain_smul
File: Mathlib/Data/Finsupp/Basic.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
M : Type u_5
M' : Type u_6
N : Type u_7
P : Type u_8
G : Type u_9
H : Type u_10
R : Type u_11
S : Type u_12
inst✝² : AddMonoid M
inst✝¹ : Monoid R
inst✝ : DistribMulAction R M
f : α → β
r : R
v : β →₀ M
hfv : Set.InjOn f (f ⁻¹' ↑v.support)
hfrv : optParam (Set.InjOn f (f ⁻¹' ↑(r • v).support)) ⋯
⊢ comapDomain f (r • v) hfrv = r • comapDomain f v hfv
state_after: case h
α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
M : Type u_5
M' : Type u_6
N : Type u_7
P : Type u_8
G : Type u_9
H : Type u_10
R : Type u_11
S : Type u_12
inst✝² : AddMonoid M
inst✝¹ : Monoid R
inst✝ : DistribMulAction R M
f : α → β
r : R
v : β →₀ M
hfv : Set.InjOn f (f ⁻¹' ↑v.support)
hfrv : optParam (Set.InjOn f (f ⁻¹' ↑(r • v).support)) ⋯
a✝ : α
⊢ (comapDomain f (r • v) hfrv) a✝ = (r • comapDomain f v hfv) a✝
tactic: ext
state_before: case h
α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
M : Type u_5
M' : Type u_6
N : Type u_7
P : Type u_8
G : Type u_9
H : Type u_10
R : Type u_11
S : Type u_12
inst✝² : AddMonoid M
inst✝¹ : Monoid R
inst✝ : DistribMulAction R M
f : α → β
r : R
v : β →₀ M
hfv : Set.InjOn f (f ⁻¹' ↑v.support)
hfrv : optParam (Set.InjOn f (f ⁻¹' ↑(r • v).support)) ⋯
a✝ : α
⊢ (comapDomain f (r • v) hfrv) a✝ = (r • comapDomain f v hfv) a✝
state_after: no goals
tactic: rfl
Theorem: Matrix.isDiag_fromBlocks_iff
File: Mathlib/LinearAlgebra/Matrix/IsDiag.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
R : Type u_3
n : Type u_4
m : Type u_5
inst✝ : Zero α
A : Matrix m m α
B : Matrix m n α
C : Matrix n m α
D : Matrix n n α
⊢ (fromBlocks A B C D).IsDiag ↔ A.IsDiag ∧ B = 0 ∧ C = 0 ∧ D.IsDiag
state_after: case mp
α : Type u_1
β : Type u_2
R : Type u_3
n : Type u_4
m : Type u_5
inst✝ : Zero α
A : Matrix m m α
B : Matrix m n α
C : Matrix n m α
D : Matrix n n α
⊢ (fromBlocks A B C D).IsDiag → A.IsDiag ∧ B = 0 ∧ C = 0 ∧ D.IsDiag

case mpr
α : Type u_1
β : Type u_2
R : Type u_3
n : Type u_4
m : Type u_5
inst✝ : Zero α
A : Matrix m m α
B : Matrix m n α
C : Matrix n m α
D : Matrix n n α
⊢ A.IsDiag ∧ B = 0 ∧ C = 0 ∧ D.IsDiag → (fromBlocks A B C D).IsDiag
tactic: constructor
Theorem: ProbabilityTheory.IsCondKernelCDF.lintegral
File: Mathlib/Probability/Kernel/Disintegration/CdfToKernel.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
mα : MeasurableSpace α
mβ : MeasurableSpace β
κ : Kernel α (β × ℝ)
ν : Kernel α β
f✝ : α × β → StieltjesFunction
inst✝ : IsFiniteKernel κ
f : α × β → StieltjesFunction
hf : IsCondKernelCDF f κ ν
a : α
x : ℝ
⊢ ∫⁻ (b : β), ENNReal.ofReal (↑(f (a, b)) x) ∂ν a = (κ a) (univ ×ˢ Iic x)
state_after: no goals
tactic: rw [← hf.setLIntegral _ MeasurableSet.univ, Measure.restrict_univ]
Theorem: Algebra.lmul_isUnit_iff
File: Mathlib/Algebra/Algebra/Bilinear.lean

Proof steps:
state_before: R : Type u_1
A : Type u_2
B : Type u_3
inst✝⁴ : CommSemiring R
inst✝³ : Semiring A
inst✝² : Semiring B
inst✝¹ : Algebra R A
inst✝ : Algebra R B
x : A
⊢ IsUnit ((Algebra.lmul R A) x) ↔ IsUnit x
state_after: R : Type u_1
A : Type u_2
B : Type u_3
inst✝⁴ : CommSemiring R
inst✝³ : Semiring A
inst✝² : Semiring B
inst✝¹ : Algebra R A
inst✝ : Algebra R B
x : A
⊢ IsUnit x ↔ Function.Bijective ⇑((Algebra.lmul R A) x)
tactic: rw [Module.End_isUnit_iff, Iff.comm]
state_before: R : Type u_1
A : Type u_2
B : Type u_3
inst✝⁴ : CommSemiring R
inst✝³ : Semiring A
inst✝² : Semiring B
inst✝¹ : Algebra R A
inst✝ : Algebra R B
x : A
⊢ IsUnit x ↔ Function.Bijective ⇑((Algebra.lmul R A) x)
state_after: no goals
tactic: exact IsUnit.isUnit_iff_mulLeft_bijective
Theorem: HasStrictFDerivAt.cpow
File: Mathlib/Analysis/SpecialFunctions/Pow/Deriv.lean

Proof steps:
state_before: E : Type u_1
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace ℂ E
f g : E → ℂ
f' g' : E →L[ℂ] ℂ
x : E
s : Set E
c : ℂ
hf : HasStrictFDerivAt f f' x
hg : HasStrictFDerivAt g g' x
h0 : f x ∈ slitPlane
⊢ HasStrictFDerivAt (fun x => f x ^ g x) ((g x * f x ^ (g x - 1)) • f' + (f x ^ g x * Complex.log (f x)) • g') x
state_after: no goals
tactic: convert (@hasStrictFDerivAt_cpow ((fun x => (f x, g x)) x) h0).comp x (hf.prod hg)
Theorem: List.forall₂_drop
File: Mathlib/Data/List/Forall2.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
R S : α → β → Prop
P : γ → δ → Prop
Rₐ : α → α → Prop
x✝¹ : List α
x✝ : List β
h : Forall₂ R x✝¹ x✝
⊢ Forall₂ R (drop 0 x✝¹) (drop 0 x✝)
state_after: no goals
tactic: simp only [drop, h]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
R S : α → β → Prop
P : γ → δ → Prop
Rₐ : α → α → Prop
n✝ : ℕ
⊢ Forall₂ R (drop (n✝ + 1) []) (drop (n✝ + 1) [])
state_after: no goals
tactic: simp only [Forall₂.nil, drop]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
R S : α → β → Prop
P : γ → δ → Prop
Rₐ : α → α → Prop
n : ℕ
a✝ : α
b✝ : β
l₁✝ : List α
l₂✝ : List β
h₁ : R a✝ b✝
h₂ : Forall₂ R l₁✝ l₂✝
⊢ Forall₂ R (drop (n + 1) (a✝ :: l₁✝)) (drop (n + 1) (b✝ :: l₂✝))
state_after: no goals
tactic: simp [And.intro h₁ h₂, forall₂_drop n]
Theorem: neg_le_iff_add_nonneg'
File: Mathlib/Algebra/Order/Group/Unbundled/Basic.lean

Proof steps:
state_before: α : Type u
inst✝² : Group α
inst✝¹ : LE α
inst✝ : CovariantClass α α (fun x x_1 => x * x_1) fun x x_1 => x ≤ x_1
a b c d : α
⊢ a * a⁻¹ ≤ a * b ↔ 1 ≤ a * b
state_after: no goals
tactic: rw [mul_inv_self]
Theorem: CategoryTheory.Equivalence.invFunIdAssoc_hom_app
File: Mathlib/CategoryTheory/Equivalence.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
e : C ≌ D
F : D ⥤ E
X : D
⊢ (e.invFunIdAssoc F).hom.app X = F.map (e.counit.app X)
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
e : C ≌ D
F : D ⥤ E
X : D
⊢ 𝟙 (F.obj (e.functor.obj (e.inverse.obj X))) ≫ F.map (e.counitIso.hom.app X) ≫ 𝟙 (F.obj X) = F.map (e.counit.app X)
tactic: dsimp [invFunIdAssoc]
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
e : C ≌ D
F : D ⥤ E
X : D
⊢ 𝟙 (F.obj (e.functor.obj (e.inverse.obj X))) ≫ F.map (e.counitIso.hom.app X) ≫ 𝟙 (F.obj X) = F.map (e.counit.app X)
state_after: no goals
tactic: aesop_cat