1337xyz1337xyz/leandojo-benchmark4-v10 huggingface dataset:
Theorem: LieDerivation.leibniz_lie
File: Mathlib/Algebra/Lie/Derivation/Basic.lean

tactic: ext y
state_before: R : Type u_1
L : Type u_2
M : Type u_3
inst✝⁶ : CommRing R
inst✝⁵ : LieRing L
inst✝⁴ : LieAlgebra R L
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : LieRingModule L M
inst✝ : LieModule R L M
x : L
D₁ D₂ : LieDerivation R L L
⊢ ⁅x, ⁅D₁, D₂⁆⁆ = ⁅⁅x, D₁⁆, D₂⁆ + ⁅D₁, ⁅x, D₂⁆⁆
state_after: case H
R : Type u_1
L : Type u_2
M : Type u_3
inst✝⁶ : CommRing R
inst✝⁵ : LieRing L
inst✝⁴ : LieAlgebra R L
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : LieRingModule L M
inst✝ : LieModule R L M
x : L
D₁ D₂ : LieDerivation R L L
y : L
⊢ ⁅x, ⁅D₁, D₂⁆⁆ y = (⁅⁅x, D₁⁆, D₂⁆ + ⁅D₁, ⁅x, D₂⁆⁆) y

tactic: simp [-lie_skew, ← lie_skew (D₁ x) (D₂ y), ← lie_skew (D₂ x) (D₁ y), sub_eq_neg_add]
state_before: case H
R : Type u_1
L : Type u_2
M : Type u_3
inst✝⁶ : CommRing R
inst✝⁵ : LieRing L
inst✝⁴ : LieAlgebra R L
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : LieRingModule L M
inst✝ : LieModule R L M
x : L
D₁ D₂ : LieDerivation R L L
y : L
⊢ ⁅x, ⁅D₁, D₂⁆⁆ y = (⁅⁅x, D₁⁆, D₂⁆ + ⁅D₁, ⁅x, D₂⁆⁆) y
state_after: no goals
Theorem: CategoryTheory.Limits.IsLimit.conePointsIsoOfNatIso_hom_comp
File: Mathlib/CategoryTheory/Limits/IsLimit.lean

tactic: simp
state_before: J : Type u₁
inst✝² : Category.{v₁, u₁} J
K : Type u₂
inst✝¹ : Category.{v₂, u₂} K
C : Type u₃
inst✝ : Category.{v₃, u₃} C
F✝ : J ⥤ C
t✝ : Cone F✝
F G : J ⥤ C
s : Cone F
t : Cone G
P : IsLimit s
Q : IsLimit t
w : F ≅ G
j : J
⊢ (P.conePointsIsoOfNatIso Q w).hom ≫ t.π.app j = s.π.app j ≫ w.hom.app j
state_after: no goals
Theorem: Filter.lift_neBot_iff
File: Mathlib/Order/Filter/Lift.lean

tactic: simp only [neBot_iff, Ne, ← empty_mem_iff_bot, mem_lift_sets hm, not_exists, not_and]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
f f₁ f₂ : Filter α
g g₁ g₂ : Set α → Filter β
hm : Monotone g
⊢ (f.lift g).NeBot ↔ ∀ s ∈ f, (g s).NeBot
state_after: no goals
Theorem: Matrix.cons_mulVec
File: Mathlib/Data/Matrix/Notation.lean

tactic: ext i
state_before: α : Type u
o n m : ℕ
m' : Type uₘ
n' : Type uₙ
o' : Type uₒ
a b : ℕ
inst✝¹ : NonUnitalNonAssocSemiring α
inst✝ : Fintype n'
v : n' → α
A : Fin m → n' → α
w : n' → α
⊢ of (vecCons v A) *ᵥ w = vecCons (v ⬝ᵥ w) (of A *ᵥ w)
state_after: case h
α : Type u
o n m : ℕ
m' : Type uₘ
n' : Type uₙ
o' : Type uₒ
a b : ℕ
inst✝¹ : NonUnitalNonAssocSemiring α
inst✝ : Fintype n'
v : n' → α
A : Fin m → n' → α
w : n' → α
i : Fin m.succ
⊢ (of (vecCons v A) *ᵥ w) i = vecCons (v ⬝ᵥ w) (of A *ᵥ w) i

tactic: refine Fin.cases ?_ ?_ i <;> simp [mulVec]
state_before: case h
α : Type u
o n m : ℕ
m' : Type uₘ
n' : Type uₙ
o' : Type uₒ
a b : ℕ
inst✝¹ : NonUnitalNonAssocSemiring α
inst✝ : Fintype n'
v : n' → α
A : Fin m → n' → α
w : n' → α
i : Fin m.succ
⊢ (of (vecCons v A) *ᵥ w) i = vecCons (v ⬝ᵥ w) (of A *ᵥ w) i
state_after: no goals
Theorem: Real.one_lt_rpow_iff
File: Mathlib/Analysis/SpecialFunctions/Pow/Real.lean

