ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: integral_rpow
File: Mathlib/Analysis/SpecialFunctions/Integrals.lean

Proof steps:
state_before: a b : ℝ
n : ℕ
r : ℝ
h : -1 < r ∨ r ≠ -1 ∧ 0 ∉ [[a, b]]
h' : -1 < (↑r).re ∨ ↑r ≠ -1 ∧ 0 ∉ [[a, b]]
⊢ ∫ (x : ℝ) in a..b, x ^ r = (b ^ (r + 1) - a ^ (r + 1)) / (r + 1)
state_after: a b : ℝ
n : ℕ
r : ℝ
h : -1 < r ∨ r ≠ -1 ∧ 0 ∉ [[a, b]]
h' : -1 < (↑r).re ∨ ↑r ≠ -1 ∧ 0 ∉ [[a, b]]
this : ∫ (x : ℝ) in a..b, ↑x ^ ↑r = (↑b ^ (↑r + 1) - ↑a ^ (↑r + 1)) / (↑r + 1)
⊢ ∫ (x : ℝ) in a..b, x ^ r = (b ^ (r + 1) - a ^ (r + 1)) / (r + 1)
tactic: have :
    (∫ x in a..b, (x : ℂ) ^ (r : ℂ)) = ((b : ℂ) ^ (r + 1 : ℂ) - (a : ℂ) ^ (r + 1 : ℂ)) / (r + 1) :=
    integral_cpow h'
state_before: a b : ℝ
n : ℕ
r : ℝ
h : -1 < r ∨ r ≠ -1 ∧ 0 ∉ [[a, b]]
h' : -1 < (↑r).re ∨ ↑r ≠ -1 ∧ 0 ∉ [[a, b]]
this : ∫ (x : ℝ) in a..b, ↑x ^ ↑r = (↑b ^ (↑r + 1) - ↑a ^ (↑r + 1)) / (↑r + 1)
⊢ ∫ (x : ℝ) in a..b, x ^ r = (b ^ (r + 1) - a ^ (r + 1)) / (r + 1)
state_after: a b : ℝ
n : ℕ
r : ℝ
h : -1 < r ∨ r ≠ -1 ∧ 0 ∉ [[a, b]]
h' : -1 < (↑r).re ∨ ↑r ≠ -1 ∧ 0 ∉ [[a, b]]
this : (∫ (x : ℝ) in a..b, ↑x ^ ↑r).re = ((↑b ^ (↑r + 1) - ↑a ^ (↑r + 1)) / (↑r + 1)).re
⊢ ∫ (x : ℝ) in a..b, x ^ r = (b ^ (r + 1) - a ^ (r + 1)) / (r + 1)
tactic: apply_fun Complex.re at this
state_before: a b : ℝ
n : ℕ
r : ℝ
h : -1 < r ∨ r ≠ -1 ∧ 0 ∉ [[a, b]]
h' : -1 < (↑r).re ∨ ↑r ≠ -1 ∧ 0 ∉ [[a, b]]
this : (∫ (x : ℝ) in a..b, ↑x ^ ↑r).re = ((↑b ^ (↑r + 1) - ↑a ^ (↑r + 1)) / (↑r + 1)).re
⊢ ∫ (x : ℝ) in a..b, x ^ r = (b ^ (r + 1) - a ^ (r + 1)) / (r + 1)
state_after: case h.e'_2
a b : ℝ
n : ℕ
r : ℝ
h : -1 < r ∨ r ≠ -1 ∧ 0 ∉ [[a, b]]
h' : -1 < (↑r).re ∨ ↑r ≠ -1 ∧ 0 ∉ [[a, b]]
this : (∫ (x : ℝ) in a..b, ↑x ^ ↑r).re = ((↑b ^ (↑r + 1) - ↑a ^ (↑r + 1)) / (↑r + 1)).re
⊢ ∫ (x : ℝ) in a..b, x ^ r = (∫ (x : ℝ) in a..b, ↑x ^ ↑r).re

case h.e'_3
a b : ℝ
n : ℕ
r : ℝ
h : -1 < r ∨ r ≠ -1 ∧ 0 ∉ [[a, b]]
h' : -1 < (↑r).re ∨ ↑r ≠ -1 ∧ 0 ∉ [[a, b]]
this : (∫ (x : ℝ) in a..b, ↑x ^ ↑r).re = ((↑b ^ (↑r + 1) - ↑a ^ (↑r + 1)) / (↑r + 1)).re
⊢ (b ^ (r + 1) - a ^ (r + 1)) / (r + 1) = ((↑b ^ (↑r + 1) - ↑a ^ (↑r + 1)) / (↑r + 1)).re
tactic: convert this
Theorem: Int.Ioc_filter_dvd_card
File: Mathlib/Data/Int/CardIntervalMod.lean

