tasksource/leandojo huggingface dataset:
Theorem: ProbabilityTheory.IndepSets.iInter
File: Mathlib/Probability/Independence/Basic.lean

tactic: intro t1 t2 ht1 ht2
state_before: Ω : Type u_1
ι : Type u_2
inst✝ : MeasurableSpace Ω
s : ι → Set (Set Ω)
s' : Set (Set Ω)
μ : MeasureTheory.Measure Ω
h : ∃ n, IndepSets (s n) s'
⊢ IndepSets (⋂ (n : ι), s n) s'

tactic: cases' h with n h
state_before: Ω : Type u_1
ι : Type u_2
inst✝ : MeasurableSpace Ω
s : ι → Set (Set Ω)
s' : Set (Set Ω)
μ : MeasureTheory.Measure Ω
h : ∃ n, IndepSets (s n) s'
t1 t2 : Set Ω
ht1 : t1 ∈ ⋂ (n : ι), s n
ht2 : t2 ∈ s'
⊢ ↑↑μ (t1 ∩ t2) = ↑↑μ t1 * ↑↑μ t2

tactic: exact h t1 t2 (Set.mem_iInter.mp ht1 n) ht2
state_before: case intro
Ω : Type u_1
ι : Type u_2
inst✝ : MeasurableSpace Ω
s : ι → Set (Set Ω)
s' : Set (Set Ω)
μ : MeasureTheory.Measure Ω
t1 t2 : Set Ω
ht1 : t1 ∈ ⋂ (n : ι), s n
ht2 : t2 ∈ s'
n : ι
h : IndepSets (s n) s'
⊢ ↑↑μ (t1 ∩ t2) = ↑↑μ t1 * ↑↑μ t2
Theorem: PNat.one_gcd
File: Mathlib/Data/PNat/Prime.lean

tactic: rw [← gcd_eq_left_iff_dvd]
state_before: n : ℕ+
⊢ gcd 1 n = 1

tactic: apply one_dvd
state_before: n : ℕ+
⊢ 1 ∣ n
Theorem: CategoryTheory.IsEquivalence.fun_inv_map
File: Mathlib/CategoryTheory/Equivalence.lean

tactic: erw [NatIso.naturality_2]
state_before: C : Type u₁
inst✝² : Category C
D : Type u₂
inst✝¹ : Category D
F : C ⥤ D
inst✝ : IsEquivalence F
X Y : D
f : X ⟶ Y
⊢ F.map ((Functor.inv F).map f) =
    (Equivalence.counit (asEquivalence F)).app X ≫ f ≫ (Equivalence.counitInv (asEquivalence F)).app Y

tactic: rfl
state_before: C : Type u₁
inst✝² : Category C
D : Type u₂
inst✝¹ : Category D
F : C ⥤ D
inst✝ : IsEquivalence F
X Y : D
f : X ⟶ Y
⊢ F.map ((Functor.inv F).map f) = ((asEquivalence F).inverse ⋙ (asEquivalence F).functor).map f
Theorem: FinEnum.nodup_toList
File: Mathlib/Data/FinEnum.lean

tactic: simp [toList]
state_before: α : Type u
β : α → Type v
inst✝ : FinEnum α
⊢ List.Nodup (toList α)

tactic: apply List.Nodup.map <;> [apply Equiv.injective; apply List.nodup_finRange]
state_before: α : Type u
β : α → Type v
inst✝ : FinEnum α
⊢ List.Nodup (List.map (↑Equiv.symm) (List.finRange (card α)))
Theorem: Polynomial.roots_list_prod
File: Mathlib/Data/Polynomial/RingDivision.lean

tactic: rw [List.mem_cons, not_or] at H
state_before: R : Type u
S : Type v
T : Type w
a b : R
n : ℕ
inst✝¹ : CommRing R
inst✝ : IsDomain R
p q : R[X]
L : List R[X]
hd : R[X]
tl : List R[X]
ih : ¬0 ∈ tl → roots (List.prod tl) = Multiset.bind (↑tl) roots
H : ¬0 ∈ hd :: tl
⊢ roots (List.prod (hd :: tl)) = Multiset.bind (↑(hd :: tl)) roots

tactic: rw [List.prod_cons, roots_mul (mul_ne_zero (Ne.symm H.1) <| List.prod_ne_zero H.2), ←
  Multiset.cons_coe, Multiset.cons_bind, ih H.2]
