1337xyz1337xyz/leandojo-benchmark4-v10 huggingface dataset:
Theorem: Equiv.Perm.support_subtype_perm
File: Mathlib/GroupTheory/Perm/Support.lean

tactic: ext
state_before: α : Type u_1
inst✝ : DecidableEq α
s : Finset α
f : Perm α
h : ∀ (x : α), x ∈ s ↔ f x ∈ s
⊢ (f.subtypePerm h).support = filter (fun x => decide (f ↑x ≠ ↑x) = true) s.attach
state_after: case a
α : Type u_1
inst✝ : DecidableEq α
s : Finset α
f : Perm α
h : ∀ (x : α), x ∈ s ↔ f x ∈ s
a✝ : { x // x ∈ s }
⊢ a✝ ∈ (f.subtypePerm h).support ↔ a✝ ∈ filter (fun x => decide (f ↑x ≠ ↑x) = true) s.attach

tactic: simp [Subtype.ext_iff]
state_before: case a
α : Type u_1
inst✝ : DecidableEq α
s : Finset α
f : Perm α
h : ∀ (x : α), x ∈ s ↔ f x ∈ s
a✝ : { x // x ∈ s }
⊢ a✝ ∈ (f.subtypePerm h).support ↔ a✝ ∈ filter (fun x => decide (f ↑x ≠ ↑x) = true) s.attach
state_after: no goals
Theorem: UniqueFactorizationMonoid.exists_mem_normalizedFactors
File: Mathlib/RingTheory/UniqueFactorizationDomain.lean

tactic: obtain ⟨p', hp', hp'x⟩ := WfDvdMonoid.exists_irreducible_factor h hx
state_before: α : Type u_1
inst✝² : CancelCommMonoidWithZero α
inst✝¹ : NormalizationMonoid α
inst✝ : UniqueFactorizationMonoid α
x : α
hx : x ≠ 0
h : ¬IsUnit x
⊢ ∃ p, p ∈ normalizedFactors x
state_after: case intro.intro
α : Type u_1
inst✝² : CancelCommMonoidWithZero α
inst✝¹ : NormalizationMonoid α
inst✝ : UniqueFactorizationMonoid α
x : α
hx : x ≠ 0
h : ¬IsUnit x
p' : α
hp' : Irreducible p'
hp'x : p' ∣ x
⊢ ∃ p, p ∈ normalizedFactors x

tactic: obtain ⟨p, hp, _⟩ := exists_mem_normalizedFactors_of_dvd hx hp' hp'x
state_before: case intro.intro
α : Type u_1
inst✝² : CancelCommMonoidWithZero α
inst✝¹ : NormalizationMonoid α
inst✝ : UniqueFactorizationMonoid α
x : α
hx : x ≠ 0
h : ¬IsUnit x
p' : α
hp' : Irreducible p'
hp'x : p' ∣ x
⊢ ∃ p, p ∈ normalizedFactors x
state_after: case intro.intro.intro.intro
α : Type u_1
inst✝² : CancelCommMonoidWithZero α
inst✝¹ : NormalizationMonoid α
inst✝ : UniqueFactorizationMonoid α
x : α
hx : x ≠ 0
h : ¬IsUnit x
p' : α
hp' : Irreducible p'
hp'x : p' ∣ x
p : α
hp : p ∈ normalizedFactors x
right✝ : p' ~ᵤ p
⊢ ∃ p, p ∈ normalizedFactors x

tactic: exact ⟨p, hp⟩
state_before: case intro.intro.intro.intro
α : Type u_1
inst✝² : CancelCommMonoidWithZero α
inst✝¹ : NormalizationMonoid α
inst✝ : UniqueFactorizationMonoid α
x : α
hx : x ≠ 0
h : ¬IsUnit x
p' : α
hp' : Irreducible p'
hp'x : p' ∣ x
p : α
hp : p ∈ normalizedFactors x
right✝ : p' ~ᵤ p
⊢ ∃ p, p ∈ normalizedFactors x
state_after: no goals
Theorem: Set.card_union_le
File: Mathlib/Data/Finite/Card.lean

tactic: cases' _root_.finite_or_infinite (↥(s ∪ t)) with h h
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
s t : Set α
⊢ Nat.card ↑(s ∪ t) ≤ Nat.card ↑s + Nat.card ↑t
state_after: case inl
α : Type u_1
β : Type u_2
γ : Type u_3
s t : Set α
h : Finite ↑(s ∪ t)
⊢ Nat.card ↑(s ∪ t) ≤ Nat.card ↑s + Nat.card ↑t

case inr
α : Type u_1
β : Type u_2
γ : Type u_3
s t : Set α
h : Infinite ↑(s ∪ t)
⊢ Nat.card ↑(s ∪ t) ≤ Nat.card ↑s + Nat.card ↑t

tactic: rw [finite_coe_iff, finite_union, ← finite_coe_iff, ← finite_coe_iff] at h
state_before: case inl
α : Type u_1
β : Type u_2
γ : Type u_3
s t : Set α
h : Finite ↑(s ∪ t)
⊢ Nat.card ↑(s ∪ t) ≤ Nat.card ↑s + Nat.card ↑t
state_after: case inl
α : Type u_1
β : Type u_2
γ : Type u_3
s t : Set α
h : Finite ↑s ∧ Finite ↑t
⊢ Nat.card ↑(s ∪ t) ≤ Nat.card ↑s + Nat.card ↑t

tactic: cases h
state_before: case inl
α : Type u_1
β : Type u_2
γ : Type u_3
s t : Set α
h : Finite ↑s ∧ Finite ↑t
⊢ Nat.card ↑(s ∪ t) ≤ Nat.card ↑s + Nat.card ↑t
state_after: case inl.intro
α : Type u_1
β : Type u_2
γ : Type u_3
s t : Set α
left✝ : Finite ↑s
right✝ : Finite ↑t
⊢ Nat.card ↑(s ∪ t) ≤ Nat.card ↑s + Nat.card ↑t

tactic: rw [← Cardinal.natCast_le, Nat.cast_add, Finite.cast_card_eq_mk, Finite.cast_card_eq_mk,
  Finite.cast_card_eq_mk]
state_before: case inl.intro
α : Type u_1
β : Type u_2
γ : Type u_3
s t : Set α
left✝ : Finite ↑s
right✝ : Finite ↑t
⊢ Nat.card ↑(s ∪ t) ≤ Nat.card ↑s + Nat.card ↑t
state_after: case inl.intro
α : Type u_1
β : Type u_2
γ : Type u_3
s t : Set α
left✝ : Finite ↑s
right✝ : Finite ↑t
⊢ Cardinal.mk ↑(s ∪ t) ≤ Cardinal.mk ↑s + Cardinal.mk ↑t

tactic: exact Cardinal.mk_union_le s t
state_before: case inl.intro
α : Type u_1
β : Type u_2
γ : Type u_3
s t : Set α
left✝ : Finite ↑s
right✝ : Finite ↑t
⊢ Cardinal.mk ↑(s ∪ t) ≤ Cardinal.mk ↑s + Cardinal.mk ↑t
state_after: no goals

tactic: exact Nat.card_eq_zero_of_infinite.trans_le (zero_le _)
state_before: case inr
α : Type u_1
β : Type u_2
γ : Type u_3
s t : Set α
h : Infinite ↑(s ∪ t)
⊢ Nat.card ↑(s ∪ t) ≤ Nat.card ↑s + Nat.card ↑t
state_after: no goals
Theorem: Real.pi_pos
File: Mathlib/Analysis/SpecialFunctions/Trigonometric/Basic.lean

tactic: norm_num
state_before: ⊢ 0 < 2
state_after: no goals
Theorem: Filter.tendsto_div_const_atBot_iff_pos
File: Mathlib/Order/Filter/AtTopBot.lean

tactic: simp [div_eq_mul_inv, tendsto_mul_const_atBot_iff_pos h]
state_before: ι : Type u_1
ι' : Type u_2
α : Type u_3
β : Type u_4
γ : Type u_5
inst✝¹ : LinearOrderedField α
l : Filter β
f : β → α
r : α
inst✝ : l.NeBot
h : Tendsto f l atBot
⊢ Tendsto (fun x => f x / r) l atBot ↔ 0 < r
state_after: no goals
Theorem: WeierstrassCurve.Affine.evalEval_polynomial
File: Mathlib/AlgebraicGeometry/EllipticCurve/Affine.lean

tactic: simp only [polynomial]
state_before: R : Type u
inst✝ : CommRing R
W : Affine R
x y : R
⊢ evalEval x y W.polynomial = y ^ 2 + W.a₁ * x * y + W.a₃ * y - (x ^ 3 + W.a₂ * x ^ 2 + W.a₄ * x + W.a₆)
state_after: R : Type u
inst✝ : CommRing R
W : Affine R
x y : R
⊢ evalEval x y (Y ^ 2 + C (C W.a₁ * X + C W.a₃) * Y - C (X ^ 3 + C W.a₂ * X ^ 2 + C W.a₄ * X + C W.a₆)) =
    y ^ 2 + W.a₁ * x * y + W.a₃ * y - (x ^ 3 + W.a₂ * x ^ 2 + W.a₄ * x + W.a₆)

tactic: eval_simp
state_before: R : Type u
inst✝ : CommRing R
W : Affine R
x y : R
⊢ evalEval x y (Y ^ 2 + C (C W.a₁ * X + C W.a₃) * Y - C (X ^ 3 + C W.a₂ * X ^ 2 + C W.a₄ * X + C W.a₆)) =
    y ^ 2 + W.a₁ * x * y + W.a₃ * y - (x ^ 3 + W.a₂ * x ^ 2 + W.a₄ * x + W.a₆)
state_after: R : Type u
inst✝ : CommRing R
W : Affine R
x y : R
⊢ y ^ 2 + (W.a₁ * x + W.a₃) * y - (x ^ 3 + W.a₂ * x ^ 2 + W.a₄ * x + W.a₆) =
    y ^ 2 + W.a₁ * x * y + W.a₃ * y - (x ^ 3 + W.a₂ * x ^ 2 + W.a₄ * x + W.a₆)

tactic: rw [add_mul, ← add_assoc]
state_before: R : Type u
inst✝ : CommRing R
W : Affine R
x y : R
⊢ y ^ 2 + (W.a₁ * x + W.a₃) * y - (x ^ 3 + W.a₂ * x ^ 2 + W.a₄ * x + W.a₆) =
    y ^ 2 + W.a₁ * x * y + W.a₃ * y - (x ^ 3 + W.a₂ * x ^ 2 + W.a₄ * x + W.a₆)
state_after: no goals
Theorem: List.Duplicate.mono_sublist
File: Mathlib/Data/List/Duplicate.lean

tactic: induction' h with l₁ l₂ y _ IH l₁ l₂ y h IH
state_before: α : Type u_1
l : List α
x : α
l' : List α
hx : x ∈+ l
h : l <+ l'
⊢ x ∈+ l'
state_after: case slnil
α : Type u_1
l : List α
x : α
l' : List α
hx : x ∈+ []
⊢ x ∈+ []

case cons
α : Type u_1
l : List α
x : α
l' l₁ l₂ : List α
y : α
a✝ : l₁ <+ l₂
IH : x ∈+ l₁ → x ∈+ l₂
hx : x ∈+ l₁
⊢ x ∈+ y :: l₂

case cons₂
α : Type u_1
l : List α
x : α
l' l₁ l₂ : List α
y : α
h : l₁ <+ l₂
IH : x ∈+ l₁ → x ∈+ l₂
hx : x ∈+ y :: l₁
⊢ x ∈+ y :: l₂

tactic: exact hx
state_before: case slnil
α : Type u_1
l : List α
x : α
l' : List α
hx : x ∈+ []
⊢ x ∈+ []
state_after: no goals

tactic: exact (IH hx).duplicate_cons _
state_before: case cons
α : Type u_1
l : List α
x : α
l' l₁ l₂ : List α
y : α
a✝ : l₁ <+ l₂
IH : x ∈+ l₁ → x ∈+ l₂
hx : x ∈+ l₁
⊢ x ∈+ y :: l₂
state_after: no goals

tactic: rw [duplicate_cons_iff] at hx ⊢
state_before: case cons₂
α : Type u_1
l : List α
x : α
l' l₁ l₂ : List α
y : α
h : l₁ <+ l₂
IH : x ∈+ l₁ → x ∈+ l₂
hx : x ∈+ y :: l₁
⊢ x ∈+ y :: l₂
state_after: case cons₂
α : Type u_1
l : List α
x : α
l' l₁ l₂ : List α
y : α
h : l₁ <+ l₂
IH : x ∈+ l₁ → x ∈+ l₂
hx : y = x ∧ x ∈ l₁ ∨ x ∈+ l₁
⊢ y = x ∧ x ∈ l₂ ∨ x ∈+ l₂

tactic: rcases hx with (⟨rfl, hx⟩ | hx)
state_before: case cons₂
α : Type u_1
l : List α
x : α
l' l₁ l₂ : List α
y : α
h : l₁ <+ l₂
IH : x ∈+ l₁ → x ∈+ l₂
hx : y = x ∧ x ∈ l₁ ∨ x ∈+ l₁
⊢ y = x ∧ x ∈ l₂ ∨ x ∈+ l₂
state_after: case cons₂.inl.intro
α : Type u_1
l l' l₁ l₂ : List α
y : α
h : l₁ <+ l₂
IH : y ∈+ l₁ → y ∈+ l₂
hx : y ∈ l₁
⊢ y = y ∧ y ∈ l₂ ∨ y ∈+ l₂

case cons₂.inr
α : Type u_1
l : List α
x : α
l' l₁ l₂ : List α
y : α
h : l₁ <+ l₂
IH : x ∈+ l₁ → x ∈+ l₂
hx : x ∈+ l₁
⊢ y = x ∧ x ∈ l₂ ∨ x ∈+ l₂

tactic: simp [h.subset hx]
state_before: case cons₂.inl.intro
α : Type u_1
l l' l₁ l₂ : List α
y : α
h : l₁ <+ l₂
IH : y ∈+ l₁ → y ∈+ l₂
hx : y ∈ l₁
⊢ y = y ∧ y ∈ l₂ ∨ y ∈+ l₂
state_after: no goals

tactic: simp [IH hx]
state_before: case cons₂.inr
α : Type u_1
l : List α
x : α
l' l₁ l₂ : List α
y : α
h : l₁ <+ l₂
IH : x ∈+ l₁ → x ∈+ l₂
hx : x ∈+ l₁
⊢ y = x ∧ x ∈ l₂ ∨ x ∈+ l₂
state_after: no goals
Theorem: Ordnode.raised_iff
File: Mathlib/Data/Ordmap/Ordset.lean

tactic: constructor
state_before: α : Type u_1
n m : ℕ
⊢ Raised n m ↔ n ≤ m ∧ m ≤ n + 1
state_after: case mp
α : Type u_1
n m : ℕ
⊢ Raised n m → n ≤ m ∧ m ≤ n + 1

case mpr
α : Type u_1
n m : ℕ
⊢ n ≤ m ∧ m ≤ n + 1 → Raised n m

tactic: rintro (rfl | rfl)
state_before: case mp
α : Type u_1
n m : ℕ
⊢ Raised n m → n ≤ m ∧ m ≤ n + 1
state_after: case mp.inl
α : Type u_1
m : ℕ
⊢ m ≤ m ∧ m ≤ m + 1

case mp.inr
α : Type u_1
n : ℕ
⊢ n ≤ n + 1 ∧ n + 1 ≤ n + 1

tactic: exact ⟨le_rfl, Nat.le_succ _⟩
state_before: case mp.inl
α : Type u_1
m : ℕ
⊢ m ≤ m ∧ m ≤ m + 1
state_after: no goals

tactic: exact ⟨Nat.le_succ _, le_rfl⟩
state_before: case mp.inr
α : Type u_1
n : ℕ
⊢ n ≤ n + 1 ∧ n + 1 ≤ n + 1
state_after: no goals

tactic: rintro ⟨h₁, h₂⟩
state_before: case mpr
α : Type u_1
n m : ℕ
⊢ n ≤ m ∧ m ≤ n + 1 → Raised n m
state_after: case mpr.intro
α : Type u_1
n m : ℕ
h₁ : n ≤ m
h₂ : m ≤ n + 1
⊢ Raised n m

tactic: rcases eq_or_lt_of_le h₁ with (rfl | h₁)
state_before: case mpr.intro
α : Type u_1
n m : ℕ
h₁ : n ≤ m
h₂ : m ≤ n + 1
⊢ Raised n m
state_after: case mpr.intro.inl
α : Type u_1
n : ℕ
h₁ : n ≤ n
h₂ : n ≤ n + 1
⊢ Raised n n

case mpr.intro.inr
α : Type u_1
n m : ℕ
h₁✝ : n ≤ m
h₂ : m ≤ n + 1
h₁ : n < m
⊢ Raised n m

tactic: exact Or.inl rfl
state_before: case mpr.intro.inl
α : Type u_1
n : ℕ
h₁ : n ≤ n
h₂ : n ≤ n + 1
⊢ Raised n n
state_after: no goals

tactic: exact Or.inr (le_antisymm h₂ h₁)
state_before: case mpr.intro.inr
α : Type u_1
n m : ℕ
h₁✝ : n ≤ m
h₂ : m ≤ n + 1
h₁ : n < m
⊢ Raised n m
state_after: no goals
Theorem: Semiquot.IsPure.min
File: Mathlib/Data/Semiquot.lean

tactic: rw [eq_pure h, eq_pure (h.mono st)]
state_before: α : Type u_1
β : Type u_2
s t : Semiquot α
h : t.IsPure
st : s ≤ t
⊢ t ≤ s
state_after: α : Type u_1
β : Type u_2
s t : Semiquot α
h : t.IsPure
st : s ≤ t
⊢ pure (t.get h) ≤ pure (s.get ⋯)

tactic: simp
state_before: α : Type u_1
β : Type u_2
s t : Semiquot α
h : t.IsPure
st : s ≤ t
⊢ pure (t.get h) ≤ pure (s.get ⋯)
state_after: α : Type u_1
β : Type u_2
s t : Semiquot α
h : t.IsPure
st : s ≤ t
⊢ t.get h = s.get ⋯

tactic: exact h _ (get_mem _) _ (st <| get_mem _)
state_before: α : Type u_1
β : Type u_2
s t : Semiquot α
h : t.IsPure
st : s ≤ t
⊢ t.get h = s.get ⋯
state_after: no goals
Theorem: Filter.map₂_right_comm
File: Mathlib/Order/Filter/NAry.lean

tactic: rw [map₂_swap n, map₂_swap n']
state_before: α : Type u_1
α' : Type u_2
β : Type u_3
β' : Type u_4
γ : Type u_5
γ' : Type u_6
δ : Type u_7
δ' : Type u_8
ε : Type u_9
ε' : Type u_10
m✝ : α → β → γ
f f₁ f₂ : Filter α
g g₁ g₂ : Filter β
h h₁ h₂ : Filter γ
s s₁ s₂ : Set α
t t₁ t₂ : Set β
u : Set γ
v : Set δ
a : α
b : β
c : γ
m : δ → γ → ε
n : α → β → δ
m' : α → γ → δ'
n' : δ' → β → ε
h_right_comm : ∀ (a : α) (b : β) (c : γ), m (n a b) c = n' (m' a c) b
⊢ map₂ m (map₂ n f g) h = map₂ n' (map₂ m' f h) g
state_after: α : Type u_1
α' : Type u_2
β : Type u_3
β' : Type u_4
γ : Type u_5
γ' : Type u_6
δ : Type u_7
δ' : Type u_8
ε : Type u_9
ε' : Type u_10
m✝ : α → β → γ
f f₁ f₂ : Filter α
g g₁ g₂ : Filter β
h h₁ h₂ : Filter γ
s s₁ s₂ : Set α
t t₁ t₂ : Set β
u : Set γ
v : Set δ
a : α
b : β
c : γ
m : δ → γ → ε
n : α → β → δ
m' : α → γ → δ'
n' : δ' → β → ε
h_right_comm : ∀ (a : α) (b : β) (c : γ), m (n a b) c = n' (m' a c) b
⊢ map₂ m (map₂ (fun a b => n b a) g f) h = map₂ (fun a b => n' b a) g (map₂ m' f h)

