tasksource/leandojo huggingface dataset:
Theorem: inv_le_iff_one_le_mul
File: Mathlib/Algebra/Order/Group/Defs.lean

tactic: rw [inv_mul_self]
state_before: α : Type u
inst✝² : Group α
inst✝¹ : LE α
inst✝ : CovariantClass α α (swap fun x x_1 => x * x_1) fun x x_1 => x ≤ x_1
a b c : α
⊢ a⁻¹ * a ≤ b * a ↔ 1 ≤ b * a
Theorem: Multiset.one_le_count_iff_mem
File: Mathlib/Data/Multiset/Basic.lean

tactic: rw [succ_le_iff, count_pos]
state_before: α : Type u_1
β : Type ?u.358132
γ : Type ?u.358135
inst✝ : DecidableEq α
a : α
s : Multiset α
⊢ 1 ≤ count a s ↔ a ∈ s
Theorem: Complex.cos_pi_div_two
File: Mathlib/Analysis/SpecialFunctions/Trigonometric/Basic.lean

tactic: rw [ofReal_cos]
state_before: ⊢ cos (↑π / 2) = ↑(Real.cos (π / 2))

tactic: simp
state_before: ⊢ cos (↑π / 2) = cos ↑(π / 2)

tactic: simp
state_before: ⊢ ↑(Real.cos (π / 2)) = 0
Theorem: Nat.le_and_le_add_one_iff
File: Mathlib/Data/Nat/Order/Basic.lean

tactic: rw [le_add_one_iff, and_or_left, ← le_antisymm_iff, eq_comm, and_iff_right_of_imp]
state_before: m n k l : ℕ
⊢ n ≤ m ∧ m ≤ n + 1 ↔ m = n ∨ m = n + 1

tactic: rintro rfl
state_before: m n k l : ℕ
⊢ m = n + 1 → n ≤ m

tactic: exact n.le_succ
state_before: n k l : ℕ
⊢ n ≤ n + 1
Theorem: CategoryTheory.Limits.colimit.pre_post
File: Mathlib/CategoryTheory/Limits/HasLimits.lean

tactic: ext j
state_before: J : Type u₁
inst✝⁶ : Category J
K : Type u₂
inst✝⁵ : Category K
C : Type u
inst✝⁴ : Category C
F✝ : J ⥤ C
D : Type u'
inst✝³ : Category D
E : K ⥤ J
F : J ⥤ C
G : C ⥤ D
inst✝² : HasColimit F
inst✝¹ : HasColimit (E ⋙ F)
inst✝ : HasColimit (F ⋙ G)
h : HasColimit ((E ⋙ F) ⋙ G)
⊢ post (E ⋙ F) G ≫ G.map (pre F E) = pre (F ⋙ G) E ≫ post F G

tactic: rw [← assoc, colimit.ι_post, ← G.map_comp, colimit.ι_pre, ← assoc]
state_before: case w
J : Type u₁
inst✝⁶ : Category J
K : Type u₂
inst✝⁵ : Category K
C : Type u
inst✝⁴ : Category C
F✝ : J ⥤ C
D : Type u'
inst✝³ : Category D
E : K ⥤ J
F : J ⥤ C
G : C ⥤ D
inst✝² : HasColimit F
inst✝¹ : HasColimit (E ⋙ F)
inst✝ : HasColimit (F ⋙ G)
h : HasColimit ((E ⋙ F) ⋙ G)
j : K
⊢ ι ((E ⋙ F) ⋙ G) j ≫ post (E ⋙ F) G ≫ G.map (pre F E) = ι ((E ⋙ F) ⋙ G) j ≫ pre (F ⋙ G) E ≫ post F G

tactic: haveI : HasColimit (E ⋙ F ⋙ G) := h
state_before: case w
J : Type u₁
inst✝⁶ : Category J
K : Type u₂
inst✝⁵ : Category K
C : Type u
inst✝⁴ : Category C
F✝ : J ⥤ C
D : Type u'
inst✝³ : Category D
E : K ⥤ J
F : J ⥤ C
G : C ⥤ D
inst✝² : HasColimit F
inst✝¹ : HasColimit (E ⋙ F)
inst✝ : HasColimit (F ⋙ G)
h : HasColimit ((E ⋙ F) ⋙ G)
j : K
⊢ G.map (ι F (E.obj j)) = (ι ((E ⋙ F) ⋙ G) j ≫ pre (F ⋙ G) E) ≫ post F G

