ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: induced_to_pi
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
ι : Type u_5
π : ι → Type u_6
κ : Type u_7
inst✝ : TopologicalSpace X✝
T : (i : ι) → TopologicalSpace (π i)
f✝ : X✝ → (i : ι) → π i
X : Type u_8
f : X → (i : ι) → π i
⊢ induced f Pi.topologicalSpace = ⨅ i, induced (fun x => f x i) inferInstance
state_after: no goals
tactic: simp_rw [Pi.topologicalSpace, induced_iInf, induced_compose, Function.comp]
Theorem: nilpotencyClass_pi
File: Mathlib/GroupTheory/Nilpotent.lean

Proof steps:
state_before: G : Type u_1
inst✝⁴ : Group G
H : Subgroup G
inst✝³ : H.Normal
η : Type u_2
Gs : η → Type u_3
inst✝² : (i : η) → Group (Gs i)
inst✝¹ : Fintype η
inst✝ : ∀ (i : η), Group.IsNilpotent (Gs i)
⊢ Group.nilpotencyClass ((i : η) → Gs i) = Finset.univ.sup fun i => Group.nilpotencyClass (Gs i)
state_after: case H
G : Type u_1
inst✝⁴ : Group G
H : Subgroup G
inst✝³ : H.Normal
η : Type u_2
Gs : η → Type u_3
inst✝² : (i : η) → Group (Gs i)
inst✝¹ : Fintype η
inst✝ : ∀ (i : η), Group.IsNilpotent (Gs i)
⊢ ∀ (c : ℕ), Group.nilpotencyClass ((i : η) → Gs i) ≤ c ↔ (Finset.univ.sup fun i => Group.nilpotencyClass (Gs i)) ≤ c
tactic: apply eq_of_forall_ge_iff
state_before: case H
G : Type u_1
inst✝⁴ : Group G
H : Subgroup G
inst✝³ : H.Normal
η : Type u_2
Gs : η → Type u_3
inst✝² : (i : η) → Group (Gs i)
inst✝¹ : Fintype η
inst✝ : ∀ (i : η), Group.IsNilpotent (Gs i)
⊢ ∀ (c : ℕ), Group.nilpotencyClass ((i : η) → Gs i) ≤ c ↔ (Finset.univ.sup fun i => Group.nilpotencyClass (Gs i)) ≤ c
state_after: case H
G : Type u_1
inst✝⁴ : Group G
H : Subgroup G
inst✝³ : H.Normal
η : Type u_2
Gs : η → Type u_3
inst✝² : (i : η) → Group (Gs i)
inst✝¹ : Fintype η
inst✝ : ∀ (i : η), Group.IsNilpotent (Gs i)
k : ℕ
⊢ Group.nilpotencyClass ((i : η) → Gs i) ≤ k ↔ (Finset.univ.sup fun i => Group.nilpotencyClass (Gs i)) ≤ k
tactic: intro k
state_before: case H
G : Type u_1
inst✝⁴ : Group G
H : Subgroup G
inst✝³ : H.Normal
η : Type u_2
Gs : η → Type u_3
inst✝² : (i : η) → Group (Gs i)
inst✝¹ : Fintype η
inst✝ : ∀ (i : η), Group.IsNilpotent (Gs i)
k : ℕ
⊢ Group.nilpotencyClass ((i : η) → Gs i) ≤ k ↔ (Finset.univ.sup fun i => Group.nilpotencyClass (Gs i)) ≤ k
state_after: no goals
tactic: simp only [Finset.sup_le_iff, ← lowerCentralSeries_eq_bot_iff_nilpotencyClass_le,
    lowerCentralSeries_pi_of_finite, pi_eq_bot_iff, Finset.mem_univ, true_imp_iff]
Theorem: Set.nonempty_iInter_Iic_iff
File: Mathlib/Data/Set/Lattice.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
ι' : Sort u_5
ι₂ : Sort u_6
κ : ι → Sort u_7
κ₁ : ι → Sort u_8
κ₂ : ι → Sort u_9
κ' : ι' → Sort u_10
inst✝ : Preorder α
f : ι → α
⊢ (⋂ i, Iic (f i)).Nonempty ↔ BddBelow (range f)
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
ι' : Sort u_5
ι₂ : Sort u_6
κ : ι → Sort u_7
κ₁ : ι → Sort u_8
κ₂ : ι → Sort u_9
κ' : ι' → Sort u_10
inst✝ : Preorder α
f : ι → α
this : ⋂ i, Iic (f i) = lowerBounds (range f)
⊢ (⋂ i, Iic (f i)).Nonempty ↔ BddBelow (range f)
tactic: have : (⋂ (i : ι), Iic (f i)) = lowerBounds (range f) := by
    ext c; simp [lowerBounds]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
