tasksource/leandojo huggingface dataset:
Theorem: CategoryTheory.Limits.cokernel.desc_zero
File: Mathlib/CategoryTheory/Limits/Shapes/Kernels.lean

tactic: apply coequalizer.hom_ext
state_before: C : Type u
inst✝² : Category C
inst✝¹ : HasZeroMorphisms C
X Y : C
f : X ⟶ Y
inst✝ : HasCokernel f
W : C
h : f ≫ 0 = 0
⊢ desc f 0 h = 0

tactic: simp
state_before: case h
C : Type u
inst✝² : Category C
inst✝¹ : HasZeroMorphisms C
X Y : C
f : X ⟶ Y
inst✝ : HasCokernel f
W : C
h : f ≫ 0 = 0
⊢ coequalizer.π f 0 ≫ desc f 0 h = coequalizer.π f 0 ≫ 0
Theorem: Set.infsep_pos
File: Mathlib/Topology/MetricSpace/Infsep.lean

tactic: simp_rw [infsep, ENNReal.toReal_pos_iff]
state_before: α : Type u_1
β : Type ?u.55201
inst✝ : EDist α
x y : α
s : Set α
⊢ 0 < infsep s ↔ 0 < einfsep s ∧ einfsep s < ⊤
Theorem: Filter.Tendsto.mul_atTop
File: Mathlib/Topology/Algebra/Order/Field.lean

tactic: simpa only [mul_comm] using hg.atTop_mul hC hf
state_before: 𝕜 : Type u_1
α : Type u_2
inst✝² : LinearOrderedField 𝕜
inst✝¹ : TopologicalSpace 𝕜
inst✝ : OrderTopology 𝕜
l : Filter α
f g : α → 𝕜
C : 𝕜
hC : 0 < C
hf : Tendsto f l (𝓝 C)
hg : Tendsto g l atTop
⊢ Tendsto (fun x => f x * g x) l atTop
Theorem: List.kerase_of_not_mem_keys
File: Mathlib/Data/List/Sigma.lean

tactic: induction' l with _ _ ih <;> [rfl; (simp [not_or] at h; simp [h.1, ih h.2])]
state_before: α : Type u
β : α → Type v
l✝ l₁ l₂ : List (Sigma β)
inst✝ : DecidableEq α
a : α
l : List (Sigma β)
h : ¬a ∈ keys l
⊢ kerase a l = l

tactic: simp [not_or] at h
state_before: case cons
α : Type u
β : α → Type v
l✝ l₁ l₂ : List (Sigma β)
inst✝ : DecidableEq α
a : α
l : List (Sigma β)
h✝ : ¬a ∈ keys l
head✝ : Sigma β
tail✝ : List (Sigma β)
ih : ¬a ∈ keys tail✝ → kerase a tail✝ = tail✝
h : ¬a ∈ keys (head✝ :: tail✝)
⊢ kerase a (head✝ :: tail✝) = head✝ :: tail✝

tactic: simp [h.1, ih h.2]
state_before: case cons
α : Type u
β : α → Type v
l✝ l₁ l₂ : List (Sigma β)
inst✝ : DecidableEq α
a : α
l : List (Sigma β)
h✝ : ¬a ∈ keys l
head✝ : Sigma β
tail✝ : List (Sigma β)
ih : ¬a ∈ keys tail✝ → kerase a tail✝ = tail✝
h : ¬a = head✝.fst ∧ ¬a ∈ keys tail✝
⊢ kerase a (head✝ :: tail✝) = head✝ :: tail✝
Theorem: Nat.pred_inj
File: Std/Data/Nat/Lemmas.lean

tactic: rw [show a = b from h]
state_before: a b : Nat
x✝¹ : 0 < a + 1
x✝ : 0 < b + 1
h : pred (a + 1) = pred (b + 1)
⊢ a + 1 = b + 1
Theorem: MeasureTheory.Integrable.hasSum_intervalIntegral_comp_add_int
File: Mathlib/MeasureTheory/Integral/IntervalIntegral.lean

tactic: simpa only [integral_comp_add_right, zero_add, add_comm (1:ℝ)] using hfi.hasSum_intervalIntegral 0
state_before: ι : Type ?u.21918495
𝕜 : Type ?u.21918498
E : Type u_1
F : Type ?u.21918504
A : Type ?u.21918507
inst✝² : NormedAddCommGroup E
inst✝¹ : CompleteSpace E
inst✝ : NormedSpace ℝ E
μ : MeasureTheory.Measure ℝ
f : ℝ → E
hfi : Integrable f
⊢ HasSum (fun n => ∫ (x : ℝ) in 0 ..1, f (x + ↑n)) (∫ (x : ℝ), f x)
Theorem: Ordinal.nadd_succ
File: Mathlib/SetTheory/Ordinal/NaturalOps.lean

