tasksource/leandojo huggingface dataset:
Theorem: EMetric.infEdist_le_infEdist_add_edist
File: Mathlib/Topology/MetricSpace/HausdorffDistance.lean

tactic: simp only [ENNReal.iInf_add]
state_before: ι : Sort ?u.5234
α : Type u
β : Type v
inst✝¹ : PseudoEMetricSpace α
inst✝ : PseudoEMetricSpace β
x y : α
s t : Set α
Φ : α → β
⊢ (⨅ (z : α) (_ : z ∈ s), edist y z + edist x y) = (⨅ (z : α) (_ : z ∈ s), edist y z) + edist x y
Theorem: Multiset.lcm_union
File: Mathlib/Algebra/GCDMonoid/Multiset.lean

tactic: rw [← lcm_dedup, dedup_ext.2, lcm_dedup, lcm_add]
state_before: α : Type u_1
inst✝² : CancelCommMonoidWithZero α
inst✝¹ : NormalizedGCDMonoid α
inst✝ : DecidableEq α
s₁ s₂ : Multiset α
⊢ lcm (s₁ ∪ s₂) = GCDMonoid.lcm (lcm s₁) (lcm s₂)

tactic: simp
state_before: α : Type u_1
inst✝² : CancelCommMonoidWithZero α
inst✝¹ : NormalizedGCDMonoid α
inst✝ : DecidableEq α
s₁ s₂ : Multiset α
⊢ ∀ (a : α), a ∈ s₁ ∪ s₂ ↔ a ∈ s₁ + s₂
Theorem: Polynomial.binomial_eq_binomial
File: Mathlib/Data/Polynomial/Basic.lean

tactic: simp_rw [C_mul_X_pow_eq_monomial, ← toFinsupp_inj, toFinsupp_add, toFinsupp_monomial]
state_before: R : Type u
a b : R
m✝ n✝ : ℕ
inst✝ : Semiring R
p q : R[X]
k l m n : ℕ
u v : R
hu : u ≠ 0
hv : v ≠ 0
⊢ ↑C u * X ^ k + ↑C v * X ^ l = ↑C u * X ^ m + ↑C v * X ^ n ↔
    k = m ∧ l = n ∨ u = v ∧ k = n ∧ l = m ∨ u + v = 0 ∧ k = l ∧ m = n

tactic: exact Finsupp.single_add_single_eq_single_add_single hu hv
state_before: R : Type u
a b : R
m✝ n✝ : ℕ
inst✝ : Semiring R
p q : R[X]
k l m n : ℕ
u v : R
hu : u ≠ 0
hv : v ≠ 0
⊢ Finsupp.single k u + Finsupp.single l v = Finsupp.single m u + Finsupp.single n v ↔
    k = m ∧ l = n ∨ u = v ∧ k = n ∧ l = m ∨ u + v = 0 ∧ k = l ∧ m = n
Theorem: List.maximum_eq_coe_iff
File: Mathlib/Data/List/MinMax.lean

tactic: rw [maximum, ← WithBot.some_eq_coe, argmax_eq_some_iff]
state_before: α : Type u_1
β : Type ?u.104435
inst✝ : LinearOrder α
l : List α
a m : α
⊢ maximum l = ↑m ↔ m ∈ l ∧ ∀ (a : α), a ∈ l → a ≤ m

tactic: simp only [id_eq, and_congr_right_iff, and_iff_left_iff_imp]
state_before: α : Type u_1
β : Type ?u.104435
inst✝ : LinearOrder α
l : List α
a m : α
⊢ (m ∈ l ∧ (∀ (a : α), a ∈ l → id a ≤ id m) ∧ ∀ (a : α), a ∈ l → id m ≤ id a → indexOf m l ≤ indexOf a l) ↔
    m ∈ l ∧ ∀ (a : α), a ∈ l → a ≤ m

tactic: intro _ h a hal hma
state_before: α : Type u_1
β : Type ?u.104435
inst✝ : LinearOrder α
l : List α
a m : α
⊢ m ∈ l → (∀ (a : α), a ∈ l → a ≤ m) → ∀ (a : α), a ∈ l → m ≤ a → indexOf m l ≤ indexOf a l

tactic: rw [_root_.le_antisymm hma (h a hal)]
state_before: α : Type u_1
β : Type ?u.104435
inst✝ : LinearOrder α
l : List α
a✝¹ m : α
a✝ : m ∈ l
h : ∀ (a : α), a ∈ l → a ≤ m
a : α
hal : a ∈ l
hma : m ≤ a
⊢ indexOf m l ≤ indexOf a l
Theorem: PiCountable.min_dist_le_dist_pi
File: Mathlib/Topology/MetricSpace/PiNat.lean

