1337xyz1337xyz/leandojo-benchmark4-v10 huggingface dataset:
Theorem: CompleteLattice.independent_of_dfinsupp_sumAddHom_injective
File: Mathlib/LinearAlgebra/DFinsupp.lean

tactic: rw [← independent_map_orderIso_iff (AddSubmonoid.toNatSubmodule : AddSubmonoid N ≃o _)]
state_before: ι : Type u_1
R : Type u_2
S : Type u_3
M : ι → Type u_4
N : Type u_5
inst✝³ : DecidableEq ι
inst✝² : Semiring R
inst✝¹ : AddCommMonoid N
inst✝ : Module R N
p : ι → AddSubmonoid N
h : Function.Injective ⇑(sumAddHom fun i => (p i).subtype)
⊢ Independent p
state_after: ι : Type u_1
R : Type u_2
S : Type u_3
M : ι → Type u_4
N : Type u_5
inst✝³ : DecidableEq ι
inst✝² : Semiring R
inst✝¹ : AddCommMonoid N
inst✝ : Module R N
p : ι → AddSubmonoid N
h : Function.Injective ⇑(sumAddHom fun i => (p i).subtype)
⊢ Independent (⇑AddSubmonoid.toNatSubmodule ∘ p)

tactic: exact independent_of_dfinsupp_lsum_injective _ h
state_before: ι : Type u_1
R : Type u_2
S : Type u_3
M : ι → Type u_4
N : Type u_5
inst✝³ : DecidableEq ι
inst✝² : Semiring R
inst✝¹ : AddCommMonoid N
inst✝ : Module R N
p : ι → AddSubmonoid N
h : Function.Injective ⇑(sumAddHom fun i => (p i).subtype)
⊢ Independent (⇑AddSubmonoid.toNatSubmodule ∘ p)
state_after: no goals
Theorem: Real.rpow_sub_nat'
File: Mathlib/Analysis/SpecialFunctions/Pow/Real.lean

