tasksource/leandojo huggingface dataset:
Theorem: List.TProd.elim_self
File: Mathlib/Data/Prod/TProd.lean

tactic: simp [TProd.elim]
state_before: ι : Type u
α : ι → Type v
i j : ι
l : List ι
f : (i : ι) → α i
inst✝ : DecidableEq ι
v : TProd α (i :: l)
⊢ TProd.elim v (_ : i ∈ i :: l) = v.fst
Theorem: QuotientGroup.rangeKerLift_surjective
File: Mathlib/GroupTheory/QuotientGroup.lean

tactic: rintro ⟨_, g, rfl⟩
state_before: G : Type u
inst✝¹ : Group G
N : Subgroup G
nN : Subgroup.Normal N
H : Type v
inst✝ : Group H
φ : G →* H
⊢ Surjective ↑(rangeKerLift φ)

tactic: use mk g
state_before: case mk.intro
G : Type u
inst✝¹ : Group G
N : Subgroup G
nN : Subgroup.Normal N
H : Type v
inst✝ : Group H
φ : G →* H
g : G
⊢ ∃ a, ↑(rangeKerLift φ) a = { val := ↑φ g, property := (_ : ∃ y, ↑φ y = ↑φ g) }

tactic: rfl
state_before: case mk.intro
G : Type u
inst✝¹ : Group G
N : Subgroup G
nN : Subgroup.Normal N
H : Type v
inst✝ : Group H
φ : G →* H
g : G
⊢ ↑(rangeKerLift φ) ↑g = { val := ↑φ g, property := (_ : ∃ y, ↑φ y = ↑φ g) }
Theorem: Set.bounded_le_inter_lt
File: Mathlib/Order/Bounded.lean

tactic: simp_rw [← not_le, bounded_le_inter_not_le]
state_before: α : Type u_1
r : α → α → Prop
s t : Set α
inst✝ : LinearOrder α
a : α
⊢ Bounded (fun x x_1 => x ≤ x_1) (s ∩ {b | a < b}) ↔ Bounded (fun x x_1 => x ≤ x_1) s
Theorem: List.toFinsupp_eq_sum_map_enum_single
File: Mathlib/Data/List/ToFinsupp.lean

tactic: revert l
state_before: M : Type ?u.27284
inst✝³ : Zero M
l✝ : List M
inst✝² : DecidablePred fun x => getD l✝ x 0 ≠ 0
n : ℕ
R : Type u_1
inst✝¹ : AddMonoid R
l : List R
inst✝ : DecidablePred fun x => getD l x 0 ≠ 0
⊢ toFinsupp l = sum (map (fun nr => Finsupp.single nr.fst nr.snd) (enum l))

tactic: intro l
state_before: M : Type ?u.27284
inst✝² : Zero M
l : List M
inst✝¹ : DecidablePred fun x => getD l x 0 ≠ 0
n : ℕ
R : Type u_1
inst✝ : AddMonoid R
⊢ ∀ (l : List R) [inst : DecidablePred fun x => getD l x 0 ≠ 0],
    toFinsupp l = sum (map (fun nr => Finsupp.single nr.fst nr.snd) (enum l))

tactic: induction l using List.reverseRecOn with
| H0 => exact toFinsupp_nil
| H1 x xs ih =>
  classical simp [toFinsupp_concat_eq_toFinsupp_add_single, enum_append, ih]
state_before: M : Type ?u.27284
inst✝² : Zero M
l✝ : List M
inst✝¹ : DecidablePred fun x => getD l✝ x 0 ≠ 0
n : ℕ
R : Type u_1
inst✝ : AddMonoid R
l : List R
⊢ ∀ [inst : DecidablePred fun x => getD l x 0 ≠ 0],
    toFinsupp l = sum (map (fun nr => Finsupp.single nr.fst nr.snd) (enum l))

tactic: exact toFinsupp_nil
state_before: case H0
M : Type ?u.27284
inst✝² : Zero M
l : List M
inst✝¹ : DecidablePred fun x => getD l x 0 ≠ 0
n : ℕ
R : Type u_1
inst✝ : AddMonoid R
⊢ ∀ [inst : DecidablePred fun x => getD [] x 0 ≠ 0],
    toFinsupp [] = sum (map (fun nr => Finsupp.single nr.fst nr.snd) (enum []))

tactic: classical simp [toFinsupp_concat_eq_toFinsupp_add_single, enum_append, ih]
state_before: case H1
M : Type ?u.27284
inst✝² : Zero M
l : List M
inst✝¹ : DecidablePred fun x => getD l x 0 ≠ 0
n : ℕ
R : Type u_1
inst✝ : AddMonoid R
x : List R
xs : R
ih :
  ∀ [inst : DecidablePred fun x_1 => getD x x_1 0 ≠ 0],
    toFinsupp x = sum (map (fun nr => Finsupp.single nr.fst nr.snd) (enum x))