tactic: exact map₂_assoc fun _ _ _ => h_right_comm _ _ _
state_before: α : Type u_1
α' : Type u_2
β : Type u_3
β' : Type u_4
γ : Type u_5
γ' : Type u_6
δ : Type u_7
δ' : Type u_8
ε : Type u_9
ε' : Type u_10
m✝ : α → β → γ
f f₁ f₂ : Filter α
g g₁ g₂ : Filter β
h h₁ h₂ : Filter γ
s s₁ s₂ : Set α
t t₁ t₂ : Set β
u : Set γ
v : Set δ
a : α
b : β
c : γ
m : δ → γ → ε
n : α → β → δ
m' : α → γ → δ'
n' : δ' → β → ε
h_right_comm : ∀ (a : α) (b : β) (c : γ), m (n a b) c = n' (m' a c) b
⊢ map₂ m (map₂ (fun a b => n b a) g f) h = map₂ (fun a b => n' b a) g (map₂ m' f h)
state_after: no goals
Theorem: AlgebraicIndependent.mono
File: Mathlib/RingTheory/AlgebraicIndependent.lean

tactic: simpa [Function.comp] using hx.comp (inclusion h) (inclusion_injective h)
state_before: ι : Type u_1
ι' : Type u_2
R : Type u_3
K : Type u_4
A : Type u_5
A' : Type u_6
A'' : Type u_7
V : Type u
V' : Type u_8
x : ι → A
inst✝⁶ : CommRing R
inst✝⁵ : CommRing A
inst✝⁴ : CommRing A'
inst✝³ : CommRing A''
inst✝² : Algebra R A
inst✝¹ : Algebra R A'
inst✝ : Algebra R A''
a b : R
t s : Set A
h : t ⊆ s
hx : AlgebraicIndependent R Subtype.val
⊢ AlgebraicIndependent R Subtype.val
state_after: no goals
Theorem: HurwitzZeta.hasSum_expZeta_of_one_lt_re
File: Mathlib/NumberTheory/LSeries/HurwitzZeta.lean

