tasksource/leandojo huggingface dataset:
Theorem: derangements.Equiv.RemoveNone.fiber_none
File: Mathlib/Combinatorics/Derangements/Basic.lean

tactic: rw [Set.eq_empty_iff_forall_not_mem]
state_before: α : Type u_1
β : Type ?u.80928
inst✝ : DecidableEq α
⊢ fiber none = ∅

tactic: intro f hyp
state_before: α : Type u_1
β : Type ?u.80928
inst✝ : DecidableEq α
⊢ ∀ (x : Perm α), ¬x ∈ fiber none

tactic: rw [RemoveNone.mem_fiber] at hyp
state_before: α : Type u_1
β : Type ?u.80928
inst✝ : DecidableEq α
f : Perm α
hyp : f ∈ fiber none
⊢ False

tactic: rcases hyp with ⟨F, F_derangement, F_none, _⟩
state_before: α : Type u_1
β : Type ?u.80928
inst✝ : DecidableEq α
f : Perm α
hyp : ∃ F, F ∈ derangements (Option α) ∧ ↑F none = none ∧ removeNone F = f
⊢ False

tactic: exact F_derangement none F_none
state_before: case intro.intro.intro
α : Type u_1
β : Type ?u.80928
inst✝ : DecidableEq α
f : Perm α
F : Perm (Option α)
F_derangement : F ∈ derangements (Option α)
F_none : ↑F none = none
right✝ : removeNone F = f
⊢ False
Theorem: Polynomial.card_support_binomial
File: Mathlib/Data/Polynomial/Coeff.lean

tactic: rw [support_binomial h hx hy, card_insert_of_not_mem (mt mem_singleton.mp h), card_singleton]
state_before: R : Type u
S : Type v
a b : R
n m✝ : ℕ
inst✝ : Semiring R
p q r : R[X]
k m : ℕ
h : k ≠ m
x y : R
hx : x ≠ 0
hy : y ≠ 0
⊢ card (support (↑C x * X ^ k + ↑C y * X ^ m)) = 2
Theorem: MeasureTheory.Integrable.ae_eq_of_forall_set_integral_eq
File: Mathlib/MeasureTheory/Function/AEEqOfIntegral.lean

tactic: rw [← sub_ae_eq_zero]
state_before: α : Type u_2
E : Type u_1
m m0 : MeasurableSpace α
μ : Measure α
s t : Set α
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℝ E
inst✝ : CompleteSpace E
p : ℝ≥0∞
f g : α → E
hf : Integrable f
hg : Integrable g
hfg : ∀ (s : Set α), MeasurableSet s → ↑↑μ s < ⊤ → (∫ (x : α) in s, f x ∂μ) = ∫ (x : α) in s, g x ∂μ
⊢ f =ᵐ[μ] g