tactic: rw [rpow_sub' hx h, rpow_natCast]
state_before: x y z : ℝ
n : ℕ
hx : 0 ≤ x
h : y - ↑n ≠ 0
⊢ x ^ (y - ↑n) = x ^ y / x ^ n
state_after: no goals
Theorem: Set.image2_iInter_subset_right
File: Mathlib/Data/Set/Lattice.lean

tactic: simp_rw [image2_subset_iff, mem_iInter]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
ι' : Sort u_5
ι₂ : Sort u_6
κ : ι → Sort u_7
κ₁ : ι → Sort u_8
κ₂ : ι → Sort u_9
κ' : ι' → Sort u_10
f : α → β → γ
s✝ : Set α
t✝ : Set β
s : Set α
t : ι → Set β
⊢ image2 f s (⋂ i, t i) ⊆ ⋂ i, image2 f s (t i)
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
ι' : Sort u_5
ι₂ : Sort u_6
κ : ι → Sort u_7
κ₁ : ι → Sort u_8
κ₂ : ι → Sort u_9
κ' : ι' → Sort u_10
f : α → β → γ
s✝ : Set α
t✝ : Set β
s : Set α
t : ι → Set β
⊢ ∀ x ∈ s, ∀ (y : β), (∀ (i : ι), y ∈ t i) → ∀ (i : ι), f x y ∈ image2 f s (t i)

tactic: exact fun x hx y hy i => mem_image2_of_mem hx (hy _)
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
ι' : Sort u_5
ι₂ : Sort u_6
κ : ι → Sort u_7
κ₁ : ι → Sort u_8
κ₂ : ι → Sort u_9
κ' : ι' → Sort u_10
f : α → β → γ
s✝ : Set α
t✝ : Set β
s : Set α
t : ι → Set β
⊢ ∀ x ∈ s, ∀ (y : β), (∀ (i : ι), y ∈ t i) → ∀ (i : ι), f x y ∈ image2 f s (t i)
state_after: no goals
Theorem: Finsupp.total_single
File: Mathlib/LinearAlgebra/Finsupp.lean

tactic: simp [total_apply, sum_single_index]
state_before: α : Type u_1
M : Type u_2
N : Type u_3
P : Type u_4
R : Type u_5
S : Type u_6
inst✝⁹ : Semiring R
inst✝⁸ : Semiring S
inst✝⁷ : AddCommMonoid M
inst✝⁶ : Module R M
inst✝⁵ : AddCommMonoid N
inst✝⁴ : Module R N
inst✝³ : AddCommMonoid P
inst✝² : Module R P
α' : Type u_7
M' : Type u_8
inst✝¹ : AddCommMonoid M'
inst✝ : Module R M'
v : α → M
v' : α' → M'
c : R
a : α
⊢ (Finsupp.total α M R v) (single a c) = c • v a
state_after: no goals
Theorem: Matroid.Base.ssubset_ground
File: Mathlib/Data/Matroid/Dual.lean

tactic: rintro rfl
state_before: α : Type u_1
M : Matroid α
I B X : Set α
h : M✶.RkPos
hB : M.Base B
⊢ B ≠ M.E
state_after: α : Type u_1
M : Matroid α
I X : Set α
h : M✶.RkPos
hB : M.Base M.E
⊢ False

tactic: exact M.ground_not_base hB
state_before: α : Type u_1
M : Matroid α
I X : Set α
h : M✶.RkPos
hB : M.Base M.E
⊢ False
state_after: no goals
Theorem: CategoryTheory.Abelian.exact_epi_comp_iff
File: Mathlib/CategoryTheory/Abelian/Exact.lean

tactic: refine ⟨fun hfg => ?_, fun h => exact_epi_comp h⟩
state_before: C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : Abelian C
X Y Z : C
f : X ⟶ Y
g : Y ⟶ Z
W : C
h : W ⟶ X
inst✝ : Epi h
⊢ Exact (h ≫ f) g ↔ Exact f g
state_after: C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : Abelian C
X Y Z : C
f : X ⟶ Y
g : Y ⟶ Z
W : C
h : W ⟶ X
inst✝ : Epi h
hfg : Exact (h ≫ f) g
⊢ Exact f g

tactic: let hc := isCokernelOfComp _ _ (colimit.isColimit (parallelPair (h ≫ f) 0))
  (by rw [← cancel_epi h, ← Category.assoc, CokernelCofork.condition, comp_zero]) rfl
state_before: C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : Abelian C
X Y Z : C
f : X ⟶ Y
g : Y ⟶ Z
W : C
h : W ⟶ X
inst✝ : Epi h
hfg : Exact (h ≫ f) g
⊢ Exact f g
state_after: C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : Abelian C
X Y Z : C
f : X ⟶ Y
g : Y ⟶ Z
W : C
h : W ⟶ X
inst✝ : Epi h
hfg : Exact (h ≫ f) g
hc : IsColimit (CokernelCofork.ofπ (Cofork.π (colimit.cocone (parallelPair (h ≫ f) 0))) ⋯) :=
  isCokernelOfComp h (h ≫ f) (colimit.isColimit (parallelPair (h ≫ f) 0)) ⋯ ⋯
⊢ Exact f g

tactic: refine (exact_iff' _ _ (limit.isLimit _) hc).2 ⟨?_, ((exact_iff _ _).1 hfg).2⟩
state_before: C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : Abelian C
X Y Z : C
f : X ⟶ Y
g : Y ⟶ Z
W : C
h : W ⟶ X
inst✝ : Epi h
hfg : Exact (h ≫ f) g
hc : IsColimit (CokernelCofork.ofπ (Cofork.π (colimit.cocone (parallelPair (h ≫ f) 0))) ⋯) :=
  isCokernelOfComp h (h ≫ f) (colimit.isColimit (parallelPair (h ≫ f) 0)) ⋯ ⋯
⊢ Exact f g
state_after: C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : Abelian C
X Y Z : C
f : X ⟶ Y
g : Y ⟶ Z
W : C
h : W ⟶ X
inst✝ : Epi h
hfg : Exact (h ≫ f) g
hc : IsColimit (CokernelCofork.ofπ (Cofork.π (colimit.cocone (parallelPair (h ≫ f) 0))) ⋯) :=
  isCokernelOfComp h (h ≫ f) (colimit.isColimit (parallelPair (h ≫ f) 0)) ⋯ ⋯
⊢ f ≫ g = 0

tactic: exact zero_of_epi_comp h (by rw [← hfg.1, Category.assoc])
state_before: C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : Abelian C
X Y Z : C
f : X ⟶ Y
g : Y ⟶ Z
W : C
h : W ⟶ X
inst✝ : Epi h
hfg : Exact (h ≫ f) g
hc : IsColimit (CokernelCofork.ofπ (Cofork.π (colimit.cocone (parallelPair (h ≫ f) 0))) ⋯) :=
  isCokernelOfComp h (h ≫ f) (colimit.isColimit (parallelPair (h ≫ f) 0)) ⋯ ⋯
⊢ f ≫ g = 0
state_after: no goals

tactic: rw [← cancel_epi h, ← Category.assoc, CokernelCofork.condition, comp_zero]
state_before: C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : Abelian C
X Y Z : C
f : X ⟶ Y
g : Y ⟶ Z
W : C
h : W ⟶ X
inst✝ : Epi h
hfg : Exact (h ≫ f) g
⊢ f ≫ Cofork.π (colimit.cocone (parallelPair (h ≫ f) 0)) = 0
state_after: no goals

tactic: rw [← hfg.1, Category.assoc]
state_before: C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : Abelian C
X Y Z : C
f : X ⟶ Y
g : Y ⟶ Z
W : C
h : W ⟶ X
inst✝ : Epi h
hfg : Exact (h ≫ f) g
hc : IsColimit (CokernelCofork.ofπ (Cofork.π (colimit.cocone (parallelPair (h ≫ f) 0))) ⋯) :=
  isCokernelOfComp h (h ≫ f) (colimit.isColimit (parallelPair (h ≫ f) 0)) ⋯ ⋯
⊢ h ≫ f ≫ g = 0
state_after: no goals
Theorem: LSeriesSummable.neg
File: Mathlib/NumberTheory/LSeries/Linearity.lean

tactic: simpa only [LSeriesSummable, term_neg] using Summable.neg hf
state_before: f : ℕ → ℂ
s : ℂ
hf : LSeriesSummable f s
⊢ LSeriesSummable (-f) s
state_after: no goals
Theorem: not_wcovBy_iff
File: Mathlib/Order/Cover.lean

tactic: simp_rw [WCovBy, h, true_and_iff, not_forall, exists_prop, not_not]
state_before: α : Type u_1
β : Type u_2
inst✝¹ : Preorder α
inst✝ : Preorder β
a b c : α
h : a ≤ b
⊢ ¬a ⩿ b ↔ ∃ c, a < c ∧ c < b
state_after: no goals
Theorem: ProbabilityTheory.aestronglyMeasurable_exp_mul_add
File: Mathlib/Probability/Moments.lean

tactic: simp_rw [Pi.add_apply, mul_add, exp_add]
state_before: Ω : Type u_1
ι : Type u_2
m : MeasurableSpace Ω
X✝ : Ω → ℝ
p : ℕ
μ : Measure Ω
t : ℝ
X Y : Ω → ℝ
h_int_X : AEStronglyMeasurable (fun ω => rexp (t * X ω)) μ
h_int_Y : AEStronglyMeasurable (fun ω => rexp (t * Y ω)) μ
⊢ AEStronglyMeasurable (fun ω => rexp (t * (X + Y) ω)) μ
state_after: Ω : Type u_1
ι : Type u_2
m : MeasurableSpace Ω
X✝ : Ω → ℝ
p : ℕ
μ : Measure Ω
t : ℝ
X Y : Ω → ℝ
h_int_X : AEStronglyMeasurable (fun ω => rexp (t * X ω)) μ
h_int_Y : AEStronglyMeasurable (fun ω => rexp (t * Y ω)) μ
⊢ AEStronglyMeasurable (fun ω => rexp (t * X ω) * rexp (t * Y ω)) μ

tactic: exact AEStronglyMeasurable.mul h_int_X h_int_Y
state_before: Ω : Type u_1
ι : Type u_2
m : MeasurableSpace Ω
X✝ : Ω → ℝ
p : ℕ
μ : Measure Ω
t : ℝ
X Y : Ω → ℝ
h_int_X : AEStronglyMeasurable (fun ω => rexp (t * X ω)) μ
h_int_Y : AEStronglyMeasurable (fun ω => rexp (t * Y ω)) μ
⊢ AEStronglyMeasurable (fun ω => rexp (t * X ω) * rexp (t * Y ω)) μ
state_after: no goals
Theorem: MeasureTheory.tilted_of_not_aemeasurable
File: Mathlib/MeasureTheory/Measure/Tilted.lean

tactic: refine tilted_of_not_integrable ?_
state_before: α : Type u_1
mα : MeasurableSpace α
μ : Measure α
f : α → ℝ
hf : ¬AEMeasurable f μ
⊢ μ.tilted f = 0
state_after: α : Type u_1
mα : MeasurableSpace α
μ : Measure α
f : α → ℝ
hf : ¬AEMeasurable f μ
⊢ ¬Integrable (fun x => rexp (f x)) μ

tactic: suffices ¬ AEMeasurable (fun x ↦ exp (f x)) μ by exact fun h ↦ this h.1.aemeasurable
state_before: α : Type u_1
mα : MeasurableSpace α
μ : Measure α
f : α → ℝ
hf : ¬AEMeasurable f μ
⊢ ¬Integrable (fun x => rexp (f x)) μ
state_after: α : Type u_1
mα : MeasurableSpace α
μ : Measure α
f : α → ℝ
hf : ¬AEMeasurable f μ
⊢ ¬AEMeasurable (fun x => rexp (f x)) μ

tactic: exact fun h ↦ hf (aemeasurable_of_aemeasurable_exp h)
state_before: α : Type u_1
mα : MeasurableSpace α
μ : Measure α
f : α → ℝ
hf : ¬AEMeasurable f μ
⊢ ¬AEMeasurable (fun x => rexp (f x)) μ
state_after: no goals

tactic: exact fun h ↦ this h.1.aemeasurable
state_before: α : Type u_1
mα : MeasurableSpace α
μ : Measure α
f : α → ℝ
hf : ¬AEMeasurable f μ
this : ¬AEMeasurable (fun x => rexp (f x)) μ
⊢ ¬Integrable (fun x => rexp (f x)) μ
state_after: no goals
Theorem: smul_eq_self_of_mem_zpowers
File: Mathlib/GroupTheory/OrderOfElement.lean

tactic: obtain ⟨k, rfl⟩ := Subgroup.mem_zpowers_iff.mp hx
state_before: G : Type u_1
H : Type u_2
A : Type u_3
α✝ : Type u_4
β : Type u_5
inst✝¹ : Group G
x y : G
i : ℤ
α : Type u_6
inst✝ : MulAction G α
hx : x ∈ zpowers y
a : α
hs : y • a = a
⊢ x • a = a
state_after: case intro
G : Type u_1
H : Type u_2
A : Type u_3
α✝ : Type u_4
β : Type u_5
inst✝¹ : Group G
y : G
i : ℤ
α : Type u_6
inst✝ : MulAction G α
a : α
hs : y • a = a
k : ℤ
hx : y ^ k ∈ zpowers y
⊢ y ^ k • a = a

tactic: rw [← MulAction.toPerm_apply, ← MulAction.toPermHom_apply, MonoidHom.map_zpow _ y k,
  MulAction.toPermHom_apply]
state_before: case intro
G : Type u_1
H : Type u_2
A : Type u_3
α✝ : Type u_4
β : Type u_5
inst✝¹ : Group G
y : G
i : ℤ
α : Type u_6
inst✝ : MulAction G α
a : α
hs : y • a = a
k : ℤ
hx : y ^ k ∈ zpowers y
⊢ y ^ k • a = a
state_after: case intro
G : Type u_1
H : Type u_2
A : Type u_3
α✝ : Type u_4
β : Type u_5
inst✝¹ : Group G
y : G
i : ℤ
α : Type u_6
inst✝ : MulAction G α
a : α
hs : y • a = a
k : ℤ
hx : y ^ k ∈ zpowers y
⊢ (MulAction.toPerm y ^ k) a = a

tactic: exact Function.IsFixedPt.perm_zpow (by exact hs) k
state_before: case intro
G : Type u_1
H : Type u_2
A : Type u_3
α✝ : Type u_4
β : Type u_5
inst✝¹ : Group G
y : G
i : ℤ
α : Type u_6
inst✝ : MulAction G α
a : α
hs : y • a = a
k : ℤ
hx : y ^ k ∈ zpowers y
⊢ (MulAction.toPerm y ^ k) a = a
state_after: no goals

tactic: exact hs
state_before: G : Type u_1
H : Type u_2
A : Type u_3
α✝ : Type u_4
β : Type u_5
inst✝¹ : Group G
y : G
i : ℤ
α : Type u_6
inst✝ : MulAction G α
a : α
hs : y • a = a
k : ℤ
hx : y ^ k ∈ zpowers y
⊢ IsFixedPt (⇑(MulAction.toPerm y)) a
state_after: no goals
Theorem: List.mergeSort_cons_cons
File: Mathlib/Data/List/Sort.lean

tactic: simp only [mergeSort, h]
state_before: α : Type u
r : α → α → Prop
inst✝ : DecidableRel r
a b : α
l l₁ l₂ : List α
h : (a :: b :: l).split = (l₁, l₂)
⊢ mergeSort r (a :: b :: l) = merge (fun x x_1 => decide (r x x_1)) (mergeSort r l₁) (mergeSort r l₂)
state_after: no goals
Theorem: Set.range_inl
File: Mathlib/Data/Set/Image.lean

tactic: ext (_|_) <;> simp
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
ι' : Sort u_5
f : ι → α
s t : Set α
⊢ range Sum.inl = {x | x.isLeft = true}
state_after: no goals
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₂)
state_after: 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 : α
hl₁ : Chain R a []
ha : p a
hl₂ : ∀ (a : α), a ∈ [] → p a
⊢ Chain S (f a ha) (pmap f [] hl₂)

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)
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₂)

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 : α
hl₁ : Chain R a []
ha : p a
hl₂ : ∀ (a : α), a ∈ [] → p a
⊢ Chain S (f a ha) (pmap f [] hl₂)
state_after: no goals

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)
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₂)
state_after: no goals
Theorem: Batteries.UnionFind.parent'_lt
File: .lake/packages/batteries/Batteries/Data/UnionFind/Basic.lean

