ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: smul_algebraMap
File: Mathlib/Algebra/Algebra/Defs.lean

Proof steps:
state_before: R : Type u
S : Type v
A : Type w
B : Type u_1
inst✝⁸ : CommSemiring R
inst✝⁷ : CommSemiring S
inst✝⁶ : Semiring A
inst✝⁵ : Algebra R A
inst✝⁴ : Semiring B
inst✝³ : Algebra R B
α : Type u_2
inst✝² : Monoid α
inst✝¹ : MulDistribMulAction α A
inst✝ : SMulCommClass α R A
a : α
r : R
⊢ a • (algebraMap R A) r = (algebraMap R A) r
state_after: no goals
tactic: rw [algebraMap_eq_smul_one, smul_comm a r (1 : A), smul_one]
Theorem: IsUnit.mem_unitary_of_star_mul_self
File: Mathlib/Algebra/Star/Unitary.lean

Proof steps:
state_before: R : Type u_1
inst✝¹ : Monoid R
inst✝ : StarMul R
u : R
hu : IsUnit u
h_mul : star u * u = 1
⊢ u ∈ unitary R
state_after: R : Type u_1
inst✝¹ : Monoid R
inst✝ : StarMul R
u : R
hu : IsUnit u
h_mul : star u * u = 1
⊢ u * star u = 1
tactic: refine unitary.mem_iff.mpr ⟨h_mul, ?_⟩
state_before: R : Type u_1
inst✝¹ : Monoid R
inst✝ : StarMul R
u : R
hu : IsUnit u
h_mul : star u * u = 1
⊢ u * star u = 1
state_after: case intro
R : Type u_1
inst✝¹ : Monoid R
inst✝ : StarMul R
u : Rˣ
h_mul : star ↑u * ↑u = 1
⊢ ↑u * star ↑u = 1
tactic: lift u to Rˣ using hu
state_before: case intro
R : Type u_1
inst✝¹ : Monoid R
inst✝ : StarMul R
u : Rˣ
h_mul : star ↑u * ↑u = 1
⊢ ↑u * star ↑u = 1
state_after: no goals
tactic: exact left_inv_eq_right_inv h_mul u.mul_inv ▸ u.mul_inv
Theorem: Equiv.Perm.perm_mapsTo_inl_iff_mapsTo_inr
File: Mathlib/GroupTheory/Perm/Finite.lean

Proof steps:
state_before: α : Type u
β : Type v
m : Type u_1
n : Type u_2
inst✝¹ : Finite m
inst✝ : Finite n
σ : Perm (m ⊕ n)
⊢ Set.MapsTo (⇑σ) (Set.range Sum.inl) (Set.range Sum.inl) ↔ Set.MapsTo (⇑σ) (Set.range Sum.inr) (Set.range Sum.inr)
state_after: case mp.inl
α : Type u
β : Type v
m : Type u_1
n : Type u_2
inst✝¹ : Finite m
inst✝ : Finite n
σ : Perm (m ⊕ n)
h : Set.MapsTo (⇑σ⁻¹) (Set.range Sum.inl) (Set.range Sum.inl)
x : m ⊕ n
l : m
hx : σ x = Sum.inl l
⊢ x ∈ Set.range Sum.inr → Sum.inl l ∈ Set.range Sum.inr

case mp.inr
α : Type u
β : Type v
m : Type u_1
n : Type u_2
inst✝¹ : Finite m
inst✝ : Finite n
σ : Perm (m ⊕ n)
h : Set.MapsTo (⇑σ⁻¹) (Set.range Sum.inl) (Set.range Sum.inl)
x : m ⊕ n
r : n
hx : σ x = Sum.inr r
⊢ x ∈ Set.range Sum.inr → Sum.inr r ∈ Set.range Sum.inr

case mpr.inl
α : Type u
β : Type v
m : Type u_1
n : Type u_2
inst✝¹ : Finite m
inst✝ : Finite n
σ : Perm (m ⊕ n)
h : Set.MapsTo (⇑σ⁻¹) (Set.range Sum.inr) (Set.range Sum.inr)
x : m ⊕ n
l : m
hx : σ x = Sum.inl l
⊢ x ∈ Set.range Sum.inl → Sum.inl l ∈ Set.range Sum.inl

