1337xyz1337xyz/leandojo-benchmark4-v10 huggingface dataset:
Theorem: ContinuousMap.continuous_eval
File: Mathlib/Topology/CompactOpen.lean

tactic: simp_rw [continuous_iff_continuousAt, ContinuousAt, (nhds_basis_opens _).tendsto_right_iff]
state_before: α : Type u_1
X : Type u_2
Y : Type u_3
Z : Type u_4
T : Type u_5
inst✝⁴ : TopologicalSpace X
inst✝³ : TopologicalSpace Y
inst✝² : TopologicalSpace Z
inst✝¹ : TopologicalSpace T
K : Set X
U : Set Y
inst✝ : LocallyCompactPair X Y
⊢ Continuous fun p => p.1 p.2
state_after: α : Type u_1
X : Type u_2
Y : Type u_3
Z : Type u_4
T : Type u_5
inst✝⁴ : TopologicalSpace X
inst✝³ : TopologicalSpace Y
inst✝² : TopologicalSpace Z
inst✝¹ : TopologicalSpace T
K : Set X
U : Set Y
inst✝ : LocallyCompactPair X Y
⊢ ∀ (x : C(X, Y) × X) (i : Set Y), x.1 x.2 ∈ i ∧ IsOpen i → ∀ᶠ (x : C(X, Y) × X) in 𝓝 x, x.1 x.2 ∈ i

tactic: rintro ⟨f, x⟩ U ⟨hx : f x ∈ U, hU : IsOpen U⟩
state_before: α : Type u_1
X : Type u_2
Y : Type u_3
Z : Type u_4
T : Type u_5
inst✝⁴ : TopologicalSpace X
inst✝³ : TopologicalSpace Y
inst✝² : TopologicalSpace Z
inst✝¹ : TopologicalSpace T
K : Set X
U : Set Y
inst✝ : LocallyCompactPair X Y
⊢ ∀ (x : C(X, Y) × X) (i : Set Y), x.1 x.2 ∈ i ∧ IsOpen i → ∀ᶠ (x : C(X, Y) × X) in 𝓝 x, x.1 x.2 ∈ i
state_after: case mk.intro
α : Type u_1
X : Type u_2
Y : Type u_3
Z : Type u_4
T : Type u_5
inst✝⁴ : TopologicalSpace X
inst✝³ : TopologicalSpace Y
inst✝² : TopologicalSpace Z
inst✝¹ : TopologicalSpace T
K : Set X
U✝ : Set Y
inst✝ : LocallyCompactPair X Y
f : C(X, Y)
x : X
U : Set Y
hx : f x ∈ U
hU : IsOpen U
⊢ ∀ᶠ (x : C(X, Y) × X) in 𝓝 (f, x), x.1 x.2 ∈ U

tactic: rcases exists_mem_nhds_isCompact_mapsTo f.continuous (hU.mem_nhds hx) with ⟨K, hxK, hK, hKU⟩
state_before: case mk.intro
α : Type u_1
X : Type u_2
Y : Type u_3
Z : Type u_4
T : Type u_5
inst✝⁴ : TopologicalSpace X
inst✝³ : TopologicalSpace Y
inst✝² : TopologicalSpace Z
inst✝¹ : TopologicalSpace T
K : Set X
U✝ : Set Y
inst✝ : LocallyCompactPair X Y
f : C(X, Y)
x : X
U : Set Y
hx : f x ∈ U
hU : IsOpen U
⊢ ∀ᶠ (x : C(X, Y) × X) in 𝓝 (f, x), x.1 x.2 ∈ U
state_after: case mk.intro.intro.intro.intro
α : Type u_1
X : Type u_2
Y : Type u_3
Z : Type u_4
T : Type u_5
inst✝⁴ : TopologicalSpace X
inst✝³ : TopologicalSpace Y
inst✝² : TopologicalSpace Z
inst✝¹ : TopologicalSpace T
K✝ : Set X
U✝ : Set Y
inst✝ : LocallyCompactPair X Y
f : C(X, Y)
x : X
U : Set Y
hx : f x ∈ U
hU : IsOpen U
K : Set X
hxK : K ∈ 𝓝 x
hK : IsCompact K
hKU : MapsTo (⇑f) K U
⊢ ∀ᶠ (x : C(X, Y) × X) in 𝓝 (f, x), x.1 x.2 ∈ U