tactic: simp only [← parentD_eq, parentD_lt, Fin.is_lt, Array.data_length]
state_before: self : UnionFind
i : Fin self.size
⊢ (self.arr.get i).parent < self.size
state_after: no goals
Theorem: Polynomial.support_erase
File: Mathlib/Algebra/Polynomial/Basic.lean

tactic: rcases p with ⟨⟩
state_before: R : Type u
a b : R
m n✝ : ℕ
inst✝ : Semiring R
p✝ q p : R[X]
n : ℕ
⊢ (erase n p).support = p.support.erase n
state_after: case ofFinsupp
R : Type u
a b : R
m n✝ : ℕ
inst✝ : Semiring R
p q : R[X]
n : ℕ
toFinsupp✝ : R[ℕ]
⊢ (erase n { toFinsupp := toFinsupp✝ }).support = { toFinsupp := toFinsupp✝ }.support.erase n

tactic: simp only [support, erase_def, Finsupp.support_erase]
state_before: case ofFinsupp
R : Type u
a b : R
m n✝ : ℕ
inst✝ : Semiring R
p q : R[X]
n : ℕ
toFinsupp✝ : R[ℕ]
⊢ (erase n { toFinsupp := toFinsupp✝ }).support = { toFinsupp := toFinsupp✝ }.support.erase n
state_after: no goals
Theorem: monic_ascPochhammer
File: Mathlib/RingTheory/Polynomial/Pochhammer.lean