tactic: rw [← nadd_one (a ♯ b), nadd_assoc, nadd_one]
state_before: a b c : Ordinal
⊢ a ♯ succ b = succ (a ♯ b)
Theorem: List.chain_pmap_of_chain
File: Mathlib/Data/List/Chain.lean

tactic: induction' l with lh lt l_ih generalizing a
state_before: α : Type u
β : Type v
R r : α → α → Prop
l✝ l₁ l₂ : List α
a✝ b : α
S : β → β → Prop
p : α → Prop
f : (a : α) → p a → β
H : ∀ (a b : α) (ha : p a) (hb : p b), R a b → S (f a ha) (f b hb)
a : α
l : List α
hl₁ : Chain R a l
ha : p a
hl₂ : ∀ (a : α), a ∈ l → p a
⊢ Chain S (f a ha) (pmap f l hl₂)

tactic: simp
state_before: case nil
α : Type u
β : Type v
R r : α → α → Prop
l✝ l₁ l₂ : List α
a✝¹ b : α
S : β → β → Prop
p : α → Prop
f : (a : α) → p a → β
H : ∀ (a b : α) (ha : p a) (hb : p b), R a b → S (f a ha) (f b hb)
a✝ : α
l : List α
hl₁✝ : Chain R a✝ l
ha✝ : p a✝
hl₂✝ : ∀ (a : α), a ∈ l → p a
a : α
hl₁ : Chain R a []
ha : p a
hl₂ : ∀ (a : α), a ∈ [] → p a
⊢ Chain S (f a ha) (pmap f [] hl₂)

tactic: simp [H _ _ _ _ (rel_of_chain_cons hl₁), l_ih (chain_of_chain_cons hl₁)]
state_before: case cons
α : Type u
β : Type v
R r : α → α → Prop
l✝ l₁ l₂ : List α
a✝¹ b : α
S : β → β → Prop
p : α → Prop
f : (a : α) → p a → β
H : ∀ (a b : α) (ha : p a) (hb : p b), R a b → S (f a ha) (f b hb)
a✝ : α
l : List α
hl₁✝ : Chain R a✝ l
ha✝ : p a✝
hl₂✝ : ∀ (a : α), a ∈ l → p a
lh : α
lt : List α
l_ih : ∀ {a : α}, Chain R a lt → ∀ (ha : p a) (hl₂ : ∀ (a : α), a ∈ lt → p a), Chain S (f a ha) (pmap f lt hl₂)
a : α
hl₁ : Chain R a (lh :: lt)
ha : p a
hl₂ : ∀ (a : α), a ∈ lh :: lt → p a
⊢ Chain S (f a ha) (pmap f (lh :: lt) hl₂)
Theorem: ContDiffWithinAt.eventually
File: Mathlib/Analysis/Calculus/ContDiffDef.lean

tactic: rcases h.contDiffOn le_rfl with ⟨u, hu, _, hd⟩
state_before: 𝕜 : Type u
inst✝⁸ : NontriviallyNormedField 𝕜
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type uX
inst✝¹ : NormedAddCommGroup X
inst✝ : NormedSpace 𝕜 X
s s₁ t u : Set E
f f₁ : E → F
g : F → G
x x₀ : E
c : F
m n✝ : ℕ∞
p : E → FormalMultilinearSeries 𝕜 E F
n : ℕ
h : ContDiffWithinAt 𝕜 (↑n) f s x
⊢ ∀ᶠ (y : E) in 𝓝[insert x s] x, ContDiffWithinAt 𝕜 (↑n) f s y

tactic: have : ∀ᶠ y : E in 𝓝[insert x s] x, u ∈ 𝓝[insert x s] y ∧ y ∈ u :=
  (eventually_nhdsWithin_nhdsWithin.2 hu).and hu
state_before: case intro.intro.intro
𝕜 : Type u
inst✝⁸ : NontriviallyNormedField 𝕜
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type uX
inst✝¹ : NormedAddCommGroup X
inst✝ : NormedSpace 𝕜 X
s s₁ t u✝ : Set E
f f₁ : E → F
g : F → G
x x₀ : E
c : F
m n✝ : ℕ∞
p : E → FormalMultilinearSeries 𝕜 E F
n : ℕ
h : ContDiffWithinAt 𝕜 (↑n) f s x
u : Set E
hu : u ∈ 𝓝[insert x s] x
left✝ : u ⊆ insert x s
hd : ContDiffOn 𝕜 (↑n) f u
⊢ ∀ᶠ (y : E) in 𝓝[insert x s] x, ContDiffWithinAt 𝕜 (↑n) f s y