tactic: have hfg' : ∀ s : Set α, MeasurableSet s → μ s < ∞ → (∫ x in s, (f - g) x ∂μ) = 0 := by
  intro s hs hμs
  rw [integral_sub' hf.integrableOn hg.integrableOn]
  exact sub_eq_zero.mpr (hfg s hs hμs)
state_before: α : Type u_2
E : Type u_1
m m0 : MeasurableSpace α
μ : Measure α
s t : Set α
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℝ E
inst✝ : CompleteSpace E
p : ℝ≥0∞
f g : α → E
hf : Integrable f
hg : Integrable g
hfg : ∀ (s : Set α), MeasurableSet s → ↑↑μ s < ⊤ → (∫ (x : α) in s, f x ∂μ) = ∫ (x : α) in s, g x ∂μ
⊢ f - g =ᵐ[μ] 0

tactic: exact Integrable.ae_eq_zero_of_forall_set_integral_eq_zero (hf.sub hg) hfg'
state_before: α : Type u_2
E : Type u_1
m m0 : MeasurableSpace α
μ : Measure α
s t : Set α
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℝ E
inst✝ : CompleteSpace E
p : ℝ≥0∞
f g : α → E
hf : Integrable f
hg : Integrable g
hfg : ∀ (s : Set α), MeasurableSet s → ↑↑μ s < ⊤ → (∫ (x : α) in s, f x ∂μ) = ∫ (x : α) in s, g x ∂μ
hfg' : ∀ (s : Set α), MeasurableSet s → ↑↑μ s < ⊤ → (∫ (x : α) in s, (f - g) x ∂μ) = 0
⊢ f - g =ᵐ[μ] 0

tactic: intro s hs hμs
state_before: α : Type u_2
E : Type u_1
m m0 : MeasurableSpace α
μ : Measure α
s t : Set α
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℝ E
inst✝ : CompleteSpace E
p : ℝ≥0∞
f g : α → E
hf : Integrable f
hg : Integrable g
hfg : ∀ (s : Set α), MeasurableSet s → ↑↑μ s < ⊤ → (∫ (x : α) in s, f x ∂μ) = ∫ (x : α) in s, g x ∂μ
⊢ ∀ (s : Set α), MeasurableSet s → ↑↑μ s < ⊤ → (∫ (x : α) in s, (f - g) x ∂μ) = 0

tactic: rw [integral_sub' hf.integrableOn hg.integrableOn]
state_before: α : Type u_2
E : Type u_1
m m0 : MeasurableSpace α
μ : Measure α
s✝ t : Set α
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℝ E
inst✝ : CompleteSpace E
p : ℝ≥0∞
f g : α → E
hf : Integrable f
hg : Integrable g
hfg : ∀ (s : Set α), MeasurableSet s → ↑↑μ s < ⊤ → (∫ (x : α) in s, f x ∂μ) = ∫ (x : α) in s, g x ∂μ
s : Set α
hs : MeasurableSet s
hμs : ↑↑μ s < ⊤
⊢ (∫ (x : α) in s, (f - g) x ∂μ) = 0

tactic: exact sub_eq_zero.mpr (hfg s hs hμs)
state_before: α : Type u_2
E : Type u_1
m m0 : MeasurableSpace α
μ : Measure α
s✝ t : Set α
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℝ E
inst✝ : CompleteSpace E
p : ℝ≥0∞
f g : α → E
hf : Integrable f
hg : Integrable g
hfg : ∀ (s : Set α), MeasurableSet s → ↑↑μ s < ⊤ → (∫ (x : α) in s, f x ∂μ) = ∫ (x : α) in s, g x ∂μ
s : Set α
hs : MeasurableSet s
hμs : ↑↑μ s < ⊤
⊢ ((∫ (a : α) in s, f a ∂μ) - ∫ (a : α) in s, g a ∂μ) = 0
Theorem: map_iSup₂
File: Mathlib/Order/Hom/CompleteLattice.lean

tactic: simp_rw [map_iSup]
state_before: F : Type u_3
α : Type u_1
β : Type u_2
γ : Type ?u.5694
δ : Type ?u.5697
ι : Sort u_4
κ : ι → Sort u_5
inst✝² : SupSet α
inst✝¹ : SupSet β
inst✝ : sSupHomClass F α β
f : F
g : (i : ι) → κ i → α
⊢ ↑f (⨆ (i : ι) (j : κ i), g i j) = ⨆ (i : ι) (j : κ i), ↑f (g i j)
Theorem: PartENat.add_lt_add_iff_left
File: Mathlib/Data/Nat/PartENat.lean

tactic: rw [add_comm z, add_comm z, PartENat.add_lt_add_iff_right hz]
state_before: x y z : PartENat
hz : z ≠ ⊤
⊢ z + x < z + y ↔ x < y
Theorem: MeasureTheory.integrableOn_Ioi_deriv_of_nonneg'
File: Mathlib/MeasureTheory/Integral/IntegralEqImproper.lean

tactic: refine integrableOn_Ioi_deriv_of_nonneg (fun x hx ↦ ?_) (fun x hx => hderiv x hx.out.le) g'pos hg
state_before: E : Type ?u.158221
f f' : ℝ → E
g g' : ℝ → ℝ
a b l : ℝ
m : E
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℝ E
inst✝ : CompleteSpace E
hderiv : ∀ (x : ℝ), x ∈ Ici a → HasDerivAt g (g' x) x
g'pos : ∀ (x : ℝ), x ∈ Ioi a → 0 ≤ g' x
hg : Tendsto g atTop (𝓝 l)
⊢ IntegrableOn g' (Ioi a)

tactic: exact (hderiv x hx).continuousAt.continuousWithinAt
state_before: E : Type ?u.158221
f f' : ℝ → E
g g' : ℝ → ℝ
a b l : ℝ
m : E
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℝ E
inst✝ : CompleteSpace E
hderiv : ∀ (x : ℝ), x ∈ Ici a → HasDerivAt g (g' x) x
g'pos : ∀ (x : ℝ), x ∈ Ioi a → 0 ≤ g' x
hg : Tendsto g atTop (𝓝 l)
x : ℝ
hx : x ∈ Ici a
⊢ ContinuousWithinAt g (Ici a) x
Theorem: CategoryTheory.Limits.kernelSubobject_arrow
File: Mathlib/CategoryTheory/Subobject/Limits.lean

tactic: simp [kernelSubobjectIso]
state_before: C : Type u
inst✝² : Category C
X Y Z : C
inst✝¹ : HasZeroMorphisms C
f : X ⟶ Y
inst✝ : HasKernel f
⊢ (kernelSubobjectIso f).hom ≫ kernel.ι f = arrow (kernelSubobject f)
Theorem: Fintype.prod_fiberwise
File: Mathlib/Data/Fintype/BigOperators.lean

tactic: rw [← (Equiv.sigmaFiberEquiv f).prod_comp, ← univ_sigma_univ, prod_sigma]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
inst✝³ : Fintype α
inst✝² : DecidableEq β
inst✝¹ : Fintype β
inst✝ : CommMonoid γ
f : α → β
g : α → γ
⊢ ∏ b : β, ∏ a : { a // f a = b }, g ↑a = ∏ a : α, g a

tactic: rfl
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
inst✝³ : Fintype α
inst✝² : DecidableEq β
inst✝¹ : Fintype β
inst✝ : CommMonoid γ
f : α → β
g : α → γ
⊢ ∏ b : β, ∏ a : { a // f a = b }, g ↑a =
    ∏ a : β, ∏ s : { x // f x = a }, g (↑(Equiv.sigmaFiberEquiv f) { fst := a, snd := s })
Theorem: List.pairwise_append_comm
File: Mathlib/Data/List/Pairwise.lean

tactic: have : ∀ l₁ l₂ : List α, (∀ x : α, x ∈ l₁ → ∀ y : α, y ∈ l₂ → R x y) →
  ∀ x : α, x ∈ l₂ → ∀ y : α, y ∈ l₁ → R x y := fun l₁ l₂ a x xm y ym ↦ s (a y ym x xm)
state_before: α : Type u_1
β : Type ?u.9493
R S T : α → α → Prop
a : α
l : List α
s : Symmetric R
l₁ l₂ : List α
⊢ Pairwise R (l₁ ++ l₂) ↔ Pairwise R (l₂ ++ l₁)

tactic: simp only [pairwise_append, and_left_comm]
state_before: α : Type u_1
β : Type ?u.9493
R S T : α → α → Prop
a : α
l : List α
s : Symmetric R
l₁ l₂ : List α
this :
  ∀ (l₁ l₂ : List α), (∀ (x : α), x ∈ l₁ → ∀ (y : α), y ∈ l₂ → R x y) → ∀ (x : α), x ∈ l₂ → ∀ (y : α), y ∈ l₁ → R x y
⊢ Pairwise R (l₁ ++ l₂) ↔ Pairwise R (l₂ ++ l₁)

tactic: rw [Iff.intro (this l₁ l₂) (this l₂ l₁)]
state_before: α : Type u_1
β : Type ?u.9493
R S T : α → α → Prop
a : α
l : List α
s : Symmetric R
l₁ l₂ : List α
this :
  ∀ (l₁ l₂ : List α), (∀ (x : α), x ∈ l₁ → ∀ (y : α), y ∈ l₂ → R x y) → ∀ (x : α), x ∈ l₂ → ∀ (y : α), y ∈ l₁ → R x y
⊢ (Pairwise R l₁ ∧ Pairwise R l₂ ∧ ∀ (a : α), a ∈ l₁ → ∀ (b : α), b ∈ l₂ → R a b) ↔
    Pairwise R l₁ ∧ Pairwise R l₂ ∧ ∀ (a : α), a ∈ l₂ → ∀ (b : α), b ∈ l₁ → R a b
Theorem: FreeMagma.toFreeSemigroup_comp_map
File: Mathlib/Algebra/Free.lean

tactic: ext1
state_before: α : Type u
β : Type v
f : α → β
⊢ MulHom.comp toFreeSemigroup (map f) = MulHom.comp (FreeSemigroup.map f) toFreeSemigroup

tactic: rfl
state_before: case h
α : Type u
β : Type v
f : α → β
⊢ ↑(MulHom.comp toFreeSemigroup (map f)) ∘ of = ↑(MulHom.comp (FreeSemigroup.map f) toFreeSemigroup) ∘ of
Theorem: MeasureTheory.Measure.InnerRegular.trans
File: Mathlib/MeasureTheory/Measure/Regular.lean

tactic: intro U hU r hr
state_before: α : Type u_1
m : MeasurableSpace α
μ : Measure α
p q : Set α → Prop
U : Set α
ε : ℝ≥0∞
q' : Set α → Prop
H : InnerRegular μ p q
H' : InnerRegular μ q q'
⊢ InnerRegular μ p q'

tactic: rcases H' hU r hr with ⟨F, hFU, hqF, hF⟩
state_before: α : Type u_1
m : MeasurableSpace α
μ : Measure α
p q : Set α → Prop
U✝ : Set α
ε : ℝ≥0∞
q' : Set α → Prop
H : InnerRegular μ p q
H' : InnerRegular μ q q'
U : Set α
hU : q' U
r : ℝ≥0∞
hr : r < ↑↑μ U
⊢ ∃ K, K ⊆ U ∧ p K ∧ r < ↑↑μ K

tactic: rcases H hqF _ hF with ⟨K, hKF, hpK, hrK⟩
state_before: case intro.intro.intro
α : Type u_1
m : MeasurableSpace α
μ : Measure α
p q : Set α → Prop
U✝ : Set α
ε : ℝ≥0∞
q' : Set α → Prop
H : InnerRegular μ p q
H' : InnerRegular μ q q'
U : Set α
hU : q' U
r : ℝ≥0∞
hr : r < ↑↑μ U
F : Set α
hFU : F ⊆ U
hqF : q F
hF : r < ↑↑μ F
⊢ ∃ K, K ⊆ U ∧ p K ∧ r < ↑↑μ K

tactic: exact ⟨K, hKF.trans hFU, hpK, hrK⟩
state_before: case intro.intro.intro.intro.intro.intro
α : Type u_1
m : MeasurableSpace α
μ : Measure α
p q : Set α → Prop
U✝ : Set α
ε : ℝ≥0∞
q' : Set α → Prop
H : InnerRegular μ p q
H' : InnerRegular μ q q'
U : Set α
hU : q' U
r : ℝ≥0∞
hr : r < ↑↑μ U
F : Set α
hFU : F ⊆ U
hqF : q F
hF : r < ↑↑μ F
K : Set α
hKF : K ⊆ F
hpK : p K
hrK : r < ↑↑μ K
⊢ ∃ K, K ⊆ U ∧ p K ∧ r < ↑↑μ K
Theorem: Option.map_uncurry
File: Mathlib/Data/Option/NAry.lean

tactic: cases x <;> rfl
state_before: α : Type u_2
β : Type u_1
γ : Type u_3
f✝ : α → β → γ
a : Option α
b : Option β
c : Option γ
f : α → β → γ
x : Option (α × β)
⊢ Option.map (uncurry f) x = map₂ f (Option.map Prod.fst x) (Option.map Prod.snd x)
Theorem: List.get?_concat_length
File: Std/Data/List/Lemmas.lean

tactic: rw [cons_append, length_cons]
state_before: α : Type u_1
b : α
l : List α
a : α
⊢ get? (b :: l ++ [a]) (length (b :: l)) = some a

tactic: simp only [get?, get?_concat_length]
state_before: α : Type u_1
b : α
l : List α
a : α
⊢ get? (b :: (l ++ [a])) (succ (length l)) = some a
Theorem: List.length_append
File: src/lean/Init/Data/List/Basic.lean

tactic: induction as with
| nil => simp
| cons _ as ih => simp [ih, Nat.succ_add]
state_before: α : Type u
β : Type v
γ : Type w
as bs : List α
⊢ length (as ++ bs) = length as + length bs

tactic: simp
state_before: case nil
α : Type u
β : Type v
γ : Type w
bs : List α
⊢ length (nil ++ bs) = length nil + length bs

tactic: simp [ih, Nat.succ_add]
state_before: case cons
α : Type u
β : Type v
γ : Type w
bs : List α
head✝ : α
as : List α
ih : length (as ++ bs) = length as + length bs
⊢ length (head✝ :: as ++ bs) = length (head✝ :: as) + length bs
Theorem: RelIso.symm_apply_rel
File: Mathlib/Order/RelIso/Basic.lean

tactic: rw [← e.map_rel_iff, e.apply_symm_apply]
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.83181
δ : Type ?u.83184
r : α → α → Prop
s : β → β → Prop
t : γ → γ → Prop
u : δ → δ → Prop
e : r ≃r s
x : β
y : α
⊢ r (↑(RelIso.symm e) x) y ↔ s x (↑e y)
Theorem: Bool.xor_true
File: Mathlib/Init/Data/Bool/Lemmas.lean

tactic: cases b <;> simp
state_before: b : Bool
⊢ xor b true = !b
Theorem: Behrend.addSalemSpencer_image_sphere
File: Mathlib/Combinatorics/Additive/Behrend.lean

tactic: rw [coe_image]
state_before: α : Type ?u.461418
β : Type ?u.461421
n d k N : ℕ
x : Fin n → ℕ
⊢ AddSalemSpencer ↑(image (↑(map (2 * d - 1))) (sphere n d k))

tactic: refine' @AddSalemSpencer.image _ (Fin n → ℕ) ℕ _ _ (sphere n d k) _ (map (2 * d - 1))
  (map_injOn.mono _) addSalemSpencer_sphere
state_before: α : Type ?u.461418
β : Type ?u.461421
n d k N : ℕ
x : Fin n → ℕ
⊢ AddSalemSpencer (↑(map (2 * d - 1)) '' ↑(sphere n d k))

tactic: rw [Set.add_subset_iff]
state_before: case refine'_2
α : Type ?u.461418
β : Type ?u.461421
n d k N : ℕ
x : Fin n → ℕ
⊢ ↑(sphere n d k) + ↑(sphere n d k) ⊆ {x | ∀ (i : Fin n), x i < 2 * d - 1}

tactic: rintro a ha b hb i
state_before: case refine'_2
α : Type ?u.461418
β : Type ?u.461421
n d k N : ℕ
x : Fin n → ℕ
⊢ ∀ (x : Fin n → ℕ),
    x ∈ ↑(sphere n d k) → ∀ (y : Fin n → ℕ), y ∈ ↑(sphere n d k) → x + y ∈ {x | ∀ (i : Fin n), x i < 2 * d - 1}

tactic: have hai := mem_box.1 (sphere_subset_box ha) i
state_before: case refine'_2
α : Type ?u.461418
β : Type ?u.461421
n d k N : ℕ
x a : Fin n → ℕ
ha : a ∈ ↑(sphere n d k)
b : Fin n → ℕ
hb : b ∈ ↑(sphere n d k)
i : Fin n
⊢ (a + b) i < 2 * d - 1

tactic: have hbi := mem_box.1 (sphere_subset_box hb) i
state_before: case refine'_2
α : Type ?u.461418
β : Type ?u.461421
n d k N : ℕ
x a : Fin n → ℕ
ha : a ∈ ↑(sphere n d k)
b : Fin n → ℕ
hb : b ∈ ↑(sphere n d k)
i : Fin n
hai : a i < d
⊢ (a + b) i < 2 * d - 1

tactic: rw [lt_tsub_iff_right, ← succ_le_iff, two_mul]
state_before: case refine'_2
α : Type ?u.461418
β : Type ?u.461421
n d k N : ℕ
x a : Fin n → ℕ
ha : a ∈ ↑(sphere n d k)
b : Fin n → ℕ
hb : b ∈ ↑(sphere n d k)
i : Fin n
hai : a i < d
hbi : b i < d
⊢ (a + b) i < 2 * d - 1

tactic: exact (add_add_add_comm _ _ 1 1).trans_le (_root_.add_le_add hai hbi)
state_before: case refine'_2
α : Type ?u.461418
β : Type ?u.461421
n d k N : ℕ
x a : Fin n → ℕ
ha : a ∈ ↑(sphere n d k)
b : Fin n → ℕ
hb : b ∈ ↑(sphere n d k)
i : Fin n
hai : a i < d
hbi : b i < d
⊢ succ ((a + b) i + 1) ≤ d + d

tactic: exact x
state_before: case refine'_1
α : Type ?u.461418
β : Type ?u.461421
n d k N : ℕ
x : Fin n → ℕ
⊢ Fin n → ℕ
Theorem: Nat.ArithmeticFunction.LSeriesSummable_iff_of_re_eq_re
File: Mathlib/NumberTheory/LSeries.lean

tactic: suffices h :
  ∀ n : ℕ, Complex.abs (f n) / Complex.abs (↑n ^ w) = Complex.abs (f n) / Complex.abs (↑n ^ z)
state_before: f : ArithmeticFunction ℂ
w z : ℂ
h : w.re = z.re
⊢ LSeriesSummable f w ↔ LSeriesSummable f z

tactic: intro n
state_before: case h
f : ArithmeticFunction ℂ
w z : ℂ
h : w.re = z.re
⊢ ∀ (n : ℕ), ↑Complex.abs (↑f n) / ↑Complex.abs (↑n ^ w) = ↑Complex.abs (↑f n) / ↑Complex.abs (↑n ^ z)

tactic: cases' n with n
state_before: case h
f : ArithmeticFunction ℂ
w z : ℂ
h : w.re = z.re
n : ℕ
⊢ ↑Complex.abs (↑f n) / ↑Complex.abs (↑n ^ w) = ↑Complex.abs (↑f n) / ↑Complex.abs (↑n ^ z)

tactic: apply congr rfl
state_before: case h.succ
f : ArithmeticFunction ℂ
w z : ℂ
h : w.re = z.re
n : ℕ
⊢ ↑Complex.abs (↑f (succ n)) / ↑Complex.abs (↑(succ n) ^ w) = ↑Complex.abs (↑f (succ n)) / ↑Complex.abs (↑(succ n) ^ z)

tactic: have h0 : (n.succ : ℂ) ≠ 0 := by
  rw [Ne.def, Nat.cast_eq_zero]
  apply n.succ_ne_zero
state_before: case h.succ
f : ArithmeticFunction ℂ
w z : ℂ
h : w.re = z.re
n : ℕ
⊢ ↑Complex.abs (↑(succ n) ^ w) = ↑Complex.abs (↑(succ n) ^ z)

tactic: rw [Complex.cpow_def, Complex.cpow_def, if_neg h0, if_neg h0, Complex.abs_exp_eq_iff_re_eq]
state_before: case h.succ
f : ArithmeticFunction ℂ
w z : ℂ
h : w.re = z.re
n : ℕ
h0 : ↑(succ n) ≠ 0
⊢ ↑Complex.abs (↑(succ n) ^ w) = ↑Complex.abs (↑(succ n) ^ z)

tactic: simp only [h, Complex.mul_re, mul_eq_mul_left_iff, sub_right_inj]
state_before: case h.succ
f : ArithmeticFunction ℂ
w z : ℂ
h : w.re = z.re
n : ℕ
h0 : ↑(succ n) ≠ 0
⊢ (Complex.log ↑(succ n) * w).re = (Complex.log ↑(succ n) * z).re

tactic: right
state_before: case h.succ
f : ArithmeticFunction ℂ
w z : ℂ
h : w.re = z.re
n : ℕ
h0 : ↑(succ n) ≠ 0
⊢ w.im = z.im ∨ (Complex.log ↑(succ n)).im = 0

tactic: rw [Complex.log_im, ← Complex.ofReal_nat_cast]
state_before: case h.succ.h
f : ArithmeticFunction ℂ
w z : ℂ
h : w.re = z.re
n : ℕ
h0 : ↑(succ n) ≠ 0
⊢ (Complex.log ↑(succ n)).im = 0

tactic: exact Complex.arg_ofReal_of_nonneg (le_of_lt (cast_pos.2 n.succ_pos))
state_before: case h.succ.h
f : ArithmeticFunction ℂ
w z : ℂ
h : w.re = z.re
n : ℕ
h0 : ↑(succ n) ≠ 0
⊢ Complex.arg ↑↑(succ n) = 0

tactic: simp [LSeriesSummable, ← summable_norm_iff, h, Complex.norm_eq_abs]
state_before: f : ArithmeticFunction ℂ
w z : ℂ
h✝ : w.re = z.re
h : ∀ (n : ℕ), ↑Complex.abs (↑f n) / ↑Complex.abs (↑n ^ w) = ↑Complex.abs (↑f n) / ↑Complex.abs (↑n ^ z)
⊢ LSeriesSummable f w ↔ LSeriesSummable f z

tactic: simp
state_before: case h.zero
f : ArithmeticFunction ℂ
w z : ℂ
h : w.re = z.re
⊢ ↑Complex.abs (↑f Nat.zero) / ↑Complex.abs (↑Nat.zero ^ w) = ↑Complex.abs (↑f Nat.zero) / ↑Complex.abs (↑Nat.zero ^ z)

tactic: rw [Ne.def, Nat.cast_eq_zero]
state_before: f : ArithmeticFunction ℂ
w z : ℂ
h : w.re = z.re
n : ℕ
⊢ ↑(succ n) ≠ 0

tactic: apply n.succ_ne_zero
state_before: f : ArithmeticFunction ℂ
w z : ℂ
h : w.re = z.re
n : ℕ
⊢ ¬succ n = 0
Theorem: LatticeHom.cancel_left
File: Mathlib/Order/Hom/Lattice.lean

tactic: rw [← LatticeHom.comp_apply, h, LatticeHom.comp_apply]
state_before: F : Type ?u.147149
ι : Type ?u.147152
α : Type u_3
β : Type u_1
γ : Type u_2
δ : Type ?u.147164
inst✝³ : Lattice α
inst✝² : Lattice β
inst✝¹ : Lattice γ
inst✝ : Lattice δ
g : LatticeHom β γ
f₁ f₂ : LatticeHom α β
hg : Injective ↑g
h : comp g f₁ = comp g f₂
a : α
⊢ ↑g (↑f₁ a) = ↑g (↑f₂ a)
Theorem: abs_sub_round
File: Mathlib/Algebra/Order/Floor.lean

tactic: rw [round_eq, abs_sub_le_iff]
state_before: F : Type ?u.283221
α : Type u_1
β : Type ?u.283227
inst✝¹ : LinearOrderedField α
inst✝ : FloorRing α
x : α
⊢ abs (x - ↑(round x)) ≤ 1 / 2

tactic: have := floor_le (x + 1 / 2)
state_before: F : Type ?u.283221
α : Type u_1
β : Type ?u.283227
inst✝¹ : LinearOrderedField α
inst✝ : FloorRing α
x : α
⊢ x - ↑⌊x + 1 / 2⌋ ≤ 1 / 2 ∧ ↑⌊x + 1 / 2⌋ - x ≤ 1 / 2

tactic: have := lt_floor_add_one (x + 1 / 2)
state_before: F : Type ?u.283221
α : Type u_1
β : Type ?u.283227
inst✝¹ : LinearOrderedField α
inst✝ : FloorRing α
x : α
this : ↑⌊x + 1 / 2⌋ ≤ x + 1 / 2
⊢ x - ↑⌊x + 1 / 2⌋ ≤ 1 / 2 ∧ ↑⌊x + 1 / 2⌋ - x ≤ 1 / 2

tactic: constructor <;> linarith
state_before: F : Type ?u.283221
α : Type u_1
β : Type ?u.283227
inst✝¹ : LinearOrderedField α
inst✝ : FloorRing α
x : α
this✝ : ↑⌊x + 1 / 2⌋ ≤ x + 1 / 2
this : x + 1 / 2 < ↑⌊x + 1 / 2⌋ + 1
⊢ x - ↑⌊x + 1 / 2⌋ ≤ 1 / 2 ∧ ↑⌊x + 1 / 2⌋ - x ≤ 1 / 2
Theorem: Complex.contDiff_exp
File: Mathlib/Analysis/SpecialFunctions/ExpDeriv.lean

tactic: refine' @(contDiff_all_iff_nat.2 fun n => ?_)
state_before: 𝕜 : Type u_1
inst✝¹ : NontriviallyNormedField 𝕜
inst✝ : NormedAlgebra 𝕜 ℂ
⊢ ∀ {n : ℕ∞}, ContDiff 𝕜 n exp

tactic: exact this.restrict_scalars 𝕜
state_before: 𝕜 : Type u_1
inst✝¹ : NontriviallyNormedField 𝕜
inst✝ : NormedAlgebra 𝕜 ℂ
n : ℕ
this : ContDiff ℂ (↑n) exp
⊢ ContDiff 𝕜 (↑n) exp

tactic: induction' n with n ihn
state_before: 𝕜 : Type u_1
inst✝¹ : NontriviallyNormedField 𝕜
inst✝ : NormedAlgebra 𝕜 ℂ
n : ℕ
⊢ ContDiff ℂ (↑n) exp

tactic: exact contDiff_zero.2 continuous_exp
state_before: case zero
𝕜 : Type u_1
inst✝¹ : NontriviallyNormedField 𝕜
inst✝ : NormedAlgebra 𝕜 ℂ
⊢ ContDiff ℂ (↑Nat.zero) exp

tactic: rw [contDiff_succ_iff_deriv]
state_before: case succ
𝕜 : Type u_1
inst✝¹ : NontriviallyNormedField 𝕜
inst✝ : NormedAlgebra 𝕜 ℂ
n : ℕ
ihn : ContDiff ℂ (↑n) exp
⊢ ContDiff ℂ (↑(Nat.succ n)) exp

tactic: use differentiable_exp
state_before: case succ
𝕜 : Type u_1
inst✝¹ : NontriviallyNormedField 𝕜
inst✝ : NormedAlgebra 𝕜 ℂ
n : ℕ
ihn : ContDiff ℂ (↑n) exp
⊢ Differentiable ℂ exp ∧ ContDiff ℂ (↑n) (deriv exp)

tactic: rwa [deriv_exp]
state_before: case succ
𝕜 : Type u_1
inst✝¹ : NontriviallyNormedField 𝕜
inst✝ : NormedAlgebra 𝕜 ℂ
n : ℕ
ihn : ContDiff ℂ (↑n) exp
⊢ ContDiff ℂ (↑n) (deriv exp)
Theorem: pow_pos
File: Mathlib/Algebra/Order/Ring/Defs.lean

tactic: nontriviality
state_before: α : Type u
β : Type ?u.57127
inst✝ : StrictOrderedSemiring α
a b c d : α
H : 0 < a
⊢ 0 < a ^ 0

tactic: rw [pow_zero]
state_before: α : Type u
β : Type ?u.57127
inst✝¹ : StrictOrderedSemiring α
a b c d : α
H : 0 < a
inst✝ : Nontrivial α
⊢ 0 < a ^ 0

tactic: exact zero_lt_one
state_before: α : Type u
β : Type ?u.57127
inst✝¹ : StrictOrderedSemiring α
a b c d : α
H : 0 < a
inst✝ : Nontrivial α
⊢ 0 < 1

tactic: rw [pow_succ]
state_before: α : Type u
β : Type ?u.57127
inst✝ : StrictOrderedSemiring α
a b c d : α
H : 0 < a
n : ℕ
⊢ 0 < a ^ (n + 1)

tactic: exact mul_pos H (pow_pos H _)
state_before: α : Type u
β : Type ?u.57127
inst✝ : StrictOrderedSemiring α
a b c d : α
H : 0 < a
n : ℕ
⊢ 0 < a * a ^ n
Theorem: dist_add_dist_of_mem_segment
File: Mathlib/Analysis/Convex/Normed.lean

tactic: simp only [dist_eq_norm, mem_segment_iff_sameRay] at *
state_before: ι : Type ?u.46254
E : Type u_1
inst✝¹ : SeminormedAddCommGroup E
inst✝ : NormedSpace ℝ E
s t : Set E
x y z : E
h : y ∈ [x-[ℝ]z]
⊢ dist x y + dist y z = dist x z

tactic: simpa only [sub_add_sub_cancel', norm_sub_rev] using h.norm_add.symm
state_before: ι : Type ?u.46254
E : Type u_1
inst✝¹ : SeminormedAddCommGroup E
inst✝ : NormedSpace ℝ E
s t : Set E
x y z : E
h : SameRay ℝ (y - x) (z - y)
⊢ ‖x - y‖ + ‖y - z‖ = ‖x - z‖
Theorem: MeasureTheory.average_mem_openSegment_compl_self
File: Mathlib/MeasureTheory/Integral/Average.lean

tactic: simpa only [union_compl_self, restrict_univ] using
  average_union_mem_openSegment aedisjoint_compl_right hs.compl hs₀ hsc₀ (measure_ne_top _ _)
    (measure_ne_top _ _) hfi.integrableOn hfi.integrableOn
state_before: α : Type u_1
E : Type u_2
F : Type ?u.228473
m0 : MeasurableSpace α
inst✝⁶ : NormedAddCommGroup E
inst✝⁵ : NormedSpace ℝ E
inst✝⁴ : CompleteSpace E
inst✝³ : NormedAddCommGroup F
inst✝² : NormedSpace ℝ F
inst✝¹ : CompleteSpace F
μ : Measure α
s✝ : Set E
inst✝ : IsFiniteMeasure μ
f : α → E
s : Set α
hs : NullMeasurableSet s
hs₀ : ↑↑μ s ≠ 0
hsc₀ : ↑↑μ (sᶜ) ≠ 0
hfi : Integrable f
⊢ (⨍ (x : α), f x ∂μ) ∈ openSegment ℝ (⨍ (x : α) in s, f x ∂μ) (⨍ (x : α) in sᶜ, f x ∂μ)
Theorem: integral_zpow
File: Mathlib/Analysis/SpecialFunctions/Integrals.lean

tactic: replace h : -1 < (n : ℝ) ∨ (n : ℝ) ≠ -1 ∧ (0 : ℝ) ∉ [[a, b]]
state_before: a b : ℝ
n✝ : ℕ
n : ℤ
h : 0 ≤ n ∨ n ≠ -1 ∧ ¬0 ∈ [[a, b]]
⊢ (∫ (x : ℝ) in a..b, x ^ n) = (b ^ (n + 1) - a ^ (n + 1)) / (↑n + 1)

tactic: exact_mod_cast integral_rpow h
state_before: a b : ℝ
n✝ : ℕ
n : ℤ
h : -1 < ↑n ∨ ↑n ≠ -1 ∧ ¬0 ∈ [[a, b]]
⊢ (∫ (x : ℝ) in a..b, x ^ n) = (b ^ (n + 1) - a ^ (n + 1)) / (↑n + 1)

tactic: exact_mod_cast h
state_before: case h
a b : ℝ
n✝ : ℕ
n : ℤ
h : 0 ≤ n ∨ n ≠ -1 ∧ ¬0 ∈ [[a, b]]
⊢ -1 < ↑n ∨ ↑n ≠ -1 ∧ ¬0 ∈ [[a, b]]
Theorem: div_eq_of_eq_mul'
File: Mathlib/Algebra/Group/Basic.lean

tactic: rw [h, div_eq_mul_inv, mul_comm, inv_mul_cancel_left]
state_before: α : Type ?u.65284
β : Type ?u.65287
G : Type u_1
inst✝ : CommGroup G
a✝ b✝ c✝ d a b c : G
h : a = b * c
⊢ a / b = c
Theorem: EuclideanGeometry.dist_div_cos_angle_of_angle_eq_pi_div_two
File: Mathlib/Geometry/Euclidean/Angle/Unoriented/RightAngle.lean

tactic: rw [angle, ← inner_eq_zero_iff_angle_eq_pi_div_two, real_inner_comm, ← neg_eq_zero, ←
  inner_neg_left, neg_vsub_eq_vsub_rev] at h
state_before: V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
p₁ p₂ p₃ : P
h : ∠ p₁ p₂ p₃ = π / 2
h0 : p₁ = p₂ ∨ p₃ ≠ p₂
⊢ dist p₃ p₂ / Real.cos (∠ p₂ p₃ p₁) = dist p₁ p₃

tactic: rw [ne_comm, ← @vsub_ne_zero V, ← @vsub_eq_zero_iff_eq V, or_comm] at h0
state_before: V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
p₁ p₂ p₃ : P
h : inner (p₂ -ᵥ p₃) (p₁ -ᵥ p₂) = 0
h0 : p₁ = p₂ ∨ p₃ ≠ p₂
⊢ dist p₃ p₂ / Real.cos (∠ p₂ p₃ p₁) = dist p₁ p₃

tactic: rw [angle, dist_eq_norm_vsub' V p₃ p₂, dist_eq_norm_vsub V p₁ p₃, ← vsub_add_vsub_cancel p₁ p₂ p₃,
  add_comm, norm_div_cos_angle_add_of_inner_eq_zero h h0]
state_before: V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
p₁ p₂ p₃ : P
h : inner (p₂ -ᵥ p₃) (p₁ -ᵥ p₂) = 0
h0 : p₂ -ᵥ p₃ ≠ 0 ∨ p₁ -ᵥ p₂ = 0
⊢ dist p₃ p₂ / Real.cos (∠ p₂ p₃ p₁) = dist p₁ p₃