ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: InnerProductGeometry.angle_zero_left
File: Mathlib/Geometry/Euclidean/Angle/Unoriented/Basic.lean

Proof steps:
state_before: V : Type u_1
inst✝¹ : NormedAddCommGroup V
inst✝ : InnerProductSpace ℝ V
x✝ y x : V
⊢ angle 0 x = π / 2
state_after: V : Type u_1
inst✝¹ : NormedAddCommGroup V
inst✝ : InnerProductSpace ℝ V
x✝ y x : V
⊢ arccos (⟪0, x⟫_ℝ / (‖0‖ * ‖x‖)) = π / 2
tactic: unfold angle
state_before: V : Type u_1
inst✝¹ : NormedAddCommGroup V
inst✝ : InnerProductSpace ℝ V
x✝ y x : V
⊢ arccos (⟪0, x⟫_ℝ / (‖0‖ * ‖x‖)) = π / 2
state_after: no goals
tactic: rw [inner_zero_left, zero_div, Real.arccos_zero]
Theorem: aemeasurable_inv_iff
File: Mathlib/MeasureTheory/Group/Arithmetic.lean

Proof steps:
state_before: α✝ : Type u_1
G✝ : Type u_2
α : Type u_3
inst✝⁵ : Inv G✝
inst✝⁴ : MeasurableSpace G✝
inst✝³ : MeasurableInv G✝
m : MeasurableSpace α
f✝ : α → G✝
μ : Measure α
G : Type u_4
inst✝² : Group G
inst✝¹ : MeasurableSpace G
inst✝ : MeasurableInv G
f : α → G
h : AEMeasurable (fun x => (f x)⁻¹) μ
⊢ AEMeasurable f μ
state_after: no goals
tactic: simpa only [inv_inv] using h.inv
Theorem: Function.iterate_add_minimalPeriod_eq
File: Mathlib/Dynamics/PeriodicPts.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
f fa : α → α
fb : β → β
x y : α
m n : ℕ
⊢ f^[n + minimalPeriod f x] x = f^[n] x
state_after: α : Type u_1
β : Type u_2
f fa : α → α
fb : β → β
x y : α
m n : ℕ
⊢ f^[n] (f^[minimalPeriod f x] x) = f^[n] x
tactic: rw [iterate_add_apply]
state_before: α : Type u_1
β : Type u_2
f fa : α → α
fb : β → β
x y : α
m n : ℕ
⊢ f^[n] (f^[minimalPeriod f x] x) = f^[n] x
state_after: case e_a
α : Type u_1
β : Type u_2
f fa : α → α
fb : β → β
x y : α
m n : ℕ
⊢ f^[minimalPeriod f x] x = x
tactic: congr
state_before: case e_a
α : Type u_1
β : Type u_2
f fa : α → α
fb : β → β
x y : α
m n : ℕ
⊢ f^[minimalPeriod f x] x = x
state_after: no goals
tactic: exact isPeriodicPt_minimalPeriod f x
Theorem: isSMulRegular_of_group
File: Mathlib/Algebra/Regular/SMul.lean

Proof steps:
state_before: R : Type u_1
S : Type u_2
M : Type u_3
a b : R
s : S
G : Type u_4
inst✝¹ : Group G
inst✝ : MulAction G R
g : G
⊢ IsSMulRegular R g
state_after: R : Type u_1
S : Type u_2
M : Type u_3
a b : R
s : S
G : Type u_4
inst✝¹ : Group G
inst✝ : MulAction G R
g : G
x y : R
h : (fun x => g • x) x = (fun x => g • x) y
⊢ x = y
tactic: intro x y h
Theorem: DFinsupp.prod_add_index
File: Mathlib/Data/DFinsupp/Basic.lean