⊢ ∀ [inst : DecidablePred fun x_1 => getD (x ++ [xs]) x_1 0 ≠ 0],
    toFinsupp (x ++ [xs]) = sum (map (fun nr => Finsupp.single nr.fst nr.snd) (enum (x ++ [xs])))

tactic: simp [toFinsupp_concat_eq_toFinsupp_add_single, enum_append, ih]
state_before: case H1
M : Type ?u.27284
inst✝² : Zero M
l : List M
inst✝¹ : DecidablePred fun x => getD l x 0 ≠ 0
n : ℕ
R : Type u_1
inst✝ : AddMonoid R
x : List R
xs : R
ih :
  ∀ [inst : DecidablePred fun x_1 => getD x x_1 0 ≠ 0],
    toFinsupp x = sum (map (fun nr => Finsupp.single nr.fst nr.snd) (enum x))
⊢ ∀ [inst : DecidablePred fun x_1 => getD (x ++ [xs]) x_1 0 ≠ 0],
    toFinsupp (x ++ [xs]) = sum (map (fun nr => Finsupp.single nr.fst nr.snd) (enum (x ++ [xs])))
Theorem: Finset.image₂_empty_left
File: Mathlib/Data/Finset/NAry.lean

tactic: simp
state_before: α : Type u_2
α' : Type ?u.23812
β : Type u_3
β' : Type ?u.23818
γ : Type u_1
γ' : Type ?u.23824
δ : Type ?u.23827
δ' : Type ?u.23830
ε : Type ?u.23833
ε' : Type ?u.23836
ζ : Type ?u.23839
ζ' : Type ?u.23842
ν : Type ?u.23845
inst✝⁷ : DecidableEq α'
inst✝⁶ : DecidableEq β'
inst✝⁵ : DecidableEq γ
inst✝⁴ : DecidableEq γ'
inst✝³ : DecidableEq δ
inst✝² : DecidableEq δ'
inst✝¹ : DecidableEq ε
inst✝ : DecidableEq ε'
f f' : α → β → γ
g g' : α → β → γ → δ
s s' : Finset α
t t' : Finset β
u u' : Finset γ
a a' : α
b b' : β
c : γ
⊢ ↑(image₂ f ∅ t) = ↑∅
Theorem: Even.sub_odd
File: Mathlib/Algebra/Parity.lean

tactic: rw [sub_eq_add_neg]
state_before: F : Type ?u.104684
α : Type u_1
β : Type ?u.104690
R : Type ?u.104693
inst✝ : Ring α
a b : α
n : ℕ
ha : Even a
hb : Odd b
⊢ Odd (a - b)

tactic: exact ha.add_odd hb.neg
state_before: F : Type ?u.104684
α : Type u_1
β : Type ?u.104690
R : Type ?u.104693
inst✝ : Ring α
a b : α
n : ℕ
ha : Even a
hb : Odd b
⊢ Odd (a + -b)
Theorem: Subgroup.nontrivial_iff_exists_ne_one
File: Mathlib/GroupTheory/Subgroup/Basic.lean

