ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: HomologicalComplex.unopFunctor_obj
File: Mathlib/Algebra/Homology/Opposite.lean

Proof steps:
state_before: ι : Type u_1
V : Type u_2
inst✝¹ : Category.{?u.46156, u_2} V
c : ComplexShape ι
inst✝ : HasZeroMorphisms V
X✝ Y✝ : (HomologicalComplex Vᵒᵖ c)ᵒᵖ
f : X✝ ⟶ Y✝
i j : ι
x✝ : c.symm.Rel i j
⊢ (fun i => (f.unop.f i).unop) i ≫ ((fun X => (unop X).unop) Y✝).d i j =
    ((fun X => (unop X).unop) X✝).d i j ≫ (fun i => (f.unop.f i).unop) j
state_after: no goals
tactic: simp only [unop_d, ← unop_comp, f.unop.comm]
Theorem: FiniteDimensional.nonempty_linearEquiv_of_finrank_eq
File: Mathlib/LinearAlgebra/Dimension/Free.lean

Proof steps:
state_before: R : Type u
M M₁ : Type v
M' : Type v'
inst✝¹² : Ring R
inst✝¹¹ : StrongRankCondition R
inst✝¹⁰ : AddCommGroup M
inst✝⁹ : Module R M
inst✝⁸ : Module.Free R M
inst✝⁷ : AddCommGroup M'
inst✝⁶ : Module R M'
inst✝⁵ : Module.Free R M'
inst✝⁴ : AddCommGroup M₁
inst✝³ : Module R M₁
inst✝² : Module.Free R M₁
inst✝¹ : Module.Finite R M
inst✝ : Module.Finite R M'
cond : finrank R M = finrank R M'
⊢ lift.{v', v} (Module.rank R M) = lift.{v, v'} (Module.rank R M')
state_after: no goals
tactic: simp only [← finrank_eq_rank, cond, lift_natCast]
Theorem: ProbabilityTheory.IsMeasurableRatCDF.stieltjesFunctionAux_nonneg
File: Mathlib/Probability/Kernel/Disintegration/MeasurableStieltjes.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
ι : Type u_3
inst✝ : MeasurableSpace α
f : α → ℚ → ℝ
hf : IsMeasurableRatCDF f
a : α
r : ℝ
⊢ 0 ≤ stieltjesFunctionAux f a r
state_after: α : Type u_1
β : Type u_2
ι : Type u_3
inst✝ : MeasurableSpace α
f : α → ℚ → ℝ
hf : IsMeasurableRatCDF f
a : α
r : ℝ
this : Nonempty { r' // r < ↑r' }
⊢ 0 ≤ stieltjesFunctionAux f a r
tactic: have : Nonempty { r' : ℚ // r < ↑r' } := by
    obtain ⟨r, hrx⟩ := exists_rat_gt r
    exact ⟨⟨r, hrx⟩⟩
state_before: α : Type u_1
β : Type u_2
ι : Type u_3
inst✝ : MeasurableSpace α
f : α → ℚ → ℝ
hf : IsMeasurableRatCDF f
a : α
r : ℝ
this : Nonempty { r' // r < ↑r' }
⊢ 0 ≤ stieltjesFunctionAux f a r
state_after: α : Type u_1
β : Type u_2
ι : Type u_3
inst✝ : MeasurableSpace α
f : α → ℚ → ℝ
hf : IsMeasurableRatCDF f
a : α
r : ℝ
this : Nonempty { r' // r < ↑r' }
⊢ 0 ≤ ⨅ q, f a ↑q
tactic: rw [IsMeasurableRatCDF.stieltjesFunctionAux_def]
state_before: α : Type u_1
β : Type u_2
ι : Type u_3
inst✝ : MeasurableSpace α
f : α → ℚ → ℝ
hf : IsMeasurableRatCDF f
a : α
r : ℝ
this : Nonempty { r' // r < ↑r' }
⊢ 0 ≤ ⨅ q, f a ↑q
state_after: no goals
tactic: exact le_ciInf fun r' ↦ hf.nonneg a _
Theorem: Equiv.piFinSuccAbove_symm_apply
File: Mathlib/Logic/Equiv/Fin.lean

Proof steps:
state_before: m n : ℕ
α : Fin (n + 1) → Type u
i : Fin (n + 1)
f : (j : Fin (n + 1)) → α j
⊢ (fun f => i.insertNth f.1 f.2) ((fun f => (f i, i.removeNth f)) f) = f
state_after: no goals
tactic: simp
state_before: m n : ℕ
α : Fin (n + 1) → Type u
i : Fin (n + 1)
f : α i × ((j : Fin n) → α (i.succAbove j))
⊢ (fun f => (f i, i.removeNth f)) ((fun f => i.insertNth f.1 f.2) f) = f
state_after: no goals
tactic: simp
Theorem: linearIndependent_biUnion_of_directed
File: Mathlib/LinearAlgebra/LinearIndependent.lean

Proof steps:
state_before: ι : Type u'
ι' : Type u_1
R : Type u_2
K : Type u_3
M : Type u_4
M' : Type u_5
M'' : Type u_6
V : Type u
V' : Type u_7
v : ι → M
inst✝⁶ : Semiring R
inst✝⁵ : AddCommMonoid M
inst✝⁴ : AddCommMonoid M'
inst✝³ : AddCommMonoid M''
inst✝² : Module R M
inst✝¹ : Module R M'
inst✝ : Module R M''
a b : R
x y : M
η : Type u_8
s : Set η
t : η → Set M
hs : DirectedOn (t ⁻¹'o fun x x_1 => x ⊆ x_1) s
h : ∀ a ∈ s, LinearIndependent R fun (x : ↑(t a)) => ↑x
⊢ LinearIndependent R fun (x : ↑(⋃ a ∈ s, t a)) => ↑x
state_after: ι : Type u'
ι' : Type u_1
R : Type u_2
K : Type u_3
M : Type u_4
M' : Type u_5
M'' : Type u_6
V : Type u
V' : Type u_7
v : ι → M
inst✝⁶ : Semiring R
inst✝⁵ : AddCommMonoid M
inst✝⁴ : AddCommMonoid M'
inst✝³ : AddCommMonoid M''
inst✝² : Module R M
inst✝¹ : Module R M'
inst✝ : Module R M''
a b : R
x y : M
η : Type u_8
s : Set η
t : η → Set M
hs : DirectedOn (t ⁻¹'o fun x x_1 => x ⊆ x_1) s
h : ∀ a ∈ s, LinearIndependent R fun (x : ↑(t a)) => ↑x
⊢ LinearIndependent R fun (x : ↑(⋃ x, t ↑x)) => ↑x
tactic: rw [biUnion_eq_iUnion]
state_before: ι : Type u'
ι' : Type u_1
R : Type u_2
K : Type u_3
M : Type u_4
M' : Type u_5
M'' : Type u_6
V : Type u
V' : Type u_7
v : ι → M
inst✝⁶ : Semiring R
inst✝⁵ : AddCommMonoid M
inst✝⁴ : AddCommMonoid M'
inst✝³ : AddCommMonoid M''
inst✝² : Module R M
inst✝¹ : Module R M'
inst✝ : Module R M''
a b : R
x y : M
η : Type u_8
s : Set η
t : η → Set M
hs : DirectedOn (t ⁻¹'o fun x x_1 => x ⊆ x_1) s
h : ∀ a ∈ s, LinearIndependent R fun (x : ↑(t a)) => ↑x
⊢ LinearIndependent R fun (x : ↑(⋃ x, t ↑x)) => ↑x
state_after: no goals
tactic: exact
    linearIndependent_iUnion_of_directed (directed_comp.2 <| hs.directed_val) (by simpa using h)
Theorem: YoungDiagram.mk_mem_col_iff
File: Mathlib/Combinatorics/Young/YoungDiagram.lean

Proof steps:
state_before: μ : YoungDiagram
i j : ℕ
⊢ (i, j) ∈ μ.col j ↔ (i, j) ∈ μ
state_after: no goals
tactic: simp [col]
Theorem: HomologicalComplex.IsStrictlySupportedOutside.isSupportedOutside
File: Mathlib/Algebra/Homology/Embedding/IsSupported.lean

Proof steps:
state_before: ι : Type u_1
ι' : Type u_2
c : ComplexShape ι
c' : ComplexShape ι'
C : Type u_3
inst✝¹ : Category.{u_4, u_3} C
inst✝ : HasZeroMorphisms C
K L : HomologicalComplex C c'
e' : K ≅ L
e : c.Embedding c'
h : K.IsStrictlySupportedOutside e
i : ι
⊢ K.ExactAt (e.f i)
state_after: ι : Type u_1
ι' : Type u_2
c : ComplexShape ι
c' : ComplexShape ι'
C : Type u_3
inst✝¹ : Category.{u_4, u_3} C
inst✝ : HasZeroMorphisms C
K L : HomologicalComplex C c'
e' : K ≅ L
e : c.Embedding c'
h : K.IsStrictlySupportedOutside e
i : ι
⊢ (K.sc (e.f i)).Exact
tactic: rw [exactAt_iff]
state_before: ι : Type u_1
ι' : Type u_2
c : ComplexShape ι
c' : ComplexShape ι'
C : Type u_3
inst✝¹ : Category.{u_4, u_3} C
inst✝ : HasZeroMorphisms C
K L : HomologicalComplex C c'
e' : K ≅ L
e : c.Embedding c'
h : K.IsStrictlySupportedOutside e
i : ι
⊢ (K.sc (e.f i)).Exact
state_after: no goals
tactic: exact ShortComplex.exact_of_isZero_X₂ _ (h.isZero i)
Theorem: List.sorted_mergeSort
File: Mathlib/Data/List/Sort.lean

Proof steps:
state_before: α : Type u
r : α → α → Prop
inst✝² : DecidableRel r
inst✝¹ : IsTotal α r
inst✝ : IsTrans α r
⊢ Sorted r (mergeSort r [])
state_after: no goals
tactic: simp [mergeSort]
state_before: α : Type u
r : α → α → Prop
inst✝² : DecidableRel r
inst✝¹ : IsTotal α r
inst✝ : IsTrans α r
a : α
⊢ Sorted r (mergeSort r [a])
state_after: no goals
tactic: simp [mergeSort]
state_before: α : Type u
r : α → α → Prop
inst✝² : DecidableRel r
inst✝¹ : IsTotal α r
inst✝ : IsTrans α r
a b : α
l : List α
⊢ Sorted r (mergeSort r (a :: b :: l))
state_after: case mk
α : Type u
r : α → α → Prop
inst✝² : DecidableRel r
inst✝¹ : IsTotal α r
inst✝ : IsTrans α r
a b : α
l l₁ l₂ : List α
e : (a :: b :: l).split = (l₁, l₂)
⊢ Sorted r (mergeSort r (a :: b :: l))
tactic: cases' e : split (a :: b :: l) with l₁ l₂
state_before: case mk
α : Type u
r : α → α → Prop
inst✝² : DecidableRel r
inst✝¹ : IsTotal α r
inst✝ : IsTrans α r
a b : α
l l₁ l₂ : List α
e : (a :: b :: l).split = (l₁, l₂)
⊢ Sorted r (mergeSort r (a :: b :: l))
state_after: case mk.intro
α : Type u
r : α → α → Prop
inst✝² : DecidableRel r
inst✝¹ : IsTotal α r
inst✝ : IsTrans α r
a b : α
l l₁ l₂ : List α
e : (a :: b :: l).split = (l₁, l₂)
h₁ : l₁.length < (a :: b :: l).length
h₂ : l₂.length < (a :: b :: l).length
⊢ Sorted r (mergeSort r (a :: b :: l))
tactic: cases' length_split_lt e with h₁ h₂
state_before: case mk.intro
α : Type u
r : α → α → Prop
inst✝² : DecidableRel r
inst✝¹ : IsTotal α r
inst✝ : IsTrans α r
a b : α
l l₁ l₂ : List α
e : (a :: b :: l).split = (l₁, l₂)
h₁ : l₁.length < (a :: b :: l).length
h₂ : l₂.length < (a :: b :: l).length
⊢ Sorted r (mergeSort r (a :: b :: l))
state_after: case mk.intro
α : Type u
r : α → α → Prop
inst✝² : DecidableRel r
inst✝¹ : IsTotal α r
inst✝ : IsTrans α r
a b : α
l l₁ l₂ : List α
e : (a :: b :: l).split = (l₁, l₂)
h₁ : l₁.length < (a :: b :: l).length
h₂ : l₂.length < (a :: b :: l).length
⊢ Sorted r (merge (fun x x_1 => decide (r x x_1)) (mergeSort r l₁) (mergeSort r l₂))
tactic: rw [mergeSort_cons_cons r e]
state_before: case mk.intro
α : Type u
r : α → α → Prop
inst✝² : DecidableRel r
inst✝¹ : IsTotal α r
inst✝ : IsTrans α r
a b : α
l l₁ l₂ : List α
e : (a :: b :: l).split = (l₁, l₂)
h₁ : l₁.length < (a :: b :: l).length
h₂ : l₂.length < (a :: b :: l).length
⊢ Sorted r (merge (fun x x_1 => decide (r x x_1)) (mergeSort r l₁) (mergeSort r l₂))
state_after: no goals
tactic: exact (sorted_mergeSort l₁).merge (sorted_mergeSort l₂)
Theorem: Filter.cocardinal_aleph0_eq_cofinite
File: Mathlib/Order/Filter/Cocardinal.lean

Proof steps:
state_before: ι α β : Type u
c : Cardinal.{u}
hreg : c.IsRegular
l : Filter α
⊢ cocardinal α isRegular_aleph0 = cofinite
state_after: no goals
tactic: aesop
Theorem: IsLocalization.mk'_mem_map_algebraMap_iff
File: Mathlib/RingTheory/Localization/Ideal.lean

Proof steps:
state_before: R : Type u_1
inst✝³ : CommSemiring R
M : Submonoid R
S : Type u_2
inst✝² : CommSemiring S
inst✝¹ : Algebra R S
inst✝ : IsLocalization M S
I : Ideal R
x : R
s : ↥M
⊢ mk' S x s ∈ Ideal.map (algebraMap R S) I ↔ ∃ s ∈ M, s * x ∈ I
state_after: R : Type u_1
inst✝³ : CommSemiring R
M : Submonoid R
S : Type u_2
inst✝² : CommSemiring S
inst✝¹ : Algebra R S
inst✝ : IsLocalization M S
I : Ideal R
x : R
s : ↥M
⊢ (∃ x_1, (algebraMap R S) x * (algebraMap R S) ↑x_1.2 = (algebraMap R S) ↑x_1.1) ↔ ∃ s ∈ M, s * x ∈ I
tactic: rw [← Ideal.unit_mul_mem_iff_mem _ (IsLocalization.map_units S s), IsLocalization.mk'_spec',
    IsLocalization.mem_map_algebraMap_iff M]
state_before: R : Type u_1
inst✝³ : CommSemiring R
M : Submonoid R
S : Type u_2
inst✝² : CommSemiring S
inst✝¹ : Algebra R S
inst✝ : IsLocalization M S
I : Ideal R
x : R
s : ↥M
⊢ (∃ x_1, (algebraMap R S) x * (algebraMap R S) ↑x_1.2 = (algebraMap R S) ↑x_1.1) ↔ ∃ s ∈ M, s * x ∈ I
state_after: R : Type u_1
inst✝³ : CommSemiring R
M : Submonoid R
S : Type u_2
inst✝² : CommSemiring S
inst✝¹ : Algebra R S
inst✝ : IsLocalization M S
I : Ideal R
x : R
s : ↥M
⊢ (∃ x_1 c, ↑(c * x_1.2) * x = ↑c * ↑x_1.1) ↔ ∃ s ∈ M, s * x ∈ I
tactic: simp_rw [← map_mul, IsLocalization.eq_iff_exists M, mul_comm x, ← mul_assoc, ← Submonoid.coe_mul]
state_before: R : Type u_1
inst✝³ : CommSemiring R
M : Submonoid R
S : Type u_2
inst✝² : CommSemiring S
inst✝¹ : Algebra R S
inst✝ : IsLocalization M S
I : Ideal R
x : R
s : ↥M
⊢ (∃ x_1 c, ↑(c * x_1.2) * x = ↑c * ↑x_1.1) ↔ ∃ s ∈ M, s * x ∈ I
state_after: no goals
tactic: exact ⟨fun ⟨⟨y, t⟩, c, h⟩ ↦ ⟨_, (c * t).2, h ▸ I.mul_mem_left c.1 y.2⟩, fun ⟨s, hs, h⟩ ↦
    ⟨⟨⟨_, h⟩, ⟨s, hs⟩⟩, 1, by simp⟩⟩
Theorem: div_le_div_of_nonneg_right
File: Mathlib/Algebra/Order/Field/Basic.lean

Proof steps:
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
inst✝ : LinearOrderedSemifield α
a b c d e : α
m n : ℤ
hab : a ≤ b
hc : 0 ≤ c
⊢ a / c ≤ b / c
state_after: ι : Type u_1
α : Type u_2
β : Type u_3
inst✝ : LinearOrderedSemifield α
a b c d e : α
m n : ℤ
hab : a ≤ b
hc : 0 ≤ c
⊢ a * (1 / c) ≤ b * (1 / c)
tactic: rw [div_eq_mul_one_div a c, div_eq_mul_one_div b c]
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
inst✝ : LinearOrderedSemifield α
a b c d e : α
m n : ℤ
hab : a ≤ b
hc : 0 ≤ c
⊢ a * (1 / c) ≤ b * (1 / c)
state_after: no goals
tactic: exact mul_le_mul_of_nonneg_right hab (one_div_nonneg (α := α) |>.2 hc)
Theorem: ENNReal.log_strictMono
File: Mathlib/Analysis/SpecialFunctions/Log/ENNRealLog.lean

Proof steps:
state_before: ⊢ StrictMono log
state_after: x y : ℝ≥0∞
h : x < y
⊢ x.log < y.log
tactic: intro x y h
state_before: x y : ℝ≥0∞
h : x < y
⊢ x.log < y.log
state_after: x y : ℝ≥0∞
h : x < y
⊢ (if x = 0 then ⊥ else if x = ⊤ then ⊤ else ↑(Real.log x.toReal)) <
    if y = 0 then ⊥ else if y = ⊤ then ⊤ else ↑(Real.log y.toReal)
tactic: unfold log
state_before: x y : ℝ≥0∞
h : x < y
⊢ (if x = 0 then ⊥ else if x = ⊤ then ⊤ else ↑(Real.log x.toReal)) <
    if y = 0 then ⊥ else if y = ⊤ then ⊤ else ↑(Real.log y.toReal)
state_after: case inl
y : ℝ≥0∞
h : 0 < y
⊢ (if 0 = 0 then ⊥ else if 0 = ⊤ then ⊤ else ↑(Real.log (ENNReal.toReal 0))) <
    if y = 0 then ⊥ else if y = ⊤ then ⊤ else ↑(Real.log y.toReal)

case inr.inl
y : ℝ≥0∞
h : ⊤ < y
⊢ (if ⊤ = 0 then ⊥ else if ⊤ = ⊤ then ⊤ else ↑(Real.log ⊤.toReal)) <
    if y = 0 then ⊥ else if y = ⊤ then ⊤ else ↑(Real.log y.toReal)

case inr.inr
x y : ℝ≥0∞
h : x < y
x_real : 0 < x.toReal
⊢ (if x = 0 then ⊥ else if x = ⊤ then ⊤ else ↑(Real.log x.toReal)) <
    if y = 0 then ⊥ else if y = ⊤ then ⊤ else ↑(Real.log y.toReal)
tactic: rcases ENNReal.trichotomy x with (rfl | rfl | x_real)
Theorem: coe_toPrincipalIdeal
File: Mathlib/RingTheory/ClassGroup.lean

Proof steps:
state_before: R : Type u_1
K : Type u_2
L : Type u_3
inst✝⁹ : CommRing R
inst✝⁸ : Field K
inst✝⁷ : Field L
inst✝⁶ : DecidableEq L
inst✝⁵ : Algebra R K
inst✝⁴ : IsFractionRing R K
inst✝³ : Algebra K L
inst✝² : FiniteDimensional K L
inst✝¹ : Algebra R L
inst✝ : IsScalarTower R K L
x : Kˣ
⊢ ↑((toPrincipalIdeal R K) x) = spanSingleton R⁰ ↑x
state_after: R : Type u_1
K : Type u_2
L : Type u_3
inst✝⁹ : CommRing R
inst✝⁸ : Field K
inst✝⁷ : Field L
inst✝⁶ : DecidableEq L
inst✝⁵ : Algebra R K
inst✝⁴ : IsFractionRing R K
inst✝³ : Algebra K L
inst✝² : FiniteDimensional K L
inst✝¹ : Algebra R L
inst✝ : IsScalarTower R K L
x : Kˣ
⊢ ↑({ toFun := fun x => { val := spanSingleton R⁰ ↑x, inv := spanSingleton R⁰ (↑x)⁻¹, val_inv := ⋯, inv_val := ⋯ },
          map_one' := ⋯, map_mul' := ⋯ }
        x) =
    spanSingleton R⁰ ↑x
tactic: simp only [toPrincipalIdeal]
state_before: R : Type u_1
K : Type u_2
L : Type u_3
inst✝⁹ : CommRing R
inst✝⁸ : Field K
inst✝⁷ : Field L
inst✝⁶ : DecidableEq L
inst✝⁵ : Algebra R K
inst✝⁴ : IsFractionRing R K
inst✝³ : Algebra K L
inst✝² : FiniteDimensional K L
inst✝¹ : Algebra R L
inst✝ : IsScalarTower R K L
x : Kˣ
⊢ ↑({ toFun := fun x => { val := spanSingleton R⁰ ↑x, inv := spanSingleton R⁰ (↑x)⁻¹, val_inv := ⋯, inv_val := ⋯ },
          map_one' := ⋯, map_mul' := ⋯ }
        x) =
    spanSingleton R⁰ ↑x
state_after: no goals
tactic: rfl
Theorem: NNRat.ext_num_den
File: Mathlib/Data/NNRat/Defs.lean

Proof steps:
state_before: p q : ℚ≥0
hn : p.num = q.num
hd : p.den = q.den
⊢ p = q
state_after: p q : ℚ≥0
hn : p.num = q.num
hd : p.den = q.den
⊢ (↑p).num = (↑q).num
tactic: refine ext <| Rat.ext ?_ hd
state_before: p q : ℚ≥0
hn : p.num = q.num
hd : p.den = q.den
⊢ (↑p).num = (↑q).num
state_after: no goals
tactic: simpa [num_coe]
Theorem: Fin.castSucc_castPred
File: Mathlib/Data/Fin/Basic.lean

Proof steps:
state_before: n m : ℕ
i : Fin (n + 1)
h : i ≠ last n
⊢ (i.castPred h).castSucc = i
state_after: case intro
n m : ℕ
y : Fin n
h : y.castSucc ≠ last n
⊢ (y.castSucc.castPred h).castSucc = y.castSucc
tactic: rcases exists_castSucc_eq.mpr h with ⟨y, rfl⟩
state_before: case intro
n m : ℕ
y : Fin n
h : y.castSucc ≠ last n
⊢ (y.castSucc.castPred h).castSucc = y.castSucc
state_after: no goals
tactic: rw [castPred_castSucc]
Theorem: Set.not_subset_iff_exists_mem_not_mem
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 : Set α✝
α : Type u_1
s t : Set α
⊢ ¬s ⊆ t ↔ ∃ x ∈ s, x ∉ t
state_after: no goals
tactic: simp [subset_def]
Theorem: banach_steinhaus
File: Mathlib/Analysis/Normed/Operator/BanachSteinhaus.lean

Proof steps:
state_before: E : Type u_1
F : Type u_2
𝕜 : Type u_3
𝕜₂ : Type u_4
inst✝⁷ : SeminormedAddCommGroup E
inst✝⁶ : SeminormedAddCommGroup F
inst✝⁵ : NontriviallyNormedField 𝕜
inst✝⁴ : NontriviallyNormedField 𝕜₂
inst✝³ : NormedSpace 𝕜 E
inst✝² : NormedSpace 𝕜₂ F
σ₁₂ : 𝕜 →+* 𝕜₂
inst✝¹ : RingHomIsometric σ₁₂
ι : Type u_5
inst✝ : CompleteSpace E
g : ι → E →SL[σ₁₂] F
h : ∀ (x : E), ∃ C, ∀ (i : ι), ‖(g i) x‖ ≤ C
⊢ ∃ C', ∀ (i : ι), ‖g i‖ ≤ C'
state_after: E : Type u_1
F : Type u_2
𝕜 : Type u_3
𝕜₂ : Type u_4
inst✝⁷ : SeminormedAddCommGroup E
inst✝⁶ : SeminormedAddCommGroup F
inst✝⁵ : NontriviallyNormedField 𝕜
inst✝⁴ : NontriviallyNormedField 𝕜₂
inst✝³ : NormedSpace 𝕜 E
inst✝² : NormedSpace 𝕜₂ F
σ₁₂ : 𝕜 →+* 𝕜₂
inst✝¹ : RingHomIsometric σ₁₂
ι : Type u_5
inst✝ : CompleteSpace E
g : ι → E →SL[σ₁₂] F
h : ∀ (x : E), ∃ C, ∀ (i : ι), ‖(g i) x‖ ≤ C
⊢ UniformEquicontinuous (DFunLike.coe ∘ g)
tactic: rw [show (∃ C, ∀ i, ‖g i‖ ≤ C) ↔ _ from (NormedSpace.equicontinuous_TFAE g).out 5 2]
state_before: E : Type u_1
F : Type u_2
𝕜 : Type u_3
𝕜₂ : Type u_4
inst✝⁷ : SeminormedAddCommGroup E
inst✝⁶ : SeminormedAddCommGroup F
inst✝⁵ : NontriviallyNormedField 𝕜
inst✝⁴ : NontriviallyNormedField 𝕜₂
inst✝³ : NormedSpace 𝕜 E
inst✝² : NormedSpace 𝕜₂ F
σ₁₂ : 𝕜 →+* 𝕜₂
inst✝¹ : RingHomIsometric σ₁₂
ι : Type u_5
inst✝ : CompleteSpace E
g : ι → E →SL[σ₁₂] F
h : ∀ (x : E), ∃ C, ∀ (i : ι), ‖(g i) x‖ ≤ C
⊢ UniformEquicontinuous (DFunLike.coe ∘ g)
state_after: E : Type u_1
F : Type u_2
𝕜 : Type u_3
𝕜₂ : Type u_4
inst✝⁷ : SeminormedAddCommGroup E
inst✝⁶ : SeminormedAddCommGroup F
inst✝⁵ : NontriviallyNormedField 𝕜
inst✝⁴ : NontriviallyNormedField 𝕜₂
inst✝³ : NormedSpace 𝕜 E
inst✝² : NormedSpace 𝕜₂ F
σ₁₂ : 𝕜 →+* 𝕜₂
inst✝¹ : RingHomIsometric σ₁₂
ι : Type u_5
inst✝ : CompleteSpace E
g : ι → E →SL[σ₁₂] F
h : ∀ (x : E), ∃ C, ∀ (i : ι), ‖(g i) x‖ ≤ C
x✝ : Fin 1
x : E
⊢ BddAbove (range fun i => (normSeminorm 𝕜₂ F) ((g i) x))
tactic: refine (norm_withSeminorms 𝕜₂ F).banach_steinhaus (fun _ x ↦ ?_)
state_before: E : Type u_1
F : Type u_2
𝕜 : Type u_3
𝕜₂ : Type u_4
inst✝⁷ : SeminormedAddCommGroup E
inst✝⁶ : SeminormedAddCommGroup F
inst✝⁵ : NontriviallyNormedField 𝕜
inst✝⁴ : NontriviallyNormedField 𝕜₂
inst✝³ : NormedSpace 𝕜 E
inst✝² : NormedSpace 𝕜₂ F
σ₁₂ : 𝕜 →+* 𝕜₂
inst✝¹ : RingHomIsometric σ₁₂
ι : Type u_5
inst✝ : CompleteSpace E
g : ι → E →SL[σ₁₂] F
h : ∀ (x : E), ∃ C, ∀ (i : ι), ‖(g i) x‖ ≤ C
x✝ : Fin 1
x : E
⊢ BddAbove (range fun i => (normSeminorm 𝕜₂ F) ((g i) x))
state_after: no goals
tactic: simpa [bddAbove_def, forall_mem_range] using h x
Theorem: WittVector.mapFun.mul
File: Mathlib/RingTheory/WittVector/Basic.lean

Proof steps:
state_before: p : ℕ
R : Type u_1
S : Type u_2
T : Type u_3
hp : Fact (Nat.Prime p)
inst✝² : CommRing R
inst✝¹ : CommRing S
inst✝ : CommRing T
α : Type u_4
β : Type u_5
f : R →+* S
x y : 𝕎 R
⊢ mapFun (⇑f) (x * y) = mapFun (⇑f) x * mapFun (⇑f) y
state_after: no goals
tactic: map_fun_tac
Theorem: Real.contDiffAt_arccos_iff
File: Mathlib/Analysis/SpecialFunctions/Trigonometric/InverseDeriv.lean

Proof steps:
state_before: x : ℝ
n : ℕ∞
⊢ ContDiffAt ℝ n arccos x ↔ n = 0 ∨ x ≠ -1 ∧ x ≠ 1
state_after: no goals
tactic: refine Iff.trans ⟨fun h => ?_, fun h => ?_⟩ contDiffAt_arcsin_iff <;>
    simpa [arccos] using (contDiffAt_const (c := π / 2)).sub h
Theorem: le_iff_exists_add'
File: Mathlib/Algebra/Order/Monoid/Canonical/Defs.lean

Proof steps:
state_before: α : Type u
inst✝ : CanonicallyOrderedCommMonoid α
a b c d : α
⊢ a ≤ b ↔ ∃ c, b = c * a
state_after: no goals
tactic: simp only [mul_comm _ a, le_iff_exists_mul]
Theorem: measurable_pi_iff
File: Mathlib/MeasureTheory/MeasurableSpace/Basic.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
δ' : Type u_5
ι : Sort uι
s t u : Set α
π : δ → Type u_6
inst✝² : MeasurableSpace α
inst✝¹ : (a : δ) → MeasurableSpace (π a)
inst✝ : MeasurableSpace γ
g : α → (a : δ) → π a
⊢ Measurable g ↔ ∀ (a : δ), Measurable fun x => g x a
state_after: no goals
tactic: simp_rw [measurable_iff_comap_le, MeasurableSpace.pi, MeasurableSpace.comap_iSup,
    MeasurableSpace.comap_comp, Function.comp, iSup_le_iff]
Theorem: List.length_join'
File: Mathlib/Data/List/Join.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
L : List (List α)
⊢ L.join.length = Nat.sum (map length L)
state_after: no goals
tactic: induction L <;> [rfl; simp only [*, join, map, Nat.sum_cons, length_append]]
Theorem: CategoryTheory.Presieve.extend_agrees
File: Mathlib/CategoryTheory/Sites/IsSheafFor.lean

Proof steps:
state_before: C : Type u₁
inst✝ : Category.{v₁, u₁} C
P Q U : Cᵒᵖ ⥤ Type w
X Y : C
S : Sieve X
R : Presieve X
x : FamilyOfElements P R
t : x.Compatible
f : Y ⟶ X
hf : R f
⊢ x.sieveExtend f ⋯ = x f hf
state_after: C : Type u₁
inst✝ : Category.{v₁, u₁} C
P Q U : Cᵒᵖ ⥤ Type w
X Y : C
S : Sieve X
R : Presieve X
x : FamilyOfElements P R
t : x.Compatible
f : Y ⟶ X
hf : R f
h : ∃ h g, R g ∧ h ≫ g = f
⊢ x.sieveExtend f ⋯ = x f hf
tactic: have h := (le_generate R Y hf).choose_spec
state_before: C : Type u₁
inst✝ : Category.{v₁, u₁} C
P Q U : Cᵒᵖ ⥤ Type w
X Y : C
S : Sieve X
R : Presieve X
x : FamilyOfElements P R
t : x.Compatible
f : Y ⟶ X
hf : R f
h : ∃ h g, R g ∧ h ≫ g = f
⊢ x.sieveExtend f ⋯ = x f hf
state_after: C : Type u₁
inst✝ : Category.{v₁, u₁} C
P Q U : Cᵒᵖ ⥤ Type w
X Y : C
S : Sieve X
R : Presieve X
x : FamilyOfElements P R
t : x.Compatible
f : Y ⟶ X
hf : R f
h : ∃ h g, R g ∧ h ≫ g = f
⊢ P.map ⋯.choose.op (x ⋯.choose ⋯) = x f hf
tactic: unfold FamilyOfElements.sieveExtend
state_before: C : Type u₁
inst✝ : Category.{v₁, u₁} C
P Q U : Cᵒᵖ ⥤ Type w
X Y : C
S : Sieve X
R : Presieve X
x : FamilyOfElements P R
t : x.Compatible
f : Y ⟶ X
hf : R f
h : ∃ h g, R g ∧ h ≫ g = f
⊢ P.map ⋯.choose.op (x ⋯.choose ⋯) = x f hf
state_after: C : Type u₁
inst✝ : Category.{v₁, u₁} C
P Q U : Cᵒᵖ ⥤ Type w
X Y : C
S : Sieve X
R : Presieve X
x : FamilyOfElements P R
t : x.Compatible
f : Y ⟶ X
hf : R f
h : ∃ h g, R g ∧ h ≫ g = f
⊢ P.map (𝟙 Y).op (x f hf) = x f hf

C : Type u₁
inst✝ : Category.{v₁, u₁} C
P Q U : Cᵒᵖ ⥤ Type w
X Y : C
S : Sieve X
R : Presieve X
x : FamilyOfElements P R
t : x.Compatible
f : Y ⟶ X
hf : R f
h : ∃ h g, R g ∧ h ≫ g = f
⊢ h.choose ≫ ⋯.choose = 𝟙 Y ≫ f
tactic: rw [t h.choose (𝟙 _) _ hf _]
Theorem: Sym2.ball
File: Mathlib/Data/Sym/Sym2.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
p : α → Prop
a b : α
⊢ (∀ c ∈ s(a, b), p c) ↔ p a ∧ p b
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
p : α → Prop
a b : α
h : p a ∧ p b
c : α
hc : c ∈ s(a, b)
⊢ p c
tactic: refine ⟨fun h => ⟨h _ <| mem_mk_left _ _, h _ <| mem_mk_right _ _⟩, fun h c hc => ?_⟩
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
p : α → Prop
a b : α
h : p a ∧ p b
c : α
hc : c ∈ s(a, b)
⊢ p c
state_after: case inl
α : Type u_1
β : Type u_2
γ : Type u_3
p : α → Prop
b c : α
h : p c ∧ p b
hc : c ∈ s(c, b)
⊢ p c

case inr
α : Type u_1
β : Type u_2
γ : Type u_3
p : α → Prop
a c : α
h : p a ∧ p c
hc : c ∈ s(a, c)
⊢ p c
tactic: obtain rfl | rfl := Sym2.mem_iff.1 hc
Theorem: Matrix.rank_unit
File: Mathlib/Data/Matrix/Rank.lean

Proof steps:
state_before: l : Type u_1
m : Type u_2
n : Type u_3
o : Type u_4
R : Type u_5
inst✝⁴ : Fintype n
inst✝³ : Fintype o
inst✝² : CommRing R
inst✝¹ : StrongRankCondition R
inst✝ : DecidableEq n
A : (Matrix n n R)ˣ
⊢ (↑A).rank = Fintype.card n
state_after: l : Type u_1
m : Type u_2
n : Type u_3
o : Type u_4
R : Type u_5
inst✝⁴ : Fintype n
inst✝³ : Fintype o
inst✝² : CommRing R
inst✝¹ : StrongRankCondition R
inst✝ : DecidableEq n
A : (Matrix n n R)ˣ
⊢ Fintype.card n ≤ (↑A).rank
tactic: apply le_antisymm (rank_le_card_width (A : Matrix n n R)) _
state_before: l : Type u_1
m : Type u_2
n : Type u_3
o : Type u_4
R : Type u_5
inst✝⁴ : Fintype n
inst✝³ : Fintype o
inst✝² : CommRing R
inst✝¹ : StrongRankCondition R
inst✝ : DecidableEq n
A : (Matrix n n R)ˣ
⊢ Fintype.card n ≤ (↑A).rank
state_after: l : Type u_1
m : Type u_2
n : Type u_3
o : Type u_4
R : Type u_5
inst✝⁴ : Fintype n
inst✝³ : Fintype o
inst✝² : CommRing R
inst✝¹ : StrongRankCondition R
inst✝ : DecidableEq n
A : (Matrix n n R)ˣ
this : (↑A * ↑A⁻¹).rank ≤ (↑A).rank
⊢ Fintype.card n ≤ (↑A).rank
tactic: have := rank_mul_le_left (A : Matrix n n R) (↑A⁻¹ : Matrix n n R)
state_before: l : Type u_1
m : Type u_2
n : Type u_3
o : Type u_4
R : Type u_5
inst✝⁴ : Fintype n
inst✝³ : Fintype o
inst✝² : CommRing R
inst✝¹ : StrongRankCondition R
inst✝ : DecidableEq n
A : (Matrix n n R)ˣ
this : (↑A * ↑A⁻¹).rank ≤ (↑A).rank
⊢ Fintype.card n ≤ (↑A).rank
state_after: no goals
tactic: rwa [← Units.val_mul, mul_inv_self, Units.val_one, rank_one] at this
Theorem: Nat.mul_self_lt_mul_self_iff
File: Mathlib/Data/Nat/Defs.lean

Proof steps:
state_before: a b c d m n k : ℕ
p q : ℕ → Prop
⊢ m * m < n * n ↔ m < n
state_after: no goals
tactic: simp only [← Nat.not_le, mul_self_le_mul_self_iff]