tactic: induction' n with n hn
state_before: S : Type u
inst✝² : Semiring S
n : ℕ
inst✝¹ : Nontrivial S
inst✝ : NoZeroDivisors S
⊢ (ascPochhammer S n).Monic
state_after: case zero
S : Type u
inst✝² : Semiring S
inst✝¹ : Nontrivial S
inst✝ : NoZeroDivisors S
⊢ (ascPochhammer S 0).Monic

case succ
S : Type u
inst✝² : Semiring S
inst✝¹ : Nontrivial S
inst✝ : NoZeroDivisors S
n : ℕ
hn : (ascPochhammer S n).Monic
⊢ (ascPochhammer S (n + 1)).Monic

tactic: simp
state_before: case zero
S : Type u
inst✝² : Semiring S
inst✝¹ : Nontrivial S
inst✝ : NoZeroDivisors S
⊢ (ascPochhammer S 0).Monic
state_after: no goals

tactic: have : leadingCoeff (X + 1 : S[X]) = 1 := leadingCoeff_X_add_C 1
state_before: case succ
S : Type u
inst✝² : Semiring S
inst✝¹ : Nontrivial S
inst✝ : NoZeroDivisors S
n : ℕ
hn : (ascPochhammer S n).Monic
⊢ (ascPochhammer S (n + 1)).Monic
state_after: case succ
S : Type u
inst✝² : Semiring S
inst✝¹ : Nontrivial S
inst✝ : NoZeroDivisors S
n : ℕ
hn : (ascPochhammer S n).Monic
this : (X + 1).leadingCoeff = 1
⊢ (ascPochhammer S (n + 1)).Monic