Proof steps:
state_before: a b r : ℤ
hr : 0 < r
⊢ ↑(filter (fun x => r ∣ x) (Ioc a b)).card = max (⌊↑b / ↑r⌋ - ⌊↑a / ↑r⌋) 0
state_after: no goals
tactic: rw [Ioc_filter_dvd_eq _ _ hr, card_map, card_Ioc, toNat_eq_max]
Theorem: CategoryTheory.Subgroupoid.mem_top_objs
File: Mathlib/CategoryTheory/Groupoid/Subgroupoid.lean

Proof steps:
state_before: C : Type u
inst✝ : Groupoid C
S : Subgroupoid C
c : C
⊢ c ∈ ⊤.objs
state_after: C : Type u
inst✝ : Groupoid C
S : Subgroupoid C
c : C
⊢ univ.Nonempty
tactic: dsimp [Top.top, objs]
state_before: C : Type u
inst✝ : Groupoid C
S : Subgroupoid C
c : C
⊢ univ.Nonempty
state_after: no goals
tactic: simp only [univ_nonempty]
Theorem: AffineMap.homothety_zero
File: Mathlib/LinearAlgebra/AffineSpace/AffineMap.lean

Proof steps:
state_before: R : Type u_1
k : Type u_2
V1 : Type u_3
P1 : Type u_4
V2 : Type u_5
P2 : Type u_6
V3 : Type u_7
P3 : Type u_8
inst✝⁵ : CommRing k
inst✝⁴ : AddCommGroup V1
inst✝³ : AffineSpace V1 P1
inst✝² : AddCommGroup V2
inst✝¹ : Module k V1
inst✝ : Module k V2
c : P1
⊢ homothety c 0 = const k P1 c
state_after: case h
R : Type u_1
k : Type u_2
V1 : Type u_3
P1 : Type u_4
V2 : Type u_5
P2 : Type u_6
V3 : Type u_7
P3 : Type u_8
inst✝⁵ : CommRing k
inst✝⁴ : AddCommGroup V1
inst✝³ : AffineSpace V1 P1
inst✝² : AddCommGroup V2
inst✝¹ : Module k V1
inst✝ : Module k V2
c p : P1
⊢ (homothety c 0) p = (const k P1 c) p
tactic: ext p
state_before: case h
R : Type u_1
k : Type u_2
V1 : Type u_3
P1 : Type u_4
V2 : Type u_5
P2 : Type u_6
V3 : Type u_7
P3 : Type u_8
inst✝⁵ : CommRing k
inst✝⁴ : AddCommGroup V1
inst✝³ : AffineSpace V1 P1
inst✝² : AddCommGroup V2
inst✝¹ : Module k V1
inst✝ : Module k V2
c p : P1
⊢ (homothety c 0) p = (const k P1 c) p
state_after: no goals
tactic: simp [homothety_apply]
Theorem: Set.Icc.addNSMul_eq_right
File: Mathlib/Topology/UnitInterval.lean

Proof steps:
state_before: α : Type u_1
inst✝¹ : LinearOrderedAddCommGroup α
a b c d : α
h : a ≤ b
δ : α
inst✝ : Archimedean α
hδ : 0 < δ
⊢ ∃ m, ∀ n ≥ m, ↑(addNSMul h δ n) = b
state_after: case intro
α : Type u_1
inst✝¹ : LinearOrderedAddCommGroup α
a b c d : α
h : a ≤ b
δ : α
inst✝ : Archimedean α
hδ : 0 < δ
m : ℕ
hm : b - a ≤ m • δ
⊢ ∃ m, ∀ n ≥ m, ↑(addNSMul h δ n) = b
tactic: obtain ⟨m, hm⟩ := Archimedean.arch (b - a) hδ
state_before: case intro
α : Type u_1
inst✝¹ : LinearOrderedAddCommGroup α
a b c d : α
h : a ≤ b
δ : α
inst✝ : Archimedean α
hδ : 0 < δ
m : ℕ
hm : b - a ≤ m • δ
⊢ ∃ m, ∀ n ≥ m, ↑(addNSMul h δ n) = b
state_after: case intro
α : Type u_1
inst✝¹ : LinearOrderedAddCommGroup α
a b c d : α
h : a ≤ b
δ : α
inst✝ : Archimedean α
hδ : 0 < δ
m : ℕ
hm : b - a ≤ m • δ
n : ℕ
hn : n ≥ m
⊢ ↑(addNSMul h δ n) = b
tactic: refine ⟨m, fun n hn ↦ ?_⟩
state_before: case intro
α : Type u_1
inst✝¹ : LinearOrderedAddCommGroup α
a b c d : α
h : a ≤ b
δ : α
inst✝ : Archimedean α
hδ : 0 < δ
m : ℕ
hm : b - a ≤ m • δ
n : ℕ
hn : n ≥ m
⊢ ↑(addNSMul h δ n) = b
state_after: case intro
α : Type u_1
inst✝¹ : LinearOrderedAddCommGroup α
a b c d : α
h : a ≤ b
δ : α
inst✝ : Archimedean α
hδ : 0 < δ
m : ℕ
hm : b - a ≤ m • δ
n : ℕ
hn : n ≥ m
⊢ b ≤ n • δ + a
tactic: rw [addNSMul, coe_projIcc, add_comm, min_eq_left_iff.mpr, max_eq_right h]
state_before: case intro
α : Type u_1
inst✝¹ : LinearOrderedAddCommGroup α
a b c d : α
h : a ≤ b
δ : α
inst✝ : Archimedean α
hδ : 0 < δ
m : ℕ
hm : b - a ≤ m • δ
n : ℕ
hn : n ≥ m
⊢ b ≤ n • δ + a
state_after: no goals
tactic: exact sub_le_iff_le_add.mp (hm.trans <| nsmul_le_nsmul_left hδ.le hn)
Theorem: Function.iterate_comm
File: Mathlib/Logic/Function/Iterate.lean

