tasksource/leandojo huggingface dataset:
Theorem: BoundedContinuousFunction.NNReal.toReal_lintegral_eq_integral
File: Mathlib/MeasureTheory/Measure/FiniteMeasure.lean

tactic: rw [integral_eq_lintegral_of_nonneg_ae _ (by simpa [Function.comp_apply] using
      (NNReal.continuous_coe.comp f.continuous).measurable.aestronglyMeasurable)]
state_before: Ω : Type u_1
inst✝² : MeasurableSpace Ω
inst✝¹ : TopologicalSpace Ω
inst✝ : OpensMeasurableSpace Ω
f : Ω →ᵇ ℝ≥0
μ : Measure Ω
⊢ ENNReal.toReal (∫⁻ (x : Ω), ↑(↑f x) ∂μ) = ∫ (x : Ω), ↑(↑f x) ∂μ

tactic: simpa [Function.comp_apply] using
(NNReal.continuous_coe.comp f.continuous).measurable.aestronglyMeasurable
state_before: Ω : Type u_1
inst✝² : MeasurableSpace Ω
inst✝¹ : TopologicalSpace Ω
inst✝ : OpensMeasurableSpace Ω
f : Ω →ᵇ ℝ≥0
μ : Measure Ω
⊢ AEStronglyMeasurable (fun x => ↑(↑f x)) μ

tactic: simp only [ENNReal.ofReal_coe_nnreal]
state_before: Ω : Type u_1
inst✝² : MeasurableSpace Ω
inst✝¹ : TopologicalSpace Ω
inst✝ : OpensMeasurableSpace Ω
f : Ω →ᵇ ℝ≥0
μ : Measure Ω
⊢ ENNReal.toReal (∫⁻ (x : Ω), ↑(↑f x) ∂μ) = ENNReal.toReal (∫⁻ (a : Ω), ENNReal.ofReal ↑(↑f a) ∂μ)

tactic: apply eventually_of_forall
state_before: Ω : Type u_1
inst✝² : MeasurableSpace Ω
inst✝¹ : TopologicalSpace Ω
inst✝ : OpensMeasurableSpace Ω
f : Ω →ᵇ ℝ≥0
μ : Measure Ω
⊢ 0 ≤ᵐ[μ] fun x => ↑(↑f x)

tactic: simp only [Pi.zero_apply, NNReal.zero_le_coe, imp_true_iff]
state_before: case hp
Ω : Type u_1
inst✝² : MeasurableSpace Ω
inst✝¹ : TopologicalSpace Ω
inst✝ : OpensMeasurableSpace Ω
f : Ω →ᵇ ℝ≥0
μ : Measure Ω
⊢ ∀ (x : Ω), OfNat.ofNat 0 x ≤ (fun x => ↑(↑f x)) x
Theorem: Turing.PartrecToTM2.unrev_ok
File: Mathlib/Computability/TMToPartrec.lean

tactic: decide
state_before: q : Λ'
s : Option Γ'
S : K' → List Γ'
⊢ rev ≠ main
Theorem: Filter.map₂_pure_right
File: Mathlib/Order/Filter/NAry.lean

