tasksource/leandojo huggingface dataset:
Theorem: Multiset.count_sub
File: Mathlib/Data/Multiset/Basic.lean

tactic: revert s
state_before: α : Type u_1
β : Type ?u.387659
γ : Type ?u.387662
inst✝ : DecidableEq α
a : α
s t : Multiset α
⊢ count a (s - t) = count a s - count a t

tactic: refine' Multiset.induction_on t (by simp) fun b t IH s => _
state_before: α : Type u_1
β : Type ?u.387659
γ : Type ?u.387662
inst✝ : DecidableEq α
a : α
t : Multiset α
⊢ ∀ (s : Multiset α), count a (s - t) = count a s - count a t

tactic: rw [sub_cons, IH]
state_before: α : Type u_1
β : Type ?u.387659
γ : Type ?u.387662
inst✝ : DecidableEq α
a : α
t✝ : Multiset α
b : α
t : Multiset α
IH : ∀ (s : Multiset α), count a (s - t) = count a s - count a t
s : Multiset α
⊢ count a (s - b ::ₘ t) = count a s - count a (b ::ₘ t)

tactic: rcases Decidable.eq_or_ne a b with rfl | ab
state_before: α : Type u_1
β : Type ?u.387659
γ : Type ?u.387662
inst✝ : DecidableEq α
a : α
t✝ : Multiset α
b : α
t : Multiset α
IH : ∀ (s : Multiset α), count a (s - t) = count a s - count a t
s : Multiset α
⊢ count a (erase s b) - count a t = count a s - count a (b ::ₘ t)

tactic: simp
state_before: α : Type u_1
β : Type ?u.387659
γ : Type ?u.387662
inst✝ : DecidableEq α
a : α
t : Multiset α
⊢ ∀ (s : Multiset α), count a (s - 0) = count a s - count a 0

tactic: rw [count_erase_self, count_cons_self, Nat.sub_sub, add_comm]
state_before: case inl
α : Type u_1
β : Type ?u.387659
γ : Type ?u.387662
inst✝ : DecidableEq α
a : α
t✝ t : Multiset α
IH : ∀ (s : Multiset α), count a (s - t) = count a s - count a t
s : Multiset α
⊢ count a (erase s a) - count a t = count a s - count a (a ::ₘ t)

tactic: rw [count_erase_of_ne ab, count_cons_of_ne ab]
state_before: case inr
α : Type u_1
β : Type ?u.387659
γ : Type ?u.387662
inst✝ : DecidableEq α
a : α
t✝ : Multiset α
b : α
t : Multiset α
IH : ∀ (s : Multiset α), count a (s - t) = count a s - count a t
s : Multiset α
ab : a ≠ b
⊢ count a (erase s b) - count a t = count a s - count a (b ::ₘ t)
Theorem: MeasureTheory.Measure.haar.index_empty
File: Mathlib/MeasureTheory/Measure/Haar/Basic.lean

tactic: simp only [index, Nat.sInf_eq_zero]
state_before: G : Type u_1
inst✝ : Group G
V : Set G
⊢ index ∅ V = 0

