tasksource/leandojo huggingface dataset:
Theorem: MeasureTheory.integrable_of_intervalIntegral_norm_bounded
File: Mathlib/MeasureTheory/Integral/IntegralEqImproper.lean

tactic: have hφ : AECover μ l _ := aecover_Ioc ha hb
state_before: ι : Type u_2
E : Type u_1
μ : Measure ℝ
l : Filter ι
inst✝² : NeBot l
inst✝¹ : IsCountablyGenerated l
inst✝ : NormedAddCommGroup E
a b : ι → ℝ
f : ℝ → E
I : ℝ
hfi : ∀ (i : ι), IntegrableOn f (Ioc (a i) (b i))
ha : Tendsto a l atBot
hb : Tendsto b l atTop
h : ∀ᶠ (i : ι) in l, (∫ (x : ℝ) in a i..b i, ‖f x‖ ∂μ) ≤ I
⊢ Integrable f

tactic: refine' hφ.integrable_of_integral_norm_bounded I hfi (h.mp _)
state_before: ι : Type u_2
E : Type u_1
μ : Measure ℝ
l : Filter ι
inst✝² : NeBot l
inst✝¹ : IsCountablyGenerated l
inst✝ : NormedAddCommGroup E
a b : ι → ℝ
f : ℝ → E
I : ℝ
hfi : ∀ (i : ι), IntegrableOn f (Ioc (a i) (b i))
ha : Tendsto a l atBot
hb : Tendsto b l atTop
h : ∀ᶠ (i : ι) in l, (∫ (x : ℝ) in a i..b i, ‖f x‖ ∂μ) ≤ I
hφ : AECover μ l fun i => Ioc (a i) (b i)
⊢ Integrable f

tactic: filter_upwards [ha.eventually (eventually_le_atBot 0),
  hb.eventually (eventually_ge_atTop 0)] with i hai hbi ht
state_before: ι : Type u_2
E : Type u_1
μ : Measure ℝ
l : Filter ι
inst✝² : NeBot l
inst✝¹ : IsCountablyGenerated l
inst✝ : NormedAddCommGroup E
a b : ι → ℝ
f : ℝ → E
I : ℝ
hfi : ∀ (i : ι), IntegrableOn f (Ioc (a i) (b i))
ha : Tendsto a l atBot
hb : Tendsto b l atTop
h : ∀ᶠ (i : ι) in l, (∫ (x : ℝ) in a i..b i, ‖f x‖ ∂μ) ≤ I
hφ : AECover μ l fun i => Ioc (a i) (b i)
⊢ ∀ᶠ (x : ι) in l, (∫ (x : ℝ) in a x..b x, ‖f x‖ ∂μ) ≤ I → (∫ (x : ℝ) in Ioc (a x) (b x), ‖f x‖ ∂μ) ≤ I

tactic: rwa [← intervalIntegral.integral_of_le (hai.trans hbi)]
state_before: case h
ι : Type u_2
E : Type u_1
μ : Measure ℝ
l : Filter ι
inst✝² : NeBot l
inst✝¹ : IsCountablyGenerated l
inst✝ : NormedAddCommGroup E
a b : ι → ℝ
f : ℝ → E
I : ℝ
hfi : ∀ (i : ι), IntegrableOn f (Ioc (a i) (b i))
ha : Tendsto a l atBot
hb : Tendsto b l atTop
h : ∀ᶠ (i : ι) in l, (∫ (x : ℝ) in a i..b i, ‖f x‖ ∂μ) ≤ I
hφ : AECover μ l fun i => Ioc (a i) (b i)
i : ι
hai : a i ≤ 0
hbi : 0 ≤ b i
ht : (∫ (x : ℝ) in a i..b i, ‖f x‖ ∂μ) ≤ I
⊢ (∫ (x : ℝ) in Ioc (a i) (b i), ‖f x‖ ∂μ) ≤ I
Theorem: Polynomial.monomial_left_inj
File: Mathlib/Data/Polynomial/Basic.lean

tactic: rw [← ofFinsupp_single, ← ofFinsupp_single, ofFinsupp.injEq, Finsupp.single_left_inj ha]
state_before: R : Type u
a✝ b : R
m n : ℕ
inst✝ : Semiring R
p q : R[X]
a : R
ha : a ≠ 0
i j : ℕ
⊢ ↑(monomial i) a = ↑(monomial j) a ↔ i = j
Theorem: MeasureTheory.Measure.rnDeriv_restrict
File: Mathlib/MeasureTheory/Decomposition/Lebesgue.lean

tactic: rw [← withDensity_indicator_one hs]
state_before: α : Type u_1
β : Type ?u.62355
m : MeasurableSpace α
μ ν✝ ν : Measure α
inst✝ : SigmaFinite ν
s : Set α
hs : MeasurableSet s
⊢ rnDeriv (restrict ν s) ν =ᶠ[ae ν] indicator s 1