ι' : Sort u_5
ι₂ : Sort u_6
κ : ι → Sort u_7
κ₁ : ι → Sort u_8
κ₂ : ι → Sort u_9
κ' : ι' → Sort u_10
inst✝ : Preorder α
f : ι → α
this : ⋂ i, Iic (f i) = lowerBounds (range f)
⊢ (⋂ i, Iic (f i)).Nonempty ↔ BddBelow (range f)
state_after: no goals
tactic: simp [this, BddBelow]
Theorem: inner_re_zero_left
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✝³ : NormedAddCommGroup E
inst✝² : InnerProductSpace 𝕜 E
inst✝¹ : NormedAddCommGroup F
inst✝ : InnerProductSpace ℝ F
x : E
⊢ re ⟪0, x⟫_𝕜 = 0
state_after: no goals
tactic: simp only [inner_zero_left, AddMonoidHom.map_zero]
Theorem: ProbabilityTheory.defaultRatCDF_nonneg
File: Mathlib/Probability/Kernel/Disintegration/MeasurableStieltjes.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
ι : Type u_3
inst✝ : MeasurableSpace α
q : ℚ
⊢ 0 ≤ defaultRatCDF q
state_after: α : Type u_1
β : Type u_2
ι : Type u_3
inst✝ : MeasurableSpace α
q : ℚ
⊢ 0 ≤ if q < 0 then 0 else 1
tactic: unfold defaultRatCDF
state_before: α : Type u_1
β : Type u_2
ι : Type u_3
inst✝ : MeasurableSpace α
q : ℚ
⊢ 0 ≤ if q < 0 then 0 else 1
state_after: case pos
α : Type u_1
β : Type u_2
ι : Type u_3
inst✝ : MeasurableSpace α
q : ℚ
h✝ : q < 0
⊢ 0 ≤ 0

case neg
α : Type u_1
β : Type u_2
ι : Type u_3
inst✝ : MeasurableSpace α
q : ℚ
h✝ : ¬q < 0
⊢ 0 ≤ 1
tactic: split_ifs
state_before: case pos
α : Type u_1
β : Type u_2
ι : Type u_3
inst✝ : MeasurableSpace α
q : ℚ
h✝ : q < 0
⊢ 0 ≤ 0

case neg
α : Type u_1
β : Type u_2
ι : Type u_3
inst✝ : MeasurableSpace α
q : ℚ
h✝ : ¬q < 0
⊢ 0 ≤ 1
state_after: no goals
tactic: exacts [le_rfl, zero_le_one]
Theorem: Set.sized_empty
File: Mathlib/Data/Finset/Slice.lean

Proof steps:
state_before: α : Type u_1
ι : Sort u_2
κ : ι → Sort u_3
A B : Set (Finset α)
s : Finset α
r : ℕ
⊢ Sized r ∅
state_after: no goals
tactic: simp [Sized]
Theorem: Primrec.of_graph
File: Mathlib/Computability/Primrec.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
σ : Type u_5
inst✝⁴ : Primcodable α
inst✝³ : Primcodable β
inst✝² : Primcodable γ
inst✝¹ : Primcodable δ
inst✝ : Primcodable σ
f : α → ℕ
h₁ : PrimrecBounded f
h₂ : PrimrecRel fun a b => f a = b
⊢ Primrec f
state_after: case intro.intro
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
σ : Type u_5
inst✝⁴ : Primcodable α
inst✝³ : Primcodable β
inst✝² : Primcodable γ
inst✝¹ : Primcodable δ
inst✝ : Primcodable σ
f : α → ℕ
h₂ : PrimrecRel fun a b => f a = b
g : α → ℕ
pg : Primrec g
hg : ∀ (x : α), f x ≤ g x
⊢ Primrec f
tactic: rcases h₁ with ⟨g, pg, hg : ∀ x, f x ≤ g x⟩
state_before: case intro.intro
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
σ : Type u_5
inst✝⁴ : Primcodable α
inst✝³ : Primcodable β
inst✝² : Primcodable γ
inst✝¹ : Primcodable δ
inst✝ : Primcodable σ
f : α → ℕ
h₂ : PrimrecRel fun a b => f a = b
g : α → ℕ
pg : Primrec g
hg : ∀ (x : α), f x ≤ g x
⊢ Primrec f
state_after: case intro.intro
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
σ : Type u_5
inst✝⁴ : Primcodable α
inst✝³ : Primcodable β
inst✝² : Primcodable γ
inst✝¹ : Primcodable δ
inst✝ : Primcodable σ
f : α → ℕ
h₂ : PrimrecRel fun a b => f a = b
g : α → ℕ
pg : Primrec g
hg : ∀ (x : α), f x ≤ g x
n : α
⊢ Nat.findGreatest (fun b => f n = b) (g n) = f n
tactic: refine (nat_findGreatest pg h₂).of_eq fun n => ?_
state_before: case intro.intro
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
σ : Type u_5
inst✝⁴ : Primcodable α
inst✝³ : Primcodable β
inst✝² : Primcodable γ
inst✝¹ : Primcodable δ
inst✝ : Primcodable σ
f : α → ℕ
h₂ : PrimrecRel fun a b => f a = b
g : α → ℕ
pg : Primrec g
hg : ∀ (x : α), f x ≤ g x
n : α
⊢ Nat.findGreatest (fun b => f n = b) (g n) = f n
state_after: no goals
tactic: exact (Nat.findGreatest_spec (P := fun b => f n = b) (hg n) rfl).symm
Theorem: BoxIntegral.Box.withBotCoe_inj
File: Mathlib/Analysis/BoxIntegral/Box/Basic.lean

