ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: Prime.exists_mem_multiset_dvd
File: Mathlib/Algebra/BigOperators/Associated.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝ : CommMonoidWithZero α
p : α
hp : Prime p
s✝ : Multiset α
a : α
s : Multiset α
ih : p ∣ s.prod → ∃ a ∈ s, p ∣ a
h : p ∣ (a ::ₘ s).prod
⊢ p ∣ a * s.prod
state_after: no goals
tactic: simpa using h
Theorem: Real.arctan_neg
File: Mathlib/Analysis/SpecialFunctions/Trigonometric/Arctan.lean

Proof steps:
state_before: x : ℝ
⊢ arctan (-x) = -arctan x
state_after: no goals
tactic: simp [arctan_eq_arcsin, neg_div]
Theorem: CategoryTheory.shiftFunctorAdd_hom_app_obj_of_induced
File: Mathlib/CategoryTheory/Shift/Induced.lean

Proof steps:
state_before: C : Type u_4
D : Type u_2
inst✝⁵ : Category.{u_5, u_4} C
inst✝⁴ : Category.{u_1, u_2} D
F : C ⥤ D
A : Type u_3
inst✝³ : AddMonoid A
inst✝² : HasShift C A
s : A → D ⥤ D
i : (a : A) → F ⋙ s a ≅ shiftFunctor C a ⋙ F
inst✝¹ : ((whiskeringLeft C D D).obj F).Full
inst✝ : ((whiskeringLeft C D D).obj F).Faithful
a b : A
X : C
⊢ (shiftFunctorAdd D a b).hom.app (F.obj X) =
    (i (a + b)).hom.app X ≫
      F.map ((shiftFunctorAdd C a b).hom.app X) ≫ (i b).inv.app ((shiftFunctor C a).obj X) ≫ (s b).map ((i a).inv.app X)
state_after: C : Type u_4
D : Type u_2
inst✝⁵ : Category.{u_5, u_4} C
inst✝⁴ : Category.{u_1, u_2} D
F : C ⥤ D
A : Type u_3
inst✝³ : AddMonoid A
inst✝² : HasShift C A
s : A → D ⥤ D
i : (a : A) → F ⋙ s a ≅ shiftFunctor C a ⋙ F
inst✝¹ : ((whiskeringLeft C D D).obj F).Full
inst✝ : ((whiskeringLeft C D D).obj F).Faithful
a b : A
X : C
this : HasShift D A := HasShift.induced F A s i
⊢ (shiftFunctorAdd D a b).hom.app (F.obj X) =
    (i (a + b)).hom.app X ≫
      F.map ((shiftFunctorAdd C a b).hom.app X) ≫ (i b).inv.app ((shiftFunctor C a).obj X) ≫ (s b).map ((i a).inv.app X)
tactic: letI := HasShift.induced F A s i
state_before: C : Type u_4
D : Type u_2
inst✝⁵ : Category.{u_5, u_4} C
inst✝⁴ : Category.{u_1, u_2} D
F : C ⥤ D
A : Type u_3
inst✝³ : AddMonoid A
inst✝² : HasShift C A
s : A → D ⥤ D
i : (a : A) → F ⋙ s a ≅ shiftFunctor C a ⋙ F
inst✝¹ : ((whiskeringLeft C D D).obj F).Full
inst✝ : ((whiskeringLeft C D D).obj F).Faithful
a b : A
X : C
this : HasShift D A := HasShift.induced F A s i
⊢ (shiftFunctorAdd D a b).hom.app (F.obj X) =
    (i (a + b)).hom.app X ≫
      F.map ((shiftFunctorAdd C a b).hom.app X) ≫ (i b).inv.app ((shiftFunctor C a).obj X) ≫ (s b).map ((i a).inv.app X)
state_after: no goals
tactic: simp only [ShiftMkCore.shiftFunctorAdd_eq, HasShift.Induced.add_hom_app_obj]
Theorem: SimpleGraph.chromaticNumber_ne_top_iff_exists
File: Mathlib/Combinatorics/SimpleGraph/Coloring.lean

Proof steps:
state_before: V : Type u
G : SimpleGraph V
n : ℕ
α : Type u_1
β : Type u_2
C : G.Coloring α
⊢ G.chromaticNumber ≠ ⊤ ↔ ∃ n, G.Colorable n
state_after: V : Type u
G : SimpleGraph V
n : ℕ
α : Type u_1
β : Type u_2
C : G.Coloring α
⊢ ⨅ n ∈ setOf G.Colorable, ↑n ≠ ⊤ ↔ ∃ n, G.Colorable n
tactic: rw [chromaticNumber]
state_before: V : Type u
G : SimpleGraph V
n : ℕ
α : Type u_1
β : Type u_2
C : G.Coloring α
⊢ ⨅ n ∈ setOf G.Colorable, ↑n ≠ ⊤ ↔ ∃ n, G.Colorable n
state_after: case h.e'_1.a
V : Type u
G : SimpleGraph V
n : ℕ
α : Type u_1
β : Type u_2
C : G.Coloring α
⊢ ⨅ n ∈ setOf G.Colorable, ↑n ≠ ⊤ ↔ ⨅ n, ↑↑n ≠ ⊤

