tasksource/leandojo huggingface dataset:
Theorem: PadicInt.zmod_congr_of_sub_mem_span_aux
File: Mathlib/NumberTheory/Padics/RingHoms.lean

tactic: rw [Ideal.mem_span_singleton] at ha hb
state_before: p : ℕ
hp_prime : Fact (Nat.Prime p)
r : ℚ
n : ℕ
x : ℤ_[p]
a b : ℤ
ha : x - ↑a ∈ Ideal.span {↑p ^ n}
hb : x - ↑b ∈ Ideal.span {↑p ^ n}
⊢ ↑a = ↑b

tactic: rw [← sub_eq_zero, ← Int.cast_sub, ZMod.int_cast_zmod_eq_zero_iff_dvd, Int.coe_nat_pow]
state_before: p : ℕ
hp_prime : Fact (Nat.Prime p)
r : ℚ
n : ℕ
x : ℤ_[p]
a b : ℤ
ha : ↑p ^ n ∣ x - ↑a
hb : ↑p ^ n ∣ x - ↑b
⊢ ↑a = ↑b

tactic: rw [← dvd_neg, neg_sub] at ha
state_before: p : ℕ
hp_prime : Fact (Nat.Prime p)
r : ℚ
n : ℕ
x : ℤ_[p]
a b : ℤ
ha : ↑p ^ n ∣ x - ↑a
hb : ↑p ^ n ∣ x - ↑b
⊢ ↑p ^ n ∣ a - b

tactic: have := dvd_add ha hb
state_before: p : ℕ
hp_prime : Fact (Nat.Prime p)
r : ℚ
n : ℕ
x : ℤ_[p]
a b : ℤ
ha✝ : ↑p ^ n ∣ x - ↑a
ha : ↑p ^ n ∣ ↑a - x
hb : ↑p ^ n ∣ x - ↑b
⊢ ↑p ^ n ∣ a - b

tactic: rwa [sub_eq_add_neg, sub_eq_add_neg, add_assoc, neg_add_cancel_left, ← sub_eq_add_neg, ←
  Int.cast_sub, pow_p_dvd_int_iff, Nat.cast_pow] at this
state_before: p : ℕ
hp_prime : Fact (Nat.Prime p)
r : ℚ
n : ℕ
x : ℤ_[p]
a b : ℤ
ha✝ : ↑p ^ n ∣ x - ↑a
ha : ↑p ^ n ∣ ↑a - x
hb : ↑p ^ n ∣ x - ↑b
this : ↑p ^ n ∣ ↑a - x + (x - ↑b)
⊢ ↑p ^ n ∣ a - b
Theorem: Dfinsupp.sum_single
File: Mathlib/Data/Dfinsupp/Basic.lean

tactic: have := FunLike.congr_fun (liftAddHom_singleAddHom (β := β)) f
state_before: ι : Type u
γ : Type w
β : ι → Type v
β₁ : ι → Type v₁
β₂ : ι → Type v₂
dec : DecidableEq ι
inst✝¹ : (i : ι) → AddCommMonoid (β i)
inst✝ : (i : ι) → (x : β i) → Decidable (x ≠ 0)
f : Π₀ (i : ι), β i
⊢ sum f single = f

tactic: rw [liftAddHom_apply, sumAddHom_apply] at this
state_before: ι : Type u
γ : Type w
β : ι → Type v
β₁ : ι → Type v₁
β₂ : ι → Type v₂
dec : DecidableEq ι
inst✝¹ : (i : ι) → AddCommMonoid (β i)
inst✝ : (i : ι) → (x : β i) → Decidable (x ≠ 0)
f : Π₀ (i : ι), β i
this : ↑(↑liftAddHom (singleAddHom β)) f = ↑(AddMonoidHom.id (Π₀ (i : ι), β i)) f
⊢ sum f single = f

tactic: exact this
state_before: ι : Type u
γ : Type w
β : ι → Type v
β₁ : ι → Type v₁
β₂ : ι → Type v₂
dec : DecidableEq ι
inst✝¹ : (i : ι) → AddCommMonoid (β i)
inst✝ : (i : ι) → (x : β i) → Decidable (x ≠ 0)
f : Π₀ (i : ι), β i
this✝ : ↑(sumAddHom (singleAddHom β)) f = ↑(AddMonoidHom.id (Π₀ (i : ι), β i)) f
this : (sum f fun x => ↑(singleAddHom β x)) = ↑(AddMonoidHom.id (Π₀ (i : ι), β i)) f
⊢ sum f single = f
Theorem: Stream'.WSeq.tail_cons
File: Mathlib/Data/Seq/WSeq.lean