tactic: rw [ascPochhammer_succ_left, Monic.def, leadingCoeff_mul,
  leadingCoeff_comp (ne_zero_of_eq_one <| natDegree_X_add_C 1 : natDegree (X + 1) ≠ 0), hn,
  monic_X, one_mul, one_mul, this, one_pow]
state_before: case succ
S : Type u
inst✝² : Semiring S
inst✝¹ : Nontrivial S
inst✝ : NoZeroDivisors S
n : ℕ
hn : (ascPochhammer S n).Monic
this : (X + 1).leadingCoeff = 1
⊢ (ascPochhammer S (n + 1)).Monic
state_after: no goals
Theorem: Polynomial.natDegree_prod_le
File: Mathlib/Algebra/Polynomial/BigOperators.lean

tactic: simpa using natDegree_multiset_prod_le (s.1.map f)
state_before: R : Type u
ι : Type w
s : Finset ι
inst✝ : CommSemiring R
f : ι → R[X]
t : Multiset R[X]
⊢ (∏ i ∈ s, f i).natDegree ≤ ∑ i ∈ s, (f i).natDegree
state_after: no goals
Theorem: LinearMap.surjective_or_eq_zero
File: Mathlib/RingTheory/SimpleModule.lean

tactic: rw [← range_eq_top, ← range_eq_bot, or_comm]
state_before: ι : Type u_1
R : Type u_2
S : Type u_3
inst✝⁶ : Ring R
inst✝⁵ : Ring S
M : Type u_4
inst✝⁴ : AddCommGroup M
inst✝³ : Module R M
m : Submodule R M
N : Type u_5
inst✝² : AddCommGroup N
inst✝¹ : Module R N
inst✝ : IsSimpleModule R N
f : M →ₗ[R] N
⊢ Function.Surjective ⇑f ∨ f = 0
state_after: ι : Type u_1
R : Type u_2
S : Type u_3
inst✝⁶ : Ring R
inst✝⁵ : Ring S
M : Type u_4
inst✝⁴ : AddCommGroup M
inst✝³ : Module R M
m : Submodule R M
N : Type u_5
inst✝² : AddCommGroup N
inst✝¹ : Module R N
inst✝ : IsSimpleModule R N
f : M →ₗ[R] N
⊢ range f = ⊥ ∨ range f = ⊤