Proof steps:
state_before: α : Type u
β : Type v
f✝ : α → α
m✝ n✝ : ℕ
a : α
f : α → α
m n : ℕ
⊢ f^[n * m] = f^[m * n]
state_after: no goals
tactic: rw [Nat.mul_comm]
Theorem: List.Ico.pred_singleton
File: Mathlib/Data/List/Intervals.lean

Proof steps:
state_before: m : ℕ
h : 0 < m
⊢ Ico (m - 1) m = [m - 1]
state_after: m : ℕ
h : 0 < m
⊢ range' (m - 1) (m - (m - 1)) = [m - 1]
tactic: dsimp [Ico]
state_before: m : ℕ
h : 0 < m
⊢ range' (m - 1) (m - (m - 1)) = [m - 1]
state_after: m : ℕ
h : 0 < m
⊢ range' (m - 1) (succ 0) = [m - 1]
tactic: rw [Nat.sub_sub_self (succ_le_of_lt h)]
state_before: m : ℕ
h : 0 < m
⊢ range' (m - 1) (succ 0) = [m - 1]
state_after: no goals
tactic: simp [← Nat.one_eq_succ_zero]
Theorem: Finset.sup_bot
File: Mathlib/Data/Finset/Lattice.lean

Proof steps:
state_before: F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
ι : Type u_5
κ : Type u_6
inst✝¹ : SemilatticeSup α
inst✝ : OrderBot α
s✝ s₁ s₂ : Finset β
f g : β → α
a : α
s : Finset β
⊢ (s.sup fun x => ⊥) = ⊥
state_after: case inl
F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
ι : Type u_5
κ : Type u_6
inst✝¹ : SemilatticeSup α
inst✝ : OrderBot α
s s₁ s₂ : Finset β
f g : β → α
a : α
⊢ (∅.sup fun x => ⊥) = ⊥

case inr
F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
ι : Type u_5
κ : Type u_6
inst✝¹ : SemilatticeSup α
inst✝ : OrderBot α
s✝ s₁ s₂ : Finset β
f g : β → α
a : α
s : Finset β
hs : s.Nonempty
⊢ (s.sup fun x => ⊥) = ⊥
tactic: obtain rfl | hs := s.eq_empty_or_nonempty
Theorem: Ideal.map_spanNorm
File: Mathlib/RingTheory/Ideal/Norm.lean

Proof steps:
state_before: R : Type u_1
inst✝³ : CommRing R
S : Type u_2
inst✝² : CommRing S
inst✝¹ : Algebra R S
I : Ideal S
T : Type u_3
inst✝ : CommRing T
f : R →+* T
⊢ map f (spanNorm R I) = span (⇑f ∘ ⇑(Algebra.norm R) '' ↑I)
state_after: R : Type u_1
inst✝³ : CommRing R
S : Type u_2
inst✝² : CommRing S
inst✝¹ : Algebra R S
I : Ideal S
T : Type u_3
inst✝ : CommRing T
f : R →+* T
⊢ span ((fun x => f ((Algebra.norm R) x)) '' ↑I) = span (⇑f ∘ ⇑(Algebra.norm R) '' ↑I)
tactic: rw [spanNorm, map_span, Set.image_image]
state_before: R : Type u_1
inst✝³ : CommRing R
S : Type u_2
inst✝² : CommRing S
inst✝¹ : Algebra R S
I : Ideal S
T : Type u_3
inst✝ : CommRing T
f : R →+* T
⊢ span ((fun x => f ((Algebra.norm R) x)) '' ↑I) = span (⇑f ∘ ⇑(Algebra.norm R) '' ↑I)
state_after: no goals
tactic: rfl
Theorem: TwoSidedIdeal.neg_mem
File: Mathlib/RingTheory/TwoSidedIdeal/Basic.lean