tactic: exact rnDeriv_withDensity _ (measurable_one.indicator hs)
state_before: α : Type u_1
β : Type ?u.62355
m : MeasurableSpace α
μ ν✝ ν : Measure α
inst✝ : SigmaFinite ν
s : Set α
hs : MeasurableSet s
⊢ rnDeriv (withDensity ν (indicator s 1)) ν =ᶠ[ae ν] indicator s 1
Theorem: ZMod.χ₄_nat_eq_if_mod_four
File: Mathlib/NumberTheory/LegendreSymbol/ZModChar.lean

tactic: exact_mod_cast χ₄_int_eq_if_mod_four n
state_before: n : ℕ
⊢ ↑χ₄ ↑n = if n % 2 = 0 then 0 else if n % 4 = 1 then 1 else -1
Theorem: MeasureTheory.SignedMeasure.toJordanDecomposition_smul
File: Mathlib/MeasureTheory/Decomposition/Jordan.lean

tactic: apply toSignedMeasure_injective
state_before: α : Type u_1
β : Type ?u.75261
inst✝ : MeasurableSpace α
s : SignedMeasure α
r : ℝ≥0
⊢ toJordanDecomposition (r • s) = r • toJordanDecomposition s

tactic: simp [toSignedMeasure_smul]
state_before: case a
α : Type u_1
β : Type ?u.75261
inst✝ : MeasurableSpace α
s : SignedMeasure α
r : ℝ≥0
⊢ toSignedMeasure (toJordanDecomposition (r • s)) = toSignedMeasure (r • toJordanDecomposition s)
Theorem: eq_on_inv₀
File: Mathlib/Algebra/GroupWithZero/Units/Lemmas.lean

tactic: rcases eq_or_ne a 0 with (rfl | ha)
state_before: α : Type ?u.15847
M₀ : Type ?u.15850
G₀ : Type u_3
M₀' : Type u_1
G₀' : Type ?u.15859
F : Type ?u.15862
F' : Type u_2
inst✝⁵ : MonoidWithZero M₀
inst✝⁴ : GroupWithZero G₀
inst✝³ : Nontrivial M₀
inst✝² : MonoidWithZero M₀'
inst✝¹ : MonoidWithZeroHomClass F G₀ M₀
inst✝ : MonoidWithZeroHomClass F' G₀ M₀'
f✝ : F
a : G₀
f g : F'
h : ↑f a = ↑g a
⊢ ↑f a⁻¹ = ↑g a⁻¹

tactic: rw [inv_zero, map_zero, map_zero]
state_before: case inl
α : Type ?u.15847
M₀ : Type ?u.15850
G₀ : Type u_3
M₀' : Type u_1
G₀' : Type ?u.15859
F : Type ?u.15862
F' : Type u_2
inst✝⁵ : MonoidWithZero M₀
inst✝⁴ : GroupWithZero G₀
inst✝³ : Nontrivial M₀
inst✝² : MonoidWithZero M₀'
inst✝¹ : MonoidWithZeroHomClass F G₀ M₀
inst✝ : MonoidWithZeroHomClass F' G₀ M₀'
f✝ : F
f g : F'
h : ↑f 0 = ↑g 0
⊢ ↑f 0⁻¹ = ↑g 0⁻¹

tactic: exact (IsUnit.mk0 a ha).eq_on_inv f g h
state_before: case inr
α : Type ?u.15847
M₀ : Type ?u.15850
G₀ : Type u_3
M₀' : Type u_1
G₀' : Type ?u.15859
F : Type ?u.15862
F' : Type u_2
inst✝⁵ : MonoidWithZero M₀
inst✝⁴ : GroupWithZero G₀
inst✝³ : Nontrivial M₀
inst✝² : MonoidWithZero M₀'
inst✝¹ : MonoidWithZeroHomClass F G₀ M₀
inst✝ : MonoidWithZeroHomClass F' G₀ M₀'
f✝ : F
a : G₀
f g : F'
h : ↑f a = ↑g a
ha : a ≠ 0
⊢ ↑f a⁻¹ = ↑g a⁻¹
Theorem: IntermediateField.adjoin.finrank
File: Mathlib/FieldTheory/Adjoin.lean

