tasksource/leandojo huggingface dataset:
Theorem: UniversalEnvelopingAlgebra.lift_ι_apply
File: Mathlib/Algebra/Lie/UniversalEnveloping.lean

tactic: rw [← Function.comp_apply (f := lift R f) (g := ι R) (x := x), ι_comp_lift]
state_before: R : Type u₁
L : Type u₂
inst✝⁴ : CommRing R
inst✝³ : LieRing L
inst✝² : LieAlgebra R L
A : Type u₃
inst✝¹ : Ring A
inst✝ : Algebra R A
f : L →ₗ⁅R⁆ A
x : L
⊢ ↑(↑(lift R) f) (↑(ι R) x) = ↑f x
Theorem: le_himp_comm
File: Mathlib/Order/Heyting/Basic.lean

tactic: rw [le_himp_iff, le_himp_iff']
state_before: ι : Type ?u.26953
α : Type u_1
β : Type ?u.26959
inst✝ : GeneralizedHeytingAlgebra α
a b c d : α
⊢ a ≤ b ⇨ c ↔ b ≤ a ⇨ c
Theorem: Polynomial.Chebyshev.map_U
File: Mathlib/RingTheory/Polynomial/Chebyshev.lean

tactic: simp only [U_zero, Polynomial.map_one]
state_before: R : Type u_1
S : Type u_2
inst✝¹ : CommRing R
inst✝ : CommRing S
f : R →+* S
⊢ map f (U R 0) = U S 0

tactic: simp [U_one, map_X, Polynomial.map_mul, Polynomial.map_add, Polynomial.map_one]
state_before: R : Type u_1
S : Type u_2
inst✝¹ : CommRing R
inst✝ : CommRing S
f : R →+* S
⊢ map f (U R 1) = U S 1

tactic: simp only [U_add_two, Polynomial.map_mul, Polynomial.map_sub, map_X, Polynomial.map_add,
  Polynomial.map_one, map_U f (n + 1), map_U f n]
state_before: R : Type u_1
S : Type u_2
inst✝¹ : CommRing R
inst✝ : CommRing S
f : R →+* S
n : ℕ
⊢ map f (U R (n + 2)) = U S (n + 2)

tactic: norm_num
state_before: R : Type u_1
S : Type u_2
inst✝¹ : CommRing R
inst✝ : CommRing S
f : R →+* S
n : ℕ
⊢ map f 2 * X * U S (n + 1) - U S n = 2 * X * U S (n + 1) - U S n
Theorem: isEmpty_sum
File: Mathlib/Logic/IsEmpty.lean

tactic: simp only [← not_nonempty_iff, nonempty_sum, not_or]
state_before: α✝ : Sort ?u.3308
β✝ : Sort ?u.3311
γ : Sort ?u.3314
α : Type u_1
β : Type u_2
⊢ IsEmpty (α ⊕ β) ↔ IsEmpty α ∧ IsEmpty β
Theorem: Euclidean.nhds_basis_ball
File: Mathlib/Analysis/InnerProductSpace/EuclideanDist.lean

tactic: rw [toEuclidean.toHomeomorph.nhds_eq_comap x]
state_before: E : Type u_1
inst✝⁶ : AddCommGroup E
inst✝⁵ : TopologicalSpace E
inst✝⁴ : TopologicalAddGroup E
inst✝³ : T2Space E
inst✝² : Module ℝ E
inst✝¹ : ContinuousSMul ℝ E
inst✝ : FiniteDimensional ℝ E
x : E
⊢ Filter.HasBasis (𝓝 x) (fun r => 0 < r) (ball x)

tactic: exact Metric.nhds_basis_ball.comap _
state_before: E : Type u_1
inst✝⁶ : AddCommGroup E
inst✝⁵ : TopologicalSpace E
inst✝⁴ : TopologicalAddGroup E
inst✝³ : T2Space E
inst✝² : Module ℝ E
inst✝¹ : ContinuousSMul ℝ E
inst✝ : FiniteDimensional ℝ E
x : E
⊢ Filter.HasBasis
    (Filter.comap (↑(ContinuousLinearEquiv.toHomeomorph toEuclidean))
      (𝓝 (↑(ContinuousLinearEquiv.toHomeomorph toEuclidean) x)))
    (fun r => 0 < r) (ball x)
Theorem: mem_rootsOfUnity_prime_pow_mul_iff'
File: Mathlib/RingTheory/RootsOfUnity/Basic.lean

tactic: rw [← PNat.mk_coe p hp.1.pos, ← PNat.pow_coe, ← PNat.mul_coe, ← mem_rootsOfUnity,
  mem_rootsOfUnity_prime_pow_mul_iff]
state_before: M : Type ?u.1342912
N : Type ?u.1342915
G : Type ?u.1342918
R : Type u_1
S : Type ?u.1342924
F : Type ?u.1342927
inst✝⁵ : CommMonoid M
inst✝⁴ : CommMonoid N
inst✝³ : DivisionCommMonoid G
k✝ l : ℕ+
inst✝² : CommRing R
inst✝¹ : IsReduced R
p k : ℕ
m : ℕ+
hp : Fact (Nat.Prime p)
inst✝ : CharP R p
ζ : Rˣ
⊢ ζ ^ (p ^ k * ↑m) = 1 ↔ ζ ∈ rootsOfUnity m R
Theorem: not_neZero
File: Mathlib/Algebra/NeZero.lean

tactic: simp [neZero_iff]
state_before: R : Type u_1
inst✝ : Zero R
n : R
⊢ ¬NeZero n ↔ n = 0
Theorem: Hyperreal.infinitePos_mul_of_infiniteNeg_not_infinitesimal_neg
File: Mathlib/Data/Real/Hyperreal.lean

tactic: rw [← infinitePos_neg, ← neg_pos, ← neg_mul_neg, ← infinitesimal_neg]
state_before: x y : ℝ*
⊢ InfiniteNeg x → ¬Infinitesimal y → y < 0 → InfinitePos (x * y)

tactic: exact infinitePos_mul_of_infinitePos_not_infinitesimal_pos
state_before: x y : ℝ*
⊢ InfinitePos (-x) → ¬Infinitesimal (-y) → 0 < -y → InfinitePos (-x * -y)
Theorem: Ultrafilter.finite_sUnion_mem_iff
File: Mathlib/Order/Filter/Ultrafilter.lean

tactic: simp
state_before: α : Type u
β : Type v
γ : Type ?u.12991
f g : Ultrafilter α
s✝ t : Set α
p q : α → Prop
s : Set (Set α)
hs : Set.Finite s
⊢ ⋃₀ ∅ ∈ f ↔ ∃ t, t ∈ ∅ ∧ t ∈ f

tactic: simp [union_mem_iff, his, or_and_right, exists_or]
state_before: α : Type u
β : Type v
γ : Type ?u.12991
f g : Ultrafilter α
s✝¹ t : Set α
p q : α → Prop
s : Set (Set α)
hs : Set.Finite s
a✝ : Set α
s✝ : Set (Set α)
x✝¹ : ¬a✝ ∈ s✝
x✝ : Set.Finite s✝
his : ⋃₀ s✝ ∈ f ↔ ∃ t, t ∈ s✝ ∧ t ∈ f
⊢ ⋃₀ insert a✝ s✝ ∈ f ↔ ∃ t, t ∈ insert a✝ s✝ ∧ t ∈ f
Theorem: Matrix.dotProduct_eq
File: Mathlib/LinearAlgebra/Matrix/DotProduct.lean

tactic: funext x
state_before: R : Type v
n : Type w
inst✝¹ : Semiring R
inst✝ : Fintype n
v w : n → R
h : ∀ (u : n → R), v ⬝ᵥ u = w ⬝ᵥ u
⊢ v = w

tactic: classical rw [← dotProduct_stdBasis_one v x, ← dotProduct_stdBasis_one w x, h]
state_before: case h
R : Type v
n : Type w
inst✝¹ : Semiring R
inst✝ : Fintype n
v w : n → R
h : ∀ (u : n → R), v ⬝ᵥ u = w ⬝ᵥ u
x : n
⊢ v x = w x

tactic: rw [← dotProduct_stdBasis_one v x, ← dotProduct_stdBasis_one w x, h]
state_before: case h
R : Type v
n : Type w
inst✝¹ : Semiring R
inst✝ : Fintype n
v w : n → R
h : ∀ (u : n → R), v ⬝ᵥ u = w ⬝ᵥ u
x : n
⊢ v x = w x
Theorem: TopCat.Presheaf.coveringOfPresieve.iSup_eq_of_mem_grothendieck
File: Mathlib/Topology/Sheaves/SheafCondition/Sites.lean

tactic: apply le_antisymm
state_before: X : TopCat
U : Opens ↑X
R : Presieve U
hR : Sieve.generate R ∈ GrothendieckTopology.sieves (Opens.grothendieckTopology ↑X) U
⊢ iSup (coveringOfPresieve U R) = U

tactic: intro x hxU
state_before: case a
X : TopCat
U : Opens ↑X
R : Presieve U
hR : Sieve.generate R ∈ GrothendieckTopology.sieves (Opens.grothendieckTopology ↑X) U
⊢ U ≤ iSup (coveringOfPresieve U R)

tactic: rw [Opens.coe_iSup, Set.mem_iUnion]
state_before: case a
X : TopCat
U : Opens ↑X
R : Presieve U
hR : Sieve.generate R ∈ GrothendieckTopology.sieves (Opens.grothendieckTopology ↑X) U
x : ↑X
hxU : x ∈ ↑U
⊢ x ∈ ↑(iSup (coveringOfPresieve U R))

tactic: obtain ⟨V, iVU, ⟨W, iVW, iWU, hiWU, -⟩, hxV⟩ := hR x hxU
state_before: case a
X : TopCat
U : Opens ↑X
R : Presieve U
hR : Sieve.generate R ∈ GrothendieckTopology.sieves (Opens.grothendieckTopology ↑X) U
x : ↑X
hxU : x ∈ ↑U
⊢ ∃ i, x ∈ ↑(coveringOfPresieve U R i)

tactic: exact ⟨⟨W, ⟨iWU, hiWU⟩⟩, iVW.le hxV⟩
state_before: case a.intro.intro.intro.intro.intro.intro.intro
X : TopCat
U : Opens ↑X
R : Presieve U
hR : Sieve.generate R ∈ GrothendieckTopology.sieves (Opens.grothendieckTopology ↑X) U
x : ↑X
hxU : x ∈ ↑U
V : Opens ↑X
iVU : V ⟶ U
hxV : x ∈ V
W : Opens ↑X
iVW : V ⟶ W
iWU : W ⟶ U
hiWU : R iWU
⊢ ∃ i, x ∈ ↑(coveringOfPresieve U R i)

tactic: refine' iSup_le _
state_before: case a
X : TopCat
U : Opens ↑X
R : Presieve U
hR : Sieve.generate R ∈ GrothendieckTopology.sieves (Opens.grothendieckTopology ↑X) U
⊢ iSup (coveringOfPresieve U R) ≤ U

tactic: intro f
state_before: case a
X : TopCat
U : Opens ↑X
R : Presieve U
hR : Sieve.generate R ∈ GrothendieckTopology.sieves (Opens.grothendieckTopology ↑X) U
⊢ ∀ (i : (V : Opens ↑X) × { f // R f }), coveringOfPresieve U R i ≤ U

tactic: exact f.2.1.le
state_before: case a
X : TopCat
U : Opens ↑X
R : Presieve U
hR : Sieve.generate R ∈ GrothendieckTopology.sieves (Opens.grothendieckTopology ↑X) U
f : (V : Opens ↑X) × { f // R f }
⊢ coveringOfPresieve U R f ≤ U
Theorem: Finset.card_le_card_of_forall_subsingleton
File: Mathlib/Combinatorics/DoubleCounting.lean

tactic: classical
  rw [← mul_one s.card, ← mul_one t.card]
  exact card_mul_le_card_mul r
    (fun a h ↦ card_pos.2 (by
      rw [← coe_nonempty, coe_bipartiteAbove]
      exact hs _ h : (t.bipartiteAbove r a).Nonempty))
    (fun b h ↦ card_le_one.2 (by
      simp_rw [mem_bipartiteBelow]
      exact ht _ h))
state_before: α : Type u_1
β : Type u_2
r : α → β → Prop
s : Finset α
t : Finset β
a a' : α
b b' : β
inst✝¹ : DecidablePred (r a)
inst✝ : (a : α) → Decidable (r a b)
m n : ℕ
hs : ∀ (a : α), a ∈ s → ∃ b, b ∈ t ∧ r a b
ht : ∀ (b : β), b ∈ t → Set.Subsingleton {a | a ∈ s ∧ r a b}
⊢ card s ≤ card t

tactic: rw [← mul_one s.card, ← mul_one t.card]
state_before: α : Type u_1
β : Type u_2
r : α → β → Prop
s : Finset α
t : Finset β
a a' : α
b b' : β
inst✝¹ : DecidablePred (r a)
inst✝ : (a : α) → Decidable (r a b)
m n : ℕ
hs : ∀ (a : α), a ∈ s → ∃ b, b ∈ t ∧ r a b
ht : ∀ (b : β), b ∈ t → Set.Subsingleton {a | a ∈ s ∧ r a b}
⊢ card s ≤ card t

tactic: exact card_mul_le_card_mul r
  (fun a h ↦ card_pos.2 (by
    rw [← coe_nonempty, coe_bipartiteAbove]
    exact hs _ h : (t.bipartiteAbove r a).Nonempty))
  (fun b h ↦ card_le_one.2 (by
    simp_rw [mem_bipartiteBelow]
    exact ht _ h))
state_before: α : Type u_1
β : Type u_2
r : α → β → Prop
s : Finset α
t : Finset β
a a' : α
b b' : β
inst✝¹ : DecidablePred (r a)
inst✝ : (a : α) → Decidable (r a b)
m n : ℕ
hs : ∀ (a : α), a ∈ s → ∃ b, b ∈ t ∧ r a b
ht : ∀ (b : β), b ∈ t → Set.Subsingleton {a | a ∈ s ∧ r a b}
⊢ card s * 1 ≤ card t * 1

tactic: rw [← coe_nonempty, coe_bipartiteAbove]
state_before: α : Type u_1
β : Type u_2
r : α → β → Prop
s : Finset α
t : Finset β
a✝ a' : α
b b' : β
inst✝¹ : DecidablePred (r a✝)
inst✝ : (a : α) → Decidable (r a b)
m n : ℕ
hs : ∀ (a : α), a ∈ s → ∃ b, b ∈ t ∧ r a b
ht : ∀ (b : β), b ∈ t → Set.Subsingleton {a | a ∈ s ∧ r a b}
a : α
h : a ∈ s
⊢ Finset.Nonempty (bipartiteAbove r t a)

tactic: exact hs _ h
state_before: α : Type u_1
β : Type u_2
r : α → β → Prop
s : Finset α
t : Finset β
a✝ a' : α
b b' : β
inst✝¹ : DecidablePred (r a✝)
inst✝ : (a : α) → Decidable (r a b)
m n : ℕ
hs : ∀ (a : α), a ∈ s → ∃ b, b ∈ t ∧ r a b
ht : ∀ (b : β), b ∈ t → Set.Subsingleton {a | a ∈ s ∧ r a b}
a : α
h : a ∈ s
⊢ Set.Nonempty {b | b ∈ t ∧ r a b}

tactic: simp_rw [mem_bipartiteBelow]
state_before: α : Type u_1
β : Type u_2
r : α → β → Prop
s : Finset α
t : Finset β
a a' : α
b✝ b' : β
inst✝¹ : DecidablePred (r a)
inst✝ : (a : α) → Decidable (r a b✝)
m n : ℕ
hs : ∀ (a : α), a ∈ s → ∃ b, b ∈ t ∧ r a b
ht : ∀ (b : β), b ∈ t → Set.Subsingleton {a | a ∈ s ∧ r a b}
b : β
h : b ∈ t
⊢ ∀ (a : α), a ∈ bipartiteBelow r s b → ∀ (b_1 : α), b_1 ∈ bipartiteBelow r s b → a = b_1

tactic: exact ht _ h
state_before: α : Type u_1
β : Type u_2
r : α → β → Prop
s : Finset α
t : Finset β
a a' : α
b✝ b' : β
inst✝¹ : DecidablePred (r a)
inst✝ : (a : α) → Decidable (r a b✝)
m n : ℕ
hs : ∀ (a : α), a ∈ s → ∃ b, b ∈ t ∧ r a b
ht : ∀ (b : β), b ∈ t → Set.Subsingleton {a | a ∈ s ∧ r a b}
b : β
h : b ∈ t
⊢ ∀ (a : α), a ∈ s ∧ r a b → ∀ (b_1 : α), b_1 ∈ s ∧ r b_1 b → a = b_1
Theorem: List.Sublist.filterMap
File: Std/Data/List/Lemmas.lean

tactic: induction s <;> simp <;> split <;> simp [*, cons, cons₂]
state_before: α : Type u_1
β : Type u_2
l₁ l₂ : List α
f : α → Option β
s : l₁ <+ l₂
⊢ List.filterMap f l₁ <+ List.filterMap f l₂
Theorem: List.sublist_replicate_iff
File: Mathlib/Data/List/Basic.lean

tactic: rintro ⟨k, h, rfl⟩
state_before: ι : Type ?u.72813
α : Type u
β : Type v
γ : Type w
δ : Type x
l₁ l₂ l : List α
a : α
n : ℕ
⊢ (∃ k, k ≤ n ∧ l = replicate k a) → l <+ replicate n a

tactic: exact (replicate_sublist_replicate _).mpr h
state_before: case intro.intro
ι : Type ?u.72813
α : Type u
β : Type v
γ : Type w
δ : Type x
l₁ l₂ : List α
a : α
n k : ℕ
h : k ≤ n
⊢ replicate k a <+ replicate n a
Theorem: dense_closure
File: Mathlib/Topology/Basic.lean

tactic: rw [Dense, Dense, closure_closure]
state_before: α : Type u
β : Type v
ι : Sort w
a : α
s✝ s₁ s₂ t : Set α
p p₁ p₂ : α → Prop
inst✝ : TopologicalSpace α
s : Set α
⊢ Dense (closure s) ↔ Dense s
Theorem: Multiset.count_pos
File: Mathlib/Data/Multiset/Basic.lean

tactic: simp [count, countp_pos]
state_before: α : Type u_1
β : Type ?u.357322
γ : Type ?u.357325
inst✝ : DecidableEq α
a : α
s : Multiset α
⊢ 0 < count a s ↔ a ∈ s
Theorem: Ideal.Filtration.Stable.exists_forall_le
File: Mathlib/RingTheory/Filtration.lean

tactic: obtain ⟨n₀, hF⟩ := h
state_before: R M : Type u
inst✝² : CommRing R
inst✝¹ : AddCommGroup M
inst✝ : Module R M
I : Ideal R
F F' : Filtration I M
h✝ h : Stable F
e : N F 0 ≤ N F' 0
⊢ ∃ n₀, ∀ (n : ℕ), N F (n + n₀) ≤ N F' n

tactic: use n₀
state_before: case intro
R M : Type u
inst✝² : CommRing R
inst✝¹ : AddCommGroup M
inst✝ : Module R M
I : Ideal R
F F' : Filtration I M
h : Stable F
e : N F 0 ≤ N F' 0
n₀ : ℕ
hF : ∀ (n : ℕ), n ≥ n₀ → I • N F n = N F (n + 1)
⊢ ∃ n₀, ∀ (n : ℕ), N F (n + n₀) ≤ N F' n

tactic: intro n
state_before: case intro
R M : Type u
inst✝² : CommRing R
inst✝¹ : AddCommGroup M
inst✝ : Module R M
I : Ideal R
F F' : Filtration I M
h : Stable F
e : N F 0 ≤ N F' 0
n₀ : ℕ
hF : ∀ (n : ℕ), n ≥ n₀ → I • N F n = N F (n + 1)
⊢ ∀ (n : ℕ), N F (n + n₀) ≤ N F' n

tactic: induction' n with n hn
state_before: case intro
R M : Type u
inst✝² : CommRing R
inst✝¹ : AddCommGroup M
inst✝ : Module R M
I : Ideal R
F F' : Filtration I M
h : Stable F
e : N F 0 ≤ N F' 0
n₀ : ℕ
hF : ∀ (n : ℕ), n ≥ n₀ → I • N F n = N F (n + 1)
n : ℕ
⊢ N F (n + n₀) ≤ N F' n

tactic: refine' (F.antitone _).trans e
state_before: case intro.zero
R M : Type u
inst✝² : CommRing R
inst✝¹ : AddCommGroup M
inst✝ : Module R M
I : Ideal R
F F' : Filtration I M
h : Stable F
e : N F 0 ≤ N F' 0
n₀ : ℕ
hF : ∀ (n : ℕ), n ≥ n₀ → I • N F n = N F (n + 1)
⊢ N F (Nat.zero + n₀) ≤ N F' Nat.zero

tactic: simp
state_before: case intro.zero
R M : Type u
inst✝² : CommRing R
inst✝¹ : AddCommGroup M
inst✝ : Module R M
I : Ideal R
F F' : Filtration I M
h : Stable F
e : N F 0 ≤ N F' 0
n₀ : ℕ
hF : ∀ (n : ℕ), n ≥ n₀ → I • N F n = N F (n + 1)
⊢ 0 ≤ Nat.zero + n₀

tactic: rw [Nat.succ_eq_one_add, add_assoc, add_comm, add_comm 1 n, ← hF]
state_before: case intro.succ
R M : Type u
inst✝² : CommRing R
inst✝¹ : AddCommGroup M
inst✝ : Module R M
I : Ideal R
F F' : Filtration I M
h : Stable F
e : N F 0 ≤ N F' 0
n₀ : ℕ
hF : ∀ (n : ℕ), n ≥ n₀ → I • N F n = N F (n + 1)
n : ℕ
hn : N F (n + n₀) ≤ N F' n
⊢ N F (Nat.succ n + n₀) ≤ N F' (Nat.succ n)

tactic: exact (Submodule.smul_mono_right hn).trans (F'.smul_le _)
state_before: case intro.succ
R M : Type u
inst✝² : CommRing R
inst✝¹ : AddCommGroup M
inst✝ : Module R M
I : Ideal R
F F' : Filtration I M
h : Stable F
e : N F 0 ≤ N F' 0
n₀ : ℕ
hF : ∀ (n : ℕ), n ≥ n₀ → I • N F n = N F (n + 1)
n : ℕ
hn : N F (n + n₀) ≤ N F' n
⊢ I • N F (n + n₀) ≤ N F' (n + 1)

case intro.succ.a
R M : Type u
inst✝² : CommRing R
inst✝¹ : AddCommGroup M
inst✝ : Module R M
I : Ideal R
F F' : Filtration I M
h : Stable F
e : N F 0 ≤ N F' 0
n₀ : ℕ
hF : ∀ (n : ℕ), n ≥ n₀ → I • N F n = N F (n + 1)
n : ℕ
hn : N F (n + n₀) ≤ N F' n
⊢ n + n₀ ≥ n₀

tactic: simp
state_before: case intro.succ.a
R M : Type u
inst✝² : CommRing R
inst✝¹ : AddCommGroup M
inst✝ : Module R M
I : Ideal R
F F' : Filtration I M
h : Stable F
e : N F 0 ≤ N F' 0
n₀ : ℕ
hF : ∀ (n : ℕ), n ≥ n₀ → I • N F n = N F (n + 1)
n : ℕ
hn : N F (n + n₀) ≤ N F' n
⊢ n + n₀ ≥ n₀
Theorem: CategoryTheory.Limits.zero_of_source_iso_zero
File: Mathlib/CategoryTheory/Limits/Shapes/ZeroMorphisms.lean

tactic: have h : f = i.hom ≫ 𝟙 0 ≫ i.inv ≫ f := by simp only [Iso.hom_inv_id_assoc, id_comp, comp_id]
state_before: C : Type u
inst✝³ : Category C
D : Type u'
inst✝² : Category D
inst✝¹ : HasZeroObject C
inst✝ : HasZeroMorphisms C
X Y : C
f : X ⟶ Y
i : X ≅ 0
⊢ f = 0

tactic: simpa using h
state_before: C : Type u
inst✝³ : Category C
D : Type u'
inst✝² : Category D
inst✝¹ : HasZeroObject C
inst✝ : HasZeroMorphisms C
X Y : C
f : X ⟶ Y
i : X ≅ 0
h : f = i.hom ≫ 𝟙 0 ≫ i.inv ≫ f
⊢ f = 0

tactic: simp only [Iso.hom_inv_id_assoc, id_comp, comp_id]
state_before: C : Type u
inst✝³ : Category C
D : Type u'
inst✝² : Category D
inst✝¹ : HasZeroObject C
inst✝ : HasZeroMorphisms C
X Y : C
f : X ⟶ Y
i : X ≅ 0
⊢ f = i.hom ≫ 𝟙 0 ≫ i.inv ≫ f
Theorem: connectedComponentIn_eq
File: Mathlib/Topology/Connected.lean

tactic: have hx : x ∈ F := connectedComponentIn_nonempty_iff.mp ⟨y, h⟩
state_before: α : Type u
β : Type v
ι : Type ?u.56608
π : ι → Type ?u.56613
inst✝ : TopologicalSpace α
s t u v : Set α
x y : α
F : Set α
h : y ∈ connectedComponentIn F x
⊢ connectedComponentIn F x = connectedComponentIn F y

tactic: simp_rw [connectedComponentIn_eq_image hx] at h⊢
state_before: α : Type u
β : Type v
ι : Type ?u.56608
π : ι → Type ?u.56613
inst✝ : TopologicalSpace α
s t u v : Set α
x y : α
F : Set α
h : y ∈ connectedComponentIn F x
hx : x ∈ F
⊢ connectedComponentIn F x = connectedComponentIn F y

tactic: obtain ⟨⟨y, hy⟩, h2y, rfl⟩ := h
state_before: α : Type u
β : Type v
ι : Type ?u.56608
π : ι → Type ?u.56613
inst✝ : TopologicalSpace α
s t u v : Set α
x y : α
F : Set α
hx : x ∈ F
h : y ∈ Subtype.val '' connectedComponent { val := x, property := hx }
⊢ Subtype.val '' connectedComponent { val := x, property := hx } = connectedComponentIn F y

tactic: simp_rw [connectedComponentIn_eq_image hy, connectedComponent_eq h2y]
state_before: case intro.mk.intro
α : Type u
β : Type v
ι : Type ?u.56608
π : ι → Type ?u.56613
inst✝ : TopologicalSpace α
s t u v : Set α
x : α
F : Set α
hx : x ∈ F
y : α
hy : y ∈ F
h2y : { val := y, property := hy } ∈ connectedComponent { val := x, property := hx }
⊢ Subtype.val '' connectedComponent { val := x, property := hx } = connectedComponentIn F ↑{ val := y, property := hy }
Theorem: Matrix.vecMul_smul
File: Mathlib/Data/Matrix/Basic.lean

tactic: ext i
state_before: l : Type ?u.858279
m : Type u_4
n : Type u_1
o : Type ?u.858288
m' : o → Type ?u.858293
n' : o → Type ?u.858298
R : Type u_2
S : Type u_3
α : Type v
β : Type w
γ : Type ?u.858311
inst✝⁵ : NonUnitalNonAssocSemiring α
inst✝⁴ : Fintype n
inst✝³ : Monoid R
inst✝² : NonUnitalNonAssocSemiring S
inst✝¹ : DistribMulAction R S
inst✝ : IsScalarTower R S S
M : Matrix n m S
b : R
v : n → S
⊢ vecMul (b • v) M = b • vecMul v M

tactic: simp only [vecMul, dotProduct, Finset.smul_sum, Pi.smul_apply, smul_mul_assoc]
state_before: case h
l : Type ?u.858279
m : Type u_4
n : Type u_1
o : Type ?u.858288
m' : o → Type ?u.858293
n' : o → Type ?u.858298
R : Type u_2
S : Type u_3
α : Type v
β : Type w
γ : Type ?u.858311
inst✝⁵ : NonUnitalNonAssocSemiring α
inst✝⁴ : Fintype n
inst✝³ : Monoid R
inst✝² : NonUnitalNonAssocSemiring S
inst✝¹ : DistribMulAction R S
inst✝ : IsScalarTower R S S
M : Matrix n m S
b : R
v : n → S
i : m
⊢ vecMul (b • v) M i = (b • vecMul v M) i
Theorem: Int.neg_add
File: Std/Data/Int/Lemmas.lean

tactic: apply Int.add_left_cancel (a := a + b)
state_before: a b : Int
⊢ -(a + b) = -a + -b

tactic: rw [Int.add_right_neg, Int.add_comm a, ← Int.add_assoc, Int.add_assoc b,
  Int.add_right_neg, Int.add_zero, Int.add_right_neg]
state_before: a b : Int
⊢ a + b + -(a + b) = a + b + (-a + -b)
Theorem: BilinForm.nondegenerate_iff_det_ne_zero
File: Mathlib/LinearAlgebra/Matrix/BilinearForm.lean

tactic: rw [← Matrix.nondegenerate_iff_det_ne_zero, nondegenerate_toMatrix_iff]
state_before: R : Type ?u.3009706
M : Type ?u.3009709
inst✝¹⁹ : Semiring R
inst✝¹⁸ : AddCommMonoid M
inst✝¹⁷ : Module R M
R₁ : Type ?u.3009745
M₁ : Type ?u.3009748
inst✝¹⁶ : Ring R₁
inst✝¹⁵ : AddCommGroup M₁
inst✝¹⁴ : Module R₁ M₁
R₂ : Type ?u.3010357
M₂ : Type ?u.3010360
inst✝¹³ : CommSemiring R₂
inst✝¹² : AddCommMonoid M₂
inst✝¹¹ : Module R₂ M₂
R₃ : Type ?u.3010547
M₃ : Type u_2
inst✝¹⁰ : CommRing R₃
inst✝⁹ : AddCommGroup M₃
inst✝⁸ : Module R₃ M₃
V : Type ?u.3011138
K : Type ?u.3011141
inst✝⁷ : Field K
inst✝⁶ : AddCommGroup V
inst✝⁵ : Module K V
B✝ : BilinForm R M
B₁ : BilinForm R₁ M₁
B₂ : BilinForm R₂ M₂
A : Type u_1
inst✝⁴ : CommRing A
inst✝³ : IsDomain A
inst✝² : Module A M₃
B₃ : BilinForm A M₃
ι : Type u_3
inst✝¹ : DecidableEq ι
inst✝ : Fintype ι
B : BilinForm A M₃
b : Basis ι A M₃
⊢ Nondegenerate B ↔ det (↑(toMatrix b) B) ≠ 0
Theorem: PowerSeries.rescale_zero
File: Mathlib/RingTheory/PowerSeries/Basic.lean

tactic: ext x n
state_before: R : Type u_1
inst✝ : CommSemiring R
⊢ rescale 0 = RingHom.comp (C R) (constantCoeff R)

tactic: simp only [Function.comp_apply, RingHom.coe_comp, rescale, RingHom.coe_mk,
  PowerSeries.coeff_mk _ _, coeff_C]
state_before: case a.h
R : Type u_1
inst✝ : CommSemiring R
x : PowerSeries R
n : ℕ
⊢ ↑(coeff R n) (↑(rescale 0) x) = ↑(coeff R n) (↑(RingHom.comp (C R) (constantCoeff R)) x)

tactic: split_ifs with h <;> simp [h]
state_before: case a.h
R : Type u_1
inst✝ : CommSemiring R
x : PowerSeries R
n : ℕ
⊢ ↑(coeff R n)
      (↑{
            toOneHom :=
              { toFun := fun f => mk fun n => 0 ^ n * ↑(coeff R n) f,
                map_one' := (_ : (fun f => mk fun n => 0 ^ n * ↑(coeff R n) f) 1 = 1) },
            map_mul' :=
              (_ :
                ∀ (f g : PowerSeries R),
                  OneHom.toFun
                      { toFun := fun f => mk fun n => 0 ^ n * ↑(coeff R n) f,
                        map_one' := (_ : (fun f => mk fun n => 0 ^ n * ↑(coeff R n) f) 1 = 1) }
                      (f * g) =
                    OneHom.toFun
                        { toFun := fun f => mk fun n => 0 ^ n * ↑(coeff R n) f,
                          map_one' := (_ : (fun f => mk fun n => 0 ^ n * ↑(coeff R n) f) 1 = 1) }
                        f *
                      OneHom.toFun
                        { toFun := fun f => mk fun n => 0 ^ n * ↑(coeff R n) f,
                          map_one' := (_ : (fun f => mk fun n => 0 ^ n * ↑(coeff R n) f) 1 = 1) }
                        g) }
        x) =
    if n = 0 then ↑(constantCoeff R) x else 0
Theorem: IsIdempotentElem.pow
File: Mathlib/Algebra/Ring/Idempotents.lean

tactic: conv_rhs => rw [← h.eq]
state_before: M : Type ?u.3776
N : Type u_1
S : Type ?u.3782
M₀ : Type ?u.3785
M₁ : Type ?u.3788
R : Type ?u.3791
G : Type ?u.3794
G₀ : Type ?u.3797
inst✝⁷ : Mul M
inst✝⁶ : Monoid N
inst✝⁵ : Semigroup S
inst✝⁴ : MulZeroClass M₀
inst✝³ : MulOneClass M₁
inst✝² : NonAssocRing R
inst✝¹ : Group G
inst✝ : CancelMonoidWithZero G₀
p : N
n✝ : ℕ
h : IsIdempotentElem p
n : ℕ
x✝ : IsIdempotentElem (p ^ n)
⊢ p ^ Nat.succ n * p ^ Nat.succ n = p ^ Nat.succ n

tactic: rw [← sq, ← sq, ← pow_mul, ← pow_mul']
state_before: M : Type ?u.3776
N : Type u_1
S : Type ?u.3782
M₀ : Type ?u.3785
M₁ : Type ?u.3788
R : Type ?u.3791
G : Type ?u.3794
G₀ : Type ?u.3797
inst✝⁷ : Mul M
inst✝⁶ : Monoid N
inst✝⁵ : Semigroup S
inst✝⁴ : MulZeroClass M₀
inst✝³ : MulOneClass M₁
inst✝² : NonAssocRing R
inst✝¹ : Group G
inst✝ : CancelMonoidWithZero G₀
p : N
n✝ : ℕ
h : IsIdempotentElem p
n : ℕ
x✝ : IsIdempotentElem (p ^ n)
⊢ p ^ Nat.succ n * p ^ Nat.succ n = (p * p) ^ Nat.succ n
Theorem: List.nodup_append_comm
File: Mathlib/Data/List/Nodup.lean

tactic: simp only [nodup_append, and_left_comm, disjoint_comm]
state_before: α : Type u
β : Type v
l l₁✝ l₂✝ : List α
r : α → α → Prop
a b : α
l₁ l₂ : List α
⊢ Nodup (l₁ ++ l₂) ↔ Nodup (l₂ ++ l₁)
Theorem: MvPolynomial.support_esymm'
File: Mathlib/RingTheory/MvPolynomial/Symmetric.lean

tactic: rw [support_esymm'']
state_before: σ : Type u_1
R : Type u_2
τ : Type ?u.190525
S : Type ?u.190528
inst✝⁵ : CommSemiring R
inst✝⁴ : CommSemiring S
inst✝³ : Fintype σ
inst✝² : Fintype τ
n : ℕ
inst✝¹ : DecidableEq σ
inst✝ : Nontrivial R
⊢ support (esymm σ R n) = Finset.biUnion (powersetLen n univ) fun t => {∑ i in t, Finsupp.single i 1}

tactic: congr
state_before: σ : Type u_1
R : Type u_2
τ : Type ?u.190525
S : Type ?u.190528
inst✝⁵ : CommSemiring R
inst✝⁴ : CommSemiring S
inst✝³ : Fintype σ
inst✝² : Fintype τ
n : ℕ
inst✝¹ : DecidableEq σ
inst✝ : Nontrivial R
⊢ (Finset.biUnion (powersetLen n univ) fun t => (Finsupp.single (∑ i in t, Finsupp.single i 1) 1).support) =
    Finset.biUnion (powersetLen n univ) fun t => {∑ i in t, Finsupp.single i 1}

tactic: funext
state_before: case e_t
σ : Type u_1
R : Type u_2
τ : Type ?u.190525
S : Type ?u.190528
inst✝⁵ : CommSemiring R
inst✝⁴ : CommSemiring S
inst✝³ : Fintype σ
inst✝² : Fintype τ
n : ℕ
inst✝¹ : DecidableEq σ
inst✝ : Nontrivial R
⊢ (fun t => (Finsupp.single (∑ i in t, Finsupp.single i 1) 1).support) = fun t => {∑ i in t, Finsupp.single i 1}

tactic: exact Finsupp.support_single_ne_zero _ one_ne_zero
state_before: case e_t.h
σ : Type u_1
R : Type u_2
τ : Type ?u.190525
S : Type ?u.190528
inst✝⁵ : CommSemiring R
inst✝⁴ : CommSemiring S
inst✝³ : Fintype σ
inst✝² : Fintype τ
n : ℕ
inst✝¹ : DecidableEq σ
inst✝ : Nontrivial R
x✝ : Finset σ
⊢ (Finsupp.single (∑ i in x✝, Finsupp.single i 1) 1).support = {∑ i in x✝, Finsupp.single i 1}