tactic: refine' this.mono fun y hy => (hd y hy.2).mono_of_mem _
state_before: case intro.intro.intro
𝕜 : Type u
inst✝⁸ : NontriviallyNormedField 𝕜
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type uX
inst✝¹ : NormedAddCommGroup X
inst✝ : NormedSpace 𝕜 X
s s₁ t u✝ : Set E
f f₁ : E → F
g : F → G
x x₀ : E
c : F
m n✝ : ℕ∞
p : E → FormalMultilinearSeries 𝕜 E F
n : ℕ
h : ContDiffWithinAt 𝕜 (↑n) f s x
u : Set E
hu : u ∈ 𝓝[insert x s] x
left✝ : u ⊆ insert x s
hd : ContDiffOn 𝕜 (↑n) f u
this : ∀ᶠ (y : E) in 𝓝[insert x s] x, u ∈ 𝓝[insert x s] y ∧ y ∈ u
⊢ ∀ᶠ (y : E) in 𝓝[insert x s] x, ContDiffWithinAt 𝕜 (↑n) f s y

tactic: exact nhdsWithin_mono y (subset_insert _ _) hy.1
state_before: case intro.intro.intro
𝕜 : Type u
inst✝⁸ : NontriviallyNormedField 𝕜
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type uX
inst✝¹ : NormedAddCommGroup X
inst✝ : NormedSpace 𝕜 X
s s₁ t u✝ : Set E
f f₁ : E → F
g : F → G
x x₀ : E
c : F
m n✝ : ℕ∞
p : E → FormalMultilinearSeries 𝕜 E F
n : ℕ
h : ContDiffWithinAt 𝕜 (↑n) f s x
u : Set E
hu : u ∈ 𝓝[insert x s] x
left✝ : u ⊆ insert x s
hd : ContDiffOn 𝕜 (↑n) f u
this : ∀ᶠ (y : E) in 𝓝[insert x s] x, u ∈ 𝓝[insert x s] y ∧ y ∈ u
y : E
hy : u ∈ 𝓝[insert x s] y ∧ y ∈ u
⊢ u ∈ 𝓝[s] y
Theorem: unitInterval.symm_zero
File: Mathlib/Topology/UnitInterval.lean

tactic: simp [symm]
state_before: ⊢ ↑(σ 0) = ↑1
Theorem: sameRay_iff_inv_norm_smul_eq_of_ne
File: Mathlib/Analysis/NormedSpace/Ray.lean

tactic: rw [inv_smul_eq_iff₀, smul_comm, eq_comm, inv_smul_eq_iff₀, sameRay_iff_norm_smul_eq] <;>
  rwa [norm_ne_zero_iff]
state_before: E : Type ?u.229888
inst✝³ : SeminormedAddCommGroup E
inst✝² : NormedSpace ℝ E
F : Type u_1
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedSpace ℝ F
x y : F
hx : x ≠ 0
hy : y ≠ 0
⊢ SameRay ℝ x y ↔ ‖x‖⁻¹ • x = ‖y‖⁻¹ • y
Theorem: IsROrC.hasSum_ofReal
File: Mathlib/Analysis/Complex/Basic.lean

tactic: simpa only [IsROrC.reClm_apply, IsROrC.ofReal_re] using reClm.hasSum h
state_before: α : Type u_2
𝕜 : Type u_1
inst✝ : IsROrC 𝕜
f : α → ℝ
x : ℝ
h : HasSum (fun x => ↑(f x)) ↑x
⊢ HasSum f x
Theorem: Finsupp.neLocus_self_sub_left
File: Mathlib/Data/Finsupp/NeLocus.lean

tactic: rw [neLocus_comm, neLocus_self_sub_right]
state_before: α : Type u_1
M : Type ?u.40308
N : Type u_2
P : Type ?u.40314
inst✝² : DecidableEq α
inst✝¹ : DecidableEq N
inst✝ : AddGroup N
f f₁ f₂ g g₁ g₂ : α →₀ N
⊢ neLocus (f - g) f = g.support
Theorem: AddSubgroup.tendsto_zmultiples_subtype_cofinite
File: Mathlib/Topology/Instances/Real.lean

tactic: rcases eq_or_ne a 0 with rfl | ha
state_before: α : Type u
β : Type v
γ : Type w
a : ℝ
⊢ Tendsto (↑(AddSubgroup.subtype (zmultiples a))) cofinite (cocompact ℝ)

tactic: rw [zmultiples_zero_eq_bot, cofinite_eq_bot]
state_before: case inl
α : Type u
β : Type v
γ : Type w
⊢ Tendsto (↑(AddSubgroup.subtype (zmultiples 0))) cofinite (cocompact ℝ)

tactic: exact tendsto_bot
state_before: case inl
α : Type u
β : Type v
γ : Type w
⊢ Tendsto ↑(AddSubgroup.subtype ⊥) ⊥ (cocompact ℝ)
Theorem: Mathlib.Tactic.Ring.cast_rat
File: Mathlib/Tactic/Ring/Basic.lean