Proof steps:
state_before: ι : Type u_1
I✝ J✝ : Box ι
x y : ι → ℝ
I J : WithBot (Box ι)
⊢ ↑I = ↑J ↔ I = J
state_after: no goals
tactic: simp only [Subset.antisymm_iff, ← le_antisymm_iff, withBotCoe_subset_iff]
Theorem: Submonoid.bot_or_nontrivial
File: Mathlib/Algebra/Group/Submonoid/Operations.lean

Proof steps:
state_before: M : Type u_1
N : Type u_2
P : Type u_3
inst✝³ : MulOneClass M
inst✝² : MulOneClass N
inst✝¹ : MulOneClass P
S✝ : Submonoid M
A : Type u_4
inst✝ : SetLike A M
hA : SubmonoidClass A M
S' : A
S : Submonoid M
⊢ S = ⊥ ∨ Nontrivial ↥S
state_after: no goals
tactic: simp only [eq_bot_iff_forall, nontrivial_iff_exists_ne_one, ← not_forall, ← Classical.not_imp,
    Classical.em]
Theorem: MeasureTheory.ExistsSeqTendstoAe.seqTendstoAeSeq_succ
File: Mathlib/MeasureTheory/Function/ConvergenceInMeasure.lean

Proof steps:
state_before: α : Type u_1
ι : Type u_2
E : Type u_3
m : MeasurableSpace α
μ : Measure α
inst✝ : MetricSpace E
f : ℕ → α → E
g : α → E
hfg : TendstoInMeasure μ f atTop g
n : ℕ
⊢ seqTendstoAeSeq hfg (n + 1) = max (seqTendstoAeSeqAux hfg (n + 1)) (seqTendstoAeSeq hfg n + 1)
state_after: no goals
tactic: rw [seqTendstoAeSeq]
Theorem: Fin.cons_comp_rev
File: Mathlib/Data/Fin/Tuple/Basic.lean

Proof steps:
state_before: m n✝ : ℕ
α✝ : Fin (n✝ + 1) → Type u
β : Type v
α : Type u_1
n : ℕ
a : α
f : Fin n → α
⊢ cons a f ∘ rev = snoc (f ∘ rev) a
state_after: case h
m n✝ : ℕ
α✝ : Fin (n✝ + 1) → Type u
β : Type v
α : Type u_1
n : ℕ
a : α
f : Fin n → α
i : Fin (n + 1)
⊢ (cons a f ∘ rev) i = snoc (f ∘ rev) a i
tactic: funext i
state_before: case h
m n✝ : ℕ
α✝ : Fin (n✝ + 1) → Type u
β : Type v
α : Type u_1
n : ℕ
a : α
f : Fin n → α
i : Fin (n + 1)
⊢ (cons a f ∘ rev) i = snoc (f ∘ rev) a i
state_after: no goals
tactic: exact cons_rev ..
Theorem: UniformSpace.toTopologicalSpace_iInf
File: Mathlib/Topology/UniformSpace/Basic.lean

Proof steps:
state_before: α : Type ua
β : Type ub
γ : Type uc
δ : Type ud
ι✝ : Sort u_1
ι : Sort u_2
u : ι → UniformSpace α
a : α
⊢ 𝓝 a = 𝓝 a
state_after: no goals
tactic: simp only [@nhds_eq_comap_uniformity _ (iInf u), nhds_iInf,
    iInf_uniformity, @nhds_eq_comap_uniformity _ (u _), Filter.comap_iInf]
Theorem: Set.Finite.isCompact_convexHull
File: Mathlib/Analysis/Convex/Topology.lean