tactic: convert (hasSum_nat_cosZeta a hs).add ((hasSum_nat_sinZeta a hs).mul_left I) using 1
state_before: a : ℝ
s : ℂ
hs : 1 < s.re
⊢ HasSum (fun n => cexp (2 * ↑π * I * ↑a * ↑n) / ↑n ^ s) (expZeta (↑a) s)
state_after: case h.e'_5
a : ℝ
s : ℂ
hs : 1 < s.re
⊢ (fun n => cexp (2 * ↑π * I * ↑a * ↑n) / ↑n ^ s) = fun b =>
    ↑(Real.cos (2 * π * a * ↑b)) / ↑b ^ s + I * (↑(Real.sin (2 * π * a * ↑b)) / ↑b ^ s)

tactic: ext1 n
state_before: case h.e'_5
a : ℝ
s : ℂ
hs : 1 < s.re
⊢ (fun n => cexp (2 * ↑π * I * ↑a * ↑n) / ↑n ^ s) = fun b =>
    ↑(Real.cos (2 * π * a * ↑b)) / ↑b ^ s + I * (↑(Real.sin (2 * π * a * ↑b)) / ↑b ^ s)
state_after: case h.e'_5.h
a : ℝ
s : ℂ
hs : 1 < s.re
n : ℕ
⊢ cexp (2 * ↑π * I * ↑a * ↑n) / ↑n ^ s =
    ↑(Real.cos (2 * π * a * ↑n)) / ↑n ^ s + I * (↑(Real.sin (2 * π * a * ↑n)) / ↑n ^ s)