tactic: erw [colimit.ι_pre (F ⋙ G) E j, colimit.ι_post]
state_before: case w
J : Type u₁
inst✝⁶ : Category J
K : Type u₂
inst✝⁵ : Category K
C : Type u
inst✝⁴ : Category C
F✝ : J ⥤ C
D : Type u'
inst✝³ : Category D
E : K ⥤ J
F : J ⥤ C
G : C ⥤ D
inst✝² : HasColimit F
inst✝¹ : HasColimit (E ⋙ F)
inst✝ : HasColimit (F ⋙ G)
h : HasColimit ((E ⋙ F) ⋙ G)
j : K
this : HasColimit (E ⋙ F ⋙ G)
⊢ G.map (ι F (E.obj j)) = (ι ((E ⋙ F) ⋙ G) j ≫ pre (F ⋙ G) E) ≫ post F G
Theorem: Int.add_comm
File: Std/Data/Int/Lemmas.lean

tactic: simp [Nat.add_comm]
state_before: n m : Nat
⊢ ofNat n + ofNat m = ofNat m + ofNat n

tactic: simp [Nat.add_comm]
state_before: a✝¹ a✝ : Nat
⊢ -[a✝¹+1] + -[a✝+1] = -[a✝+1] + -[a✝¹+1]
Theorem: Nat.sub_pos_of_lt
File: Std/Data/Nat/Lemmas.lean

tactic: apply Nat.lt_of_add_lt_add_right (b := m)
state_before: m n : Nat
h : m < n
⊢ 0 < n - m

tactic: rwa [Nat.zero_add, Nat.sub_add_cancel (Nat.le_of_lt h)]
state_before: m n : Nat
h : m < n
⊢ 0 + m < n - m + m
Theorem: Num.ofNat'_eq
File: Mathlib/Data/Num/Lemmas.lean

tactic: simp
state_before: α : Type ?u.445696
⊢ ofNat' 0 = ↑0