tactic: filter_upwards [prod_mem_nhds (eventually_mapsTo hK hU hKU) hxK] using fun _ h ↦ h.1 h.2
state_before: case mk.intro.intro.intro.intro
α : Type u_1
X : Type u_2
Y : Type u_3
Z : Type u_4
T : Type u_5
inst✝⁴ : TopologicalSpace X
inst✝³ : TopologicalSpace Y
inst✝² : TopologicalSpace Z
inst✝¹ : TopologicalSpace T
K✝ : Set X
U✝ : Set Y
inst✝ : LocallyCompactPair X Y
f : C(X, Y)
x : X
U : Set Y
hx : f x ∈ U
hU : IsOpen U
K : Set X
hxK : K ∈ 𝓝 x
hK : IsCompact K
hKU : MapsTo (⇑f) K U
⊢ ∀ᶠ (x : C(X, Y) × X) in 𝓝 (f, x), x.1 x.2 ∈ U
state_after: no goals
Theorem: Finsupp.indicator_apply
File: Mathlib/Data/Finsupp/Indicator.lean

tactic: simp only [indicator, ne_eq, coe_mk]
state_before: ι : Type u_1
α : Type u_2
inst✝¹ : Zero α
s : Finset ι
f : (i : ι) → i ∈ s → α
i : ι
inst✝ : DecidableEq ι
⊢ (indicator s f) i = if hi : i ∈ s then f i hi else 0
state_after: ι : Type u_1
α : Type u_2
inst✝¹ : Zero α
s : Finset ι
f : (i : ι) → i ∈ s → α
i : ι
inst✝ : DecidableEq ι
⊢ (if H : i ∈ s then f i H else 0) = if hi : i ∈ s then f i hi else 0

tactic: congr
state_before: ι : Type u_1
α : Type u_2
inst✝¹ : Zero α
s : Finset ι
f : (i : ι) → i ∈ s → α
i : ι
inst✝ : DecidableEq ι
⊢ (if H : i ∈ s then f i H else 0) = if hi : i ∈ s then f i hi else 0
state_after: no goals
Theorem: Matrix.rank_mul_le_right
File: Mathlib/Data/Matrix/Rank.lean

tactic: rw [rank, rank, mulVecLin_mul]
state_before: l : Type u_1
m : Type u_2
n : Type u_3
o : Type u_4
R : Type u_5
inst✝³ : Fintype n
inst✝² : Fintype o
inst✝¹ : CommRing R
inst✝ : StrongRankCondition R
A : Matrix m n R
B : Matrix n o R
⊢ (A * B).rank ≤ B.rank
state_after: l : Type u_1
m : Type u_2
n : Type u_3
o : Type u_4
R : Type u_5
inst✝³ : Fintype n
inst✝² : Fintype o
inst✝¹ : CommRing R
inst✝ : StrongRankCondition R
A : Matrix m n R
B : Matrix n o R
⊢ finrank R ↥(LinearMap.range (A.mulVecLin ∘ₗ B.mulVecLin)) ≤ finrank R ↥(LinearMap.range B.mulVecLin)

tactic: exact finrank_le_finrank_of_rank_le_rank (LinearMap.lift_rank_comp_le_right _ _)
  (rank_lt_aleph0 _ _)
state_before: l : Type u_1
m : Type u_2
n : Type u_3
o : Type u_4
R : Type u_5
inst✝³ : Fintype n
inst✝² : Fintype o
inst✝¹ : CommRing R
inst✝ : StrongRankCondition R
A : Matrix m n R
B : Matrix n o R
⊢ finrank R ↥(LinearMap.range (A.mulVecLin ∘ₗ B.mulVecLin)) ≤ finrank R ↥(LinearMap.range B.mulVecLin)
state_after: no goals
Theorem: RingHom.prod_unique
File: Mathlib/Algebra/Ring/Prod.lean

tactic: simp only [prod_apply, coe_fst, coe_snd, comp_apply]
state_before: α : Type u_1
β : Type u_2
R : Type u_3
R' : Type u_4
S : Type u_5
S' : Type u_6
T : Type u_7
T' : Type u_8
inst✝² : NonAssocSemiring R
inst✝¹ : NonAssocSemiring S
inst✝ : NonAssocSemiring T
f✝ : R →+* S
g : R →+* T
f : R →+* S × T
x : R
⊢ (((fst S T).comp f).prod ((snd S T).comp f)) x = f x
state_after: no goals
Theorem: AlgebraicGeometry.LocallyRingedSpace.IsOpenImmersion.invApp_app
File: Mathlib/Geometry/RingedSpace/OpenImmersion.lean

