tasksource/leandojo huggingface dataset:
Theorem: deriv.lhopital_zero_atTop
File: Mathlib/Analysis/Calculus/LHopital.lean

tactic: have hdg : ∀ᶠ x in atTop, DifferentiableAt ℝ g x := hg'.mp
  (eventually_of_forall fun _ hg' =>
    by_contradiction fun h => hg' (deriv_zero_of_not_differentiableAt h))
state_before: a b : ℝ
hab : a < b
l : Filter ℝ
f f' g g' : ℝ → ℝ
hdf : ∀ᶠ (x : ℝ) in atTop, DifferentiableAt ℝ f x
hg' : ∀ᶠ (x : ℝ) in atTop, deriv g x ≠ 0
hftop : Tendsto f atTop (𝓝 0)
hgtop : Tendsto g atTop (𝓝 0)
hdiv : Tendsto (fun x => deriv f x / deriv g x) atTop l
⊢ Tendsto (fun x => f x / g x) atTop l

tactic: have hdf' : ∀ᶠ x in atTop, HasDerivAt f (deriv f x) x :=
  hdf.mp (eventually_of_forall fun _ => DifferentiableAt.hasDerivAt)
state_before: a b : ℝ
hab : a < b
l : Filter ℝ
f f' g g' : ℝ → ℝ
hdf : ∀ᶠ (x : ℝ) in atTop, DifferentiableAt ℝ f x
hg' : ∀ᶠ (x : ℝ) in atTop, deriv g x ≠ 0
hftop : Tendsto f atTop (𝓝 0)
hgtop : Tendsto g atTop (𝓝 0)
hdiv : Tendsto (fun x => deriv f x / deriv g x) atTop l
hdg : ∀ᶠ (x : ℝ) in atTop, DifferentiableAt ℝ g x
⊢ Tendsto (fun x => f x / g x) atTop l

tactic: have hdg' : ∀ᶠ x in atTop, HasDerivAt g (deriv g x) x :=
  hdg.mp (eventually_of_forall fun _ => DifferentiableAt.hasDerivAt)
state_before: a b : ℝ
hab : a < b
l : Filter ℝ
f f' g g' : ℝ → ℝ
hdf : ∀ᶠ (x : ℝ) in atTop, DifferentiableAt ℝ f x
hg' : ∀ᶠ (x : ℝ) in atTop, deriv g x ≠ 0
hftop : Tendsto f atTop (𝓝 0)
hgtop : Tendsto g atTop (𝓝 0)
hdiv : Tendsto (fun x => deriv f x / deriv g x) atTop l
hdg : ∀ᶠ (x : ℝ) in atTop, DifferentiableAt ℝ g x
hdf' : ∀ᶠ (x : ℝ) in atTop, HasDerivAt f (deriv f x) x
⊢ Tendsto (fun x => f x / g x) atTop l

tactic: exact HasDerivAt.lhopital_zero_atTop hdf' hdg' hg' hftop hgtop hdiv
state_before: a b : ℝ
hab : a < b
l : Filter ℝ
f f' g g' : ℝ → ℝ
hdf : ∀ᶠ (x : ℝ) in atTop, DifferentiableAt ℝ f x
hg' : ∀ᶠ (x : ℝ) in atTop, deriv g x ≠ 0
hftop : Tendsto f atTop (𝓝 0)
hgtop : Tendsto g atTop (𝓝 0)
hdiv : Tendsto (fun x => deriv f x / deriv g x) atTop l
hdg : ∀ᶠ (x : ℝ) in atTop, DifferentiableAt ℝ g x
hdf' : ∀ᶠ (x : ℝ) in atTop, HasDerivAt f (deriv f x) x
hdg' : ∀ᶠ (x : ℝ) in atTop, HasDerivAt g (deriv g x) x
⊢ Tendsto (fun x => f x / g x) atTop l
Theorem: Equiv.Perm.sameCycle_inv
File: Mathlib/GroupTheory/Perm/Cycle/Basic.lean

tactic: simp [SameCycle]
state_before: ι : Type ?u.33030
α : Type u_1
β : Type ?u.33036
f g : Perm α
p : α → Prop
x y z : α
⊢ (∃ b, ↑(f⁻¹ ^ ↑(Equiv.neg ℤ).symm b) x = y) ↔ SameCycle f x y
Theorem: DifferentiableAt.derivWithin
File: Mathlib/Analysis/Calculus/Deriv/Basic.lean

tactic: unfold derivWithin deriv
state_before: 𝕜 : Type u
inst✝⁴ : NontriviallyNormedField 𝕜
F : Type v
inst✝³ : NormedAddCommGroup F
inst✝² : NormedSpace 𝕜 F
E : Type w
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace 𝕜 E
f f₀ f₁ g : 𝕜 → F
f' f₀' f₁' g' : F
x : 𝕜
s t : Set 𝕜
L L₁ L₂ : Filter 𝕜
h : DifferentiableAt 𝕜 f x
hxs : UniqueDiffWithinAt 𝕜 s x
⊢ _root_.derivWithin f s x = deriv f x

tactic: rw [h.fderivWithin hxs]
state_before: 𝕜 : Type u
inst✝⁴ : NontriviallyNormedField 𝕜
F : Type v
inst✝³ : NormedAddCommGroup F
inst✝² : NormedSpace 𝕜 F
E : Type w
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace 𝕜 E
f f₀ f₁ g : 𝕜 → F
f' f₀' f₁' g' : F
x : 𝕜
s t : Set 𝕜
L L₁ L₂ : Filter 𝕜
h : DifferentiableAt 𝕜 f x
hxs : UniqueDiffWithinAt 𝕜 s x
⊢ ↑(fderivWithin 𝕜 f s x) 1 = ↑(fderiv 𝕜 f x) 1
Theorem: LinearMap.span_singleton_eq_range
File: Mathlib/LinearAlgebra/Span.lean

tactic: refine' Iff.trans _ LinearMap.mem_range.symm
state_before: R : Type u_2
R₂ : Type ?u.329641
K : Type ?u.329644
M : Type u_1
M₂ : Type ?u.329650
V : Type ?u.329653
S : Type ?u.329656
inst✝² : Semiring R
inst✝¹ : AddCommMonoid M
inst✝ : Module R M
x y : M
⊢ y ∈ span R {x} ↔ y ∈ range (toSpanSingleton R M x)

tactic: exact mem_span_singleton
state_before: R : Type u_2
R₂ : Type ?u.329641
K : Type ?u.329644
M : Type u_1
M₂ : Type ?u.329650
V : Type ?u.329653
S : Type ?u.329656
inst✝² : Semiring R
inst✝¹ : AddCommMonoid M
inst✝ : Module R M
x y : M
⊢ y ∈ span R {x} ↔ ∃ y_1, ↑(toSpanSingleton R M x) y_1 = y
Theorem: FirstOrder.Language.BoundedFormula.realize_foldr_sup
File: Mathlib/ModelTheory/Semantics.lean

tactic: induction' l with φ l ih
state_before: L : Language
L' : Language
M : Type w
N : Type ?u.66568
P : Type ?u.66571
inst✝² : Structure L M
inst✝¹ : Structure L N
inst✝ : Structure L P
α : Type u'
β : Type v'
n l✝ : ℕ
φ ψ : BoundedFormula L α l✝
θ : BoundedFormula L α (Nat.succ l✝)
v✝ : α → M
xs✝ : Fin l✝ → M
l : List (BoundedFormula L α n)
v : α → M
xs : Fin n → M
⊢ Realize (List.foldr (fun x x_1 => x ⊔ x_1) ⊥ l) v xs ↔ ∃ φ, φ ∈ l ∧ Realize φ v xs

tactic: simp
state_before: case nil
L : Language
L' : Language
M : Type w
N : Type ?u.66568
P : Type ?u.66571
inst✝² : Structure L M
inst✝¹ : Structure L N
inst✝ : Structure L P
α : Type u'
β : Type v'
n l : ℕ
φ ψ : BoundedFormula L α l
θ : BoundedFormula L α (Nat.succ l)
v✝ : α → M
xs✝ : Fin l → M
v : α → M
xs : Fin n → M
⊢ Realize (List.foldr (fun x x_1 => x ⊔ x_1) ⊥ []) v xs ↔ ∃ φ, φ ∈ [] ∧ Realize φ v xs

tactic: simp_rw [List.foldr_cons, realize_sup, ih, exists_prop, List.mem_cons, or_and_right, exists_or,
  exists_eq_left]
state_before: case cons
L : Language
L' : Language
M : Type w
N : Type ?u.66568
P : Type ?u.66571
inst✝² : Structure L M
inst✝¹ : Structure L N
inst✝ : Structure L P
α : Type u'
β : Type v'
n l✝ : ℕ
φ✝ ψ : BoundedFormula L α l✝
θ : BoundedFormula L α (Nat.succ l✝)
v✝ : α → M
xs✝ : Fin l✝ → M
v : α → M
xs : Fin n → M
φ : BoundedFormula L α n
l : List (BoundedFormula L α n)
ih : Realize (List.foldr (fun x x_1 => x ⊔ x_1) ⊥ l) v xs ↔ ∃ φ, φ ∈ l ∧ Realize φ v xs
⊢ Realize (List.foldr (fun x x_1 => x ⊔ x_1) ⊥ (φ :: l)) v xs ↔ ∃ φ_1, φ_1 ∈ φ :: l ∧ Realize φ_1 v xs
Theorem: List.prod_ofFn
File: Mathlib/Algebra/BigOperators/Fin.lean

tactic: convert prod_take_ofFn f n
state_before: α : Type u_1
β : Type ?u.226607
inst✝ : CommMonoid α
n : ℕ
f : Fin n → α
⊢ prod (ofFn f) = ∏ i : Fin n, f i

tactic: rw [take_all_of_le (le_of_eq (length_ofFn f))]
state_before: case h.e'_2.h.e'_4
α : Type u_1
β : Type ?u.226607
inst✝ : CommMonoid α
n : ℕ
f : Fin n → α
⊢ ofFn f = take n (ofFn f)

tactic: simp
state_before: case h.e'_3.h
α : Type u_1
β : Type ?u.226607
inst✝ : CommMonoid α
n : ℕ
f : Fin n → α
⊢ univ = Finset.filter (fun j => ↑j < n) univ
Theorem: Set.subsingleton_of_preimage
File: Mathlib/Data/Set/Image.lean

tactic: rcases hf fx, hf fy with ⟨⟨x, rfl⟩, ⟨y, rfl⟩⟩
state_before: α✝ : Type ?u.101676
β✝ : Type ?u.101679
γ : Type ?u.101682
ι : Sort ?u.101685
ι' : Sort ?u.101688
s✝ : Set α✝
α : Type u_1
β : Type u_2
f : α → β
hf : Surjective f
s : Set β
hs : Set.Subsingleton (f ⁻¹' s)
fx : β
hx : fx ∈ s
fy : β
hy : fy ∈ s
⊢ fx = fy

tactic: exact congr_arg f (hs hx hy)
state_before: case intro.intro
α✝ : Type ?u.101676
β✝ : Type ?u.101679
γ : Type ?u.101682
ι : Sort ?u.101685
ι' : Sort ?u.101688
s✝ : Set α✝
α : Type u_1
β : Type u_2
f : α → β
hf : Surjective f
s : Set β
hs : Set.Subsingleton (f ⁻¹' s)
x : α
hx : f x ∈ s
y : α
hy : f y ∈ s
⊢ f x = f y
Theorem: Succ.rec
File: Mathlib/Order/SuccPred/Basic.lean

tactic: obtain ⟨n, rfl⟩ := hmn.exists_succ_iterate
state_before: α : Type u_1
inst✝² : Preorder α
inst✝¹ : SuccOrder α
inst✝ : IsSuccArchimedean α
a b : α
P : α → Prop
m : α
h0 : P m
h1 : ∀ (n : α), m ≤ n → P n → P (succ n)
n : α
hmn : m ≤ n
⊢ P n

tactic: clear hmn
state_before: case intro
α : Type u_1
inst✝² : Preorder α
inst✝¹ : SuccOrder α
inst✝ : IsSuccArchimedean α
a b : α
P : α → Prop
m : α
h0 : P m
h1 : ∀ (n : α), m ≤ n → P n → P (succ n)
n : ℕ
hmn : m ≤ (succ^[n]) m
⊢ P ((succ^[n]) m)

tactic: induction' n with n ih
state_before: case intro
α : Type u_1
inst✝² : Preorder α
inst✝¹ : SuccOrder α
inst✝ : IsSuccArchimedean α
a b : α
P : α → Prop
m : α
h0 : P m
h1 : ∀ (n : α), m ≤ n → P n → P (succ n)
n : ℕ
⊢ P ((succ^[n]) m)

tactic: exact h0
state_before: case intro.zero
α : Type u_1
inst✝² : Preorder α
inst✝¹ : SuccOrder α
inst✝ : IsSuccArchimedean α
a b : α
P : α → Prop
m : α
h0 : P m
h1 : ∀ (n : α), m ≤ n → P n → P (succ n)
⊢ P ((succ^[Nat.zero]) m)

tactic: rw [Function.iterate_succ_apply']
state_before: case intro.succ
α : Type u_1
inst✝² : Preorder α
inst✝¹ : SuccOrder α
inst✝ : IsSuccArchimedean α
a b : α
P : α → Prop
m : α
h0 : P m
h1 : ∀ (n : α), m ≤ n → P n → P (succ n)
n : ℕ
ih : P ((succ^[n]) m)
⊢ P ((succ^[Nat.succ n]) m)

tactic: exact h1 _ (id_le_iterate_of_id_le le_succ n m) ih
state_before: case intro.succ
α : Type u_1
inst✝² : Preorder α
inst✝¹ : SuccOrder α
inst✝ : IsSuccArchimedean α
a b : α
P : α → Prop
m : α
h0 : P m
h1 : ∀ (n : α), m ≤ n → P n → P (succ n)
n : ℕ
ih : P ((succ^[n]) m)
⊢ P (succ ((succ^[n]) m))
Theorem: skewAdjointMatricesLieSubalgebraEquiv_apply
File: Mathlib/Algebra/Lie/SkewAdjoint.lean

tactic: simp [skewAdjointMatricesLieSubalgebraEquiv]
state_before: R : Type u
n : Type w
inst✝² : CommRing R
inst✝¹ : DecidableEq n
inst✝ : Fintype n
J P : Matrix n n R
h : Invertible P
A : { x // x ∈ skewAdjointMatricesLieSubalgebra J }
⊢ ↑(↑(skewAdjointMatricesLieSubalgebraEquiv J P h) A) = P⁻¹ ⬝ ↑A ⬝ P
Theorem: fderivWithin_const_apply
File: Mathlib/Analysis/Calculus/FDeriv/Basic.lean

tactic: rw [DifferentiableAt.fderivWithin (differentiableAt_const _) hxs]
state_before: 𝕜 : Type u_1
inst✝⁸ : NontriviallyNormedField 𝕜
E : Type u_2
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type u_3
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type ?u.1390092
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
G' : Type ?u.1390187
inst✝¹ : NormedAddCommGroup G'
inst✝ : NormedSpace 𝕜 G'
f f₀ f₁ g : E → F
f' f₀' f₁' g' e : E →L[𝕜] F
x : E
s t : Set E
L L₁ L₂ : Filter E
c : F
hxs : UniqueDiffWithinAt 𝕜 s x
⊢ fderivWithin 𝕜 (fun x => c) s x = 0

tactic: exact fderiv_const_apply _
state_before: 𝕜 : Type u_1
inst✝⁸ : NontriviallyNormedField 𝕜
E : Type u_2
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type u_3
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type ?u.1390092
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
G' : Type ?u.1390187
inst✝¹ : NormedAddCommGroup G'
inst✝ : NormedSpace 𝕜 G'
f f₀ f₁ g : E → F
f' f₀' f₁' g' e : E →L[𝕜] F
x : E
s t : Set E
L L₁ L₂ : Filter E
c : F
hxs : UniqueDiffWithinAt 𝕜 s x
⊢ fderiv 𝕜 (fun x => c) x = 0
Theorem: Pmf.toMeasure_apply_inter_support
File: Mathlib/Probability/ProbabilityMassFunction/Basic.lean

tactic: simp [p.toMeasure_apply_eq_toOuterMeasure_apply s hs,
  p.toMeasure_apply_eq_toOuterMeasure_apply _ (hs.inter hp)]
state_before: α : Type u_1
β : Type ?u.84659
γ : Type ?u.84662
inst✝ : MeasurableSpace α
p : Pmf α
s t : Set α
hs : MeasurableSet s
hp : MeasurableSet (support p)
⊢ ↑↑(toMeasure p) (s ∩ support p) = ↑↑(toMeasure p) s
Theorem: MvPolynomial.coeff_mul_X'
File: Mathlib/Data/MvPolynomial/Basic.lean

tactic: refine' (coeff_mul_monomial' _ _ _ _).trans _
state_before: R : Type u
S₁ : Type v
S₂ : Type w
S₃ : Type x
σ : Type u_1
a a' a₁ a₂ : R
e : ℕ
n m✝ : σ
s✝ : σ →₀ ℕ
inst✝² : CommSemiring R
inst✝¹ : CommSemiring S₁
p✝ q : MvPolynomial σ R
inst✝ : DecidableEq σ
m : σ →₀ ℕ
s : σ
p : MvPolynomial σ R
⊢ coeff m (p * X s) = if s ∈ m.support then coeff (m - Finsupp.single s 1) p else 0

tactic: simp_rw [Finsupp.single_le_iff, Finsupp.mem_support_iff, Nat.succ_le_iff, pos_iff_ne_zero,
  mul_one]
state_before: R : Type u
S₁ : Type v
S₂ : Type w
S₃ : Type x
σ : Type u_1
a a' a₁ a₂ : R
e : ℕ
n m✝ : σ
s✝ : σ →₀ ℕ
inst✝² : CommSemiring R
inst✝¹ : CommSemiring S₁
p✝ q : MvPolynomial σ R
inst✝ : DecidableEq σ
m : σ →₀ ℕ
s : σ
p : MvPolynomial σ R
⊢ (if Finsupp.single s 1 ≤ m then coeff (m - Finsupp.single s 1) p * 1 else 0) =
    if s ∈ m.support then coeff (m - Finsupp.single s 1) p else 0
Theorem: Polynomial.Chebyshev.T_complex_cos
File: Mathlib/Analysis/SpecialFunctions/Trigonometric/Chebyshev.lean

tactic: simp only [T_zero, eval_one, Nat.cast_zero, MulZeroClass.zero_mul, cos_zero]
state_before: R : Type ?u.105956
A : Type ?u.105959
inst✝² : CommRing R
inst✝¹ : CommRing A
inst✝ : Algebra R A
θ : ℂ
⊢ eval (cos θ) (T ℂ 0) = cos (↑0 * θ)

tactic: simp only [eval_X, one_mul, T_one, Nat.cast_one]
state_before: R : Type ?u.105956
A : Type ?u.105959
inst✝² : CommRing R
inst✝¹ : CommRing A
inst✝ : Algebra R A
θ : ℂ
⊢ eval (cos θ) (T ℂ 1) = cos (↑1 * θ)

tactic: have : (2 : ℂ[X]) = (2 : ℕ) := by norm_num
state_before: R : Type ?u.105956
A : Type ?u.105959
inst✝² : CommRing R
inst✝¹ : CommRing A
inst✝ : Algebra R A
θ : ℂ
n : ℕ
⊢ eval (cos θ) (T ℂ (n + 2)) = cos (↑(n + 2) * θ)

tactic: simp only [this, eval_X, eval_one, T_add_two, eval_sub, eval_mul, eval_nat_cast]
state_before: R : Type ?u.105956
A : Type ?u.105959
inst✝² : CommRing R
inst✝¹ : CommRing A
inst✝ : Algebra R A
θ : ℂ
n : ℕ
this : 2 = ↑2
⊢ eval (cos θ) (T ℂ (n + 2)) = cos (↑(n + 2) * θ)

tactic: simp only [Nat.cast_ofNat, Nat.cast_add]
state_before: R : Type ?u.105956
A : Type ?u.105959
inst✝² : CommRing R
inst✝¹ : CommRing A
inst✝ : Algebra R A
θ : ℂ
n : ℕ
this : 2 = ↑2
⊢ ↑2 * cos θ * eval (cos θ) (T ℂ (n + 1)) - eval (cos θ) (T ℂ n) = cos (↑(n + 2) * θ)

tactic: rw [T_complex_cos (n + 1), T_complex_cos n]
state_before: R : Type ?u.105956
A : Type ?u.105959
inst✝² : CommRing R
inst✝¹ : CommRing A
inst✝ : Algebra R A
θ : ℂ
n : ℕ
this : 2 = ↑2
⊢ 2 * cos θ * eval (cos θ) (T ℂ (n + 1)) - eval (cos θ) (T ℂ n) = cos ((↑n + 2) * θ)

tactic: simp only [Nat.cast_add, Nat.cast_one, add_mul, cos_add, one_mul, mul_assoc, sin_two_mul,
  cos_two_mul]
state_before: R : Type ?u.105956
A : Type ?u.105959
inst✝² : CommRing R
inst✝¹ : CommRing A
inst✝ : Algebra R A
θ : ℂ
n : ℕ
this : 2 = ↑2
⊢ 2 * cos θ * cos (↑(n + 1) * θ) - cos (↑n * θ) = cos ((↑n + 2) * θ)

tactic: ring
state_before: R : Type ?u.105956
A : Type ?u.105959
inst✝² : CommRing R
inst✝¹ : CommRing A
inst✝ : Algebra R A
θ : ℂ
n : ℕ
this : 2 = ↑2
⊢ 2 * (cos θ * (cos (↑n * θ) * cos θ - sin (↑n * θ) * sin θ)) - cos (↑n * θ) =
    cos (↑n * θ) * (2 * cos θ ^ 2 - 1) - sin (↑n * θ) * (2 * (sin θ * cos θ))

tactic: norm_num
state_before: R : Type ?u.105956
A : Type ?u.105959
inst✝² : CommRing R
inst✝¹ : CommRing A
inst✝ : Algebra R A
θ : ℂ
n : ℕ
⊢ 2 = ↑2
Theorem: PrimeSpectrum.basicOpen_le_basicOpen_iff
File: Mathlib/AlgebraicGeometry/PrimeSpectrum/Basic.lean

tactic: rw [← SetLike.coe_subset_coe, basicOpen_eq_zeroLocus_compl, basicOpen_eq_zeroLocus_compl,
  Set.compl_subset_compl, zeroLocus_subset_zeroLocus_singleton_iff]
state_before: R : Type u
S : Type v
inst✝¹ : CommRing R
inst✝ : CommRing S
f g : R
⊢ basicOpen f ≤ basicOpen g ↔ f ∈ Ideal.radical (Ideal.span {g})
Theorem: LocalEquiv.EqOnSource.source_inter_preimage_eq
File: Mathlib/Logic/Equiv/LocalEquiv.lean

tactic: rw [he.eqOn.inter_preimage_eq, source_eq he]
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.57966
δ : Type ?u.57969
e✝ : LocalEquiv α β
e'✝ : LocalEquiv β γ
e e' : LocalEquiv α β
he : e ≈ e'
s : Set β
⊢ e.source ∩ ↑e ⁻¹' s = e'.source ∩ ↑e' ⁻¹' s
Theorem: iteratedDeriv_succ'
File: Mathlib/Analysis/Calculus/IteratedDeriv.lean

tactic: rw [iteratedDeriv_eq_iterate, iteratedDeriv_eq_iterate]
state_before: 𝕜 : Type u_1
inst✝⁴ : NontriviallyNormedField 𝕜
F : Type u_2
inst✝³ : NormedAddCommGroup F
inst✝² : NormedSpace 𝕜 F
E : Type ?u.162489
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace 𝕜 E
n : ℕ
f : 𝕜 → F
s : Set 𝕜
x : 𝕜
⊢ iteratedDeriv (n + 1) f = iteratedDeriv n (deriv f)

tactic: rfl
state_before: 𝕜 : Type u_1
inst✝⁴ : NontriviallyNormedField 𝕜
F : Type u_2
inst✝³ : NormedAddCommGroup F
inst✝² : NormedSpace 𝕜 F
E : Type ?u.162489
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace 𝕜 E
n : ℕ
f : 𝕜 → F
s : Set 𝕜
x : 𝕜
⊢ (deriv^[n + 1]) f = (deriv^[n]) (deriv f)
Theorem: RatFunc.taylor_mem_nonZeroDivisors
File: Mathlib/FieldTheory/Laurent.lean

tactic: rw [mem_nonZeroDivisors_iff]
state_before: R : Type u
inst✝ : CommRing R
hdomain : IsDomain R
r s : R
p q : R[X]
f : RatFunc R
hp : p ∈ R[X]⁰
⊢ ↑(taylor r) p ∈ R[X]⁰

tactic: intro x hx
state_before: R : Type u
inst✝ : CommRing R
hdomain : IsDomain R
r s : R
p q : R[X]
f : RatFunc R
hp : p ∈ R[X]⁰
⊢ ∀ (x : (fun x => R[X]) p), x * ↑(taylor r) p = 0 → x = 0

tactic: have : x = taylor (r - r) x := by simp
state_before: R : Type u
inst✝ : CommRing R
hdomain : IsDomain R
r s : R
p q : R[X]
f : RatFunc R
hp : p ∈ R[X]⁰
x : R[X]
hx : x * ↑(taylor r) p = 0
⊢ x = 0

tactic: rwa [this, sub_eq_add_neg, ← taylor_taylor, ← taylor_mul,
  LinearMap.map_eq_zero_iff _ (taylor_injective _), mul_right_mem_nonZeroDivisors_eq_zero_iff hp,
  LinearMap.map_eq_zero_iff _ (taylor_injective _)] at hx
state_before: R : Type u
inst✝ : CommRing R
hdomain : IsDomain R
r s : R
p q : R[X]
f : RatFunc R
hp : p ∈ R[X]⁰
x : R[X]
hx : x * ↑(taylor r) p = 0
this : x = ↑(taylor (r - r)) x
⊢ x = 0

tactic: simp
state_before: R : Type u
inst✝ : CommRing R
hdomain : IsDomain R
r s : R
p q : R[X]
f : RatFunc R
hp : p ∈ R[X]⁰
x : R[X]
hx : x * ↑(taylor r) p = 0
⊢ x = ↑(taylor (r - r)) x
Theorem: FirstOrder.Language.Theory.CompleteType.setOf_subset_eq_empty_iff
File: Mathlib/ModelTheory/Types.lean

tactic: rw [iff_not_comm, ← not_nonempty_iff_eq_empty, Classical.not_not, Set.Nonempty]
state_before: L : Language
T : Theory L
α : Type w
S : Theory (L[[α]])
⊢ {p | S ⊆ ↑p} = ∅ ↔ ¬IsSatisfiable (LHom.onTheory (lhomWithConstants L α) T ∪ S)

tactic: refine'
  ⟨fun h =>
    ⟨⟨L[[α]].completeTheory h.some, (subset_union_left _ S).trans completeTheory.subset,
        completeTheory.isMaximal (L[[α]]) h.some⟩,
      (subset_union_right ((L.lhomWithConstants α).onTheory T) _).trans completeTheory.subset⟩,
    _⟩
state_before: L : Language
T : Theory L
α : Type w
S : Theory (L[[α]])
⊢ IsSatisfiable (LHom.onTheory (lhomWithConstants L α) T ∪ S) ↔ ∃ x, x ∈ {p | S ⊆ ↑p}

tactic: rintro ⟨p, hp⟩
state_before: L : Language
T : Theory L
α : Type w
S : Theory (L[[α]])
⊢ (∃ x, x ∈ {p | S ⊆ ↑p}) → IsSatisfiable (LHom.onTheory (lhomWithConstants L α) T ∪ S)

tactic: exact p.isMaximal.1.mono (union_subset p.subset hp)
state_before: case intro
L : Language
T : Theory L
α : Type w
S : Theory (L[[α]])
p : CompleteType T α
hp : p ∈ {p | S ⊆ ↑p}
⊢ IsSatisfiable (LHom.onTheory (lhomWithConstants L α) T ∪ S)
Theorem: ENNReal.top_rpow_of_pos
File: Mathlib/Analysis/SpecialFunctions/Pow/NNReal.lean

tactic: simp [top_rpow_def, h]
state_before: y : ℝ
h : 0 < y
⊢ ⊤ ^ y = ⊤
Theorem: Function.Semiconj.injOn_range
File: Mathlib/Data/Set/Function.lean

tactic: rw [← image_univ] at *
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.112312
ι : Sort ?u.112315
π : α → Type ?u.112320
fa : α → α
fb : β → β
f : α → β
g : β → γ
s t : Set α
h : Semiconj f fa fb
ha : Injective fa
hf : InjOn f (range fa)
⊢ InjOn fb (range f)

tactic: exact h.injOn_image (ha.injOn univ) hf
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.112312
ι : Sort ?u.112315
π : α → Type ?u.112320
fa : α → α
fb : β → β
f : α → β
g : β → γ
s t : Set α
h : Semiconj f fa fb
ha : Injective fa
hf : InjOn f (fa '' univ)
⊢ InjOn fb (f '' univ)
Theorem: CategoryTheory.Limits.kernelSubobjectMap_id
File: Mathlib/CategoryTheory/Subobject/Limits.lean

tactic: aesop_cat
state_before: C : Type u
inst✝³ : Category C
X Y Z : C
inst✝² : HasZeroMorphisms C
f : X ⟶ Y
inst✝¹ : HasKernel f
X' Y' : C
f' : X' ⟶ Y'
inst✝ : HasKernel f'
⊢ kernelSubobjectMap (𝟙 (Arrow.mk f)) = 𝟙 (underlying.obj (kernelSubobject f))
Theorem: Set.not_bounded_iff
File: Mathlib/Order/RelClasses.lean

tactic: simp only [Bounded, Unbounded, not_forall, not_exists, exists_prop, not_and, not_not]
state_before: α : Type u
β : Type v
r✝ : α → α → Prop
s✝ : β → β → Prop
r : α → α → Prop
s : Set α
⊢ ¬Bounded r s ↔ Unbounded r s
Theorem: Real.Angle.sin_add
File: Mathlib/Analysis/SpecialFunctions/Trigonometric/Angle.lean

tactic: induction θ₁ using Real.Angle.induction_on
state_before: θ₁ θ₂ : Angle
⊢ sin (θ₁ + θ₂) = sin θ₁ * cos θ₂ + cos θ₁ * sin θ₂

tactic: induction θ₂ using Real.Angle.induction_on
state_before: case h
θ₂ : Angle
x✝ : ℝ
⊢ sin (↑x✝ + θ₂) = sin ↑x✝ * cos θ₂ + cos ↑x✝ * sin θ₂

tactic: exact Real.sin_add _ _
state_before: case h.h
x✝¹ x✝ : ℝ
⊢ sin (↑x✝¹ + ↑x✝) = sin ↑x✝¹ * cos ↑x✝ + cos ↑x✝¹ * sin ↑x✝
Theorem: Finset.image_subset_iff_subset_preimage
File: Mathlib/Data/Finset/Preimage.lean

tactic: simp only [subset_iff, mem_preimage]
state_before: α : Type u
β : Type v
ι : Sort w
γ : Type x
inst✝ : DecidableEq β
f : α → β
s : Finset α
t : Finset β
hf : InjOn f (f ⁻¹' ↑t)
⊢ (∀ (x : α), x ∈ s → f x ∈ t) ↔ s ⊆ preimage t f hf
Theorem: ZMod.inv_zero
File: Mathlib/Data/ZMod/Basic.lean

tactic: rw [val_zero]
state_before: n : ℕ
⊢ ↑(Nat.gcdA (val 0) (n + 1)) = 0

tactic: unfold Nat.gcdA Nat.xgcd Nat.xgcdAux
state_before: n : ℕ
⊢ ↑(Nat.gcdA 0 (n + 1)) = 0

tactic: rfl
state_before: n : ℕ
⊢ ↑(n + 1, 0, 1).snd.fst = 0
Theorem: LinearOrderedField.cutMap_bddAbove
File: Mathlib/Algebra/Order/CompleteField.lean

tactic: obtain ⟨q, hq⟩ := exists_rat_gt a
state_before: F : Type ?u.11263
α : Type u_2
β : Type u_1
γ : Type ?u.11272
inst✝² : LinearOrderedField α
inst✝¹ : LinearOrderedField β
a✝ a₁ a₂ : α
b : β
q : ℚ
inst✝ : Archimedean α
a : α
⊢ BddAbove (cutMap β a)

tactic: exact ⟨q, ball_image_iff.2 fun r hr => by exact_mod_cast (hq.trans' hr).le⟩
state_before: case intro
F : Type ?u.11263
α : Type u_2
β : Type u_1
γ : Type ?u.11272
inst✝² : LinearOrderedField α
inst✝¹ : LinearOrderedField β
a✝ a₁ a₂ : α
b : β
q✝ : ℚ
inst✝ : Archimedean α
a : α
q : ℚ
hq : a < ↑q
⊢ BddAbove (cutMap β a)

tactic: exact_mod_cast (hq.trans' hr).le
state_before: F : Type ?u.11263
α : Type u_2
β : Type u_1
γ : Type ?u.11272
inst✝² : LinearOrderedField α
inst✝¹ : LinearOrderedField β
a✝ a₁ a₂ : α
b : β
q✝ : ℚ
inst✝ : Archimedean α
a : α
q : ℚ
hq : a < ↑q
r : ℚ
hr : r ∈ {t | ↑t < a}
⊢ ↑r ≤ ↑q
Theorem: Polynomial.comp_assoc
File: Mathlib/Data/Polynomial/Eval.lean

tactic: intros
state_before: case refine_3
R✝ : Type u
S : Type v
T : Type w
ι : Type y
a b : R✝
m n : ℕ
inst✝¹ : Semiring R✝
p q r : R✝[X]
R : Type u_1
inst✝ : CommSemiring R
φ ψ χ : R[X]
⊢ ∀ (n : ℕ) (a : R),
    comp (comp (↑C a * X ^ n) ψ) χ = comp (↑C a * X ^ n) (comp ψ χ) →
      comp (comp (↑C a * X ^ (n + 1)) ψ) χ = comp (↑C a * X ^ (n + 1)) (comp ψ χ)

tactic: simp_all only [add_comp, mul_comp, C_comp, X_comp, pow_succ', ← mul_assoc]
state_before: case refine_3
R✝ : Type u
S : Type v
T : Type w
ι : Type y
a b : R✝
m n : ℕ
inst✝¹ : Semiring R✝
p q r : R✝[X]
R : Type u_1
inst✝ : CommSemiring R
φ ψ χ : R[X]
n✝ : ℕ
a✝¹ : R
a✝ : comp (comp (↑C a✝¹ * X ^ n✝) ψ) χ = comp (↑C a✝¹ * X ^ n✝) (comp ψ χ)
⊢ comp (comp (↑C a✝¹ * X ^ (n✝ + 1)) ψ) χ = comp (↑C a✝¹ * X ^ (n✝ + 1)) (comp ψ χ)
Theorem: Function.Bijective.cauchySeq_comp_iff
File: Mathlib/Topology/UniformSpace/Cauchy.lean

tactic: refine' ⟨fun H => _, fun H => H.comp_injective hf.injective⟩
state_before: α : Type u
β : Type v
inst✝ : UniformSpace α
f : ℕ → ℕ
hf : Bijective f
u : ℕ → α
⊢ CauchySeq (u ∘ f) ↔ CauchySeq u

tactic: lift f to ℕ ≃ ℕ using hf
state_before: α : Type u
β : Type v
inst✝ : UniformSpace α
f : ℕ → ℕ
hf : Bijective f
u : ℕ → α
H : CauchySeq (u ∘ f)
⊢ CauchySeq u
Theorem: ExceptT.ext
File: src/lean/Init/Control/Lawful.lean

tactic: simp [run] at h
state_before: m : Type u_1 → Type u_2
ε α : Type u_1
inst✝ : Monad m
x y : ExceptT ε m α
h : run x = run y
⊢ x = y

tactic: assumption
state_before: m : Type u_1 → Type u_2
ε α : Type u_1
inst✝ : Monad m
x y : ExceptT ε m α
h : x = y
⊢ x = y
Theorem: Quaternion.norm_exp
File: Mathlib/Analysis/NormedSpace/QuaternionExponential.lean

tactic: rw [norm_eq_sqrt_real_inner (exp ℝ q), inner_self, normSq_exp, Real.sqrt_sq_eq_abs,
  Real.norm_eq_abs]
state_before: q : ℍ
⊢ ‖exp ℝ q‖ = ‖exp ℝ q.re‖
Theorem: LocalEquiv.refl_trans
File: Mathlib/Logic/Equiv/LocalEquiv.lean

tactic: simp [trans_source, preimage_id]
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.47735
δ : Type ?u.47738
e : LocalEquiv α β
e' : LocalEquiv β γ
⊢ (LocalEquiv.trans (LocalEquiv.refl α) e).source = e.source
Theorem: MonoidHom.toFreimanHom_injective
File: Mathlib/Algebra/Hom/Freiman.lean

tactic: rwa [toFreimanHom, toFreimanHom, FreimanHom.mk.injEq, FunLike.coe_fn_eq] at h
state_before: F : Type ?u.80415
α : Type u_1
β : Type u_2
γ : Type ?u.80424
δ : Type ?u.80427
G : Type ?u.80430
inst✝⁵ : FunLike F α fun x => β
inst✝⁴ : CommMonoid α
inst✝³ : CommMonoid β
inst✝² : CommMonoid γ
inst✝¹ : CommMonoid δ
inst✝ : CommGroup G
A : Set α
B : Set β
C : Set γ
n : ℕ
a b c d : α
f g : α →* β
h : toFreimanHom A n f = toFreimanHom A n g
⊢ f = g