tactic: simp [e, div_eq_mul_inv]
state_before: u : Lean.Level
R✝ : Type ?u.334202
α : Q(Type u)
sα : Q(CommSemiring «$α»)
inst✝¹ : CommSemiring R✝
n : ℤ
d : ℕ
R : Type u_1
inst✝ : DivisionRing R
a : R
inv✝ : Invertible ↑d
e : a = ↑n * ⅟↑d
⊢ a = Rat.rawCast n d + 0
Theorem: Subalgebra.restrictScalars_top
File: Mathlib/Algebra/Algebra/Subalgebra/Tower.lean

tactic: dsimp
state_before: R : Type u
S : Type v
A : Type w
B : Type u₁
M : Type v₁
inst✝¹⁰ : CommSemiring R
inst✝⁹ : CommSemiring S
inst✝⁸ : Semiring A
inst✝⁷ : Semiring B
inst✝⁶ : Algebra R S
inst✝⁵ : Algebra S A
inst✝⁴ : Algebra R A
inst✝³ : Algebra S B
inst✝² : Algebra R B
inst✝¹ : IsScalarTower R S A
inst✝ : IsScalarTower R S B
⊢ ↑(restrictScalars R ⊤) = ↑⊤
Theorem: Submodule.map₂_bot_left
File: Mathlib/Algebra/Module/Submodule/Bilinear.lean

tactic: rw [Submodule.mem_bot] at hm⊢
state_before: ι : Sort uι
R : Type u_1
M : Type u_2
N : Type u_4
P : Type u_3
inst✝⁶ : CommSemiring R
inst✝⁵ : AddCommMonoid M
inst✝⁴ : AddCommMonoid N
inst✝³ : AddCommMonoid P
inst✝² : Module R M
inst✝¹ : Module R N
inst✝ : Module R P
f : M →ₗ[R] N →ₗ[R] P
q : Submodule R N
m : M
hm : m ∈ ⊥
n : N
hn : n ∈ q
⊢ ↑(↑f m) n ∈ ⊥

tactic: rw [hm, LinearMap.map_zero₂]
state_before: ι : Sort uι
R : Type u_1
M : Type u_2
N : Type u_4
P : Type u_3
inst✝⁶ : CommSemiring R
inst✝⁵ : AddCommMonoid M
inst✝⁴ : AddCommMonoid N
inst✝³ : AddCommMonoid P
inst✝² : Module R M
inst✝¹ : Module R N
inst✝ : Module R P
f : M →ₗ[R] N →ₗ[R] P
q : Submodule R N
m : M
hm : m = 0
n : N
hn : n ∈ q
⊢ ↑(↑f m) n = 0
Theorem: RingHom.isIntegral_quotient_of_isIntegral
File: Mathlib/RingTheory/IntegralClosure.lean

tactic: rintro ⟨x⟩
state_before: R : Type u_2
A : Type ?u.1581561
B : Type ?u.1581564
S : Type u_1
T : Type ?u.1581570
inst✝⁸ : CommRing R
inst✝⁷ : CommRing A
inst✝⁶ : CommRing B
inst✝⁵ : CommRing S
inst✝⁴ : CommRing T
inst✝³ : Algebra A B
inst✝² : Algebra R B
f : R →+* S
g : S →+* T
inst✝¹ : Algebra R A
inst✝ : IsScalarTower R A B
I : Ideal S
hf : IsIntegral f
⊢ IsIntegral (Ideal.quotientMap I f (_ : Ideal.comap f I ≤ Ideal.comap f I))

tactic: obtain ⟨p, ⟨p_monic, hpx⟩⟩ := hf x
state_before: case mk
R : Type u_2
A : Type ?u.1581561
B : Type ?u.1581564
S : Type u_1
T : Type ?u.1581570
inst✝⁸ : CommRing R
inst✝⁷ : CommRing A
inst✝⁶ : CommRing B
inst✝⁵ : CommRing S
inst✝⁴ : CommRing T
inst✝³ : Algebra A B
inst✝² : Algebra R B
f : R →+* S
g : S →+* T
inst✝¹ : Algebra R A
inst✝ : IsScalarTower R A B
I : Ideal S
hf : IsIntegral f
x✝ : S ⧸ I
x : S
⊢ IsIntegralElem (Ideal.quotientMap I f (_ : Ideal.comap f I ≤ Ideal.comap f I)) (Quot.mk Setoid.r x)