tactic: rw [Subtype.nontrivial_iff_exists_ne (fun x => x ∈ H) (1 : H)]
state_before: G : Type u_1
G' : Type ?u.170709
inst✝² : Group G
inst✝¹ : Group G'
A : Type ?u.170718
inst✝ : AddGroup A
H✝ K H : Subgroup G
⊢ Nontrivial { x // x ∈ H } ↔ ∃ x, x ∈ H ∧ x ≠ 1

tactic: simp
state_before: G : Type u_1
G' : Type ?u.170709
inst✝² : Group G
inst✝¹ : Group G'
A : Type ?u.170718
inst✝ : AddGroup A
H✝ K H : Subgroup G
⊢ (∃ y x, y ≠ ↑1) ↔ ∃ x, x ∈ H ∧ x ≠ 1
Theorem: AddCircle.continuousAt_equivIco
File: Mathlib/Topology/Instances/AddCircle.lean

tactic: induction x using QuotientAddGroup.induction_on'
state_before: 𝕜 : Type u_1
B : Type ?u.98530
inst✝³ : LinearOrderedAddCommGroup 𝕜
inst✝² : TopologicalSpace 𝕜
inst✝¹ : OrderTopology 𝕜
p : 𝕜
hp : Fact (0 < p)
a : 𝕜
inst✝ : Archimedean 𝕜
x : AddCircle p
hx : x ≠ ↑a
⊢ ContinuousAt (↑(equivIco p a)) x

tactic: rw [ContinuousAt, Filter.Tendsto, QuotientAddGroup.nhds_eq, Filter.map_map]
state_before: case H
𝕜 : Type u_1
B : Type ?u.98530
inst✝³ : LinearOrderedAddCommGroup 𝕜
inst✝² : TopologicalSpace 𝕜
inst✝¹ : OrderTopology 𝕜
p : 𝕜
hp : Fact (0 < p)
a : 𝕜
inst✝ : Archimedean 𝕜
x : AddCircle p
z✝ : 𝕜
hx : ↑z✝ ≠ ↑a
⊢ ContinuousAt ↑(equivIco p a) ↑z✝

tactic: exact (continuousAt_toIcoMod hp.out a hx).codRestrict _
state_before: case H
𝕜 : Type u_1
B : Type ?u.98530
inst✝³ : LinearOrderedAddCommGroup 𝕜
inst✝² : TopologicalSpace 𝕜
inst✝¹ : OrderTopology 𝕜
p : 𝕜
hp : Fact (0 < p)
a : 𝕜
inst✝ : Archimedean 𝕜
x : AddCircle p
z✝ : 𝕜
hx : ↑z✝ ≠ ↑a
⊢ Filter.map (↑(equivIco p a) ∘ QuotientAddGroup.mk) (𝓝 z✝) ≤ 𝓝 (↑(equivIco p a) ↑z✝)
Theorem: Finset.uIcc_of_ge
File: Mathlib/Data/Finset/LocallyFinite.lean

tactic: rw [uIcc, inf_eq_right.2 h, sup_eq_left.2 h]
state_before: ι : Type ?u.173551
α : Type u_1
inst✝¹ : Lattice α
inst✝ : LocallyFiniteOrder α
a a₁ a₂ b b₁ b₂ c x : α
h : b ≤ a
⊢ [[a, b]] = Icc b a
Theorem: inv_ne_zero
File: Mathlib/Algebra/GroupWithZero/Basic.lean

tactic: have := mul_inv_cancel h
state_before: α : Type ?u.15737
M₀ : Type ?u.15740
G₀ : Type u_1
M₀' : Type ?u.15746
G₀' : Type ?u.15749
F : Type ?u.15752
F' : Type ?u.15755
inst✝ : GroupWithZero G₀
a b c g h✝ x : G₀
h : a ≠ 0
a_eq_0 : a⁻¹ = 0
⊢ False

tactic: simp [a_eq_0] at this
state_before: α : Type ?u.15737
M₀ : Type ?u.15740
G₀ : Type u_1
M₀' : Type ?u.15746
G₀' : Type ?u.15749
F : Type ?u.15752
F' : Type ?u.15755
inst✝ : GroupWithZero G₀
a b c g h✝ x : G₀
h : a ≠ 0
a_eq_0 : a⁻¹ = 0
this : a * a⁻¹ = 1
⊢ False
Theorem: Polynomial.natDegree_of_subsingleton
File: Mathlib/Data/Polynomial/Degree/Definitions.lean

tactic: rw [Subsingleton.elim p 0, natDegree_zero]
state_before: R : Type u
S : Type v
a b c d : R
n m : ℕ
inst✝¹ : Semiring R
p q r : R[X]
inst✝ : Subsingleton R
⊢ natDegree p = 0
Theorem: Nat.succ_add_eq_succ_add
File: Std/Data/Nat/Lemmas.lean

tactic: simp [succ_add, add_succ]
state_before: n m : Nat
⊢ succ n + m = n + succ m
Theorem: EReal.coe_ennreal_eq_one
File: Mathlib/Data/Real/EReal.lean

tactic: rw [← coe_ennreal_eq_coe_ennreal_iff, coe_ennreal_one]
state_before: x : ℝ≥0∞
⊢ ↑x = 1 ↔ x = 1
Theorem: Set.not_monotoneOn_not_antitoneOn_iff_exists_le_le
File: Mathlib/Data/Set/Basic.lean

tactic: simp [monotoneOn_iff_monotone, antitoneOn_iff_antitone, and_assoc, exists_and_left,
  not_monotone_not_antitone_iff_exists_le_le, @and_left_comm (_ ∈ s)]
state_before: α : Type u
β : Type v
γ : Type w
ι : Sort x
a b : α
s s₁ s₂ t t₁ t₂ u : Set α
inst✝¹ : LinearOrder α
inst✝ : LinearOrder β
f : α → β
⊢ ¬MonotoneOn f s ∧ ¬AntitoneOn f s ↔ ∃ a x b x c x, a ≤ b ∧ b ≤ c ∧ (f a < f b ∧ f c < f b ∨ f b < f a ∧ f b < f c)
Theorem: List.map_reverseAux
File: Mathlib/Data/List/Basic.lean

tactic: simp only [reverseAux_eq, map_append, map_reverse]
state_before: ι : Type ?u.27240
α : Type u
β : Type v
γ : Type w
δ : Type x
l₁✝ l₂✝ : List α
f : α → β
l₁ l₂ : List α
⊢ map f (reverseAux l₁ l₂) = reverseAux (map f l₁) (map f l₂)
Theorem: MonoidWithZeroHom.ext_rat_on_pnat
File: Mathlib/Data/Rat/Cast.lean

tactic: simpa
state_before: F : Type u_2
ι : Type ?u.88378
α : Type ?u.88381
β : Type ?u.88384
M₀ : Type u_1
inst✝¹ : MonoidWithZero M₀
inst✝ : MonoidWithZeroHomClass F ℚ M₀
f g : F
same_on_neg_one : ↑f (-1) = ↑g (-1)
same_on_pnat : ∀ (n : ℕ), 0 < n → ↑f ↑n = ↑g ↑n
⊢ ↑(comp ↑f ↑(Int.castRingHom ℚ)) (-1) = ↑(comp ↑g ↑(Int.castRingHom ℚ)) (-1)

tactic: simpa
state_before: F : Type u_2
ι : Type ?u.88378
α : Type ?u.88381
β : Type ?u.88384
M₀ : Type u_1
inst✝¹ : MonoidWithZero M₀
inst✝ : MonoidWithZeroHomClass F ℚ M₀
f g : F
same_on_neg_one : ↑f (-1) = ↑g (-1)
same_on_pnat : ∀ (n : ℕ), 0 < n → ↑f ↑n = ↑g ↑n
⊢ ∀ (n : ℕ), 0 < n → ↑(comp ↑f ↑(Int.castRingHom ℚ)) ↑n = ↑(comp ↑g ↑(Int.castRingHom ℚ)) ↑n
Theorem: circleMap_not_mem_ball
File: Mathlib/MeasureTheory/Integral/CircleIntegral.lean

tactic: simp [dist_eq, le_abs_self]
state_before: E : Type ?u.11344
inst✝ : NormedAddCommGroup E
c : ℂ
R θ : ℝ
⊢ ¬circleMap c R θ ∈ ball c R
Theorem: CategoryTheory.Sieve.pushforward_le_bind_of_mem
File: Mathlib/CategoryTheory/Sites/Sieves.lean

tactic: rintro Z _ ⟨g, rfl, hg⟩
state_before: C : Type u₁
inst✝¹ : Category C
D : Type u₂
inst✝ : Category D
F : C ⥤ D
X Y Z : C
f✝ : Y ⟶ X
S✝ R✝ : Sieve X
S : Presieve X
R : ⦃Y : C⦄ → ⦃f : Y ⟶ X⦄ → S f → Sieve Y
f : Y ⟶ X
h : S f
⊢ pushforward f (R h) ≤ bind S R

tactic: exact ⟨_, g, f, h, hg, rfl⟩
state_before: case intro.intro
C : Type u₁
inst✝¹ : Category C
D : Type u₂
inst✝ : Category D
F : C ⥤ D
X Y Z✝ : C
f✝ : Y ⟶ X
S✝ R✝ : Sieve X
S : Presieve X
R : ⦃Y : C⦄ → ⦃f : Y ⟶ X⦄ → S f → Sieve Y
f : Y ⟶ X
h : S f
Z : C
g : Z ⟶ Y
hg : (R h).arrows g
⊢ (bind S R).arrows (g ≫ f)
Theorem: MeasureTheory.memℒp_zero_iff_aestronglyMeasurable
File: Mathlib/MeasureTheory/Function/LpSeminorm.lean

tactic: simp [Memℒp, snorm_exponent_zero]
state_before: α : Type u_2
E : Type u_1
F : Type ?u.910332
G : Type ?u.910335
m m0 : MeasurableSpace α
p : ℝ≥0∞
q : ℝ
μ ν : Measure α
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedAddCommGroup G
f : α → E
⊢ Memℒp f 0 ↔ AEStronglyMeasurable f μ
Theorem: CategoryTheory.Preadditive.cokernelCoforkOfCofork_ofπ
File: Mathlib/CategoryTheory/Preadditive/Basic.lean

tactic: simp [w]
state_before: C : Type u
inst✝¹ : Category C
inst✝ : Preadditive C
X Y : C
f g : X ⟶ Y
P : C
π : Y ⟶ P
w : f ≫ π = g ≫ π
⊢ (f - g) ≫ π = 0
Theorem: Finset.prod_fin_eq_prod_range
File: Mathlib/Data/Fintype/BigOperators.lean

tactic: rw [← Fin.prod_univ_eq_prod_range, Finset.prod_congr rfl]
state_before: α : Type ?u.56017
β : Type u_1
γ : Type ?u.56023
inst✝ : CommMonoid β
n : ℕ
c : Fin n → β
⊢ ∏ i : Fin n, c i = ∏ i in range n, if h : i < n then c { val := i, isLt := h } else 1

tactic: rintro ⟨i, hi⟩ _
state_before: α : Type ?u.56017
β : Type u_1
γ : Type ?u.56023
inst✝ : CommMonoid β
n : ℕ
c : Fin n → β
⊢ ∀ (x : Fin n), x ∈ univ → c x = if h : ↑x < n then c { val := ↑x, isLt := h } else 1

tactic: simp only [hi, dif_pos]
state_before: case mk
α : Type ?u.56017
β : Type u_1
γ : Type ?u.56023
inst✝ : CommMonoid β
n : ℕ
c : Fin n → β
i : ℕ
hi : i < n
a✝ : { val := i, isLt := hi } ∈ univ
⊢ c { val := i, isLt := hi } =
    if h : ↑{ val := i, isLt := hi } < n then c { val := ↑{ val := i, isLt := hi }, isLt := h } else 1
Theorem: BilinForm.toMatrix_mul
File: Mathlib/LinearAlgebra/Matrix/BilinearForm.lean

tactic: rw [B.toMatrix_compRight b, toMatrix_toLin]
state_before: R : Type ?u.1773392
M✝ : Type ?u.1773395
inst✝²⁰ : Semiring R
inst✝¹⁹ : AddCommMonoid M✝
inst✝¹⁸ : Module R M✝
R₁ : Type ?u.1773431
M₁ : Type ?u.1773434
inst✝¹⁷ : Ring R₁
inst✝¹⁶ : AddCommGroup M₁
inst✝¹⁵ : Module R₁ M₁
R₂ : Type u_1
M₂ : Type u_2
inst✝¹⁴ : CommSemiring R₂
inst✝¹³ : AddCommMonoid M₂
inst✝¹² : Module R₂ M₂
R₃ : Type ?u.1774233
M₃ : Type ?u.1774236
inst✝¹¹ : CommRing R₃
inst✝¹⁰ : AddCommGroup M₃
inst✝⁹ : Module R₃ M₃
V : Type ?u.1774824
K : Type ?u.1774827
inst✝⁸ : Field K
inst✝⁷ : AddCommGroup V
inst✝⁶ : Module K V
B✝ : BilinForm R M✝
B₁ : BilinForm R₁ M₁
B₂ : BilinForm R₂ M₂
n : Type u_3
o : Type ?u.1776044
inst✝⁵ : Fintype n
inst✝⁴ : Fintype o
inst✝³ : DecidableEq n
b : Basis n R₂ M₂
M₂' : Type ?u.1776203
inst✝² : AddCommMonoid M₂'
inst✝¹ : Module R₂ M₂'
c : Basis o R₂ M₂'
inst✝ : DecidableEq o
B : BilinForm R₂ M₂
M : Matrix n n R₂
⊢ ↑(toMatrix b) B ⬝ M = ↑(toMatrix b) (compRight B (↑(Matrix.toLin b b) M))
Theorem: ENNReal.top_div_of_ne_top
File: Mathlib/Data/Real/ENNReal.lean

tactic: simp [top_div, h]
state_before: α : Type ?u.274575
β : Type ?u.274578
a b c d : ℝ≥0∞
r p q : ℝ≥0
h : a ≠ ⊤
⊢ ⊤ / a = ⊤
Theorem: CategoryTheory.Subobject.le_inf
File: Mathlib/CategoryTheory/Subobject/Lattice.lean

tactic: rintro f g h ⟨k⟩ ⟨l⟩
state_before: C : Type u₁
inst✝² : Category C
X Y Z : C
D : Type u₂
inst✝¹ : Category D
inst✝ : HasPullbacks C
A : C
h f g : Subobject A
⊢ ∀ (a₁ a₂ a₃ : MonoOver A),
    Quotient.mk'' a₁ ≤ Quotient.mk'' a₂ →
      Quotient.mk'' a₁ ≤ Quotient.mk'' a₃ → Quotient.mk'' a₁ ≤ (inf.obj (Quotient.mk'' a₂)).obj (Quotient.mk'' a₃)

tactic: exact ⟨MonoOver.leInf _ _ _ k l⟩
state_before: case intro.intro
C : Type u₁
inst✝² : Category C
X Y Z : C
D : Type u₂
inst✝¹ : Category D
inst✝ : HasPullbacks C
A : C
h✝ f✝ g✝ : Subobject A
f g h : MonoOver A
k : f ⟶ g
l : f ⟶ h
⊢ Quotient.mk'' f ≤ (inf.obj (Quotient.mk'' g)).obj (Quotient.mk'' h)
Theorem: Set.sUnion_mem_empty_univ
File: Mathlib/Data/Set/Lattice.lean

tactic: simp only [mem_insert_iff, mem_singleton_iff, or_iff_not_imp_left, sUnion_eq_empty, not_forall]
state_before: α : Type u_1
β : Type ?u.121205
γ : Type ?u.121208
ι : Sort ?u.121211
ι' : Sort ?u.121214
ι₂ : Sort ?u.121217
κ : ι → Sort ?u.121222
κ₁ : ι → Sort ?u.121227
κ₂ : ι → Sort ?u.121232
κ' : ι' → Sort ?u.121237
S : Set (Set α)
h : S ⊆ {∅, univ}
⊢ ⋃₀ S ∈ {∅, univ}

tactic: rintro ⟨s, hs, hne⟩
state_before: α : Type u_1
β : Type ?u.121205
γ : Type ?u.121208
ι : Sort ?u.121211
ι' : Sort ?u.121214
ι₂ : Sort ?u.121217
κ : ι → Sort ?u.121222
κ₁ : ι → Sort ?u.121227
κ₂ : ι → Sort ?u.121232
κ' : ι' → Sort ?u.121237
S : Set (Set α)
h : S ⊆ {∅, univ}
⊢ (∃ x x_1, ¬x = ∅) → ⋃₀ S = univ

tactic: obtain rfl : s = univ := (h hs).resolve_left hne
state_before: case intro.intro
α : Type u_1
β : Type ?u.121205
γ : Type ?u.121208
ι : Sort ?u.121211
ι' : Sort ?u.121214
ι₂ : Sort ?u.121217
κ : ι → Sort ?u.121222
κ₁ : ι → Sort ?u.121227
κ₂ : ι → Sort ?u.121232
κ' : ι' → Sort ?u.121237
S : Set (Set α)
h : S ⊆ {∅, univ}
s : Set α
hs : s ∈ S
hne : ¬s = ∅
⊢ ⋃₀ S = univ

tactic: exact univ_subset_iff.1 <| subset_sUnion_of_mem hs
state_before: case intro.intro
α : Type u_1
β : Type ?u.121205
γ : Type ?u.121208
ι : Sort ?u.121211
ι' : Sort ?u.121214
ι₂ : Sort ?u.121217
κ : ι → Sort ?u.121222
κ₁ : ι → Sort ?u.121227
κ₂ : ι → Sort ?u.121232
κ' : ι' → Sort ?u.121237
S : Set (Set α)
h : S ⊆ {∅, univ}
hs : univ ∈ S
hne : ¬univ = ∅
⊢ ⋃₀ S = univ
Theorem: Finsupp.mapDomain_comp
File: Mathlib/Data/Finsupp/Basic.lean

tactic: refine' ((sum_sum_index _ _).trans _).symm
state_before: α : Type u_3
β : Type u_4
γ : Type u_1
ι : Type ?u.162151
M : Type u_2
M' : Type ?u.162157
N : Type ?u.162160
P : Type ?u.162163
G : Type ?u.162166
H : Type ?u.162169
R : Type ?u.162172
S : Type ?u.162175
inst✝ : AddCommMonoid M
v v₁ v₂ : α →₀ M
f : α → β
g : β → γ
⊢ mapDomain (g ∘ f) v = mapDomain g (mapDomain f v)

tactic: refine' sum_congr fun _ _ => sum_single_index _
state_before: case refine'_3
α : Type u_3
β : Type u_4
γ : Type u_1
ι : Type ?u.162151
M : Type u_2
M' : Type ?u.162157
N : Type ?u.162160
P : Type ?u.162163
G : Type ?u.162166
H : Type ?u.162169
R : Type ?u.162172
S : Type ?u.162175
inst✝ : AddCommMonoid M
v v₁ v₂ : α →₀ M
f : α → β
g : β → γ
⊢ (sum v fun a b => sum (single (f a) b) fun a => single (g a)) = mapDomain (g ∘ f) v

tactic: intro
state_before: case refine'_1
α : Type u_3
β : Type u_4
γ : Type u_1
ι : Type ?u.162151
M : Type u_2
M' : Type ?u.162157
N : Type ?u.162160
P : Type ?u.162163
G : Type ?u.162166
H : Type ?u.162169
R : Type ?u.162172
S : Type ?u.162175
inst✝ : AddCommMonoid M
v v₁ v₂ : α →₀ M
f : α → β
g : β → γ
⊢ ∀ (a : β), single (g a) 0 = 0

tactic: exact single_zero _
state_before: case refine'_1
α : Type u_3
β : Type u_4
γ : Type u_1
ι : Type ?u.162151
M : Type u_2
M' : Type ?u.162157
N : Type ?u.162160
P : Type ?u.162163
G : Type ?u.162166
H : Type ?u.162169
R : Type ?u.162172
S : Type ?u.162175
inst✝ : AddCommMonoid M
v v₁ v₂ : α →₀ M
f : α → β
g : β → γ
a✝ : β
⊢ single (g a✝) 0 = 0

tactic: intro
state_before: case refine'_2
α : Type u_3
β : Type u_4
γ : Type u_1
ι : Type ?u.162151
M : Type u_2
M' : Type ?u.162157
N : Type ?u.162160
P : Type ?u.162163
G : Type ?u.162166
H : Type ?u.162169
R : Type ?u.162172
S : Type ?u.162175
inst✝ : AddCommMonoid M
v v₁ v₂ : α →₀ M
f : α → β
g : β → γ
⊢ ∀ (a : β) (b₁ b₂ : M), single (g a) (b₁ + b₂) = single (g a) b₁ + single (g a) b₂

tactic: exact single_add _
state_before: case refine'_2
α : Type u_3
β : Type u_4
γ : Type u_1
ι : Type ?u.162151
M : Type u_2
M' : Type ?u.162157
N : Type ?u.162160
P : Type ?u.162163
G : Type ?u.162166
H : Type ?u.162169
R : Type ?u.162172
S : Type ?u.162175
inst✝ : AddCommMonoid M
v v₁ v₂ : α →₀ M
f : α → β
g : β → γ
a✝ : β
⊢ ∀ (b₁ b₂ : M), single (g a✝) (b₁ + b₂) = single (g a✝) b₁ + single (g a✝) b₂

tactic: exact single_zero _
state_before: case refine'_3
α : Type u_3
β : Type u_4
γ : Type u_1
ι : Type ?u.162151
M : Type u_2
M' : Type ?u.162157
N : Type ?u.162160
P : Type ?u.162163
G : Type ?u.162166
H : Type ?u.162169
R : Type ?u.162172
S : Type ?u.162175
inst✝ : AddCommMonoid M
v v₁ v₂ : α →₀ M
f : α → β
g : β → γ
x✝¹ : α
x✝ : x✝¹ ∈ v.support
⊢ single (g (f x✝¹)) 0 = 0
Theorem: List.getLast_congr
File: Mathlib/Data/List/Basic.lean

tactic: subst l₁
state_before: ι : Type ?u.31925
α : Type u
β : Type v
γ : Type w
δ : Type x
l₁✝ l₂✝ l₁ l₂ : List α
h₁ : l₁ ≠ []
h₂ : l₂ ≠ []
h₃ : l₁ = l₂
⊢ getLast l₁ h₁ = getLast l₂ h₂

tactic: rfl
state_before: ι : Type ?u.31925
α : Type u
β : Type v
γ : Type w
δ : Type x
l₁ l₂✝ l₂ : List α
h₂ h₁ : l₂ ≠ []
⊢ getLast l₂ h₁ = getLast l₂ h₂
Theorem: CategoryTheory.NonPreadditiveAbelian.add_comm
File: Mathlib/CategoryTheory/Abelian/NonPreadditive.lean

tactic: rw [add_def]
state_before: C : Type u
inst✝¹ : Category C
inst✝ : NonPreadditiveAbelian C
X Y : C
a b : X ⟶ Y
⊢ a + b = b + a

tactic: conv_lhs => rw [← neg_neg a]
state_before: C : Type u
inst✝¹ : Category C
inst✝ : NonPreadditiveAbelian C
X Y : C
a b : X ⟶ Y
⊢ a - -b = b + a

tactic: rw [neg_def, neg_def, neg_def, sub_sub_sub]
state_before: C : Type u
inst✝¹ : Category C
inst✝ : NonPreadditiveAbelian C
X Y : C
a b : X ⟶ Y
⊢ - -a - -b = b + a

tactic: conv_lhs =>
  congr
  next => skip
  rw [← neg_def, neg_sub]
state_before: C : Type u
inst✝¹ : Category C
inst✝ : NonPreadditiveAbelian C
X Y : C
a b : X ⟶ Y
⊢ 0 - 0 - (0 - a - b) = b + a

tactic: rw [sub_sub_sub, add_def, ← neg_def, neg_neg b, neg_def]
state_before: C : Type u
inst✝¹ : Category C
inst✝ : NonPreadditiveAbelian C
X Y : C
a b : X ⟶ Y
⊢ 0 - 0 - (-b - a) = b + a
Theorem: LieAlgebra.self_module_ker_eq_center
File: Mathlib/Algebra/Lie/Abelian.lean

tactic: ext y
state_before: R : Type u
L : Type v
M : Type w
N : Type w₁
inst✝¹⁰ : CommRing R
inst✝⁹ : LieRing L
inst✝⁸ : LieAlgebra R L
inst✝⁷ : AddCommGroup M
inst✝⁶ : Module R M
inst✝⁵ : LieRingModule L M
inst✝⁴ : LieModule R L M
inst✝³ : AddCommGroup N
inst✝² : Module R N
inst✝¹ : LieRingModule L N
inst✝ : LieModule R L N
⊢ LieModule.ker R L L = center R L

tactic: simp only [LieModule.mem_maxTrivSubmodule, LieModule.mem_ker, ← lie_skew _ y, neg_eq_zero]
state_before: case h
R : Type u
L : Type v
M : Type w
N : Type w₁
inst✝¹⁰ : CommRing R
inst✝⁹ : LieRing L
inst✝⁸ : LieAlgebra R L
inst✝⁷ : AddCommGroup M
inst✝⁶ : Module R M
inst✝⁵ : LieRingModule L M
inst✝⁴ : LieModule R L M
inst✝³ : AddCommGroup N
inst✝² : Module R N
inst✝¹ : LieRingModule L N
inst✝ : LieModule R L N
y : L
⊢ y ∈ LieModule.ker R L L ↔ y ∈ center R L
Theorem: CauchyFilter.separated_pureCauchy_injective
File: Mathlib/Topology/UniformSpace/Completion.lean

tactic: refine separated_def.1 s _ _ (fun s hs => ?_)
state_before: α : Type u_1
inst✝ : UniformSpace α
s : SeparatedSpace α
a b : α
h :
  (fun a => Quotient.mk (UniformSpace.separationSetoid (CauchyFilter α)) (pureCauchy a)) a =
    (fun a => Quotient.mk (UniformSpace.separationSetoid (CauchyFilter α)) (pureCauchy a)) b
⊢ a = b

tactic: rw [← (@uniformEmbedding_pureCauchy α _).comap_uniformity, Filter.mem_comap] at hs
state_before: α : Type u_1
inst✝ : UniformSpace α
s✝ : SeparatedSpace α
a b : α
h :
  (fun a => Quotient.mk (UniformSpace.separationSetoid (CauchyFilter α)) (pureCauchy a)) a =
    (fun a => Quotient.mk (UniformSpace.separationSetoid (CauchyFilter α)) (pureCauchy a)) b
s : Set (α × α)
hs : s ∈ 𝓤 α
⊢ (a, b) ∈ s

tactic: obtain ⟨t, ht, hts⟩ := hs
state_before: α : Type u_1
inst✝ : UniformSpace α
s✝ : SeparatedSpace α
a b : α
h :
  (fun a => Quotient.mk (UniformSpace.separationSetoid (CauchyFilter α)) (pureCauchy a)) a =
    (fun a => Quotient.mk (UniformSpace.separationSetoid (CauchyFilter α)) (pureCauchy a)) b
s : Set (α × α)
hs : ∃ t, t ∈ 𝓤 (CauchyFilter α) ∧ (fun x => (pureCauchy x.fst, pureCauchy x.snd)) ⁻¹' t ⊆ s
⊢ (a, b) ∈ s

tactic: exact @hts (a, b) (Quotient.exact h t ht)
state_before: case intro.intro
α : Type u_1
inst✝ : UniformSpace α
s✝ : SeparatedSpace α
a b : α
h :
  (fun a => Quotient.mk (UniformSpace.separationSetoid (CauchyFilter α)) (pureCauchy a)) a =
    (fun a => Quotient.mk (UniformSpace.separationSetoid (CauchyFilter α)) (pureCauchy a)) b
s : Set (α × α)
t : Set (CauchyFilter α × CauchyFilter α)
ht : t ∈ 𝓤 (CauchyFilter α)
hts : (fun x => (pureCauchy x.fst, pureCauchy x.snd)) ⁻¹' t ⊆ s
⊢ (a, b) ∈ s
Theorem: MeasureTheory.Measure.measure_prod_null
File: Mathlib/MeasureTheory/Constructions/Prod/Basic.lean

tactic: rw [prod_apply hs, lintegral_eq_zero_iff (measurable_measure_prod_mk_left hs)]
state_before: α : Type u_2
α' : Type ?u.4447223
β : Type u_1
β' : Type ?u.4447229
γ : Type ?u.4447232
E : Type ?u.4447235
inst✝⁶ : MeasurableSpace α
inst✝⁵ : MeasurableSpace α'
inst✝⁴ : MeasurableSpace β
inst✝³ : MeasurableSpace β'
inst✝² : MeasurableSpace γ
μ μ' : Measure α
ν ν' : Measure β
τ : Measure γ
inst✝¹ : NormedAddCommGroup E
inst✝ : SigmaFinite ν
s : Set (α × β)
hs : MeasurableSet s
⊢ ↑↑(Measure.prod μ ν) s = 0 ↔ (fun x => ↑↑ν (Prod.mk x ⁻¹' s)) =ᶠ[ae μ] 0
Theorem: cauchySeq_iff_tendsto
File: Mathlib/Topology/UniformSpace/Cauchy.lean

tactic: simp only [prod_atTop_atTop_eq, Prod.map_def]
state_before: α : Type u
β : Type v
inst✝² : UniformSpace α
inst✝¹ : Nonempty β
inst✝ : SemilatticeSup β
u : β → α
⊢ Tendsto (fun p => (u p.fst, u p.snd)) (atTop ×ˢ atTop) (𝓤 α) ↔ Tendsto (Prod.map u u) atTop (𝓤 α)