tactic: simp [tail]
state_before: α : Type u
β : Type v
γ : Type w
a : α
s : WSeq α
⊢ tail (cons a s) = s
Theorem: integral_sin_mul_cos_sq
File: Mathlib/Analysis/SpecialFunctions/Integrals.lean

tactic: have := @integral_sin_pow_odd_mul_cos_pow a b 0 2
state_before: a b : ℝ
n : ℕ
⊢ (∫ (x : ℝ) in a..b, sin x * cos x ^ 2) = (cos a ^ 3 - cos b ^ 3) / 3

tactic: norm_num at this
state_before: a b : ℝ
n : ℕ
this : (∫ (x : ℝ) in a..b, sin x ^ (2 * 0 + 1) * cos x ^ 2) = ∫ (u : ℝ) in cos b..cos a, u ^ 2 * (1 - u ^ 2) ^ 0
⊢ (∫ (x : ℝ) in a..b, sin x * cos x ^ 2) = (cos a ^ 3 - cos b ^ 3) / 3

tactic: exact this
state_before: a b : ℝ
n : ℕ
this : (∫ (x : ℝ) in a..b, sin x * cos x ^ 2) = (cos a ^ 3 - cos b ^ 3) / 3
⊢ (∫ (x : ℝ) in a..b, sin x * cos x ^ 2) = (cos a ^ 3 - cos b ^ 3) / 3
Theorem: CategoryTheory.Abelian.epi_fst_of_factor_thru_epi_mono_factorization
File: Mathlib/CategoryTheory/Abelian/Basic.lean