tactic: refine' ⟨p.map (Ideal.Quotient.mk _), ⟨p_monic.map _, _⟩⟩
state_before: case mk.intro.intro
R : Type u_2
A : Type ?u.1581561
B : Type ?u.1581564
S : Type u_1
T : Type ?u.1581570
inst✝⁸ : CommRing R
inst✝⁷ : CommRing A
inst✝⁶ : CommRing B
inst✝⁵ : CommRing S
inst✝⁴ : CommRing T
inst✝³ : Algebra A B
inst✝² : Algebra R B
f : R →+* S
g : S →+* T
inst✝¹ : Algebra R A
inst✝ : IsScalarTower R A B
I : Ideal S
hf : IsIntegral f
x✝ : S ⧸ I
x : S
p : R[X]
p_monic : Monic p
hpx : eval₂ f x p = 0
⊢ IsIntegralElem (Ideal.quotientMap I f (_ : Ideal.comap f I ≤ Ideal.comap f I)) (Quot.mk Setoid.r x)

tactic: simpa only [hom_eval₂, eval₂_map] using congr_arg (Ideal.Quotient.mk I) hpx
state_before: case mk.intro.intro
R : Type u_2
A : Type ?u.1581561
B : Type ?u.1581564
S : Type u_1
T : Type ?u.1581570
inst✝⁸ : CommRing R
inst✝⁷ : CommRing A
inst✝⁶ : CommRing B
inst✝⁵ : CommRing S
inst✝⁴ : CommRing T
inst✝³ : Algebra A B
inst✝² : Algebra R B
f : R →+* S
g : S →+* T
inst✝¹ : Algebra R A
inst✝ : IsScalarTower R A B
I : Ideal S
hf : IsIntegral f
x✝ : S ⧸ I
x : S
p : R[X]
p_monic : Monic p
hpx : eval₂ f x p = 0
⊢ eval₂ (Ideal.quotientMap I f (_ : Ideal.comap f I ≤ Ideal.comap f I)) (Quot.mk Setoid.r x)
      (Polynomial.map (Ideal.Quotient.mk (Ideal.comap f I)) p) =
    0
Theorem: padicNorm.sum_le
File: Mathlib/NumberTheory/Padics/PadicNorm.lean

tactic: refine' s.induction_on (by rintro ⟨-, ⟨⟩⟩) _
state_before: p : ℕ
hp : Fact (Nat.Prime p)
α : Type u_1
F : α → ℚ
t : ℚ
s : Finset α
⊢ Finset.Nonempty s → (∀ (i : α), i ∈ s → padicNorm p (F i) ≤ t) → padicNorm p (∑ i in s, F i) ≤ t

tactic: rintro a S haS IH - ht
state_before: p : ℕ
hp : Fact (Nat.Prime p)
α : Type u_1
F : α → ℚ
t : ℚ
s : Finset α
⊢ ∀ ⦃a : α⦄ {s : Finset α},
    ¬a ∈ s →
      (Finset.Nonempty s → (∀ (i : α), i ∈ s → padicNorm p (F i) ≤ t) → padicNorm p (∑ i in s, F i) ≤ t) →
        Finset.Nonempty (insert a s) →
          (∀ (i : α), i ∈ insert a s → padicNorm p (F i) ≤ t) → padicNorm p (∑ i in insert a s, F i) ≤ t

tactic: by_cases hs : S.Nonempty
state_before: p : ℕ
hp : Fact (Nat.Prime p)
α : Type u_1
F : α → ℚ
t : ℚ
s : Finset α
a : α
S : Finset α
haS : ¬a ∈ S
IH : Finset.Nonempty S → (∀ (i : α), i ∈ S → padicNorm p (F i) ≤ t) → padicNorm p (∑ i in S, F i) ≤ t
ht : ∀ (i : α), i ∈ insert a S → padicNorm p (F i) ≤ t
⊢ padicNorm p (∑ i in insert a S, F i) ≤ t

tactic: rintro ⟨-, ⟨⟩⟩
state_before: p : ℕ
hp : Fact (Nat.Prime p)
α : Type u_1
F : α → ℚ
t : ℚ
s : Finset α
⊢ Finset.Nonempty ∅ → (∀ (i : α), i ∈ ∅ → padicNorm p (F i) ≤ t) → padicNorm p (∑ i in ∅, F i) ≤ t

tactic: rw [Finset.sum_insert haS]
state_before: case pos
p : ℕ
hp : Fact (Nat.Prime p)
α : Type u_1
F : α → ℚ
t : ℚ
s : Finset α
a : α
S : Finset α
haS : ¬a ∈ S
IH : Finset.Nonempty S → (∀ (i : α), i ∈ S → padicNorm p (F i) ≤ t) → padicNorm p (∑ i in S, F i) ≤ t
ht : ∀ (i : α), i ∈ insert a S → padicNorm p (F i) ≤ t
hs : Finset.Nonempty S
⊢ padicNorm p (∑ i in insert a S, F i) ≤ t

tactic: exact
  padicNorm.nonarchimedean.trans
    (max_le (ht a (Finset.mem_insert_self a S))
      (IH hs fun b hb ↦ ht b (Finset.mem_insert_of_mem hb)))