case convert_2
V : Type u
G : SimpleGraph V
n : ℕ
α : Type u_1
β : Type u_2
C : G.Coloring α
⊢ ⨅ n, ↑↑n ≠ ⊤ ↔ ∃ n, G.Colorable n
tactic: convert_to ⨅ n : {m | G.Colorable m}, (n : ℕ∞) ≠ ⊤ ↔ _
state_before: case convert_2
V : Type u
G : SimpleGraph V
n : ℕ
α : Type u_1
β : Type u_2
C : G.Coloring α
⊢ ⨅ n, ↑↑n ≠ ⊤ ↔ ∃ n, G.Colorable n
state_after: case convert_2
V : Type u
G : SimpleGraph V
n : ℕ
α : Type u_1
β : Type u_2
C : G.Coloring α
⊢ Nonempty ↑{m | G.Colorable m} ↔ ∃ n, G.Colorable n
tactic: rw [← lt_top_iff_ne_top, ENat.iInf_coe_lt_top]
state_before: case convert_2
V : Type u
G : SimpleGraph V
n : ℕ
α : Type u_1
β : Type u_2
C : G.Coloring α
⊢ Nonempty ↑{m | G.Colorable m} ↔ ∃ n, G.Colorable n
state_after: no goals
tactic: simp
Theorem: addOrderOf_pos_iff
File: Mathlib/GroupTheory/OrderOfElement.lean

Proof steps:
state_before: G : Type u_1
H : Type u_2
A : Type u_3
α : Type u_4
β : Type u_5
inst✝ : Monoid G
a b x y : G
n m : ℕ
⊢ 0 < orderOf x ↔ IsOfFinOrder x
state_after: no goals
tactic: rw [iff_not_comm.mp orderOf_eq_zero_iff, pos_iff_ne_zero]
Theorem: modEq_mersenne
File: Mathlib/NumberTheory/LucasLehmer.lean

Proof steps:
state_before: n k : ℕ
⊢ 1 * (k / 2 ^ n) + k % 2 ^ n = k / 2 ^ n + k % 2 ^ n
state_after: no goals
tactic: rw [one_mul]
Theorem: iSup_unique
File: Mathlib/Order/CompleteLattice.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
β₂ : Type u_3
γ : Type u_4
ι : Sort u_5
ι' : Sort u_6
κ : ι → Sort u_7
κ' : ι' → Sort u_8
inst✝¹ : CompleteLattice α
f✝ g s t : ι → α
a b : α
inst✝ : Unique ι
f : ι → α
⊢ ⨆ i, f i = f default
state_after: no goals
tactic: simp only [congr_arg f (Unique.eq_default _), iSup_const]
Theorem: Algebra.IsAlgebraic.normalClosure_le_iSup_adjoin
File: Mathlib/FieldTheory/NormalClosure.lean

Proof steps:
state_before: F : Type u_1
K : Type u_2
L : Type u_3
inst✝⁵ : Field F
inst✝⁴ : Field K
inst✝³ : Field L
inst✝² : Algebra F K
inst✝¹ : Algebra F L
inst✝ : Algebra.IsAlgebraic F K
f : K →ₐ[F] L
x✝¹ : L
x✝ : x✝¹ ∈ f.fieldRange
x : K
hx : f.toRingHom x = x✝¹
⊢ x✝¹ ∈ (minpoly F x).rootSet L
state_after: no goals
tactic: rw [mem_rootSet_of_ne (minpoly.ne_zero (Algebra.IsIntegral.isIntegral x)), ← hx,
        AlgHom.toRingHom_eq_coe, AlgHom.coe_toRingHom, aeval_algHom_apply, minpoly.aeval, map_zero]
Theorem: Matrix.BlockTriangular.add
File: Mathlib/LinearAlgebra/Matrix/Block.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
m : Type u_3
n : Type u_4
o : Type u_5
m' : α → Type u_6
n' : α → Type u_7
R : Type v
inst✝¹ : CommRing R
M N : Matrix m m R
b : m → α
inst✝ : LT α
hM : M.BlockTriangular b
hN : N.BlockTriangular b
i j : m
h : b j < b i
⊢ (M + N) i j = 0
state_after: no goals
tactic: simp_rw [Matrix.add_apply, hM h, hN h, zero_add]
Theorem: seminormFromBounded_mul
File: Mathlib/Analysis/Normed/Ring/SeminormFromBounded.lean