Proof steps:
state_before: R : Type u_1
inst✝ : NonUnitalNonAssocRing R
I : TwoSidedIdeal R
x : R
hx : x ∈ I
⊢ -x ∈ I
state_after: no goals
tactic: simpa using I.ringCon.neg hx
Theorem: Int.le_induction
File: Mathlib/Data/Int/Defs.lean

Proof steps:
state_before: a b c d m✝ n✝ : ℤ
P : ℤ → Prop
m : ℤ
h0 : P m
h1 : ∀ (n : ℤ), m ≤ n → P n → P (n + 1)
n : ℤ
⊢ m ≤ n → P n
state_after: case refine_1
a b c d m✝ n✝ : ℤ
P : ℤ → Prop
m : ℤ
h0 : P m
h1 : ∀ (n : ℤ), m ≤ n → P n → P (n + 1)
n : ℤ
⊢ m ≤ m → P m

case refine_2
a b c d m✝ n✝ : ℤ
P : ℤ → Prop
m : ℤ
h0 : P m
h1 : ∀ (n : ℤ), m ≤ n → P n → P (n + 1)
n : ℤ
⊢ ∀ (k : ℤ), m ≤ k → (m ≤ k → P k) → m ≤ k + 1 → P (k + 1)

case refine_3
a b c d m✝ n✝ : ℤ
P : ℤ → Prop
m : ℤ
h0 : P m
h1 : ∀ (n : ℤ), m ≤ n → P n → P (n + 1)
n : ℤ
⊢ ∀ (k : ℤ), k ≤ m → (m ≤ k → P k) → m ≤ k - 1 → P (k - 1)
tactic: refine Int.inductionOn' n m ?_ ?_ ?_
Theorem: MeasureTheory.IsAddFundamentalDomain.measure_addFundamentalFrontier
File: Mathlib/MeasureTheory/Group/FundamentalDomain.lean

Proof steps:
state_before: G : Type u_1
H : Type u_2
α : Type u_3
β : Type u_4
E : Type u_5
inst✝³ : Countable G
inst✝² : Group G
inst✝¹ : MulAction G α
inst✝ : MeasurableSpace α
μ : Measure α
s : Set α
hs : IsFundamentalDomain G s μ
⊢ μ (fundamentalFrontier G s) = 0
state_after: no goals
tactic: simpa only [fundamentalFrontier, iUnion₂_inter, one_smul, measure_iUnion_null_iff, inter_comm s,
    Function.onFun] using fun g (hg : g ≠ 1) => hs.aedisjoint hg
Theorem: AlgebraicGeometry.morphismRestrict_ι
File: Mathlib/AlgebraicGeometry/Restrict.lean

Proof steps:
state_before: C : Type u₁
inst✝ : Category.{v, u₁} C
X Y : Scheme
f : X ⟶ Y
U : Y.Opens
⊢ f ∣_ U ≫ U.ι = (f ⁻¹ᵁ U).ι ≫ f
state_after: C : Type u₁
inst✝ : Category.{v, u₁} C
X Y : Scheme
f : X ⟶ Y
U : Y.Opens
⊢ ((pullbackRestrictIsoRestrict f U).inv ≫ pullback.snd f U.ι) ≫ U.ι = (f ⁻¹ᵁ U).ι ≫ f
tactic: delta morphismRestrict
state_before: C : Type u₁
inst✝ : Category.{v, u₁} C
X Y : Scheme
f : X ⟶ Y
U : Y.Opens
⊢ ((pullbackRestrictIsoRestrict f U).inv ≫ pullback.snd f U.ι) ≫ U.ι = (f ⁻¹ᵁ U).ι ≫ f
state_after: no goals
tactic: rw [Category.assoc, pullback.condition.symm, pullbackRestrictIsoRestrict_inv_fst_assoc]
Theorem: CategoryTheory.Square.toArrowArrowFunctor'_obj_hom_right
File: Mathlib/CategoryTheory/Square.lean

Proof steps:
state_before: C : Type u
inst✝¹ : Category.{v, u} C
D : Type u'
inst✝ : Category.{v', u'} D
X✝ Y✝ : Square C
φ : X✝ ⟶ Y✝
⊢ Arrow.homMk ⋯ ≫ ((fun sq => Arrow.mk (Arrow.homMk ⋯)) Y✝).hom =
    ((fun sq => Arrow.mk (Arrow.homMk ⋯)) X✝).hom ≫ Arrow.homMk ⋯
state_after: no goals
tactic: aesop_cat
Theorem: Real.cos_sq_add_sin_sq
File: Mathlib/Data/Complex/Exponential.lean