Proof steps:
state_before: ι : Type u_1
𝕜 : Type u_2
E : Type u_3
inst✝⁴ : AddCommGroup E
inst✝³ : Module ℝ E
inst✝² : TopologicalSpace E
inst✝¹ : TopologicalAddGroup E
inst✝ : ContinuousSMul ℝ E
s : Set E
hs : s.Finite
⊢ IsCompact ((convexHull ℝ) s)
state_after: ι : Type u_1
𝕜 : Type u_2
E : Type u_3
inst✝⁴ : AddCommGroup E
inst✝³ : Module ℝ E
inst✝² : TopologicalSpace E
inst✝¹ : TopologicalAddGroup E
inst✝ : ContinuousSMul ℝ E
s : Set E
hs : s.Finite
⊢ IsCompact (⇑(∑ x : ↑s, (LinearMap.proj x).smulRight ↑x) '' stdSimplex ℝ ↑s)
tactic: rw [hs.convexHull_eq_image]
state_before: ι : Type u_1
𝕜 : Type u_2
E : Type u_3
inst✝⁴ : AddCommGroup E
inst✝³ : Module ℝ E
inst✝² : TopologicalSpace E
inst✝¹ : TopologicalAddGroup E
inst✝ : ContinuousSMul ℝ E
s : Set E
hs : s.Finite
⊢ IsCompact (⇑(∑ x : ↑s, (LinearMap.proj x).smulRight ↑x) '' stdSimplex ℝ ↑s)
state_after: ι : Type u_1
𝕜 : Type u_2
E : Type u_3
inst✝⁴ : AddCommGroup E
inst✝³ : Module ℝ E
inst✝² : TopologicalSpace E
inst✝¹ : TopologicalAddGroup E
inst✝ : ContinuousSMul ℝ E
s : Set E
hs : s.Finite
⊢ Continuous ⇑(∑ x : ↑s, (LinearMap.proj x).smulRight ↑x)
tactic: apply (@isCompact_stdSimplex _ hs.fintype).image
state_before: ι : Type u_1
𝕜 : Type u_2
E : Type u_3
inst✝⁴ : AddCommGroup E
inst✝³ : Module ℝ E
inst✝² : TopologicalSpace E
inst✝¹ : TopologicalAddGroup E
inst✝ : ContinuousSMul ℝ E
s : Set E
hs : s.Finite
⊢ Continuous ⇑(∑ x : ↑s, (LinearMap.proj x).smulRight ↑x)
state_after: ι : Type u_1
𝕜 : Type u_2
E : Type u_3
inst✝⁴ : AddCommGroup E
inst✝³ : Module ℝ E
inst✝² : TopologicalSpace E
inst✝¹ : TopologicalAddGroup E
inst✝ : ContinuousSMul ℝ E
s : Set E
hs : s.Finite
this : Fintype ↑s
⊢ Continuous ⇑(∑ x : ↑s, (LinearMap.proj x).smulRight ↑x)
tactic: haveI := hs.fintype
state_before: ι : Type u_1
𝕜 : Type u_2
E : Type u_3
inst✝⁴ : AddCommGroup E
inst✝³ : Module ℝ E
inst✝² : TopologicalSpace E
inst✝¹ : TopologicalAddGroup E
inst✝ : ContinuousSMul ℝ E
s : Set E
hs : s.Finite
this : Fintype ↑s
⊢ Continuous ⇑(∑ x : ↑s, (LinearMap.proj x).smulRight ↑x)
state_after: no goals
tactic: apply LinearMap.continuous_on_pi
Theorem: Fin.map_valEmbedding_Iio
File: Mathlib/Order/Interval/Finset/Fin.lean

Proof steps:
state_before: n : ℕ
a b : Fin n
⊢ map valEmbedding (Iio b) = Iio ↑b
state_after: no goals
tactic: simp [Iio_eq_finset_subtype, Finset.fin, Finset.map_map]
Theorem: List.mem_range'
File: .lake/packages/batteries/Batteries/Data/List/Lemmas.lean