Proof steps:
state_before: R : Type u_1
inst✝ : CommRing R
f : R → ℝ
c : ℝ
f_nonneg : 0 ≤ f
f_mul : ∀ (x y : R), f (x * y) ≤ c * f x * f y
x y : R
⊢ seminormFromBounded' f (x * y) ≤ seminormFromBounded' f x * seminormFromBounded' f y
state_after: case H
R : Type u_1
inst✝ : CommRing R
f : R → ℝ
c : ℝ
f_nonneg : 0 ≤ f
f_mul : ∀ (x y : R), f (x * y) ≤ c * f x * f y
x y : R
⊢ ∀ (x_1 : R), f (x * y * x_1) / f x_1 ≤ seminormFromBounded' f x * seminormFromBounded' f y
tactic: apply ciSup_le
state_before: case H
R : Type u_1
inst✝ : CommRing R
f : R → ℝ
c : ℝ
f_nonneg : 0 ≤ f
f_mul : ∀ (x y : R), f (x * y) ≤ c * f x * f y
x y : R
⊢ ∀ (x_1 : R), f (x * y * x_1) / f x_1 ≤ seminormFromBounded' f x * seminormFromBounded' f y
state_after: case pos
R : Type u_1
inst✝ : CommRing R
f : R → ℝ
c : ℝ
f_nonneg : 0 ≤ f
f_mul : ∀ (x y : R), f (x * y) ≤ c * f x * f y
x y : R
hy : seminormFromBounded' f y = 0
⊢ ∀ (x_1 : R), f (x * y * x_1) / f x_1 ≤ seminormFromBounded' f x * seminormFromBounded' f y

case neg
R : Type u_1
inst✝ : CommRing R
f : R → ℝ
c : ℝ
f_nonneg : 0 ≤ f
f_mul : ∀ (x y : R), f (x * y) ≤ c * f x * f y
x y : R
hy : ¬seminormFromBounded' f y = 0
⊢ ∀ (x_1 : R), f (x * y * x_1) / f x_1 ≤ seminormFromBounded' f x * seminormFromBounded' f y
tactic: by_cases hy : seminormFromBounded' f y = 0
Theorem: Equiv.Perm.sumCongr_swap_refl
File: Mathlib/Logic/Equiv/Basic.lean

Proof steps:
state_before: α✝ : Sort ?u.98918
inst✝² : DecidableEq α✝
α : Type u_1
β : Type u_2
inst✝¹ : DecidableEq α
inst✝ : DecidableEq β
i j : α
⊢ (swap i j).sumCongr (Equiv.refl β) = swap (Sum.inl i) (Sum.inl j)
state_after: case H
α✝ : Sort ?u.98918
inst✝² : DecidableEq α✝
α : Type u_1
β : Type u_2
inst✝¹ : DecidableEq α
inst✝ : DecidableEq β
i j : α
x : α ⊕ β
⊢ ((swap i j).sumCongr (Equiv.refl β)) x = (swap (Sum.inl i) (Sum.inl j)) x
tactic: ext x
state_before: case H
α✝ : Sort ?u.98918
inst✝² : DecidableEq α✝
α : Type u_1
β : Type u_2
inst✝¹ : DecidableEq α
inst✝ : DecidableEq β
i j : α
x : α ⊕ β
⊢ ((swap i j).sumCongr (Equiv.refl β)) x = (swap (Sum.inl i) (Sum.inl j)) x
state_after: case H.inl
α✝ : Sort ?u.98918
inst✝² : DecidableEq α✝
α : Type u_1
β : Type u_2
inst✝¹ : DecidableEq α
inst✝ : DecidableEq β
i j val✝ : α
⊢ ((swap i j).sumCongr (Equiv.refl β)) (Sum.inl val✝) = (swap (Sum.inl i) (Sum.inl j)) (Sum.inl val✝)

case H.inr
α✝ : Sort ?u.98918
inst✝² : DecidableEq α✝
α : Type u_1
β : Type u_2
inst✝¹ : DecidableEq α
inst✝ : DecidableEq β
i j : α
val✝ : β
⊢ ((swap i j).sumCongr (Equiv.refl β)) (Sum.inr val✝) = (swap (Sum.inl i) (Sum.inl j)) (Sum.inr val✝)
tactic: cases x
Theorem: zpow_mul_comm
File: Mathlib/Algebra/Group/Basic.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
G : Type u_3
M : Type u_4
inst✝ : Group G
a✝ b c d : G
n✝ : ℤ
a : G
m n : ℤ
⊢ a ^ m * a ^ n = a ^ n * a ^ m
state_after: no goals
tactic: rw [← zpow_add, Int.add_comm, zpow_add]
Theorem: ZMod.subsingleton_iff
File: Mathlib/Data/ZMod/Basic.lean

Proof steps:
state_before: m n✝ n : ℕ
⊢ Subsingleton (ZMod n) ↔ n = 1
state_after: case mp
m n✝ n : ℕ
⊢ Subsingleton (ZMod n) → n = 1

