tasksource/leandojo huggingface dataset:
Theorem: Path.Homotopy.continuous_transAssocReparamAux
File: Mathlib/AlgebraicTopology/FundamentalGroupoid/Basic.lean

tactic: intro x hx
state_before: case refine'_9
X : Type u
Y : Type v
inst✝¹ : TopologicalSpace X
inst✝ : TopologicalSpace Y
x₀ x₁ : X
⊢ ∀ (x : ↑I), ↑x = 1 / 4 → 2 * ↑x = if ↑x ≤ 1 / 2 then ↑x + 1 / 4 else 1 / 2 * (↑x + 1)

tactic: simp [hx]
state_before: case refine'_9
X : Type u
Y : Type v
inst✝¹ : TopologicalSpace X
inst✝ : TopologicalSpace Y
x₀ x₁ : X
x : ↑I
hx : ↑x = 1 / 4
⊢ 2 * ↑x = if ↑x ≤ 1 / 2 then ↑x + 1 / 4 else 1 / 2 * (↑x + 1)

tactic: norm_num
state_before: case refine'_9
X : Type u
Y : Type v
inst✝¹ : TopologicalSpace X
inst✝ : TopologicalSpace Y
x₀ x₁ : X
x : ↑I
hx : ↑x = 1 / 4
⊢ 2 * 4⁻¹ = if 4⁻¹ ≤ 2⁻¹ then 4⁻¹ + 4⁻¹ else 2⁻¹ * (4⁻¹ + 1)
Theorem: EuclideanGeometry.inner_nonneg_of_dist_le_radius
File: Mathlib/Geometry/Euclidean/Sphere/Basic.lean

tactic: rcases inner_pos_or_eq_of_dist_le_radius hp₁ hp₂ with (h | rfl)
state_before: V : Type u_2
P : Type u_1
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
s : Sphere P
p₁ p₂ : P
hp₁ : p₁ ∈ s
hp₂ : dist p₂ s.center ≤ s.radius
⊢ 0 ≤ inner (p₁ -ᵥ p₂) (p₁ -ᵥ s.center)

tactic: exact h.le
state_before: case inl
V : Type u_2
P : Type u_1
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
s : Sphere P
p₁ p₂ : P
hp₁ : p₁ ∈ s
hp₂ : dist p₂ s.center ≤ s.radius
h : 0 < inner (p₁ -ᵥ p₂) (p₁ -ᵥ s.center)
⊢ 0 ≤ inner (p₁ -ᵥ p₂) (p₁ -ᵥ s.center)

tactic: simp
state_before: case inr
V : Type u_2
P : Type u_1
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
s : Sphere P
p₁ : P
hp₁ : p₁ ∈ s
hp₂ : dist p₁ s.center ≤ s.radius
⊢ 0 ≤ inner (p₁ -ᵥ p₁) (p₁ -ᵥ s.center)
Theorem: StieltjesFunction.length_Ioc
File: Mathlib/MeasureTheory/Measure/Stieltjes.lean

tactic: refine'
  le_antisymm (iInf_le_of_le a <| iInf₂_le b Subset.rfl)
    (le_iInf fun a' => le_iInf fun b' => le_iInf fun h => ENNReal.coe_le_coe.2 _)
state_before: f : StieltjesFunction
a b : ℝ
⊢ length f (Ioc a b) = ofReal (↑f b - ↑f a)

tactic: cases' le_or_lt b a with ab ab
state_before: f : StieltjesFunction
a b a' b' : ℝ
h : Ioc a b ⊆ Ioc a' b'
⊢ Real.toNNReal (↑f b - ↑f a) ≤ Real.toNNReal (↑f b' - ↑f a')

tactic: cases' (Ioc_subset_Ioc_iff ab).1 h with h₁ h₂
state_before: case inr
f : StieltjesFunction
a b a' b' : ℝ
h : Ioc a b ⊆ Ioc a' b'
ab : a < b
⊢ Real.toNNReal (↑f b - ↑f a) ≤ Real.toNNReal (↑f b' - ↑f a')

tactic: exact Real.toNNReal_le_toNNReal (sub_le_sub (f.mono h₁) (f.mono h₂))
state_before: case inr.intro
f : StieltjesFunction
a b a' b' : ℝ
h : Ioc a b ⊆ Ioc a' b'
ab : a < b
h₁ : b ≤ b'
h₂ : a' ≤ a
⊢ Real.toNNReal (↑f b - ↑f a) ≤ Real.toNNReal (↑f b' - ↑f a')

tactic: rw [Real.toNNReal_of_nonpos (sub_nonpos.2 (f.mono ab))]
state_before: case inl
f : StieltjesFunction
a b a' b' : ℝ
h : Ioc a b ⊆ Ioc a' b'
ab : b ≤ a
⊢ Real.toNNReal (↑f b - ↑f a) ≤ Real.toNNReal (↑f b' - ↑f a')