state_before: R : Type u
S : Type v
T : Type w
a b : R
n : ℕ
inst✝¹ : CommRing R
inst✝ : IsDomain R
p q : R[X]
L : List R[X]
hd : R[X]
tl : List R[X]
ih : ¬0 ∈ tl → roots (List.prod tl) = Multiset.bind (↑tl) roots
H : ¬0 = hd ∧ ¬0 ∈ tl
⊢ roots (List.prod (hd :: tl)) = Multiset.bind (↑(hd :: tl)) roots
Theorem: Polynomial.trailingDegree_eq_iff_natTrailingDegree_eq_of_pos
File: Mathlib/Data/Polynomial/Degree/TrailingDegree.lean

tactic: constructor
state_before: R : Type u
S : Type v
a b : R
n✝ m : ℕ
inst✝ : Semiring R
p✝ q r p : R[X]
n : ℕ
hn : 0 < n
⊢ trailingDegree p = ↑n ↔ natTrailingDegree p = n

tactic: intro H
state_before: case mp
R : Type u
S : Type v
a b : R
n✝ m : ℕ
inst✝ : Semiring R
p✝ q r p : R[X]
n : ℕ
hn : 0 < n
⊢ trailingDegree p = ↑n → natTrailingDegree p = n

tactic: rwa [← trailingDegree_eq_iff_natTrailingDegree_eq]
state_before: case mp
R : Type u
S : Type v
a b : R
n✝ m : ℕ
inst✝ : Semiring R
p✝ q r p : R[X]
n : ℕ
hn : 0 < n
H : trailingDegree p = ↑n
⊢ natTrailingDegree p = n

tactic: rintro rfl
state_before: case mp
R : Type u
S : Type v
a b : R
n✝ m : ℕ
inst✝ : Semiring R
p✝ q r p : R[X]
n : ℕ
hn : 0 < n
H : trailingDegree p = ↑n
⊢ p ≠ 0

tactic: rw [trailingDegree_zero] at H
state_before: case mp
R : Type u
S : Type v
a b : R
n✝ m : ℕ
inst✝ : Semiring R
p q r : R[X]
n : ℕ
hn : 0 < n
H : trailingDegree 0 = ↑n
⊢ False

tactic: exact Option.noConfusion H
state_before: case mp
R : Type u
S : Type v
a b : R
n✝ m : ℕ
inst✝ : Semiring R
p q r : R[X]
n : ℕ
hn : 0 < n
H : ⊤ = ↑n
⊢ False

tactic: intro H
state_before: case mpr
R : Type u
S : Type v
a b : R
n✝ m : ℕ
inst✝ : Semiring R
p✝ q r p : R[X]
n : ℕ
hn : 0 < n
⊢ natTrailingDegree p = n → trailingDegree p = ↑n

tactic: rwa [trailingDegree_eq_iff_natTrailingDegree_eq]
state_before: case mpr
R : Type u
S : Type v
a b : R
n✝ m : ℕ
inst✝ : Semiring R
p✝ q r p : R[X]
n : ℕ
hn : 0 < n
H : natTrailingDegree p = n
⊢ trailingDegree p = ↑n

tactic: rintro rfl
state_before: case mpr
R : Type u
S : Type v
a b : R
n✝ m : ℕ
inst✝ : Semiring R
p✝ q r p : R[X]
n : ℕ
hn : 0 < n
H : natTrailingDegree p = n
⊢ p ≠ 0

tactic: rw [natTrailingDegree_zero] at H
state_before: case mpr
R : Type u
S : Type v
a b : R
n✝ m : ℕ
inst✝ : Semiring R
p q r : R[X]
n : ℕ
hn : 0 < n
H : natTrailingDegree 0 = n
⊢ False

tactic: rw [H] at hn
state_before: case mpr
R : Type u
S : Type v
a b : R
n✝ m : ℕ
inst✝ : Semiring R
p q r : R[X]
n : ℕ
hn : 0 < n
H : 0 = n
⊢ False

tactic: exact lt_irrefl _ hn
state_before: case mpr
R : Type u
S : Type v
a b : R
n✝ m : ℕ
inst✝ : Semiring R
p q r : R[X]
n : ℕ
hn : n < n
H : 0 = n
⊢ False
Theorem: Finset.div_zero_subset
File: Mathlib/Data/Finset/Pointwise.lean

tactic: simp [subset_iff, mem_div]
state_before: F : Type ?u.652865
α : Type u_1
β : Type ?u.652871
γ : Type ?u.652874
inst✝² : DecidableEq α
inst✝¹ : DecidableEq β
inst✝ : GroupWithZero α
s✝ t s : Finset α
⊢ s / 0 ⊆ 0
Theorem: Real.add_one_lt_exp_of_neg
File: Mathlib/Data/Complex/Exponential.lean

tactic: have h1 : 0 < -x := by linarith
state_before: x : ℝ
h : x < 0
⊢ x + 1 < exp x

