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

Proof steps:
state_before: V : Type u_1
inst✝¹ : NormedAddCommGroup V
inst✝ : InnerProductSpace ℝ V
x y : V
h : ⟪x, y⟫_ℝ = 0
h0 : x ≠ 0 ∨ y ≠ 0
hxy : ‖x + y‖ ^ 2 ≠ 0
⊢ angle x (x + y) = Real.arcsin (‖y‖ / ‖x + y‖)
state_after: V : Type u_1
inst✝¹ : NormedAddCommGroup V
inst✝ : InnerProductSpace ℝ V
x y : V
h : ⟪x, y⟫_ℝ = 0
h0 : x ≠ 0 ∨ y ≠ 0
hxy : ‖x + y‖ ^ 2 ≠ 0
⊢ Real.arcsin √((‖x + y‖ ^ 2 - ‖x‖ ^ 2) / ‖x + y‖ ^ 2) = Real.arcsin (‖y‖ / ‖x + y‖)
tactic: rw [angle_add_eq_arccos_of_inner_eq_zero h,
    Real.arccos_eq_arcsin (div_nonneg (norm_nonneg _) (norm_nonneg _)), div_pow, one_sub_div hxy]
state_before: V : Type u_1
inst✝¹ : NormedAddCommGroup V
inst✝ : InnerProductSpace ℝ V
x y : V
h : ⟪x, y⟫_ℝ = 0
h0 : x ≠ 0 ∨ y ≠ 0
hxy : ‖x + y‖ ^ 2 ≠ 0
⊢ Real.arcsin √((‖x + y‖ ^ 2 - ‖x‖ ^ 2) / ‖x + y‖ ^ 2) = Real.arcsin (‖y‖ / ‖x + y‖)
state_after: V : Type u_1
inst✝¹ : NormedAddCommGroup V
inst✝ : InnerProductSpace ℝ V
x y : V
h : ⟪x, y⟫_ℝ = 0
h0 : x ≠ 0 ∨ y ≠ 0
hxy : ‖x + y‖ ^ 2 ≠ 0
⊢ Real.arcsin √((‖x + y‖ * ‖x + y‖ - ‖x‖ ^ 2) / ‖x + y‖ ^ 2) = Real.arcsin (‖y‖ / ‖x + y‖)
tactic: nth_rw 1 [pow_two]
state_before: V : Type u_1
inst✝¹ : NormedAddCommGroup V
inst✝ : InnerProductSpace ℝ V
x y : V
h : ⟪x, y⟫_ℝ = 0
h0 : x ≠ 0 ∨ y ≠ 0
hxy : ‖x + y‖ ^ 2 ≠ 0
⊢ Real.arcsin √((‖x + y‖ * ‖x + y‖ - ‖x‖ ^ 2) / ‖x + y‖ ^ 2) = Real.arcsin (‖y‖ / ‖x + y‖)
state_after: no goals
tactic: rw [norm_add_sq_eq_norm_sq_add_norm_sq_real h, pow_two, add_sub_cancel_left, ← pow_two, ← div_pow,
    Real.sqrt_sq (div_nonneg (norm_nonneg _) (norm_nonneg _))]
Theorem: Finpartition.IsEquipartition.filter_ne_average_add_one_eq_average
File: Mathlib/Order/Partition/Equipartition.lean

Proof steps:
state_before: α : Type u_1
inst✝ : DecidableEq α
s t : Finset α
P : Finpartition s
hP : P.IsEquipartition
⊢ filter (fun p => ¬p.card = s.card / P.parts.card + 1) P.parts =
    filter (fun p => p.card = s.card / P.parts.card) P.parts
state_after: case a
α : Type u_1
inst✝ : DecidableEq α
s t : Finset α
P : Finpartition s
hP : P.IsEquipartition
p : Finset α
⊢ p ∈ filter (fun p => ¬p.card = s.card / P.parts.card + 1) P.parts ↔
    p ∈ filter (fun p => p.card = s.card / P.parts.card) P.parts
tactic: ext p
state_before: case a
α : Type u_1
inst✝ : DecidableEq α
s t : Finset α
P : Finpartition s
hP : P.IsEquipartition
p : Finset α
⊢ p ∈ filter (fun p => ¬p.card = s.card / P.parts.card + 1) P.parts ↔
    p ∈ filter (fun p => p.card = s.card / P.parts.card) P.parts