state_before: case pos
p : ℕ
hp : Fact (Nat.Prime p)
α : Type u_1
F : α → ℚ
t : ℚ
s : Finset α
a : α
S : Finset α
haS : ¬a ∈ S
IH : Finset.Nonempty S → (∀ (i : α), i ∈ S → padicNorm p (F i) ≤ t) → padicNorm p (∑ i in S, F i) ≤ t
ht : ∀ (i : α), i ∈ insert a S → padicNorm p (F i) ≤ t
hs : Finset.Nonempty S
⊢ padicNorm p (F a + ∑ x in S, F x) ≤ t

tactic: simp_all
state_before: case neg
p : ℕ
hp : Fact (Nat.Prime p)
α : Type u_1
F : α → ℚ
t : ℚ
s : Finset α
a : α
S : Finset α
haS : ¬a ∈ S
IH : Finset.Nonempty S → (∀ (i : α), i ∈ S → padicNorm p (F i) ≤ t) → padicNorm p (∑ i in S, F i) ≤ t
ht : ∀ (i : α), i ∈ insert a S → padicNorm p (F i) ≤ t
hs : ¬Finset.Nonempty S
⊢ padicNorm p (∑ i in insert a S, F i) ≤ t
Theorem: Cubic.monic_of_c_eq_one
File: Mathlib/Algebra/CubicDiscriminant.lean

tactic: nontriviality R
state_before: R : Type u_1
S : Type ?u.564413
F : Type ?u.564416
K : Type ?u.564419
P Q : Cubic R
a b c d a' b' c' d' : R
inst✝ : Semiring R
ha : P.a = 0
hb : P.b = 0
hc : P.c = 1
⊢ Monic (toPoly P)

tactic: rw [Monic, leadingCoeff_of_c_ne_zero ha hb (hc ▸ one_ne_zero), hc]
state_before: R : Type u_1
S : Type ?u.564413
F : Type ?u.564416
K : Type ?u.564419
P Q : Cubic R
a b c d a' b' c' d' : R
inst✝ : Semiring R
ha : P.a = 0
hb : P.b = 0
hc : P.c = 1
✝ : Nontrivial R
⊢ Monic (toPoly P)
Theorem: Nat.coprime_mul_right_add_left
File: Mathlib/Data/Nat/GCD/Basic.lean

tactic: rw [coprime, coprime, gcd_mul_right_add_left]
state_before: m n k : ℕ
⊢ coprime (k * n + m) n ↔ coprime m n
Theorem: Filter.coprodᵢ_eq_bot_iff'
File: Mathlib/Order/Filter/Pi.lean

tactic: simpa only [not_neBot, not_and_or, funext_iff, not_forall, not_exists, not_nonempty_iff]
  using coprodᵢ_neBot_iff'.not
state_before: ι : Type u_1
α : ι → Type u_2
f f₁ f₂ : (i : ι) → Filter (α i)
s : (i : ι) → Set (α i)
⊢ Filter.coprodᵢ f = ⊥ ↔ (∃ i, IsEmpty (α i)) ∨ f = ⊥
Theorem: LieModule.iInf_max_gen_zero_eigenspace_eq_top_of_nilpotent
File: Mathlib/Algebra/Lie/Nilpotent.lean

tactic: ext m
state_before: R : Type u
L : Type v
M : Type w
inst✝⁷ : CommRing R
inst✝⁶ : LieRing L
inst✝⁵ : LieAlgebra R L
inst✝⁴ : AddCommGroup M
inst✝³ : Module R M
inst✝² : LieRingModule L M
inst✝¹ : LieModule R L M
k : ℕ
N : LieSubmodule R L M
inst✝ : IsNilpotent R L M
⊢ (⨅ (x : L), Module.End.maximalGeneralizedEigenspace (↑(toEndomorphism R L M) x) 0) = ⊤

tactic: simp only [Module.End.mem_maximalGeneralizedEigenspace, Submodule.mem_top, sub_zero, iff_true_iff,
  zero_smul, Submodule.mem_iInf]
state_before: case h
R : Type u
L : Type v
M : Type w
inst✝⁷ : CommRing R
inst✝⁶ : LieRing L
inst✝⁵ : LieAlgebra R L
inst✝⁴ : AddCommGroup M
inst✝³ : Module R M
inst✝² : LieRingModule L M
inst✝¹ : LieModule R L M
k : ℕ
N : LieSubmodule R L M
inst✝ : IsNilpotent R L M
m : M
⊢ (m ∈ ⨅ (x : L), Module.End.maximalGeneralizedEigenspace (↑(toEndomorphism R L M) x) 0) ↔ m ∈ ⊤