tactic: apply epi_fst_of_isLimit _ _ (PullbackCone.isLimitOfFactors f g g₂ f' g₁ hf hg t ht)
state_before: C : Type u
inst✝⁴ : Category C
inst✝³ : Abelian C
inst✝² : HasPullbacks C
W X Y Z : C
f : X ⟶ Z
g : Y ⟶ Z
g₁ : Y ⟶ W
inst✝¹ : Epi g₁
g₂ : W ⟶ Z
inst✝ : Mono g₂
hg : g₁ ≫ g₂ = g
f' : X ⟶ W
hf : f' ≫ g₂ = f
t : PullbackCone f g
ht : IsLimit t
⊢ Epi (PullbackCone.fst t)
Theorem: MeasureTheory.integral_prod_swap
File: Mathlib/MeasureTheory/Constructions/Prod/Integral.lean

tactic: rw [← prod_swap] at hf
state_before: α : Type u_1
α' : Type ?u.2413828
β : Type u_2
β' : Type ?u.2413834
γ : Type ?u.2413837
E : Type u_3
inst✝⁹ : MeasurableSpace α
inst✝⁸ : MeasurableSpace α'
inst✝⁷ : MeasurableSpace β
inst✝⁶ : MeasurableSpace β'
inst✝⁵ : MeasurableSpace γ
μ μ' : Measure α
ν ν' : Measure β
τ : Measure γ
inst✝⁴ : NormedAddCommGroup E
inst✝³ : SigmaFinite ν
inst✝² : NormedSpace ℝ E
inst✝¹ : CompleteSpace E
inst✝ : SigmaFinite μ
f : α × β → E
hf : AEStronglyMeasurable f (Measure.prod μ ν)
⊢ (∫ (z : β × α), f (Prod.swap z) ∂Measure.prod ν μ) = ∫ (z : α × β), f z ∂Measure.prod μ ν

tactic: rw [← integral_map measurable_swap.aemeasurable hf, prod_swap]
state_before: α : Type u_1
α' : Type ?u.2413828
β : Type u_2
β' : Type ?u.2413834
γ : Type ?u.2413837
E : Type u_3
inst✝⁹ : MeasurableSpace α
inst✝⁸ : MeasurableSpace α'
inst✝⁷ : MeasurableSpace β
inst✝⁶ : MeasurableSpace β'
inst✝⁵ : MeasurableSpace γ
μ μ' : Measure α
ν ν' : Measure β
τ : Measure γ
inst✝⁴ : NormedAddCommGroup E
inst✝³ : SigmaFinite ν
inst✝² : NormedSpace ℝ E
inst✝¹ : CompleteSpace E
inst✝ : SigmaFinite μ
f : α × β → E
hf : AEStronglyMeasurable f (map Prod.swap (Measure.prod ν μ))
⊢ (∫ (z : β × α), f (Prod.swap z) ∂Measure.prod ν μ) = ∫ (z : α × β), f z ∂Measure.prod μ ν
Theorem: List.inits_reverse
File: Mathlib/Data/List/Infix.lean

tactic: rw [tails_eq_inits l]
state_before: α : Type u_1
β : Type ?u.46786
l✝ l₁ l₂ l₃ : List α
a b : α
m n : ℕ
l : List α
⊢ inits (reverse l) = reverse (map reverse (tails l))

tactic: simp [reverse_involutive.comp_self, reverse_map]
state_before: α : Type u_1
β : Type ?u.46786
l✝ l₁ l₂ l₃ : List α
a b : α
m n : ℕ
l : List α
⊢ inits (reverse l) = reverse (map reverse (reverse (map reverse (inits (reverse l)))))
Theorem: BoxIntegral.Box.mapsTo_insertNth_face
File: Mathlib/Analysis/BoxIntegral/Box/Basic.lean

tactic: intro y hy
state_before: ι : Type ?u.314687
I✝ J : Box ι
x✝ y : ι → ℝ
n : ℕ
I : Box (Fin (n + 1))
i : Fin (n + 1)
x : ℝ
hx : x ∈ Ioc (lower I i) (upper I i)
⊢ MapsTo (Fin.insertNth i x) ↑(face I i) ↑I

tactic: simp_rw [mem_coe, mem_def, i.forall_iff_succAbove, Fin.insertNth_apply_same,
  Fin.insertNth_apply_succAbove]
state_before: ι : Type ?u.314687
I✝ J : Box ι
x✝ y✝ : ι → ℝ
n : ℕ
I : Box (Fin (n + 1))
i : Fin (n + 1)
x : ℝ
hx : x ∈ Ioc (lower I i) (upper I i)
y : Fin n → ℝ
hy : y ∈ ↑(face I i)
⊢ Fin.insertNth i x y ∈ ↑I

tactic: exact ⟨hx, hy⟩
state_before: ι : Type ?u.314687
I✝ J : Box ι
x✝ y✝ : ι → ℝ
n : ℕ
I : Box (Fin (n + 1))
i : Fin (n + 1)
x : ℝ
hx : x ∈ Ioc (lower I i) (upper I i)
y : Fin n → ℝ
hy : y ∈ ↑(face I i)
⊢ x ∈ Ioc (lower I i) (upper I i) ∧
    ∀ (j : Fin n), y j ∈ Ioc (lower I (↑(Fin.succAbove i) j)) (upper I (↑(Fin.succAbove i) j))
Theorem: Lists.Equiv.antisymm_iff
File: Mathlib/SetTheory/Lists.lean

tactic: refine' ⟨fun h => _, fun ⟨h₁, h₂⟩ => Equiv.antisymm h₁ h₂⟩
state_before: α : Type u_1
l₁ l₂ : Lists' α true
⊢ of' l₁ ~ of' l₂ ↔ l₁ ⊆ l₂ ∧ l₂ ⊆ l₁

tactic: cases' h with _ _ _ h₁ h₂
state_before: α : Type u_1
l₁ l₂ : Lists' α true
h : of' l₁ ~ of' l₂
⊢ l₁ ⊆ l₂ ∧ l₂ ⊆ l₁

tactic: . exact ⟨h₁, h₂⟩
state_before: case antisymm
α : Type u_1
l₁ l₂ : Lists' α true
h₁ : Lists'.Subset l₁ l₂
h₂ : Lists'.Subset l₂ l₁
⊢ l₁ ⊆ l₂ ∧ l₂ ⊆ l₁

tactic: simp [Lists'.Subset.refl]
state_before: case refl
α : Type u_1
l₁ : Lists' α true
⊢ l₁ ⊆ l₁ ∧ l₁ ⊆ l₁

tactic: exact ⟨h₁, h₂⟩
state_before: case antisymm
α : Type u_1
l₁ l₂ : Lists' α true
h₁ : Lists'.Subset l₁ l₂
h₂ : Lists'.Subset l₂ l₁
⊢ l₁ ⊆ l₂ ∧ l₂ ⊆ l₁
Theorem: Finset.prod_sdiff
File: Mathlib/Algebra/BigOperators/Basic.lean

tactic: rw [← prod_union sdiff_disjoint, sdiff_union_of_subset h]
state_before: ι : Type ?u.306898
β : Type u
α : Type v
γ : Type w
s s₁ s₂ : Finset α
a : α
f g : α → β
inst✝¹ : CommMonoid β
inst✝ : DecidableEq α
h : s₁ ⊆ s₂
⊢ (∏ x in s₂ \ s₁, f x) * ∏ x in s₁, f x = ∏ x in s₂, f x
Theorem: padicNormE.norm_p_zpow
File: Mathlib/NumberTheory/Padics/PadicNumbers.lean

tactic: rw [norm_zpow, norm_p, zpow_neg, inv_zpow]
state_before: p : ℕ
hp : Fact (Nat.Prime p)
n : ℤ
⊢ ‖↑p ^ n‖ = ↑p ^ (-n)
Theorem: Submodule.snd_map_snd
File: Mathlib/LinearAlgebra/Prod.lean

tactic: rw [eq_top_iff]
state_before: R : Type u
K : Type u'
M : Type v
V : Type v'
M₂ : Type w
V₂ : Type w'
M₃ : Type y
V₃ : Type y'
M₄ : Type z
ι : Type x
M₅ : Type ?u.362883
M₆ : Type ?u.362886
inst✝⁴ : Semiring R
inst✝³ : AddCommMonoid M
inst✝² : AddCommMonoid M₂
inst✝¹ : Module R M
inst✝ : Module R M₂
p : Submodule R M
q : Submodule R M₂
⊢ map (LinearMap.snd R M M₂) (snd R M M₂) = ⊤

tactic: rintro x -
state_before: R : Type u
K : Type u'
M : Type v
V : Type v'
M₂ : Type w
V₂ : Type w'
M₃ : Type y
V₃ : Type y'
M₄ : Type z
ι : Type x
M₅ : Type ?u.362883
M₆ : Type ?u.362886
inst✝⁴ : Semiring R
inst✝³ : AddCommMonoid M
inst✝² : AddCommMonoid M₂
inst✝¹ : Module R M
inst✝ : Module R M₂
p : Submodule R M
q : Submodule R M₂
⊢ ⊤ ≤ map (LinearMap.snd R M M₂) (snd R M M₂)

tactic: simp only [snd, comap_bot, mem_map, mem_ker, snd_apply, fst_apply,
  Prod.exists, exists_eq_right, exists_eq]
state_before: R : Type u
K : Type u'
M : Type v
V : Type v'
M₂ : Type w
V₂ : Type w'
M₃ : Type y
V₃ : Type y'
M₄ : Type z
ι : Type x
M₅ : Type ?u.362883
M₆ : Type ?u.362886
inst✝⁴ : Semiring R
inst✝³ : AddCommMonoid M
inst✝² : AddCommMonoid M₂
inst✝¹ : Module R M
inst✝ : Module R M₂
p : Submodule R M
q : Submodule R M₂
x : M₂
⊢ x ∈ map (LinearMap.snd R M M₂) (snd R M M₂)
Theorem: MeasureTheory.integral_nonneg_of_ae
File: Mathlib/MeasureTheory/Integral/Bochner.lean

tactic: simp only [integral, L1.integral]
state_before: α : Type u_1
E : Type ?u.1063910
F : Type ?u.1063913
𝕜 : Type ?u.1063916
inst✝¹⁰ : NormedAddCommGroup E
inst✝⁹ : NormedSpace ℝ E
inst✝⁸ : CompleteSpace E
inst✝⁷ : NontriviallyNormedField 𝕜
inst✝⁶ : NormedSpace 𝕜 E
inst✝⁵ : SMulCommClass ℝ 𝕜 E
inst✝⁴ : NormedAddCommGroup F
inst✝³ : NormedSpace ℝ F
inst✝² : CompleteSpace F
f✝ g : α → E
m : MeasurableSpace α
μ : Measure α
X : Type ?u.1066607
inst✝¹ : TopologicalSpace X
inst✝ : FirstCountableTopology X
f : α → ℝ
hf : 0 ≤ᵐ[μ] f
⊢ 0 ≤ ∫ (a : α), f a ∂μ

tactic: exact setToFun_nonneg (dominatedFinMeasAdditive_weightedSMul μ)
  (fun s _ _ => weightedSMul_nonneg s) hf
state_before: α : Type u_1
E : Type ?u.1063910
F : Type ?u.1063913
𝕜 : Type ?u.1063916
inst✝¹⁰ : NormedAddCommGroup E
inst✝⁹ : NormedSpace ℝ E
inst✝⁸ : CompleteSpace E
inst✝⁷ : NontriviallyNormedField 𝕜
inst✝⁶ : NormedSpace 𝕜 E
inst✝⁵ : SMulCommClass ℝ 𝕜 E
inst✝⁴ : NormedAddCommGroup F
inst✝³ : NormedSpace ℝ F
inst✝² : CompleteSpace F
f✝ g : α → E
m : MeasurableSpace α
μ : Measure α
X : Type ?u.1066607
inst✝¹ : TopologicalSpace X
inst✝ : FirstCountableTopology X
f : α → ℝ
hf : 0 ≤ᵐ[μ] f
⊢ 0 ≤ if hf : Integrable fun a => f a then ↑L1.integralCLM (Integrable.toL1 (fun a => f a) hf) else 0
Theorem: Equiv.Perm.signAux_swap
File: Mathlib/GroupTheory/Perm/Sign.lean

tactic: intro
state_before: α : Type u
β : Type v
inst✝ : DecidableEq α
x y : Fin 0
⊢ x ≠ y → signAux (swap x y) = -1

tactic: exact Fin.elim0 x
state_before: α : Type u
β : Type v
inst✝ : DecidableEq α
x y : Fin 0
_hxy✝ : x ≠ y
⊢ signAux (swap x y) = -1

tactic: dsimp [signAux, swap, swapCore]
state_before: α : Type u
β : Type v
inst✝ : DecidableEq α
x y : Fin 1
⊢ x ≠ y → signAux (swap x y) = -1

tactic: simp only [eq_iff_true_of_subsingleton, not_true, ite_true, le_refl, prod_const,
           IsEmpty.forall_iff]
state_before: α : Type u
β : Type v
inst✝ : DecidableEq α
x y : Fin 1
⊢ ¬x = y →
    (∏ x_1 in finPairsLT 1,
        if
            (if x_1.fst = x then y else if x_1.fst = y then x else x_1.fst) ≤
              if x_1.snd = x then y else if x_1.snd = y then x else x_1.snd then
          -1
        else 1) =
      -1

tactic: have h2n : 2 ≤ n + 2 := by exact le_add_self
state_before: α : Type u
β : Type v
inst✝ : DecidableEq α
n : ℕ
x y : Fin (n + 2)
hxy : x ≠ y
⊢ signAux (swap x y) = -1

tactic: rw [← isConj_iff_eq, ← signAux_swap_zero_one h2n]
state_before: α : Type u
β : Type v
inst✝ : DecidableEq α
n : ℕ
x y : Fin (n + 2)
hxy : x ≠ y
h2n : 2 ≤ n + 2
⊢ signAux (swap x y) = -1

tactic: exact (MonoidHom.mk' signAux signAux_mul).map_isConj
  (isConj_swap hxy (by exact of_decide_eq_true rfl))
state_before: α : Type u
β : Type v
inst✝ : DecidableEq α
n : ℕ
x y : Fin (n + 2)
hxy : x ≠ y
h2n : 2 ≤ n + 2
⊢ IsConj (signAux (swap x y))
    (signAux (swap { val := 0, isLt := (_ : 0 < n + 2) } { val := 1, isLt := (_ : 1 < n + 2) }))

tactic: exact le_add_self
state_before: α : Type u
β : Type v
inst✝ : DecidableEq α
n : ℕ
x y : Fin (n + 2)
hxy : x ≠ y
⊢ 2 ≤ n + 2

tactic: exact of_decide_eq_true rfl
state_before: α : Type u
β : Type v
inst✝ : DecidableEq α
n : ℕ
x y : Fin (n + 2)
hxy : x ≠ y
h2n : 2 ≤ n + 2
⊢ { val := 0, isLt := (_ : 0 < n + 2) } ≠ { val := 1, isLt := (_ : 1 < n + 2) }
Theorem: Filter.generate_eq_generate_inter
File: Mathlib/Order/Filter/Bases.lean

tactic: rw [← FilterBasis.ofSets_sets, FilterBasis.generate, ← (hasBasis_generate s).filter_eq]
state_before: α : Type u_1
β : Type ?u.15651
γ : Type ?u.15654
ι : Sort ?u.15657
ι' : Sort ?u.15660
l l' : Filter α
p : ι → Prop
s✝ : ι → Set α
t : Set α
i : ι
p' : ι' → Prop
s' : ι' → Set α
i' : ι'
s : Set (Set α)
⊢ generate s = generate (sInter '' {t | Set.Finite t ∧ t ⊆ s})

tactic: rfl
state_before: α : Type u_1
β : Type ?u.15651
γ : Type ?u.15654
ι : Sort ?u.15657
ι' : Sort ?u.15660
l l' : Filter α
p : ι → Prop
s✝ : ι → Set α
t : Set α
i : ι
p' : ι' → Prop
s' : ι' → Set α
i' : ι'
s : Set (Set α)
⊢ IsBasis.filter (_ : IsBasis (fun t => Set.Finite t ∧ t ⊆ s) fun t => ⋂₀ t) = FilterBasis.filter (FilterBasis.ofSets s)
Theorem: taylorWithinEval_succ
File: Mathlib/Analysis/Calculus/Taylor.lean

tactic: simp_rw [taylorWithinEval, taylorWithin_succ, LinearMap.map_add, PolynomialModule.comp_eval]
state_before: 𝕜 : Type ?u.131034
E : Type u_1
F : Type ?u.131040
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace ℝ E
f : ℝ → E
n : ℕ
s : Set ℝ
x₀ x : ℝ
⊢ taylorWithinEval f (n + 1) s x₀ x =
    taylorWithinEval f n s x₀ x + (((↑n + 1) * ↑n !)⁻¹ * (x - x₀) ^ (n + 1)) • iteratedDerivWithin (n + 1) f s x₀

tactic: congr
state_before: 𝕜 : Type ?u.131034
E : Type u_1
F : Type ?u.131040
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace ℝ E
f : ℝ → E
n : ℕ
s : Set ℝ
x₀ x : ℝ
⊢ ↑(PolynomialModule.eval x) (taylorWithin f n s x₀) +
      ↑(PolynomialModule.eval (Polynomial.eval x (Polynomial.X - ↑Polynomial.C x₀)))
        (↑(PolynomialModule.single ℝ (n + 1)) (taylorCoeffWithin f (n + 1) s x₀)) =
    ↑(PolynomialModule.eval x) (taylorWithin f n s x₀) +
      (((↑n + 1) * ↑n !)⁻¹ * (x - x₀) ^ (n + 1)) • iteratedDerivWithin (n + 1) f s x₀

tactic: simp only [Polynomial.eval_sub, Polynomial.eval_X, Polynomial.eval_C,
  PolynomialModule.eval_single, mul_inv_rev]
state_before: case e_a
𝕜 : Type ?u.131034
E : Type u_1
F : Type ?u.131040
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace ℝ E
f : ℝ → E
n : ℕ
s : Set ℝ
x₀ x : ℝ
⊢ ↑(PolynomialModule.eval (Polynomial.eval x (Polynomial.X - ↑Polynomial.C x₀)))
      (↑(PolynomialModule.single ℝ (n + 1)) (taylorCoeffWithin f (n + 1) s x₀)) =
    (((↑n + 1) * ↑n !)⁻¹ * (x - x₀) ^ (n + 1)) • iteratedDerivWithin (n + 1) f s x₀

tactic: dsimp only [taylorCoeffWithin]
state_before: case e_a
𝕜 : Type ?u.131034
E : Type u_1
F : Type ?u.131040
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace ℝ E
f : ℝ → E
n : ℕ
s : Set ℝ
x₀ x : ℝ
⊢ (x - x₀) ^ (n + 1) • taylorCoeffWithin f (n + 1) s x₀ =
    ((↑n !)⁻¹ * (↑n + 1)⁻¹ * (x - x₀) ^ (n + 1)) • iteratedDerivWithin (n + 1) f s x₀

tactic: rw [← mul_smul, mul_comm, Nat.factorial_succ, Nat.cast_mul, Nat.cast_add, Nat.cast_one,
  mul_inv_rev]
state_before: case e_a
𝕜 : Type ?u.131034
E : Type u_1
F : Type ?u.131040
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace ℝ E
f : ℝ → E
n : ℕ
s : Set ℝ
x₀ x : ℝ
⊢ (x - x₀) ^ (n + 1) • (↑(n + 1)!)⁻¹ • iteratedDerivWithin (n + 1) f s x₀ =
    ((↑n !)⁻¹ * (↑n + 1)⁻¹ * (x - x₀) ^ (n + 1)) • iteratedDerivWithin (n + 1) f s x₀
Theorem: IsROrC.reClm_norm
File: Mathlib/Data/IsROrC/Lemmas.lean

tactic: apply le_antisymm (LinearMap.mkContinuous_norm_le _ zero_le_one _)
state_before: K : Type u_1
E : Type ?u.115606
inst✝ : IsROrC K
⊢ ‖reClm‖ = 1

tactic: convert ContinuousLinearMap.ratio_le_op_norm (reClm : K →L[ℝ] ℝ) (1 : K)
state_before: K : Type u_1
E : Type ?u.115606
inst✝ : IsROrC K
⊢ 1 ≤ ‖LinearMap.mkContinuous reLm 1 (_ : ∀ (x : K), ‖↑reLm x‖ ≤ 1 * ‖x‖)‖

tactic: simp
state_before: case h.e'_3
K : Type u_1
E : Type ?u.115606
inst✝ : IsROrC K
⊢ 1 = ‖↑reClm 1‖ / ‖1‖
Theorem: Finset.not_mem_uIcc_of_gt
File: Mathlib/Data/Finset/LocallyFinite.lean

tactic: rw [mem_uIcc]
state_before: ι : Type ?u.205943
α : Type u_1
inst✝¹ : LinearOrder α
inst✝ : LocallyFiniteOrder α
a a₁ a₂ b b₁ b₂ c x : α
⊢ a < c → b < c → ¬c ∈ [[a, b]]

tactic: exact Set.not_mem_uIcc_of_gt
state_before: ι : Type ?u.205943
α : Type u_1
inst✝¹ : LinearOrder α
inst✝ : LocallyFiniteOrder α
a a₁ a₂ b b₁ b₂ c x : α
⊢ a < c → b < c → ¬(a ⊓ b ≤ c ∧ c ≤ a ⊔ b)
Theorem: Turing.BlankExtends.below_of_le
File: Mathlib/Computability/TuringMachine.lean

tactic: rintro ⟨i, rfl⟩ ⟨j, rfl⟩ h
state_before: Γ : Type u_1
inst✝ : Inhabited Γ
l l₁ l₂ : List Γ
⊢ BlankExtends l l₁ → BlankExtends l l₂ → List.length l₁ ≤ List.length l₂ → BlankExtends l₁ l₂

tactic: use j - i
state_before: case intro.intro
Γ : Type u_1
inst✝ : Inhabited Γ
l : List Γ
i j : ℕ
h : List.length (l ++ List.replicate i default) ≤ List.length (l ++ List.replicate j default)
⊢ BlankExtends (l ++ List.replicate i default) (l ++ List.replicate j default)

tactic: simp only [List.length_append, add_le_add_iff_left, List.length_replicate] at h
state_before: case intro.intro
Γ : Type u_1
inst✝ : Inhabited Γ
l : List Γ
i j : ℕ
h : List.length (l ++ List.replicate i default) ≤ List.length (l ++ List.replicate j default)
⊢ l ++ List.replicate j default = l ++ List.replicate i default ++ List.replicate (j - i) default

tactic: simp only [← List.replicate_add, add_tsub_cancel_of_le h, List.append_assoc]
state_before: case intro.intro
Γ : Type u_1
inst✝ : Inhabited Γ
l : List Γ
i j : ℕ
h : i ≤ j
⊢ l ++ List.replicate j default = l ++ List.replicate i default ++ List.replicate (j - i) default
Theorem: List.head!_append
File: Mathlib/Data/List/Basic.lean

tactic: induction s
state_before: ι : Type ?u.42548
α : Type u
β : Type v
γ : Type w
δ : Type x
l₁ l₂ : List α
inst✝ : Inhabited α
t s : List α
h : s ≠ []
⊢ head! (s ++ t) = head! s

tactic: contradiction
state_before: case nil
ι : Type ?u.42548
α : Type u
β : Type v
γ : Type w
δ : Type x
l₁ l₂ : List α
inst✝ : Inhabited α
t : List α
h : [] ≠ []
⊢ head! ([] ++ t) = head! []

case cons
ι : Type ?u.42548
α : Type u
β : Type v
γ : Type w
δ : Type x
l₁ l₂ : List α
inst✝ : Inhabited α
t : List α
head✝ : α
tail✝ : List α
tail_ih✝ : tail✝ ≠ [] → head! (tail✝ ++ t) = head! tail✝
h : head✝ :: tail✝ ≠ []
⊢ head! (head✝ :: tail✝ ++ t) = head! (head✝ :: tail✝)

tactic: rfl
state_before: case cons
ι : Type ?u.42548
α : Type u
β : Type v
γ : Type w
δ : Type x
l₁ l₂ : List α
inst✝ : Inhabited α
t : List α
head✝ : α
tail✝ : List α
tail_ih✝ : tail✝ ≠ [] → head! (tail✝ ++ t) = head! tail✝
h : head✝ :: tail✝ ≠ []
⊢ head! (head✝ :: tail✝ ++ t) = head! (head✝ :: tail✝)
Theorem: intervalIntegral.integral_sub_integral_sub_linear_isLittleO_of_tendsto_ae_left
File: Mathlib/MeasureTheory/Integral/FundThmCalculus.lean

tactic: simpa only [integral_const, smul_eq_mul, mul_one] using
  measure_integral_sub_integral_sub_linear_isLittleO_of_tendsto_ae_left hab hmeas hf hu hv
state_before: ι : Type u_2
𝕜 : Type ?u.1641367
E : Type u_1
F : Type ?u.1641373
A : Type ?u.1641376
inst✝⁴ : NormedAddCommGroup E
inst✝³ : CompleteSpace E
inst✝² : NormedSpace ℝ E
f : ℝ → E
c ca cb : E
l l' la la' lb lb' : Filter ℝ
lt : Filter ι
a b z : ℝ
u v ua ub va vb : ι → ℝ
inst✝¹ : FTCFilter a la la'
inst✝ : FTCFilter b lb lb'
hab : IntervalIntegrable f volume a b
hmeas : StronglyMeasurableAtFilter f la'
hf : Tendsto f (la' ⊓ Measure.ae volume) (𝓝 c)
hu : Tendsto u lt la
hv : Tendsto v lt la
⊢ (fun t => ((∫ (x : ℝ) in v t..b, f x) - ∫ (x : ℝ) in u t..b, f x) + (v t - u t) • c) =o[lt] (v - u)
Theorem: LiouvilleWith.mul_rat_iff
File: Mathlib/NumberTheory/Liouville/LiouvilleWith.lean

tactic: simpa only [mul_assoc, ← Rat.cast_mul, mul_inv_cancel hr, Rat.cast_one, mul_one] using
  h.mul_rat (inv_ne_zero hr)
state_before: p q x y : ℝ
r : ℚ
m : ℤ
n : ℕ
hr : r ≠ 0
h : LiouvilleWith p (x * ↑r)
⊢ LiouvilleWith p x
Theorem: Nat.Linear.Poly.denote_sort_go
File: src/lean/Init/Data/Nat/Linear.lean

tactic: match p with
| [] => simp
| (k, v):: p => simp [denote_sort_go]
state_before: ctx : Context
p r : Poly
⊢ denote ctx (sort.go p r) = denote ctx p + denote ctx r

tactic: simp
state_before: ctx : Context
p r : Poly
⊢ denote ctx (sort.go [] r) = denote ctx [] + denote ctx r

tactic: simp [denote_sort_go]
state_before: ctx : Context
p✝ r : Poly
k : Nat
v : Var
p : List (Nat × Var)
⊢ denote ctx (sort.go ((k, v) :: p) r) = denote ctx ((k, v) :: p) + denote ctx r
Theorem: tendsto_rpow_div_mul_add
File: Mathlib/Analysis/SpecialFunctions/Pow/Asymptotics.lean

tactic: refine'
  Tendsto.congr' _
    ((tendsto_exp_nhds_0_nhds_1.comp
          (by
            simpa only [MulZeroClass.mul_zero, pow_one] using
              (@tendsto_const_nhds _ _ _ a _).mul
                (tendsto_div_pow_mul_exp_add_atTop b c 1 hb))).comp
      tendsto_log_atTop)
state_before: a b c : ℝ
hb : 0 ≠ b
⊢ Tendsto (fun x => x ^ (a / (b * x + c))) atTop (𝓝 1)

tactic: apply eventuallyEq_of_mem (Ioi_mem_atTop (0 : ℝ))
state_before: a b c : ℝ
hb : 0 ≠ b
⊢ (exp ∘ fun x => a * (x / (b * exp x + c))) ∘ log =ᶠ[atTop] fun x => x ^ (a / (b * x + c))

tactic: intro x hx
state_before: a b c : ℝ
hb : 0 ≠ b
⊢ EqOn ((exp ∘ fun x => a * (x / (b * exp x + c))) ∘ log) (fun x => x ^ (a / (b * x + c))) (Set.Ioi 0)

tactic: simp only [Set.mem_Ioi, Function.comp_apply] at hx⊢
state_before: a b c : ℝ
hb : 0 ≠ b
x : ℝ
hx : x ∈ Set.Ioi 0
⊢ ((exp ∘ fun x => a * (x / (b * exp x + c))) ∘ log) x = (fun x => x ^ (a / (b * x + c))) x

tactic: rw [exp_log hx, ← exp_log (rpow_pos_of_pos hx (a / (b * x + c))), log_rpow hx (a / (b * x + c))]
state_before: a b c : ℝ
hb : 0 ≠ b
x : ℝ
hx : 0 < x
⊢ exp (a * (log x / (b * exp (log x) + c))) = x ^ (a / (b * x + c))

tactic: field_simp
state_before: a b c : ℝ
hb : 0 ≠ b
x : ℝ
hx : 0 < x
⊢ exp (a * (log x / (b * x + c))) = exp (a / (b * x + c) * log x)

tactic: simpa only [MulZeroClass.mul_zero, pow_one] using
  (@tendsto_const_nhds _ _ _ a _).mul
    (tendsto_div_pow_mul_exp_add_atTop b c 1 hb)
state_before: a b c : ℝ
hb : 0 ≠ b
⊢ Tendsto ?m.9221 atTop (𝓝 0)
Theorem: one_le_norm_one
File: Mathlib/Analysis/Normed/Field/Basic.lean

tactic: simpa only [mul_one] using norm_mul_le (1 : β) 1
state_before: α : Type ?u.13548
β✝ : Type ?u.13551
γ : Type ?u.13554
ι : Type ?u.13557
inst✝² : NonUnitalSeminormedRing α
β : Type u_1
inst✝¹ : NormedRing β
inst✝ : Nontrivial β
⊢ ‖1‖ ≤ ‖1‖ * ‖1‖