tasksource/leandojo huggingface dataset:
Theorem: List.eq_of_prod_take_eq
File: Mathlib/Data/List/BigOperators/Basic.lean

tactic: refine ext_get h fun i h₁ h₂ => ?_
state_before: ι : Type ?u.124973
α : Type ?u.124976
M : Type u_1
N : Type ?u.124982
P : Type ?u.124985
M₀ : Type ?u.124988
G : Type ?u.124991
R : Type ?u.124994
inst✝ : LeftCancelMonoid M
L L' : List M
h : length L = length L'
h' : ∀ (i : ℕ), i ≤ length L → prod (take i L) = prod (take i L')
⊢ L = L'

tactic: have : (L.take (i + 1)).prod = (L'.take (i + 1)).prod := h' _ (Nat.succ_le_of_lt h₁)
state_before: ι : Type ?u.124973
α : Type ?u.124976
M : Type u_1
N : Type ?u.124982
P : Type ?u.124985
M₀ : Type ?u.124988
G : Type ?u.124991
R : Type ?u.124994
inst✝ : LeftCancelMonoid M
L L' : List M
h : length L = length L'
h' : ∀ (i : ℕ), i ≤ length L → prod (take i L) = prod (take i L')
i : ℕ
h₁ : i < length L
h₂ : i < length L'
⊢ get L { val := i, isLt := h₁ } = get L' { val := i, isLt := h₂ }

tactic: rw [prod_take_succ L i h₁, prod_take_succ L' i h₂, h' i (le_of_lt h₁)] at this
state_before: ι : Type ?u.124973
α : Type ?u.124976
M : Type u_1
N : Type ?u.124982
P : Type ?u.124985
M₀ : Type ?u.124988
G : Type ?u.124991
R : Type ?u.124994
inst✝ : LeftCancelMonoid M
L L' : List M
h : length L = length L'
h' : ∀ (i : ℕ), i ≤ length L → prod (take i L) = prod (take i L')
i : ℕ
h₁ : i < length L
h₂ : i < length L'
this : prod (take (i + 1) L) = prod (take (i + 1) L')
⊢ get L { val := i, isLt := h₁ } = get L' { val := i, isLt := h₂ }

tactic: convert mul_left_cancel this
state_before: ι : Type ?u.124973
α : Type ?u.124976
M : Type u_1
N : Type ?u.124982
P : Type ?u.124985
M₀ : Type ?u.124988
G : Type ?u.124991
R : Type ?u.124994
inst✝ : LeftCancelMonoid M
L L' : List M
h : length L = length L'
h' : ∀ (i : ℕ), i ≤ length L → prod (take i L) = prod (take i L')
i : ℕ
h₁ : i < length L
h₂ : i < length L'
this : prod (take i L') * nthLe L i h₁ = prod (take i L') * nthLe L' i h₂
⊢ get L { val := i, isLt := h₁ } = get L' { val := i, isLt := h₂ }
Theorem: add_self_div_two
File: Mathlib/Algebra/Order/Field/Basic.lean

tactic: rw [← mul_two, mul_div_cancel a two_ne_zero]
state_before: ι : Type ?u.90856
α : Type u_1
β : Type ?u.90862
inst✝ : LinearOrderedSemifield α
a✝ b c d e : α
m n : ℤ
a : α
⊢ (a + a) / 2 = a
Theorem: ZMod.ne_neg_self
File: Mathlib/Data/ZMod/Basic.lean

tactic: have : a.val ≤ n / 2 ↔ (n : ℕ) / 2 < (-a).val := le_div_two_iff_lt_neg n ha
state_before: n : ℕ
hn : Fact (n % 2 = 1)
a : ZMod n
ha : a ≠ 0
h : a = -a
⊢ False

tactic: rwa [← h, ← not_lt, ← not_iff, iff_self, not_true] at this
state_before: n : ℕ
hn : Fact (n % 2 = 1)
a : ZMod n
ha : a ≠ 0
h : a = -a
this : val a ≤ n / 2 ↔ n / 2 < val (-a)
⊢ False
Theorem: smul_cancel_of_non_zero_divisor
File: Mathlib/GroupTheory/GroupAction/Basic.lean

tactic: rw [← sub_eq_zero]
state_before: α : Type u
β : Type v
γ : Type w
M : Type u_1
R : Type u_2
inst✝² : Monoid M
inst✝¹ : NonUnitalNonAssocRing R
inst✝ : DistribMulAction M R
k : M
h : ∀ (x : R), k • x = 0 → x = 0
a b : R
h' : k • a = k • b
⊢ a = b

