tasksource/leandojo huggingface dataset:
Theorem: FinVec.forall_iff
File: Mathlib/Data/Fin/Tuple/Reflection.lean

tactic: simp only [Forall, Fin.forall_fin_zero_pi]
state_before: m n : ℕ
α : Type u_1
β : Type ?u.5607
γ : Type ?u.5610
P : (Fin 0 → α) → Prop
⊢ Forall P ↔ ∀ (x : Fin 0 → α), P x

tactic: rfl
state_before: m n : ℕ
α : Type u_1
β : Type ?u.5607
γ : Type ?u.5610
P : (Fin 0 → α) → Prop
⊢ P ![] ↔ P finZeroElim

tactic: simp only [Forall, forall_iff, Fin.forall_fin_succ_pi, Matrix.vecCons]
state_before: m n✝ : ℕ
α : Type u_1
β : Type ?u.5607
γ : Type ?u.5610
n : ℕ
P : (Fin (Nat.succ n) → α) → Prop
⊢ Forall P ↔ ∀ (x : Fin (Nat.succ n) → α), P x
Theorem: Polynomial.nthRoots_two_eq_zero_iff
File: Mathlib/Data/Polynomial/RingDivision.lean

tactic: simp_rw [isSquare_iff_exists_sq, eq_zero_iff_forall_not_mem, mem_nthRoots (by norm_num : 0 < 2),
  ← not_exists, eq_comm]
state_before: R : Type u
S : Type v
T : Type w
a b : R
n : ℕ
inst✝¹ : CommRing R
inst✝ : IsDomain R
p q : R[X]
r : R
⊢ nthRoots 2 r = 0 ↔ ¬IsSquare r

tactic: norm_num
state_before: R : Type u
S : Type v
T : Type w
a b : R
n : ℕ
inst✝¹ : CommRing R
inst✝ : IsDomain R
p q : R[X]
r : R
⊢ 0 < 2
Theorem: abs_add'
File: Mathlib/Algebra/Order/Group/Abs.lean

tactic: simpa using abs_add (-b) (b + a)
state_before: α : Type u_1
inst✝ : LinearOrderedAddCommGroup α
a✝ b✝ c d a b : α
⊢ abs a ≤ abs b + abs (b + a)
Theorem: Matrix.fromBlocks_zero
File: Mathlib/Data/Matrix/Block.lean

tactic: ext (i j)
state_before: l : Type u_2
m : Type u_3
n : Type u_4
o : Type u_5
p : Type ?u.36307
q : Type ?u.36310
m' : o → Type ?u.36315
n' : o → Type ?u.36320
p' : o → Type ?u.36325
R : Type ?u.36328
S : Type ?u.36331
α : Type u_1
β : Type ?u.36337
inst✝ : Zero α
⊢ fromBlocks 0 0 0 0 = 0

tactic: rcases i with ⟨⟩ <;> rcases j with ⟨⟩ <;> rfl
state_before: case a.h
l : Type u_2
m : Type u_3
n : Type u_4
o : Type u_5
p : Type ?u.36307
q : Type ?u.36310
m' : o → Type ?u.36315
n' : o → Type ?u.36320
p' : o → Type ?u.36325
R : Type ?u.36328
S : Type ?u.36331
α : Type u_1
β : Type ?u.36337
inst✝ : Zero α
i : n ⊕ o
j : l ⊕ m
⊢ fromBlocks 0 0 0 0 i j = OfNat.ofNat 0 i j
Theorem: MeasureTheory.Measure.fst_apply
File: Mathlib/MeasureTheory/Constructions/Prod/Basic.lean

