tasksource/leandojo huggingface dataset:
Theorem: Nat.fib_two_mul
File: Mathlib/Data/Nat/Fib.lean

tactic: cases n
state_before: n : ℕ
⊢ fib (2 * n) = fib n * (2 * fib (n + 1) - fib n)

tactic: simp
state_before: case zero

⊢ fib (2 * zero) = fib zero * (2 * fib (zero + 1) - fib zero)

tactic: rw [Nat.succ_eq_add_one, two_mul, ← add_assoc, fib_add, fib_add_two, two_mul]
state_before: case succ
n✝ : ℕ
⊢ fib (2 * succ n✝) = fib (succ n✝) * (2 * fib (succ n✝ + 1) - fib (succ n✝))

tactic: simp only [← add_assoc, add_tsub_cancel_right]
state_before: case succ
n✝ : ℕ
⊢ fib (n✝ + 1) * fib n✝ + (fib n✝ + fib (n✝ + 1)) * fib (n✝ + 1) =
    fib (n✝ + 1) * (fib n✝ + fib (n✝ + 1) + (fib n✝ + fib (n✝ + 1)) - fib (n✝ + 1))

tactic: ring
state_before: case succ
n✝ : ℕ
⊢ fib (n✝ + 1) * fib n✝ + (fib n✝ + fib (n✝ + 1)) * fib (n✝ + 1) = fib (n✝ + 1) * (fib n✝ + fib (n✝ + 1) + fib n✝)
Theorem: Polynomial.Monic.geom_sum
File: Mathlib/RingTheory/Polynomial/Basic.lean

tactic: nontriviality R
state_before: R : Type u
S : Type ?u.54680
inst✝ : Semiring R
P : R[X]
hP : Monic P
hdeg : 0 < natDegree P
n : ℕ
hn : n ≠ 0
⊢ Monic (∑ i in range n, P ^ i)

tactic: obtain ⟨n, rfl⟩ := Nat.exists_eq_succ_of_ne_zero hn
state_before: R : Type u
S : Type ?u.54680
inst✝ : Semiring R
P : R[X]
hP : Monic P
hdeg : 0 < natDegree P
n : ℕ
hn : n ≠ 0
✝ : Nontrivial R
⊢ Monic (∑ i in range n, P ^ i)

