tasksource/leandojo huggingface dataset:
Theorem: Nat.prime_iff_card_units
File: Mathlib/Data/Nat/Totient.lean

tactic: cases' eq_zero_or_neZero p with hp hp
state_before: p : ℕ
inst✝ : Fintype (ZMod p)ˣ
⊢ Prime p ↔ Fintype.card (ZMod p)ˣ = p - 1

tactic: rw [ZMod.card_units_eq_totient, Nat.totient_eq_iff_prime <| NeZero.pos p]
state_before: case inr
p : ℕ
inst✝ : Fintype (ZMod p)ˣ
hp : NeZero p
⊢ Prime p ↔ Fintype.card (ZMod p)ˣ = p - 1

tactic: subst hp
state_before: case inl
p : ℕ
inst✝ : Fintype (ZMod p)ˣ
hp : p = 0
⊢ Prime p ↔ Fintype.card (ZMod p)ˣ = p - 1

tactic: simp only [ZMod, not_prime_zero, false_iff_iff, zero_tsub]
state_before: case inl
inst✝ : Fintype (ZMod 0)ˣ
⊢ Prime 0 ↔ Fintype.card (ZMod 0)ˣ = 0 - 1

tactic: suffices Fintype.card ℤˣ ≠ 0 by convert this
state_before: case inl
inst✝ : Fintype (ZMod 0)ˣ
⊢ ¬Fintype.card ℤˣ = 0

tactic: simp
state_before: case inl
inst✝ : Fintype (ZMod 0)ˣ
⊢ Fintype.card ℤˣ ≠ 0

tactic: convert this
state_before: inst✝ : Fintype (ZMod 0)ˣ
this : Fintype.card ℤˣ ≠ 0
⊢ ¬Fintype.card ℤˣ = 0
Theorem: Complex.arg_eq_nhds_of_re_neg_of_im_pos
File: Mathlib/Analysis/SpecialFunctions/Complex/Arg.lean

tactic: suffices h_forall_nhds : ∀ᶠ y : ℂ in 𝓝 x, y.re < 0 ∧ 0 < y.im
state_before: x z : ℂ
hx_re : x.re < 0
hx_im : 0 < x.im
⊢ arg =ᶠ[𝓝 x] fun x => arcsin ((-x).im / ↑abs x) + π

tactic: exact h_forall_nhds.mono fun y hy => arg_of_re_neg_of_im_nonneg hy.1 hy.2.le
state_before: x z : ℂ
hx_re : x.re < 0
hx_im : 0 < x.im
h_forall_nhds : ∀ᶠ (y : ℂ) in 𝓝 x, y.re < 0 ∧ 0 < y.im
⊢ arg =ᶠ[𝓝 x] fun x => arcsin ((-x).im / ↑abs x) + π

case h_forall_nhds
x z : ℂ
hx_re : x.re < 0
hx_im : 0 < x.im
⊢ ∀ᶠ (y : ℂ) in 𝓝 x, y.re < 0 ∧ 0 < y.im

tactic: refine' IsOpen.eventually_mem _ (⟨hx_re, hx_im⟩ : x.re < 0 ∧ 0 < x.im)
state_before: case h_forall_nhds
x z : ℂ
hx_re : x.re < 0
hx_im : 0 < x.im
⊢ ∀ᶠ (y : ℂ) in 𝓝 x, y.re < 0 ∧ 0 < y.im

tactic: exact
  IsOpen.and (isOpen_lt continuous_re continuous_zero) (isOpen_lt continuous_zero continuous_im)
state_before: case h_forall_nhds
x z : ℂ
hx_re : x.re < 0
hx_im : 0 < x.im
⊢ IsOpen fun y => y.re < 0 ∧ 0 < y.im
Theorem: Real.dist_le_of_mem_Icc_01
File: Mathlib/Topology/MetricSpace/Basic.lean

tactic: simpa only [sub_zero] using Real.dist_le_of_mem_Icc hx hy
state_before: α : Type u
β : Type v
X : Type ?u.197176
ι : Type ?u.197179
inst✝ : PseudoMetricSpace α
x y : ℝ
hx : x ∈ Icc 0 1
hy : y ∈ Icc 0 1
⊢ dist x y ≤ 1
Theorem: tendstoUniformly_iff_seq_tendstoUniformly
File: Mathlib/Topology/UniformSpace/UniformConvergence.lean

tactic: simp_rw [← tendstoUniformlyOn_univ]
state_before: α : Type u
β : Type v
γ : Type w
ι : Type x
inst✝¹ : UniformSpace β
F : ι → α → β
f : α → β
s s' : Set α
x : α
p : Filter ι
p' : Filter α
g : ι → α
l : Filter ι
inst✝ : IsCountablyGenerated l
⊢ TendstoUniformly F f l ↔ ∀ (u : ℕ → ι), Tendsto u atTop l → TendstoUniformly (fun n => F (u n)) f atTop

