ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: Filter.Tendsto.atTop_mul_const'
File: Mathlib/Order/Filter/Archimedean.lean

Proof steps:
state_before: α : Type u_1
R : Type u_2
l : Filter α
f : α → R
r : R
inst✝¹ : LinearOrderedSemiring R
inst✝ : Archimedean R
hr : 0 < r
hf : Tendsto f l atTop
⊢ Tendsto (fun x => f x * r) l atTop
state_after: α : Type u_1
R : Type u_2
l : Filter α
f : α → R
r : R
inst✝¹ : LinearOrderedSemiring R
inst✝ : Archimedean R
hr : 0 < r
hf : Tendsto f l atTop
b : R
⊢ ∀ᶠ (a : α) in l, b ≤ f a * r
tactic: refine tendsto_atTop.2 fun b => ?_
state_before: α : Type u_1
R : Type u_2
l : Filter α
f : α → R
r : R
inst✝¹ : LinearOrderedSemiring R
inst✝ : Archimedean R
hr : 0 < r
hf : Tendsto f l atTop
b : R
⊢ ∀ᶠ (a : α) in l, b ≤ f a * r
state_after: case intro
α : Type u_1
R : Type u_2
l : Filter α
f : α → R
r : R
inst✝¹ : LinearOrderedSemiring R
inst✝ : Archimedean R
hr : 0 < r
hf : Tendsto f l atTop
b : R
n : ℕ
hn : 1 ≤ n • r
⊢ ∀ᶠ (a : α) in l, b ≤ f a * r
tactic: obtain ⟨n : ℕ, hn : 1 ≤ n • r⟩ := Archimedean.arch 1 hr
state_before: case intro
α : Type u_1
R : Type u_2
l : Filter α
f : α → R
r : R
inst✝¹ : LinearOrderedSemiring R
inst✝ : Archimedean R
hr : 0 < r
hf : Tendsto f l atTop
b : R
n : ℕ
hn : 1 ≤ n • r
⊢ ∀ᶠ (a : α) in l, b ≤ f a * r
state_after: case intro
α : Type u_1
R : Type u_2
l : Filter α
f : α → R
r : R
inst✝¹ : LinearOrderedSemiring R
inst✝ : Archimedean R
hr : 0 < r
hf : Tendsto f l atTop
b : R
n : ℕ
hn : 1 ≤ n • r
hn' : 1 ≤ ↑n * r
⊢ ∀ᶠ (a : α) in l, b ≤ f a * r
tactic: have hn' : 1 ≤ (n : R) * r := by rwa [nsmul_eq_mul] at hn
state_before: case intro
α : Type u_1
R : Type u_2
l : Filter α
f : α → R
r : R
inst✝¹ : LinearOrderedSemiring R
inst✝ : Archimedean R
hr : 0 < r
hf : Tendsto f l atTop
b : R
n : ℕ
hn : 1 ≤ n • r
hn' : 1 ≤ ↑n * r
⊢ ∀ᶠ (a : α) in l, b ≤ f a * r
state_after: case h
α : Type u_1
R : Type u_2
l : Filter α
f : α → R
r : R
inst✝¹ : LinearOrderedSemiring R
inst✝ : Archimedean R
hr : 0 < r
hf : Tendsto f l atTop
b : R
n : ℕ
hn : 1 ≤ n • r
hn' : 1 ≤ ↑n * r
x : α
hx : max b 0 * ↑n ≤ f x
⊢ b ≤ f x * r
tactic: filter_upwards [tendsto_atTop.1 hf (max b 0 * n)] with x hx
state_before: case h
α : Type u_1
R : Type u_2
l : Filter α
f : α → R
r : R
inst✝¹ : LinearOrderedSemiring R
inst✝ : Archimedean R
hr : 0 < r
hf : Tendsto f l atTop
b : R
n : ℕ
hn : 1 ≤ n • r
hn' : 1 ≤ ↑n * r
x : α
hx : max b 0 * ↑n ≤ f x
⊢ b ≤ f x * r
state_after: no goals
tactic: calc
    b ≤ max b 0 * 1 := by
    { rw [mul_one]
      exact le_max_left _ _ }
    _ ≤ max b 0 * (n * r) := by gcongr
    _ = max b 0 * n * r := by rw [mul_assoc]
    _ ≤ f x * r := by gcongr
Theorem: DerivedCategory.mem_distTriang_iff
File: Mathlib/Algebra/Homology/DerivedCategory/Basic.lean

