ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: CategoryTheory.ShortComplex.Exact.mono_g'
File: Mathlib/Algebra/Homology/ShortComplex/Exact.lean

Proof steps:
state_before: C : Type u_1
D : Type u_2
inst✝³ : Category.{u_3, u_1} C
inst✝² : Category.{?u.36381, u_2} D
inst✝¹ : Preadditive C
inst✝ : Preadditive D
S : ShortComplex C
hS : S.Exact
h : S.RightHomologyData
⊢ IsZero (KernelFork.ofι h.ι ⋯).pt
state_after: C : Type u_1
D : Type u_2
inst✝³ : Category.{u_3, u_1} C
inst✝² : Category.{?u.36381, u_2} D
inst✝¹ : Preadditive C
inst✝ : Preadditive D
S : ShortComplex C
hS : S.Exact
h : S.RightHomologyData
this : S.HasHomology
⊢ IsZero (KernelFork.ofι h.ι ⋯).pt
tactic: haveI := hS.hasHomology
state_before: C : Type u_1
D : Type u_2
inst✝³ : Category.{u_3, u_1} C
inst✝² : Category.{?u.36381, u_2} D
inst✝¹ : Preadditive C
inst✝ : Preadditive D
S : ShortComplex C
hS : S.Exact
h : S.RightHomologyData
this : S.HasHomology
⊢ IsZero (KernelFork.ofι h.ι ⋯).pt
state_after: C : Type u_1
D : Type u_2
inst✝³ : Category.{u_3, u_1} C
inst✝² : Category.{?u.36381, u_2} D
inst✝¹ : Preadditive C
inst✝ : Preadditive D
S : ShortComplex C
hS : S.Exact
h : S.RightHomologyData
this : S.HasHomology
⊢ IsZero h.H
tactic: dsimp
state_before: C : Type u_1
D : Type u_2
inst✝³ : Category.{u_3, u_1} C
inst✝² : Category.{?u.36381, u_2} D
inst✝¹ : Preadditive C
inst✝ : Preadditive D
S : ShortComplex C
hS : S.Exact
h : S.RightHomologyData
this : S.HasHomology
⊢ IsZero h.H
state_after: no goals
tactic: simpa only [← h.exact_iff] using hS
Theorem: ZMod.χ₈_apply
File: Mathlib/NumberTheory/LegendreSymbol/ZModChar.lean