case mpr
m n✝ n : ℕ
⊢ n = 1 → Subsingleton (ZMod n)
tactic: constructor
Theorem: PowerBasis.minpolyGen_map
File: Mathlib/RingTheory/PowerBasis.lean

Proof steps:
state_before: R : Type u_1
S : Type u_2
T : Type u_3
inst✝¹¹ : CommRing R
inst✝¹⁰ : Ring S
inst✝⁹ : Algebra R S
A : Type u_4
B : Type u_5
inst✝⁸ : CommRing A
inst✝⁷ : CommRing B
inst✝⁶ : IsDomain B
inst✝⁵ : Algebra A B
K : Type u_6
inst✝⁴ : Field K
S' : Type u_7
inst✝³ : CommRing S'
inst✝² : Algebra R S'
inst✝¹ : Algebra A S
inst✝ : Algebra A S'
pb : PowerBasis A S
e : S ≃ₐ[A] S'
⊢ (pb.map e).minpolyGen = pb.minpolyGen
state_after: R : Type u_1
S : Type u_2
T : Type u_3
inst✝¹¹ : CommRing R
inst✝¹⁰ : Ring S
inst✝⁹ : Algebra R S
A : Type u_4
B : Type u_5
inst✝⁸ : CommRing A
inst✝⁷ : CommRing B
inst✝⁶ : IsDomain B
inst✝⁵ : Algebra A B
K : Type u_6
inst✝⁴ : Field K
S' : Type u_7
inst✝³ : CommRing S'
inst✝² : Algebra R S'
inst✝¹ : Algebra A S
inst✝ : Algebra A S'
pb : PowerBasis A S
e : S ≃ₐ[A] S'
⊢ X ^ pb.dim - ∑ i : Fin pb.dim, C (((pb.map e).basis.repr ((pb.map e).gen ^ pb.dim)) i) * X ^ ↑i =
    X ^ pb.dim - ∑ i : Fin pb.dim, C ((pb.basis.repr (pb.gen ^ pb.dim)) i) * X ^ ↑i
tactic: dsimp only [minpolyGen, map_dim]
state_before: R : Type u_1
S : Type u_2
T : Type u_3
inst✝¹¹ : CommRing R
inst✝¹⁰ : Ring S
inst✝⁹ : Algebra R S
A : Type u_4
B : Type u_5
inst✝⁸ : CommRing A
inst✝⁷ : CommRing B
inst✝⁶ : IsDomain B
inst✝⁵ : Algebra A B
K : Type u_6
inst✝⁴ : Field K
S' : Type u_7
inst✝³ : CommRing S'
inst✝² : Algebra R S'
inst✝¹ : Algebra A S
inst✝ : Algebra A S'
pb : PowerBasis A S
e : S ≃ₐ[A] S'
⊢ X ^ pb.dim - ∑ i : Fin pb.dim, C (((pb.map e).basis.repr ((pb.map e).gen ^ pb.dim)) i) * X ^ ↑i =
    X ^ pb.dim - ∑ i : Fin pb.dim, C ((pb.basis.repr (pb.gen ^ pb.dim)) i) * X ^ ↑i
state_after: no goals
tactic: simp only [LinearEquiv.trans_apply, map_basis, Basis.map_repr, map_gen,
    AlgEquiv.toLinearEquiv_apply, e.toLinearEquiv_symm, map_pow,
    AlgEquiv.symm_apply_apply, sub_right_inj]
Theorem: InnerProductSpace.Core.inner_self_eq_norm_mul_norm
File: Mathlib/Analysis/InnerProductSpace/Basic.lean

Proof steps:
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
inst✝² : _root_.RCLike 𝕜
inst✝¹ : AddCommGroup F
inst✝ : Module 𝕜 F
c : Core 𝕜 F
x : F
⊢ re ⟪x, x⟫_𝕜 = ‖x‖ * ‖x‖
state_after: no goals
tactic: rw [norm_eq_sqrt_inner, ← sqrt_mul inner_self_nonneg (re ⟪x, x⟫), sqrt_mul_self inner_self_nonneg]
Theorem: HolorIndex.cast_type
File: Mathlib/Data/Holor.lean

Proof steps:
state_before: ds₁ ds₂ ds₃ is : List ℕ
eq : ds₁ = ds₂
h : Forall₂ (fun x x_1 => x < x_1) is ds₁
⊢ ↑(cast ⋯ ⟨is, h⟩) = is
state_after: ds₁ ds₃ is : List ℕ
h : Forall₂ (fun x x_1 => x < x_1) is ds₁
⊢ ↑(cast ⋯ ⟨is, h⟩) = is
tactic: subst eq
state_before: ds₁ ds₃ is : List ℕ
h : Forall₂ (fun x x_1 => x < x_1) is ds₁
⊢ ↑(cast ⋯ ⟨is, h⟩) = is
state_after: no goals
tactic: rfl
Theorem: Nat.Partrec.Code.const_prim
File: Mathlib/Computability/PartrecCode.lean