tactic: apply zero_le
state_before: case inl
f : StieltjesFunction
a b a' b' : ℝ
h : Ioc a b ⊆ Ioc a' b'
ab : b ≤ a
⊢ 0 ≤ Real.toNNReal (↑f b' - ↑f a')
Theorem: AlgebraicGeometry.StructureSheaf.const_mul_rev
File: Mathlib/AlgebraicGeometry/StructureSheaf.lean

tactic: rw [const_mul, const_congr R rfl (mul_comm g f), const_self]
state_before: R : Type u
inst✝ : CommRing R
f g : R
U : Opens ↑(PrimeSpectrum.Top R)
hu₁ : ∀ (x : ↑(PrimeSpectrum.Top R)), x ∈ U → g ∈ Ideal.primeCompl x.asIdeal
hu₂ : ∀ (x : ↑(PrimeSpectrum.Top R)), x ∈ U → f ∈ Ideal.primeCompl x.asIdeal
⊢ const R f g U hu₁ * const R g f U hu₂ = 1
Theorem: Ordset.empty_iff
File: Mathlib/Data/Ordmap/Ordset.lean

tactic: cases h
state_before: α : Type u_1
inst✝ : Preorder α
s : Ordset α
h : s = ∅
⊢ empty ↑s = true

tactic: exact rfl
state_before: case refl
α : Type u_1
inst✝ : Preorder α
⊢ empty ↑∅ = true

tactic: cases s with | mk s_val _ => cases s_val <;> [rfl; cases h]
state_before: α : Type u_1
inst✝ : Preorder α
s : Ordset α
h : empty ↑s = true
⊢ s = ∅

tactic: cases s_val <;> [rfl; cases h]
state_before: case mk
α : Type u_1
inst✝ : Preorder α
s_val : Ordnode α
property✝ : Valid s_val
h : empty ↑{ val := s_val, property := property✝ } = true
⊢ { val := s_val, property := property✝ } = ∅
Theorem: List.mapIdx_eq_ofFn
File: Mathlib/Data/List/Indexes.lean

tactic: induction' l with hd tl IH generalizing f
state_before: α✝ : Type u
β✝ : Type v
α : Type u_1
β : Type u_2
l : List α
f : ℕ → α → β
⊢ mapIdx f l = ofFn fun i => f (↑i) (get l i)

tactic: rfl
state_before: case nil
α✝ : Type u
β✝ : Type v
α : Type u_1
β : Type u_2
f✝ f : ℕ → α → β
⊢ mapIdx f [] = ofFn fun i => f (↑i) (get [] i)

tactic: simp [IH]
state_before: case cons
α✝ : Type u
β✝ : Type v
α : Type u_1
β : Type u_2
f✝ : ℕ → α → β
hd : α
tl : List α
IH : ∀ (f : ℕ → α → β), mapIdx f tl = ofFn fun i => f (↑i) (get tl i)
f : ℕ → α → β
⊢ mapIdx f (hd :: tl) = ofFn fun i => f (↑i) (get (hd :: tl) i)
Theorem: List.Perm.pmap
File: Mathlib/Data/List/Perm.lean

tactic: induction p with
| nil => simp
| cons x _p IH => simp [IH, Perm.cons]
| swap x y => simp [swap]
| trans _p₁ p₂ IH₁ IH₂ =>
  refine' IH₁.trans IH₂
  exact fun a m => H₂ a (p₂.subset m)
state_before: α : Type uu
β : Type vv
l₁✝ l₂✝ : List α
p✝ : α → Prop
f : (a : α) → p✝ a → β
l₁ l₂ : List α
p : l₁ ~ l₂
H₁ : ∀ (a : α), a ∈ l₁ → p✝ a
H₂ : ∀ (a : α), a ∈ l₂ → p✝ a
⊢ List.pmap f l₁ H₁ ~ List.pmap f l₂ H₂

tactic: simp
state_before: case nil
α : Type uu
β : Type vv
l₁✝ l₂✝ : List α
p : α → Prop
f : (a : α) → p a → β
l₁ l₂ : List α
H₁ H₂ : ∀ (a : α), a ∈ [] → p a
⊢ List.pmap f [] H₁ ~ List.pmap f [] H₂

tactic: simp [IH, Perm.cons]
state_before: case cons
α : Type uu
β : Type vv
l₁✝¹ l₂✝¹ : List α
p : α → Prop
f : (a : α) → p a → β
l₁ l₂ : List α
x : α
l₁✝ l₂✝ : List α
_p : l₁✝ ~ l₂✝
IH : ∀ {H₁ : ∀ (a : α), a ∈ l₁✝ → p a} {H₂ : ∀ (a : α), a ∈ l₂✝ → p a}, List.pmap f l₁✝ H₁ ~ List.pmap f l₂✝ H₂
H₁ : ∀ (a : α), a ∈ x :: l₁✝ → p a
H₂ : ∀ (a : α), a ∈ x :: l₂✝ → p a
⊢ List.pmap f (x :: l₁✝) H₁ ~ List.pmap f (x :: l₂✝) H₂

