tasksource/leandojo huggingface dataset:
Theorem: IsCoercive.antilipschitz
File: Mathlib/Analysis/InnerProductSpace/LaxMilgram.lean

tactic: rcases coercive.bounded_below with ⟨C, C_pos, below_bound⟩
state_before: V : Type u
inst✝² : NormedAddCommGroup V
inst✝¹ : InnerProductSpace ℝ V
inst✝ : CompleteSpace V
B : V →L[ℝ] V →L[ℝ] ℝ
coercive : IsCoercive B
⊢ ∃ C, 0 < C ∧ AntilipschitzWith C ↑(continuousLinearMapOfBilin B)

tactic: refine' ⟨C⁻¹.toNNReal, Real.toNNReal_pos.mpr (inv_pos.mpr C_pos), _⟩
state_before: case intro.intro
V : Type u
inst✝² : NormedAddCommGroup V
inst✝¹ : InnerProductSpace ℝ V
inst✝ : CompleteSpace V
B : V →L[ℝ] V →L[ℝ] ℝ
coercive : IsCoercive B
C : ℝ
C_pos : 0 < C
below_bound : ∀ (v : V), C * ‖v‖ ≤ ‖↑(continuousLinearMapOfBilin B) v‖
⊢ ∃ C, 0 < C ∧ AntilipschitzWith C ↑(continuousLinearMapOfBilin B)

tactic: refine' ContinuousLinearMap.antilipschitz_of_bound B♯ _
state_before: case intro.intro
V : Type u
inst✝² : NormedAddCommGroup V
inst✝¹ : InnerProductSpace ℝ V
inst✝ : CompleteSpace V
B : V →L[ℝ] V →L[ℝ] ℝ
coercive : IsCoercive B
C : ℝ
C_pos : 0 < C
below_bound : ∀ (v : V), C * ‖v‖ ≤ ‖↑(continuousLinearMapOfBilin B) v‖
⊢ AntilipschitzWith (Real.toNNReal C⁻¹) ↑(continuousLinearMapOfBilin B)

tactic: simp_rw [Real.coe_toNNReal', max_eq_left_of_lt (inv_pos.mpr C_pos), ←
  inv_mul_le_iff (inv_pos.mpr C_pos)]
state_before: case intro.intro
V : Type u
inst✝² : NormedAddCommGroup V
inst✝¹ : InnerProductSpace ℝ V
inst✝ : CompleteSpace V
B : V →L[ℝ] V →L[ℝ] ℝ
coercive : IsCoercive B
C : ℝ
C_pos : 0 < C
below_bound : ∀ (v : V), C * ‖v‖ ≤ ‖↑(continuousLinearMapOfBilin B) v‖
⊢ ∀ (x : V), ‖x‖ ≤ ↑(Real.toNNReal C⁻¹) * ‖↑(continuousLinearMapOfBilin B) x‖

tactic: simpa using below_bound
state_before: case intro.intro
V : Type u
inst✝² : NormedAddCommGroup V
inst✝¹ : InnerProductSpace ℝ V
inst✝ : CompleteSpace V
B : V →L[ℝ] V →L[ℝ] ℝ
coercive : IsCoercive B
C : ℝ
C_pos : 0 < C
below_bound : ∀ (v : V), C * ‖v‖ ≤ ‖↑(continuousLinearMapOfBilin B) v‖
⊢ ∀ (x : V), C⁻¹⁻¹ * ‖x‖ ≤ ‖↑(continuousLinearMapOfBilin B) x‖
Theorem: Finset.affineCombinationLineMapWeights_apply_of_ne
File: Mathlib/LinearAlgebra/AffineSpace/Combination.lean

tactic: simp [affineCombinationLineMapWeights, hi, hj]
state_before: k : Type u_2
V : Type ?u.441077
P : Type ?u.441080
inst✝³ : Ring k
inst✝² : AddCommGroup V
inst✝¹ : Module k V
S : AffineSpace V P
ι : Type u_1
s : Finset ι
ι₂ : Type ?u.441736
s₂ : Finset ι₂
inst✝ : DecidableEq ι
i j t : ι
hi : t ≠ i
hj : t ≠ j
c : k
⊢ affineCombinationLineMapWeights i j c t = 0
Theorem: Set.insert_diff_of_not_mem
File: Mathlib/Data/Set/Basic.lean

tactic: ext x
state_before: α : Type u
β : Type v
γ : Type w
ι : Sort x
a b : α
s✝ s₁ s₂ t t₁ t₂ u s : Set α
h : ¬a ∈ t
⊢ insert a s \ t = insert a (s \ t)

tactic: by_cases h' : x ∈ t
state_before: case h
α : Type u
β : Type v
γ : Type w
ι : Sort x
a b : α
s✝ s₁ s₂ t t₁ t₂ u s : Set α
h : ¬a ∈ t
x : α
⊢ x ∈ insert a s \ t ↔ x ∈ insert a (s \ t)

tactic: have : x ≠ a := by
  intro H
  rw [H] at h'
  exact h h'