tactic: simp only [mul_right_comm _ I, ← cos_add_sin_I, push_cast]
state_before: case h.e'_5.h
a : ℝ
s : ℂ
hs : 1 < s.re
n : ℕ
⊢ cexp (2 * ↑π * I * ↑a * ↑n) / ↑n ^ s =
    ↑(Real.cos (2 * π * a * ↑n)) / ↑n ^ s + I * (↑(Real.sin (2 * π * a * ↑n)) / ↑n ^ s)
state_after: case h.e'_5.h
a : ℝ
s : ℂ
hs : 1 < s.re
n : ℕ
⊢ (Complex.cos (2 * ↑π * ↑a * ↑n) + Complex.sin (2 * ↑π * ↑a * ↑n) * I) / ↑n ^ s =
    Complex.cos (2 * ↑π * ↑a * ↑n) / ↑n ^ s + I * (Complex.sin (2 * ↑π * ↑a * ↑n) / ↑n ^ s)

tactic: rw [add_div, mul_div, mul_comm _ I]
state_before: case h.e'_5.h
a : ℝ
s : ℂ
hs : 1 < s.re
n : ℕ
⊢ (Complex.cos (2 * ↑π * ↑a * ↑n) + Complex.sin (2 * ↑π * ↑a * ↑n) * I) / ↑n ^ s =
    Complex.cos (2 * ↑π * ↑a * ↑n) / ↑n ^ s + I * (Complex.sin (2 * ↑π * ↑a * ↑n) / ↑n ^ s)