tactic: simp [swap]
state_before: case swap
α : Type uu
β : Type vv
l₁✝ l₂✝ : List α
p : α → Prop
f : (a : α) → p a → β
l₁ l₂ : List α
x y : α
l✝ : List α
H₁ : ∀ (a : α), a ∈ y :: x :: l✝ → p a
H₂ : ∀ (a : α), a ∈ x :: y :: l✝ → p a
⊢ List.pmap f (y :: x :: l✝) H₁ ~ List.pmap f (x :: y :: l✝) H₂

tactic: refine' IH₁.trans IH₂
state_before: case trans
α : Type uu
β : Type vv
l₁✝¹ l₂✝¹ : List α
p : α → Prop
f : (a : α) → p a → β
l₁ l₂ l₁✝ l₂✝ l₃✝ : List α
_p₁ : l₁✝ ~ l₂✝
p₂ : l₂✝ ~ l₃✝
IH₁ : ∀ {H₁ : ∀ (a : α), a ∈ l₁✝ → p a} {H₂ : ∀ (a : α), a ∈ l₂✝ → p a}, List.pmap f l₁✝ H₁ ~ List.pmap f l₂✝ H₂
IH₂ : ∀ {H₁ : ∀ (a : α), a ∈ l₂✝ → p a} {H₂ : ∀ (a : α), a ∈ l₃✝ → p a}, List.pmap f l₂✝ H₁ ~ List.pmap f l₃✝ H₂
H₁ : ∀ (a : α), a ∈ l₁✝ → p a
H₂ : ∀ (a : α), a ∈ l₃✝ → p a
⊢ List.pmap f l₁✝ H₁ ~ List.pmap f l₃✝ H₂

tactic: exact fun a m => H₂ a (p₂.subset m)
state_before: case trans
α : Type uu
β : Type vv
l₁✝¹ l₂✝¹ : List α
p : α → Prop
f : (a : α) → p a → β
l₁ l₂ l₁✝ l₂✝ l₃✝ : List α
_p₁ : l₁✝ ~ l₂✝
p₂ : l₂✝ ~ l₃✝
IH₁ : ∀ {H₁ : ∀ (a : α), a ∈ l₁✝ → p a} {H₂ : ∀ (a : α), a ∈ l₂✝ → p a}, List.pmap f l₁✝ H₁ ~ List.pmap f l₂✝ H₂
IH₂ : ∀ {H₁ : ∀ (a : α), a ∈ l₂✝ → p a} {H₂ : ∀ (a : α), a ∈ l₃✝ → p a}, List.pmap f l₂✝ H₁ ~ List.pmap f l₃✝ H₂
H₁ : ∀ (a : α), a ∈ l₁✝ → p a
H₂ : ∀ (a : α), a ∈ l₃✝ → p a
⊢ ∀ (a : α), a ∈ l₂✝ → p a
Theorem: Finset.prod_pow_eq_pow_sum
File: Mathlib/Algebra/BigOperators/Ring.lean

tactic: apply Finset.induction
state_before: α : Type u
β : Type v
γ : Type w
s s₁ s₂ : Finset α
a : α
b : β
f✝ g : α → β
inst✝ : CommMonoid β
x : β
f : α → ℕ
⊢ ∀ {s : Finset α}, ∏ i in s, x ^ f i = x ^ ∑ x in s, f x

tactic: simp
state_before: case empty
α : Type u
β : Type v
γ : Type w
s s₁ s₂ : Finset α
a : α
b : β
f✝ g : α → β
inst✝ : CommMonoid β
x : β
f : α → ℕ
⊢ ∏ i in ∅, x ^ f i = x ^ ∑ x in ∅, f x

tactic: intro a s has H
state_before: case insert
α : Type u
β : Type v
γ : Type w
s s₁ s₂ : Finset α
a : α
b : β
f✝ g : α → β
inst✝ : CommMonoid β
x : β
f : α → ℕ
⊢ ∀ ⦃a : α⦄ {s : Finset α},
    ¬a ∈ s → ∏ i in s, x ^ f i = x ^ ∑ x in s, f x → ∏ i in insert a s, x ^ f i = x ^ ∑ x in insert a s, f x

tactic: rw [Finset.prod_insert has, Finset.sum_insert has, pow_add, H]
state_before: case insert
α : Type u
β : Type v
γ : Type w
s✝ s₁ s₂ : Finset α
a✝ : α
b : β
f✝ g : α → β
inst✝ : CommMonoid β
x : β
f : α → ℕ
a : α
s : Finset α
has : ¬a ∈ s
H : ∏ i in s, x ^ f i = x ^ ∑ x in s, f x
⊢ ∏ i in insert a s, x ^ f i = x ^ ∑ x in insert a s, f x
Theorem: Polynomial.map_natDegree_eq_natDegree
File: Mathlib/Data/Polynomial/EraseLead.lean