tactic: apply eq_bot_or_eq_top
state_before: ι : Type u_1
R : Type u_2
S : Type u_3
inst✝⁶ : Ring R
inst✝⁵ : Ring S
M : Type u_4
inst✝⁴ : AddCommGroup M
inst✝³ : Module R M
m : Submodule R M
N : Type u_5
inst✝² : AddCommGroup N
inst✝¹ : Module R N
inst✝ : IsSimpleModule R N
f : M →ₗ[R] N
⊢ range f = ⊥ ∨ range f = ⊤
state_after: no goals
Theorem: padicNormE.is_rat
File: Mathlib/NumberTheory/Padics/PadicNumbers.lean

tactic: simp [h]
state_before: p : ℕ
hp : Fact (Nat.Prime p)
q : ℚ_[p]
h : q = 0
⊢ ‖q‖ = ↑0
state_after: no goals
Theorem: MeasureTheory.AEStronglyMeasurable'.const_smul
File: Mathlib/MeasureTheory/Function/ConditionalExpectation/AEMeasurable.lean

tactic: rcases hf with ⟨f', h_f'_meas, hff'⟩
state_before: α : Type u_1
β : Type u_2
𝕜 : Type u_3
m m0 : MeasurableSpace α
μ : Measure α
inst✝² : TopologicalSpace β
f g : α → β
inst✝¹ : SMul 𝕜 β
inst✝ : ContinuousConstSMul 𝕜 β
c : 𝕜
hf : AEStronglyMeasurable' m f μ
⊢ AEStronglyMeasurable' m (c • f) μ
state_after: case intro.intro
α : Type u_1
β : Type u_2
𝕜 : Type u_3
m m0 : MeasurableSpace α
μ : Measure α
inst✝² : TopologicalSpace β
f g : α → β
inst✝¹ : SMul 𝕜 β
inst✝ : ContinuousConstSMul 𝕜 β
c : 𝕜
f' : α → β
h_f'_meas : StronglyMeasurable f'
hff' : f =ᶠ[ae μ] f'
⊢ AEStronglyMeasurable' m (c • f) μ