tactic: rw [image2_singleton_right, image_subset_iff]
state_before: α : Type u_2
α' : Type ?u.28301
β : Type u_3
β' : Type ?u.28307
γ : Type u_1
γ' : Type ?u.28313
δ : Type ?u.28316
δ' : Type ?u.28319
ε : Type ?u.28322
ε' : Type ?u.28325
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 : γ
u : Set γ
h : u ∈ map (fun a => m a b) f
⊢ image2 m ((fun a => m a b) ⁻¹' u) {b} ⊆ u
Theorem: sup_iSup_nat_succ
File: Mathlib/Order/CompleteLattice.lean

tactic: rw [Nat.zero_union_range_succ, iSup_univ]
state_before: α : Type u_1
β : Type ?u.180415
β₂ : Type ?u.180418
γ : Type ?u.180421
ι : Sort ?u.180424
ι' : Sort ?u.180427
κ : ι → Sort ?u.180432
κ' : ι' → Sort ?u.180437
inst✝ : CompleteLattice α
f g s t : ι → α
a b : α
u : ℕ → α
⊢ (⨆ (x : ℕ) (_ : x ∈ {0} ∪ range Nat.succ), u x) = ⨆ (i : ℕ), u i
Theorem: normalizeScaleRoots_degree
File: Mathlib/RingTheory/IntegralClosure.lean

tactic: apply le_antisymm
state_before: R : Type u_1
A : Type ?u.886014
B : Type ?u.886017
S : Type ?u.886020
inst✝⁵ : CommRing R
inst✝⁴ : CommRing A
inst✝³ : CommRing B
inst✝² : CommRing S
inst✝¹ : Algebra R A
inst✝ : Algebra R B
f : R →+* S
p : R[X]
x : S
⊢ degree (normalizeScaleRoots p) = degree p

tactic: exact Finset.sup_mono (normalizeScaleRoots_support p)
state_before: case a
R : Type u_1
A : Type ?u.886014
B : Type ?u.886017
S : Type ?u.886020
inst✝⁵ : CommRing R
inst✝⁴ : CommRing A
inst✝³ : CommRing B
inst✝² : CommRing S
inst✝¹ : Algebra R A
inst✝ : Algebra R B
f : R →+* S
p : R[X]
x : S
⊢ degree (normalizeScaleRoots p) ≤ degree p

tactic: rw [← degree_scaleRoots, ← leadingCoeff_smul_normalizeScaleRoots]
state_before: case a
R : Type u_1
A : Type ?u.886014
B : Type ?u.886017
S : Type ?u.886020
inst✝⁵ : CommRing R
inst✝⁴ : CommRing A
inst✝³ : CommRing B
inst✝² : CommRing S
inst✝¹ : Algebra R A
inst✝ : Algebra R B
f : R →+* S
p : R[X]
x : S
⊢ degree p ≤ degree (normalizeScaleRoots p)

tactic: exact degree_smul_le _ _
state_before: case a
R : Type u_1
A : Type ?u.886014
B : Type ?u.886017
S : Type ?u.886020
inst✝⁵ : CommRing R
inst✝⁴ : CommRing A
inst✝³ : CommRing B
inst✝² : CommRing S
inst✝¹ : Algebra R A
inst✝ : Algebra R B
f : R →+* S
p : R[X]
x : S
⊢ degree (leadingCoeff p • normalizeScaleRoots p) ≤ degree (normalizeScaleRoots p)
Theorem: CategoryTheory.Limits.hasEqualizer_of_common_retraction
File: Mathlib/CategoryTheory/Limits/Shapes/Reflexive.lean

tactic: letI := IsCoreflexivePair.mk' r fr gr
state_before: C : Type u
inst✝² : Category C
D : Type u₂
inst✝¹ : Category D
A✝ B✝ : C
f✝ g✝ : A✝ ⟶ B✝
F : C ⥤ D
G : D ⥤ C
adj : F ⊣ G
inst✝ : HasCoreflexiveEqualizers C
A B : C
f g : A ⟶ B
r : B ⟶ A
fr : f ≫ r = 𝟙 A
gr : g ≫ r = 𝟙 A
⊢ HasEqualizer f g

tactic: infer_instance
state_before: C : Type u
inst✝² : Category C
D : Type u₂
inst✝¹ : Category D
A✝ B✝ : C
f✝ g✝ : A✝ ⟶ B✝
F : C ⥤ D
G : D ⥤ C
adj : F ⊣ G
inst✝ : HasCoreflexiveEqualizers C
A B : C
f g : A ⟶ B
r : B ⟶ A
fr : f ≫ r = 𝟙 A
gr : g ≫ r = 𝟙 A
this : IsCoreflexivePair f g := IsCoreflexivePair.mk' r fr gr
⊢ HasEqualizer f g
Theorem: MeasureTheory.lintegral_const_mul_le
File: Mathlib/MeasureTheory/Integral/Lebesgue.lean

tactic: rw [lintegral, ENNReal.mul_iSup]
state_before: α : Type u_1
β : Type ?u.935860
γ : Type ?u.935863
δ : Type ?u.935866
m : MeasurableSpace α
μ ν : Measure α
r : ℝ≥0∞
f : α → ℝ≥0∞
⊢ (r * ∫⁻ (a : α), f a ∂μ) ≤ ∫⁻ (a : α), r * f a ∂μ

tactic: refine' iSup_le fun s => _
state_before: α : Type u_1
β : Type ?u.935860
γ : Type ?u.935863
δ : Type ?u.935866
m : MeasurableSpace α
μ ν : Measure α
r : ℝ≥0∞
f : α → ℝ≥0∞
⊢ (⨆ (i : α →ₛ ℝ≥0∞), r * ⨆ (_ : ↑i ≤ fun a => f a), SimpleFunc.lintegral i μ) ≤ ∫⁻ (a : α), r * f a ∂μ

tactic: rw [ENNReal.mul_iSup]
state_before: α : Type u_1
β : Type ?u.935860
γ : Type ?u.935863
δ : Type ?u.935866
m : MeasurableSpace α
μ ν : Measure α
r : ℝ≥0∞
f : α → ℝ≥0∞
s : α →ₛ ℝ≥0∞
⊢ (r * ⨆ (_ : ↑s ≤ fun a => f a), SimpleFunc.lintegral s μ) ≤ ∫⁻ (a : α), r * f a ∂μ

tactic: simp only [iSup_le_iff]
state_before: α : Type u_1
β : Type ?u.935860
γ : Type ?u.935863
δ : Type ?u.935866
m : MeasurableSpace α
μ ν : Measure α
r : ℝ≥0∞
f : α → ℝ≥0∞
s : α →ₛ ℝ≥0∞
⊢ (⨆ (_ : ↑s ≤ fun a => f a), r * SimpleFunc.lintegral s μ) ≤ ∫⁻ (a : α), r * f a ∂μ

tactic: intro hs
state_before: α : Type u_1
β : Type ?u.935860
γ : Type ?u.935863
δ : Type ?u.935866
m : MeasurableSpace α
μ ν : Measure α
r : ℝ≥0∞
f : α → ℝ≥0∞
s : α →ₛ ℝ≥0∞
⊢ (↑s ≤ fun a => f a) → r * SimpleFunc.lintegral s μ ≤ ∫⁻ (a : α), r * f a ∂μ

tactic: rw [← SimpleFunc.const_mul_lintegral, lintegral]
state_before: α : Type u_1
β : Type ?u.935860
γ : Type ?u.935863
δ : Type ?u.935866
m : MeasurableSpace α
μ ν : Measure α
r : ℝ≥0∞
f : α → ℝ≥0∞
s : α →ₛ ℝ≥0∞
hs : ↑s ≤ fun a => f a
⊢ r * SimpleFunc.lintegral s μ ≤ ∫⁻ (a : α), r * f a ∂μ

tactic: refine' le_iSup_of_le (const α r * s) (le_iSup_of_le (fun x => _) le_rfl)
state_before: α : Type u_1
β : Type ?u.935860
γ : Type ?u.935863
δ : Type ?u.935866
m : MeasurableSpace α
μ ν : Measure α
r : ℝ≥0∞
f : α → ℝ≥0∞
s : α →ₛ ℝ≥0∞
hs : ↑s ≤ fun a => f a
⊢ SimpleFunc.lintegral (const α r * s) μ ≤ ⨆ (g : α →ₛ ℝ≥0∞) (_ : ↑g ≤ fun a => r * f a), SimpleFunc.lintegral g μ

tactic: exact mul_le_mul_left' (hs x) _
state_before: α : Type u_1
β : Type ?u.935860
γ : Type ?u.935863
δ : Type ?u.935866
m : MeasurableSpace α
μ ν : Measure α
r : ℝ≥0∞
f : α → ℝ≥0∞
s : α →ₛ ℝ≥0∞
hs : ↑s ≤ fun a => f a
x : α
⊢ ↑(const α r * s) x ≤ (fun a => r * f a) x
Theorem: pow_mul_pow_sub
File: Mathlib/Algebra/GroupPower/Basic.lean

tactic: rw [← pow_add, Nat.add_comm, Nat.sub_add_cancel h]
state_before: α : Type ?u.24421
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
m n : ℕ
h : m ≤ n
⊢ a ^ m * a ^ (n - m) = a ^ n
Theorem: Subsemiring.coe_iSup_of_directed
File: Mathlib/RingTheory/Subsemiring/Basic.lean

tactic: simp [mem_iSup_of_directed hS]
state_before: R : Type u
S✝ : Type v
T : Type w
inst✝² : NonAssocSemiring R
M : Submonoid R
inst✝¹ : NonAssocSemiring S✝
inst✝ : NonAssocSemiring T
ι : Sort u_1
hι : Nonempty ι
S : ι → Subsemiring R
hS : Directed (fun x x_1 => x ≤ x_1) S
x : R
⊢ x ∈ ↑(⨆ (i : ι), S i) ↔ x ∈ ⋃ (i : ι), ↑(S i)
Theorem: Zsqrtd.norm_zero
File: Mathlib/NumberTheory/Zsqrtd/Basic.lean

tactic: simp [norm]
state_before: d : ℤ
⊢ norm 0 = 0
Theorem: Pretrivialization.coe_linearMapAt
File: Mathlib/Topology/VectorBundle/Basic.lean

tactic: rw [Pretrivialization.linearMapAt]
state_before: R : Type u_4
B : Type u_1
F : Type u_2
E : B → Type u_3
inst✝⁷ : Semiring R
inst✝⁶ : TopologicalSpace F
inst✝⁵ : TopologicalSpace B
e✝ : Pretrivialization F TotalSpace.proj
x : TotalSpace E
b✝ : B
y : E b✝
inst✝⁴ : AddCommMonoid F
inst✝³ : Module R F
inst✝² : (x : B) → AddCommMonoid (E x)
inst✝¹ : (x : B) → Module R (E x)
e : Pretrivialization F TotalSpace.proj
inst✝ : Pretrivialization.IsLinear R e
b : B
⊢ ↑(Pretrivialization.linearMapAt R e b) = fun y => if b ∈ e.baseSet then (↑e (totalSpaceMk b y)).snd else 0

tactic: split_ifs <;> rfl
state_before: R : Type u_4
B : Type u_1
F : Type u_2
E : B → Type u_3
inst✝⁷ : Semiring R
inst✝⁶ : TopologicalSpace F
inst✝⁵ : TopologicalSpace B
e✝ : Pretrivialization F TotalSpace.proj
x : TotalSpace E
b✝ : B
y : E b✝
inst✝⁴ : AddCommMonoid F
inst✝³ : Module R F
inst✝² : (x : B) → AddCommMonoid (E x)
inst✝¹ : (x : B) → Module R (E x)
e : Pretrivialization F TotalSpace.proj
inst✝ : Pretrivialization.IsLinear R e
b : B
⊢ ↑(if hb : b ∈ e.baseSet then ↑(linearEquivAt R e b hb) else 0) = fun y =>
    if b ∈ e.baseSet then (↑e (totalSpaceMk b y)).snd else 0
Theorem: CategoryTheory.Limits.imageSubobject_le
File: Mathlib/CategoryTheory/Subobject/Limits.lean

tactic: rw [assoc, image.lift_fac, imageSubobject_arrow]
state_before: C : Type u
inst✝² : Category C
X✝ Y Z : C
f✝ : X✝ ⟶ Y
inst✝¹ : HasImage f✝
A B : C
X : Subobject B
f : A ⟶ B
inst✝ : HasImage f
h : A ⟶ underlying.obj X
w : h ≫ arrow X = f
⊢ ((imageSubobjectIso f).hom ≫ image.lift (MonoFactorisation.mk (underlying.obj X) (arrow X) h)) ≫ arrow X =
    arrow (imageSubobject f)
Theorem: ContDiffAt.differentiableAt
File: Mathlib/Analysis/Calculus/ContDiffDef.lean

tactic: simpa [hn, differentiableWithinAt_univ] using h.differentiableWithinAt
state_before: 𝕜 : Type u
inst✝⁸ : NontriviallyNormedField 𝕜
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type uX
inst✝¹ : NormedAddCommGroup X
inst✝ : NormedSpace 𝕜 X
s s₁ t u : Set E
f f₁ : E → F
g : F → G
x x₀ : E
c : F
m n : ℕ∞
p : E → FormalMultilinearSeries 𝕜 E F
h : ContDiffAt 𝕜 n f x
hn : 1 ≤ n
⊢ DifferentiableAt 𝕜 f x
Theorem: Pmf.uniformOfFintype_apply
File: Mathlib/Probability/ProbabilityMassFunction/Uniform.lean

tactic: simp [uniformOfFintype, Finset.mem_univ, if_true, uniformOfFinset_apply]
state_before: α : Type u_1
β : Type ?u.17026
γ : Type ?u.17029
inst✝¹ : Fintype α
inst✝ : Nonempty α
a : α
⊢ ↑(uniformOfFintype α) a = (↑(Fintype.card α))⁻¹

tactic: rfl
state_before: α : Type u_1
β : Type ?u.17026
γ : Type ?u.17029
inst✝¹ : Fintype α
inst✝ : Nonempty α
a : α
⊢ Finset.card Finset.univ = Fintype.card α
Theorem: ContinuousAffineMap.mk_coe
File: Mathlib/Topology/Algebra/ContinuousAffineMap.lean

tactic: ext
state_before: R : Type u_1
V : Type u_2
W : Type u_3
P : Type u_4
Q : Type u_5
inst✝⁸ : Ring R
inst✝⁷ : AddCommGroup V
inst✝⁶ : Module R V
inst✝⁵ : TopologicalSpace P
inst✝⁴ : AddTorsor V P
inst✝³ : AddCommGroup W
inst✝² : Module R W
inst✝¹ : TopologicalSpace Q
inst✝ : AddTorsor W Q
f : P →A[R] Q
h : Continuous f.toFun
⊢ { toAffineMap := f.toAffineMap, cont := h } = f

tactic: rfl
state_before: case h
R : Type u_1
V : Type u_2
W : Type u_3
P : Type u_4
Q : Type u_5
inst✝⁸ : Ring R
inst✝⁷ : AddCommGroup V
inst✝⁶ : Module R V
inst✝⁵ : TopologicalSpace P
inst✝⁴ : AddTorsor V P
inst✝³ : AddCommGroup W
inst✝² : Module R W
inst✝¹ : TopologicalSpace Q
inst✝ : AddTorsor W Q
f : P →A[R] Q
h : Continuous f.toFun
x✝ : P
⊢ ↑{ toAffineMap := f.toAffineMap, cont := h } x✝ = ↑f x✝
Theorem: Real.hasStrictDerivAt_rpow_const_of_ne
File: Mathlib/Analysis/SpecialFunctions/Pow/Deriv.lean

tactic: cases' hx.lt_or_lt with hx hx
state_before: x✝ y z x : ℝ
hx : x ≠ 0
p : ℝ
⊢ HasStrictDerivAt (fun x => x ^ p) (p * x ^ (p - 1)) x

tactic: have := (hasStrictFDerivAt_rpow_of_neg (x, p) hx).comp_hasStrictDerivAt x
  ((hasStrictDerivAt_id x).prod (hasStrictDerivAt_const _ _))
state_before: case inl
x✝ y z x : ℝ
hx✝ : x ≠ 0
p : ℝ
hx : x < 0
⊢ HasStrictDerivAt (fun x => x ^ p) (p * x ^ (p - 1)) x

tactic: convert this using 1
state_before: case inl
x✝ y z x : ℝ
hx✝ : x ≠ 0
p : ℝ
hx : x < 0
this :
  HasStrictDerivAt ((fun x => x.fst ^ x.snd) ∘ fun x => (id x, p))
    (↑(((x, p).snd * (x, p).fst ^ ((x, p).snd - 1)) • ContinuousLinearMap.fst ℝ ℝ ℝ +
          ((x, p).fst ^ (x, p).snd * log (x, p).fst - exp (log (x, p).fst * (x, p).snd) * sin ((x, p).snd * π) * π) •
            ContinuousLinearMap.snd ℝ ℝ ℝ)
      (1, 0))
    x
⊢ HasStrictDerivAt (fun x => x ^ p) (p * x ^ (p - 1)) x

tactic: simp
state_before: case h.e'_7
x✝ y z x : ℝ
hx✝ : x ≠ 0
p : ℝ
hx : x < 0
this :
  HasStrictDerivAt ((fun x => x.fst ^ x.snd) ∘ fun x => (id x, p))
    (↑(((x, p).snd * (x, p).fst ^ ((x, p).snd - 1)) • ContinuousLinearMap.fst ℝ ℝ ℝ +
          ((x, p).fst ^ (x, p).snd * log (x, p).fst - exp (log (x, p).fst * (x, p).snd) * sin ((x, p).snd * π) * π) •
            ContinuousLinearMap.snd ℝ ℝ ℝ)
      (1, 0))
    x
⊢ p * x ^ (p - 1) =
    ↑(((x, p).snd * (x, p).fst ^ ((x, p).snd - 1)) • ContinuousLinearMap.fst ℝ ℝ ℝ +
          ((x, p).fst ^ (x, p).snd * log (x, p).fst - exp (log (x, p).fst * (x, p).snd) * sin ((x, p).snd * π) * π) •
            ContinuousLinearMap.snd ℝ ℝ ℝ)
      (1, 0)

tactic: simpa using (hasStrictDerivAt_id x).rpow (hasStrictDerivAt_const x p) hx
state_before: case inr
x✝ y z x : ℝ
hx✝ : x ≠ 0
p : ℝ
hx : 0 < x
⊢ HasStrictDerivAt (fun x => x ^ p) (p * x ^ (p - 1)) x
Theorem: MulChar.IsNontrivial.comp
File: Mathlib/NumberTheory/LegendreSymbol/MulCharacter.lean

tactic: obtain ⟨a, ha⟩ := hχ
state_before: R : Type u
inst✝² : CommRing R
R' : Type v
inst✝¹ : CommRing R'
R'' : Type w
inst✝ : CommRing R''
χ : MulChar R R'
hχ : IsNontrivial χ
f : R' →+* R''
hf : Function.Injective ↑f
⊢ IsNontrivial (ringHomComp χ f)

tactic: use a
state_before: case intro
R : Type u
inst✝² : CommRing R
R' : Type v
inst✝¹ : CommRing R'
R'' : Type w
inst✝ : CommRing R''
χ : MulChar R R'
f : R' →+* R''
hf : Function.Injective ↑f
a : Rˣ
ha : ↑χ ↑a ≠ 1
⊢ IsNontrivial (ringHomComp χ f)

tactic: rw [ringHomComp_apply, ← RingHom.map_one f]
state_before: case intro
R : Type u
inst✝² : CommRing R
R' : Type v
inst✝¹ : CommRing R'
R'' : Type w
inst✝ : CommRing R''
χ : MulChar R R'
f : R' →+* R''
hf : Function.Injective ↑f
a : Rˣ
ha : ↑χ ↑a ≠ 1
⊢ ↑(ringHomComp χ f) ↑a ≠ 1

tactic: exact fun h => ha (hf h)
state_before: case intro
R : Type u
inst✝² : CommRing R
R' : Type v
inst✝¹ : CommRing R'
R'' : Type w
inst✝ : CommRing R''
χ : MulChar R R'
f : R' →+* R''
hf : Function.Injective ↑f
a : Rˣ
ha : ↑χ ↑a ≠ 1
⊢ ↑f (↑χ ↑a) ≠ ↑f 1
Theorem: MeasureTheory.SimpleFunc.eapprox_lt_top
File: Mathlib/MeasureTheory/Function/SimpleFunc.lean

tactic: simp only [eapprox, approx, finset_sup_apply, Finset.mem_range, ENNReal.bot_eq_zero, restrict]
state_before: α : Type u_1
β : Type ?u.834539
γ : Type ?u.834542
δ : Type ?u.834545
inst✝ : MeasurableSpace α
K : Type ?u.834551
f : α → ℝ≥0∞
n : ℕ
a : α
⊢ ↑(eapprox f n) a < ⊤

tactic: rw [Finset.sup_lt_iff (α := ℝ≥0∞) WithTop.zero_lt_top]
state_before: α : Type u_1
β : Type ?u.834539
γ : Type ?u.834542
δ : Type ?u.834545
inst✝ : MeasurableSpace α
K : Type ?u.834551
f : α → ℝ≥0∞
n : ℕ
a : α
⊢ (Finset.sup (Finset.range n) fun c =>
      ↑(if hs : MeasurableSet {a | ennrealRatEmbed c ≤ f a} then
            piecewise {a | ennrealRatEmbed c ≤ f a} hs (const α (ennrealRatEmbed c)) 0
          else 0)
        a) <
    ⊤

tactic: intro b _
state_before: α : Type u_1
β : Type ?u.834539
γ : Type ?u.834542
δ : Type ?u.834545
inst✝ : MeasurableSpace α
K : Type ?u.834551
f : α → ℝ≥0∞
n : ℕ
a : α
⊢ ∀ (b : ℕ),
    b ∈ Finset.range n →
      ↑(if hs : MeasurableSet {a | ennrealRatEmbed b ≤ f a} then
              piecewise {a | ennrealRatEmbed b ≤ f a} hs (const α (ennrealRatEmbed b)) 0
            else 0)
          a <
        ⊤

tactic: split_ifs
state_before: α : Type u_1
β : Type ?u.834539
γ : Type ?u.834542
δ : Type ?u.834545
inst✝ : MeasurableSpace α
K : Type ?u.834551
f : α → ℝ≥0∞
n : ℕ
a : α
b : ℕ
a✝ : b ∈ Finset.range n
⊢ ↑(if hs : MeasurableSet {a | ennrealRatEmbed b ≤ f a} then
          piecewise {a | ennrealRatEmbed b ≤ f a} hs (const α (ennrealRatEmbed b)) 0
        else 0)
      a <
    ⊤

tactic: simp only [coe_zero, coe_piecewise, piecewise_eq_indicator, coe_const]
state_before: case inl
α : Type u_1
β : Type ?u.834539
γ : Type ?u.834542
δ : Type ?u.834545
inst✝ : MeasurableSpace α
K : Type ?u.834551
f : α → ℝ≥0∞
n : ℕ
a : α
b : ℕ
a✝ : b ∈ Finset.range n
h✝ : MeasurableSet {a | ennrealRatEmbed b ≤ f a}
⊢ ↑(piecewise {a | ennrealRatEmbed b ≤ f a} h✝ (const α (ennrealRatEmbed b)) 0) a < ⊤

tactic: calc
  { a : α | ennrealRatEmbed b ≤ f a }.indicator (fun _ => ennrealRatEmbed b) a ≤
      ennrealRatEmbed b :=
    indicator_le_self _ _ a
  _ < ⊤ := ENNReal.coe_lt_top
state_before: case inl
α : Type u_1
β : Type ?u.834539
γ : Type ?u.834542
δ : Type ?u.834545
inst✝ : MeasurableSpace α
K : Type ?u.834551
f : α → ℝ≥0∞
n : ℕ
a : α
b : ℕ
a✝ : b ∈ Finset.range n
h✝ : MeasurableSet {a | ennrealRatEmbed b ≤ f a}
⊢ Set.piecewise {a | ennrealRatEmbed b ≤ f a} (Function.const α (ennrealRatEmbed b)) 0 a < ⊤

tactic: exact WithTop.zero_lt_top
state_before: case inr
α : Type u_1
β : Type ?u.834539
γ : Type ?u.834542
δ : Type ?u.834545
inst✝ : MeasurableSpace α
K : Type ?u.834551
f : α → ℝ≥0∞
n : ℕ
a : α
b : ℕ
a✝ : b ∈ Finset.range n
h✝ : ¬MeasurableSet {a | ennrealRatEmbed b ≤ f a}
⊢ ↑0 a < ⊤
Theorem: List.chain'_iff_nthLe
File: Mathlib/Data/List/Chain.lean

tactic: simp [nthLe]
state_before: α : Type u
β : Type v
R✝ r : α → α → Prop
l✝ l₁ l₂ : List α
a b : α
R : α → α → Prop
l : List α
⊢ (∀ (i : ℕ) (h : i < length l - 1),
      R (get l { val := i, isLt := (_ : i < length l) }) (get l { val := i + 1, isLt := (_ : succ i < length l) })) ↔
    ∀ (i : ℕ) (h : i < length l - 1), R (nthLe l i (_ : i < length l)) (nthLe l (i + 1) (_ : succ i < length l))
Theorem: LieIdeal.map_sup_ker_eq_map'
File: Mathlib/Algebra/Lie/Submodule.lean

tactic: simpa using map_sup_ker_eq_map (f := f)
state_before: R : Type u
L : Type v
L' : Type w₂
M : Type w
M' : Type w₁
inst✝¹² : CommRing R
inst✝¹¹ : LieRing L
inst✝¹⁰ : LieAlgebra R L
inst✝⁹ : LieRing L'
inst✝⁸ : LieAlgebra R L'
inst✝⁷ : AddCommGroup M
inst✝⁶ : Module R M
inst✝⁵ : LieRingModule L M
inst✝⁴ : LieModule R L M
inst✝³ : AddCommGroup M'
inst✝² : Module R M'
inst✝¹ : LieRingModule L M'
inst✝ : LieModule R L M'
f : L →ₗ⁅R⁆ L'
I : LieIdeal R L
J : LieIdeal R L'
⊢ map f I ⊔ map f (LieHom.ker f) = map f I
Theorem: Set.range_list_map_coe
File: Mathlib/Data/Set/List.lean

tactic: rw [range_list_map, Subtype.range_coe]
state_before: α : Type u_1
β : Type ?u.559
l : List α
s : Set α
⊢ range (map Subtype.val) = {l | ∀ (x : α), x ∈ l → x ∈ s}
Theorem: NNReal.tendsto_tsum_compl_atTop_zero
File: Mathlib/Topology/Instances/NNReal.lean

tactic: simp_rw [← tendsto_coe, coe_tsum, NNReal.coe_zero]
state_before: α : Type u_1
f : α → ℝ≥0
⊢ Tendsto (fun s => ∑' (b : { x // ¬x ∈ s }), f ↑b) atTop (𝓝 0)

tactic: exact tendsto_tsum_compl_atTop_zero fun a : α => (f a : ℝ)
state_before: α : Type u_1
f : α → ℝ≥0
⊢ Tendsto (fun a => ∑' (a_1 : { x // ¬x ∈ a }), ↑(f ↑a_1)) atTop (𝓝 0)
Theorem: CategoryTheory.kernel.ι_op
File: Mathlib/CategoryTheory/Abelian/Opposite.lean

tactic: simp [kernelOpUnop]
state_before: C : Type u_2
inst✝¹ : Category C
inst✝ : Abelian C
X Y : C
f : X ⟶ Y
A B : Cᵒᵖ
g : A ⟶ B
⊢ (kernel.ι f.op).unop = eqToHom (_ : Y.op.unop = Y) ≫ cokernel.π f ≫ (kernelOpUnop f).inv
Theorem: Matrix.dotProduct_self_star_eq_zero
File: Mathlib/LinearAlgebra/Matrix/DotProduct.lean

tactic: simp [Function.funext_iff, mul_eq_zero]
state_before: R : Type v
n : Type w
inst✝⁴ : Fintype n
inst✝³ : PartialOrder R
inst✝² : NonUnitalRing R
inst✝¹ : StarOrderedRing R
inst✝ : NoZeroDivisors R
v : n → R
⊢ (∀ (i : n), i ∈ Finset.univ → v i * star (v i) = 0) ↔ v = 0
Theorem: AffineSubspace.vsub_left_mem_direction_iff_mem
File: Mathlib/LinearAlgebra/AffineSpace/AffineSubspace.lean

tactic: rw [mem_direction_iff_eq_vsub_left hp]
state_before: k : Type u_1
V : Type u_2
P : Type u_3
inst✝³ : Ring k
inst✝² : AddCommGroup V
inst✝¹ : Module k V
inst✝ : AffineSpace V P
s : AffineSubspace k P
p : P
hp : p ∈ s
p2 : P
⊢ p -ᵥ p2 ∈ direction s ↔ p2 ∈ s

tactic: simp
state_before: k : Type u_1
V : Type u_2
P : Type u_3
inst✝³ : Ring k
inst✝² : AddCommGroup V
inst✝¹ : Module k V
inst✝ : AffineSpace V P
s : AffineSubspace k P
p : P
hp : p ∈ s
p2 : P
⊢ (∃ p2_1, p2_1 ∈ s ∧ p -ᵥ p2 = p -ᵥ p2_1) ↔ p2 ∈ s
Theorem: ENat.nat_induction
File: Mathlib/Data/ENat/Basic.lean

tactic: have A : ∀ n : ℕ, P n := fun n => Nat.recOn n h0 hsuc
state_before: m n : ℕ∞
P : ℕ∞ → Prop
a : ℕ∞
h0 : P 0
hsuc : ∀ (n : ℕ), P ↑n → P ↑(Nat.succ n)
htop : (∀ (n : ℕ), P ↑n) → P ⊤
⊢ P a

tactic: cases a
state_before: m n : ℕ∞
P : ℕ∞ → Prop
a : ℕ∞
h0 : P 0
hsuc : ∀ (n : ℕ), P ↑n → P ↑(Nat.succ n)
htop : (∀ (n : ℕ), P ↑n) → P ⊤
A : ∀ (n : ℕ), P ↑n
⊢ P a

tactic: . exact htop A
state_before: case none
m n : ℕ∞
P : ℕ∞ → Prop
h0 : P 0
hsuc : ∀ (n : ℕ), P ↑n → P ↑(Nat.succ n)
htop : (∀ (n : ℕ), P ↑n) → P ⊤
A : ∀ (n : ℕ), P ↑n
⊢ P none

case some
m n : ℕ∞
P : ℕ∞ → Prop
h0 : P 0
hsuc : ∀ (n : ℕ), P ↑n → P ↑(Nat.succ n)
htop : (∀ (n : ℕ), P ↑n) → P ⊤
A : ∀ (n : ℕ), P ↑n
val✝ : ℕ
⊢ P (some val✝)

tactic: . exact A _
state_before: case some
m n : ℕ∞
P : ℕ∞ → Prop
h0 : P 0
hsuc : ∀ (n : ℕ), P ↑n → P ↑(Nat.succ n)
htop : (∀ (n : ℕ), P ↑n) → P ⊤
A : ∀ (n : ℕ), P ↑n
val✝ : ℕ
⊢ P (some val✝)

tactic: exact htop A
state_before: case none
m n : ℕ∞
P : ℕ∞ → Prop
h0 : P 0
hsuc : ∀ (n : ℕ), P ↑n → P ↑(Nat.succ n)
htop : (∀ (n : ℕ), P ↑n) → P ⊤
A : ∀ (n : ℕ), P ↑n
⊢ P none

tactic: exact A _
state_before: case some
m n : ℕ∞
P : ℕ∞ → Prop
h0 : P 0
hsuc : ∀ (n : ℕ), P ↑n → P ↑(Nat.succ n)
htop : (∀ (n : ℕ), P ↑n) → P ⊤
A : ∀ (n : ℕ), P ↑n
val✝ : ℕ
⊢ P (some val✝)
Theorem: Finsupp.mapRange.equiv_trans
File: Mathlib/Data/Finsupp/Basic.lean

tactic: rw [Equiv.trans_apply, hf, hf₂]
state_before: α : Type ?u.10603
β : Type ?u.10606
γ : Type ?u.10609
ι : Type ?u.10612
M : Type ?u.10615
M' : Type ?u.10618
N : Type ?u.10621
P : Type ?u.10624
G : Type ?u.10627
H : Type ?u.10630
R : Type ?u.10633
S : Type ?u.10636
inst✝² : Zero M
inst✝¹ : Zero N
inst✝ : Zero P
f : M ≃ N
hf : ↑f 0 = 0
hf' : ↑f.symm 0 = 0
f₂ : N ≃ P
hf₂ : ↑f₂ 0 = 0
hf₂' : ↑f₂.symm 0 = 0
⊢ ↑(f.trans f₂) 0 = 0

tactic: rw [Equiv.symm_trans_apply, hf₂', hf']
state_before: α : Type ?u.10603
β : Type ?u.10606
γ : Type ?u.10609
ι : Type ?u.10612
M : Type ?u.10615
M' : Type ?u.10618
N : Type ?u.10621
P : Type ?u.10624
G : Type ?u.10627
H : Type ?u.10630
R : Type ?u.10633
S : Type ?u.10636
inst✝² : Zero M
inst✝¹ : Zero N
inst✝ : Zero P
f : M ≃ N
hf : ↑f 0 = 0
hf' : ↑f.symm 0 = 0
f₂ : N ≃ P
hf₂ : ↑f₂ 0 = 0
hf₂' : ↑f₂.symm 0 = 0
⊢ ↑(f.trans f₂).symm 0 = 0