Proof steps:
state_before: C : Type u
inst✝² : Category.{v, u} C
inst✝¹ : Abelian C
inst✝ : HasDerivedCategory C
T : Triangle (DerivedCategory C)
⊢ T ∈ distinguishedTriangles ↔ ∃ X Y f, Nonempty (T ≅ Q.mapTriangle.obj (CochainComplex.mappingCone.triangle f))
state_after: case mp
C : Type u
inst✝² : Category.{v, u} C
inst✝¹ : Abelian C
inst✝ : HasDerivedCategory C
T : Triangle (DerivedCategory C)
⊢ T ∈ distinguishedTriangles → ∃ X Y f, Nonempty (T ≅ Q.mapTriangle.obj (CochainComplex.mappingCone.triangle f))

case mpr
C : Type u
inst✝² : Category.{v, u} C
inst✝¹ : Abelian C
inst✝ : HasDerivedCategory C
T : Triangle (DerivedCategory C)
⊢ (∃ X Y f, Nonempty (T ≅ Q.mapTriangle.obj (CochainComplex.mappingCone.triangle f))) → T ∈ distinguishedTriangles
tactic: constructor
Theorem: CategoryTheory.Limits.pullbackDiagonalMapIso_inv_snd_fst
File: Mathlib/CategoryTheory/Limits/Shapes/Diagonal.lean

Proof steps:
state_before: C : Type u_1
inst✝² : Category.{u_2, u_1} C
X Y Z : C
inst✝¹ : HasPullbacks C
U V₁ V₂ : C
f : X ⟶ Y
i : U ⟶ Y
i₁ : V₁ ⟶ pullback f i
i₂ : V₂ ⟶ pullback f i
inst✝ : HasPullback i₁ i₂
⊢ (pullbackDiagonalMapIso f i i₁ i₂).inv ≫
      snd (diagonal f) (map (i₁ ≫ snd f i) (i₂ ≫ snd f i) f f (i₁ ≫ fst f i) (i₂ ≫ fst f i) i ⋯ ⋯) ≫
        fst (i₁ ≫ snd f i) (i₂ ≫ snd f i) =
    fst i₁ i₂
state_after: C : Type u_1
inst✝² : Category.{u_2, u_1} C
X Y Z : C
inst✝¹ : HasPullbacks C
U V₁ V₂ : C
f : X ⟶ Y
i : U ⟶ Y
i₁ : V₁ ⟶ pullback f i
i₂ : V₂ ⟶ pullback f i
inst✝ : HasPullback i₁ i₂
⊢ {
          hom :=
            lift
              (snd (diagonal f) (map (i₁ ≫ snd f i) (i₂ ≫ snd f i) f f (i₁ ≫ fst f i) (i₂ ≫ fst f i) i ⋯ ⋯) ≫
                fst (i₁ ≫ snd f i) (i₂ ≫ snd f i))
              (snd (diagonal f) (map (i₁ ≫ snd f i) (i₂ ≫ snd f i) f f (i₁ ≫ fst f i) (i₂ ≫ fst f i) i ⋯ ⋯) ≫
                snd (i₁ ≫ snd f i) (i₂ ≫ snd f i))
              ⋯,
          inv :=
            lift (fst i₁ i₂ ≫ i₁ ≫ fst f i) (map i₁ i₂ (i₁ ≫ snd f i) (i₂ ≫ snd f i) (𝟙 V₁) (𝟙 V₂) (snd f i) ⋯ ⋯) ⋯,
          hom_inv_id := ⋯, inv_hom_id := ⋯ }.inv ≫
      snd (diagonal f) (map (i₁ ≫ snd f i) (i₂ ≫ snd f i) f f (i₁ ≫ fst f i) (i₂ ≫ fst f i) i ⋯ ⋯) ≫
        fst (i₁ ≫ snd f i) (i₂ ≫ snd f i) =
    fst i₁ i₂
tactic: delta pullbackDiagonalMapIso
state_before: C : Type u_1
inst✝² : Category.{u_2, u_1} C
X Y Z : C
inst✝¹ : HasPullbacks C
U V₁ V₂ : C
f : X ⟶ Y
i : U ⟶ Y
i₁ : V₁ ⟶ pullback f i
i₂ : V₂ ⟶ pullback f i
inst✝ : HasPullback i₁ i₂
⊢ {
          hom :=
            lift
              (snd (diagonal f) (map (i₁ ≫ snd f i) (i₂ ≫ snd f i) f f (i₁ ≫ fst f i) (i₂ ≫ fst f i) i ⋯ ⋯) ≫
                fst (i₁ ≫ snd f i) (i₂ ≫ snd f i))
              (snd (diagonal f) (map (i₁ ≫ snd f i) (i₂ ≫ snd f i) f f (i₁ ≫ fst f i) (i₂ ≫ fst f i) i ⋯ ⋯) ≫
                snd (i₁ ≫ snd f i) (i₂ ≫ snd f i))
              ⋯,
          inv :=
            lift (fst i₁ i₂ ≫ i₁ ≫ fst f i) (map i₁ i₂ (i₁ ≫ snd f i) (i₂ ≫ snd f i) (𝟙 V₁) (𝟙 V₂) (snd f i) ⋯ ⋯) ⋯,
          hom_inv_id := ⋯, inv_hom_id := ⋯ }.inv ≫
      snd (diagonal f) (map (i₁ ≫ snd f i) (i₂ ≫ snd f i) f f (i₁ ≫ fst f i) (i₂ ≫ fst f i) i ⋯ ⋯) ≫
        fst (i₁ ≫ snd f i) (i₂ ≫ snd f i) =
    fst i₁ i₂