Proof steps:
state_before: m s step : Nat
⊢ m ∈ range' s 0 step ↔ ∃ i, i < 0 ∧ m = s + step * i
state_after: no goals
tactic: simp [range', Nat.not_lt_zero]
state_before: m s step n : Nat
⊢ m ∈ range' s (n + 1) step ↔ ∃ i, i < n + 1 ∧ m = s + step * i
state_after: m s step n : Nat
h : ∀ (i : Nat), i ≤ n ↔ i = 0 ∨ ∃ j, i = j.succ ∧ j < n
⊢ m ∈ range' s (n + 1) step ↔ ∃ i, i < n + 1 ∧ m = s + step * i
tactic: have h (i) : i ≤ n ↔ i = 0 ∨ ∃ j, i = succ j ∧ j < n := by cases i <;> simp [Nat.succ_le]
state_before: m s step n : Nat
h : ∀ (i : Nat), i ≤ n ↔ i = 0 ∨ ∃ j, i = j.succ ∧ j < n
⊢ m ∈ range' s (n + 1) step ↔ ∃ i, i < n + 1 ∧ m = s + step * i
state_after: m s step n : Nat
h : ∀ (i : Nat), i ≤ n ↔ i = 0 ∨ ∃ j, i = j.succ ∧ j < n
⊢ (m = s ∨ ∃ i, i < n ∧ m = s + step + step * i) ↔ m = s ∨ ∃ a, (∃ j, a = j + 1 ∧ j < n) ∧ m = s + step * a
tactic: simp [range', mem_range', Nat.lt_succ, h]
state_before: m s step n : Nat
h : ∀ (i : Nat), i ≤ n ↔ i = 0 ∨ ∃ j, i = j.succ ∧ j < n
⊢ (m = s ∨ ∃ i, i < n ∧ m = s + step + step * i) ↔ m = s ∨ ∃ a, (∃ j, a = j + 1 ∧ j < n) ∧ m = s + step * a
state_after: m s step n : Nat
h : ∀ (i : Nat), i ≤ n ↔ i = 0 ∨ ∃ j, i = j.succ ∧ j < n
⊢ (m = s ∨ ∃ i, i < n ∧ m = s + step + step * i) ↔ m = s ∨ ∃ a x, a = x + 1 ∧ x < n ∧ m = s + step * a
tactic: simp only [← exists_and_right, and_assoc]
state_before: m s step n : Nat
h : ∀ (i : Nat), i ≤ n ↔ i = 0 ∨ ∃ j, i = j.succ ∧ j < n
⊢ (m = s ∨ ∃ i, i < n ∧ m = s + step + step * i) ↔ m = s ∨ ∃ a x, a = x + 1 ∧ x < n ∧ m = s + step * a
state_after: m s step n : Nat
h : ∀ (i : Nat), i ≤ n ↔ i = 0 ∨ ∃ j, i = j.succ ∧ j < n
⊢ (m = s ∨ ∃ i, i < n ∧ m = s + step + step * i) ↔ m = s ∨ ∃ b a, a = b + 1 ∧ b < n ∧ m = s + step * a
tactic: rw [exists_comm]
state_before: m s step n : Nat
h : ∀ (i : Nat), i ≤ n ↔ i = 0 ∨ ∃ j, i = j.succ ∧ j < n
⊢ (m = s ∨ ∃ i, i < n ∧ m = s + step + step * i) ↔ m = s ∨ ∃ b a, a = b + 1 ∧ b < n ∧ m = s + step * a
state_after: no goals
tactic: simp [Nat.mul_succ, Nat.add_assoc, Nat.add_comm]
Theorem: List.take_range
File: Mathlib/Data/List/Range.lean

Proof steps:
state_before: α : Type u
m n : ℕ
⊢ take m (range n) = range (min m n)
state_after: case hl
α : Type u
m n : ℕ
⊢ (take m (range n)).length = (range (min m n)).length

case h
α : Type u
m n : ℕ
⊢ ∀ (n_1 : ℕ) (h₁ : n_1 < (take m (range n)).length) (h₂ : n_1 < (range (min m n)).length),
    (take m (range n))[n_1] = (range (min m n))[n_1]
tactic: apply List.ext_getElem
Theorem: LinearEquiv.ofBijective_symm_apply_apply
File: Mathlib/Algebra/Module/Submodule/Equiv.lean

Proof steps:
state_before: R : Type u_1
R₁ : Type u_2
R₂ : Type u_3
R₃ : Type u_4
M : Type u_5
M₁ : Type u_6
M₂ : Type u_7
M₃ : Type u_8
N : Type u_9
inst✝⁸ : Semiring R
inst✝⁷ : Semiring R₂
inst✝⁶ : Semiring R₃
inst✝⁵ : AddCommMonoid M
inst✝⁴ : AddCommMonoid M₂
inst✝³ : AddCommMonoid M₃
module_M : Module R M
module_M₂ : Module R₂ M₂
module_M₃ : Module R₃ M₃
σ₁₂ : R →+* R₂
σ₂₁ : R₂ →+* R
σ₂₃ : R₂ →+* R₃
σ₁₃ : R →+* R₃
inst✝² : RingHomCompTriple σ₁₂ σ₂₃ σ₁₃
σ₃₂ : R₃ →+* R₂
re₁₂ : RingHomInvPair σ₁₂ σ₂₁
re₂₁ : RingHomInvPair σ₂₁ σ₁₂
re₂₃ : RingHomInvPair σ₂₃ σ₃₂
re₃₂ : RingHomInvPair σ₃₂ σ₂₃
f : M →ₛₗ[σ₁₂] M₂
g : M₂ →ₛₗ[σ₂₁] M
e : M ≃ₛₗ[σ₁₂] M₂
h✝ : M₂ →ₛₗ[σ₂₃] M₃
p q : Submodule R M
inst✝¹ : RingHomInvPair σ₁₂ σ₂₁
inst✝ : RingHomInvPair σ₂₁ σ₁₂
h : Bijective ⇑f
x : M
⊢ (ofBijective f h).symm (f x) = x
state_after: no goals
tactic: simp [LinearEquiv.symm_apply_eq]
Theorem: inseparable_zero_iff_norm
File: Mathlib/Analysis/Normed/Group/Basic.lean

Proof steps:
state_before: 𝓕 : Type u_1
𝕜 : Type u_2
α : Type u_3
ι : Type u_4
κ : Type u_5
E : Type u_6
F : Type u_7
G : Type u_8
inst✝² : SeminormedGroup E
inst✝¹ : SeminormedGroup F
inst✝ : SeminormedGroup G
s : Set E
a✝ a₁ a₂ b b₁ b₂ : E
r r₁ r₂ : ℝ
a : E
⊢ Inseparable a 1 ↔ ‖a‖ = 0
state_after: no goals
tactic: rw [Metric.inseparable_iff, dist_one_right]
Theorem: Real.cosh_sq
File: Mathlib/Data/Complex/Exponential.lean

Proof steps:
state_before: x y : ℝ
⊢ cosh x ^ 2 = sinh x ^ 2 + 1
state_after: x y : ℝ
⊢ ↑(cosh x ^ 2) = ↑(sinh x ^ 2 + 1)
tactic: rw [← ofReal_inj]
state_before: x y : ℝ
⊢ ↑(cosh x ^ 2) = ↑(sinh x ^ 2 + 1)
state_after: no goals
tactic: simp [cosh_sq]
Theorem: NumberField.mixedEmbedding.normAtPlace_eq_zero
File: Mathlib/NumberTheory/NumberField/CanonicalEmbedding/Basic.lean

Proof steps:
state_before: K : Type u_1
inst✝ : Field K
x : ({ w // w.IsReal } → ℝ) × ({ w // w.IsComplex } → ℂ)
⊢ (∀ (w : InfinitePlace K), (normAtPlace w) x = 0) ↔ x = 0
state_after: case refine_1
K : Type u_1
inst✝ : Field K
x : ({ w // w.IsReal } → ℝ) × ({ w // w.IsComplex } → ℂ)
h : ∀ (w : InfinitePlace K), (normAtPlace w) x = 0
⊢ x = 0

case refine_2
K : Type u_1
inst✝ : Field K
x : ({ w // w.IsReal } → ℝ) × ({ w // w.IsComplex } → ℂ)
h : x = 0
⊢ ∀ (w : InfinitePlace K), (normAtPlace w) x = 0
tactic: refine ⟨fun h ↦ ?_, fun h ↦ ?_⟩
Theorem: Fin.sum_congr'
File: Mathlib/Algebra/BigOperators/Fin.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
M : Type u_3
inst✝ : CommMonoid M
a b : ℕ
f : Fin b → M
h : a = b
⊢ ∏ i : Fin a, f (cast h i) = ∏ i : Fin b, f i
state_after: α : Type u_1
β : Type u_2
M : Type u_3
inst✝ : CommMonoid M
a : ℕ
f : Fin a → M
⊢ ∏ i : Fin a, f (cast ⋯ i) = ∏ i : Fin a, f i
tactic: subst h
state_before: α : Type u_1
β : Type u_2
M : Type u_3
inst✝ : CommMonoid M
a : ℕ
f : Fin a → M
⊢ ∏ i : Fin a, f (cast ⋯ i) = ∏ i : Fin a, f i
state_after: no goals
tactic: congr
Theorem: EuclideanGeometry.cospherical_pair
File: Mathlib/Geometry/Euclidean/Sphere/Basic.lean

Proof steps:
state_before: V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : NormedSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
p₁ p₂ : P
⊢ ∀ p ∈ {p₁, p₂}, dist p (midpoint ℝ p₁ p₂) = ‖2‖⁻¹ * dist p₁ p₂
state_after: case inl
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : NormedSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
p₂ p : P
⊢ dist p (midpoint ℝ p p₂) = ‖2‖⁻¹ * dist p p₂

case inr.refl
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : NormedSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
p₁ p₂ : P
⊢ dist p₂ (midpoint ℝ p₁ p₂) = ‖2‖⁻¹ * dist p₁ p₂
tactic: rintro p (rfl | rfl | _)
Theorem: List.Chain.pairwise
File: Mathlib/Data/List/Chain.lean

Proof steps:
state_before: α : Type u
β : Type v
R r : α → α → Prop
l✝ l₁ l₂ : List α
a✝ b✝ : α
inst✝ : IsTrans α R
a b : α
l : List α
h : R a b
hb : Chain R b l
⊢ ∀ (a' : α), a' ∈ b :: l → R a a'
state_after: α : Type u
β : Type v
R r : α → α → Prop
l✝ l₁ l₂ : List α
a✝ b✝ : α
inst✝ : IsTrans α R
a b : α
l : List α
h : R a b
hb : Chain R b l
⊢ ∀ (a_1 : α), a_1 ∈ l → R a a_1
tactic: simp only [mem_cons, forall_eq_or_imp, h, true_and_iff]
state_before: α : Type u
β : Type v
R r : α → α → Prop
l✝ l₁ l₂ : List α
a✝ b✝ : α
inst✝ : IsTrans α R
a b : α
l : List α
h : R a b
hb : Chain R b l
⊢ ∀ (a_1 : α), a_1 ∈ l → R a a_1
state_after: no goals
tactic: exact fun c hc => _root_.trans h (rel_of_pairwise_cons hb.pairwise hc)
Theorem: Multiset.noncommSum_cons
File: Mathlib/Data/Finset/NoncommProd.lean

Proof steps:
state_before: F : Type u_1
ι : Type u_2
α : Type u_3
β : Type u_4
γ : Type u_5
f : α → β → β
op : α → α → α
inst✝¹ : Monoid α
inst✝ : Monoid β
s : Multiset α
a : α
comm : {x | x ∈ a ::ₘ s}.Pairwise Commute
⊢ (a ::ₘ s).noncommProd comm = a * s.noncommProd ⋯
state_after: case h
F : Type u_1
ι : Type u_2
α : Type u_3
β : Type u_4
γ : Type u_5
f : α → β → β
op : α → α → α
inst✝¹ : Monoid α
inst✝ : Monoid β
a : α
a✝ : List α
comm : {x | x ∈ a ::ₘ ⟦a✝⟧}.Pairwise Commute
⊢ (a ::ₘ ⟦a✝⟧).noncommProd comm = a * noncommProd ⟦a✝⟧ ⋯
tactic: induction s using Quotient.inductionOn
state_before: case h
F : Type u_1
ι : Type u_2
α : Type u_3
β : Type u_4
γ : Type u_5
f : α → β → β
op : α → α → α
inst✝¹ : Monoid α
inst✝ : Monoid β
a : α
a✝ : List α
comm : {x | x ∈ a ::ₘ ⟦a✝⟧}.Pairwise Commute
⊢ (a ::ₘ ⟦a✝⟧).noncommProd comm = a * noncommProd ⟦a✝⟧ ⋯
state_after: no goals
tactic: simp
Theorem: CategoryTheory.functorProdToProdFunctor_obj
File: Mathlib/CategoryTheory/Products/Basic.lean

Proof steps:
state_before: A : Type u₁
inst✝³ : Category.{v₁, u₁} A
B : Type u₂
inst✝² : Category.{v₂, u₂} B
C : Type u₃
inst✝¹ : Category.{v₃, u₃} C
D : Type u₄
inst✝ : Category.{v₄, u₄} D
X✝ Y✝ : A ⥤ B × C
α : X✝ ⟶ Y✝
X Y : A
f : X ⟶ Y
⊢ ((fun F => (F ⋙ Prod.fst B C, F ⋙ Prod.snd B C)) X✝).1.map f ≫ (fun X => (α.app X).1) Y =
    (fun X => (α.app X).1) X ≫ ((fun F => (F ⋙ Prod.fst B C, F ⋙ Prod.snd B C)) Y✝).1.map f
state_after: no goals
tactic: simp only [Functor.comp_map, Prod.fst_map, ← prod_comp_fst, α.naturality]
state_before: A : Type u₁
inst✝³ : Category.{v₁, u₁} A
B : Type u₂
inst✝² : Category.{v₂, u₂} B
C : Type u₃
inst✝¹ : Category.{v₃, u₃} C
D : Type u₄
inst✝ : Category.{v₄, u₄} D
X✝ Y✝ : A ⥤ B × C
α : X✝ ⟶ Y✝
X Y : A
f : X ⟶ Y
⊢ ((fun F => (F ⋙ Prod.fst B C, F ⋙ Prod.snd B C)) X✝).2.map f ≫ (fun X => (α.app X).2) Y =
    (fun X => (α.app X).2) X ≫ ((fun F => (F ⋙ Prod.fst B C, F ⋙ Prod.snd B C)) Y✝).2.map f
state_after: no goals
tactic: simp only [Functor.comp_map, Prod.snd_map, ← prod_comp_snd, α.naturality]
Theorem: HasDerivAt.div
File: Mathlib/Analysis/Calculus/Deriv/Inv.lean

Proof steps:
state_before: 𝕜 : Type u
inst✝⁶ : NontriviallyNormedField 𝕜
F : Type v
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
E : Type w
inst✝³ : NormedAddCommGroup E
inst✝² : NormedSpace 𝕜 E
f f₀ f₁ g : 𝕜 → F
f' f₀' f₁' g' : F
x : 𝕜
s t : Set 𝕜
L : Filter 𝕜
𝕜' : Type u_1
inst✝¹ : NontriviallyNormedField 𝕜'
inst✝ : NormedAlgebra 𝕜 𝕜'
c d : 𝕜 → 𝕜'
c' d' : 𝕜'
hc : HasDerivAt c c' x
hd : HasDerivAt d d' x
hx : d x ≠ 0
⊢ HasDerivAt (fun y => c y / d y) ((c' * d x - c x * d') / d x ^ 2) x
state_after: 𝕜 : Type u
inst✝⁶ : NontriviallyNormedField 𝕜
F : Type v
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
E : Type w
inst✝³ : NormedAddCommGroup E
inst✝² : NormedSpace 𝕜 E
f f₀ f₁ g : 𝕜 → F
f' f₀' f₁' g' : F
x : 𝕜
s t : Set 𝕜
L : Filter 𝕜
𝕜' : Type u_1
inst✝¹ : NontriviallyNormedField 𝕜'
inst✝ : NormedAlgebra 𝕜 𝕜'
c d : 𝕜 → 𝕜'
c' d' : 𝕜'
hc : HasDerivWithinAt c c' univ x
hd : HasDerivWithinAt d d' univ x
hx : d x ≠ 0
⊢ HasDerivWithinAt (fun y => c y / d y) ((c' * d x - c x * d') / d x ^ 2) univ x
tactic: rw [← hasDerivWithinAt_univ] at *
state_before: 𝕜 : Type u
inst✝⁶ : NontriviallyNormedField 𝕜
F : Type v
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
E : Type w
inst✝³ : NormedAddCommGroup E
inst✝² : NormedSpace 𝕜 E
f f₀ f₁ g : 𝕜 → F
f' f₀' f₁' g' : F
x : 𝕜
s t : Set 𝕜
L : Filter 𝕜
𝕜' : Type u_1
inst✝¹ : NontriviallyNormedField 𝕜'
inst✝ : NormedAlgebra 𝕜 𝕜'
c d : 𝕜 → 𝕜'
c' d' : 𝕜'
hc : HasDerivWithinAt c c' univ x
hd : HasDerivWithinAt d d' univ x
hx : d x ≠ 0
⊢ HasDerivWithinAt (fun y => c y / d y) ((c' * d x - c x * d') / d x ^ 2) univ x
state_after: no goals
tactic: exact hc.div hd hx
Theorem: Finset.pi_nonempty
File: Mathlib/Data/Finset/Pi.lean

Proof steps:
state_before: α : Type u_1
β : α → Type u
δ : α → Sort v
inst✝ : DecidableEq α
s : Finset α
t : (a : α) → Finset (β a)
⊢ (s.pi t).Nonempty ↔ ∀ a ∈ s, (t a).Nonempty
state_after: no goals
tactic: simp [Finset.Nonempty, Classical.skolem]
Theorem: GaussianInt.toComplex_im
File: Mathlib/NumberTheory/Zsqrtd/GaussianInt.lean

Proof steps:
state_before: x y : ℤ
⊢ (toComplex { re := x, im := y }).im = ↑y
state_after: no goals
tactic: simp [toComplex_def]
Theorem: pow_mul_pow_eq_one
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✝ : Monoid M
a b c : M
m n : ℕ
x✝ : a * b = 1
⊢ a ^ 0 * b ^ 0 = 1
state_after: no goals
tactic: simp
state_before: α : Type u_1
β : Type u_2
G : Type u_3
M : Type u_4
inst✝ : Monoid M
a b c : M
m n✝ n : ℕ
h : a * b = 1
⊢ a ^ n.succ * b ^ n.succ = a ^ n * a * (b * b ^ n)
state_after: no goals
tactic: rw [pow_succ, pow_succ']
state_before: α : Type u_1
β : Type u_2
G : Type u_3
M : Type u_4
inst✝ : Monoid M
a b c : M
m n✝ n : ℕ
h : a * b = 1
⊢ a ^ n * a * (b * b ^ n) = a ^ n * (a * b) * b ^ n
state_after: no goals
tactic: simp only [mul_assoc]
state_before: α : Type u_1
β : Type u_2
G : Type u_3
M : Type u_4
inst✝ : Monoid M
a b c : M
m n✝ n : ℕ
h : a * b = 1
⊢ a ^ n * (a * b) * b ^ n = 1
state_after: no goals
tactic: simp [h, pow_mul_pow_eq_one]