tactic: simp [Opens.map, Set.preimage_image_eq _ H.base_open.inj]
state_before: C : Type u
inst✝ : Category.{v, u} C
X Y : LocallyRingedSpace
f : X ⟶ Y
H : IsOpenImmersion f
U : Opens ↑X.toTopCat
⊢ { unop := U } = (Opens.map f.val.base).op.obj { unop := (opensFunctor f).obj U }
state_after: no goals
Theorem: Filter.countable_biInf_eq_iInf_seq'
File: Mathlib/Order/Filter/Bases.lean

tactic: rcases B.eq_empty_or_nonempty with hB | Bnonempty
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
ι' : Sort u_5
inst✝ : CompleteLattice α
B : Set ι
Bcbl : B.Countable
f : ι → α
i₀ : ι
h : f i₀ = ⊤
⊢ ∃ x, ⨅ t ∈ B, f t = ⨅ i, f (x i)
state_after: case inl
α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
ι' : Sort u_5
inst✝ : CompleteLattice α
B : Set ι
Bcbl : B.Countable
f : ι → α
i₀ : ι
h : f i₀ = ⊤
hB : B = ∅
⊢ ∃ x, ⨅ t ∈ B, f t = ⨅ i, f (x i)

case inr
α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
ι' : Sort u_5
inst✝ : CompleteLattice α
B : Set ι
Bcbl : B.Countable
f : ι → α
i₀ : ι
h : f i₀ = ⊤
Bnonempty : B.Nonempty
⊢ ∃ x, ⨅ t ∈ B, f t = ⨅ i, f (x i)

tactic: rw [hB, iInf_emptyset]
state_before: case inl
α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
ι' : Sort u_5
inst✝ : CompleteLattice α
B : Set ι
Bcbl : B.Countable
f : ι → α
i₀ : ι
h : f i₀ = ⊤
hB : B = ∅
⊢ ∃ x, ⨅ t ∈ B, f t = ⨅ i, f (x i)
state_after: case inl
α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
ι' : Sort u_5
inst✝ : CompleteLattice α
B : Set ι
Bcbl : B.Countable
f : ι → α
i₀ : ι
h : f i₀ = ⊤
hB : B = ∅
⊢ ∃ x, ⊤ = ⨅ i, f (x i)

tactic: use fun _ => i₀
state_before: case inl
α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
ι' : Sort u_5
inst✝ : CompleteLattice α
B : Set ι
Bcbl : B.Countable
f : ι → α
i₀ : ι
h : f i₀ = ⊤
hB : B = ∅
⊢ ∃ x, ⊤ = ⨅ i, f (x i)
state_after: case h
α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
ι' : Sort u_5
inst✝ : CompleteLattice α
B : Set ι
Bcbl : B.Countable
f : ι → α
i₀ : ι
h : f i₀ = ⊤
hB : B = ∅
⊢ ⊤ = ⨅ i, f i₀

tactic: simp [h]
state_before: case h
α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
ι' : Sort u_5
inst✝ : CompleteLattice α
B : Set ι
Bcbl : B.Countable
f : ι → α
i₀ : ι
h : f i₀ = ⊤
hB : B = ∅
⊢ ⊤ = ⨅ i, f i₀
state_after: no goals

tactic: exact countable_biInf_eq_iInf_seq Bcbl Bnonempty f
state_before: case inr
α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
ι' : Sort u_5
inst✝ : CompleteLattice α
B : Set ι
Bcbl : B.Countable
f : ι → α
i₀ : ι
h : f i₀ = ⊤
Bnonempty : B.Nonempty
⊢ ∃ x, ⨅ t ∈ B, f t = ⨅ i, f (x i)
state_after: no goals
Theorem: List.map₂Left_eq_zipWith
File: Mathlib/Data/List/Basic.lean

tactic: simp
state_before: ι : Type u_1
α : Type u
β : Type v
γ : Type w
l₁ l₂ : List α
f : α → Option β → γ
as : List α
x✝ : [].length ≤ [].length
⊢ map₂Left f [] [] = zipWith (fun a b => f a (some b)) [] []
state_after: no goals

tactic: simp
state_before: ι : Type u_1
α : Type u
β : Type v
γ : Type w
l₁ l₂ : List α
f : α → Option β → γ
as : List α
head✝ : β
tail✝ : List β
x✝ : [].length ≤ (head✝ :: tail✝).length
⊢ map₂Left f [] (head✝ :: tail✝) = zipWith (fun a b => f a (some b)) [] (head✝ :: tail✝)
state_after: no goals