tactic: refine' h _ _
state_before: α : Type u
β : Type v
γ : Type w
M : Type u_1
R : Type u_2
inst✝² : Monoid M
inst✝¹ : NonUnitalNonAssocRing R
inst✝ : DistribMulAction M R
k : M
h : ∀ (x : R), k • x = 0 → x = 0
a b : R
h' : k • a = k • b
⊢ a - b = 0

tactic: rw [smul_sub, h', sub_self]
state_before: α : Type u
β : Type v
γ : Type w
M : Type u_1
R : Type u_2
inst✝² : Monoid M
inst✝¹ : NonUnitalNonAssocRing R
inst✝ : DistribMulAction M R
k : M
h : ∀ (x : R), k • x = 0 → x = 0
a b : R
h' : k • a = k • b
⊢ k • (a - b) = 0
Theorem: Ordinal.enum_zero_eq_bot
File: Mathlib/SetTheory/Ordinal/Basic.lean

tactic: rwa [type_lt]
state_before: α : Type ?u.207159
β : Type ?u.207162
γ : Type ?u.207165
r : α → α → Prop
s : β → β → Prop
t : γ → γ → Prop
o : Ordinal
ho : 0 < o
⊢ 0 < type fun x x_1 => x < x_1
Theorem: cthickening_ball
File: Mathlib/Analysis/NormedSpace/Pointwise.lean

tactic: rw [← thickening_singleton, cthickening_thickening hε hδ,
    cthickening_singleton _ (add_nonneg hε hδ.le)]
state_before: 𝕜 : Type ?u.447208
E : Type u_1
inst✝³ : NormedField 𝕜
inst✝² : SeminormedAddCommGroup E
inst✝¹ : NormedSpace 𝕜 E
inst✝ : NormedSpace ℝ E
x✝ y z : E
δ ε : ℝ
hε : 0 ≤ ε
hδ : 0 < δ
x : E
⊢ cthickening ε (Metric.ball x δ) = Metric.closedBall x (ε + δ)
Theorem: Function.disjoint_mulSupport_iff
File: Mathlib/Algebra/Support.lean

tactic: rw [disjoint_comm, mulSupport_disjoint_iff]
state_before: α : Type u_1
β : Type ?u.4262
A : Type ?u.4265
B : Type ?u.4268
M : Type u_2
N : Type ?u.4274
P : Type ?u.4277
R : Type ?u.4280
S : Type ?u.4283
G : Type ?u.4286
M₀ : Type ?u.4289
G₀ : Type ?u.4292
ι : Sort ?u.4295
inst✝² : One M
inst✝¹ : One N
inst✝ : One P
f : α → M
s : Set α
⊢ Disjoint s (mulSupport f) ↔ EqOn f 1 s
Theorem: Multiset.count_map_eq_count'
File: Mathlib/Data/Multiset/Basic.lean

tactic: by_cases H : x ∈ s
state_before: α : Type u_2
β : Type u_1
γ : Type ?u.418813
inst✝¹ : DecidableEq α
inst✝ : DecidableEq β
f : α → β
s : Multiset α
hf : Injective f
x : α
⊢ count (f x) (map f s) = count x s

tactic: exact count_map_eq_count f _ (Set.injOn_of_injective hf _) _ H
state_before: case pos
α : Type u_2
β : Type u_1
γ : Type ?u.418813
inst✝¹ : DecidableEq α
inst✝ : DecidableEq β
f : α → β
s : Multiset α
hf : Injective f
x : α
H : x ∈ s
⊢ count (f x) (map f s) = count x s

tactic: rw [count_eq_zero_of_not_mem H, count_eq_zero, mem_map]
state_before: case neg
α : Type u_2
β : Type u_1
γ : Type ?u.418813
inst✝¹ : DecidableEq α
inst✝ : DecidableEq β
f : α → β
s : Multiset α
hf : Injective f
x : α
H : ¬x ∈ s
⊢ count (f x) (map f s) = count x s

tactic: rintro ⟨k, hks, hkx⟩
state_before: case neg
α : Type u_2
β : Type u_1
γ : Type ?u.418813
inst✝¹ : DecidableEq α
inst✝ : DecidableEq β
f : α → β
s : Multiset α
hf : Injective f
x : α
H : ¬x ∈ s
⊢ ¬∃ a, a ∈ s ∧ f a = f x

tactic: rw [hf hkx] at hks
state_before: case neg.intro.intro
α : Type u_2
β : Type u_1
γ : Type ?u.418813
inst✝¹ : DecidableEq α
inst✝ : DecidableEq β
f : α → β
s : Multiset α
hf : Injective f
x : α
H : ¬x ∈ s
k : α
hks : k ∈ s
hkx : f k = f x
⊢ False

tactic: contradiction
state_before: case neg.intro.intro
α : Type u_2
β : Type u_1
γ : Type ?u.418813
inst✝¹ : DecidableEq α
inst✝ : DecidableEq β
f : α → β
s : Multiset α
hf : Injective f
x : α
H : ¬x ∈ s
k : α
hks : x ∈ s
hkx : f k = f x
⊢ False
Theorem: NormedSpace.sphere_nonempty
File: Mathlib/Analysis/NormedSpace/Pointwise.lean

tactic: obtain ⟨y, hy⟩ := exists_ne x
state_before: 𝕜 : Type ?u.1764162
E : Type u_1
inst✝⁴ : NormedField 𝕜
inst✝³ : NormedAddCommGroup E
inst✝² : NormedSpace 𝕜 E
inst✝¹ : NormedSpace ℝ E
inst✝ : Nontrivial E
x : E
r : ℝ
⊢ Set.Nonempty (sphere x r) ↔ 0 ≤ r

tactic: refine' ⟨fun h => nonempty_closedBall.1 (h.mono sphere_subset_closedBall), fun hr =>
  ⟨r • ‖y - x‖⁻¹ • (y - x) + x, _⟩⟩
state_before: case intro
𝕜 : Type ?u.1764162
E : Type u_1
inst✝⁴ : NormedField 𝕜
inst✝³ : NormedAddCommGroup E
inst✝² : NormedSpace 𝕜 E
inst✝¹ : NormedSpace ℝ E
inst✝ : Nontrivial E
x : E
r : ℝ
y : E
hy : y ≠ x
⊢ Set.Nonempty (sphere x r) ↔ 0 ≤ r

tactic: have : ‖y - x‖ ≠ 0 := by simpa [sub_eq_zero]
state_before: case intro
𝕜 : Type ?u.1764162
E : Type u_1
inst✝⁴ : NormedField 𝕜
inst✝³ : NormedAddCommGroup E
inst✝² : NormedSpace 𝕜 E
inst✝¹ : NormedSpace ℝ E
inst✝ : Nontrivial E
x : E
r : ℝ
y : E
hy : y ≠ x
hr : 0 ≤ r
⊢ r • ‖y - x‖⁻¹ • (y - x) + x ∈ sphere x r

tactic: simp [norm_smul, this, Real.norm_of_nonneg hr]
state_before: case intro
𝕜 : Type ?u.1764162
E : Type u_1
inst✝⁴ : NormedField 𝕜
inst✝³ : NormedAddCommGroup E
inst✝² : NormedSpace 𝕜 E
inst✝¹ : NormedSpace ℝ E
inst✝ : Nontrivial E
x : E
r : ℝ
y : E
hy : y ≠ x
hr : 0 ≤ r
this : ‖y - x‖ ≠ 0
⊢ r • ‖y - x‖⁻¹ • (y - x) + x ∈ sphere x r

tactic: rw [inv_mul_cancel this, mul_one, abs_eq_self.mpr hr]
state_before: case intro
𝕜 : Type ?u.1764162
E : Type u_1
inst✝⁴ : NormedField 𝕜
inst✝³ : NormedAddCommGroup E
inst✝² : NormedSpace 𝕜 E
inst✝¹ : NormedSpace ℝ E
inst✝ : Nontrivial E
x : E
r : ℝ
y : E
hy : y ≠ x
hr : 0 ≤ r
this : ‖y - x‖ ≠ 0
⊢ abs r * (‖y - x‖⁻¹ * ‖y - x‖) = r

tactic: simpa [sub_eq_zero]
state_before: 𝕜 : Type ?u.1764162
E : Type u_1
inst✝⁴ : NormedField 𝕜
inst✝³ : NormedAddCommGroup E
inst✝² : NormedSpace 𝕜 E
inst✝¹ : NormedSpace ℝ E
inst✝ : Nontrivial E
x : E
r : ℝ
y : E
hy : y ≠ x
hr : 0 ≤ r
⊢ ‖y - x‖ ≠ 0
Theorem: MvPolynomial.degree_finSuccEquiv
File: Mathlib/Data/MvPolynomial/Equiv.lean

tactic: have h₀ : ∀ {α β : Type _} (f : α → β), (fun x => x) ∘ f = f := fun f => rfl
state_before: R : Type u
S₁ : Type v
S₂ : Type w
S₃ : Type x
σ : Type ?u.1335767
a a' a₁ a₂ : R
e : ℕ
s : σ →₀ ℕ
inst✝ : CommSemiring R
n : ℕ
f : MvPolynomial (Fin (n + 1)) R
h : f ≠ 0
⊢ degree (↑(finSuccEquiv R n) f) = ↑(degreeOf 0 f)

tactic: have h₁ : ∀ {α β : Type _} (f : α → β), f ∘ (fun x => x) = f := fun f => rfl
state_before: R : Type u
S₁ : Type v
S₂ : Type w
S₃ : Type x
σ : Type ?u.1335767
a a' a₁ a₂ : R
e : ℕ
s : σ →₀ ℕ
inst✝ : CommSemiring R
n : ℕ
f : MvPolynomial (Fin (n + 1)) R
h : f ≠ 0
h₀ : ∀ {α : Type ?u.1350795} {β : Type ?u.1350798} (f : α → β), (fun x => x) ∘ f = f
⊢ degree (↑(finSuccEquiv R n) f) = ↑(degreeOf 0 f)

tactic: have h₂ : WithBot.some = Nat.cast := rfl
state_before: R : Type u
S₁ : Type v
S₂ : Type w
S₃ : Type x
σ : Type ?u.1335767
a a' a₁ a₂ : R
e : ℕ
s : σ →₀ ℕ
inst✝ : CommSemiring R
n : ℕ
f : MvPolynomial (Fin (n + 1)) R
h : f ≠ 0
h₀ : ∀ {α : Type ?u.1350795} {β : Type ?u.1350798} (f : α → β), (fun x => x) ∘ f = f
h₁ : ∀ {α : Type ?u.1350860} {β : Type ?u.1350863} (f : α → β), (f ∘ fun x => x) = f
⊢ degree (↑(finSuccEquiv R n) f) = ↑(degreeOf 0 f)

tactic: have h' : ((finSuccEquiv R n f).support.sup fun x => x) = degreeOf 0 f := by
  rw [degreeOf_eq_sup, finSuccEquiv_support f, Finset.sup_image, h₀]
state_before: R : Type u
S₁ : Type v
S₂ : Type w
S₃ : Type x
σ : Type ?u.1335767
a a' a₁ a₂ : R
e : ℕ
s : σ →₀ ℕ
inst✝ : CommSemiring R
n : ℕ
f : MvPolynomial (Fin (n + 1)) R
h : f ≠ 0
h₀ : ∀ {α : Type ?u.1350795} {β : Type ?u.1350798} (f : α → β), (fun x => x) ∘ f = f
h₁ : ∀ {α : Type ?u.1350860} {β : Type ?u.1350863} (f : α → β), (f ∘ fun x => x) = f
h₂ : WithBot.some = Nat.cast
⊢ degree (↑(finSuccEquiv R n) f) = ↑(degreeOf 0 f)

tactic: rw [Polynomial.degree, ← h', ← h₂, Finset.coe_sup_of_nonempty (support_finSuccEquiv_nonempty h),
  Finset.max_eq_sup_coe, h₁]
state_before: R : Type u
S₁ : Type v
S₂ : Type w
S₃ : Type x
σ : Type ?u.1335767
a a' a₁ a₂ : R
e : ℕ
s : σ →₀ ℕ
inst✝ : CommSemiring R
n : ℕ
f : MvPolynomial (Fin (n + 1)) R
h : f ≠ 0
h₀ : ∀ {α β : Type} (f : α → β), (fun x => x) ∘ f = f
h₁ : ∀ {α : Type ?u.1350860} {β : Type ?u.1350863} (f : α → β), (f ∘ fun x => x) = f
h₂ : WithBot.some = Nat.cast
h' : (Finset.sup (Polynomial.support (↑(finSuccEquiv R n) f)) fun x => x) = degreeOf 0 f
⊢ degree (↑(finSuccEquiv R n) f) = ↑(degreeOf 0 f)

tactic: rw [degreeOf_eq_sup, finSuccEquiv_support f, Finset.sup_image, h₀]
state_before: R : Type u
S₁ : Type v
S₂ : Type w
S₃ : Type x
σ : Type ?u.1335767
a a' a₁ a₂ : R
e : ℕ
s : σ →₀ ℕ
inst✝ : CommSemiring R
n : ℕ
f : MvPolynomial (Fin (n + 1)) R
h : f ≠ 0
h₀ : ∀ {α : Type ?u.1350795} {β : Type ?u.1350798} (f : α → β), (fun x => x) ∘ f = f
h₁ : ∀ {α : Type ?u.1350860} {β : Type ?u.1350863} (f : α → β), (f ∘ fun x => x) = f
h₂ : WithBot.some = Nat.cast
⊢ (Finset.sup (Polynomial.support (↑(finSuccEquiv R n) f)) fun x => x) = degreeOf 0 f
Theorem: Function.Periodic.const_smul₀
File: Mathlib/Algebra/Periodic.lean

tactic: by_cases ha : a = 0
state_before: α : Type u_1
β : Type u_3
γ : Type u_2
f g : α → β
c c₁ c₂ x✝ : α
inst✝² : AddCommMonoid α
inst✝¹ : DivisionSemiring γ
inst✝ : Module γ α
h : Periodic f c
a : γ
x : α
⊢ (fun x => f (a • x)) (x + a⁻¹ • c) = (fun x => f (a • x)) x

tactic: simp only [ha, zero_smul]
state_before: case pos
α : Type u_1
β : Type u_3
γ : Type u_2
f g : α → β
c c₁ c₂ x✝ : α
inst✝² : AddCommMonoid α
inst✝¹ : DivisionSemiring γ
inst✝ : Module γ α
h : Periodic f c
a : γ
x : α
ha : a = 0
⊢ (fun x => f (a • x)) (x + a⁻¹ • c) = (fun x => f (a • x)) x

tactic: simpa only [smul_add, smul_inv_smul₀ ha] using h (a • x)
state_before: case neg
α : Type u_1
β : Type u_3
γ : Type u_2
f g : α → β
c c₁ c₂ x✝ : α
inst✝² : AddCommMonoid α
inst✝¹ : DivisionSemiring γ
inst✝ : Module γ α
h : Periodic f c
a : γ
x : α
ha : ¬a = 0
⊢ (fun x => f (a • x)) (x + a⁻¹ • c) = (fun x => f (a • x)) x
Theorem: Polynomial.reverse_natDegree_le
File: Mathlib/Data/Polynomial/Reverse.lean

tactic: rw [natDegree_le_iff_degree_le, degree_le_iff_coeff_zero]
state_before: R : Type u_1
inst✝ : Semiring R
f✝ f : R[X]
⊢ natDegree (reverse f) ≤ natDegree f

tactic: intro n hn
state_before: R : Type u_1
inst✝ : Semiring R
f✝ f : R[X]
⊢ ∀ (m : ℕ), ↑(natDegree f) < ↑m → coeff (reverse f) m = 0

tactic: rw [Nat.cast_withBot, Nat.cast_withBot, WithBot.coe_lt_coe] at hn
state_before: R : Type u_1
inst✝ : Semiring R
f✝ f : R[X]
n : ℕ
hn : ↑(natDegree f) < ↑n
⊢ coeff (reverse f) n = 0

tactic: rw [coeff_reverse, revAt, Function.Embedding.coeFn_mk, if_neg (not_le_of_gt hn),
  coeff_eq_zero_of_natDegree_lt hn]
state_before: R : Type u_1
inst✝ : Semiring R
f✝ f : R[X]
n : ℕ
hn : natDegree f < n
⊢ coeff (reverse f) n = 0
Theorem: CategoryTheory.preimage_map
File: Mathlib/CategoryTheory/Functor/FullyFaithful.lean

tactic: simp
state_before: C : Type u₁
inst✝³ : Category C
D : Type u₂
inst✝² : Category D
F : C ⥤ D
inst✝¹ : Full F
inst✝ : Faithful F
X Y Z : C
f : X ⟶ Y
⊢ F.map (F.preimage (F.map f)) = F.map f
Theorem: Matrix.vecMulVec_cons
File: Mathlib/Data/Matrix/Notation.lean

tactic: ext (i j)
state_before: α : Type u
o n m : ℕ
m' : Type uₘ
n' : Type uₙ
o' : Type uₒ
a b : ℕ
inst✝ : Semiring α
v : m' → α
x : α
w : Fin n → α
⊢ vecMulVec v (vecCons x w) = fun i => v i • vecCons x w

tactic: rw [vecMulVec_apply, Pi.smul_apply, smul_eq_mul]
state_before: case a.h
α : Type u
o n m : ℕ
m' : Type uₘ
n' : Type uₙ
o' : Type uₒ
a b : ℕ
inst✝ : Semiring α
v : m' → α
x : α
w : Fin n → α
i : m'
j : Fin (Nat.succ n)
⊢ vecMulVec v (vecCons x w) i j = (v i • vecCons x w) j
Theorem: Decidable.and_iff_not_or_not
File: Std/Logic.lean

tactic: rw [← not_and, not_not]
state_before: a b : Prop
inst✝¹ : Decidable a
inst✝ : Decidable b
⊢ a ∧ b ↔ ¬(¬a ∨ ¬b)
Theorem: MeasureTheory.lintegral_fintype
File: Mathlib/MeasureTheory/Integral/Lebesgue.lean

tactic: rw [← lintegral_finset, Finset.coe_univ, Measure.restrict_univ]
state_before: α : Type u_1
β : Type ?u.1733938
γ : Type ?u.1733941
δ : Type ?u.1733944
m : MeasurableSpace α
μ ν : Measure α
inst✝¹ : MeasurableSingletonClass α
inst✝ : Fintype α
f : α → ℝ≥0∞
⊢ (∫⁻ (x : α), f x ∂μ) = ∑ x : α, f x * ↑↑μ {x}
Theorem: Fin.cast_succ_eq
File: Mathlib/Data/Fin/Basic.lean

tactic: simp
state_before: n m n' : ℕ
i : Fin n
h : Nat.succ n = Nat.succ n'
⊢ ↑(↑(cast h) (succ i)) = ↑(succ (↑(cast (_ : n = n')) i))
Theorem: Submodule.map₂_flip
File: Mathlib/Algebra/Module/Submodule/Bilinear.lean

tactic: rw [map₂_eq_span_image2, map₂_eq_span_image2, Set.image2_swap]
state_before: ι : Sort uι
R : Type u_1
M : Type u_2
N : Type u_4
P : Type u_3
inst✝⁶ : CommSemiring R
inst✝⁵ : AddCommMonoid M
inst✝⁴ : AddCommMonoid N
inst✝³ : AddCommMonoid P
inst✝² : Module R M
inst✝¹ : Module R N
inst✝ : Module R P
f : M →ₗ[R] N →ₗ[R] P
p : Submodule R M
q : Submodule R N
⊢ map₂ (LinearMap.flip f) q p = map₂ f p q

tactic: rfl
state_before: ι : Sort uι
R : Type u_1
M : Type u_2
N : Type u_4
P : Type u_3
inst✝⁶ : CommSemiring R
inst✝⁵ : AddCommMonoid M
inst✝⁴ : AddCommMonoid N
inst✝³ : AddCommMonoid P
inst✝² : Module R M
inst✝¹ : Module R N
inst✝ : Module R P
f : M →ₗ[R] N →ₗ[R] P
p : Submodule R M
q : Submodule R N
⊢ span R (image2 (fun a b => ↑(↑(LinearMap.flip f) b) a) ↑p ↑q) = span R (image2 (fun m n => ↑(↑f m) n) ↑p ↑q)
Theorem: hasSum_pi_single
File: Mathlib/Topology/Algebra/InfiniteSum/Basic.lean

tactic: convert hasSum_ite_eq b a
state_before: α : Type u_2
β : Type u_1
γ : Type ?u.43306
δ : Type ?u.43309
inst✝² : AddCommMonoid α
inst✝¹ : TopologicalSpace α
f g : β → α
a✝ b✝ : α
s : Finset β
inst✝ : DecidableEq β
b : β
a : α
⊢ HasSum (Pi.single b a) a

tactic: simp [Pi.single_apply]
state_before: case h.e'_5.h
α : Type u_2
β : Type u_1
γ : Type ?u.43306
δ : Type ?u.43309
inst✝² : AddCommMonoid α
inst✝¹ : TopologicalSpace α
f g : β → α
a✝ b✝ : α
s : Finset β
inst✝ : DecidableEq β
b : β
a : α
x✝ : β
⊢ Pi.single b a x✝ = if x✝ = b then a else 0
Theorem: Sylow.smul_eq_iff_mem_normalizer
File: Mathlib/GroupTheory/Sylow.lean

tactic: rw [eq_comm, SetLike.ext_iff, ← inv_mem_iff (G := G) (H := normalizer P.toSubgroup),
    mem_normalizer_iff, inv_inv]
state_before: p : ℕ
G : Type u_1
inst✝ : Group G
g : G
P : Sylow p G
⊢ g • P = P ↔ g ∈ normalizer ↑P

tactic: exact
  forall_congr' fun h =>
    iff_congr Iff.rfl
      ⟨fun ⟨a, b, c⟩ => c ▸ by simpa [mul_assoc] using b,
        fun hh => ⟨(MulAut.conj g)⁻¹ h, hh, MulAut.apply_inv_self G (MulAut.conj g) h⟩⟩
state_before: p : ℕ
G : Type u_1
inst✝ : Group G
g : G
P : Sylow p G
⊢ (∀ (x : G), x ∈ P ↔ x ∈ g • P) ↔ ∀ (h : G), h ∈ ↑P ↔ g⁻¹ * h * g ∈ ↑P

tactic: simpa [mul_assoc] using b
state_before: p : ℕ
G : Type u_1
inst✝ : Group G
g : G
P : Sylow p G
h : G
x✝ : h ∈ g • P
a : G
b : a ∈ ↑↑P
c : ↑(↑(MulDistribMulAction.toMonoidEnd (MulAut G) G) (↑MulAut.conj g)) a = h
⊢ g⁻¹ * ↑(↑(MulDistribMulAction.toMonoidEnd (MulAut G) G) (↑MulAut.conj g)) a * g ∈ ↑P
Theorem: CategoryTheory.Subobject.factors_zero
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✝ : HasZeroMorphisms C
X Y : C
P : Subobject Y
⊢ 0 ≫ MonoOver.arrow (representative.obj P) = 0
Theorem: Set.preimage_surjective
File: Mathlib/Data/Set/Image.lean

tactic: refine' ⟨fun h x x' hx => _, Injective.preimage_surjective⟩
state_before: α : Type u
β : Type v
f : α → β
⊢ Surjective (preimage f) ↔ Injective f

tactic: cases' h {x} with s hs
state_before: α : Type u
β : Type v
f : α → β
h : Surjective (preimage f)
x x' : α
hx : f x = f x'
⊢ x = x'

tactic: have := mem_singleton x
state_before: case intro
α : Type u
β : Type v
f : α → β
h : Surjective (preimage f)
x x' : α
hx : f x = f x'
s : Set β
hs : f ⁻¹' s = {x}
⊢ x = x'

tactic: rwa [← hs, mem_preimage, hx, ← mem_preimage, hs, mem_singleton_iff, eq_comm] at this
state_before: case intro
α : Type u
β : Type v
f : α → β
h : Surjective (preimage f)
x x' : α
hx : f x = f x'
s : Set β
hs : f ⁻¹' s = {x}
this : x ∈ {x}
⊢ x = x'
Theorem: Finset.coe_cons
File: Mathlib/Data/Finset/Basic.lean

tactic: ext
state_before: α : Type u_1
β : Type ?u.38954
γ : Type ?u.38957
s✝ t : Finset α
a✝ b a : α
s : Finset α
h : ¬a ∈ s
⊢ ↑(cons a s h) = insert a ↑s

tactic: simp
state_before: case h
α : Type u_1
β : Type ?u.38954
γ : Type ?u.38957
s✝ t : Finset α
a✝ b a : α
s : Finset α
h : ¬a ∈ s
x✝ : α
⊢ x✝ ∈ ↑(cons a s h) ↔ x✝ ∈ insert a ↑s
Theorem: HasStrictFDerivAt.add
File: Mathlib/Analysis/Calculus/FDeriv/Add.lean

tactic: simp only [LinearMap.sub_apply, LinearMap.add_apply, map_sub, map_add, add_apply]
state_before: 𝕜 : Type u_1
inst✝⁸ : NontriviallyNormedField 𝕜
E : Type u_2
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type u_3
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type ?u.108128
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
G' : Type ?u.108223
inst✝¹ : NormedAddCommGroup G'
inst✝ : NormedSpace 𝕜 G'
f f₀ f₁ g : E → F
f' f₀' f₁' g' e : E →L[𝕜] F
x : E
s t : Set E
L L₁ L₂ : Filter E
hf : HasStrictFDerivAt f f' x
hg : HasStrictFDerivAt g g' x
y : E × E
⊢ f y.fst - f y.snd - ↑f' (y.fst - y.snd) + (g y.fst - g y.snd - ↑g' (y.fst - y.snd)) =
    (fun y => f y + g y) y.fst - (fun y => f y + g y) y.snd - ↑(f' + g') (y.fst - y.snd)

tactic: abel
state_before: 𝕜 : Type u_1
inst✝⁸ : NontriviallyNormedField 𝕜
E : Type u_2
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type u_3
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type ?u.108128
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
G' : Type ?u.108223
inst✝¹ : NormedAddCommGroup G'
inst✝ : NormedSpace 𝕜 G'
f f₀ f₁ g : E → F
f' f₀' f₁' g' e : E →L[𝕜] F
x : E
s t : Set E
L L₁ L₂ : Filter E
hf : HasStrictFDerivAt f f' x
hg : HasStrictFDerivAt g g' x
y : E × E
⊢ f y.fst - f y.snd - (↑f' y.fst - ↑f' y.snd) + (g y.fst - g y.snd - (↑g' y.fst - ↑g' y.snd)) =
    f y.fst + g y.fst - (f y.snd + g y.snd) - (↑f' y.fst + ↑g' y.fst - (↑f' y.snd + ↑g' y.snd))
Theorem: NormedAddGroupHom.norm_id
File: Mathlib/Analysis/Normed/Group/Hom.lean

tactic: refine' norm_id_of_nontrivial_seminorm V _
state_before: V✝ : Type ?u.320637
V₁ : Type ?u.320640
V₂ : Type ?u.320643
V₃ : Type ?u.320646
inst✝⁵ : SeminormedAddCommGroup V✝
inst✝⁴ : SeminormedAddCommGroup V₁
inst✝³ : SeminormedAddCommGroup V₂
inst✝² : SeminormedAddCommGroup V₃
f g : NormedAddGroupHom V₁ V₂
V : Type u_1
inst✝¹ : NormedAddCommGroup V
inst✝ : Nontrivial V
⊢ ‖id V‖ = 1

tactic: obtain ⟨x, hx⟩ := exists_ne (0 : V)
state_before: V✝ : Type ?u.320637
V₁ : Type ?u.320640
V₂ : Type ?u.320643
V₃ : Type ?u.320646
inst✝⁵ : SeminormedAddCommGroup V✝
inst✝⁴ : SeminormedAddCommGroup V₁
inst✝³ : SeminormedAddCommGroup V₂
inst✝² : SeminormedAddCommGroup V₃
f g : NormedAddGroupHom V₁ V₂
V : Type u_1
inst✝¹ : NormedAddCommGroup V
inst✝ : Nontrivial V
⊢ ∃ x, ‖x‖ ≠ 0

tactic: exact ⟨x, ne_of_gt (norm_pos_iff.2 hx)⟩
state_before: case intro
V✝ : Type ?u.320637
V₁ : Type ?u.320640
V₂ : Type ?u.320643
V₃ : Type ?u.320646
inst✝⁵ : SeminormedAddCommGroup V✝
inst✝⁴ : SeminormedAddCommGroup V₁
inst✝³ : SeminormedAddCommGroup V₂
inst✝² : SeminormedAddCommGroup V₃
f g : NormedAddGroupHom V₁ V₂
V : Type u_1
inst✝¹ : NormedAddCommGroup V
inst✝ : Nontrivial V
x : V
hx : x ≠ 0
⊢ ∃ x, ‖x‖ ≠ 0
Theorem: Set.image2_right
File: Mathlib/Data/Set/NAry.lean

tactic: simp [nonempty_def.mp h, ext_iff]
state_before: α : Type u_1
α' : Type ?u.37462
β : Type u_2
β' : Type ?u.37468
γ : Type ?u.37471
γ' : Type ?u.37474
δ : Type ?u.37477
δ' : Type ?u.37480
ε : Type ?u.37483
ε' : Type ?u.37486
ζ : Type ?u.37489
ζ' : Type ?u.37492
ν : Type ?u.37495
f f' : α → β → γ
g g' : α → β → γ → δ
s s' : Set α
t t' : Set β
u u' : Set γ
v : Set δ
a a' : α
b b' : β
c c' : γ
d d' : δ
h : Set.Nonempty s
⊢ image2 (fun x y => y) s t = t