tasksource/leandojo huggingface dataset:
Theorem: Ordinal.le_iff_derivBFamily
File: Mathlib/SetTheory/Ordinal/FixedPoint.lean

tactic: unfold derivBFamily
state_before: o : Ordinal
f : (b : Ordinal) → b < o → Ordinal → Ordinal
H : ∀ (i : Ordinal) (hi : i < o), IsNormal (f i hi)
a : Ordinal
⊢ (∀ (i : Ordinal) (hi : i < o), f i hi a ≤ a) ↔ ∃ b, derivBFamily o f b = a

tactic: rw [← le_iff_derivFamily]
state_before: o : Ordinal
f : (b : Ordinal) → b < o → Ordinal → Ordinal
H : ∀ (i : Ordinal) (hi : i < o), IsNormal (f i hi)
a : Ordinal
⊢ (∀ (i : Ordinal) (hi : i < o), f i hi a ≤ a) ↔ ∃ b, derivFamily (familyOfBFamily o f) b = a

tactic: refine' ⟨fun h i => h _ _, fun h i hi => _⟩
state_before: o : Ordinal
f : (b : Ordinal) → b < o → Ordinal → Ordinal
H : ∀ (i : Ordinal) (hi : i < o), IsNormal (f i hi)
a : Ordinal
⊢ (∀ (i : Ordinal) (hi : i < o), f i hi a ≤ a) ↔ ∀ (i : (Quotient.out o).α), familyOfBFamily o f i a ≤ a

tactic: rw [← familyOfBFamily_enum o f]
state_before: o : Ordinal
f : (b : Ordinal) → b < o → Ordinal → Ordinal
H : ∀ (i : Ordinal) (hi : i < o), IsNormal (f i hi)
a : Ordinal
h : ∀ (i : (Quotient.out o).α), familyOfBFamily o f i a ≤ a
i : Ordinal
hi : i < o
⊢ f i hi a ≤ a

tactic: apply h
state_before: o : Ordinal
f : (b : Ordinal) → b < o → Ordinal → Ordinal
H : ∀ (i : Ordinal) (hi : i < o), IsNormal (f i hi)
a : Ordinal
h : ∀ (i : (Quotient.out o).α), familyOfBFamily o f i a ≤ a
i : Ordinal
hi : i < o
⊢ familyOfBFamily o f (enum (fun x x_1 => x < x_1) i (_ : i < type fun x x_1 => x < x_1)) a ≤ a

tactic: exact fun _ => H _ _
state_before: case H
o : Ordinal
f : (b : Ordinal) → b < o → Ordinal → Ordinal
H : ∀ (i : Ordinal) (hi : i < o), IsNormal (f i hi)
a : Ordinal
⊢ ∀ (i : (Quotient.out o).α), IsNormal (familyOfBFamily o f i)
Theorem: PrimeSpectrum.vanishingIdeal_zeroLocus_eq_radical
File: Mathlib/AlgebraicGeometry/PrimeSpectrum/Basic.lean

tactic: rw [mem_vanishingIdeal, Ideal.radical_eq_sInf, Submodule.mem_sInf]
state_before: R : Type u
S : Type v
inst✝¹ : CommRing R
inst✝ : CommRing S
I : Ideal R
f : R
⊢ f ∈ vanishingIdeal (zeroLocus ↑I) ↔ f ∈ Ideal.radical I

tactic: exact ⟨fun h x hx => h ⟨x, hx.2⟩ hx.1, fun h x hx => h x.1 ⟨hx, x.2⟩⟩
state_before: R : Type u
S : Type v
inst✝¹ : CommRing R
inst✝ : CommRing S
I : Ideal R
f : R
⊢ (∀ (x : PrimeSpectrum R), x ∈ zeroLocus ↑I → f ∈ x.asIdeal) ↔
    ∀ (p : Submodule R R), p ∈ {J | I ≤ J ∧ Ideal.IsPrime J} → f ∈ p
Theorem: Nat.gcd_zero_right
File: src/lean/Init/Data/Nat/Gcd.lean

tactic: cases n with
| zero => simp [gcd_succ]
| succ n =>
  rw [gcd_succ]
  exact gcd_zero_left _
state_before: n : Nat
⊢ gcd n 0 = n

tactic: simp [gcd_succ]
state_before: case zero

⊢ gcd zero 0 = zero

tactic: rw [gcd_succ]
state_before: case succ
n : Nat
⊢ gcd (succ n) 0 = succ n

tactic: exact gcd_zero_left _
state_before: case succ
n : Nat
⊢ gcd (0 % succ n) (succ n) = succ n
Theorem: Real.sqrt_div_self'
File: Mathlib/Data/Real/Sqrt.lean

tactic: rw [← div_sqrt, one_div_div, div_sqrt]
state_before: x : ℝ
⊢ sqrt x / x = 1 / sqrt x
Theorem: CategoryTheory.Limits.colimit.ι_post
File: Mathlib/CategoryTheory/Limits/HasLimits.lean