state_after: case a
α : Type u_1
inst✝ : DecidableEq α
s t : Finset α
P : Finpartition s
hP : P.IsEquipartition
p : Finset α
⊢ p ∈ P.parts → (¬p.card = s.card / P.parts.card + 1 ↔ p.card = s.card / P.parts.card)
tactic: simp only [mem_filter, and_congr_right_iff]
state_before: case a
α : Type u_1
inst✝ : DecidableEq α
s t : Finset α
P : Finpartition s
hP : P.IsEquipartition
p : Finset α
⊢ p ∈ P.parts → (¬p.card = s.card / P.parts.card + 1 ↔ p.card = s.card / P.parts.card)
state_after: no goals
tactic: exact fun hp ↦ (hP.card_part_eq_average_iff hp).symm
Theorem: Configuration.ProjectivePlane.lineCount_eq
File: Mathlib/Combinatorics/Configuration.lean

Proof steps:
state_before: P : Type u_1
L : Type u_2
inst✝³ : Membership P L
inst✝² : ProjectivePlane P L
inst✝¹ : Finite P
inst✝ : Finite L
p : P
⊢ lineCount L p = order P L + 1
state_after: no goals
tactic: classical
    obtain ⟨q, -, -, l, -, -, -, -, h, -⟩ := Classical.choose_spec (@exists_config P L _ _)
    cases nonempty_fintype { l : L // q ∈ l }
    rw [order, lineCount_eq_lineCount L p q, lineCount_eq_lineCount L (Classical.choose _) q,
      lineCount, Nat.card_eq_fintype_card, Nat.sub_add_cancel]
    exact Fintype.card_pos_iff.mpr ⟨⟨l, h⟩⟩
Theorem: iteratedDerivWithin_sub
File: Mathlib/Analysis/Calculus/IteratedDeriv/Lemmas.lean

Proof steps:
state_before: 𝕜 : Type u_1
inst✝⁶ : NontriviallyNormedField 𝕜
F : Type u_2
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
R : Type u_3
inst✝³ : Semiring R
inst✝² : Module R F
inst✝¹ : SMulCommClass 𝕜 R F
inst✝ : ContinuousConstSMul R F
n : ℕ
x : 𝕜
s : Set 𝕜
hx : x ∈ s
h : UniqueDiffOn 𝕜 s
f g : 𝕜 → F
hf : ContDiffOn 𝕜 (↑n) f s
hg : ContDiffOn 𝕜 (↑n) g s
⊢ iteratedDerivWithin n (f - g) s x = iteratedDerivWithin n f s x - iteratedDerivWithin n g s x
state_after: no goals
tactic: rw [sub_eq_add_neg, sub_eq_add_neg, Pi.neg_def, iteratedDerivWithin_add hx h hf hg.neg,
    iteratedDerivWithin_neg' hx h]
Theorem: sdiff_eq_sdiff_iff
File: Mathlib/Order/Heyting/Basic.lean

Proof steps:
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
inst✝ : GeneralizedCoheytingAlgebra α
a b c d : α
⊢ a \ b = b \ a ↔ a = b
state_after: no goals
tactic: simp [le_antisymm_iff]
Theorem: Finset.one_le_prod'
File: Mathlib/Algebra/Order/BigOperators/Group/Finset.lean

Proof steps:
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
M : Type u_4
N : Type u_5
G : Type u_6
k : Type u_7
R : Type u_8
inst✝¹ : CommMonoid M
inst✝ : OrderedCommMonoid N
f g : ι → N
s t : Finset ι
h : ∀ i ∈ s, 1 ≤ f i
⊢ 1 ≤ ∏ i ∈ s, 1
state_after: no goals
tactic: rw [prod_const_one]
Theorem: Set.prod_image_image_eq
File: Mathlib/Data/Set/Prod.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
s s₁ s₂ : Set α
t t₁ t₂ : Set β
a : α
b : β
m₁ : α → γ
m₂ : β → δ
⊢ ∀ (x : γ × δ), x ∈ (m₁ '' s) ×ˢ (m₂ '' t) ↔ x ∈ (fun p => (m₁ p.1, m₂ p.2)) '' s ×ˢ t
state_after: no goals
tactic: simp [-exists_and_right, exists_and_right.symm, and_left_comm, and_assoc, and_comm]
Theorem: CategoryTheory.Abelian.Ext.ext_iff
File: Mathlib/Algebra/Homology/DerivedCategory/Ext.lean

Proof steps:
state_before: C : Type u
inst✝³ : Category.{v, u} C
inst✝² : Abelian C
inst✝¹ : HasExt C
X Y Z T : C
inst✝ : HasDerivedCategory C
n : ℕ
α β : Ext X Y n
h : α = β
⊢ α.hom = β.hom
state_after: no goals
tactic: rw [h]
Theorem: LinearMap.ext_ring
File: Mathlib/Algebra/Module/LinearMap/Defs.lean

Proof steps:
state_before: R : Type u_1
R₁ : Type u_2
R₂ : Type u_3
R₃ : Type u_4
k : Type u_5
S : Type u_6
S₃ : Type u_7
T : Type u_8
M : Type u_9
M₁ : Type u_10
M₂ : Type u_11
M₃ : Type u_12
N₁ : Type u_13
N₂ : Type u_14
N₃ : Type u_15
ι : Type u_16
inst✝¹¹ : Semiring R
inst✝¹⁰ : Semiring S
inst✝⁹ : AddCommMonoid M
inst✝⁸ : AddCommMonoid M₁
inst✝⁷ : AddCommMonoid M₂
inst✝⁶ : AddCommMonoid M₃
inst✝⁵ : AddCommMonoid N₁
inst✝⁴ : AddCommMonoid N₂
inst✝³ : AddCommMonoid N₃
inst✝² : Module R M
inst✝¹ : Module R M₂
inst✝ : Module S M₃
σ : R →+* S
fₗ gₗ : M →ₗ[R] M₂
f✝ g✝ : M →ₛₗ[σ] M₃
f g : R →ₛₗ[σ] M₃
h : f 1 = g 1
x : R
⊢ f x = g x
state_after: no goals
tactic: rw [← mul_one x, ← smul_eq_mul, f.map_smulₛₗ, g.map_smulₛₗ, h]
Theorem: mul_rotate
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✝ : CommSemigroup G
a b c : G
⊢ a * b * c = b * c * a
state_after: no goals
tactic: simp only [mul_left_comm, mul_comm]
Theorem: CategoryTheory.Functor.mapTriangleRotateIso_hom_app_hom₂
File: Mathlib/CategoryTheory/Triangulated/Functor.lean

Proof steps:
state_before: C : Type u_1
D : Type u_2
E : Type u_3
inst✝¹⁰ : Category.{?u.192876, u_1} C
inst✝⁹ : Category.{?u.192880, u_2} D
inst✝⁸ : Category.{?u.192884, u_3} E
inst✝⁷ : HasShift C ℤ
inst✝⁶ : HasShift D ℤ
inst✝⁵ : HasShift E ℤ
F : C ⥤ D
inst✝⁴ : F.CommShift ℤ
G : D ⥤ E
inst✝³ : G.CommShift ℤ
inst✝² : Preadditive C
inst✝¹ : Preadditive D
inst✝ : F.Additive
T : Triangle C
⊢ ((F.mapTriangle ⋙ rotate D).obj T).mor₁ ≫ (Iso.refl ((F.mapTriangle ⋙ rotate D).obj T).obj₂).hom =
    (Iso.refl ((F.mapTriangle ⋙ rotate D).obj T).obj₁).hom ≫ ((rotate C ⋙ F.mapTriangle).obj T).mor₁
state_after: no goals
tactic: aesop_cat
state_before: C : Type u_1
D : Type u_2
E : Type u_3
inst✝¹⁰ : Category.{?u.192876, u_1} C
inst✝⁹ : Category.{?u.192880, u_2} D
inst✝⁸ : Category.{?u.192884, u_3} E
inst✝⁷ : HasShift C ℤ
inst✝⁶ : HasShift D ℤ
inst✝⁵ : HasShift E ℤ
F : C ⥤ D
inst✝⁴ : F.CommShift ℤ
G : D ⥤ E
inst✝³ : G.CommShift ℤ
inst✝² : Preadditive C
inst✝¹ : Preadditive D
inst✝ : F.Additive
T : Triangle C
⊢ ((F.mapTriangle ⋙ rotate D).obj T).mor₂ ≫ ((F.commShiftIso 1).symm.app T.obj₁).hom =
    (Iso.refl ((F.mapTriangle ⋙ rotate D).obj T).obj₂).hom ≫ ((rotate C ⋙ F.mapTriangle).obj T).mor₂
state_after: no goals
tactic: aesop_cat
state_before: C : Type u_1
D : Type u_2
E : Type u_3
inst✝¹⁰ : Category.{?u.192876, u_1} C
inst✝⁹ : Category.{?u.192880, u_2} D
inst✝⁸ : Category.{?u.192884, u_3} E
inst✝⁷ : HasShift C ℤ
inst✝⁶ : HasShift D ℤ
inst✝⁵ : HasShift E ℤ
F : C ⥤ D
inst✝⁴ : F.CommShift ℤ
G : D ⥤ E
inst✝³ : G.CommShift ℤ
inst✝² : Preadditive C
inst✝¹ : Preadditive D
inst✝ : F.Additive
T : Triangle C
⊢ ((F.mapTriangle ⋙ rotate D).obj T).mor₃ ≫
      (shiftFunctor D 1).map (Iso.refl ((F.mapTriangle ⋙ rotate D).obj T).obj₁).hom =
    ((F.commShiftIso 1).symm.app T.obj₁).hom ≫ ((rotate C ⋙ F.mapTriangle).obj T).mor₃
state_after: no goals
tactic: aesop_cat
state_before: C : Type u_1
D : Type u_2
E : Type u_3
inst✝¹⁰ : Category.{?u.192876, u_1} C
inst✝⁹ : Category.{?u.192880, u_2} D
inst✝⁸ : Category.{?u.192884, u_3} E
inst✝⁷ : HasShift C ℤ
inst✝⁶ : HasShift D ℤ
inst✝⁵ : HasShift E ℤ
F : C ⥤ D
inst✝⁴ : F.CommShift ℤ
G : D ⥤ E
inst✝³ : G.CommShift ℤ
inst✝² : Preadditive C
inst✝¹ : Preadditive D
inst✝ : F.Additive
⊢ ∀ {X Y : Triangle C} (f : X ⟶ Y),
    (F.mapTriangle ⋙ rotate D).map f ≫
        ((fun T =>
              ((F.mapTriangle ⋙ rotate D).obj T).isoMk ((rotate C ⋙ F.mapTriangle).obj T)
                (Iso.refl ((F.mapTriangle ⋙ rotate D).obj T).obj₁) (Iso.refl ((F.mapTriangle ⋙ rotate D).obj T).obj₂)
                ((F.commShiftIso 1).symm.app T.obj₁) ⋯ ⋯ ⋯)
            Y).hom =
      ((fun T =>
              ((F.mapTriangle ⋙ rotate D).obj T).isoMk ((rotate C ⋙ F.mapTriangle).obj T)
                (Iso.refl ((F.mapTriangle ⋙ rotate D).obj T).obj₁) (Iso.refl ((F.mapTriangle ⋙ rotate D).obj T).obj₂)
                ((F.commShiftIso 1).symm.app T.obj₁) ⋯ ⋯ ⋯)
            X).hom ≫
        (rotate C ⋙ F.mapTriangle).map f
state_after: no goals
tactic: aesop_cat
Theorem: MeasureTheory.SimpleFunc.setToSimpleFunc_smul_real
File: Mathlib/MeasureTheory/Integral/SetToL1.lean

Proof steps:
state_before: α : Type u_1
E : Type u_2
F : Type u_3
F' : Type u_4
G : Type u_5
𝕜 : Type u_6
p : ℝ≥0∞
inst✝⁶ : NormedAddCommGroup E
inst✝⁵ : NormedSpace ℝ E
inst✝⁴ : NormedAddCommGroup F
inst✝³ : NormedSpace ℝ F
inst✝² : NormedAddCommGroup F'
inst✝¹ : NormedSpace ℝ F'
inst✝ : NormedAddCommGroup G
m : MeasurableSpace α
μ : Measure α
T : Set α → E →L[ℝ] F
h_add : FinMeasAdditive μ T
c : ℝ
f : α →ₛ E
hf : Integrable (↑f) μ
⊢ setToSimpleFunc T (c • f) = ∑ x ∈ f.range, (T (↑f ⁻¹' {x})) (c • x)
state_after: α : Type u_1
E : Type u_2
F : Type u_3
F' : Type u_4
G : Type u_5
𝕜 : Type u_6
p : ℝ≥0∞
inst✝⁶ : NormedAddCommGroup E
inst✝⁵ : NormedSpace ℝ E
inst✝⁴ : NormedAddCommGroup F
inst✝³ : NormedSpace ℝ F
inst✝² : NormedAddCommGroup F'
inst✝¹ : NormedSpace ℝ F'
inst✝ : NormedAddCommGroup G
m : MeasurableSpace α
μ : Measure α
T : Set α → E →L[ℝ] F
h_add : FinMeasAdditive μ T
c : ℝ
f : α →ₛ E
hf : Integrable (↑f) μ
⊢ c • 0 = 0
tactic: rw [smul_eq_map c f, map_setToSimpleFunc T h_add hf]
state_before: α : Type u_1
E : Type u_2
F : Type u_3
F' : Type u_4
G : Type u_5
𝕜 : Type u_6
p : ℝ≥0∞
inst✝⁶ : NormedAddCommGroup E
inst✝⁵ : NormedSpace ℝ E
inst✝⁴ : NormedAddCommGroup F
inst✝³ : NormedSpace ℝ F
inst✝² : NormedAddCommGroup F'
inst✝¹ : NormedSpace ℝ F'
inst✝ : NormedAddCommGroup G
m : MeasurableSpace α
μ : Measure α
T : Set α → E →L[ℝ] F
h_add : FinMeasAdditive μ T
c : ℝ
f : α →ₛ E
hf : Integrable (↑f) μ
⊢ c • 0 = 0
state_after: no goals
tactic: rw [smul_zero]
state_before: α : Type u_1
E : Type u_2
F : Type u_3
F' : Type u_4
G : Type u_5
𝕜 : Type u_6
p : ℝ≥0∞
inst✝⁶ : NormedAddCommGroup E
inst✝⁵ : NormedSpace ℝ E
inst✝⁴ : NormedAddCommGroup F
inst✝³ : NormedSpace ℝ F
inst✝² : NormedAddCommGroup F'
inst✝¹ : NormedSpace ℝ F'
inst✝ : NormedAddCommGroup G
m : MeasurableSpace α
μ : Measure α
T : Set α → E →L[ℝ] F
h_add : FinMeasAdditive μ T
c : ℝ
f : α →ₛ E
hf : Integrable (↑f) μ
b : E
x✝ : b ∈ f.range
⊢ (T (↑f ⁻¹' {b})) (c • b) = c • (T (↑f ⁻¹' {b})) b
state_after: no goals
tactic: rw [ContinuousLinearMap.map_smul (T (f ⁻¹' {b})) c b]
state_before: α : Type u_1
E : Type u_2
F : Type u_3
F' : Type u_4
G : Type u_5
𝕜 : Type u_6
p : ℝ≥0∞
inst✝⁶ : NormedAddCommGroup E
inst✝⁵ : NormedSpace ℝ E
inst✝⁴ : NormedAddCommGroup F
inst✝³ : NormedSpace ℝ F
inst✝² : NormedAddCommGroup F'
inst✝¹ : NormedSpace ℝ F'
inst✝ : NormedAddCommGroup G
m : MeasurableSpace α
μ : Measure α
T : Set α → E →L[ℝ] F
h_add : FinMeasAdditive μ T
c : ℝ
f : α →ₛ E
hf : Integrable (↑f) μ
⊢ ∑ x ∈ f.range, c • (T (↑f ⁻¹' {x})) x = c • setToSimpleFunc T f
state_after: no goals
tactic: simp only [setToSimpleFunc, smul_sum, smul_smul, mul_comm]
Theorem: Nat.clog_mono_right
File: Mathlib/Data/Nat/Log.lean

Proof steps:
state_before: b n m : ℕ
h : n ≤ m
⊢ clog b n ≤ clog b m
state_after: case inl
b n m : ℕ
h : n ≤ m
hb : b ≤ 1
⊢ clog b n ≤ clog b m

case inr
b n m : ℕ
h : n ≤ m
hb : 1 < b
⊢ clog b n ≤ clog b m
tactic: rcases le_or_lt b 1 with hb | hb
Theorem: List.getElem_attach
File: Mathlib/Data/List/Basic.lean

Proof steps:
state_before: ι : Type u_1
α : Type u
β : Type v
γ : Type w
l₁ l₂ L : List α
i : ℕ
h : i < L.attach.length
⊢ i < (map Subtype.val L.attach).length
state_after: no goals
tactic: simpa using h
state_before: ι : Type u_1
α : Type u
β : Type v
γ : Type w
l₁ l₂ L : List α
i : ℕ
h : i < L.attach.length
⊢ ↑L.attach[i] = (map Subtype.val L.attach)[i]
state_after: no goals
tactic: rw [getElem_map]
state_before: ι : Type u_1
α : Type u
β : Type v
γ : Type w
l₁ l₂ L : List α
i : ℕ
h : i < L.attach.length
⊢ (map Subtype.val L.attach)[i] = L[i]
state_after: case e_xs
ι : Type u_1
α : Type u
β : Type v
γ : Type w
l₁ l₂ L : List α
i : ℕ
h : i < L.attach.length
⊢ map Subtype.val L.attach = L
tactic: congr 2
state_before: case e_xs
ι : Type u_1
α : Type u
β : Type v
γ : Type w
l₁ l₂ L : List α
i : ℕ
h : i < L.attach.length
⊢ map Subtype.val L.attach = L
state_after: no goals
tactic: simp
Theorem: Ordinal.toPGame_lf
File: Mathlib/SetTheory/Game/Ordinal.lean

Proof steps:
state_before: a b : Ordinal.{u_1}
h : a < b
⊢ a.toPGame ⧏ b.toPGame
state_after: case h.e'_1
a b : Ordinal.{u_1}
h : a < b
⊢ a.toPGame = b.toPGame.moveLeft (toLeftMovesToPGame ⟨a, h⟩)
tactic: convert moveLeft_lf (toLeftMovesToPGame ⟨a, h⟩)
state_before: case h.e'_1
a b : Ordinal.{u_1}
h : a < b
⊢ a.toPGame = b.toPGame.moveLeft (toLeftMovesToPGame ⟨a, h⟩)
state_after: no goals
tactic: rw [toPGame_moveLeft]
Theorem: LieModule.disjoint_weightSpace
File: Mathlib/Algebra/Lie/Weights/Basic.lean

Proof steps:
state_before: K : Type u_1
R : Type u_2
L : Type u_3
M : Type u_4
inst✝⁸ : CommRing R
inst✝⁷ : LieRing L
inst✝⁶ : LieAlgebra R L
inst✝⁵ : LieAlgebra.IsNilpotent R L
inst✝⁴ : AddCommGroup M
inst✝³ : Module R M
inst✝² : LieRingModule L M
inst✝¹ : LieModule R L M
inst✝ : NoZeroSMulDivisors R M
χ₁ χ₂ : L → R
h : χ₁ ≠ χ₂
⊢ Disjoint (weightSpace M χ₁) (weightSpace M χ₂)
state_after: case intro
K : Type u_1
R : Type u_2
L : Type u_3
M : Type u_4
inst✝⁸ : CommRing R
inst✝⁷ : LieRing L
inst✝⁶ : LieAlgebra R L
inst✝⁵ : LieAlgebra.IsNilpotent R L
inst✝⁴ : AddCommGroup M
inst✝³ : Module R M
inst✝² : LieRingModule L M
inst✝¹ : LieModule R L M
inst✝ : NoZeroSMulDivisors R M
χ₁ χ₂ : L → R
h : χ₁ ≠ χ₂
x : L
hx : χ₁ x ≠ χ₂ x
⊢ Disjoint (weightSpace M χ₁) (weightSpace M χ₂)
tactic: obtain ⟨x, hx⟩ : ∃ x, χ₁ x ≠ χ₂ x := Function.ne_iff.mp h
state_before: case intro
K : Type u_1
R : Type u_2
L : Type u_3
M : Type u_4
inst✝⁸ : CommRing R
inst✝⁷ : LieRing L
inst✝⁶ : LieAlgebra R L
inst✝⁵ : LieAlgebra.IsNilpotent R L
inst✝⁴ : AddCommGroup M
inst✝³ : Module R M
inst✝² : LieRingModule L M
inst✝¹ : LieModule R L M
inst✝ : NoZeroSMulDivisors R M
χ₁ χ₂ : L → R
h : χ₁ ≠ χ₂
x : L
hx : χ₁ x ≠ χ₂ x
⊢ Disjoint (weightSpace M χ₁) (weightSpace M χ₂)
state_after: no goals
tactic: exact (disjoint_weightSpaceOf R L M hx).mono
    (weightSpace_le_weightSpaceOf M x χ₁) (weightSpace_le_weightSpaceOf M x χ₂)
Theorem: MellinConvergent.div_const
File: Mathlib/Analysis/MellinTransform.lean

Proof steps:
state_before: E : Type u_1
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace ℂ E
f : ℝ → ℂ
s : ℂ
hf : MellinConvergent f s
a : ℂ
⊢ MellinConvergent (fun t => f t / a) s
state_after: no goals
tactic: simpa only [MellinConvergent, smul_eq_mul, ← mul_div_assoc] using hf.div_const a
Theorem: normal_exists_closure_subset
File: Mathlib/Topology/Separation.lean

Proof steps:
state_before: X : Type u_1
Y : Type u_2
inst✝¹ : TopologicalSpace X
inst✝ : NormalSpace X
s t : Set X
hs : IsClosed s
ht : IsOpen t
hst : s ⊆ t
⊢ ∃ u, IsOpen u ∧ s ⊆ u ∧ closure u ⊆ t
state_after: X : Type u_1
Y : Type u_2
inst✝¹ : TopologicalSpace X
inst✝ : NormalSpace X
s t : Set X
hs : IsClosed s
ht : IsOpen t
hst : s ⊆ t
this : Disjoint s tᶜ
⊢ ∃ u, IsOpen u ∧ s ⊆ u ∧ closure u ⊆ t
tactic: have : Disjoint s tᶜ := Set.disjoint_left.mpr fun x hxs hxt => hxt (hst hxs)
state_before: X : Type u_1
Y : Type u_2
inst✝¹ : TopologicalSpace X
inst✝ : NormalSpace X
s t : Set X
hs : IsClosed s
ht : IsOpen t
hst : s ⊆ t
this : Disjoint s tᶜ
⊢ ∃ u, IsOpen u ∧ s ⊆ u ∧ closure u ⊆ t
state_after: case intro.intro.intro.intro.intro.intro
X : Type u_1
Y : Type u_2
inst✝¹ : TopologicalSpace X
inst✝ : NormalSpace X
s t : Set X
hs : IsClosed s
ht : IsOpen t
hst : s ⊆ t
this : Disjoint s tᶜ
s' t' : Set X
hs' : IsOpen s'
ht' : IsOpen t'
hss' : s ⊆ s'
htt' : tᶜ ⊆ t'
hs't' : Disjoint s' t'
⊢ ∃ u, IsOpen u ∧ s ⊆ u ∧ closure u ⊆ t
tactic: rcases normal_separation hs (isClosed_compl_iff.2 ht) this with
    ⟨s', t', hs', ht', hss', htt', hs't'⟩
state_before: case intro.intro.intro.intro.intro.intro
X : Type u_1
Y : Type u_2
inst✝¹ : TopologicalSpace X
inst✝ : NormalSpace X
s t : Set X
hs : IsClosed s
ht : IsOpen t
hst : s ⊆ t
this : Disjoint s tᶜ
s' t' : Set X
hs' : IsOpen s'
ht' : IsOpen t'
hss' : s ⊆ s'
htt' : tᶜ ⊆ t'
hs't' : Disjoint s' t'
⊢ ∃ u, IsOpen u ∧ s ⊆ u ∧ closure u ⊆ t
state_after: case intro.intro.intro.intro.intro.intro
X : Type u_1
Y : Type u_2
inst✝¹ : TopologicalSpace X
inst✝ : NormalSpace X
s t : Set X
hs : IsClosed s
ht : IsOpen t
hst : s ⊆ t
this : Disjoint s tᶜ
s' t' : Set X
hs' : IsOpen s'
ht' : IsOpen t'
hss' : s ⊆ s'
htt' : tᶜ ⊆ t'
hs't' : Disjoint s' t'
⊢ s' ⊆ t'ᶜ
tactic: refine ⟨s', hs', hss', Subset.trans (closure_minimal ?_ (isClosed_compl_iff.2 ht'))
    (compl_subset_comm.1 htt')⟩
state_before: case intro.intro.intro.intro.intro.intro
X : Type u_1
Y : Type u_2
inst✝¹ : TopologicalSpace X
inst✝ : NormalSpace X
s t : Set X
hs : IsClosed s
ht : IsOpen t
hst : s ⊆ t
this : Disjoint s tᶜ
s' t' : Set X
hs' : IsOpen s'
ht' : IsOpen t'
hss' : s ⊆ s'
htt' : tᶜ ⊆ t'
hs't' : Disjoint s' t'
⊢ s' ⊆ t'ᶜ
state_after: no goals
tactic: exact fun x hxs hxt => hs't'.le_bot ⟨hxs, hxt⟩
Theorem: prod_mem_nhds_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
inst✝⁴ : TopologicalSpace Y
inst✝³ : TopologicalSpace Z
inst✝² : TopologicalSpace W
inst✝¹ : TopologicalSpace ε
inst✝ : TopologicalSpace ζ
s : Set X
t : Set Y
x : X
y : Y
⊢ s ×ˢ t ∈ 𝓝 (x, y) ↔ s ∈ 𝓝 x ∧ t ∈ 𝓝 y
state_after: no goals
tactic: rw [nhds_prod_eq, prod_mem_prod_iff]
Theorem: Prime.not_dvd_finset_prod
File: Mathlib/Algebra/BigOperators/Associated.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
M : Type u_5
inst✝ : CommMonoidWithZero M
S : Finset α
p : M
pp : Prime p
g : α → M
hS : ∀ a ∈ S, ¬p ∣ g a
⊢ ¬p ∣ S.prod g
state_after: no goals
tactic: exact mt (Prime.dvd_finset_prod_iff pp _).1 <| not_exists.2 fun a => not_and.2 (hS a)
Theorem: AddCommGrp.uliftFunctor_map
File: Mathlib/Algebra/Category/Grp/Basic.lean

Proof steps:
state_before: X : CommGrp
⊢ { obj := fun X => of (ULift.{v, u} ↑X),
          map := fun {X Y} f =>
            ofHom (MulEquiv.ulift.symm.toMonoidHom.comp (MonoidHom.comp f MulEquiv.ulift.toMonoidHom)) }.map
      (𝟙 X) =
    𝟙
      ({ obj := fun X => of (ULift.{v, u} ↑X),
            map := fun {X Y} f =>
              ofHom (MulEquiv.ulift.symm.toMonoidHom.comp (MonoidHom.comp f MulEquiv.ulift.toMonoidHom)) }.obj
        X)
state_after: no goals
tactic: rfl
state_before: X Y Z : CommGrp
f : X ⟶ Y
g : Y ⟶ Z
⊢ { obj := fun X => of (ULift.{v, u} ↑X),
          map := fun {X Y} f =>
            ofHom (MulEquiv.ulift.symm.toMonoidHom.comp (MonoidHom.comp f MulEquiv.ulift.toMonoidHom)) }.map
      (f ≫ g) =
    { obj := fun X => of (ULift.{v, u} ↑X),
            map := fun {X Y} f =>
              ofHom (MulEquiv.ulift.symm.toMonoidHom.comp (MonoidHom.comp f MulEquiv.ulift.toMonoidHom)) }.map
        f ≫
      { obj := fun X => of (ULift.{v, u} ↑X),
            map := fun {X Y} f =>
              ofHom (MulEquiv.ulift.symm.toMonoidHom.comp (MonoidHom.comp f MulEquiv.ulift.toMonoidHom)) }.map
        g
state_after: no goals
tactic: rfl
Theorem: Profinite.NobelingProof.GoodProducts.linearIndependent_iff_sum
File: Mathlib/Topology/Category/Profinite/Nobeling.lean

Proof steps:
state_before: I : Type u
inst✝¹ : LinearOrder I
inst✝ : IsWellOrder I fun x x_1 => x < x_1
C : Set (I → Bool)
o : Ordinal.{u}
hC : IsClosed C
hsC : contained C (Order.succ o)
ho : o < Ordinal.type fun x x_1 => x < x_1
⊢ LinearIndependent ℤ (eval C) ↔ LinearIndependent ℤ (SumEval C ho)
state_after: I : Type u
inst✝¹ : LinearOrder I
inst✝ : IsWellOrder I fun x x_1 => x < x_1
C : Set (I → Bool)
o : Ordinal.{u}
hC : IsClosed C
hsC : contained C (Order.succ o)
ho : o < Ordinal.type fun x x_1 => x < x_1
⊢ LinearIndependent ℤ (eval C ∘ ⇑(sum_equiv C hsC ho)) ↔ LinearIndependent ℤ (eval C ∘ (sum_equiv C hsC ho).toFun)
tactic: rw [← linearIndependent_equiv (sum_equiv C hsC ho), SumEval,
    ← sum_equiv_comp_eval_eq_elim C hsC ho]
state_before: I : Type u
inst✝¹ : LinearOrder I
inst✝ : IsWellOrder I fun x x_1 => x < x_1
C : Set (I → Bool)
o : Ordinal.{u}
hC : IsClosed C
hsC : contained C (Order.succ o)
ho : o < Ordinal.type fun x x_1 => x < x_1
⊢ LinearIndependent ℤ (eval C ∘ ⇑(sum_equiv C hsC ho)) ↔ LinearIndependent ℤ (eval C ∘ (sum_equiv C hsC ho).toFun)
state_after: no goals
tactic: exact Iff.rfl
Theorem: Set.image_update_Ioo_left
File: Mathlib/Order/Interval/Set/Pi.lean

Proof steps:
state_before: ι : Type u_1
α : ι → Type u_2
inst✝¹ : DecidableEq ι
inst✝ : (i : ι) → PartialOrder (α i)
f : (i : ι) → α i
i : ι
a : α i
⊢ update f i '' Ioo a (f i) = Ioo (update f i a) f
state_after: no goals
tactic: simpa using image_update_Ioo f i a (f i)
Theorem: Finset.le_sup'_iff
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✝ : LinearOrder α
s : Finset ι
H : s.Nonempty
f : ι → α
a : α
⊢ a ≤ s.sup' H f ↔ ∃ b ∈ s, a ≤ f b
state_after: F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
ι : Type u_5
κ : Type u_6
inst✝ : LinearOrder α
s : Finset ι
H : s.Nonempty
f : ι → α
a : α
⊢ (∃ b ∈ s, ↑a ≤ (WithBot.some ∘ f) b) ↔ ∃ b ∈ s, a ≤ f b
tactic: rw [← WithBot.coe_le_coe, coe_sup', Finset.le_sup_iff (WithBot.bot_lt_coe a)]
state_before: F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
ι : Type u_5
κ : Type u_6
inst✝ : LinearOrder α
s : Finset ι
H : s.Nonempty
f : ι → α
a : α
⊢ (∃ b ∈ s, ↑a ≤ (WithBot.some ∘ f) b) ↔ ∃ b ∈ s, a ≤ f b
state_after: no goals
tactic: exact exists_congr (fun _ => and_congr_right' WithBot.coe_le_coe)