tactic: refine ⟨c • f', h_f'_meas.const_smul c, ?_⟩
state_before: case intro.intro
α : Type u_1
β : Type u_2
𝕜 : Type u_3
m m0 : MeasurableSpace α
μ : Measure α
inst✝² : TopologicalSpace β
f g : α → β
inst✝¹ : SMul 𝕜 β
inst✝ : ContinuousConstSMul 𝕜 β
c : 𝕜
f' : α → β
h_f'_meas : StronglyMeasurable f'
hff' : f =ᶠ[ae μ] f'
⊢ AEStronglyMeasurable' m (c • f) μ
state_after: case intro.intro
α : Type u_1
β : Type u_2
𝕜 : Type u_3
m m0 : MeasurableSpace α
μ : Measure α
inst✝² : TopologicalSpace β
f g : α → β
inst✝¹ : SMul 𝕜 β
inst✝ : ContinuousConstSMul 𝕜 β
c : 𝕜
f' : α → β
h_f'_meas : StronglyMeasurable f'
hff' : f =ᶠ[ae μ] f'
⊢ c • f =ᶠ[ae μ] c • f'

tactic: exact EventuallyEq.fun_comp hff' fun x => c • x
state_before: case intro.intro
α : Type u_1
β : Type u_2
𝕜 : Type u_3
m m0 : MeasurableSpace α
μ : Measure α
inst✝² : TopologicalSpace β
f g : α → β
inst✝¹ : SMul 𝕜 β
inst✝ : ContinuousConstSMul 𝕜 β
c : 𝕜
f' : α → β
h_f'_meas : StronglyMeasurable f'
hff' : f =ᶠ[ae μ] f'
⊢ c • f =ᶠ[ae μ] c • f'
state_after: no goals
Theorem: WeierstrassCurve.Affine.CoordinateRing.YClass_ne_zero
File: Mathlib/AlgebraicGeometry/EllipticCurve/Group.lean