tactic: rw [geom_sum_succ']
state_before: case intro
R : Type u
S : Type ?u.54680
inst✝ : Semiring R
P : R[X]
hP : Monic P
hdeg : 0 < natDegree P
✝ : Nontrivial R
n : ℕ
hn : Nat.succ n ≠ 0
⊢ Monic (∑ i in range (Nat.succ n), P ^ i)

tactic: refine' (hP.pow _).add_of_left _
state_before: case intro
R : Type u
S : Type ?u.54680
inst✝ : Semiring R
P : R[X]
hP : Monic P
hdeg : 0 < natDegree P
✝ : Nontrivial R
n : ℕ
hn : Nat.succ n ≠ 0
⊢ Monic (P ^ n + ∑ i in range n, P ^ i)

tactic: refine' lt_of_le_of_lt (degree_sum_le _ _) _
state_before: case intro
R : Type u
S : Type ?u.54680
inst✝ : Semiring R
P : R[X]
hP : Monic P
hdeg : 0 < natDegree P
✝ : Nontrivial R
n : ℕ
hn : Nat.succ n ≠ 0
⊢ degree (∑ i in range n, P ^ i) < degree (P ^ n)

tactic: rw [Finset.sup_lt_iff]
state_before: case intro
R : Type u
S : Type ?u.54680
inst✝ : Semiring R
P : R[X]
hP : Monic P
hdeg : 0 < natDegree P
✝ : Nontrivial R
n : ℕ
hn : Nat.succ n ≠ 0
⊢ (sup (range n) fun b => degree (P ^ b)) < degree (P ^ n)

tactic: simp only [Finset.mem_range, degree_eq_natDegree (hP.pow _).ne_zero]
state_before: case intro
R : Type u
S : Type ?u.54680
inst✝ : Semiring R
P : R[X]
hP : Monic P
hdeg : 0 < natDegree P
✝ : Nontrivial R
n : ℕ
hn : Nat.succ n ≠ 0
⊢ ∀ (b : ℕ), b ∈ range n → degree (P ^ b) < degree (P ^ n)

tactic: simp only [Nat.cast_withBot, WithBot.coe_lt_coe, hP.natDegree_pow]
state_before: case intro
R : Type u
S : Type ?u.54680
inst✝ : Semiring R
P : R[X]
hP : Monic P
hdeg : 0 < natDegree P
✝ : Nontrivial R
n : ℕ
hn : Nat.succ n ≠ 0
⊢ ∀ (b : ℕ), b < n → ↑(natDegree (P ^ b)) < ↑(natDegree (P ^ n))

tactic: intro k
state_before: case intro
R : Type u
S : Type ?u.54680
inst✝ : Semiring R
P : R[X]
hP : Monic P
hdeg : 0 < natDegree P
✝ : Nontrivial R
n : ℕ
hn : Nat.succ n ≠ 0
⊢ ∀ (b : ℕ), b < n → b * natDegree P < n * natDegree P

tactic: exact nsmul_lt_nsmul hdeg
state_before: case intro
R : Type u
S : Type ?u.54680
inst✝ : Semiring R
P : R[X]
hP : Monic P
hdeg : 0 < natDegree P
✝ : Nontrivial R
n : ℕ
hn : Nat.succ n ≠ 0
k : ℕ
⊢ k < n → k * natDegree P < n * natDegree P

tactic: rw [bot_lt_iff_ne_bot, Ne.def, degree_eq_bot]
state_before: case intro
R : Type u
S : Type ?u.54680
inst✝ : Semiring R
P : R[X]
hP : Monic P
hdeg : 0 < natDegree P
✝ : Nontrivial R
n : ℕ
hn : Nat.succ n ≠ 0
⊢ ⊥ < degree (P ^ n)

tactic: exact (hP.pow _).ne_zero
state_before: case intro
R : Type u
S : Type ?u.54680
inst✝ : Semiring R
P : R[X]
hP : Monic P
hdeg : 0 < natDegree P
✝ : Nontrivial R
n : ℕ
hn : Nat.succ n ≠ 0
⊢ ¬P ^ n = 0
Theorem: Real.cauchy_add
File: Mathlib/Data/Real/Basic.lean

tactic: rw [add_def]
state_before: x y : ℝ
a b : Cauchy abs
⊢ (Real.add { cauchy := a } { cauchy := b }).cauchy = { cauchy := a }.cauchy + { cauchy := b }.cauchy
Theorem: CompleteLattice.Independent.injective
File: Mathlib/Order/SupIndep.lean

tactic: intro i j h
state_before: α : Type u_2
β : Type ?u.53351
ι : Type u_1
ι' : Type ?u.53357
inst✝ : CompleteLattice α
s : Set α
hs : SetIndependent s
t : ι → α
ht✝ ht : Independent t
h_ne_bot : ∀ (i : ι), t i ≠ ⊥
⊢ Injective t

tactic: by_contra' contra
state_before: α : Type u_2
β : Type ?u.53351
ι : Type u_1
ι' : Type ?u.53357
inst✝ : CompleteLattice α
s : Set α
hs : SetIndependent s
t : ι → α
ht✝ ht : Independent t
h_ne_bot : ∀ (i : ι), t i ≠ ⊥
i j : ι
h : t i = t j
⊢ i = j

tactic: apply h_ne_bot j
state_before: α : Type u_2
β : Type ?u.53351
ι : Type u_1
ι' : Type ?u.53357
inst✝ : CompleteLattice α
s : Set α
hs : SetIndependent s
t : ι → α
ht✝ ht : Independent t
h_ne_bot : ∀ (i : ι), t i ≠ ⊥
i j : ι
h : t i = t j
contra : i ≠ j
⊢ False

tactic: suffices t j ≤ ⨆ (k) (_ : k ≠ i), t k by
  replace ht := (ht i).mono_right this
  rwa [h, disjoint_self] at ht
state_before: α : Type u_2
β : Type ?u.53351
ι : Type u_1
ι' : Type ?u.53357
inst✝ : CompleteLattice α
s : Set α
hs : SetIndependent s
t : ι → α
ht✝ ht : Independent t
h_ne_bot : ∀ (i : ι), t i ≠ ⊥
i j : ι
h : t i = t j
contra : i ≠ j
⊢ t j = ⊥

tactic: replace contra : j ≠ i
state_before: α : Type u_2
β : Type ?u.53351
ι : Type u_1
ι' : Type ?u.53357
inst✝ : CompleteLattice α
s : Set α
hs : SetIndependent s
t : ι → α
ht✝ ht : Independent t
h_ne_bot : ∀ (i : ι), t i ≠ ⊥
i j : ι
h : t i = t j
contra : i ≠ j
⊢ t j ≤ ⨆ (k : ι) (_ : k ≠ i), t k

tactic: exact @le_iSup₂ _ _ _ _ (fun x _ => t x) j contra
state_before: α : Type u_2
β : Type ?u.53351
ι : Type u_1
ι' : Type ?u.53357
inst✝ : CompleteLattice α
s : Set α
hs : SetIndependent s
t : ι → α
ht✝ ht : Independent t
h_ne_bot : ∀ (i : ι), t i ≠ ⊥
i j : ι
h : t i = t j
contra : j ≠ i
⊢ t j ≤ ⨆ (k : ι) (_ : k ≠ i), t k

tactic: replace ht := (ht i).mono_right this
state_before: α : Type u_2
β : Type ?u.53351
ι : Type u_1
ι' : Type ?u.53357
inst✝ : CompleteLattice α
s : Set α
hs : SetIndependent s
t : ι → α
ht✝ ht : Independent t
h_ne_bot : ∀ (i : ι), t i ≠ ⊥
i j : ι
h : t i = t j
contra : i ≠ j
this : t j ≤ ⨆ (k : ι) (_ : k ≠ i), t k
⊢ t j = ⊥

tactic: rwa [h, disjoint_self] at ht
state_before: α : Type u_2
β : Type ?u.53351
ι : Type u_1
ι' : Type ?u.53357
inst✝ : CompleteLattice α
s : Set α
hs : SetIndependent s
t : ι → α
ht✝ : Independent t
h_ne_bot : ∀ (i : ι), t i ≠ ⊥
i j : ι
h : t i = t j
contra : i ≠ j
this : t j ≤ ⨆ (k : ι) (_ : k ≠ i), t k
ht : Disjoint (t i) (t j)
⊢ t j = ⊥

tactic: exact Ne.symm contra
state_before: case contra
α : Type u_2
β : Type ?u.53351
ι : Type u_1
ι' : Type ?u.53357
inst✝ : CompleteLattice α
s : Set α
hs : SetIndependent s
t : ι → α
ht✝ ht : Independent t
h_ne_bot : ∀ (i : ι), t i ≠ ⊥
i j : ι
h : t i = t j
contra : i ≠ j
⊢ j ≠ i
Theorem: Class.sUnion_empty
File: Mathlib/SetTheory/ZFC/Basic.lean

tactic: ext
state_before: ⊢ ⋃₀ ∅ = ∅

tactic: simp
state_before: case a
z✝ : ZFSet
⊢ (⋃₀ ∅) z✝ ↔ ∅ z✝
Theorem: Polynomial.natTrailingDegree_monomial_le
File: Mathlib/Data/Polynomial/Degree/TrailingDegree.lean

tactic: simp [ha]
state_before: R : Type u
S : Type v
a b : R
n m : ℕ
inst✝ : Semiring R
p q r : R[X]
ha : a = 0
⊢ natTrailingDegree (↑(monomial n) a) ≤ n
Theorem: Real.sqrtTwoAddSeries_lt_two
File: Mathlib/Analysis/SpecialFunctions/Trigonometric/Basic.lean

tactic: norm_num
state_before: x : ℝ
⊢ sqrtTwoAddSeries 0 0 < 2

tactic: refine' lt_of_lt_of_le _ (sqrt_sq zero_lt_two.le).le
state_before: x : ℝ
n : ℕ
⊢ sqrtTwoAddSeries 0 (n + 1) < 2

tactic: rw [sqrtTwoAddSeries, sqrt_lt_sqrt_iff, ← lt_sub_iff_add_lt']
state_before: x : ℝ
n : ℕ
⊢ sqrtTwoAddSeries 0 (n + 1) < sqrt (2 ^ 2)

tactic: refine' (sqrtTwoAddSeries_lt_two n).trans_le _
state_before: x : ℝ
n : ℕ
⊢ sqrtTwoAddSeries 0 n < 2 ^ 2 - 2

tactic: norm_num
state_before: x : ℝ
n : ℕ
⊢ 2 ≤ 2 ^ 2 - 2

tactic: exact add_nonneg zero_le_two (sqrtTwoAddSeries_zero_nonneg n)
state_before: x : ℝ
n : ℕ
⊢ 0 ≤ 2 + sqrtTwoAddSeries 0 n
Theorem: Polynomial.coeff_map
File: Mathlib/Data/Polynomial/Eval.lean

tactic: rw [map, eval₂_def, coeff_sum, sum]
state_before: R : Type u
S : Type v
T : Type w
ι : Type y
a b : R
m n✝ : ℕ
inst✝¹ : Semiring R
p q r : R[X]
inst✝ : Semiring S
f : R →+* S
n : ℕ
⊢ coeff (map f p) n = ↑f (coeff p n)

tactic: conv_rhs => rw [← sum_C_mul_X_pow_eq p, coeff_sum, sum, map_sum]
state_before: R : Type u
S : Type v
T : Type w
ι : Type y
a b : R
m n✝ : ℕ
inst✝¹ : Semiring R
p q r : R[X]
inst✝ : Semiring S
f : R →+* S
n : ℕ
⊢ ∑ n_1 in support p, coeff (↑(RingHom.comp C f) (coeff p n_1) * X ^ n_1) n = ↑f (coeff p n)

tactic: refine' Finset.sum_congr rfl fun x _hx => _
state_before: R : Type u
S : Type v
T : Type w
ι : Type y
a b : R
m n✝ : ℕ
inst✝¹ : Semiring R
p q r : R[X]
inst✝ : Semiring S
f : R →+* S
n : ℕ
⊢ ∑ n_1 in support p, coeff (↑(RingHom.comp C f) (coeff p n_1) * X ^ n_1) n =
    ∑ x in support p, ↑f (coeff (↑C (coeff p x) * X ^ x) n)

tactic: simp [Function.comp, coeff_C_mul_X_pow, - map_mul, - coeff_C_mul]
state_before: R : Type u
S : Type v
T : Type w
ι : Type y
a b : R
m n✝ : ℕ
inst✝¹ : Semiring R
p q r : R[X]
inst✝ : Semiring S
f : R →+* S
n x : ℕ
_hx : x ∈ support p
⊢ coeff (↑(RingHom.comp C f) (coeff p x) * X ^ x) n = ↑f (coeff (↑C (coeff p x) * X ^ x) n)

tactic: split_ifs <;> simp [f.map_zero]
state_before: R : Type u
S : Type v
T : Type w
ι : Type y
a b : R
m n✝ : ℕ
inst✝¹ : Semiring R
p q r : R[X]
inst✝ : Semiring S
f : R →+* S
n x : ℕ
_hx : x ∈ support p
⊢ (if n = x then ↑f (coeff p x) else 0) = ↑f (if n = x then coeff p x else 0)
Theorem: Int.norm_eq_abs
File: Mathlib/Analysis/Normed/Group/Basic.lean

tactic: rw [Real.norm_eq_abs, cast_abs]
state_before: 𝓕 : Type ?u.1111123
𝕜 : Type ?u.1111126
α : Type ?u.1111129
ι : Type ?u.1111132
κ : Type ?u.1111135
E : Type ?u.1111138
F : Type ?u.1111141
G : Type ?u.1111144
inst✝¹ : SeminormedCommGroup E
inst✝ : SeminormedCommGroup F
a a₁ a₂ b b₁ b₂ : E
r r₁ r₂ : ℝ
n : ℤ
⊢ ‖↑n‖ = ↑(abs n)
Theorem: nsmul_zero
File: Mathlib/Algebra/GroupPower/Basic.lean

tactic: induction' n with n ih
state_before: α : Type ?u.8662
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
n : ℕ
⊢ n • 0 = 0

tactic: exact zero_nsmul _
state_before: case zero
α : Type ?u.8662
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
⊢ Nat.zero • 0 = 0

tactic: rw [succ_nsmul, ih, add_zero]
state_before: case succ
α : Type ?u.8662
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
n : ℕ
ih : n • 0 = 0
⊢ Nat.succ n • 0 = 0
Theorem: SatisfiesM.pure
File: Std/Classes/LawfulMonad.lean

tactic: simp
state_before: m : Type u_1 → Type u_2
α✝ : Type u_1
p : α✝ → Prop
a : α✝
inst✝¹ : Applicative m
inst✝ : LawfulApplicative m
h : p a
⊢ Subtype.val <$> pure { val := a, property := h } = pure a
Theorem: Equiv.comp_traverse
File: Mathlib/Control/Traversable/Equiv.lean

tactic: simp [Equiv.traverse, comp_traverse, functor_norm]
state_before: t t' : Type u → Type u
eqv : (α : Type u) → t α ≃ t' α
inst✝⁵ : Traversable t
inst✝⁴ : IsLawfulTraversable t
F G : Type u → Type u
inst✝³ : Applicative F
inst✝² : Applicative G
inst✝¹ : LawfulApplicative F
inst✝ : LawfulApplicative G
η : ApplicativeTransformation F G
α β γ : Type u
f : β → F γ
g : α → G β
x : t' α
⊢ Equiv.traverse eqv (Comp.mk ∘ map f ∘ g) x = Comp.mk (Equiv.traverse eqv f <$> Equiv.traverse eqv g x)

tactic: congr
state_before: t t' : Type u → Type u
eqv : (α : Type u) → t α ≃ t' α
inst✝⁵ : Traversable t
inst✝⁴ : IsLawfulTraversable t
F G : Type u → Type u
inst✝³ : Applicative F
inst✝² : Applicative G
inst✝¹ : LawfulApplicative F
inst✝ : LawfulApplicative G
η : ApplicativeTransformation F G
α β γ : Type u
f : β → F γ
g : α → G β
x : t' α
⊢ Comp.mk (((fun x => ↑(eqv γ) <$> x) ∘ traverse f) <$> traverse g (↑(eqv α).symm x)) =
    Comp.mk (((fun x => ↑(eqv γ) <$> traverse f (↑(eqv β).symm x)) ∘ ↑(eqv β)) <$> traverse g (↑(eqv α).symm x))

tactic: ext
state_before: case e_x.e_a
t t' : Type u → Type u
eqv : (α : Type u) → t α ≃ t' α
inst✝⁵ : Traversable t
inst✝⁴ : IsLawfulTraversable t
F G : Type u → Type u
inst✝³ : Applicative F
inst✝² : Applicative G
inst✝¹ : LawfulApplicative F
inst✝ : LawfulApplicative G
η : ApplicativeTransformation F G
α β γ : Type u
f : β → F γ
g : α → G β
x : t' α
⊢ (fun x => ↑(eqv γ) <$> x) ∘ traverse f = (fun x => ↑(eqv γ) <$> traverse f (↑(eqv β).symm x)) ∘ ↑(eqv β)

tactic: simp
state_before: case e_x.e_a.h
t t' : Type u → Type u
eqv : (α : Type u) → t α ≃ t' α
inst✝⁵ : Traversable t
inst✝⁴ : IsLawfulTraversable t
F G : Type u → Type u
inst✝³ : Applicative F
inst✝² : Applicative G
inst✝¹ : LawfulApplicative F
inst✝ : LawfulApplicative G
η : ApplicativeTransformation F G
α β γ : Type u
f : β → F γ
g : α → G β
x : t' α
x✝ : t β
⊢ ((fun x => ↑(eqv γ) <$> x) ∘ traverse f) x✝ = ((fun x => ↑(eqv γ) <$> traverse f (↑(eqv β).symm x)) ∘ ↑(eqv β)) x✝
Theorem: FreeProduct.NeWord.inv_head
File: Mathlib/GroupTheory/FreeProduct.lean

tactic: induction w <;> simp [inv, *]
state_before: ι : Type u_1
M : ι → Type ?u.649174
inst✝² : (i : ι) → Monoid (M i)
N : Type ?u.649185
inst✝¹ : Monoid N
G : ι → Type u_2
inst✝ : (i : ι) → Group (G i)
i j : ι
w : NeWord G i j
⊢ head (inv w) = (last w)⁻¹
Theorem: CategoryTheory.Endofunctor.Coalgebra.iso_of_iso
File: Mathlib/CategoryTheory/Endofunctor/Algebra.lean

tactic: rw [IsIso.eq_inv_comp f.1, ← Category.assoc, ← f.h, Category.assoc]
state_before: C : Type u
inst✝¹ : Category C
F : C ⥤ C
V V₀ V₁ V₂ : Coalgebra F
f✝ : V₀ ⟶ V₁
g : V₁ ⟶ V₂
f : V₀ ⟶ V₁
inst✝ : IsIso f.f
⊢ V₁.str ≫ F.map (inv f.f) = inv f.f ≫ V₀.str

tactic: simp
state_before: C : Type u
inst✝¹ : Category C
F : C ⥤ C
V V₀ V₁ V₂ : Coalgebra F
f✝ : V₀ ⟶ V₁
g : V₁ ⟶ V₂
f : V₀ ⟶ V₁
inst✝ : IsIso f.f
⊢ V₀.str ≫ F.map f.f ≫ F.map (inv f.f) = V₀.str

tactic: aesop_cat
state_before: C : Type u
inst✝¹ : Category C
F : C ⥤ C
V V₀ V₁ V₂ : Coalgebra F
f✝ : V₀ ⟶ V₁
g : V₁ ⟶ V₂
f : V₀ ⟶ V₁
inst✝ : IsIso f.f
⊢ f ≫ Hom.mk (inv f.f) = 𝟙 V₀

tactic: aesop_cat
state_before: C : Type u
inst✝¹ : Category C
F : C ⥤ C
V V₀ V₁ V₂ : Coalgebra F
f✝ : V₀ ⟶ V₁
g : V₁ ⟶ V₂
f : V₀ ⟶ V₁
inst✝ : IsIso f.f
⊢ Hom.mk (inv f.f) ≫ f = 𝟙 V₁
Theorem: Ideal.hasBasis_nhds_zero_adic
File: Mathlib/Topology/Algebra/Nonarchimedean/AdicTopology.lean

tactic: intro U
state_before: R : Type u_1
inst✝ : CommRing R
I : Ideal R
⊢ ∀ (t : Set R), t ∈ 𝓝 0 ↔ ∃ i, True ∧ ↑(I ^ i) ⊆ t

tactic: rw [I.ringFilterBasis.toAddGroupFilterBasis.nhds_zero_hasBasis.mem_iff]
state_before: R : Type u_1
inst✝ : CommRing R
I : Ideal R
U : Set R
⊢ U ∈ 𝓝 0 ↔ ∃ i, True ∧ ↑(I ^ i) ⊆ U

tactic: constructor
state_before: R : Type u_1
inst✝ : CommRing R
I : Ideal R
U : Set R
⊢ (∃ i, i ∈ RingFilterBasis.toAddGroupFilterBasis ∧ id i ⊆ U) ↔ ∃ i, True ∧ ↑(I ^ i) ⊆ U

tactic: rintro ⟨-, ⟨i, rfl⟩, h⟩
state_before: case mp
R : Type u_1
inst✝ : CommRing R
I : Ideal R
U : Set R
⊢ (∃ i, i ∈ RingFilterBasis.toAddGroupFilterBasis ∧ id i ⊆ U) → ∃ i, True ∧ ↑(I ^ i) ⊆ U

tactic: replace h : ↑(I ^ i) ⊆ U := by simpa using h
state_before: case mp.intro.intro.intro
R : Type u_1
inst✝ : CommRing R
I : Ideal R
U : Set R
i : ℕ
h : id ↑((fun i => toAddSubgroup (I ^ i • ⊤)) i) ⊆ U
⊢ ∃ i, True ∧ ↑(I ^ i) ⊆ U

tactic: exact ⟨i, trivial, h⟩
state_before: case mp.intro.intro.intro
R : Type u_1
inst✝ : CommRing R
I : Ideal R
U : Set R
i : ℕ
h : ↑(I ^ i) ⊆ U
⊢ ∃ i, True ∧ ↑(I ^ i) ⊆ U

tactic: simpa using h
state_before: R : Type u_1
inst✝ : CommRing R
I : Ideal R
U : Set R
i : ℕ
h : id ↑((fun i => toAddSubgroup (I ^ i • ⊤)) i) ⊆ U
⊢ ↑(I ^ i) ⊆ U

tactic: rintro ⟨i, -, h⟩
state_before: case mpr
R : Type u_1
inst✝ : CommRing R
I : Ideal R
U : Set R
⊢ (∃ i, True ∧ ↑(I ^ i) ⊆ U) → ∃ i, i ∈ RingFilterBasis.toAddGroupFilterBasis ∧ id i ⊆ U

tactic: exact ⟨(I ^ i : Ideal R), ⟨i, by simp⟩, h⟩
state_before: case mpr.intro.intro
R : Type u_1
inst✝ : CommRing R
I : Ideal R
U : Set R
i : ℕ
h : ↑(I ^ i) ⊆ U
⊢ ∃ i, i ∈ RingFilterBasis.toAddGroupFilterBasis ∧ id i ⊆ U

tactic: simp
state_before: R : Type u_1
inst✝ : CommRing R
I : Ideal R
U : Set R
i : ℕ
h : ↑(I ^ i) ⊆ U
⊢ ↑(I ^ i) = ↑((fun i => toAddSubgroup (I ^ i • ⊤)) i)
Theorem: norm_le_mul_norm_add
File: Mathlib/Analysis/Normed/Group/Basic.lean

tactic: rw [mul_div_cancel'']
state_before: 𝓕 : Type ?u.86827
𝕜 : Type ?u.86830
α : Type ?u.86833
ι : Type ?u.86836
κ : Type ?u.86839
E : Type u_1
F : Type ?u.86845
G : Type ?u.86848
inst✝² : SeminormedGroup E
inst✝¹ : SeminormedGroup F
inst✝ : SeminormedGroup G
s : Set E
a a₁ a₂ b b₁ b₂ : E
r r₁ r₂ : ℝ
u v : E
⊢ ‖u‖ = ‖u * v / v‖
Theorem: Encodable.decode₂_ne_none_iff
File: Mathlib/Logic/Encodable/Basic.lean

tactic: simp_rw [Set.range, Set.mem_setOf_eq, Ne.def, Option.eq_none_iff_forall_not_mem,
  Encodable.mem_decode₂, not_forall, not_not]
state_before: α : Type u_1
β : Type ?u.7543
inst✝ : Encodable α
n : ℕ
⊢ decode₂ α n ≠ none ↔ n ∈ Set.range encode
Theorem: Cardinal.nat_lt_lift_iff
File: Mathlib/SetTheory/Cardinal/Basic.lean

tactic: rw [← lift_natCast.{v,u}, lift_lt]
state_before: α β : Type u
n : ℕ
a : Cardinal
⊢ ↑n < lift a ↔ ↑n < a
Theorem: Nat.ArithmeticFunction.isMultiplicative_sigma
File: Mathlib/NumberTheory/ArithmeticFunction.lean

tactic: rw [← zeta_mul_pow_eq_sigma]
state_before: R : Type ?u.546111
k : ℕ
⊢ IsMultiplicative (σ k)

tactic: apply isMultiplicative_zeta.mul isMultiplicative_pow
state_before: R : Type ?u.546111
k : ℕ
⊢ IsMultiplicative (ζ * pow k)
Theorem: Trivialization.Prod.left_inv
File: Mathlib/Topology/FiberBundle/Constructions.lean

tactic: obtain ⟨x, v₁, v₂⟩ := x
state_before: B : Type u_1
inst✝⁶ : TopologicalSpace B
F₁ : Type u_4
inst✝⁵ : TopologicalSpace F₁
E₁ : B → Type u_3
inst✝⁴ : TopologicalSpace (TotalSpace E₁)
F₂ : Type u_5
inst✝³ : TopologicalSpace F₂
E₂ : B → Type u_2
inst✝² : TopologicalSpace (TotalSpace E₂)
e₁ : Trivialization F₁ TotalSpace.proj
e₂ : Trivialization F₂ TotalSpace.proj
inst✝¹ : (x : B) → Zero (E₁ x)
inst✝ : (x : B) → Zero (E₂ x)
x : TotalSpace fun x => E₁ x × E₂ x
h : x ∈ TotalSpace.proj ⁻¹' (e₁.baseSet ∩ e₂.baseSet)
⊢ invFun' e₁ e₂ (toFun' e₁ e₂ x) = x

tactic: obtain ⟨h₁ : x ∈ e₁.baseSet, h₂ : x ∈ e₂.baseSet⟩ := h
state_before: case mk.mk
B : Type u_1
inst✝⁶ : TopologicalSpace B
F₁ : Type u_4
inst✝⁵ : TopologicalSpace F₁
E₁ : B → Type u_3
inst✝⁴ : TopologicalSpace (TotalSpace E₁)
F₂ : Type u_5
inst✝³ : TopologicalSpace F₂
E₂ : B → Type u_2
inst✝² : TopologicalSpace (TotalSpace E₂)
e₁ : Trivialization F₁ TotalSpace.proj
e₂ : Trivialization F₂ TotalSpace.proj
inst✝¹ : (x : B) → Zero (E₁ x)
inst✝ : (x : B) → Zero (E₂ x)
x : B
v₁ : E₁ x
v₂ : E₂ x
h : { fst := x, snd := (v₁, v₂) } ∈ TotalSpace.proj ⁻¹' (e₁.baseSet ∩ e₂.baseSet)
⊢ invFun' e₁ e₂ (toFun' e₁ e₂ { fst := x, snd := (v₁, v₂) }) = { fst := x, snd := (v₁, v₂) }

