ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: LieAlgebra.mem_ker_killingForm_of_mem_rootSpace_of_forall_rootSpace_neg
File: Mathlib/Algebra/Lie/Weights/Killing.lean

Proof steps:
state_before: R : Type u_1
K : Type u_2
L : Type u_3
inst✝⁷ : CommRing R
inst✝⁶ : LieRing L
inst✝⁵ : LieAlgebra R L
inst✝⁴ : Field K
inst✝³ : LieAlgebra K L
inst✝² : FiniteDimensional K L
H : LieSubalgebra K L
inst✝¹ : H.IsCartanSubalgebra
inst✝ : IsTriangularizable K (↥H) L
α : ↥H → K
x : L
hx : x ∈ rootSpace H α
hx' : ∀ y ∈ rootSpace H (-α), ((killingForm K L) x) y = 0
⊢ x ∈ LinearMap.ker (killingForm K L)
state_after: R : Type u_1
K : Type u_2
L : Type u_3
inst✝⁷ : CommRing R
inst✝⁶ : LieRing L
inst✝⁵ : LieAlgebra R L
inst✝⁴ : Field K
inst✝³ : LieAlgebra K L
inst✝² : FiniteDimensional K L
H : LieSubalgebra K L
inst✝¹ : H.IsCartanSubalgebra
inst✝ : IsTriangularizable K (↥H) L
α : ↥H → K
x : L
hx : x ∈ rootSpace H α
hx' : ∀ y ∈ rootSpace H (-α), ((killingForm K L) x) y = 0
⊢ (killingForm K L) x = 0
tactic: rw [LinearMap.mem_ker]
state_before: R : Type u_1
K : Type u_2
L : Type u_3
inst✝⁷ : CommRing R
inst✝⁶ : LieRing L
inst✝⁵ : LieAlgebra R L
inst✝⁴ : Field K
inst✝³ : LieAlgebra K L
inst✝² : FiniteDimensional K L
H : LieSubalgebra K L
inst✝¹ : H.IsCartanSubalgebra
inst✝ : IsTriangularizable K (↥H) L
α : ↥H → K
x : L
hx : x ∈ rootSpace H α
hx' : ∀ y ∈ rootSpace H (-α), ((killingForm K L) x) y = 0
⊢ (killingForm K L) x = 0
state_after: case h
R : Type u_1
K : Type u_2
L : Type u_3
inst✝⁷ : CommRing R
inst✝⁶ : LieRing L
inst✝⁵ : LieAlgebra R L
inst✝⁴ : Field K
inst✝³ : LieAlgebra K L
inst✝² : FiniteDimensional K L
H : LieSubalgebra K L
inst✝¹ : H.IsCartanSubalgebra
inst✝ : IsTriangularizable K (↥H) L
α : ↥H → K
x : L
hx : x ∈ rootSpace H α
hx' : ∀ y ∈ rootSpace H (-α), ((killingForm K L) x) y = 0
y : L
⊢ ((killingForm K L) x) y = 0 y
tactic: ext y
state_before: case h
R : Type u_1
K : Type u_2
L : Type u_3
inst✝⁷ : CommRing R
inst✝⁶ : LieRing L
inst✝⁵ : LieAlgebra R L
inst✝⁴ : Field K
inst✝³ : LieAlgebra K L
inst✝² : FiniteDimensional K L
H : LieSubalgebra K L
inst✝¹ : H.IsCartanSubalgebra
inst✝ : IsTriangularizable K (↥H) L
α : ↥H → K
x : L
hx : x ∈ rootSpace H α
hx' : ∀ y ∈ rootSpace H (-α), ((killingForm K L) x) y = 0
y : L
⊢ ((killingForm K L) x) y = 0 y
state_after: case h
R : Type u_1
K : Type u_2
L : Type u_3
inst✝⁷ : CommRing R
inst✝⁶ : LieRing L
inst✝⁵ : LieAlgebra R L
inst✝⁴ : Field K
inst✝³ : LieAlgebra K L
inst✝² : FiniteDimensional K L
H : LieSubalgebra K L
inst✝¹ : H.IsCartanSubalgebra
inst✝ : IsTriangularizable K (↥H) L
α : ↥H → K
x : L
hx : x ∈ rootSpace H α
hx' : ∀ y ∈ rootSpace H (-α), ((killingForm K L) x) y = 0
y : L
hy : y ∈ ⨆ β, rootSpace H β
⊢ ((killingForm K L) x) y = 0 y
tactic: have hy : y ∈ ⨆ β, rootSpace H β := by simp [iSup_weightSpace_eq_top K H L]
Theorem: RatFunc.denom_mul_dvd
File: Mathlib/FieldTheory/RatFunc/Basic.lean

