tasksource/leandojo huggingface dataset:
Theorem: ENNReal.tsum_mul_left
File: Mathlib/Topology/Instances/ENNReal.lean

tactic: by_cases hf : ∀ i, f i = 0
state_before: α : Type u_1
β : Type ?u.252239
γ : Type ?u.252242
a b c d : ℝ≥0∞
r p q : ℝ≥0
x y z ε ε₁ ε₂ : ℝ≥0∞
s : Set ℝ≥0∞
f g : α → ℝ≥0∞
⊢ (∑' (i : α), a * f i) = a * ∑' (i : α), f i

tactic: simp [hf]
state_before: case pos
α : Type u_1
β : Type ?u.252239
γ : Type ?u.252242
a b c d : ℝ≥0∞
r p q : ℝ≥0
x y z ε ε₁ ε₂ : ℝ≥0∞
s : Set ℝ≥0∞
f g : α → ℝ≥0∞
hf : ∀ (i : α), f i = 0
⊢ (∑' (i : α), a * f i) = a * ∑' (i : α), f i

tactic: rw [← ENNReal.tsum_eq_zero] at hf
state_before: case neg
α : Type u_1
β : Type ?u.252239
γ : Type ?u.252242
a b c d : ℝ≥0∞
r p q : ℝ≥0
x y z ε ε₁ ε₂ : ℝ≥0∞
s : Set ℝ≥0∞
f g : α → ℝ≥0∞
hf : ¬∀ (i : α), f i = 0
⊢ (∑' (i : α), a * f i) = a * ∑' (i : α), f i

tactic: have : Tendsto (fun s : Finset α => ∑ j in s, a * f j) atTop (𝓝 (a * ∑' i, f i)) := by
  simp only [← Finset.mul_sum]
  exact ENNReal.Tendsto.const_mul ENNReal.summable.hasSum (Or.inl hf)
state_before: case neg
α : Type u_1
β : Type ?u.252239
γ : Type ?u.252242
a b c d : ℝ≥0∞
r p q : ℝ≥0
x y z ε ε₁ ε₂ : ℝ≥0∞
s : Set ℝ≥0∞
f g : α → ℝ≥0∞
hf : ¬(∑' (i : α), f i) = 0
⊢ (∑' (i : α), a * f i) = a * ∑' (i : α), f i

tactic: exact HasSum.tsum_eq this
state_before: case neg
α : Type u_1
β : Type ?u.252239
γ : Type ?u.252242
a b c d : ℝ≥0∞
r p q : ℝ≥0
x y z ε ε₁ ε₂ : ℝ≥0∞
s : Set ℝ≥0∞
f g : α → ℝ≥0∞
hf : ¬(∑' (i : α), f i) = 0
this : Tendsto (fun s => ∑ j in s, a * f j) atTop (𝓝 (a * ∑' (i : α), f i))
⊢ (∑' (i : α), a * f i) = a * ∑' (i : α), f i

tactic: simp only [← Finset.mul_sum]
state_before: α : Type u_1
β : Type ?u.252239
γ : Type ?u.252242
a b c d : ℝ≥0∞
r p q : ℝ≥0
x y z ε ε₁ ε₂ : ℝ≥0∞
s : Set ℝ≥0∞
f g : α → ℝ≥0∞
hf : ¬(∑' (i : α), f i) = 0
⊢ Tendsto (fun s => ∑ j in s, a * f j) atTop (𝓝 (a * ∑' (i : α), f i))

tactic: exact ENNReal.Tendsto.const_mul ENNReal.summable.hasSum (Or.inl hf)
state_before: α : Type u_1
β : Type ?u.252239
γ : Type ?u.252242
a b c d : ℝ≥0∞
r p q : ℝ≥0
x y z ε ε₁ ε₂ : ℝ≥0∞
s : Set ℝ≥0∞
f g : α → ℝ≥0∞
hf : ¬(∑' (i : α), f i) = 0
⊢ Tendsto (fun s => a * ∑ x in s, f x) atTop (𝓝 (a * ∑' (x : α), f x))
Theorem: CategoryTheory.Iso.homCongr_comp
File: Mathlib/CategoryTheory/Conj.lean

tactic: simp
state_before: C : Type u
inst✝ : Category C
X Y Z X₁ Y₁ Z₁ : C
α : X ≅ X₁
β : Y ≅ Y₁
γ : Z ≅ Z₁
f : X ⟶ Y
g : Y ⟶ Z
⊢ ↑(homCongr α γ) (f ≫ g) = ↑(homCongr α β) f ≫ ↑(homCongr β γ) g
Theorem: Polynomial.not_isUnit_X
File: Mathlib/Data/Polynomial/Degree/Definitions.lean

tactic: conv at hgf => change g * monomial 1 1 = 1
state_before: R : Type u
S : Type v
a b c d : R
n m : ℕ
inst✝¹ : Semiring R
inst✝ : Nontrivial R
p q : R[X]
x✝ : IsUnit X
g : R[X]
_hfg : ↑(monomial 1) 1 * g = 1
hgf : g * ↑(monomial 1) 1 = 1
⊢ 0 = 1

tactic: rw [← coeff_one_zero, ← hgf]
state_before: R : Type u
S : Type v
a b c d : R
n m : ℕ
inst✝¹ : Semiring R
inst✝ : Nontrivial R
p q : R[X]
x✝ : IsUnit X
g : R[X]
_hfg : ↑(monomial 1) 1 * g = 1
hgf : g * ↑(monomial 1) 1 = 1
⊢ 0 = 1

tactic: simp
state_before: R : Type u
S : Type v
a b c d : R
n m : ℕ
inst✝¹ : Semiring R
inst✝ : Nontrivial R
p q : R[X]
x✝ : IsUnit X
g : R[X]
_hfg : ↑(monomial 1) 1 * g = 1
hgf : g * ↑(monomial 1) 1 = 1
⊢ 0 = coeff (g * ↑(monomial 1) 1) 0
Theorem: Set.multiset_prod_subset_multiset_prod
File: Mathlib/Data/Set/Pointwise/BigOperators.lean

tactic: induction t using Quotient.inductionOn
state_before: ι : Type u_1
α : Type u_2
β : Type ?u.79804
F : Type ?u.79807
inst✝² : CommMonoid α
inst✝¹ : CommMonoid β
inst✝ : MonoidHomClass F α β
t : Multiset ι
f₁ f₂ : ι → Set α
hf : ∀ (i : ι), i ∈ t → f₁ i ⊆ f₂ i
⊢ Multiset.prod (Multiset.map f₁ t) ⊆ Multiset.prod (Multiset.map f₂ t)

tactic: simp_rw [Multiset.quot_mk_to_coe, Multiset.coe_map, Multiset.coe_prod]
state_before: case h
ι : Type u_1
α : Type u_2
β : Type ?u.79804
F : Type ?u.79807
inst✝² : CommMonoid α
inst✝¹ : CommMonoid β
inst✝ : MonoidHomClass F α β
f₁ f₂ : ι → Set α
a✝ : List ι
hf : ∀ (i : ι), i ∈ Quotient.mk (List.isSetoid ι) a✝ → f₁ i ⊆ f₂ i
⊢ Multiset.prod (Multiset.map f₁ (Quotient.mk (List.isSetoid ι) a✝)) ⊆
    Multiset.prod (Multiset.map f₂ (Quotient.mk (List.isSetoid ι) a✝))

tactic: exact list_prod_subset_list_prod _ _ _ hf
state_before: case h
ι : Type u_1
α : Type u_2
β : Type ?u.79804
F : Type ?u.79807
inst✝² : CommMonoid α
inst✝¹ : CommMonoid β
inst✝ : MonoidHomClass F α β
f₁ f₂ : ι → Set α
a✝ : List ι
hf : ∀ (i : ι), i ∈ Quotient.mk (List.isSetoid ι) a✝ → f₁ i ⊆ f₂ i
⊢ List.prod (List.map f₁ a✝) ⊆ List.prod (List.map f₂ a✝)
Theorem: Multiset.stronglyMeasurable_prod
File: Mathlib/MeasureTheory/Function/StronglyMeasurable/Basic.lean

tactic: simpa only [← Pi.multiset_prod_apply] using s.stronglyMeasurable_prod' hs
state_before: α : Type u_1
β : Type ?u.127112
γ : Type ?u.127115
ι : Type ?u.127118
inst✝³ : Countable ι
f g : α → β
M : Type u_2
inst✝² : CommMonoid M
inst✝¹ : TopologicalSpace M
inst✝ : ContinuousMul M
m : MeasurableSpace α
s : Multiset (α → M)
hs : ∀ (f : α → M), f ∈ s → StronglyMeasurable f
⊢ StronglyMeasurable fun x => Multiset.prod (Multiset.map (fun f => f x) s)
Theorem: MeasureTheory.snorm'_const_smul
File: Mathlib/MeasureTheory/Function/LpSeminorm.lean

tactic: obtain rfl | hc := eq_or_ne c 0
state_before: α : Type u_1
E : Type ?u.5959548
F : Type u_2
G : Type ?u.5959554
m m0 : MeasurableSpace α
p : ℝ≥0∞
q : ℝ
μ ν : Measure α
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedAddCommGroup F
inst✝⁵ : NormedAddCommGroup G
𝕜 : Type u_3
inst✝⁴ : NormedDivisionRing 𝕜
inst✝³ : MulActionWithZero 𝕜 E
inst✝² : Module 𝕜 F
inst✝¹ : BoundedSMul 𝕜 E
inst✝ : BoundedSMul 𝕜 F
f : α → F
c : 𝕜
hq_pos : 0 < q
⊢ snorm' (c • f) q μ = ‖c‖₊ • snorm' f q μ

tactic: refine' le_antisymm (snorm'_const_smul_le _ _ hq_pos) _
state_before: case inr
α : Type u_1
E : Type ?u.5959548
F : Type u_2
G : Type ?u.5959554
m m0 : MeasurableSpace α
p : ℝ≥0∞
q : ℝ
μ ν : Measure α
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedAddCommGroup F
inst✝⁵ : NormedAddCommGroup G
𝕜 : Type u_3
inst✝⁴ : NormedDivisionRing 𝕜
inst✝³ : MulActionWithZero 𝕜 E
inst✝² : Module 𝕜 F
inst✝¹ : BoundedSMul 𝕜 E
inst✝ : BoundedSMul 𝕜 F
f : α → F
c : 𝕜
hq_pos : 0 < q
hc : c ≠ 0
⊢ snorm' (c • f) q μ = ‖c‖₊ • snorm' f q μ

tactic: have : snorm' _ q μ ≤ _ := snorm'_const_smul_le c⁻¹ (c • f) hq_pos
state_before: case inr
α : Type u_1
E : Type ?u.5959548
F : Type u_2
G : Type ?u.5959554
m m0 : MeasurableSpace α
p : ℝ≥0∞
q : ℝ
μ ν : Measure α
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedAddCommGroup F
inst✝⁵ : NormedAddCommGroup G
𝕜 : Type u_3
inst✝⁴ : NormedDivisionRing 𝕜
inst✝³ : MulActionWithZero 𝕜 E
inst✝² : Module 𝕜 F
inst✝¹ : BoundedSMul 𝕜 E
inst✝ : BoundedSMul 𝕜 F
f : α → F
c : 𝕜
hq_pos : 0 < q
hc : c ≠ 0
⊢ ‖c‖₊ • snorm' f q μ ≤ snorm' (c • f) q μ

tactic: rwa [inv_smul_smul₀ hc, nnnorm_inv, ENNReal.le_inv_smul_iff (nnnorm_ne_zero_iff.mpr hc)] at this
state_before: case inr
α : Type u_1
E : Type ?u.5959548
F : Type u_2
G : Type ?u.5959554
m m0 : MeasurableSpace α
p : ℝ≥0∞
q : ℝ
μ ν : Measure α
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedAddCommGroup F
inst✝⁵ : NormedAddCommGroup G
𝕜 : Type u_3
inst✝⁴ : NormedDivisionRing 𝕜
inst✝³ : MulActionWithZero 𝕜 E
inst✝² : Module 𝕜 F
inst✝¹ : BoundedSMul 𝕜 E
inst✝ : BoundedSMul 𝕜 F
f : α → F
c : 𝕜
hq_pos : 0 < q
hc : c ≠ 0
this : snorm' (c⁻¹ • c • f) q μ ≤ ‖c⁻¹‖₊ • snorm' (c • f) q μ
⊢ ‖c‖₊ • snorm' f q μ ≤ snorm' (c • f) q μ

tactic: simp [snorm', hq_pos]
state_before: case inl
α : Type u_1
E : Type ?u.5959548
F : Type u_2
G : Type ?u.5959554
m m0 : MeasurableSpace α
p : ℝ≥0∞
q : ℝ
μ ν : Measure α
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedAddCommGroup F
inst✝⁵ : NormedAddCommGroup G
𝕜 : Type u_3
inst✝⁴ : NormedDivisionRing 𝕜
inst✝³ : MulActionWithZero 𝕜 E
inst✝² : Module 𝕜 F
inst✝¹ : BoundedSMul 𝕜 E
inst✝ : BoundedSMul 𝕜 F
f : α → F
hq_pos : 0 < q
⊢ snorm' (0 • f) q μ = ‖0‖₊ • snorm' f q μ
Theorem: isOpen_setOf_eventually_nhds
File: Mathlib/Topology/Basic.lean

tactic: simp only [← interior_setOf_eq, isOpen_interior]
state_before: α : Type u
β : Type v
ι : Sort w
a : α
s s₁ s₂ t : Set α
p✝ p₁ p₂ : α → Prop
inst✝ : TopologicalSpace α
p : α → Prop
⊢ IsOpen {x | ∀ᶠ (y : α) in 𝓝 x, p y}
Theorem: Std.RBNode.foldr_eq_foldr_toList
File: Std/Data/RBMap/Lemmas.lean

tactic: induction t generalizing init <;> simp [*]
state_before: α : Type u_1
α✝ : Type u_2
f : α → α✝ → α✝
init : α✝
t : RBNode α
⊢ foldr f t init = List.foldr f init (toList t)
Theorem: Ideal.cotangent_subsingleton_iff
File: Mathlib/RingTheory/Ideal/Cotangent.lean

tactic: constructor
state_before: R : Type u
S : Type v
S' : Type w
inst✝⁶ : CommRing R
inst✝⁵ : CommSemiring S
inst✝⁴ : Algebra S R
inst✝³ : CommSemiring S'
inst✝² : Algebra S' R
inst✝¹ : Algebra S S'
inst✝ : IsScalarTower S S' R
I : Ideal R
⊢ Subsingleton (Cotangent I) ↔ IsIdempotentElem I

tactic: intro H
state_before: case mp
R : Type u
S : Type v
S' : Type w
inst✝⁶ : CommRing R
inst✝⁵ : CommSemiring S
inst✝⁴ : Algebra S R
inst✝³ : CommSemiring S'
inst✝² : Algebra S' R
inst✝¹ : Algebra S S'
inst✝ : IsScalarTower S S' R
I : Ideal R
⊢ Subsingleton (Cotangent I) → IsIdempotentElem I

tactic: refine' (pow_two I).symm.trans (le_antisymm (Ideal.pow_le_self two_ne_zero) _)
state_before: case mp
R : Type u
S : Type v
S' : Type w
inst✝⁶ : CommRing R
inst✝⁵ : CommSemiring S
inst✝⁴ : Algebra S R
inst✝³ : CommSemiring S'
inst✝² : Algebra S' R
inst✝¹ : Algebra S S'
inst✝ : IsScalarTower S S' R
I : Ideal R
H : Subsingleton (Cotangent I)
⊢ IsIdempotentElem I

tactic: exact fun x hx => (I.toCotangent_eq_zero ⟨x, hx⟩).mp (Subsingleton.elim _ _)
state_before: case mp
R : Type u
S : Type v
S' : Type w
inst✝⁶ : CommRing R
inst✝⁵ : CommSemiring S
inst✝⁴ : Algebra S R
inst✝³ : CommSemiring S'
inst✝² : Algebra S' R
inst✝¹ : Algebra S S'
inst✝ : IsScalarTower S S' R
I : Ideal R
H : Subsingleton (Cotangent I)
⊢ I ≤ I ^ 2

tactic: exact fun e =>
  ⟨fun x y =>
    Quotient.inductionOn₂' x y fun x y =>
      I.toCotangent_eq.mpr <| ((pow_two I).trans e).symm ▸ I.sub_mem x.prop y.prop⟩
state_before: case mpr
R : Type u
S : Type v
S' : Type w
inst✝⁶ : CommRing R
inst✝⁵ : CommSemiring S
inst✝⁴ : Algebra S R
inst✝³ : CommSemiring S'
inst✝² : Algebra S' R
inst✝¹ : Algebra S S'
inst✝ : IsScalarTower S S' R
I : Ideal R
⊢ IsIdempotentElem I → Subsingleton (Cotangent I)
Theorem: Equiv.Perm.sign_prod_list_swap
File: Mathlib/GroupTheory/Perm/Sign.lean

tactic: have h₁ : l.map sign = List.replicate l.length (-1) :=
  List.eq_replicate.2
    ⟨by simp, fun u hu =>
      let ⟨g, hg⟩ := List.mem_map.1 hu
      hg.2 ▸ (hl _ hg.1).sign_eq⟩
state_before: α : Type u
β : Type v
inst✝¹ : DecidableEq α
inst✝ : Fintype α
l : List (Perm α)
hl : ∀ (g : Perm α), g ∈ l → IsSwap g
⊢ ↑sign (List.prod l) = (-1) ^ List.length l

tactic: rw [← List.prod_replicate, ← h₁, List.prod_hom _ (@sign α _ _)]
state_before: α : Type u
β : Type v
inst✝¹ : DecidableEq α
inst✝ : Fintype α
l : List (Perm α)
hl : ∀ (g : Perm α), g ∈ l → IsSwap g
h₁ : List.map (↑sign) l = List.replicate (List.length l) (-1)
⊢ ↑sign (List.prod l) = (-1) ^ List.length l

tactic: simp
state_before: α : Type u
β : Type v
inst✝¹ : DecidableEq α
inst✝ : Fintype α
l : List (Perm α)
hl : ∀ (g : Perm α), g ∈ l → IsSwap g
⊢ List.length (List.map (↑sign) l) = List.length l
Theorem: Finset.card_Iio_eq_card_Iic_sub_one
File: Mathlib/Data/Finset/LocallyFinite.lean

tactic: rw [Iic_eq_cons_Iio, card_cons, add_tsub_cancel_right]
state_before: ι : Type ?u.120186
α : Type u_1
inst✝¹ : PartialOrder α
inst✝ : LocallyFiniteOrderBot α
a : α
⊢ card (Iio a) = card (Iic a) - 1
Theorem: Cardinal.mk_Ioo_real
File: Mathlib/Data/Real/Cardinality.lean

tactic: refine' le_antisymm (mk_real ▸ mk_set_le _) _
state_before: c : ℝ
f g : ℕ → Bool
n : ℕ
a b : ℝ
h : a < b
⊢ (#↑(Ioo a b)) = 𝔠

tactic: have h1 : (#(fun x => x - a) '' Ioo a b) ≤ (#Ioo a b) := mk_image_le
state_before: c : ℝ
f g : ℕ → Bool
n : ℕ
a b : ℝ
h : a < b
⊢ 𝔠 ≤ (#↑(Ioo a b))

tactic: refine' le_trans _ h1
state_before: c : ℝ
f g : ℕ → Bool
n : ℕ
a b : ℝ
h : a < b
h1 : (#↑((fun x => x - a) '' Ioo a b)) ≤ (#↑(Ioo a b))
⊢ 𝔠 ≤ (#↑(Ioo a b))

tactic: rw [image_sub_const_Ioo, sub_self]
state_before: c : ℝ
f g : ℕ → Bool
n : ℕ
a b : ℝ
h : a < b
h1 : (#↑((fun x => x - a) '' Ioo a b)) ≤ (#↑(Ioo a b))
⊢ 𝔠 ≤ (#↑((fun x => x - a) '' Ioo a b))

tactic: replace h := sub_pos_of_lt h
state_before: c : ℝ
f g : ℕ → Bool
n : ℕ
a b : ℝ
h : a < b
h1 : (#↑((fun x => x - a) '' Ioo a b)) ≤ (#↑(Ioo a b))
⊢ 𝔠 ≤ (#↑(Ioo 0 (b - a)))

tactic: have h2 : (#Inv.inv '' Ioo 0 (b - a)) ≤ (#Ioo 0 (b - a)) := mk_image_le
state_before: c : ℝ
f g : ℕ → Bool
n : ℕ
a b : ℝ
h1 : (#↑((fun x => x - a) '' Ioo a b)) ≤ (#↑(Ioo a b))
h : 0 < b - a
⊢ 𝔠 ≤ (#↑(Ioo 0 (b - a)))

tactic: refine' le_trans _ h2
state_before: c : ℝ
f g : ℕ → Bool
n : ℕ
a b : ℝ
h1 : (#↑((fun x => x - a) '' Ioo a b)) ≤ (#↑(Ioo a b))
h : 0 < b - a
h2 : (#↑(Inv.inv '' Ioo 0 (b - a))) ≤ (#↑(Ioo 0 (b - a)))
⊢ 𝔠 ≤ (#↑(Ioo 0 (b - a)))

tactic: rw [image_inv, inv_Ioo_0_left h, mk_Ioi_real]
state_before: c : ℝ
f g : ℕ → Bool
n : ℕ
a b : ℝ
h1 : (#↑((fun x => x - a) '' Ioo a b)) ≤ (#↑(Ioo a b))
h : 0 < b - a
h2 : (#↑(Inv.inv '' Ioo 0 (b - a))) ≤ (#↑(Ioo 0 (b - a)))
⊢ 𝔠 ≤ (#↑(Inv.inv '' Ioo 0 (b - a)))
Theorem: Ideal.inf_eq_mul_of_coprime
File: Mathlib/RingTheory/DedekindDomain/Ideal.lean

tactic: rw [← associated_iff_eq.mp (gcd_mul_lcm I J), lcm_eq_inf I J, gcd_eq_sup, coprime, top_mul]
state_before: R : Type ?u.899540
A : Type u_1
K : Type ?u.899546
inst✝⁶ : CommRing R
inst✝⁵ : CommRing A
inst✝⁴ : Field K
inst✝³ : IsDomain A
inst✝² : IsDedekindDomain A
inst✝¹ : Algebra A K
inst✝ : IsFractionRing A K
I J : Ideal A
coprime : I ⊔ J = ⊤
⊢ I ⊓ J = I * J
Theorem: WithTop.add_eq_top
File: Mathlib/Algebra/Order/Monoid/WithTop.lean

tactic: cases a <;> cases b <;> simp [none_eq_top, some_eq_coe, ← WithTop.coe_add]
state_before: α : Type u
β : Type v
inst✝ : Add α
a b c d : WithTop α
x y : α
⊢ a + b = ⊤ ↔ a = ⊤ ∨ b = ⊤
Theorem: SpectralMap.coe_comp_continuousMap'
File: Mathlib/Topology/Spectral/Hom.lean

tactic: simp only [@coe_comp]
state_before: F : Type ?u.9868
α : Type u_3
β : Type u_1
γ : Type u_2
δ : Type ?u.9880
inst✝³ : TopologicalSpace α
inst✝² : TopologicalSpace β
inst✝¹ : TopologicalSpace γ
inst✝ : TopologicalSpace δ
f : SpectralMap β γ
g : SpectralMap α β
⊢ ContinuousMap.mk ↑(comp f g) = ContinuousMap.comp (ContinuousMap.mk ↑f) (ContinuousMap.mk ↑g)

tactic: rfl
state_before: F : Type ?u.9868
α : Type u_3
β : Type u_1
γ : Type u_2
δ : Type ?u.9880
inst✝³ : TopologicalSpace α
inst✝² : TopologicalSpace β
inst✝¹ : TopologicalSpace γ
inst✝ : TopologicalSpace δ
f : SpectralMap β γ
g : SpectralMap α β
⊢ ContinuousMap.mk (↑f ∘ ↑g) = ContinuousMap.comp (ContinuousMap.mk ↑f) (ContinuousMap.mk ↑g)
Theorem: Sum.getRight_eq_none_iff
File: Mathlib/Data/Sum/Basic.lean

tactic: cases x <;> simp only [getRight, isLeft, eq_self_iff_true]
state_before: α : Type u
α' : Type w
β : Type v
β' : Type x
γ : Type ?u.4983
δ : Type ?u.4986
x y : α ⊕ β
⊢ getRight x = none ↔ isLeft x = true
Theorem: Fermat42.ne_zero
File: Mathlib/NumberTheory/Fermat4.lean

tactic: apply ne_zero_pow two_ne_zero _
state_before: a b c : ℤ
h : Fermat42 a b c
⊢ c ≠ 0

tactic: apply ne_of_gt
state_before: a b c : ℤ
h : Fermat42 a b c
⊢ c ^ 2 ≠ 0

tactic: rw [← h.2.2, (by ring : a ^ 4 + b ^ 4 = (a ^ 2) ^ 2 + (b ^ 2) ^ 2)]
state_before: case h
a b c : ℤ
h : Fermat42 a b c
⊢ 0 < c ^ 2

tactic: exact
  add_pos (sq_pos_of_ne_zero _ (pow_ne_zero 2 h.1)) (sq_pos_of_ne_zero _ (pow_ne_zero 2 h.2.1))
state_before: case h
a b c : ℤ
h : Fermat42 a b c
⊢ 0 < (a ^ 2) ^ 2 + (b ^ 2) ^ 2

tactic: ring
state_before: a b c : ℤ
h : Fermat42 a b c
⊢ a ^ 4 + b ^ 4 = (a ^ 2) ^ 2 + (b ^ 2) ^ 2
Theorem: Nat.eq_one_iff_not_exists_prime_dvd
File: Mathlib/Data/Nat/Prime.lean

tactic: simpa using not_iff_not.mpr ne_one_iff_exists_prime_dvd
state_before: n : ℕ
⊢ n = 1 ↔ ∀ (p : ℕ), Prime p → ¬p ∣ n
Theorem: Nat.eleven_dvd_iff
File: Mathlib/Data/Nat/Digits.lean

tactic: have t := dvd_iff_dvd_ofDigits 11 10 (-1 : ℤ) (by norm_num) n
state_before: n : ℕ
⊢ 11 ∣ n ↔ 11 ∣ List.alternatingSum (List.map (fun n => ↑n) (digits 10 n))

tactic: rw [ofDigits_neg_one] at t
state_before: n : ℕ
t : 11 ∣ n ↔ ↑11 ∣ ofDigits (-1) (digits 10 n)
⊢ 11 ∣ n ↔ 11 ∣ List.alternatingSum (List.map (fun n => ↑n) (digits 10 n))

tactic: exact t
state_before: n : ℕ
t : 11 ∣ n ↔ ↑11 ∣ List.alternatingSum (List.map (fun n => ↑n) (digits 10 n))
⊢ 11 ∣ n ↔ 11 ∣ List.alternatingSum (List.map (fun n => ↑n) (digits 10 n))

tactic: norm_num
state_before: n : ℕ
⊢ ↑11 ∣ ↑10 - -1
Theorem: LocalHomeomorph.map_nhdsWithin_preimage_eq
File: Mathlib/Topology/LocalHomeomorph.lean

tactic: rw [e.map_nhdsWithin_eq hx, e.image_source_inter_eq', e.target_inter_inv_preimage_preimage,
  e.nhdsWithin_target_inter (e.map_source hx)]
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.32937
δ : Type ?u.32940
inst✝³ : TopologicalSpace α
inst✝² : TopologicalSpace β
inst✝¹ : TopologicalSpace γ
inst✝ : TopologicalSpace δ
e✝ : LocalHomeomorph α β
e' : LocalHomeomorph β γ
e : LocalHomeomorph α β
x : α
hx : x ∈ e.source
s : Set β
⊢ map (↑e) (𝓝[↑e ⁻¹' s] x) = 𝓝[s] ↑e x
Theorem: TypeVec.const_append1
File: Mathlib/Data/TypeVec.lean

tactic: ext i : 1
state_before: n✝ : ℕ
β : Type u_1
γ : Type u_2
x : γ
n : ℕ
α : TypeVec n
⊢ TypeVec.const x (α ::: β) = (TypeVec.const x α ::: fun x_1 => x)

tactic: cases i <;> rfl
state_before: case a
n✝ : ℕ
β : Type u_1
γ : Type u_2
x : γ
n : ℕ
α : TypeVec n
i : Fin2 (n + 1)
⊢ TypeVec.const x (α ::: β) i = (TypeVec.const x α ::: fun x_1 => x) i
Theorem: Polynomial.rootMultiplicity_eq_multiplicity
File: Mathlib/Data/Polynomial/Div.lean

tactic: simp [multiplicity, rootMultiplicity, Part.Dom]
state_before: R : Type u
S : Type v
T : Type w
A : Type z
a✝ b : R
n : ℕ
inst✝ : CommRing R
p✝ q p : R[X]
a : R
⊢ rootMultiplicity a p =
    if h0 : p = 0 then 0 else Part.get (multiplicity (X - ↑C a) p) (_ : multiplicity.Finite (X - ↑C a) p)

tactic: congr
state_before: R : Type u
S : Type v
T : Type w
A : Type z
a✝ b : R
n : ℕ
inst✝ : CommRing R
p✝ q p : R[X]
a : R
⊢ (if h : p = 0 then 0 else Nat.find (_ : multiplicity.Finite (X - ↑C a) p)) =
    if h : p = 0 then 0 else Nat.find (_ : (PartENat.find fun n => ¬(X - ↑C a) ^ (n + 1) ∣ p).Dom)

tactic: funext
state_before: case e_e
R : Type u
S : Type v
T : Type w
A : Type z
a✝ b : R
n : ℕ
inst✝ : CommRing R
p✝ q p : R[X]
a : R
⊢ (fun h => Nat.find (_ : multiplicity.Finite (X - ↑C a) p)) = fun h =>
    Nat.find (_ : (PartENat.find fun n => ¬(X - ↑C a) ^ (n + 1) ∣ p).Dom)

tactic: congr
state_before: case e_e.h
R : Type u
S : Type v
T : Type w
A : Type z
a✝ b : R
n : ℕ
inst✝ : CommRing R
p✝ q p : R[X]
a : R
x✝ : ¬p = 0
⊢ Nat.find (_ : multiplicity.Finite (X - ↑C a) p) =
    Nat.find (_ : (PartENat.find fun n => ¬(X - ↑C a) ^ (n + 1) ∣ p).Dom)
Theorem: Matrix.conjTranspose_mul
File: Mathlib/Data/Matrix/Basic.lean

tactic: simp [mul_apply]
state_before: l : Type u_3
m : Type u_2
n : Type u_1
o : Type ?u.1044104
m' : o → Type ?u.1044109
n' : o → Type ?u.1044114
R : Type ?u.1044117
S : Type ?u.1044120
α : Type v
β : Type w
γ : Type ?u.1044127
inst✝² : Fintype n
inst✝¹ : NonUnitalSemiring α
inst✝ : StarRing α
M : Matrix m n α
N : Matrix n l α
⊢ ∀ (i : l) (j : m), (M ⬝ N)ᴴ i j = (Nᴴ ⬝ Mᴴ) i j
Theorem: Polynomial.derivative_monomial
File: Mathlib/Data/Polynomial/Derivative.lean

tactic: rw [derivative_apply, sum_monomial_index, C_mul_X_pow_eq_monomial]
state_before: R : Type u
S : Type v
T : Type w
ι : Type y
A : Type z
a✝ b : R
n✝ : ℕ
inst✝ : Semiring R
a : R
n : ℕ
⊢ ↑derivative (↑(monomial n) a) = ↑(monomial (n - 1)) (a * ↑n)

tactic: simp
state_before: case hf
R : Type u
S : Type v
T : Type w
ι : Type y
A : Type z
a✝ b : R
n✝ : ℕ
inst✝ : Semiring R
a : R
n : ℕ
⊢ ↑C (0 * ↑n) * X ^ (n - 1) = 0
Theorem: CategoryTheory.left_unitality_app
File: Mathlib/CategoryTheory/Monoidal/End.lean

tactic: have := congr_app (F.toLaxMonoidalFunctor.left_unitality n) X
state_before: C : Type u
inst✝² : Category C
M : Type u_2
inst✝¹ : Category M
inst✝ : MonoidalCategory M
F : MonoidalFunctor M (C ⥤ C)
n : M
X : C
⊢ (F.obj n).map (F.ε.app X) ≫ (LaxMonoidalFunctor.μ F.toLaxMonoidalFunctor (𝟙_ M) n).app X ≫ (F.map (λ_ n).hom).app X =
    𝟙 ((F.obj n).obj ((𝟙_ (C ⥤ C)).obj X))

tactic: dsimp [endofunctorMonoidalCategory] at this
state_before: C : Type u
inst✝² : Category C
M : Type u_2
inst✝¹ : Category M
inst✝ : MonoidalCategory M
F : MonoidalFunctor M (C ⥤ C)
n : M
X : C
this :
  (λ_ (F.obj n)).hom.app X =
    ((F.ε ⊗ 𝟙 (F.obj n)) ≫ LaxMonoidalFunctor.μ F.toLaxMonoidalFunctor (𝟙_ M) n ≫ F.map (λ_ n).hom).app X
⊢ (F.obj n).map (F.ε.app X) ≫ (LaxMonoidalFunctor.μ F.toLaxMonoidalFunctor (𝟙_ M) n).app X ≫ (F.map (λ_ n).hom).app X =
    𝟙 ((F.obj n).obj ((𝟙_ (C ⥤ C)).obj X))

tactic: simpa using this.symm
state_before: C : Type u
inst✝² : Category C
M : Type u_2
inst✝¹ : Category M
inst✝ : MonoidalCategory M
F : MonoidalFunctor M (C ⥤ C)
n : M
X : C
this :
  𝟙 ((F.obj n).obj X) =
    (𝟙 ((F.obj n).obj ((𝟙_ (C ⥤ C)).obj X)) ≫ (F.obj n).map (F.ε.app X)) ≫
      (LaxMonoidalFunctor.μ F.toLaxMonoidalFunctor (𝟙_ M) n).app X ≫ (F.map (λ_ n).hom).app X
⊢ (F.obj n).map (F.ε.app X) ≫ (LaxMonoidalFunctor.μ F.toLaxMonoidalFunctor (𝟙_ M) n).app X ≫ (F.map (λ_ n).hom).app X =
    𝟙 ((F.obj n).obj ((𝟙_ (C ⥤ C)).obj X))
Theorem: Option.mem_toFinset
File: Mathlib/Data/Finset/Option.lean

tactic: cases o <;> simp [eq_comm]
state_before: α : Type u_1
β : Type ?u.398
a : α
o : Option α
⊢ a ∈ toFinset o ↔ a ∈ o
Theorem: Int.Prime.dvd_pow'
File: Mathlib/RingTheory/Int/Basic.lean

tactic: rw [Int.coe_nat_dvd_left]
state_before: n : ℤ
k p : ℕ
hp : Nat.Prime p
h : ↑p ∣ n ^ k
⊢ ↑p ∣ n

tactic: exact Int.Prime.dvd_pow hp h
state_before: n : ℤ
k p : ℕ
hp : Nat.Prime p
h : ↑p ∣ n ^ k
⊢ p ∣ natAbs n
Theorem: Filter.neBot_of_comap
File: Mathlib/Order/Filter/Basic.lean

tactic: rw [neBot_iff] at *
state_before: α : Type u
β : Type v
γ : Type w
δ : Type ?u.252476
ι : Sort x
f f₁ f₂ : Filter α
g g₁ g₂ : Filter β
m : α → β
m' : β → γ
s : Set α
t : Set β
h : NeBot (comap m g)
⊢ NeBot g

tactic: contrapose! h
state_before: α : Type u
β : Type v
γ : Type w
δ : Type ?u.252476
ι : Sort x
f f₁ f₂ : Filter α
g g₁ g₂ : Filter β
m : α → β
m' : β → γ
s : Set α
t : Set β
h : comap m g ≠ ⊥
⊢ g ≠ ⊥

tactic: rw [h]
state_before: α : Type u
β : Type v
γ : Type w
δ : Type ?u.252476
ι : Sort x
f f₁ f₂ : Filter α
g g₁ g₂ : Filter β
m : α → β
m' : β → γ
s : Set α
t : Set β
h : g = ⊥
⊢ comap m g = ⊥

tactic: exact comap_bot
state_before: α : Type u
β : Type v
γ : Type w
δ : Type ?u.252476
ι : Sort x
f f₁ f₂ : Filter α
g g₁ g₂ : Filter β
m : α → β
m' : β → γ
s : Set α
t : Set β
h : g = ⊥
⊢ comap m ⊥ = ⊥