case mpr.inr
α : Type u
β : Type v
m : Type u_1
n : Type u_2
inst✝¹ : Finite m
inst✝ : Finite n
σ : Perm (m ⊕ n)
h : Set.MapsTo (⇑σ⁻¹) (Set.range Sum.inr) (Set.range Sum.inr)
x : m ⊕ n
r : n
hx : σ x = Sum.inr r
⊢ x ∈ Set.range Sum.inl → Sum.inr r ∈ Set.range Sum.inl
tactic: constructor <;>
    ( intro h
      classical
        rw [← perm_inv_mapsTo_iff_mapsTo] at h
        intro x
        cases' hx : σ x with l r)
Theorem: Matroid.not_infiniteRk
File: Mathlib/Data/Matroid/Basic.lean

Proof steps:
state_before: α : Type u_1
M✝ : Matroid α
B B₁ B₂ : Set α
M : Matroid α
inst✝ : M.FiniteRk
⊢ ¬M.InfiniteRk
state_after: α : Type u_1
M✝ : Matroid α
B B₁ B₂ : Set α
M : Matroid α
inst✝ : M.FiniteRk
h : M.InfiniteRk
⊢ False
tactic: intro h
state_before: α : Type u_1
M✝ : Matroid α
B B₁ B₂ : Set α
M : Matroid α
inst✝ : M.FiniteRk
h : M.InfiniteRk
⊢ False
state_after: case intro
α : Type u_1
M✝ : Matroid α
B✝ B₁ B₂ : Set α
M : Matroid α
inst✝ : M.FiniteRk
h : M.InfiniteRk
B : Set α
hB : M.Base B
⊢ False
tactic: obtain ⟨B,hB⟩ := M.exists_base
state_before: case intro
α : Type u_1
M✝ : Matroid α
B✝ B₁ B₂ : Set α
M : Matroid α
inst✝ : M.FiniteRk
h : M.InfiniteRk
B : Set α
hB : M.Base B
⊢ False
state_after: no goals
tactic: exact hB.infinite hB.finite
Theorem: Localization.mk_pow
File: Mathlib/GroupTheory/MonoidLocalization/Basic.lean

Proof steps:
state_before: M : Type u_1
inst✝² : CommMonoid M
S : Submonoid M
N : Type u_2
inst✝¹ : CommMonoid N
P : Type u_3
inst✝ : CommMonoid P
n : ℕ
a : M
b : ↥S
⊢ mk a b ^ n = mk (a ^ n) (b ^ n)
state_after: no goals
tactic: induction n <;> simp [pow_succ, *, ← mk_mul, ← mk_one]
Theorem: MeasureTheory.FiniteMeasure.testAgainstNN_mono
File: Mathlib/MeasureTheory/Measure/FiniteMeasure.lean

Proof steps:
state_before: Ω : Type u_1
inst✝⁵ : MeasurableSpace Ω
R : Type u_2
inst✝⁴ : SMul R ℝ≥0
inst✝³ : SMul R ℝ≥0∞
inst✝² : IsScalarTower R ℝ≥0 ℝ≥0∞
inst✝¹ : IsScalarTower R ℝ≥0∞ ℝ≥0∞
inst✝ : TopologicalSpace Ω
μ : FiniteMeasure Ω
f g : Ω →ᵇ ℝ≥0
f_le_g : ⇑f ≤ ⇑g
⊢ μ.testAgainstNN f ≤ μ.testAgainstNN g
state_after: Ω : Type u_1
inst✝⁵ : MeasurableSpace Ω
R : Type u_2
inst✝⁴ : SMul R ℝ≥0
inst✝³ : SMul R ℝ≥0∞
inst✝² : IsScalarTower R ℝ≥0 ℝ≥0∞
inst✝¹ : IsScalarTower R ℝ≥0∞ ℝ≥0∞
inst✝ : TopologicalSpace Ω
μ : FiniteMeasure Ω
f g : Ω →ᵇ ℝ≥0
f_le_g : ⇑f ≤ ⇑g
⊢ ∫⁻ (ω : Ω), ↑(f ω) ∂↑μ ≤ ∫⁻ (ω : Ω), ↑(g ω) ∂↑μ
tactic: simp only [← ENNReal.coe_le_coe, testAgainstNN_coe_eq]
state_before: Ω : Type u_1
inst✝⁵ : MeasurableSpace Ω
R : Type u_2
inst✝⁴ : SMul R ℝ≥0
inst✝³ : SMul R ℝ≥0∞
inst✝² : IsScalarTower R ℝ≥0 ℝ≥0∞
inst✝¹ : IsScalarTower R ℝ≥0∞ ℝ≥0∞
inst✝ : TopologicalSpace Ω
μ : FiniteMeasure Ω
f g : Ω →ᵇ ℝ≥0
f_le_g : ⇑f ≤ ⇑g
⊢ ∫⁻ (ω : Ω), ↑(f ω) ∂↑μ ≤ ∫⁻ (ω : Ω), ↑(g ω) ∂↑μ
state_after: case hfg.a
Ω : Type u_1
inst✝⁵ : MeasurableSpace Ω
R : Type u_2
inst✝⁴ : SMul R ℝ≥0
inst✝³ : SMul R ℝ≥0∞
inst✝² : IsScalarTower R ℝ≥0 ℝ≥0∞
inst✝¹ : IsScalarTower R ℝ≥0∞ ℝ≥0∞
inst✝ : TopologicalSpace Ω
μ : FiniteMeasure Ω
f g : Ω →ᵇ ℝ≥0
f_le_g : ⇑f ≤ ⇑g
x✝ : Ω
⊢ f x✝ ≤ g x✝
tactic: gcongr
state_before: case hfg.a
Ω : Type u_1
inst✝⁵ : MeasurableSpace Ω
R : Type u_2
inst✝⁴ : SMul R ℝ≥0
inst✝³ : SMul R ℝ≥0∞
inst✝² : IsScalarTower R ℝ≥0 ℝ≥0∞
inst✝¹ : IsScalarTower R ℝ≥0∞ ℝ≥0∞
inst✝ : TopologicalSpace Ω
μ : FiniteMeasure Ω
f g : Ω →ᵇ ℝ≥0
f_le_g : ⇑f ≤ ⇑g
x✝ : Ω
⊢ f x✝ ≤ g x✝
state_after: no goals
tactic: apply f_le_g
Theorem: ENNReal.pow_eq_top_iff
File: Mathlib/Data/ENNReal/Operations.lean

Proof steps:
state_before: a b c d : ℝ≥0∞
r p q : ℝ≥0
α : Type u_1
n : ℕ
⊢ a ^ n = ⊤ ↔ a = ⊤ ∧ n ≠ 0
state_after: case inl
a b c d : ℝ≥0∞
r p q : ℝ≥0
α : Type u_1
⊢ a ^ 0 = ⊤ ↔ a = ⊤ ∧ 0 ≠ 0

case inr
a b c d : ℝ≥0∞
r p q : ℝ≥0
α : Type u_1
n : ℕ
hn : 0 < n
⊢ a ^ n = ⊤ ↔ a = ⊤ ∧ n ≠ 0
tactic: rcases n.eq_zero_or_pos with rfl | (hn : 0 < n)
Theorem: Cardinal.aleph'_omega
File: Mathlib/SetTheory/Cardinal/Ordinal.lean

Proof steps:
state_before: c : Cardinal.{u_1}
⊢ aleph' ω ≤ c ↔ ℵ₀ ≤ c
state_after: c : Cardinal.{u_1}
⊢ (∀ (o' : Ordinal.{u_1}) (x : ℕ), o' = ↑x → aleph' o' ≤ c) ↔ ∀ (n : ℕ), ↑n ≤ c
tactic: simp only [aleph'_le_of_limit omega_isLimit, lt_omega, exists_imp, aleph0_le]
state_before: c : Cardinal.{u_1}
⊢ (∀ (o' : Ordinal.{u_1}) (x : ℕ), o' = ↑x → aleph' o' ≤ c) ↔ ∀ (n : ℕ), ↑n ≤ c
state_after: no goals
tactic: exact forall_swap.trans (forall_congr' fun n => by simp only [forall_eq, aleph'_nat])
Theorem: CategoryTheory.Localization.Preadditive.add'_comm
File: Mathlib/CategoryTheory/Localization/CalculusOfFractions/Preadditive.lean

Proof steps:
state_before: C : Type u_1
D : Type u_2
inst✝⁴ : Category.{u_4, u_1} C
inst✝³ : Category.{u_3, u_2} D
inst✝² : Preadditive C
L : C ⥤ D
W : MorphismProperty C
inst✝¹ : L.IsLocalization W
inst✝ : W.HasLeftCalculusOfFractions
X Y Z : C
f₁ f₂ : L.obj X ⟶ L.obj Y
⊢ add' W f₁ f₂ = add' W f₂ f₁
state_after: case intro.intro
C : Type u_1
D : Type u_2
inst✝⁴ : Category.{u_4, u_1} C
inst✝³ : Category.{u_3, u_2} D
inst✝² : Preadditive C
L : C ⥤ D
W : MorphismProperty C
inst✝¹ : L.IsLocalization W
inst✝ : W.HasLeftCalculusOfFractions
X Y Z : C
f₁ f₂ : L.obj X ⟶ L.obj Y
α : W.LeftFraction₂ X Y
h₁ : f₁ = α.fst.map L ⋯
h₂ : f₂ = α.snd.map L ⋯
⊢ add' W f₁ f₂ = add' W f₂ f₁
tactic: obtain ⟨α, h₁, h₂⟩ := exists_leftFraction₂ L W f₁ f₂
state_before: case intro.intro
C : Type u_1
D : Type u_2
inst✝⁴ : Category.{u_4, u_1} C
inst✝³ : Category.{u_3, u_2} D
inst✝² : Preadditive C
L : C ⥤ D
W : MorphismProperty C
inst✝¹ : L.IsLocalization W
inst✝ : W.HasLeftCalculusOfFractions
X Y Z : C
f₁ f₂ : L.obj X ⟶ L.obj Y
α : W.LeftFraction₂ X Y
h₁ : f₁ = α.fst.map L ⋯
h₂ : f₂ = α.snd.map L ⋯
⊢ add' W f₁ f₂ = add' W f₂ f₁
state_after: no goals
tactic: rw [add'_eq W f₁ f₂ α h₁ h₂, add'_eq W f₂ f₁ α.symm h₂ h₁, α.symm_add]
Theorem: coplanar_of_finrank_eq_two
File: Mathlib/LinearAlgebra/AffineSpace/FiniteDimensional.lean

Proof steps:
state_before: k : Type u_1
V : Type u_2
P : Type u_3
inst✝³ : DivisionRing k
inst✝² : AddCommGroup V
inst✝¹ : Module k V
inst✝ : AffineSpace V P
s : Set P
h : finrank k V = 2
⊢ Coplanar k s
state_after: k : Type u_1
V : Type u_2
P : Type u_3
inst✝³ : DivisionRing k
inst✝² : AddCommGroup V
inst✝¹ : Module k V
inst✝ : AffineSpace V P
s : Set P
h : finrank k V = 2
this : FiniteDimensional k V
⊢ Coplanar k s
tactic: have : FiniteDimensional k V := .of_finrank_eq_succ h
state_before: k : Type u_1
V : Type u_2
P : Type u_3
inst✝³ : DivisionRing k
inst✝² : AddCommGroup V
inst✝¹ : Module k V
inst✝ : AffineSpace V P
s : Set P
h : finrank k V = 2
this : FiniteDimensional k V
⊢ Coplanar k s
state_after: k : Type u_1
V : Type u_2
P : Type u_3
inst✝³ : DivisionRing k
inst✝² : AddCommGroup V
inst✝¹ : Module k V
inst✝ : AffineSpace V P
s : Set P
h : finrank k V = 2
this : FiniteDimensional k V
⊢ finrank k ↥(vectorSpan k s) ≤ finrank k V
tactic: rw [coplanar_iff_finrank_le_two, ← h]
state_before: k : Type u_1
V : Type u_2
P : Type u_3
inst✝³ : DivisionRing k
inst✝² : AddCommGroup V
inst✝¹ : Module k V
inst✝ : AffineSpace V P
s : Set P
h : finrank k V = 2
this : FiniteDimensional k V
⊢ finrank k ↥(vectorSpan k s) ≤ finrank k V
state_after: no goals
tactic: exact Submodule.finrank_le _
Theorem: IsCoprime.mul_left
File: Mathlib/RingTheory/Coprime/Basic.lean

Proof steps:
state_before: R : Type u
inst✝ : CommSemiring R
x y z : R
H1 : IsCoprime x z
H2 : IsCoprime y z
a b : R
h1 : a * x + b * z = 1
c d : R
h2 : c * y + d * z = 1
⊢ a * c * (x * y) + (a * x * d + b * c * y + b * d * z) * z = (a * x + b * z) * (c * y + d * z)
state_after: no goals
tactic: ring
state_before: R : Type u
inst✝ : CommSemiring R
x y z : R
H1 : IsCoprime x z
H2 : IsCoprime y z
a b : R
h1 : a * x + b * z = 1
c d : R
h2 : c * y + d * z = 1
⊢ (a * x + b * z) * (c * y + d * z) = 1
state_after: no goals
tactic: rw [h1, h2, mul_one]
Theorem: finprod_mem_comm
File: Mathlib/Algebra/BigOperators/Finprod.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
ι : Type u_3
G : Type u_4
M : Type u_5
N : Type u_6
inst✝¹ : CommMonoid M
inst✝ : CommMonoid N
f✝ g : α → M
a b : α
s✝ t✝ s : Set α
t : Set β
f : α → β → M
hs : s.Finite
ht : t.Finite
⊢ ∏ᶠ (i : α) (_ : i ∈ s) (j : β) (_ : j ∈ t), f i j = ∏ᶠ (j : β) (_ : j ∈ t) (i : α) (_ : i ∈ s), f i j
state_after: case intro
α : Type u_1
β : Type u_2
ι : Type u_3
G : Type u_4
M : Type u_5
N : Type u_6
inst✝¹ : CommMonoid M
inst✝ : CommMonoid N
f✝ g : α → M
a b : α
s✝ t✝ : Set α
t : Set β
f : α → β → M
ht : t.Finite
s : Finset α
⊢ ∏ᶠ (i : α) (_ : i ∈ ↑s) (j : β) (_ : j ∈ t), f i j = ∏ᶠ (j : β) (_ : j ∈ t) (i : α) (_ : i ∈ ↑s), f i j
tactic: lift s to Finset α using hs
state_before: case intro
α : Type u_1
β : Type u_2
ι : Type u_3
G : Type u_4
M : Type u_5
N : Type u_6
inst✝¹ : CommMonoid M
inst✝ : CommMonoid N
f✝ g : α → M
a b : α
s✝ t✝ : Set α
t : Set β
f : α → β → M
ht : t.Finite
s : Finset α
⊢ ∏ᶠ (i : α) (_ : i ∈ ↑s) (j : β) (_ : j ∈ t), f i j = ∏ᶠ (j : β) (_ : j ∈ t) (i : α) (_ : i ∈ ↑s), f i j
state_after: case intro.intro
α : Type u_1
β : Type u_2
ι : Type u_3
G : Type u_4
M : Type u_5
N : Type u_6
inst✝¹ : CommMonoid M
inst✝ : CommMonoid N
f✝ g : α → M
a b : α
s✝ t✝ : Set α
f : α → β → M
s : Finset α
t : Finset β
⊢ ∏ᶠ (i : α) (_ : i ∈ ↑s) (j : β) (_ : j ∈ ↑t), f i j = ∏ᶠ (j : β) (_ : j ∈ ↑t) (i : α) (_ : i ∈ ↑s), f i j
tactic: lift t to Finset β using ht
state_before: case intro.intro
α : Type u_1
β : Type u_2
ι : Type u_3
G : Type u_4
M : Type u_5
N : Type u_6
inst✝¹ : CommMonoid M
inst✝ : CommMonoid N
f✝ g : α → M
a b : α
s✝ t✝ : Set α
f : α → β → M
s : Finset α
t : Finset β
⊢ ∏ᶠ (i : α) (_ : i ∈ ↑s) (j : β) (_ : j ∈ ↑t), f i j = ∏ᶠ (j : β) (_ : j ∈ ↑t) (i : α) (_ : i ∈ ↑s), f i j
state_after: case intro.intro
α : Type u_1
β : Type u_2
ι : Type u_3
G : Type u_4
M : Type u_5
N : Type u_6
inst✝¹ : CommMonoid M
inst✝ : CommMonoid N
f✝ g : α → M
a b : α
s✝ t✝ : Set α
f : α → β → M
s : Finset α
t : Finset β
⊢ ∏ i ∈ s, ∏ i_1 ∈ t, f i i_1 = ∏ i ∈ t, ∏ i_1 ∈ s, f i_1 i
tactic: simp only [finprod_mem_coe_finset]
state_before: case intro.intro
α : Type u_1
β : Type u_2
ι : Type u_3
G : Type u_4
M : Type u_5
N : Type u_6
inst✝¹ : CommMonoid M
inst✝ : CommMonoid N
f✝ g : α → M
a b : α
s✝ t✝ : Set α
f : α → β → M
s : Finset α
t : Finset β
⊢ ∏ i ∈ s, ∏ i_1 ∈ t, f i i_1 = ∏ i ∈ t, ∏ i_1 ∈ s, f i_1 i
state_after: no goals
tactic: exact Finset.prod_comm
Theorem: SimpleGraph.dart_edge_eq_mk'_iff'
File: Mathlib/Combinatorics/SimpleGraph/Dart.lean

Proof steps:
state_before: V : Type u_1
G : SimpleGraph V
⊢ ∀ {d : G.Dart} {u v : V}, d.edge = s(u, v) ↔ d.toProd.1 = u ∧ d.toProd.2 = v ∨ d.toProd.1 = v ∧ d.toProd.2 = u
state_after: case mk.mk
V : Type u_1
G : SimpleGraph V
a b : V
h : G.Adj (a, b).1 (a, b).2
u v : V
⊢ { toProd := (a, b), adj := h }.edge = s(u, v) ↔
    { toProd := (a, b), adj := h }.toProd.1 = u ∧ { toProd := (a, b), adj := h }.toProd.2 = v ∨
      { toProd := (a, b), adj := h }.toProd.1 = v ∧ { toProd := (a, b), adj := h }.toProd.2 = u
tactic: rintro ⟨⟨a, b⟩, h⟩ u v
state_before: case mk.mk
V : Type u_1
G : SimpleGraph V
a b : V
h : G.Adj (a, b).1 (a, b).2
u v : V
⊢ { toProd := (a, b), adj := h }.edge = s(u, v) ↔
    { toProd := (a, b), adj := h }.toProd.1 = u ∧ { toProd := (a, b), adj := h }.toProd.2 = v ∨
      { toProd := (a, b), adj := h }.toProd.1 = v ∧ { toProd := (a, b), adj := h }.toProd.2 = u
state_after: case mk.mk
V : Type u_1
G : SimpleGraph V
a b : V
h : G.Adj (a, b).1 (a, b).2
u v : V
⊢ { toProd := (a, b), adj := h }.toProd = (u, v) ∨ { toProd := (a, b), adj := h }.toProd = (u, v).swap ↔
    { toProd := (a, b), adj := h }.toProd.1 = u ∧ { toProd := (a, b), adj := h }.toProd.2 = v ∨
      { toProd := (a, b), adj := h }.toProd.1 = v ∧ { toProd := (a, b), adj := h }.toProd.2 = u
tactic: rw [dart_edge_eq_mk'_iff]
state_before: case mk.mk
V : Type u_1
G : SimpleGraph V
a b : V
h : G.Adj (a, b).1 (a, b).2
u v : V
⊢ { toProd := (a, b), adj := h }.toProd = (u, v) ∨ { toProd := (a, b), adj := h }.toProd = (u, v).swap ↔
    { toProd := (a, b), adj := h }.toProd.1 = u ∧ { toProd := (a, b), adj := h }.toProd.2 = v ∨
      { toProd := (a, b), adj := h }.toProd.1 = v ∧ { toProd := (a, b), adj := h }.toProd.2 = u
state_after: no goals
tactic: simp
Theorem: SetTheory.PGame.zero_le_neg_iff
File: Mathlib/SetTheory/Game/PGame.lean

Proof steps:
state_before: xl xr : Type u
x : PGame
⊢ 0 ≤ -x ↔ x ≤ 0
state_after: no goals
tactic: rw [le_neg_iff, neg_zero]
Theorem: SMulPosMono.lift
File: Mathlib/Algebra/Order/Module/Defs.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
a a₁✝ a₂✝ : α
b✝ b₁ b₂ : β
γ : Type u_3
inst✝⁸ : Zero α
inst✝⁷ : Preorder α
inst✝⁶ : Zero β
inst✝⁵ : Preorder β
inst✝⁴ : Zero γ
inst✝³ : Preorder γ
inst✝² : SMul α β
inst✝¹ : SMul α γ
f : β → γ
inst✝ : SMulPosMono α γ
hf : ∀ {b₁ b₂ : β}, f b₁ ≤ f b₂ ↔ b₁ ≤ b₂
smul : ∀ (a : α) (b : β), f (a • b) = a • f b
zero : f 0 = 0
b : β
hb : 0 ≤ b
a₁ a₂ : α
ha : a₁ ≤ a₂
⊢ a₁ • b ≤ a₂ • b
state_after: α : Type u_1
β : Type u_2
a a₁✝ a₂✝ : α
b✝ b₁ b₂ : β
γ : Type u_3
inst✝⁸ : Zero α
inst✝⁷ : Preorder α
inst✝⁶ : Zero β
inst✝⁵ : Preorder β
inst✝⁴ : Zero γ
inst✝³ : Preorder γ
inst✝² : SMul α β
inst✝¹ : SMul α γ
f : β → γ
inst✝ : SMulPosMono α γ
b : β
a₁ a₂ : α
ha : a₁ ≤ a₂
hf : ∀ {b₁ b₂ : β}, True
smul : α → β → True
zero : True
hb : 0 ≤ f b
⊢ a₁ • f b ≤ a₂ • f b
tactic: simp only [← hf, zero, smul] at *
state_before: α : Type u_1
β : Type u_2
a a₁✝ a₂✝ : α
b✝ b₁ b₂ : β
γ : Type u_3
inst✝⁸ : Zero α
inst✝⁷ : Preorder α
inst✝⁶ : Zero β
inst✝⁵ : Preorder β
inst✝⁴ : Zero γ
inst✝³ : Preorder γ
inst✝² : SMul α β
inst✝¹ : SMul α γ
f : β → γ
inst✝ : SMulPosMono α γ
b : β
a₁ a₂ : α
ha : a₁ ≤ a₂
hf : ∀ {b₁ b₂ : β}, True
smul : α → β → True
zero : True
hb : 0 ≤ f b
⊢ a₁ • f b ≤ a₂ • f b
state_after: no goals
tactic: exact smul_le_smul_of_nonneg_right ha hb
Theorem: toIcoMod_eq_self
File: Mathlib/Algebra/Order/ToIntervalMod.lean

Proof steps:
state_before: α : Type u_1
inst✝ : LinearOrderedAddCommGroup α
hα : Archimedean α
p : α
hp : 0 < p
a b c : α
n : ℤ
⊢ toIcoMod hp a b = b ↔ b ∈ Set.Ico a (a + p)
state_after: α : Type u_1
inst✝ : LinearOrderedAddCommGroup α
hα : Archimedean α
p : α
hp : 0 < p
a b c : α
n : ℤ
⊢ ∃ z, b = b + z • p
tactic: rw [toIcoMod_eq_iff, and_iff_left]
state_before: α : Type u_1
inst✝ : LinearOrderedAddCommGroup α
hα : Archimedean α
p : α
hp : 0 < p
a b c : α
n : ℤ
⊢ ∃ z, b = b + z • p
state_after: no goals
tactic: exact ⟨0, by simp⟩
Theorem: isPreconnected_connectedComponentIn
File: Mathlib/Topology/Connected/Basic.lean

Proof steps:
state_before: α : Type u
β : Type v
ι : Type u_1
π : ι → Type u_2
inst✝ : TopologicalSpace α
s t u v : Set α
x : α
F : Set α
⊢ IsPreconnected (connectedComponentIn F x)
state_after: α : Type u
β : Type v
ι : Type u_1
π : ι → Type u_2
inst✝ : TopologicalSpace α
s t u v : Set α
x : α
F : Set α
⊢ IsPreconnected (if h : x ∈ F then Subtype.val '' connectedComponent ⟨x, h⟩ else ∅)
tactic: rw [connectedComponentIn]
state_before: α : Type u
β : Type v
ι : Type u_1
π : ι → Type u_2
inst✝ : TopologicalSpace α
s t u v : Set α
x : α
F : Set α
⊢ IsPreconnected (if h : x ∈ F then Subtype.val '' connectedComponent ⟨x, h⟩ else ∅)
state_after: case pos
α : Type u
β : Type v
ι : Type u_1
π : ι → Type u_2
inst✝ : TopologicalSpace α
s t u v : Set α
x : α
F : Set α
h✝ : x ∈ F
⊢ IsPreconnected (Subtype.val '' connectedComponent ⟨x, h✝⟩)

case neg
α : Type u
β : Type v
ι : Type u_1
π : ι → Type u_2
inst✝ : TopologicalSpace α
s t u v : Set α
x : α
F : Set α
h✝ : x ∉ F
⊢ IsPreconnected ∅
tactic: split_ifs
Theorem: ENNReal.rpow_le_one_of_one_le_of_neg
File: Mathlib/Analysis/SpecialFunctions/Pow/NNReal.lean

Proof steps:
state_before: x : ℝ≥0∞
z : ℝ
hx : 1 ≤ x
hz : z < 0
⊢ x ^ z ≤ 1
state_after: case top
z : ℝ
hz : z < 0
hx : 1 ≤ ⊤
⊢ ⊤ ^ z ≤ 1

case coe
z : ℝ
hz : z < 0
x✝ : ℝ≥0
hx : 1 ≤ ↑x✝
⊢ ↑x✝ ^ z ≤ 1
tactic: cases x
Theorem: groupCohomology.resolution.actionDiagonalSucc_hom_apply
File: Mathlib/RepresentationTheory/GroupCohomology/Resolution.lean

Proof steps:
state_before: k G✝ : Type u
inst✝² : CommRing k
n✝ : ℕ
inst✝¹ : Group G✝
G : Type u
inst✝ : Group G
n : ℕ
f : Fin (n + 1) → G
⊢ (actionDiagonalSucc G n).hom.hom f = (f 0, fun i => (f i.castSucc)⁻¹ * f i.succ)
state_after: case zero
k G✝ : Type u
inst✝² : CommRing k
n : ℕ
inst✝¹ : Group G✝
G : Type u
inst✝ : Group G
f : Fin (0 + 1) → G
⊢ (actionDiagonalSucc G 0).hom.hom f = (f 0, fun i => (f i.castSucc)⁻¹ * f i.succ)

case succ
k G✝ : Type u
inst✝² : CommRing k
n✝ : ℕ
inst✝¹ : Group G✝
G : Type u
inst✝ : Group G
n : ℕ
hn : ∀ (f : Fin (n + 1) → G), (actionDiagonalSucc G n).hom.hom f = (f 0, fun i => (f i.castSucc)⁻¹ * f i.succ)
f : Fin (n + 1 + 1) → G
⊢ (actionDiagonalSucc G (n + 1)).hom.hom f = (f 0, fun i => (f i.castSucc)⁻¹ * f i.succ)
tactic: induction' n with n hn
Theorem: MeasureTheory.measure_union₀_aux
File: Mathlib/MeasureTheory/Measure/NullMeasurable.lean

Proof steps:
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
m0 : MeasurableSpace α
μ : Measure α
s t : Set α
hs : NullMeasurableSet s μ
ht : NullMeasurableSet t μ
hd : AEDisjoint μ s t
⊢ μ (s ∪ t) = μ s + μ t
state_after: case hd
ι : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
m0 : MeasurableSpace α
μ : Measure α
s t : Set α
hs : NullMeasurableSet s μ
ht : NullMeasurableSet t μ
hd : AEDisjoint μ s t
⊢ Pairwise (AEDisjoint μ on fun b => bif b then s else t)

case h
ι : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
m0 : MeasurableSpace α
μ : Measure α
s t : Set α
hs : NullMeasurableSet s μ
ht : NullMeasurableSet t μ
hd : AEDisjoint μ s t
⊢ ∀ (i : Bool), NullMeasurableSet (bif i then s else t) μ
tactic: rw [union_eq_iUnion, measure_iUnion₀, tsum_fintype, Fintype.sum_bool, cond, cond]
state_before: case hd
ι : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
m0 : MeasurableSpace α
μ : Measure α
s t : Set α
hs : NullMeasurableSet s μ
ht : NullMeasurableSet t μ
hd : AEDisjoint μ s t
⊢ Pairwise (AEDisjoint μ on fun b => bif b then s else t)

case h
ι : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
m0 : MeasurableSpace α
μ : Measure α
s t : Set α
hs : NullMeasurableSet s μ
ht : NullMeasurableSet t μ
hd : AEDisjoint μ s t
⊢ ∀ (i : Bool), NullMeasurableSet (bif i then s else t) μ
state_after: no goals
tactic: exacts [(pairwise_on_bool AEDisjoint.symmetric).2 hd, fun b => Bool.casesOn b ht hs]
Theorem: Path.delayReflRight_one
File: Mathlib/Topology/Homotopy/HSpaces.lean

Proof steps:
state_before: X : Type u
inst✝ : TopologicalSpace X
x y : X
γ : Path x y
⊢ delayReflRight 1 γ = γ
state_after: case a.h
X : Type u
inst✝ : TopologicalSpace X
x y : X
γ : Path x y
t : ↑I
⊢ (delayReflRight 1 γ) t = γ t
tactic: ext t
state_before: case a.h
X : Type u
inst✝ : TopologicalSpace X
x y : X
γ : Path x y
t : ↑I
⊢ (delayReflRight 1 γ) t = γ t
state_after: no goals
tactic: exact congr_arg γ (qRight_one_right t)
Theorem: Complex.sinh_sq
File: Mathlib/Data/Complex/Exponential.lean

Proof steps:
state_before: x y : ℂ
⊢ sinh x ^ 2 = cosh x ^ 2 - 1
state_after: x y : ℂ
⊢ sinh x ^ 2 = cosh x ^ 2 - (cosh x ^ 2 - sinh x ^ 2)
tactic: rw [← cosh_sq_sub_sinh_sq x]
state_before: x y : ℂ
⊢ sinh x ^ 2 = cosh x ^ 2 - (cosh x ^ 2 - sinh x ^ 2)
state_after: no goals
tactic: ring
Theorem: Homeomorph.mulRight_symm
File: Mathlib/Topology/Algebra/Group/Basic.lean

Proof steps:
state_before: G : Type w
H : Type x
α : Type u
β : Type v
inst✝² : TopologicalSpace G
inst✝¹ : Group G
inst✝ : ContinuousMul G
a : G
⊢ (Homeomorph.mulRight a).symm = Homeomorph.mulRight a⁻¹
state_after: case H
G : Type w
H : Type x
α : Type u
β : Type v
inst✝² : TopologicalSpace G
inst✝¹ : Group G
inst✝ : ContinuousMul G
a x✝ : G
⊢ (Homeomorph.mulRight a).symm x✝ = (Homeomorph.mulRight a⁻¹) x✝
tactic: ext
state_before: case H
G : Type w
H : Type x
α : Type u
β : Type v
inst✝² : TopologicalSpace G
inst✝¹ : Group G
inst✝ : ContinuousMul G
a x✝ : G
⊢ (Homeomorph.mulRight a).symm x✝ = (Homeomorph.mulRight a⁻¹) x✝
state_after: no goals
tactic: rfl
Theorem: RCLike.pos_iff
File: Mathlib/Analysis/RCLike/Basic.lean

Proof steps:
state_before: K : Type u_1
E : Type u_2
inst✝ : RCLike K
z w : K
⊢ 0 < z ↔ 0 < re z ∧ im z = 0
state_after: no goals
tactic: simpa only [map_zero, eq_comm] using lt_iff_re_im (z := 0) (w := z)