Proof steps:
state_before: K : Type u
inst✝ : Field K
x y : RatFunc K
⊢ (x * y).denom ∣ x.denom * y.denom
state_after: K : Type u
inst✝ : Field K
x y : RatFunc K
⊢ ∃ p, x * y = (algebraMap K[X] (RatFunc K)) p / (algebraMap K[X] (RatFunc K)) (x.denom * y.denom)
tactic: rw [denom_dvd (mul_ne_zero (denom_ne_zero x) (denom_ne_zero y))]
state_before: K : Type u
inst✝ : Field K
x y : RatFunc K
⊢ ∃ p, x * y = (algebraMap K[X] (RatFunc K)) p / (algebraMap K[X] (RatFunc K)) (x.denom * y.denom)
state_after: K : Type u
inst✝ : Field K
x y : RatFunc K
⊢ x * y = (algebraMap K[X] (RatFunc K)) (x.num * y.num) / (algebraMap K[X] (RatFunc K)) (x.denom * y.denom)
tactic: refine ⟨x.num * y.num, ?_⟩
state_before: K : Type u
inst✝ : Field K
x y : RatFunc K
⊢ x * y = (algebraMap K[X] (RatFunc K)) (x.num * y.num) / (algebraMap K[X] (RatFunc K)) (x.denom * y.denom)
state_after: no goals
tactic: rw [RingHom.map_mul, RingHom.map_mul, ← div_mul_div_comm, num_div_denom, num_div_denom]
Theorem: FirstOrder.Language.BoundedFormula.not_ex_isQF
File: Mathlib/ModelTheory/Complexity.lean