tactic: intro x
state_before: case h
R : Type u
L : Type v
M : Type w
inst✝⁷ : CommRing R
inst✝⁶ : LieRing L
inst✝⁵ : LieAlgebra R L
inst✝⁴ : AddCommGroup M
inst✝³ : Module R M
inst✝² : LieRingModule L M
inst✝¹ : LieModule R L M
k : ℕ
N : LieSubmodule R L M
inst✝ : IsNilpotent R L M
m : M
⊢ ∀ (i : L), ∃ k, ↑(↑(toEndomorphism R L M) i ^ k) m = 0

tactic: obtain ⟨k, hk⟩ := nilpotent_endo_of_nilpotent_module R L M
state_before: case h
R : Type u
L : Type v
M : Type w
inst✝⁷ : CommRing R
inst✝⁶ : LieRing L
inst✝⁵ : LieAlgebra R L
inst✝⁴ : AddCommGroup M
inst✝³ : Module R M
inst✝² : LieRingModule L M
inst✝¹ : LieModule R L M
k : ℕ
N : LieSubmodule R L M
inst✝ : IsNilpotent R L M
m : M
x : L
⊢ ∃ k, ↑(↑(toEndomorphism R L M) x ^ k) m = 0

tactic: use k
state_before: case h.intro
R : Type u
L : Type v
M : Type w
inst✝⁷ : CommRing R
inst✝⁶ : LieRing L
inst✝⁵ : LieAlgebra R L
inst✝⁴ : AddCommGroup M
inst✝³ : Module R M
inst✝² : LieRingModule L M
inst✝¹ : LieModule R L M
k✝ : ℕ
N : LieSubmodule R L M
inst✝ : IsNilpotent R L M
m : M
x : L
k : ℕ
hk : ∀ (x : L), ↑(toEndomorphism R L M) x ^ k = 0
⊢ ∃ k, ↑(↑(toEndomorphism R L M) x ^ k) m = 0

tactic: rw [hk]
state_before: case h.intro
R : Type u
L : Type v
M : Type w
inst✝⁷ : CommRing R
inst✝⁶ : LieRing L
inst✝⁵ : LieAlgebra R L
inst✝⁴ : AddCommGroup M
inst✝³ : Module R M
inst✝² : LieRingModule L M
inst✝¹ : LieModule R L M
k✝ : ℕ
N : LieSubmodule R L M
inst✝ : IsNilpotent R L M
m : M
x : L
k : ℕ
hk : ∀ (x : L), ↑(toEndomorphism R L M) x ^ k = 0
⊢ ↑(↑(toEndomorphism R L M) x ^ k) m = 0

tactic: exact LinearMap.zero_apply m
state_before: case h.intro
R : Type u
L : Type v
M : Type w
inst✝⁷ : CommRing R
inst✝⁶ : LieRing L
inst✝⁵ : LieAlgebra R L
inst✝⁴ : AddCommGroup M
inst✝³ : Module R M
inst✝² : LieRingModule L M
inst✝¹ : LieModule R L M
k✝ : ℕ
N : LieSubmodule R L M
inst✝ : IsNilpotent R L M
m : M
x : L
k : ℕ
hk : ∀ (x : L), ↑(toEndomorphism R L M) x ^ k = 0
⊢ ↑0 m = 0
Theorem: Filter.map_fst_prod
File: Mathlib/Order/Filter/Prod.lean

tactic: ext s
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.16299
δ : Type ?u.16302
ι : Sort ?u.16305
s : Set α
t : Set β
f✝ : Filter α
g✝ : Filter β
f : Filter α
g : Filter β
inst✝ : NeBot g
⊢ map Prod.fst (f ×ˢ g) = f

tactic: simp only [mem_map, mem_prod_iff_left, mem_preimage, eventually_const, ← subset_def,
  exists_mem_subset_iff]
state_before: case a
α : Type u_1
β : Type u_2
γ : Type ?u.16299
δ : Type ?u.16302
ι : Sort ?u.16305
s✝ : Set α
t : Set β
f✝ : Filter α
g✝ : Filter β
f : Filter α
g : Filter β
inst✝ : NeBot g
s : Set α
⊢ s ∈ map Prod.fst (f ×ˢ g) ↔ s ∈ f
Theorem: Finset.image_inter_of_injOn
File: Mathlib/Data/Finset/Image.lean

tactic: push_cast
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.87546
inst✝¹ : DecidableEq β
f✝ g : α → β
s✝ : Finset α
t✝ : Finset β
a : α
b c : β
inst✝ : DecidableEq α
f : α → β
s t : Finset α
hf : Set.InjOn f (↑s ∪ ↑t)
⊢ ↑(image f (s ∩ t)) = ↑(image f s ∩ image f t)