Proof steps:
state_before: ⊢ ∀ (x y : ZMod 8),
    {
            toFun := fun a =>
              match a with
              | 0 => 0
              | 2 => 0
              | 4 => 0
              | 6 => 0
              | 1 => 1
              | 7 => 1
              | 3 => -1
              | 5 => -1,
            map_one' := ⋯ }.toFun
        (x * y) =
      {
              toFun := fun a =>
                match a with
                | 0 => 0
                | 2 => 0
                | 4 => 0
                | 6 => 0
                | 1 => 1
                | 7 => 1
                | 3 => -1
                | 5 => -1,
              map_one' := ⋯ }.toFun
          x *
        {
              toFun := fun a =>
                match a with
                | 0 => 0
                | 2 => 0
                | 4 => 0
                | 6 => 0
                | 1 => 1
                | 7 => 1
                | 3 => -1
                | 5 => -1,
              map_one' := ⋯ }.toFun
          y
state_after: no goals
tactic: decide
state_before: ⊢ ∀ (a : ZMod 8),
    ¬IsUnit a →
      (↑{
                toFun := fun a =>
                  match a with
                  | 0 => 0
                  | 2 => 0
                  | 4 => 0
                  | 6 => 0
                  | 1 => 1
                  | 7 => 1
                  | 3 => -1
                  | 5 => -1,
                map_one' := ⋯, map_mul' := ⋯ }).toFun
          a =
        0
state_after: no goals
tactic: decide
Theorem: Basis.flag_mono
File: Mathlib/LinearAlgebra/Basis/Flag.lean

Proof steps:
state_before: R : Type u_1
M : Type u_2
inst✝² : Semiring R
inst✝¹ : AddCommMonoid M
inst✝ : Module R M
n : ℕ
b : Basis (Fin n) R M
k : Fin n
⊢ b.flag k.castSucc ≤ b.flag k.succ
state_after: R : Type u_1
M : Type u_2
inst✝² : Semiring R
inst✝¹ : AddCommMonoid M
inst✝ : Module R M
n : ℕ
b : Basis (Fin n) R M
k : Fin n
⊢ b.flag k.castSucc ≤ span R {b k} ⊔ b.flag k.castSucc
tactic: rw [flag_succ]
state_before: R : Type u_1
M : Type u_2
inst✝² : Semiring R
inst✝¹ : AddCommMonoid M
inst✝ : Module R M
n : ℕ
b : Basis (Fin n) R M
k : Fin n
⊢ b.flag k.castSucc ≤ span R {b k} ⊔ b.flag k.castSucc
state_after: no goals
tactic: exact le_sup_right
Theorem: div_mul_div_cancel''
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✝ : CommGroup G
a✝ b✝ c✝ d a b c : G
⊢ a / b * (c / a) = c / b
state_after: α : Type u_1
β : Type u_2
G : Type u_3
M : Type u_4
inst✝ : CommGroup G
a✝ b✝ c✝ d a b c : G
⊢ c / a * (a / b) = c / b
tactic: rw [mul_comm]
state_before: α : Type u_1
β : Type u_2
G : Type u_3
M : Type u_4
inst✝ : CommGroup G
a✝ b✝ c✝ d a b c : G
⊢ c / a * (a / b) = c / b
state_after: no goals
tactic: apply div_mul_div_cancel'
Theorem: Polynomial.IsRoot.of_map
File: Mathlib/Algebra/Polynomial/Eval.lean

Proof steps:
state_before: R✝ : Type u
S : Type v
T : Type w
ι : Type y
a b : R✝
m n : ℕ
inst✝² : CommSemiring R✝
inst✝¹ : CommSemiring S
f✝ : R✝ →+* S
R : Type u_1
inst✝ : CommRing R
f : R →+* S
x : R
p : R[X]
h : (Polynomial.map f p).IsRoot (f x)
hf : Function.Injective ⇑f
⊢ p.IsRoot x
state_after: no goals
tactic: rwa [IsRoot, ← (injective_iff_map_eq_zero' f).mp hf, ← eval₂_hom, ← eval_map]
Theorem: Equiv.Perm.exists_fixed_point_of_prime'
File: Mathlib/GroupTheory/Perm/Cycle/Type.lean

Proof steps:
state_before: α : Type u_1
inst✝ : Fintype α
p n : ℕ
hp : Fact (Nat.Prime p)
hα : p ∣ Fintype.card α
σ : Perm α
hσ : σ ^ p ^ n = 1
a : α
ha : σ a = a
⊢ ∃ b, σ b = b ∧ b ≠ a
state_after: no goals
tactic: classical
    have h : ∀ b : α, b ∈ σ.supportᶜ ↔ σ b = b := fun b => by
      rw [Finset.mem_compl, mem_support, Classical.not_not]
    obtain ⟨b, hb1, hb2⟩ := Finset.exists_ne_of_one_lt_card (hp.out.one_lt.trans_le
      (Nat.le_of_dvd (Finset.card_pos.mpr ⟨a, (h a).mpr ha⟩) (Nat.modEq_zero_iff_dvd.mp
        ((card_compl_support_modEq hσ).trans (Nat.modEq_zero_iff_dvd.mpr hα))))) a
    exact ⟨b, (h b).mp hb1, hb2⟩
Theorem: AddSubgroup.op_closure
File: Mathlib/Algebra/Group/Subgroup/MulOpposite.lean

Proof steps:
state_before: ι : Sort u_1
G : Type u_2
inst✝ : Group G
s : Set G
⊢ (closure s).op = closure (MulOpposite.unop ⁻¹' s)
state_after: ι : Sort u_1
G : Type u_2
inst✝ : Group G
s : Set G
⊢ sInf {a | s ⊆ MulOpposite.op ⁻¹' ↑a} = sInf {K | MulOpposite.unop ⁻¹' s ⊆ ↑K}
tactic: simp_rw [closure, op_sInf, Set.preimage_setOf_eq, Subgroup.unop_coe]
state_before: ι : Sort u_1
G : Type u_2
inst✝ : Group G
s : Set G
⊢ sInf {a | s ⊆ MulOpposite.op ⁻¹' ↑a} = sInf {K | MulOpposite.unop ⁻¹' s ⊆ ↑K}
state_after: case e_a.h
ι : Sort u_1
G : Type u_2
inst✝ : Group G
s : Set G
a : Subgroup Gᵐᵒᵖ
⊢ a ∈ {a | s ⊆ MulOpposite.op ⁻¹' ↑a} ↔ a ∈ {K | MulOpposite.unop ⁻¹' s ⊆ ↑K}
tactic: congr with a
state_before: case e_a.h
ι : Sort u_1
G : Type u_2
inst✝ : Group G
s : Set G
a : Subgroup Gᵐᵒᵖ
⊢ a ∈ {a | s ⊆ MulOpposite.op ⁻¹' ↑a} ↔ a ∈ {K | MulOpposite.unop ⁻¹' s ⊆ ↑K}
state_after: no goals
tactic: exact MulOpposite.unop_surjective.forall
Theorem: sdiff_sdiff_eq_self
File: Mathlib/Order/BooleanAlgebra.lean

Proof steps:
state_before: α : Type u
β : Type u_1
w x y z : α
inst✝ : GeneralizedBooleanAlgebra α
h : y ≤ x
⊢ x \ (x \ y) = y
state_after: no goals
tactic: rw [sdiff_sdiff_right_self, inf_of_le_right h]
Theorem: Monoid.PushoutI.NormalWord.of_smul_eq_smul
File: Mathlib/GroupTheory/PushoutI.lean

Proof steps:
state_before: ι : Type u_1
G : ι → Type u_2
H : Type u_3
K : Type u_4
inst✝⁴ : Monoid K
inst✝³ : (i : ι) → Group (G i)
inst✝² : Group H
φ : (i : ι) → H →* G i
d : Transversal φ
inst✝¹ : DecidableEq ι
inst✝ : (i : ι) → DecidableEq (G i)
i : ι
g : G i
w : NormalWord d
⊢ (of i) g • w = g • w
state_after: no goals
tactic: rw [summand_smul_def, summand_smul_def']
Theorem: kstar_le_of_mul_le_left
File: Mathlib/Algebra/Order/Kleene.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
ι : Type u_3
π : ι → Type u_4
inst✝ : KleeneAlgebra α
a b c : α
hb : 1 ≤ b
⊢ b * a ≤ b → a∗ ≤ b
state_after: no goals
tactic: simpa using mul_kstar_le hb
Theorem: Subgroup.index_iInf_ne_zero
File: Mathlib/GroupTheory/Index.lean

Proof steps:
state_before: G : Type u_1
G' : Type u_2
inst✝² : Group G
inst✝¹ : Group G'
H K L : Subgroup G
ι : Type u_3
inst✝ : Finite ι
f : ι → Subgroup G
hf : ∀ (i : ι), (f i).index ≠ 0
⊢ (⨅ i, f i).index ≠ 0
state_after: G : Type u_1
G' : Type u_2
inst✝² : Group G
inst✝¹ : Group G'
H K L : Subgroup G
ι : Type u_3
inst✝ : Finite ι
f : ι → Subgroup G
hf : ∀ (i : ι), (f i).relindex ⊤ ≠ 0
⊢ (⨅ i, f i).relindex ⊤ ≠ 0
tactic: simp_rw [← relindex_top_right] at hf ⊢
state_before: G : Type u_1
G' : Type u_2
inst✝² : Group G
inst✝¹ : Group G'
H K L : Subgroup G
ι : Type u_3
inst✝ : Finite ι
f : ι → Subgroup G
hf : ∀ (i : ι), (f i).relindex ⊤ ≠ 0
⊢ (⨅ i, f i).relindex ⊤ ≠ 0
state_after: no goals
tactic: exact relindex_iInf_ne_zero hf
Theorem: CategoryTheory.Iso.cancel_iso_hom_right_assoc
File: Mathlib/CategoryTheory/Iso.lean

Proof steps:
state_before: C : Type u
inst✝ : Category.{v, u} C
X✝ Y✝ Z✝ W X X' Y Z : C
f : W ⟶ X
g : X ⟶ Y
f' : W ⟶ X'
g' : X' ⟶ Y
h : Y ≅ Z
⊢ f ≫ g ≫ h.hom = f' ≫ g' ≫ h.hom ↔ f ≫ g = f' ≫ g'
state_after: no goals
tactic: simp only [← Category.assoc, cancel_mono]
Theorem: StrictMonoOn.union
File: Mathlib/Order/Monotone/Union.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
inst✝¹ : LinearOrder α
inst✝ : Preorder β
a : α
f : α → β
s t : Set α
c : α
h₁ : StrictMonoOn f s
h₂ : StrictMonoOn f t
hs : IsGreatest s c
ht : IsLeast t c
A : ∀ x ∈ s ∪ t, x ≤ c → x ∈ s
B : ∀ x ∈ s ∪ t, c ≤ x → x ∈ t
⊢ StrictMonoOn f (s ∪ t)
state_after: α : Type u_1
β : Type u_2
inst✝¹ : LinearOrder α
inst✝ : Preorder β
a : α
f : α → β
s t : Set α
c : α
h₁ : StrictMonoOn f s
h₂ : StrictMonoOn f t
hs : IsGreatest s c
ht : IsLeast t c
A : ∀ x ∈ s ∪ t, x ≤ c → x ∈ s
B : ∀ x ∈ s ∪ t, c ≤ x → x ∈ t
x : α
hx : x ∈ s ∪ t
y : α
hy : y ∈ s ∪ t
hxy : x < y
⊢ f x < f y
tactic: intro x hx y hy hxy
state_before: α : Type u_1
β : Type u_2
inst✝¹ : LinearOrder α
inst✝ : Preorder β
a : α
f : α → β
s t : Set α
c : α
h₁ : StrictMonoOn f s
h₂ : StrictMonoOn f t
hs : IsGreatest s c
ht : IsLeast t c
A : ∀ x ∈ s ∪ t, x ≤ c → x ∈ s
B : ∀ x ∈ s ∪ t, c ≤ x → x ∈ t
x : α
hx : x ∈ s ∪ t
y : α
hy : y ∈ s ∪ t
hxy : x < y
⊢ f x < f y
state_after: case inl
α : Type u_1
β : Type u_2
inst✝¹ : LinearOrder α
inst✝ : Preorder β
a : α
f : α → β
s t : Set α
c : α
h₁ : StrictMonoOn f s
h₂ : StrictMonoOn f t
hs : IsGreatest s c
ht : IsLeast t c
A : ∀ x ∈ s ∪ t, x ≤ c → x ∈ s
B : ∀ x ∈ s ∪ t, c ≤ x → x ∈ t
x : α
hx : x ∈ s ∪ t
y : α
hy : y ∈ s ∪ t
hxy : x < y
hxc : x < c
⊢ f x < f y

case inr
α : Type u_1
β : Type u_2
inst✝¹ : LinearOrder α
inst✝ : Preorder β
a : α
f : α → β
s t : Set α
c : α
h₁ : StrictMonoOn f s
h₂ : StrictMonoOn f t
hs : IsGreatest s c
ht : IsLeast t c
A : ∀ x ∈ s ∪ t, x ≤ c → x ∈ s
B : ∀ x ∈ s ∪ t, c ≤ x → x ∈ t
x : α
hx : x ∈ s ∪ t
y : α
hy : y ∈ s ∪ t
hxy : x < y
hcx : c ≤ x
⊢ f x < f y
tactic: rcases lt_or_le x c with (hxc | hcx)
Theorem: Set.Finite.toFinset_offDiag
File: Mathlib/Data/Set/Finite.lean

Proof steps:
state_before: α : Type u
β : Type v
ι : Sort w
γ : Type x
s : Set α
inst✝ : DecidableEq α
hs : s.Finite
⊢ ∀ (a : α × α), a ∈ ⋯.toFinset ↔ a ∈ hs.toFinset.offDiag
state_after: no goals
tactic: simp
Theorem: ENNReal.lt_ofReal_iff_toReal_lt
File: Mathlib/Data/ENNReal/Real.lean

Proof steps:
state_before: a✝ b✝ c d : ℝ≥0∞
r p q : ℝ≥0
a : ℝ≥0∞
b : ℝ
ha : a ≠ ⊤
⊢ a < ENNReal.ofReal b ↔ a.toReal < b
state_after: case intro
a✝ b✝ c d : ℝ≥0∞
r p q : ℝ≥0
b : ℝ
a : ℝ≥0
⊢ ↑a < ENNReal.ofReal b ↔ (↑a).toReal < b
tactic: lift a to ℝ≥0 using ha
state_before: case intro
a✝ b✝ c d : ℝ≥0∞
r p q : ℝ≥0
b : ℝ
a : ℝ≥0
⊢ ↑a < ENNReal.ofReal b ↔ (↑a).toReal < b
state_after: no goals
tactic: simpa [ENNReal.ofReal, ENNReal.toReal] using Real.lt_toNNReal_iff_coe_lt
Theorem: Doset.doset_union_leftCoset
File: Mathlib/GroupTheory/DoubleCoset.lean

Proof steps:
state_before: G : Type u_1
inst✝¹ : Group G
α : Type u_2
inst✝ : Mul α
J : Subgroup G
g : G
H K : Subgroup G
a : G
⊢ ⋃ h, (↑h * a) • ↑K = doset a ↑H ↑K
state_after: case h
G : Type u_1
inst✝¹ : Group G
α : Type u_2
inst✝ : Mul α
J : Subgroup G
g : G
H K : Subgroup G
a x : G
⊢ x ∈ ⋃ h, (↑h * a) • ↑K ↔ x ∈ doset a ↑H ↑K
tactic: ext x
state_before: case h
G : Type u_1
inst✝¹ : Group G
α : Type u_2
inst✝ : Mul α
J : Subgroup G
g : G
H K : Subgroup G
a x : G
⊢ x ∈ ⋃ h, (↑h * a) • ↑K ↔ x ∈ doset a ↑H ↑K
state_after: case h
G : Type u_1
inst✝¹ : Group G
α : Type u_2
inst✝ : Mul α
J : Subgroup G
g : G
H K : Subgroup G
a x : G
⊢ (∃ i, a⁻¹ * (↑i)⁻¹ * x ∈ ↑K) ↔ ∃ x_1 ∈ ↑H, ∃ y ∈ ↑K, x = x_1 * a * y
tactic: simp only [mem_leftCoset_iff, mul_inv_rev, Set.mem_iUnion, mem_doset]
state_before: case h
G : Type u_1
inst✝¹ : Group G
α : Type u_2
inst✝ : Mul α
J : Subgroup G
g : G
H K : Subgroup G
a x : G
⊢ (∃ i, a⁻¹ * (↑i)⁻¹ * x ∈ ↑K) ↔ ∃ x_1 ∈ ↑H, ∃ y ∈ ↑K, x = x_1 * a * y
state_after: case h.mp
G : Type u_1
inst✝¹ : Group G
α : Type u_2
inst✝ : Mul α
J : Subgroup G
g : G
H K : Subgroup G
a x : G
⊢ (∃ i, a⁻¹ * (↑i)⁻¹ * x ∈ ↑K) → ∃ x_1 ∈ ↑H, ∃ y ∈ ↑K, x = x_1 * a * y

case h.mpr
G : Type u_1
inst✝¹ : Group G
α : Type u_2
inst✝ : Mul α
J : Subgroup G
g : G
H K : Subgroup G
a x : G
⊢ (∃ x_1 ∈ ↑H, ∃ y ∈ ↑K, x = x_1 * a * y) → ∃ i, a⁻¹ * (↑i)⁻¹ * x ∈ ↑K
tactic: constructor
Theorem: LinearMap.dualMap_bijective_iff
File: Mathlib/LinearAlgebra/Dual.lean

Proof steps:
state_before: K : Type uK
inst✝⁴ : Field K
V₁ : Type uV₁
V₂ : Type uV₂
inst✝³ : AddCommGroup V₁
inst✝² : Module K V₁
inst✝¹ : AddCommGroup V₂
inst✝ : Module K V₂
f : V₁ →ₗ[K] V₂
⊢ Function.Bijective ⇑f.dualMap ↔ Function.Bijective ⇑f
state_after: no goals
tactic: simp_rw [Function.Bijective, dualMap_surjective_iff, dualMap_injective_iff, and_comm]
Theorem: Real.norm_rpow_of_nonneg
File: Mathlib/Analysis/SpecialFunctions/Pow/Real.lean

Proof steps:
state_before: x✝ y✝ z x y : ℝ
hx_nonneg : 0 ≤ x
⊢ ‖x ^ y‖ = ‖x‖ ^ y
state_after: x✝ y✝ z x y : ℝ
hx_nonneg : 0 ≤ x
⊢ |x ^ y| = |x| ^ y
tactic: simp_rw [Real.norm_eq_abs]
state_before: x✝ y✝ z x y : ℝ
hx_nonneg : 0 ≤ x
⊢ |x ^ y| = |x| ^ y
state_after: no goals
tactic: exact abs_rpow_of_nonneg hx_nonneg
Theorem: eventually_le_limsup
File: Mathlib/Topology/Algebra/Order/LiminfLimsup.lean

Proof steps:
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
R : Type u_4
S : Type u_5
π : ι → Type u_6
inst✝⁴ : ConditionallyCompleteLinearOrder α
inst✝³ : TopologicalSpace α
inst✝² : OrderTopology α
inst✝¹ : FirstCountableTopology α
f : Filter β
inst✝ : CountableInterFilter f
u : β → α
hf : autoParam (IsBoundedUnder (fun x x_1 => x ≤ x_1) f u) _auto✝
⊢ ∀ᶠ (b : β) in f, u b ≤ limsup u f
state_after: case inl
ι : Type u_1
α : Type u_2
β : Type u_3
R : Type u_4
S : Type u_5
π : ι → Type u_6
inst✝⁴ : ConditionallyCompleteLinearOrder α
inst✝³ : TopologicalSpace α
inst✝² : OrderTopology α
inst✝¹ : FirstCountableTopology α
f : Filter β
inst✝ : CountableInterFilter f
u : β → α
hf : autoParam (IsBoundedUnder (fun x x_1 => x ≤ x_1) f u) _auto✝
ha : IsTop (limsup u f)
⊢ ∀ᶠ (b : β) in f, u b ≤ limsup u f

case inr
ι : Type u_1
α : Type u_2
β : Type u_3
R : Type u_4
S : Type u_5
π : ι → Type u_6
inst✝⁴ : ConditionallyCompleteLinearOrder α
inst✝³ : TopologicalSpace α
inst✝² : OrderTopology α
inst✝¹ : FirstCountableTopology α
f : Filter β
inst✝ : CountableInterFilter f
u : β → α
hf : autoParam (IsBoundedUnder (fun x x_1 => x ≤ x_1) f u) _auto✝
ha : ∃ b, limsup u f < b
⊢ ∀ᶠ (b : β) in f, u b ≤ limsup u f
tactic: obtain ha | ha := isTop_or_exists_gt (f.limsup u)
state_before: case inr
ι : Type u_1
α : Type u_2
β : Type u_3
R : Type u_4
S : Type u_5
π : ι → Type u_6
inst✝⁴ : ConditionallyCompleteLinearOrder α
inst✝³ : TopologicalSpace α
inst✝² : OrderTopology α
inst✝¹ : FirstCountableTopology α
f : Filter β
inst✝ : CountableInterFilter f
u : β → α
hf : autoParam (IsBoundedUnder (fun x x_1 => x ≤ x_1) f u) _auto✝
ha : ∃ b, limsup u f < b
⊢ ∀ᶠ (b : β) in f, u b ≤ limsup u f
state_after: case pos
ι : Type u_1
α : Type u_2
β : Type u_3
R : Type u_4
S : Type u_5
π : ι → Type u_6
inst✝⁴ : ConditionallyCompleteLinearOrder α
inst✝³ : TopologicalSpace α
inst✝² : OrderTopology α
inst✝¹ : FirstCountableTopology α
f : Filter β
inst✝ : CountableInterFilter f
u : β → α
hf : autoParam (IsBoundedUnder (fun x x_1 => x ≤ x_1) f u) _auto✝
ha : ∃ b, limsup u f < b
H : IsGLB (Set.Ioi (limsup u f)) (limsup u f)
⊢ ∀ᶠ (b : β) in f, u b ≤ limsup u f

case neg
ι : Type u_1
α : Type u_2
β : Type u_3
R : Type u_4
S : Type u_5
π : ι → Type u_6
inst✝⁴ : ConditionallyCompleteLinearOrder α
inst✝³ : TopologicalSpace α
inst✝² : OrderTopology α
inst✝¹ : FirstCountableTopology α
f : Filter β
inst✝ : CountableInterFilter f
u : β → α
hf : autoParam (IsBoundedUnder (fun x x_1 => x ≤ x_1) f u) _auto✝
ha : ∃ b, limsup u f < b
H : ¬IsGLB (Set.Ioi (limsup u f)) (limsup u f)
⊢ ∀ᶠ (b : β) in f, u b ≤ limsup u f
tactic: by_cases H : IsGLB (Set.Ioi (f.limsup u)) (f.limsup u)
Theorem: CategoryTheory.MonoidalCategory.fullBraidedSubcategory.map_map
File: Mathlib/CategoryTheory/Monoidal/Subcategory.lean

Proof steps:
state_before: C : Type u
inst✝⁴ : Category.{v, u} C
inst✝³ : MonoidalCategory C
P : C → Prop
inst✝² : MonoidalPredicate P
P' : C → Prop
inst✝¹ : MonoidalPredicate P'
inst✝ : BraidedCategory C
h : ∀ ⦃X : C⦄, P X → P' X
X Y : FullSubcategory P
⊢ (fullMonoidalSubcategory.map h).map (β_ X Y).hom =
    inv ((fullMonoidalSubcategory.map h).μ X Y) ≫
      (β_ ((fullMonoidalSubcategory.map h).obj X) ((fullMonoidalSubcategory.map h).obj Y)).hom ≫
        (fullMonoidalSubcategory.map h).μ Y X
state_after: C : Type u
inst✝⁴ : Category.{v, u} C
inst✝³ : MonoidalCategory C
P : C → Prop
inst✝² : MonoidalPredicate P
P' : C → Prop
inst✝¹ : MonoidalPredicate P'
inst✝ : BraidedCategory C
h : ∀ ⦃X : C⦄, P X → P' X
X Y : FullSubcategory P
⊢ (fullMonoidalSubcategory.map h).μ X Y ≫ (fullMonoidalSubcategory.map h).map (β_ X Y).hom =
    (β_ ((fullMonoidalSubcategory.map h).obj X) ((fullMonoidalSubcategory.map h).obj Y)).hom ≫
      (fullMonoidalSubcategory.map h).μ Y X
tactic: rw [IsIso.eq_inv_comp]
state_before: C : Type u
inst✝⁴ : Category.{v, u} C
inst✝³ : MonoidalCategory C
P : C → Prop
inst✝² : MonoidalPredicate P
P' : C → Prop
inst✝¹ : MonoidalPredicate P'
inst✝ : BraidedCategory C
h : ∀ ⦃X : C⦄, P X → P' X
X Y : FullSubcategory P
⊢ (fullMonoidalSubcategory.map h).μ X Y ≫ (fullMonoidalSubcategory.map h).map (β_ X Y).hom =
    (β_ ((fullMonoidalSubcategory.map h).obj X) ((fullMonoidalSubcategory.map h).obj Y)).hom ≫
      (fullMonoidalSubcategory.map h).μ Y X
state_after: no goals
tactic: aesop_cat
Theorem: Module.injective_of_ulift_injective
File: Mathlib/Algebra/Module/Injective.lean

Proof steps:
state_before: R : Type u
inst✝⁴ : Ring R
Q : Type v
inst✝³ : AddCommGroup Q
inst✝² : Module R Q
M : Type v
inst✝¹ : AddCommGroup M
inst✝ : Module R M
inj : Injective R (ULift.{v', v} M)
X Y : Type v
x✝³ : AddCommGroup X
x✝² : AddCommGroup Y
x✝¹ : Module R X
x✝ : Module R Y
f : X →ₗ[R] Y
hf : Function.Injective ⇑f
g : X →ₗ[R] M
eX : ULift.{v', v} X ≃ₗ[R] X := ULift.moduleEquiv
⊢ Function.Injective ⇑(↑ULift.moduleEquiv.symm ∘ₗ f ∘ₗ ↑eX)
state_after: no goals
tactic: exact ULift.moduleEquiv.symm.injective.comp <| hf.comp eX.injective
state_before: R : Type u
inst✝⁴ : Ring R
Q : Type v
inst✝³ : AddCommGroup Q
inst✝² : Module R Q
M : Type v
inst✝¹ : AddCommGroup M
inst✝ : Module R M
inj : Injective R (ULift.{v', v} M)
X Y : Type v
x✝³ : AddCommGroup X
x✝² : AddCommGroup Y
x✝¹ : Module R X
x✝ : Module R Y
f : X →ₗ[R] Y
hf : Function.Injective ⇑f
g : X →ₗ[R] M
eX : ULift.{v', v} X ≃ₗ[R] X := ULift.moduleEquiv
g' : ULift.{v', v} Y →ₗ[R] ULift.{v', v} M
hg' : ∀ (x : ULift.{v', v} X), g' ((↑ULift.moduleEquiv.symm ∘ₗ f ∘ₗ ↑eX) x) = (↑ULift.moduleEquiv.symm ∘ₗ g ∘ₗ ↑eX) x
x : X
⊢ (↑ULift.moduleEquiv ∘ₗ g' ∘ₗ ↑ULift.moduleEquiv.symm) (f x) = g x
state_after: no goals
tactic: exact congr(ULift.down $(hg' ⟨x⟩))
Theorem: Complex.angle_div_left_eq_angle_mul_right
File: Mathlib/Analysis/Complex/Angle.lean

Proof steps:
state_before: a✝ x✝ y✝ a x y : ℂ
⊢ angle (x / a) y = angle x (y * a)
state_after: case inl
a x✝ y✝ x y : ℂ
⊢ angle (x / 0) y = angle x (y * 0)

case inr
a✝ x✝ y✝ a x y : ℂ
ha : a ≠ 0
⊢ angle (x / a) y = angle x (y * a)
tactic: obtain rfl | ha := eq_or_ne a 0
Theorem: hasDerivAt_bernoulliFun
File: Mathlib/NumberTheory/ZetaValues.lean

Proof steps:
state_before: k : ℕ
x : ℝ
⊢ HasDerivAt (bernoulliFun k) (↑k * bernoulliFun (k - 1) x) x
state_after: case h.e'_7
k : ℕ
x : ℝ
⊢ ↑k * bernoulliFun (k - 1) x =
    Polynomial.eval x (Polynomial.derivative (Polynomial.map (algebraMap ℚ ℝ) (Polynomial.bernoulli k)))
tactic: convert ((Polynomial.bernoulli k).map <| algebraMap ℚ ℝ).hasDerivAt x using 1
state_before: case h.e'_7
k : ℕ
x : ℝ
⊢ ↑k * bernoulliFun (k - 1) x =
    Polynomial.eval x (Polynomial.derivative (Polynomial.map (algebraMap ℚ ℝ) (Polynomial.bernoulli k)))
state_after: no goals
tactic: simp only [bernoulliFun, Polynomial.derivative_map, Polynomial.derivative_bernoulli k,
    Polynomial.map_mul, Polynomial.map_natCast, Polynomial.eval_mul, Polynomial.eval_natCast]
Theorem: SimpleGraph.girth_eq_zero
File: Mathlib/Combinatorics/SimpleGraph/Girth.lean

Proof steps:
state_before: α : Type u_1
G : SimpleGraph α
h : G.girth = 0
⊢ ¬3 ≤ G.girth
state_after: no goals
tactic: omega
state_before: α : Type u_1
G : SimpleGraph α
h : G.IsAcyclic
⊢ G.girth = 0
state_after: no goals
tactic: simp [girth, h]
Theorem: eigenvalue_nonneg_of_nonneg
File: Mathlib/Analysis/InnerProductSpace/Spectrum.lean

Proof steps:
state_before: 𝕜 : Type u_1
inst✝² : RCLike 𝕜
E : Type u_2
inst✝¹ : NormedAddCommGroup E
inst✝ : InnerProductSpace 𝕜 E
μ : ℝ
T : E →ₗ[𝕜] E
hμ : HasEigenvalue T ↑μ
hnn : ∀ (x : E), 0 ≤ RCLike.re ⟪x, T x⟫_𝕜
⊢ 0 ≤ μ
state_after: case intro
𝕜 : Type u_1
inst✝² : RCLike 𝕜
E : Type u_2
inst✝¹ : NormedAddCommGroup E
inst✝ : InnerProductSpace 𝕜 E
μ : ℝ
T : E →ₗ[𝕜] E
hμ : HasEigenvalue T ↑μ
hnn : ∀ (x : E), 0 ≤ RCLike.re ⟪x, T x⟫_𝕜
v : E
hv : HasEigenvector T (↑μ) v
⊢ 0 ≤ μ
tactic: obtain ⟨v, hv⟩ := hμ.exists_hasEigenvector
state_before: case intro
𝕜 : Type u_1
inst✝² : RCLike 𝕜
E : Type u_2
inst✝¹ : NormedAddCommGroup E
inst✝ : InnerProductSpace 𝕜 E
μ : ℝ
T : E →ₗ[𝕜] E
hμ : HasEigenvalue T ↑μ
hnn : ∀ (x : E), 0 ≤ RCLike.re ⟪x, T x⟫_𝕜
v : E
hv : HasEigenvector T (↑μ) v
⊢ 0 ≤ μ
state_after: case intro
𝕜 : Type u_1
inst✝² : RCLike 𝕜
E : Type u_2
inst✝¹ : NormedAddCommGroup E
inst✝ : InnerProductSpace 𝕜 E
μ : ℝ
T : E →ₗ[𝕜] E
hμ : HasEigenvalue T ↑μ
hnn : ∀ (x : E), 0 ≤ RCLike.re ⟪x, T x⟫_𝕜
v : E
hv : HasEigenvector T (↑μ) v
hpos : 0 < ‖v‖ ^ 2
⊢ 0 ≤ μ
tactic: have hpos : (0 : ℝ) < ‖v‖ ^ 2 := by simpa only [sq_pos_iff, norm_ne_zero_iff] using hv.2
state_before: case intro
𝕜 : Type u_1
inst✝² : RCLike 𝕜
E : Type u_2
inst✝¹ : NormedAddCommGroup E
inst✝ : InnerProductSpace 𝕜 E
μ : ℝ
T : E →ₗ[𝕜] E
hμ : HasEigenvalue T ↑μ
hnn : ∀ (x : E), 0 ≤ RCLike.re ⟪x, T x⟫_𝕜
v : E
hv : HasEigenvector T (↑μ) v
hpos : 0 < ‖v‖ ^ 2
⊢ 0 ≤ μ
state_after: case intro
𝕜 : Type u_1
inst✝² : RCLike 𝕜
E : Type u_2
inst✝¹ : NormedAddCommGroup E
inst✝ : InnerProductSpace 𝕜 E
μ : ℝ
T : E →ₗ[𝕜] E
hμ : HasEigenvalue T ↑μ
hnn : ∀ (x : E), 0 ≤ RCLike.re ⟪x, T x⟫_𝕜
v : E
hv : HasEigenvector T (↑μ) v
hpos : 0 < ‖v‖ ^ 2
this : RCLike.re ⟪v, T v⟫_𝕜 = μ * ‖v‖ ^ 2
⊢ 0 ≤ μ
tactic: have : RCLike.re ⟪v, T v⟫ = μ * ‖v‖ ^ 2 := by
    have := congr_arg RCLike.re (inner_product_apply_eigenvector hv.1)
    -- Porting note: why can't `exact_mod_cast` do this? These lemmas are marked `norm_cast`
    rw [← RCLike.ofReal_pow, ← RCLike.ofReal_mul] at this
    exact mod_cast this
state_before: case intro
𝕜 : Type u_1
inst✝² : RCLike 𝕜
E : Type u_2
inst✝¹ : NormedAddCommGroup E
inst✝ : InnerProductSpace 𝕜 E
μ : ℝ
T : E →ₗ[𝕜] E
hμ : HasEigenvalue T ↑μ
hnn : ∀ (x : E), 0 ≤ RCLike.re ⟪x, T x⟫_𝕜
v : E
hv : HasEigenvector T (↑μ) v
hpos : 0 < ‖v‖ ^ 2
this : RCLike.re ⟪v, T v⟫_𝕜 = μ * ‖v‖ ^ 2
⊢ 0 ≤ μ
state_after: no goals
tactic: exact (mul_nonneg_iff_of_pos_right hpos).mp (this ▸ hnn v)
Theorem: CategoryTheory.hom_inl_inr_false
File: Mathlib/CategoryTheory/Sums/Basic.lean

Proof steps:
state_before: C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
D : Type u₁
inst✝ : Category.{v₁, u₁} D
X : C
Y : D
f : inl X ⟶ inr Y
⊢ False
state_after: no goals
tactic: cases f