tactic: simpa
state_before: R : Type u_3
inst✝² : Semiring R
f : R[X]
S : Type u_1
F : Type u_2
inst✝¹ : Semiring S
inst✝ : AddMonoidHomClass F R[X] S[X]
φ : F
p : R[X]
φ_mon_nat : ∀ (n : ℕ) (c : R), c ≠ 0 → natDegree (↑φ (↑(monomial n) c)) = n
⊢ ∀ (n : ℕ) (c : R), c ≠ 0 → natDegree (↑φ (↑(monomial n) c)) = n - 0
Theorem: Set.Finite.toFinset_insert
File: Mathlib/Data/Set/Finite.lean

tactic: simp
state_before: α : Type u
β : Type v
ι : Sort w
γ : Type x
inst✝ : DecidableEq α
s : Set α
a : α
hs : Set.Finite (insert a s)
⊢ ∀ (a_1 : α), a_1 ∈ Finite.toFinset hs ↔ a_1 ∈ insert a (Finite.toFinset (_ : Set.Finite s))
Theorem: Polynomial.exists_finset_of_splits
File: Mathlib/FieldTheory/Separable.lean

tactic: obtain ⟨s, h⟩ := (splits_iff_exists_multiset _).1 sp
state_before: F : Type u
inst✝¹ : Field F
K : Type v
inst✝ : Field K
i✝ i : F →+* K
f : F[X]
sep : Separable f
sp : Splits i f
⊢ ∃ s, map i f = ↑C (↑i (leadingCoeff f)) * ∏ a in s, (X - ↑C a)

tactic: use s.toFinset
state_before: case intro
F : Type u
inst✝¹ : Field F
K : Type v
inst✝ : Field K
i✝ i : F →+* K
f : F[X]
sep : Separable f
sp : Splits i f
s : Multiset K
h : map i f = ↑C (↑i (leadingCoeff f)) * Multiset.prod (Multiset.map (fun a => X - ↑C a) s)
⊢ ∃ s, map i f = ↑C (↑i (leadingCoeff f)) * ∏ a in s, (X - ↑C a)

tactic: rw [h, Finset.prod_eq_multiset_prod, ← Multiset.toFinset_eq]
state_before: case intro
F : Type u
inst✝¹ : Field F
K : Type v
inst✝ : Field K
i✝ i : F →+* K
f : F[X]
sep : Separable f
sp : Splits i f
s : Multiset K
h : map i f = ↑C (↑i (leadingCoeff f)) * Multiset.prod (Multiset.map (fun a => X - ↑C a) s)
⊢ map i f = ↑C (↑i (leadingCoeff f)) * ∏ a in Multiset.toFinset s, (X - ↑C a)

tactic: apply nodup_of_separable_prod
state_before: case intro
F : Type u
inst✝¹ : Field F
K : Type v
inst✝ : Field K
i✝ i : F →+* K
f : F[X]
sep : Separable f
sp : Splits i f
s : Multiset K
h : map i f = ↑C (↑i (leadingCoeff f)) * Multiset.prod (Multiset.map (fun a => X - ↑C a) s)
⊢ Multiset.Nodup s

tactic: apply Separable.of_mul_right
state_before: case intro.hs
F : Type u
inst✝¹ : Field F
K : Type v
inst✝ : Field K
i✝ i : F →+* K
f : F[X]
sep : Separable f
sp : Splits i f
s : Multiset K
h : map i f = ↑C (↑i (leadingCoeff f)) * Multiset.prod (Multiset.map (fun a => X - ↑C a) s)
⊢ Separable (Multiset.prod (Multiset.map (fun a => X - ↑C a) s))

tactic: rw [← h]
state_before: case intro.hs.h
F : Type u
inst✝¹ : Field F
K : Type v
inst✝ : Field K
i✝ i : F →+* K
f : F[X]
sep : Separable f
sp : Splits i f
s : Multiset K
h : map i f = ↑C (↑i (leadingCoeff f)) * Multiset.prod (Multiset.map (fun a => X - ↑C a) s)
⊢ Separable (?intro.hs.f * Multiset.prod (Multiset.map (fun a => X - ↑C a) s))

case intro.hs.f
F : Type u
inst✝¹ : Field F
K : Type v
inst✝ : Field K
i✝ i : F →+* K
f : F[X]
sep : Separable f
sp : Splits i f
s : Multiset K
h : map i f = ↑C (↑i (leadingCoeff f)) * Multiset.prod (Multiset.map (fun a => X - ↑C a) s)
⊢ K[X]

tactic: exact sep.map
state_before: case intro.hs.h
F : Type u
inst✝¹ : Field F
K : Type v
inst✝ : Field K
i✝ i : F →+* K
f : F[X]
sep : Separable f
sp : Splits i f
s : Multiset K
h : map i f = ↑C (↑i (leadingCoeff f)) * Multiset.prod (Multiset.map (fun a => X - ↑C a) s)
⊢ Separable (map i f)
Theorem: QuotientGroup.rangeKerLift_injective
File: Mathlib/GroupTheory/QuotientGroup.lean

