tasksource/leandojo huggingface dataset:
Theorem: Disjoint.exists_cthickenings
File: Mathlib/Topology/MetricSpace/HausdorffDistance.lean

tactic: obtain ⟨δ, hδ, h⟩ := hst.exists_thickenings hs ht
state_before: ι : Sort ?u.135640
α : Type u
β : Type v
inst✝ : PseudoEMetricSpace α
δ ε : ℝ
s t : Set α
x : α
hst : Disjoint s t
hs : IsCompact s
ht : IsClosed t
⊢ ∃ δ, 0 < δ ∧ Disjoint (cthickening δ s) (cthickening δ t)

tactic: refine' ⟨δ / 2, half_pos hδ, h.mono _ _⟩ <;>
  exact cthickening_subset_thickening' hδ (half_lt_self hδ) _
state_before: case intro.intro
ι : Sort ?u.135640
α : Type u
β : Type v
inst✝ : PseudoEMetricSpace α
δ✝ ε : ℝ
s t : Set α
x : α
hst : Disjoint s t
hs : IsCompact s
ht : IsClosed t
δ : ℝ
hδ : 0 < δ
h : Disjoint (thickening δ s) (thickening δ t)
⊢ ∃ δ, 0 < δ ∧ Disjoint (cthickening δ s) (cthickening δ t)
Theorem: Ordinal.cof_sup_le_lift
File: Mathlib/SetTheory/Cardinal/Cofinality.lean