tactic: exact tendstoUniformlyOn_iff_seq_tendstoUniformlyOn
state_before: α : Type u
β : Type v
γ : Type w
ι : Type x
inst✝¹ : UniformSpace β
F : ι → α → β
f : α → β
s s' : Set α
x : α
p : Filter ι
p' : Filter α
g : ι → α
l : Filter ι
inst✝ : IsCountablyGenerated l
⊢ TendstoUniformlyOn F f l univ ↔ ∀ (u : ℕ → ι), Tendsto u atTop l → TendstoUniformlyOn (fun n => F (u n)) f atTop univ
Theorem: Nat.multichoose_eq
File: Mathlib/Data/Nat/Choose/Basic.lean

tactic: simp
state_before: x✝ : ℕ
⊢ multichoose x✝ 0 = choose (x✝ + 0 - 1) 0

tactic: simp
state_before: k : ℕ
⊢ multichoose 0 (k + 1) = choose (0 + (k + 1) - 1) (k + 1)

tactic: have : n + (k + 1) < (n + 1) + (k + 1) := add_lt_add_right (Nat.lt_succ_self _) _
state_before: n k : ℕ
⊢ multichoose (n + 1) (k + 1) = choose (n + 1 + (k + 1) - 1) (k + 1)

tactic: have : (n + 1) + k < (n + 1) + (k + 1) := add_lt_add_left (Nat.lt_succ_self _) _
state_before: n k : ℕ
this : n + (k + 1) < n + 1 + (k + 1)
⊢ multichoose (n + 1) (k + 1) = choose (n + 1 + (k + 1) - 1) (k + 1)

tactic: erw [multichoose_succ_succ, add_comm, Nat.succ_add_sub_one, ← add_assoc, Nat.choose_succ_succ]
state_before: n k : ℕ
this✝ : n + (k + 1) < n + 1 + (k + 1)
this : n + 1 + k < n + 1 + (k + 1)
⊢ multichoose (n + 1) (k + 1) = choose (n + 1 + (k + 1) - 1) (k + 1)

tactic: simp [multichoose_eq n (k+1), multichoose_eq (n+1) k]
state_before: n k : ℕ
this✝ : n + (k + 1) < n + 1 + (k + 1)
this : n + 1 + k < n + 1 + (k + 1)
⊢ multichoose (n + 1) k + multichoose n (k + 1) = choose (n + k) k + choose (n + k) (succ k)
Theorem: Nat.zpow_pos_of_pos
File: Mathlib/Algebra/Order/Field/Power.lean

tactic: apply zpow_pos_of_pos
state_before: α : Type u_1
inst✝ : LinearOrderedSemifield α
a✝ b c d e : α
m n✝ : ℤ
a : ℕ
h : 0 < a
n : ℤ
⊢ 0 < ↑a ^ n

tactic: exact_mod_cast h
state_before: case ha
α : Type u_1
inst✝ : LinearOrderedSemifield α
a✝ b c d e : α
m n✝ : ℤ
a : ℕ
h : 0 < a
n : ℤ
⊢ 0 < ↑a
Theorem: Finset.Icc_diff_both
File: Mathlib/Data/Finset/LocallyFinite.lean

tactic: simp [← coe_inj]
state_before: ι : Type ?u.89689
α : Type u_1
inst✝² : PartialOrder α
inst✝¹ : LocallyFiniteOrder α
a✝ b✝ c : α
inst✝ : DecidableEq α
a b : α
⊢ Icc a b \ {a, b} = Ioo a b
Theorem: Complex.sinh_add
File: Mathlib/Data/Complex/Exponential.lean

tactic: rw [← mul_right_inj' (two_ne_zero' ℂ), two_sinh, exp_add, neg_add, exp_add, eq_comm, mul_add, ←
  mul_assoc, two_sinh, mul_left_comm, two_sinh, ← mul_right_inj' (two_ne_zero' ℂ), mul_add,
  mul_left_comm, two_cosh, ← mul_assoc, two_cosh]
state_before: x y : ℂ
⊢ sinh (x + y) = sinh x * cosh y + cosh x * sinh y

tactic: exact sinh_add_aux
state_before: x y : ℂ
⊢ (exp x - exp (-x)) * (exp y + exp (-y)) + (exp x + exp (-x)) * (exp y - exp (-y)) =
    2 * (exp x * exp y - exp (-x) * exp (-y))
Theorem: List.zipLeft_eq_zipLeft'
File: Mathlib/Data/List/Basic.lean

