tasksource/leandojo huggingface dataset:
Theorem: Metric.mem_ball_comm
File: Mathlib/Topology/MetricSpace/Basic.lean

tactic: rw [mem_ball', mem_ball]
state_before: α : Type u
β : Type v
X : Type ?u.38658
ι : Type ?u.38661
inst✝ : PseudoMetricSpace α
x y z : α
δ ε ε₁ ε₂ : ℝ
s : Set α
⊢ x ∈ ball y ε ↔ y ∈ ball x ε
Theorem: SMulCommClass.of_mclosure_eq_top
File: Mathlib/GroupTheory/Submonoid/Membership.lean

tactic: refine' ⟨fun x => Submonoid.induction_of_closure_eq_top_left htop x _ _⟩
state_before: M : Type u_3
A : Type ?u.240612
B : Type ?u.240615
N : Type u_1
α : Type u_2
inst✝² : Monoid M
inst✝¹ : SMul N α
inst✝ : MulAction M α
s : Set M
htop : Submonoid.closure s = ⊤
hs : ∀ (x : M), x ∈ s → ∀ (y : N) (z : α), x • y • z = y • x • z
⊢ SMulCommClass M N α

tactic: intro y z
state_before: case refine'_1
M : Type u_3
A : Type ?u.240612
B : Type ?u.240615
N : Type u_1
α : Type u_2
inst✝² : Monoid M
inst✝¹ : SMul N α
inst✝ : MulAction M α
s : Set M
htop : Submonoid.closure s = ⊤
hs : ∀ (x : M), x ∈ s → ∀ (y : N) (z : α), x • y • z = y • x • z
x : M
⊢ ∀ (n : N) (a : α), 1 • n • a = n • 1 • a

tactic: rw [one_smul, one_smul]
state_before: case refine'_1
M : Type u_3
A : Type ?u.240612
B : Type ?u.240615
N : Type u_1
α : Type u_2
inst✝² : Monoid M
inst✝¹ : SMul N α
inst✝ : MulAction M α
s : Set M
htop : Submonoid.closure s = ⊤
hs : ∀ (x : M), x ∈ s → ∀ (y : N) (z : α), x • y • z = y • x • z
x : M
y : N
z : α
⊢ 1 • y • z = y • 1 • z

tactic: clear x
state_before: case refine'_2
M : Type u_3
A : Type ?u.240612
B : Type ?u.240615
N : Type u_1
α : Type u_2
inst✝² : Monoid M
inst✝¹ : SMul N α
inst✝ : MulAction M α
s : Set M
htop : Submonoid.closure s = ⊤
hs : ∀ (x : M), x ∈ s → ∀ (y : N) (z : α), x • y • z = y • x • z
x : M
⊢ ∀ (x : M),
    x ∈ s → ∀ (y : M), (∀ (n : N) (a : α), y • n • a = n • y • a) → ∀ (n : N) (a : α), (x * y) • n • a = n • (x * y) • a

tactic: intro x hx x' hx' y z
state_before: case refine'_2
M : Type u_3
A : Type ?u.240612
B : Type ?u.240615
N : Type u_1
α : Type u_2
inst✝² : Monoid M
inst✝¹ : SMul N α
inst✝ : MulAction M α
s : Set M
htop : Submonoid.closure s = ⊤
hs : ∀ (x : M), x ∈ s → ∀ (y : N) (z : α), x • y • z = y • x • z
⊢ ∀ (x : M),
    x ∈ s → ∀ (y : M), (∀ (n : N) (a : α), y • n • a = n • y • a) → ∀ (n : N) (a : α), (x * y) • n • a = n • (x * y) • a

tactic: rw [mul_smul, mul_smul, hx', hs x hx]
state_before: case refine'_2
M : Type u_3
A : Type ?u.240612
B : Type ?u.240615
N : Type u_1
α : Type u_2
inst✝² : Monoid M
inst✝¹ : SMul N α
inst✝ : MulAction M α
s : Set M
htop : Submonoid.closure s = ⊤
hs : ∀ (x : M), x ∈ s → ∀ (y : N) (z : α), x • y • z = y • x • z
x : M
hx : x ∈ s
x' : M
hx' : ∀ (n : N) (a : α), x' • n • a = n • x' • a
y : N
z : α
⊢ (x * x') • y • z = y • (x * x') • z
Theorem: List.cycleType_formPerm
File: Mathlib/GroupTheory/Perm/Cycle/Concrete.lean

tactic: rw [← length_attach] at hn
state_before: α : Type u_1
inst✝ : DecidableEq α
l l' : List α
hl : Nodup l
hn : 2 ≤ length l
⊢ cycleType (formPerm (attach l)) = {length l}

tactic: rw [← nodup_attach] at hl
state_before: α : Type u_1
inst✝ : DecidableEq α
l l' : List α
hl : Nodup l
hn : 2 ≤ length (attach l)
⊢ cycleType (formPerm (attach l)) = {length l}

tactic: rw [cycleType_eq [l.attach.formPerm]]
state_before: α : Type u_1
inst✝ : DecidableEq α
l l' : List α
hl : Nodup (attach l)
hn : 2 ≤ length (attach l)
⊢ cycleType (formPerm (attach l)) = {length l}

tactic: simp only [map, Function.comp_apply]
state_before: α : Type u_1
inst✝ : DecidableEq α
l l' : List α
hl : Nodup (attach l)
hn : 2 ≤ length (attach l)
⊢ ↑(map (Finset.card ∘ support) [formPerm (attach l)]) = {length l}

tactic: rw [support_formPerm_of_nodup _ hl, card_toFinset, dedup_eq_self.mpr hl]
state_before: α : Type u_1
inst✝ : DecidableEq α
l l' : List α
hl : Nodup (attach l)
hn : 2 ≤ length (attach l)
⊢ ↑[Finset.card (support (formPerm (attach l)))] = {length l}

tactic: simp
state_before: α : Type u_1
inst✝ : DecidableEq α
l l' : List α
hl : Nodup (attach l)
hn : 2 ≤ length (attach l)
⊢ ↑[length (attach l)] = {length l}

tactic: intro x h
state_before: α : Type u_1
inst✝ : DecidableEq α
l l' : List α
hl : Nodup (attach l)
hn : 2 ≤ length (attach l)
⊢ ∀ (x : { x // x ∈ l }), attach l ≠ [x]

tactic: simp [h, Nat.succ_le_succ_iff] at hn
state_before: α : Type u_1
inst✝ : DecidableEq α
l l' : List α
hl : Nodup (attach l)
hn : 2 ≤ length (attach l)
x : { x // x ∈ l }
h : attach l = [x]
⊢ False

tactic: simp
state_before: case h0
α : Type u_1
inst✝ : DecidableEq α
l l' : List α
hl : Nodup (attach l)
hn : 2 ≤ length (attach l)
⊢ prod [formPerm (attach l)] = formPerm (attach l)

tactic: simpa using isCycle_formPerm hl hn
state_before: case h1
α : Type u_1
inst✝ : DecidableEq α
l l' : List α
hl : Nodup (attach l)
hn : 2 ≤ length (attach l)
⊢ ∀ (σ : Equiv.Perm { x // x ∈ l }), σ ∈ [formPerm (attach l)] → IsCycle σ

tactic: simp
state_before: case h2
α : Type u_1
inst✝ : DecidableEq α
l l' : List α
hl : Nodup (attach l)
hn : 2 ≤ length (attach l)
⊢ Pairwise Perm.Disjoint [formPerm (attach l)]
Theorem: Nat.bit_cases_on_injective
File: Mathlib/Data/Nat/Bits.lean

tactic: intro H₁ H₂ h
state_before: n : ℕ
C : ℕ → Sort u
⊢ Function.Injective fun H n => bitCasesOn n H

tactic: ext (b n)
state_before: n : ℕ
C : ℕ → Sort u
H₁ H₂ : (b : Bool) → (n : ℕ) → C (bit b n)
h : (fun H n => bitCasesOn n H) H₁ = (fun H n => bitCasesOn n H) H₂
⊢ H₁ = H₂

tactic: simpa only [bitCasesOn_bit] using congr_fun h (bit b n)
state_before: case h.h
n✝ : ℕ
C : ℕ → Sort u
H₁ H₂ : (b : Bool) → (n : ℕ) → C (bit b n)
h : (fun H n => bitCasesOn n H) H₁ = (fun H n => bitCasesOn n H) H₂
b : Bool
n : ℕ
⊢ H₁ b n = H₂ b n
Theorem: Nat.Prime.dvd_choose_pow
File: Mathlib/Data/Nat/Multiplicity.lean

tactic: obtain hkp | hkp := hkp.symm.lt_or_lt
state_before: p n k : ℕ
hp : Prime p
hk : k ≠ 0
hkp : k ≠ p ^ n
⊢ p ∣ choose (p ^ n) k

tactic: refine' multiplicity_ne_zero.1 fun h => hkp.not_le <| Nat.le_of_dvd hk.bot_lt _
state_before: case inr
p n k : ℕ
hp : Prime p
hk : k ≠ 0
hkp✝ : k ≠ p ^ n
hkp : k < p ^ n
⊢ p ∣ choose (p ^ n) k

tactic: have H := hp.multiplicity_choose_prime_pow_add_multiplicity hkp.le hk
state_before: case inr
p n k : ℕ
hp : Prime p
hk : k ≠ 0
hkp✝ : k ≠ p ^ n
hkp : k < p ^ n
h : multiplicity p (choose (p ^ n) k) = 0
⊢ p ^ n ∣ k

tactic: rw [h, zero_add, eq_coe_iff] at H
state_before: case inr
p n k : ℕ
hp : Prime p
hk : k ≠ 0
hkp✝ : k ≠ p ^ n
hkp : k < p ^ n
h : multiplicity p (choose (p ^ n) k) = 0
H : multiplicity p (choose (p ^ n) k) + multiplicity p k = ↑n
⊢ p ^ n ∣ k

tactic: exact H.1
state_before: case inr
p n k : ℕ
hp : Prime p
hk : k ≠ 0
hkp✝ : k ≠ p ^ n
hkp : k < p ^ n
h : multiplicity p (choose (p ^ n) k) = 0
H : p ^ n ∣ k ∧ ¬p ^ (n + 1) ∣ k
⊢ p ^ n ∣ k

tactic: simp [choose_eq_zero_of_lt hkp]
state_before: case inl
p n k : ℕ
hp : Prime p
hk : k ≠ 0
hkp✝ : k ≠ p ^ n
hkp : p ^ n < k
⊢ p ∣ choose (p ^ n) k
Theorem: HahnSeries.ofPowerSeries_X_pow
File: Mathlib/RingTheory/HahnSeries.lean

tactic: rw [RingHom.map_pow]
state_before: Γ : Type u_2
R✝ : Type ?u.2401544
inst✝² : Semiring R✝
inst✝¹ : StrictOrderedSemiring Γ
R : Type u_1
inst✝ : CommSemiring R
n : ℕ
⊢ ↑(ofPowerSeries Γ R) (PowerSeries.X ^ n) = ↑(single ↑n) 1

tactic: induction' n with n ih
state_before: Γ : Type u_2
R✝ : Type ?u.2401544
inst✝² : Semiring R✝
inst✝¹ : StrictOrderedSemiring Γ
R : Type u_1
inst✝ : CommSemiring R
n : ℕ
⊢ ↑(ofPowerSeries Γ R) PowerSeries.X ^ n = ↑(single ↑n) 1

tactic: . rw [pow_succ, pow_succ, ih, ofPowerSeries_X, mul_comm, single_mul_single, one_mul,
    Nat.cast_succ, add_comm]
state_before: case succ
Γ : Type u_2
R✝ : Type ?u.2401544
inst✝² : Semiring R✝
inst✝¹ : StrictOrderedSemiring Γ
R : Type u_1
inst✝ : CommSemiring R
n : ℕ
ih : ↑(ofPowerSeries Γ R) PowerSeries.X ^ n = ↑(single ↑n) 1
⊢ ↑(ofPowerSeries Γ R) PowerSeries.X ^ Nat.succ n = ↑(single ↑(Nat.succ n)) 1

tactic: simp
state_before: case zero
Γ : Type u_2
R✝ : Type ?u.2401544
inst✝² : Semiring R✝
inst✝¹ : StrictOrderedSemiring Γ
R : Type u_1
inst✝ : CommSemiring R
⊢ ↑(ofPowerSeries Γ R) PowerSeries.X ^ Nat.zero = ↑(single ↑Nat.zero) 1

tactic: rfl
state_before: case zero
Γ : Type u_2
R✝ : Type ?u.2401544
inst✝² : Semiring R✝
inst✝¹ : StrictOrderedSemiring Γ
R : Type u_1
inst✝ : CommSemiring R
⊢ 1 = ↑(single 0) 1

tactic: rw [pow_succ, pow_succ, ih, ofPowerSeries_X, mul_comm, single_mul_single, one_mul,
  Nat.cast_succ, add_comm]
state_before: case succ
Γ : Type u_2
R✝ : Type ?u.2401544
inst✝² : Semiring R✝
inst✝¹ : StrictOrderedSemiring Γ
R : Type u_1
inst✝ : CommSemiring R
n : ℕ
ih : ↑(ofPowerSeries Γ R) PowerSeries.X ^ n = ↑(single ↑n) 1
⊢ ↑(ofPowerSeries Γ R) PowerSeries.X ^ Nat.succ n = ↑(single ↑(Nat.succ n)) 1
Theorem: AddMonoidAlgebra.sup_support_multiset_prod_le
File: Mathlib/Algebra/MonoidAlgebra/Degree.lean

tactic: induction m using Quot.inductionOn
state_before: R : Type u_3
A : Type u_2
T : Type ?u.70204
B : Type u_1
ι : Type ?u.70210
inst✝¹¹ : SemilatticeSup B
inst✝¹⁰ : OrderBot B
inst✝⁹ : SemilatticeInf T
inst✝⁸ : OrderTop T
inst✝⁷ : CommSemiring R
inst✝⁶ : AddCommMonoid A
inst✝⁵ : AddCommMonoid B
inst✝⁴ : CovariantClass B B (fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1
inst✝³ : CovariantClass B B (Function.swap fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1
inst✝² : AddCommMonoid T
inst✝¹ : CovariantClass T T (fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1
inst✝ : CovariantClass T T (Function.swap fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1
degb : A → B
degt : A → T
degb0 : degb 0 ≤ 0
degbm : ∀ (a b : A), degb (a + b) ≤ degb a + degb b
m : Multiset (AddMonoidAlgebra R A)
⊢ Finset.sup (Multiset.prod m).support degb ≤ Multiset.sum (Multiset.map (fun f => Finset.sup f.support degb) m)

tactic: rw [Multiset.quot_mk_to_coe'', Multiset.coe_map, Multiset.coe_sum, Multiset.coe_prod]
state_before: case h
R : Type u_3
A : Type u_2
T : Type ?u.70204
B : Type u_1
ι : Type ?u.70210
inst✝¹¹ : SemilatticeSup B
inst✝¹⁰ : OrderBot B
inst✝⁹ : SemilatticeInf T
inst✝⁸ : OrderTop T
inst✝⁷ : CommSemiring R
inst✝⁶ : AddCommMonoid A
inst✝⁵ : AddCommMonoid B
inst✝⁴ : CovariantClass B B (fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1
inst✝³ : CovariantClass B B (Function.swap fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1
inst✝² : AddCommMonoid T
inst✝¹ : CovariantClass T T (fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1
inst✝ : CovariantClass T T (Function.swap fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1
degb : A → B
degt : A → T
degb0 : degb 0 ≤ 0
degbm : ∀ (a b : A), degb (a + b) ≤ degb a + degb b
a✝ : List (AddMonoidAlgebra R A)
⊢ Finset.sup (Multiset.prod (Quot.mk Setoid.r a✝)).support degb ≤
    Multiset.sum (Multiset.map (fun f => Finset.sup f.support degb) (Quot.mk Setoid.r a✝))

tactic: exact sup_support_list_prod_le degb0 degbm _
state_before: case h
R : Type u_3
A : Type u_2
T : Type ?u.70204
B : Type u_1
ι : Type ?u.70210
inst✝¹¹ : SemilatticeSup B
inst✝¹⁰ : OrderBot B
inst✝⁹ : SemilatticeInf T
inst✝⁸ : OrderTop T
inst✝⁷ : CommSemiring R
inst✝⁶ : AddCommMonoid A
inst✝⁵ : AddCommMonoid B
inst✝⁴ : CovariantClass B B (fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1
inst✝³ : CovariantClass B B (Function.swap fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1
inst✝² : AddCommMonoid T
inst✝¹ : CovariantClass T T (fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1
inst✝ : CovariantClass T T (Function.swap fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1
degb : A → B
degt : A → T
degb0 : degb 0 ≤ 0
degbm : ∀ (a b : A), degb (a + b) ≤ degb a + degb b
a✝ : List (AddMonoidAlgebra R A)
⊢ Finset.sup (List.prod a✝).support degb ≤ List.sum (List.map (fun f => Finset.sup f.support degb) a✝)
Theorem: padicNorm.values_discrete
File: Mathlib/NumberTheory/Padics/PadicNorm.lean

tactic: simp [padicNorm, hq]
state_before: p : ℕ
q : ℚ
hq : q ≠ 0
⊢ padicNorm p q = ↑p ^ (-padicValRat p q)
Theorem: Set.Ioo_subset_Ioo_iff
File: Mathlib/Data/Set/Intervals/Basic.lean

tactic: rcases exists_between h₁ with ⟨x, xa, xb⟩
state_before: α : Type u_1
β : Type ?u.68154
inst✝¹ : LinearOrder α
a a₁ a₂ b b₁ b₂ c d : α
inst✝ : DenselyOrdered α
h₁ : a₁ < b₁
h : Ioo a₁ b₁ ⊆ Ioo a₂ b₂
⊢ a₂ ≤ a₁ ∧ b₁ ≤ b₂

tactic: constructor <;> refine' le_of_not_lt fun h' => _
state_before: case intro.intro
α : Type u_1
β : Type ?u.68154
inst✝¹ : LinearOrder α
a a₁ a₂ b b₁ b₂ c d : α
inst✝ : DenselyOrdered α
h₁ : a₁ < b₁
h : Ioo a₁ b₁ ⊆ Ioo a₂ b₂
x : α
xa : a₁ < x
xb : x < b₁
⊢ a₂ ≤ a₁ ∧ b₁ ≤ b₂

tactic: have ab := (h ⟨xa, xb⟩).1.trans xb
state_before: case intro.intro.left
α : Type u_1
β : Type ?u.68154
inst✝¹ : LinearOrder α
a a₁ a₂ b b₁ b₂ c d : α
inst✝ : DenselyOrdered α
h₁ : a₁ < b₁
h : Ioo a₁ b₁ ⊆ Ioo a₂ b₂
x : α
xa : a₁ < x
xb : x < b₁
h' : a₁ < a₂
⊢ False

tactic: exact lt_irrefl _ (h ⟨h', ab⟩).1
state_before: case intro.intro.left
α : Type u_1
β : Type ?u.68154
inst✝¹ : LinearOrder α
a a₁ a₂ b b₁ b₂ c d : α
inst✝ : DenselyOrdered α
h₁ : a₁ < b₁
h : Ioo a₁ b₁ ⊆ Ioo a₂ b₂
x : α
xa : a₁ < x
xb : x < b₁
h' : a₁ < a₂
ab : a₂ < b₁
⊢ False

tactic: have ab := xa.trans (h ⟨xa, xb⟩).2
state_before: case intro.intro.right
α : Type u_1
β : Type ?u.68154
inst✝¹ : LinearOrder α
a a₁ a₂ b b₁ b₂ c d : α
inst✝ : DenselyOrdered α
h₁ : a₁ < b₁
h : Ioo a₁ b₁ ⊆ Ioo a₂ b₂
x : α
xa : a₁ < x
xb : x < b₁
h' : b₂ < b₁
⊢ False

tactic: exact lt_irrefl _ (h ⟨ab, h'⟩).2
state_before: case intro.intro.right
α : Type u_1
β : Type ?u.68154
inst✝¹ : LinearOrder α
a a₁ a₂ b b₁ b₂ c d : α
inst✝ : DenselyOrdered α
h₁ : a₁ < b₁
h : Ioo a₁ b₁ ⊆ Ioo a₂ b₂
x : α
xa : a₁ < x
xb : x < b₁
h' : b₂ < b₁
ab : a₁ < b₂
⊢ False
Theorem: Ideal.comap_minimalPrimes_eq_of_surjective
File: Mathlib/RingTheory/Ideal/MinimalPrime.lean

tactic: ext J
state_before: R : Type u_1
S : Type u_2
inst✝¹ : CommRing R
inst✝ : CommRing S
I✝ J : Ideal R
f : R →+* S
hf : Function.Surjective ↑f
I : Ideal S
⊢ Ideal.minimalPrimes (comap f I) = comap f '' Ideal.minimalPrimes I

tactic: constructor
state_before: case h
R : Type u_1
S : Type u_2
inst✝¹ : CommRing R
inst✝ : CommRing S
I✝ J✝ : Ideal R
f : R →+* S
hf : Function.Surjective ↑f
I : Ideal S
J : Ideal R
⊢ J ∈ Ideal.minimalPrimes (comap f I) ↔ J ∈ comap f '' Ideal.minimalPrimes I

tactic: intro H
state_before: case h.mp
R : Type u_1
S : Type u_2
inst✝¹ : CommRing R
inst✝ : CommRing S
I✝ J✝ : Ideal R
f : R →+* S
hf : Function.Surjective ↑f
I : Ideal S
J : Ideal R
⊢ J ∈ Ideal.minimalPrimes (comap f I) → J ∈ comap f '' Ideal.minimalPrimes I

tactic: obtain ⟨p, h, rfl⟩ := Ideal.exists_minimalPrimes_comap_eq f J H
state_before: case h.mp
R : Type u_1
S : Type u_2
inst✝¹ : CommRing R
inst✝ : CommRing S
I✝ J✝ : Ideal R
f : R →+* S
hf : Function.Surjective ↑f
I : Ideal S
J : Ideal R
H : J ∈ Ideal.minimalPrimes (comap f I)
⊢ J ∈ comap f '' Ideal.minimalPrimes I

tactic: exact ⟨p, h, rfl⟩
state_before: case h.mp.intro.intro
R : Type u_1
S : Type u_2
inst✝¹ : CommRing R
inst✝ : CommRing S
I✝ J : Ideal R
f : R →+* S
hf : Function.Surjective ↑f
I p : Ideal S
h : p ∈ Ideal.minimalPrimes I
H : comap f p ∈ Ideal.minimalPrimes (comap f I)
⊢ comap f p ∈ comap f '' Ideal.minimalPrimes I

tactic: rintro ⟨J, hJ, rfl⟩
state_before: case h.mpr
R : Type u_1
S : Type u_2
inst✝¹ : CommRing R
inst✝ : CommRing S
I✝ J✝ : Ideal R
f : R →+* S
hf : Function.Surjective ↑f
I : Ideal S
J : Ideal R
⊢ J ∈ comap f '' Ideal.minimalPrimes I → J ∈ Ideal.minimalPrimes (comap f I)

tactic: exact Ideal.mimimal_primes_comap_of_surjective hf hJ
state_before: case h.mpr.intro.intro
R : Type u_1
S : Type u_2
inst✝¹ : CommRing R
inst✝ : CommRing S
I✝ J✝ : Ideal R
f : R →+* S
hf : Function.Surjective ↑f
I J : Ideal S
hJ : J ∈ Ideal.minimalPrimes I
⊢ comap f J ∈ Ideal.minimalPrimes (comap f I)
Theorem: Ordinal.le_one_iff
File: Mathlib/SetTheory/Ordinal/Basic.lean

tactic: simpa using @le_succ_bot_iff _ _ _ a _
state_before: α : Type ?u.181428
β : Type ?u.181431
γ : Type ?u.181434
r : α → α → Prop
s : β → β → Prop
t : γ → γ → Prop
a : Ordinal
⊢ a ≤ 1 ↔ a = 0 ∨ a = 1
Theorem: pow_mul_pow_eq_one
File: Mathlib/Algebra/GroupPower/Basic.lean

tactic: induction' n with n hn
state_before: α : Type ?u.41048
M : Type u
N : Type v
G : Type w
H : Type x
A : Type y
B : Type z
R : Type u₁
S : Type u₂
inst✝¹ : Monoid M
inst✝ : AddMonoid A
a b : M
n : ℕ
h : a * b = 1
⊢ a ^ n * b ^ n = 1

tactic: simp
state_before: case zero
α : Type ?u.41048
M : Type u
N : Type v
G : Type w
H : Type x
A : Type y
B : Type z
R : Type u₁
S : Type u₂
inst✝¹ : Monoid M
inst✝ : AddMonoid A
a b : M
h : a * b = 1
⊢ a ^ Nat.zero * b ^ Nat.zero = 1

tactic: calc
  a ^ n.succ * b ^ n.succ = a ^ n * a * (b * b ^ n) := by rw [pow_succ', pow_succ]
  _ = a ^ n * (a * b) * b ^ n := by simp only [mul_assoc]
  _ = 1 := by simp [h, hn]
state_before: case succ
α : Type ?u.41048
M : Type u
N : Type v
G : Type w
H : Type x
A : Type y
B : Type z
R : Type u₁
S : Type u₂
inst✝¹ : Monoid M
inst✝ : AddMonoid A
a b : M
h : a * b = 1
n : ℕ
hn : a ^ n * b ^ n = 1
⊢ a ^ Nat.succ n * b ^ Nat.succ n = 1

tactic: rw [pow_succ', pow_succ]
state_before: α : Type ?u.41048
M : Type u
N : Type v
G : Type w
H : Type x
A : Type y
B : Type z
R : Type u₁
S : Type u₂
inst✝¹ : Monoid M
inst✝ : AddMonoid A
a b : M
h : a * b = 1
n : ℕ
hn : a ^ n * b ^ n = 1
⊢ a ^ Nat.succ n * b ^ Nat.succ n = a ^ n * a * (b * b ^ n)

tactic: simp only [mul_assoc]
state_before: α : Type ?u.41048
M : Type u
N : Type v
G : Type w
H : Type x
A : Type y
B : Type z
R : Type u₁
S : Type u₂
inst✝¹ : Monoid M
inst✝ : AddMonoid A
a b : M
h : a * b = 1
n : ℕ
hn : a ^ n * b ^ n = 1
⊢ a ^ n * a * (b * b ^ n) = a ^ n * (a * b) * b ^ n

tactic: simp [h, hn]
state_before: α : Type ?u.41048
M : Type u
N : Type v
G : Type w
H : Type x
A : Type y
B : Type z
R : Type u₁
S : Type u₂
inst✝¹ : Monoid M
inst✝ : AddMonoid A
a b : M
h : a * b = 1
n : ℕ
hn : a ^ n * b ^ n = 1
⊢ a ^ n * (a * b) * b ^ n = 1
Theorem: Matrix.Fin.transpose_circulant
File: Mathlib/LinearAlgebra/Matrix/Circulant.lean

tactic: simp [Injective]
state_before: α : Type u_1
β : Type ?u.8775
m : Type ?u.8778
n : Type ?u.8781
R : Type ?u.8784
⊢ ∀ (v : Fin 0 → α), (circulant v)ᵀ = circulant fun i => v (-i)
Theorem: Asymptotics.isLittleO_pi
File: Mathlib/Analysis/Asymptotics/Asymptotics.lean

tactic: simp (config := { contextual := true }) only [IsLittleO_def, isBigOWith_pi, le_of_lt]
state_before: α : Type u_3
β : Type ?u.696195
E : Type ?u.696198
F : Type ?u.696201
G : Type ?u.696204
E'✝ : Type ?u.696207
F' : Type u_4
G' : Type ?u.696213
E'' : Type ?u.696216
F'' : Type ?u.696219
G'' : Type ?u.696222
R : Type ?u.696225
R' : Type ?u.696228
𝕜 : Type ?u.696231
𝕜' : Type ?u.696234
inst✝¹⁴ : Norm E
inst✝¹³ : Norm F
inst✝¹² : Norm G
inst✝¹¹ : SeminormedAddCommGroup E'✝
inst✝¹⁰ : SeminormedAddCommGroup F'
inst✝⁹ : SeminormedAddCommGroup G'
inst✝⁸ : NormedAddCommGroup E''
inst✝⁷ : NormedAddCommGroup F''
inst✝⁶ : NormedAddCommGroup G''
inst✝⁵ : SeminormedRing R
inst✝⁴ : SeminormedRing R'
inst✝³ : NormedField 𝕜
inst✝² : NormedField 𝕜'
c c' c₁ c₂ : ℝ
f✝ : α → E
g : α → F
k : α → G
f' : α → E'✝
g' : α → F'
k' : α → G'
f'' : α → E''
g'' : α → F''
k'' : α → G''
l l' : Filter α
ι : Type u_1
inst✝¹ : Fintype ι
E' : ι → Type u_2
inst✝ : (i : ι) → NormedAddCommGroup (E' i)
f : α → (i : ι) → E' i
⊢ f =o[l] g' ↔ ∀ (i : ι), (fun x => f x i) =o[l] g'

tactic: exact ⟨fun h i c hc => h hc i, fun h c hc i => h i hc⟩
state_before: α : Type u_3
β : Type ?u.696195
E : Type ?u.696198
F : Type ?u.696201
G : Type ?u.696204
E'✝ : Type ?u.696207
F' : Type u_4
G' : Type ?u.696213
E'' : Type ?u.696216
F'' : Type ?u.696219
G'' : Type ?u.696222
R : Type ?u.696225
R' : Type ?u.696228
𝕜 : Type ?u.696231
𝕜' : Type ?u.696234
inst✝¹⁴ : Norm E
inst✝¹³ : Norm F
inst✝¹² : Norm G
inst✝¹¹ : SeminormedAddCommGroup E'✝
inst✝¹⁰ : SeminormedAddCommGroup F'
inst✝⁹ : SeminormedAddCommGroup G'
inst✝⁸ : NormedAddCommGroup E''
inst✝⁷ : NormedAddCommGroup F''
inst✝⁶ : NormedAddCommGroup G''
inst✝⁵ : SeminormedRing R
inst✝⁴ : SeminormedRing R'
inst✝³ : NormedField 𝕜
inst✝² : NormedField 𝕜'
c c' c₁ c₂ : ℝ
f✝ : α → E
g : α → F
k : α → G
f' : α → E'✝
g' : α → F'
k' : α → G'
f'' : α → E''
g'' : α → F''
k'' : α → G''
l l' : Filter α
ι : Type u_1
inst✝¹ : Fintype ι
E' : ι → Type u_2
inst✝ : (i : ι) → NormedAddCommGroup (E' i)
f : α → (i : ι) → E' i
⊢ (∀ ⦃c : ℝ⦄, 0 < c → ∀ (i : ι), IsBigOWith c l (fun x => f x i) g') ↔
    ∀ (i : ι) ⦃c : ℝ⦄, 0 < c → IsBigOWith c l (fun x => f x i) g'
Theorem: Ideal.iInf_pow_smul_eq_bot_of_localRing
File: Mathlib/RingTheory/Filtration.lean

tactic: rw [eq_bot_iff]
state_before: R M : Type u
inst✝⁵ : CommRing R
inst✝⁴ : AddCommGroup M
inst✝³ : Module R M
I : Ideal R
F F' : Filtration I M
inst✝² : IsNoetherianRing R
inst✝¹ : LocalRing R
inst✝ : Module.Finite R M
h : I ≠ ⊤
⊢ (⨅ (i : ℕ), I ^ i • ⊤) = ⊥

tactic: intro x hx
state_before: R M : Type u
inst✝⁵ : CommRing R
inst✝⁴ : AddCommGroup M
inst✝³ : Module R M
I : Ideal R
F F' : Filtration I M
inst✝² : IsNoetherianRing R
inst✝¹ : LocalRing R
inst✝ : Module.Finite R M
h : I ≠ ⊤
⊢ (⨅ (i : ℕ), I ^ i • ⊤) ≤ ⊥

tactic: obtain ⟨r, hr⟩ := (I.mem_iInf_smul_pow_eq_bot_iff x).mp hx
state_before: R M : Type u
inst✝⁵ : CommRing R
inst✝⁴ : AddCommGroup M
inst✝³ : Module R M
I : Ideal R
F F' : Filtration I M
inst✝² : IsNoetherianRing R
inst✝¹ : LocalRing R
inst✝ : Module.Finite R M
h : I ≠ ⊤
x : M
hx : x ∈ ⨅ (i : ℕ), I ^ i • ⊤
⊢ x ∈ ⊥

tactic: have := LocalRing.isUnit_one_sub_self_of_mem_nonunits _ (LocalRing.le_maximalIdeal h r.prop)
state_before: case intro
R M : Type u
inst✝⁵ : CommRing R
inst✝⁴ : AddCommGroup M
inst✝³ : Module R M
I : Ideal R
F F' : Filtration I M
inst✝² : IsNoetherianRing R
inst✝¹ : LocalRing R
inst✝ : Module.Finite R M
h : I ≠ ⊤
x : M
hx : x ∈ ⨅ (i : ℕ), I ^ i • ⊤
r : { x // x ∈ I }
hr : ↑r • x = x
⊢ x ∈ ⊥

tactic: apply this.smul_left_cancel.mp
state_before: case intro
R M : Type u
inst✝⁵ : CommRing R
inst✝⁴ : AddCommGroup M
inst✝³ : Module R M
I : Ideal R
F F' : Filtration I M
inst✝² : IsNoetherianRing R
inst✝¹ : LocalRing R
inst✝ : Module.Finite R M
h : I ≠ ⊤
x : M
hx : x ∈ ⨅ (i : ℕ), I ^ i • ⊤
r : { x // x ∈ I }
hr : ↑r • x = x
this : IsUnit (1 - ↑r)
⊢ x ∈ ⊥

tactic: simp [sub_smul, hr]
state_before: case intro
R M : Type u
inst✝⁵ : CommRing R
inst✝⁴ : AddCommGroup M
inst✝³ : Module R M
I : Ideal R
F F' : Filtration I M
inst✝² : IsNoetherianRing R
inst✝¹ : LocalRing R
inst✝ : Module.Finite R M
h : I ≠ ⊤
x : M
hx : x ∈ ⨅ (i : ℕ), I ^ i • ⊤
r : { x // x ∈ I }
hr : ↑r • x = x
this : IsUnit (1 - ↑r)
⊢ (1 - ↑r) • x = (1 - ↑r) • 0
Theorem: Fin.mk_succ_pos
File: Mathlib/Data/Fin/Basic.lean

tactic: rw [lt_iff_val_lt_val, val_zero]
state_before: n m i : ℕ
h : i < n
⊢ 0 < { val := Nat.succ i, isLt := (_ : i + 1 < n + 1) }

tactic: exact Nat.succ_pos i
state_before: n m i : ℕ
h : i < n
⊢ 0 < ↑{ val := Nat.succ i, isLt := (_ : i + 1 < n + 1) }
Theorem: Submodule.mem_of_span_top_of_smul_mem
File: Mathlib/RingTheory/Ideal/Operations.lean

tactic: suffices (⊤ : Ideal R) • span R ({x} : Set M) ≤ M' by
  rw [top_smul] at this
  exact this (subset_span (Set.mem_singleton x))
state_before: R : Type u
M : Type v
F : Type ?u.105735
G : Type ?u.105738
inst✝² : CommSemiring R
inst✝¹ : AddCommMonoid M
inst✝ : Module R M
I J : Ideal R
N P : Submodule R M
S : Set R
T : Set M
M' : Submodule R M
s : Set R
hs : Ideal.span s = ⊤
x : M
H : ∀ (r : ↑s), ↑r • x ∈ M'
⊢ x ∈ M'

tactic: rw [← hs, span_smul_span, span_le]
state_before: R : Type u
M : Type v
F : Type ?u.105735
G : Type ?u.105738
inst✝² : CommSemiring R
inst✝¹ : AddCommMonoid M
inst✝ : Module R M
I J : Ideal R
N P : Submodule R M
S : Set R
T : Set M
M' : Submodule R M
s : Set R
hs : Ideal.span s = ⊤
x : M
H : ∀ (r : ↑s), ↑r • x ∈ M'
⊢ ⊤ • span R {x} ≤ M'

tactic: simpa using H
state_before: R : Type u
M : Type v
F : Type ?u.105735
G : Type ?u.105738
inst✝² : CommSemiring R
inst✝¹ : AddCommMonoid M
inst✝ : Module R M
I J : Ideal R
N P : Submodule R M
S : Set R
T : Set M
M' : Submodule R M
s : Set R
hs : Ideal.span s = ⊤
x : M
H : ∀ (r : ↑s), ↑r • x ∈ M'
⊢ (⋃ (s_1 : R) (_ : s_1 ∈ s) (t : M) (_ : t ∈ {x}), {s_1 • t}) ⊆ ↑M'

tactic: rw [top_smul] at this
state_before: R : Type u
M : Type v
F : Type ?u.105735
G : Type ?u.105738
inst✝² : CommSemiring R
inst✝¹ : AddCommMonoid M
inst✝ : Module R M
I J : Ideal R
N P : Submodule R M
S : Set R
T : Set M
M' : Submodule R M
s : Set R
hs : Ideal.span s = ⊤
x : M
H : ∀ (r : ↑s), ↑r • x ∈ M'
this : ⊤ • span R {x} ≤ M'
⊢ x ∈ M'

tactic: exact this (subset_span (Set.mem_singleton x))
state_before: R : Type u
M : Type v
F : Type ?u.105735
G : Type ?u.105738
inst✝² : CommSemiring R
inst✝¹ : AddCommMonoid M
inst✝ : Module R M
I J : Ideal R
N P : Submodule R M
S : Set R
T : Set M
M' : Submodule R M
s : Set R
hs : Ideal.span s = ⊤
x : M
H : ∀ (r : ↑s), ↑r • x ∈ M'
this : span R {x} ≤ M'
⊢ x ∈ M'