tactic: simp at h
state_before: ι : Type u_1
α : Type u
β : Type v
γ : Type w
l₁ l₂ : List α
f : α → Option β → γ
as✝ : List α
a : α
as : List α
h : (a :: as).length ≤ [].length
⊢ map₂Left f (a :: as) [] = zipWith (fun a b => f a (some b)) (a :: as) []
state_after: no goals

tactic: simp only [length_cons, succ_le_succ_iff] at h
state_before: ι : Type u_1
α : Type u
β : Type v
γ : Type w
l₁ l₂ : List α
f : α → Option β → γ
as✝ : List α
a : α
as : List α
b : β
bs : List β
h : (a :: as).length ≤ (b :: bs).length
⊢ map₂Left f (a :: as) (b :: bs) = zipWith (fun a b => f a (some b)) (a :: as) (b :: bs)
state_after: ι : Type u_1
α : Type u
β : Type v
γ : Type w
l₁ l₂ : List α
f : α → Option β → γ
as✝ : List α
a : α
as : List α
b : β
bs : List β
h : as.length ≤ bs.length
⊢ map₂Left f (a :: as) (b :: bs) = zipWith (fun a b => f a (some b)) (a :: as) (b :: bs)

tactic: simp [h, map₂Left_eq_zipWith]
state_before: ι : Type u_1
α : Type u
β : Type v
γ : Type w
l₁ l₂ : List α
f : α → Option β → γ
as✝ : List α
a : α
as : List α
b : β
bs : List β
h : as.length ≤ bs.length
⊢ map₂Left f (a :: as) (b :: bs) = zipWith (fun a b => f a (some b)) (a :: as) (b :: bs)
state_after: no goals
Theorem: uniformity_eq_comap_inv_mul_nhds_one
File: Mathlib/Topology/Algebra/UniformGroup.lean

tactic: rw [← comap_uniformity_mulOpposite, uniformity_eq_comap_nhds_one, ← op_one, ← comap_unop_nhds,
  comap_comap, comap_comap]
state_before: α : Type u_1
β : Type u_2
inst✝² : UniformSpace α
inst✝¹ : Group α
inst✝ : UniformGroup α
⊢ 𝓤 α = comap (fun x => x.1⁻¹ * x.2) (𝓝 1)
state_after: α : Type u_1
β : Type u_2
inst✝² : UniformSpace α
inst✝¹ : Group α
inst✝ : UniformGroup α
⊢ comap (unop ∘ (fun x => x.2 / x.1) ∘ fun p => (op p.1, op p.2)) (𝓝 1) = comap (fun x => x.1⁻¹ * x.2) (𝓝 1)
Theorem: continuousOn_iff
File: Mathlib/Topology/ContinuousOn.lean

tactic: simp only [ContinuousOn, ContinuousWithinAt, tendsto_nhds, mem_nhdsWithin]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝⁴ : TopologicalSpace α
ι : Type u_5
π : ι → Type u_6
inst✝³ : (i : ι) → TopologicalSpace (π i)
inst✝² : TopologicalSpace β
inst✝¹ : TopologicalSpace γ
inst✝ : TopologicalSpace δ
f : α → β
s : Set α
⊢ ContinuousOn f s ↔ ∀ x ∈ s, ∀ (t : Set β), IsOpen t → f x ∈ t → ∃ u, IsOpen u ∧ x ∈ u ∧ u ∩ s ⊆ f ⁻¹' t
state_after: no goals
Theorem: ProbabilityTheory.centralMoment_one'
File: Mathlib/Probability/Moments.lean

tactic: simp only [centralMoment, Pi.sub_apply, pow_one]
state_before: Ω : Type u_1
ι : Type u_2
m : MeasurableSpace Ω
X : Ω → ℝ
p : ℕ
μ : Measure Ω
inst✝ : IsFiniteMeasure μ
h_int : Integrable X μ
⊢ centralMoment X 1 μ = (1 - (μ Set.univ).toReal) * ∫ (x : Ω), X x ∂μ
state_after: Ω : Type u_1
ι : Type u_2
m : MeasurableSpace Ω
X : Ω → ℝ
p : ℕ
μ : Measure Ω
inst✝ : IsFiniteMeasure μ
h_int : Integrable X μ
⊢ ∫ (x : Ω), X x - ∫ (x : Ω), X x ∂μ ∂μ = (1 - (μ Set.univ).toReal) * ∫ (x : Ω), X x ∂μ