Proof steps:
state_before: ι : Type u
γ : Type w
β : ι → Type v
β₁ : ι → Type v₁
β₂ : ι → Type v₂
inst✝³ : DecidableEq ι
inst✝² : (i : ι) → AddCommMonoid (β i)
inst✝¹ : (i : ι) → (x : β i) → Decidable (x ≠ 0)
inst✝ : CommMonoid γ
f g : Π₀ (i : ι), β i
h : (i : ι) → β i → γ
h_zero : ∀ (i : ι), h i 0 = 1
h_add : ∀ (i : ι) (b₁ b₂ : β i), h i (b₁ + b₂) = h i b₁ * h i b₂
⊢ ∀ x ∈ f.support ∪ g.support, x ∉ f.support → h x (f x) = 1
state_after: no goals
tactic: simp (config := { contextual := true }) [mem_support_iff, h_zero]
state_before: ι : Type u
γ : Type w
β : ι → Type v
β₁ : ι → Type v₁
β₂ : ι → Type v₂
inst✝³ : DecidableEq ι
inst✝² : (i : ι) → AddCommMonoid (β i)
inst✝¹ : (i : ι) → (x : β i) → Decidable (x ≠ 0)
inst✝ : CommMonoid γ
f g : Π₀ (i : ι), β i
h : (i : ι) → β i → γ
h_zero : ∀ (i : ι), h i 0 = 1
h_add : ∀ (i : ι) (b₁ b₂ : β i), h i (b₁ + b₂) = h i b₁ * h i b₂
f_eq : ∏ i ∈ f.support ∪ g.support, h i (f i) = f.prod h
⊢ ∀ x ∈ f.support ∪ g.support, x ∉ g.support → h x (g x) = 1
state_after: no goals
tactic: simp (config := { contextual := true }) [mem_support_iff, h_zero]
state_before: ι : Type u
γ : Type w
β : ι → Type v
β₁ : ι → Type v₁
β₂ : ι → Type v₂
inst✝³ : DecidableEq ι
inst✝² : (i : ι) → AddCommMonoid (β i)
inst✝¹ : (i : ι) → (x : β i) → Decidable (x ≠ 0)
inst✝ : CommMonoid γ
f g : Π₀ (i : ι), β i
h : (i : ι) → β i → γ
h_zero : ∀ (i : ι), h i 0 = 1
h_add : ∀ (i : ι) (b₁ b₂ : β i), h i (b₁ + b₂) = h i b₁ * h i b₂
f_eq : ∏ i ∈ f.support ∪ g.support, h i (f i) = f.prod h
g_eq : ∏ i ∈ f.support ∪ g.support, h i (g i) = g.prod h
⊢ ∀ x ∈ f.support ∪ g.support, x ∉ (f + g).support → h x ((f + g) x) = 1
state_after: no goals
tactic: simp (config := { contextual := true }) [mem_support_iff, h_zero]
state_before: ι : Type u
γ : Type w
β : ι → Type v
β₁ : ι → Type v₁
β₂ : ι → Type v₂
inst✝³ : DecidableEq ι
inst✝² : (i : ι) → AddCommMonoid (β i)
inst✝¹ : (i : ι) → (x : β i) → Decidable (x ≠ 0)
inst✝ : CommMonoid γ
f g : Π₀ (i : ι), β i
h : (i : ι) → β i → γ
h_zero : ∀ (i : ι), h i 0 = 1
h_add : ∀ (i : ι) (b₁ b₂ : β i), h i (b₁ + b₂) = h i b₁ * h i b₂
f_eq : ∏ i ∈ f.support ∪ g.support, h i (f i) = f.prod h
g_eq : ∏ i ∈ f.support ∪ g.support, h i (g i) = g.prod h
⊢ ∏ i ∈ f.support ∪ g.support, h i ((f + g) i) =
    (∏ i ∈ f.support ∪ g.support, h i (f i)) * ∏ i ∈ f.support ∪ g.support, h i (g i)
state_after: no goals
tactic: simp [h_add, Finset.prod_mul_distrib]
state_before: ι : Type u
γ : Type w
β : ι → Type v
β₁ : ι → Type v₁
β₂ : ι → Type v₂
inst✝³ : DecidableEq ι
inst✝² : (i : ι) → AddCommMonoid (β i)
inst✝¹ : (i : ι) → (x : β i) → Decidable (x ≠ 0)
inst✝ : CommMonoid γ
f g : Π₀ (i : ι), β i
h : (i : ι) → β i → γ
h_zero : ∀ (i : ι), h i 0 = 1
h_add : ∀ (i : ι) (b₁ b₂ : β i), h i (b₁ + b₂) = h i b₁ * h i b₂
f_eq : ∏ i ∈ f.support ∪ g.support, h i (f i) = f.prod h
g_eq : ∏ i ∈ f.support ∪ g.support, h i (g i) = g.prod h
⊢ (∏ i ∈ f.support ∪ g.support, h i (f i)) * ∏ i ∈ f.support ∪ g.support, h i (g i) = f.prod h * g.prod h
state_after: no goals
tactic: rw [f_eq, g_eq]
Theorem: CategoryTheory.Comma.coconeOfPreserves_ι_app_left
File: Mathlib/CategoryTheory/Limits/Comma.lean