state_before: case pos
α : Type u
β : Type v
γ : Type w
ι : Sort x
a b : α
s✝ s₁ s₂ t t₁ t₂ u s : Set α
h : ¬a ∈ t
x : α
h' : x ∈ t
⊢ x ∈ insert a s \ t ↔ x ∈ insert a (s \ t)

tactic: simp [h, h', this]
state_before: case pos
α : Type u
β : Type v
γ : Type w
ι : Sort x
a b : α
s✝ s₁ s₂ t t₁ t₂ u s : Set α
h : ¬a ∈ t
x : α
h' : x ∈ t
this : x ≠ a
⊢ x ∈ insert a s \ t ↔ x ∈ insert a (s \ t)

tactic: intro H
state_before: α : Type u
β : Type v
γ : Type w
ι : Sort x
a b : α
s✝ s₁ s₂ t t₁ t₂ u s : Set α
h : ¬a ∈ t
x : α
h' : x ∈ t
⊢ x ≠ a

tactic: rw [H] at h'
state_before: α : Type u
β : Type v
γ : Type w
ι : Sort x
a b : α
s✝ s₁ s₂ t t₁ t₂ u s : Set α
h : ¬a ∈ t
x : α
h' : x ∈ t
H : x = a
⊢ False

tactic: exact h h'
state_before: α : Type u
β : Type v
γ : Type w
ι : Sort x
a b : α
s✝ s₁ s₂ t t₁ t₂ u s : Set α
h : ¬a ∈ t
x : α
h' : a ∈ t
H : x = a
⊢ False

tactic: simp [h, h']
state_before: case neg
α : Type u
β : Type v
γ : Type w
ι : Sort x
a b : α
s✝ s₁ s₂ t t₁ t₂ u s : Set α
h : ¬a ∈ t
x : α
h' : ¬x ∈ t
⊢ x ∈ insert a s \ t ↔ x ∈ insert a (s \ t)
Theorem: BoxIntegral.Prepartition.inf_splitMany
File: Mathlib/Analysis/BoxIntegral/Partition/Split.lean

tactic: induction' s using Finset.induction_on with p s _ ihp
state_before: ι : Type u_1
M : Type ?u.45780
n : ℕ
I✝ J : Box ι
i : ι
x : ℝ
I : Box ι
π : Prepartition I
s : Finset (ι × ℝ)
⊢ π ⊓ splitMany I s = biUnion π fun J => splitMany J s

tactic: simp
state_before: case empty
ι : Type u_1
M : Type ?u.45780
n : ℕ
I✝ J : Box ι
i : ι
x : ℝ
I : Box ι
π : Prepartition I
⊢ π ⊓ splitMany I ∅ = biUnion π fun J => splitMany J ∅

tactic: simp_rw [splitMany_insert, ← inf_assoc, ihp, inf_split, biUnion_assoc]
state_before: case insert
ι : Type u_1
M : Type ?u.45780
n : ℕ
I✝ J : Box ι
i : ι
x : ℝ
I : Box ι
π : Prepartition I
p : ι × ℝ
s : Finset (ι × ℝ)
a✝ : ¬p ∈ s
ihp : π ⊓ splitMany I s = biUnion π fun J => splitMany J s
⊢ π ⊓ splitMany I (insert p s) = biUnion π fun J => splitMany J (insert p s)
Theorem: charZero_of_inj_zero
File: Mathlib/Algebra/CharZero/Defs.lean

tactic: induction' m with m ih generalizing n
state_before: R : Type u_1
inst✝ : AddGroupWithOne R
H : ∀ (n : ℕ), ↑n = 0 → n = 0
m n : ℕ
h : ↑m = ↑n
⊢ m = n

tactic: cases' n with n
state_before: case succ
R : Type u_1
inst✝ : AddGroupWithOne R
H : ∀ (n : ℕ), ↑n = 0 → n = 0
m✝ n✝ : ℕ
h✝ : ↑m✝ = ↑n✝
m : ℕ
ih : ∀ (n : ℕ), ↑m = ↑n → m = n
n : ℕ
h : ↑(Nat.succ m) = ↑n
⊢ Nat.succ m = n

tactic: simp only [Nat.cast_succ, add_right_cancel_iff] at h
state_before: case succ.succ
R : Type u_1
inst✝ : AddGroupWithOne R
H : ∀ (n : ℕ), ↑n = 0 → n = 0
m✝ n✝ : ℕ
h✝ : ↑m✝ = ↑n✝
m : ℕ
ih : ∀ (n : ℕ), ↑m = ↑n → m = n
n : ℕ
h : ↑(Nat.succ m) = ↑(Nat.succ n)
⊢ Nat.succ m = Nat.succ n

tactic: rwa [ih]
state_before: case succ.succ
R : Type u_1
inst✝ : AddGroupWithOne R
H : ∀ (n : ℕ), ↑n = 0 → n = 0
m✝ n✝ : ℕ
h✝ : ↑m✝ = ↑n✝
m : ℕ
ih : ∀ (n : ℕ), ↑m = ↑n → m = n
n : ℕ
h : ↑m = ↑n
⊢ Nat.succ m = Nat.succ n

tactic: rw [H n]
state_before: case zero
R : Type u_1
inst✝ : AddGroupWithOne R
H : ∀ (n : ℕ), ↑n = 0 → n = 0
m n✝ : ℕ
h✝ : ↑m = ↑n✝
n : ℕ
h : ↑Nat.zero = ↑n
⊢ Nat.zero = n

tactic: rw [← h, Nat.cast_zero]
state_before: case zero
R : Type u_1
inst✝ : AddGroupWithOne R
H : ∀ (n : ℕ), ↑n = 0 → n = 0
m n✝ : ℕ
h✝ : ↑m = ↑n✝
n : ℕ
h : ↑Nat.zero = ↑n
⊢ ↑n = 0

tactic: apply H
state_before: case succ.zero
R : Type u_1
inst✝ : AddGroupWithOne R
H : ∀ (n : ℕ), ↑n = 0 → n = 0
m✝ n : ℕ
h✝ : ↑m✝ = ↑n
m : ℕ
ih : ∀ (n : ℕ), ↑m = ↑n → m = n
h : ↑(Nat.succ m) = ↑Nat.zero
⊢ Nat.succ m = Nat.zero

tactic: rw [h, Nat.cast_zero]
state_before: case succ.zero.a
R : Type u_1
inst✝ : AddGroupWithOne R
H : ∀ (n : ℕ), ↑n = 0 → n = 0
m✝ n : ℕ
h✝ : ↑m✝ = ↑n
m : ℕ
ih : ∀ (n : ℕ), ↑m = ↑n → m = n
h : ↑(Nat.succ m) = ↑Nat.zero
⊢ ↑(Nat.succ m) = 0
Theorem: Set.Nonempty.pairwise_iff_exists_forall
File: Mathlib/Data/Set/Pairwise/Basic.lean

tactic: constructor
state_before: α : Type u_1
β : Type ?u.5561
γ : Type ?u.5564
ι : Type u_2
ι' : Type ?u.5570
r p q : α → α → Prop
f g : ι → α
s✝ t u : Set α
a b : α
inst✝ : IsEquiv α r
s : Set ι
hs : Set.Nonempty s
⊢ Set.Pairwise s (r on f) ↔ ∃ z, ∀ (x : ι), x ∈ s → r (f x) z

tactic: rcases hs with ⟨y, hy⟩
state_before: case mp
α : Type u_1
β : Type ?u.5561
γ : Type ?u.5564
ι : Type u_2
ι' : Type ?u.5570
r p q : α → α → Prop
f g : ι → α
s✝ t u : Set α
a b : α
inst✝ : IsEquiv α r
s : Set ι
hs : Set.Nonempty s
⊢ Set.Pairwise s (r on f) → ∃ z, ∀ (x : ι), x ∈ s → r (f x) z

tactic: refine' fun H => ⟨f y, fun x hx => _⟩
state_before: case mp.intro
α : Type u_1
β : Type ?u.5561
γ : Type ?u.5564
ι : Type u_2
ι' : Type ?u.5570
r p q : α → α → Prop
f g : ι → α
s✝ t u : Set α
a b : α
inst✝ : IsEquiv α r
s : Set ι
y : ι
hy : y ∈ s
⊢ Set.Pairwise s (r on f) → ∃ z, ∀ (x : ι), x ∈ s → r (f x) z

tactic: rcases eq_or_ne x y with (rfl | hne)
state_before: case mp.intro
α : Type u_1
β : Type ?u.5561
γ : Type ?u.5564
ι : Type u_2
ι' : Type ?u.5570
r p q : α → α → Prop
f g : ι → α
s✝ t u : Set α
a b : α
inst✝ : IsEquiv α r
s : Set ι
y : ι
hy : y ∈ s
H : Set.Pairwise s (r on f)
x : ι
hx : x ∈ s
⊢ r (f x) (f y)

tactic: apply IsRefl.refl
state_before: case mp.intro.inl
α : Type u_1
β : Type ?u.5561
γ : Type ?u.5564
ι : Type u_2
ι' : Type ?u.5570
r p q : α → α → Prop
f g : ι → α
s✝ t u : Set α
a b : α
inst✝ : IsEquiv α r
s : Set ι
H : Set.Pairwise s (r on f)
x : ι
hx hy : x ∈ s
⊢ r (f x) (f x)

tactic: exact H hx hy hne
state_before: case mp.intro.inr
α : Type u_1
β : Type ?u.5561
γ : Type ?u.5564
ι : Type u_2
ι' : Type ?u.5570
r p q : α → α → Prop
f g : ι → α
s✝ t u : Set α
a b : α
inst✝ : IsEquiv α r
s : Set ι
y : ι
hy : y ∈ s
H : Set.Pairwise s (r on f)
x : ι
hx : x ∈ s
hne : x ≠ y
⊢ r (f x) (f y)

tactic: rintro ⟨z, hz⟩ x hx y hy _
state_before: case mpr
α : Type u_1
β : Type ?u.5561
γ : Type ?u.5564
ι : Type u_2
ι' : Type ?u.5570
r p q : α → α → Prop
f g : ι → α
s✝ t u : Set α
a b : α
inst✝ : IsEquiv α r
s : Set ι
hs : Set.Nonempty s
⊢ (∃ z, ∀ (x : ι), x ∈ s → r (f x) z) → Set.Pairwise s (r on f)

tactic: exact @IsTrans.trans α r _ (f x) z (f y) (hz _ hx) (IsSymm.symm _ _ <| hz _ hy)
state_before: case mpr.intro
α : Type u_1
β : Type ?u.5561
γ : Type ?u.5564
ι : Type u_2
ι' : Type ?u.5570
r p q : α → α → Prop
f g : ι → α
s✝ t u : Set α
a b : α
inst✝ : IsEquiv α r
s : Set ι
hs : Set.Nonempty s
z : α
hz : ∀ (x : ι), x ∈ s → r (f x) z
x : ι
hx : x ∈ s
y : ι
hy : y ∈ s
a✝ : x ≠ y
⊢ (r on f) x y
Theorem: List.takeWhile_eq_nil_iff
File: Mathlib/Data/List/Basic.lean

tactic: induction' l with x xs IH
state_before: ι : Type ?u.412046
α : Type u
β : Type v
γ : Type w
δ : Type x
l₁ l₂ : List α
p : α → Bool
l : List α
⊢ takeWhile p l = [] ↔ ∀ (hl : 0 < length l), ¬p (nthLe l 0 hl) = true

tactic: simp [takeWhile, true_iff]
state_before: case nil
ι : Type ?u.412046
α : Type u
β : Type v
γ : Type w
δ : Type x
l₁ l₂ : List α
p : α → Bool
l : List α
⊢ takeWhile p [] = [] ↔ ∀ (hl : 0 < length []), ¬p (nthLe [] 0 hl) = true

tactic: intro h
state_before: case nil
ι : Type ?u.412046
α : Type u
β : Type v
γ : Type w
δ : Type x
l₁ l₂ : List α
p : α → Bool
l : List α
⊢ ∀ (hl : 0 < length []), p (nthLe [] 0 hl) = false

tactic: simp at h
state_before: case nil
ι : Type ?u.412046
α : Type u
β : Type v
γ : Type w
δ : Type x
l₁ l₂ : List α
p : α → Bool
l : List α
h : 0 < length []
⊢ p (nthLe [] 0 h) = false

tactic: by_cases hp : p x <;> simp [hp, takeWhile, IH, nthLe_cons]
state_before: case cons
ι : Type ?u.412046
α : Type u
β : Type v
γ : Type w
δ : Type x
l₁ l₂ : List α
p : α → Bool
l : List α
x : α
xs : List α
IH : takeWhile p xs = [] ↔ ∀ (hl : 0 < length xs), ¬p (nthLe xs 0 hl) = true
⊢ takeWhile p (x :: xs) = [] ↔ ∀ (hl : 0 < length (x :: xs)), ¬p (nthLe (x :: xs) 0 hl) = true
Theorem: Bifunctor.mapEquiv_refl_refl
File: Mathlib/Logic/Equiv/Functor.lean

tactic: ext x
state_before: α β : Type u
α' β' : Type v
F : Type u → Type v → Type w
inst✝¹ : Bifunctor F
inst✝ : LawfulBifunctor F
⊢ mapEquiv F (Equiv.refl α) (Equiv.refl α') = Equiv.refl (F α α')

tactic: simp [id_bimap]
state_before: case H
α β : Type u
α' β' : Type v
F : Type u → Type v → Type w
inst✝¹ : Bifunctor F
inst✝ : LawfulBifunctor F
x : F α α'
⊢ ↑(mapEquiv F (Equiv.refl α) (Equiv.refl α')) x = ↑(Equiv.refl (F α α')) x
Theorem: Real.cauchy_zero
File: Mathlib/Data/Real/Basic.lean

tactic: rw [zero_def]
state_before: x y : ℝ
⊢ Real.zero.cauchy = 0
Theorem: List.nthLe_join
File: Mathlib/Data/List/Join.lean

tactic: have := nthLe_take L.join (sum_take_map_length_lt2 L hi hj) (sum_take_map_length_lt1 L hi hj)
state_before: α : Type u_1
β : Type ?u.15601
L : List (List α)
i j : ℕ
hi : i < length L
hj : j < length (nthLe L i hi)
⊢ nthLe (join L) (sum (take i (map length L)) + j) (_ : sum (take i (map length L)) + j < length (join L)) =
    nthLe (nthLe L i hi) j hj

tactic: rw [this, nthLe_drop, nthLe_of_eq (drop_take_succ_join_eq_nthLe L hi)]
state_before: α : Type u_1
β : Type ?u.15601
L : List (List α)
i j : ℕ
hi : i < length L
hj : j < length (nthLe L i hi)
this :
  nthLe (join L) (sum (take i (map length L)) + j) (_ : sum (take i (map length L)) + j < length (join L)) =
    nthLe (take (sum (take (i + 1) (map length L))) (join L)) (sum (take i (map length L)) + j)
      (_ : sum (take i (map length L)) + j < length (take (sum (take (i + 1) (map length L))) (join L)))
⊢ nthLe (join L) (sum (take i (map length L)) + j) (_ : sum (take i (map length L)) + j < length (join L)) =
    nthLe (nthLe L i hi) j hj
Theorem: Complex.arg_of_im_nonneg_of_ne_zero
File: Mathlib/Analysis/SpecialFunctions/Complex/Arg.lean

tactic: rw [← cos_arg h₂, Real.arccos_cos (arg_nonneg_iff.2 h₁) (arg_le_pi _)]
state_before: z : ℂ
h₁ : 0 ≤ z.im
h₂ : z ≠ 0
⊢ arg z = arccos (z.re / ↑abs z)
Theorem: mulSalemSpencer_mul_right_iff₀
File: Mathlib/Combinatorics/Additive/SalemSpencer.lean

tactic: rw [mul_mul_mul_comm, h, mul_mul_mul_comm]
state_before: F : Type ?u.106147
α : Type u_1
β : Type ?u.106153
𝕜 : Type ?u.106156
E : Type ?u.106159
inst✝¹ : CancelCommMonoidWithZero α
inst✝ : NoZeroDivisors α
s : Set α
a : α
ha : a ≠ 0
hs : MulSalemSpencer ((fun x => x * a) '' s)
b c d : α
hb : b ∈ s
hc : c ∈ s
hd : d ∈ s
h : b * c = d * d
⊢ b * a * (c * a) = d * a * (d * a)
Theorem: String.Pos.zero_addString_eq
File: Std/Data/String/Lemmas.lean

tactic: rw [← zero_addString_byteIdx]
state_before: s : String
⊢ 0 + s = { byteIdx := utf8ByteSize s }
Theorem: Subgroup.Normal.comap
File: Mathlib/GroupTheory/Subgroup/Basic.lean

tactic: simp (config := { contextual := true }) [Subgroup.mem_comap, hH.conj_mem]
state_before: G : Type u_2
G' : Type ?u.669539
inst✝³ : Group G
inst✝² : Group G'
A : Type ?u.669548
inst✝¹ : AddGroup A
N : Type u_1
inst✝ : Group N
H : Subgroup N
hH : Normal H
f : G →* N
x✝ : G
⊢ x✝ ∈ Subgroup.comap f H → ∀ (g : G), g * x✝ * g⁻¹ ∈ Subgroup.comap f H
Theorem: Nat.gcd_mul_right_left
File: Std/Data/Nat/Gcd.lean

tactic: rw [Nat.mul_comm, gcd_mul_left_left]
state_before: m n : Nat
⊢ gcd (n * m) n = n
Theorem: CategoryTheory.Idempotents.Karoubi.ext
File: Mathlib/CategoryTheory/Idempotents/Karoubi.lean

tactic: cases P
state_before: C : Type u_1
inst✝ : Category C
P Q : Karoubi C
h_X : P.X = Q.X
h_p : P.p ≫ eqToHom h_X = eqToHom h_X ≫ Q.p
⊢ P = Q

tactic: cases Q
state_before: case mk
C : Type u_1
inst✝ : Category C
Q : Karoubi C
X✝ : C
p✝ : X✝ ⟶ X✝
idem✝ : p✝ ≫ p✝ = p✝
h_X : (mk X✝ p✝).X = Q.X
h_p : (mk X✝ p✝).p ≫ eqToHom h_X = eqToHom h_X ≫ Q.p
⊢ mk X✝ p✝ = Q

tactic: dsimp at h_X h_p
state_before: case mk.mk
C : Type u_1
inst✝ : Category C
X✝¹ : C
p✝¹ : X✝¹ ⟶ X✝¹
idem✝¹ : p✝¹ ≫ p✝¹ = p✝¹
X✝ : C
p✝ : X✝ ⟶ X✝
idem✝ : p✝ ≫ p✝ = p✝
h_X : (mk X✝¹ p✝¹).X = (mk X✝ p✝).X
h_p : (mk X✝¹ p✝¹).p ≫ eqToHom h_X = eqToHom h_X ≫ (mk X✝ p✝).p
⊢ mk X✝¹ p✝¹ = mk X✝ p✝

tactic: subst h_X
state_before: case mk.mk
C : Type u_1
inst✝ : Category C
X✝¹ : C
p✝¹ : X✝¹ ⟶ X✝¹
idem✝¹ : p✝¹ ≫ p✝¹ = p✝¹
X✝ : C
p✝ : X✝ ⟶ X✝
idem✝ : p✝ ≫ p✝ = p✝
h_X : X✝¹ = X✝
h_p : p✝¹ ≫ eqToHom h_X = eqToHom h_X ≫ p✝
⊢ mk X✝¹ p✝¹ = mk X✝ p✝

tactic: simpa only [mk.injEq, heq_eq_eq, true_and, eqToHom_refl, comp_id, id_comp] using h_p
state_before: case mk.mk
C : Type u_1
inst✝ : Category C
X✝ : C
p✝¹ : X✝ ⟶ X✝
idem✝¹ : p✝¹ ≫ p✝¹ = p✝¹
p✝ : X✝ ⟶ X✝
idem✝ : p✝ ≫ p✝ = p✝
h_p : p✝¹ ≫ eqToHom (_ : X✝ = X✝) = eqToHom (_ : X✝ = X✝) ≫ p✝
⊢ mk X✝ p✝¹ = mk X✝ p✝
Theorem: Finset.diag_mem_sym2_iff
File: Mathlib/Data/Finset/Sym.lean

tactic: simp [diag_mem_sym2_mem_iff]
state_before: α : Type u_1
inst✝ : DecidableEq α
s t : Finset α
a b : α
m : Sym2 α
⊢ Sym2.diag a ∈ Finset.sym2 s ↔ a ∈ s
Theorem: nnnorm_multiset_prod_le
File: Mathlib/Analysis/Normed/Group/Basic.lean

tactic: push_cast
state_before: 𝓕 : Type ?u.1102052
𝕜 : Type ?u.1102055
α : Type ?u.1102058
ι : Type ?u.1102061
κ : Type ?u.1102064
E : Type u_1
F : Type ?u.1102070
G : Type ?u.1102073
inst✝¹ : SeminormedCommGroup E
inst✝ : SeminormedCommGroup F
a a₁ a₂ b b₁ b₂ : E
r r₁ r₂ : ℝ
m : Multiset E
⊢ ↑‖Multiset.prod m‖₊ ≤ ↑(Multiset.sum (Multiset.map (fun x => ‖x‖₊) m))

tactic: rw [Multiset.map_map]
state_before: 𝓕 : Type ?u.1102052
𝕜 : Type ?u.1102055
α : Type ?u.1102058
ι : Type ?u.1102061
κ : Type ?u.1102064
E : Type u_1
F : Type ?u.1102070
G : Type ?u.1102073
inst✝¹ : SeminormedCommGroup E
inst✝ : SeminormedCommGroup F
a a₁ a₂ b b₁ b₂ : E
r r₁ r₂ : ℝ
m : Multiset E
⊢ ‖Multiset.prod m‖ ≤ Multiset.sum (Multiset.map toReal (Multiset.map (fun x => ‖x‖₊) m))

tactic: exact norm_multiset_prod_le _
state_before: 𝓕 : Type ?u.1102052
𝕜 : Type ?u.1102055
α : Type ?u.1102058
ι : Type ?u.1102061
κ : Type ?u.1102064
E : Type u_1
F : Type ?u.1102070
G : Type ?u.1102073
inst✝¹ : SeminormedCommGroup E
inst✝ : SeminormedCommGroup F
a a₁ a₂ b b₁ b₂ : E
r r₁ r₂ : ℝ
m : Multiset E
⊢ ‖Multiset.prod m‖ ≤ Multiset.sum (Multiset.map (toReal ∘ fun x => ‖x‖₊) m)
Theorem: Complex.norm_eventually_eq_of_isLocalMax
File: Mathlib/Analysis/Complex/AbsMax.lean

tactic: rcases nhds_basis_closedBall.eventually_iff.1 (hd.and hc) with ⟨r, hr₀, hr⟩
state_before: E : Type u
inst✝³ : NormedAddCommGroup E
inst✝² : NormedSpace ℂ E
F : Type v
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedSpace ℂ F
f : E → F
c : E
hd : ∀ᶠ (z : E) in 𝓝 c, DifferentiableAt ℂ f z
hc : IsLocalMax (norm ∘ f) c
⊢ ∀ᶠ (y : E) in 𝓝 c, ‖f y‖ = ‖f c‖

tactic: exact nhds_basis_closedBall.eventually_iff.2
  ⟨r, hr₀, norm_eqOn_closedBall_of_isMaxOn (DifferentiableOn.diffContOnCl fun x hx =>
      (hr <| closure_ball_subset_closedBall hx).1.differentiableWithinAt) fun x hx =>
    (hr <| ball_subset_closedBall hx).2⟩
state_before: case intro.intro
E : Type u
inst✝³ : NormedAddCommGroup E
inst✝² : NormedSpace ℂ E
F : Type v
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedSpace ℂ F
f : E → F
c : E
hd : ∀ᶠ (z : E) in 𝓝 c, DifferentiableAt ℂ f z
hc : IsLocalMax (norm ∘ f) c
r : ℝ
hr₀ : 0 < r
hr : ∀ ⦃x : E⦄, x ∈ closedBall c r → DifferentiableAt ℂ f x ∧ (fun x => (norm ∘ f) x ≤ (norm ∘ f) c) x
⊢ ∀ᶠ (y : E) in 𝓝 c, ‖f y‖ = ‖f c‖
Theorem: PadicInt.norm_eq_pow_val
File: Mathlib/NumberTheory/Padics/PadicIntegers.lean

tactic: refine @Padic.norm_eq_pow_val p hp x ?_
state_before: p : ℕ
hp : Fact (Nat.Prime p)
x : ℤ_[p]
hx : x ≠ 0
⊢ ‖x‖ = ↑p ^ (-valuation x)

tactic: contrapose! hx
state_before: p : ℕ
hp : Fact (Nat.Prime p)
x : ℤ_[p]
hx : x ≠ 0
⊢ ↑x ≠ 0

tactic: exact Subtype.val_injective hx
state_before: p : ℕ
hp : Fact (Nat.Prime p)
x : ℤ_[p]
hx : ↑x = 0
⊢ x = 0
Theorem: CategoryTheory.Limits.IsInitial.hom_ext
File: Mathlib/CategoryTheory/Limits/Shapes/Terminal.lean

tactic: aesop_cat
state_before: C : Type u₁
inst✝ : Category C
X Y : C
t : IsInitial X
f g : X ⟶ Y
⊢ ∀ (j : Discrete PEmpty), (asEmptyCocone X).ι.app j ≫ f = (asEmptyCocone X).ι.app j ≫ g
Theorem: ADEInequality.admissible_of_one_lt_sumInv_aux'
File: Mathlib/NumberTheory/ADEInequality.lean

tactic: have hp3 : p < 3 := lt_three hpq hqr H
state_before: p q r : ℕ+
hpq : p ≤ q
hqr : q ≤ r
H : 1 < sumInv {p, q, r}
⊢ Admissible {p, q, r}

tactic: replace hp3 := Finset.mem_Iio.mpr hp3
state_before: p q r : ℕ+
hpq : p ≤ q
hqr : q ≤ r
H : 1 < sumInv {p, q, r}
hp3 : p < 3
⊢ Admissible {p, q, r}

tactic: conv at hp3 => change p ∈ ({1, 2} : Multiset ℕ+)
state_before: p q r : ℕ+
hpq : p ≤ q
hqr : q ≤ r
H : 1 < sumInv {p, q, r}
hp3 : p ∈ Finset.Iio 3
⊢ Admissible {p, q, r}

tactic: fin_cases hp3
state_before: p q r : ℕ+
hpq : p ≤ q
hqr : q ≤ r
H : 1 < sumInv {p, q, r}
hp3 : p ∈ {1, 2}
⊢ Admissible {p, q, r}

tactic: have hq4 : q < 4 := lt_four hqr H
state_before: case tail.head
q r : ℕ+
hqr : q ≤ r
hpq : 2 ≤ q
H : 1 < sumInv {2, q, r}
⊢ Admissible {2, q, r}

tactic: replace hq4 := Finset.mem_Ico.mpr ⟨hpq, hq4⟩
state_before: case tail.head
q r : ℕ+
hqr : q ≤ r
hpq : 2 ≤ q
H : 1 < sumInv {2, q, r}
hq4 : q < 4
⊢ Admissible {2, q, r}

tactic: clear hpq
state_before: case tail.head
q r : ℕ+
hqr : q ≤ r
hpq : 2 ≤ q
H : 1 < sumInv {2, q, r}
hq4 : q ∈ Finset.Ico 2 4
⊢ Admissible {2, q, r}

tactic: conv at hq4 => change q ∈ ({2, 3} : Multiset ℕ+)
state_before: case tail.head
q r : ℕ+
hqr : q ≤ r
H : 1 < sumInv {2, q, r}
hq4 : q ∈ Finset.Ico 2 4
⊢ Admissible {2, q, r}

tactic: fin_cases hq4
state_before: case tail.head
q r : ℕ+
hqr : q ≤ r
H : 1 < sumInv {2, q, r}
hq4 : q ∈ {2, 3}
⊢ Admissible {2, q, r}

tactic: have hr6 : r < 6 := lt_six H
state_before: case tail.head.tail.head
r : ℕ+
hqr : 3 ≤ r
H : 1 < sumInv {2, 3, r}
⊢ Admissible {2, 3, r}

tactic: replace hr6 := Finset.mem_Ico.mpr ⟨hqr, hr6⟩
state_before: case tail.head.tail.head
r : ℕ+
hqr : 3 ≤ r
H : 1 < sumInv {2, 3, r}
hr6 : r < 6
⊢ Admissible {2, 3, r}

tactic: clear hqr
state_before: case tail.head.tail.head
r : ℕ+
hqr : 3 ≤ r
H : 1 < sumInv {2, 3, r}
hr6 : r ∈ Finset.Ico 3 6
⊢ Admissible {2, 3, r}

tactic: conv at hr6 => change r ∈ ({3, 4, 5} : Multiset ℕ+)
state_before: case tail.head.tail.head
r : ℕ+
H : 1 < sumInv {2, 3, r}
hr6 : r ∈ Finset.Ico 3 6
⊢ Admissible {2, 3, r}

tactic: fin_cases hr6
state_before: case tail.head.tail.head
r : ℕ+
H : 1 < sumInv {2, 3, r}
hr6 : r ∈ {3, 4, 5}
⊢ Admissible {2, 3, r}

tactic: exact admissible_A' q r
state_before: case head
q r : ℕ+
hqr : q ≤ r
hpq : 1 ≤ q
H : 1 < sumInv {1, q, r}
⊢ Admissible {1, q, r}

tactic: exact admissible_D' r
state_before: case tail.head.head
r : ℕ+
hqr : 2 ≤ r
H : 1 < sumInv {2, 2, r}
⊢ Admissible {2, 2, r}

tactic: exact admissible_E6
state_before: case tail.head.tail.head.head
H : 1 < sumInv {2, 3, 3}
⊢ Admissible {2, 3, 3}

tactic: exact admissible_E7
state_before: case tail.head.tail.head.tail.head
H : 1 < sumInv {2, 3, 4}
⊢ Admissible {2, 3, 4}

tactic: exact admissible_E8
state_before: case tail.head.tail.head.tail.tail.head
H : 1 < sumInv {2, 3, 5}
⊢ Admissible {2, 3, 5}
Theorem: uniformGroup_iInf
File: Mathlib/Topology/Algebra/UniformGroup.lean

tactic: rw [← sInf_range]
state_before: α : Type ?u.118853
β : Type u_2
inst✝³ : UniformSpace α
inst✝² : Group α
inst✝¹ : UniformGroup α
inst✝ : Group β
ι : Sort u_1
us' : ι → UniformSpace β
h' : ∀ (i : ι), UniformGroup β
⊢ UniformGroup β

tactic: exact uniformGroup_sInf (Set.forall_range_iff.mpr h')
state_before: α : Type ?u.118853
β : Type u_2
inst✝³ : UniformSpace α
inst✝² : Group α
inst✝¹ : UniformGroup α
inst✝ : Group β
ι : Sort u_1
us' : ι → UniformSpace β
h' : ∀ (i : ι), UniformGroup β
⊢ UniformGroup β
Theorem: inv_zpow
File: Mathlib/Algebra/GroupPower/Basic.lean

tactic: rw [zpow_ofNat, zpow_ofNat, inv_pow]
state_before: α : Type u_1
M : Type u
N : Type v
G : Type w
H : Type x
A : Type y
B : Type z
R : Type u₁
S : Type u₂
inst✝ : DivisionMonoid α
a✝ b a : α
n : ℕ
⊢ a⁻¹ ^ ↑n = (a ^ ↑n)⁻¹

tactic: rw [zpow_negSucc, zpow_negSucc, inv_pow]
state_before: α : Type u_1
M : Type u
N : Type v
G : Type w
H : Type x
A : Type y
B : Type z
R : Type u₁
S : Type u₂
inst✝ : DivisionMonoid α
a✝ b a : α
n : ℕ
⊢ a⁻¹ ^ Int.negSucc n = (a ^ Int.negSucc n)⁻¹
Theorem: IsGroupHom.map_div
File: Mathlib/Deprecated/Group.lean

tactic: simp_rw [div_eq_mul_inv, hf.map_mul, hf.map_inv]
state_before: α : Type u
β : Type v
inst✝¹ : Group α
inst✝ : Group β
f : α → β
hf✝ hf : IsGroupHom f
a b : α
⊢ f (a / b) = f a / f b
Theorem: Int.sign_mul_abs
File: Mathlib/Data/Int/Order/Basic.lean

tactic: rw [abs_eq_natAbs, sign_mul_natAbs a]
state_before: a : ℤ
⊢ sign a * abs a = a
Theorem: TopologicalSpace.Opens.adjunction_counit_map_functor
File: Mathlib/Topology/Category/TopCat/Opens.lean

tactic: dsimp
state_before: X : TopCat
U : Opens ↑X
V : Opens { x // x ∈ U }
⊢ (map (inclusion U) ⋙ IsOpenMap.functor (_ : IsOpenMap ((forget TopCat).map (inclusion U)))).obj
      ((IsOpenMap.functor (_ : IsOpenMap ((forget TopCat).map (inclusion U)))).obj V) =
    (𝟭 (Opens ↑X)).obj ((IsOpenMap.functor (_ : IsOpenMap ((forget TopCat).map (inclusion U)))).obj V)

tactic: rw [map_functor_eq V]
state_before: X : TopCat
U : Opens ↑X
V : Opens { x // x ∈ U }
⊢ (IsOpenMap.functor (_ : IsOpenMap ((forget TopCat).map (inclusion U)))).obj
      ((map (inclusion U)).obj ((IsOpenMap.functor (_ : IsOpenMap ((forget TopCat).map (inclusion U)))).obj V)) =
    (IsOpenMap.functor (_ : IsOpenMap ((forget TopCat).map (inclusion U)))).obj V

tactic: apply Subsingleton.elim
state_before: X : TopCat
U : Opens ↑X
V : Opens { x // x ∈ U }
⊢ (IsOpenMap.adjunction (_ : IsOpenMap ((forget TopCat).map (inclusion U)))).counit.app
      ((IsOpenMap.functor (_ : IsOpenMap ((forget TopCat).map (inclusion U)))).obj V) =
    eqToHom
      (_ :
        (map (inclusion U) ⋙ IsOpenMap.functor (_ : IsOpenMap ((forget TopCat).map (inclusion U)))).obj
            ((IsOpenMap.functor (_ : IsOpenMap ((forget TopCat).map (inclusion U)))).obj V) =
          (𝟭 (Opens ↑X)).obj ((IsOpenMap.functor (_ : IsOpenMap ((forget TopCat).map (inclusion U)))).obj V))