tactic: simp only [Prod.toFun', Prod.invFun', symm_apply_apply_mk, h₁, h₂]
state_before: case mk.mk.intro
B : Type u_1
inst✝⁶ : TopologicalSpace B
F₁ : Type u_4
inst✝⁵ : TopologicalSpace F₁
E₁ : B → Type u_3
inst✝⁴ : TopologicalSpace (TotalSpace E₁)
F₂ : Type u_5
inst✝³ : TopologicalSpace F₂
E₂ : B → Type u_2
inst✝² : TopologicalSpace (TotalSpace E₂)
e₁ : Trivialization F₁ TotalSpace.proj
e₂ : Trivialization F₂ TotalSpace.proj
inst✝¹ : (x : B) → Zero (E₁ x)
inst✝ : (x : B) → Zero (E₂ x)
x : B
v₁ : E₁ x
v₂ : E₂ x
h₁ : x ∈ e₁.baseSet
h₂ : x ∈ e₂.baseSet
⊢ invFun' e₁ e₂ (toFun' e₁ e₂ { fst := x, snd := (v₁, v₂) }) = { fst := x, snd := (v₁, v₂) }
Theorem: Nat.exists_factorization_lt_of_lt
File: Mathlib/Data/Nat/Factorization/Basic.lean

tactic: have hb : b ≠ 0 := (ha.bot_lt.trans hab).ne'
state_before: a b : ℕ
ha : a ≠ 0
hab : a < b
⊢ ∃ p, ↑(factorization a) p < ↑(factorization b) p

