ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: Multiset.sum_map_zsmul
File: Mathlib/Algebra/BigOperators/Group/Multiset.lean

Proof steps:
state_before: F : Type u_1
ι : Type u_2
α : Type u_3
β : Type u_4
γ : Type u_5
inst✝ : DivisionCommMonoid α
m : Multiset ι
f g : ι → α
n : ℤ
⊢ (map (fun i => f i ^ n) m).prod = (map f m).prod ^ n
state_after: case h.e'_2.h.e'_3
F : Type u_1
ι : Type u_2
α : Type u_3
β : Type u_4
γ : Type u_5
inst✝ : DivisionCommMonoid α
m : Multiset ι
f g : ι → α
n : ℤ
⊢ map (fun i => f i ^ n) m = map (⇑(zpowGroupHom n)) (map f m)
tactic: convert (m.map f).prod_hom (zpowGroupHom n : α →* α)
state_before: case h.e'_2.h.e'_3
F : Type u_1
ι : Type u_2
α : Type u_3
β : Type u_4
γ : Type u_5
inst✝ : DivisionCommMonoid α
m : Multiset ι
f g : ι → α
n : ℤ
⊢ map (fun i => f i ^ n) m = map (⇑(zpowGroupHom n)) (map f m)
state_after: no goals
tactic: simp only [map_map, Function.comp_apply, zpowGroupHom_apply]
Theorem: CategoryTheory.Localization.Preadditive.homEquiv_apply
File: Mathlib/CategoryTheory/Localization/CalculusOfFractions/Preadditive.lean

Proof steps:
state_before: C : Type u_1
D : Type u_2
inst✝⁴ : Category.{?u.55034, u_1} C
inst✝³ : Category.{?u.55038, u_2} D
inst✝² : Preadditive C
L : C ⥤ D
W : MorphismProperty C
inst✝¹ : L.IsLocalization W
inst✝ : W.HasLeftCalculusOfFractions
X Y Z : C
X' Y' Z' : D
eX : L.obj X ≅ X'
eY : L.obj Y ≅ Y'
eZ : L.obj Z ≅ Z'
x✝ : X' ⟶ Y'
⊢ (fun g => eX.inv ≫ g ≫ eY.hom) ((fun f => eX.hom ≫ f ≫ eY.inv) x✝) = x✝
state_after: no goals
tactic: simp
state_before: C : Type u_1
D : Type u_2
inst✝⁴ : Category.{?u.55034, u_1} C
inst✝³ : Category.{?u.55038, u_2} D
inst✝² : Preadditive C
L : C ⥤ D
W : MorphismProperty C
inst✝¹ : L.IsLocalization W
inst✝ : W.HasLeftCalculusOfFractions
X Y Z : C
X' Y' Z' : D
eX : L.obj X ≅ X'
eY : L.obj Y ≅ Y'
eZ : L.obj Z ≅ Z'
x✝ : L.obj X ⟶ L.obj Y
⊢ (fun f => eX.hom ≫ f ≫ eY.inv) ((fun g => eX.inv ≫ g ≫ eY.hom) x✝) = x✝
state_after: no goals
tactic: simp
Theorem: Cardinal.aleph0_mul_ofENat
File: Mathlib/SetTheory/Cardinal/ENat.lean

Proof steps:
state_before: m : ℕ∞
hm : m ≠ 0
⊢ ℵ₀ * ↑m = ℵ₀
state_after: no goals
tactic: rw [mul_comm, ofENat_mul_aleph0 hm]
Theorem: contDiffWithinAt_succ_iff_hasFDerivWithinAt'
File: Mathlib/Analysis/Calculus/ContDiff/Defs.lean

Proof steps:
state_before: 𝕜 : Type u
inst✝⁸ : NontriviallyNormedField 𝕜
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type uX
inst✝¹ : NormedAddCommGroup X
inst✝ : NormedSpace 𝕜 X
s s₁ t u : Set E
f f₁ : E → F
g : F → G
x x₀ : E
c : F
m n✝ : ℕ∞
p : E → FormalMultilinearSeries 𝕜 E F
n : ℕ
⊢ ContDiffWithinAt 𝕜 (↑(n + 1)) f s x ↔
    ∃ u ∈ 𝓝[insert x s] x,
      u ⊆ insert x s ∧ ∃ f', (∀ x ∈ u, HasFDerivWithinAt f (f' x) s x) ∧ ContDiffWithinAt 𝕜 (↑n) f' s x
state_after: case refine_1
𝕜 : Type u
inst✝⁸ : NontriviallyNormedField 𝕜
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type uX
inst✝¹ : NormedAddCommGroup X
inst✝ : NormedSpace 𝕜 X
s s₁ t u : Set E
f f₁ : E → F
g : F → G
x x₀ : E
c : F
m n✝ : ℕ∞
p : E → FormalMultilinearSeries 𝕜 E F
n : ℕ
hf : ContDiffWithinAt 𝕜 (↑(n + 1)) f s x
⊢ ∃ u ∈ 𝓝[insert x s] x,
    u ⊆ insert x s ∧ ∃ f', (∀ x ∈ u, HasFDerivWithinAt f (f' x) s x) ∧ ContDiffWithinAt 𝕜 (↑n) f' s x