tactic: rw [natDegree_polynomial, natDegree_X_sub_C]
state_before: R : Type u
S : Type v
inst✝² : CommRing R
inst✝¹ : CommRing S
W : Affine R
f : R →+* S
inst✝ : Nontrivial R
y : R[X]
⊢ (Y - C y).natDegree < W.polynomial.natDegree
state_after: R : Type u
S : Type v
inst✝² : CommRing R
inst✝¹ : CommRing S
W : Affine R
f : R →+* S
inst✝ : Nontrivial R
y : R[X]
⊢ 1 < 2

tactic: norm_num1
state_before: R : Type u
S : Type v
inst✝² : CommRing R
inst✝¹ : CommRing S
W : Affine R
f : R →+* S
inst✝ : Nontrivial R
y : R[X]
⊢ 1 < 2
state_after: no goals
Theorem: Matrix.isUnit_submatrix_equiv
File: Mathlib/LinearAlgebra/Matrix/NonsingularInverse.lean

tactic: simp only [← nonempty_invertible_iff_isUnit,
  (submatrixEquivInvertibleEquivInvertible A _ _).nonempty_congr]
state_before: l : Type u_1
m : Type u
n : Type u'
α : Type v
inst✝⁴ : Fintype n
inst✝³ : DecidableEq n
inst✝² : CommRing α
A✝ B : Matrix n n α
inst✝¹ : Fintype m
inst✝ : DecidableEq m
A : Matrix m m α
e₁ e₂ : n ≃ m
⊢ IsUnit (A.submatrix ⇑e₁ ⇑e₂) ↔ IsUnit A
state_after: no goals
Theorem: AffineMap.lineMap_apply_zero
File: Mathlib/LinearAlgebra/AffineSpace/AffineMap.lean

tactic: simp [lineMap_apply]
state_before: k : Type u_1
V1 : Type u_2
P1 : Type u_3
V2 : Type u_4
P2 : Type u_5
V3 : Type u_6
P3 : Type u_7
V4 : Type u_8
P4 : Type u_9
inst✝¹² : Ring k
inst✝¹¹ : AddCommGroup V1
inst✝¹⁰ : Module k V1
inst✝⁹ : AffineSpace V1 P1
inst✝⁸ : AddCommGroup V2
inst✝⁷ : Module k V2
inst✝⁶ : AffineSpace V2 P2
inst✝⁵ : AddCommGroup V3
inst✝⁴ : Module k V3
inst✝³ : AffineSpace V3 P3
inst✝² : AddCommGroup V4
inst✝¹ : Module k V4
inst✝ : AffineSpace V4 P4
p₀ p₁ : P1
⊢ (lineMap p₀ p₁) 0 = p₀
state_after: no goals
Theorem: Monoid.Coprod.induction_on
File: Mathlib/GroupTheory/Coprod/Basic.lean

tactic: simpa using inl 1
state_before: M : Type u_1
N : Type u_2
M' : Type u_3
N' : Type u_4
P : Type u_5
inst✝⁴ : MulOneClass M
inst✝³ : MulOneClass N
inst✝² : MulOneClass M'
inst✝¹ : MulOneClass N'
inst✝ : MulOneClass P
C : M ∗ N → Prop
m : M ∗ N
inl : ∀ (m : M), C (Monoid.Coprod.inl m)
inr : ∀ (n : N), C (Monoid.Coprod.inr n)
mul : ∀ (x y : M ∗ N), C x → C y → C (x * y)
⊢ C 1
state_after: no goals
Theorem: Hyperreal.infiniteNeg_add_not_infinitePos
File: Mathlib/Data/Real/Hyperreal.lean

tactic: rw [← infinitePos_neg, ← infinitePos_neg, ← @infiniteNeg_neg y, neg_add]
state_before: x y : ℝ*
⊢ x.InfiniteNeg → ¬y.InfinitePos → (x + y).InfiniteNeg
state_after: x y : ℝ*
⊢ (-x).InfinitePos → ¬(-y).InfiniteNeg → (-x + -y).InfinitePos

tactic: exact infinitePos_add_not_infiniteNeg
state_before: x y : ℝ*
⊢ (-x).InfinitePos → ¬(-y).InfiniteNeg → (-x + -y).InfinitePos
state_after: no goals