tactic: rw [zipLeft, zipLeft']
state_before: ι : Type ?u.477219
α : Type u
β : Type v
γ : Type w
δ : Type x
l₁ l₂ : List α
a : α
as✝ : List α
b : β
bs✝ : List β
as : List α
bs : List β
⊢ zipLeft as bs = (zipLeft' as bs).fst

tactic: cases as with
| nil => rfl
| cons _ atl =>
  cases bs with
  | nil => rfl
  | cons _ btl => rw [zipWithLeft, zipWithLeft', cons_inj]; exact @zipLeft_eq_zipLeft' atl btl
state_before: ι : Type ?u.477219
α : Type u
β : Type v
γ : Type w
δ : Type x
l₁ l₂ : List α
a : α
as✝ : List α
b : β
bs✝ : List β
as : List α
bs : List β
⊢ zipWithLeft Prod.mk as bs = (zipWithLeft' Prod.mk as bs).fst

tactic: rfl
state_before: case nil
ι : Type ?u.477219
α : Type u
β : Type v
γ : Type w
δ : Type x
l₁ l₂ : List α
a : α
as : List α
b : β
bs✝ bs : List β
⊢ zipWithLeft Prod.mk [] bs = (zipWithLeft' Prod.mk [] bs).fst

tactic: cases bs with
| nil => rfl
| cons _ btl => rw [zipWithLeft, zipWithLeft', cons_inj]; exact @zipLeft_eq_zipLeft' atl btl
state_before: case cons
ι : Type ?u.477219
α : Type u
β : Type v
γ : Type w
δ : Type x
l₁ l₂ : List α
a : α
as : List α
b : β
bs✝ bs : List β
head✝ : α
atl : List α
⊢ zipWithLeft Prod.mk (head✝ :: atl) bs = (zipWithLeft' Prod.mk (head✝ :: atl) bs).fst

tactic: rfl
state_before: case cons.nil
ι : Type ?u.477219
α : Type u
β : Type v
γ : Type w
δ : Type x
l₁ l₂ : List α
a : α
as : List α
b : β
bs : List β
head✝ : α
atl : List α
⊢ zipWithLeft Prod.mk (head✝ :: atl) [] = (zipWithLeft' Prod.mk (head✝ :: atl) []).fst

tactic: rw [zipWithLeft, zipWithLeft', cons_inj]
state_before: case cons.cons
ι : Type ?u.477219
α : Type u
β : Type v
γ : Type w
δ : Type x
l₁ l₂ : List α
a : α
as : List α
b : β
bs : List β
head✝¹ : α
atl : List α
head✝ : β
btl : List β
⊢ zipWithLeft Prod.mk (head✝¹ :: atl) (head✝ :: btl) = (zipWithLeft' Prod.mk (head✝¹ :: atl) (head✝ :: btl)).fst

tactic: exact @zipLeft_eq_zipLeft' atl btl
state_before: case cons.cons
ι : Type ?u.477219
α : Type u
β : Type v
γ : Type w
δ : Type x
l₁ l₂ : List α
a : α
as : List α
b : β
bs : List β
head✝¹ : α
atl : List α
head✝ : β
btl : List β
⊢ zipWithLeft Prod.mk atl btl = (zipWithLeft' Prod.mk atl btl).fst
Theorem: Filter.EventuallyLE.mul_le_mul'
File: Mathlib/Order/Filter/Basic.lean

tactic: filter_upwards [hf, hg] with x hfx hgx using _root_.mul_le_mul' hfx hgx
state_before: α : Type u
β : Type v
γ : Type w
δ : Type ?u.213025
ι : Sort x
inst✝³ : Mul β
inst✝² : Preorder β
inst✝¹ : CovariantClass β β (fun x x_1 => x * x_1) fun x x_1 => x ≤ x_1
inst✝ : CovariantClass β β (swap fun x x_1 => x * x_1) fun x x_1 => x ≤ x_1
l : Filter α
f₁ f₂ g₁ g₂ : α → β
hf : f₁ ≤ᶠ[l] f₂
hg : g₁ ≤ᶠ[l] g₂
⊢ f₁ * g₁ ≤ᶠ[l] f₂ * g₂
Theorem: LatticeOrderedCommGroup.pos_le_one_iff
File: Mathlib/Algebra/Order/LatticeGroup.lean

tactic: rw [m_pos_part_def, sup_le_iff, and_iff_left le_rfl]
state_before: α : Type u
inst✝¹ : Lattice α
inst✝ : CommGroup α
a : α
⊢ a⁺ ≤ 1 ↔ a ≤ 1
Theorem: Nat.sub_lt_self
File: Std/Data/Nat/Lemmas.lean

tactic: apply sub_lt _ h₀
state_before: a b : Nat
h₀ : 0 < a
h₁ : a ≤ b
⊢ b - a < b

tactic: apply Nat.lt_of_lt_of_le h₀ h₁
state_before: a b : Nat
h₀ : 0 < a
h₁ : a ≤ b
⊢ 0 < b
Theorem: Real.sqrt_le_sqrt_iff
File: Mathlib/Data/Real/Sqrt.lean

tactic: rw [sqrt, sqrt, NNReal.coe_le_coe, NNReal.sqrt_le_sqrt_iff, Real.toNNReal_le_toNNReal_iff hy]
state_before: x y : ℝ
hy : 0 ≤ y
⊢ sqrt x ≤ sqrt y ↔ x ≤ y
Theorem: LinearMap.isCoatom_ker_of_surjective
File: Mathlib/RingTheory/SimpleModule.lean

tactic: rw [← isSimpleModule_iff_isCoatom]
state_before: R : Type u_1
inst✝⁵ : Ring R
M : Type u_3
inst✝⁴ : AddCommGroup M
inst✝³ : Module R M
m : Submodule R M
N : Type u_2
inst✝² : AddCommGroup N
inst✝¹ : Module R N
inst✝ : IsSimpleModule R N
f : M →ₗ[R] N
hf : Function.Surjective ↑f
⊢ IsCoatom (ker f)

tactic: exact IsSimpleModule.congr (f.quotKerEquivOfSurjective hf)
state_before: R : Type u_1
inst✝⁵ : Ring R
M : Type u_3
inst✝⁴ : AddCommGroup M
inst✝³ : Module R M
m : Submodule R M
N : Type u_2
inst✝² : AddCommGroup N
inst✝¹ : Module R N
inst✝ : IsSimpleModule R N
f : M →ₗ[R] N
hf : Function.Surjective ↑f
⊢ IsSimpleModule R (M ⧸ ker f)
Theorem: CategoryTheory.IsFiltered.tulip
File: Mathlib/CategoryTheory/Filtered.lean

tactic: obtain ⟨l', k₁l, k₂l, hl⟩ := span f₂ f₃
state_before: C : Type u
inst✝¹ : Category C
inst✝ : IsFilteredOrEmpty C
j₁ j₂ j₃ k₁ k₂ l : C
f₁ : j₁ ⟶ k₁
f₂ : j₂ ⟶ k₁
f₃ : j₂ ⟶ k₂
f₄ : j₃ ⟶ k₂
g₁ : j₁ ⟶ l
g₂ : j₃ ⟶ l
⊢ ∃ s α β γ, f₁ ≫ α = g₁ ≫ β ∧ f₂ ≫ α = f₃ ≫ γ ∧ f₄ ≫ γ = g₂ ≫ β

tactic: obtain ⟨s, ls, l's, hs₁, hs₂⟩ := bowtie g₁ (f₁ ≫ k₁l) g₂ (f₄ ≫ k₂l)
state_before: case intro.intro.intro
C : Type u
inst✝¹ : Category C
inst✝ : IsFilteredOrEmpty C
j₁ j₂ j₃ k₁ k₂ l : C
f₁ : j₁ ⟶ k₁
f₂ : j₂ ⟶ k₁
f₃ : j₂ ⟶ k₂
f₄ : j₃ ⟶ k₂
g₁ : j₁ ⟶ l
g₂ : j₃ ⟶ l
l' : C
k₁l : k₁ ⟶ l'
k₂l : k₂ ⟶ l'
hl : f₂ ≫ k₁l = f₃ ≫ k₂l
⊢ ∃ s α β γ, f₁ ≫ α = g₁ ≫ β ∧ f₂ ≫ α = f₃ ≫ γ ∧ f₄ ≫ γ = g₂ ≫ β

tactic: refine' ⟨s, k₁l ≫ l's, ls, k₂l ≫ l's, _, by simp only [←Category.assoc, hl], _⟩ <;>
  simp only [hs₁, hs₂, Category.assoc]
state_before: case intro.intro.intro.intro.intro.intro.intro
C : Type u
inst✝¹ : Category C
inst✝ : IsFilteredOrEmpty C
j₁ j₂ j₃ k₁ k₂ l : C
f₁ : j₁ ⟶ k₁
f₂ : j₂ ⟶ k₁
f₃ : j₂ ⟶ k₂
f₄ : j₃ ⟶ k₂
g₁ : j₁ ⟶ l
g₂ : j₃ ⟶ l
l' : C
k₁l : k₁ ⟶ l'
k₂l : k₂ ⟶ l'
hl : f₂ ≫ k₁l = f₃ ≫ k₂l
s : C
ls : l ⟶ s
l's : l' ⟶ s
hs₁ : g₁ ≫ ls = (f₁ ≫ k₁l) ≫ l's
hs₂ : g₂ ≫ ls = (f₄ ≫ k₂l) ≫ l's
⊢ ∃ s α β γ, f₁ ≫ α = g₁ ≫ β ∧ f₂ ≫ α = f₃ ≫ γ ∧ f₄ ≫ γ = g₂ ≫ β

tactic: simp only [←Category.assoc, hl]
state_before: C : Type u
inst✝¹ : Category C
inst✝ : IsFilteredOrEmpty C
j₁ j₂ j₃ k₁ k₂ l : C
f₁ : j₁ ⟶ k₁
f₂ : j₂ ⟶ k₁
f₃ : j₂ ⟶ k₂
f₄ : j₃ ⟶ k₂
g₁ : j₁ ⟶ l
g₂ : j₃ ⟶ l
l' : C
k₁l : k₁ ⟶ l'
k₂l : k₂ ⟶ l'
hl : f₂ ≫ k₁l = f₃ ≫ k₂l
s : C
ls : l ⟶ s
l's : l' ⟶ s
hs₁ : g₁ ≫ ls = (f₁ ≫ k₁l) ≫ l's
hs₂ : g₂ ≫ ls = (f₄ ≫ k₂l) ≫ l's
⊢ f₂ ≫ k₁l ≫ l's = f₃ ≫ k₂l ≫ l's
Theorem: Equiv.Perm.sign_prodCongrRight
File: Mathlib/GroupTheory/Perm/Sign.lean

tactic: obtain ⟨l, hl, mem_l⟩ := Finite.exists_univ_list α
state_before: α : Type u
β : Type v
inst✝³ : DecidableEq α
inst✝² : Fintype α
inst✝¹ : DecidableEq β
inst✝ : Fintype β
σ : α → Perm β
⊢ ↑sign (prodCongrRight σ) = ∏ k : α, ↑sign (σ k)

tactic: have l_to_finset : l.toFinset = Finset.univ := by
  apply eq_top_iff.mpr
  intro b _
  exact List.mem_toFinset.mpr (mem_l b)
state_before: case intro.intro
α : Type u
β : Type v
inst✝³ : DecidableEq α
inst✝² : Fintype α
inst✝¹ : DecidableEq β
inst✝ : Fintype β
σ : α → Perm β
l : List α
hl : List.Nodup l
mem_l : ∀ (x : α), x ∈ l
⊢ ↑sign (prodCongrRight σ) = ∏ k : α, ↑sign (σ k)

tactic: rw [← prod_prodExtendRight σ hl mem_l, sign.map_list_prod, List.map_map, ← l_to_finset,
  List.prod_toFinset _ hl]
state_before: case intro.intro
α : Type u
β : Type v
inst✝³ : DecidableEq α
inst✝² : Fintype α
inst✝¹ : DecidableEq β
inst✝ : Fintype β
σ : α → Perm β
l : List α
hl : List.Nodup l
mem_l : ∀ (x : α), x ∈ l
l_to_finset : List.toFinset l = univ
⊢ ↑sign (prodCongrRight σ) = ∏ k : α, ↑sign (σ k)

tactic: simp_rw [← fun a => sign_prodExtendRight a (σ a), Function.comp]
state_before: case intro.intro
α : Type u
β : Type v
inst✝³ : DecidableEq α
inst✝² : Fintype α
inst✝¹ : DecidableEq β
inst✝ : Fintype β
σ : α → Perm β
l : List α
hl : List.Nodup l
mem_l : ∀ (x : α), x ∈ l
l_to_finset : List.toFinset l = univ
⊢ List.prod (List.map (↑sign ∘ fun a => prodExtendRight a (σ a)) l) = List.prod (List.map (fun k => ↑sign (σ k)) l)

tactic: apply eq_top_iff.mpr
state_before: α : Type u
β : Type v
inst✝³ : DecidableEq α
inst✝² : Fintype α
inst✝¹ : DecidableEq β
inst✝ : Fintype β
σ : α → Perm β
l : List α
hl : List.Nodup l
mem_l : ∀ (x : α), x ∈ l
⊢ List.toFinset l = univ

tactic: intro b _
state_before: α : Type u
β : Type v
inst✝³ : DecidableEq α
inst✝² : Fintype α
inst✝¹ : DecidableEq β
inst✝ : Fintype β
σ : α → Perm β
l : List α
hl : List.Nodup l
mem_l : ∀ (x : α), x ∈ l
⊢ ⊤ ≤ List.toFinset l

tactic: exact List.mem_toFinset.mpr (mem_l b)
state_before: α : Type u
β : Type v
inst✝³ : DecidableEq α
inst✝² : Fintype α
inst✝¹ : DecidableEq β
inst✝ : Fintype β
σ : α → Perm β
l : List α
hl : List.Nodup l
mem_l : ∀ (x : α), x ∈ l
b : α
a✝ : b ∈ ⊤
⊢ b ∈ List.toFinset l
Theorem: UniformOnFun.tendsto_iff_tendstoUniformlyOn
File: Mathlib/Topology/UniformSpace/UniformConvergenceTopology.lean

tactic: rw [UniformOnFun.topologicalSpace_eq, nhds_iInf, tendsto_iInf]
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.103872
ι : Type u_3
s s' : Set α
x : α
p : Filter ι
g : ι → α
inst✝ : UniformSpace β
𝔖 : Set (Set α)
F : ι → α →ᵤ[𝔖] β
f : α →ᵤ[𝔖] β
⊢ Tendsto F p (𝓝 f) ↔ ∀ (s : Set α), s ∈ 𝔖 → TendstoUniformlyOn F f p s

tactic: refine' forall_congr' fun s => _
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.103872
ι : Type u_3
s s' : Set α
x : α
p : Filter ι
g : ι → α
inst✝ : UniformSpace β
𝔖 : Set (Set α)
F : ι → α →ᵤ[𝔖] β
f : α →ᵤ[𝔖] β
⊢ (∀ (i : Set α), Tendsto F p (𝓝 f)) ↔ ∀ (s : Set α), s ∈ 𝔖 → TendstoUniformlyOn F f p s

tactic: rw [nhds_iInf, tendsto_iInf]
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.103872
ι : Type u_3
s✝ s' : Set α
x : α
p : Filter ι
g : ι → α
inst✝ : UniformSpace β
𝔖 : Set (Set α)
F : ι → α →ᵤ[𝔖] β
f : α →ᵤ[𝔖] β
s : Set α
⊢ Tendsto F p (𝓝 f) ↔ s ∈ 𝔖 → TendstoUniformlyOn F f p s

tactic: refine' forall_congr' fun hs => _
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.103872
ι : Type u_3
s✝ s' : Set α
x : α
p : Filter ι
g : ι → α
inst✝ : UniformSpace β
𝔖 : Set (Set α)
F : ι → α →ᵤ[𝔖] β
f : α →ᵤ[𝔖] β
s : Set α
⊢ s ∈ 𝔖 → Tendsto F p (𝓝 f) ↔ s ∈ 𝔖 → TendstoUniformlyOn F f p s

tactic: rw [nhds_induced (T := _), tendsto_comap_iff, tendstoUniformlyOn_iff_tendstoUniformly_comp_coe,
  UniformFun.tendsto_iff_tendstoUniformly]
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.103872
ι : Type u_3
s✝ s' : Set α
x : α
p : Filter ι
g : ι → α
inst✝ : UniformSpace β
𝔖 : Set (Set α)
F : ι → α →ᵤ[𝔖] β
f : α →ᵤ[𝔖] β
s : Set α
hs : s ∈ 𝔖
⊢ Tendsto F p (𝓝 f) ↔ TendstoUniformlyOn F f p s

tactic: rfl
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.103872
ι : Type u_3
s✝ s' : Set α
x : α
p : Filter ι
g : ι → α
inst✝ : UniformSpace β
𝔖 : Set (Set α)
F : ι → α →ᵤ[𝔖] β
f : α →ᵤ[𝔖] β
s : Set α
hs : s ∈ 𝔖
⊢ TendstoUniformly ((restrict s ∘ ↑UniformFun.toFun) ∘ F) ((restrict s ∘ ↑UniformFun.toFun) f) p ↔
    TendstoUniformly (fun i x => F i ↑x) (f ∘ Subtype.val) p
Theorem: NonarchAddGroupSeminorm.toZeroHom_eq_coe
File: Mathlib/Analysis/Normed/Group/Seminorm.lean

tactic: rfl
state_before: ι : Type ?u.127014
R : Type ?u.127017
R' : Type ?u.127020
E : Type u_1
F : Type ?u.127026
G : Type ?u.127029
inst✝² : AddGroup E
inst✝¹ : AddGroup F
inst✝ : AddGroup G
p q : NonarchAddGroupSeminorm E
⊢ ↑p.toZeroHom = ↑p
Theorem: List.nthLe_cons
File: Mathlib/Data/List/Basic.lean

tactic: split_ifs with h
state_before: ι : Type ?u.48326
α : Type u
β : Type v
γ : Type w
δ : Type x
l₁ l₂ l : List α
a : α
n : ℕ
hl : n < length (a :: l)
⊢ nthLe (a :: l) n hl = if hn : n = 0 then a else nthLe l (n - 1) (_ : n - 1 < length l)

tactic: cases l
state_before: case inr
ι : Type ?u.48326
α : Type u
β : Type v
γ : Type w
δ : Type x
l₁ l₂ l : List α
a : α
n : ℕ
hl : n < length (a :: l)
h : ¬n = 0
⊢ nthLe (a :: l) n hl = nthLe l (n - 1) (_ : n - 1 < length l)

tactic: cases n
state_before: case inr.cons
ι : Type ?u.48326
α : Type u
β : Type v
γ : Type w
δ : Type x
l₁ l₂ : List α
a : α
n : ℕ
h : ¬n = 0
head✝ : α
tail✝ : List α
hl : n < length (a :: head✝ :: tail✝)
⊢ nthLe (a :: head✝ :: tail✝) n hl = nthLe (head✝ :: tail✝) (n - 1) (_ : n - 1 < length (head✝ :: tail✝))

tactic: rfl
state_before: case inr.cons.succ
ι : Type ?u.48326
α : Type u
β : Type v
γ : Type w
δ : Type x
l₁ l₂ : List α
a head✝ : α
tail✝ : List α
n✝ : ℕ
h : ¬succ n✝ = 0
hl : succ n✝ < length (a :: head✝ :: tail✝)
⊢ nthLe (a :: head✝ :: tail✝) (succ n✝) hl =
    nthLe (head✝ :: tail✝) (succ n✝ - 1) (_ : succ n✝ - 1 < length (head✝ :: tail✝))

tactic: simp [nthLe, h]
state_before: case inl
ι : Type ?u.48326
α : Type u
β : Type v
γ : Type w
δ : Type x
l₁ l₂ l : List α
a : α
n : ℕ
hl : n < length (a :: l)
h : n = 0
⊢ nthLe (a :: l) n hl = a

tactic: rw [length_singleton, lt_succ_iff, nonpos_iff_eq_zero] at hl
state_before: case inr.nil
ι : Type ?u.48326
α : Type u
β : Type v
γ : Type w
δ : Type x
l₁ l₂ : List α
a : α
n : ℕ
h : ¬n = 0
hl : n < length [a]
⊢ nthLe [a] n hl = nthLe [] (n - 1) (_ : n - 1 < length [])

tactic: contradiction
state_before: case inr.nil
ι : Type ?u.48326
α : Type u
β : Type v
γ : Type w
δ : Type x
l₁ l₂ : List α
a : α
n : ℕ
h : ¬n = 0
hl✝ : n < length [a]
hl : n = 0
⊢ nthLe [a] n hl✝ = nthLe [] (n - 1) (_ : n - 1 < length [])

tactic: contradiction
state_before: case inr.cons.zero
ι : Type ?u.48326
α : Type u
β : Type v
γ : Type w
δ : Type x
l₁ l₂ : List α
a head✝ : α
tail✝ : List α
h : ¬zero = 0
hl : zero < length (a :: head✝ :: tail✝)
⊢ nthLe (a :: head✝ :: tail✝) zero hl = nthLe (head✝ :: tail✝) (zero - 1) (_ : zero - 1 < length (head✝ :: tail✝))
Theorem: Nat.le_log2
File: Std/Data/Nat/Lemmas.lean

tactic: simp [show 1 ≤ n from Nat.pos_of_ne_zero h]
state_before: n k : Nat
h : n ≠ 0
⊢ 0 ≤ log2 n ↔ 2 ^ 0 ≤ n

tactic: rw [log2]
state_before: n k✝ : Nat
h : n ≠ 0
k : Nat
⊢ k + 1 ≤ log2 n ↔ 2 ^ (k + 1) ≤ n

tactic: split
state_before: n k✝ : Nat
h : n ≠ 0
k : Nat
⊢ (k + 1 ≤ if n ≥ 2 then log2 (n / 2) + 1 else 0) ↔ 2 ^ (k + 1) ≤ n

tactic: have n0 : 0 < n / 2 := (Nat.le_div_iff_mul_le (by decide)).2 ‹_›
state_before: case inl
n k✝ : Nat
h : n ≠ 0
k : Nat
h✝ : n ≥ 2
⊢ k + 1 ≤ log2 (n / 2) + 1 ↔ 2 ^ (k + 1) ≤ n

tactic: simp [Nat.add_le_add_iff_le_right, le_log2 (Nat.ne_of_gt n0), le_div_iff_mul_le, Nat.pow_succ]
state_before: case inl
n k✝ : Nat
h : n ≠ 0
k : Nat
h✝ : n ≥ 2
n0 : 0 < n / 2
⊢ k + 1 ≤ log2 (n / 2) + 1 ↔ 2 ^ (k + 1) ≤ n

tactic: decide
state_before: n k✝ : Nat
h : n ≠ 0
k : Nat
h✝ : n ≥ 2
⊢ 0 < 2

tactic: simp only [le_zero_eq, succ_ne_zero, false_iff]
state_before: case inr
n k✝ : Nat
h : n ≠ 0
k : Nat
h✝ : ¬n ≥ 2
⊢ k + 1 ≤ 0 ↔ 2 ^ (k + 1) ≤ n

tactic: refine mt (Nat.le_trans ?_) ‹_›
state_before: case inr
n k✝ : Nat
h : n ≠ 0
k : Nat
h✝ : ¬n ≥ 2
⊢ ¬2 ^ (k + 1) ≤ n

tactic: exact Nat.pow_le_pow_of_le_right (Nat.succ_pos 1) (Nat.le_add_left 1 k)
state_before: case inr
n k✝ : Nat
h : n ≠ 0
k : Nat
h✝ : ¬n ≥ 2
⊢ 2 ≤ 2 ^ (k + 1)
Theorem: spectrum.exists_mem_of_not_isUnit_aeval_prod
File: Mathlib/FieldTheory/IsAlgClosed/Spectrum.lean

tactic: rw [← Multiset.prod_toList, AlgHom.map_list_prod] at h
state_before: R : Type u
A : Type v
inst✝³ : CommRing R
inst✝² : Ring A
inst✝¹ : Algebra R A
inst✝ : IsDomain R
p : R[X]
a : A
h : ¬IsUnit (↑(aeval a) (Multiset.prod (Multiset.map (fun x => X - ↑C x) (roots p))))
⊢ ∃ k, k ∈ σ a ∧ eval k p = 0

tactic: replace h := mt List.prod_isUnit h
state_before: R : Type u
A : Type v
inst✝³ : CommRing R
inst✝² : Ring A
inst✝¹ : Algebra R A
inst✝ : IsDomain R
p : R[X]
a : A
h : ¬IsUnit (List.prod (List.map (↑(aeval a)) (Multiset.toList (Multiset.map (fun x => X - ↑C x) (roots p)))))
⊢ ∃ k, k ∈ σ a ∧ eval k p = 0

tactic: simp only [not_forall, exists_prop, aeval_C, Multiset.mem_toList, List.mem_map, aeval_X,
  exists_exists_and_eq_and, Multiset.mem_map, AlgHom.map_sub] at h
state_before: R : Type u
A : Type v
inst✝³ : CommRing R
inst✝² : Ring A
inst✝¹ : Algebra R A
inst✝ : IsDomain R
p : R[X]
a : A
h :
  ¬∀ (m : (fun x => A) (List.prod (Multiset.toList (Multiset.map (fun x => X - ↑C x) (roots p))))),
      m ∈ List.map (↑(aeval a)) (Multiset.toList (Multiset.map (fun x => X - ↑C x) (roots p))) → IsUnit m
⊢ ∃ k, k ∈ σ a ∧ eval k p = 0

tactic: rcases h with ⟨r, r_mem, r_nu⟩
state_before: R : Type u
A : Type v
inst✝³ : CommRing R
inst✝² : Ring A
inst✝¹ : Algebra R A
inst✝ : IsDomain R
p : R[X]
a : A
h : ∃ a_1, a_1 ∈ roots p ∧ ¬IsUnit (a - ↑↑ₐ a_1)
⊢ ∃ k, k ∈ σ a ∧ eval k p = 0

tactic: exact ⟨r, by rwa [mem_iff, ← IsUnit.sub_iff], (mem_roots'.1 r_mem).2⟩
state_before: case intro.intro
R : Type u
A : Type v
inst✝³ : CommRing R
inst✝² : Ring A
inst✝¹ : Algebra R A
inst✝ : IsDomain R
p : R[X]
a : A
r : R
r_mem : r ∈ roots p
r_nu : ¬IsUnit (a - ↑↑ₐ r)
⊢ ∃ k, k ∈ σ a ∧ eval k p = 0

tactic: rwa [mem_iff, ← IsUnit.sub_iff]
state_before: R : Type u
A : Type v
inst✝³ : CommRing R
inst✝² : Ring A
inst✝¹ : Algebra R A
inst✝ : IsDomain R
p : R[X]
a : A
r : R
r_mem : r ∈ roots p
r_nu : ¬IsUnit (a - ↑↑ₐ r)
⊢ r ∈ σ a
Theorem: hyperoperation_ge_two_eq_self
File: Mathlib/Data/Nat/Hyperoperation.lean

tactic: induction' n with nn nih
state_before: n m : ℕ
⊢ hyperoperation (n + 2) m 1 = m

tactic: rw [hyperoperation_two]
state_before: case zero
m : ℕ
⊢ hyperoperation (Nat.zero + 2) m 1 = m

tactic: ring
state_before: case zero
m : ℕ
⊢ (fun x x_1 => x * x_1) m 1 = m

tactic: rw [hyperoperation_recursion, hyperoperation_ge_three_eq_one, nih]
state_before: case succ
m nn : ℕ
nih : hyperoperation (nn + 2) m 1 = m
⊢ hyperoperation (Nat.succ nn + 2) m 1 = m
Theorem: FinEnum.mem_toList
File: Mathlib/Data/FinEnum.lean

tactic: simp [toList]
state_before: α : Type u
β : α → Type v
inst✝ : FinEnum α
x : α
⊢ x ∈ toList α

tactic: exists Equiv x
state_before: α : Type u
β : α → Type v
inst✝ : FinEnum α
x : α
⊢ ∃ a, ↑Equiv.symm a = x

tactic: simp
state_before: α : Type u
β : α → Type v
inst✝ : FinEnum α
x : α
⊢ ↑Equiv.symm (↑Equiv x) = x
Theorem: List.Duplicate.ne_singleton
File: Mathlib/Data/List/Duplicate.lean

tactic: induction' h with l' h z l' h _
state_before: α : Type u_1
l : List α
x : α
h : x ∈+ l
y : α
⊢ l ≠ [y]

tactic: simp [ne_nil_of_mem h]
state_before: case cons_mem
α : Type u_1
l : List α
x y : α
l' : List α
h : x ∈ l'
⊢ x :: l' ≠ [y]

tactic: simp [ne_nil_of_mem h.mem]
state_before: case cons_duplicate
α : Type u_1
l : List α
x y z : α
l' : List α
h : x ∈+ l'
a_ih✝ : l' ≠ [y]
⊢ z :: l' ≠ [y]
Theorem: CategoryTheory.Limits.coprodComparison_inv_natural
File: Mathlib/CategoryTheory/Limits/Shapes/BinaryProducts.lean

tactic: rw [IsIso.eq_comp_inv, Category.assoc, IsIso.inv_comp_eq, coprodComparison_natural]
state_before: C : Type u
inst✝⁷ : Category C
X Y : C
D : Type u₂
inst✝⁶ : Category D
F : C ⥤ D
A A' B B' : C
inst✝⁵ : HasBinaryCoproduct A B
inst✝⁴ : HasBinaryCoproduct A' B'
inst✝³ : HasBinaryCoproduct (F.obj A) (F.obj B)
inst✝² : HasBinaryCoproduct (F.obj A') (F.obj B')
f : A ⟶ A'
g : B ⟶ B'
inst✝¹ : IsIso (coprodComparison F A B)
inst✝ : IsIso (coprodComparison F A' B')
⊢ inv (coprodComparison F A B) ≫ coprod.map (F.map f) (F.map g) =
    F.map (coprod.map f g) ≫ inv (coprodComparison F A' B')
Theorem: Gamma1_in_Gamma0
File: Mathlib/NumberTheory/ModularForms/CongruenceSubgroups.lean

tactic: intro x HA
state_before: N✝ N : ℕ
⊢ Gamma1 N ≤ Gamma0 N

tactic: simp only [Gamma0_mem, Gamma1_mem, coe_matrix_coe, Int.coe_castRingHom, map_apply] at *
state_before: N✝ N : ℕ
x : SL(2, ℤ)
HA : x ∈ Gamma1 N
⊢ x ∈ Gamma0 N

tactic: exact HA.2.2
state_before: N✝ N : ℕ
x : SL(2, ℤ)
HA : ↑(↑x 0 0) = 1 ∧ ↑(↑x 1 1) = 1 ∧ ↑(↑x 1 0) = 0
⊢ ↑(↑x 1 0) = 0