state_after: no goals
Theorem: Sym2.out_fst_mem
File: Mathlib/Data/Sym/Sym2.lean

tactic: rw [Sym2.mk, e.out_eq]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
e : Sym2 α
⊢ e = s((Quot.out e).1, (Quot.out e).2)
state_after: no goals
Theorem: WittVector.mul_polyOfInterest_aux5
File: Mathlib/RingTheory/WittVector/MulCoeff.lean

tactic: simp only [polyOfInterest, mul_sub, mul_add, sub_eq_iff_eq_add']
state_before: p : ℕ
hp : Fact (Nat.Prime p)
k : Type u_1
inst✝ : CommRing k
n : ℕ
⊢ ↑p ^ (n + 1) * polyOfInterest p n = remainder p n - wittPolyProdRemainder p (n + 1)
state_after: p : ℕ
hp : Fact (Nat.Prime p)
k : Type u_1
inst✝ : CommRing k
n : ℕ
⊢ ↑p ^ (n + 1) * wittMul p (n + 1) + ↑p ^ (n + 1) * (↑p ^ (n + 1) * X (0, n + 1) * X (1, n + 1)) =
    ↑p ^ (n + 1) * (X (0, n + 1) * (rename (Prod.mk 1)) (wittPolynomial p ℤ (n + 1))) +
      (↑p ^ (n + 1) * (X (1, n + 1) * (rename (Prod.mk 0)) (wittPolynomial p ℤ (n + 1))) +
        (remainder p n - wittPolyProdRemainder p (n + 1)))

tactic: rw [mul_polyOfInterest_aux4 p n]
state_before: p : ℕ
hp : Fact (Nat.Prime p)
k : Type u_1
inst✝ : CommRing k
n : ℕ
⊢ ↑p ^ (n + 1) * wittMul p (n + 1) + ↑p ^ (n + 1) * (↑p ^ (n + 1) * X (0, n + 1) * X (1, n + 1)) =
    ↑p ^ (n + 1) * (X (0, n + 1) * (rename (Prod.mk 1)) (wittPolynomial p ℤ (n + 1))) +
      (↑p ^ (n + 1) * (X (1, n + 1) * (rename (Prod.mk 0)) (wittPolynomial p ℤ (n + 1))) +
        (remainder p n - wittPolyProdRemainder p (n + 1)))
state_after: p : ℕ
hp : Fact (Nat.Prime p)
k : Type u_1
inst✝ : CommRing k
n : ℕ
⊢ -(↑p ^ (n + 1) * X (0, n + 1)) * (↑p ^ (n + 1) * X (1, n + 1)) +
            ↑p ^ (n + 1) * X (0, n + 1) * (rename (Prod.mk 1)) (wittPolynomial p ℤ (n + 1)) +
          ↑p ^ (n + 1) * X (1, n + 1) * (rename (Prod.mk 0)) (wittPolynomial p ℤ (n + 1)) +
        (remainder p n - wittPolyProdRemainder p (n + 1)) +
      ↑p ^ (n + 1) * (↑p ^ (n + 1) * X (0, n + 1) * X (1, n + 1)) =
    ↑p ^ (n + 1) * (X (0, n + 1) * (rename (Prod.mk 1)) (wittPolynomial p ℤ (n + 1))) +
      (↑p ^ (n + 1) * (X (1, n + 1) * (rename (Prod.mk 0)) (wittPolynomial p ℤ (n + 1))) +
        (remainder p n - wittPolyProdRemainder p (n + 1)))

tactic: ring
state_before: p : ℕ
hp : Fact (Nat.Prime p)
k : Type u_1
inst✝ : CommRing k
n : ℕ
⊢ -(↑p ^ (n + 1) * X (0, n + 1)) * (↑p ^ (n + 1) * X (1, n + 1)) +
            ↑p ^ (n + 1) * X (0, n + 1) * (rename (Prod.mk 1)) (wittPolynomial p ℤ (n + 1)) +
          ↑p ^ (n + 1) * X (1, n + 1) * (rename (Prod.mk 0)) (wittPolynomial p ℤ (n + 1)) +
        (remainder p n - wittPolyProdRemainder p (n + 1)) +
      ↑p ^ (n + 1) * (↑p ^ (n + 1) * X (0, n + 1) * X (1, n + 1)) =
    ↑p ^ (n + 1) * (X (0, n + 1) * (rename (Prod.mk 1)) (wittPolynomial p ℤ (n + 1))) +
      (↑p ^ (n + 1) * (X (1, n + 1) * (rename (Prod.mk 0)) (wittPolynomial p ℤ (n + 1))) +
        (remainder p n - wittPolyProdRemainder p (n + 1)))
state_after: no goals
Theorem: Filter.isCountablyGenerated_seq
File: Mathlib/Order/Filter/Bases.lean

tactic: use range x, countable_range x
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
ι' : Sort u_5
inst✝ : Countable ι'
x : ι' → Set α
⊢ (⨅ i, 𝓟 (x i)).IsCountablyGenerated
state_after: case right
α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
ι' : Sort u_5
inst✝ : Countable ι'
x : ι' → Set α
⊢ ⨅ i, 𝓟 (x i) = generate (range x)

tactic: rw [generate_eq_biInf, iInf_range]
state_before: case right
α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
ι' : Sort u_5
inst✝ : Countable ι'
x : ι' → Set α
⊢ ⨅ i, 𝓟 (x i) = generate (range x)
state_after: no goals
Theorem: inv_lt'
File: Mathlib/Algebra/Order/Group/Defs.lean

tactic: rw [← inv_lt_inv_iff, inv_inv]
state_before: α : Type u
inst✝³ : Group α
inst✝² : LT α
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
a b c d : α
⊢ a⁻¹ < b ↔ b⁻¹ < a
state_after: no goals
Theorem: Finmap.insert_entries_of_neg
File: Mathlib/Data/Finmap.lean

tactic: simp [AList.insert_entries_of_neg (mt mem_toFinmap.1 h), -insert_entries]
state_before: α : Type u
β : α → Type v
inst✝ : DecidableEq α
a : α
b : β a
s✝ : Finmap β
s : AList β
h : a ∉ ⟦s⟧
⊢ (insert a b ⟦s⟧).entries = ⟨a, b⟩ ::ₘ ⟦s⟧.entries
state_after: no goals
Theorem: Mathlib.Tactic.Ring.mul_pf_right
File: Mathlib/Tactic/Ring/Basic.lean

tactic: subst_vars
state_before: u : Lean.Level
R : Type u_1
α : Q(Type u)
sα : Q(CommSemiring «$α»)
inst✝ : CommSemiring R
a b₃ c b₁ : R
b₂ : ℕ
x✝ : a * b₃ = c
⊢ a * (b₁ ^ b₂ * b₃) = b₁ ^ b₂ * c
state_after: u : Lean.Level
R : Type u_1
α : Q(Type u)
sα : Q(CommSemiring «$α»)
inst✝ : CommSemiring R
a b₃ b₁ : R
b₂ : ℕ
⊢ a * (b₁ ^ b₂ * b₃) = b₁ ^ b₂ * (a * b₃)

tactic: rw [mul_left_comm]
state_before: u : Lean.Level
R : Type u_1
α : Q(Type u)
sα : Q(CommSemiring «$α»)
inst✝ : CommSemiring R
a b₃ b₁ : R
b₂ : ℕ
⊢ a * (b₁ ^ b₂ * b₃) = b₁ ^ b₂ * (a * b₃)
state_after: no goals
Theorem: Order.pred_le_pred_iff
File: Mathlib/Order/SuccPred/Basic.lean

tactic: simp
state_before: α : Type u_1
β : Type u_2
inst✝² : Preorder α
inst✝¹ : PredOrder α
a b : α
inst✝ : NoMinOrder α
⊢ pred a ≤ pred b ↔ a ≤ b
state_after: no goals
Theorem: SimpleGraph.Walk.edges_copy
File: Mathlib/Combinatorics/SimpleGraph/Connectivity.lean

tactic: subst_vars
state_before: V : Type u
V' : Type v
V'' : Type w
G : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
u v u' v' : V
p : G.Walk u v
hu : u = u'
hv : v = v'
⊢ (p.copy hu hv).edges = p.edges
state_after: V : Type u
V' : Type v
V'' : Type w
G : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
u' v' : V
p : G.Walk u' v'
⊢ (p.copy ⋯ ⋯).edges = p.edges

tactic: rfl
state_before: V : Type u
V' : Type v
V'' : Type w
G : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
u' v' : V
p : G.Walk u' v'
⊢ (p.copy ⋯ ⋯).edges = p.edges
state_after: no goals
Theorem: Matrix.toMvPolynomial_eval_eq_apply
File: Mathlib/Algebra/Module/LinearMap/Polynomial.lean

tactic: simp only [toMvPolynomial, map_sum, eval_monomial, pow_zero, Finsupp.prod_single_index, pow_one,
  mulVec, dotProduct]
state_before: m : Type u_1
n : Type u_2
o : Type u_3
R : Type u_4
S : Type u_5
inst✝³ : Fintype n
inst✝² : Fintype o
inst✝¹ : CommSemiring R
inst✝ : CommSemiring S
M : Matrix m n R
i : m
c : n → R
⊢ (eval c) (M.toMvPolynomial i) = (M *ᵥ c) i
state_after: no goals
Theorem: LocalizedModule.mul_smul'
File: Mathlib/Algebra/Module/LocalizedModule.lean

tactic: induction p₁, p₂ using induction_on₂ with | _ a₁ s₁ a₂ s₂ => _
state_before: R : Type u
inst✝⁷ : CommSemiring R
S : Submonoid R
M : Type v
inst✝⁶ : AddCommMonoid M
inst✝⁵ : Module R M
T : Type u_1
inst✝⁴ : CommSemiring T
inst✝³ : Algebra R T
inst✝² : IsLocalization S T
A : Type u_2
inst✝¹ : Semiring A
inst✝ : Algebra R A
x : T
p₁ p₂ : LocalizedModule S A
⊢ p₁ * x • p₂ = x • (p₁ * p₂)
state_after: case h
R : Type u
inst✝⁷ : CommSemiring R
S : Submonoid R
M : Type v
inst✝⁶ : AddCommMonoid M
inst✝⁵ : Module R M
T : Type u_1
inst✝⁴ : CommSemiring T
inst✝³ : Algebra R T
inst✝² : IsLocalization S T
A : Type u_2
inst✝¹ : Semiring A
inst✝ : Algebra R A
x : T
a₁ s₁ : A
a₂ s₂ : ↥S
⊢ mk a₁ a₂ * x • mk s₁ s₂ = x • (mk a₁ a₂ * mk s₁ s₂)

tactic: rw [smul_def, mk_mul_mk, mk_mul_mk, smul_def, mul_left_comm, mul_smul_comm]
state_before: case h
R : Type u
inst✝⁷ : CommSemiring R
S : Submonoid R
M : Type v
inst✝⁶ : AddCommMonoid M
inst✝⁵ : Module R M
T : Type u_1
inst✝⁴ : CommSemiring T
inst✝³ : Algebra R T
inst✝² : IsLocalization S T
A : Type u_2
inst✝¹ : Semiring A
inst✝ : Algebra R A
x : T
a₁ s₁ : A
a₂ s₂ : ↥S
⊢ mk a₁ a₂ * x • mk s₁ s₂ = x • (mk a₁ a₂ * mk s₁ s₂)
state_after: no goals
Theorem: derangements.Equiv.RemoveNone.mem_fiber
File: Mathlib/Combinatorics/Derangements/Basic.lean

tactic: simp [RemoveNone.fiber, derangements]
state_before: α : Type u_1
β : Type u_2
inst✝ : DecidableEq α
a : Option α
f : Perm α
⊢ f ∈ fiber a ↔ ∃ F ∈ derangements (Option α), F none = a ∧ removeNone F = f
state_after: no goals
Theorem: MvPolynomial.pderiv_C_mul
File: Mathlib/Algebra/MvPolynomial/PDeriv.lean

tactic: rw [C_mul', Derivation.map_smul, C_mul']
state_before: R : Type u
σ : Type v
a a' a₁ a₂ : R
s : σ →₀ ℕ
inst✝ : CommSemiring R
f : MvPolynomial σ R
i : σ
⊢ (pderiv i) (C a * f) = C a * (pderiv i) f
state_after: no goals
Theorem: Int.natCast_ne_zero
File: Mathlib/Data/Int/Defs.lean

tactic: omega
state_before: a b c d m n✝ : ℤ
n : ℕ
⊢ ↑n ≠ 0 ↔ n ≠ 0
state_after: no goals
Theorem: IsPrimitiveRoot.pow_isRoot_minpoly
File: Mathlib/RingTheory/RootsOfUnity/Minpoly.lean

tactic: simp only [minpoly_eq_pow_coprime h hcop, IsRoot.def, eval_map]
state_before: n : ℕ
K : Type u_1
inst✝² : CommRing K
μ : K
h : IsPrimitiveRoot μ n
inst✝¹ : IsDomain K
inst✝ : CharZero K
m : ℕ
hcop : m.Coprime n
⊢ (map (Int.castRingHom K) (minpoly ℤ μ)).IsRoot (μ ^ m)
state_after: n : ℕ
K : Type u_1
inst✝² : CommRing K
μ : K
h : IsPrimitiveRoot μ n
inst✝¹ : IsDomain K
inst✝ : CharZero K
m : ℕ
hcop : m.Coprime n
⊢ eval₂ (Int.castRingHom K) (μ ^ m) (minpoly ℤ (μ ^ m)) = 0

tactic: exact minpoly.aeval ℤ (μ ^ m)
state_before: n : ℕ
K : Type u_1
inst✝² : CommRing K
μ : K
h : IsPrimitiveRoot μ n
inst✝¹ : IsDomain K
inst✝ : CharZero K
m : ℕ
hcop : m.Coprime n
⊢ eval₂ (Int.castRingHom K) (μ ^ m) (minpoly ℤ (μ ^ m)) = 0
state_after: no goals
Theorem: Cardinal.ofENat_le_nat
File: Mathlib/SetTheory/Cardinal/ENat.lean

tactic: norm_cast
state_before: m : ℕ∞
n : ℕ
⊢ ↑m ≤ ↑n ↔ m ≤ ↑n
state_after: no goals