tactic: rw [fst, Measure.map_apply measurable_fst hs]
state_before: α : Type u_1
α' : Type ?u.5370740
β : Type u_2
β' : Type ?u.5370746
γ : Type ?u.5370749
E : Type ?u.5370752
inst✝⁶ : MeasurableSpace α
inst✝⁵ : MeasurableSpace α'
inst✝⁴ : MeasurableSpace β
inst✝³ : MeasurableSpace β'
inst✝² : MeasurableSpace γ
μ μ' : Measure α
ν ν' : Measure β
τ : Measure γ
inst✝¹ : NormedAddCommGroup E
inst✝ : SigmaFinite ν
ρ : Measure (α × β)
s : Set α
hs : MeasurableSet s
⊢ ↑↑(fst ρ) s = ↑↑ρ (Prod.fst ⁻¹' s)
Theorem: Submonoid.mem_iSup_of_directed
File: Mathlib/GroupTheory/Submonoid/Membership.lean

tactic: refine' ⟨_, fun ⟨i, hi⟩ => (SetLike.le_def.1 <| le_iSup S i) hi⟩
state_before: M : Type u_2
A : Type ?u.32885
B : Type ?u.32888
inst✝ : MulOneClass M
ι : Sort u_1
hι : Nonempty ι
S : ι → Submonoid M
hS : Directed (fun x x_1 => x ≤ x_1) S
x : M
⊢ (x ∈ ⨆ (i : ι), S i) ↔ ∃ i, x ∈ S i

tactic: suffices x ∈ closure (⋃ i, (S i : Set M)) → ∃ i, x ∈ S i by
  simpa only [closure_iUnion, closure_eq (S _)] using this
state_before: M : Type u_2
A : Type ?u.32885
B : Type ?u.32888
inst✝ : MulOneClass M
ι : Sort u_1
hι : Nonempty ι
S : ι → Submonoid M
hS : Directed (fun x x_1 => x ≤ x_1) S
x : M
⊢ (x ∈ ⨆ (i : ι), S i) → ∃ i, x ∈ S i

tactic: refine' fun hx => closure_induction hx (fun _ => mem_iUnion.1) _ _
state_before: M : Type u_2
A : Type ?u.32885
B : Type ?u.32888
inst✝ : MulOneClass M
ι : Sort u_1
hι : Nonempty ι
S : ι → Submonoid M
hS : Directed (fun x x_1 => x ≤ x_1) S
x : M
⊢ x ∈ closure (⋃ (i : ι), ↑(S i)) → ∃ i, x ∈ S i

tactic: simpa only [closure_iUnion, closure_eq (S _)] using this
state_before: M : Type u_2
A : Type ?u.32885
B : Type ?u.32888
inst✝ : MulOneClass M
ι : Sort u_1
hι : Nonempty ι
S : ι → Submonoid M
hS : Directed (fun x x_1 => x ≤ x_1) S
x : M
this : x ∈ closure (⋃ (i : ι), ↑(S i)) → ∃ i, x ∈ S i
⊢ (x ∈ ⨆ (i : ι), S i) → ∃ i, x ∈ S i

tactic: exact hι.elim fun i => ⟨i, (S i).one_mem⟩
state_before: case refine'_1
M : Type u_2
A : Type ?u.32885
B : Type ?u.32888
inst✝ : MulOneClass M
ι : Sort u_1
hι : Nonempty ι
S : ι → Submonoid M
hS : Directed (fun x x_1 => x ≤ x_1) S
x : M
hx : x ∈ closure (⋃ (i : ι), ↑(S i))
⊢ ∃ i, 1 ∈ S i

tactic: rintro x y ⟨i, hi⟩ ⟨j, hj⟩
state_before: case refine'_2
M : Type u_2
A : Type ?u.32885
B : Type ?u.32888
inst✝ : MulOneClass M
ι : Sort u_1
hι : Nonempty ι
S : ι → Submonoid M
hS : Directed (fun x x_1 => x ≤ x_1) S
x : M
hx : x ∈ closure (⋃ (i : ι), ↑(S i))
⊢ ∀ (x y : M), (∃ i, x ∈ S i) → (∃ i, y ∈ S i) → ∃ i, x * y ∈ S i

tactic: rcases hS i j with ⟨k, hki, hkj⟩
state_before: case refine'_2.intro.intro
M : Type u_2
A : Type ?u.32885
B : Type ?u.32888
inst✝ : MulOneClass M
ι : Sort u_1
hι : Nonempty ι
S : ι → Submonoid M
hS : Directed (fun x x_1 => x ≤ x_1) S
x✝ : M
hx : x✝ ∈ closure (⋃ (i : ι), ↑(S i))
x y : M
i : ι
hi : x ∈ S i
j : ι
hj : y ∈ S j
⊢ ∃ i, x * y ∈ S i

tactic: exact ⟨k, (S k).mul_mem (hki hi) (hkj hj)⟩
state_before: case refine'_2.intro.intro.intro.intro
M : Type u_2
A : Type ?u.32885
B : Type ?u.32888
inst✝ : MulOneClass M
ι : Sort u_1
hι : Nonempty ι
S : ι → Submonoid M
hS : Directed (fun x x_1 => x ≤ x_1) S
x✝ : M
hx : x✝ ∈ closure (⋃ (i : ι), ↑(S i))
x y : M
i : ι
hi : x ∈ S i
j : ι
hj : y ∈ S j
k : ι
hki : S i ≤ S k
hkj : S j ≤ S k
⊢ ∃ i, x * y ∈ S i
Theorem: StrictMono.prod_map
File: Mathlib/Order/Monotone/Basic.lean

tactic: simp only [Prod.lt_iff]
state_before: ι : Type ?u.47834
α : Type u
β : Type v
γ : Type w
δ : Type u_1
π : ι → Type ?u.47848
r : α → α → Prop
inst✝³ : PartialOrder α
inst✝² : PartialOrder β
inst✝¹ : Preorder γ
inst✝ : Preorder δ
f : α → γ
g : β → δ
hf : StrictMono f
hg : StrictMono g
a b : α × β
⊢ a < b → Prod.map f g a < Prod.map f g b

tactic: exact Or.imp (And.imp hf.imp hg.monotone.imp) (And.imp hf.monotone.imp hg.imp)
state_before: ι : Type ?u.47834
α : Type u
β : Type v
γ : Type w
δ : Type u_1
π : ι → Type ?u.47848
r : α → α → Prop
inst✝³ : PartialOrder α
inst✝² : PartialOrder β
inst✝¹ : Preorder γ
inst✝ : Preorder δ
f : α → γ
g : β → δ
hf : StrictMono f
hg : StrictMono g
a b : α × β
⊢ a.fst < b.fst ∧ a.snd ≤ b.snd ∨ a.fst ≤ b.fst ∧ a.snd < b.snd →
    (Prod.map f g a).fst < (Prod.map f g b).fst ∧ (Prod.map f g a).snd ≤ (Prod.map f g b).snd ∨
      (Prod.map f g a).fst ≤ (Prod.map f g b).fst ∧ (Prod.map f g a).snd < (Prod.map f g b).snd
Theorem: StarAlgHom.snd_prod
File: Mathlib/Algebra/Star/StarAlgHom.lean

tactic: ext
state_before: R : Type u_1
A : Type u_2
B : Type u_3
C : Type u_4
inst✝⁹ : CommSemiring R
inst✝⁸ : Semiring A
inst✝⁷ : Algebra R A
inst✝⁶ : Star A
inst✝⁵ : Semiring B
inst✝⁴ : Algebra R B
inst✝³ : Star B
inst✝² : Semiring C
inst✝¹ : Algebra R C
inst✝ : Star C
f : A →⋆ₐ[R] B
g : A →⋆ₐ[R] C
⊢ comp (snd R B C) (prod f g) = g

tactic: rfl
state_before: case h
R : Type u_1
A : Type u_2
B : Type u_3
C : Type u_4
inst✝⁹ : CommSemiring R
inst✝⁸ : Semiring A
inst✝⁷ : Algebra R A
inst✝⁶ : Star A
inst✝⁵ : Semiring B
inst✝⁴ : Algebra R B
inst✝³ : Star B
inst✝² : Semiring C
inst✝¹ : Algebra R C
inst✝ : Star C
f : A →⋆ₐ[R] B
g : A →⋆ₐ[R] C
x✝ : A
⊢ ↑(comp (snd R B C) (prod f g)) x✝ = ↑g x✝
Theorem: DirectSum.sum_support_decompose
File: Mathlib/Algebra/DirectSum/Decomposition.lean

tactic: conv_rhs =>
  rw [← (decompose ℳ).symm_apply_apply r, ← sum_support_of (fun i ↦ ℳ i) (decompose ℳ r)]
state_before: ι : Type u_3
R : Type ?u.193623
M : Type u_1
σ : Type u_2
inst✝⁵ : DecidableEq ι
inst✝⁴ : AddCommMonoid M
inst✝³ : SetLike σ M
inst✝² : AddSubmonoidClass σ M
ℳ : ι → σ
inst✝¹ : Decomposition ℳ
inst✝ : (i : ι) → (x : { x // x ∈ ℳ i }) → Decidable (x ≠ 0)
r : M
⊢ ∑ i in Dfinsupp.support (↑(decompose ℳ) r), ↑(↑(↑(decompose ℳ) r) i) = r

tactic: rw [decompose_symm_sum]
state_before: ι : Type u_3
R : Type ?u.193623
M : Type u_1
σ : Type u_2
inst✝⁵ : DecidableEq ι
inst✝⁴ : AddCommMonoid M
inst✝³ : SetLike σ M
inst✝² : AddSubmonoidClass σ M
ℳ : ι → σ
inst✝¹ : Decomposition ℳ
inst✝ : (i : ι) → (x : { x // x ∈ ℳ i }) → Decidable (x ≠ 0)
r : M
⊢ ∑ i in Dfinsupp.support (↑(decompose ℳ) r), ↑(↑(↑(decompose ℳ) r) i) =
    ↑(decompose ℳ).symm
      (∑ i in Dfinsupp.support (↑(decompose ℳ) r), ↑(of (fun i => { x // x ∈ ℳ i }) i) (↑(↑(decompose ℳ) r) i))

tactic: simp_rw [decompose_symm_of]
state_before: ι : Type u_3
R : Type ?u.193623
M : Type u_1
σ : Type u_2
inst✝⁵ : DecidableEq ι
inst✝⁴ : AddCommMonoid M
inst✝³ : SetLike σ M
inst✝² : AddSubmonoidClass σ M
ℳ : ι → σ
inst✝¹ : Decomposition ℳ
inst✝ : (i : ι) → (x : { x // x ∈ ℳ i }) → Decidable (x ≠ 0)
r : M
⊢ ∑ i in Dfinsupp.support (↑(decompose ℳ) r), ↑(↑(↑(decompose ℳ) r) i) =
    ∑ i in Dfinsupp.support (↑(decompose ℳ) r),
      ↑(decompose ℳ).symm (↑(of (fun i => { x // x ∈ ℳ i }) i) (↑(↑(decompose ℳ) r) i))
Theorem: AlgebraicTopology.DoldKan.Γ₀.Obj.Termwise.mapMono_δ₀
File: Mathlib/AlgebraicTopology/DoldKan/FunctorGamma.lean

tactic: rw [Isδ₀.iff]
state_before: C : Type u_2
inst✝¹ : Category C
inst✝ : Preadditive C
K K' : ChainComplex C ℕ
f : K ⟶ K'
Δ Δ' Δ'' : SimplexCategory
n : ℕ
⊢ Isδ₀ (SimplexCategory.δ 0)
Theorem: LocalRing.of_unique_nonzero_prime
File: Mathlib/RingTheory/Ideal/LocalRing.lean

tactic: rcases h with ⟨P, ⟨hPnonzero, hPnot_top, _⟩, hPunique⟩
state_before: R : Type u
S : Type v
T : Type w
K : Type u'
inst✝ : CommSemiring R
h : ∃! P, P ≠ ⊥ ∧ Ideal.IsPrime P
⊢ ∃! I, Ideal.IsMaximal I

tactic: refine' ⟨P, ⟨⟨hPnot_top, _⟩⟩, fun M hM => hPunique _ ⟨_, Ideal.IsMaximal.isPrime hM⟩⟩
state_before: case intro.intro.intro.mk
R : Type u
S : Type v
T : Type w
K : Type u'
inst✝ : CommSemiring R
P : Ideal R
hPunique : ∀ (y : Ideal R), (fun P => P ≠ ⊥ ∧ Ideal.IsPrime P) y → y = P
hPnonzero : P ≠ ⊥
hPnot_top : P ≠ ⊤
mem_or_mem'✝ : ∀ {x y : R}, x * y ∈ P → x ∈ P ∨ y ∈ P
⊢ ∃! I, Ideal.IsMaximal I

tactic: refine' Ideal.maximal_of_no_maximal fun M hPM hM => ne_of_lt hPM _
state_before: case intro.intro.intro.mk.refine'_1
R : Type u
S : Type v
T : Type w
K : Type u'
inst✝ : CommSemiring R
P : Ideal R
hPunique : ∀ (y : Ideal R), (fun P => P ≠ ⊥ ∧ Ideal.IsPrime P) y → y = P
hPnonzero : P ≠ ⊥
hPnot_top : P ≠ ⊤
mem_or_mem'✝ : ∀ {x y : R}, x * y ∈ P → x ∈ P ∨ y ∈ P
⊢ ∀ (b : Ideal R), P < b → b = ⊤

tactic: exact (hPunique _ ⟨ne_bot_of_gt hPM, Ideal.IsMaximal.isPrime hM⟩).symm
state_before: case intro.intro.intro.mk.refine'_1
R : Type u
S : Type v
T : Type w
K : Type u'
inst✝ : CommSemiring R
P : Ideal R
hPunique : ∀ (y : Ideal R), (fun P => P ≠ ⊥ ∧ Ideal.IsPrime P) y → y = P
hPnonzero : P ≠ ⊥
hPnot_top : P ≠ ⊤
mem_or_mem'✝ : ∀ {x y : R}, x * y ∈ P → x ∈ P ∨ y ∈ P
M : Ideal R
hPM : P < M
hM : Ideal.IsMaximal M
⊢ P = M

tactic: rintro rfl
state_before: case intro.intro.intro.mk.refine'_2
R : Type u
S : Type v
T : Type w
K : Type u'
inst✝ : CommSemiring R
P : Ideal R
hPunique : ∀ (y : Ideal R), (fun P => P ≠ ⊥ ∧ Ideal.IsPrime P) y → y = P
hPnonzero : P ≠ ⊥
hPnot_top : P ≠ ⊤
mem_or_mem'✝ : ∀ {x y : R}, x * y ∈ P → x ∈ P ∨ y ∈ P
M : Ideal R
hM : (fun I => Ideal.IsMaximal I) M
⊢ M ≠ ⊥

tactic: exact hPnot_top (hM.1.2 P (bot_lt_iff_ne_bot.2 hPnonzero))
state_before: case intro.intro.intro.mk.refine'_2
R : Type u
S : Type v
T : Type w
K : Type u'
inst✝ : CommSemiring R
P : Ideal R
hPunique : ∀ (y : Ideal R), (fun P => P ≠ ⊥ ∧ Ideal.IsPrime P) y → y = P
hPnonzero : P ≠ ⊥
hPnot_top : P ≠ ⊤
mem_or_mem'✝ : ∀ {x y : R}, x * y ∈ P → x ∈ P ∨ y ∈ P
hM : Ideal.IsMaximal ⊥
⊢ False
Theorem: Mathlib.Tactic.Ring.pow_bit1
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 : R
k : ℕ
b c d : R
x✝² : a ^ k = b
x✝¹ : b * b = c
x✝ : c * a = d
⊢ a ^ Nat.add (Nat.mul 2 k) 1 = d

tactic: simp [Nat.succ_mul, pow_add]
state_before: u : Lean.Level
R : Type u_1
α : Q(Type u)
sα : Q(CommSemiring «$α»)
inst✝ : CommSemiring R
a : R
k : ℕ
⊢ a ^ Nat.add (Nat.mul 2 k) 1 = a ^ k * a ^ k * a
Theorem: SemidirectProduct.inl_aut_inv
File: Mathlib/GroupTheory/SemidirectProduct.lean

tactic: rw [← MonoidHom.map_inv, inl_aut, inv_inv]
state_before: N : Type u_1
G : Type u_2
H : Type ?u.83486
inst✝² : Group N
inst✝¹ : Group G
inst✝ : Group H
φ : G →* MulAut N
g : G
n : N
⊢ ↑inl (↑(↑φ g)⁻¹ n) = ↑inr g⁻¹ * ↑inl n * ↑inr g
Theorem: ContinuousLinearEquiv.comp_hasFDerivWithinAt_iff'
File: Mathlib/Analysis/Calculus/FDeriv/Equiv.lean

tactic: rw [← iso.comp_hasFDerivWithinAt_iff, ← ContinuousLinearMap.comp_assoc, iso.coe_comp_coe_symm,
  ContinuousLinearMap.id_comp]
state_before: 𝕜 : Type u_2
inst✝⁸ : NontriviallyNormedField 𝕜
E : Type u_4
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type u_3
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type u_1
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
G' : Type ?u.118107
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
iso : E ≃L[𝕜] F
f : G → E
s : Set G
x : G
f' : G →L[𝕜] F
⊢ HasFDerivWithinAt (↑iso ∘ f) f' s x ↔ HasFDerivWithinAt f (comp (↑(ContinuousLinearEquiv.symm iso)) f') s x
Theorem: DirectSum.coe_of_apply
File: Mathlib/Algebra/DirectSum/Basic.lean

tactic: obtain rfl | h := Decidable.eq_or_ne i j
state_before: ι : Type v
dec_ι : DecidableEq ι
β : ι → Type w
inst✝⁵ : (i : ι) → AddCommMonoid (β i)
γ : Type u₁
inst✝⁴ : AddCommMonoid γ
M : Type u_1
S : Type u_2
inst✝³ : DecidableEq ι
inst✝² : AddCommMonoid M
inst✝¹ : SetLike S M
inst✝ : AddSubmonoidClass S M
A : ι → S
i j : ι
x : { x // x ∈ A i }
⊢ ↑(↑(↑(of (fun i => { x // x ∈ A i }) i) x) j) = ↑(if i = j then x else 0)

tactic: rw [DirectSum.of_eq_same, if_pos rfl]
state_before: case inl
ι : Type v
dec_ι : DecidableEq ι
β : ι → Type w
inst✝⁵ : (i : ι) → AddCommMonoid (β i)
γ : Type u₁
inst✝⁴ : AddCommMonoid γ
M : Type u_1
S : Type u_2
inst✝³ : DecidableEq ι
inst✝² : AddCommMonoid M
inst✝¹ : SetLike S M
inst✝ : AddSubmonoidClass S M
A : ι → S
i : ι
x : { x // x ∈ A i }
⊢ ↑(↑(↑(of (fun i => { x // x ∈ A i }) i) x) i) = ↑(if i = i then x else 0)

tactic: rw [DirectSum.of_eq_of_ne _ _ _ _ h, if_neg h, ZeroMemClass.coe_zero, ZeroMemClass.coe_zero]
state_before: case inr
ι : Type v
dec_ι : DecidableEq ι
β : ι → Type w
inst✝⁵ : (i : ι) → AddCommMonoid (β i)
γ : Type u₁
inst✝⁴ : AddCommMonoid γ
M : Type u_1
S : Type u_2
inst✝³ : DecidableEq ι
inst✝² : AddCommMonoid M
inst✝¹ : SetLike S M
inst✝ : AddSubmonoidClass S M
A : ι → S
i j : ι
x : { x // x ∈ A i }
h : i ≠ j
⊢ ↑(↑(↑(of (fun i => { x // x ∈ A i }) i) x) j) = ↑(if i = j then x else 0)
Theorem: Polynomial.degree_cyclotomic
File: Mathlib/RingTheory/Polynomial/Cyclotomic/Basic.lean

tactic: rw [← map_cyclotomic_int]
state_before: n : ℕ
R : Type u_1
inst✝¹ : Ring R
inst✝ : Nontrivial R
⊢ degree (cyclotomic n R) = ↑(Nat.totient n)

tactic: rw [degree_map_eq_of_leadingCoeff_ne_zero (Int.castRingHom R) _]
state_before: n : ℕ
R : Type u_1
inst✝¹ : Ring R
inst✝ : Nontrivial R
⊢ degree (map (Int.castRingHom R) (cyclotomic n ℤ)) = ↑(Nat.totient n)

tactic: simp only [(int_cyclotomic_spec n).right.right, eq_intCast, Monic.leadingCoeff, Int.cast_one,
  Ne.def, not_false_iff, one_ne_zero]
state_before: n : ℕ
R : Type u_1
inst✝¹ : Ring R
inst✝ : Nontrivial R
⊢ ↑(Int.castRingHom R) (leadingCoeff (cyclotomic n ℤ)) ≠ 0

tactic: cases' n with k
state_before: n : ℕ
R : Type u_1
inst✝¹ : Ring R
inst✝ : Nontrivial R
⊢ degree (cyclotomic n ℤ) = ↑(Nat.totient n)

tactic: rw [← degree_cyclotomic' (Complex.isPrimitiveRoot_exp k.succ (Nat.succ_ne_zero k))]
state_before: case succ
R : Type u_1
inst✝¹ : Ring R
inst✝ : Nontrivial R
k : ℕ
⊢ degree (cyclotomic (Nat.succ k) ℤ) = ↑(Nat.totient (Nat.succ k))

tactic: exact (int_cyclotomic_spec k.succ).2.1
state_before: case succ
R : Type u_1
inst✝¹ : Ring R
inst✝ : Nontrivial R
k : ℕ
⊢ degree (cyclotomic (Nat.succ k) ℤ) = degree (cyclotomic' (Nat.succ k) ℂ)

tactic: simp only [cyclotomic, degree_one, dif_pos, Nat.totient_zero, WithTop.coe_zero]
state_before: case zero
R : Type u_1
inst✝¹ : Ring R
inst✝ : Nontrivial R
⊢ degree (cyclotomic Nat.zero ℤ) = ↑(Nat.totient Nat.zero)
Theorem: Finset.pimage_subset
File: Mathlib/Data/Finset/PImage.lean

tactic: simp [subset_iff, @forall_swap _ β]
state_before: α : Type u_2
β : Type u_1
inst✝² : DecidableEq β
f g : α →. β
inst✝¹ : (x : α) → Decidable (f x).Dom
inst✝ : (x : α) → Decidable (g x).Dom
s t✝ : Finset α
b : β
t : Finset β
⊢ pimage f s ⊆ t ↔ ∀ (x : α), x ∈ s → ∀ (y : β), y ∈ f x → y ∈ t
Theorem: Complex.exp_add_mul_I
File: Mathlib/Data/Complex/Exponential.lean

tactic: rw [exp_add, exp_mul_I]
state_before: x y : ℂ
⊢ exp (x + y * I) = exp x * (cos y + sin y * I)
Theorem: Finset.image₂_image_left
File: Mathlib/Data/Finset/NAry.lean

tactic: push_cast
state_before: α : Type u_4
α' : Type ?u.59914
β : Type u_3
β' : Type ?u.59920
γ : Type u_2
γ' : Type ?u.59926
δ : Type u_1
δ' : Type ?u.59932
ε : Type ?u.59935
ε' : Type ?u.59938
ζ : Type ?u.59941
ζ' : Type ?u.59944
ν : Type ?u.59947
inst✝⁷ : DecidableEq α'
inst✝⁶ : DecidableEq β'
inst✝⁵ : DecidableEq γ
inst✝⁴ : DecidableEq γ'
inst✝³ : DecidableEq δ
inst✝² : DecidableEq δ'
inst✝¹ : DecidableEq ε
inst✝ : DecidableEq ε'
f✝ f' : α → β → γ
g✝ g' : α → β → γ → δ
s s' : Finset α
t t' : Finset β
u u' : Finset γ
a a' : α
b b' : β
c : γ
f : γ → β → δ
g : α → γ
⊢ ↑(image₂ f (image g s) t) = ↑(image₂ (fun a b => f (g a) b) s t)

tactic: exact image2_image_left _ _
state_before: α : Type u_4
α' : Type ?u.59914
β : Type u_3
β' : Type ?u.59920
γ : Type u_2
γ' : Type ?u.59926
δ : Type u_1
δ' : Type ?u.59932
ε : Type ?u.59935
ε' : Type ?u.59938
ζ : Type ?u.59941
ζ' : Type ?u.59944
ν : Type ?u.59947
inst✝⁷ : DecidableEq α'
inst✝⁶ : DecidableEq β'
inst✝⁵ : DecidableEq γ
inst✝⁴ : DecidableEq γ'
inst✝³ : DecidableEq δ
inst✝² : DecidableEq δ'
inst✝¹ : DecidableEq ε
inst✝ : DecidableEq ε'
f✝ f' : α → β → γ
g✝ g' : α → β → γ → δ
s s' : Finset α
t t' : Finset β
u u' : Finset γ
a a' : α
b b' : β
c : γ
f : γ → β → δ
g : α → γ
⊢ image2 f (g '' ↑s) ↑t = image2 (fun a b => f (g a) b) ↑s ↑t
Theorem: CategoryTheory.CostructuredArrow.unop_left_comp_ofMkLEMk_unop
File: Mathlib/CategoryTheory/Subobject/Comma.lean

tactic: conv_lhs =>
  congr
  rw [← Quiver.Hom.unop_op g.unop.left]
state_before: C : Type u₁
inst✝³ : Category C
D : Type u₂
inst✝² : Category D
S : C ⥤ D
T : D
A : CostructuredArrow S T
P Q : (CostructuredArrow S T)ᵒᵖ
f : P ⟶ A.op
g : Q ⟶ A.op
inst✝¹ : Mono f.unop.left.op
inst✝ : Mono g.unop.left.op
h : Subobject.mk f.unop.left.op ≤ Subobject.mk g.unop.left.op
⊢ g.unop.left ≫ (Subobject.ofMkLEMk f.unop.left.op g.unop.left.op h).unop = f.unop.left

tactic: rw [← unop_comp]
state_before: C : Type u₁
inst✝³ : Category C
D : Type u₂
inst✝² : Category D
S : C ⥤ D
T : D
A : CostructuredArrow S T
P Q : (CostructuredArrow S T)ᵒᵖ
f : P ⟶ A.op
g : Q ⟶ A.op
inst✝¹ : Mono f.unop.left.op
inst✝ : Mono g.unop.left.op
h : Subobject.mk f.unop.left.op ≤ Subobject.mk g.unop.left.op
⊢ g.unop.left.op.unop ≫ (Subobject.ofMkLEMk f.unop.left.op g.unop.left.op h).unop = f.unop.left

tactic: simp only [Subobject.ofMkLEMk_comp, Quiver.Hom.unop_op]
state_before: C : Type u₁
inst✝³ : Category C
D : Type u₂
inst✝² : Category D
S : C ⥤ D
T : D
A : CostructuredArrow S T
P Q : (CostructuredArrow S T)ᵒᵖ
f : P ⟶ A.op
g : Q ⟶ A.op
inst✝¹ : Mono f.unop.left.op
inst✝ : Mono g.unop.left.op
h : Subobject.mk f.unop.left.op ≤ Subobject.mk g.unop.left.op
⊢ (Subobject.ofMkLEMk f.unop.left.op g.unop.left.op h ≫ g.unop.left.op).unop = f.unop.left
Theorem: smul_neg
File: Mathlib/GroupTheory/GroupAction/Defs.lean

tactic: rw [← smul_add, neg_add_self, smul_zero]
state_before: M : Type u_2
N : Type ?u.62017
G : Type ?u.62020
A : Type u_1
B : Type ?u.62026
α : Type ?u.62029
β : Type ?u.62032
γ : Type ?u.62035
δ : Type ?u.62038
inst✝² : Monoid M
inst✝¹ : AddGroup A
inst✝ : DistribMulAction M A
r : M
x : A
⊢ r • -x + r • x = 0
Theorem: NNReal.summable_one_div_rpow
File: Mathlib/Analysis/PSeries.lean

tactic: simp
state_before: p : ℝ
⊢ (Summable fun n => 1 / ↑n ^ p) ↔ 1 < p
Theorem: Real.inner_le_Lp_mul_Lq_of_nonneg
File: Mathlib/Analysis/MeanInequalities.lean

tactic: convert inner_le_Lp_mul_Lq s f g hpq using 3 <;> apply sum_congr rfl <;> intro i hi <;>
  simp only [abs_of_nonneg, hf i hi, hg i hi]
state_before: ι : Type u
s : Finset ι
f g : ι → ℝ
p q : ℝ
hpq : IsConjugateExponent p q
hf : ∀ (i : ι), i ∈ s → 0 ≤ f i
hg : ∀ (i : ι), i ∈ s → 0 ≤ g i
⊢ ∑ i in s, f i * g i ≤ (∑ i in s, f i ^ p) ^ (1 / p) * (∑ i in s, g i ^ q) ^ (1 / q)
Theorem: coe_inv_circle_eq_conj
File: Mathlib/Analysis/Complex/Circle.lean

tactic: rw [coe_inv_circle, inv_def, normSq_eq_of_mem_circle, inv_one, ofReal_one, mul_one]
state_before: z : { x // x ∈ circle }
⊢ ↑z⁻¹ = ↑(starRingEnd ℂ) ↑z
Theorem: Int.sub_floor_div_mul_lt
File: Mathlib/Algebra/Order/Floor.lean

tactic: rw [← one_add_mul _ b, ← div_lt_iff hb, add_comm]
state_before: F : Type ?u.186509
α : Type ?u.186512
β : Type ?u.186515
inst✝³ : LinearOrderedRing α
inst✝² : FloorRing α
z : ℤ
a✝ : α
k : Type u_1
inst✝¹ : LinearOrderedField k
inst✝ : FloorRing k
b a : k
hb : 0 < b
⊢ a < b + ↑⌊a / b⌋ * b

tactic: exact lt_floor_add_one _
state_before: F : Type ?u.186509
α : Type ?u.186512
β : Type ?u.186515
inst✝³ : LinearOrderedRing α
inst✝² : FloorRing α
z : ℤ
a✝ : α
k : Type u_1
inst✝¹ : LinearOrderedField k
inst✝ : FloorRing k
b a : k
hb : 0 < b
⊢ a / b < ↑⌊a / b⌋ + 1
Theorem: Prod.covby_iff
File: Mathlib/Order/Cover.lean

tactic: cases x
state_before: α : Type u_1
β : Type u_2
inst✝¹ : PartialOrder α
inst✝ : PartialOrder β
a a₁ a₂ : α
b b₁ b₂ : β
x y : α × β
⊢ x ⋖ y ↔ x.fst ⋖ y.fst ∧ x.snd = y.snd ∨ x.snd ⋖ y.snd ∧ x.fst = y.fst

tactic: cases y
state_before: case mk
α : Type u_1
β : Type u_2
inst✝¹ : PartialOrder α
inst✝ : PartialOrder β
a a₁ a₂ : α
b b₁ b₂ : β
y : α × β
fst✝ : α
snd✝ : β
⊢ (fst✝, snd✝) ⋖ y ↔
    (fst✝, snd✝).fst ⋖ y.fst ∧ (fst✝, snd✝).snd = y.snd ∨ (fst✝, snd✝).snd ⋖ y.snd ∧ (fst✝, snd✝).fst = y.fst

tactic: exact mk_covby_mk_iff
state_before: case mk.mk
α : Type u_1
β : Type u_2
inst✝¹ : PartialOrder α
inst✝ : PartialOrder β
a a₁ a₂ : α
b b₁ b₂ : β
fst✝¹ : α
snd✝¹ : β
fst✝ : α
snd✝ : β
⊢ (fst✝¹, snd✝¹) ⋖ (fst✝, snd✝) ↔
    (fst✝¹, snd✝¹).fst ⋖ (fst✝, snd✝).fst ∧ (fst✝¹, snd✝¹).snd = (fst✝, snd✝).snd ∨
      (fst✝¹, snd✝¹).snd ⋖ (fst✝, snd✝).snd ∧ (fst✝¹, snd✝¹).fst = (fst✝, snd✝).fst
Theorem: nilpotent_iff_finite_ascending_central_series
File: Mathlib/GroupTheory/Nilpotent.lean

tactic: constructor
state_before: G : Type u_1
inst✝¹ : Group G
H : Subgroup G
inst✝ : Normal H
⊢ Group.IsNilpotent G ↔ ∃ n H, IsAscendingCentralSeries H ∧ H n = ⊤

tactic: rintro ⟨n, nH⟩
state_before: case mp
G : Type u_1
inst✝¹ : Group G
H : Subgroup G
inst✝ : Normal H
⊢ Group.IsNilpotent G → ∃ n H, IsAscendingCentralSeries H ∧ H n = ⊤

tactic: refine' ⟨_, _, upperCentralSeries_isAscendingCentralSeries G, nH⟩
state_before: case mp.mk.intro
G : Type u_1
inst✝¹ : Group G
H : Subgroup G
inst✝ : Normal H
n : ℕ
nH : upperCentralSeries G n = ⊤
⊢ ∃ n H, IsAscendingCentralSeries H ∧ H n = ⊤

tactic: rintro ⟨n, H, hH, hn⟩
state_before: case mpr
G : Type u_1
inst✝¹ : Group G
H : Subgroup G
inst✝ : Normal H
⊢ (∃ n H, IsAscendingCentralSeries H ∧ H n = ⊤) → Group.IsNilpotent G

tactic: use n
state_before: case mpr.intro.intro.intro
G : Type u_1
inst✝¹ : Group G
H✝ : Subgroup G
inst✝ : Normal H✝
n : ℕ
H : ℕ → Subgroup G
hH : IsAscendingCentralSeries H
hn : H n = ⊤
⊢ Group.IsNilpotent G

tactic: rw [eq_top_iff, ← hn]
state_before: case mpr.intro.intro.intro
G : Type u_1
inst✝¹ : Group G
H✝ : Subgroup G
inst✝ : Normal H✝
n : ℕ
H : ℕ → Subgroup G
hH : IsAscendingCentralSeries H
hn : H n = ⊤
⊢ upperCentralSeries G n = ⊤

tactic: exact ascending_central_series_le_upper H hH n
state_before: case mpr.intro.intro.intro
G : Type u_1
inst✝¹ : Group G
H✝ : Subgroup G
inst✝ : Normal H✝
n : ℕ
H : ℕ → Subgroup G
hH : IsAscendingCentralSeries H
hn : H n = ⊤
⊢ H n ≤ upperCentralSeries G n