tactic: rw [integral_sub h_int (integrable_const _)]
state_before: Ω : Type u_1
ι : Type u_2
m : MeasurableSpace Ω
X : Ω → ℝ
p : ℕ
μ : Measure Ω
inst✝ : IsFiniteMeasure μ
h_int : Integrable X μ
⊢ ∫ (x : Ω), X x - ∫ (x : Ω), X x ∂μ ∂μ = (1 - (μ Set.univ).toReal) * ∫ (x : Ω), X x ∂μ
state_after: Ω : Type u_1
ι : Type u_2
m : MeasurableSpace Ω
X : Ω → ℝ
p : ℕ
μ : Measure Ω
inst✝ : IsFiniteMeasure μ
h_int : Integrable X μ
⊢ ∫ (a : Ω), X a ∂μ - ∫ (a : Ω), ∫ (x : Ω), X x ∂μ ∂μ = (1 - (μ Set.univ).toReal) * ∫ (x : Ω), X x ∂μ

tactic: simp only [sub_mul, integral_const, smul_eq_mul, one_mul]
state_before: Ω : Type u_1
ι : Type u_2
m : MeasurableSpace Ω
X : Ω → ℝ
p : ℕ
μ : Measure Ω
inst✝ : IsFiniteMeasure μ
h_int : Integrable X μ
⊢ ∫ (a : Ω), X a ∂μ - ∫ (a : Ω), ∫ (x : Ω), X x ∂μ ∂μ = (1 - (μ Set.univ).toReal) * ∫ (x : Ω), X x ∂μ
state_after: no goals
Theorem: IsUnit.map
File: Mathlib/Algebra/Group/Units/Hom.lean

tactic: rcases h with ⟨y, rfl⟩
state_before: F : Type u_1
G : Type u_2
α : Type u_3
M : Type u_4
N : Type u_5
inst✝⁴ : FunLike F M N
inst✝³ : FunLike G N M
inst✝² : Monoid M
inst✝¹ : Monoid N
inst✝ : MonoidHomClass F M N
f : F
x : M
h : IsUnit x
⊢ IsUnit (f x)
state_after: case intro
F : Type u_1
G : Type u_2
α : Type u_3
M : Type u_4
N : Type u_5
inst✝⁴ : FunLike F M N
inst✝³ : FunLike G N M
inst✝² : Monoid M
inst✝¹ : Monoid N
inst✝ : MonoidHomClass F M N
f : F
y : Mˣ
⊢ IsUnit (f ↑y)

tactic: exact (Units.map (f : M →* N) y).isUnit
state_before: case intro
F : Type u_1
G : Type u_2
α : Type u_3
M : Type u_4
N : Type u_5
inst✝⁴ : FunLike F M N
inst✝³ : FunLike G N M
inst✝² : Monoid M
inst✝¹ : Monoid N
inst✝ : MonoidHomClass F M N
f : F
y : Mˣ
⊢ IsUnit (f ↑y)
state_after: no goals
Theorem: ENNReal.toReal_lt_toReal
File: Mathlib/Data/ENNReal/Real.lean

tactic: lift a to ℝ≥0 using ha
state_before: a b c d : ℝ≥0∞
r p q : ℝ≥0
ha : a ≠ ⊤
hb : b ≠ ⊤
⊢ a.toReal < b.toReal ↔ a < b
state_after: case intro
b c d : ℝ≥0∞
r p q : ℝ≥0
hb : b ≠ ⊤
a : ℝ≥0
⊢ (↑a).toReal < b.toReal ↔ ↑a < b

tactic: lift b to ℝ≥0 using hb
state_before: case intro
b c d : ℝ≥0∞
r p q : ℝ≥0
hb : b ≠ ⊤
a : ℝ≥0
⊢ (↑a).toReal < b.toReal ↔ ↑a < b
state_after: case intro.intro
c d : ℝ≥0∞
r p q a b : ℝ≥0
⊢ (↑a).toReal < (↑b).toReal ↔ ↑a < ↑b

tactic: norm_cast
state_before: case intro.intro
c d : ℝ≥0∞
r p q a b : ℝ≥0
⊢ (↑a).toReal < (↑b).toReal ↔ ↑a < ↑b
state_after: no goals
Theorem: CategoryTheory.ShortComplex.HomologyData.leftRightHomologyComparison'_eq
File: Mathlib/Algebra/Homology/ShortComplex/Homology.lean