tactic: rw [← sup_eq_lsub_iff_lt_sup.{u, v}] at H
state_before: α : Type ?u.29854
r : α → α → Prop
ι : Type u
f : ι → Ordinal
H : ∀ (i : ι), f i < sup f
⊢ cof (sup f) ≤ Cardinal.lift (#ι)

tactic: rw [H]
state_before: α : Type ?u.29854
r : α → α → Prop
ι : Type u
f : ι → Ordinal
H : (sup fun i => f i) = lsub fun i => f i
⊢ cof (sup f) ≤ Cardinal.lift (#ι)

tactic: exact cof_lsub_le_lift f
state_before: α : Type ?u.29854
r : α → α → Prop
ι : Type u
f : ι → Ordinal
H : (sup fun i => f i) = lsub fun i => f i
⊢ cof (lsub fun i => f i) ≤ Cardinal.lift (#ι)
Theorem: CategoryTheory.shift_shiftFunctorCompIsoId_add_neg_self_inv_app
File: Mathlib/CategoryTheory/Shift/Basic.lean

tactic: apply shift_shiftFunctorCompIsoId_inv_app
state_before: C : Type u
A : Type u_1
inst✝² : Category C
inst✝¹ : AddGroup A
inst✝ : HasShift C A
X✝ Y : C
f : X✝ ⟶ Y
n : A
X : C
⊢ (shiftFunctor C n).map ((shiftFunctorCompIsoId C n (-n) (_ : n + -n = 0)).inv.app X) =
    (shiftFunctorCompIsoId C (-n) n (_ : -n + n = 0)).inv.app ((shiftFunctor C n).obj X)
Theorem: mul_lt_of_one_lt_left
File: Mathlib/Algebra/Order/Ring/Defs.lean

tactic: simpa only [one_mul] using mul_lt_mul_of_neg_right h hb
state_before: α : Type u
β : Type ?u.87941
inst✝ : StrictOrderedRing α
a b c : α
hb : b < 0
h : 1 < a
⊢ a * b < b
Theorem: ZFSet.mem_pairSep
File: Mathlib/SetTheory/ZFC/Basic.lean

tactic: refine' mem_sep.trans ⟨And.right, fun e => ⟨_, e⟩⟩
state_before: p : ZFSet → ZFSet → Prop
x y z : ZFSet
⊢ z ∈ pairSep p x y ↔ ∃ a, a ∈ x ∧ ∃ b, b ∈ y ∧ z = pair a b ∧ p a b

tactic: rcases e with ⟨a, ax, b, bY, rfl, pab⟩
state_before: p : ZFSet → ZFSet → Prop
x y z : ZFSet
e : ∃ a, a ∈ x ∧ ∃ b, b ∈ y ∧ z = pair a b ∧ p a b
⊢ z ∈ powerset (powerset (x ∪ y))

tactic: simp only [mem_powerset, subset_def, mem_union, pair, mem_pair]
state_before: case intro.intro.intro.intro.intro
p : ZFSet → ZFSet → Prop
x y a : ZFSet
ax : a ∈ x
b : ZFSet
bY : b ∈ y
pab : p a b
⊢ pair a b ∈ powerset (powerset (x ∪ y))

tactic: rintro u (rfl | rfl) v <;> simp only [mem_singleton, mem_pair]
state_before: case intro.intro.intro.intro.intro
p : ZFSet → ZFSet → Prop
x y a : ZFSet
ax : a ∈ x
b : ZFSet
bY : b ∈ y
pab : p a b
⊢ ∀ ⦃z : ZFSet⦄, z = {a} ∨ z = {a, b} → ∀ ⦃z_1 : ZFSet⦄, z_1 ∈ z → z_1 ∈ x ∨ z_1 ∈ y

tactic: rintro rfl
state_before: case intro.intro.intro.intro.intro.inl
p : ZFSet → ZFSet → Prop
x y a : ZFSet
ax : a ∈ x
b : ZFSet
bY : b ∈ y
pab : p a b
v : ZFSet
⊢ v = a → v ∈ x ∨ v ∈ y

tactic: exact Or.inl ax
state_before: case intro.intro.intro.intro.intro.inl
p : ZFSet → ZFSet → Prop
x y b : ZFSet
bY : b ∈ y
v : ZFSet
ax : v ∈ x
pab : p v b
⊢ v ∈ x ∨ v ∈ y

tactic: rintro (rfl | rfl) <;> [left; right] <;> assumption
state_before: case intro.intro.intro.intro.intro.inr
p : ZFSet → ZFSet → Prop
x y a : ZFSet
ax : a ∈ x
b : ZFSet
bY : b ∈ y
pab : p a b
v : ZFSet
⊢ v = a ∨ v = b → v ∈ x ∨ v ∈ y
Theorem: Set.abs_sub_le_of_uIcc_subset_uIcc
File: Mathlib/Data/Set/Pointwise/Interval.lean

tactic: rw [← max_sub_min_eq_abs, ← max_sub_min_eq_abs]
state_before: α : Type u_1
inst✝ : LinearOrderedAddCommGroup α
a b c d : α
h : [[c, d]] ⊆ [[a, b]]
⊢ abs (d - c) ≤ abs (b - a)

tactic: rw [uIcc_subset_uIcc_iff_le] at h
state_before: α : Type u_1
inst✝ : LinearOrderedAddCommGroup α
a b c d : α
h : [[c, d]] ⊆ [[a, b]]
⊢ max c d - min c d ≤ max a b - min a b

tactic: exact sub_le_sub h.2 h.1
state_before: α : Type u_1
inst✝ : LinearOrderedAddCommGroup α
a b c d : α
h : min a b ≤ min c d ∧ max c d ≤ max a b
⊢ max c d - min c d ≤ max a b - min a b
Theorem: Set.center_units_subset
File: Mathlib/GroupTheory/Subsemigroup/Center.lean

tactic: obtain rfl | hb := eq_or_ne b 0
state_before: M : Type u_1
inst✝ : GroupWithZero M
a : Mˣ
ha : a ∈ center Mˣ
b : M
⊢ b * ↑a = ↑a * b

tactic: rw [zero_mul, mul_zero]
state_before: case inl
M : Type u_1
inst✝ : GroupWithZero M
a : Mˣ
ha : a ∈ center Mˣ
⊢ 0 * ↑a = ↑a * 0

tactic: exact Units.ext_iff.mp (ha (Units.mk0 _ hb))
state_before: case inr
M : Type u_1
inst✝ : GroupWithZero M
a : Mˣ
ha : a ∈ center Mˣ
b : M
hb : b ≠ 0
⊢ b * ↑a = ↑a * b
Theorem: irreducible_iff_prime_of_exists_prime_factors
File: Mathlib/RingTheory/UniqueFactorizationDomain.lean

tactic: by_cases hp0 : p = 0
state_before: α : Type u_1
inst✝ : CancelCommMonoidWithZero α
pf : ∀ (a : α), a ≠ 0 → ∃ f, (∀ (b : α), b ∈ f → Prime b) ∧ Multiset.prod f ~ᵤ a
p : α
⊢ Irreducible p ↔ Prime p

tactic: refine' ⟨fun h => _, Prime.irreducible⟩
state_before: case neg
α : Type u_1
inst✝ : CancelCommMonoidWithZero α
pf : ∀ (a : α), a ≠ 0 → ∃ f, (∀ (b : α), b ∈ f → Prime b) ∧ Multiset.prod f ~ᵤ a
p : α
hp0 : ¬p = 0
⊢ Irreducible p ↔ Prime p

tactic: obtain ⟨f, hf⟩ := pf p hp0
state_before: case neg
α : Type u_1
inst✝ : CancelCommMonoidWithZero α
pf : ∀ (a : α), a ≠ 0 → ∃ f, (∀ (b : α), b ∈ f → Prime b) ∧ Multiset.prod f ~ᵤ a
p : α
hp0 : ¬p = 0
h : Irreducible p
⊢ Prime p

tactic: obtain ⟨q, hq, rfl⟩ := prime_factors_irreducible h hf
state_before: case neg.intro
α : Type u_1
inst✝ : CancelCommMonoidWithZero α
pf : ∀ (a : α), a ≠ 0 → ∃ f, (∀ (b : α), b ∈ f → Prime b) ∧ Multiset.prod f ~ᵤ a
p : α
hp0 : ¬p = 0
h : Irreducible p
f : Multiset α
hf : (∀ (b : α), b ∈ f → Prime b) ∧ Multiset.prod f ~ᵤ p
⊢ Prime p

tactic: rw [hq.prime_iff]
state_before: case neg.intro.intro.intro
α : Type u_1
inst✝ : CancelCommMonoidWithZero α
pf : ∀ (a : α), a ≠ 0 → ∃ f, (∀ (b : α), b ∈ f → Prime b) ∧ Multiset.prod f ~ᵤ a
p : α
hp0 : ¬p = 0
h : Irreducible p
q : α
hq : p ~ᵤ q
hf : (∀ (b : α), b ∈ {q} → Prime b) ∧ Multiset.prod {q} ~ᵤ p
⊢ Prime p

tactic: exact hf.1 q (Multiset.mem_singleton_self _)
state_before: case neg.intro.intro.intro
α : Type u_1
inst✝ : CancelCommMonoidWithZero α
pf : ∀ (a : α), a ≠ 0 → ∃ f, (∀ (b : α), b ∈ f → Prime b) ∧ Multiset.prod f ~ᵤ a
p : α
hp0 : ¬p = 0
h : Irreducible p
q : α
hq : p ~ᵤ q
hf : (∀ (b : α), b ∈ {q} → Prime b) ∧ Multiset.prod {q} ~ᵤ p
⊢ Prime q

tactic: simp [hp0]
state_before: case pos
α : Type u_1
inst✝ : CancelCommMonoidWithZero α
pf : ∀ (a : α), a ≠ 0 → ∃ f, (∀ (b : α), b ∈ f → Prime b) ∧ Multiset.prod f ~ᵤ a
p : α
hp0 : p = 0
⊢ Irreducible p ↔ Prime p
Theorem: CircleDeg1Lift.map_one_add
File: Mathlib/Dynamics/Circle/RotationNumber/TranslationNumber.lean

tactic: rw [add_comm, map_add_one, add_comm 1]
state_before: f g : CircleDeg1Lift
x : ℝ
⊢ ↑f (1 + x) = 1 + ↑f x
Theorem: ChainComplex.chainComplex_d_succ_succ_zero
File: Mathlib/Algebra/Homology/Augment.lean

tactic: rw [C.shape]
state_before: V : Type u
inst✝¹ : Category V
inst✝ : HasZeroMorphisms V
C : ChainComplex V ℕ
i : ℕ
⊢ d C (i + 2) 0 = 0

tactic: exact i.succ_succ_ne_one.symm
state_before: case a
V : Type u
inst✝¹ : Category V
inst✝ : HasZeroMorphisms V
C : ChainComplex V ℕ
i : ℕ
⊢ ¬ComplexShape.Rel (ComplexShape.down ℕ) (i + 2) 0
Theorem: PowerSeries.coeff_C_mul_X_pow
File: Mathlib/RingTheory/PowerSeries/Basic.lean

tactic: simp [X_pow_eq, coeff_monomial]
state_before: R : Type u_1
inst✝ : Semiring R
x : R
k n : ℕ
⊢ ↑(coeff R n) (↑(C R) x * X ^ k) = if n = k then x else 0
Theorem: Substring.prev_zero
File: Std/Data/String/Lemmas.lean

tactic: simp [prev, Pos.add_eq]
state_before: s : Substring
⊢ prev s 0 = 0
Theorem: summable_norm_sum_mul_range_of_summable_norm
File: Mathlib/Analysis/Normed/Field/InfiniteSum.lean

tactic: simp_rw [← sum_antidiagonal_eq_sum_range_succ fun k l => f k * g l]
state_before: R : Type u_1
ι : Type ?u.10189
ι' : Type ?u.10192
inst✝ : NormedRing R
f g : ℕ → R
hf : Summable fun x => ‖f x‖
hg : Summable fun x => ‖g x‖
⊢ Summable fun n => ‖∑ k in range (n + 1), f k * g (n - k)‖

tactic: exact summable_norm_sum_mul_antidiagonal_of_summable_norm hf hg
state_before: R : Type u_1
ι : Type ?u.10189
ι' : Type ?u.10192
inst✝ : NormedRing R
f g : ℕ → R
hf : Summable fun x => ‖f x‖
hg : Summable fun x => ‖g x‖
⊢ Summable fun n => ‖∑ ij in antidiagonal n, f ij.fst * g ij.snd‖
Theorem: Ordinal.nat_lt_card
File: Mathlib/SetTheory/Ordinal/Basic.lean

tactic: rw [← succ_le_iff, ← succ_le_iff, ← nat_succ, nat_le_card]
state_before: α : Type ?u.236919
β : Type ?u.236922
γ : Type ?u.236925
r : α → α → Prop
s : β → β → Prop
t : γ → γ → Prop
o : Ordinal
n : ℕ
⊢ ↑n < card o ↔ ↑n < o

tactic: rfl
state_before: α : Type ?u.236919
β : Type ?u.236922
γ : Type ?u.236925
r : α → α → Prop
s : β → β → Prop
t : γ → γ → Prop
o : Ordinal
n : ℕ
⊢ ↑(Nat.succ n) ≤ o ↔ succ ↑n ≤ o
Theorem: Nat.div_left_inj
File: Mathlib/Data/Nat/Basic.lean

tactic: refine ⟨fun h => ?_, congr_arg fun n => n / d⟩
state_before: m n k a b d : ℕ
hda : d ∣ a
hdb : d ∣ b
⊢ a / d = b / d ↔ a = b

tactic: rw [← Nat.mul_div_cancel' hda, ← Nat.mul_div_cancel' hdb, h]
state_before: m n k a b d : ℕ
hda : d ∣ a
hdb : d ∣ b
h : a / d = b / d
⊢ a = b
Theorem: Commute.isNilpotent_mul_right
File: Mathlib/RingTheory/Nilpotent.lean

tactic: rw [h_comm.eq]
state_before: R S : Type u
x y : R
inst✝ : Semiring R
h_comm : Commute x y
h : IsNilpotent y
⊢ IsNilpotent (x * y)

tactic: exact h_comm.symm.isNilpotent_mul_left h
state_before: R S : Type u
x y : R
inst✝ : Semiring R
h_comm : Commute x y
h : IsNilpotent y
⊢ IsNilpotent (y * x)
Theorem: one_div_mul_sub_mul_one_div_eq_one_div_add_one_div
File: Mathlib/Algebra/Field/Basic.lean

tactic: rw [mul_sub_left_distrib (1 / a), one_div_mul_cancel ha, mul_sub_right_distrib, one_mul,
  mul_assoc, mul_one_div_cancel hb, mul_one]
state_before: α : Type ?u.42728
β : Type ?u.42731
K : Type u_1
inst✝ : DivisionRing K
a b c d : K
ha : a ≠ 0
hb : b ≠ 0
⊢ 1 / a * (b - a) * (1 / b) = 1 / a - 1 / b
Theorem: Ideal.fg_of_isUnit
File: Mathlib/RingTheory/FractionalIdeal.lean

tactic: rw [← coeIdeal_fg S inj I]
state_before: R : Type u_1
inst✝⁶ : CommRing R
S : Submonoid R
P : Type u_2
inst✝⁵ : CommRing P
inst✝⁴ : Algebra R P
loc : IsLocalization S P
P' : Type ?u.763155
inst✝³ : CommRing P'
inst✝² : Algebra R P'
loc' : IsLocalization S P'
P'' : Type ?u.763608
inst✝¹ : CommRing P''
inst✝ : Algebra R P''
loc'' : IsLocalization S P''
I✝ J : FractionalIdeal S P
g : P →ₐ[R] P'
inj : Function.Injective ↑(algebraMap R P)
I : Ideal R
h : IsUnit ↑I
⊢ Ideal.FG I

tactic: exact FractionalIdeal.fg_of_isUnit I h
state_before: R : Type u_1
inst✝⁶ : CommRing R
S : Submonoid R
P : Type u_2
inst✝⁵ : CommRing P
inst✝⁴ : Algebra R P
loc : IsLocalization S P
P' : Type ?u.763155
inst✝³ : CommRing P'
inst✝² : Algebra R P'
loc' : IsLocalization S P'
P'' : Type ?u.763608
inst✝¹ : CommRing P''
inst✝ : Algebra R P''
loc'' : IsLocalization S P''
I✝ J : FractionalIdeal S P
g : P →ₐ[R] P'
inj : Function.Injective ↑(algebraMap R P)
I : Ideal R
h : IsUnit ↑I
⊢ FG ↑↑I
Theorem: ContDiffBump.sub
File: Mathlib/Analysis/Calculus/BumpFunctionInner.lean

tactic: simp [f.apply, ContDiffBumpBase.symmetric]
state_before: E : Type u_1
X : Type ?u.74038
inst✝⁴ : NormedAddCommGroup E
inst✝³ : NormedSpace ℝ E
inst✝² : NormedAddCommGroup X
inst✝¹ : NormedSpace ℝ X
inst✝ : HasContDiffBump E
c : E
f : ContDiffBump c
x✝ : E
n : ℕ∞
x : E
⊢ ↑f (c - x) = ↑f (c + x)
Theorem: Set.Ioo_union_Ioi'
File: Mathlib/Data/Set/Intervals/Basic.lean

tactic: ext1 x
state_before: α : Type u_1
β : Type ?u.77673
inst✝ : LinearOrder α
a a₁ a₂ b b₁ b₂ c d : α
h₁ : c < b
⊢ Ioo a b ∪ Ioi c = Ioi (min a c)

tactic: simp_rw [mem_union, mem_Ioo, mem_Ioi, min_lt_iff]
state_before: case h
α : Type u_1
β : Type ?u.77673
inst✝ : LinearOrder α
a a₁ a₂ b b₁ b₂ c d : α
h₁ : c < b
x : α
⊢ x ∈ Ioo a b ∪ Ioi c ↔ x ∈ Ioi (min a c)

tactic: by_cases hc : c < x
state_before: case h
α : Type u_1
β : Type ?u.77673
inst✝ : LinearOrder α
a a₁ a₂ b b₁ b₂ c d : α
h₁ : c < b
x : α
⊢ a < x ∧ x < b ∨ c < x ↔ a < x ∨ c < x

tactic: simp only [hc, or_true]
state_before: case pos
α : Type u_1
β : Type ?u.77673
inst✝ : LinearOrder α
a a₁ a₂ b b₁ b₂ c d : α
h₁ : c < b
x : α
hc : c < x
⊢ a < x ∧ x < b ∨ c < x ↔ a < x ∨ c < x

tactic: have hxb : x < b := (le_of_not_gt hc).trans_lt h₁
state_before: case neg
α : Type u_1
β : Type ?u.77673
inst✝ : LinearOrder α
a a₁ a₂ b b₁ b₂ c d : α
h₁ : c < b
x : α
hc : ¬c < x
⊢ a < x ∧ x < b ∨ c < x ↔ a < x ∨ c < x

tactic: simp only [hxb, and_true]
state_before: case neg
α : Type u_1
β : Type ?u.77673
inst✝ : LinearOrder α
a a₁ a₂ b b₁ b₂ c d : α
h₁ : c < b
x : α
hc : ¬c < x
hxb : x < b
⊢ a < x ∧ x < b ∨ c < x ↔ a < x ∨ c < x
Theorem: Ideal.IsRadical.comap
File: Mathlib/RingTheory/Ideal/Operations.lean

tactic: rw [← hK.radical, comap_radical]
state_before: R : Type u
S : Type v
F : Type u_1
inst✝¹ : CommRing R
inst✝ : CommRing S
rc : RingHomClass F R S
f : F
I J : Ideal R
K L : Ideal S
hK : IsRadical K
⊢ IsRadical (Ideal.comap f K)

tactic: apply radical_isRadical
state_before: R : Type u
S : Type v
F : Type u_1
inst✝¹ : CommRing R
inst✝ : CommRing S
rc : RingHomClass F R S
f : F
I J : Ideal R
K L : Ideal S
hK : IsRadical K
⊢ IsRadical (Ideal.radical (Ideal.comap f K))
Theorem: CommGroup.center_eq_top
File: Mathlib/GroupTheory/Subgroup/Basic.lean

tactic: rw [eq_top_iff']
state_before: G✝ : Type ?u.362185
G' : Type ?u.362188
inst✝³ : Group G✝
inst✝² : Group G'
A : Type ?u.362197
inst✝¹ : AddGroup A
H K : Subgroup G✝
G : Type u_1
inst✝ : CommGroup G
⊢ center G = ⊤

tactic: intro x y
state_before: G✝ : Type ?u.362185
G' : Type ?u.362188
inst✝³ : Group G✝
inst✝² : Group G'
A : Type ?u.362197
inst✝¹ : AddGroup A
H K : Subgroup G✝
G : Type u_1
inst✝ : CommGroup G
⊢ ∀ (x : G), x ∈ center G

tactic: exact mul_comm y x
state_before: G✝ : Type ?u.362185
G' : Type ?u.362188
inst✝³ : Group G✝
inst✝² : Group G'
A : Type ?u.362197
inst✝¹ : AddGroup A
H K : Subgroup G✝
G : Type u_1
inst✝ : CommGroup G
x y : G
⊢ y * x = x * y
Theorem: Nat.lt_one_add_iff
File: Mathlib/Data/Nat/Basic.lean

tactic: simp only [add_comm, lt_succ_iff]
state_before: m n k a b : ℕ
⊢ a < 1 + b ↔ a ≤ b
Theorem: infinite_sum
File: Mathlib/Data/Fintype/Sum.lean

tactic: refine' ⟨fun H => _, fun H => H.elim (@Sum.infinite_of_left α β) (@Sum.infinite_of_right α β)⟩
state_before: α : Type u_2
β : Type u_1
⊢ Infinite (α ⊕ β) ↔ Infinite α ∨ Infinite β

tactic: contrapose! H
state_before: α : Type u_2
β : Type u_1
H : Infinite (α ⊕ β)
⊢ Infinite α ∨ Infinite β

tactic: haveI := fintypeOfNotInfinite H.1
state_before: α : Type u_2
β : Type u_1
H : ¬Infinite α ∧ ¬Infinite β
⊢ ¬Infinite (α ⊕ β)

tactic: haveI := fintypeOfNotInfinite H.2
state_before: α : Type u_2
β : Type u_1
H : ¬Infinite α ∧ ¬Infinite β
this : Fintype α
⊢ ¬Infinite (α ⊕ β)

tactic: exact Infinite.false
state_before: α : Type u_2
β : Type u_1
H : ¬Infinite α ∧ ¬Infinite β
this✝ : Fintype α
this : Fintype β
⊢ ¬Infinite (α ⊕ β)
Theorem: clusterPt_iff_not_disjoint
File: Mathlib/Topology/Basic.lean

tactic: rw [disjoint_iff, ClusterPt, neBot_iff]
state_before: α : Type u
β : Type v
ι : Sort w
a : α
s s₁ s₂ t : Set α
p p₁ p₂ : α → Prop
inst✝ : TopologicalSpace α
x : α
F : Filter α
⊢ ClusterPt x F ↔ ¬Disjoint (𝓝 x) F
Theorem: Mathlib.Tactic.Ring.one_mul
File: Mathlib/Tactic/Ring/Basic.lean

tactic: simp [Nat.rawCast]
state_before: u : Lean.Level
R : Type u_1
α : Q(Type u)
sα : Q(CommSemiring «$α»)
inst✝ : CommSemiring R
a : R
⊢ Nat.rawCast 1 * a = a
Theorem: LieModuleHom.coe_injective
File: Mathlib/Algebra/Lie/Basic.lean

tactic: rintro ⟨⟨⟨f, _⟩⟩⟩ ⟨⟨⟨g, _⟩⟩⟩ h
state_before: R : Type u
L : Type v
M : Type w
N : Type w₁
P : Type w₂
inst✝¹⁴ : CommRing R
inst✝¹³ : LieRing L
inst✝¹² : LieAlgebra R L
inst✝¹¹ : AddCommGroup M
inst✝¹⁰ : AddCommGroup N
inst✝⁹ : AddCommGroup P
inst✝⁸ : Module R M
inst✝⁷ : Module R N
inst✝⁶ : Module R P
inst✝⁵ : LieRingModule L M
inst✝⁴ : LieRingModule L N
inst✝³ : LieRingModule L P
inst✝² : LieModule R L M
inst✝¹ : LieModule R L N
inst✝ : LieModule R L P
⊢ Injective FunLike.coe

tactic: congr
state_before: case mk.mk.mk.mk.mk.mk
R : Type u
L : Type v
M : Type w
N : Type w₁
P : Type w₂
inst✝¹⁴ : CommRing R
inst✝¹³ : LieRing L
inst✝¹² : LieAlgebra R L
inst✝¹¹ : AddCommGroup M
inst✝¹⁰ : AddCommGroup N
inst✝⁹ : AddCommGroup P
inst✝⁸ : Module R M
inst✝⁷ : Module R N
inst✝⁶ : Module R P
inst✝⁵ : LieRingModule L M
inst✝⁴ : LieRingModule L N
inst✝³ : LieRingModule L P
inst✝² : LieModule R L M
inst✝¹ : LieModule R L N
inst✝ : LieModule R L P
f : M → N
map_add'✝¹ : ∀ (x y : M), f (x + y) = f x + f y
map_smul'✝¹ :
  ∀ (r : R) (x : M),
    AddHom.toFun { toFun := f, map_add' := map_add'✝¹ } (r • x) =
      ↑(RingHom.id R) r • AddHom.toFun { toFun := f, map_add' := map_add'✝¹ } x
map_lie'✝¹ :
  ∀ {x : L} {m : M},
    AddHom.toFun { toAddHom := { toFun := f, map_add' := map_add'✝¹ }, map_smul' := map_smul'✝¹ }.toAddHom ⁅x, m⁆ =
      ⁅x, AddHom.toFun { toAddHom := { toFun := f, map_add' := map_add'✝¹ }, map_smul' := map_smul'✝¹ }.toAddHom m⁆
g : M → N
map_add'✝ : ∀ (x y : M), g (x + y) = g x + g y
map_smul'✝ :
  ∀ (r : R) (x : M),
    AddHom.toFun { toFun := g, map_add' := map_add'✝ } (r • x) =
      ↑(RingHom.id R) r • AddHom.toFun { toFun := g, map_add' := map_add'✝ } x
map_lie'✝ :
  ∀ {x : L} {m : M},
    AddHom.toFun { toAddHom := { toFun := g, map_add' := map_add'✝ }, map_smul' := map_smul'✝ }.toAddHom ⁅x, m⁆ =
      ⁅x, AddHom.toFun { toAddHom := { toFun := g, map_add' := map_add'✝ }, map_smul' := map_smul'✝ }.toAddHom m⁆
h :
  ↑{ toLinearMap := { toAddHom := { toFun := f, map_add' := map_add'✝¹ }, map_smul' := map_smul'✝¹ },
        map_lie' := map_lie'✝¹ } =
    ↑{ toLinearMap := { toAddHom := { toFun := g, map_add' := map_add'✝ }, map_smul' := map_smul'✝ },
        map_lie' := map_lie'✝ }
⊢ { toLinearMap := { toAddHom := { toFun := f, map_add' := map_add'✝¹ }, map_smul' := map_smul'✝¹ },
      map_lie' := map_lie'✝¹ } =
    { toLinearMap := { toAddHom := { toFun := g, map_add' := map_add'✝ }, map_smul' := map_smul'✝ },
      map_lie' := map_lie'✝ }
Theorem: Ordnode.size_balanceL
File: Mathlib/Data/Ordmap/Ordset.lean

tactic: rw [balanceL_eq_balance' hl hr sl sr H, size_balance' sl sr]
state_before: α : Type u_1
l : Ordnode α
x : α
r : Ordnode α
hl : Balanced l
hr : Balanced r
sl : Sized l
sr : Sized r
H : (∃ l', Raised l' (size l) ∧ BalancedSz l' (size r)) ∨ ∃ r', Raised (size r) r' ∧ BalancedSz (size l) r'
⊢ size (balanceL l x r) = size l + size r + 1
Theorem: Multiset.coe_eq
File: Mathlib/Data/Multiset/Fintype.lean

tactic: cases x
state_before: α : Type u_1
inst✝ : DecidableEq α
m : Multiset α
x y : ToType m
⊢ x.fst = y.fst ↔ x.fst = y.fst

tactic: cases y
state_before: case mk
α : Type u_1
inst✝ : DecidableEq α
m : Multiset α
y : ToType m
fst✝ : α
snd✝ : Fin (count fst✝ m)
⊢ { fst := fst✝, snd := snd✝ }.fst = y.fst ↔ { fst := fst✝, snd := snd✝ }.fst = y.fst

tactic: rfl
state_before: case mk.mk
α : Type u_1
inst✝ : DecidableEq α
m : Multiset α
fst✝¹ : α
snd✝¹ : Fin (count fst✝¹ m)
fst✝ : α
snd✝ : Fin (count fst✝ m)
⊢ { fst := fst✝¹, snd := snd✝¹ }.fst = { fst := fst✝, snd := snd✝ }.fst ↔
    { fst := fst✝¹, snd := snd✝¹ }.fst = { fst := fst✝, snd := snd✝ }.fst
Theorem: Seminorm.absorbent_ball
File: Mathlib/Analysis/Seminorm.lean

tactic: refine' (p.absorbent_ball_zero <| sub_pos.2 hpr).subset fun y hy => _
state_before: R : Type ?u.1242330
R' : Type ?u.1242333
𝕜 : Type u_2
𝕜₂ : Type ?u.1242339
𝕜₃ : Type ?u.1242342
𝕝 : Type ?u.1242345
E : Type u_1
E₂ : Type ?u.1242351
E₃ : Type ?u.1242354
F : Type ?u.1242357
G : Type ?u.1242360
ι : Type ?u.1242363
inst✝² : NormedField 𝕜
inst✝¹ : AddCommGroup E
inst✝ : Module 𝕜 E
p : Seminorm 𝕜 E
A B : Set E
a : 𝕜
r : ℝ
x : E
hpr : ↑p x < r
⊢ Absorbent 𝕜 (ball p x r)

tactic: rw [p.mem_ball_zero] at hy
state_before: R : Type ?u.1242330
R' : Type ?u.1242333
𝕜 : Type u_2
𝕜₂ : Type ?u.1242339
𝕜₃ : Type ?u.1242342
𝕝 : Type ?u.1242345
E : Type u_1
E₂ : Type ?u.1242351
E₃ : Type ?u.1242354
F : Type ?u.1242357
G : Type ?u.1242360
ι : Type ?u.1242363
inst✝² : NormedField 𝕜
inst✝¹ : AddCommGroup E
inst✝ : Module 𝕜 E
p : Seminorm 𝕜 E
A B : Set E
a : 𝕜
r : ℝ
x : E
hpr : ↑p x < r
y : E
hy : y ∈ ball p 0 (r - ↑p x)
⊢ y ∈ ball p x r

tactic: exact p.mem_ball.2 ((map_sub_le_add p _ _).trans_lt <| add_lt_of_lt_sub_right hy)
state_before: R : Type ?u.1242330
R' : Type ?u.1242333
𝕜 : Type u_2
𝕜₂ : Type ?u.1242339
𝕜₃ : Type ?u.1242342
𝕝 : Type ?u.1242345
E : Type u_1
E₂ : Type ?u.1242351
E₃ : Type ?u.1242354
F : Type ?u.1242357
G : Type ?u.1242360
ι : Type ?u.1242363
inst✝² : NormedField 𝕜
inst✝¹ : AddCommGroup E
inst✝ : Module 𝕜 E
p : Seminorm 𝕜 E
A B : Set E
a : 𝕜
r : ℝ
x : E
hpr : ↑p x < r
y : E
hy : ↑p y < r - ↑p x
⊢ y ∈ ball p x r
Theorem: Polynomial.degree_le_degree
File: Mathlib/Data/Polynomial/Degree/Definitions.lean

tactic: by_cases hp : p = 0
state_before: R : Type u
S : Type v
a b c d : R
n m : ℕ
inst✝ : Semiring R
p q r : R[X]
h : coeff q (natDegree p) ≠ 0
⊢ degree p ≤ degree q

tactic: rw [hp]
state_before: case pos
R : Type u
S : Type v
a b c d : R
n m : ℕ
inst✝ : Semiring R
p q r : R[X]
h : coeff q (natDegree p) ≠ 0
hp : p = 0
⊢ degree p ≤ degree q

tactic: exact bot_le
state_before: case pos
R : Type u
S : Type v
a b c d : R
n m : ℕ
inst✝ : Semiring R
p q r : R[X]
h : coeff q (natDegree p) ≠ 0
hp : p = 0
⊢ degree 0 ≤ degree q

tactic: rw [degree_eq_natDegree hp]
state_before: case neg
R : Type u
S : Type v
a b c d : R
n m : ℕ
inst✝ : Semiring R
p q r : R[X]
h : coeff q (natDegree p) ≠ 0
hp : ¬p = 0
⊢ degree p ≤ degree q

tactic: exact le_degree_of_ne_zero h
state_before: case neg
R : Type u
S : Type v
a b c d : R
n m : ℕ
inst✝ : Semiring R
p q r : R[X]
h : coeff q (natDegree p) ≠ 0
hp : ¬p = 0
⊢ ↑(natDegree p) ≤ degree q
Theorem: Filter.compl_mem_comap
File: Mathlib/Order/Filter/Basic.lean

tactic: rw [mem_comap_iff_compl, compl_compl]
state_before: α : Type u
β : Type v
γ : Type w
δ : Type ?u.227630
ι : Sort x
f : α → β
l : Filter β
p : α → Prop
s : Set α
⊢ sᶜ ∈ comap f l ↔ (f '' s)ᶜ ∈ l
Theorem: String.atEnd_of_valid
File: Std/Data/String/Lemmas.lean

tactic: simp [atEnd_iff]
state_before: cs cs' : List Char
⊢ atEnd { data := cs ++ cs' } { byteIdx := utf8Len cs } = true ↔ cs' = []

tactic: cases cs' <;> simp [Pos.le_iff, Nat.lt_add_of_pos_right add_csize_pos]
state_before: cs cs' : List Char
⊢ utf8Len cs + utf8Len cs' ≤ utf8Len cs ↔ cs' = []
Theorem: HasDerivWithinAt.rpow_const
File: Mathlib/Analysis/SpecialFunctions/Pow/Deriv.lean

tactic: convert (hasDerivAt_rpow_const hx).comp_hasDerivWithinAt x hf using 1
state_before: f g : ℝ → ℝ
f' g' x y p : ℝ
s : Set ℝ
hf : HasDerivWithinAt f f' s x
hx : f x ≠ 0 ∨ 1 ≤ p
⊢ HasDerivWithinAt (fun y => f y ^ p) (f' * p * f x ^ (p - 1)) s x

tactic: ring
state_before: case h.e'_7
f g : ℝ → ℝ
f' g' x y p : ℝ
s : Set ℝ
hf : HasDerivWithinAt f f' s x
hx : f x ≠ 0 ∨ 1 ≤ p
⊢ f' * p * f x ^ (p - 1) = p * f x ^ (p - 1) * f'