case refine_2
𝕜 : Type u
inst✝⁸ : NontriviallyNormedField 𝕜
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type uX
inst✝¹ : NormedAddCommGroup X
inst✝ : NormedSpace 𝕜 X
s s₁ t u : Set E
f f₁ : E → F
g : F → G
x x₀ : E
c : F
m n✝ : ℕ∞
p : E → FormalMultilinearSeries 𝕜 E F
n : ℕ
⊢ (∃ u ∈ 𝓝[insert x s] x,
      u ⊆ insert x s ∧ ∃ f', (∀ x ∈ u, HasFDerivWithinAt f (f' x) s x) ∧ ContDiffWithinAt 𝕜 (↑n) f' s x) →
    ContDiffWithinAt 𝕜 (↑(n + 1)) f s x
tactic: refine ⟨fun hf => ?_, ?_⟩
Theorem: Set.image2_range
File: Mathlib/Data/Set/NAry.lean

Proof steps:
state_before: α : Type u_1
α' : Type u_2
β : Type u_3
β' : Type u_4
γ : Type u_5
γ' : Type u_6
δ : Type u_7
δ' : Type u_8
ε : Type u_9
ε' : Type u_10
ζ : Type u_11
ζ' : Type u_12
ν : Type u_13
f✝ f' : α → β → γ
g✝ g' : α → β → γ → δ
s s' : Set α
t t' : Set β
u u' : Set γ
v : Set δ
a a' : α
b b' : β
c c' : γ
d d' : δ
f : α' → β' → γ
g : α → α'
h : β → β'
⊢ image2 f (range g) (range h) = range fun x => f (g x.1) (h x.2)
state_after: no goals
tactic: simp_rw [← image_univ, image2_image_left, image2_image_right, ← image_prod, univ_prod_univ]
Theorem: Rat.inv_def'
File: Mathlib/Data/Rat/Defs.lean