Proof steps:
state_before: L : Language
L' : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝² : L.Structure M
inst✝¹ : L.Structure N
inst✝ : L.Structure P
α : Type u'
β : Type v'
γ : Type u_3
n l : ℕ
φ✝ ψ : L.BoundedFormula α l
θ : L.BoundedFormula α l.succ
v : α → M
xs : Fin l → M
φ : L.BoundedFormula α (n + 1)
con : (∃'φ).IsQF
⊢ False
state_after: case of_isAtomic
L : Language
L' : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝² : L.Structure M
inst✝¹ : L.Structure N
inst✝ : L.Structure P
α : Type u'
β : Type v'
γ : Type u_3
n l : ℕ
φ✝ ψ : L.BoundedFormula α l
θ : L.BoundedFormula α l.succ
v : α → M
xs : Fin l → M
φ : L.BoundedFormula α (n + 1)
con : (∃'φ).IsAtomic
⊢ False

case imp
L : Language
L' : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝² : L.Structure M
inst✝¹ : L.Structure N
inst✝ : L.Structure P
α : Type u'
β : Type v'
γ : Type u_3
n l : ℕ
φ✝ ψ : L.BoundedFormula α l
θ : L.BoundedFormula α l.succ
v : α → M
xs : Fin l → M
φ : L.BoundedFormula α (n + 1)
con : (∀'∼φ).IsQF
h₂✝ : ⊥.IsQF
⊢ False
tactic: cases' con with _ con _ _ con
Theorem: HurwitzZeta.completedHurwitzZetaEven_residue_zero
File: Mathlib/NumberTheory/LSeries/HurwitzZetaEven.lean

Proof steps:
state_before: a : UnitAddCircle
⊢ Tendsto (fun s => s * completedHurwitzZetaEven a s) (𝓝[≠] 0) (𝓝 (if a = 0 then -1 else 0))
state_after: a : UnitAddCircle
h1 : Tendsto (fun s => s * (hurwitzEvenFEPair a).Λ s) (𝓝[≠] 0) (𝓝 (-if a = 0 then 1 else 0))
⊢ Tendsto (fun s => s * completedHurwitzZetaEven a s) (𝓝[≠] 0) (𝓝 (if a = 0 then -1 else 0))
tactic: have h1 : Tendsto (fun s : ℂ ↦ s * _) (𝓝[≠] 0)
    (𝓝 (-(if a = 0 then 1 else 0))) := (hurwitzEvenFEPair a).Λ_residue_zero
state_before: a : UnitAddCircle
h1 : Tendsto (fun s => s * (hurwitzEvenFEPair a).Λ s) (𝓝[≠] 0) (𝓝 (-if a = 0 then 1 else 0))
⊢ Tendsto (fun s => s * completedHurwitzZetaEven a s) (𝓝[≠] 0) (𝓝 (if a = 0 then -1 else 0))
state_after: a : UnitAddCircle
h1 : Tendsto (fun s => s * (hurwitzEvenFEPair a).Λ s) (𝓝[≠] 0) (𝓝 (-if a = 0 then 1 else 0))
this : (-if a = 0 then 1 else 0) = if a = 0 then -1 else 0
⊢ Tendsto (fun s => s * completedHurwitzZetaEven a s) (𝓝[≠] 0) (𝓝 (if a = 0 then -1 else 0))
tactic: have : -(if a = 0 then (1 : ℂ) else 0) = (if a = 0 then -1 else 0) := by { split_ifs <;> simp }
state_before: a : UnitAddCircle
h1 : Tendsto (fun s => s * (hurwitzEvenFEPair a).Λ s) (𝓝[≠] 0) (𝓝 (-if a = 0 then 1 else 0))
this : (-if a = 0 then 1 else 0) = if a = 0 then -1 else 0
⊢ Tendsto (fun s => s * completedHurwitzZetaEven a s) (𝓝[≠] 0) (𝓝 (if a = 0 then -1 else 0))
state_after: a : UnitAddCircle
this : (-if a = 0 then 1 else 0) = if a = 0 then -1 else 0
h1 : Tendsto (fun s => s * (hurwitzEvenFEPair a).Λ s) (𝓝[≠] 0) (𝓝 (if a = 0 then -1 else 0))
⊢ Tendsto (fun s => s * completedHurwitzZetaEven a s) (𝓝[≠] 0) (𝓝 (if a = 0 then -1 else 0))
tactic: simp only [this, push_cast, one_mul] at h1
state_before: a : UnitAddCircle
this : (-if a = 0 then 1 else 0) = if a = 0 then -1 else 0
h1 : Tendsto (fun s => s * (hurwitzEvenFEPair a).Λ s) (𝓝[≠] 0) (𝓝 (if a = 0 then -1 else 0))
⊢ Tendsto (fun s => s * completedHurwitzZetaEven a s) (𝓝[≠] 0) (𝓝 (if a = 0 then -1 else 0))
state_after: a : UnitAddCircle
this : (-if a = 0 then 1 else 0) = if a = 0 then -1 else 0
h1 : Tendsto (fun s => s * (hurwitzEvenFEPair a).Λ s) (𝓝[≠] 0) (𝓝 (if a = 0 then -1 else 0))
s : ℂ
⊢ ((fun s => s * (hurwitzEvenFEPair a).Λ s) ∘ fun s => s / 2) s = s * completedHurwitzZetaEven a s
tactic: refine (h1.comp <| zero_div (2 : ℂ) ▸ (tendsto_div_two_punctured_nhds 0)).congr (fun s ↦ ?_)
state_before: a : UnitAddCircle
this : (-if a = 0 then 1 else 0) = if a = 0 then -1 else 0
h1 : Tendsto (fun s => s * (hurwitzEvenFEPair a).Λ s) (𝓝[≠] 0) (𝓝 (if a = 0 then -1 else 0))
s : ℂ
⊢ ((fun s => s * (hurwitzEvenFEPair a).Λ s) ∘ fun s => s / 2) s = s * completedHurwitzZetaEven a s
state_after: no goals
tactic: rw [completedHurwitzZetaEven, Function.comp_apply, div_mul_eq_mul_div, mul_div_assoc]
Theorem: MeasureTheory.IntegrableOn.continuousOn_smul
File: Mathlib/MeasureTheory/Function/LocallyIntegrable.lean

Proof steps:
state_before: X : Type u_1
Y : Type u_2
E : Type u_3
F : Type u_4
R : Type u_5
inst✝¹⁰ : MeasurableSpace X
inst✝⁹ : TopologicalSpace X
inst✝⁸ : MeasurableSpace Y
inst✝⁷ : TopologicalSpace Y
inst✝⁶ : NormedAddCommGroup E
inst✝⁵ : NormedAddCommGroup F
f✝ g✝ : X → E
μ : Measure X
s : Set X
inst✝⁴ : OpensMeasurableSpace X
A K : Set X
𝕜 : Type u_6
inst✝³ : NormedField 𝕜
inst✝² : NormedSpace 𝕜 E
inst✝¹ : T2Space X
inst✝ : SecondCountableTopologyEither X 𝕜
g : X → E
hg : IntegrableOn g K μ
f : X → 𝕜
hf : ContinuousOn f K
hK : IsCompact K
⊢ IntegrableOn (fun x => f x • g x) K μ
state_after: X : Type u_1
Y : Type u_2
E : Type u_3
F : Type u_4
R : Type u_5
inst✝¹⁰ : MeasurableSpace X
inst✝⁹ : TopologicalSpace X
inst✝⁸ : MeasurableSpace Y
inst✝⁷ : TopologicalSpace Y
inst✝⁶ : NormedAddCommGroup E
inst✝⁵ : NormedAddCommGroup F
f✝ g✝ : X → E
μ : Measure X
s : Set X
inst✝⁴ : OpensMeasurableSpace X
A K : Set X
𝕜 : Type u_6
inst✝³ : NormedField 𝕜
inst✝² : NormedSpace 𝕜 E
inst✝¹ : T2Space X
inst✝ : SecondCountableTopologyEither X 𝕜
g : X → E
hg : IntegrableOn g K μ
f : X → 𝕜
hf : ContinuousOn f K
hK : IsCompact K
⊢ Integrable (fun a => ‖f a • g a‖) (μ.restrict K)

X : Type u_1
Y : Type u_2
E : Type u_3
F : Type u_4
R : Type u_5
inst✝¹⁰ : MeasurableSpace X
inst✝⁹ : TopologicalSpace X
inst✝⁸ : MeasurableSpace Y
inst✝⁷ : TopologicalSpace Y
inst✝⁶ : NormedAddCommGroup E
inst✝⁵ : NormedAddCommGroup F
f✝ g✝ : X → E
μ : Measure X
s : Set X
inst✝⁴ : OpensMeasurableSpace X
A K : Set X
𝕜 : Type u_6
inst✝³ : NormedField 𝕜
inst✝² : NormedSpace 𝕜 E
inst✝¹ : T2Space X
inst✝ : SecondCountableTopologyEither X 𝕜
g : X → E
hg : IntegrableOn g K μ
f : X → 𝕜
hf : ContinuousOn f K
hK : IsCompact K
⊢ AEStronglyMeasurable (fun x => f x • g x) (μ.restrict K)
tactic: rw [IntegrableOn, ← integrable_norm_iff]
Theorem: List.Sublist.sym
File: Mathlib/Data/List/Sym.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
xs✝¹ ys✝¹ : List α
n✝ n : ℕ
xs✝ ys✝ : List α
h : xs✝ <+ ys✝
ys xs : List α
x✝ : xs <+ ys
⊢ List.sym 0 xs <+ List.sym 0 ys
state_after: no goals
tactic: simp [List.sym]
state_before: α : Type u_1
β : Type u_2
xs✝ ys✝ : List α
n✝¹ n✝ : ℕ
xs ys : List α
h : xs <+ ys
n : ℕ
⊢ List.sym (n + 1) [] <+ List.sym (n + 1) []
state_after: no goals
tactic: simp only [refl]
state_before: α : Type u_1
β : Type u_2
xs✝¹ ys✝ : List α
n✝¹ n✝ : ℕ
xs✝ ys : List α
h✝ : xs✝ <+ ys
xs : List α
n : ℕ
l₂✝ : List α
a : α
h : xs <+ l₂✝
⊢ List.sym (n + 1) xs <+ List.sym (n + 1) (a :: l₂✝)
state_after: α : Type u_1
β : Type u_2
xs✝¹ ys✝ : List α
n✝¹ n✝ : ℕ
xs✝ ys : List α
h✝ : xs✝ <+ ys
xs : List α
n : ℕ
l₂✝ : List α
a : α
h : xs <+ l₂✝
⊢ [] ++ List.sym (n + 1) xs <+ List.map (fun p => a ::ₛ p) (List.sym n (a :: l₂✝)) ++ List.sym (n + 1) l₂✝
tactic: rw [List.sym, ← nil_append (List.sym (n + 1) xs)]
state_before: α : Type u_1
β : Type u_2
xs✝¹ ys✝ : List α
n✝¹ n✝ : ℕ
xs✝ ys : List α
h✝ : xs✝ <+ ys
xs : List α
n : ℕ
l₂✝ : List α
a : α
h : xs <+ l₂✝
⊢ [] ++ List.sym (n + 1) xs <+ List.map (fun p => a ::ₛ p) (List.sym n (a :: l₂✝)) ++ List.sym (n + 1) l₂✝
state_after: α : Type u_1
β : Type u_2
xs✝¹ ys✝ : List α
n✝¹ n✝ : ℕ
xs✝ ys : List α
h✝ : xs✝ <+ ys
xs : List α
n : ℕ
l₂✝ : List α
a : α
h : xs <+ l₂✝
⊢ List.sym (n + 1) xs <+ List.sym (n + 1) l₂✝
tactic: apply Sublist.append (nil_sublist _)
state_before: α : Type u_1
β : Type u_2
xs✝¹ ys✝ : List α
n✝¹ n✝ : ℕ
xs✝ ys : List α
h✝ : xs✝ <+ ys
xs : List α
n : ℕ
l₂✝ : List α
a : α
h : xs <+ l₂✝
⊢ List.sym (n + 1) xs <+ List.sym (n + 1) l₂✝
state_after: no goals
tactic: exact h.sym (n + 1)
state_before: α : Type u_1
β : Type u_2
xs✝ ys✝ : List α
n✝¹ n✝ : ℕ
xs ys : List α
h✝ : xs <+ ys
n : ℕ
l₁✝ l₂✝ : List α
a : α
h : l₁✝ <+ l₂✝
⊢ List.sym (n + 1) (a :: l₁✝) <+ List.sym (n + 1) (a :: l₂✝)
state_after: α : Type u_1
β : Type u_2
xs✝ ys✝ : List α
n✝¹ n✝ : ℕ
xs ys : List α
h✝ : xs <+ ys
n : ℕ
l₁✝ l₂✝ : List α
a : α
h : l₁✝ <+ l₂✝
⊢ List.map (fun p => a ::ₛ p) (List.sym n (a :: l₁✝)) ++ List.sym (n + 1) l₁✝ <+
    List.map (fun p => a ::ₛ p) (List.sym n (a :: l₂✝)) ++ List.sym (n + 1) l₂✝
tactic: rw [List.sym, List.sym]
state_before: α : Type u_1
β : Type u_2
xs✝ ys✝ : List α
n✝¹ n✝ : ℕ
xs ys : List α
h✝ : xs <+ ys
n : ℕ
l₁✝ l₂✝ : List α
a : α
h : l₁✝ <+ l₂✝
⊢ List.map (fun p => a ::ₛ p) (List.sym n (a :: l₁✝)) ++ List.sym (n + 1) l₁✝ <+
    List.map (fun p => a ::ₛ p) (List.sym n (a :: l₂✝)) ++ List.sym (n + 1) l₂✝
state_after: case hl
α : Type u_1
β : Type u_2
xs✝ ys✝ : List α
n✝¹ n✝ : ℕ
xs ys : List α
h✝ : xs <+ ys
n : ℕ
l₁✝ l₂✝ : List α
a : α
h : l₁✝ <+ l₂✝
⊢ List.map (fun p => a ::ₛ p) (List.sym n (a :: l₁✝)) <+ List.map (fun p => a ::ₛ p) (List.sym n (a :: l₂✝))

case hr
α : Type u_1
β : Type u_2
xs✝ ys✝ : List α
n✝¹ n✝ : ℕ
xs ys : List α
h✝ : xs <+ ys
n : ℕ
l₁✝ l₂✝ : List α
a : α
h : l₁✝ <+ l₂✝
⊢ List.sym (n + 1) l₁✝ <+ List.sym (n + 1) l₂✝
tactic: apply Sublist.append
Theorem: isSimpleModule_iff_quot_maximal
File: Mathlib/RingTheory/SimpleModule.lean

Proof steps:
state_before: ι : Type u_1
R : Type u_2
S : Type u_3
inst✝⁵ : Ring R
inst✝⁴ : Ring S
M : Type u_4
inst✝³ : AddCommGroup M
inst✝² : Module R M
m : Submodule R M
N : Type u_5
inst✝¹ : AddCommGroup N
inst✝ : Module R N
⊢ IsSimpleModule R M ↔ ∃ I, I.IsMaximal ∧ Nonempty (M ≃ₗ[R] R ⧸ I)
state_after: case refine_1
ι : Type u_1
R : Type u_2
S : Type u_3
inst✝⁵ : Ring R
inst✝⁴ : Ring S
M : Type u_4
inst✝³ : AddCommGroup M
inst✝² : Module R M
m : Submodule R M
N : Type u_5
inst✝¹ : AddCommGroup N
inst✝ : Module R N
h : IsSimpleModule R M
⊢ ∃ I, I.IsMaximal ∧ Nonempty (M ≃ₗ[R] R ⧸ I)

case refine_2
ι : Type u_1
R : Type u_2
S : Type u_3
inst✝⁵ : Ring R
inst✝⁴ : Ring S
M : Type u_4
inst✝³ : AddCommGroup M
inst✝² : Module R M
m : Submodule R M
N : Type u_5
inst✝¹ : AddCommGroup N
inst✝ : Module R N
x✝ : ∃ I, I.IsMaximal ∧ Nonempty (M ≃ₗ[R] R ⧸ I)
I : Ideal R
coatom : IsCoatom I
equiv : M ≃ₗ[R] R ⧸ I
⊢ IsSimpleModule R M
tactic: refine ⟨fun h ↦ ?_, fun ⟨I, ⟨coatom⟩, ⟨equiv⟩⟩ ↦ ?_⟩
Theorem: Surreal.bddAbove_of_small
File: Mathlib/SetTheory/Surreal/Basic.lean

Proof steps:
state_before: s : Set Surreal
inst✝ : Small.{u, u + 1} ↑s
⊢ BddAbove s
state_after: no goals
tactic: simpa using bddAbove_range_of_small (Subtype.val : s → Surreal.{u})
Theorem: List.foldl_join
File: Mathlib/Data/List/Basic.lean

Proof steps:
state_before: ι : Type u_1
α : Type u
β : Type v
γ : Type w
l₁ l₂ : List α
f : α → β → α
a : α
l : List β
L : List (List β)
⊢ foldl f a (l :: L).join = foldl (foldl f) a (l :: L)
state_after: no goals
tactic: simp only [join, foldl_append, foldl_cons, foldl_join f (foldl f a l) L]
Theorem: List.iota_eq_reverse_range'
File: .lake/packages/batteries/Batteries/Data/List/Lemmas.lean

Proof steps:
state_before: n : Nat
⊢ iota (n + 1) = (range' 1 (n + 1)).reverse
state_after: no goals
tactic: simp [iota, range'_concat, iota_eq_reverse_range' n, reverse_append, Nat.add_comm]
Theorem: dite_nonneg
File: Mathlib/Order/Basic.lean

Proof steps:
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
π : ι → Type u_4
inst✝² : One α
p : Prop
inst✝¹ : Decidable p
a : p → α
b : ¬p → α
inst✝ : LE α
ha : ∀ (h : p), 1 ≤ a h
hb : ∀ (h : ¬p), 1 ≤ b h
⊢ 1 ≤ dite p a b
state_after: case isTrue
ι : Type u_1
α : Type u_2
β : Type u_3
π : ι → Type u_4
inst✝² : One α
p : Prop
inst✝¹ : Decidable p
a : p → α
b : ¬p → α
inst✝ : LE α
ha : ∀ (h : p), 1 ≤ a h
hb : ∀ (h : ¬p), 1 ≤ b h
h✝ : p
⊢ 1 ≤ a h✝

case isFalse
ι : Type u_1
α : Type u_2
β : Type u_3
π : ι → Type u_4
inst✝² : One α
p : Prop
inst✝¹ : Decidable p
a : p → α
b : ¬p → α
inst✝ : LE α
ha : ∀ (h : p), 1 ≤ a h
hb : ∀ (h : ¬p), 1 ≤ b h
h✝ : ¬p
⊢ 1 ≤ b h✝
tactic: split
state_before: case isTrue
ι : Type u_1
α : Type u_2
β : Type u_3
π : ι → Type u_4
inst✝² : One α
p : Prop
inst✝¹ : Decidable p
a : p → α
b : ¬p → α
inst✝ : LE α
ha : ∀ (h : p), 1 ≤ a h
hb : ∀ (h : ¬p), 1 ≤ b h
h✝ : p
⊢ 1 ≤ a h✝

case isFalse
ι : Type u_1
α : Type u_2
β : Type u_3
π : ι → Type u_4
inst✝² : One α
p : Prop
inst✝¹ : Decidable p
a : p → α
b : ¬p → α
inst✝ : LE α
ha : ∀ (h : p), 1 ≤ a h
hb : ∀ (h : ¬p), 1 ≤ b h
h✝ : ¬p
⊢ 1 ≤ b h✝
state_after: no goals
tactic: exacts [ha ‹_›, hb ‹_›]
Theorem: inner_eq_zero_symm
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 y : E
⊢ ⟪x, y⟫_𝕜 = 0 ↔ ⟪y, x⟫_𝕜 = 0
state_after: 𝕜 : 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 y : E
⊢ (starRingEnd 𝕜) ⟪y, x⟫_𝕜 = 0 ↔ ⟪y, x⟫_𝕜 = 0
tactic: rw [← inner_conj_symm]
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 y : E
⊢ (starRingEnd 𝕜) ⟪y, x⟫_𝕜 = 0 ↔ ⟪y, x⟫_𝕜 = 0
state_after: no goals
tactic: exact star_eq_zero
Theorem: MeasureTheory.weightedSMul_congr
File: Mathlib/MeasureTheory/Integral/Bochner.lean

Proof steps:
state_before: α : Type u_1
E : Type u_2
F : Type u_3
𝕜 : Type u_4
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedSpace ℝ F
m : MeasurableSpace α
μ : Measure α
s t : Set α
hst : μ s = μ t
⊢ weightedSMul μ s = weightedSMul μ t
state_after: case h
α : Type u_1
E : Type u_2
F : Type u_3
𝕜 : Type u_4
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedSpace ℝ F
m : MeasurableSpace α
μ : Measure α
s t : Set α
hst : μ s = μ t
x : F
⊢ (weightedSMul μ s) x = (weightedSMul μ t) x
tactic: ext1 x
state_before: case h
α : Type u_1
E : Type u_2
F : Type u_3
𝕜 : Type u_4
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedSpace ℝ F
m : MeasurableSpace α
μ : Measure α
s t : Set α
hst : μ s = μ t
x : F
⊢ (weightedSMul μ s) x = (weightedSMul μ t) x
state_after: case h
α : Type u_1
E : Type u_2
F : Type u_3
𝕜 : Type u_4
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedSpace ℝ F
m : MeasurableSpace α
μ : Measure α
s t : Set α
hst : μ s = μ t
x : F
⊢ (μ s).toReal • x = (μ t).toReal • x
tactic: simp_rw [weightedSMul_apply]
state_before: case h
α : Type u_1
E : Type u_2
F : Type u_3
𝕜 : Type u_4
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedSpace ℝ F
m : MeasurableSpace α
μ : Measure α
s t : Set α
hst : μ s = μ t
x : F
⊢ (μ s).toReal • x = (μ t).toReal • x
state_after: no goals
tactic: congr 2
Theorem: CategoryTheory.MorphismProperty.LeftFraction.map_ofInv_hom_id
File: Mathlib/CategoryTheory/Localization/CalculusOfFractions.lean

Proof steps:
state_before: C : Type u_1
D : Type u_2
inst✝¹ : Category.{u_3, u_1} C
inst✝ : Category.{u_4, u_2} D
W : MorphismProperty C
X Y : C
s : Y ⟶ X
hs : W s
L : C ⥤ D
hL : W.IsInvertedBy L
⊢ (ofInv s hs).map L hL ≫ L.map s = 𝟙 (L.obj X)
state_after: C : Type u_1
D : Type u_2
inst✝¹ : Category.{u_3, u_1} C
inst✝ : Category.{u_4, u_2} D
W : MorphismProperty C
X Y : C
s : Y ⟶ X
hs : W s
L : C ⥤ D
hL : W.IsInvertedBy L
this : IsIso (L.map s) := hL s hs
⊢ (ofInv s hs).map L hL ≫ L.map s = 𝟙 (L.obj X)
tactic: letI := hL _ hs
state_before: C : Type u_1
D : Type u_2
inst✝¹ : Category.{u_3, u_1} C
inst✝ : Category.{u_4, u_2} D
W : MorphismProperty C
X Y : C
s : Y ⟶ X
hs : W s
L : C ⥤ D
hL : W.IsInvertedBy L
this : IsIso (L.map s) := hL s hs
⊢ (ofInv s hs).map L hL ≫ L.map s = 𝟙 (L.obj X)
state_after: no goals
tactic: simp [map]
Theorem: discrim_neg
File: Mathlib/Algebra/QuadraticDiscriminant.lean

Proof steps:
state_before: R : Type u_1
inst✝ : Ring R
a b c : R
⊢ discrim (-a) (-b) (-c) = discrim a b c
state_after: no goals
tactic: simp [discrim]
Theorem: CategoryTheory.ShortComplex.π_leftRightHomologyComparison'_ι
File: Mathlib/Algebra/Homology/ShortComplex/Homology.lean

Proof steps:
state_before: C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : HasZeroMorphisms C
S S₁ S₂ S₃ S₄ : ShortComplex C
φ : S₁ ⟶ S₂
h₁✝ : S₁.HomologyData
h₂✝ : S₂.HomologyData
h₁ : S.LeftHomologyData
h₂ : S.RightHomologyData
⊢ h₁.π ≫ leftRightHomologyComparison' h₁ h₂ ≫ h₂.ι = h₁.i ≫ h₂.p
state_after: no goals
tactic: simp only [leftRightHomologyComparison'_eq_liftH,
    RightHomologyData.liftH_ι, LeftHomologyData.π_descH]
Theorem: List.pmap_eq_nil
File: Mathlib/Data/List/Basic.lean

Proof steps:
state_before: ι : Type u_1
α : Type u
β : Type v
γ : Type w
l₁ l₂ : List α
p : α → Prop
f : (a : α) → p a → β
l : List α
H : ∀ (a : α), a ∈ l → p a
⊢ pmap f l H = [] ↔ l = []
state_after: no goals
tactic: rw [← length_eq_zero, length_pmap, length_eq_zero]
Theorem: spectrum.spectralRadius_lt_of_forall_lt_of_nonempty
File: Mathlib/Analysis/Normed/Algebra/Spectrum.lean

Proof steps:
state_before: 𝕜 : Type u_1
A : Type u_2
inst✝⁴ : NormedField 𝕜
inst✝³ : NormedRing A
inst✝² : NormedAlgebra 𝕜 A
inst✝¹ : CompleteSpace A
inst✝ : ProperSpace 𝕜
a : A
ha : (σ a).Nonempty
r : ℝ≥0
hr : ∀ k ∈ σ a, ‖k‖₊ < r
⊢ ∀ x ∈ σ a, ↑‖x‖₊ < ↑r
state_after: no goals
tactic: exact mod_cast hr
Theorem: Set.surjOn_empty_iff
File: Mathlib/Data/Set/Function.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
π : α → Type u_5
s s₁ s₂ : Set α
t t₁ t₂ : Set β
p : Set γ
f f₁ f₂ f₃ : α → β
g g₁ g₂ : β → γ
f' f₁' f₂' : β → α
g' : γ → β
a : α
b : β
⊢ SurjOn f ∅ t ↔ t = ∅
state_after: no goals
tactic: simp [SurjOn, subset_empty_iff]
Theorem: intervalIntegral.integral_Iio_add_Ici
File: Mathlib/MeasureTheory/Integral/IntervalIntegral.lean

Proof steps:
state_before: ι : Type u_1
𝕜 : Type u_2
E : Type u_3
F : Type u_4
A : Type u_5
inst✝² : NormedAddCommGroup E
inst✝¹ : CompleteSpace E
inst✝ : NormedSpace ℝ E
a b c d : ℝ
f g : ℝ → E
μ : Measure ℝ
h_left : IntegrableOn f (Iio b) μ
h_right : IntegrableOn f (Ici b) μ
⊢ ∫ (x : ℝ) in Iio b, f x ∂μ + ∫ (x : ℝ) in Ici b, f x ∂μ = ∫ (x : ℝ), f x ∂μ
state_after: case h.e'_3.h.e'_6
ι : Type u_1
𝕜 : Type u_2
E : Type u_3
F : Type u_4
A : Type u_5
inst✝² : NormedAddCommGroup E
inst✝¹ : CompleteSpace E
inst✝ : NormedSpace ℝ E
a b c d : ℝ
f g : ℝ → E
μ : Measure ℝ
h_left : IntegrableOn f (Iio b) μ
h_right : IntegrableOn f (Ici b) μ
⊢ μ = μ.restrict (Iio b ∪ Ici b)
tactic: convert (integral_union (Iio_disjoint_Ici <| Eq.le rfl) measurableSet_Ici h_left h_right).symm
state_before: case h.e'_3.h.e'_6
ι : Type u_1
𝕜 : Type u_2
E : Type u_3
F : Type u_4
A : Type u_5
inst✝² : NormedAddCommGroup E
inst✝¹ : CompleteSpace E
inst✝ : NormedSpace ℝ E
a b c d : ℝ
f g : ℝ → E
μ : Measure ℝ
h_left : IntegrableOn f (Iio b) μ
h_right : IntegrableOn f (Ici b) μ
⊢ μ = μ.restrict (Iio b ∪ Ici b)
state_after: no goals
tactic: rw [Iio_union_Ici, Measure.restrict_univ]
Theorem: Real.rpow_natCast_mul
File: Mathlib/Analysis/SpecialFunctions/Pow/Real.lean

Proof steps:
state_before: x y z✝ : ℝ
n✝ : ℕ
hx : 0 ≤ x
n : ℕ
z : ℝ
⊢ x ^ (↑n * z) = (x ^ n) ^ z
state_after: no goals
tactic: rw [rpow_mul hx, rpow_natCast]
Theorem: Homeomorph.opensCongr_apply
File: Mathlib/Topology/Sets/Opens.lean

Proof steps:
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
inst✝² : TopologicalSpace α
inst✝¹ : TopologicalSpace β
inst✝ : TopologicalSpace γ
f : α ≃ₜ β
⊢ ∀ {a b : Opens α},
    { toFun := ⇑(comap f.symm.toContinuousMap), invFun := ⇑(comap f.toContinuousMap), left_inv := ⋯, right_inv := ⋯ }
          a ≤
        { toFun := ⇑(comap f.symm.toContinuousMap), invFun := ⇑(comap f.toContinuousMap), left_inv := ⋯,
            right_inv := ⋯ }
          b ↔
      a ≤ b
state_after: ι : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
inst✝² : TopologicalSpace α
inst✝¹ : TopologicalSpace β
inst✝ : TopologicalSpace γ
f : α ≃ₜ β
⊢ ∀ {a b : Opens α},
    ↑({ toFun := ⇑(comap f.symm.toContinuousMap), invFun := ⇑(comap f.toContinuousMap), left_inv := ⋯, right_inv := ⋯ }
            a) ⊆
        ↑({ toFun := ⇑(comap f.symm.toContinuousMap), invFun := ⇑(comap f.toContinuousMap), left_inv := ⋯,
              right_inv := ⋯ }
            b) ↔
      ↑a ⊆ ↑b
tactic: simp only [← SetLike.coe_subset_coe]
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
inst✝² : TopologicalSpace α
inst✝¹ : TopologicalSpace β
inst✝ : TopologicalSpace γ
f : α ≃ₜ β
⊢ ∀ {a b : Opens α},
    ↑({ toFun := ⇑(comap f.symm.toContinuousMap), invFun := ⇑(comap f.toContinuousMap), left_inv := ⋯, right_inv := ⋯ }
            a) ⊆
        ↑({ toFun := ⇑(comap f.symm.toContinuousMap), invFun := ⇑(comap f.toContinuousMap), left_inv := ⋯,
              right_inv := ⋯ }
            b) ↔
      ↑a ⊆ ↑b
state_after: no goals
tactic: exact f.symm.surjective.preimage_subset_preimage_iff