Proof steps:
state_before: x y : ℝ
⊢ cos x ^ 2 + sin x ^ 2 = 1
state_after: no goals
tactic: rw [add_comm, sin_sq_add_cos_sq]
Theorem: AddSubgroup.nontrivial_iff_exists_ne_zero
File: Mathlib/Algebra/Group/Subgroup/Basic.lean

Proof steps:
state_before: G : Type u_1
G' : Type u_2
G'' : Type u_3
inst✝³ : Group G
inst✝² : Group G'
inst✝¹ : Group G''
A : Type u_4
inst✝ : AddGroup A
H✝ K H : Subgroup G
⊢ Nontrivial ↥H ↔ ∃ x ∈ H, x ≠ 1
state_after: G : Type u_1
G' : Type u_2
G'' : Type u_3
inst✝³ : Group G
inst✝² : Group G'
inst✝¹ : Group G''
A : Type u_4
inst✝ : AddGroup A
H✝ K H : Subgroup G
⊢ (∃ y, ∃ (_ : y ∈ H), y ≠ ↑1) ↔ ∃ x ∈ H, x ≠ 1
tactic: rw [Subtype.nontrivial_iff_exists_ne (fun x => x ∈ H) (1 : H)]
state_before: G : Type u_1
G' : Type u_2
G'' : Type u_3
inst✝³ : Group G
inst✝² : Group G'
inst✝¹ : Group G''
A : Type u_4
inst✝ : AddGroup A
H✝ K H : Subgroup G
⊢ (∃ y, ∃ (_ : y ∈ H), y ≠ ↑1) ↔ ∃ x ∈ H, x ≠ 1
state_after: no goals
tactic: simp
Theorem: ContinuousLinearMap.coe_toContinuousLinearEquivOfDetNeZero
File: Mathlib/Topology/Algebra/Module/FiniteDimension.lean

Proof steps:
state_before: 𝕜 : Type u
hnorm : NontriviallyNormedField 𝕜
E : Type v
inst✝¹⁷ : AddCommGroup E
inst✝¹⁶ : Module 𝕜 E
inst✝¹⁵ : TopologicalSpace E
inst✝¹⁴ : TopologicalAddGroup E
inst✝¹³ : ContinuousSMul 𝕜 E
F : Type w
inst✝¹² : AddCommGroup F
inst✝¹¹ : Module 𝕜 F
inst✝¹⁰ : TopologicalSpace F
inst✝⁹ : TopologicalAddGroup F
inst✝⁸ : ContinuousSMul 𝕜 F
F' : Type x
inst✝⁷ : AddCommGroup F'
inst✝⁶ : Module 𝕜 F'
inst✝⁵ : TopologicalSpace F'
inst✝⁴ : TopologicalAddGroup F'
inst✝³ : ContinuousSMul 𝕜 F'
inst✝² : CompleteSpace 𝕜
inst✝¹ : T2Space E
inst✝ : FiniteDimensional 𝕜 E
f : E →L[𝕜] E
hf : f.det ≠ 0
⊢ ↑(f.toContinuousLinearEquivOfDetNeZero hf) = f
state_after: case h
𝕜 : Type u
hnorm : NontriviallyNormedField 𝕜
E : Type v
inst✝¹⁷ : AddCommGroup E
inst✝¹⁶ : Module 𝕜 E
inst✝¹⁵ : TopologicalSpace E
inst✝¹⁴ : TopologicalAddGroup E
inst✝¹³ : ContinuousSMul 𝕜 E
F : Type w
inst✝¹² : AddCommGroup F
inst✝¹¹ : Module 𝕜 F
inst✝¹⁰ : TopologicalSpace F
inst✝⁹ : TopologicalAddGroup F
inst✝⁸ : ContinuousSMul 𝕜 F
F' : Type x
inst✝⁷ : AddCommGroup F'
inst✝⁶ : Module 𝕜 F'
inst✝⁵ : TopologicalSpace F'
inst✝⁴ : TopologicalAddGroup F'
inst✝³ : ContinuousSMul 𝕜 F'
inst✝² : CompleteSpace 𝕜
inst✝¹ : T2Space E
inst✝ : FiniteDimensional 𝕜 E
f : E →L[𝕜] E
hf : f.det ≠ 0
x : E
⊢ ↑(f.toContinuousLinearEquivOfDetNeZero hf) x = f x
tactic: ext x
state_before: case h
𝕜 : Type u
hnorm : NontriviallyNormedField 𝕜
E : Type v
inst✝¹⁷ : AddCommGroup E
inst✝¹⁶ : Module 𝕜 E
inst✝¹⁵ : TopologicalSpace E
inst✝¹⁴ : TopologicalAddGroup E
inst✝¹³ : ContinuousSMul 𝕜 E
F : Type w
inst✝¹² : AddCommGroup F
inst✝¹¹ : Module 𝕜 F
inst✝¹⁰ : TopologicalSpace F
inst✝⁹ : TopologicalAddGroup F
inst✝⁸ : ContinuousSMul 𝕜 F
F' : Type x
inst✝⁷ : AddCommGroup F'
inst✝⁶ : Module 𝕜 F'
inst✝⁵ : TopologicalSpace F'
inst✝⁴ : TopologicalAddGroup F'
inst✝³ : ContinuousSMul 𝕜 F'
inst✝² : CompleteSpace 𝕜
inst✝¹ : T2Space E
inst✝ : FiniteDimensional 𝕜 E
f : E →L[𝕜] E
hf : f.det ≠ 0
x : E
⊢ ↑(f.toContinuousLinearEquivOfDetNeZero hf) x = f x
state_after: no goals
tactic: rfl
Theorem: ZeroAtInftyContinuousMap.ContinuousMap.liftZeroAtInfty_apply_toFun
File: Mathlib/Topology/ContinuousFunction/ZeroAtInfty.lean

