tasksource/leandojo huggingface dataset:
Theorem: Filter.hasBasis_biInf_principal
File: Mathlib/Order/Filter/Bases.lean

tactic: refine' mem_biInf_of_directed _ ne
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.64418
ι : Sort ?u.64421
ι' : Sort ?u.64424
l l' : Filter α
p : ι → Prop
s✝ : ι → Set α
t✝ : Set α
i : ι
p' : ι' → Prop
s' : ι' → Set α
i' : ι'
s : β → Set α
S : Set β
h : DirectedOn (s ⁻¹'o fun x x_1 => x ≥ x_1) S
ne : Set.Nonempty S
t : Set α
⊢ (t ∈ ⨅ (i : β) (_ : i ∈ S), 𝓟 (s i)) ↔ ∃ i, i ∈ S ∧ s i ⊆ t

tactic: rw [directedOn_iff_directed, ← directed_comp] at h ⊢
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.64418
ι : Sort ?u.64421
ι' : Sort ?u.64424
l l' : Filter α
p : ι → Prop
s✝ : ι → Set α
t✝ : Set α
i : ι
p' : ι' → Prop
s' : ι' → Set α
i' : ι'
s : β → Set α
S : Set β
h : DirectedOn (s ⁻¹'o fun x x_1 => x ≥ x_1) S
ne : Set.Nonempty S
t : Set α
⊢ DirectedOn ((fun i => 𝓟 (s i)) ⁻¹'o fun x x_1 => x ≥ x_1) S

tactic: refine' h.mono_comp _
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.64418
ι : Sort ?u.64421
ι' : Sort ?u.64424
l l' : Filter α
p : ι → Prop
s✝ : ι → Set α
t✝ : Set α
i : ι
p' : ι' → Prop
s' : ι' → Set α
i' : ι'
s : β → Set α
S : Set β
h : Directed (fun x x_1 => x ≥ x_1) (s ∘ Subtype.val)
ne : Set.Nonempty S
t : Set α
⊢ Directed (fun x x_1 => x ≥ x_1) ((fun i => 𝓟 (s i)) ∘ Subtype.val)

tactic: exact fun _ _ => principal_mono.2
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.64418
ι : Sort ?u.64421
ι' : Sort ?u.64424
l l' : Filter α
p : ι → Prop
s✝ : ι → Set α
t✝ : Set α
i : ι
p' : ι' → Prop
s' : ι' → Set α
i' : ι'
s : β → Set α
S : Set β
h : Directed (fun x x_1 => x ≥ x_1) (s ∘ Subtype.val)
ne : Set.Nonempty S
t : Set α
⊢ ∀ ⦃x y : Set α⦄, x ≥ y → 𝓟 x ≥ 𝓟 y
Theorem: Finset.preimage_univ
File: Mathlib/Data/Finset/Preimage.lean

tactic: simp
state_before: α : Type u
β : Type v
ι : Sort w
γ : Type x
f : α → β
inst✝¹ : Fintype α
inst✝ : Fintype β
hf : InjOn f (f ⁻¹' ↑univ)
⊢ ↑(preimage univ f hf) = ↑univ
Theorem: Commute.mul_inv
File: Mathlib/Algebra/Group/Commute.lean

tactic: rw [hab.eq, mul_inv_rev]
state_before: G : Type u_1
inst✝ : DivisionMonoid G
a b c d : G
hab : Commute a b
⊢ (a * b)⁻¹ = a⁻¹ * b⁻¹
Theorem: Polynomial.bernoulli_succ_eval
File: Mathlib/NumberTheory/BernoulliPolynomials.lean

tactic: apply eq_add_of_sub_eq'
state_before: n p : ℕ
⊢ eval (↑n) (bernoulli (succ p)) = _root_.bernoulli (succ p) + (↑p + 1) * ∑ k in range n, ↑k ^ p

tactic: rw [sum_range_pow_eq_bernoulli_sub]
state_before: case h
n p : ℕ
⊢ eval (↑n) (bernoulli (succ p)) - _root_.bernoulli (succ p) = (↑p + 1) * ∑ k in range n, ↑k ^ p
Theorem: Qpf.suppPreservation_iff_uniform
File: Mathlib/Data/QPF/Univariate/Basic.lean

tactic: constructor
state_before: F : Type u → Type u
inst✝ : Functor F
q : Qpf F
⊢ SuppPreservation ↔ IsUniform

tactic: intro h α a a' f f' h'
state_before: case mp
F : Type u → Type u
inst✝ : Functor F
q : Qpf F
⊢ SuppPreservation → IsUniform

tactic: rw [← PFunctor.supp_eq, ← PFunctor.supp_eq, ← h, h', h]
state_before: case mp
F : Type u → Type u
inst✝ : Functor F
q : Qpf F
h : SuppPreservation
α : Type u
a a' : (P F).A
f : PFunctor.B (P F) a → α
f' : PFunctor.B (P F) a' → α
h' : abs { fst := a, snd := f } = abs { fst := a', snd := f' }
⊢ f '' univ = f' '' univ

tactic: rintro h α ⟨a, f⟩
state_before: case mpr
F : Type u → Type u
inst✝ : Functor F
q : Qpf F
⊢ IsUniform → SuppPreservation

tactic: rwa [supp_eq_of_isUniform, PFunctor.supp_eq]
state_before: case mpr.mk
F : Type u → Type u
inst✝ : Functor F
q : Qpf F
h : IsUniform
α : Type u
a : (P F).A
f : PFunctor.B (P F) a → α
⊢ supp (abs { fst := a, snd := f }) = supp { fst := a, snd := f }
Theorem: EulerSine.integral_cos_mul_cos_pow
File: Mathlib/Analysis/SpecialFunctions/Trigonometric/EulerSineProd.lean

tactic: have nne : (n : ℂ) ≠ 0 := by
  contrapose! hn; rw [Nat.cast_eq_zero] at hn ; rw [hn]; exact zero_lt_two
state_before: z : ℂ
n : ℕ
hn : 2 ≤ n
hz : z ≠ 0
⊢ ((1 - 4 * z ^ 2 / ↑n ^ 2) * ∫ (x : ℝ) in 0 ..π / 2, Complex.cos (2 * z * ↑x) * ↑(cos x) ^ n) =
    (↑n - 1) / ↑n * ∫ (x : ℝ) in 0 ..π / 2, Complex.cos (2 * z * ↑x) * ↑(cos x) ^ (n - 2)

tactic: have := integral_cos_mul_cos_pow_aux hn hz
state_before: z : ℂ
n : ℕ
hn : 2 ≤ n
hz : z ≠ 0
nne : ↑n ≠ 0
⊢ ((1 - 4 * z ^ 2 / ↑n ^ 2) * ∫ (x : ℝ) in 0 ..π / 2, Complex.cos (2 * z * ↑x) * ↑(cos x) ^ n) =
    (↑n - 1) / ↑n * ∫ (x : ℝ) in 0 ..π / 2, Complex.cos (2 * z * ↑x) * ↑(cos x) ^ (n - 2)

tactic: rw [integral_sin_mul_sin_mul_cos_pow_eq hn hz, sub_eq_neg_add, mul_add, ← sub_eq_iff_eq_add]
  at this
state_before: z : ℂ
n : ℕ
hn : 2 ≤ n
hz : z ≠ 0
nne : ↑n ≠ 0
this :
  (∫ (x : ℝ) in 0 ..π / 2, Complex.cos (2 * z * ↑x) * ↑(cos x) ^ n) =
    ↑n / (2 * z) * ∫ (x : ℝ) in 0 ..π / 2, Complex.sin (2 * z * ↑x) * ↑(sin x) * ↑(cos x) ^ (n - 1)
⊢ ((1 - 4 * z ^ 2 / ↑n ^ 2) * ∫ (x : ℝ) in 0 ..π / 2, Complex.cos (2 * z * ↑x) * ↑(cos x) ^ n) =
    (↑n - 1) / ↑n * ∫ (x : ℝ) in 0 ..π / 2, Complex.cos (2 * z * ↑x) * ↑(cos x) ^ (n - 2)

tactic: convert congr_arg (fun u : ℂ => -u * (2 * z) ^ 2 / n ^ 2) this using 1 <;> field_simp <;> ring
state_before: z : ℂ
n : ℕ
hn : 2 ≤ n
hz : z ≠ 0
nne : ↑n ≠ 0
this :
  (∫ (x : ℝ) in 0 ..π / 2, Complex.cos (2 * z * ↑x) * ↑(cos x) ^ n) -
      ↑n / (2 * z) * (↑n / (2 * z) * ∫ (x : ℝ) in 0 ..π / 2, Complex.cos (2 * z * ↑x) * ↑(cos x) ^ n) =
    ↑n / (2 * z) * -((↑n - 1) / (2 * z) * ∫ (x : ℝ) in 0 ..π / 2, Complex.cos (2 * z * ↑x) * ↑(cos x) ^ (n - 2))
⊢ ((1 - 4 * z ^ 2 / ↑n ^ 2) * ∫ (x : ℝ) in 0 ..π / 2, Complex.cos (2 * z * ↑x) * ↑(cos x) ^ n) =
    (↑n - 1) / ↑n * ∫ (x : ℝ) in 0 ..π / 2, Complex.cos (2 * z * ↑x) * ↑(cos x) ^ (n - 2)

tactic: contrapose! hn
state_before: z : ℂ
n : ℕ
hn : 2 ≤ n
hz : z ≠ 0
⊢ ↑n ≠ 0

tactic: rw [Nat.cast_eq_zero] at hn
state_before: z : ℂ
n : ℕ
hz : z ≠ 0
hn : ↑n = 0
⊢ n < 2

tactic: rw [hn]
state_before: z : ℂ
n : ℕ
hz : z ≠ 0
hn : n = 0
⊢ n < 2

tactic: exact zero_lt_two
state_before: z : ℂ
n : ℕ
hz : z ≠ 0
hn : n = 0
⊢ 0 < 2
Theorem: Dfinsupp.mk_sub
File: Mathlib/Data/Dfinsupp/Basic.lean

tactic: simp only [sub_apply, mk_apply]
state_before: ι : Type u
γ : Type w
β : ι → Type v
β₁ : ι → Type v₁
β₂ : ι → Type v₂
dec : DecidableEq ι
inst✝ : (i : ι) → AddGroup (β i)
s : Finset ι
x y : (i : ↑↑s) → β ↑i
i : ι
⊢ ↑(mk s (x - y)) i = ↑(mk s x - mk s y) i

tactic: split_ifs <;> [rfl; rw [sub_zero]]
state_before: ι : Type u
γ : Type w
β : ι → Type v
β₁ : ι → Type v₁
β₂ : ι → Type v₂
dec : DecidableEq ι
inst✝ : (i : ι) → AddGroup (β i)
s : Finset ι
x y : (i : ↑↑s) → β ↑i
i : ι
⊢ (if H : i ∈ s then (x - y) { val := i, property := H } else 0) =
    (if H : i ∈ s then x { val := i, property := H } else 0) - if H : i ∈ s then y { val := i, property := H } else 0
Theorem: hasDerivAtFilter_iff_tendsto_slope
File: Mathlib/Analysis/Calculus/Deriv/Slope.lean

tactic: simp only [hasDerivAtFilter_iff_tendsto, ← norm_inv, ← norm_smul,
  ← tendsto_zero_iff_norm_tendsto_zero, slope_def_module, smul_sub]
state_before: 𝕜 : Type u
inst✝⁴ : NontriviallyNormedField 𝕜
F : Type v
inst✝³ : NormedAddCommGroup F
inst✝² : NormedSpace 𝕜 F
E : Type w
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace 𝕜 E
f f₀ f₁ g : 𝕜 → F
f' f₀' f₁' g' : F
x✝ : 𝕜
s t : Set 𝕜
L✝ L₁ L₂ : Filter 𝕜
x : 𝕜
L : Filter 𝕜
⊢ HasDerivAtFilter f f' x L ↔ Tendsto (fun y => slope f x y - (y - x)⁻¹ • (y - x) • f') L (𝓝 0)

tactic: simp
state_before: 𝕜 : Type u
inst✝⁴ : NontriviallyNormedField 𝕜
F : Type v
inst✝³ : NormedAddCommGroup F
inst✝² : NormedSpace 𝕜 F
E : Type w
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace 𝕜 E
f f₀ f₁ g : 𝕜 → F
f' f₀' f₁' g' : F
x✝ : 𝕜
s t : Set 𝕜
L✝ L₁ L₂ : Filter 𝕜
x : 𝕜
L : Filter 𝕜
⊢ ∀ (x_1 : 𝕜), ¬x_1 ∈ {x}ᶜ → slope f x x_1 - (x_1 - x)⁻¹ • (x_1 - x) • f' = 0

tactic: refine (EqOn.eventuallyEq fun y hy ↦ ?_).filter_mono inf_le_right
state_before: 𝕜 : Type u
inst✝⁴ : NontriviallyNormedField 𝕜
F : Type v
inst✝³ : NormedAddCommGroup F
inst✝² : NormedSpace 𝕜 F
E : Type w
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace 𝕜 E
f f₀ f₁ g : 𝕜 → F
f' f₀' f₁' g' : F
x✝ : 𝕜
s t : Set 𝕜
L✝ L₁ L₂ : Filter 𝕜
x : 𝕜
L : Filter 𝕜
⊢ (fun y => slope f x y - (y - x)⁻¹ • (y - x) • f') =ᶠ[L ⊓ 𝓟 ({x}ᶜ)] fun y => slope f x y - f'

tactic: rw [inv_smul_smul₀ (sub_ne_zero.2 hy) f']
state_before: 𝕜 : Type u
inst✝⁴ : NontriviallyNormedField 𝕜
F : Type v
inst✝³ : NormedAddCommGroup F
inst✝² : NormedSpace 𝕜 F
E : Type w
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace 𝕜 E
f f₀ f₁ g : 𝕜 → F
f' f₀' f₁' g' : F
x✝ : 𝕜
s t : Set 𝕜
L✝ L₁ L₂ : Filter 𝕜
x : 𝕜
L : Filter 𝕜
y : 𝕜
hy : y ∈ {x}ᶜ
⊢ slope f x y - (y - x)⁻¹ • (y - x) • f' = slope f x y - f'

tactic: rw [← nhds_translation_sub f', tendsto_comap_iff]
state_before: 𝕜 : Type u
inst✝⁴ : NontriviallyNormedField 𝕜
F : Type v
inst✝³ : NormedAddCommGroup F
inst✝² : NormedSpace 𝕜 F
E : Type w
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace 𝕜 E
f f₀ f₁ g : 𝕜 → F
f' f₀' f₁' g' : F
x✝ : 𝕜
s t : Set 𝕜
L✝ L₁ L₂ : Filter 𝕜
x : 𝕜
L : Filter 𝕜
⊢ Tendsto (fun y => slope f x y - f') (L ⊓ 𝓟 ({x}ᶜ)) (𝓝 0) ↔ Tendsto (slope f x) (L ⊓ 𝓟 ({x}ᶜ)) (𝓝 f')

tactic: rfl
state_before: 𝕜 : Type u
inst✝⁴ : NontriviallyNormedField 𝕜
F : Type v
inst✝³ : NormedAddCommGroup F
inst✝² : NormedSpace 𝕜 F
E : Type w
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace 𝕜 E
f f₀ f₁ g : 𝕜 → F
f' f₀' f₁' g' : F
x✝ : 𝕜
s t : Set 𝕜
L✝ L₁ L₂ : Filter 𝕜
x : 𝕜
L : Filter 𝕜
⊢ Tendsto (fun y => slope f x y - f') (L ⊓ 𝓟 ({x}ᶜ)) (𝓝 0) ↔
    Tendsto ((fun x => x - f') ∘ slope f x) (L ⊓ 𝓟 ({x}ᶜ)) (𝓝 0)
Theorem: TypeVec.eq_nilFun
File: Mathlib/Data/TypeVec.lean

tactic: ext x
state_before: n : ℕ
α : TypeVec 0
β : TypeVec 0
f : α ⟹ β
⊢ f = nilFun

tactic: cases x
state_before: case a.h
n : ℕ
α : TypeVec 0
β : TypeVec 0
f : α ⟹ β
x : Fin2 0
x✝ : α x
⊢ f x x✝ = nilFun x x✝
Theorem: Linarith.le_of_le_of_eq
File: Mathlib/Tactic/Linarith/Lemmas.lean

tactic: simp [*]
state_before: α : Type u_1
inst✝ : OrderedSemiring α
a b : α
ha : a ≤ 0
hb : b = 0
⊢ a + b ≤ 0
Theorem: CauSeq.sup_lt
File: Mathlib/Data/Real/CauSeq.lean

tactic: obtain ⟨⟨εa, εa0, ia, ha⟩, ⟨εb, εb0, ib, hb⟩⟩ := ha, hb
state_before: α : Type u_1
inst✝ : LinearOrderedField α
a b c : CauSeq α abs
ha : a < c
hb : b < c
⊢ a ⊔ b < c

tactic: refine' ⟨εa ⊓ εb, lt_inf_iff.mpr ⟨εa0, εb0⟩, ia ⊔ ib, fun i hi => _⟩
state_before: case intro.intro.intro.intro.intro.intro
α : Type u_1
inst✝ : LinearOrderedField α
a b c : CauSeq α abs
εa : α
εa0 : εa > 0
ia : ℕ
ha : ∀ (j : ℕ), j ≥ ia → εa ≤ ↑(c - a) j
εb : α
εb0 : εb > 0
ib : ℕ
hb : ∀ (j : ℕ), j ≥ ib → εb ≤ ↑(c - b) j
⊢ a ⊔ b < c

tactic: have := min_le_min (ha _ (sup_le_iff.mp hi).1) (hb _ (sup_le_iff.mp hi).2)
state_before: case intro.intro.intro.intro.intro.intro
α : Type u_1
inst✝ : LinearOrderedField α
a b c : CauSeq α abs
εa : α
εa0 : εa > 0
ia : ℕ
ha : ∀ (j : ℕ), j ≥ ia → εa ≤ ↑(c - a) j
εb : α
εb0 : εb > 0
ib : ℕ
hb : ∀ (j : ℕ), j ≥ ib → εb ≤ ↑(c - b) j
i : ℕ
hi : i ≥ ia ⊔ ib
⊢ εa ⊓ εb ≤ ↑(c - a ⊔ b) i

tactic: exact this.trans_eq (min_sub_sub_left _ _ _)
state_before: case intro.intro.intro.intro.intro.intro
α : Type u_1
inst✝ : LinearOrderedField α
a b c : CauSeq α abs
εa : α
εa0 : εa > 0
ia : ℕ
ha : ∀ (j : ℕ), j ≥ ia → εa ≤ ↑(c - a) j
εb : α
εb0 : εb > 0
ib : ℕ
hb : ∀ (j : ℕ), j ≥ ib → εb ≤ ↑(c - b) j
i : ℕ
hi : i ≥ ia ⊔ ib
this : min εa εb ≤ min (↑(c - a) i) (↑(c - b) i)
⊢ εa ⊓ εb ≤ ↑(c - a ⊔ b) i
Theorem: List.take_all_of_le
File: Mathlib/Data/List/Basic.lean

tactic: change a :: take n l = a :: l
state_before: ι : Type ?u.157660
α : Type u
β : Type v
γ : Type w
δ : Type x
l₁ l₂ : List α
n : ℕ
a : α
l : List α
h : length (a :: l) ≤ n + 1
⊢ take (n + 1) (a :: l) = a :: l

tactic: rw [take_all_of_le (le_of_succ_le_succ h)]
state_before: ι : Type ?u.157660
α : Type u
β : Type v
γ : Type w
δ : Type x
l₁ l₂ : List α
n : ℕ
a : α
l : List α
h : length (a :: l) ≤ n + 1
⊢ a :: take n l = a :: l
Theorem: neg_one_pow_eq_or
File: Mathlib/Algebra/GroupPower/Ring.lean

tactic: rw [pow_succ, h, neg_one_mul, neg_neg]
state_before: R : Type u_1
S : Type ?u.92208
M : Type ?u.92211
inst✝¹ : Monoid R
inst✝ : HasDistribNeg R
n : ℕ
h : (-1) ^ n = -1
⊢ (-1) ^ (n + 1) = 1

tactic: rw [pow_succ, h, mul_one]
state_before: R : Type u_1
S : Type ?u.92208
M : Type ?u.92211
inst✝¹ : Monoid R
inst✝ : HasDistribNeg R
n : ℕ
h : (-1) ^ n = 1
⊢ (-1) ^ (n + 1) = -1
Theorem: imageToKernel'_kernelSubobjectIso
File: Mathlib/Algebra/Homology/ImageToKernel.lean

tactic: ext
state_before: ι : Type ?u.277955
V : Type u
inst✝³ : Category V
inst✝² : HasZeroMorphisms V
A B C : V
f : A ⟶ B
g : B ⟶ C
w✝ : f ≫ g = 0
inst✝¹ : HasKernels V
inst✝ : HasImages V
w : f ≫ g = 0
⊢ imageToKernel' f g w ≫ (kernelSubobjectIso g).inv = (imageSubobjectIso f).inv ≫ imageToKernel f g w

tactic: simp [imageToKernel']
state_before: case h
ι : Type ?u.277955
V : Type u
inst✝³ : Category V
inst✝² : HasZeroMorphisms V
A B C : V
f : A ⟶ B
g : B ⟶ C
w✝ : f ≫ g = 0
inst✝¹ : HasKernels V
inst✝ : HasImages V
w : f ≫ g = 0
⊢ (imageToKernel' f g w ≫ (kernelSubobjectIso g).inv) ≫ Subobject.arrow (kernelSubobject g) =
    ((imageSubobjectIso f).inv ≫ imageToKernel f g w) ≫ Subobject.arrow (kernelSubobject g)
Theorem: frontier_Ici'
File: Mathlib/Topology/Order/Basic.lean

tactic: simp [frontier, ha]
state_before: α : Type u
β : Type v
γ : Type w
inst✝³ : TopologicalSpace α
inst✝² : LinearOrder α
inst✝¹ : OrderTopology α
inst✝ : DenselyOrdered α
a✝ b : α
s : Set α
a : α
ha : Set.Nonempty (Iio a)
⊢ frontier (Ici a) = {a}
Theorem: NNReal.summable_condensed_iff
File: Mathlib/Analysis/PSeries.lean

tactic: simp only [← ENNReal.tsum_coe_ne_top_iff_summable, Ne.def, not_iff_not, ENNReal.coe_mul,
  ENNReal.coe_pow, ENNReal.coe_two]
state_before: f : ℕ → ℝ≥0
hf : ∀ ⦃m n : ℕ⦄, 0 < m → m ≤ n → f n ≤ f m
⊢ (Summable fun k => 2 ^ k * f (2 ^ k)) ↔ Summable f

tactic: constructor <;> intro h
state_before: f : ℕ → ℝ≥0
hf : ∀ ⦃m n : ℕ⦄, 0 < m → m ≤ n → f n ≤ f m
⊢ (∑' (b : ℕ), 2 ^ b * ↑(f (2 ^ b))) = ⊤ ↔ (∑' (b : ℕ), ↑(f b)) = ⊤

tactic: replace hf : ∀ m n, 1 < m → m ≤ n → (f n : ℝ≥0∞) ≤ f m := fun m n hm hmn =>
  ENNReal.coe_le_coe.2 (hf (zero_lt_one.trans hm) hmn)
state_before: case mp
f : ℕ → ℝ≥0
hf : ∀ ⦃m n : ℕ⦄, 0 < m → m ≤ n → f n ≤ f m
h : (∑' (b : ℕ), 2 ^ b * ↑(f (2 ^ b))) = ⊤
⊢ (∑' (b : ℕ), ↑(f b)) = ⊤

tactic: simpa [h, ENNReal.add_eq_top, ENNReal.mul_eq_top] using ENNReal.tsum_condensed_le hf
state_before: case mp
f : ℕ → ℝ≥0
h : (∑' (b : ℕ), 2 ^ b * ↑(f (2 ^ b))) = ⊤
hf : ∀ (m n : ℕ), 1 < m → m ≤ n → ↑(f n) ≤ ↑(f m)
⊢ (∑' (b : ℕ), ↑(f b)) = ⊤

tactic: replace hf : ∀ m n, 0 < m → m ≤ n → (f n : ℝ≥0∞) ≤ f m := fun m n hm hmn =>
  ENNReal.coe_le_coe.2 (hf hm hmn)
state_before: case mpr
f : ℕ → ℝ≥0
hf : ∀ ⦃m n : ℕ⦄, 0 < m → m ≤ n → f n ≤ f m
h : (∑' (b : ℕ), ↑(f b)) = ⊤
⊢ (∑' (b : ℕ), 2 ^ b * ↑(f (2 ^ b))) = ⊤

tactic: simpa [h, ENNReal.add_eq_top] using ENNReal.le_tsum_condensed hf
state_before: case mpr
f : ℕ → ℝ≥0
h : (∑' (b : ℕ), ↑(f b)) = ⊤
hf : ∀ (m n : ℕ), 0 < m → m ≤ n → ↑(f n) ≤ ↑(f m)
⊢ (∑' (b : ℕ), 2 ^ b * ↑(f (2 ^ b))) = ⊤
Theorem: Set.singleton_op_unop
File: Mathlib/Data/Set/Opposite.lean

tactic: ext
state_before: α : Type u_1
x : α
⊢ Set.unop {op x} = {x}

tactic: constructor
state_before: case h
α : Type u_1
x x✝ : α
⊢ x✝ ∈ Set.unop {op x} ↔ x✝ ∈ {x}

tactic: . apply op_injective
state_before: case h.mp
α : Type u_1
x x✝ : α
⊢ x✝ ∈ Set.unop {op x} → x✝ ∈ {x}

case h.mpr
α : Type u_1
x x✝ : α
⊢ x✝ ∈ {x} → x✝ ∈ Set.unop {op x}

tactic: . apply unop_injective
state_before: case h.mpr
α : Type u_1
x x✝ : α
⊢ x✝ ∈ {x} → x✝ ∈ Set.unop {op x}

tactic: apply op_injective
state_before: case h.mp
α : Type u_1
x x✝ : α
⊢ x✝ ∈ Set.unop {op x} → x✝ ∈ {x}

tactic: apply unop_injective
state_before: case h.mpr
α : Type u_1
x x✝ : α
⊢ x✝ ∈ {x} → x✝ ∈ Set.unop {op x}
Theorem: MeasureTheory.norm_setToFun_le_mul_norm'
File: Mathlib/MeasureTheory/Integral/SetToL1.lean

tactic: rw [L1.setToFun_eq_setToL1]
state_before: α : Type u_1
E : Type u_2
F : Type u_3
F' : Type ?u.1690915
G : Type ?u.1690918
𝕜 : Type ?u.1690921
p : ℝ≥0∞
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace ℝ E
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace ℝ F
inst✝³ : NormedAddCommGroup F'
inst✝² : NormedSpace ℝ F'
inst✝¹ : NormedAddCommGroup G
m : MeasurableSpace α
μ : Measure α
inst✝ : CompleteSpace F
T T' T'' : Set α → E →L[ℝ] F
C C' C'' : ℝ
f✝ g : α → E
hT : DominatedFinMeasAdditive μ T C
f : { x // x ∈ Lp E 1 }
⊢ ‖setToFun μ T hT ↑↑f‖ ≤ max C 0 * ‖f‖

tactic: exact L1.norm_setToL1_le_mul_norm' hT f
state_before: α : Type u_1
E : Type u_2
F : Type u_3
F' : Type ?u.1690915
G : Type ?u.1690918
𝕜 : Type ?u.1690921
p : ℝ≥0∞
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace ℝ E
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace ℝ F
inst✝³ : NormedAddCommGroup F'
inst✝² : NormedSpace ℝ F'
inst✝¹ : NormedAddCommGroup G
m : MeasurableSpace α
μ : Measure α
inst✝ : CompleteSpace F
T T' T'' : Set α → E →L[ℝ] F
C C' C'' : ℝ
f✝ g : α → E
hT : DominatedFinMeasAdditive μ T C
f : { x // x ∈ Lp E 1 }
⊢ ‖↑(L1.setToL1 hT) f‖ ≤ max C 0 * ‖f‖
Theorem: List.prod_hom₂
File: Mathlib/Data/List/BigOperators/Basic.lean

tactic: simp only [prod, foldl_map]
state_before: ι : Type u_1
α : Type ?u.28780
M : Type u_3
N : Type u_4
P : Type u_2
M₀ : Type ?u.28792
G : Type ?u.28795
R : Type ?u.28798
inst✝² : Monoid M
inst✝¹ : Monoid N
inst✝ : Monoid P
l✝ l₁ l₂ : List M
a : M
l : List ι
f : M → N → P
hf : ∀ (a b : M) (c d : N), f (a * b) (c * d) = f a c * f b d
hf' : f 1 1 = 1
f₁ : ι → M
f₂ : ι → N
⊢ prod (map (fun i => f (f₁ i) (f₂ i)) l) = f (prod (map f₁ l)) (prod (map f₂ l))

tactic: rw [← l.foldl_hom₂ (fun a b => f a b), hf']
state_before: ι : Type u_1
α : Type ?u.28780
M : Type u_3
N : Type u_4
P : Type u_2
M₀ : Type ?u.28792
G : Type ?u.28795
R : Type ?u.28798
inst✝² : Monoid M
inst✝¹ : Monoid N
inst✝ : Monoid P
l✝ l₁ l₂ : List M
a : M
l : List ι
f : M → N → P
hf : ∀ (a b : M) (c d : N), f (a * b) (c * d) = f a c * f b d
hf' : f 1 1 = 1
f₁ : ι → M
f₂ : ι → N
⊢ foldl (fun x y => x * f (f₁ y) (f₂ y)) 1 l = f (foldl (fun x y => x * f₁ y) 1 l) (foldl (fun x y => x * f₂ y) 1 l)

tactic: intros
state_before: case h
ι : Type u_1
α : Type ?u.28780
M : Type u_3
N : Type u_4
P : Type u_2
M₀ : Type ?u.28792
G : Type ?u.28795
R : Type ?u.28798
inst✝² : Monoid M
inst✝¹ : Monoid N
inst✝ : Monoid P
l✝ l₁ l₂ : List M
a : M
l : List ι
f : M → N → P
hf : ∀ (a b : M) (c d : N), f (a * b) (c * d) = f a c * f b d
hf' : f 1 1 = 1
f₁ : ι → M
f₂ : ι → N
⊢ ∀ (a : M) (b : N) (i : ι), f (a * f₁ i) (b * f₂ i) = f a b * f (f₁ i) (f₂ i)

tactic: exact hf _ _ _ _
state_before: case h
ι : Type u_1
α : Type ?u.28780
M : Type u_3
N : Type u_4
P : Type u_2
M₀ : Type ?u.28792
G : Type ?u.28795
R : Type ?u.28798
inst✝² : Monoid M
inst✝¹ : Monoid N
inst✝ : Monoid P
l✝ l₁ l₂ : List M
a : M
l : List ι
f : M → N → P
hf : ∀ (a b : M) (c d : N), f (a * b) (c * d) = f a c * f b d
hf' : f 1 1 = 1
f₁ : ι → M
f₂ : ι → N
a✝ : M
b✝ : N
i✝ : ι
⊢ f (a✝ * f₁ i✝) (b✝ * f₂ i✝) = f a✝ b✝ * f (f₁ i✝) (f₂ i✝)
Theorem: CategoryTheory.Limits.equalizerSubobject_arrow'
File: Mathlib/CategoryTheory/Subobject/Limits.lean

tactic: simp [equalizerSubobjectIso]
state_before: C : Type u
inst✝¹ : Category C
X Y Z : C
f g : X ⟶ Y
inst✝ : HasEqualizer f g
⊢ (equalizerSubobjectIso f g).inv ≫ arrow (equalizerSubobject f g) = equalizer.ι f g
Theorem: NormedAddGroupHom.opNorm_le_of_lipschitz
File: Mathlib/Analysis/Normed/Group/Hom.lean

tactic: simpa only [dist_zero_right, map_zero] using hf.dist_le_mul x 0
state_before: V : Type ?u.236326
V₁ : Type u_1
V₂ : Type u_2
V₃ : Type ?u.236335
inst✝³ : SeminormedAddCommGroup V
inst✝² : SeminormedAddCommGroup V₁
inst✝¹ : SeminormedAddCommGroup V₂
inst✝ : SeminormedAddCommGroup V₃
f✝ g f : NormedAddGroupHom V₁ V₂
K : ℝ≥0
hf : LipschitzWith K ↑f
x : V₁
⊢ ‖↑f x‖ ≤ ↑K * ‖x‖
Theorem: List.filterMap_filterMap
File: Std/Data/List/Lemmas.lean

tactic: induction l with
| nil => rfl
| cons a l IH => cases h : f a <;> simp [*]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
f : α → Option β
g : β → Option γ
l : List α
⊢ filterMap g (filterMap f l) = filterMap (fun x => Option.bind (f x) g) l

tactic: rfl
state_before: case nil
α : Type u_1
β : Type u_2
γ : Type u_3
f : α → Option β
g : β → Option γ
⊢ filterMap g (filterMap f []) = filterMap (fun x => Option.bind (f x) g) []

tactic: cases h : f a <;> simp [*]
state_before: case cons
α : Type u_1
β : Type u_2
γ : Type u_3
f : α → Option β
g : β → Option γ
a : α
l : List α
IH : filterMap g (filterMap f l) = filterMap (fun x => Option.bind (f x) g) l
⊢ filterMap g (filterMap f (a :: l)) = filterMap (fun x => Option.bind (f x) g) (a :: l)
Theorem: MonotoneOn.integrableOn_isCompact
File: Mathlib/MeasureTheory/Function/LocallyIntegrable.lean

tactic: obtain rfl | h := s.eq_empty_or_nonempty
state_before: X : Type u_1
Y : Type ?u.1878962
E : Type u_2
R : Type ?u.1878968
inst✝¹¹ : MeasurableSpace X
inst✝¹⁰ : TopologicalSpace X
inst✝⁹ : MeasurableSpace Y
inst✝⁸ : TopologicalSpace Y
inst✝⁷ : NormedAddCommGroup E
f : X → E
μ : MeasureTheory.Measure X
s : Set X
inst✝⁶ : BorelSpace X
inst✝⁵ : ConditionallyCompleteLinearOrder X
inst✝⁴ : ConditionallyCompleteLinearOrder E
inst✝³ : OrderTopology X
inst✝² : OrderTopology E
inst✝¹ : SecondCountableTopology E
inst✝ : IsFiniteMeasureOnCompacts μ
hs : IsCompact s
hmono : MonotoneOn f s
⊢ IntegrableOn f s

tactic: exact integrableOn_empty
state_before: case inl
X : Type u_1
Y : Type ?u.1878962
E : Type u_2
R : Type ?u.1878968
inst✝¹¹ : MeasurableSpace X
inst✝¹⁰ : TopologicalSpace X
inst✝⁹ : MeasurableSpace Y
inst✝⁸ : TopologicalSpace Y
inst✝⁷ : NormedAddCommGroup E
f : X → E
μ : MeasureTheory.Measure X
inst✝⁶ : BorelSpace X
inst✝⁵ : ConditionallyCompleteLinearOrder X
inst✝⁴ : ConditionallyCompleteLinearOrder E
inst✝³ : OrderTopology X
inst✝² : OrderTopology E
inst✝¹ : SecondCountableTopology E
inst✝ : IsFiniteMeasureOnCompacts μ
hs : IsCompact ∅
hmono : MonotoneOn f ∅
⊢ IntegrableOn f ∅

tactic: exact
  hmono.integrableOn_of_measure_ne_top (hs.isLeast_sInf h) (hs.isGreatest_sSup h)
    hs.measure_lt_top.ne hs.measurableSet
state_before: case inr
X : Type u_1
Y : Type ?u.1878962
E : Type u_2
R : Type ?u.1878968
inst✝¹¹ : MeasurableSpace X
inst✝¹⁰ : TopologicalSpace X
inst✝⁹ : MeasurableSpace Y
inst✝⁸ : TopologicalSpace Y
inst✝⁷ : NormedAddCommGroup E
f : X → E
μ : MeasureTheory.Measure X
s : Set X
inst✝⁶ : BorelSpace X
inst✝⁵ : ConditionallyCompleteLinearOrder X
inst✝⁴ : ConditionallyCompleteLinearOrder E
inst✝³ : OrderTopology X
inst✝² : OrderTopology E
inst✝¹ : SecondCountableTopology E
inst✝ : IsFiniteMeasureOnCompacts μ
hs : IsCompact s
hmono : MonotoneOn f s
h : Set.Nonempty s
⊢ IntegrableOn f s
Theorem: Lean.PersistentHashMap.size_set
File: src/lean/Lean/Data/PersistentHashMap.lean

tactic: simp [h]
state_before: α : Type u_1
β : Type u_2
ks : Array α
vs : Array β
h : Array.size ks = Array.size vs
i : Fin (Array.size ks)
j : Fin (Array.size vs)
k : α
v : β
⊢ Array.size (Array.set ks i k) = Array.size (Array.set vs j v)
Theorem: dist_center_homothety
File: Mathlib/Analysis/NormedSpace/AddTorsor.lean

tactic: rw [homothety_def, dist_eq_norm_vsub V]
state_before: α : Type ?u.5505
V : Type u_2
P : Type u_1
W : Type ?u.5514
Q : Type ?u.5517
inst✝⁸ : SeminormedAddCommGroup V
inst✝⁷ : PseudoMetricSpace P
inst✝⁶ : NormedAddTorsor V P
inst✝⁵ : NormedAddCommGroup W
inst✝⁴ : MetricSpace Q
inst✝³ : NormedAddTorsor W Q
𝕜 : Type u_3
inst✝² : NormedField 𝕜
inst✝¹ : NormedSpace 𝕜 V
inst✝ : NormedSpace 𝕜 W
p₁ p₂ : P
c : 𝕜
⊢ dist p₁ (↑(homothety p₁ c) p₂) = ‖c‖ * dist p₁ p₂

tactic: simp [norm_smul, ← dist_eq_norm_vsub V, dist_comm]
state_before: α : Type ?u.5505
V : Type u_2
P : Type u_1
W : Type ?u.5514
Q : Type ?u.5517
inst✝⁸ : SeminormedAddCommGroup V
inst✝⁷ : PseudoMetricSpace P
inst✝⁶ : NormedAddTorsor V P
inst✝⁵ : NormedAddCommGroup W
inst✝⁴ : MetricSpace Q
inst✝³ : NormedAddTorsor W Q
𝕜 : Type u_3
inst✝² : NormedField 𝕜
inst✝¹ : NormedSpace 𝕜 V
inst✝ : NormedSpace 𝕜 W
p₁ p₂ : P
c : 𝕜
⊢ ‖p₁ -ᵥ ↑(c • (AffineMap.id 𝕜 P -ᵥ const 𝕜 P p₁) +ᵥ const 𝕜 P p₁) p₂‖ = ‖c‖ * dist p₁ p₂
Theorem: Vector.map_id
File: Mathlib/Data/Vector/Basic.lean

tactic: simp only [List.map_id, Vector.toList_map]
state_before: n✝ : ℕ
α : Type u_1
n : ℕ
v : Vector α n
⊢ toList (map id v) = toList v
Theorem: Set.ncard_le_one_of_subsingleton
File: Mathlib/Data/Set/Ncard.lean

tactic: rw [ncard_eq_toFinset_card]
state_before: α : Type u_1
β : Type ?u.155682
s✝ t : Set α
a b x y : α
f : α → β
inst✝ : Subsingleton α
s : Set α
⊢ ncard s ≤ 1

tactic: exact Finset.card_le_one_of_subsingleton _
state_before: α : Type u_1
β : Type ?u.155682
s✝ t : Set α
a b x y : α
f : α → β
inst✝ : Subsingleton α
s : Set α
⊢ Finset.card (Finite.toFinset (_ : Set.Finite s)) ≤ 1