tactic: erw [IsColimit.fac]
state_before: J : Type u₁
inst✝⁵ : Category J
K : Type u₂
inst✝⁴ : Category K
C : Type u
inst✝³ : Category C
F : J ⥤ C
D : Type u'
inst✝² : Category D
inst✝¹ : HasColimit F
G : C ⥤ D
inst✝ : HasColimit (F ⋙ G)
j : J
⊢ ι (F ⋙ G) j ≫ post F G = G.map (ι F j)

tactic: rfl
state_before: J : Type u₁
inst✝⁵ : Category J
K : Type u₂
inst✝⁴ : Category K
C : Type u
inst✝³ : Category C
F : J ⥤ C
D : Type u'
inst✝² : Category D
inst✝¹ : HasColimit F
G : C ⥤ D
inst✝ : HasColimit (F ⋙ G)
j : J
⊢ (G.mapCocone (cocone F)).ι.app j = G.map (ι F j)
Theorem: exists_pos_left_iff_sameRay_and_ne_zero
File: Mathlib/LinearAlgebra/Ray.lean

tactic: constructor
state_before: R : Type u_2
inst✝² : LinearOrderedField R
M : Type u_1
inst✝¹ : AddCommGroup M
inst✝ : Module R M
x y : M
hx : x ≠ 0
⊢ (∃ r, 0 < r ∧ r • x = y) ↔ SameRay R x y ∧ y ≠ 0

tactic: rintro ⟨r, hr, rfl⟩
state_before: case mp
R : Type u_2
inst✝² : LinearOrderedField R
M : Type u_1
inst✝¹ : AddCommGroup M
inst✝ : Module R M
x y : M
hx : x ≠ 0
⊢ (∃ r, 0 < r ∧ r • x = y) → SameRay R x y ∧ y ≠ 0