tactic: rw [PowerBasis.finrank (adjoin.powerBasis hx : _)]
state_before: F : Type ?u.870038
inst✝⁶ : Field F
E : Type ?u.870044
inst✝⁵ : Field E
inst✝⁴ : Algebra F E
α : E
K : Type u_1
inst✝³ : Field K
inst✝² : Algebra F K
L : Type u_2
inst✝¹ : Field L
inst✝ : Algebra K L
x : L
hx : IsIntegral K x
⊢ FiniteDimensional.finrank K { x_1 // x_1 ∈ K⟮x⟯ } = natDegree (minpoly K x)

tactic: rfl
state_before: F : Type ?u.870038
inst✝⁶ : Field F
E : Type ?u.870044
inst✝⁵ : Field E
inst✝⁴ : Algebra F E
α : E
K : Type u_1
inst✝³ : Field K
inst✝² : Algebra F K
L : Type u_2
inst✝¹ : Field L
inst✝ : Algebra K L
x : L
hx : IsIntegral K x
⊢ (powerBasis hx).dim = natDegree (minpoly K x)
Theorem: Pell.xn_modEq_x4n_add
File: Mathlib/NumberTheory/PellMatiyasevic.lean

tactic: refine' @ModEq.trans _ _ 0 _ _ (by rw [add_comm]; exact (xn_modEq_x2n_add _ _ _).symm)
state_before: a : ℕ
a1 : 1 < a
n j : ℕ
⊢ xn a1 (4 * n + j) + xn a1 (2 * n + j) ≡ xn a1 j + xn a1 (2 * n + j) [MOD xn a1 n]

tactic: rw [show 4 * n = 2 * n + 2 * n from right_distrib 2 2 n, add_assoc]
state_before: a : ℕ
a1 : 1 < a
n j : ℕ
⊢ xn a1 (4 * n + j) + xn a1 (2 * n + j) ≡ 0 [MOD xn a1 n]

tactic: apply xn_modEq_x2n_add
state_before: a : ℕ
a1 : 1 < a
n j : ℕ
⊢ xn a1 (2 * n + (2 * n + j)) + xn a1 (2 * n + j) ≡ 0 [MOD xn a1 n]

tactic: rw [add_comm]
state_before: a : ℕ
a1 : 1 < a
n j : ℕ
⊢ 0 ≡ xn a1 j + xn a1 (2 * n + j) [MOD xn a1 n]

tactic: exact (xn_modEq_x2n_add _ _ _).symm
state_before: a : ℕ
a1 : 1 < a
n j : ℕ
⊢ 0 ≡ xn a1 (2 * n + j) + xn a1 j [MOD xn a1 n]
Theorem: PGame.zero_lt_neg_iff
File: Mathlib/SetTheory/Game/PGame.lean

tactic: rw [lt_neg_iff, neg_zero]
state_before: x : PGame
⊢ 0 < -x ↔ x < 0
Theorem: FirstOrder.Language.LHom.map_constants_comp_sumInl
File: Mathlib/ModelTheory/LanguageMap.lean

tactic: ext <;> rfl
state_before: L : Language
L' : Language
M : Type w
inst✝ : Structure L M
α : Type w'
β : Type u_1
f : α → β
⊢ comp (lhomWithConstantsMap L f) LHom.sumInl = lhomWithConstants L β
Theorem: ContinuousLinearMap.pi_eq_zero
File: Mathlib/Topology/Algebra/Module/Basic.lean

tactic: simp only [ext_iff, pi_apply, Function.funext_iff]
state_before: R : Type u_1
inst✝⁹ : Semiring R
M : Type u_2
inst✝⁸ : TopologicalSpace M
inst✝⁷ : AddCommMonoid M
inst✝⁶ : Module R M
M₂ : Type ?u.693068
inst✝⁵ : TopologicalSpace M₂
inst✝⁴ : AddCommMonoid M₂
inst✝³ : Module R M₂
ι : Type u_4
φ : ι → Type u_3
inst✝² : (i : ι) → TopologicalSpace (φ i)
inst✝¹ : (i : ι) → AddCommMonoid (φ i)
inst✝ : (i : ι) → Module R (φ i)
f : (i : ι) → M →L[R] φ i
⊢ pi f = 0 ↔ ∀ (i : ι), f i = 0

tactic: exact forall_swap
state_before: R : Type u_1
inst✝⁹ : Semiring R
M : Type u_2
inst✝⁸ : TopologicalSpace M
inst✝⁷ : AddCommMonoid M
inst✝⁶ : Module R M
M₂ : Type ?u.693068
inst✝⁵ : TopologicalSpace M₂
inst✝⁴ : AddCommMonoid M₂
inst✝³ : Module R M₂
ι : Type u_4
φ : ι → Type u_3
inst✝² : (i : ι) → TopologicalSpace (φ i)
inst✝¹ : (i : ι) → AddCommMonoid (φ i)
inst✝ : (i : ι) → Module R (φ i)
f : (i : ι) → M →L[R] φ i
⊢ (∀ (x : M) (a : ι), ↑(f a) x = ↑0 x a) ↔ ∀ (i : ι) (x : M), ↑(f i) x = ↑0 x
Theorem: FreeGroup.lift_eq_prod_map
File: Mathlib/GroupTheory/FreeGroup.lean

tactic: rw [← lift.unique (prod.comp (map f))]
state_before: α : Type u
L L₁ L₂ L₃ L₄ : List (α × Bool)
β : Type v
inst✝ : Group β
f : α → β
x : FreeGroup α
⊢ ↑(↑lift f) x = ↑prod (↑(map f) x)

tactic: rfl
state_before: α : Type u
L L₁ L₂ L₃ L₄ : List (α × Bool)
β : Type v
inst✝ : Group β
f : α → β
x : FreeGroup α
⊢ ↑(MonoidHom.comp prod (map f)) x = ↑prod (↑(map f) x)

tactic: simp
state_before: case hg
α : Type u
L L₁ L₂ L₃ L₄ : List (α × Bool)
β : Type v
inst✝ : Group β
f : α → β
x : FreeGroup α
⊢ ∀ (x : α), ↑(MonoidHom.comp prod (map f)) (of x) = f x
Theorem: frontier_le_subset_eq
File: Mathlib/Topology/Order/Basic.lean

tactic: rw [frontier_eq_closure_inter_closure, closure_le_eq hf hg]
state_before: α : Type u
β : Type v
γ : Type w
inst✝³ : TopologicalSpace α
inst✝² : LinearOrder α
inst✝¹ : OrderClosedTopology α
f g : β → α
inst✝ : TopologicalSpace β
hf : Continuous f
hg : Continuous g
⊢ frontier {b | f b ≤ g b} ⊆ {b | f b = g b}

tactic: rintro b ⟨hb₁, hb₂⟩
state_before: α : Type u
β : Type v
γ : Type w
inst✝³ : TopologicalSpace α
inst✝² : LinearOrder α
inst✝¹ : OrderClosedTopology α
f g : β → α
inst✝ : TopologicalSpace β
hf : Continuous f
hg : Continuous g
⊢ {b | f b ≤ g b} ∩ closure ({b | f b ≤ g b}ᶜ) ⊆ {b | f b = g b}

tactic: refine' le_antisymm hb₁ (closure_lt_subset_le hg hf _)
state_before: case intro
α : Type u
β : Type v
γ : Type w
inst✝³ : TopologicalSpace α
inst✝² : LinearOrder α
inst✝¹ : OrderClosedTopology α
f g : β → α
inst✝ : TopologicalSpace β
hf : Continuous f
hg : Continuous g
b : β
hb₁ : b ∈ {b | f b ≤ g b}
hb₂ : b ∈ closure ({b | f b ≤ g b}ᶜ)
⊢ b ∈ {b | f b = g b}

tactic: convert hb₂ using 2
state_before: case intro
α : Type u
β : Type v
γ : Type w
inst✝³ : TopologicalSpace α
inst✝² : LinearOrder α
inst✝¹ : OrderClosedTopology α
f g : β → α
inst✝ : TopologicalSpace β
hf : Continuous f
hg : Continuous g
b : β
hb₁ : b ∈ {b | f b ≤ g b}
hb₂ : b ∈ closure ({b | f b ≤ g b}ᶜ)
⊢ b ∈ closure {b | g b < f b}

tactic: simp only [not_le.symm]
state_before: case h.e'_5.h.e'_3
α : Type u
β : Type v
γ : Type w
inst✝³ : TopologicalSpace α
inst✝² : LinearOrder α
inst✝¹ : OrderClosedTopology α
f g : β → α
inst✝ : TopologicalSpace β
hf : Continuous f
hg : Continuous g
b : β
hb₁ : b ∈ {b | f b ≤ g b}
hb₂ : b ∈ closure ({b | f b ≤ g b}ᶜ)
⊢ {b | g b < f b} = {b | f b ≤ g b}ᶜ

tactic: rfl
state_before: case h.e'_5.h.e'_3
α : Type u
β : Type v
γ : Type w
inst✝³ : TopologicalSpace α
inst✝² : LinearOrder α
inst✝¹ : OrderClosedTopology α
f g : β → α
inst✝ : TopologicalSpace β
hf : Continuous f
hg : Continuous g
b : β
hb₁ : b ∈ {b | f b ≤ g b}
hb₂ : b ∈ closure ({b | f b ≤ g b}ᶜ)
⊢ {b | ¬f b ≤ g b} = {b | f b ≤ g b}ᶜ
Theorem: Matrix.adjugate_conjTranspose
File: Mathlib/LinearAlgebra/Matrix/Adjugate.lean

tactic: dsimp only [conjTranspose]
state_before: m : Type u
n : Type v
α : Type w
inst✝⁵ : DecidableEq n
inst✝⁴ : Fintype n
inst✝³ : DecidableEq m
inst✝² : Fintype m
inst✝¹ : CommRing α
inst✝ : StarRing α
A : Matrix n n α
⊢ (adjugate A)ᴴ = adjugate Aᴴ

tactic: have : Aᵀ.adjugate.map star = adjugate (Aᵀ.map star) := (starRingEnd α).map_adjugate Aᵀ
state_before: m : Type u
n : Type v
α : Type w
inst✝⁵ : DecidableEq n
inst✝⁴ : Fintype n
inst✝³ : DecidableEq m
inst✝² : Fintype m
inst✝¹ : CommRing α
inst✝ : StarRing α
A : Matrix n n α
⊢ map (adjugate A)ᵀ star = adjugate (map Aᵀ star)

tactic: rw [A.adjugate_transpose, this]
state_before: m : Type u
n : Type v
α : Type w
inst✝⁵ : DecidableEq n
inst✝⁴ : Fintype n
inst✝³ : DecidableEq m
inst✝² : Fintype m
inst✝¹ : CommRing α
inst✝ : StarRing α
A : Matrix n n α
this : map (adjugate Aᵀ) star = adjugate (map Aᵀ star)
⊢ map (adjugate A)ᵀ star = adjugate (map Aᵀ star)
Theorem: Hyperreal.gt_of_tendsto_zero_of_neg
File: Mathlib/Data/Real/Hyperreal.lean

tactic: rw [← neg_neg r, coe_neg]
state_before: f : ℕ → ℝ
hf : Tendsto f atTop (𝓝 0)
r : ℝ
hr : r < 0
⊢ ↑r < ofSeq f

tactic: exact neg_lt_of_tendsto_zero_of_pos hf (neg_pos.mpr hr)
state_before: f : ℕ → ℝ
hf : Tendsto f atTop (𝓝 0)
r : ℝ
hr : r < 0
⊢ -↑(-r) < ofSeq f
Theorem: CommRingCat.pushoutCocone_inr
File: Mathlib/Algebra/Category/Ring/Constructions.lean

tactic: letI := f.toAlgebra
state_before: R A B : CommRingCat
f : R ⟶ A
g : R ⟶ B
⊢ B ⟶ (pushoutCocone f g).pt

tactic: letI := g.toAlgebra
state_before: R A B : CommRingCat
f : R ⟶ A
g : R ⟶ B
this : Algebra ↑R ↑A := RingHom.toAlgebra f
⊢ B ⟶ (pushoutCocone f g).pt

tactic: exact Algebra.TensorProduct.includeRight.toRingHom
state_before: R A B : CommRingCat
f : R ⟶ A
g : R ⟶ B
this✝ : Algebra ↑R ↑A := RingHom.toAlgebra f
this : Algebra ↑R ↑B := RingHom.toAlgebra g
⊢ B ⟶ (pushoutCocone f g).pt
Theorem: Ordinal.nfpFamily_lt_ord_lift
File: Mathlib/SetTheory/Cardinal/Cofinality.lean

tactic: refine' sup_lt_ord_lift ((Cardinal.lift_le.2 (mk_list_le_max ι)).trans_lt _) fun l => _
state_before: α : Type ?u.32966
r : α → α → Prop
ι : Type u
f : ι → Ordinal → Ordinal
c : Ordinal
hc : ℵ₀ < cof c
hc' : Cardinal.lift (#ι) < cof c
hf : ∀ (i : ι) (b : Ordinal), b < c → f i b < c
a : Ordinal
ha : a < c
⊢ nfpFamily f a < c

tactic: rw [lift_max]
state_before: case refine'_1
α : Type ?u.32966
r : α → α → Prop
ι : Type u
f : ι → Ordinal → Ordinal
c : Ordinal
hc : ℵ₀ < cof c
hc' : Cardinal.lift (#ι) < cof c
hf : ∀ (i : ι) (b : Ordinal), b < c → f i b < c
a : Ordinal
ha : a < c
⊢ Cardinal.lift (max ℵ₀ (#ι)) < cof c

tactic: apply max_lt _ hc'
state_before: case refine'_1
α : Type ?u.32966
r : α → α → Prop
ι : Type u
f : ι → Ordinal → Ordinal
c : Ordinal
hc : ℵ₀ < cof c
hc' : Cardinal.lift (#ι) < cof c
hf : ∀ (i : ι) (b : Ordinal), b < c → f i b < c
a : Ordinal
ha : a < c
⊢ max (Cardinal.lift ℵ₀) (Cardinal.lift (#ι)) < cof c

tactic: rwa [Cardinal.lift_aleph0]
state_before: α : Type ?u.32966
r : α → α → Prop
ι : Type u
f : ι → Ordinal → Ordinal
c : Ordinal
hc : ℵ₀ < cof c
hc' : Cardinal.lift (#ι) < cof c
hf : ∀ (i : ι) (b : Ordinal), b < c → f i b < c
a : Ordinal
ha : a < c
⊢ Cardinal.lift ℵ₀ < cof c

tactic: induction' l with i l H
state_before: case refine'_2
α : Type ?u.32966
r : α → α → Prop
ι : Type u
f : ι → Ordinal → Ordinal
c : Ordinal
hc : ℵ₀ < cof c
hc' : Cardinal.lift (#ι) < cof c
hf : ∀ (i : ι) (b : Ordinal), b < c → f i b < c
a : Ordinal
ha : a < c
l : List ι
⊢ List.foldr f a l < c

tactic: exact ha
state_before: case refine'_2.nil
α : Type ?u.32966
r : α → α → Prop
ι : Type u
f : ι → Ordinal → Ordinal
c : Ordinal
hc : ℵ₀ < cof c
hc' : Cardinal.lift (#ι) < cof c
hf : ∀ (i : ι) (b : Ordinal), b < c → f i b < c
a : Ordinal
ha : a < c
⊢ List.foldr f a [] < c

tactic: exact hf _ _ H
state_before: case refine'_2.cons
α : Type ?u.32966
r : α → α → Prop
ι : Type u
f : ι → Ordinal → Ordinal
c : Ordinal
hc : ℵ₀ < cof c
hc' : Cardinal.lift (#ι) < cof c
hf : ∀ (i : ι) (b : Ordinal), b < c → f i b < c
a : Ordinal
ha : a < c
i : ι
l : List ι
H : List.foldr f a l < c
⊢ List.foldr f a (i :: l) < c
Theorem: List.Ico.pred_singleton
File: Mathlib/Data/List/Intervals.lean

tactic: dsimp [Ico]
state_before: m : ℕ
h : 0 < m
⊢ Ico (m - 1) m = [m - 1]

tactic: rw [tsub_tsub_cancel_of_le (succ_le_of_lt h)]
state_before: m : ℕ
h : 0 < m
⊢ range' (m - 1) (m - (m - 1)) = [m - 1]

tactic: simp [← Nat.one_eq_succ_zero]
state_before: m : ℕ
h : 0 < m
⊢ range' (m - 1) (succ 0) = [m - 1]
Theorem: Real.exp_approx_end
File: Mathlib/Data/Complex/Exponential.lean

tactic: simp [expNear]
state_before: n m : ℕ
x : ℝ
e₁ : n + 1 = m
h : abs' x ≤ 1
⊢ abs' (exp x - expNear m x 0) ≤ abs' x ^ m / ↑(Nat.factorial m) * ((↑m + 1) / ↑m)

tactic: convert exp_bound (n := m) h ?_ using 1
state_before: n m : ℕ
x : ℝ
e₁ : n + 1 = m
h : abs' x ≤ 1
⊢ abs' (exp x - ∑ m in range m, x ^ m / ↑(Nat.factorial m)) ≤ abs' x ^ m / ↑(Nat.factorial m) * ((↑m + 1) / ↑m)

tactic: field_simp [mul_comm]
state_before: case h.e'_4
n m : ℕ
x : ℝ
e₁ : n + 1 = m
h : abs' x ≤ 1
⊢ abs' x ^ m / ↑(Nat.factorial m) * ((↑m + 1) / ↑m) = abs' x ^ m * (↑(Nat.succ m) / (↑(Nat.factorial m) * ↑m))

n m : ℕ
x : ℝ
e₁ : n + 1 = m
h : abs' x ≤ 1
⊢ 0 < m

tactic: linarith
state_before: n m : ℕ
x : ℝ
e₁ : n + 1 = m
h : abs' x ≤ 1
⊢ 0 < m
Theorem: Cardinal.isRegular_aleph_succ
File: Mathlib/SetTheory/Cardinal/Cofinality.lean

tactic: rw [aleph_succ]
state_before: α : Type ?u.147903
r : α → α → Prop
o : Ordinal
⊢ IsRegular (aleph (succ o))

tactic: exact isRegular_succ (aleph0_le_aleph o)
state_before: α : Type ?u.147903
r : α → α → Prop
o : Ordinal
⊢ IsRegular (succ (aleph o))
Theorem: IntermediateField.fieldRange_le
File: Mathlib/FieldTheory/IntermediateField.lean

tactic: rwa [Set.mem_range, ← RingHom.mem_fieldRange]
state_before: K : Type u_2
L : Type u_1
L' : Type ?u.252800
inst✝⁴ : Field K
inst✝³ : Field L
inst✝² : Field L'
inst✝¹ : Algebra K L
inst✝ : Algebra K L'
S : IntermediateField K L
x : L
hx : x ∈ RingHom.fieldRange (algebraMap K L)
⊢ x ∈ Set.range ↑(algebraMap K L)
Theorem: FermatPsp.frequently_atTop_fermatPsp
File: Mathlib/NumberTheory/FermatPsp.lean

tactic: refine' Filter.frequently_atTop.2 fun n => _
state_before: b : ℕ
h : 1 ≤ b
⊢ ∃ᶠ (n : ℕ) in Filter.atTop, FermatPsp n b

tactic: obtain ⟨p, hp⟩ := exists_infinite_pseudoprimes h n
state_before: b : ℕ
h : 1 ≤ b
n : ℕ
⊢ ∃ b_1, b_1 ≥ n ∧ FermatPsp b_1 b

tactic: exact ⟨p, hp.2, hp.1⟩
state_before: case intro
b : ℕ
h : 1 ≤ b
n p : ℕ
hp : FermatPsp p b ∧ n ≤ p
⊢ ∃ b_1, b_1 ≥ n ∧ FermatPsp b_1 b
Theorem: Basis.toDual_range
File: Mathlib/LinearAlgebra/Dual.lean

tactic: cases nonempty_fintype ι
state_before: R : Type u
M : Type v
K : Type u₁
V : Type u₂
ι : Type w
inst✝⁴ : CommSemiring R
inst✝³ : AddCommMonoid M
inst✝² : Module R M
inst✝¹ : DecidableEq ι
b : Basis ι R M
inst✝ : _root_.Finite ι
⊢ range (toDual b) = ⊤

tactic: refine' eq_top_iff'.2 fun f => _
state_before: case intro
R : Type u
M : Type v
K : Type u₁
V : Type u₂
ι : Type w
inst✝⁴ : CommSemiring R
inst✝³ : AddCommMonoid M
inst✝² : Module R M
inst✝¹ : DecidableEq ι
b : Basis ι R M
inst✝ : _root_.Finite ι
val✝ : Fintype ι
⊢ range (toDual b) = ⊤

tactic: rw [LinearMap.mem_range]
state_before: case intro
R : Type u
M : Type v
K : Type u₁
V : Type u₂
ι : Type w
inst✝⁴ : CommSemiring R
inst✝³ : AddCommMonoid M
inst✝² : Module R M
inst✝¹ : DecidableEq ι
b : Basis ι R M
inst✝ : _root_.Finite ι
val✝ : Fintype ι
f : Dual R M
⊢ f ∈ range (toDual b)

tactic: let lin_comb : ι →₀ R := Finsupp.equivFunOnFinite.symm fun i => f.toFun (b i)
state_before: case intro
R : Type u
M : Type v
K : Type u₁
V : Type u₂
ι : Type w
inst✝⁴ : CommSemiring R
inst✝³ : AddCommMonoid M
inst✝² : Module R M
inst✝¹ : DecidableEq ι
b : Basis ι R M
inst✝ : _root_.Finite ι
val✝ : Fintype ι
f : Dual R M
⊢ ∃ y, ↑(toDual b) y = f

tactic: refine' ⟨Finsupp.total ι M R b lin_comb, b.ext fun i => _⟩
state_before: case intro
R : Type u
M : Type v
K : Type u₁
V : Type u₂
ι : Type w
inst✝⁴ : CommSemiring R
inst✝³ : AddCommMonoid M
inst✝² : Module R M
inst✝¹ : DecidableEq ι
b : Basis ι R M
inst✝ : _root_.Finite ι
val✝ : Fintype ι
f : Dual R M
lin_comb : ι →₀ R := ↑Finsupp.equivFunOnFinite.symm fun i => AddHom.toFun f.toAddHom (↑b i)
⊢ ∃ y, ↑(toDual b) y = f

tactic: rw [b.toDual_eq_repr _ i, repr_total b]
state_before: case intro
R : Type u
M : Type v
K : Type u₁
V : Type u₂
ι : Type w
inst✝⁴ : CommSemiring R
inst✝³ : AddCommMonoid M
inst✝² : Module R M
inst✝¹ : DecidableEq ι
b : Basis ι R M
inst✝ : _root_.Finite ι
val✝ : Fintype ι
f : Dual R M
lin_comb : ι →₀ R := ↑Finsupp.equivFunOnFinite.symm fun i => AddHom.toFun f.toAddHom (↑b i)
i : ι
⊢ ↑(↑(toDual b) (↑(Finsupp.total ι M R ↑b) lin_comb)) (↑b i) = ↑f (↑b i)

tactic: rfl
state_before: case intro
R : Type u
M : Type v
K : Type u₁
V : Type u₂
ι : Type w
inst✝⁴ : CommSemiring R
inst✝³ : AddCommMonoid M
inst✝² : Module R M
inst✝¹ : DecidableEq ι
b : Basis ι R M
inst✝ : _root_.Finite ι
val✝ : Fintype ι
f : Dual R M
lin_comb : ι →₀ R := ↑Finsupp.equivFunOnFinite.symm fun i => AddHom.toFun f.toAddHom (↑b i)
i : ι
⊢ ↑lin_comb i = ↑f (↑b i)
Theorem: Filter.pure_seq_eq_map
File: Mathlib/Order/Filter/Basic.lean

tactic: refine' le_antisymm (le_map fun s hs => _) (le_seq fun s hs t ht => _)
state_before: α : Type u
β : Type v
γ : Type w
δ : Type ?u.293780
ι : Sort x
g : α → β
f : Filter α
⊢ seq (pure g) f = map g f

tactic: rw [← singleton_seq]
state_before: case refine'_1
α : Type u
β : Type v
γ : Type w
δ : Type ?u.293780
ι : Sort x
g : α → β
f : Filter α
s : Set α
hs : s ∈ f
⊢ g '' s ∈ seq (pure g) f

tactic: apply seq_mem_seq _ hs
state_before: case refine'_1
α : Type u
β : Type v
γ : Type w
δ : Type ?u.293780
ι : Sort x
g : α → β
f : Filter α
s : Set α
hs : s ∈ f
⊢ Set.seq {g} s ∈ seq (pure g) f

tactic: exact singleton_mem_pure
state_before: α : Type u
β : Type v
γ : Type w
δ : Type ?u.293780
ι : Sort x
g : α → β
f : Filter α
s : Set α
hs : s ∈ f
⊢ {g} ∈ pure g

tactic: refine' sets_of_superset (map g f) (image_mem_map ht) _
state_before: case refine'_2
α : Type u
β : Type v
γ : Type w
δ : Type ?u.293780
ι : Sort x
g : α → β
f : Filter α
s : Set (α → β)
hs : s ∈ pure g
t : Set α
ht : t ∈ f
⊢ Set.seq s t ∈ map g f

tactic: rintro b ⟨a, ha, rfl⟩
state_before: case refine'_2
α : Type u
β : Type v
γ : Type w
δ : Type ?u.293780
ι : Sort x
g : α → β
f : Filter α
s : Set (α → β)
hs : s ∈ pure g
t : Set α
ht : t ∈ f
⊢ g '' t ⊆ Set.seq s t

tactic: exact ⟨g, hs, a, ha, rfl⟩
state_before: case refine'_2.intro.intro
α : Type u
β : Type v
γ : Type w
δ : Type ?u.293780
ι : Sort x
g : α → β
f : Filter α
s : Set (α → β)
hs : s ∈ pure g
t : Set α
ht : t ∈ f
a : α
ha : a ∈ t
⊢ g a ∈ Set.seq s t
Theorem: Nat.add_div_eq_of_add_mod_lt
File: Mathlib/Data/Nat/ModEq.lean

tactic: simp [hc0]
state_before: m n a✝ b✝ c✝ d a b c : ℕ
hc : a % c + b % c < c
hc0 : c = 0
⊢ (a + b) / c = a / c + b / c

tactic: rw [add_div (Nat.pos_of_ne_zero hc0), if_neg (not_le_of_lt hc), add_zero]
state_before: m n a✝ b✝ c✝ d a b c : ℕ
hc : a % c + b % c < c
hc0 : ¬c = 0
⊢ (a + b) / c = a / c + b / c
Theorem: List.IsRotated.map
File: Mathlib/Data/List/Rotate.lean

tactic: obtain ⟨n, rfl⟩ := h
state_before: α : Type u
l l' : List α
β : Type u_1
l₁ l₂ : List α
h : l₁ ~r l₂
f : α → β
⊢ List.map f l₁ ~r List.map f l₂

tactic: rw [map_rotate]
state_before: case intro
α : Type u
l l' : List α
β : Type u_1
l₁ : List α
f : α → β
n : ℕ
⊢ List.map f l₁ ~r List.map f (rotate l₁ n)

tactic: use n
state_before: case intro
α : Type u
l l' : List α
β : Type u_1
l₁ : List α
f : α → β
n : ℕ
⊢ List.map f l₁ ~r rotate (List.map f l₁) n
Theorem: Subgroup.mem_leftTransversals_iff_existsUnique_quotient_mk''_eq
File: Mathlib/GroupTheory/Complement.lean

tactic: simp_rw [mem_leftTransversals_iff_existsUnique_inv_mul_mem, SetLike.mem_coe, ←
  QuotientGroup.eq']
state_before: G : Type u_1
inst✝ : Group G
H K : Subgroup G
S T : Set G
⊢ S ∈ leftTransversals ↑H ↔ ∀ (q : Quotient (QuotientGroup.leftRel H)), ∃! s, Quotient.mk'' ↑s = q

tactic: exact ⟨fun h q => Quotient.inductionOn' q h, fun h g => h (Quotient.mk'' g)⟩
state_before: G : Type u_1
inst✝ : Group G
H K : Subgroup G
S T : Set G
⊢ (∀ (g : G), ∃! s, ↑↑s = ↑g) ↔ ∀ (q : Quotient (QuotientGroup.leftRel H)), ∃! s, Quotient.mk'' ↑s = q
Theorem: InnerProductGeometry.tan_angle_sub_of_inner_eq_zero
File: Mathlib/Geometry/Euclidean/Angle/Unoriented/RightAngle.lean

tactic: rw [← neg_eq_zero, ← inner_neg_right] at h
state_before: V : Type u_1
inst✝¹ : NormedAddCommGroup V
inst✝ : InnerProductSpace ℝ V
x y : V
h : inner x y = 0
⊢ Real.tan (angle x (x - y)) = ‖y‖ / ‖x‖

tactic: rw [sub_eq_add_neg, tan_angle_add_of_inner_eq_zero h, norm_neg]
state_before: V : Type u_1
inst✝¹ : NormedAddCommGroup V
inst✝ : InnerProductSpace ℝ V
x y : V
h : inner x (-y) = 0
⊢ Real.tan (angle x (x - y)) = ‖y‖ / ‖x‖