Proof steps:
state_before: J : Type w
inst✝⁴ : Category.{w', w} J
A : Type u₁
inst✝³ : Category.{v₁, u₁} A
B : Type u₂
inst✝² : Category.{v₂, u₂} B
T : Type u₃
inst✝¹ : Category.{v₃, u₃} T
L : A ⥤ T
R : B ⥤ T
F : J ⥤ Comma L R
inst✝ : PreservesColimit (F ⋙ fst L R) L
c₁ : Cocone (F ⋙ fst L R)
t₁ : IsColimit c₁
c₂ : Cocone (F ⋙ snd L R)
j₁ j₂ : J
t : j₁ ⟶ j₂
⊢ F.map t ≫ (fun j => { left := c₁.ι.app j, right := c₂.ι.app j, w := ⋯ }) j₂ =
    (fun j => { left := c₁.ι.app j, right := c₂.ι.app j, w := ⋯ }) j₁ ≫
      ((Functor.const J).obj
            { left := c₁.pt, right := c₂.pt,
              hom := (isColimitOfPreserves L t₁).desc (colimitAuxiliaryCocone F c₂) }).map
        t
state_after: case h₁
J : Type w
inst✝⁴ : Category.{w', w} J
A : Type u₁
inst✝³ : Category.{v₁, u₁} A
B : Type u₂
inst✝² : Category.{v₂, u₂} B
T : Type u₃
inst✝¹ : Category.{v₃, u₃} T
L : A ⥤ T
R : B ⥤ T
F : J ⥤ Comma L R
inst✝ : PreservesColimit (F ⋙ fst L R) L
c₁ : Cocone (F ⋙ fst L R)
t₁ : IsColimit c₁
c₂ : Cocone (F ⋙ snd L R)
j₁ j₂ : J
t : j₁ ⟶ j₂
⊢ (F.map t ≫ (fun j => { left := c₁.ι.app j, right := c₂.ι.app j, w := ⋯ }) j₂).left =
    ((fun j => { left := c₁.ι.app j, right := c₂.ι.app j, w := ⋯ }) j₁ ≫
        ((Functor.const J).obj
              { left := c₁.pt, right := c₂.pt,
                hom := (isColimitOfPreserves L t₁).desc (colimitAuxiliaryCocone F c₂) }).map
          t).left

case h₂
J : Type w
inst✝⁴ : Category.{w', w} J
A : Type u₁
inst✝³ : Category.{v₁, u₁} A
B : Type u₂
inst✝² : Category.{v₂, u₂} B
T : Type u₃
inst✝¹ : Category.{v₃, u₃} T
L : A ⥤ T
R : B ⥤ T
F : J ⥤ Comma L R
inst✝ : PreservesColimit (F ⋙ fst L R) L
c₁ : Cocone (F ⋙ fst L R)
t₁ : IsColimit c₁
c₂ : Cocone (F ⋙ snd L R)
j₁ j₂ : J
t : j₁ ⟶ j₂
⊢ (F.map t ≫ (fun j => { left := c₁.ι.app j, right := c₂.ι.app j, w := ⋯ }) j₂).right =
    ((fun j => { left := c₁.ι.app j, right := c₂.ι.app j, w := ⋯ }) j₁ ≫
        ((Functor.const J).obj
              { left := c₁.pt, right := c₂.pt,
                hom := (isColimitOfPreserves L t₁).desc (colimitAuxiliaryCocone F c₂) }).map
          t).right
tactic: ext
Theorem: ProbabilityTheory.Kernel.setLIntegral_density
File: Mathlib/Probability/Kernel/Disintegration/Density.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
mγ : MeasurableSpace γ
inst✝¹ : CountablyGenerated γ
κ : Kernel α (γ × β)
ν : Kernel α γ
hκν : κ.fst ≤ ν
inst✝ : IsFiniteKernel ν
a : α
s : Set β
hs : MeasurableSet s
A : Set γ
hA : MeasurableSet A
⊢ ∫⁻ (x : γ) in A, ENNReal.ofReal (κ.density ν a x s) ∂ν a = (κ a) (A ×ˢ s)
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
mγ : MeasurableSpace γ
inst✝¹ : CountablyGenerated γ
κ : Kernel α (γ × β)
ν : Kernel α γ
hκν : κ.fst ≤ ν
inst✝ : IsFiniteKernel ν
a : α
s : Set β
hs : MeasurableSet s
A : Set γ
hA : MeasurableSet A
this : IsFiniteKernel κ
⊢ ∫⁻ (x : γ) in A, ENNReal.ofReal (κ.density ν a x s) ∂ν a = (κ a) (A ×ˢ s)
tactic: have : IsFiniteKernel κ := isFiniteKernel_of_isFiniteKernel_fst (h := isFiniteKernel_of_le hκν)
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
mγ : MeasurableSpace γ
inst✝¹ : CountablyGenerated γ
κ : Kernel α (γ × β)
ν : Kernel α γ
hκν : κ.fst ≤ ν
inst✝ : IsFiniteKernel ν
a : α
s : Set β
hs : MeasurableSet s
A : Set γ
hA : MeasurableSet A
this : IsFiniteKernel κ
⊢ ∫⁻ (x : γ) in A, ENNReal.ofReal (κ.density ν a x s) ∂ν a = (κ a) (A ×ˢ s)
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
mγ : MeasurableSpace γ
inst✝¹ : CountablyGenerated γ
κ : Kernel α (γ × β)
ν : Kernel α γ
hκν : κ.fst ≤ ν
inst✝ : IsFiniteKernel ν
a : α
s : Set β
hs : MeasurableSet s
A : Set γ
hA : MeasurableSet A
this : IsFiniteKernel κ
⊢ ENNReal.ofReal (∫ (x : γ) in A, κ.density ν a x s ∂ν a) = (κ a) (A ×ˢ s)

case hfi
α : Type u_1
β : Type u_2
γ : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
mγ : MeasurableSpace γ
inst✝¹ : CountablyGenerated γ
κ : Kernel α (γ × β)
ν : Kernel α γ
hκν : κ.fst ≤ ν
inst✝ : IsFiniteKernel ν
a : α
s : Set β
hs : MeasurableSet s
A : Set γ
hA : MeasurableSet A
this : IsFiniteKernel κ
⊢ Integrable (fun x => κ.density ν a x s) ((ν a).restrict A)

case f_nn
α : Type u_1
β : Type u_2
γ : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
mγ : MeasurableSpace γ
inst✝¹ : CountablyGenerated γ
κ : Kernel α (γ × β)
ν : Kernel α γ
hκν : κ.fst ≤ ν
inst✝ : IsFiniteKernel ν
a : α
s : Set β
hs : MeasurableSet s
A : Set γ
hA : MeasurableSet A
this : IsFiniteKernel κ
⊢ 0 ≤ᶠ[ae ((ν a).restrict A)] fun x => κ.density ν a x s
tactic: rw [← ofReal_integral_eq_lintegral_ofReal]
Theorem: Set.ite_compl
File: Mathlib/Data/Set/Basic.lean

Proof steps:
state_before: α : Type u
β : Type v
γ : Type w
ι : Sort x
a b : α
s✝ s₁ s₂ t✝ t₁ t₂ u t s s' : Set α
⊢ tᶜ.ite s s' = t.ite s' s
state_after: no goals
tactic: rw [Set.ite, Set.ite, diff_compl, union_comm, diff_eq]
Theorem: Polynomial.erase_mem_lifts
File: Mathlib/Algebra/Polynomial/Lifts.lean

Proof steps:
state_before: R : Type u
inst✝¹ : Semiring R
S : Type v
inst✝ : Semiring S
f : R →+* S
p : S[X]
n : ℕ
h : p ∈ lifts f
⊢ erase n p ∈ lifts f
state_after: R : Type u
inst✝¹ : Semiring R
S : Type v
inst✝ : Semiring S
f : R →+* S
p : S[X]
n : ℕ
h : ∀ (n : ℕ), p.coeff n ∈ f.rangeS
⊢ ∀ (n_1 : ℕ), (erase n p).coeff n_1 ∈ f.rangeS
tactic: rw [lifts_iff_ringHom_rangeS, mem_map_rangeS] at h ⊢
state_before: R : Type u
inst✝¹ : Semiring R
S : Type v
inst✝ : Semiring S
f : R →+* S
p : S[X]
n : ℕ
h : ∀ (n : ℕ), p.coeff n ∈ f.rangeS
⊢ ∀ (n_1 : ℕ), (erase n p).coeff n_1 ∈ f.rangeS
state_after: R : Type u
inst✝¹ : Semiring R
S : Type v
inst✝ : Semiring S
f : R →+* S
p : S[X]
n : ℕ
h : ∀ (n : ℕ), p.coeff n ∈ f.rangeS
k : ℕ
⊢ (erase n p).coeff k ∈ f.rangeS
tactic: intro k
state_before: R : Type u
inst✝¹ : Semiring R
S : Type v
inst✝ : Semiring S
f : R →+* S
p : S[X]
n : ℕ
h : ∀ (n : ℕ), p.coeff n ∈ f.rangeS
k : ℕ
⊢ (erase n p).coeff k ∈ f.rangeS
state_after: case pos
R : Type u
inst✝¹ : Semiring R
S : Type v
inst✝ : Semiring S
f : R →+* S
p : S[X]
n : ℕ
h : ∀ (n : ℕ), p.coeff n ∈ f.rangeS
k : ℕ
hk : k = n
⊢ (erase n p).coeff k ∈ f.rangeS

case neg
R : Type u
inst✝¹ : Semiring R
S : Type v
inst✝ : Semiring S
f : R →+* S
p : S[X]
n : ℕ
h : ∀ (n : ℕ), p.coeff n ∈ f.rangeS
k : ℕ
hk : ¬k = n
⊢ (erase n p).coeff k ∈ f.rangeS
tactic: by_cases hk : k = n
state_before: case neg
R : Type u
inst✝¹ : Semiring R
S : Type v
inst✝ : Semiring S
f : R →+* S
p : S[X]
n : ℕ
h : ∀ (n : ℕ), p.coeff n ∈ f.rangeS
k : ℕ
hk : ¬k = n
⊢ (erase n p).coeff k ∈ f.rangeS
state_after: case neg.intro
R : Type u
inst✝¹ : Semiring R
S : Type v
inst✝ : Semiring S
f : R →+* S
p : S[X]
n : ℕ
h : ∀ (n : ℕ), p.coeff n ∈ f.rangeS
k : ℕ
hk : ¬k = n
i : R
hi : f i = p.coeff k
⊢ (erase n p).coeff k ∈ f.rangeS
tactic: obtain ⟨i, hi⟩ := h k
state_before: case neg.intro
R : Type u
inst✝¹ : Semiring R
S : Type v
inst✝ : Semiring S
f : R →+* S
p : S[X]
n : ℕ
h : ∀ (n : ℕ), p.coeff n ∈ f.rangeS
k : ℕ
hk : ¬k = n
i : R
hi : f i = p.coeff k
⊢ (erase n p).coeff k ∈ f.rangeS
state_after: case h
R : Type u
inst✝¹ : Semiring R
S : Type v
inst✝ : Semiring S
f : R →+* S
p : S[X]
n : ℕ
h : ∀ (n : ℕ), p.coeff n ∈ f.rangeS
k : ℕ
hk : ¬k = n
i : R
hi : f i = p.coeff k
⊢ f i = (erase n p).coeff k
tactic: use i
state_before: case h
R : Type u
inst✝¹ : Semiring R
S : Type v
inst✝ : Semiring S
f : R →+* S
p : S[X]
n : ℕ
h : ∀ (n : ℕ), p.coeff n ∈ f.rangeS
k : ℕ
hk : ¬k = n
i : R
hi : f i = p.coeff k
⊢ f i = (erase n p).coeff k
state_after: no goals
tactic: simp only [hi, hk, erase_ne, Ne, not_false_iff]
Theorem: DoubleCentralizer.coe_eq_algebraMap
File: Mathlib/Analysis/CstarAlgebra/Multiplier.lean

Proof steps:
state_before: 𝕜 : Type u_1
A : Type u_2
inst✝⁴ : NontriviallyNormedField 𝕜
inst✝³ : NonUnitalNormedRing A
inst✝² : NormedSpace 𝕜 A
inst✝¹ : SMulCommClass 𝕜 A A
inst✝ : IsScalarTower 𝕜 A A
⊢ ↑𝕜 = ⇑(algebraMap 𝕜 𝓜(𝕜, 𝕜))
state_after: case h.h.a
𝕜 : Type u_1
A : Type u_2
inst✝⁴ : NontriviallyNormedField 𝕜
inst✝³ : NonUnitalNormedRing A
inst✝² : NormedSpace 𝕜 A
inst✝¹ : SMulCommClass 𝕜 A A
inst✝ : IsScalarTower 𝕜 A A
x : 𝕜
⊢ (↑𝕜 x).toProd.1 = ((algebraMap 𝕜 𝓜(𝕜, 𝕜)) x).toProd.1

case h.h.a
𝕜 : Type u_1
A : Type u_2
inst✝⁴ : NontriviallyNormedField 𝕜
inst✝³ : NonUnitalNormedRing A
inst✝² : NormedSpace 𝕜 A
inst✝¹ : SMulCommClass 𝕜 A A
inst✝ : IsScalarTower 𝕜 A A
x : 𝕜
⊢ (↑𝕜 x).toProd.2 = ((algebraMap 𝕜 𝓜(𝕜, 𝕜)) x).toProd.2
tactic: ext x : 3
Theorem: inv_cthickening
File: Mathlib/Analysis/Normed/Group/Pointwise.lean

Proof steps:
state_before: E : Type u_1
inst✝ : SeminormedCommGroup E
ε δ : ℝ
s t : Set E
x y : E
⊢ (cthickening δ s)⁻¹ = cthickening δ s⁻¹
state_after: E : Type u_1
inst✝ : SeminormedCommGroup E
ε δ : ℝ
s t : Set E
x y : E
⊢ {x | EMetric.infEdist x s ≤ ENNReal.ofReal δ}⁻¹ = {x | EMetric.infEdist x⁻¹ s ≤ ENNReal.ofReal δ}
tactic: simp_rw [cthickening, ← infEdist_inv]
state_before: E : Type u_1
inst✝ : SeminormedCommGroup E
ε δ : ℝ
s t : Set E
x y : E
⊢ {x | EMetric.infEdist x s ≤ ENNReal.ofReal δ}⁻¹ = {x | EMetric.infEdist x⁻¹ s ≤ ENNReal.ofReal δ}
state_after: no goals
tactic: rfl
Theorem: iSup_range'
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✝ : SupSet α
f✝ g✝ : ι → α
g : β → α
f : ι → β
⊢ ⨆ b, g ↑b = ⨆ i, g (f i)
state_after: α : 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✝ : SupSet α
f✝ g✝ : ι → α
g : β → α
f : ι → β
⊢ sSup (range (g ∘ f)) = sSup (range fun i => g (f i))
tactic: rw [iSup, iSup, ← image_eq_range, ← range_comp]
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✝ : SupSet α
f✝ g✝ : ι → α
g : β → α
f : ι → β
⊢ sSup (range (g ∘ f)) = sSup (range fun i => g (f i))
state_after: no goals
tactic: rfl
Theorem: Affine.Simplex.face_centroid_eq_iff
File: Mathlib/LinearAlgebra/AffineSpace/Independent.lean

Proof steps:
state_before: k : Type u_1
V : Type u_2
P : Type u_3
inst✝⁴ : DivisionRing k
inst✝³ : AddCommGroup V
inst✝² : Module k V
inst✝¹ : AffineSpace V P
inst✝ : CharZero k
n : ℕ
s : Simplex k P n
fs₁ fs₂ : Finset (Fin (n + 1))
m₁ m₂ : ℕ
h₁ : fs₁.card = m₁ + 1
h₂ : fs₂.card = m₂ + 1
⊢ centroid k univ (s.face h₁).points = centroid k univ (s.face h₂).points ↔ fs₁ = fs₂
state_after: k : Type u_1
V : Type u_2
P : Type u_3
inst✝⁴ : DivisionRing k
inst✝³ : AddCommGroup V
inst✝² : Module k V
inst✝¹ : AffineSpace V P
inst✝ : CharZero k
n : ℕ
s : Simplex k P n
fs₁ fs₂ : Finset (Fin (n + 1))
m₁ m₂ : ℕ
h₁ : fs₁.card = m₁ + 1
h₂ : fs₂.card = m₂ + 1
⊢ centroid k fs₁ s.points = centroid k fs₂ s.points ↔ fs₁ = fs₂
tactic: rw [face_centroid_eq_centroid, face_centroid_eq_centroid]
state_before: k : Type u_1
V : Type u_2
P : Type u_3
inst✝⁴ : DivisionRing k
inst✝³ : AddCommGroup V
inst✝² : Module k V
inst✝¹ : AffineSpace V P
inst✝ : CharZero k
n : ℕ
s : Simplex k P n
fs₁ fs₂ : Finset (Fin (n + 1))
m₁ m₂ : ℕ
h₁ : fs₁.card = m₁ + 1
h₂ : fs₂.card = m₂ + 1
⊢ centroid k fs₁ s.points = centroid k fs₂ s.points ↔ fs₁ = fs₂
state_after: no goals
tactic: exact s.centroid_eq_iff h₁ h₂
Theorem: geom_sum₂_self
File: Mathlib/Algebra/GeomSum.lean

Proof steps:
state_before: α✝ : Type u
α : Type u_1
inst✝ : CommRing α
x : α
n : ℕ
⊢ ∑ i ∈ range n, x ^ i * x ^ (n - 1 - i) = ∑ i ∈ range n, x ^ (i + (n - 1 - i))
state_after: no goals
tactic: simp_rw [← pow_add]
state_before: α✝ : Type u
α : Type u_1
inst✝ : CommRing α
x : α
n : ℕ
⊢ (range n).card • x ^ (n - 1) = ↑n * x ^ (n - 1)
state_after: no goals
tactic: rw [Finset.card_range, nsmul_eq_mul]
Theorem: LinearMap.isCompl_iSup_ker_pow_iInf_range_pow
File: Mathlib/RingTheory/Artinian.lean

Proof steps:
state_before: R : Type u_1
M : Type u_2
inst✝⁴ : Ring R
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : IsArtinian R M
inst✝ : IsNoetherian R M
f : M →ₗ[R] M
⊢ IsCompl (⨆ n, ker (f ^ n)) (⨅ n, range (f ^ n))
state_after: case intro
R : Type u_1
M : Type u_2
inst✝⁴ : Ring R
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : IsArtinian R M
inst✝ : IsNoetherian R M
f : M →ₗ[R] M
k : ℕ
hk :
  ∀ b ≥ k, IsCompl (ker (f ^ b)) (range (f ^ b)) ∧ ⨅ m, range (f ^ m) = range (f ^ b) ∧ ⨆ m, ker (f ^ m) = ker (f ^ b)
⊢ IsCompl (⨆ n, ker (f ^ n)) (⨅ n, range (f ^ n))
tactic: obtain ⟨k, hk⟩ := eventually_atTop.mp <| f.eventually_isCompl_ker_pow_range_pow.and <|
    f.eventually_iInf_range_pow_eq.and f.eventually_iSup_ker_pow_eq
state_before: case intro
R : Type u_1
M : Type u_2
inst✝⁴ : Ring R
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : IsArtinian R M
inst✝ : IsNoetherian R M
f : M →ₗ[R] M
k : ℕ
hk :
  ∀ b ≥ k, IsCompl (ker (f ^ b)) (range (f ^ b)) ∧ ⨅ m, range (f ^ m) = range (f ^ b) ∧ ⨆ m, ker (f ^ m) = ker (f ^ b)
⊢ IsCompl (⨆ n, ker (f ^ n)) (⨅ n, range (f ^ n))
state_after: case intro.intro.intro
R : Type u_1
M : Type u_2
inst✝⁴ : Ring R
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : IsArtinian R M
inst✝ : IsNoetherian R M
f : M →ₗ[R] M
k : ℕ
hk :
  ∀ b ≥ k, IsCompl (ker (f ^ b)) (range (f ^ b)) ∧ ⨅ m, range (f ^ m) = range (f ^ b) ∧ ⨆ m, ker (f ^ m) = ker (f ^ b)
h₁ : IsCompl (ker (f ^ k)) (range (f ^ k))
h₂ : ⨅ m, range (f ^ m) = range (f ^ k)
h₃ : ⨆ m, ker (f ^ m) = ker (f ^ k)
⊢ IsCompl (⨆ n, ker (f ^ n)) (⨅ n, range (f ^ n))
tactic: obtain ⟨h₁, h₂, h₃⟩ := hk k (le_refl k)
state_before: case intro.intro.intro
R : Type u_1
M : Type u_2
inst✝⁴ : Ring R
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : IsArtinian R M
inst✝ : IsNoetherian R M
f : M →ₗ[R] M
k : ℕ
hk :
  ∀ b ≥ k, IsCompl (ker (f ^ b)) (range (f ^ b)) ∧ ⨅ m, range (f ^ m) = range (f ^ b) ∧ ⨆ m, ker (f ^ m) = ker (f ^ b)
h₁ : IsCompl (ker (f ^ k)) (range (f ^ k))
h₂ : ⨅ m, range (f ^ m) = range (f ^ k)
h₃ : ⨆ m, ker (f ^ m) = ker (f ^ k)
⊢ IsCompl (⨆ n, ker (f ^ n)) (⨅ n, range (f ^ n))
state_after: no goals
tactic: rwa [h₂, h₃]
Theorem: Submodule.LinearDisjoint.not_linearIndependent_pair_of_commute_of_flat
File: Mathlib/LinearAlgebra/LinearDisjoint.lean

Proof steps:
state_before: R : Type u
S : Type v
inst✝³ : CommRing R
inst✝² : Ring S
inst✝¹ : Algebra R S
M N : Submodule R S
H : M.LinearDisjoint N
inst✝ : Nontrivial R
hf : Module.Flat R ↥M ∨ Module.Flat R ↥N
a b : ↥(M ⊓ N)
hc : Commute ↑a ↑b
⊢ ¬LinearIndependent R ![a, b]
state_after: case inl
R : Type u
S : Type v
inst✝³ : CommRing R
inst✝² : Ring S
inst✝¹ : Algebra R S
M N : Submodule R S
H : M.LinearDisjoint N
inst✝ : Nontrivial R
a b : ↥(M ⊓ N)
hc : Commute ↑a ↑b
h✝ : Module.Flat R ↥M
⊢ ¬LinearIndependent R ![a, b]

case inr
R : Type u
S : Type v
inst✝³ : CommRing R
inst✝² : Ring S
inst✝¹ : Algebra R S
M N : Submodule R S
H : M.LinearDisjoint N
inst✝ : Nontrivial R
a b : ↥(M ⊓ N)
hc : Commute ↑a ↑b
h✝ : Module.Flat R ↥N
⊢ ¬LinearIndependent R ![a, b]
tactic: rcases hf with _ | _
Theorem: DihedralGroup.r_one_pow
File: Mathlib/GroupTheory/SpecificGroups/Dihedral.lean

Proof steps:
state_before: n k : ℕ
⊢ r 1 ^ k = r ↑k
state_after: case zero
n : ℕ
⊢ r 1 ^ 0 = r ↑0

case succ
n k : ℕ
IH : r 1 ^ k = r ↑k
⊢ r 1 ^ (k + 1) = r ↑(k + 1)
tactic: induction' k with k IH
Theorem: Submonoid.mem_iInf
File: Mathlib/Algebra/Group/Submonoid/Basic.lean

Proof steps:
state_before: M : Type u_1
N : Type u_2
A : Type u_3
inst✝¹ : MulOneClass M
s : Set M
inst✝ : AddZeroClass A
t : Set A
S✝ : Submonoid M
ι : Sort u_4
S : ι → Submonoid M
x : M
⊢ x ∈ ⨅ i, S i ↔ ∀ (i : ι), x ∈ S i
state_after: no goals
tactic: simp only [iInf, mem_sInf, Set.forall_mem_range]
Theorem: Polynomial.map_roots_le
File: Mathlib/Algebra/Polynomial/Roots.lean

Proof steps:
state_before: R : Type u
S : Type v
T : Type w
a b : R
n : ℕ
A : Type u_1
B : Type u_2
inst✝³ : CommRing A
inst✝² : CommRing B
inst✝¹ : IsDomain A
inst✝ : IsDomain B
p : A[X]
f : A →+* B
h : map f p ≠ 0
⊢ Multiset.map (⇑f) p.roots ≤ (map f p).roots
state_after: no goals
tactic: classical
  exact Multiset.le_iff_count.2 fun b => by
    rw [count_roots]
    apply count_map_roots h