Proof steps:
state_before: F : Type u_1
α : Type u
β : Type v
γ : Type w
inst✝⁵ : TopologicalSpace α
inst✝⁴ : TopologicalSpace β
inst✝³ : Zero β
inst✝² : FunLike F α β
inst✝¹ : ZeroAtInftyContinuousMapClass F α β
inst✝ : CompactSpace α
f : C(α, β)
⊢ Tendsto { toFun := ⇑f, continuous_toFun := ⋯ }.toFun (cocompact α) (𝓝 0)
state_after: no goals
tactic: simp
state_before: F : Type u_1
α : Type u
β : Type v
γ : Type w
inst✝⁵ : TopologicalSpace α
inst✝⁴ : TopologicalSpace β
inst✝³ : Zero β
inst✝² : FunLike F α β
inst✝¹ : ZeroAtInftyContinuousMapClass F α β
inst✝ : CompactSpace α
f : C(α, β)
⊢ (fun f => ↑f) ((fun f => { toFun := ⇑f, continuous_toFun := ⋯, zero_at_infty' := ⋯ }) f) = f
state_after: case h
F : Type u_1
α : Type u
β : Type v
γ : Type w
inst✝⁵ : TopologicalSpace α
inst✝⁴ : TopologicalSpace β
inst✝³ : Zero β
inst✝² : FunLike F α β
inst✝¹ : ZeroAtInftyContinuousMapClass F α β
inst✝ : CompactSpace α
f : C(α, β)
a✝ : α
⊢ ((fun f => ↑f) ((fun f => { toFun := ⇑f, continuous_toFun := ⋯, zero_at_infty' := ⋯ }) f)) a✝ = f a✝
tactic: ext
state_before: case h
F : Type u_1
α : Type u
β : Type v
γ : Type w
inst✝⁵ : TopologicalSpace α
inst✝⁴ : TopologicalSpace β
inst✝³ : Zero β
inst✝² : FunLike F α β
inst✝¹ : ZeroAtInftyContinuousMapClass F α β
inst✝ : CompactSpace α
f : C(α, β)
a✝ : α
⊢ ((fun f => ↑f) ((fun f => { toFun := ⇑f, continuous_toFun := ⋯, zero_at_infty' := ⋯ }) f)) a✝ = f a✝
state_after: no goals
tactic: rfl
state_before: F : Type u_1
α : Type u
β : Type v
γ : Type w
inst✝⁵ : TopologicalSpace α
inst✝⁴ : TopologicalSpace β
inst✝³ : Zero β
inst✝² : FunLike F α β
inst✝¹ : ZeroAtInftyContinuousMapClass F α β
inst✝ : CompactSpace α
f : α →C₀ β
⊢ (fun f => { toFun := ⇑f, continuous_toFun := ⋯, zero_at_infty' := ⋯ }) ((fun f => ↑f) f) = f
state_after: case h
F : Type u_1
α : Type u
β : Type v
γ : Type w
inst✝⁵ : TopologicalSpace α
inst✝⁴ : TopologicalSpace β
inst✝³ : Zero β
inst✝² : FunLike F α β
inst✝¹ : ZeroAtInftyContinuousMapClass F α β
inst✝ : CompactSpace α
f : α →C₀ β
x✝ : α
⊢ ((fun f => { toFun := ⇑f, continuous_toFun := ⋯, zero_at_infty' := ⋯ }) ((fun f => ↑f) f)) x✝ = f x✝
tactic: ext
state_before: case h
F : Type u_1
α : Type u
β : Type v
γ : Type w
inst✝⁵ : TopologicalSpace α
inst✝⁴ : TopologicalSpace β
inst✝³ : Zero β
inst✝² : FunLike F α β
inst✝¹ : ZeroAtInftyContinuousMapClass F α β
inst✝ : CompactSpace α
f : α →C₀ β
x✝ : α
⊢ ((fun f => { toFun := ⇑f, continuous_toFun := ⋯, zero_at_infty' := ⋯ }) ((fun f => ↑f) f)) x✝ = f x✝
state_after: no goals
tactic: rfl
Theorem: WeierstrassCurve.Affine.eval_negPolynomial
File: Mathlib/AlgebraicGeometry/EllipticCurve/Affine.lean

Proof steps:
state_before: R : Type u
inst✝ : CommRing R
W : Affine R
x y : R
⊢ evalEval x y W.negPolynomial = W.negY x y
state_after: R : Type u
inst✝ : CommRing R
W : Affine R
x y : R
⊢ evalEval x y (-Y - C (C W.a₁ * X + C W.a₃)) = -y - (W.a₁ * x + W.a₃)
tactic: rw [negY, sub_sub, negPolynomial]
state_before: R : Type u
inst✝ : CommRing R
W : Affine R
x y : R
⊢ evalEval x y (-Y - C (C W.a₁ * X + C W.a₃)) = -y - (W.a₁ * x + W.a₃)
state_after: no goals
tactic: eval_simp
Theorem: Partrec.option_some_iff
File: Mathlib/Computability/Partrec.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 σ
f : α →. σ
h : Partrec fun a => Part.map Option.some (f a)
n : ℕ
⊢ (do
      let n ← (↑(decode n)).bind fun a => Part.map encode ((fun a => Part.map Option.some (f a)) a)
      ↑n.ppred) =
    (↑(decode n)).bind fun a => Part.map encode (f a)
state_after: no goals
tactic: simp [Part.bind_assoc, ← Function.comp_apply (f := Part.some) (g := encode), bind_some_eq_map,
        -Function.comp_apply]
Theorem: FirstOrder.Ring.realize_termOfFreeCommRing
File: Mathlib/ModelTheory/Algebra/Ring/FreeCommRing.lean

Proof steps:
state_before: α : Type u_1
R : Type u_2
inst✝¹ : CommRing R
inst✝ : CompatibleRing R
p : FreeCommRing α
v : α → R
⊢ Term.realize v (termOfFreeCommRing p) = (FreeCommRing.lift v) p
state_after: α : Type u_1
R : Type u_2
inst✝¹ : CommRing R
inst✝ : CompatibleRing R
p : FreeCommRing α
v : α → R
x✝ : CompatibleRing (FreeCommRing α) := compatibleRingOfRing (FreeCommRing α)
⊢ Term.realize v (termOfFreeCommRing p) = (FreeCommRing.lift v) p
tactic: let _ := compatibleRingOfRing (FreeCommRing α)
state_before: α : Type u_1
R : Type u_2
inst✝¹ : CommRing R
inst✝ : CompatibleRing R
p : FreeCommRing α
v : α → R
x✝ : CompatibleRing (FreeCommRing α) := compatibleRingOfRing (FreeCommRing α)
⊢ Term.realize v (termOfFreeCommRing p) = (FreeCommRing.lift v) p
state_after: α : Type u_1
R : Type u_2
inst✝¹ : CommRing R
inst✝ : CompatibleRing R
p : FreeCommRing α
v : α → R
x✝ : CompatibleRing (FreeCommRing α) := compatibleRingOfRing (FreeCommRing α)
⊢ Term.realize v (Classical.choose ⋯) = (FreeCommRing.lift v) p
tactic: rw [termOfFreeCommRing]
state_before: α : Type u_1
R : Type u_2
inst✝¹ : CommRing R
inst✝ : CompatibleRing R
p : FreeCommRing α
v : α → R
x✝ : CompatibleRing (FreeCommRing α) := compatibleRingOfRing (FreeCommRing α)
⊢ Term.realize v (Classical.choose ⋯) = (FreeCommRing.lift v) p
state_after: α : Type u_1
R : Type u_2
inst✝¹ : CommRing R
inst✝ : CompatibleRing R
p : FreeCommRing α
v : α → R
x✝ : CompatibleRing (FreeCommRing α) := compatibleRingOfRing (FreeCommRing α)
⊢ Term.realize v (Classical.choose ⋯) = (FreeCommRing.lift v) (Term.realize FreeCommRing.of (Classical.choose ⋯))
tactic: conv_rhs => rw [← Classical.choose_spec (exists_term_realize_eq_freeCommRing p)]
state_before: α : Type u_1
R : Type u_2
inst✝¹ : CommRing R
inst✝ : CompatibleRing R
p : FreeCommRing α
v : α → R
x✝ : CompatibleRing (FreeCommRing α) := compatibleRingOfRing (FreeCommRing α)
⊢ Term.realize v (Classical.choose ⋯) = (FreeCommRing.lift v) (Term.realize FreeCommRing.of (Classical.choose ⋯))
state_after: no goals
tactic: induction Classical.choose (exists_term_realize_eq_freeCommRing p) with
  | var _ => simp
  | func f a ih =>
    cases f <;>
    simp [ih]
Theorem: UniformCauchySeqOn.uniformCauchySeqOnFilter
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 : ι → α
hF : UniformCauchySeqOn F p s
⊢ UniformCauchySeqOnFilter F p (𝓟 s)
state_after: no goals
tactic: rwa [← uniformCauchySeqOn_iff_uniformCauchySeqOnFilter]
Theorem: Associates.count_pow
File: Mathlib/RingTheory/UniqueFactorizationDomain.lean

Proof steps:
state_before: α : Type u_1
inst✝⁵ : CancelCommMonoidWithZero α
inst✝⁴ : UniqueFactorizationMonoid α
inst✝³ : DecidableEq (Associates α)
inst✝² : (p : Associates α) → Decidable (Irreducible p)
inst✝¹ : Nontrivial α
inst✝ : DecidableEq (Associates α)
a : Associates α
ha : a ≠ 0
p : Associates α
hp : Irreducible p
k : ℕ
⊢ p.count (a ^ k).factors = k * p.count a.factors
state_after: case zero
α : Type u_1
inst✝⁵ : CancelCommMonoidWithZero α
inst✝⁴ : UniqueFactorizationMonoid α
inst✝³ : DecidableEq (Associates α)
inst✝² : (p : Associates α) → Decidable (Irreducible p)
inst✝¹ : Nontrivial α
inst✝ : DecidableEq (Associates α)
a : Associates α
ha : a ≠ 0
p : Associates α
hp : Irreducible p
⊢ p.count (a ^ 0).factors = 0 * p.count a.factors

case succ
α : Type u_1
inst✝⁵ : CancelCommMonoidWithZero α
inst✝⁴ : UniqueFactorizationMonoid α
inst✝³ : DecidableEq (Associates α)
inst✝² : (p : Associates α) → Decidable (Irreducible p)
inst✝¹ : Nontrivial α
inst✝ : DecidableEq (Associates α)
a : Associates α
ha : a ≠ 0
p : Associates α
hp : Irreducible p
n : ℕ
h : p.count (a ^ n).factors = n * p.count a.factors
⊢ p.count (a ^ (n + 1)).factors = (n + 1) * p.count a.factors
tactic: induction' k with n h
Theorem: List.map₂Left_eq_zipWith
File: Mathlib/Data/List/Basic.lean

Proof steps:
state_before: ι : Type u_1
α : Type u
β : Type v
γ : Type w
l₁ l₂ : List α
f : α → Option β → γ
as : List α
x✝ : [].length ≤ [].length
⊢ map₂Left f [] [] = zipWith (fun a b => f a (some b)) [] []
state_after: no goals
tactic: simp
state_before: ι : Type u_1
α : Type u
β : Type v
γ : Type w
l₁ l₂ : List α
f : α → Option β → γ
as : List α
head✝ : β
tail✝ : List β
x✝ : [].length ≤ (head✝ :: tail✝).length
⊢ map₂Left f [] (head✝ :: tail✝) = zipWith (fun a b => f a (some b)) [] (head✝ :: tail✝)
state_after: no goals
tactic: simp
state_before: ι : Type u_1
α : Type u
β : Type v
γ : Type w
l₁ l₂ : List α
f : α → Option β → γ
as✝ : List α
a : α
as : List α
h : (a :: as).length ≤ [].length
⊢ map₂Left f (a :: as) [] = zipWith (fun a b => f a (some b)) (a :: as) []
state_after: no goals
tactic: simp at h
state_before: ι : Type u_1
α : Type u
β : Type v
γ : Type w
l₁ l₂ : List α
f : α → Option β → γ
as✝ : List α
a : α
as : List α
b : β
bs : List β
h : (a :: as).length ≤ (b :: bs).length
⊢ map₂Left f (a :: as) (b :: bs) = zipWith (fun a b => f a (some b)) (a :: as) (b :: bs)
state_after: ι : Type u_1
α : Type u
β : Type v
γ : Type w
l₁ l₂ : List α
f : α → Option β → γ
as✝ : List α
a : α
as : List α
b : β
bs : List β
h : as.length ≤ bs.length
⊢ map₂Left f (a :: as) (b :: bs) = zipWith (fun a b => f a (some b)) (a :: as) (b :: bs)
tactic: simp only [length_cons, succ_le_succ_iff] at h
state_before: ι : Type u_1
α : Type u
β : Type v
γ : Type w
l₁ l₂ : List α
f : α → Option β → γ
as✝ : List α
a : α
as : List α
b : β
bs : List β
h : as.length ≤ bs.length
⊢ map₂Left f (a :: as) (b :: bs) = zipWith (fun a b => f a (some b)) (a :: as) (b :: bs)
state_after: no goals
tactic: simp [h, map₂Left_eq_zipWith]