state_after: no goals
tactic: simp
Theorem: MeasureTheory.SimpleFunc.FinMeasSupp.lintegral_lt_top
File: Mathlib/MeasureTheory/Function/SimpleFunc.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
m : MeasurableSpace α
inst✝¹ : Zero β
inst✝ : Zero γ
μ : Measure α
f✝ : α →ₛ β
f : α →ₛ ℝ≥0∞
hm : f.FinMeasSupp μ
hf : ∀ᵐ (a : α) ∂μ, ↑f a ≠ ⊤
⊢ f.lintegral μ < ⊤
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
m : MeasurableSpace α
inst✝¹ : Zero β
inst✝ : Zero γ
μ : Measure α
f✝ : α →ₛ β
f : α →ₛ ℝ≥0∞
hm : f.FinMeasSupp μ
hf : ∀ᵐ (a : α) ∂μ, ↑f a ≠ ⊤
a : ℝ≥0∞
ha : a ∈ f.range
⊢ a * μ (↑f ⁻¹' {a}) ≠ ⊤
tactic: refine sum_lt_top fun a ha => ?_
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
m : MeasurableSpace α
inst✝¹ : Zero β
inst✝ : Zero γ
μ : Measure α
f✝ : α →ₛ β
f : α →ₛ ℝ≥0∞
hm : f.FinMeasSupp μ
hf : ∀ᵐ (a : α) ∂μ, ↑f a ≠ ⊤
a : ℝ≥0∞
ha : a ∈ f.range
⊢ a * μ (↑f ⁻¹' {a}) ≠ ⊤
state_after: case inl
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
m : MeasurableSpace α
inst✝¹ : Zero β
inst✝ : Zero γ
μ : Measure α
f✝ : α →ₛ β
f : α →ₛ ℝ≥0∞
hm : f.FinMeasSupp μ
hf : ∀ᵐ (a : α) ∂μ, ↑f a ≠ ⊤
ha : ⊤ ∈ f.range
⊢ ⊤ * μ (↑f ⁻¹' {⊤}) ≠ ⊤

case inr
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
m : MeasurableSpace α
inst✝¹ : Zero β
inst✝ : Zero γ
μ : Measure α
f✝ : α →ₛ β
f : α →ₛ ℝ≥0∞
hm : f.FinMeasSupp μ
hf : ∀ᵐ (a : α) ∂μ, ↑f a ≠ ⊤
a : ℝ≥0∞
ha✝ : a ∈ f.range
ha : a ≠ ⊤
⊢ a * μ (↑f ⁻¹' {a}) ≠ ⊤
tactic: rcases eq_or_ne a ∞ with (rfl | ha)
Theorem: Complex.map_exp_comap_re_atBot
File: Mathlib/Analysis/SpecialFunctions/Complex/Log.lean

Proof steps:
state_before: ⊢ map cexp (comap re atBot) = 𝓝[≠] 0
state_after: no goals
tactic: rw [← comap_exp_nhds_zero, map_comap, range_exp, nhdsWithin]
Theorem: _private.Mathlib.NumberTheory.FermatPsp.0.Nat.a_id_helper
File: Mathlib/NumberTheory/FermatPsp.lean

Proof steps:
state_before: a b : ℕ
ha : 2 ≤ a
hb : 2 ≤ b
⊢ 2 ≤ (a ^ b - 1) / (a - 1)
state_after: a b : ℕ
ha : 2 ≤ a
hb : 2 ≤ b
⊢ 1 < (a ^ b - 1) / (a - 1)
tactic: change 1 < _
state_before: a b : ℕ
ha : 2 ≤ a
hb : 2 ≤ b
⊢ 1 < (a ^ b - 1) / (a - 1)
state_after: a b : ℕ
ha : 2 ≤ a
hb : 2 ≤ b
h₁ : a - 1 ∣ a ^ b - 1
⊢ 1 < (a ^ b - 1) / (a - 1)
tactic: have h₁ : a - 1 ∣ a ^ b - 1 := by simpa only [one_pow] using nat_sub_dvd_pow_sub_pow a 1 b
state_before: a b : ℕ
ha : 2 ≤ a
hb : 2 ≤ b
h₁ : a - 1 ∣ a ^ b - 1
⊢ 1 < (a ^ b - 1) / (a - 1)
state_after: a b : ℕ
ha : 2 ≤ a
hb : 2 ≤ b
h₁ : a - 1 ∣ a ^ b - 1
⊢ a < a ^ b
tactic: rw [Nat.lt_div_iff_mul_lt h₁, mul_one, tsub_lt_tsub_iff_right (Nat.le_of_succ_le ha)]
state_before: a b : ℕ
ha : 2 ≤ a
hb : 2 ≤ b
h₁ : a - 1 ∣ a ^ b - 1
⊢ a < a ^ b
state_after: no goals
tactic: exact lt_self_pow (Nat.lt_of_succ_le ha) hb
Theorem: CategoryTheory.OplaxFunctor.bicategory_whiskerLeft_app
File: Mathlib/CategoryTheory/Bicategory/FunctorBicategory.lean

Proof steps:
state_before: B : Type u₁
inst✝¹ : Bicategory B
C : Type u₂
inst✝ : Bicategory C
F G H I a b c : OplaxFunctor B C
f g : a ⟶ b
h i : b ⟶ c
η : f ⟶ g
θ : h ⟶ i
⊢ (fun {F G H} η x x_1 Γ => OplaxNatTrans.whiskerLeft η Γ) f h i θ ≫
      (fun {F G H} x x_1 Γ η => OplaxNatTrans.whiskerRight Γ η) f g η i =
    (fun {F G H} x x_1 Γ η => OplaxNatTrans.whiskerRight Γ η) f g η h ≫
      (fun {F G H} η x x_1 Γ => OplaxNatTrans.whiskerLeft η Γ) g h i θ
state_after: case w
B : Type u₁
inst✝¹ : Bicategory B
C : Type u₂
inst✝ : Bicategory C
F G H I a b c : OplaxFunctor B C
f g : a ⟶ b
h i : b ⟶ c
η : f ⟶ g
θ : h ⟶ i
b✝ : B
⊢ ((fun {F G H} η x x_1 Γ => OplaxNatTrans.whiskerLeft η Γ) f h i θ ≫
          (fun {F G H} x x_1 Γ η => OplaxNatTrans.whiskerRight Γ η) f g η i).app
      b✝ =
    ((fun {F G H} x x_1 Γ η => OplaxNatTrans.whiskerRight Γ η) f g η h ≫
          (fun {F G H} η x x_1 Γ => OplaxNatTrans.whiskerLeft η Γ) g h i θ).app
      b✝
tactic: ext
state_before: case w
B : Type u₁
inst✝¹ : Bicategory B
C : Type u₂
inst✝ : Bicategory C
F G H I a b c : OplaxFunctor B C
f g : a ⟶ b
h i : b ⟶ c
η : f ⟶ g
θ : h ⟶ i
b✝ : B
⊢ ((fun {F G H} η x x_1 Γ => OplaxNatTrans.whiskerLeft η Γ) f h i θ ≫
          (fun {F G H} x x_1 Γ η => OplaxNatTrans.whiskerRight Γ η) f g η i).app
      b✝ =
    ((fun {F G H} x x_1 Γ η => OplaxNatTrans.whiskerRight Γ η) f g η h ≫
          (fun {F G H} η x x_1 Γ => OplaxNatTrans.whiskerLeft η Γ) g h i θ).app
      b✝
state_after: no goals
tactic: exact whisker_exchange _ _
Theorem: Nat.fib_add_two_strictMono
File: Mathlib/Data/Nat/Fib/Basic.lean

Proof steps:
state_before: ⊢ StrictMono fun n => fib (n + 2)
state_after: n : ℕ
⊢ fib (n + 2) < fib (n + 1 + 2)
tactic: refine strictMono_nat_of_lt_succ fun n => ?_
state_before: n : ℕ
⊢ fib (n + 2) < fib (n + 1 + 2)
state_after: n : ℕ
⊢ fib (n + 2) < fib (n + 2 + 1)
tactic: rw [add_right_comm]
state_before: n : ℕ
⊢ fib (n + 2) < fib (n + 2 + 1)
state_after: no goals
tactic: exact fib_lt_fib_succ (self_le_add_left _ _)
Theorem: Polynomial.aroots_neg
File: Mathlib/Algebra/Polynomial/Roots.lean

Proof steps:
state_before: R : Type u
S : Type v
T : Type w
a b : R
n : ℕ
inst✝⁵ : CommRing R
inst✝⁴ : IsDomain R
p✝ q : R[X]
inst✝³ : CommRing T
inst✝² : CommRing S
inst✝¹ : IsDomain S
inst✝ : Algebra T S
p : T[X]
⊢ (-p).aroots S = p.aroots S
state_after: no goals
tactic: rw [aroots, Polynomial.map_neg, roots_neg]
Theorem: Sum.getRight_eq_getRight?
File: Mathlib/Data/Sum/Basic.lean

Proof steps:
state_before: α : Type u
α' : Type w
β : Type v
β' : Type x
γ : Type u_1
δ : Type u_2
x y : α ⊕ β
h₁ : x.isRight = true
h₂ : x.getRight?.isSome = true
⊢ x.getRight h₁ = x.getRight?.get h₂
state_after: no goals
tactic: simp [← getRight?_eq_some_iff]
Theorem: ONote.NFBelow.lt
File: Mathlib/SetTheory/Ordinal/Notation.lean

Proof steps:
state_before: e : ONote
n : ℕ+
a : ONote
b : Ordinal.{0}
h : (e.oadd n a).NFBelow b
⊢ e.repr < b
state_after: case oadd'
e : ONote
n : ℕ+
a : ONote
b eb : Ordinal.{0}
h₁ : e.NFBelow eb
h₂ : a.NFBelow e.repr
h₃ : e.repr < b
⊢ e.repr < b
tactic: cases' h with _ _ _ _ eb _ h₁ h₂ h₃
state_before: case oadd'
e : ONote
n : ℕ+
a : ONote
b eb : Ordinal.{0}
h₁ : e.NFBelow eb
h₂ : a.NFBelow e.repr
h₃ : e.repr < b
⊢ e.repr < b
state_after: no goals
tactic: exact h₃
Theorem: CompositionSeries.last_eraseLast_le
File: Mathlib/Order/JordanHolder.lean

Proof steps:
state_before: X : Type u
inst✝¹ : Lattice X
inst✝ : JordanHolderLattice X
s : CompositionSeries X
⊢ (eraseLast s).last ≤ last s
state_after: no goals
tactic: simp [eraseLast, last, s.strictMono.le_iff_le, Fin.le_iff_val_le_val, tsub_le_self]
Theorem: WittVector.constantCoeff_wittNeg
File: Mathlib/RingTheory/WittVector/Defs.lean

Proof steps:
state_before: p : ℕ
R : Type u_1
hp : Fact (Nat.Prime p)
inst✝ : CommRing R
n : ℕ
⊢ constantCoeff (wittNeg p n) = 0
state_after: p : ℕ
R : Type u_1
hp : Fact (Nat.Prime p)
inst✝ : CommRing R
n : ℕ
⊢ constantCoeff (-X 0) = 0
tactic: apply constantCoeff_wittStructureInt p _ _ n
state_before: p : ℕ
R : Type u_1
hp : Fact (Nat.Prime p)
inst✝ : CommRing R
n : ℕ
⊢ constantCoeff (-X 0) = 0
state_after: no goals
tactic: simp only [neg_zero, RingHom.map_neg, constantCoeff_X]
Theorem: IsGroupHom.one_ker_inv
File: Mathlib/Deprecated/Subgroup.lean

Proof steps:
state_before: G : Type u_1
H : Type u_2
A : Type u_3
a✝ a₁ a₂ b✝ c : G
inst✝¹ : Group G
inst✝ : Group H
f : G → H
hf : IsGroupHom f
a b : G
h : f (a * b⁻¹) = 1
⊢ f a = f b
state_after: G : Type u_1
H : Type u_2
A : Type u_3
a✝ a₁ a₂ b✝ c : G
inst✝¹ : Group G
inst✝ : Group H
f : G → H
hf : IsGroupHom f
a b : G
h : f a * (f b)⁻¹ = 1
⊢ f a = f b
tactic: rw [hf.map_mul, hf.map_inv] at h
state_before: G : Type u_1
H : Type u_2
A : Type u_3
a✝ a₁ a₂ b✝ c : G
inst✝¹ : Group G
inst✝ : Group H
f : G → H
hf : IsGroupHom f
a b : G
h : f a * (f b)⁻¹ = 1
⊢ f a = f b
state_after: no goals
tactic: rw [← inv_inv (f b), eq_inv_of_mul_eq_one_left h]
Theorem: Summable.ofStar
File: Mathlib/Topology/Algebra/InfiniteSum/Constructions.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝³ : AddCommMonoid α
inst✝² : TopologicalSpace α
inst✝¹ : StarAddMonoid α
inst✝ : ContinuousStar α
f : β → α
a : α
hf : Summable fun b => Star.star (f b)
⊢ Summable f
state_after: no goals
tactic: simpa only [star_star] using hf.star
Theorem: Submodule.comm_trans_lTensorOne
File: Mathlib/LinearAlgebra/TensorProduct/Submodule.lean

Proof steps:
state_before: R : Type u
S : Type v
inst✝² : CommSemiring R
inst✝¹ : Semiring S
inst✝ : Algebra R S
M N : Submodule R S
⊢ TensorProduct.comm R ↥M ↥⊥ ≪≫ₗ M.lTensorOne = M.rTensorOne
state_after: R : Type u
S : Type v
inst✝² : CommSemiring R
inst✝¹ : Semiring S
inst✝ : Algebra R S
M N : Submodule R S
m : ↥M
r : ↥⊥
⊢ ↑(TensorProduct.comm R ↥M ↥⊥ ≪≫ₗ M.lTensorOne) (m ⊗ₜ[R] r) = ↑M.rTensorOne (m ⊗ₜ[R] r)
tactic: refine LinearEquiv.toLinearMap_injective <| TensorProduct.ext' fun m r ↦ ?_
state_before: R : Type u
S : Type v
inst✝² : CommSemiring R
inst✝¹ : Semiring S
inst✝ : Algebra R S
M N : Submodule R S
m : ↥M
r : ↥⊥
⊢ ↑(TensorProduct.comm R ↥M ↥⊥ ≪≫ₗ M.lTensorOne) (m ⊗ₜ[R] r) = ↑M.rTensorOne (m ⊗ₜ[R] r)
state_after: case intro
R : Type u
S : Type v
inst✝² : CommSemiring R
inst✝¹ : Semiring S
inst✝ : Algebra R S
M N : Submodule R S
m : ↥M
r : ↥⊥
x : R
h : (algebraMap R S) x = ↑r
⊢ ↑(TensorProduct.comm R ↥M ↥⊥ ≪≫ₗ M.lTensorOne) (m ⊗ₜ[R] r) = ↑M.rTensorOne (m ⊗ₜ[R] r)
tactic: obtain ⟨x, h⟩ := Algebra.mem_bot.1 r.2
state_before: case intro
R : Type u
S : Type v
inst✝² : CommSemiring R
inst✝¹ : Semiring S
inst✝ : Algebra R S
M N : Submodule R S
m : ↥M
r : ↥⊥
x : R
h : (algebraMap R S) x = ↑r
⊢ ↑(TensorProduct.comm R ↥M ↥⊥ ≪≫ₗ M.lTensorOne) (m ⊗ₜ[R] r) = ↑M.rTensorOne (m ⊗ₜ[R] r)
state_after: case intro
R : Type u
S : Type v
inst✝² : CommSemiring R
inst✝¹ : Semiring S
inst✝ : Algebra R S
M N : Submodule R S
m : ↥M
r : ↥⊥
x : R
h : (algebraMap R ↥⊥) x = r
⊢ ↑(TensorProduct.comm R ↥M ↥⊥ ≪≫ₗ M.lTensorOne) (m ⊗ₜ[R] r) = ↑M.rTensorOne (m ⊗ₜ[R] r)
tactic: replace h : algebraMap R _ x = r := Subtype.val_injective h
state_before: case intro
R : Type u
S : Type v
inst✝² : CommSemiring R
inst✝¹ : Semiring S
inst✝ : Algebra R S
M N : Submodule R S
m : ↥M
r : ↥⊥
x : R
h : (algebraMap R ↥⊥) x = r
⊢ ↑(TensorProduct.comm R ↥M ↥⊥ ≪≫ₗ M.lTensorOne) (m ⊗ₜ[R] r) = ↑M.rTensorOne (m ⊗ₜ[R] r)
state_after: case intro
R : Type u
S : Type v
inst✝² : CommSemiring R
inst✝¹ : Semiring S
inst✝ : Algebra R S
M N : Submodule R S
m : ↥M
r : ↥⊥
x : R
h : (algebraMap R ↥⊥) x = r
⊢ ↑(TensorProduct.comm R ↥M ↥⊥ ≪≫ₗ M.lTensorOne) (m ⊗ₜ[R] (algebraMap R ↥⊥) x) =
    ↑M.rTensorOne (m ⊗ₜ[R] (algebraMap R ↥⊥) x)
tactic: rw [← h]
state_before: case intro
R : Type u
S : Type v
inst✝² : CommSemiring R
inst✝¹ : Semiring S
inst✝ : Algebra R S
M N : Submodule R S
m : ↥M
r : ↥⊥
x : R
h : (algebraMap R ↥⊥) x = r
⊢ ↑(TensorProduct.comm R ↥M ↥⊥ ≪≫ₗ M.lTensorOne) (m ⊗ₜ[R] (algebraMap R ↥⊥) x) =
    ↑M.rTensorOne (m ⊗ₜ[R] (algebraMap R ↥⊥) x)
state_after: no goals
tactic: simp
Theorem: CategoryTheory.Limits.prodZeroIso_iso_inv_snd
File: Mathlib/CategoryTheory/Limits/Constructions/ZeroObjects.lean

Proof steps:
state_before: C : Type u_1
inst✝² : Category.{u_2, u_1} C
inst✝¹ : HasZeroObject C
inst✝ : HasZeroMorphisms C
X : C
⊢ (prodZeroIso X).inv ≫ prod.fst = 𝟙 X
state_after: C : Type u_1
inst✝² : Category.{u_2, u_1} C
inst✝¹ : HasZeroObject C
inst✝ : HasZeroMorphisms C
X : C
⊢ (limit.isoLimitCone { cone := BinaryFan.mk (𝟙 X) 0, isLimit := binaryFanZeroRightIsLimit X }).inv ≫ prod.fst = 𝟙 X
tactic: dsimp [prodZeroIso, binaryFanZeroRight]
state_before: C : Type u_1
inst✝² : Category.{u_2, u_1} C
inst✝¹ : HasZeroObject C
inst✝ : HasZeroMorphisms C
X : C
⊢ (limit.isoLimitCone { cone := BinaryFan.mk (𝟙 X) 0, isLimit := binaryFanZeroRightIsLimit X }).inv ≫ prod.fst = 𝟙 X
state_after: no goals
tactic: simp
Theorem: EckmannHilton.one
File: Mathlib/GroupTheory/EckmannHilton.lean

Proof steps:
state_before: X : Type u
m₁ m₂ : X → X → X
e₁ e₂ : X
h₁ : IsUnital m₁ e₁
h₂ : IsUnital m₂ e₂
distrib : ∀ (a b c d : X), m₁ (m₂ a b) (m₂ c d) = m₂ (m₁ a c) (m₁ b d)
⊢ e₁ = e₂
state_after: no goals
tactic: simpa only [h₁.left_id, h₁.right_id, h₂.left_id, h₂.right_id] using distrib e₂ e₁ e₁ e₂
Theorem: Codisjoint.himp_eq_right
File: Mathlib/Order/Heyting/Basic.lean

Proof steps:
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
inst✝ : GeneralizedHeytingAlgebra α
a b c d : α
h : Codisjoint a b
⊢ b ⇨ a = a
state_after: ι : Type u_1
α : Type u_2
β : Type u_3
inst✝ : GeneralizedHeytingAlgebra α
a b c d : α
h : Codisjoint a b
⊢ b ⇨ a = ⊤ ⇨ a
tactic: conv_rhs => rw [← @top_himp _ _ a]
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
inst✝ : GeneralizedHeytingAlgebra α
a b c d : α
h : Codisjoint a b
⊢ b ⇨ a = ⊤ ⇨ a
state_after: no goals
tactic: rw [← h.eq_top, sup_himp_self_left]
Theorem: IsUnit.div_div_cancel
File: Mathlib/Algebra/Group/Units.lean

Proof steps:
state_before: α : Type u
M : Type u_1
N : Type u_2
inst✝ : DivisionCommMonoid α
a b c d : α
h : IsUnit a
⊢ a / (a / b) = b
state_after: no goals
tactic: rw [div_div_eq_mul_div, h.mul_div_cancel_left]
Theorem: Option.map_bind
File: Mathlib/Data/Option/Basic.lean

Proof steps:
state_before: α✝ : Type u_1
β✝ : Type u_2
γ✝ : Type u_3
δ : Type u_4
p : α✝ → Prop
f✝ : (a : α✝) → p a → β✝
x✝ : Option α✝
α β γ : Type u_5
f : β → γ
x : Option α
g : α → Option β
⊢ Option.map f (x >>= g) = do
    let a ← x
    Option.map f (g a)
state_after: no goals
tactic: simp only [← map_eq_map, ← bind_pure_comp, LawfulMonad.bind_assoc]
Theorem: _private.Mathlib.CategoryTheory.Galois.Decomposition.0.CategoryTheory.PreGaloisCategory.mkSelfProdFib_map_π
File: Mathlib/CategoryTheory/Galois/Decomposition.lean

Proof steps:
state_before: C : Type u₁
inst✝² : Category.{u₂, u₁} C
inst✝¹ : GaloisCategory C
F : C ⥤ FintypeCat
inst✝ : FiberFunctor F
X : C
t : ↑(F.obj X)
⊢ F.map (Pi.π (fun x => X) t) (CategoryTheory.PreGaloisCategory.mkSelfProdFib F X) = t
state_after: C : Type u₁
inst✝² : Category.{u₂, u₁} C
inst✝¹ : GaloisCategory C
F : C ⥤ FintypeCat
inst✝ : FiberFunctor F
X : C
t : ↑(F.obj X)
⊢ Pi.π (fun b => F.obj X) t
      ((PreservesProduct.iso F fun x => X).hom (CategoryTheory.PreGaloisCategory.mkSelfProdFib F X)) =
    t
tactic: rw [← congrFun (piComparison_comp_π F _ t), FintypeCat.comp_apply,
    ← PreservesProduct.iso_hom]
state_before: C : Type u₁
inst✝² : Category.{u₂, u₁} C
inst✝¹ : GaloisCategory C
F : C ⥤ FintypeCat
inst✝ : FiberFunctor F
X : C
t : ↑(F.obj X)
⊢ Pi.π (fun b => F.obj X) t
      ((PreservesProduct.iso F fun x => X).hom (CategoryTheory.PreGaloisCategory.mkSelfProdFib F X)) =
    t
state_after: C : Type u₁
inst✝² : Category.{u₂, u₁} C
inst✝¹ : GaloisCategory C
F : C ⥤ FintypeCat
inst✝ : FiberFunctor F
X : C
t : ↑(F.obj X)
⊢ Pi.π (fun b => F.obj X) t ((Concrete.productEquiv fun x => F.obj X).symm id) = t
tactic: simp only [mkSelfProdFib, FintypeCat.inv_hom_id_apply]
state_before: C : Type u₁
inst✝² : Category.{u₂, u₁} C
inst✝¹ : GaloisCategory C
F : C ⥤ FintypeCat
inst✝ : FiberFunctor F
X : C
t : ↑(F.obj X)
⊢ Pi.π (fun b => F.obj X) t ((Concrete.productEquiv fun x => F.obj X).symm id) = t
state_after: no goals
tactic: exact Concrete.productEquiv_symm_apply_π.{w, w, w+1} (fun _ : F.obj X ↦ F.obj X) id t
Theorem: Set.piecewise_le
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
δ✝ : α → Sort u_6
s✝ : Set α
f g✝ : (i : α) → δ✝ i
inst✝² : (j : α) → Decidable (j ∈ s✝)
δ : α → Type u_7
inst✝¹ : (i : α) → Preorder (δ i)
s : Set α
inst✝ : (j : α) → Decidable (j ∈ s)
f₁ f₂ g : (i : α) → δ i
h₁ : ∀ i ∈ s, f₁ i ≤ g i
h₂ : ∀ i ∉ s, f₂ i ≤ g i
i : α
h : i ∈ s
⊢ s.piecewise f₁ f₂ i ≤ g i
state_after: no goals
tactic: simp [*]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
π : α → Type u_5
δ✝ : α → Sort u_6
s✝ : Set α
f g✝ : (i : α) → δ✝ i
inst✝² : (j : α) → Decidable (j ∈ s✝)
δ : α → Type u_7
inst✝¹ : (i : α) → Preorder (δ i)
s : Set α
inst✝ : (j : α) → Decidable (j ∈ s)
f₁ f₂ g : (i : α) → δ i
h₁ : ∀ i ∈ s, f₁ i ≤ g i
h₂ : ∀ i ∉ s, f₂ i ≤ g i
i : α
h : i ∉ s
⊢ s.piecewise f₁ f₂ i ≤ g i
state_after: no goals
tactic: simp [*]
Theorem: Batteries.DList.toList_ofList
File: Mathlib/Data/DList/Defs.lean

Proof steps:
state_before: α : Type u
l : List α
⊢ (ofList l).toList = l
state_after: case nil
α : Type u
⊢ (ofList []).toList = []

case cons
α : Type u
head✝ : α
tail✝ : List α
⊢ (ofList (head✝ :: tail✝)).toList = head✝ :: tail✝
tactic: cases l
state_before: case nil
α : Type u
⊢ (ofList []).toList = []

case cons
α : Type u
head✝ : α
tail✝ : List α
⊢ (ofList (head✝ :: tail✝)).toList = head✝ :: tail✝
state_after: case cons
α : Type u
head✝ : α
tail✝ : List α
⊢ (ofList (head✝ :: tail✝)).toList = head✝ :: tail✝
tactic: rfl
state_before: case cons
α : Type u
head✝ : α
tail✝ : List α
⊢ (ofList (head✝ :: tail✝)).toList = head✝ :: tail✝
state_after: no goals
tactic: simp only [DList.toList, DList.ofList, List.cons_append, List.append_nil]