tactic: rw [ofNat'] at IH ⊢
state_before: α : Type ?u.445696
b : Bool
n : ℕ
IH : ofNat' n = ↑n
⊢ ofNat' (Nat.bit b n) = ↑(Nat.bit b n)

tactic: rw [Nat.binaryRec_eq, IH]
state_before: α : Type ?u.445696
b : Bool
n : ℕ
IH : Nat.binaryRec 0 (fun b x => bif b then Num.bit1 else Num.bit0) n = ↑n
⊢ Nat.binaryRec 0 (fun b x => bif b then Num.bit1 else Num.bit0) (Nat.bit b n) = ↑(Nat.bit b n)

tactic: cases b <;> simp [Nat.bit, bit0_of_bit0, bit1_of_bit1, Nat.cast_bit0, Nat.cast_bit1]
state_before: α : Type ?u.445696
b : Bool
n : ℕ
IH : Nat.binaryRec 0 (fun b x => bif b then Num.bit1 else Num.bit0) n = ↑n
⊢ cond b Num.bit1 Num.bit0 ↑n = ↑(Nat.bit b n)

tactic: rfl
state_before: case h
α : Type ?u.445696
b : Bool
n : ℕ
IH : Nat.binaryRec 0 (fun b x => bif b then Num.bit1 else Num.bit0) n = ↑n
⊢ cond false Num.bit1 Num.bit0 0 = 0
Theorem: Erased.mk_out
File: Mathlib/Data/Erased.lean

tactic: simp [mk]
state_before: α : Sort u_1
s : α → Prop
h : ∃ a, (fun b => a = b) = s
⊢ mk (out { fst := s, snd := h }) = { fst := s, snd := h }

tactic: congr
state_before: α : Sort u_1
s : α → Prop
h : ∃ a, (fun b => a = b) = s
⊢ { fst := fun b => out { fst := s, snd := h } = b,
      snd := (_ : ∃ a, (fun b => a = b) = fun b => out { fst := s, snd := h } = b) } =
    { fst := s, snd := h }

tactic: exact Classical.choose_spec h
state_before: case e_fst
α : Sort u_1
s : α → Prop
h : ∃ a, (fun b => a = b) = s
⊢ (fun b => out { fst := s, snd := h } = b) = s
Theorem: Basis.eval_ker
File: Mathlib/LinearAlgebra/Dual.lean

tactic: rw [ker_eq_bot']
state_before: R : Type u
M : Type v
K : Type u₁
V : Type u₂
ι✝ : Type w
inst✝³ : CommRing R
inst✝² : AddCommGroup M
inst✝¹ : Module R M
inst✝ : DecidableEq ι✝
b✝ : Basis ι✝ R M
ι : Type u_1
b : Basis ι R M
⊢ ker (Dual.eval R M) = ⊥

tactic: intro m hm
state_before: R : Type u
M : Type v
K : Type u₁
V : Type u₂
ι✝ : Type w
inst✝³ : CommRing R
inst✝² : AddCommGroup M
inst✝¹ : Module R M
inst✝ : DecidableEq ι✝
b✝ : Basis ι✝ R M
ι : Type u_1
b : Basis ι R M
⊢ ∀ (m : M), ↑(Dual.eval R M) m = 0 → m = 0

tactic: simp_rw [LinearMap.ext_iff, Dual.eval_apply, zero_apply] at hm
state_before: R : Type u
M : Type v
K : Type u₁
V : Type u₂
ι✝ : Type w
inst✝³ : CommRing R
inst✝² : AddCommGroup M
inst✝¹ : Module R M
inst✝ : DecidableEq ι✝
b✝ : Basis ι✝ R M
ι : Type u_1
b : Basis ι R M
m : M
hm : ↑(Dual.eval R M) m = 0
⊢ m = 0

tactic: exact (Basis.forall_coord_eq_zero_iff _).mp fun i => hm (b.coord i)
state_before: R : Type u
M : Type v
K : Type u₁
V : Type u₂
ι✝ : Type w
inst✝³ : CommRing R
inst✝² : AddCommGroup M
inst✝¹ : Module R M
inst✝ : DecidableEq ι✝
b✝ : Basis ι✝ R M
ι : Type u_1
b : Basis ι R M
m : M
hm : ∀ (x : Dual R M), ↑x m = 0
⊢ m = 0
Theorem: UV.le_of_mem_compression_of_not_mem
File: Mathlib/Combinatorics/SetFamily/Compression/UV.lean

tactic: rw [mem_compression] at h
state_before: α : Type u_1
inst✝² : GeneralizedBooleanAlgebra α
inst✝¹ : DecidableRel Disjoint
inst✝ : DecidableRel fun x x_1 => x ≤ x_1
s : Finset α
u v a b : α
h : a ∈ 𝓒 u v s
ha : ¬a ∈ s
⊢ u ≤ a

tactic: obtain h | ⟨-, b, hb, hba⟩ := h
state_before: α : Type u_1
inst✝² : GeneralizedBooleanAlgebra α
inst✝¹ : DecidableRel Disjoint
inst✝ : DecidableRel fun x x_1 => x ≤ x_1
s : Finset α
u v a b : α
h : a ∈ s ∧ compress u v a ∈ s ∨ ¬a ∈ s ∧ ∃ b, b ∈ s ∧ compress u v b = a
ha : ¬a ∈ s
⊢ u ≤ a

tactic: unfold compress at hba
state_before: case inr.intro.intro.intro
α : Type u_1
inst✝² : GeneralizedBooleanAlgebra α
inst✝¹ : DecidableRel Disjoint
inst✝ : DecidableRel fun x x_1 => x ≤ x_1
s : Finset α
u v a b✝ : α
ha : ¬a ∈ s
b : α
hb : b ∈ s
hba : compress u v b = a
⊢ u ≤ a

tactic: split_ifs at hba with h
state_before: case inr.intro.intro.intro
α : Type u_1
inst✝² : GeneralizedBooleanAlgebra α
inst✝¹ : DecidableRel Disjoint
inst✝ : DecidableRel fun x x_1 => x ≤ x_1
s : Finset α
u v a b✝ : α
ha : ¬a ∈ s
b : α
hb : b ∈ s
hba : (if Disjoint u b ∧ v ≤ b then (b ⊔ u) \ v else b) = a
⊢ u ≤ a

tactic: cases ha h.1
state_before: case inl
α : Type u_1
inst✝² : GeneralizedBooleanAlgebra α
inst✝¹ : DecidableRel Disjoint
inst✝ : DecidableRel fun x x_1 => x ≤ x_1
s : Finset α
u v a b : α
ha : ¬a ∈ s
h : a ∈ s ∧ compress u v a ∈ s
⊢ u ≤ a

tactic: rw [← hba, le_sdiff]
state_before: case inr.intro.intro.intro.inl
α : Type u_1
inst✝² : GeneralizedBooleanAlgebra α
inst✝¹ : DecidableRel Disjoint
inst✝ : DecidableRel fun x x_1 => x ≤ x_1
s : Finset α
u v a b✝ : α
ha : ¬a ∈ s
b : α
hb : b ∈ s
h : Disjoint u b ∧ v ≤ b
hba : (b ⊔ u) \ v = a
⊢ u ≤ a

tactic: exact ⟨le_sup_right, h.1.mono_right h.2⟩
state_before: case inr.intro.intro.intro.inl
α : Type u_1
inst✝² : GeneralizedBooleanAlgebra α
inst✝¹ : DecidableRel Disjoint
inst✝ : DecidableRel fun x x_1 => x ≤ x_1
s : Finset α
u v a b✝ : α
ha : ¬a ∈ s
b : α
hb : b ∈ s
h : Disjoint u b ∧ v ≤ b
hba : (b ⊔ u) \ v = a
⊢ u ≤ b ⊔ u ∧ Disjoint u v

tactic: cases ne_of_mem_of_not_mem hb ha hba
state_before: case inr.intro.intro.intro.inr
α : Type u_1
inst✝² : GeneralizedBooleanAlgebra α
inst✝¹ : DecidableRel Disjoint
inst✝ : DecidableRel fun x x_1 => x ≤ x_1
s : Finset α
u v a b✝ : α
ha : ¬a ∈ s
b : α
hb : b ∈ s
h : ¬(Disjoint u b ∧ v ≤ b)
hba : b = a
⊢ u ≤ a
Theorem: padicValRat.self
File: Mathlib/NumberTheory/Padics/PadicVal.lean

tactic: simp [hp]
state_before: p : ℕ
hp : 1 < p
⊢ padicValRat p ↑p = 1
Theorem: CategoryTheory.Limits.KernelFork.app_one
File: Mathlib/CategoryTheory/Limits/Shapes/Kernels.lean

tactic: simp [Fork.app_one_eq_ι_comp_right]
state_before: C : Type u
inst✝¹ : Category C
inst✝ : HasZeroMorphisms C
X Y : C
f : X ⟶ Y
s : KernelFork f
⊢ s.π.app one = 0
Theorem: Matrix.star_dotProduct_star
File: Mathlib/Data/Matrix/Basic.lean

tactic: simp [dotProduct]
state_before: l : Type ?u.208169
m : Type u_1
n : Type ?u.208175
o : Type ?u.208178
m' : o → Type ?u.208183
n' : o → Type ?u.208188
R : Type ?u.208191
S : Type ?u.208194
α : Type v
β : Type w
γ : Type ?u.208201
inst✝³ : Fintype m
inst✝² : Fintype n
inst✝¹ : NonUnitalSemiring α
inst✝ : StarRing α
v w : m → α
⊢ star v ⬝ᵥ star w = star (w ⬝ᵥ v)
Theorem: IntermediateField.eq_of_le_of_finrank_le'
File: Mathlib/FieldTheory/IntermediateField.lean

tactic: apply eq_of_le_of_finrank_le h_le
state_before: K : Type u_1
L : Type u_2
L' : Type ?u.284724
inst✝⁵ : Field K
inst✝⁴ : Field L
inst✝³ : Field L'
inst✝² : Algebra K L
inst✝¹ : Algebra K L'
S F E : IntermediateField K L
inst✝ : FiniteDimensional K L
h_le : F ≤ E
h_finrank : finrank { x // x ∈ F } L ≤ finrank { x // x ∈ E } L
⊢ F = E

tactic: have h1 := finrank_mul_finrank K F L
state_before: K : Type u_1
L : Type u_2
L' : Type ?u.284724
inst✝⁵ : Field K
inst✝⁴ : Field L
inst✝³ : Field L'
inst✝² : Algebra K L
inst✝¹ : Algebra K L'
S F E : IntermediateField K L
inst✝ : FiniteDimensional K L
h_le : F ≤ E
h_finrank : finrank { x // x ∈ F } L ≤ finrank { x // x ∈ E } L
⊢ finrank K { x // x ∈ E } ≤ finrank K { x // x ∈ F }

tactic: have h2 := finrank_mul_finrank K E L
state_before: K : Type u_1
L : Type u_2
L' : Type ?u.284724
inst✝⁵ : Field K
inst✝⁴ : Field L
inst✝³ : Field L'
inst✝² : Algebra K L
inst✝¹ : Algebra K L'
S F E : IntermediateField K L
inst✝ : FiniteDimensional K L
h_le : F ≤ E
h_finrank : finrank { x // x ∈ F } L ≤ finrank { x // x ∈ E } L
h1 : finrank K { x // x ∈ F } * finrank { x // x ∈ F } L = finrank K L
⊢ finrank K { x // x ∈ E } ≤ finrank K { x // x ∈ F }

tactic: have h3 : 0 < finrank E L := finrank_pos
state_before: K : Type u_1
L : Type u_2
L' : Type ?u.284724
inst✝⁵ : Field K
inst✝⁴ : Field L
inst✝³ : Field L'
inst✝² : Algebra K L
inst✝¹ : Algebra K L'
S F E : IntermediateField K L
inst✝ : FiniteDimensional K L
h_le : F ≤ E
h_finrank : finrank { x // x ∈ F } L ≤ finrank { x // x ∈ E } L
h1 : finrank K { x // x ∈ F } * finrank { x // x ∈ F } L = finrank K L
h2 : finrank K { x // x ∈ E } * finrank { x // x ∈ E } L = finrank K L
⊢ finrank K { x // x ∈ E } ≤ finrank K { x // x ∈ F }

tactic: nlinarith
state_before: K : Type u_1
L : Type u_2
L' : Type ?u.284724
inst✝⁵ : Field K
inst✝⁴ : Field L
inst✝³ : Field L'
inst✝² : Algebra K L
inst✝¹ : Algebra K L'
S F E : IntermediateField K L
inst✝ : FiniteDimensional K L
h_le : F ≤ E
h_finrank : finrank { x // x ∈ F } L ≤ finrank { x // x ∈ E } L
h1 : finrank K { x // x ∈ F } * finrank { x // x ∈ F } L = finrank K L
h2 : finrank K { x // x ∈ E } * finrank { x // x ∈ E } L = finrank K L
h3 : 0 < finrank { x // x ∈ E } L
⊢ finrank K { x // x ∈ E } ≤ finrank K { x // x ∈ F }
Theorem: minpoly.coeff_zero_ne_zero
File: Mathlib/FieldTheory/Minpoly/Field.lean

tactic: contrapose! h
state_before: A : Type u_1
B : Type u_2
inst✝³ : Field A
inst✝² : Ring B
inst✝¹ : IsDomain B
inst✝ : Algebra A B
x : B
hx : IsIntegral A x
h : x ≠ 0
⊢ coeff (minpoly A x) 0 ≠ 0

tactic: simpa only [hx, coeff_zero_eq_zero] using h
state_before: A : Type u_1
B : Type u_2
inst✝³ : Field A
inst✝² : Ring B
inst✝¹ : IsDomain B
inst✝ : Algebra A B
x : B
hx : IsIntegral A x
h : coeff (minpoly A x) 0 = 0
⊢ x = 0
Theorem: MeasureTheory.OuterMeasure.iInf_apply'
File: Mathlib/MeasureTheory/Measure/OuterMeasure.lean

tactic: rw [iInf, sInf_apply' hs]
state_before: α : Type u_2
ι : Sort u_1
m : ι → OuterMeasure α
s : Set α
hs : Set.Nonempty s
⊢ ↑(⨅ (i : ι), m i) s = ⨅ (t : ℕ → Set α) (_ : s ⊆ iUnion t), ∑' (n : ℕ), ⨅ (i : ι), ↑(m i) (t n)

tactic: simp only [iInf_range]
state_before: α : Type u_2
ι : Sort u_1
m : ι → OuterMeasure α
s : Set α
hs : Set.Nonempty s
⊢ (⨅ (t : ℕ → Set α) (_ : s ⊆ iUnion t), ∑' (n : ℕ), ⨅ (μ : OuterMeasure α) (_ : μ ∈ range fun i => m i), ↑μ (t n)) =
    ⨅ (t : ℕ → Set α) (_ : s ⊆ iUnion t), ∑' (n : ℕ), ⨅ (i : ι), ↑(m i) (t n)
Theorem: CategoryTheory.Subobject.factors_left_of_factors_add
File: Mathlib/CategoryTheory/Subobject/FactorThru.lean

tactic: simp
state_before: C : Type u₁
inst✝² : Category C
X✝ Y✝ Z : C
D : Type u₂
inst✝¹ : Category D
inst✝ : Preadditive C
X Y : C
P : Subobject Y
f g : X ⟶ Y
w : Factors P (f + g)
wg : Factors P g
⊢ (factorThru P (f + g) w - factorThru P g wg) ≫ MonoOver.arrow (representative.obj P) = f
Theorem: Quaternion.im_exp
File: Mathlib/Analysis/NormedSpace/QuaternionExponential.lean

tactic: simp [exp_eq, smul_smul]
state_before: q : ℍ
⊢ im (exp ℝ q) = (exp ℝ q.re * (Real.sin ‖im q‖ / ‖im q‖)) • im q
Theorem: image_range_orderOf
File: Mathlib/GroupTheory/OrderOfElement.lean

tactic: ext x
state_before: G : Type u
A : Type v
x y : G
a b : A
n m : ℕ
inst✝³ : Group G
inst✝² : AddGroup A
inst✝¹ : Fintype G
inst✝ : DecidableEq G
⊢ Finset.image (fun i => x ^ i) (Finset.range (orderOf x)) = Set.toFinset ↑(zpowers x)

tactic: rw [Set.mem_toFinset, SetLike.mem_coe, mem_zpowers_iff_mem_range_orderOf]
state_before: case a
G : Type u
A : Type v
x✝ y : G
a b : A
n m : ℕ
inst✝³ : Group G
inst✝² : AddGroup A
inst✝¹ : Fintype G
inst✝ : DecidableEq G
x : G
⊢ x ∈ Finset.image (fun i => x✝ ^ i) (Finset.range (orderOf x✝)) ↔ x ∈ Set.toFinset ↑(zpowers x✝)
Theorem: continuous_clm_apply
File: Mathlib/Analysis/NormedSpace/FiniteDimension.lean

tactic: simp_rw [continuous_iff_continuousOn_univ, continuousOn_clm_apply]
state_before: 𝕜 : Type u
inst✝¹² : NontriviallyNormedField 𝕜
E : Type v
inst✝¹¹ : NormedAddCommGroup E
inst✝¹⁰ : NormedSpace 𝕜 E
F : Type w
inst✝⁹ : NormedAddCommGroup F
inst✝⁸ : NormedSpace 𝕜 F
F' : Type x
inst✝⁷ : AddCommGroup F'
inst✝⁶ : Module 𝕜 F'
inst✝⁵ : TopologicalSpace F'
inst✝⁴ : TopologicalAddGroup F'
inst✝³ : ContinuousSMul 𝕜 F'
inst✝² : CompleteSpace 𝕜
X : Type u_1
inst✝¹ : TopologicalSpace X
inst✝ : FiniteDimensional 𝕜 E
f : X → E →L[𝕜] F
⊢ Continuous f ↔ ∀ (y : E), Continuous fun x => ↑(f x) y
Theorem: MeasureTheory.snorm'_measure_zero_of_exponent_zero
File: Mathlib/MeasureTheory/Function/LpSeminorm.lean

tactic: simp [snorm']
state_before: α : Type u_1
E : Type ?u.947882
F : Type u_2
G : Type ?u.947888
m m0 : MeasurableSpace α
p : ℝ≥0∞
q : ℝ
μ ν : Measure α
inst✝³ : NormedAddCommGroup E
inst✝² : NormedAddCommGroup F
inst✝¹ : NormedAddCommGroup G
inst✝ : MeasurableSpace α
f : α → F
⊢ snorm' f 0 0 = 1
Theorem: Lean.Data.AC.Context.mergeIdem_nonEmpty
File: src/lean/Init/Data/AC.lean

tactic: induction e using List.two_step_induction with
| empty => simp_all
| single => simp [mergeIdem, mergeIdem.loop]
| step => simp [mergeIdem, mergeIdem.loop] at *; split <;> simp_all
state_before: e : List Nat
h : e ≠ []
⊢ mergeIdem e ≠ []

tactic: simp_all
state_before: case empty
h : [] ≠ []
⊢ mergeIdem [] ≠ []

tactic: simp [mergeIdem, mergeIdem.loop]
state_before: case single
a✝ : Nat
h : [a✝] ≠ []
⊢ mergeIdem [a✝] ≠ []

tactic: simp [mergeIdem, mergeIdem.loop] at *
state_before: case step
a✝¹ b✝ : Nat
l✝ : List Nat
a✝ : b✝ :: l✝ ≠ [] → mergeIdem (b✝ :: l✝) ≠ []
h : a✝¹ :: b✝ :: l✝ ≠ []
⊢ mergeIdem (a✝¹ :: b✝ :: l✝) ≠ []

tactic: split <;> simp_all
state_before: case step
a✝¹ b✝ : Nat
l✝ : List Nat
a✝ : ¬mergeIdem.loop b✝ l✝ = []
h : True
⊢ ¬(if a✝¹ = b✝ then mergeIdem.loop a✝¹ l✝ else a✝¹ :: mergeIdem.loop b✝ l✝) = []
Theorem: Sum.liftRel_inr_inr
File: Mathlib/Data/Sum/Basic.lean

tactic: cases h
state_before: α : Type u
α' : Type w
β : Type v
β' : Type x
γ : Type u_1
δ : Type u_2
r r₁ r₂ : α → γ → Prop
s s₁ s₂ : β → δ → Prop
a : α
b : β
c : γ
d : δ
x : α ⊕ β
y : γ ⊕ δ
h : LiftRel r s (inr b) (inr d)
⊢ s b d

tactic: assumption
state_before: case inr
α : Type u
α' : Type w
β : Type v
β' : Type x
γ : Type u_1
δ : Type u_2
r r₁ r₂ : α → γ → Prop
s s₁ s₂ : β → δ → Prop
a : α
b : β
c : γ
d : δ
x : α ⊕ β
y : γ ⊕ δ
a✝ : s b d
⊢ s b d
Theorem: Convex.strictAntiOn_of_deriv_neg
File: Mathlib/Analysis/Calculus/MeanValue.lean

tactic: simpa only [zero_mul, sub_lt_zero] using
  hD.image_sub_lt_mul_sub_of_deriv_lt hf
    (fun z hz => (differentiableAt_of_deriv_ne_zero (hf' z hz).ne).differentiableWithinAt) hf' x
    hx y
state_before: E : Type ?u.418135
inst✝³ : NormedAddCommGroup E
inst✝² : NormedSpace ℝ E
F : Type ?u.418231
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedSpace ℝ F
D : Set ℝ
hD : Convex ℝ D
f : ℝ → ℝ
hf : ContinuousOn f D
hf' : ∀ (x : ℝ), x ∈ interior D → deriv f x < 0
x : ℝ
hx : x ∈ D
y : ℝ
⊢ y ∈ D → x < y → f y < f x
Theorem: toIocDiv_add_left
File: Mathlib/Algebra/Order/ToIntervalMod.lean

tactic: rw [add_comm, toIocDiv_add_right]
state_before: α : Type u_1
inst✝ : LinearOrderedAddCommGroup α
hα : Archimedean α
p : α
hp : 0 < p
a✝ b✝ c : α
n : ℤ
a b : α
⊢ toIocDiv hp a (p + b) = toIocDiv hp a b + 1
Theorem: Equiv.Set.sumCompl_symm_apply_compl
File: Mathlib/Logic/Equiv/Set.lean

tactic: cases' x with x hx
state_before: α✝ : Sort u
β : Sort v
γ : Sort w
α : Type u_1
s : Set α
inst✝ : DecidablePred fun x => x ∈ s
x : ↑(sᶜ)
⊢ ↑(Set.sumCompl s).symm ↑x = Sum.inr x

tactic: exact Set.sumCompl_symm_apply_of_not_mem hx
state_before: case mk
α✝ : Sort u
β : Sort v
γ : Sort w
α : Type u_1
s : Set α
inst✝ : DecidablePred fun x => x ∈ s
x : α
hx : x ∈ sᶜ
⊢ ↑(Set.sumCompl s).symm ↑{ val := x, property := hx } = Sum.inr { val := x, property := hx }
Theorem: ultrafilter_comap_pure_nhds
File: Mathlib/Topology/StoneCech.lean

tactic: rw [TopologicalSpace.nhds_generateFrom]
state_before: α : Type u
b : Ultrafilter α
⊢ comap pure (𝓝 b) ≤ ↑b

tactic: simp only [comap_iInf, comap_principal]
state_before: α : Type u
b : Ultrafilter α
⊢ comap pure (⨅ (s : Set (Ultrafilter α)) (_ : s ∈ {s | b ∈ s ∧ s ∈ ultrafilterBasis α}), 𝓟 s) ≤ ↑b

tactic: intro s hs
state_before: α : Type u
b : Ultrafilter α
⊢ (⨅ (i : Set (Ultrafilter α)) (_ : i ∈ {s | b ∈ s ∧ s ∈ ultrafilterBasis α}), 𝓟 (pure ⁻¹' i)) ≤ ↑b

tactic: rw [← le_principal_iff]
state_before: α : Type u
b : Ultrafilter α
s : Set α
hs : s ∈ ↑b
⊢ s ∈ ⨅ (i : Set (Ultrafilter α)) (_ : i ∈ {s | b ∈ s ∧ s ∈ ultrafilterBasis α}), 𝓟 (pure ⁻¹' i)

tactic: refine' iInf_le_of_le { u | s ∈ u } _
state_before: α : Type u
b : Ultrafilter α
s : Set α
hs : s ∈ ↑b
⊢ (⨅ (i : Set (Ultrafilter α)) (_ : i ∈ {s | b ∈ s ∧ s ∈ ultrafilterBasis α}), 𝓟 (pure ⁻¹' i)) ≤ 𝓟 s

tactic: refine' iInf_le_of_le ⟨hs, ⟨s, rfl⟩⟩ _
state_before: α : Type u
b : Ultrafilter α
s : Set α
hs : s ∈ ↑b
⊢ (⨅ (_ : {u | s ∈ u} ∈ {s | b ∈ s ∧ s ∈ ultrafilterBasis α}), 𝓟 (pure ⁻¹' {u | s ∈ u})) ≤ 𝓟 s

tactic: exact principal_mono.2 fun a => id
state_before: α : Type u
b : Ultrafilter α
s : Set α
hs : s ∈ ↑b
⊢ 𝓟 (pure ⁻¹' {u | s ∈ u}) ≤ 𝓟 s
Theorem: NeZero.nat_of_neZero
File: Mathlib/Data/Nat/Cast/Basic.lean

tactic: simp only [map_natCast, hn]
state_before: α : Type ?u.62486
β : Type ?u.62489
R✝ : Type ?u.62492
S✝ : Type ?u.62495
F✝ : Type ?u.62498
inst✝⁴ : NonAssocSemiring R✝
inst✝³ : NonAssocSemiring S✝
R : Type u_1
S : Type u_2
inst✝² : Semiring R
inst✝¹ : Semiring S
F : Type u_3
inst✝ : RingHomClass F R S
f : F
n : ℕ
hn : NeZero ↑n
⊢ NeZero (↑f ↑n)
Theorem: measurable_deriv
File: Mathlib/Analysis/Calculus/FDerivMeasurable.lean

tactic: simpa only [fderiv_deriv] using measurable_fderiv_apply_const 𝕜 f 1
state_before: 𝕜 : Type u_1
inst✝¹¹ : NontriviallyNormedField 𝕜
E : Type ?u.401298
inst✝¹⁰ : NormedAddCommGroup E
inst✝⁹ : NormedSpace 𝕜 E
F : Type u_2
inst✝⁸ : NormedAddCommGroup F
inst✝⁷ : NormedSpace 𝕜 F
f✝ : E → F
K : Set (E →L[𝕜] F)
inst✝⁶ : MeasurableSpace E
inst✝⁵ : OpensMeasurableSpace E
inst✝⁴ : CompleteSpace F
inst✝³ : MeasurableSpace 𝕜
inst✝² : OpensMeasurableSpace 𝕜
inst✝¹ : MeasurableSpace F
inst✝ : BorelSpace F
f : 𝕜 → F
⊢ Measurable (deriv f)
Theorem: uniformContinuous_of_const
File: Mathlib/Topology/UniformSpace/Basic.lean

tactic: simp [comap_principal, this, univ_mem]
state_before: α : Type ua
β : Type ub
γ : Type uc
δ : Type ud
ι : Sort ?u.112580
inst✝¹ : UniformSpace α
inst✝ : UniformSpace β
c : α → β
h : ∀ (a b : α), c a = c b
this : (fun x => (c x.fst, c x.snd)) ⁻¹' idRel = univ
⊢ 𝓤 α ≤ comap (fun x => (c x.fst, c x.snd)) (𝓟 idRel)
Theorem: CategoryTheory.SimplicialObject.δ_comp_δ
File: Mathlib/AlgebraicTopology/SimplicialObject.lean

tactic: dsimp [δ]
state_before: C : Type u
inst✝ : Category C
X : SimplicialObject C
n : ℕ
i j : Fin (n + 2)
H : i ≤ j
⊢ δ X (Fin.succ j) ≫ δ X i = δ X (↑Fin.castSucc i) ≫ δ X j

tactic: simp only [← X.map_comp, ← op_comp, SimplexCategory.δ_comp_δ H]
state_before: C : Type u
inst✝ : Category C
X : SimplicialObject C
n : ℕ
i j : Fin (n + 2)
H : i ≤ j
⊢ X.map (SimplexCategory.δ (Fin.succ j)).op ≫ X.map (SimplexCategory.δ i).op =
    X.map (SimplexCategory.δ (↑Fin.castSucc i)).op ≫ X.map (SimplexCategory.δ j).op
Theorem: least_ascending_central_series_length_eq_nilpotencyClass
File: Mathlib/GroupTheory/Nilpotent.lean

tactic: refine le_antisymm (Nat.find_mono ?_) (Nat.find_mono ?_)
state_before: G : Type u_1
inst✝¹ : Group G
H : Subgroup G
inst✝ : Normal H
hG : Group.IsNilpotent G
⊢ Nat.find (_ : ∃ n H, IsAscendingCentralSeries H ∧ H n = ⊤) = nilpotencyClass G

tactic: intro n hn
state_before: case refine_1
G : Type u_1
inst✝¹ : Group G
H : Subgroup G
inst✝ : Normal H
hG : Group.IsNilpotent G
⊢ ∀ (n : ℕ), upperCentralSeries G n = ⊤ → ∃ H, IsAscendingCentralSeries H ∧ H n = ⊤

tactic: exact ⟨upperCentralSeries G, upperCentralSeries_isAscendingCentralSeries G, hn⟩
state_before: case refine_1
G : Type u_1
inst✝¹ : Group G
H : Subgroup G
inst✝ : Normal H
hG : Group.IsNilpotent G
n : ℕ
hn : upperCentralSeries G n = ⊤
⊢ ∃ H, IsAscendingCentralSeries H ∧ H n = ⊤

tactic: rintro n ⟨H, ⟨hH, hn⟩⟩
state_before: case refine_2
G : Type u_1
inst✝¹ : Group G
H : Subgroup G
inst✝ : Normal H
hG : Group.IsNilpotent G
⊢ ∀ (n : ℕ), (∃ H, IsAscendingCentralSeries H ∧ H n = ⊤) → upperCentralSeries G n = ⊤

tactic: rw [← top_le_iff, ← hn]
state_before: case refine_2.intro.intro
G : Type u_1
inst✝¹ : Group G
H✝ : Subgroup G
inst✝ : Normal H✝
hG : Group.IsNilpotent G
n : ℕ
H : ℕ → Subgroup G
hH : IsAscendingCentralSeries H
hn : H n = ⊤
⊢ upperCentralSeries G n = ⊤

tactic: exact ascending_central_series_le_upper H hH n
state_before: case refine_2.intro.intro
G : Type u_1
inst✝¹ : Group G
H✝ : Subgroup G
inst✝ : Normal H✝
hG : Group.IsNilpotent G
n : ℕ
H : ℕ → Subgroup G
hH : IsAscendingCentralSeries H
hn : H n = ⊤
⊢ H n ≤ upperCentralSeries G n