tasksource/leandojo huggingface dataset:
Theorem: Set.prod_iUnion
File: Mathlib/Data/Set/Lattice.lean

tactic: ext
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.227121
ι : Sort u_3
ι' : Sort ?u.227127
ι₂ : Sort ?u.227130
κ : ι → Sort ?u.227135
κ₁ : ι → Sort ?u.227140
κ₂ : ι → Sort ?u.227145
κ' : ι' → Sort ?u.227150
s : Set α
t : ι → Set β
⊢ (s ×ˢ ⋃ (i : ι), t i) = ⋃ (i : ι), s ×ˢ t i

tactic: simp
state_before: case h
α : Type u_1
β : Type u_2
γ : Type ?u.227121
ι : Sort u_3
ι' : Sort ?u.227127
ι₂ : Sort ?u.227130
κ : ι → Sort ?u.227135
κ₁ : ι → Sort ?u.227140
κ₂ : ι → Sort ?u.227145
κ' : ι' → Sort ?u.227150
s : Set α
t : ι → Set β
x✝ : α × β
⊢ (x✝ ∈ s ×ˢ ⋃ (i : ι), t i) ↔ x✝ ∈ ⋃ (i : ι), s ×ˢ t i
Theorem: CategoryTheory.Limits.biproduct.fromSubtype_toSubtype
File: Mathlib/CategoryTheory/Limits/Shapes/Biproducts.lean

tactic: refine' biproduct.hom_ext _ _ fun j => _
state_before: J : Type w
C : Type u
inst✝³ : Category C
inst✝² : HasZeroMorphisms C
f : J → C
inst✝¹ : HasBiproduct f
p : J → Prop
inst✝ : HasBiproduct (Subtype.restrict p f)
⊢ fromSubtype f p ≫ toSubtype f p = 𝟙 (⨁ Subtype.restrict p f)

tactic: rw [Category.assoc, biproduct.toSubtype_π, biproduct.fromSubtype_π_subtype, Category.id_comp]
state_before: J : Type w
C : Type u
inst✝³ : Category C
inst✝² : HasZeroMorphisms C
f : J → C
inst✝¹ : HasBiproduct f
p : J → Prop
inst✝ : HasBiproduct (Subtype.restrict p f)
j : Subtype p
⊢ (fromSubtype f p ≫ toSubtype f p) ≫ π (Subtype.restrict p f) j =
    𝟙 (⨁ Subtype.restrict p f) ≫ π (Subtype.restrict p f) j
Theorem: ENNReal.rpow_lt_one
File: Mathlib/Analysis/SpecialFunctions/Pow/NNReal.lean

tactic: lift x to ℝ≥0 using ne_of_lt (lt_of_lt_of_le hx le_top)
state_before: x : ℝ≥0∞
z : ℝ
hx : x < 1
hz : 0 < z
⊢ x ^ z < 1

tactic: simp only [coe_lt_one_iff] at hx
state_before: case intro
z : ℝ
hz : 0 < z
x : ℝ≥0
hx : ↑x < 1
⊢ ↑x ^ z < 1

tactic: simp [coe_rpow_of_nonneg _ (le_of_lt hz), NNReal.rpow_lt_one hx hz]
state_before: case intro
z : ℝ
hz : 0 < z
x : ℝ≥0
hx : x < 1
⊢ ↑x ^ z < 1
Theorem: LinearMap.baseChange_sub
File: Mathlib/RingTheory/TensorProduct.lean

tactic: ext
state_before: R : Type u_4
A : Type u_1
B : Type ?u.473826
M : Type u_2
N : Type u_3
inst✝⁸ : CommRing R
inst✝⁷ : Ring A
inst✝⁶ : Algebra R A
inst✝⁵ : Ring B
inst✝⁴ : Algebra R B
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : AddCommGroup N
inst✝ : Module R N
f g : M →ₗ[R] N
⊢ baseChange A (f - g) = baseChange A f - baseChange A g

tactic: simp [baseChange_eq_ltensor, tmul_sub]
state_before: case a.h.h
R : Type u_4
A : Type u_1
B : Type ?u.473826
M : Type u_2
N : Type u_3
inst✝⁸ : CommRing R
inst✝⁷ : Ring A
inst✝⁶ : Algebra R A
inst✝⁵ : Ring B
inst✝⁴ : Algebra R B
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : AddCommGroup N
inst✝ : Module R N
f g : M →ₗ[R] N
x✝ : M
⊢ ↑(↑(AlgebraTensorModule.curry (baseChange A (f - g))) 1) x✝ =
    ↑(↑(AlgebraTensorModule.curry (baseChange A f - baseChange A g)) 1) x✝
Theorem: Ordinal.iSup_lt
File: Mathlib/SetTheory/Cardinal/Cofinality.lean