tactic: exact Set.image_inter_on fun a ha b hb => hf (Or.inr ha) <| Or.inl hb
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.87546
inst✝¹ : DecidableEq β
f✝ g : α → β
s✝ : Finset α
t✝ : Finset β
a : α
b c : β
inst✝ : DecidableEq α
f : α → β
s t : Finset α
hf : Set.InjOn f (↑s ∪ ↑t)
⊢ f '' (↑s ∩ ↑t) = f '' ↑s ∩ f '' ↑t
Theorem: Finset.mul_prod_erase
File: Mathlib/Algebra/BigOperators/Basic.lean

tactic: rw [← prod_insert (not_mem_erase a s), insert_erase h]
state_before: ι : Type ?u.794748
β : Type u
α : Type v
γ : Type w
s✝ s₁ s₂ : Finset α
a✝ : α
f✝ g : α → β
inst✝¹ : CommMonoid β
inst✝ : DecidableEq α
s : Finset α
f : α → β
a : α
h : a ∈ s
⊢ f a * ∏ x in erase s a, f x = ∏ x in s, f x
Theorem: Int.add_neg_cancel_left
File: Std/Data/Int/Lemmas.lean

tactic: rw [← Int.add_assoc, Int.add_right_neg, Int.zero_add]
state_before: a b : Int
⊢ a + (-a + b) = b
Theorem: SimpleGraph.Walk.edges_nodup_of_support_nodup
File: Mathlib/Combinatorics/SimpleGraph/Connectivity.lean

tactic: induction p with
| nil => simp
| cons _ p' ih =>
  simp only [edges_cons, support_cons, List.nodup_cons] at h ⊢
  exact ⟨fun h' => h.1 (fst_mem_support_of_mem_edges p' h'), ih h.2⟩
state_before: V : Type u
V' : Type v
V'' : Type w
G : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
u v : V
p : Walk G u v
h : List.Nodup (support p)
⊢ List.Nodup (edges p)

tactic: simp
state_before: case nil
V : Type u
V' : Type v
V'' : Type w
G : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
u v u✝ : V
h : List.Nodup (support nil)
⊢ List.Nodup (edges nil)

tactic: simp only [edges_cons, support_cons, List.nodup_cons] at h ⊢
state_before: case cons
V : Type u
V' : Type v
V'' : Type w
G : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
u v u✝ v✝ w✝ : V
h✝ : Adj G u✝ v✝
p' : Walk G v✝ w✝
ih : List.Nodup (support p') → List.Nodup (edges p')
h : List.Nodup (support (cons h✝ p'))
⊢ List.Nodup (edges (cons h✝ p'))

tactic: exact ⟨fun h' => h.1 (fst_mem_support_of_mem_edges p' h'), ih h.2⟩
state_before: case cons
V : Type u
V' : Type v
V'' : Type w
G : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
u v u✝ v✝ w✝ : V
h✝ : Adj G u✝ v✝
p' : Walk G v✝ w✝
ih : List.Nodup (support p') → List.Nodup (edges p')
h : ¬u✝ ∈ support p' ∧ List.Nodup (support p')
⊢ ¬Quotient.mk (Sym2.Rel.setoid V) (u✝, v✝) ∈ edges p' ∧ List.Nodup (edges p')
Theorem: MeasureTheory.Measure.measure_toMeasurable_add_inter_right
File: Mathlib/MeasureTheory/Measure/MeasureSpace.lean

tactic: rw [add_comm] at ht⊢
state_before: α : Type u_1
β : Type ?u.141288
γ : Type ?u.141291
δ : Type ?u.141294
ι : Type ?u.141297
R : Type ?u.141300
R' : Type ?u.141303
m0 : MeasurableSpace α
inst✝¹ : MeasurableSpace β
inst✝ : MeasurableSpace γ
μ μ₁ μ₂ μ₃ ν ν' ν₁ ν₂ : Measure α
s✝ s' t✝ s t : Set α
hs : MeasurableSet s
ht : ↑↑(μ + ν) t ≠ ⊤
⊢ ↑↑ν (toMeasurable (μ + ν) t ∩ s) = ↑↑ν (t ∩ s)

tactic: exact measure_toMeasurable_add_inter_left hs ht
state_before: α : Type u_1
β : Type ?u.141288
γ : Type ?u.141291
δ : Type ?u.141294
ι : Type ?u.141297
R : Type ?u.141300
R' : Type ?u.141303
m0 : MeasurableSpace α
inst✝¹ : MeasurableSpace β
inst✝ : MeasurableSpace γ
μ μ₁ μ₂ μ₃ ν ν' ν₁ ν₂ : Measure α
s✝ s' t✝ s t : Set α
hs : MeasurableSet s
ht : ↑↑(ν + μ) t ≠ ⊤
⊢ ↑↑ν (toMeasurable (ν + μ) t ∩ s) = ↑↑ν (t ∩ s)