tactic: left
state_before: G : Type u_1
inst✝ : Group G
V : Set G
⊢ 0 ∈ Finset.card '' {t | ∅ ⊆ ⋃ (g : G) (_ : g ∈ t), (fun h => g * h) ⁻¹' V} ∨
    Finset.card '' {t | ∅ ⊆ ⋃ (g : G) (_ : g ∈ t), (fun h => g * h) ⁻¹' V} = ∅

tactic: use ∅
state_before: case h
G : Type u_1
inst✝ : Group G
V : Set G
⊢ 0 ∈ Finset.card '' {t | ∅ ⊆ ⋃ (g : G) (_ : g ∈ t), (fun h => g * h) ⁻¹' V}

tactic: simp only [Finset.card_empty, empty_subset, mem_setOf_eq, eq_self_iff_true, and_self_iff]
state_before: case h
G : Type u_1
inst✝ : Group G
V : Set G
⊢ ∅ ∈ {t | ∅ ⊆ ⋃ (g : G) (_ : g ∈ t), (fun h => g * h) ⁻¹' V} ∧ Finset.card ∅ = 0
Theorem: Subgroup.closure_induction'
File: Mathlib/GroupTheory/Subgroup/Basic.lean

tactic: refine' Exists.elim _ fun (hx : x ∈ closure k) (hc : p x hx) => hc
state_before: G : Type u_1
G' : Type ?u.201068
inst✝² : Group G
inst✝¹ : Group G'
A : Type ?u.201077
inst✝ : AddGroup A
H K : Subgroup G
k : Set G
p : (x : G) → x ∈ closure k → Prop
Hs : ∀ (x : G) (h : x ∈ k), p x (_ : x ∈ ↑(closure k))
H1 : p 1 (_ : 1 ∈ closure k)
Hmul : ∀ (x : G) (hx : x ∈ closure k) (y : G) (hy : y ∈ closure k), p x hx → p y hy → p (x * y) (_ : x * y ∈ closure k)
Hinv : ∀ (x : G) (hx : x ∈ closure k), p x hx → p x⁻¹ (_ : x⁻¹ ∈ closure k)
x : G
hx : x ∈ closure k
⊢ p x hx

tactic: exact
  closure_induction hx (fun x hx => ⟨_, Hs x hx⟩) ⟨_, H1⟩
    (fun x y ⟨hx', hx⟩ ⟨hy', hy⟩ => ⟨_, Hmul _ _ _ _ hx hy⟩) fun x ⟨hx', hx⟩ => ⟨_, Hinv _ _ hx⟩
state_before: G : Type u_1
G' : Type ?u.201068
inst✝² : Group G
inst✝¹ : Group G'
A : Type ?u.201077
inst✝ : AddGroup A
H K : Subgroup G
k : Set G
p : (x : G) → x ∈ closure k → Prop
Hs : ∀ (x : G) (h : x ∈ k), p x (_ : x ∈ ↑(closure k))
H1 : p 1 (_ : 1 ∈ closure k)
Hmul : ∀ (x : G) (hx : x ∈ closure k) (y : G) (hy : y ∈ closure k), p x hx → p y hy → p (x * y) (_ : x * y ∈ closure k)
Hinv : ∀ (x : G) (hx : x ∈ closure k), p x hx → p x⁻¹ (_ : x⁻¹ ∈ closure k)
x : G
hx : x ∈ closure k
⊢ ∃ x_1, p x x_1
Theorem: FractionalIdeal.map_inv
File: Mathlib/RingTheory/DedekindDomain/Ideal.lean

tactic: rw [inv_eq, map_div, map_one, inv_eq]
state_before: R : Type ?u.33955
A : Type ?u.33958
K : Type u_2
inst✝¹⁰ : CommRing R
inst✝⁹ : CommRing A
inst✝⁸ : Field K
inst✝⁷ : IsDomain A
R₁ : Type u_1
inst✝⁶ : CommRing R₁
inst✝⁵ : IsDomain R₁
inst✝⁴ : Algebra R₁ K
inst✝³ : IsFractionRing R₁ K
I✝ J : FractionalIdeal R₁⁰ K
K' : Type u_3
inst✝² : Field K'
inst✝¹ : Algebra R₁ K'
inst✝ : IsFractionRing R₁ K'
I : FractionalIdeal R₁⁰ K
h : K ≃ₐ[R₁] K'
⊢ map (↑h) I⁻¹ = (map (↑h) I)⁻¹
Theorem: Basis.repr_injective
File: Mathlib/LinearAlgebra/Basis.lean

tactic: cases f
state_before: ι : Type u_1
ι' : Type ?u.4334
R : Type u_2
R₂ : Type ?u.4340
K : Type ?u.4343
M : Type u_3
M' : Type ?u.4349
M'' : Type ?u.4352
V : Type u
V' : Type ?u.4357
inst✝⁴ : Semiring R
inst✝³ : AddCommMonoid M
inst✝² : Module R M
inst✝¹ : AddCommMonoid M'
inst✝ : Module R M'
b b₁ : Basis ι R M
i : ι
c : R
x : M
f g : Basis ι R M
h : f.repr = g.repr
⊢ f = g

tactic: cases g
state_before: case ofRepr
ι : Type u_1
ι' : Type ?u.4334
R : Type u_2
R₂ : Type ?u.4340
K : Type ?u.4343
M : Type u_3
M' : Type ?u.4349
M'' : Type ?u.4352
V : Type u
V' : Type ?u.4357
inst✝⁴ : Semiring R
inst✝³ : AddCommMonoid M
inst✝² : Module R M
inst✝¹ : AddCommMonoid M'
inst✝ : Module R M'
b b₁ : Basis ι R M
i : ι
c : R
x : M
g : Basis ι R M
repr✝ : M ≃ₗ[R] ι →₀ R
h : { repr := repr✝ }.repr = g.repr
⊢ { repr := repr✝ } = g

tactic: congr
state_before: case ofRepr.ofRepr
ι : Type u_1
ι' : Type ?u.4334
R : Type u_2
R₂ : Type ?u.4340
K : Type ?u.4343
M : Type u_3
M' : Type ?u.4349
M'' : Type ?u.4352
V : Type u
V' : Type ?u.4357
inst✝⁴ : Semiring R
inst✝³ : AddCommMonoid M
inst✝² : Module R M
inst✝¹ : AddCommMonoid M'
inst✝ : Module R M'
b b₁ : Basis ι R M
i : ι
c : R
x : M
repr✝¹ repr✝ : M ≃ₗ[R] ι →₀ R
h : { repr := repr✝¹ }.repr = { repr := repr✝ }.repr
⊢ { repr := repr✝¹ } = { repr := repr✝ }
Theorem: HomogeneousIdeal.toIdeal_iInf
File: Mathlib/RingTheory/GradedAlgebra/HomogeneousIdeal.lean

tactic: rw [iInf, toIdeal_sInf, iInf_range]
state_before: ι : Type u_2
σ : Type u_3
R : Type ?u.161617
A : Type u_4
inst✝⁵ : Semiring A
inst✝⁴ : DecidableEq ι
inst✝³ : AddMonoid ι
inst✝² : SetLike σ A
inst✝¹ : AddSubmonoidClass σ A
𝒜 : ι → σ
inst✝ : GradedRing 𝒜
κ : Sort u_1
s : κ → HomogeneousIdeal 𝒜
⊢ toIdeal (⨅ (i : κ), s i) = ⨅ (i : κ), toIdeal (s i)
Theorem: frequently_frequently_nhds
File: Mathlib/Topology/Basic.lean

tactic: rw [← not_iff_not]
state_before: α : Type u
β : Type v
ι : Sort w
a✝ : α
s s₁ s₂ t : Set α
p✝ p₁ p₂ : α → Prop
inst✝ : TopologicalSpace α
p : α → Prop
a : α
⊢ (∃ᶠ (y : α) in 𝓝 a, ∃ᶠ (x : α) in 𝓝 y, p x) ↔ ∃ᶠ (x : α) in 𝓝 a, p x

tactic: simp only [not_frequently, eventually_eventually_nhds]
state_before: α : Type u
β : Type v
ι : Sort w
a✝ : α
s s₁ s₂ t : Set α
p✝ p₁ p₂ : α → Prop
inst✝ : TopologicalSpace α
p : α → Prop
a : α
⊢ (¬∃ᶠ (y : α) in 𝓝 a, ∃ᶠ (x : α) in 𝓝 y, p x) ↔ ¬∃ᶠ (x : α) in 𝓝 a, p x
Theorem: Set.Ioo_union_Ioo
File: Mathlib/Data/Set/Intervals/Basic.lean

tactic: cases' le_total a b with hab hab <;> cases' le_total c d with hcd hcd <;>
  simp only [min_eq_left, min_eq_right, max_eq_left, max_eq_right, hab, hcd] at h₁ h₂
state_before: α : Type u_1
β : Type ?u.165798
inst✝ : LinearOrder α
a a₁ a₂ b b₁ b₂ c d : α
h₁ : min a b < max c d
h₂ : min c d < max a b
⊢ Ioo a b ∪ Ioo c d = Ioo (min a c) (max b d)

tactic: all_goals
  simp [*, min_eq_left_of_lt, min_eq_right_of_lt, max_eq_left_of_lt, max_eq_right_of_lt,
    le_of_lt h₂, le_of_lt h₁]
state_before: case inl.inr
α : Type u_1
β : Type ?u.165798
inst✝ : LinearOrder α
a a₁ a₂ b b₁ b₂ c d : α
hab : a ≤ b
hcd : d ≤ c
h₁ : a < c
h₂ : d < b
⊢ Ioo a b ∪ Ioo c d = Ioo (min a c) (max b d)

case inr.inl
α : Type u_1
β : Type ?u.165798
inst✝ : LinearOrder α
a a₁ a₂ b b₁ b₂ c d : α
hab : b ≤ a
hcd : c ≤ d
h₁ : b < d
h₂ : c < a
⊢ Ioo a b ∪ Ioo c d = Ioo (min a c) (max b d)

case inr.inr
α : Type u_1
β : Type ?u.165798
inst✝ : LinearOrder α
a a₁ a₂ b b₁ b₂ c d : α
hab : b ≤ a
hcd : d ≤ c
h₁ : b < c
h₂ : d < a
⊢ Ioo a b ∪ Ioo c d = Ioo (min a c) (max b d)

tactic: exact Ioo_union_Ioo' h₂ h₁
state_before: case inl.inl
α : Type u_1
β : Type ?u.165798
inst✝ : LinearOrder α
a a₁ a₂ b b₁ b₂ c d : α
hab : a ≤ b
hcd : c ≤ d
h₁ : a < d
h₂ : c < b
⊢ Ioo a b ∪ Ioo c d = Ioo (min a c) (max b d)

tactic: simp [*, min_eq_left_of_lt, min_eq_right_of_lt, max_eq_left_of_lt, max_eq_right_of_lt,
  le_of_lt h₂, le_of_lt h₁]
state_before: case inr.inr
α : Type u_1
β : Type ?u.165798
inst✝ : LinearOrder α
a a₁ a₂ b b₁ b₂ c d : α
hab : b ≤ a
hcd : d ≤ c
h₁ : b < c
h₂ : d < a
⊢ Ioo a b ∪ Ioo c d = Ioo (min a c) (max b d)
Theorem: PNat.Prime.not_dvd_one
File: Mathlib/Data/PNat/Prime.lean

tactic: rw [dvd_iff]
state_before: p : ℕ+
pp : Prime p
⊢ ¬p ∣ 1

tactic: apply Nat.Prime.not_dvd_one pp
state_before: p : ℕ+
pp : Prime p
⊢ ¬↑p ∣ ↑1
Theorem: Filter.tendsto_add_atTop_iff_nat
File: Mathlib/Order/Filter/AtTopBot.lean

tactic: rw [← tendsto_map'_iff, map_add_atTop_eq_nat]
state_before: ι : Type ?u.345463
ι' : Type ?u.345466
α : Type u_1
β : Type ?u.345472
γ : Type ?u.345475
f : ℕ → α
l : Filter α
k : ℕ
⊢ Tendsto (f ∘ fun n => n + k) atTop l ↔ Tendsto f atTop l
Theorem: zero_lt_mul_right
File: Mathlib/Algebra/Order/Ring/Lemmas.lean

tactic: rw [←zero_mul c, mul_lt_mul_right h]
state_before: α : Type u_1
a b c d : α
inst✝³ : MulZeroClass α
inst✝² : Preorder α
inst✝¹ : MulPosStrictMono α
inst✝ : MulPosReflectLT α
h : 0 < c
⊢ 0 < b * c ↔ 0 < b

tactic: simp
state_before: α : Type u_1
a b c d : α
inst✝³ : MulZeroClass α
inst✝² : Preorder α
inst✝¹ : MulPosStrictMono α
inst✝ : MulPosReflectLT α
h : 0 < c
⊢ 0 < b ↔ 0 * c < b
Theorem: Ordinal.bmex_lt_ord_succ_card
File: Mathlib/SetTheory/Ordinal/Arithmetic.lean

tactic: rw [← mk_ordinal_out]
state_before: α : Type ?u.388950
β : Type ?u.388953
γ : Type ?u.388956
r : α → α → Prop
s : β → β → Prop
t : γ → γ → Prop
o : Ordinal
f : (a : Ordinal) → a < o → Ordinal
⊢ bmex o f < ord (succ (card o))

tactic: exact mex_lt_ord_succ_mk (familyOfBFamily o f)
state_before: α : Type ?u.388950
β : Type ?u.388953
γ : Type ?u.388956
r : α → α → Prop
s : β → β → Prop
t : γ → γ → Prop
o : Ordinal
f : (a : Ordinal) → a < o → Ordinal
⊢ bmex o f < ord (succ (#(Quotient.out o).α))
Theorem: Multiset.sup_union
File: Mathlib/Data/Multiset/Lattice.lean

tactic: rw [← sup_dedup, dedup_ext.2, sup_dedup, sup_add]
state_before: α : Type u_1
inst✝² : SemilatticeSup α
inst✝¹ : OrderBot α
inst✝ : DecidableEq α
s₁ s₂ : Multiset α
⊢ sup (s₁ ∪ s₂) = sup s₁ ⊔ sup s₂

tactic: simp
state_before: α : Type u_1
inst✝² : SemilatticeSup α
inst✝¹ : OrderBot α
inst✝ : DecidableEq α
s₁ s₂ : Multiset α
⊢ ∀ (a : α), a ∈ s₁ ∪ s₂ ↔ a ∈ s₁ + s₂
Theorem: min_def_lt
File: Mathlib/Order/Basic.lean

tactic: rw [min_comm, min_def, ← ite_not]
state_before: ι : Type ?u.76194
α : Type u
β : Type v
γ : Type w
π : ι → Type ?u.76205
r : α → α → Prop
inst✝ : LinearOrder α
p : α → Prop
x✝ y✝ x y : α
⊢ min x y = if x < y then x else y

tactic: simp only [not_le]
state_before: ι : Type ?u.76194
α : Type u
β : Type v
γ : Type w
π : ι → Type ?u.76205
r : α → α → Prop
inst✝ : LinearOrder α
p : α → Prop
x✝ y✝ x y : α
⊢ (if ¬y ≤ x then x else y) = if x < y then x else y
Theorem: MeasurableSet.biUnion
File: Mathlib/MeasureTheory/MeasurableSpaceDef.lean

tactic: rw [biUnion_eq_iUnion]
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.4604
δ : Type ?u.4607
δ' : Type ?u.4610
ι : Sort ?u.4613
s✝ t u : Set α
m : MeasurableSpace α
f : β → Set α
s : Set β
hs : Set.Countable s
h : ∀ (b : β), b ∈ s → MeasurableSet (f b)
⊢ MeasurableSet (⋃ (b : β) (_ : b ∈ s), f b)

tactic: have := hs.to_subtype
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.4604
δ : Type ?u.4607
δ' : Type ?u.4610
ι : Sort ?u.4613
s✝ t u : Set α
m : MeasurableSpace α
f : β → Set α
s : Set β
hs : Set.Countable s
h : ∀ (b : β), b ∈ s → MeasurableSet (f b)
⊢ MeasurableSet (⋃ (x : ↑s), f ↑x)

tactic: exact MeasurableSet.iUnion (by simpa using h)
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.4604
δ : Type ?u.4607
δ' : Type ?u.4610
ι : Sort ?u.4613
s✝ t u : Set α
m : MeasurableSpace α
f : β → Set α
s : Set β
hs : Set.Countable s
h : ∀ (b : β), b ∈ s → MeasurableSet (f b)
this : Countable ↑s
⊢ MeasurableSet (⋃ (x : ↑s), f ↑x)

tactic: simpa using h
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.4604
δ : Type ?u.4607
δ' : Type ?u.4610
ι : Sort ?u.4613
s✝ t u : Set α
m : MeasurableSpace α
f : β → Set α
s : Set β
hs : Set.Countable s
h : ∀ (b : β), b ∈ s → MeasurableSet (f b)
this : Countable ↑s
⊢ ∀ (b : ↑s), MeasurableSet (f ↑b)
Theorem: ENNReal.rpow_eq_top_iff_of_pos
File: Mathlib/Analysis/SpecialFunctions/Pow/NNReal.lean

tactic: simp [rpow_eq_top_iff, hy, asymm hy]
state_before: x : ℝ≥0∞
y : ℝ
hy : 0 < y
⊢ x ^ y = ⊤ ↔ x = ⊤
Theorem: TopologicalSpace.IsTopologicalBasis.diff_empty
File: Mathlib/Topology/Bases.lean

tactic: refine' ⟨_, by rw [sUnion_diff_singleton_empty, h.sUnion_eq], _⟩
state_before: α : Type u
t : TopologicalSpace α
s : Set (Set α)
h : IsTopologicalBasis s
⊢ IsTopologicalBasis (s \ {∅})

tactic: rw [sUnion_diff_singleton_empty, h.sUnion_eq]
state_before: α : Type u
t : TopologicalSpace α
s : Set (Set α)
h : IsTopologicalBasis s
⊢ ⋃₀ (s \ {∅}) = univ

tactic: rintro t₁ ⟨h₁, -⟩ t₂ ⟨h₂, -⟩ x hx
state_before: case refine'_1
α : Type u
t : TopologicalSpace α
s : Set (Set α)
h : IsTopologicalBasis s
⊢ ∀ (t₁ : Set α),
    t₁ ∈ s \ {∅} → ∀ (t₂ : Set α), t₂ ∈ s \ {∅} → ∀ (x : α), x ∈ t₁ ∩ t₂ → ∃ t₃, t₃ ∈ s \ {∅} ∧ x ∈ t₃ ∧ t₃ ⊆ t₁ ∩ t₂

tactic: obtain ⟨t₃, h₃, hs⟩ := h.exists_subset_inter _ h₁ _ h₂ x hx
state_before: case refine'_1.intro.intro
α : Type u
t : TopologicalSpace α
s : Set (Set α)
h : IsTopologicalBasis s
t₁ : Set α
h₁ : t₁ ∈ s
t₂ : Set α
h₂ : t₂ ∈ s
x : α
hx : x ∈ t₁ ∩ t₂
⊢ ∃ t₃, t₃ ∈ s \ {∅} ∧ x ∈ t₃ ∧ t₃ ⊆ t₁ ∩ t₂

tactic: exact ⟨t₃, ⟨h₃, Nonempty.ne_empty ⟨x, hs.1⟩⟩, hs⟩
state_before: case refine'_1.intro.intro.intro.intro
α : Type u
t : TopologicalSpace α
s : Set (Set α)
h : IsTopologicalBasis s
t₁ : Set α
h₁ : t₁ ∈ s
t₂ : Set α
h₂ : t₂ ∈ s
x : α
hx : x ∈ t₁ ∩ t₂
t₃ : Set α
h₃ : t₃ ∈ s
hs : x ∈ t₃ ∧ t₃ ⊆ t₁ ∩ t₂
⊢ ∃ t₃, t₃ ∈ s \ {∅} ∧ x ∈ t₃ ∧ t₃ ⊆ t₁ ∩ t₂

tactic: rw [h.eq_generateFrom]
state_before: case refine'_2
α : Type u
t : TopologicalSpace α
s : Set (Set α)
h : IsTopologicalBasis s
⊢ t = generateFrom (s \ {∅})

tactic: refine' le_antisymm (generateFrom_anti <| diff_subset s _) (le_generateFrom fun t ht => _)
state_before: case refine'_2
α : Type u
t : TopologicalSpace α
s : Set (Set α)
h : IsTopologicalBasis s
⊢ generateFrom s = generateFrom (s \ {∅})

tactic: obtain rfl | he := eq_or_ne t ∅
state_before: case refine'_2
α : Type u
t✝ : TopologicalSpace α
s : Set (Set α)
h : IsTopologicalBasis s
t : Set α
ht : t ∈ s
⊢ IsOpen t

tactic: exact @isOpen_empty _ (generateFrom _)
state_before: case refine'_2.inl
α : Type u
t : TopologicalSpace α
s : Set (Set α)
h : IsTopologicalBasis s
ht : ∅ ∈ s
⊢ IsOpen ∅

tactic: exact .basic t ⟨ht, he⟩
state_before: case refine'_2.inr
α : Type u
t✝ : TopologicalSpace α
s : Set (Set α)
h : IsTopologicalBasis s
t : Set α
ht : t ∈ s
he : t ≠ ∅
⊢ IsOpen t
Theorem: Function.update_sup
File: Mathlib/Order/Lattice.lean

tactic: obtain rfl | hji := eq_or_ne j i <;> simp [update_noteq, *]
state_before: α : Type u
β : Type v
ι : Type u_2
π : ι → Type u_1
inst✝¹ : DecidableEq ι
inst✝ : (i : ι) → SemilatticeSup (π i)
f : (i : ι) → π i
i : ι
a b : π i
j : ι
⊢ update f i (a ⊔ b) j = (update f i a ⊔ update f i b) j
Theorem: Convex.lipschitzOnWith_of_nnnorm_hasFDerivWithin_le
File: Mathlib/Analysis/Calculus/MeanValue.lean

tactic: rw [lipschitzOnWith_iff_norm_sub_le]
state_before: E : Type u_1
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace ℝ E
F : Type ?u.166456
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace ℝ F
𝕜 : Type u_2
G : Type u_3
inst✝³ : IsROrC 𝕜
inst✝² : NormedSpace 𝕜 E
inst✝¹ : NormedAddCommGroup G
inst✝ : NormedSpace 𝕜 G
f g : E → G
C✝ : ℝ
s : Set E
x y : E
f' g' : E → E →L[𝕜] G
φ : E →L[𝕜] G
C : ℝ≥0
hf : ∀ (x : E), x ∈ s → HasFDerivWithinAt f (f' x) s x
bound : ∀ (x : E), x ∈ s → ‖f' x‖₊ ≤ C
hs : Convex ℝ s
⊢ LipschitzOnWith C f s

tactic: intro x x_in y y_in
state_before: E : Type u_1
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace ℝ E
F : Type ?u.166456
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace ℝ F
𝕜 : Type u_2
G : Type u_3
inst✝³ : IsROrC 𝕜
inst✝² : NormedSpace 𝕜 E
inst✝¹ : NormedAddCommGroup G
inst✝ : NormedSpace 𝕜 G
f g : E → G
C✝ : ℝ
s : Set E
x y : E
f' g' : E → E →L[𝕜] G
φ : E →L[𝕜] G
C : ℝ≥0
hf : ∀ (x : E), x ∈ s → HasFDerivWithinAt f (f' x) s x
bound : ∀ (x : E), x ∈ s → ‖f' x‖₊ ≤ C
hs : Convex ℝ s
⊢ ∀ ⦃x : E⦄, x ∈ s → ∀ ⦃y : E⦄, y ∈ s → ‖f x - f y‖ ≤ ↑C * ‖x - y‖

tactic: exact hs.norm_image_sub_le_of_norm_hasFDerivWithin_le hf bound y_in x_in
state_before: E : Type u_1
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace ℝ E
F : Type ?u.166456
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace ℝ F
𝕜 : Type u_2
G : Type u_3
inst✝³ : IsROrC 𝕜
inst✝² : NormedSpace 𝕜 E
inst✝¹ : NormedAddCommGroup G
inst✝ : NormedSpace 𝕜 G
f g : E → G
C✝ : ℝ
s : Set E
x✝ y✝ : E
f' g' : E → E →L[𝕜] G
φ : E →L[𝕜] G
C : ℝ≥0
hf : ∀ (x : E), x ∈ s → HasFDerivWithinAt f (f' x) s x
bound : ∀ (x : E), x ∈ s → ‖f' x‖₊ ≤ C
hs : Convex ℝ s
x : E
x_in : x ∈ s
y : E
y_in : y ∈ s
⊢ ‖f x - f y‖ ≤ ↑C * ‖x - y‖
Theorem: right_eq_midpoint_iff
File: Mathlib/LinearAlgebra/AffineSpace/Midpoint.lean

tactic: rw [eq_comm, midpoint_eq_right_iff]
state_before: R : Type u_2
V : Type u_3
V' : Type ?u.97975
P : Type u_1
P' : Type ?u.97981
inst✝⁷ : Ring R
inst✝⁶ : Invertible 2
inst✝⁵ : AddCommGroup V
inst✝⁴ : Module R V
inst✝³ : AddTorsor V P
inst✝² : AddCommGroup V'
inst✝¹ : Module R V'
inst✝ : AddTorsor V' P'
x✝ y✝ z x y : P
⊢ y = midpoint R x y ↔ x = y
Theorem: PartENat.eq_top_iff_forall_lt
File: Mathlib/Data/Nat/PartENat.lean

tactic: constructor
state_before: x : PartENat
⊢ x = ⊤ ↔ ∀ (n : ℕ), ↑n < x

tactic: rintro rfl n
state_before: case mp
x : PartENat
⊢ x = ⊤ → ∀ (n : ℕ), ↑n < x

tactic: exact natCast_lt_top _
state_before: case mp
n : ℕ
⊢ ↑n < ⊤

tactic: contrapose
state_before: case mpr
x : PartENat
⊢ (∀ (n : ℕ), ↑n < x) → x = ⊤

tactic: rw [←Ne, ne_top_iff, not_forall]
state_before: case mpr
x : PartENat
⊢ ¬x = ⊤ → ¬∀ (n : ℕ), ↑n < x

tactic: rintro ⟨n, rfl⟩
state_before: case mpr
x : PartENat
⊢ (∃ n, x = ↑n) → ∃ x_1, ¬↑x_1 < x

tactic: exact ⟨n, irrefl _⟩
state_before: case mpr.intro
n : ℕ
⊢ ∃ x, ¬↑x < ↑n
Theorem: List.foldr_eq_foldrTR
File: Std/Data/List/Basic.lean

tactic: funext α β f init l
state_before: ⊢ @foldr = @foldrTR

tactic: simp [foldrTR, Array.foldr_eq_foldr_data, -Array.size_toArray]
state_before: case h.h.h.h.h
α : Type u_2
β : Type u_1
f : α → β → β
init : β
l : List α
⊢ foldr f init l = foldrTR f init l
Theorem: Subgroup.coe_iInf
File: Mathlib/GroupTheory/Subgroup/Basic.lean

tactic: simp only [iInf, coe_sInf, Set.biInter_range]
state_before: G : Type u_2
G' : Type ?u.188842
inst✝² : Group G
inst✝¹ : Group G'
A : Type ?u.188851
inst✝ : AddGroup A
H K : Subgroup G
ι : Sort u_1
S : ι → Subgroup G
⊢ ↑(⨅ (i : ι), S i) = ⋂ (i : ι), ↑(S i)
Theorem: OnePoint.hasBasis_nhds_infty
File: Mathlib/Topology/Compactification/OnePoint.lean

tactic: rw [nhds_infty_eq]
state_before: X : Type u_1
inst✝ : TopologicalSpace X
s : Set (OnePoint X)
t : Set X
⊢ HasBasis (𝓝 ∞) (fun s => IsClosed s ∧ IsCompact s) fun s => some '' sᶜ ∪ {∞}

tactic: exact (hasBasis_coclosedCompact.map _).sup_pure _
state_before: X : Type u_1
inst✝ : TopologicalSpace X
s : Set (OnePoint X)
t : Set X
⊢ HasBasis (map some (coclosedCompact X) ⊔ pure ∞) (fun s => IsClosed s ∧ IsCompact s) fun s => some '' sᶜ ∪ {∞}
Theorem: Ordinal.bmex_not_mem_brange
File: Mathlib/SetTheory/Ordinal/Arithmetic.lean

tactic: rw [← range_familyOfBFamily]
state_before: α : Type ?u.382418
β : Type ?u.382421
γ : Type ?u.382424
r : α → α → Prop
s : β → β → Prop
t : γ → γ → Prop
o : Ordinal
f : (a : Ordinal) → a < o → Ordinal
⊢ ¬bmex o f ∈ brange o f

tactic: apply mex_not_mem_range
state_before: α : Type ?u.382418
β : Type ?u.382421
γ : Type ?u.382424
r : α → α → Prop
s : β → β → Prop
t : γ → γ → Prop
o : Ordinal
f : (a : Ordinal) → a < o → Ordinal
⊢ ¬bmex o f ∈ range (familyOfBFamily o f)
Theorem: List.Perm.bagInter_right
File: Mathlib/Data/List/Perm.lean

tactic: induction' h with x _ _ _ _ x y _ _ _ _ _ _ ih_1 ih_2 generalizing t
state_before: α : Type uu
β : Type vv
l₁✝ l₂✝ : List α
inst✝ : DecidableEq α
l₁ l₂ t : List α
h : l₁ ~ l₂
⊢ List.bagInter l₁ t ~ List.bagInter l₂ t

tactic: simp
state_before: case nil
α : Type uu
β : Type vv
l₁✝ l₂✝ : List α
inst✝ : DecidableEq α
l₁ l₂ t✝ t : List α
⊢ List.bagInter [] t ~ List.bagInter [] t

tactic: by_cases x ∈ t <;> simp [*, Perm.cons]
state_before: case cons
α : Type uu
β : Type vv
l₁✝¹ l₂✝¹ : List α
inst✝ : DecidableEq α
l₁ l₂ t✝ : List α
x : α
l₁✝ l₂✝ : List α
a✝ : l₁✝ ~ l₂✝
a_ih✝ : ∀ (t : List α), List.bagInter l₁✝ t ~ List.bagInter l₂✝ t
t : List α
⊢ List.bagInter (x :: l₁✝) t ~ List.bagInter (x :: l₂✝) t

tactic: by_cases h : x = y
state_before: case swap
α : Type uu
β : Type vv
l₁✝ l₂✝ : List α
inst✝ : DecidableEq α
l₁ l₂ t✝ : List α
x y : α
l✝ t : List α
⊢ List.bagInter (y :: x :: l✝) t ~ List.bagInter (x :: y :: l✝) t

tactic: by_cases xt : x ∈ t <;> by_cases yt : y ∈ t
state_before: case neg
α : Type uu
β : Type vv
l₁✝ l₂✝ : List α
inst✝ : DecidableEq α
l₁ l₂ t✝ : List α
x y : α
l✝ t : List α
h : ¬x = y
⊢ List.bagInter (y :: x :: l✝) t ~ List.bagInter (x :: y :: l✝) t

tactic: simp [h]
state_before: case pos
α : Type uu
β : Type vv
l₁✝ l₂✝ : List α
inst✝ : DecidableEq α
l₁ l₂ t✝ : List α
x y : α
l✝ t : List α
h : x = y
⊢ List.bagInter (y :: x :: l✝) t ~ List.bagInter (x :: y :: l✝) t

tactic: simp [xt, yt, mem_erase_of_ne h, mem_erase_of_ne (Ne.symm h), erase_comm, swap]
state_before: case pos
α : Type uu
β : Type vv
l₁✝ l₂✝ : List α
inst✝ : DecidableEq α
l₁ l₂ t✝ : List α
x y : α
l✝ t : List α
h : ¬x = y
xt : x ∈ t
yt : y ∈ t
⊢ List.bagInter (y :: x :: l✝) t ~ List.bagInter (x :: y :: l✝) t

tactic: simp [xt, yt, mt mem_of_mem_erase, Perm.cons]
state_before: case neg
α : Type uu
β : Type vv
l₁✝ l₂✝ : List α
inst✝ : DecidableEq α
l₁ l₂ t✝ : List α
x y : α
l✝ t : List α
h : ¬x = y
xt : x ∈ t
yt : ¬y ∈ t
⊢ List.bagInter (y :: x :: l✝) t ~ List.bagInter (x :: y :: l✝) t

tactic: simp [xt, yt, mt mem_of_mem_erase, Perm.cons]
state_before: case pos
α : Type uu
β : Type vv
l₁✝ l₂✝ : List α
inst✝ : DecidableEq α
l₁ l₂ t✝ : List α
x y : α
l✝ t : List α
h : ¬x = y
xt : ¬x ∈ t
yt : y ∈ t
⊢ List.bagInter (y :: x :: l✝) t ~ List.bagInter (x :: y :: l✝) t

tactic: simp [xt, yt]
state_before: case neg
α : Type uu
β : Type vv
l₁✝ l₂✝ : List α
inst✝ : DecidableEq α
l₁ l₂ t✝ : List α
x y : α
l✝ t : List α
h : ¬x = y
xt : ¬x ∈ t
yt : ¬y ∈ t
⊢ List.bagInter (y :: x :: l✝) t ~ List.bagInter (x :: y :: l✝) t

tactic: exact (ih_1 _).trans (ih_2 _)
state_before: case trans
α : Type uu
β : Type vv
l₁✝¹ l₂✝¹ : List α
inst✝ : DecidableEq α
l₁ l₂ t✝ l₁✝ l₂✝ l₃✝ : List α
a✝¹ : l₁✝ ~ l₂✝
a✝ : l₂✝ ~ l₃✝
ih_1 : ∀ (t : List α), List.bagInter l₁✝ t ~ List.bagInter l₂✝ t
ih_2 : ∀ (t : List α), List.bagInter l₂✝ t ~ List.bagInter l₃✝ t
t : List α
⊢ List.bagInter l₁✝ t ~ List.bagInter l₃✝ t
Theorem: starConvex_singleton
File: Mathlib/Analysis/Convex/Star.lean

tactic: rintro y (rfl : y = x) a b _ _ hab
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type ?u.32904
inst✝⁴ : OrderedSemiring 𝕜
inst✝³ : AddCommMonoid E
inst✝² : AddCommMonoid F
inst✝¹ : Module 𝕜 E
inst✝ : Module 𝕜 F
x✝ y z : E
s : Set E
x : E
⊢ StarConvex 𝕜 x {x}

tactic: exact Convex.combo_self hab _
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type ?u.32904
inst✝⁴ : OrderedSemiring 𝕜
inst✝³ : AddCommMonoid E
inst✝² : AddCommMonoid F
inst✝¹ : Module 𝕜 E
inst✝ : Module 𝕜 F
x y✝ z : E
s : Set E
y : E
a b : 𝕜
a✝¹ : 0 ≤ a
a✝ : 0 ≤ b
hab : a + b = 1
⊢ a • y + b • y ∈ {y}
Theorem: Real.cosh_log
File: Mathlib/Analysis/SpecialFunctions/Log/Basic.lean

tactic: rw [cosh_eq, exp_neg, exp_log hx]
state_before: x✝ y x : ℝ
hx : 0 < x
⊢ cosh (log x) = (x + x⁻¹) / 2