tactic: simp [hx, hr.le, hr.ne']
state_before: case mp.intro.intro
R : Type u_2
inst✝² : LinearOrderedField R
M : Type u_1
inst✝¹ : AddCommGroup M
inst✝ : Module R M
x : M
hx : x ≠ 0
r : R
hr : 0 < r
⊢ SameRay R x (r • x) ∧ r • x ≠ 0

tactic: rintro ⟨hxy, hy⟩
state_before: case mpr
R : Type u_2
inst✝² : LinearOrderedField R
M : Type u_1
inst✝¹ : AddCommGroup M
inst✝ : Module R M
x y : M
hx : x ≠ 0
⊢ SameRay R x y ∧ y ≠ 0 → ∃ r, 0 < r ∧ r • x = y

tactic: exact (exists_pos_left_iff_sameRay hx hy).2 hxy
state_before: case mpr.intro
R : Type u_2
inst✝² : LinearOrderedField R
M : Type u_1
inst✝¹ : AddCommGroup M
inst✝ : Module R M
x y : M
hx : x ≠ 0
hxy : SameRay R x y
hy : y ≠ 0
⊢ ∃ r, 0 < r ∧ r • x = y
Theorem: ZMod.χ₈_nat_mod_eight
File: Mathlib/NumberTheory/LegendreSymbol/ZModChar.lean

tactic: rw [← ZMod.nat_cast_mod n 8]
state_before: n : ℕ
⊢ ↑χ₈ ↑n = ↑χ₈ ↑(n % 8)
Theorem: Finset.prod_Ico_succ_top
File: Mathlib/Algebra/BigOperators/Intervals.lean

tactic: rw [Nat.Ico_succ_right_eq_insert_Ico hab, prod_insert right_not_mem_Ico, mul_comm]
state_before: α : Type u
β : Type v
γ : Type w
s₂ s₁ s : Finset α
a✝ : α
g f✝ : α → β
inst✝ : CommMonoid β
a b : ℕ
hab : a ≤ b
f : ℕ → β
⊢ ∏ k in Ico a (b + 1), f k = (∏ k in Ico a b, f k) * f b
Theorem: IsSMulRegular.of_mul_eq_one
File: Mathlib/Algebra/Regular/SMul.lean

tactic: rw [h]
state_before: R : Type u_1
S : Type ?u.9429
M : Type u_2
a b : R
s : S
inst✝¹ : Monoid R
inst✝ : MulAction R M
h : a * b = 1
⊢ IsSMulRegular M (?m.11206 h * b)

tactic: exact one M
state_before: R : Type u_1
S : Type ?u.9429
M : Type u_2
a b : R
s : S
inst✝¹ : Monoid R
inst✝ : MulAction R M
h : a * b = 1
⊢ IsSMulRegular M 1
Theorem: isOpen_singleton_of_finite_mem_nhds
File: Mathlib/Topology/Separation.lean

tactic: have A : {x} ⊆ s := by simp only [singleton_subset_iff, mem_of_mem_nhds hs]
state_before: α✝ : Type u
β : Type v
inst✝² : TopologicalSpace α✝
α : Type u_1
inst✝¹ : TopologicalSpace α
inst✝ : T1Space α
x : α
s : Set α
hs : s ∈ 𝓝 x
hsf : Set.Finite s
⊢ IsOpen {x}

tactic: have B : IsClosed (s \ {x}) := (hsf.subset (diff_subset _ _)).isClosed
state_before: α✝ : Type u
β : Type v
inst✝² : TopologicalSpace α✝
α : Type u_1
inst✝¹ : TopologicalSpace α
inst✝ : T1Space α
x : α
s : Set α
hs : s ∈ 𝓝 x
hsf : Set.Finite s
A : {x} ⊆ s
⊢ IsOpen {x}

tactic: have C : (s \ {x})ᶜ ∈ 𝓝 x := B.isOpen_compl.mem_nhds fun h => h.2 rfl
state_before: α✝ : Type u
β : Type v
inst✝² : TopologicalSpace α✝
α : Type u_1
inst✝¹ : TopologicalSpace α
inst✝ : T1Space α
x : α
s : Set α
hs : s ∈ 𝓝 x
hsf : Set.Finite s
A : {x} ⊆ s
B : IsClosed (s \ {x})
⊢ IsOpen {x}

tactic: have D : {x} ∈ 𝓝 x := by simpa only [← diff_eq, diff_diff_cancel_left A] using inter_mem hs C
state_before: α✝ : Type u
β : Type v
inst✝² : TopologicalSpace α✝
α : Type u_1
inst✝¹ : TopologicalSpace α
inst✝ : T1Space α
x : α
s : Set α
hs : s ∈ 𝓝 x
hsf : Set.Finite s
A : {x} ⊆ s
B : IsClosed (s \ {x})
C : (s \ {x})ᶜ ∈ 𝓝 x
⊢ IsOpen {x}

tactic: rwa [← mem_interior_iff_mem_nhds, ← singleton_subset_iff, subset_interior_iff_isOpen] at D
state_before: α✝ : Type u
β : Type v
inst✝² : TopologicalSpace α✝
α : Type u_1
inst✝¹ : TopologicalSpace α
inst✝ : T1Space α
x : α
s : Set α
hs : s ∈ 𝓝 x
hsf : Set.Finite s
A : {x} ⊆ s
B : IsClosed (s \ {x})
C : (s \ {x})ᶜ ∈ 𝓝 x
D : {x} ∈ 𝓝 x
⊢ IsOpen {x}

tactic: simp only [singleton_subset_iff, mem_of_mem_nhds hs]
state_before: α✝ : Type u
β : Type v
inst✝² : TopologicalSpace α✝
α : Type u_1
inst✝¹ : TopologicalSpace α
inst✝ : T1Space α
x : α
s : Set α
hs : s ∈ 𝓝 x
hsf : Set.Finite s
⊢ {x} ⊆ s

tactic: simpa only [← diff_eq, diff_diff_cancel_left A] using inter_mem hs C
state_before: α✝ : Type u
β : Type v
inst✝² : TopologicalSpace α✝
α : Type u_1
inst✝¹ : TopologicalSpace α
inst✝ : T1Space α
x : α
s : Set α
hs : s ∈ 𝓝 x
hsf : Set.Finite s
A : {x} ⊆ s
B : IsClosed (s \ {x})
C : (s \ {x})ᶜ ∈ 𝓝 x
⊢ {x} ∈ 𝓝 x
Theorem: ENNReal.limsup_mul_le
File: Mathlib/Order/Filter/ENNReal.lean

tactic: refine limsup_le_limsup ?_
state_before: α : Type u_1
f : Filter α
inst✝ : CountableInterFilter f
u v : α → ℝ≥0∞
⊢ limsup (u * v) f ≤ limsup (fun x => limsup u f * v x) f

tactic: filter_upwards [@eventually_le_limsup _ f _ u] with x hx using mul_le_mul' hx le_rfl
state_before: α : Type u_1
f : Filter α
inst✝ : CountableInterFilter f
u v : α → ℝ≥0∞
⊢ u * v ≤ᶠ[f] fun x => limsup u f * v x
Theorem: CategoryTheory.Adjunction.he''
File: Mathlib/CategoryTheory/Adjunction/Basic.lean

tactic: intros
state_before: C : Type u₁
inst✝¹ : Category C
D : Type u₂
inst✝ : Category D
F : C ⥤ D
G : D ⥤ C
G_obj : D → C
e : (X : C) → (Y : D) → (F.obj X ⟶ Y) ≃ (X ⟶ G_obj Y)
he : ∀ (X' X : C) (Y : D) (f : X' ⟶ X) (g : F.obj X ⟶ Y), ↑(e X' Y) (F.map f ≫ g) = f ≫ ↑(e X Y) g
X' X : C
Y : D
f : X' ⟶ X
g : X ⟶ G_obj Y
⊢ F.map f ≫ ↑(e X Y).symm g = ↑(e X' Y).symm (f ≫ g)

tactic: rw [Equiv.eq_symm_apply, he]
state_before: C : Type u₁
inst✝¹ : Category C
D : Type u₂
inst✝ : Category D
F : C ⥤ D
G : D ⥤ C
G_obj : D → C
e : (X : C) → (Y : D) → (F.obj X ⟶ Y) ≃ (X ⟶ G_obj Y)
he : ∀ (X' X : C) (Y : D) (f : X' ⟶ X) (g : F.obj X ⟶ Y), ↑(e X' Y) (F.map f ≫ g) = f ≫ ↑(e X Y) g
X' X : C
Y : D
f : X' ⟶ X
g : X ⟶ G_obj Y
⊢ F.map f ≫ ↑(e X Y).symm g = ↑(e X' Y).symm (f ≫ g)

tactic: simp
state_before: C : Type u₁
inst✝¹ : Category C
D : Type u₂
inst✝ : Category D
F : C ⥤ D
G : D ⥤ C
G_obj : D → C
e : (X : C) → (Y : D) → (F.obj X ⟶ Y) ≃ (X ⟶ G_obj Y)
he : ∀ (X' X : C) (Y : D) (f : X' ⟶ X) (g : F.obj X ⟶ Y), ↑(e X' Y) (F.map f ≫ g) = f ≫ ↑(e X Y) g
X' X : C
Y : D
f : X' ⟶ X
g : X ⟶ G_obj Y
⊢ f ≫ ↑(e X Y) (↑(e X Y).symm g) = f ≫ g
Theorem: Asymptotics.isLittleO_iff_forall_isBigOWith
File: Mathlib/Analysis/Asymptotics/Asymptotics.lean

tactic: rw [IsLittleO_def]
state_before: α : Type u_1
β : Type ?u.24405
E : Type u_2
F : Type u_3
G : Type ?u.24414
E' : Type ?u.24417
F' : Type ?u.24420
G' : Type ?u.24423
E'' : Type ?u.24426
F'' : Type ?u.24429
G'' : Type ?u.24432
R : Type ?u.24435
R' : Type ?u.24438
𝕜 : Type ?u.24441
𝕜' : Type ?u.24444
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 : ℝ⦄, 0 < c → IsBigOWith c l f g
Theorem: Finite.card_le_of_surjective
File: Mathlib/Data/Finite/Card.lean

tactic: haveI := Fintype.ofFinite α
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.2785
inst✝ : Finite α
f : α → β
hf : Function.Surjective f
⊢ Nat.card β ≤ Nat.card α

tactic: haveI := Fintype.ofSurjective f hf
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.2785
inst✝ : Finite α
f : α → β
hf : Function.Surjective f
this : Fintype α
⊢ Nat.card β ≤ Nat.card α

tactic: simpa only [Nat.card_eq_fintype_card, ge_iff_le] using Fintype.card_le_of_surjective f hf
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.2785
inst✝ : Finite α
f : α → β
hf : Function.Surjective f
this✝ : Fintype α
this : Fintype β
⊢ Nat.card β ≤ Nat.card α
Theorem: IsAntichain.minimals_upperClosure
File: Mathlib/Order/Minimal.lean

tactic: rwa [eq_of_mem_minimals ‹a ∈ _› (subset_upperClosure hb) hba]
state_before: α : Type u_1
r r₁ r₂ : α → α → Prop
s t : Set α
a✝ b✝ : α
inst✝ : PartialOrder α
hs : IsAntichain (fun x x_1 => x ≤ x_1) s
a : α
x✝ : a ∈ minimals (fun x x_1 => x ≤ x_1) ↑(upperClosure s)
b : α
hb : b ∈ s
hba : b ≤ a
right✝ : ∀ ⦃b : α⦄, b ∈ ↑(upperClosure s) → (fun x x_1 => x ≤ x_1) b a → (fun x x_1 => x ≤ x_1) a b
⊢ a ∈ s

tactic: rwa [hs.eq' ha hc (hcb.trans hba)]
state_before: α : Type u_1
r r₁ r₂ : α → α → Prop
s t : Set α
a✝ b✝ : α
inst✝ : PartialOrder α
hs : IsAntichain (fun x x_1 => x ≤ x_1) s
a : α
ha : a ∈ s
b : α
x✝ : b ∈ ↑(upperClosure s)
hba : (fun x x_1 => x ≤ x_1) b a
c : α
hc : c ∈ s
hcb : c ≤ b
⊢ (fun x x_1 => x ≤ x_1) a b
Theorem: FiniteDimensional.lt_aleph0_of_linearIndependent
File: Mathlib/LinearAlgebra/FiniteDimensional.lean

tactic: apply Cardinal.lift_lt.1
state_before: K : Type u
V : Type v
inst✝⁵ : DivisionRing K
inst✝⁴ : AddCommGroup V
inst✝³ : Module K V
V₂ : Type v'
inst✝² : AddCommGroup V₂
inst✝¹ : Module K V₂
ι : Type w
inst✝ : FiniteDimensional K V
v : ι → V
h : LinearIndependent K v
⊢ (#ι) < ℵ₀

tactic: apply lt_of_le_of_lt
state_before: K : Type u
V : Type v
inst✝⁵ : DivisionRing K
inst✝⁴ : AddCommGroup V
inst✝³ : Module K V
V₂ : Type v'
inst✝² : AddCommGroup V₂
inst✝¹ : Module K V₂
ι : Type w
inst✝ : FiniteDimensional K V
v : ι → V
h : LinearIndependent K v
⊢ lift (#ι) < lift ℵ₀

tactic: apply cardinal_lift_le_rank_of_linearIndependent h
state_before: case a
K : Type u
V : Type v
inst✝⁵ : DivisionRing K
inst✝⁴ : AddCommGroup V
inst✝³ : Module K V
V₂ : Type v'
inst✝² : AddCommGroup V₂
inst✝¹ : Module K V₂
ι : Type w
inst✝ : FiniteDimensional K V
v : ι → V
h : LinearIndependent K v
⊢ lift (#ι) ≤ ?b

case a
K : Type u
V : Type v
inst✝⁵ : DivisionRing K
inst✝⁴ : AddCommGroup V
inst✝³ : Module K V
V₂ : Type v'
inst✝² : AddCommGroup V₂
inst✝¹ : Module K V₂
ι : Type w
inst✝ : FiniteDimensional K V
v : ι → V
h : LinearIndependent K v
⊢ ?b < lift ℵ₀

case b
K : Type u
V : Type v
inst✝⁵ : DivisionRing K
inst✝⁴ : AddCommGroup V
inst✝³ : Module K V
V₂ : Type v'
inst✝² : AddCommGroup V₂
inst✝¹ : Module K V₂
ι : Type w
inst✝ : FiniteDimensional K V
v : ι → V
h : LinearIndependent K v
⊢ Cardinal

tactic: rw [← finrank_eq_rank, Cardinal.lift_aleph0, Cardinal.lift_natCast]
state_before: case a
K : Type u
V : Type v
inst✝⁵ : DivisionRing K
inst✝⁴ : AddCommGroup V
inst✝³ : Module K V
V₂ : Type v'
inst✝² : AddCommGroup V₂
inst✝¹ : Module K V₂
ι : Type w
inst✝ : FiniteDimensional K V
v : ι → V
h : LinearIndependent K v
⊢ lift (Module.rank K V) < lift ℵ₀

tactic: apply Cardinal.nat_lt_aleph0
state_before: case a
K : Type u
V : Type v
inst✝⁵ : DivisionRing K
inst✝⁴ : AddCommGroup V
inst✝³ : Module K V
V₂ : Type v'
inst✝² : AddCommGroup V₂
inst✝¹ : Module K V₂
ι : Type w
inst✝ : FiniteDimensional K V
v : ι → V
h : LinearIndependent K v
⊢ ↑(finrank K V) < ℵ₀
Theorem: ENNReal.mul_iSup
File: Mathlib/Topology/Instances/ENNReal.lean

tactic: by_cases hf : ∀ i, f i = 0
state_before: α : Type ?u.153814
β : Type ?u.153817
γ : Type ?u.153820
a✝ b c d : ℝ≥0∞
r p q : ℝ≥0
x y z ε ε₁ ε₂ : ℝ≥0∞
s : Set ℝ≥0∞
ι : Sort u_1
f : ι → ℝ≥0∞
a : ℝ≥0∞
⊢ a * iSup f = ⨆ (i : ι), a * f i

tactic: obtain rfl : f = fun _ => 0
state_before: case pos
α : Type ?u.153814
β : Type ?u.153817
γ : Type ?u.153820
a✝ b c d : ℝ≥0∞
r p q : ℝ≥0
x y z ε ε₁ ε₂ : ℝ≥0∞
s : Set ℝ≥0∞
ι : Sort u_1
f : ι → ℝ≥0∞
a : ℝ≥0∞
hf : ∀ (i : ι), f i = 0
⊢ a * iSup f = ⨆ (i : ι), a * f i

tactic: exact funext hf
state_before: α : Type ?u.153814
β : Type ?u.153817
γ : Type ?u.153820
a✝ b c d : ℝ≥0∞
r p q : ℝ≥0
x y z ε ε₁ ε₂ : ℝ≥0∞
s : Set ℝ≥0∞
ι : Sort u_1
f : ι → ℝ≥0∞
a : ℝ≥0∞
hf : ∀ (i : ι), f i = 0
⊢ f = fun x => 0

case pos
α : Type ?u.153814
β : Type ?u.153817
γ : Type ?u.153820
a✝ b c d : ℝ≥0∞
r p q : ℝ≥0
x y z ε ε₁ ε₂ : ℝ≥0∞
s : Set ℝ≥0∞
ι : Sort u_1
a : ℝ≥0∞
hf : ∀ (i : ι), (fun x => 0) i = 0
⊢ (a * ⨆ (x : ι), 0) = ⨆ (i : ι), a * (fun x => 0) i

tactic: simp only [iSup_zero_eq_zero, mul_zero]
state_before: case pos
α : Type ?u.153814
β : Type ?u.153817
γ : Type ?u.153820
a✝ b c d : ℝ≥0∞
r p q : ℝ≥0
x y z ε ε₁ ε₂ : ℝ≥0∞
s : Set ℝ≥0∞
ι : Sort u_1
a : ℝ≥0∞
hf : ∀ (i : ι), (fun x => 0) i = 0
⊢ (a * ⨆ (x : ι), 0) = ⨆ (i : ι), a * (fun x => 0) i

tactic: refine' (monotone_id.const_mul' _).map_iSup_of_continuousAt _ (mul_zero a)
state_before: case neg
α : Type ?u.153814
β : Type ?u.153817
γ : Type ?u.153820
a✝ b c d : ℝ≥0∞
r p q : ℝ≥0
x y z ε ε₁ ε₂ : ℝ≥0∞
s : Set ℝ≥0∞
ι : Sort u_1
f : ι → ℝ≥0∞
a : ℝ≥0∞
hf : ¬∀ (i : ι), f i = 0
⊢ a * iSup f = ⨆ (i : ι), a * f i

tactic: refine' ENNReal.Tendsto.const_mul tendsto_id (Or.inl _)
state_before: case neg
α : Type ?u.153814
β : Type ?u.153817
γ : Type ?u.153820
a✝ b c d : ℝ≥0∞
r p q : ℝ≥0
x y z ε ε₁ ε₂ : ℝ≥0∞
s : Set ℝ≥0∞
ι : Sort u_1
f : ι → ℝ≥0∞
a : ℝ≥0∞
hf : ¬∀ (i : ι), f i = 0
⊢ ContinuousAt (fun x => a * id x) (⨆ (i : ι), f i)

tactic: exact mt iSup_eq_zero.1 hf
state_before: case neg
α : Type ?u.153814
β : Type ?u.153817
γ : Type ?u.153820
a✝ b c d : ℝ≥0∞
r p q : ℝ≥0
x y z ε ε₁ ε₂ : ℝ≥0∞
s : Set ℝ≥0∞
ι : Sort u_1
f : ι → ℝ≥0∞
a : ℝ≥0∞
hf : ¬∀ (i : ι), f i = 0
⊢ id (⨆ (i : ι), f i) ≠ 0
Theorem: Finset.compl_insert
File: Mathlib/Data/Fintype/Basic.lean

tactic: ext
state_before: α : Type u_1
β : Type ?u.12293
γ : Type ?u.12296
inst✝¹ : Fintype α
s t : Finset α
inst✝ : DecidableEq α
a : α
⊢ insert a sᶜ = erase (sᶜ) a

tactic: simp only [not_or, mem_insert, iff_self_iff, mem_compl, mem_erase]
state_before: case a
α : Type u_1
β : Type ?u.12293
γ : Type ?u.12296
inst✝¹ : Fintype α
s t : Finset α
inst✝ : DecidableEq α
a a✝ : α
⊢ a✝ ∈ insert a sᶜ ↔ a✝ ∈ erase (sᶜ) a
Theorem: MeasureTheory.Integrable.add'
File: Mathlib/MeasureTheory/Function/L1Space.lean

tactic: exact_mod_cast nnnorm_add_le _ _
state_before: α : Type u_2
β : Type u_1
γ : Type ?u.940671
δ : Type ?u.940674
m : MeasurableSpace α
μ ν : Measure α
inst✝² : MeasurableSpace δ
inst✝¹ : NormedAddCommGroup β
inst✝ : NormedAddCommGroup γ
f g : α → β
hf : Integrable f
hg : Integrable g
a : α
⊢ ↑‖f a + g a‖₊ ≤ ↑‖f a‖₊ + ↑‖g a‖₊
Theorem: GradedRing.proj_recompose
File: Mathlib/RingTheory/GradedAlgebra/Basic.lean

tactic: rw [GradedRing.proj_apply, decompose_symm_of, Equiv.apply_symm_apply]
state_before: ι : Type u_1
R : Type ?u.79391
A : Type u_2
σ : Type u_3
inst✝⁷ : DecidableEq ι
inst✝⁶ : AddMonoid ι
inst✝⁵ : CommSemiring R
inst✝⁴ : Semiring A
inst✝³ : Algebra R A
inst✝² : SetLike σ A
inst✝¹ : AddSubmonoidClass σ A
𝒜 : ι → σ
inst✝ : GradedRing 𝒜
a : ⨁ (i : ι), { x // x ∈ 𝒜 i }
i : ι
⊢ ↑(proj 𝒜 i) (↑(decompose 𝒜).symm a) = ↑(decompose 𝒜).symm (↑(of (fun i => (fun i => { x // x ∈ 𝒜 i }) i) i) (↑a i))
Theorem: Real.toNNReal_mul_nnnorm
File: Mathlib/Analysis/Normed/Field/Basic.lean

tactic: ext
state_before: α : Type ?u.381131
β : Type ?u.381134
γ : Type ?u.381137
ι : Type ?u.381140
x y : ℝ
hx : 0 ≤ x
⊢ toNNReal x * ‖y‖₊ = ‖x * y‖₊

tactic: simp only [NNReal.coe_mul, nnnorm_mul, coe_nnnorm, Real.toNNReal_of_nonneg, norm_of_nonneg, hx,
  coe_mk]
state_before: case a
α : Type ?u.381131
β : Type ?u.381134
γ : Type ?u.381137
ι : Type ?u.381140
x y : ℝ
hx : 0 ≤ x
⊢ ↑(toNNReal x * ‖y‖₊) = ↑‖x * y‖₊
Theorem: Action.functorCategoryMonoidalEquivalence.μIso_inv_app
File: Mathlib/RepresentationTheory/Action.lean

tactic: rw [← NatIso.app_inv, ← IsIso.Iso.inv_hom]
state_before: V : Type (u + 1)
inst✝¹ : LargeCategory V
G : MonCat
inst✝ : MonoidalCategory V
A B : Action V G
⊢ (MonoidalFunctor.μIso (functorCategoryMonoidalEquivalence V G) A B).inv.app PUnit.unit =
    𝟙 (((functorCategoryMonoidalEquivalence V G).toLaxMonoidalFunctor.toFunctor.obj (A ⊗ B)).obj PUnit.unit)

tactic: refine' IsIso.inv_eq_of_hom_inv_id _
state_before: V : Type (u + 1)
inst✝¹ : LargeCategory V
G : MonCat
inst✝ : MonoidalCategory V
A B : Action V G
⊢ inv ((MonoidalFunctor.μIso (functorCategoryMonoidalEquivalence V G) A B).app PUnit.unit).hom =
    𝟙 (((functorCategoryMonoidalEquivalence V G).toLaxMonoidalFunctor.toFunctor.obj (A ⊗ B)).obj PUnit.unit)

tactic: rw [Category.comp_id, NatIso.app_hom, MonoidalFunctor.μIso_hom,
  functorCategoryMonoidalEquivalence.μ_app]
state_before: V : Type (u + 1)
inst✝¹ : LargeCategory V
G : MonCat
inst✝ : MonoidalCategory V
A B : Action V G
⊢ ((MonoidalFunctor.μIso (functorCategoryMonoidalEquivalence V G) A B).app PUnit.unit).hom ≫
      𝟙 (((functorCategoryMonoidalEquivalence V G).toLaxMonoidalFunctor.toFunctor.obj (A ⊗ B)).obj PUnit.unit) =
    𝟙
      (((functorCategoryMonoidalEquivalence V G).toLaxMonoidalFunctor.toFunctor.obj A ⊗
            (functorCategoryMonoidalEquivalence V G).toLaxMonoidalFunctor.toFunctor.obj B).obj
        PUnit.unit)
Theorem: affineIndependent_of_ne_of_mem_of_not_mem_of_mem
File: Mathlib/LinearAlgebra/AffineSpace/Independent.lean

tactic: rw [← affineIndependent_equiv (Equiv.swap (1 : Fin 3) 2)]
state_before: k : Type u_1
V : Type u_2
P : Type u_3
inst✝³ : DivisionRing k
inst✝² : AddCommGroup V
inst✝¹ : Module k V
inst✝ : AffineSpace V P
ι : Type ?u.460888
s : AffineSubspace k P
p₁ p₂ p₃ : P
hp₁p₃ : p₁ ≠ p₃
hp₁ : p₁ ∈ s
hp₂ : ¬p₂ ∈ s
hp₃ : p₃ ∈ s
⊢ AffineIndependent k ![p₁, p₂, p₃]

tactic: convert affineIndependent_of_ne_of_mem_of_mem_of_not_mem hp₁p₃ hp₁ hp₃ hp₂ using 1
state_before: k : Type u_1
V : Type u_2
P : Type u_3
inst✝³ : DivisionRing k
inst✝² : AddCommGroup V
inst✝¹ : Module k V
inst✝ : AffineSpace V P
ι : Type ?u.460888
s : AffineSubspace k P
p₁ p₂ p₃ : P
hp₁p₃ : p₁ ≠ p₃
hp₁ : p₁ ∈ s
hp₂ : ¬p₂ ∈ s
hp₃ : p₃ ∈ s
⊢ AffineIndependent k (![p₁, p₂, p₃] ∘ ↑(Equiv.swap 1 2))

tactic: ext x
state_before: case h.e'_9
k : Type u_1
V : Type u_2
P : Type u_3
inst✝³ : DivisionRing k
inst✝² : AddCommGroup V
inst✝¹ : Module k V
inst✝ : AffineSpace V P
ι : Type ?u.460888
s : AffineSubspace k P
p₁ p₂ p₃ : P
hp₁p₃ : p₁ ≠ p₃
hp₁ : p₁ ∈ s
hp₂ : ¬p₂ ∈ s
hp₃ : p₃ ∈ s
⊢ ![p₁, p₂, p₃] ∘ ↑(Equiv.swap 1 2) = ![p₁, p₃, p₂]

tactic: fin_cases x <;> rfl
state_before: case h.e'_9.h
k : Type u_1
V : Type u_2
P : Type u_3
inst✝³ : DivisionRing k
inst✝² : AddCommGroup V
inst✝¹ : Module k V
inst✝ : AffineSpace V P
ι : Type ?u.460888
s : AffineSubspace k P
p₁ p₂ p₃ : P
hp₁p₃ : p₁ ≠ p₃
hp₁ : p₁ ∈ s
hp₂ : ¬p₂ ∈ s
hp₃ : p₃ ∈ s
x : Fin 3
⊢ (![p₁, p₂, p₃] ∘ ↑(Equiv.swap 1 2)) x = Matrix.vecCons p₁ ![p₃, p₂] x
Theorem: Finset.exists_card_fiber_lt_of_card_lt_nsmul
File: Mathlib/Combinatorics/Pigeonhole.lean

tactic: simp_rw [cast_card] at ht⊢
state_before: α : Type u
β : Type v
M : Type w
inst✝¹ : DecidableEq β
s : Finset α
t : Finset β
f : α → β
w : α → M
b : M
n : ℕ
inst✝ : LinearOrderedCommSemiring M
ht : ↑(card s) < card t • b
⊢ ∃ y, y ∈ t ∧ ↑(card (filter (fun x => f x = y) s)) < b

tactic: exact
  exists_sum_fiber_lt_of_sum_fiber_nonneg_of_sum_lt_nsmul
    (fun _ _ => sum_nonneg fun _ _ => zero_le_one) ht
state_before: α : Type u
β : Type v
M : Type w
inst✝¹ : DecidableEq β
s : Finset α
t : Finset β
f : α → β
w : α → M
b : M
n : ℕ
inst✝ : LinearOrderedCommSemiring M
ht : ∑ a in s, 1 < card t • b
⊢ ∃ y, y ∈ t ∧ ∑ a in filter (fun x => f x = y) s, 1 < b
Theorem: Matrix.blockDiagonal_one
File: Mathlib/Data/Matrix/Block.lean

tactic: rw [blockDiagonal_diagonal]
state_before: l : Type ?u.138725
m : Type u_1
n : Type ?u.138731
o : Type u_3
p : Type ?u.138737
q : Type ?u.138740
m' : o → Type ?u.138745
n' : o → Type ?u.138750
p' : o → Type ?u.138755
R : Type ?u.138758
S : Type ?u.138761
α : Type u_2
β : Type ?u.138767
inst✝⁴ : DecidableEq o
inst✝³ : Zero α
inst✝² : Zero β
inst✝¹ : DecidableEq m
inst✝ : One α
⊢ (blockDiagonal fun x => diagonal fun x => 1) = diagonal fun x => 1
Theorem: List.drop_nil
File: src/lean/Init/Data/List/Basic.lean

tactic: cases i <;> rfl
state_before: α : Type u
β : Type v
γ : Type w
i : Nat
⊢ drop i nil = nil
Theorem: Set.infinite_of_not_bddBelow
File: Mathlib/Data/Set/Finite.lean

tactic: contrapose!
state_before: α : Type u
β : Type v
ι : Sort w
γ : Type x
inst✝¹ : SemilatticeInf α
inst✝ : Nonempty α
s : Set α
⊢ ¬BddBelow s → Set.Infinite s

tactic: rw [not_infinite]
state_before: α : Type u
β : Type v
ι : Sort w
γ : Type x
inst✝¹ : SemilatticeInf α
inst✝ : Nonempty α
s : Set α
⊢ ¬Set.Infinite s → BddBelow s

tactic: exact Finite.bddBelow
state_before: α : Type u
β : Type v
ι : Sort w
γ : Type x
inst✝¹ : SemilatticeInf α
inst✝ : Nonempty α
s : Set α
⊢ Set.Finite s → BddBelow s
Theorem: IsRightRegular.pow_iff
File: Mathlib/Algebra/Regular/Pow.lean

tactic: refine' ⟨_, IsRightRegular.pow n⟩
state_before: R : Type u_1
a b : R
inst✝ : Monoid R
n : ℕ
n0 : 0 < n
⊢ IsRightRegular (a ^ n) ↔ IsRightRegular a

tactic: rw [← Nat.succ_pred_eq_of_pos n0, pow_succ]
state_before: R : Type u_1
a b : R
inst✝ : Monoid R
n : ℕ
n0 : 0 < n
⊢ IsRightRegular (a ^ n) → IsRightRegular a

tactic: exact IsRightRegular.of_mul
state_before: R : Type u_1
a b : R
inst✝ : Monoid R
n : ℕ
n0 : 0 < n
⊢ IsRightRegular (a * a ^ Nat.pred n) → IsRightRegular a