tactic: simp
state_before: E : ℕ → Type ?u.304444
ι : Type u_1
inst✝¹ : Encodable ι
F : ι → Type u_2
inst✝ : (i : ι) → MetricSpace (F i)
x y : (i : ι) → F i
i j : ι
x✝ : j ≠ i
⊢ 0 ≤ (1 / 2) ^ encode j
Theorem: Filter.map₂_pure
File: Mathlib/Order/Filter/NAry.lean

tactic: rw [map₂_pure_right, map_pure]
state_before: α : Type u_2
α' : Type ?u.29150
β : Type u_3
β' : Type ?u.29156
γ : Type u_1
γ' : Type ?u.29162
δ : Type ?u.29165
δ' : Type ?u.29168
ε : Type ?u.29171
ε' : Type ?u.29174
m : α → β → γ
f f₁ f₂ : Filter α
g g₁ g₂ : Filter β
h h₁ h₂ : Filter γ
s s₁ s₂ : Set α
t t₁ t₂ : Set β
u : Set γ
v : Set δ
a : α
b : β
c : γ
⊢ map₂ m (pure a) (pure b) = pure (m a b)
Theorem: bernsteinApproximation.le_of_mem_S_compl
File: Mathlib/Analysis/SpecialFunctions/Bernstein.lean

tactic: simp only [Finset.mem_compl, not_lt, (Set.mem_toFinset), Set.mem_setOf_eq, S] at m
state_before: f : C(↑I, ℝ)
ε : ℝ
h : 0 < ε
n : ℕ
x : ↑I
k : Fin (n + 1)
m : k ∈ S f ε h n xᶜ
⊢ 1 ≤ δ f ε h ^ (-2) * (↑x - ↑k/ₙ) ^ 2

tactic: rw [zpow_neg, ← div_eq_inv_mul, zpow_two, ← pow_two, one_le_div (pow_pos δ_pos 2), sq_le_sq,
  abs_of_pos δ_pos]
state_before: f : C(↑I, ℝ)
ε : ℝ
h : 0 < ε
n : ℕ
x : ↑I
k : Fin (n + 1)
m : δ f ε h ≤ dist k/ₙ x
⊢ 1 ≤ δ f ε h ^ (-2) * (↑x - ↑k/ₙ) ^ 2

tactic: rwa [dist_comm] at m
state_before: f : C(↑I, ℝ)
ε : ℝ
h : 0 < ε
n : ℕ
x : ↑I
k : Fin (n + 1)
m : δ f ε h ≤ dist k/ₙ x
⊢ δ f ε h ≤ abs (↑x - ↑k/ₙ)
Theorem: MulAction.minimalPeriod_eq_card
File: Mathlib/Data/ZMod/Quotient.lean