tactic: contrapose! hab
state_before: a b : ℕ
ha : a ≠ 0
hab : a < b
hb : b ≠ 0
⊢ ∃ p, ↑(factorization a) p < ↑(factorization b) p

tactic: simp_rw [not_exists, not_lt] at hab
state_before: a b : ℕ
ha : a ≠ 0
hb : b ≠ 0
hab : ¬∃ p, ↑(factorization a) p < ↑(factorization b) p
⊢ b ≤ a

tactic: rw [← Finsupp.le_def, factorization_le_iff_dvd hb ha] at hab
state_before: a b : ℕ
ha : a ≠ 0
hb : b ≠ 0
hab : ∀ (x : ℕ), ↑(factorization b) x ≤ ↑(factorization a) x
⊢ b ≤ a

tactic: exact le_of_dvd ha.bot_lt hab
state_before: a b : ℕ
ha : a ≠ 0
hb : b ≠ 0
hab : b ∣ a
⊢ b ≤ a
Theorem: List.splitOnP_eq_splitOnPTR
File: Std/Data/List/Basic.lean

tactic: funext α P l
state_before: ⊢ @splitOnP = @splitOnPTR

tactic: simp [splitOnPTR]
state_before: case h.h.h
α : Type u_1
P : α → Bool
l : List α
⊢ splitOnP P l = splitOnPTR P l