tactic: rcases hx.eq_or_lt with (rfl | hx)
state_before: x y z : ℝ
n : ℕ
hx : 0 ≤ x
⊢ 1 < x ^ y ↔ 1 < x ∧ 0 < y ∨ 0 < x ∧ x < 1 ∧ y < 0
state_after: case inl
y z : ℝ
n : ℕ
hx : 0 ≤ 0
⊢ 1 < 0 ^ y ↔ 1 < 0 ∧ 0 < y ∨ 0 < 0 ∧ 0 < 1 ∧ y < 0

case inr
x y z : ℝ
n : ℕ
hx✝ : 0 ≤ x
hx : 0 < x
⊢ 1 < x ^ y ↔ 1 < x ∧ 0 < y ∨ 0 < x ∧ x < 1 ∧ y < 0

tactic: rcases _root_.em (y = 0) with (rfl | hy) <;> simp [*, lt_irrefl, (zero_lt_one' ℝ).not_lt]
state_before: case inl
y z : ℝ
n : ℕ
hx : 0 ≤ 0
⊢ 1 < 0 ^ y ↔ 1 < 0 ∧ 0 < y ∨ 0 < 0 ∧ 0 < 1 ∧ y < 0
state_after: no goals

tactic: simp [one_lt_rpow_iff_of_pos hx, hx]
state_before: case inr
x y z : ℝ
n : ℕ
hx✝ : 0 ≤ x
hx : 0 < x
⊢ 1 < x ^ y ↔ 1 < x ∧ 0 < y ∨ 0 < x ∧ x < 1 ∧ y < 0
state_after: no goals
Theorem: MeasureTheory.SimpleFunc.le_sup_lintegral
File: Mathlib/MeasureTheory/Function/SimpleFunc.lean

tactic: rw [map_lintegral, map_lintegral]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
m : MeasurableSpace α
μ ν : Measure α
f g : α →ₛ ℝ≥0∞
⊢ (map Prod.fst (f.pair g)).lintegral μ ⊔ (map Prod.snd (f.pair g)).lintegral μ ≤
    ∑ x ∈ (f.pair g).range, (x.1 ⊔ x.2) * μ (↑(f.pair g) ⁻¹' {x})
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
m : MeasurableSpace α
μ ν : Measure α
f g : α →ₛ ℝ≥0∞
⊢ (∑ x ∈ (f.pair g).range, x.1 * μ (↑(f.pair g) ⁻¹' {x})) ⊔ ∑ x ∈ (f.pair g).range, x.2 * μ (↑(f.pair g) ⁻¹' {x}) ≤
    ∑ x ∈ (f.pair g).range, (x.1 ⊔ x.2) * μ (↑(f.pair g) ⁻¹' {x})

tactic: refine sup_le ?_ ?_ <;> refine Finset.sum_le_sum fun a _ => mul_le_mul_right' ?_ _
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
m : MeasurableSpace α
μ ν : Measure α
f g : α →ₛ ℝ≥0∞
⊢ (∑ x ∈ (f.pair g).range, x.1 * μ (↑(f.pair g) ⁻¹' {x})) ⊔ ∑ x ∈ (f.pair g).range, x.2 * μ (↑(f.pair g) ⁻¹' {x}) ≤
    ∑ x ∈ (f.pair g).range, (x.1 ⊔ x.2) * μ (↑(f.pair g) ⁻¹' {x})
state_after: case refine_1
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
m : MeasurableSpace α
μ ν : Measure α
f g : α →ₛ ℝ≥0∞
a : ℝ≥0∞ × ℝ≥0∞
x✝ : a ∈ (f.pair g).range
⊢ a.1 ≤ a.1 ⊔ a.2

case refine_2
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
m : MeasurableSpace α
μ ν : Measure α
f g : α →ₛ ℝ≥0∞
a : ℝ≥0∞ × ℝ≥0∞
x✝ : a ∈ (f.pair g).range
⊢ a.2 ≤ a.1 ⊔ a.2

tactic: exact le_sup_left
state_before: case refine_1
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
m : MeasurableSpace α
μ ν : Measure α
f g : α →ₛ ℝ≥0∞
a : ℝ≥0∞ × ℝ≥0∞
x✝ : a ∈ (f.pair g).range
⊢ a.1 ≤ a.1 ⊔ a.2
state_after: no goals

tactic: exact le_sup_right
state_before: case refine_2
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
m : MeasurableSpace α
μ ν : Measure α
f g : α →ₛ ℝ≥0∞
a : ℝ≥0∞ × ℝ≥0∞
x✝ : a ∈ (f.pair g).range
⊢ a.2 ≤ a.1 ⊔ a.2
state_after: no goals

tactic: rw [sup_eq_map₂, map_lintegral]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
m : MeasurableSpace α
μ ν : Measure α
f g : α →ₛ ℝ≥0∞
⊢ ∑ x ∈ (f.pair g).range, (x.1 ⊔ x.2) * μ (↑(f.pair g) ⁻¹' {x}) = (f ⊔ g).lintegral μ
state_after: no goals
Theorem: IsCompact.le_nhds_of_unique_clusterPt
File: Mathlib/Topology/Compactness/Compact.lean

tactic: refine le_iff_ultrafilter.2 fun f hf ↦ ?_
state_before: X : Type u
Y : Type v
ι : Type u_1
inst✝¹ : TopologicalSpace X
inst✝ : TopologicalSpace Y
s t : Set X
hs : IsCompact s
l : Filter X
y : X
hmem : s ∈ l
h : ∀ x ∈ s, ClusterPt x l → x = y
⊢ l ≤ 𝓝 y
state_after: X : Type u
Y : Type v
ι : Type u_1
inst✝¹ : TopologicalSpace X
inst✝ : TopologicalSpace Y
s t : Set X
hs : IsCompact s
l : Filter X
y : X
hmem : s ∈ l
h : ∀ x ∈ s, ClusterPt x l → x = y
f : Ultrafilter X
hf : ↑f ≤ l
⊢ ↑f ≤ 𝓝 y

tactic: rcases hs.ultrafilter_le_nhds' f (hf hmem) with ⟨x, hxs, hx⟩
state_before: X : Type u
Y : Type v
ι : Type u_1
inst✝¹ : TopologicalSpace X
inst✝ : TopologicalSpace Y
s t : Set X
hs : IsCompact s
l : Filter X
y : X
hmem : s ∈ l
h : ∀ x ∈ s, ClusterPt x l → x = y
f : Ultrafilter X
hf : ↑f ≤ l
⊢ ↑f ≤ 𝓝 y
state_after: case intro.intro
X : Type u
Y : Type v
ι : Type u_1
inst✝¹ : TopologicalSpace X
inst✝ : TopologicalSpace Y
s t : Set X
hs : IsCompact s
l : Filter X
y : X
hmem : s ∈ l
h : ∀ x ∈ s, ClusterPt x l → x = y
f : Ultrafilter X
hf : ↑f ≤ l
x : X
hxs : x ∈ s
hx : ↑f ≤ 𝓝 x
⊢ ↑f ≤ 𝓝 y

tactic: convert ← hx
state_before: case intro.intro
X : Type u
Y : Type v
ι : Type u_1
inst✝¹ : TopologicalSpace X
inst✝ : TopologicalSpace Y
s t : Set X
hs : IsCompact s
l : Filter X
y : X
hmem : s ∈ l
h : ∀ x ∈ s, ClusterPt x l → x = y
f : Ultrafilter X
hf : ↑f ≤ l
x : X
hxs : x ∈ s
hx : ↑f ≤ 𝓝 x
⊢ ↑f ≤ 𝓝 y
state_after: case h.e'_4.h.e'_3
X : Type u
Y : Type v
ι : Type u_1
inst✝¹ : TopologicalSpace X
inst✝ : TopologicalSpace Y
s t : Set X
hs : IsCompact s
l : Filter X
y : X
hmem : s ∈ l
h : ∀ x ∈ s, ClusterPt x l → x = y
f : Ultrafilter X
hf : ↑f ≤ l
x : X
hxs : x ∈ s
hx : ↑f ≤ 𝓝 x
⊢ x = y

tactic: exact h x hxs (.mono (.of_le_nhds hx) hf)
state_before: case h.e'_4.h.e'_3
X : Type u
Y : Type v
ι : Type u_1
inst✝¹ : TopologicalSpace X
inst✝ : TopologicalSpace Y
s t : Set X
hs : IsCompact s
l : Filter X
y : X
hmem : s ∈ l
h : ∀ x ∈ s, ClusterPt x l → x = y
f : Ultrafilter X
hf : ↑f ≤ l
x : X
hxs : x ∈ s
hx : ↑f ≤ 𝓝 x
⊢ x = y
state_after: no goals
Theorem: ValuationSubring.nonunits_le_nonunits
File: Mathlib/RingTheory/Valuation/ValuationSubring.lean

tactic: constructor
state_before: K : Type u
inst✝ : Field K
A✝ A B : ValuationSubring K
⊢ B.nonunits ≤ A.nonunits ↔ A ≤ B
state_after: case mp
K : Type u
inst✝ : Field K
A✝ A B : ValuationSubring K
⊢ B.nonunits ≤ A.nonunits → A ≤ B

case mpr
K : Type u
inst✝ : Field K
A✝ A B : ValuationSubring K
⊢ A ≤ B → B.nonunits ≤ A.nonunits

tactic: intro h x hx
state_before: case mp
K : Type u
inst✝ : Field K
A✝ A B : ValuationSubring K
⊢ B.nonunits ≤ A.nonunits → A ≤ B
state_after: case mp
K : Type u
inst✝ : Field K
A✝ A B : ValuationSubring K
h : B.nonunits ≤ A.nonunits
x : K
hx : x ∈ A
⊢ x ∈ B

tactic: by_cases h_1 : x = 0
state_before: case mp
K : Type u
inst✝ : Field K
A✝ A B : ValuationSubring K
h : B.nonunits ≤ A.nonunits
x : K
hx : x ∈ A
⊢ x ∈ B
state_after: case pos
K : Type u
inst✝ : Field K
A✝ A B : ValuationSubring K
h : B.nonunits ≤ A.nonunits
x : K
hx : x ∈ A
h_1 : x = 0
⊢ x ∈ B

case neg
K : Type u
inst✝ : Field K
A✝ A B : ValuationSubring K
h : B.nonunits ≤ A.nonunits
x : K
hx : x ∈ A
h_1 : ¬x = 0
⊢ x ∈ B

tactic: rw [← valuation_le_one_iff, ← not_lt, Valuation.one_lt_val_iff _ h_1] at hx ⊢
state_before: case neg
K : Type u
inst✝ : Field K
A✝ A B : ValuationSubring K
h : B.nonunits ≤ A.nonunits
x : K
hx : x ∈ A
h_1 : ¬x = 0
⊢ x ∈ B
state_after: case neg
K : Type u
inst✝ : Field K
A✝ A B : ValuationSubring K
h : B.nonunits ≤ A.nonunits
x : K
hx : ¬A.valuation x⁻¹ < 1
h_1 : ¬x = 0
⊢ ¬B.valuation x⁻¹ < 1

tactic: by_contra h_2
state_before: case neg
K : Type u
inst✝ : Field K
A✝ A B : ValuationSubring K
h : B.nonunits ≤ A.nonunits
x : K
hx : ¬A.valuation x⁻¹ < 1
h_1 : ¬x = 0
⊢ ¬B.valuation x⁻¹ < 1
state_after: case neg
K : Type u
inst✝ : Field K
A✝ A B : ValuationSubring K
h : B.nonunits ≤ A.nonunits
x : K
hx : ¬A.valuation x⁻¹ < 1
h_1 : ¬x = 0
h_2 : B.valuation x⁻¹ < 1
⊢ False

tactic: exact hx (h h_2)
state_before: case neg
K : Type u
inst✝ : Field K
A✝ A B : ValuationSubring K
h : B.nonunits ≤ A.nonunits
x : K
hx : ¬A.valuation x⁻¹ < 1
h_1 : ¬x = 0
h_2 : B.valuation x⁻¹ < 1
⊢ False
state_after: no goals

tactic: simp only [h_1, zero_mem]
state_before: case pos
K : Type u
inst✝ : Field K
A✝ A B : ValuationSubring K
h : B.nonunits ≤ A.nonunits
x : K
hx : x ∈ A
h_1 : x = 0
⊢ x ∈ B
state_after: no goals

tactic: intro h x hx
state_before: case mpr
K : Type u
inst✝ : Field K
A✝ A B : ValuationSubring K
⊢ A ≤ B → B.nonunits ≤ A.nonunits
state_after: case mpr
K : Type u
inst✝ : Field K
A✝ A B : ValuationSubring K
h : A ≤ B
x : K
hx : x ∈ B.nonunits
⊢ x ∈ A.nonunits

tactic: by_contra h_1
state_before: case mpr
K : Type u
inst✝ : Field K
A✝ A B : ValuationSubring K
h : A ≤ B
x : K
hx : x ∈ B.nonunits
⊢ x ∈ A.nonunits
state_after: case mpr
K : Type u
inst✝ : Field K
A✝ A B : ValuationSubring K
h : A ≤ B
x : K
hx : x ∈ B.nonunits
h_1 : x ∉ A.nonunits
⊢ False

tactic: exact not_lt.2 (monotone_mapOfLE _ _ h (not_lt.1 h_1)) hx
state_before: case mpr
K : Type u
inst✝ : Field K
A✝ A B : ValuationSubring K
h : A ≤ B
x : K
hx : x ∈ B.nonunits
h_1 : x ∉ A.nonunits
⊢ False
state_after: no goals
Theorem: Nat.eq_of_dvd_of_lt_two_mul
File: Mathlib/Data/Nat/Defs.lean

tactic: obtain ⟨_ | _ | c, rfl⟩ := hdvd
state_before: a b c d m n k : ℕ
p q : ℕ → Prop
ha : a ≠ 0
hdvd : b ∣ a
hlt : a < 2 * b
⊢ a = b
state_after: case intro.zero
b c d m n k : ℕ
p q : ℕ → Prop
ha : b * 0 ≠ 0
hlt : b * 0 < 2 * b
⊢ b * 0 = b

case intro.succ.zero
b c d m n k : ℕ
p q : ℕ → Prop
ha : b * (0 + 1) ≠ 0
hlt : b * (0 + 1) < 2 * b
⊢ b * (0 + 1) = b

case intro.succ.succ
b c✝ d m n k : ℕ
p q : ℕ → Prop
c : ℕ
ha : b * (c + 1 + 1) ≠ 0
hlt : b * (c + 1 + 1) < 2 * b
⊢ b * (c + 1 + 1) = b

tactic: simp at ha
state_before: case intro.zero
b c d m n k : ℕ
p q : ℕ → Prop
ha : b * 0 ≠ 0
hlt : b * 0 < 2 * b
⊢ b * 0 = b
state_after: no goals

tactic: exact Nat.mul_one _
state_before: case intro.succ.zero
b c d m n k : ℕ
p q : ℕ → Prop
ha : b * (0 + 1) ≠ 0
hlt : b * (0 + 1) < 2 * b
⊢ b * (0 + 1) = b
state_after: no goals

tactic: rw [Nat.mul_comm] at hlt
state_before: case intro.succ.succ
b c✝ d m n k : ℕ
p q : ℕ → Prop
c : ℕ
ha : b * (c + 1 + 1) ≠ 0
hlt : b * (c + 1 + 1) < 2 * b
⊢ b * (c + 1 + 1) = b
state_after: case intro.succ.succ
b c✝ d m n k : ℕ
p q : ℕ → Prop
c : ℕ
ha : b * (c + 1 + 1) ≠ 0
hlt : (c + 1 + 1) * b < 2 * b
⊢ b * (c + 1 + 1) = b

tactic: cases Nat.not_le_of_lt hlt (Nat.mul_le_mul_right _ (by omega))
state_before: case intro.succ.succ
b c✝ d m n k : ℕ
p q : ℕ → Prop
c : ℕ
ha : b * (c + 1 + 1) ≠ 0
hlt : (c + 1 + 1) * b < 2 * b
⊢ b * (c + 1 + 1) = b
state_after: no goals

tactic: omega
state_before: b c✝ d m n k : ℕ
p q : ℕ → Prop
c : ℕ
ha : b * (c + 1 + 1) ≠ 0
hlt : (c + 1 + 1) * b < 2 * b
⊢ 2 ≤ c + 1 + 1
state_after: no goals
Theorem: List.IsRotated.trans
File: Mathlib/Data/List/Rotate.lean

tactic: rw [rotate_rotate]
state_before: α : Type u
l l' l✝ : List α
n m : ℕ
⊢ l✝.rotate (n + m) = (l✝.rotate n).rotate m
state_after: no goals
Theorem: torusMap_eq_center_iff
File: Mathlib/MeasureTheory/Integral/TorusIntegral.lean

tactic: simp [funext_iff, torusMap, exp_ne_zero]
state_before: n : ℕ
E : Type u_1
inst✝ : NormedAddCommGroup E
c : Fin n → ℂ
R θ : Fin n → ℝ
⊢ torusMap c R θ = c ↔ R = 0
state_after: no goals
Theorem: continuousAt_update_same
File: Mathlib/Topology/ContinuousOn.lean

tactic: rw [← continuousWithinAt_univ, continuousWithinAt_update_same, compl_eq_univ_diff]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝⁵ : TopologicalSpace α
ι : Type u_5
π : ι → Type u_6
inst✝⁴ : (i : ι) → TopologicalSpace (π i)
inst✝³ : TopologicalSpace β
inst✝² : TopologicalSpace γ
inst✝¹ : TopologicalSpace δ
inst✝ : DecidableEq α
f : α → β
x : α
y : β
⊢ ContinuousAt (update f x y) x ↔ Tendsto f (𝓝[≠] x) (𝓝 y)
state_after: no goals
Theorem: CategoryTheory.exact_comp_mono
File: Mathlib/Algebra/Homology/Exact.lean

tactic: refine ⟨by simp [hfg.w_assoc], ?_⟩
state_before: V : Type u
inst✝⁴ : Category.{v, u} V
inst✝³ : HasImages V
A B C D : V
f : A ⟶ B
g : B ⟶ C
h : C ⟶ D
inst✝² : HasZeroMorphisms V
inst✝¹ : HasEqualizers V
hfg : Exact f g
inst✝ : Mono h
⊢ Exact f (g ≫ h)
state_after: V : Type u
inst✝⁴ : Category.{v, u} V
inst✝³ : HasImages V
A B C D : V
f : A ⟶ B
g : B ⟶ C
h : C ⟶ D
inst✝² : HasZeroMorphisms V
inst✝¹ : HasEqualizers V
hfg : Exact f g
inst✝ : Mono h
⊢ Epi (imageToKernel f (g ≫ h) ⋯)

tactic: rw [imageToKernel_comp_right f g h hfg.w]
state_before: V : Type u
inst✝⁴ : Category.{v, u} V
inst✝³ : HasImages V
A B C D : V
f : A ⟶ B
g : B ⟶ C
h : C ⟶ D
inst✝² : HasZeroMorphisms V
inst✝¹ : HasEqualizers V
hfg : Exact f g
inst✝ : Mono h
⊢ Epi (imageToKernel f (g ≫ h) ⋯)
state_after: V : Type u
inst✝⁴ : Category.{v, u} V
inst✝³ : HasImages V
A B C D : V
f : A ⟶ B
g : B ⟶ C
h : C ⟶ D
inst✝² : HasZeroMorphisms V
inst✝¹ : HasEqualizers V
hfg : Exact f g
inst✝ : Mono h
⊢ Epi (imageToKernel f g ⋯ ≫ (kernelSubobject g).ofLE (kernelSubobject (g ≫ h)) ⋯)

tactic: haveI := hfg.epi
state_before: V : Type u
inst✝⁴ : Category.{v, u} V
inst✝³ : HasImages V
A B C D : V
f : A ⟶ B
g : B ⟶ C
h : C ⟶ D
inst✝² : HasZeroMorphisms V
inst✝¹ : HasEqualizers V
hfg : Exact f g
inst✝ : Mono h
⊢ Epi (imageToKernel f g ⋯ ≫ (kernelSubobject g).ofLE (kernelSubobject (g ≫ h)) ⋯)
state_after: V : Type u
inst✝⁴ : Category.{v, u} V
inst✝³ : HasImages V
A B C D : V
f : A ⟶ B
g : B ⟶ C
h : C ⟶ D
inst✝² : HasZeroMorphisms V
inst✝¹ : HasEqualizers V
hfg : Exact f g
inst✝ : Mono h
this : Epi (imageToKernel f g ⋯)
⊢ Epi (imageToKernel f g ⋯ ≫ (kernelSubobject g).ofLE (kernelSubobject (g ≫ h)) ⋯)

tactic: infer_instance
state_before: V : Type u
inst✝⁴ : Category.{v, u} V
inst✝³ : HasImages V
A B C D : V
f : A ⟶ B
g : B ⟶ C
h : C ⟶ D
inst✝² : HasZeroMorphisms V
inst✝¹ : HasEqualizers V
hfg : Exact f g
inst✝ : Mono h
this : Epi (imageToKernel f g ⋯)
⊢ Epi (imageToKernel f g ⋯ ≫ (kernelSubobject g).ofLE (kernelSubobject (g ≫ h)) ⋯)
state_after: no goals

tactic: simp [hfg.w_assoc]
state_before: V : Type u
inst✝⁴ : Category.{v, u} V
inst✝³ : HasImages V
A B C D : V
f : A ⟶ B
g : B ⟶ C
h : C ⟶ D
inst✝² : HasZeroMorphisms V
inst✝¹ : HasEqualizers V
hfg : Exact f g
inst✝ : Mono h
⊢ f ≫ g ≫ h = 0
state_after: no goals
Theorem: Ordinal.lt_nmul_iff
File: Mathlib/SetTheory/Ordinal/NaturalOps.lean

tactic: refine ⟨fun h => ?_, ?_⟩
state_before: a b c d : Ordinal.{u}
⊢ c < a ⨳ b ↔ ∃ a' < a, ∃ b' < b, c ♯ a' ⨳ b' ≤ a' ⨳ b ♯ a ⨳ b'
state_after: case refine_1
a b c d : Ordinal.{u}
h : c < a ⨳ b
⊢ ∃ a' < a, ∃ b' < b, c ♯ a' ⨳ b' ≤ a' ⨳ b ♯ a ⨳ b'

case refine_2
a b c d : Ordinal.{u}
⊢ (∃ a' < a, ∃ b' < b, c ♯ a' ⨳ b' ≤ a' ⨳ b ♯ a ⨳ b') → c < a ⨳ b

tactic: rw [nmul] at h
state_before: case refine_1
a b c d : Ordinal.{u}
h : c < a ⨳ b
⊢ ∃ a' < a, ∃ b' < b, c ♯ a' ⨳ b' ≤ a' ⨳ b ♯ a ⨳ b'
state_after: case refine_1
a b c d : Ordinal.{u}
h : c < sInf {c | ∀ a' < a, ∀ b' < b, a' ⨳ b ♯ a ⨳ b' < c ♯ a' ⨳ b'}
⊢ ∃ a' < a, ∃ b' < b, c ♯ a' ⨳ b' ≤ a' ⨳ b ♯ a ⨳ b'

tactic: simpa using not_mem_of_lt_csInf h ⟨0, fun _ _ => bot_le⟩
state_before: case refine_1
a b c d : Ordinal.{u}
h : c < sInf {c | ∀ a' < a, ∀ b' < b, a' ⨳ b ♯ a ⨳ b' < c ♯ a' ⨳ b'}
⊢ ∃ a' < a, ∃ b' < b, c ♯ a' ⨳ b' ≤ a' ⨳ b ♯ a ⨳ b'
state_after: no goals

tactic: rintro ⟨a', ha, b', hb, h⟩
state_before: case refine_2
a b c d : Ordinal.{u}
⊢ (∃ a' < a, ∃ b' < b, c ♯ a' ⨳ b' ≤ a' ⨳ b ♯ a ⨳ b') → c < a ⨳ b
state_after: case refine_2.intro.intro.intro.intro
a b c d a' : Ordinal.{u}
ha : a' < a
b' : Ordinal.{u}
hb : b' < b
h : c ♯ a' ⨳ b' ≤ a' ⨳ b ♯ a ⨳ b'
⊢ c < a ⨳ b

tactic: have := h.trans_lt (nmul_nadd_lt ha hb)
state_before: case refine_2.intro.intro.intro.intro
a b c d a' : Ordinal.{u}
ha : a' < a
b' : Ordinal.{u}
hb : b' < b
h : c ♯ a' ⨳ b' ≤ a' ⨳ b ♯ a ⨳ b'
⊢ c < a ⨳ b
state_after: case refine_2.intro.intro.intro.intro
a b c d a' : Ordinal.{u}
ha : a' < a
b' : Ordinal.{u}
hb : b' < b
h : c ♯ a' ⨳ b' ≤ a' ⨳ b ♯ a ⨳ b'
this : c ♯ a' ⨳ b' < a ⨳ b ♯ a' ⨳ b'
⊢ c < a ⨳ b

tactic: rwa [nadd_lt_nadd_iff_right] at this
state_before: case refine_2.intro.intro.intro.intro
a b c d a' : Ordinal.{u}
ha : a' < a
b' : Ordinal.{u}
hb : b' < b
h : c ♯ a' ⨳ b' ≤ a' ⨳ b ♯ a ⨳ b'
this : c ♯ a' ⨳ b' < a ⨳ b ♯ a' ⨳ b'
⊢ c < a ⨳ b
state_after: no goals
Theorem: Order.mem_range_succ_of_not_isSuccLimit
File: Mathlib/Order/SuccPred/Limit.lean

tactic: cases' not_isSuccLimit_iff.1 h with b hb
state_before: α : Type u_1
inst✝¹ : PartialOrder α
inst✝ : SuccOrder α
a b : α
C : α → Sort u_2
h : ¬IsSuccLimit a
⊢ a ∈ range succ
state_after: case intro
α : Type u_1
inst✝¹ : PartialOrder α
inst✝ : SuccOrder α
a b✝ : α
C : α → Sort u_2
h : ¬IsSuccLimit a
b : α
hb : ¬IsMax b ∧ succ b = a
⊢ a ∈ range succ

tactic: exact ⟨b, hb.2⟩
state_before: case intro
α : Type u_1
inst✝¹ : PartialOrder α
inst✝ : SuccOrder α
a b✝ : α
C : α → Sort u_2
h : ¬IsSuccLimit a
b : α
hb : ¬IsMax b ∧ succ b = a
⊢ a ∈ range succ
state_after: no goals
Theorem: Multiset.cons_bind
File: Mathlib/Data/Multiset/Bind.lean

tactic: simp [bind]
state_before: α : Type u_1
β : Type v
γ : Type u_2
δ : Type u_3
a : α
s t : Multiset α
f g : α → Multiset β
⊢ (a ::ₘ s).bind f = f a + s.bind f
state_after: no goals
Theorem: CoxeterSystem.lengthParity_eq_ofAdd_length
File: Mathlib/GroupTheory/Coxeter/Length.lean

tactic: rcases cs.exists_reduced_word w with ⟨ω, hω, rfl⟩
state_before: B : Type u_1
W : Type u_2
inst✝ : Group W
M : CoxeterMatrix B
cs : CoxeterSystem M W
w : W
⊢ cs.lengthParity w = Multiplicative.ofAdd ↑(cs.length w)
state_after: case intro.intro
B : Type u_1
W : Type u_2
inst✝ : Group W
M : CoxeterMatrix B
cs : CoxeterSystem M W
ω : List B
hω : ω.length = cs.length (cs.wordProd ω)
⊢ cs.lengthParity (cs.wordProd ω) = Multiplicative.ofAdd ↑(cs.length (cs.wordProd ω))

tactic: rw [← hω, wordProd, map_list_prod, List.map_map, lengthParity_comp_simple, map_const',
  prod_replicate, ← ofAdd_nsmul, nsmul_one]
state_before: case intro.intro
B : Type u_1
W : Type u_2
inst✝ : Group W
M : CoxeterMatrix B
cs : CoxeterSystem M W
ω : List B
hω : ω.length = cs.length (cs.wordProd ω)
⊢ cs.lengthParity (cs.wordProd ω) = Multiplicative.ofAdd ↑(cs.length (cs.wordProd ω))
state_after: no goals
Theorem: OreLocalization.universalMulHom_commutes
File: Mathlib/RingTheory/OreLocalization/Basic.lean

tactic: simp [numeratorHom_apply, universalMulHom_apply]
state_before: R : Type u_1
inst✝³ : Monoid R
S : Submonoid R
inst✝² : OreSet S
X : Type ?u.142189
inst✝¹ : MulAction R X
T : Type u_2
inst✝ : Monoid T
f : R →* T
fS : ↥S →* Tˣ
hf : ∀ (s : ↥S), f ↑s = ↑(fS s)
r : R
⊢ (universalMulHom f fS hf) (numeratorHom r) = f r
state_after: no goals
Theorem: PartialEquiv.EqOnSource.source_inter_preimage_eq
File: Mathlib/Logic/Equiv/PartialEquiv.lean

tactic: rw [he.eqOn.inter_preimage_eq, source_eq he]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
e✝ : PartialEquiv α β
e'✝ : PartialEquiv β γ
e e' : PartialEquiv α β
he : e ≈ e'
s : Set β
⊢ e.source ∩ ↑e ⁻¹' s = e'.source ∩ ↑e' ⁻¹' s
state_after: no goals
Theorem: Filter.Eventually.ratCast_atTop
File: Mathlib/Order/Filter/Archimedean.lean

tactic: rw [← Rat.comap_cast_atTop (R := R)]
state_before: α : Type u_1
R : Type u_2
inst✝¹ : LinearOrderedField R
inst✝ : Archimedean R
p : R → Prop
h : ∀ᶠ (x : R) in atTop, p x
⊢ ∀ᶠ (n : ℚ) in atTop, p ↑n
state_after: α : Type u_1
R : Type u_2
inst✝¹ : LinearOrderedField R
inst✝ : Archimedean R
p : R → Prop
h : ∀ᶠ (x : R) in atTop, p x
⊢ ∀ᶠ (n : ℚ) in Filter.comap Rat.cast atTop, p ↑n

tactic: exact h.comap _
state_before: α : Type u_1
R : Type u_2
inst✝¹ : LinearOrderedField R
inst✝ : Archimedean R
p : R → Prop
h : ∀ᶠ (x : R) in atTop, p x
⊢ ∀ᶠ (n : ℚ) in Filter.comap Rat.cast atTop, p ↑n
state_after: no goals
Theorem: SzemerediRegularity.abs_density_star_sub_density_le_eps
File: Mathlib/Combinatorics/SimpleGraph/Regularity/Chunk.lean

tactic: convert abs_edgeDensity_sub_edgeDensity_le_two_mul G.Adj
  (biUnion_star_subset_nonuniformWitness hP G ε hU V)
  (biUnion_star_subset_nonuniformWitness hP G ε hV U) (by sz_positivity)
  (one_sub_eps_mul_card_nonuniformWitness_le_card_star hV hUV' hUV hPε hε₁)
  (one_sub_eps_mul_card_nonuniformWitness_le_card_star hU hUV'.symm (fun hVU => hUV hVU.symm)
    hPε hε₁) using 1
state_before: α : Type u_1
inst✝² : Fintype α
inst✝¹ : DecidableEq α
P : Finpartition univ
hP : P.IsEquipartition
G : SimpleGraph α
inst✝ : DecidableRel G.Adj
ε : ℝ
U : Finset α
hU✝ : U ∈ P.parts
V : Finset α
𝒜 : Finset (Finset α)
s : Finset α
hPε : 100 ≤ 4 ^ P.parts.card * ε ^ 5
hε₁ : ε ≤ 1
hU : U ∈ P.parts
hV : V ∈ P.parts
hUV' : U ≠ V
hUV : ¬G.IsUniform ε U V
⊢ |↑(G.edgeDensity ((star hP G ε hU V).biUnion id) ((star hP G ε hV U).biUnion id)) -
        ↑(G.edgeDensity (G.nonuniformWitness ε U V) (G.nonuniformWitness ε V U))| ≤
    ε / 5
state_after: case h.e'_4
α : Type u_1
inst✝² : Fintype α
inst✝¹ : DecidableEq α
P : Finpartition univ
hP : P.IsEquipartition
G : SimpleGraph α
inst✝ : DecidableRel G.Adj
ε : ℝ
U : Finset α
hU✝ : U ∈ P.parts
V : Finset α
𝒜 : Finset (Finset α)
s : Finset α
hPε : 100 ≤ 4 ^ P.parts.card * ε ^ 5
hε₁ : ε ≤ 1
hU : U ∈ P.parts
hV : V ∈ P.parts
hUV' : U ≠ V
hUV : ¬G.IsUniform ε U V
⊢ ε / 5 = 2 * (ε / 10)

tactic: linarith
state_before: case h.e'_4
α : Type u_1
inst✝² : Fintype α
inst✝¹ : DecidableEq α
P : Finpartition univ
hP : P.IsEquipartition
G : SimpleGraph α
inst✝ : DecidableRel G.Adj
ε : ℝ
U : Finset α
hU✝ : U ∈ P.parts
V : Finset α
𝒜 : Finset (Finset α)
s : Finset α
hPε : 100 ≤ 4 ^ P.parts.card * ε ^ 5
hε₁ : ε ≤ 1
hU : U ∈ P.parts
hV : V ∈ P.parts
hUV' : U ≠ V
hUV : ¬G.IsUniform ε U V
⊢ ε / 5 = 2 * (ε / 10)
state_after: no goals

tactic: sz_positivity
state_before: α : Type u_1
inst✝² : Fintype α
inst✝¹ : DecidableEq α
P : Finpartition univ
hP : P.IsEquipartition
G : SimpleGraph α
inst✝ : DecidableRel G.Adj
ε : ℝ
U : Finset α
hU✝ : U ∈ P.parts
V : Finset α
𝒜 : Finset (Finset α)
s : Finset α
hPε : 100 ≤ 4 ^ P.parts.card * ε ^ 5
hε₁ : ε ≤ 1
hU : U ∈ P.parts
hV : V ∈ P.parts
hUV' : U ≠ V
hUV : ¬G.IsUniform ε U V
⊢ 0 ≤ ε / 10
state_after: no goals