Proof steps:
state_before: q✝ q : ℚ
⊢ q⁻¹ = ↑q.den /. q.num
state_after: no goals
tactic: rw [← inv_divInt', num_divInt_den]
Theorem: AlgebraicGeometry.IsAffineOpen.fromSpecStalk_eq
File: Mathlib/AlgebraicGeometry/Stalk.lean

Proof steps:
state_before: X : Scheme
x : ↑↑X.toPresheafedSpace
U V : X.Opens
hU : IsAffineOpen U
hV : IsAffineOpen V
hxU : x ∈ U
hxV : x ∈ V
⊢ hU.fromSpecStalk hxU = hV.fromSpecStalk hxV
state_after: case intro.intro.intro
X : Scheme
x : ↑↑X.toPresheafedSpace
U V : X.Opens
hU : IsAffineOpen U
hV : IsAffineOpen V
hxU : x ∈ U
hxV : x ∈ V
U' : Opens ↑↑X.toPresheafedSpace
h₁ : U' ∈ X.affineOpens
h₂ : x ∈ U'
h₃ : U' ≤ U ⊓ V
⊢ hU.fromSpecStalk hxU = hV.fromSpecStalk hxV
tactic: obtain ⟨U', h₁, h₂, h₃ : U' ≤ U ⊓ V⟩ :=
    Opens.isBasis_iff_nbhd.mp (isBasis_affine_open X) (show x ∈ U ⊓ V from ⟨hxU, hxV⟩)
state_before: case intro.intro.intro
X : Scheme
x : ↑↑X.toPresheafedSpace
U V : X.Opens
hU : IsAffineOpen U
hV : IsAffineOpen V
hxU : x ∈ U
hxV : x ∈ V
U' : Opens ↑↑X.toPresheafedSpace
h₁ : U' ∈ X.affineOpens
h₂ : x ∈ U'
h₃ : U' ≤ U ⊓ V
⊢ hU.fromSpecStalk hxU = hV.fromSpecStalk hxV
state_after: X : Scheme
x : ↑↑X.toPresheafedSpace
U V : X.Opens
hU : IsAffineOpen U
hV : IsAffineOpen V
hxU : x ∈ U
hxV : x ∈ V
U' : Opens ↑↑X.toPresheafedSpace
h₁ : U' ∈ X.affineOpens
h₂ : x ∈ U'
h₃ : U' ≤ U ⊓ V
⊢ hU.fromSpecStalk hxU = fromSpecStalk h₁ h₂

X : Scheme
x : ↑↑X.toPresheafedSpace
U V : X.Opens
hU : IsAffineOpen U
hV : IsAffineOpen V
hxU : x ∈ U
hxV : x ∈ V
U' : Opens ↑↑X.toPresheafedSpace
h₁ : U' ∈ X.affineOpens
h₂ : x ∈ U'
h₃ : U' ≤ U ⊓ V
⊢ fromSpecStalk h₁ h₂ = hV.fromSpecStalk hxV
tactic: transitivity fromSpecStalk h₁ h₂
Theorem: Grp.SurjectiveOfEpiAuxs.agree
File: Mathlib/Algebra/Category/Grp/EpiMono.lean

Proof steps:
state_before: A B : Grp
f : A ⟶ B
⊢ ↑(MonoidHom.range f) = {x | h x = g x}
state_after: case refine_1
A B : Grp
f : A ⟶ B
b : ↑B
⊢ b ∈ ↑(MonoidHom.range f) → b ∈ {x | h x = g x}

case refine_2
A B : Grp
f : A ⟶ B
b : ↑B
hb : h b = g b
r : b ∉ ↑(MonoidHom.range f)
⊢ False
tactic: refine Set.ext fun b => ⟨?_, fun hb : h b = g b => by_contradiction fun r => ?_⟩
Theorem: tprod_dite_left
File: Mathlib/Topology/Algebra/InfiniteSum/Basic.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝² : CommMonoid α
inst✝¹ : TopologicalSpace α
f g : β → α
a a₁ a₂ : α
P : Prop
inst✝ : Decidable P
x : β → P → α
⊢ (∏' (b : β), if h : P then x b h else 1) = if h : P then ∏' (b : β), x b h else 1
state_after: no goals
tactic: by_cases hP : P <;> simp [hP]
Theorem: MeasureTheory.AddQuotientMeasureEqMeasurePreimage.covolume_ne_top
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✝⁸ : Group G
inst✝⁷ : MulAction G α
inst✝⁶ : MeasurableSpace α
ν : Measure α
inst✝⁵ : Countable G
inst✝⁴ : MeasurableSpace G
inst✝³ : SMulInvariantMeasure G α ν
inst✝² : MeasurableSMul G α
μ : Measure (Quotient α_mod_G)
inst✝¹ : QuotientMeasureEqMeasurePreimage ν μ
inst✝ : IsFiniteMeasure μ
⊢ covolume G α ν < ⊤
state_after: case pos
G : Type u_1
H : Type u_2
α : Type u_3
β : Type u_4
E : Type u_5
inst✝⁸ : Group G
inst✝⁷ : MulAction G α
inst✝⁶ : MeasurableSpace α
ν : Measure α
inst✝⁵ : Countable G
inst✝⁴ : MeasurableSpace G
inst✝³ : SMulInvariantMeasure G α ν
inst✝² : MeasurableSMul G α
μ : Measure (Quotient α_mod_G)
inst✝¹ : QuotientMeasureEqMeasurePreimage ν μ
inst✝ : IsFiniteMeasure μ
hasFun : HasFundamentalDomain G α ν
⊢ covolume G α ν < ⊤

case neg
G : Type u_1
H : Type u_2
α : Type u_3
β : Type u_4
E : Type u_5
inst✝⁸ : Group G
inst✝⁷ : MulAction G α
inst✝⁶ : MeasurableSpace α
ν : Measure α
inst✝⁵ : Countable G
inst✝⁴ : MeasurableSpace G
inst✝³ : SMulInvariantMeasure G α ν
inst✝² : MeasurableSMul G α
μ : Measure (Quotient α_mod_G)
inst✝¹ : QuotientMeasureEqMeasurePreimage ν μ
inst✝ : IsFiniteMeasure μ
hasFun : ¬HasFundamentalDomain G α ν
⊢ covolume G α ν < ⊤
tactic: by_cases hasFun : HasFundamentalDomain G α ν
Theorem: CategoryTheory.Limits.prodComparison_comp
File: Mathlib/CategoryTheory/Limits/Shapes/BinaryProducts.lean

Proof steps:
state_before: C : Type u
inst✝⁸ : Category.{v, u} C
X Y : C
D : Type u₂
inst✝⁷ : Category.{w, u₂} D
E : Type u₃
inst✝⁶ : Category.{w', u₃} E
F : C ⥤ D
G : D ⥤ E
A A' B B' : C
inst✝⁵ : HasBinaryProduct A B
inst✝⁴ : HasBinaryProduct A' B'
inst✝³ : HasBinaryProduct (F.obj A) (F.obj B)
inst✝² : HasBinaryProduct (F.obj A') (F.obj B')
inst✝¹ : HasBinaryProduct (G.obj (F.obj A)) (G.obj (F.obj B))
inst✝ : HasBinaryProduct ((F ⋙ G).obj A) ((F ⋙ G).obj B)
⊢ prodComparison (F ⋙ G) A B = G.map (prodComparison F A B) ≫ prodComparison G (F.obj A) (F.obj B)
state_after: C : Type u
inst✝⁸ : Category.{v, u} C
X Y : C
D : Type u₂
inst✝⁷ : Category.{w, u₂} D
E : Type u₃
inst✝⁶ : Category.{w', u₃} E
F : C ⥤ D
G : D ⥤ E
A A' B B' : C
inst✝⁵ : HasBinaryProduct A B
inst✝⁴ : HasBinaryProduct A' B'
inst✝³ : HasBinaryProduct (F.obj A) (F.obj B)
inst✝² : HasBinaryProduct (F.obj A') (F.obj B')
inst✝¹ : HasBinaryProduct (G.obj (F.obj A)) (G.obj (F.obj B))
inst✝ : HasBinaryProduct ((F ⋙ G).obj A) ((F ⋙ G).obj B)
⊢ prod.lift ((F ⋙ G).map prod.fst) ((F ⋙ G).map prod.snd) =
    G.map (prod.lift (F.map prod.fst) (F.map prod.snd)) ≫ prod.lift (G.map prod.fst) (G.map prod.snd)
tactic: unfold prodComparison
state_before: C : Type u
inst✝⁸ : Category.{v, u} C
X Y : C
D : Type u₂
inst✝⁷ : Category.{w, u₂} D
E : Type u₃
inst✝⁶ : Category.{w', u₃} E
F : C ⥤ D
G : D ⥤ E
A A' B B' : C
inst✝⁵ : HasBinaryProduct A B
inst✝⁴ : HasBinaryProduct A' B'
inst✝³ : HasBinaryProduct (F.obj A) (F.obj B)
inst✝² : HasBinaryProduct (F.obj A') (F.obj B')
inst✝¹ : HasBinaryProduct (G.obj (F.obj A)) (G.obj (F.obj B))
inst✝ : HasBinaryProduct ((F ⋙ G).obj A) ((F ⋙ G).obj B)
⊢ prod.lift ((F ⋙ G).map prod.fst) ((F ⋙ G).map prod.snd) =
    G.map (prod.lift (F.map prod.fst) (F.map prod.snd)) ≫ prod.lift (G.map prod.fst) (G.map prod.snd)
state_after: no goals
tactic: ext <;> simp <;> rw [← G.map_comp] <;> simp
Theorem: Equiv.Perm.isCycle_cycleOf_iff
File: Mathlib/GroupTheory/Perm/Cycle/Factors.lean

Proof steps:
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
f✝ g : Perm α
x y : α
inst✝² : DecidableRel f✝.SameCycle
inst✝¹ : DecidableRel g.SameCycle
f : Perm α
inst✝ : DecidableRel f.SameCycle
⊢ (f.cycleOf x).IsCycle ↔ f x ≠ x
state_after: ι : Type u_1
α : Type u_2
β : Type u_3
f✝ g : Perm α
x y : α
inst✝² : DecidableRel f✝.SameCycle
inst✝¹ : DecidableRel g.SameCycle
f : Perm α
inst✝ : DecidableRel f.SameCycle
hx : (f.cycleOf x).IsCycle
⊢ f x ≠ x
tactic: refine ⟨fun hx => ?_, f.isCycle_cycleOf⟩
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
f✝ g : Perm α
x y : α
inst✝² : DecidableRel f✝.SameCycle
inst✝¹ : DecidableRel g.SameCycle
f : Perm α
inst✝ : DecidableRel f.SameCycle
hx : (f.cycleOf x).IsCycle
⊢ f x ≠ x
state_after: ι : Type u_1
α : Type u_2
β : Type u_3
f✝ g : Perm α
x y : α
inst✝² : DecidableRel f✝.SameCycle
inst✝¹ : DecidableRel g.SameCycle
f : Perm α
inst✝ : DecidableRel f.SameCycle
hx : (f.cycleOf x).IsCycle
⊢ ¬f.cycleOf x = 1
tactic: rw [Ne, ← cycleOf_eq_one_iff f]
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
f✝ g : Perm α
x y : α
inst✝² : DecidableRel f✝.SameCycle
inst✝¹ : DecidableRel g.SameCycle
f : Perm α
inst✝ : DecidableRel f.SameCycle
hx : (f.cycleOf x).IsCycle
⊢ ¬f.cycleOf x = 1
state_after: no goals
tactic: exact hx.ne_one
Theorem: Mathlib.Meta.List.range_succ_eq_map'
File: Mathlib/Tactic/NormNum/BigOperators.lean

Proof steps:
state_before: u v : Level
n nn n' : ℕ
pn : NormNum.IsNat n nn
pn' : nn = n'.succ
⊢ List.range n = 0 :: List.map Nat.succ (List.range n')
state_after: no goals
tactic: rw [pn.out, Nat.cast_id, pn', List.range_succ_eq_map]
Theorem: wbtw_smul_vadd_smul_vadd_of_nonpos_of_le
File: Mathlib/Analysis/Convex/Between.lean

Proof steps:
state_before: R : Type u_1
V : Type u_2
V' : Type u_3
P : Type u_4
P' : Type u_5
inst✝³ : LinearOrderedField R
inst✝² : AddCommGroup V
inst✝¹ : Module R V
inst✝ : AddTorsor V P
x : P
v : V
r₁ r₂ : R
hr₁ : r₁ ≤ 0
hr₂ : r₂ ≤ r₁
⊢ Wbtw R x (r₁ • v +ᵥ x) (r₂ • v +ᵥ x)
state_after: no goals
tactic: convert wbtw_smul_vadd_smul_vadd_of_nonneg_of_le x (-v) (Left.nonneg_neg_iff.2 hr₁)
      (neg_le_neg_iff.2 hr₂) using 1 <;>
    rw [neg_smul_neg]
Theorem: String.validFor_toSubstring
File: .lake/packages/batteries/Batteries/Data/String/Lemmas.lean

Proof steps:
state_before: s : String
⊢ s.toSubstring.str.data = [] ++ s.data ++ []
state_after: no goals
tactic: simp [toSubstring]
state_before: s : String
⊢ s.toSubstring.stopPos.byteIdx = utf8Len [] + utf8Len s.data
state_after: no goals
tactic: simp [toSubstring, endPos, utf8ByteSize]
Theorem: LSeriesSummable.of_re_le_re
File: Mathlib/NumberTheory/LSeries/Basic.lean

Proof steps:
state_before: f : ℕ → ℂ
s s' : ℂ
h : s.re ≤ s'.re
hf : LSeriesSummable f s
⊢ LSeriesSummable f s'
state_after: f : ℕ → ℂ
s s' : ℂ
h : s.re ≤ s'.re
hf : Summable fun x => ‖term f s x‖
⊢ Summable fun x => ‖term f s' x‖
tactic: rw [LSeriesSummable, ← summable_norm_iff] at hf ⊢
state_before: f : ℕ → ℂ
s s' : ℂ
h : s.re ≤ s'.re
hf : Summable fun x => ‖term f s x‖
⊢ Summable fun x => ‖term f s' x‖
state_after: no goals
tactic: exact hf.of_nonneg_of_le (fun _ ↦ norm_nonneg _) (norm_term_le_of_re_le_re f h)
Theorem: ClosureOperator.ofCompletePred_isClosed
File: Mathlib/Order/Closure.lean

Proof steps:
state_before: α : Type u_1
ι : Sort u_2
κ : ι → Sort u_3
inst✝ : CompleteLattice α
c : ClosureOperator α
p✝ p : α → Prop
hsinf : ∀ (s : Set α), (∀ a ∈ s, p a) → p (sInf s)
a : α
⊢ a ≤ (fun a => ⨅ b, ↑b) a
state_after: no goals
tactic: set_option tactic.skipAssignedInstances false in simp [forall_swap]
Theorem: AddGrp.hasLimit_iff_small_sections
File: Mathlib/Algebra/Category/Grp/Limits.lean

Proof steps:
state_before: J : Type v
inst✝ : Category.{w, v} J
F : J ⥤ Grp
⊢ HasLimit F ↔ Small.{u, max u v} ↑(F ⋙ forget Grp).sections
state_after: case mp
J : Type v
inst✝ : Category.{w, v} J
F : J ⥤ Grp
⊢ HasLimit F → Small.{u, max u v} ↑(F ⋙ forget Grp).sections

case mpr
J : Type v
inst✝ : Category.{w, v} J
F : J ⥤ Grp
⊢ Small.{u, max u v} ↑(F ⋙ forget Grp).sections → HasLimit F
tactic: constructor
Theorem: LieAlgebra.solvable_iff_equiv_solvable
File: Mathlib/Algebra/Lie/Solvable.lean

Proof steps:
state_before: R : Type u
L : Type v
M : Type w
L' : Type w₁
inst✝⁴ : CommRing R
inst✝³ : LieRing L
inst✝² : LieAlgebra R L
inst✝¹ : LieRing L'
inst✝ : LieAlgebra R L'
I J : LieIdeal R L
f : L' →ₗ⁅R⁆ L
e : L' ≃ₗ⁅R⁆ L
⊢ IsSolvable R L' ↔ IsSolvable R L
state_after: case mp
R : Type u
L : Type v
M : Type w
L' : Type w₁
inst✝⁴ : CommRing R
inst✝³ : LieRing L
inst✝² : LieAlgebra R L
inst✝¹ : LieRing L'
inst✝ : LieAlgebra R L'
I J : LieIdeal R L
f : L' →ₗ⁅R⁆ L
e : L' ≃ₗ⁅R⁆ L
h : IsSolvable R L'
⊢ IsSolvable R L

case mpr
R : Type u
L : Type v
M : Type w
L' : Type w₁
inst✝⁴ : CommRing R
inst✝³ : LieRing L
inst✝² : LieAlgebra R L
inst✝¹ : LieRing L'
inst✝ : LieAlgebra R L'
I J : LieIdeal R L
f : L' →ₗ⁅R⁆ L
e : L' ≃ₗ⁅R⁆ L
h : IsSolvable R L
⊢ IsSolvable R L'
tactic: constructor <;> intro h
Theorem: MeasureTheory.FiniteMeasure.tendsto_normalize_of_tendsto
File: Mathlib/MeasureTheory/Measure/ProbabilityMeasure.lean

Proof steps:
state_before: Ω : Type u_1
inst✝² : Nonempty Ω
m0 : MeasurableSpace Ω
μ : FiniteMeasure Ω
inst✝¹ : TopologicalSpace Ω
inst✝ : OpensMeasurableSpace Ω
γ : Type u_2
F : Filter γ
μs : γ → FiniteMeasure Ω
μs_lim : Tendsto μs F (𝓝 μ)
nonzero : μ ≠ 0
⊢ Tendsto (fun i => (μs i).normalize) F (𝓝 μ.normalize)
state_after: Ω : Type u_1
inst✝² : Nonempty Ω
m0 : MeasurableSpace Ω
μ : FiniteMeasure Ω
inst✝¹ : TopologicalSpace Ω
inst✝ : OpensMeasurableSpace Ω
γ : Type u_2
F : Filter γ
μs : γ → FiniteMeasure Ω
μs_lim : Tendsto μs F (𝓝 μ)
nonzero : μ ≠ 0
⊢ ∀ (f : Ω →ᵇ ℝ≥0),
    Tendsto (fun i => ((ProbabilityMeasure.toFiniteMeasure ∘ fun i => (μs i).normalize) i).testAgainstNN f) F
      (𝓝 (μ.normalize.toFiniteMeasure.testAgainstNN f))
tactic: rw [ProbabilityMeasure.tendsto_nhds_iff_toFiniteMeasure_tendsto_nhds,
    tendsto_iff_forall_testAgainstNN_tendsto]
state_before: Ω : Type u_1
inst✝² : Nonempty Ω
m0 : MeasurableSpace Ω
μ : FiniteMeasure Ω
inst✝¹ : TopologicalSpace Ω
inst✝ : OpensMeasurableSpace Ω
γ : Type u_2
F : Filter γ
μs : γ → FiniteMeasure Ω
μs_lim : Tendsto μs F (𝓝 μ)
nonzero : μ ≠ 0
⊢ ∀ (f : Ω →ᵇ ℝ≥0),
    Tendsto (fun i => ((ProbabilityMeasure.toFiniteMeasure ∘ fun i => (μs i).normalize) i).testAgainstNN f) F
      (𝓝 (μ.normalize.toFiniteMeasure.testAgainstNN f))
state_after: no goals
tactic: exact fun f => tendsto_normalize_testAgainstNN_of_tendsto μs_lim nonzero f
Theorem: TsirelsonInequality.sqrt_two_inv_mul_self
File: Mathlib/Algebra/Star/CHSH.lean

Proof steps:
state_before: R : Type u
⊢ (√2)⁻¹ * (√2)⁻¹ = 2⁻¹
state_after: R : Type u
⊢ (√2 * √2)⁻¹ = 2⁻¹
tactic: rw [← mul_inv]
state_before: R : Type u
⊢ (√2 * √2)⁻¹ = 2⁻¹
state_after: no goals
tactic: norm_num
Theorem: AlgHom.prodEquiv_apply
File: Mathlib/Algebra/Algebra/Prod.lean

Proof steps:
state_before: R : Type u_1
A : Type u_2
B : Type u_3
C : Type u_4
inst✝⁶ : CommSemiring R
inst✝⁵ : Semiring A
inst✝⁴ : Algebra R A
inst✝³ : Semiring B
inst✝² : Algebra R B
inst✝¹ : Semiring C
inst✝ : Algebra R C
f : (A →ₐ[R] B) × (A →ₐ[R] C)
⊢ (fun f => ((fst R B C).comp f, (snd R B C).comp f)) ((fun f => f.1.prod f.2) f) = f
state_after: no goals
tactic: ext <;> rfl
state_before: R : Type u_1
A : Type u_2
B : Type u_3
C : Type u_4
inst✝⁶ : CommSemiring R
inst✝⁵ : Semiring A
inst✝⁴ : Algebra R A
inst✝³ : Semiring B
inst✝² : Algebra R B
inst✝¹ : Semiring C
inst✝ : Algebra R C
f : A →ₐ[R] B × C
⊢ (fun f => f.1.prod f.2) ((fun f => ((fst R B C).comp f, (snd R B C).comp f)) f) = f
state_after: no goals
tactic: ext <;> rfl
Theorem: LinearEquiv.finrank_eq
File: Mathlib/LinearAlgebra/Dimension/Finrank.lean

Proof steps:
state_before: R✝ : Type u
M✝ : Type v
N : Type w
inst✝⁹ : Ring R✝
inst✝⁸ : AddCommGroup M✝
inst✝⁷ : Module R✝ M✝
inst✝⁶ : AddCommGroup N
inst✝⁵ : Module R✝ N
R : Type u_1
M : Type u_2
M₂ : Type u_3
inst✝⁴ : Ring R
inst✝³ : AddCommGroup M
inst✝² : AddCommGroup M₂
inst✝¹ : Module R M
inst✝ : Module R M₂
f : M ≃ₗ[R] M₂
⊢ finrank R M = finrank R M₂
state_after: R✝ : Type u
M✝ : Type v
N : Type w
inst✝⁹ : Ring R✝
inst✝⁸ : AddCommGroup M✝
inst✝⁷ : Module R✝ M✝
inst✝⁶ : AddCommGroup N
inst✝⁵ : Module R✝ N
R : Type u_1
M : Type u_2
M₂ : Type u_3
inst✝⁴ : Ring R
inst✝³ : AddCommGroup M
inst✝² : AddCommGroup M₂
inst✝¹ : Module R M
inst✝ : Module R M₂
f : M ≃ₗ[R] M₂
⊢ toNat (Module.rank R M) = toNat (Module.rank R M₂)
tactic: unfold finrank
state_before: R✝ : Type u
M✝ : Type v
N : Type w
inst✝⁹ : Ring R✝
inst✝⁸ : AddCommGroup M✝
inst✝⁷ : Module R✝ M✝
inst✝⁶ : AddCommGroup N
inst✝⁵ : Module R✝ N
R : Type u_1
M : Type u_2
M₂ : Type u_3
inst✝⁴ : Ring R
inst✝³ : AddCommGroup M
inst✝² : AddCommGroup M₂
inst✝¹ : Module R M
inst✝ : Module R M₂
f : M ≃ₗ[R] M₂
⊢ toNat (Module.rank R M) = toNat (Module.rank R M₂)
state_after: no goals
tactic: rw [← Cardinal.toNat_lift, f.lift_rank_eq, Cardinal.toNat_lift]
Theorem: BoundedContinuousFunction.lipschitz_comp
File: Mathlib/Topology/ContinuousFunction/Bounded.lean

Proof steps:
state_before: F : Type u_1
α : Type u
β : Type v
γ : Type w
inst✝² : TopologicalSpace α
inst✝¹ : PseudoMetricSpace β
inst✝ : PseudoMetricSpace γ
f✝ g✝ : α →ᵇ β
x✝ : α
C✝ : ℝ
G : β → γ
C : ℝ≥0
H : LipschitzWith C G
f g : α →ᵇ β
x : α
⊢ ↑C * dist (f x) (g x) ≤ ↑C * dist f g
state_after: case h
F : Type u_1
α : Type u
β : Type v
γ : Type w
inst✝² : TopologicalSpace α
inst✝¹ : PseudoMetricSpace β
inst✝ : PseudoMetricSpace γ
f✝ g✝ : α →ᵇ β
x✝ : α
C✝ : ℝ
G : β → γ
C : ℝ≥0
H : LipschitzWith C G
f g : α →ᵇ β
x : α
⊢ dist (f x) (g x) ≤ dist f g
tactic: gcongr
state_before: case h
F : Type u_1
α : Type u
β : Type v
γ : Type w
inst✝² : TopologicalSpace α
inst✝¹ : PseudoMetricSpace β
inst✝ : PseudoMetricSpace γ
f✝ g✝ : α →ᵇ β
x✝ : α
C✝ : ℝ
G : β → γ
C : ℝ≥0
H : LipschitzWith C G
f g : α →ᵇ β
x : α
⊢ dist (f x) (g x) ≤ dist f g
state_after: no goals
tactic: apply dist_coe_le_dist
Theorem: List.count_eq_of_nodup
File: Mathlib/Data/List/Nodup.lean

Proof steps:
state_before: α : Type u
β : Type v
l✝ l₁ l₂ : List α
r : α → α → Prop
a✝ b : α
inst✝ : DecidableEq α
a : α
l : List α
d : l.Nodup
⊢ count a l = if a ∈ l then 1 else 0
state_after: case pos
α : Type u
β : Type v
l✝ l₁ l₂ : List α
r : α → α → Prop
a✝ b : α
inst✝ : DecidableEq α
a : α
l : List α
d : l.Nodup
h : a ∈ l
⊢ count a l = 1

case neg
α : Type u
β : Type v
l✝ l₁ l₂ : List α
r : α → α → Prop
a✝ b : α
inst✝ : DecidableEq α
a : α
l : List α
d : l.Nodup
h : a ∉ l
⊢ count a l = 0
tactic: split_ifs with h
Theorem: Complex.cosh_conj
File: Mathlib/Data/Complex/Exponential.lean

Proof steps:
state_before: x y : ℂ
⊢ cosh ((starRingEnd ℂ) x) = (starRingEnd ℂ) (cosh x)
state_after: x y : ℂ
⊢ (starRingEnd ℂ) (cexp x + cexp (-x)) / 2 = (starRingEnd ℂ) (cexp x + cexp (-x)) / (starRingEnd ℂ) 2
tactic: rw [cosh, ← RingHom.map_neg, exp_conj, exp_conj, ← RingHom.map_add, cosh, map_div₀]
state_before: x y : ℂ
⊢ (starRingEnd ℂ) (cexp x + cexp (-x)) / 2 = (starRingEnd ℂ) (cexp x + cexp (-x)) / (starRingEnd ℂ) 2
state_after: no goals
tactic: simp [← one_add_one_eq_two]
Theorem: MulLECancellable.le_mul_iff_one_le_left
File: Mathlib/Algebra/Order/Monoid/Unbundled/Basic.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
inst✝² : LE α
inst✝¹ : MulOneClass α
i : IsSymmOp α α fun x x_1 => x * x_1
inst✝ : CovariantClass α α (fun x x_1 => x * x_1) fun x x_1 => x ≤ x_1
a b : α
ha : MulLECancellable a
⊢ a ≤ b * a ↔ 1 ≤ b
state_after: no goals
tactic: rw [i.symm_op, ha.le_mul_iff_one_le_right]
Theorem: LinearMap.toSpanSingleton_isIdempotentElem_iff
File: Mathlib/LinearAlgebra/Span.lean

Proof steps:
state_before: R : Type u_1
R₂ : Type u_2
K : Type u_3
M : Type u_4
M₂ : Type u_5
V : Type u_6
S : Type u_7
inst✝² : Semiring R
inst✝¹ : AddCommMonoid M
inst✝ : Module R M
e : R
⊢ IsIdempotentElem (toSpanSingleton R R e) ↔ IsIdempotentElem e
state_after: R : Type u_1
R₂ : Type u_2
K : Type u_3
M : Type u_4
M₂ : Type u_5
V : Type u_6
S : Type u_7
inst✝² : Semiring R
inst✝¹ : AddCommMonoid M
inst✝ : Module R M
e : R
⊢ (∀ (x : R), x * (e * e) = x * e) ↔ e * e = e
tactic: simp_rw [IsIdempotentElem, LinearMap.ext_iff, mul_apply, toSpanSingleton_apply, smul_eq_mul,
    mul_assoc]
state_before: R : Type u_1
R₂ : Type u_2
K : Type u_3
M : Type u_4
M₂ : Type u_5
V : Type u_6
S : Type u_7
inst✝² : Semiring R
inst✝¹ : AddCommMonoid M
inst✝ : Module R M
e : R
⊢ (∀ (x : R), x * (e * e) = x * e) ↔ e * e = e
state_after: no goals
tactic: exact ⟨fun h ↦ by conv_rhs => rw [← one_mul e, ← h, one_mul], fun h _ ↦ by rw [h]⟩
Theorem: midpoint_mem_segment
File: Mathlib/Analysis/Convex/Segment.lean

Proof steps:
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
G : Type u_4
ι : Type u_5
π : ι → Type u_6
inst✝³ : LinearOrderedRing 𝕜
inst✝² : AddCommGroup E
inst✝¹ : Module 𝕜 E
x✝ y✝ : E
inst✝ : Invertible 2
x y : E
⊢ midpoint 𝕜 x y ∈ [x-[𝕜]y]
state_after: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
G : Type u_4
ι : Type u_5
π : ι → Type u_6
inst✝³ : LinearOrderedRing 𝕜
inst✝² : AddCommGroup E
inst✝¹ : Module 𝕜 E
x✝ y✝ : E
inst✝ : Invertible 2
x y : E
⊢ midpoint 𝕜 x y ∈ ⇑(AffineMap.lineMap x y) '' Icc 0 1
tactic: rw [segment_eq_image_lineMap]
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
G : Type u_4
ι : Type u_5
π : ι → Type u_6
inst✝³ : LinearOrderedRing 𝕜
inst✝² : AddCommGroup E
inst✝¹ : Module 𝕜 E
x✝ y✝ : E
inst✝ : Invertible 2
x y : E
⊢ midpoint 𝕜 x y ∈ ⇑(AffineMap.lineMap x y) '' Icc 0 1
state_after: no goals
tactic: exact ⟨⅟ 2, ⟨invOf_nonneg.mpr zero_le_two, invOf_le_one one_le_two⟩, rfl⟩