tactic: rw [leftRel_apply, ← ker_rangeRestrict, mem_ker, φ.rangeRestrict.map_mul, ← h,
  φ.rangeRestrict.map_inv, inv_mul_self]
state_before: G : Type u
inst✝¹ : Group G
N : Subgroup G
nN : Subgroup.Normal N
H : Type v
inst✝ : Group H
φ : G →* H
a✝ b✝ : G ⧸ ker φ
a b : G
h : ↑(rangeRestrict φ) a = ↑(rangeRestrict φ) b
⊢ Setoid.r a b
Theorem: bernoulli'_one
File: Mathlib/NumberTheory/Bernoulli.lean

tactic: rw [bernoulli'_def]
state_before: A : Type ?u.182698
inst✝¹ : CommRing A
inst✝ : Algebra ℚ A
⊢ bernoulli' 1 = 1 / 2

tactic: norm_num
state_before: A : Type ?u.182698
inst✝¹ : CommRing A
inst✝ : Algebra ℚ A
⊢ 1 - ∑ k in range 1, ↑(Nat.choose 1 k) / (↑1 - ↑k + 1) * bernoulli' k = 1 / 2
Theorem: Asymptotics.isLittleO_sum_range_of_tendsto_zero
File: Mathlib/Analysis/Asymptotics/SpecificAsymptotics.lean

tactic: have := ((isLittleO_one_iff ℝ).2 h).sum_range fun i => zero_le_one
state_before: α : Type u_1
inst✝ : NormedAddCommGroup α
f : ℕ → α
h : Tendsto f atTop (𝓝 0)
⊢ (fun n => ∑ i in range n, f i) =o[atTop] fun n => ↑n

tactic: simp only [sum_const, card_range, Nat.smul_one_eq_coe] at this
state_before: α : Type u_1
inst✝ : NormedAddCommGroup α
f : ℕ → α
h : Tendsto f atTop (𝓝 0)
this :
  Tendsto (fun n => ∑ i in range n, 1) atTop atTop → (fun n => ∑ i in range n, f i) =o[atTop] fun n => ∑ i in range n, 1
⊢ (fun n => ∑ i in range n, f i) =o[atTop] fun n => ↑n

tactic: exact this tendsto_nat_cast_atTop_atTop
state_before: α : Type u_1
inst✝ : NormedAddCommGroup α
f : ℕ → α
h : Tendsto f atTop (𝓝 0)
this : Tendsto (fun n => ↑n) atTop atTop → (fun n => ∑ i in range n, f i) =o[atTop] fun n => ↑n
⊢ (fun n => ∑ i in range n, f i) =o[atTop] fun n => ↑n
Theorem: Functor.Comp.map_pure
File: Mathlib/Control/Applicative.lean

tactic: simp
state_before: F : Type u → Type w
G : Type v → Type u
inst✝³ : Applicative F
inst✝² : Applicative G
inst✝¹ : LawfulApplicative F
inst✝ : LawfulApplicative G
α β γ : Type v
f : α → β
x : α
⊢ run (f <$> pure x) = run (pure (f x))
Theorem: Cardinal.two_le_iff
File: Mathlib/SetTheory/Cardinal/Basic.lean

tactic: rw [← Nat.cast_two, nat_succ, succ_le_iff, Nat.cast_one, one_lt_iff_nontrivial, nontrivial_iff]
state_before: α β : Type u
⊢ 2 ≤ (#α) ↔ ∃ x y, x ≠ y
Theorem: intervalIntegral.inv_smul_integral_comp_div
File: Mathlib/MeasureTheory/Integral/IntervalIntegral.lean

tactic: by_cases hc : c = 0 <;> simp [hc, integral_comp_div]
state_before: ι : Type ?u.14846073
𝕜 : Type ?u.14846076
E : Type u_1
F : Type ?u.14846082
A : Type ?u.14846085
inst✝² : NormedAddCommGroup E
inst✝¹ : CompleteSpace E
inst✝ : NormedSpace ℝ E
a b c✝ d : ℝ
f : ℝ → E
c : ℝ
⊢ (c⁻¹ • ∫ (x : ℝ) in a..b, f (x / c)) = ∫ (x : ℝ) in a / c..b / c, f x
Theorem: pow_bit0'
File: Mathlib/Algebra/GroupPower/Basic.lean

tactic: rw [pow_bit0, (Commute.refl a).mul_pow]
state_before: α : Type ?u.37531
M : Type u
N : Type v
G : Type w
H : Type x
A : Type y
B : Type z
R : Type u₁
S : Type u₂
inst✝¹ : Monoid M
inst✝ : AddMonoid A
a : M
n : ℕ
⊢ a ^ bit0 n = (a * a) ^ n
Theorem: MeasureTheory.integrable_of_integrable_trim
File: Mathlib/MeasureTheory/Function/L1Space.lean

tactic: obtain ⟨hf_meas_ae, hf⟩ := hf_int
state_before: α : Type u_1
β : Type ?u.1259200
γ : Type ?u.1259203
δ : Type ?u.1259206
m : MeasurableSpace α
μ ν : Measure α
inst✝³ : MeasurableSpace δ
inst✝² : NormedAddCommGroup β
inst✝¹ : NormedAddCommGroup γ
H : Type u_2
inst✝ : NormedAddCommGroup H
m0 : MeasurableSpace α
μ' : Measure α
f : α → H
hm : m ≤ m0
hf_int : Integrable f
⊢ Integrable f

tactic: refine' ⟨aestronglyMeasurable_of_aestronglyMeasurable_trim hm hf_meas_ae, _⟩
state_before: case intro
α : Type u_1
β : Type ?u.1259200
γ : Type ?u.1259203
δ : Type ?u.1259206
m : MeasurableSpace α
μ ν : Measure α
inst✝³ : MeasurableSpace δ
inst✝² : NormedAddCommGroup β
inst✝¹ : NormedAddCommGroup γ
H : Type u_2
inst✝ : NormedAddCommGroup H
m0 : MeasurableSpace α
μ' : Measure α
f : α → H
hm : m ≤ m0
hf_meas_ae : AEStronglyMeasurable f (Measure.trim μ' hm)
hf : HasFiniteIntegral f
⊢ Integrable f

tactic: rw [HasFiniteIntegral] at hf ⊢
state_before: case intro
α : Type u_1
β : Type ?u.1259200
γ : Type ?u.1259203
δ : Type ?u.1259206
m : MeasurableSpace α
μ ν : Measure α
inst✝³ : MeasurableSpace δ
inst✝² : NormedAddCommGroup β
inst✝¹ : NormedAddCommGroup γ
H : Type u_2
inst✝ : NormedAddCommGroup H
m0 : MeasurableSpace α
μ' : Measure α
f : α → H
hm : m ≤ m0
hf_meas_ae : AEStronglyMeasurable f (Measure.trim μ' hm)
hf : HasFiniteIntegral f
⊢ HasFiniteIntegral f

tactic: rwa [lintegral_trim_ae hm _] at hf
state_before: case intro
α : Type u_1
β : Type ?u.1259200
γ : Type ?u.1259203
δ : Type ?u.1259206
m : MeasurableSpace α
μ ν : Measure α
inst✝³ : MeasurableSpace δ
inst✝² : NormedAddCommGroup β
inst✝¹ : NormedAddCommGroup γ
H : Type u_2
inst✝ : NormedAddCommGroup H
m0 : MeasurableSpace α
μ' : Measure α
f : α → H
hm : m ≤ m0
hf_meas_ae : AEStronglyMeasurable f (Measure.trim μ' hm)
hf : (∫⁻ (a : α), ↑‖f a‖₊ ∂Measure.trim μ' hm) < ⊤
⊢ (∫⁻ (a : α), ↑‖f a‖₊ ∂μ') < ⊤

tactic: exact AEStronglyMeasurable.ennnorm hf_meas_ae
state_before: α : Type u_1
β : Type ?u.1259200
γ : Type ?u.1259203
δ : Type ?u.1259206
m : MeasurableSpace α
μ ν : Measure α
inst✝³ : MeasurableSpace δ
inst✝² : NormedAddCommGroup β
inst✝¹ : NormedAddCommGroup γ
H : Type u_2
inst✝ : NormedAddCommGroup H
m0 : MeasurableSpace α
μ' : Measure α
f : α → H
hm : m ≤ m0
hf_meas_ae : AEStronglyMeasurable f (Measure.trim μ' hm)
hf : (∫⁻ (a : α), ↑‖f a‖₊ ∂Measure.trim μ' hm) < ⊤
⊢ AEMeasurable fun a => ↑‖f a‖₊
Theorem: AdjoinRoot.lift_of
File: Mathlib/RingTheory/AdjoinRoot.lean

tactic: rw [← mk_C x, lift_mk, eval₂_C]
state_before: R : Type u
S : Type v
K : Type w
inst✝¹ : CommRing R
f : R[X]
inst✝ : CommRing S
i : R →+* S
a : S
h : eval₂ i a f = 0
x : R
⊢ ↑(lift i a h) (↑(of f) x) = ↑i x
Theorem: Int.ceil_intCast
File: Mathlib/Algebra/Order/Floor.lean

tactic: rw [ceil_le, Int.cast_le]
state_before: F : Type ?u.210900
α : Type u_1
β : Type ?u.210906
inst✝¹ : LinearOrderedRing α
inst✝ : FloorRing α
z✝ : ℤ
a✝ : α
z a : ℤ
⊢ ⌈↑z⌉ ≤ a ↔ z ≤ a
Theorem: Nat.ArithmeticFunction.intCoe_mul
File: Mathlib/NumberTheory/ArithmeticFunction.lean

tactic: ext n
state_before: R : Type u_1
inst✝ : Ring R
f g : ArithmeticFunction ℤ
⊢ ↑(f * g) = ↑f * ↑g

tactic: simp
state_before: case h
R : Type u_1
inst✝ : Ring R
f g : ArithmeticFunction ℤ
n : ℕ
⊢ ↑↑(f * g) n = ↑(↑f * ↑g) n
Theorem: List.card_cons_of_mem
File: Mathlib/Data/List/Card.lean

tactic: simp [card, h]
state_before: α : Type u_1
β : Sort ?u.20954
inst✝¹ : DecidableEq α
inst✝ : DecidableEq β
a : α
as : List α
h : a ∈ as
⊢ card (a :: as) = card as
Theorem: Real.Angle.two_nsmul_toReal_eq_two_mul_sub_two_pi
File: Mathlib/Analysis/SpecialFunctions/Trigonometric/Angle.lean

tactic: nth_rw 1 [← coe_toReal θ]
state_before: θ : Angle
⊢ toReal (2 • θ) = 2 * toReal θ - 2 * π ↔ π / 2 < toReal θ

tactic: rw [← coe_nsmul, two_nsmul, ← two_mul, toReal_coe_eq_self_sub_two_pi_iff, Set.mem_Ioc]
state_before: θ : Angle
⊢ toReal (2 • ↑(toReal θ)) = 2 * toReal θ - 2 * π ↔ π / 2 < toReal θ

tactic: exact
  ⟨fun h => by linarith, fun h =>
    ⟨(div_lt_iff' (zero_lt_two' ℝ)).1 h, by linarith [pi_pos, toReal_le_pi θ]⟩⟩
state_before: θ : Angle
⊢ π < 2 * toReal θ ∧ 2 * toReal θ ≤ 3 * π ↔ π / 2 < toReal θ

tactic: linarith
state_before: θ : Angle
h : π < 2 * toReal θ ∧ 2 * toReal θ ≤ 3 * π
⊢ π / 2 < toReal θ

tactic: linarith [pi_pos, toReal_le_pi θ]
state_before: θ : Angle
h : π / 2 < toReal θ
⊢ 2 * toReal θ ≤ 3 * π
Theorem: Ordinal.bsup_eq_blsub_iff_lt_bsup
File: Mathlib/SetTheory/Ordinal/Arithmetic.lean

tactic: rw [h]
state_before: α : Type ?u.356399
β : Type ?u.356402
γ : Type ?u.356405
r : α → α → Prop
s : β → β → Prop
t : γ → γ → Prop
o : Ordinal
f : (a : Ordinal) → a < o → Ordinal
h : bsup o f = blsub o f
i : Ordinal
⊢ ∀ (hi : i < o), f i hi < bsup o f

tactic: apply lt_blsub
state_before: α : Type ?u.356399
β : Type ?u.356402
γ : Type ?u.356405
r : α → α → Prop
s : β → β → Prop
t : γ → γ → Prop
o : Ordinal
f : (a : Ordinal) → a < o → Ordinal
h : bsup o f = blsub o f
i : Ordinal
⊢ ∀ (hi : i < o), f i hi < blsub o f
Theorem: Polynomial.le_trailingDegree_C_mul_X_pow
File: Mathlib/Data/Polynomial/Degree/TrailingDegree.lean

tactic: rw [C_mul_X_pow_eq_monomial]
state_before: R : Type u
S : Type v
a✝ b : R
n✝ m : ℕ
inst✝ : Semiring R
p q r : R[X]
n : ℕ
a : R
⊢ ↑n ≤ trailingDegree (↑C a * X ^ n)

tactic: exact le_trailingDegree_monomial
state_before: R : Type u
S : Type v
a✝ b : R
n✝ m : ℕ
inst✝ : Semiring R
p q r : R[X]
n : ℕ
a : R
⊢ ↑n ≤ trailingDegree (↑(monomial n) a)
Theorem: Polynomial.rootMultiplicity_sub_one_le_derivative_rootMultiplicity
File: Mathlib/Data/Polynomial/FieldDivision.lean

tactic: by_cases p.IsRoot t
state_before: R : Type u
S : Type v
k : Type y
A : Type z
a b : R
n : ℕ
inst✝² : CommRing R
inst✝¹ : IsDomain R
inst✝ : CharZero R
p : R[X]
t : R
⊢ rootMultiplicity t p - 1 ≤ rootMultiplicity t (↑derivative p)

tactic: exact (derivative_rootMultiplicity_of_root h).symm.le
state_before: case pos
R : Type u
S : Type v
k : Type y
A : Type z
a b : R
n : ℕ
inst✝² : CommRing R
inst✝¹ : IsDomain R
inst✝ : CharZero R
p : R[X]
t : R
h : IsRoot p t
⊢ rootMultiplicity t p - 1 ≤ rootMultiplicity t (↑derivative p)

tactic: rw [rootMultiplicity_eq_zero h, zero_tsub]
state_before: case neg
R : Type u
S : Type v
k : Type y
A : Type z
a b : R
n : ℕ
inst✝² : CommRing R
inst✝¹ : IsDomain R
inst✝ : CharZero R
p : R[X]
t : R
h : ¬IsRoot p t
⊢ rootMultiplicity t p - 1 ≤ rootMultiplicity t (↑derivative p)

tactic: exact zero_le _
state_before: case neg
R : Type u
S : Type v
k : Type y
A : Type z
a b : R
n : ℕ
inst✝² : CommRing R
inst✝¹ : IsDomain R
inst✝ : CharZero R
p : R[X]
t : R
h : ¬IsRoot p t
⊢ 0 ≤ rootMultiplicity t (↑derivative p)
Theorem: le_of_le_mul_right
File: Mathlib/Algebra/Order/WithZero.lean

tactic: simpa only [mul_inv_cancel_right₀ h] using mul_le_mul_right' hab c⁻¹
state_before: α : Type u_1
a b c d x y z : α
inst✝ : LinearOrderedCommGroupWithZero α
h : c ≠ 0
hab : a * c ≤ b * c
⊢ a ≤ b
Theorem: Set.ncard_insert_eq_ite
File: Mathlib/Data/Set/Ncard.lean

tactic: by_cases h : a ∈ s
state_before: α : Type u_1
β : Type ?u.11523
s t : Set α
a b x y : α
f : α → β
inst✝ : Decidable (a ∈ s)
hs : autoParam (Set.Finite s) _auto✝
⊢ ncard (insert a s) = if a ∈ s then ncard s else ncard s + 1

tactic: rw [ncard_insert_of_mem h, if_pos h]
state_before: case pos
α : Type u_1
β : Type ?u.11523
s t : Set α
a b x y : α
f : α → β
inst✝ : Decidable (a ∈ s)
hs : autoParam (Set.Finite s) _auto✝
h : a ∈ s
⊢ ncard (insert a s) = if a ∈ s then ncard s else ncard s + 1

tactic: rw [ncard_insert_of_not_mem h hs, if_neg h]
state_before: case neg
α : Type u_1
β : Type ?u.11523
s t : Set α
a b x y : α
f : α → β
inst✝ : Decidable (a ∈ s)
hs : autoParam (Set.Finite s) _auto✝
h : ¬a ∈ s
⊢ ncard (insert a s) = if a ∈ s then ncard s else ncard s + 1
Theorem: hasSum_mul_left_iff
File: Mathlib/Topology/Algebra/InfiniteSum/Ring.lean

tactic: simpa only [inv_mul_cancel_left₀ h] using H.mul_left a₂⁻¹
state_before: ι : Type u_2
κ : Type ?u.8721
R : Type ?u.8724
α : Type u_1
inst✝² : DivisionSemiring α
inst✝¹ : TopologicalSpace α
inst✝ : TopologicalSemiring α
f g : ι → α
a a₁ a₂ : α
h : a₂ ≠ 0
H : HasSum (fun i => a₂ * f i) (a₂ * a₁)
⊢ HasSum f a₁
Theorem: PosNum.add_to_nat
File: Mathlib/Data/Num/Lemmas.lean

tactic: rw [one_add b, succ_to_nat, add_comm]
state_before: α : Type ?u.30847
b : PosNum
⊢ ↑(1 + b) = ↑1 + ↑b

tactic: rfl
state_before: α : Type ?u.30847
b : PosNum
⊢ 1 + ↑b = ↑1 + ↑b

tactic: rw [add_one a, succ_to_nat]
state_before: α : Type ?u.30847
a : PosNum
⊢ ↑(a + 1) = ↑a + ↑1

tactic: rfl
state_before: α : Type ?u.30847
a : PosNum
⊢ ↑a + 1 = ↑a + ↑1

tactic: simp [add_left_comm]
state_before: α : Type ?u.30847
a b : PosNum
⊢ ↑a + ↑b + (↑a + ↑b) + 1 = ↑a + ↑a + (↑b + ↑b + 1)

tactic: simp [add_comm, add_left_comm]
state_before: α : Type ?u.30847
a b : PosNum
⊢ ↑a + ↑b + (↑a + ↑b) + 1 = ↑a + ↑a + 1 + (↑b + ↑b)

tactic: rw [succ_to_nat, add_to_nat a b]
state_before: α : Type ?u.30847
a b : PosNum
⊢ ↑(succ (a + b)) + ↑(succ (a + b)) = ↑a + ↑a + 1 + (↑b + ↑b + 1)

tactic: simp [add_left_comm]
state_before: α : Type ?u.30847
a b : PosNum
⊢ ↑a + ↑b + 1 + (↑a + ↑b + 1) = ↑a + ↑a + 1 + (↑b + ↑b + 1)