tactic: simp only [← cancel_epi h.left.π, ← cancel_mono h.right.ι, assoc,
  π_leftRightHomologyComparison'_ι, comm]
state_before: C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : HasZeroMorphisms C
S S₁ S₂ S₃ S₄ : ShortComplex C
φ : S₁ ⟶ S₂
h₁ : S₁.HomologyData
h₂ : S₂.HomologyData
h : S.HomologyData
⊢ leftRightHomologyComparison' h.left h.right = h.iso.hom
state_after: no goals
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_4
G : Type u_5
𝕜 : Type u_6
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 : ↥(Lp E 1 μ)
⊢ ‖setToFun μ T hT ↑↑f‖ ≤ max C 0 * ‖f‖
state_after: α : Type u_1
E : Type u_2
F : Type u_3
F' : Type u_4
G : Type u_5
𝕜 : Type u_6
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 : ↥(Lp E 1 μ)
⊢ ‖(L1.setToL1 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_4
G : Type u_5
𝕜 : Type u_6
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 : ↥(Lp E 1 μ)
⊢ ‖(L1.setToL1 hT) f‖ ≤ max C 0 * ‖f‖
state_after: no goals
Theorem: AdicCompletion.map_ext'
File: Mathlib/RingTheory/AdicCompletion/Functoriality.lean

tactic: ext x
state_before: R : Type u_1
inst✝⁸ : CommRing R
I : Ideal R
M : Type u_2
inst✝⁷ : AddCommGroup M
inst✝⁶ : Module R M
N : Type u_3
inst✝⁵ : AddCommGroup N
inst✝⁴ : Module R N
P : Type u_4
inst✝³ : AddCommGroup P
inst✝² : Module R P
T : Type u_5
inst✝¹ : AddCommGroup T
inst✝ : Module (AdicCompletion I R) T
f g : AdicCompletion I M →ₗ[AdicCompletion I R] T
h : ∀ (a : AdicCauchySequence I M), f ((mk I M) a) = g ((mk I M) a)
⊢ f = g
state_after: case h
R : Type u_1
inst✝⁸ : CommRing R
I : Ideal R
M : Type u_2
inst✝⁷ : AddCommGroup M
inst✝⁶ : Module R M
N : Type u_3
inst✝⁵ : AddCommGroup N
inst✝⁴ : Module R N
P : Type u_4
inst✝³ : AddCommGroup P
inst✝² : Module R P
T : Type u_5
inst✝¹ : AddCommGroup T
inst✝ : Module (AdicCompletion I R) T
f g : AdicCompletion I M →ₗ[AdicCompletion I R] T
h : ∀ (a : AdicCauchySequence I M), f ((mk I M) a) = g ((mk I M) a)
x : AdicCompletion I M
⊢ f x = g x

tactic: apply induction_on I M x (fun a ↦ h a)
state_before: case h
R : Type u_1
inst✝⁸ : CommRing R
I : Ideal R
M : Type u_2
inst✝⁷ : AddCommGroup M
inst✝⁶ : Module R M
N : Type u_3
inst✝⁵ : AddCommGroup N
inst✝⁴ : Module R N
P : Type u_4
inst✝³ : AddCommGroup P
inst✝² : Module R P
T : Type u_5
inst✝¹ : AddCommGroup T
inst✝ : Module (AdicCompletion I R) T
f g : AdicCompletion I M →ₗ[AdicCompletion I R] T
h : ∀ (a : AdicCauchySequence I M), f ((mk I M) a) = g ((mk I M) a)
x : AdicCompletion I M
⊢ f x = g x
state_after: no goals
Theorem: strictMonoOn_of_deriv_pos
File: Mathlib/Analysis/Calculus/MeanValue.lean

tactic: intro x hx y hy
state_before: E : Type u_1
inst✝³ : NormedAddCommGroup E
inst✝² : NormedSpace ℝ E
F : Type u_2
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedSpace ℝ F
D : Set ℝ
hD : Convex ℝ D
f : ℝ → ℝ
hf : ContinuousOn f D
hf' : ∀ x ∈ interior D, 0 < deriv f x
⊢ StrictMonoOn f D
state_after: E : Type u_1
inst✝³ : NormedAddCommGroup E
inst✝² : NormedSpace ℝ E
F : Type u_2
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedSpace ℝ F
D : Set ℝ
hD : Convex ℝ D
f : ℝ → ℝ
hf : ContinuousOn f D
hf' : ∀ x ∈ interior D, 0 < deriv f x
x : ℝ
hx : x ∈ D
y : ℝ
hy : y ∈ D
⊢ x < y → f x < f y

tactic: have : DifferentiableOn ℝ f (interior D) := fun z hz =>
  (differentiableAt_of_deriv_ne_zero (hf' z hz).ne').differentiableWithinAt
state_before: E : Type u_1
inst✝³ : NormedAddCommGroup E
inst✝² : NormedSpace ℝ E
F : Type u_2
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedSpace ℝ F
D : Set ℝ
hD : Convex ℝ D
f : ℝ → ℝ
hf : ContinuousOn f D
hf' : ∀ x ∈ interior D, 0 < deriv f x
x : ℝ
hx : x ∈ D
y : ℝ
hy : y ∈ D
⊢ x < y → f x < f y
state_after: E : Type u_1
inst✝³ : NormedAddCommGroup E
inst✝² : NormedSpace ℝ E
F : Type u_2
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedSpace ℝ F
D : Set ℝ
hD : Convex ℝ D
f : ℝ → ℝ
hf : ContinuousOn f D
hf' : ∀ x ∈ interior D, 0 < deriv f x
x : ℝ
hx : x ∈ D
y : ℝ
hy : y ∈ D
this : DifferentiableOn ℝ f (interior D)
⊢ x < y → f x < f y

tactic: simpa only [zero_mul, sub_pos] using
  hD.mul_sub_lt_image_sub_of_lt_deriv hf this hf' x hx y hy
state_before: E : Type u_1
inst✝³ : NormedAddCommGroup E
inst✝² : NormedSpace ℝ E
F : Type u_2
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedSpace ℝ F
D : Set ℝ
hD : Convex ℝ D
f : ℝ → ℝ
hf : ContinuousOn f D
hf' : ∀ x ∈ interior D, 0 < deriv f x
x : ℝ
hx : x ∈ D
y : ℝ
hy : y ∈ D
this : DifferentiableOn ℝ f (interior D)
⊢ x < y → f x < f y
state_after: no goals
Theorem: Finset.card_Ioo_eq_card_Ico_sub_one
File: Mathlib/Order/Interval/Finset/Basic.lean

tactic: by_cases h : a < b
state_before: ι : Type u_1
α : Type u_2
inst✝¹ : PartialOrder α
inst✝ : LocallyFiniteOrder α
a✝ b✝ c a b : α
⊢ (Ioo a b).card = (Ico a b).card - 1
state_after: case pos
ι : Type u_1
α : Type u_2
inst✝¹ : PartialOrder α
inst✝ : LocallyFiniteOrder α
a✝ b✝ c a b : α
h : a < b
⊢ (Ioo a b).card = (Ico a b).card - 1

case neg
ι : Type u_1
α : Type u_2
inst✝¹ : PartialOrder α
inst✝ : LocallyFiniteOrder α
a✝ b✝ c a b : α
h : ¬a < b
⊢ (Ioo a b).card = (Ico a b).card - 1

tactic: rw [Ico_eq_cons_Ioo h, card_cons]
state_before: case pos
ι : Type u_1
α : Type u_2
inst✝¹ : PartialOrder α
inst✝ : LocallyFiniteOrder α
a✝ b✝ c a b : α
h : a < b
⊢ (Ioo a b).card = (Ico a b).card - 1
state_after: case pos
ι : Type u_1
α : Type u_2
inst✝¹ : PartialOrder α
inst✝ : LocallyFiniteOrder α
a✝ b✝ c a b : α
h : a < b
⊢ (Ioo a b).card = (Ioo a b).card + 1 - 1

tactic: exact (Nat.add_sub_cancel _ _).symm
state_before: case pos
ι : Type u_1
α : Type u_2
inst✝¹ : PartialOrder α
inst✝ : LocallyFiniteOrder α
a✝ b✝ c a b : α
h : a < b
⊢ (Ioo a b).card = (Ioo a b).card + 1 - 1
state_after: no goals

tactic: rw [Ioo_eq_empty h, Ico_eq_empty h, card_empty, Nat.zero_sub]
state_before: case neg
ι : Type u_1
α : Type u_2
inst✝¹ : PartialOrder α
inst✝ : LocallyFiniteOrder α
a✝ b✝ c a b : α
h : ¬a < b
⊢ (Ioo a b).card = (Ico a b).card - 1
state_after: no goals
Theorem: Nat.card_multiples
File: Mathlib/Data/Nat/Factorization/Basic.lean

tactic: induction' n with n hn
state_before: a b m n✝ p✝ n p : ℕ
⊢ (Finset.filter (fun e => p ∣ e + 1) (Finset.range n)).card = n / p
state_after: case zero
a b m n p✝ p : ℕ
⊢ (Finset.filter (fun e => p ∣ e + 1) (Finset.range 0)).card = 0 / p

case succ
a b m n✝ p✝ p n : ℕ
hn : (Finset.filter (fun e => p ∣ e + 1) (Finset.range n)).card = n / p
⊢ (Finset.filter (fun e => p ∣ e + 1) (Finset.range (n + 1))).card = (n + 1) / p

tactic: simp [Nat.succ_div, add_ite, add_zero, Finset.range_succ, filter_insert, apply_ite card,
  card_insert_of_not_mem, hn]
state_before: case succ
a b m n✝ p✝ p n : ℕ
hn : (Finset.filter (fun e => p ∣ e + 1) (Finset.range n)).card = n / p
⊢ (Finset.filter (fun e => p ∣ e + 1) (Finset.range (n + 1))).card = (n + 1) / p
state_after: no goals

tactic: simp
state_before: case zero
a b m n p✝ p : ℕ
⊢ (Finset.filter (fun e => p ∣ e + 1) (Finset.range 0)).card = 0 / p
state_after: no goals
Theorem: AlgebraicGeometry.isAffineOpen_opensRange
File: Mathlib/AlgebraicGeometry/AffineScheme.lean

tactic: refine isAffine_of_isIso (IsOpenImmersion.isoOfRangeEq f (Y.ofRestrict _) ?_).inv
state_before: X Y : Scheme
inst✝ : IsAffine X
f : X ⟶ Y
H : IsOpenImmersion f
⊢ IsAffineOpen (Scheme.Hom.opensRange f)
state_after: X Y : Scheme
inst✝ : IsAffine X
f : X ⟶ Y
H : IsOpenImmersion f
⊢ Set.range ⇑f.val.base = Set.range ⇑(Y.ofRestrict ⋯).val.base

tactic: exact Subtype.range_val.symm
state_before: X Y : Scheme
inst✝ : IsAffine X
f : X ⟶ Y
H : IsOpenImmersion f
⊢ Set.range ⇑f.val.base = Set.range ⇑(Y.ofRestrict ⋯).val.base
state_after: no goals
Theorem: Set.Finite.toFinset_ssubset_toFinset
File: Mathlib/Data/Set/Finite.lean

tactic: simp only [← Finset.coe_ssubset, Finite.coe_toFinset]
state_before: α : Type u
β : Type v
ι : Sort w
γ : Type x
s t : Set α
a : α
hs : s.Finite
ht : t.Finite
⊢ hs.toFinset ⊂ ht.toFinset ↔ s ⊂ t
state_after: no goals
Theorem: Filter.tendsto_atTop_principal
File: Mathlib/Order/Filter/AtTopBot.lean

tactic: simp_rw [tendsto_iff_comap, comap_principal, le_principal_iff, mem_atTop_sets, mem_preimage]
state_before: ι : Type u_1
ι' : Type u_2
α : Type u_3
β : Type u_4
γ : Type u_5
inst✝¹ : Nonempty β
inst✝ : SemilatticeSup β
f : β → α
s : Set α
⊢ Tendsto f atTop (𝓟 s) ↔ ∃ N, ∀ n ≥ N, f n ∈ s
state_after: no goals
Theorem: EReal.addLECancellable_coe
File: Mathlib/Data/Real/EReal.lean

tactic: simp only [coe_add_top, ← coe_add, top_le_iff, coe_ne_top] at h
state_before: x z : ℝ
h : ↑x + ⊤ ≤ ↑x + ↑z
⊢ ⊤ ≤ ↑z
state_after: no goals

tactic: simpa using h
state_before: x : ℝ
x✝ : EReal
h : ↑x + x✝ ≤ ↑x + ⊥
⊢ x✝ ≤ ⊥
state_after: no goals

tactic: simpa only [← coe_add, EReal.coe_le_coe_iff, add_le_add_iff_left] using h
state_before: x y z : ℝ
h : ↑x + ↑y ≤ ↑x + ↑z
⊢ ↑y ≤ ↑z
state_after: no goals
Theorem: Real.Angle.tan_toReal
File: Mathlib/Analysis/SpecialFunctions/Trigonometric/Angle.lean

tactic: conv_rhs => rw [← coe_toReal θ, tan_coe]
state_before: θ : Angle
⊢ Real.tan θ.toReal = θ.tan
state_after: no goals
Theorem: Set.iUnion₂_eq_univ_iff
File: Mathlib/Data/Set/Lattice.lean

tactic: simp only [iUnion_eq_univ_iff, mem_iUnion]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
ι' : Sort u_5
ι₂ : Sort u_6
κ : ι → Sort u_7
κ₁ : ι → Sort u_8
κ₂ : ι → Sort u_9
κ' : ι' → Sort u_10
s : (i : ι) → κ i → Set α
⊢ ⋃ i, ⋃ j, s i j = univ ↔ ∀ (a : α), ∃ i j, a ∈ s i j
state_after: no goals