Proof steps:
state_before: n : ℕ
⊢ (fun b => succ.comp (n, b).2)^[id n] zero = Code.const n
state_after: n : ℕ
⊢ (fun b => succ.comp b)^[n] zero = Code.const n
tactic: simp
state_before: n : ℕ
⊢ (fun b => succ.comp b)^[n] zero = Code.const n
state_after: no goals
tactic: induction n <;>
      simp [*, Code.const, Function.iterate_succ', -Function.iterate_succ]
Theorem: Nat.coprime_of_dvd
File: Mathlib/Data/Nat/Prime/Defs.lean

Proof steps:
state_before: n✝ m n : ℕ
H : ∀ (k : ℕ), Prime k → k ∣ m → ¬k ∣ n
⊢ m.Coprime n
state_after: n✝ m n : ℕ
H : ∀ (k : ℕ), Prime k → k ∣ m → ¬k ∣ n
⊢ m.gcd n = 1
tactic: rw [coprime_iff_gcd_eq_one]
state_before: n✝ m n : ℕ
H : ∀ (k : ℕ), Prime k → k ∣ m → ¬k ∣ n
⊢ m.gcd n = 1
state_after: n✝ m n : ℕ
H : ∀ (k : ℕ), Prime k → k ∣ m → ¬k ∣ n
g2 : ¬m.gcd n = 1
⊢ False
tactic: by_contra g2
state_before: n✝ m n : ℕ
H : ∀ (k : ℕ), Prime k → k ∣ m → ¬k ∣ n
g2 : ¬m.gcd n = 1
⊢ False
state_after: case intro.intro
n✝ m n : ℕ
H : ∀ (k : ℕ), Prime k → k ∣ m → ¬k ∣ n
g2 : ¬m.gcd n = 1
p : ℕ
hp : Prime p
hpdvd : p ∣ m.gcd n
⊢ False
tactic: obtain ⟨p, hp, hpdvd⟩ := exists_prime_and_dvd g2
state_before: case intro.intro
n✝ m n : ℕ
H : ∀ (k : ℕ), Prime k → k ∣ m → ¬k ∣ n
g2 : ¬m.gcd n = 1
p : ℕ
hp : Prime p
hpdvd : p ∣ m.gcd n
⊢ False
state_after: case intro.intro.a
n✝ m n : ℕ
H : ∀ (k : ℕ), Prime k → k ∣ m → ¬k ∣ n
g2 : ¬m.gcd n = 1
p : ℕ
hp : Prime p
hpdvd : p ∣ m.gcd n
⊢ m.gcd n ∣ m

case intro.intro.a
n✝ m n : ℕ
H : ∀ (k : ℕ), Prime k → k ∣ m → ¬k ∣ n
g2 : ¬m.gcd n = 1
p : ℕ
hp : Prime p
hpdvd : p ∣ m.gcd n
⊢ m.gcd n ∣ n
tactic: apply H p hp <;> apply dvd_trans hpdvd
Theorem: tendstoLocallyUniformlyOn_iff_tendstoUniformlyOn_of_compact
File: Mathlib/Topology/UniformSpace/UniformConvergence.lean

Proof steps:
state_before: α : Type u
β : Type v
γ : Type w
ι : Type x
inst✝¹ : UniformSpace β
F : ι → α → β
f : α → β
s s' : Set α
x : α
p : Filter ι
p' : Filter α
g : ι → α
inst✝ : TopologicalSpace α
hs : IsCompact s
⊢ TendstoLocallyUniformlyOn F f p s ↔ TendstoUniformlyOn F f p s
state_after: α : Type u
β : Type v
γ : Type w
ι : Type x
inst✝¹ : UniformSpace β
F : ι → α → β
f : α → β
s s' : Set α
x : α
p : Filter ι
p' : Filter α
g : ι → α
inst✝ : TopologicalSpace α
hs : IsCompact s
this : CompactSpace ↑s
⊢ TendstoLocallyUniformlyOn F f p s ↔ TendstoUniformlyOn F f p s
tactic: haveI : CompactSpace s := isCompact_iff_compactSpace.mp hs
state_before: α : Type u
β : Type v
γ : Type w
ι : Type x
inst✝¹ : UniformSpace β
F : ι → α → β
f : α → β
s s' : Set α
x : α
p : Filter ι
p' : Filter α
g : ι → α
inst✝ : TopologicalSpace α
hs : IsCompact s
this : CompactSpace ↑s
⊢ TendstoLocallyUniformlyOn F f p s ↔ TendstoUniformlyOn F f p s
state_after: α : Type u
β : Type v
γ : Type w
ι : Type x
inst✝¹ : UniformSpace β
F : ι → α → β
f : α → β
s s' : Set α
x : α
p : Filter ι
p' : Filter α
g : ι → α
inst✝ : TopologicalSpace α
hs : IsCompact s
this : CompactSpace ↑s
h : TendstoLocallyUniformlyOn F f p s
⊢ TendstoUniformlyOn F f p s
tactic: refine ⟨fun h => ?_, TendstoUniformlyOn.tendstoLocallyUniformlyOn⟩
state_before: α : Type u
β : Type v
γ : Type w
ι : Type x
inst✝¹ : UniformSpace β
F : ι → α → β
f : α → β
s s' : Set α
x : α
p : Filter ι
p' : Filter α
g : ι → α
inst✝ : TopologicalSpace α
hs : IsCompact s
this : CompactSpace ↑s
h : TendstoLocallyUniformlyOn F f p s
⊢ TendstoUniformlyOn F f p s
state_after: no goals
tactic: rwa [tendstoLocallyUniformlyOn_iff_tendstoLocallyUniformly_comp_coe,
    tendstoLocallyUniformly_iff_tendstoUniformly_of_compactSpace, ←
    tendstoUniformlyOn_iff_tendstoUniformly_comp_coe] at h
Theorem: Fin.rev_eq_iff
File: Mathlib/Data/Fin/Basic.lean

Proof steps:
state_before: n m : ℕ
i j : Fin n
⊢ i.rev = j ↔ i = j.rev
state_after: no goals
tactic: rw [← rev_inj, rev_rev]
Theorem: List.foldl1_eq_foldr1
File: Mathlib/Data/List/Basic.lean

Proof steps:
state_before: ι : Type u_1
α : Type u
β : Type v
γ : Type w
l₁ l₂ : List α
f : α → α → α
hassoc : Associative f
a b c : α
l : List α
⊢ foldl f a (c :: l ++ [b]) = foldr f b (a :: c :: l)
state_after: ι : Type u_1
α : Type u
β : Type v
γ : Type w
l₁ l₂ : List α
f : α → α → α
hassoc : Associative f
a b c : α
l : List α
⊢ f (f a c) (foldr f b l) = f a (f c (foldr f b l))
tactic: simp only [cons_append, foldl_cons, foldr_cons, foldl1_eq_foldr1 hassoc _ _ l]
state_before: ι : Type u_1
α : Type u
β : Type v
γ : Type w
l₁ l₂ : List α
f : α → α → α
hassoc : Associative f
a b c : α
l : List α
⊢ f (f a c) (foldr f b l) = f a (f c (foldr f b l))
state_after: no goals
tactic: rw [hassoc]
Theorem: CategoryTheory.ShortComplex.SnakeInput.op_L₁
File: Mathlib/Algebra/Homology/ShortComplex/SnakeLemma.lean

Proof steps:
state_before: C : Type u_1
inst✝¹ : Category.{?u.4837, u_1} C
inst✝ : Abelian C
S : SnakeInput C
⊢ Epi S.L₂.op.g
state_after: C : Type u_1
inst✝¹ : Category.{?u.4837, u_1} C
inst✝ : Abelian C
S : SnakeInput C
⊢ Epi S.L₂.f.op
tactic: dsimp
state_before: C : Type u_1
inst✝¹ : Category.{?u.4837, u_1} C
inst✝ : Abelian C
S : SnakeInput C
⊢ Epi S.L₂.f.op
state_after: no goals
tactic: infer_instance
state_before: C : Type u_1
inst✝¹ : Category.{?u.4837, u_1} C
inst✝ : Abelian C
S : SnakeInput C
⊢ Mono S.L₁.op.f
state_after: C : Type u_1
inst✝¹ : Category.{?u.4837, u_1} C
inst✝ : Abelian C
S : SnakeInput C
⊢ Mono S.L₁.g.op
tactic: dsimp
state_before: C : Type u_1
inst✝¹ : Category.{?u.4837, u_1} C
inst✝ : Abelian C
S : SnakeInput C
⊢ Mono S.L₁.g.op
state_after: no goals
tactic: infer_instance
Theorem: MeasureTheory.Measure.restrict_iUnion_ae
File: Mathlib/MeasureTheory/Measure/Restrict.lean

Proof steps:
state_before: R : Type u_1
α : Type u_2
β : Type u_3
δ : Type u_4
γ : Type u_5
ι : Type u_6
m0 : MeasurableSpace α
inst✝² : MeasurableSpace β
inst✝¹ : MeasurableSpace γ
μ μ₁ μ₂ μ₃ ν ν' ν₁ ν₂ : Measure α
s✝ s' t✝ : Set α
inst✝ : Countable ι
s : ι → Set α
hd : Pairwise (AEDisjoint μ on s)
hm : ∀ (i : ι), NullMeasurableSet (s i) μ
t : Set α
ht : MeasurableSet t
⊢ (μ.restrict (⋃ i, s i)) t = (sum fun i => μ.restrict (s i)) t
state_after: no goals
tactic: simp only [sum_apply _ ht, restrict_iUnion_apply_ae hd hm ht]
Theorem: AddMonoid.Coprod.fst_comp_toSum
File: Mathlib/GroupTheory/Coprod/Basic.lean

Proof steps:
state_before: M : Type u_1
N : Type u_2
inst✝¹ : Monoid M
inst✝ : Monoid N
⊢ (MonoidHom.fst M N).comp toProd = fst
state_after: no goals
tactic: rw [← fst_prod_snd, MonoidHom.fst_comp_prod]
Theorem: Primrec.listLookup
File: Mathlib/Computability/Primrec.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
σ : Type u_4
inst✝⁴ : Primcodable α
inst✝³ : Primcodable β
inst✝² : Primcodable γ
inst✝¹ : Primcodable σ
inst✝ : DecidableEq α
a : α
ps : List (α × β)
⊢ (List.recOn (a, ps).2 none fun b l IH =>
      bif ((a, ps), b, l, IH).1.1 == ((a, ps), b, l, IH).2.1.1 then some ((a, ps), b, l, IH).2.1.2
      else ((a, ps), b, l, IH).2.2.2) =
    List.lookup a ps
state_after: case cons
α : Type u_1
β : Type u_2
γ : Type u_3
σ : Type u_4
inst✝⁴ : Primcodable α
inst✝³ : Primcodable β
inst✝² : Primcodable γ
inst✝¹ : Primcodable σ
inst✝ : DecidableEq α
a : α
p : α × β
ps : List (α × β)
ih :
  (List.recOn (a, ps).2 none fun b l IH =>
      bif ((a, ps), b, l, IH).1.1 == ((a, ps), b, l, IH).2.1.1 then some ((a, ps), b, l, IH).2.1.2
      else ((a, ps), b, l, IH).2.2.2) =
    List.lookup a ps
⊢ (bif a == p.1 then some p.2 else List.lookup a ps) =
    match a == p.1 with
    | true => some p.2
    | false => List.lookup a ps
tactic: induction' ps with p ps ih <;> simp [List.lookup, *]
state_before: case cons
α : Type u_1
β : Type u_2
γ : Type u_3
σ : Type u_4
inst✝⁴ : Primcodable α
inst✝³ : Primcodable β
inst✝² : Primcodable γ
inst✝¹ : Primcodable σ
inst✝ : DecidableEq α
a : α
p : α × β
ps : List (α × β)
ih :
  (List.recOn (a, ps).2 none fun b l IH =>
      bif ((a, ps), b, l, IH).1.1 == ((a, ps), b, l, IH).2.1.1 then some ((a, ps), b, l, IH).2.1.2
      else ((a, ps), b, l, IH).2.2.2) =
    List.lookup a ps
⊢ (bif a == p.1 then some p.2 else List.lookup a ps) =
    match a == p.1 with
    | true => some p.2
    | false => List.lookup a ps
state_after: no goals
tactic: cases ha : a == p.1 <;> simp [ha]
Theorem: IntermediateField.eq_bot_of_isAlgClosed_of_isAlgebraic
File: Mathlib/FieldTheory/IsAlgClosed/Basic.lean

Proof steps:
state_before: k✝ : Type u
inst✝⁵ : Field k✝
k : Type u_1
K : Type u_2
inst✝⁴ : Field k
inst✝³ : Field K
inst✝² : IsAlgClosed k
inst✝¹ : Algebra k K
L : IntermediateField k K
inst✝ : Algebra.IsAlgebraic k ↥L
x : K
hx : x ∈ L
⊢ x ∈ ⊥
state_after: case intro
k✝ : Type u
inst✝⁵ : Field k✝
k : Type u_1
K : Type u_2
inst✝⁴ : Field k
inst✝³ : Field K
inst✝² : IsAlgClosed k
inst✝¹ : Algebra k K
L : IntermediateField k K
inst✝ : Algebra.IsAlgebraic k ↥L
x : K
hx : x ∈ L
y : k
hy : (algebraMap k ↥L) y = ⟨x, hx⟩
⊢ x ∈ ⊥
tactic: obtain ⟨y, hy⟩ := IsAlgClosed.algebraMap_surjective_of_isIntegral (k := k) (⟨x, hx⟩ : L)
state_before: case intro
k✝ : Type u
inst✝⁵ : Field k✝
k : Type u_1
K : Type u_2
inst✝⁴ : Field k
inst✝³ : Field K
inst✝² : IsAlgClosed k
inst✝¹ : Algebra k K
L : IntermediateField k K
inst✝ : Algebra.IsAlgebraic k ↥L
x : K
hx : x ∈ L
y : k
hy : (algebraMap k ↥L) y = ⟨x, hx⟩
⊢ x ∈ ⊥
state_after: no goals
tactic: exact ⟨y, congr_arg (algebraMap L K) hy⟩
Theorem: Finset.exists_mem_ne
File: Mathlib/Data/Finset/Card.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
R : Type u_3
s t u : Finset α
f : α → β
n : ℕ
hs : 1 < s.card
a : α
⊢ ∃ b ∈ s, b ≠ a
state_after: α : Type u_1
β : Type u_2
R : Type u_3
s t u : Finset α
f : α → β
n : ℕ
hs : 1 < s.card
a : α
this : Nonempty α
⊢ ∃ b ∈ s, b ≠ a
tactic: have : Nonempty α := ⟨a⟩
state_before: α : Type u_1
β : Type u_2
R : Type u_3
s t u : Finset α
f : α → β
n : ℕ
hs : 1 < s.card
a : α
this : Nonempty α
⊢ ∃ b ∈ s, b ≠ a
state_after: α : Type u_1
β : Type u_2
R : Type u_3
s t u : Finset α
f : α → β
n : ℕ
hs : 1 < s.card
a : α
this✝ : Nonempty α
this : ∀ b ∈ s, b = a
⊢ False
tactic: by_contra!
state_before: α : Type u_1
β : Type u_2
R : Type u_3
s t u : Finset α
f : α → β
n : ℕ
hs : 1 < s.card
a : α
this✝ : Nonempty α
this : ∀ b ∈ s, b = a
⊢ False
state_after: no goals
tactic: exact hs.not_le (card_le_one_iff_subset_singleton.2 ⟨a, subset_singleton_iff'.2 this⟩)
Theorem: ZMod.val_inv_mul
File: Mathlib/Data/ZMod/Basic.lean

Proof steps:
state_before: m n : ℕ
hmn : m.Coprime n
⊢ ↑(↑m)⁻¹.val * ↑m = 1
state_after: no goals
tactic: rw [mul_comm, mul_val_inv hmn]
Theorem: ULift.isClosed_iff
File: Mathlib/Topology/Constructions.lean

Proof steps:
state_before: X : Type u
Y : Type v
Z : Type u_1
W : Type u_2
ε : Type u_3
ζ : Type u_4
inst✝ : TopologicalSpace X
s : Set (ULift.{v, u} X)
⊢ IsClosed s ↔ IsClosed (up ⁻¹' s)
state_after: no goals
tactic: rw [← isOpen_compl_iff, ← isOpen_compl_iff, isOpen_iff, preimage_compl]
Theorem: partialSups_eq_sup_range
File: Mathlib/Order/PartialSups.lean

Proof steps:
state_before: α : Type u_1
inst✝¹ : SemilatticeSup α
inst✝ : OrderBot α
f : ℕ → α
n : ℕ
x✝ : α
⊢ (partialSups f) n ≤ x✝ ↔ (Finset.range (n + 1)).sup f ≤ x✝
state_after: no goals
tactic: simp [Nat.lt_succ_iff]
Theorem: Real.summable_one_div_int_add_rpow
File: Mathlib/Analysis/PSeries.lean

Proof steps:
state_before: a s : ℝ
⊢ (Summable fun n => 1 / |↑n + a| ^ s) ↔ 1 < s
state_after: no goals
tactic: simp_rw [summable_int_iff_summable_nat_and_neg, ← abs_neg (↑(-_ : ℤ) + a), neg_add,
    Int.cast_neg, neg_neg, Int.cast_natCast, summable_one_div_nat_add_rpow, and_self]
Theorem: Dioph.ne_dioph
File: Mathlib/NumberTheory/Dioph.lean

Proof steps:
state_before: α β : Type
n : ℕ
f g : (α → ℕ) → ℕ
df : DiophFn f
dg : DiophFn g
v : α → ℕ
⊢ v ∈ {v | f v < g v} ∪ {v | g v < f v} ↔ v ∈ {v | f v ≠ g v}
state_after: α β : Type
n : ℕ
f g : (α → ℕ) → ℕ
df : DiophFn f
dg : DiophFn g
v : α → ℕ
⊢ v ∈ {v | f v < g v} ∪ {v | g v < f v} ↔ ¬f v = g v
tactic: dsimp
state_before: α β : Type
n : ℕ
f g : (α → ℕ) → ℕ
df : DiophFn f
dg : DiophFn g
v : α → ℕ
⊢ v ∈ {v | f v < g v} ∪ {v | g v < f v} ↔ ¬f v = g v
state_after: no goals
tactic: exact lt_or_lt_iff_ne (α := ℕ)
Theorem: Real.Angle.neg_pi_lt_toReal
File: Mathlib/Analysis/SpecialFunctions/Trigonometric/Angle.lean

Proof steps:
state_before: θ : Angle
⊢ -π < θ.toReal
state_after: case h
x✝ : ℝ
⊢ -π < (↑x✝).toReal
tactic: induction θ using Real.Angle.induction_on
state_before: case h
x✝ : ℝ
⊢ -π < (↑x✝).toReal
state_after: no goals
tactic: exact left_lt_toIocMod _ _ _