tactic: rwa [(#ι).lift_id]
state_before: α : Type ?u.31772
r : α → α → Prop
ι : Type u_1
f : ι → Cardinal
c : Cardinal
hι : (#ι) < cof (ord c)
⊢ Cardinal.lift (#ι) < cof (ord c)
Theorem: Multiset.noncommFoldr_cons
File: Mathlib/Data/Finset/NoncommProd.lean

tactic: induction s using Quotient.inductionOn
state_before: F : Type ?u.2553
ι : Type ?u.2556
α : Type u_1
β : Type u_2
γ : Type ?u.2565
f : α → β → β
op : α → α → α
s : Multiset α
a : α
h : Set.Pairwise {x | x ∈ a ::ₘ s} fun x y => ∀ (b : β), f x (f y b) = f y (f x b)
h' : Set.Pairwise {x | x ∈ s} fun x y => ∀ (b : β), f x (f y b) = f y (f x b)
b : β
⊢ noncommFoldr f (a ::ₘ s) h b = f a (noncommFoldr f s h' b)

tactic: simp
state_before: case h
F : Type ?u.2553
ι : Type ?u.2556
α : Type u_1
β : Type u_2
γ : Type ?u.2565
f : α → β → β
op : α → α → α
a : α
b : β
a✝ : List α
h : Set.Pairwise {x | x ∈ a ::ₘ Quotient.mk (List.isSetoid α) a✝} fun x y => ∀ (b : β), f x (f y b) = f y (f x b)
h' : Set.Pairwise {x | x ∈ Quotient.mk (List.isSetoid α) a✝} fun x y => ∀ (b : β), f x (f y b) = f y (f x b)
⊢ noncommFoldr f (a ::ₘ Quotient.mk (List.isSetoid α) a✝) h b =
    f a (noncommFoldr f (Quotient.mk (List.isSetoid α) a✝) h' b)
Theorem: HallMarriageTheorem.hall_cond_of_restrict
File: Mathlib/Combinatorics/Hall/Finite.lean

tactic: classical
  rw [← card_image_of_injective s' Subtype.coe_injective]
  convert ht (s'.image fun z => z.1) using 1
  apply congr_arg
  ext y
  simp
state_before: ι✝ : Type u
α : Type v
inst✝¹ : DecidableEq α
t✝ : ι✝ → Finset α
inst✝ : Fintype ι✝
ι : Type u
t : ι → Finset α
s : Finset ι
ht : ∀ (s : Finset ι), card s ≤ card (Finset.biUnion s t)
s' : Finset ↑↑s
⊢ card s' ≤ card (Finset.biUnion s' fun a' => t ↑a')

tactic: rw [← card_image_of_injective s' Subtype.coe_injective]
state_before: ι✝ : Type u
α : Type v
inst✝¹ : DecidableEq α
t✝ : ι✝ → Finset α
inst✝ : Fintype ι✝
ι : Type u
t : ι → Finset α
s : Finset ι
ht : ∀ (s : Finset ι), card s ≤ card (Finset.biUnion s t)
s' : Finset ↑↑s
⊢ card s' ≤ card (Finset.biUnion s' fun a' => t ↑a')

tactic: convert ht (s'.image fun z => z.1) using 1
state_before: ι✝ : Type u
α : Type v
inst✝¹ : DecidableEq α
t✝ : ι✝ → Finset α
inst✝ : Fintype ι✝
ι : Type u
t : ι → Finset α
s : Finset ι
ht : ∀ (s : Finset ι), card s ≤ card (Finset.biUnion s t)
s' : Finset ↑↑s
⊢ card (image (fun a => ↑a) s') ≤ card (Finset.biUnion s' fun a' => t ↑a')

tactic: apply congr_arg
state_before: case h.e'_4
ι✝ : Type u
α : Type v
inst✝¹ : DecidableEq α
t✝ : ι✝ → Finset α
inst✝ : Fintype ι✝
ι : Type u
t : ι → Finset α
s : Finset ι
ht : ∀ (s : Finset ι), card s ≤ card (Finset.biUnion s t)
s' : Finset ↑↑s
⊢ card (Finset.biUnion s' fun a' => t ↑a') = card (Finset.biUnion (image (fun z => ↑z) s') t)

tactic: ext y
state_before: case h.e'_4.h
ι✝ : Type u
α : Type v
inst✝¹ : DecidableEq α
t✝ : ι✝ → Finset α
inst✝ : Fintype ι✝
ι : Type u
t : ι → Finset α
s : Finset ι
ht : ∀ (s : Finset ι), card s ≤ card (Finset.biUnion s t)
s' : Finset ↑↑s
⊢ (Finset.biUnion s' fun a' => t ↑a') = Finset.biUnion (image (fun z => ↑z) s') t

tactic: simp
state_before: case h.e'_4.h.a
ι✝ : Type u
α : Type v
inst✝¹ : DecidableEq α
t✝ : ι✝ → Finset α
inst✝ : Fintype ι✝
ι : Type u
t : ι → Finset α
s : Finset ι
ht : ∀ (s : Finset ι), card s ≤ card (Finset.biUnion s t)
s' : Finset ↑↑s
y : α
⊢ (y ∈ Finset.biUnion s' fun a' => t ↑a') ↔ y ∈ Finset.biUnion (image (fun z => ↑z) s') t
Theorem: Finset.coe_pair
File: Mathlib/Data/Finset/Basic.lean

tactic: ext
state_before: α : Type u_1
β : Type ?u.108687
γ : Type ?u.108690
inst✝ : DecidableEq α
s t u v : Finset α
a✝ b✝ a b : α
⊢ ↑{a, b} = {a, b}

tactic: simp
state_before: case h
α : Type u_1
β : Type ?u.108687
γ : Type ?u.108690
inst✝ : DecidableEq α
s t u v : Finset α
a✝ b✝ a b x✝ : α
⊢ x✝ ∈ ↑{a, b} ↔ x✝ ∈ {a, b}
Theorem: StrictConvex.add_right
File: Mathlib/Analysis/Convex/Strict.lean

tactic: simpa only [add_comm] using hs.add_left z
state_before: 𝕜 : Type u_1
𝕝 : Type ?u.89300
E : Type u_2
F : Type ?u.89306
β : Type ?u.89309
inst✝⁷ : OrderedSemiring 𝕜
inst✝⁶ : TopologicalSpace E
inst✝⁵ : TopologicalSpace F
inst✝⁴ : AddCommGroup E
inst✝³ : AddCommGroup F
inst✝² : Module 𝕜 E
inst✝¹ : Module 𝕜 F
inst✝ : ContinuousAdd E
s t : Set E
hs : StrictConvex 𝕜 s
z : E
⊢ StrictConvex 𝕜 ((fun x => x + z) '' s)
Theorem: UniformCauchySeqOn.div
File: Mathlib/Topology/Algebra/UniformGroup.lean

tactic: simpa using (uniformContinuous_div.comp_uniformCauchySeqOn (hf.prod' hf')) u hu
state_before: α : Type u_2
β : Type u_1
inst✝² : UniformSpace α
inst✝¹ : Group α
inst✝ : UniformGroup α
ι : Type u_3
l : Filter ι
l' : Filter β
f f' : ι → β → α
g g' : β → α
s : Set β
hf : UniformCauchySeqOn f l s
hf' : UniformCauchySeqOn f' l s
u : Set (α × α)
hu : u ∈ 𝓤 α
⊢ ∀ᶠ (m : ι × ι) in l ×ˢ l, ∀ (x : β), x ∈ s → ((f / f') m.fst x, (f / f') m.snd x) ∈ u
Theorem: PNat.Coprime.factor_eq_gcd_left
File: Mathlib/Data/PNat/Prime.lean

tactic: rw [gcd_eq_left_iff_dvd] at am
state_before: a b m n : ℕ+
cop : Coprime m n
am : a ∣ m
bn : b ∣ n
⊢ a = gcd (a * b) m

tactic: conv_lhs => rw [← am]
state_before: a b m n : ℕ+
cop : Coprime m n
am : gcd a m = a
bn : b ∣ n
⊢ a = gcd (a * b) m

tactic: rw [eq_comm]
state_before: a b m n : ℕ+
cop : Coprime m n
am : gcd a m = a
bn : b ∣ n
⊢ gcd a m = gcd (a * b) m

tactic: apply Coprime.gcd_mul_right_cancel a
state_before: a b m n : ℕ+
cop : Coprime m n
am : gcd a m = a
bn : b ∣ n
⊢ gcd (a * b) m = gcd a m

tactic: apply Coprime.coprime_dvd_left bn cop.symm
state_before: a b m n : ℕ+
cop : Coprime m n
am : gcd a m = a
bn : b ∣ n
⊢ Coprime b m
Theorem: List.foldl_ext
File: Mathlib/Data/List/Basic.lean

tactic: induction l generalizing a with
| nil => rfl
| cons hd tl ih =>
  unfold foldl
  rw [ih _ fun a b bin => H a b <| mem_cons_of_mem _ bin, H a hd (mem_cons_self _ _)]
state_before: ι : Type ?u.228451
α : Type u
β : Type v
γ : Type w
δ : Type x
l₁ l₂ : List α
f g : α → β → α
a : α
l : List β
H : ∀ (a : α) (b : β), b ∈ l → f a b = g a b
⊢ foldl f a l = foldl g a l

tactic: rfl
state_before: case nil
ι : Type ?u.228451
α : Type u
β : Type v
γ : Type w
δ : Type x
l₁ l₂ : List α
f g : α → β → α
a : α
H : ∀ (a : α) (b : β), b ∈ [] → f a b = g a b
⊢ foldl f a [] = foldl g a []

tactic: unfold foldl
state_before: case cons
ι : Type ?u.228451
α : Type u
β : Type v
γ : Type w
δ : Type x
l₁ l₂ : List α
f g : α → β → α
hd : β
tl : List β
ih : ∀ (a : α), (∀ (a : α) (b : β), b ∈ tl → f a b = g a b) → foldl f a tl = foldl g a tl
a : α
H : ∀ (a : α) (b : β), b ∈ hd :: tl → f a b = g a b
⊢ foldl f a (hd :: tl) = foldl g a (hd :: tl)

tactic: rw [ih _ fun a b bin => H a b <| mem_cons_of_mem _ bin, H a hd (mem_cons_self _ _)]
state_before: case cons
ι : Type ?u.228451
α : Type u
β : Type v
γ : Type w
δ : Type x
l₁ l₂ : List α
f g : α → β → α
hd : β
tl : List β
ih : ∀ (a : α), (∀ (a : α) (b : β), b ∈ tl → f a b = g a b) → foldl f a tl = foldl g a tl
a : α
H : ∀ (a : α) (b : β), b ∈ hd :: tl → f a b = g a b
⊢ foldl f (f a hd) tl = foldl g (g a hd) tl
Theorem: Nat.lxor'_right_injective
File: Mathlib/Data/Nat/Bitwise.lean

tactic: rw [← lxor'_cancel_left n m, ← lxor'_cancel_left n m', h]
state_before: n m m' : ℕ
h : lxor' n m = lxor' n m'
⊢ m = m'
Theorem: Irrational.rat_sub
File: Mathlib/Data/Real/Irrational.lean

tactic: simpa only [sub_eq_add_neg] using h.neg.rat_add q
state_before: q : ℚ
x y : ℝ
h : Irrational x
⊢ Irrational (↑q - x)
Theorem: Asymptotics.isBigO_iff
File: Mathlib/Analysis/Asymptotics/Asymptotics.lean

tactic: simp only [IsBigO_def, IsBigOWith_def]
state_before: α : Type u_1
β : Type ?u.12543
E : Type u_2
F : Type u_3
G : Type ?u.12552
E' : Type ?u.12555
F' : Type ?u.12558
G' : Type ?u.12561
E'' : Type ?u.12564
F'' : Type ?u.12567
G'' : Type ?u.12570
R : Type ?u.12573
R' : Type ?u.12576
𝕜 : Type ?u.12579
𝕜' : Type ?u.12582
inst✝¹² : Norm E
inst✝¹¹ : Norm F
inst✝¹⁰ : Norm G
inst✝⁹ : SeminormedAddCommGroup E'
inst✝⁸ : SeminormedAddCommGroup F'
inst✝⁷ : SeminormedAddCommGroup G'
inst✝⁶ : NormedAddCommGroup E''
inst✝⁵ : NormedAddCommGroup F''
inst✝⁴ : NormedAddCommGroup G''
inst✝³ : SeminormedRing R
inst✝² : SeminormedRing R'
inst✝¹ : NormedField 𝕜
inst✝ : NormedField 𝕜'
c c' c₁ c₂ : ℝ
f : α → E
g : α → F
k : α → G
f' : α → E'
g' : α → F'
k' : α → G'
f'' : α → E''
g'' : α → F''
k'' : α → G''
l l' : Filter α
⊢ f =O[l] g ↔ ∃ c, ∀ᶠ (x : α) in l, ‖f x‖ ≤ c * ‖g x‖
Theorem: Filter.Tendsto.atTop_nsmul_neg_const
File: Mathlib/Order/Filter/Archimedean.lean

tactic: simpa using hf.atTop_nsmul_const (neg_pos.2 hr)
state_before: α : Type u_2
R : Type u_1
l : Filter α
f✝ : α → R
r : R
inst✝¹ : LinearOrderedAddCommGroup R
inst✝ : Archimedean R
f : α → ℕ
hr : r < 0
hf : Tendsto f l atTop
⊢ Tendsto (fun x => f x • r) l atBot
Theorem: CategoryTheory.CosimplicialObject.augment_hom_zero
File: Mathlib/AlgebraicTopology/SimplicialObject.lean

tactic: dsimp
state_before: C : Type u
inst✝ : Category C
X✝ X : CosimplicialObject C
X₀ : C
f : X₀ ⟶ X.obj [0]
w : ∀ (i : SimplexCategory) (g₁ g₂ : [0] ⟶ i), f ≫ X.map g₁ = f ≫ X.map g₂
⊢ (augment X X₀ f w).hom.app [0] = f

tactic: rw [SimplexCategory.hom_zero_zero ([0].const 0), X.map_id, Category.comp_id]
state_before: C : Type u
inst✝ : Category C
X✝ X : CosimplicialObject C
X₀ : C
f : X₀ ⟶ X.obj [0]
w : ∀ (i : SimplexCategory) (g₁ g₂ : [0] ⟶ i), f ≫ X.map g₁ = f ≫ X.map g₂
⊢ f ≫ X.map (SimplexCategory.const [0] 0) = f
Theorem: one_le_of_le_mul_left
File: Mathlib/Algebra/Order/Monoid/Lemmas.lean

tactic: simpa only [one_mul]
state_before: α : Type u_1
β : Type ?u.16522
inst✝² : MulOneClass α
inst✝¹ : LE α
inst✝ : ContravariantClass α α (swap fun x x_1 => x * x_1) fun x x_1 => x ≤ x_1
a b : α
h : b ≤ a * b
⊢ 1 * ?m.16901 h ≤ a * ?m.16901 h
Theorem: MultilinearMap.domCoprod_alternization_eq
File: Mathlib/LinearAlgebra/Alternating.lean

tactic: rw [MultilinearMap.domCoprod_alternization, coe_alternatization, coe_alternatization, mul_smul,
  ← AlternatingMap.domCoprod'_apply, ← AlternatingMap.domCoprod'_apply,
  ← TensorProduct.smul_tmul', TensorProduct.tmul_smul,
  LinearMap.map_smul_of_tower AlternatingMap.domCoprod',
  LinearMap.map_smul_of_tower AlternatingMap.domCoprod']
state_before: R : Type ?u.1240826
inst✝²¹ : Semiring R
M : Type ?u.1240832
inst✝²⁰ : AddCommMonoid M
inst✝¹⁹ : Module R M
N : Type ?u.1240864
inst✝¹⁸ : AddCommMonoid N
inst✝¹⁷ : Module R N
P : Type ?u.1240894
inst✝¹⁶ : AddCommMonoid P
inst✝¹⁵ : Module R P
M' : Type ?u.1240924
inst✝¹⁴ : AddCommGroup M'
inst✝¹³ : Module R M'
N' : Type ?u.1241312
inst✝¹² : AddCommGroup N'
inst✝¹¹ : Module R N'
ι : Type ?u.1241700
ι' : Type ?u.1241703
ι'' : Type ?u.1241706
ιa : Type u_1
ιb : Type u_2
inst✝¹⁰ : Fintype ιa
inst✝⁹ : Fintype ιb
R' : Type u_3
Mᵢ : Type u_4
N₁ : Type u_5
N₂ : Type u_6
inst✝⁸ : CommSemiring R'
inst✝⁷ : AddCommGroup N₁
inst✝⁶ : Module R' N₁
inst✝⁵ : AddCommGroup N₂
inst✝⁴ : Module R' N₂
inst✝³ : AddCommMonoid Mᵢ
inst✝² : Module R' Mᵢ
inst✝¹ : DecidableEq ιa
inst✝ : DecidableEq ιb
a : AlternatingMap R' Mᵢ N₁ ιa
b : AlternatingMap R' Mᵢ N₂ ιb
⊢ ↑alternatization (domCoprod ↑a ↑b) =
    (Nat.factorial (Fintype.card ιa) * Nat.factorial (Fintype.card ιb)) • AlternatingMap.domCoprod a b
Theorem: Ordinal.lt_mul_div_add
File: Mathlib/SetTheory/Ordinal/Arithmetic.lean

tactic: simpa only [mul_succ] using lt_mul_succ_div a h
state_before: α : Type ?u.230000
β : Type ?u.230003
γ : Type ?u.230006
r : α → α → Prop
s : β → β → Prop
t : γ → γ → Prop
a b : Ordinal
h : b ≠ 0
⊢ a < b * (a / b) + b
Theorem: Nat.mul2_isPowerOfTwo_of_isPowerOfTwo
File: src/lean/Init/Data/Nat/Power2.lean

tactic: simp [h, Nat.pow_succ]
state_before: n : Nat
h✝ : isPowerOfTwo n
k : Nat
h : n = 2 ^ k
⊢ n * 2 = 2 ^ (k + 1)
Theorem: Fintype.bddAbove_range
File: Mathlib/Data/Fintype/Order.lean

tactic: obtain ⟨M, hM⟩ := Fintype.exists_le f
state_before: α : Type u_1
inst✝³ : Nonempty α
inst✝² : Preorder α
inst✝¹ : IsDirected α fun x x_1 => x ≤ x_1
β : Type u_2
inst✝ : Fintype β
f : β → α
⊢ BddAbove (Set.range f)

tactic: refine' ⟨M, fun a ha => _⟩
state_before: case intro
α : Type u_1
inst✝³ : Nonempty α
inst✝² : Preorder α
inst✝¹ : IsDirected α fun x x_1 => x ≤ x_1
β : Type u_2
inst✝ : Fintype β
f : β → α
M : α
hM : ∀ (i : β), f i ≤ M
⊢ BddAbove (Set.range f)

tactic: obtain ⟨b, rfl⟩ := ha
state_before: case intro
α : Type u_1
inst✝³ : Nonempty α
inst✝² : Preorder α
inst✝¹ : IsDirected α fun x x_1 => x ≤ x_1
β : Type u_2
inst✝ : Fintype β
f : β → α
M : α
hM : ∀ (i : β), f i ≤ M
a : α
ha : a ∈ Set.range f
⊢ a ≤ M

tactic: exact hM b
state_before: case intro.intro
α : Type u_1
inst✝³ : Nonempty α
inst✝² : Preorder α
inst✝¹ : IsDirected α fun x x_1 => x ≤ x_1
β : Type u_2
inst✝ : Fintype β
f : β → α
M : α
hM : ∀ (i : β), f i ≤ M
b : β
⊢ f b ≤ M
Theorem: MulMemClass.mul_mem_add_closure
File: Mathlib/GroupTheory/Submonoid/Membership.lean

tactic: revert a
state_before: M : Type u_2
A : Type ?u.259525
B : Type ?u.259528
R : Type u_1
inst✝² : NonUnitalNonAssocSemiring R
inst✝¹ : SetLike M R
inst✝ : MulMemClass M R
S : M
a b : R
ha : a ∈ AddSubmonoid.closure ↑S
hb : b ∈ AddSubmonoid.closure ↑S
⊢ a * b ∈ AddSubmonoid.closure ↑S

tactic: refine' @AddSubmonoid.closure_induction _ _ _
  (fun z =>  ∀ {a : R}, a ∈ AddSubmonoid.closure ↑S → a * z ∈ AddSubmonoid.closure ↑S)
    _ hb _ _ _ <;> clear hb b
state_before: M : Type u_2
A : Type ?u.259525
B : Type ?u.259528
R : Type u_1
inst✝² : NonUnitalNonAssocSemiring R
inst✝¹ : SetLike M R
inst✝ : MulMemClass M R
S : M
b : R
hb : b ∈ AddSubmonoid.closure ↑S
⊢ ∀ {a : R}, a ∈ AddSubmonoid.closure ↑S → a * b ∈ AddSubmonoid.closure ↑S

tactic: exact fun r hr b hb => MulMemClass.mul_right_mem_add_closure hb hr
state_before: case refine'_1
M : Type u_2
A : Type ?u.259525
B : Type ?u.259528
R : Type u_1
inst✝² : NonUnitalNonAssocSemiring R
inst✝¹ : SetLike M R
inst✝ : MulMemClass M R
S : M
⊢ ∀ (x : R), x ∈ ↑S → (fun z => ∀ {a : R}, a ∈ AddSubmonoid.closure ↑S → a * z ∈ AddSubmonoid.closure ↑S) x

tactic: exact fun _ => by simp only [mul_zero, (AddSubmonoid.closure (S : Set R)).zero_mem]
state_before: case refine'_2
M : Type u_2
A : Type ?u.259525
B : Type ?u.259528
R : Type u_1
inst✝² : NonUnitalNonAssocSemiring R
inst✝¹ : SetLike M R
inst✝ : MulMemClass M R
S : M
⊢ (fun z => ∀ {a : R}, a ∈ AddSubmonoid.closure ↑S → a * z ∈ AddSubmonoid.closure ↑S) 0

tactic: simp only [mul_zero, (AddSubmonoid.closure (S : Set R)).zero_mem]
state_before: M : Type u_2
A : Type ?u.259525
B : Type ?u.259528
R : Type u_1
inst✝² : NonUnitalNonAssocSemiring R
inst✝¹ : SetLike M R
inst✝ : MulMemClass M R
S : M
a✝ : R
x✝ : a✝ ∈ AddSubmonoid.closure ↑S
⊢ a✝ * 0 ∈ AddSubmonoid.closure ↑S

tactic: simp_rw [mul_add]
state_before: case refine'_3
M : Type u_2
A : Type ?u.259525
B : Type ?u.259528
R : Type u_1
inst✝² : NonUnitalNonAssocSemiring R
inst✝¹ : SetLike M R
inst✝ : MulMemClass M R
S : M
⊢ ∀ (x y : R),
    (fun z => ∀ {a : R}, a ∈ AddSubmonoid.closure ↑S → a * z ∈ AddSubmonoid.closure ↑S) x →
      (fun z => ∀ {a : R}, a ∈ AddSubmonoid.closure ↑S → a * z ∈ AddSubmonoid.closure ↑S) y →
        (fun z => ∀ {a : R}, a ∈ AddSubmonoid.closure ↑S → a * z ∈ AddSubmonoid.closure ↑S) (x + y)

tactic: exact fun r s hr hs b hb => (AddSubmonoid.closure (S : Set R)).add_mem (hr hb) (hs hb)
state_before: case refine'_3
M : Type u_2
A : Type ?u.259525
B : Type ?u.259528
R : Type u_1
inst✝² : NonUnitalNonAssocSemiring R
inst✝¹ : SetLike M R
inst✝ : MulMemClass M R
S : M
⊢ ∀ (x y : R),
    (∀ {a : R}, a ∈ AddSubmonoid.closure ↑S → a * x ∈ AddSubmonoid.closure ↑S) →
      (∀ {a : R}, a ∈ AddSubmonoid.closure ↑S → a * y ∈ AddSubmonoid.closure ↑S) →
        ∀ {a : R}, a ∈ AddSubmonoid.closure ↑S → a * x + a * y ∈ AddSubmonoid.closure ↑S
Theorem: LinearMap.separatingLeft_toLinearMap₂'_iff_det_ne_zero
File: Mathlib/LinearAlgebra/Matrix/SesquilinearForm.lean

tactic: rw [Matrix.separatingLeft_toLinearMap₂'_iff, Matrix.nondegenerate_iff_det_ne_zero]
state_before: R : Type ?u.2867092
R₁ : Type u_2
R₂ : Type ?u.2867098
M✝ : Type ?u.2867101
M₁ : Type ?u.2867104
M₂ : Type ?u.2867107
M₁' : Type ?u.2867110
M₂' : Type ?u.2867113
n : Type ?u.2867116
m : Type ?u.2867119
n' : Type ?u.2867122
m' : Type ?u.2867125
ι : Type u_1
inst✝⁵ : CommRing R₁
inst✝⁴ : AddCommMonoid M₁
inst✝³ : Module R₁ M₁
inst✝² : DecidableEq ι
inst✝¹ : Fintype ι
B : M₁ →ₗ[R₁] M₁ →ₗ[R₁] R₁
inst✝ : IsDomain R₁
M : Matrix ι ι R₁
⊢ SeparatingLeft (↑toLinearMap₂' M) ↔ det M ≠ 0
Theorem: HasDerivAt.lhopital_zero_left_on_Ioc
File: Mathlib/Analysis/Calculus/LHopital.lean

tactic: refine' lhopital_zero_left_on_Ioo hab hff' hgg' hg' _ _ hdiv
state_before: a b : ℝ
hab : a < b
l : Filter ℝ
f f' g g' : ℝ → ℝ
hff' : ∀ (x : ℝ), x ∈ Ioo a b → HasDerivAt f (f' x) x
hgg' : ∀ (x : ℝ), x ∈ Ioo a b → HasDerivAt g (g' x) x
hcf : ContinuousOn f (Ioc a b)
hcg : ContinuousOn g (Ioc a b)
hg' : ∀ (x : ℝ), x ∈ Ioo a b → g' x ≠ 0
hfb : f b = 0
hgb : g b = 0
hdiv : Tendsto (fun x => f' x / g' x) (𝓝[Iio b] b) l
⊢ Tendsto (fun x => f x / g x) (𝓝[Iio b] b) l

tactic: rw [← hfb, ← nhdsWithin_Ioo_eq_nhdsWithin_Iio hab]
state_before: case refine'_1
a b : ℝ
hab : a < b
l : Filter ℝ
f f' g g' : ℝ → ℝ
hff' : ∀ (x : ℝ), x ∈ Ioo a b → HasDerivAt f (f' x) x
hgg' : ∀ (x : ℝ), x ∈ Ioo a b → HasDerivAt g (g' x) x
hcf : ContinuousOn f (Ioc a b)
hcg : ContinuousOn g (Ioc a b)
hg' : ∀ (x : ℝ), x ∈ Ioo a b → g' x ≠ 0
hfb : f b = 0
hgb : g b = 0
hdiv : Tendsto (fun x => f' x / g' x) (𝓝[Iio b] b) l
⊢ Tendsto (fun x => f x) (𝓝[Iio b] b) (𝓝 0)

tactic: exact ((hcf b <| right_mem_Ioc.mpr hab).mono Ioo_subset_Ioc_self).tendsto
state_before: case refine'_1
a b : ℝ
hab : a < b
l : Filter ℝ
f f' g g' : ℝ → ℝ
hff' : ∀ (x : ℝ), x ∈ Ioo a b → HasDerivAt f (f' x) x
hgg' : ∀ (x : ℝ), x ∈ Ioo a b → HasDerivAt g (g' x) x
hcf : ContinuousOn f (Ioc a b)
hcg : ContinuousOn g (Ioc a b)
hg' : ∀ (x : ℝ), x ∈ Ioo a b → g' x ≠ 0
hfb : f b = 0
hgb : g b = 0
hdiv : Tendsto (fun x => f' x / g' x) (𝓝[Iio b] b) l
⊢ Tendsto (fun x => f x) (𝓝[Ioo a b] b) (𝓝 (f b))

tactic: rw [← hgb, ← nhdsWithin_Ioo_eq_nhdsWithin_Iio hab]
state_before: case refine'_2
a b : ℝ
hab : a < b
l : Filter ℝ
f f' g g' : ℝ → ℝ
hff' : ∀ (x : ℝ), x ∈ Ioo a b → HasDerivAt f (f' x) x
hgg' : ∀ (x : ℝ), x ∈ Ioo a b → HasDerivAt g (g' x) x
hcf : ContinuousOn f (Ioc a b)
hcg : ContinuousOn g (Ioc a b)
hg' : ∀ (x : ℝ), x ∈ Ioo a b → g' x ≠ 0
hfb : f b = 0
hgb : g b = 0
hdiv : Tendsto (fun x => f' x / g' x) (𝓝[Iio b] b) l
⊢ Tendsto (fun x => g x) (𝓝[Iio b] b) (𝓝 0)

tactic: exact ((hcg b <| right_mem_Ioc.mpr hab).mono Ioo_subset_Ioc_self).tendsto
state_before: case refine'_2
a b : ℝ
hab : a < b
l : Filter ℝ
f f' g g' : ℝ → ℝ
hff' : ∀ (x : ℝ), x ∈ Ioo a b → HasDerivAt f (f' x) x
hgg' : ∀ (x : ℝ), x ∈ Ioo a b → HasDerivAt g (g' x) x
hcf : ContinuousOn f (Ioc a b)
hcg : ContinuousOn g (Ioc a b)
hg' : ∀ (x : ℝ), x ∈ Ioo a b → g' x ≠ 0
hfb : f b = 0
hgb : g b = 0
hdiv : Tendsto (fun x => f' x / g' x) (𝓝[Iio b] b) l
⊢ Tendsto (fun x => g x) (𝓝[Ioo a b] b) (𝓝 (g b))
Theorem: Traversable.toList_eq_self
File: Mathlib/Control/Fold.lean

tactic: simp only [toList_spec, foldMap, traverse]
state_before: α β γ : Type u
t : Type u → Type u
inst✝¹ : Traversable t
inst✝ : IsLawfulTraversable t
xs : List α
⊢ toList xs = xs

tactic: induction xs
state_before: α β γ : Type u
t : Type u → Type u
inst✝¹ : Traversable t
inst✝ : IsLawfulTraversable t
xs : List α
⊢ ↑FreeMonoid.toList (List.traverse (Const.mk' ∘ FreeMonoid.of) xs) = xs

tactic: case nil => rfl
state_before: case nil
α β γ : Type u
t : Type u → Type u
inst✝¹ : Traversable t
inst✝ : IsLawfulTraversable t
⊢ ↑FreeMonoid.toList (List.traverse (Const.mk' ∘ FreeMonoid.of) []) = []

case cons
α β γ : Type u
t : Type u → Type u
inst✝¹ : Traversable t
inst✝ : IsLawfulTraversable t
head✝ : α
tail✝ : List α
tail_ih✝ : ↑FreeMonoid.toList (List.traverse (Const.mk' ∘ FreeMonoid.of) tail✝) = tail✝
⊢ ↑FreeMonoid.toList (List.traverse (Const.mk' ∘ FreeMonoid.of) (head✝ :: tail✝)) = head✝ :: tail✝

tactic: case cons _ _ ih => conv_rhs => rw [← ih]; rfl
state_before: case cons
α β γ : Type u
t : Type u → Type u
inst✝¹ : Traversable t
inst✝ : IsLawfulTraversable t
head✝ : α
tail✝ : List α
tail_ih✝ : ↑FreeMonoid.toList (List.traverse (Const.mk' ∘ FreeMonoid.of) tail✝) = tail✝
⊢ ↑FreeMonoid.toList (List.traverse (Const.mk' ∘ FreeMonoid.of) (head✝ :: tail✝)) = head✝ :: tail✝

tactic: rfl
state_before: α β γ : Type u
t : Type u → Type u
inst✝¹ : Traversable t
inst✝ : IsLawfulTraversable t
⊢ ↑FreeMonoid.toList (List.traverse (Const.mk' ∘ FreeMonoid.of) []) = []

tactic: conv_rhs => rw [← ih]; rfl
state_before: α β γ : Type u
t : Type u → Type u
inst✝¹ : Traversable t
inst✝ : IsLawfulTraversable t
head✝ : α
tail✝ : List α
ih : ↑FreeMonoid.toList (List.traverse (Const.mk' ∘ FreeMonoid.of) tail✝) = tail✝
⊢ ↑FreeMonoid.toList (List.traverse (Const.mk' ∘ FreeMonoid.of) (head✝ :: tail✝)) = head✝ :: tail✝