tactic: suffices ∀ xs acc r, splitOnPTR.go P xs acc r = r.data ++ splitOnP.go P xs acc.data.reverse from
  (this l #[] #[]).symm
state_before: case h.h.h
α : Type u_1
P : α → Bool
l : List α
⊢ splitOnP P l = splitOnPTR.go P l #[] #[]

tactic: intro xs acc r
state_before: case h.h.h
α : Type u_1
P : α → Bool
l : List α
⊢ ∀ (xs : List α) (acc : Array α) (r : Array (List α)),
    splitOnPTR.go P xs acc r = r.data ++ splitOnP.go P xs (reverse acc.data)

tactic: induction xs generalizing acc r with simp [splitOnP.go, splitOnPTR.go]
| cons x xs IH => cases P x <;> simp [*]
state_before: case h.h.h
α : Type u_1
P : α → Bool
l xs : List α
acc : Array α
r : Array (List α)
⊢ splitOnPTR.go P xs acc r = r.data ++ splitOnP.go P xs (reverse acc.data)

tactic: cases P x <;> simp [*]
state_before: case h.h.h.cons
α : Type u_1
P : α → Bool
l : List α
x : α
xs : List α
IH : ∀ (acc : Array α) (r : Array (List α)), splitOnPTR.go P xs acc r = r.data ++ splitOnP.go P xs (reverse acc.data)
acc : Array α
r : Array (List α)
⊢ (bif P x then splitOnPTR.go P xs #[] (Array.push r acc.data) else splitOnPTR.go P xs (Array.push acc x) r) =
    r.data ++ if P x = true then acc.data :: splitOnP.go P xs [] else splitOnP.go P xs (x :: reverse acc.data)
Theorem: TopologicalRing.of_addGroup_of_nhds_zero
File: Mathlib/Topology/Algebra/Ring/Basic.lean

tactic: refine continuous_of_continuousAt_zero₂ (AddMonoidHom.mul (R := R)) ?_ ?_ ?_ <;>
  simpa only [ContinuousAt, mul_zero, zero_mul, nhds_prod_eq, AddMonoidHom.mul_apply]
state_before: α : Type ?u.17126
R : Type u_1
inst✝² : NonUnitalNonAssocRing R
inst✝¹ : TopologicalSpace R
inst✝ : TopologicalAddGroup R
hmul : Tendsto (uncurry fun x x_1 => x * x_1) (𝓝 0 ×ˢ 𝓝 0) (𝓝 0)
hmul_left : ∀ (x₀ : R), Tendsto (fun x => x₀ * x) (𝓝 0) (𝓝 0)
hmul_right : ∀ (x₀ : R), Tendsto (fun x => x * x₀) (𝓝 0) (𝓝 0)
⊢ Continuous fun p => p.fst * p.snd
Theorem: TopologicalGroup.ext
File: Mathlib/Topology/Algebra/Group/Basic.lean

tactic: rw [← @nhds_translation_mul_inv G t _ _ x, ← @nhds_translation_mul_inv G t' _ _ x, ← h]
state_before: α : Type u
β : Type v
G✝ : Type w
H : Type x
inst✝⁴ : TopologicalSpace G✝
inst✝³ : Group G✝
inst✝² : TopologicalGroup G✝
inst✝¹ : TopologicalSpace α
f : α → G✝
s : Set α
x✝ : α
G : Type u_1
inst✝ : Group G
t t' : TopologicalSpace G
tg : TopologicalGroup G
tg' : TopologicalGroup G
h : 𝓝 1 = 𝓝 1
x : G
⊢ 𝓝 x = 𝓝 x
Theorem: Multiset.Ioo_cons_left
File: Mathlib/Data/Multiset/LocallyFinite.lean

tactic: classical
  rw [Ioo, ← Finset.insert_val_of_not_mem left_not_mem_Ioo, Finset.Ioo_insert_left h]
  rfl
state_before: α : Type u_1
inst✝¹ : PartialOrder α
inst✝ : LocallyFiniteOrder α
a b : α
h : a < b
⊢ a ::ₘ Ioo a b = Ico a b

tactic: rw [Ioo, ← Finset.insert_val_of_not_mem left_not_mem_Ioo, Finset.Ioo_insert_left h]
state_before: α : Type u_1
inst✝¹ : PartialOrder α
inst✝ : LocallyFiniteOrder α
a b : α
h : a < b
⊢ a ::ₘ Ioo a b = Ico a b

tactic: rfl
state_before: α : Type u_1
inst✝¹ : PartialOrder α
inst✝ : LocallyFiniteOrder α
a b : α
h : a < b
⊢ (Finset.Ico a b).val = Ico a b
Theorem: multiplicity.multiplicity_eq_zero
File: Mathlib/RingTheory/Multiplicity.lean

tactic: rw [← Nat.cast_zero, eq_coe_iff]
state_before: α : Type u_1
inst✝¹ : Monoid α
inst✝ : DecidableRel fun x x_1 => x ∣ x_1
a b : α
⊢ multiplicity a b = 0 ↔ ¬a ∣ b

tactic: simp only [_root_.pow_zero, isUnit_one, IsUnit.dvd, zero_add, pow_one, true_and]
state_before: α : Type u_1
inst✝¹ : Monoid α
inst✝ : DecidableRel fun x x_1 => x ∣ x_1
a b : α
⊢ a ^ 0 ∣ b ∧ ¬a ^ (0 + 1) ∣ b ↔ ¬a ∣ b