tactic: simpa [add_comm] using one_sub_lt_exp_minus_of_pos h1
state_before: x : ℝ
h : x < 0
h1 : 0 < -x
⊢ x + 1 < exp x

tactic: linarith
state_before: x : ℝ
h : x < 0
⊢ 0 < -x
Theorem: CategoryTheory.Limits.image.isoStrongEpiMono_hom_comp_ι
File: Mathlib/CategoryTheory/Limits/Shapes/Images.lean

tactic: dsimp [isoStrongEpiMono]
state_before: C : Type u
inst✝³ : Category C
inst✝² : HasStrongEpiMonoFactorisations C
X Y : C
f : X ⟶ Y
I' : C
e : X ⟶ I'
m : I' ⟶ Y
comm : e ≫ m = f
inst✝¹ : StrongEpi e
inst✝ : Mono m
⊢ (isoStrongEpiMono e m comm).hom ≫ ι f = m

tactic: apply IsImage.lift_fac
state_before: C : Type u
inst✝³ : Category C
inst✝² : HasStrongEpiMonoFactorisations C
X Y : C
f : X ⟶ Y
I' : C
e : X ⟶ I'
m : I' ⟶ Y
comm : e ≫ m = f
inst✝¹ : StrongEpi e
inst✝ : Mono m
⊢ IsImage.lift (StrongEpiMonoFactorisation.toMonoIsImage (StrongEpiMonoFactorisation.mk (MonoFactorisation.mk I' m e)))
        (Image.monoFactorisation f) ≫
      ι f =
    m
Theorem: TendstoUniformly.prod_map
File: Mathlib/Topology/UniformSpace/UniformConvergence.lean

tactic: rw [← tendstoUniformlyOn_univ, ← univ_prod_univ] at *
state_before: α : Type u
β : Type v
γ : Type w
ι : Type x
inst✝¹ : UniformSpace β
F : ι → α → β
f : α → β
s s' : Set α
x : α
p : Filter ι
p'✝ : Filter α
g : ι → α
ι' : Type u_1
α' : Type u_2
β' : Type u_3
inst✝ : UniformSpace β'
F' : ι' → α' → β'
f' : α' → β'
p' : Filter ι'
h : TendstoUniformly F f p
h' : TendstoUniformly F' f' p'
⊢ TendstoUniformly (fun i => Prod.map (F i.fst) (F' i.snd)) (Prod.map f f') (p ×ˢ p')

tactic: exact h.prod_map h'
state_before: α : Type u
β : Type v
γ : Type w
ι : Type x
inst✝¹ : UniformSpace β
F : ι → α → β
f : α → β
s s' : Set α
x : α
p : Filter ι
p'✝ : Filter α
g : ι → α
ι' : Type u_1
α' : Type u_2
β' : Type u_3
inst✝ : UniformSpace β'
F' : ι' → α' → β'
f' : α' → β'
p' : Filter ι'
h : TendstoUniformlyOn F f p univ
h' : TendstoUniformlyOn F' f' p' univ
⊢ TendstoUniformlyOn (fun i => Prod.map (F i.fst) (F' i.snd)) (Prod.map f f') (p ×ˢ p') (univ ×ˢ univ)
Theorem: WithBot.coe_unbot
File: Mathlib/Order/WithBot.lean

tactic: cases x
state_before: α : Type u_1
β : Type ?u.7014
γ : Type ?u.7017
δ : Type ?u.7020
a b : α
x : WithBot α
h : x ≠ ⊥
⊢ ↑(unbot x h) = x

tactic: exact (h rfl).elim
state_before: case none
α : Type u_1
β : Type ?u.7014
γ : Type ?u.7017
δ : Type ?u.7020
a b : α
h : none ≠ ⊥
⊢ ↑(unbot none h) = none

case some
α : Type u_1
β : Type ?u.7014
γ : Type ?u.7017
δ : Type ?u.7020
a b val✝ : α
h : Option.some val✝ ≠ ⊥
⊢ ↑(unbot (Option.some val✝) h) = Option.some val✝

tactic: rfl
state_before: case some
α : Type u_1
β : Type ?u.7014
γ : Type ?u.7017
δ : Type ?u.7020
a b val✝ : α
h : Option.some val✝ ≠ ⊥
⊢ ↑(unbot (Option.some val✝) h) = Option.some val✝
Theorem: MeasureTheory.integrable_const_iff
File: Mathlib/MeasureTheory/Function/L1Space.lean

tactic: have : AEStronglyMeasurable (fun _ : α => c) μ := aestronglyMeasurable_const
state_before: α : Type u_2
β : Type u_1
γ : Type ?u.832965
δ : Type ?u.832968
m : MeasurableSpace α
μ ν : Measure α
inst✝² : MeasurableSpace δ
inst✝¹ : NormedAddCommGroup β
inst✝ : NormedAddCommGroup γ
c : β
⊢ (Integrable fun x => c) ↔ c = 0 ∨ ↑↑μ univ < ⊤

tactic: rw [Integrable, and_iff_right this, hasFiniteIntegral_const_iff]
state_before: α : Type u_2
β : Type u_1
γ : Type ?u.832965
δ : Type ?u.832968
m : MeasurableSpace α
μ ν : Measure α
inst✝² : MeasurableSpace δ
inst✝¹ : NormedAddCommGroup β
inst✝ : NormedAddCommGroup γ
c : β
this : AEStronglyMeasurable (fun x => c) μ
⊢ (Integrable fun x => c) ↔ c = 0 ∨ ↑↑μ univ < ⊤
Theorem: Set.pairwise_iff_exists_forall
File: Mathlib/Data/Set/Pairwise/Basic.lean

tactic: rcases s.eq_empty_or_nonempty with (rfl | hne)
state_before: α : Type u_2
β : Type ?u.6322
γ : Type ?u.6325
ι : Type u_1
ι' : Type ?u.6331
r✝ p q : α → α → Prop
f✝ g : ι → α
s✝ t u : Set α
a b : α
inst✝¹ : Nonempty ι
s : Set α
f : α → ι
r : ι → ι → Prop
inst✝ : IsEquiv ι r
⊢ Set.Pairwise s (r on f) ↔ ∃ z, ∀ (x : α), x ∈ s → r (f x) z

tactic: simp
state_before: case inl
α : Type u_2
β : Type ?u.6322
γ : Type ?u.6325
ι : Type u_1
ι' : Type ?u.6331
r✝ p q : α → α → Prop
f✝ g : ι → α
s t u : Set α
a b : α
inst✝¹ : Nonempty ι
f : α → ι
r : ι → ι → Prop
inst✝ : IsEquiv ι r
⊢ Set.Pairwise ∅ (r on f) ↔ ∃ z, ∀ (x : α), x ∈ ∅ → r (f x) z

tactic: exact hne.pairwise_iff_exists_forall
state_before: case inr
α : Type u_2
β : Type ?u.6322
γ : Type ?u.6325
ι : Type u_1
ι' : Type ?u.6331
r✝ p q : α → α → Prop
f✝ g : ι → α
s✝ t u : Set α
a b : α
inst✝¹ : Nonempty ι
s : Set α
f : α → ι
r : ι → ι → Prop
inst✝ : IsEquiv ι r
hne : Set.Nonempty s
⊢ Set.Pairwise s (r on f) ↔ ∃ z, ∀ (x : α), x ∈ s → r (f x) z
Theorem: Ring.isField_iff_isSimpleOrder_ideal
File: Mathlib/RingTheory/Ideal/Basic.lean

tactic: cases subsingleton_or_nontrivial R
state_before: α : Type u
β : Type v
R : Type u_1
inst✝ : CommSemiring R
⊢ IsField R ↔ IsSimpleOrder (Ideal R)

tactic: rw [← not_iff_not, Ring.not_isField_iff_exists_ideal_bot_lt_and_lt_top, ← not_iff_not]
state_before: case inr
α : Type u
β : Type v
R : Type u_1
inst✝ : CommSemiring R
h✝ : Nontrivial R
⊢ IsField R ↔ IsSimpleOrder (Ideal R)

tactic: push_neg
state_before: case inr
α : Type u
β : Type v
R : Type u_1
inst✝ : CommSemiring R
h✝ : Nontrivial R
⊢ (¬∃ I, ⊥ < I ∧ I < ⊤) ↔ ¬¬IsSimpleOrder (Ideal R)

tactic: simp_rw [lt_top_iff_ne_top, bot_lt_iff_ne_bot, ← or_iff_not_imp_left, not_ne_iff]
state_before: case inr
α : Type u
β : Type v
R : Type u_1
inst✝ : CommSemiring R
h✝ : Nontrivial R
⊢ (∀ (I : Ideal R), ⊥ < I → ¬I < ⊤) ↔ IsSimpleOrder (Ideal R)

tactic: exact ⟨fun h => ⟨h⟩, fun h => h.2⟩
state_before: case inr
α : Type u
β : Type v
R : Type u_1
inst✝ : CommSemiring R
h✝ : Nontrivial R
⊢ (∀ (I : Ideal R), I = ⊥ ∨ I = ⊤) ↔ IsSimpleOrder (Ideal R)

tactic: exact
  ⟨fun h => (not_isField_of_subsingleton _ h).elim, fun h =>
    (false_of_nontrivial_of_subsingleton <| Ideal R).elim⟩
state_before: case inl
α : Type u
β : Type v
R : Type u_1
inst✝ : CommSemiring R
h✝ : Subsingleton R
⊢ IsField R ↔ IsSimpleOrder (Ideal R)
Theorem: CategoryTheory.isCoseparating_iff_mono
File: Mathlib/CategoryTheory/Generator.lean

tactic: refine' ⟨fun h A => ⟨fun u v huv => h _ _ fun G hG f => _⟩, fun h X Y f g hh => _⟩
state_before: C : Type u₁
inst✝² : Category C
D : Type u₂
inst✝¹ : Category D
𝒢 : Set C
inst✝ : ∀ (A : C), HasProduct fun f => ↑f.fst
⊢ IsCoseparating 𝒢 ↔ ∀ (A : C), Mono (Pi.lift Sigma.snd)

tactic: simpa using huv =≫ Pi.π (fun f : ΣG : 𝒢, A ⟶ (G : C) => (f.1 : C)) ⟨⟨G, hG⟩, f⟩
state_before: case refine'_1
C : Type u₁
inst✝² : Category C
D : Type u₂
inst✝¹ : Category D
𝒢 : Set C
inst✝ : ∀ (A : C), HasProduct fun f => ↑f.fst
h : IsCoseparating 𝒢
A Z✝ : C
u v : Z✝ ⟶ A
huv : u ≫ Pi.lift Sigma.snd = v ≫ Pi.lift Sigma.snd
G : C
hG : G ∈ 𝒢
f : A ⟶ G
⊢ u ≫ f = v ≫ f

tactic: haveI := h Y
state_before: case refine'_2
C : Type u₁
inst✝² : Category C
D : Type u₂
inst✝¹ : Category D
𝒢 : Set C
inst✝ : ∀ (A : C), HasProduct fun f => ↑f.fst
h : ∀ (A : C), Mono (Pi.lift Sigma.snd)
X Y : C
f g : X ⟶ Y
hh : ∀ (G : C), G ∈ 𝒢 → ∀ (h : Y ⟶ G), f ≫ h = g ≫ h
⊢ f = g

tactic: refine' (cancel_mono (Pi.lift (@Sigma.snd 𝒢 fun G => Y ⟶ (G : C)))).1 (limit.hom_ext fun j => _)
state_before: case refine'_2
C : Type u₁
inst✝² : Category C
D : Type u₂
inst✝¹ : Category D
𝒢 : Set C
inst✝ : ∀ (A : C), HasProduct fun f => ↑f.fst
h : ∀ (A : C), Mono (Pi.lift Sigma.snd)
X Y : C
f g : X ⟶ Y
hh : ∀ (G : C), G ∈ 𝒢 → ∀ (h : Y ⟶ G), f ≫ h = g ≫ h
this : Mono (Pi.lift Sigma.snd)
⊢ f = g

tactic: simpa using hh j.as.1.1 j.as.1.2 j.as.2
state_before: case refine'_2
C : Type u₁
inst✝² : Category C
D : Type u₂
inst✝¹ : Category D
𝒢 : Set C
inst✝ : ∀ (A : C), HasProduct fun f => ↑f.fst
h : ∀ (A : C), Mono (Pi.lift Sigma.snd)
X Y : C
f g : X ⟶ Y
hh : ∀ (G : C), G ∈ 𝒢 → ∀ (h : Y ⟶ G), f ≫ h = g ≫ h
this : Mono (Pi.lift Sigma.snd)
j : Discrete ((G : ↑𝒢) × (Y ⟶ ↑G))
⊢ (f ≫ Pi.lift Sigma.snd) ≫ limit.π (Discrete.functor fun b => ↑b.fst) j =
    (g ≫ Pi.lift Sigma.snd) ≫ limit.π (Discrete.functor fun b => ↑b.fst) j
Theorem: SeminormFamily.finset_sup_comp
File: Mathlib/Analysis/LocallyConvex/WithSeminorms.lean

tactic: ext x
state_before: 𝕜 : Type u_4
𝕜₂ : Type u_1
𝕝 : Type ?u.705364
𝕝₂ : Type ?u.705367
E : Type u_5
F : Type u_2
G : Type ?u.705376
ι : Type u_3
ι' : Type ?u.705382
inst✝⁶ : NormedField 𝕜
inst✝⁵ : AddCommGroup E
inst✝⁴ : Module 𝕜 E
inst✝³ : NormedField 𝕜₂
inst✝² : AddCommGroup F
inst✝¹ : Module 𝕜₂ F
σ₁₂ : 𝕜 →+* 𝕜₂
inst✝ : RingHomIsometric σ₁₂
q : SeminormFamily 𝕜₂ F ι
s : Finset ι
f : E →ₛₗ[σ₁₂] F
⊢ Seminorm.comp (Finset.sup s q) f = Finset.sup s (comp q f)

tactic: rw [Seminorm.comp_apply, Seminorm.finset_sup_apply, Seminorm.finset_sup_apply]
state_before: case h
𝕜 : Type u_4
𝕜₂ : Type u_1
𝕝 : Type ?u.705364
𝕝₂ : Type ?u.705367
E : Type u_5
F : Type u_2
G : Type ?u.705376
ι : Type u_3
ι' : Type ?u.705382
inst✝⁶ : NormedField 𝕜
inst✝⁵ : AddCommGroup E
inst✝⁴ : Module 𝕜 E
inst✝³ : NormedField 𝕜₂
inst✝² : AddCommGroup F
inst✝¹ : Module 𝕜₂ F
σ₁₂ : 𝕜 →+* 𝕜₂
inst✝ : RingHomIsometric σ₁₂
q : SeminormFamily 𝕜₂ F ι
s : Finset ι
f : E →ₛₗ[σ₁₂] F
x : E
⊢ ↑(Seminorm.comp (Finset.sup s q) f) x = ↑(Finset.sup s (comp q f)) x

tactic: rfl
state_before: case h
𝕜 : Type u_4
𝕜₂ : Type u_1
𝕝 : Type ?u.705364
𝕝₂ : Type ?u.705367
E : Type u_5
F : Type u_2
G : Type ?u.705376
ι : Type u_3
ι' : Type ?u.705382
inst✝⁶ : NormedField 𝕜
inst✝⁵ : AddCommGroup E
inst✝⁴ : Module 𝕜 E
inst✝³ : NormedField 𝕜₂
inst✝² : AddCommGroup F
inst✝¹ : Module 𝕜₂ F
σ₁₂ : 𝕜 →+* 𝕜₂
inst✝ : RingHomIsometric σ₁₂
q : SeminormFamily 𝕜₂ F ι
s : Finset ι
f : E →ₛₗ[σ₁₂] F
x : E
⊢ ↑(Finset.sup s fun i => { val := ↑(q i) (↑f x), property := (_ : 0 ≤ ↑(q i) (↑f x)) }) =
    ↑(Finset.sup s fun i => { val := ↑(comp q f i) x, property := (_ : 0 ≤ ↑(comp q f i) x) })
Theorem: MeasureTheory.Lp.tendsto_Lp_iff_tendsto_ℒp
File: Mathlib/MeasureTheory/Function/LpSpace.lean

tactic: rw [tendsto_Lp_iff_tendsto_ℒp']
state_before: α : Type u_2
E : Type u_3
F : Type ?u.8125054
G : Type ?u.8125057
m m0 : MeasurableSpace α
p : ℝ≥0∞
q : ℝ
μ ν : Measure α
inst✝³ : NormedAddCommGroup E
inst✝² : NormedAddCommGroup F
inst✝¹ : NormedAddCommGroup G
ι : Type u_1
fi : Filter ι
inst✝ : Fact (1 ≤ p)
f : ι → { x // x ∈ Lp E p }
f_lim : α → E
f_lim_ℒp : Memℒp f_lim p
⊢ Tendsto f fi (𝓝 (Memℒp.toLp f_lim f_lim_ℒp)) ↔ Tendsto (fun n => snorm (↑↑(f n) - f_lim) p μ) fi (𝓝 0)

tactic: suffices h_eq :
  (fun n => snorm (⇑(f n) - ⇑(Memℒp.toLp f_lim f_lim_ℒp)) p μ) =
    (fun n => snorm (⇑(f n) - f_lim) p μ)
state_before: α : Type u_2
E : Type u_3
F : Type ?u.8125054
G : Type ?u.8125057
m m0 : MeasurableSpace α
p : ℝ≥0∞
q : ℝ
μ ν : Measure α
inst✝³ : NormedAddCommGroup E
inst✝² : NormedAddCommGroup F
inst✝¹ : NormedAddCommGroup G
ι : Type u_1
fi : Filter ι
inst✝ : Fact (1 ≤ p)
f : ι → { x // x ∈ Lp E p }
f_lim : α → E
f_lim_ℒp : Memℒp f_lim p
⊢ Tendsto (fun n => snorm (↑↑(f n) - ↑↑(Memℒp.toLp f_lim f_lim_ℒp)) p μ) fi (𝓝 0) ↔
    Tendsto (fun n => snorm (↑↑(f n) - f_lim) p μ) fi (𝓝 0)

tactic: exact funext fun n => snorm_congr_ae (EventuallyEq.rfl.sub (Memℒp.coeFn_toLp f_lim_ℒp))
state_before: case h_eq
α : Type u_2
E : Type u_3
F : Type ?u.8125054
G : Type ?u.8125057
m m0 : MeasurableSpace α
p : ℝ≥0∞
q : ℝ
μ ν : Measure α
inst✝³ : NormedAddCommGroup E
inst✝² : NormedAddCommGroup F
inst✝¹ : NormedAddCommGroup G
ι : Type u_1
fi : Filter ι
inst✝ : Fact (1 ≤ p)
f : ι → { x // x ∈ Lp E p }
f_lim : α → E
f_lim_ℒp : Memℒp f_lim p
⊢ (fun n => snorm (↑↑(f n) - ↑↑(Memℒp.toLp f_lim f_lim_ℒp)) p μ) = fun n => snorm (↑↑(f n) - f_lim) p μ

tactic: rw [h_eq]
state_before: α : Type u_2
E : Type u_3
F : Type ?u.8125054
G : Type ?u.8125057
m m0 : MeasurableSpace α
p : ℝ≥0∞
q : ℝ
μ ν : Measure α
inst✝³ : NormedAddCommGroup E
inst✝² : NormedAddCommGroup F
inst✝¹ : NormedAddCommGroup G
ι : Type u_1
fi : Filter ι
inst✝ : Fact (1 ≤ p)
f : ι → { x // x ∈ Lp E p }
f_lim : α → E
f_lim_ℒp : Memℒp f_lim p
h_eq : (fun n => snorm (↑↑(f n) - ↑↑(Memℒp.toLp f_lim f_lim_ℒp)) p μ) = fun n => snorm (↑↑(f n) - f_lim) p μ
⊢ Tendsto (fun n => snorm (↑↑(f n) - ↑↑(Memℒp.toLp f_lim f_lim_ℒp)) p μ) fi (𝓝 0) ↔
    Tendsto (fun n => snorm (↑↑(f n) - f_lim) p μ) fi (𝓝 0)
Theorem: MeasureTheory.measure_iUnion_fintype_le
File: Mathlib/MeasureTheory/Measure/MeasureSpaceDef.lean

tactic: convert measure_biUnion_finset_le Finset.univ f
state_before: α : Type u_2
β : Type u_1
γ : Type ?u.19449
δ : Type ?u.19452
ι : Type ?u.19455
inst✝¹ : MeasurableSpace α
μ μ₁ μ₂ : Measure α
s s₁ s₂ t : Set α
inst✝ : Fintype β
f : β → Set α
⊢ ↑↑μ (⋃ (b : β), f b) ≤ ∑ p : β, ↑↑μ (f p)

tactic: simp
state_before: case h.e'_3.h.e'_3.h.e'_3.h
α : Type u_2
β : Type u_1
γ : Type ?u.19449
δ : Type ?u.19452
ι : Type ?u.19455
inst✝¹ : MeasurableSpace α
μ μ₁ μ₂ : Measure α
s s₁ s₂ t : Set α
inst✝ : Fintype β
f : β → Set α
x✝ : β
⊢ f x✝ = ⋃ (_ : x✝ ∈ Finset.univ), f x✝
Theorem: isIntegral_of_pow
File: Mathlib/RingTheory/IntegralClosure.lean

tactic: rcases hx with ⟨p, ⟨hmonic, heval⟩⟩
state_before: R : Type u_1
A : Type u_2
B : Type ?u.664590
S : Type ?u.664593
inst✝⁵ : CommRing R
inst✝⁴ : CommRing A
inst✝³ : CommRing B
inst✝² : CommRing S
inst✝¹ : Algebra R A
inst✝ : Algebra R B
f : R →+* S
x : A
n : ℕ
hn : 0 < n
hx : IsIntegral R (x ^ n)
⊢ IsIntegral R x

tactic: exact
  ⟨expand R n p, Monic.expand hn hmonic, by
    rwa [eval₂_eq_eval_map, map_expand, expand_eval, ← eval₂_eq_eval_map]⟩
state_before: case intro.intro
R : Type u_1
A : Type u_2
B : Type ?u.664590
S : Type ?u.664593
inst✝⁵ : CommRing R
inst✝⁴ : CommRing A
inst✝³ : CommRing B
inst✝² : CommRing S
inst✝¹ : Algebra R A
inst✝ : Algebra R B
f : R →+* S
x : A
n : ℕ
hn : 0 < n
p : R[X]
hmonic : Monic p
heval : eval₂ (algebraMap R A) (x ^ n) p = 0
⊢ IsIntegral R x

tactic: rwa [eval₂_eq_eval_map, map_expand, expand_eval, ← eval₂_eq_eval_map]
state_before: R : Type u_1
A : Type u_2
B : Type ?u.664590
S : Type ?u.664593
inst✝⁵ : CommRing R
inst✝⁴ : CommRing A
inst✝³ : CommRing B
inst✝² : CommRing S
inst✝¹ : Algebra R A
inst✝ : Algebra R B
f : R →+* S
x : A
n : ℕ
hn : 0 < n
p : R[X]
hmonic : Monic p
heval : eval₂ (algebraMap R A) (x ^ n) p = 0
⊢ eval₂ (algebraMap R A) x (↑(expand R n) p) = 0
Theorem: Finset.piecewise_insert
File: Mathlib/Data/Finset/Basic.lean

tactic: classical simp only [← piecewise_coe, coe_insert, ← Set.piecewise_insert]
state_before: α : Type u_1
β : Type ?u.298194
γ : Type ?u.298197
δ : α → Sort u_2
s : Finset α
f g : (i : α) → δ i
inst✝² : (j : α) → Decidable (j ∈ s)
inst✝¹ : DecidableEq α
j : α
inst✝ : (i : α) → Decidable (i ∈ insert j s)
⊢ piecewise (insert j s) f g = update (piecewise s f g) j (f j)

tactic: ext
state_before: α : Type u_1
β : Type ?u.298194
γ : Type ?u.298197
δ : α → Sort u_2
s : Finset α
f g : (i : α) → δ i
inst✝² : (j : α) → Decidable (j ∈ s)
inst✝¹ : DecidableEq α
j : α
inst✝ : (i : α) → Decidable (i ∈ insert j s)
⊢ Set.piecewise (↑(insert j s)) f g = Set.piecewise (insert j ↑s) f g

tactic: congr
state_before: case h
α : Type u_1
β : Type ?u.298194
γ : Type ?u.298197
δ : α → Sort u_2
s : Finset α
f g : (i : α) → δ i
inst✝² : (j : α) → Decidable (j ∈ s)
inst✝¹ : DecidableEq α
j : α
inst✝ : (i : α) → Decidable (i ∈ insert j s)
x✝ : α
⊢ Set.piecewise (↑(insert j s)) f g x✝ = Set.piecewise (insert j ↑s) f g x✝

tactic: simp
state_before: case h.e_s
α : Type u_1
β : Type ?u.298194
γ : Type ?u.298197
δ : α → Sort u_2
s : Finset α
f g : (i : α) → δ i
inst✝² : (j : α) → Decidable (j ∈ s)
inst✝¹ : DecidableEq α
j : α
inst✝ : (i : α) → Decidable (i ∈ insert j s)
x✝ : α
⊢ ↑(insert j s) = insert j ↑s

tactic: simp only [← piecewise_coe, coe_insert, ← Set.piecewise_insert]
state_before: α : Type u_1
β : Type ?u.298194
γ : Type ?u.298197
δ : α → Sort u_2
s : Finset α
f g : (i : α) → δ i
inst✝² : (j : α) → Decidable (j ∈ s)
inst✝¹ : DecidableEq α
j : α
inst✝ : (i : α) → Decidable (i ∈ insert j s)
⊢ piecewise (insert j s) f g = update (piecewise s f g) j (f j)
Theorem: List.insert_of_mem
File: Std/Data/List/Lemmas.lean

tactic: simp only [List.insert, if_pos h]
state_before: α : Type u_1
inst✝ : DecidableEq α
a : α
l : List α
h : a ∈ l
⊢ List.insert a l = l
Theorem: Matrix.blockDiagonal_zero
File: Mathlib/Data/Matrix/Block.lean

tactic: ext
state_before: l : Type ?u.135132
m : Type u_1
n : Type u_2
o : Type u_3
p : Type ?u.135144
q : Type ?u.135147
m' : o → Type ?u.135152
n' : o → Type ?u.135157
p' : o → Type ?u.135162
R : Type ?u.135165
S : Type ?u.135168
α : Type u_4
β : Type ?u.135174
inst✝² : DecidableEq o
inst✝¹ : Zero α
inst✝ : Zero β
⊢ blockDiagonal 0 = 0

tactic: simp [blockDiagonal_apply]
state_before: case a.h
l : Type ?u.135132
m : Type u_1
n : Type u_2
o : Type u_3
p : Type ?u.135144
q : Type ?u.135147
m' : o → Type ?u.135152
n' : o → Type ?u.135157
p' : o → Type ?u.135162
R : Type ?u.135165
S : Type ?u.135168
α : Type u_4
β : Type ?u.135174
inst✝² : DecidableEq o
inst✝¹ : Zero α
inst✝ : Zero β
i✝ : m × o
x✝ : n × o
⊢ blockDiagonal 0 i✝ x✝ = OfNat.ofNat 0 i✝ x✝