tactic: rw [← Fintype.ofEquiv_card (orbitZpowersEquiv a b), @ZMod.card _ (_)]
state_before: n : ℕ
A : Type ?u.315283
R : Type ?u.315286
inst✝⁴ : AddGroup A
inst✝³ : Ring R
α : Type u_2
β : Type u_1
inst✝² : Group α
a : α
inst✝¹ : MulAction α β
b : β
inst✝ : Fintype ↑(orbit { x // x ∈ zpowers a } b)
⊢ minimalPeriod ((fun x x_1 => x • x_1) a) b = Fintype.card ↑(orbit { x // x ∈ zpowers a } b)
Theorem: IsSubgroup.of_div
File: Mathlib/Deprecated/Subgroup.lean

tactic: have : 1 * a⁻¹ ∈ s := div_mem one_mem ha
state_before: G : Type u_1
H : Type ?u.4214
A : Type ?u.4217
a✝ a₁ a₂ b c : G
inst✝¹ : Group G
inst✝ : AddGroup A
s : Set G
one_mem : 1 ∈ s
div_mem : ∀ {a b : G}, a ∈ s → b ∈ s → a * b⁻¹ ∈ s
a : G
ha : a ∈ s
⊢ a⁻¹ ∈ s

tactic: convert this using 1
state_before: G : Type u_1
H : Type ?u.4214
A : Type ?u.4217
a✝ a₁ a₂ b c : G
inst✝¹ : Group G
inst✝ : AddGroup A
s : Set G
one_mem : 1 ∈ s
div_mem : ∀ {a b : G}, a ∈ s → b ∈ s → a * b⁻¹ ∈ s
a : G
ha : a ∈ s
this : 1 * a⁻¹ ∈ s
⊢ a⁻¹ ∈ s

tactic: rw [one_mul]
state_before: case h.e'_4
G : Type u_1
H : Type ?u.4214
A : Type ?u.4217
a✝ a₁ a₂ b c : G
inst✝¹ : Group G
inst✝ : AddGroup A
s : Set G
one_mem : 1 ∈ s
div_mem : ∀ {a b : G}, a ∈ s → b ∈ s → a * b⁻¹ ∈ s
a : G
ha : a ∈ s
this : 1 * a⁻¹ ∈ s
⊢ a⁻¹ = 1 * a⁻¹

tactic: have : a * b⁻¹⁻¹ ∈ s := div_mem ha (inv_mem b hb)
state_before: G : Type u_1
H : Type ?u.4214
A : Type ?u.4217
a✝ a₁ a₂ b✝ c : G
inst✝¹ : Group G
inst✝ : AddGroup A
s : Set G
one_mem : 1 ∈ s
div_mem : ∀ {a b : G}, a ∈ s → b ∈ s → a * b⁻¹ ∈ s
inv_mem : ∀ (a : G), a ∈ s → a⁻¹ ∈ s
a b : G
ha : a ∈ s
hb : b ∈ s
⊢ a * b ∈ s

tactic: convert this
state_before: G : Type u_1
H : Type ?u.4214
A : Type ?u.4217
a✝ a₁ a₂ b✝ c : G
inst✝¹ : Group G
inst✝ : AddGroup A
s : Set G
one_mem : 1 ∈ s
div_mem : ∀ {a b : G}, a ∈ s → b ∈ s → a * b⁻¹ ∈ s
inv_mem : ∀ (a : G), a ∈ s → a⁻¹ ∈ s
a b : G
ha : a ∈ s
hb : b ∈ s
this : a * b⁻¹⁻¹ ∈ s
⊢ a * b ∈ s

tactic: rw [inv_inv]
state_before: case h.e'_4.h.e'_6
G : Type u_1
H : Type ?u.4214
A : Type ?u.4217
a✝ a₁ a₂ b✝ c : G
inst✝¹ : Group G
inst✝ : AddGroup A
s : Set G
one_mem : 1 ∈ s
div_mem : ∀ {a b : G}, a ∈ s → b ∈ s → a * b⁻¹ ∈ s
inv_mem : ∀ (a : G), a ∈ s → a⁻¹ ∈ s
a b : G
ha : a ∈ s
hb : b ∈ s
this : a * b⁻¹⁻¹ ∈ s
⊢ b = b⁻¹⁻¹
Theorem: BoxIntegral.integralSum_disjUnion
File: Mathlib/Analysis/BoxIntegral/Basic.lean

tactic: rw [disjUnion_tag_of_mem_left _ hJ]
state_before: case refine'_1
ι : Type u
E : Type v
F : Type w
inst✝³ : NormedAddCommGroup E
inst✝² : NormedSpace ℝ E
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedSpace ℝ F
I J✝ : Box ι
π : TaggedPrepartition I
f : (ι → ℝ) → E
vol : ι →ᵇᵃ[⊤] E →L[ℝ] F
π₁ π₂ : TaggedPrepartition I
h : Disjoint (TaggedPrepartition.iUnion π₁) (TaggedPrepartition.iUnion π₂)
J : Box ι
hJ : J ∈ π₁.boxes
⊢ ↑(↑vol J) (f (tag (TaggedPrepartition.disjUnion π₁ π₂ h) J)) = ↑(↑vol J) (f (tag π₁ J))

tactic: rw [disjUnion_tag_of_mem_right _ hJ]
state_before: case refine'_2
ι : Type u
E : Type v
F : Type w
inst✝³ : NormedAddCommGroup E
inst✝² : NormedSpace ℝ E
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedSpace ℝ F
I J✝ : Box ι
π : TaggedPrepartition I
f : (ι → ℝ) → E
vol : ι →ᵇᵃ[⊤] E →L[ℝ] F
π₁ π₂ : TaggedPrepartition I
h : Disjoint (TaggedPrepartition.iUnion π₁) (TaggedPrepartition.iUnion π₂)
J : Box ι
hJ : J ∈ π₂.boxes
⊢ ↑(↑vol J) (f (tag (TaggedPrepartition.disjUnion π₁ π₂ h) J)) = ↑(↑vol J) (f (tag π₂ J))
Theorem: AddLECancellable.tsub_lt_iff_right
File: Mathlib/Algebra/Order/Sub/Canonical.lean

tactic: rw [add_comm]
state_before: α : Type u_1
inst✝⁵ : AddCommSemigroup α
inst✝⁴ : PartialOrder α
inst✝³ : ExistsAddOfLE α
inst✝² : CovariantClass α α (fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1
inst✝¹ : Sub α
inst✝ : OrderedSub α
a b c d : α
hb : AddLECancellable b
hba : b ≤ a
⊢ a - b < c ↔ a < c + b

tactic: exact hb.tsub_lt_iff_left hba
state_before: α : Type u_1
inst✝⁵ : AddCommSemigroup α
inst✝⁴ : PartialOrder α
inst✝³ : ExistsAddOfLE α
inst✝² : CovariantClass α α (fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1
inst✝¹ : Sub α
inst✝ : OrderedSub α
a b c d : α
hb : AddLECancellable b
hba : b ≤ a
⊢ a - b < c ↔ a < b + c
Theorem: map_mul_right_nhds_one₀
File: Mathlib/Topology/Algebra/GroupWithZero.lean

tactic: rw [map_mul_right_nhds₀ ha, one_mul]
state_before: α : Type ?u.56050
β : Type ?u.56053
G₀ : Type u_1
inst✝² : TopologicalSpace G₀
inst✝¹ : GroupWithZero G₀
inst✝ : ContinuousMul G₀
a : G₀
ha : a ≠ 0
⊢ map (fun x => x * a) (𝓝 1) = 𝓝 a
Theorem: Complex.arg_mem_Ioc
File: Mathlib/Analysis/SpecialFunctions/Complex/Arg.lean

tactic: have hπ : 0 < π := Real.pi_pos
state_before: z : ℂ
⊢ arg z ∈ Set.Ioc (-π) π

tactic: rcases eq_or_ne z 0 with (rfl | hz)
state_before: z : ℂ
hπ : 0 < π
⊢ arg z ∈ Set.Ioc (-π) π

tactic: simp [hπ, hπ.le]
state_before: case inl
hπ : 0 < π
⊢ arg 0 ∈ Set.Ioc (-π) π

case inr
z : ℂ
hπ : 0 < π
hz : z ≠ 0
⊢ arg z ∈ Set.Ioc (-π) π

tactic: rcases existsUnique_add_zsmul_mem_Ioc Real.two_pi_pos (arg z) (-π) with ⟨N, hN, -⟩
state_before: case inr
z : ℂ
hπ : 0 < π
hz : z ≠ 0
⊢ arg z ∈ Set.Ioc (-π) π

tactic: rw [two_mul, neg_add_cancel_left, ← two_mul, zsmul_eq_mul] at hN
state_before: case inr.intro.intro
z : ℂ
hπ : 0 < π
hz : z ≠ 0
N : ℤ
hN : arg z + N • (2 * π) ∈ Set.Ioc (-π) (-π + 2 * π)
⊢ arg z ∈ Set.Ioc (-π) π

tactic: rw [← abs_mul_cos_add_sin_mul_I z, ← cos_add_int_mul_two_pi _ N, ← sin_add_int_mul_two_pi _ N]
state_before: case inr.intro.intro
z : ℂ
hπ : 0 < π
hz : z ≠ 0
N : ℤ
hN : arg z + ↑N * (2 * π) ∈ Set.Ioc (-π) π
⊢ arg z ∈ Set.Ioc (-π) π

tactic: simp only [← ofReal_one, ← ofReal_bit0, ← ofReal_mul, ← ofReal_add, ofReal_int_cast]
state_before: case inr.intro.intro
z : ℂ
hπ : 0 < π
hz : z ≠ 0
N : ℤ
hN : arg z + ↑N * (2 * π) ∈ Set.Ioc (-π) π
⊢ arg (↑(↑abs z) * (cos (↑(arg z) + ↑N * (2 * ↑π)) + sin (↑(arg z) + ↑N * (2 * ↑π)) * I)) ∈ Set.Ioc (-π) π

tactic: have := arg_mul_cos_add_sin_mul_I (abs.pos hz) hN
state_before: case inr.intro.intro
z : ℂ
hπ : 0 < π
hz : z ≠ 0
N : ℤ
hN : arg z + ↑N * (2 * π) ∈ Set.Ioc (-π) π
⊢ arg (↑(↑abs z) * (cos (↑(arg z) + ↑N * (2 * ↑π)) + sin (↑(arg z) + ↑N * (2 * ↑π)) * I)) ∈ Set.Ioc (-π) π

tactic: push_cast at this
state_before: case inr.intro.intro
z : ℂ
hπ : 0 < π
hz : z ≠ 0
N : ℤ
hN : arg z + ↑N * (2 * π) ∈ Set.Ioc (-π) π
this : arg (↑(↑abs z) * (cos ↑(arg z + ↑N * (2 * π)) + sin ↑(arg z + ↑N * (2 * π)) * I)) = arg z + ↑N * (2 * π)
⊢ arg (↑(↑abs z) * (cos (↑(arg z) + ↑N * (2 * ↑π)) + sin (↑(arg z) + ↑N * (2 * ↑π)) * I)) ∈ Set.Ioc (-π) π

tactic: rwa [this]
state_before: case inr.intro.intro
z : ℂ
hπ : 0 < π
hz : z ≠ 0
N : ℤ
hN : arg z + ↑N * (2 * π) ∈ Set.Ioc (-π) π
this : arg (↑(↑abs z) * (cos (↑(arg z) + ↑N * (2 * ↑π)) + sin (↑(arg z) + ↑N * (2 * ↑π)) * I)) = arg z + ↑N * (2 * π)
⊢ arg (↑(↑abs z) * (cos (↑(arg z) + ↑N * (2 * ↑π)) + sin (↑(arg z) + ↑N * (2 * ↑π)) * I)) ∈ Set.Ioc (-π) π
Theorem: Asymptotics.isTheta_zero_left
File: Mathlib/Analysis/Asymptotics/Theta.lean

tactic: simp only [IsTheta, isBigO_zero, isBigO_zero_right_iff, true_and_iff]
state_before: α : Type u_1
β : Type ?u.51679
E : Type ?u.51682
F : Type ?u.51685
G : Type ?u.51688
E' : Type u_2
F' : Type ?u.51694
G' : Type ?u.51697
E'' : Type ?u.51700
F'' : Type u_3
G'' : Type ?u.51706
R : Type ?u.51709
R' : Type ?u.51712
𝕜 : Type ?u.51715
𝕜' : Type ?u.51718
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''
l l' : Filter α
⊢ (fun x => 0) =Θ[l] g'' ↔ g'' =ᶠ[l] 0
Theorem: CategoryTheory.Subobject.factorThru_mk_self
File: Mathlib/CategoryTheory/Subobject/FactorThru.lean

tactic: ext
state_before: C : Type u₁
inst✝² : Category C
X Y Z : C
D : Type u₂
inst✝¹ : Category D
f : X ⟶ Y
inst✝ : Mono f
⊢ factorThru (mk f) f (_ : Factors (mk f) f) = (underlyingIso f).inv

tactic: simp
state_before: case h
C : Type u₁
inst✝² : Category C
X Y Z : C
D : Type u₂
inst✝¹ : Category D
f : X ⟶ Y
inst✝ : Mono f
⊢ factorThru (mk f) f (_ : Factors (mk f) f) ≫ arrow (mk f) = (underlyingIso f).inv ≫ arrow (mk f)
Theorem: Filter.tendsto_prod_iff'
File: Mathlib/Order/Filter/Prod.lean

tactic: dsimp only [SProd.sprod]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type ?u.52575
ι : Sort ?u.52578
s✝ : Set α
t : Set β
f✝ : Filter α
g✝ : Filter β
f : Filter α
g : Filter β
g' : Filter γ
s : α → β × γ
⊢ Tendsto s f (g ×ˢ g') ↔ Tendsto (fun n => (s n).fst) f g ∧ Tendsto (fun n => (s n).snd) f g'

tactic: unfold Filter.prod
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type ?u.52575
ι : Sort ?u.52578
s✝ : Set α
t : Set β
f✝ : Filter α
g✝ : Filter β
f : Filter α
g : Filter β
g' : Filter γ
s : α → β × γ
⊢ Tendsto s f (Filter.prod g g') ↔ Tendsto (fun n => (s n).fst) f g ∧ Tendsto (fun n => (s n).snd) f g'
Theorem: ContinuousMap.continuousMap_mem_subalgebra_closure_of_separatesPoints
File: Mathlib/Topology/ContinuousFunction/StoneWeierstrass.lean

tactic: rw [subalgebra_topologicalClosure_eq_top_of_separatesPoints A w]
state_before: X : Type u_1
inst✝¹ : TopologicalSpace X
inst✝ : CompactSpace X
A : Subalgebra ℝ C(X, ℝ)
w : Subalgebra.SeparatesPoints A
f : C(X, ℝ)
⊢ f ∈ Subalgebra.topologicalClosure A

tactic: simp
state_before: X : Type u_1
inst✝¹ : TopologicalSpace X
inst✝ : CompactSpace X
A : Subalgebra ℝ C(X, ℝ)
w : Subalgebra.SeparatesPoints A
f : C(X, ℝ)
⊢ f ∈ ⊤
Theorem: Basis.mk_apply
File: Mathlib/LinearAlgebra/Basis.lean

tactic: simp
state_before: ι : Type u_2
ι' : Type ?u.820992
R : Type u_3
R₂ : Type ?u.820998
K : Type ?u.821001
M : Type u_1
M' : Type ?u.821007
M'' : Type ?u.821010
V : Type u
V' : Type ?u.821015
v : ι → M
inst✝⁸ : Ring R
inst✝⁷ : CommRing R₂
inst✝⁶ : AddCommGroup M
inst✝⁵ : AddCommGroup M'
inst✝⁴ : AddCommGroup M''
inst✝³ : Module R M
inst✝² : Module R₂ M
inst✝¹ : Module R M'
inst✝ : Module R M''
c d : R
x y : M
b : Basis ι R M
hli : LinearIndependent R v
hsp : ⊤ ≤ span R (Set.range v)
i : ι
⊢ ↑(Finsupp.total ι M R v) (Finsupp.single i 1) = v i
Theorem: WithTop.coe_iInf
File: Mathlib/Order/ConditionallyCompleteLattice/Basic.lean

tactic: rw [iInf, iInf, WithTop.coe_sInf' (range_nonempty f), ← range_comp]
state_before: α : Type u_2
β : Type ?u.4115
γ : Type ?u.4118
ι : Sort u_1
inst✝¹ : Nonempty ι
inst✝ : InfSet α
f : ι → α
⊢ ↑(⨅ (i : ι), f i) = ⨅ (i : ι), ↑(f i)

tactic: rfl
state_before: α : Type u_2
β : Type ?u.4115
γ : Type ?u.4118
ι : Sort u_1
inst✝¹ : Nonempty ι
inst✝ : InfSet α
f : ι → α
⊢ sInf (range ((fun a => ↑a) ∘ f)) = sInf (range fun i => ↑(f i))
Theorem: List.modifyNth_eq_set
File: Mathlib/Data/List/Basic.lean

tactic: cases l <;> rfl
state_before: ι : Type ?u.109543
α : Type u
β : Type v
γ : Type w
δ : Type x
l₁ l₂ : List α
f : α → α
l : List α
⊢ modifyNth f 0 l = Option.getD ((fun a => set l 0 (f a)) <$> get? l 0) l

tactic: cases get? l n <;> rfl
state_before: ι : Type ?u.109543
α : Type u
β : Type v
γ : Type w
δ : Type x
l₁ l₂ : List α
f : α → α
n : ℕ
b : α
l : List α
⊢ b :: Option.getD ((fun a => set l n (f a)) <$> get? l n) l =
    Option.getD ((fun a => set (b :: l) (n + 1) (f a)) <$> get? (b :: l) (n + 1)) (b :: l)
Theorem: CategoryTheory.Limits.Cofork.app_zero_eq_comp_π_left
File: Mathlib/CategoryTheory/Limits/Shapes/Equalizers.lean

tactic: rw [← s.app_one_eq_π, ← s.w left, parallelPair_map_left]
state_before: C : Type u
inst✝ : Category C
X Y : C
f g : X ⟶ Y
s : Cofork f g
⊢ s.ι.app zero = f ≫ π s
Theorem: indicator_le_thickenedIndicatorAux
File: Mathlib/Topology/MetricSpace/ThickenedIndicator.lean

tactic: intro a
state_before: α : Type u_1
inst✝ : PseudoEMetricSpace α
δ : ℝ
E : Set α
⊢ (indicator E fun x => 1) ≤ thickenedIndicatorAux δ E

tactic: by_cases a ∈ E
state_before: α : Type u_1
inst✝ : PseudoEMetricSpace α
δ : ℝ
E : Set α
a : α
⊢ indicator E (fun x => 1) a ≤ thickenedIndicatorAux δ E a

tactic: simp only [h, indicator_of_mem, thickenedIndicatorAux_one δ E h, le_refl]
state_before: case pos
α : Type u_1
inst✝ : PseudoEMetricSpace α
δ : ℝ
E : Set α
a : α
h : a ∈ E
⊢ indicator E (fun x => 1) a ≤ thickenedIndicatorAux δ E a

tactic: simp only [h, indicator_of_not_mem, not_false_iff, zero_le]
state_before: case neg
α : Type u_1
inst✝ : PseudoEMetricSpace α
δ : ℝ
E : Set α
a : α
h : ¬a ∈ E
⊢ indicator E (fun x => 1) a ≤ thickenedIndicatorAux δ E a
Theorem: Primrec.cond
File: Mathlib/Computability/Primrec.lean

tactic: cases c a <;> rfl
state_before: α : Type u_1
β : Type ?u.127167
γ : Type ?u.127170
δ : Type ?u.127173
σ : Type u_2
inst✝⁴ : Primcodable α
inst✝³ : Primcodable β
inst✝² : Primcodable γ
inst✝¹ : Primcodable δ
inst✝ : Primcodable σ
c : α → Bool
f g : α → σ
hc : Primrec c
hf : Primrec f
hg : Primrec g
a : α
⊢ (Nat.casesOn (encode (c a)) (g a) fun b => f (a, b).fst) = bif c a then f a else g a
Theorem: edist_inv
File: Mathlib/Topology/MetricSpace/IsometricSMul.lean

tactic: rw [← edist_inv_inv, inv_inv]
state_before: M : Type u
G : Type v
X : Type w
inst✝⁶ : PseudoEMetricSpace X
inst✝⁵ : Group G
inst✝⁴ : MulAction G X
inst✝³ : IsometricSMul G X
inst✝² : PseudoEMetricSpace G
inst✝¹ : IsometricSMul G G
inst✝ : IsometricSMul Gᵐᵒᵖ G
x y : G
⊢ edist x⁻¹ y = edist x y⁻¹
Theorem: AbstractCompletion.extend_coe
File: Mathlib/Topology/UniformSpace/AbstractCompletion.lean

tactic: rw [pkg.extend_def hf]
state_before: α : Type u_2
inst✝² : UniformSpace α
pkg : AbstractCompletion α
β : Type u_1
inst✝¹ : UniformSpace β
f : α → β
inst✝ : T2Space β
hf : UniformContinuous f
a : α
⊢ AbstractCompletion.extend pkg f (coe pkg a) = f a

tactic: exact pkg.denseInducing.extend_eq hf.continuous a
state_before: α : Type u_2
inst✝² : UniformSpace α
pkg : AbstractCompletion α
β : Type u_1
inst✝¹ : UniformSpace β
f : α → β
inst✝ : T2Space β
hf : UniformContinuous f
a : α
⊢ DenseInducing.extend (_ : DenseInducing pkg.coe) f (coe pkg a) = f a
Theorem: Polynomial.support_update_ne_zero
File: Mathlib/Data/Polynomial/Basic.lean

tactic: classical rw [support_update, if_neg ha]
state_before: R : Type u
a✝ b : R
m n✝ : ℕ
inst✝ : Semiring R
p✝ q p : R[X]
n : ℕ
a : R
ha : a ≠ 0
⊢ support (update p n a) = insert n (support p)

tactic: rw [support_update, if_neg ha]
state_before: R : Type u
a✝ b : R
m n✝ : ℕ
inst✝ : Semiring R
p✝ q p : R[X]
n : ℕ
a : R
ha : a ≠ 0
⊢ support (update p n a) = insert n (support p)
Theorem: NormedAddGroupHom.coe_injective
File: Mathlib/Analysis/Normed/Group/Hom.lean

tactic: apply coe_inj
state_before: V : Type ?u.109674
V₁ : Type u_2
V₂ : Type u_1
V₃ : Type ?u.109683
inst✝³ : SeminormedAddCommGroup V
inst✝² : SeminormedAddCommGroup V₁
inst✝¹ : SeminormedAddCommGroup V₂
inst✝ : SeminormedAddCommGroup V₃
f g : NormedAddGroupHom V₁ V₂
⊢ Function.Injective toFun
Theorem: Complex.log_im_le_pi
File: Mathlib/Analysis/SpecialFunctions/Complex/Log.lean

tactic: simp only [log_im, arg_le_pi]
state_before: x : ℂ
⊢ (log x).im ≤ π
Theorem: LieModule.nilpotent_endo_of_nilpotent_module
File: Mathlib/Algebra/Lie/Nilpotent.lean

tactic: obtain ⟨k, hM⟩ := hM
state_before: R : Type u
L : Type v
M : 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
k : ℕ
N : LieSubmodule R L M
hM : IsNilpotent R L M
⊢ ∃ k, ∀ (x : L), ↑(toEndomorphism R L M) x ^ k = 0

tactic: use k
state_before: case mk.intro
R : Type u
L : Type v
M : 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
k✝ : ℕ
N : LieSubmodule R L M
k : ℕ
hM : lowerCentralSeries R L M k = ⊥
⊢ ∃ k, ∀ (x : L), ↑(toEndomorphism R L M) x ^ k = 0

tactic: intro x
state_before: case mk.intro
R : Type u
L : Type v
M : 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
k✝ : ℕ
N : LieSubmodule R L M
k : ℕ
hM : lowerCentralSeries R L M k = ⊥
⊢ ∀ (x : L), ↑(toEndomorphism R L M) x ^ k = 0

tactic: ext m
state_before: case mk.intro
R : Type u
L : Type v
M : 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
k✝ : ℕ
N : LieSubmodule R L M
k : ℕ
hM : lowerCentralSeries R L M k = ⊥
x : L
⊢ ↑(toEndomorphism R L M) x ^ k = 0

tactic: rw [LinearMap.pow_apply, LinearMap.zero_apply, ← @LieSubmodule.mem_bot R L M, ← hM]
state_before: case mk.intro.h
R : Type u
L : Type v
M : 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
k✝ : ℕ
N : LieSubmodule R L M
k : ℕ
hM : lowerCentralSeries R L M k = ⊥
x : L
m : M
⊢ ↑(↑(toEndomorphism R L M) x ^ k) m = ↑0 m

tactic: exact iterate_toEndomorphism_mem_lowerCentralSeries R L M x m k
state_before: case mk.intro.h
R : Type u
L : Type v
M : 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
k✝ : ℕ
N : LieSubmodule R L M
k : ℕ
hM : lowerCentralSeries R L M k = ⊥
x : L
m : M
⊢ (↑(↑(toEndomorphism R L M) x)^[k]) m ∈ lowerCentralSeries R L M k
Theorem: Finset.Nonempty.cons_induction
File: Mathlib/Data/Finset/Basic.lean

tactic: induction' s using Finset.cons_induction with a t ha h
state_before: α✝ : Type ?u.117523
β : Type ?u.117526
γ : Type ?u.117529
inst✝ : DecidableEq α✝
s✝ t u v : Finset α✝
a b : α✝
α : Type u_1
p : (s : Finset α) → Finset.Nonempty s → Prop
h₀ : ∀ (a : α), p {a} (_ : Finset.Nonempty {a})
h₁ :
  ∀ ⦃a : α⦄ (s : Finset α) (h : ¬a ∈ s) (hs : Finset.Nonempty s),
    p s hs → p (cons a s h) (_ : Finset.Nonempty (cons a s h))
s : Finset α
hs : Finset.Nonempty s
⊢ p s hs

tactic: obtain rfl | ht := t.eq_empty_or_nonempty
state_before: case cons
α✝ : Type ?u.117523
β : Type ?u.117526
γ : Type ?u.117529
inst✝ : DecidableEq α✝
s✝ t✝ u v : Finset α✝
a✝ b : α✝
α : Type u_1
p : (s : Finset α) → Finset.Nonempty s → Prop
h₀ : ∀ (a : α), p {a} (_ : Finset.Nonempty {a})
h₁ :
  ∀ ⦃a : α⦄ (s : Finset α) (h : ¬a ∈ s) (hs : Finset.Nonempty s),
    p s hs → p (cons a s h) (_ : Finset.Nonempty (cons a s h))
s : Finset α
hs✝ : Finset.Nonempty s
a : α
t : Finset α
ha : ¬a ∈ t
h : ∀ (hs : Finset.Nonempty t), p t hs
hs : Finset.Nonempty (cons a t ha)
⊢ p (cons a t ha) hs

tactic: exact (not_nonempty_empty hs).elim
state_before: case empty
α✝ : Type ?u.117523
β : Type ?u.117526
γ : Type ?u.117529
inst✝ : DecidableEq α✝
s✝ t u v : Finset α✝
a b : α✝
α : Type u_1
p : (s : Finset α) → Finset.Nonempty s → Prop
h₀ : ∀ (a : α), p {a} (_ : Finset.Nonempty {a})
h₁ :
  ∀ ⦃a : α⦄ (s : Finset α) (h : ¬a ∈ s) (hs : Finset.Nonempty s),
    p s hs → p (cons a s h) (_ : Finset.Nonempty (cons a s h))
s : Finset α
hs✝ : Finset.Nonempty s
hs : Finset.Nonempty ∅
⊢ p ∅ hs

tactic: exact h₀ a
state_before: case cons.inl
α✝ : Type ?u.117523
β : Type ?u.117526
γ : Type ?u.117529
inst✝ : DecidableEq α✝
s✝ t u v : Finset α✝
a✝ b : α✝
α : Type u_1
p : (s : Finset α) → Finset.Nonempty s → Prop
h₀ : ∀ (a : α), p {a} (_ : Finset.Nonempty {a})
h₁ :
  ∀ ⦃a : α⦄ (s : Finset α) (h : ¬a ∈ s) (hs : Finset.Nonempty s),
    p s hs → p (cons a s h) (_ : Finset.Nonempty (cons a s h))
s : Finset α
hs✝ : Finset.Nonempty s
a : α
ha : ¬a ∈ ∅
h : ∀ (hs : Finset.Nonempty ∅), p ∅ hs
hs : Finset.Nonempty (cons a ∅ ha)
⊢ p (cons a ∅ ha) hs

tactic: exact h₁ t ha ht (h ht)
state_before: case cons.inr
α✝ : Type ?u.117523
β : Type ?u.117526
γ : Type ?u.117529
inst✝ : DecidableEq α✝
s✝ t✝ u v : Finset α✝
a✝ b : α✝
α : Type u_1
p : (s : Finset α) → Finset.Nonempty s → Prop
h₀ : ∀ (a : α), p {a} (_ : Finset.Nonempty {a})
h₁ :
  ∀ ⦃a : α⦄ (s : Finset α) (h : ¬a ∈ s) (hs : Finset.Nonempty s),
    p s hs → p (cons a s h) (_ : Finset.Nonempty (cons a s h))
s : Finset α
hs✝ : Finset.Nonempty s
a : α
t : Finset α
ha : ¬a ∈ t
h : ∀ (hs : Finset.Nonempty t), p t hs
hs : Finset.Nonempty (cons a t ha)
ht : Finset.Nonempty t
⊢ p (cons a t ha) hs