1337xyz1337xyz/leandojo-benchmark4-v10 huggingface dataset:
Theorem: Finpartition.IsEquipartition.card_large_parts_eq_mod
File: Mathlib/Order/Partition/Equipartition.lean

tactic: have z := P.sum_card_parts
state_before: α : Type u_1
inst✝ : DecidableEq α
s t : Finset α
P : Finpartition s
hP : P.IsEquipartition
⊢ (filter (fun p => p.card = s.card / P.parts.card + 1) P.parts).card = s.card % P.parts.card
state_after: α : Type u_1
inst✝ : DecidableEq α
s t : Finset α
P : Finpartition s
hP : P.IsEquipartition
z : ∑ i ∈ P.parts, i.card = s.card
⊢ (filter (fun p => p.card = s.card / P.parts.card + 1) P.parts).card = s.card % P.parts.card

tactic: rw [← sum_filter_add_sum_filter_not (s := P.parts)
    (p := fun x ↦ x.card = s.card / P.parts.card + 1),
  hP.filter_ne_average_add_one_eq_average,
  sum_const_nat (m := s.card / P.parts.card + 1) (by simp),
  sum_const_nat (m := s.card / P.parts.card) (by simp),
  ← hP.filter_ne_average_add_one_eq_average,
  mul_add, add_comm, ← add_assoc, ← add_mul, mul_one, add_comm (Finset.card _),
  filter_card_add_filter_neg_card_eq_card, add_comm] at z
state_before: α : Type u_1
inst✝ : DecidableEq α
s t : Finset α
P : Finpartition s
hP : P.IsEquipartition
z : ∑ i ∈ P.parts, i.card = s.card
⊢ (filter (fun p => p.card = s.card / P.parts.card + 1) P.parts).card = s.card % P.parts.card
state_after: α : Type u_1
inst✝ : DecidableEq α
s t : Finset α
P : Finpartition s
hP : P.IsEquipartition
z :
  (filter (fun x => x.card = s.card / P.parts.card + 1) P.parts).card + P.parts.card * (s.card / P.parts.card) = s.card
⊢ (filter (fun p => p.card = s.card / P.parts.card + 1) P.parts).card = s.card % P.parts.card

tactic: rw [← add_left_inj, Nat.mod_add_div, z]
state_before: α : Type u_1
inst✝ : DecidableEq α
s t : Finset α
P : Finpartition s
hP : P.IsEquipartition
z :
  (filter (fun x => x.card = s.card / P.parts.card + 1) P.parts).card + P.parts.card * (s.card / P.parts.card) = s.card
⊢ (filter (fun p => p.card = s.card / P.parts.card + 1) P.parts).card = s.card % P.parts.card
state_after: no goals

tactic: simp
state_before: α : Type u_1
inst✝ : DecidableEq α
s t : Finset α
P : Finpartition s
hP : P.IsEquipartition
z :
  ∑ x ∈ filter (fun x => x.card = s.card / P.parts.card + 1) P.parts, x.card +
      ∑ x ∈ filter (fun p => p.card = s.card / P.parts.card) P.parts, x.card =
    s.card
⊢ ∀ x ∈ filter (fun x => x.card = s.card / P.parts.card + 1) P.parts, x.card = s.card / P.parts.card + 1
state_after: no goals

tactic: simp
state_before: α : Type u_1
inst✝ : DecidableEq α
s t : Finset α
P : Finpartition s
hP : P.IsEquipartition
z :
  (filter (fun x => x.card = s.card / P.parts.card + 1) P.parts).card * (s.card / P.parts.card + 1) +
      ∑ x ∈ filter (fun p => p.card = s.card / P.parts.card) P.parts, x.card =
    s.card
⊢ ∀ x ∈ filter (fun p => p.card = s.card / P.parts.card) P.parts, x.card = s.card / P.parts.card
state_after: no goals
Theorem: CommSemiring.toSemiring_injective
File: Mathlib/Algebra/Ring/Ext.lean

tactic: rintro ⟨⟩ ⟨⟩ _
state_before: R : Type u
⊢ Function.Injective (@toSemiring R)
state_after: case mk.mk
R : Type u
toSemiring✝¹ : Semiring R
mul_comm✝¹ : ∀ (a b : R), a * b = b * a
toSemiring✝ : Semiring R
mul_comm✝ : ∀ (a b : R), a * b = b * a
a✝ : toSemiring = toSemiring
⊢ mk mul_comm✝¹ = mk mul_comm✝

tactic: congr
state_before: case mk.mk
R : Type u
toSemiring✝¹ : Semiring R
mul_comm✝¹ : ∀ (a b : R), a * b = b * a
toSemiring✝ : Semiring R
mul_comm✝ : ∀ (a b : R), a * b = b * a
a✝ : toSemiring = toSemiring
⊢ mk mul_comm✝¹ = mk mul_comm✝
state_after: no goals
Theorem: tendsto_list_prod
File: Mathlib/Topology/Algebra/Monoid.lean

tactic: simp [tendsto_const_nhds]
state_before: ι : Type u_1
α : Type u_2
M : Type u_3
N : Type u_4
X : Type u_5
inst✝³ : TopologicalSpace X
inst✝² : TopologicalSpace M
inst✝¹ : Monoid M
inst✝ : ContinuousMul M
f : ι → α → M
x : Filter α
a : ι → M
x✝ : ∀ i ∈ [], Tendsto (f i) x (𝓝 (a i))
⊢ Tendsto (fun b => (List.map (fun c => f c b) []).prod) x (𝓝 (List.map a []).prod)
state_after: no goals

tactic: simp only [List.map_cons, List.prod_cons]
state_before: ι : Type u_1
α : Type u_2
M : Type u_3
N : Type u_4
X : Type u_5
inst✝³ : TopologicalSpace X
inst✝² : TopologicalSpace M
inst✝¹ : Monoid M
inst✝ : ContinuousMul M
f✝ : ι → α → M
x : Filter α
a : ι → M
f : ι
l : List ι
h : ∀ i ∈ f :: l, Tendsto (f✝ i) x (𝓝 (a i))
⊢ Tendsto (fun b => (List.map (fun c => f✝ c b) (f :: l)).prod) x (𝓝 (List.map a (f :: l)).prod)
state_after: ι : Type u_1
α : Type u_2
M : Type u_3
N : Type u_4
X : Type u_5
inst✝³ : TopologicalSpace X
inst✝² : TopologicalSpace M
inst✝¹ : Monoid M
inst✝ : ContinuousMul M
f✝ : ι → α → M
x : Filter α
a : ι → M
f : ι
l : List ι
h : ∀ i ∈ f :: l, Tendsto (f✝ i) x (𝓝 (a i))
⊢ Tendsto (fun b => f✝ f b * (List.map (fun c => f✝ c b) l).prod) x (𝓝 (a f * (List.map a l).prod))

tactic: exact
  (h f (List.mem_cons_self _ _)).mul
    (tendsto_list_prod l fun c hc => h c (List.mem_cons_of_mem _ hc))
state_before: ι : Type u_1
α : Type u_2
M : Type u_3
N : Type u_4
X : Type u_5
inst✝³ : TopologicalSpace X
inst✝² : TopologicalSpace M
inst✝¹ : Monoid M
inst✝ : ContinuousMul M
f✝ : ι → α → M
x : Filter α
a : ι → M
f : ι
l : List ι
h : ∀ i ∈ f :: l, Tendsto (f✝ i) x (𝓝 (a i))
⊢ Tendsto (fun b => f✝ f b * (List.map (fun c => f✝ c b) l).prod) x (𝓝 (a f * (List.map a l).prod))
state_after: no goals
Theorem: Sym2.map_congr
File: Mathlib/Data/Sym/Sym2.lean

tactic: ext y
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
f g : α → β
s : Sym2 α
h : ∀ x ∈ s, f x = g x
⊢ map f s = map g s
state_after: case h
α : Type u_1
β : Type u_2
γ : Type u_3
f g : α → β
s : Sym2 α
h : ∀ x ∈ s, f x = g x
y : β
⊢ y ∈ map f s ↔ y ∈ map g s

tactic: simp only [mem_map]
state_before: case h
α : Type u_1
β : Type u_2
γ : Type u_3
f g : α → β
s : Sym2 α
h : ∀ x ∈ s, f x = g x
y : β
⊢ y ∈ map f s ↔ y ∈ map g s
state_after: case h
α : Type u_1
β : Type u_2
γ : Type u_3
f g : α → β
s : Sym2 α
h : ∀ x ∈ s, f x = g x
y : β
⊢ (∃ a ∈ s, f a = y) ↔ ∃ a ∈ s, g a = y

tactic: rintro ⟨w, hw, rfl⟩
state_before: case h.mpr
α : Type u_1
β : Type u_2
γ : Type u_3
f g : α → β
s : Sym2 α
h : ∀ x ∈ s, f x = g x
y : β
⊢ (∃ a ∈ s, g a = y) → ∃ a ∈ s, f a = y
state_after: case h.mpr.intro.intro
α : Type u_1
β : Type u_2
γ : Type u_3
f g : α → β
s : Sym2 α
h : ∀ x ∈ s, f x = g x
w : α
hw : w ∈ s
⊢ ∃ a ∈ s, f a = g w

tactic: exact ⟨w, hw, by simp [hw, h]⟩
state_before: case h.mpr.intro.intro
α : Type u_1
β : Type u_2
γ : Type u_3
f g : α → β
s : Sym2 α
h : ∀ x ∈ s, f x = g x
w : α
hw : w ∈ s
⊢ ∃ a ∈ s, f a = g w
state_after: no goals

tactic: simp [hw, h]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
f g : α → β
s : Sym2 α
h : ∀ x ∈ s, f x = g x
w : α
hw : w ∈ s
⊢ f w = g w
state_after: no goals
Theorem: List.get_length_sub_one
File: Mathlib/Data/List/Basic.lean

tactic: rintro rfl
state_before: ι : Type u_1
α : Type u
β : Type v
γ : Type w
l₁ l₂ l : List α
h : l.length - 1 < l.length
⊢ l ≠ []
state_after: ι : Type u_1
α : Type u
β : Type v
γ : Type w
l₁ l₂ : List α
h : [].length - 1 < [].length
⊢ False

tactic: exact Nat.lt_irrefl 0 h
state_before: ι : Type u_1
α : Type u
β : Type v
γ : Type w
l₁ l₂ : List α
h : [].length - 1 < [].length
⊢ False
state_after: no goals
Theorem: PowerBasis.quotientEquivQuotientMinpolyMap_apply_mk
File: Mathlib/RingTheory/AdjoinRoot.lean

tactic: rw [PowerBasis.quotientEquivQuotientMinpolyMap, AlgEquiv.trans_apply, AlgEquiv.ofRingEquiv_apply,
  quotientEquiv_mk, AlgEquiv.coe_ringEquiv', AdjoinRoot.equiv'_symm_apply, PowerBasis.lift_aeval,
  AdjoinRoot.aeval_eq, AdjoinRoot.quotEquivQuotMap_apply_mk]
state_before: R : Type u
S : Type v
K : Type w
inst✝² : CommRing R
inst✝¹ : CommRing S
inst✝ : Algebra R S
pb : PowerBasis R S
I : Ideal R
g : R[X]
⊢ (pb.quotientEquivQuotientMinpolyMap I) ((Ideal.Quotient.mk (Ideal.map (algebraMap R S) I)) ((aeval pb.gen) g)) =
    (Ideal.Quotient.mk (span {Polynomial.map (Ideal.Quotient.mk I) (minpoly R pb.gen)}))
      (Polynomial.map (Ideal.Quotient.mk I) g)
state_after: no goals
Theorem: Seminorm.ball_smul
File: Mathlib/Analysis/Seminorm.lean

tactic: ext
state_before: R : Type u_1
R' : Type u_2
𝕜 : Type u_3
𝕜₂ : Type u_4
𝕜₃ : Type u_5
𝕝 : Type u_6
E : Type u_7
E₂ : Type u_8
E₃ : Type u_9
F : Type u_10
G : Type u_11
ι : Type u_12
inst✝² : SeminormedRing 𝕜
inst✝¹ : AddCommGroup E
inst✝ : SMul 𝕜 E
p✝ : Seminorm 𝕜 E
x✝ y : E
r✝ : ℝ
p : Seminorm 𝕜 E
c : ℝ≥0
hc : 0 < c
r : ℝ
x : E
⊢ (c • p).ball x r = p.ball x (r / ↑c)
state_after: case h
R : Type u_1
R' : Type u_2
𝕜 : Type u_3
𝕜₂ : Type u_4
𝕜₃ : Type u_5
𝕝 : Type u_6
E : Type u_7
E₂ : Type u_8
E₃ : Type u_9
F : Type u_10
G : Type u_11
ι : Type u_12
inst✝² : SeminormedRing 𝕜
inst✝¹ : AddCommGroup E
inst✝ : SMul 𝕜 E
p✝ : Seminorm 𝕜 E
x✝¹ y : E
r✝ : ℝ
p : Seminorm 𝕜 E
c : ℝ≥0
hc : 0 < c
r : ℝ
x x✝ : E
⊢ x✝ ∈ (c • p).ball x r ↔ x✝ ∈ p.ball x (r / ↑c)

tactic: rw [mem_ball, mem_ball, smul_apply, NNReal.smul_def, smul_eq_mul, mul_comm,
  lt_div_iff (NNReal.coe_pos.mpr hc)]
state_before: case h
R : Type u_1
R' : Type u_2
𝕜 : Type u_3
𝕜₂ : Type u_4
𝕜₃ : Type u_5
𝕝 : Type u_6
E : Type u_7
E₂ : Type u_8
E₃ : Type u_9
F : Type u_10
G : Type u_11
ι : Type u_12
inst✝² : SeminormedRing 𝕜
inst✝¹ : AddCommGroup E
inst✝ : SMul 𝕜 E
p✝ : Seminorm 𝕜 E
x✝¹ y : E
r✝ : ℝ
p : Seminorm 𝕜 E
c : ℝ≥0
hc : 0 < c
r : ℝ
x x✝ : E
⊢ x✝ ∈ (c • p).ball x r ↔ x✝ ∈ p.ball x (r / ↑c)
state_after: no goals
Theorem: List.pmap_congr
File: Mathlib/Data/List/Basic.lean

tactic: induction' l with _ _ ih
state_before: ι : Type u_1
α : Type u
β : Type v
γ : Type w
l₁ l₂ : List α
p q : α → Prop
f : (a : α) → p a → β
g : (a : α) → q a → β
l : List α
H₁ : ∀ (a : α), a ∈ l → p a
H₂ : ∀ (a : α), a ∈ l → q a
h : ∀ (a : α), a ∈ l → ∀ (h₁ : p a) (h₂ : q a), f a h₁ = g a h₂
⊢ pmap f l H₁ = pmap g l H₂
state_after: case nil
ι : Type u_1
α : Type u
β : Type v
γ : Type w
l₁ l₂ : List α
p q : α → Prop
f : (a : α) → p a → β
g : (a : α) → q a → β
H₁ : ∀ (a : α), a ∈ [] → p a
H₂ : ∀ (a : α), a ∈ [] → q a
h : ∀ (a : α), a ∈ [] → ∀ (h₁ : p a) (h₂ : q a), f a h₁ = g a h₂
⊢ pmap f [] H₁ = pmap g [] H₂

case cons
ι : Type u_1
α : Type u
β : Type v
γ : Type w
l₁ l₂ : List α
p q : α → Prop
f : (a : α) → p a → β
g : (a : α) → q a → β
head✝ : α
tail✝ : List α
ih :
  ∀ {H₁ : ∀ (a : α), a ∈ tail✝ → p a} {H₂ : ∀ (a : α), a ∈ tail✝ → q a},
    (∀ (a : α), a ∈ tail✝ → ∀ (h₁ : p a) (h₂ : q a), f a h₁ = g a h₂) → pmap f tail✝ H₁ = pmap g tail✝ H₂
H₁ : ∀ (a : α), a ∈ head✝ :: tail✝ → p a
H₂ : ∀ (a : α), a ∈ head✝ :: tail✝ → q a
h : ∀ (a : α), a ∈ head✝ :: tail✝ → ∀ (h₁ : p a) (h₂ : q a), f a h₁ = g a h₂
⊢ pmap f (head✝ :: tail✝) H₁ = pmap g (head✝ :: tail✝) H₂

tactic: rfl
state_before: case nil
ι : Type u_1
α : Type u
β : Type v
γ : Type w
l₁ l₂ : List α
p q : α → Prop
f : (a : α) → p a → β
g : (a : α) → q a → β
H₁ : ∀ (a : α), a ∈ [] → p a
H₂ : ∀ (a : α), a ∈ [] → q a
h : ∀ (a : α), a ∈ [] → ∀ (h₁ : p a) (h₂ : q a), f a h₁ = g a h₂
⊢ pmap f [] H₁ = pmap g [] H₂
state_after: no goals

tactic: rw [pmap, pmap, h _ (mem_cons_self _ _), ih fun a ha => h a (mem_cons_of_mem _ ha)]
state_before: case cons
ι : Type u_1
α : Type u
β : Type v
γ : Type w
l₁ l₂ : List α
p q : α → Prop
f : (a : α) → p a → β
g : (a : α) → q a → β
head✝ : α
tail✝ : List α
ih :
  ∀ {H₁ : ∀ (a : α), a ∈ tail✝ → p a} {H₂ : ∀ (a : α), a ∈ tail✝ → q a},
    (∀ (a : α), a ∈ tail✝ → ∀ (h₁ : p a) (h₂ : q a), f a h₁ = g a h₂) → pmap f tail✝ H₁ = pmap g tail✝ H₂
H₁ : ∀ (a : α), a ∈ head✝ :: tail✝ → p a
H₂ : ∀ (a : α), a ∈ head✝ :: tail✝ → q a
h : ∀ (a : α), a ∈ head✝ :: tail✝ → ∀ (h₁ : p a) (h₂ : q a), f a h₁ = g a h₂
⊢ pmap f (head✝ :: tail✝) H₁ = pmap g (head✝ :: tail✝) H₂
state_after: no goals
Theorem: Nat.ceil_pos
File: Mathlib/Algebra/Order/Floor.lean

tactic: rw [lt_ceil, cast_zero]
state_before: F : Type u_1
α : Type u_2
β : Type u_3
inst✝¹ : LinearOrderedSemiring α
inst✝ : FloorSemiring α
a : α
n : ℕ
⊢ 0 < ⌈a⌉₊ ↔ 0 < a
state_after: no goals
Theorem: PNat.coprime_coe
File: Mathlib/Data/PNat/Prime.lean

tactic: unfold Nat.Coprime Coprime
state_before: m n : ℕ+
⊢ (↑m).Coprime ↑n ↔ m.Coprime n
state_after: m n : ℕ+
⊢ (↑m).gcd ↑n = 1 ↔ m.gcd n = 1

tactic: rw [← coe_inj]
state_before: m n : ℕ+
⊢ (↑m).gcd ↑n = 1 ↔ m.gcd n = 1
state_after: m n : ℕ+
⊢ (↑m).gcd ↑n = 1 ↔ ↑(m.gcd n) = ↑1

tactic: simp
state_before: m n : ℕ+
⊢ (↑m).gcd ↑n = 1 ↔ ↑(m.gcd n) = ↑1
state_after: no goals
Theorem: CategoryTheory.MonoidalOfChosenFiniteProducts.leftUnitor_naturality
File: Mathlib/CategoryTheory/Monoidal/OfChosenFiniteProducts/Basic.lean

tactic: dsimp [tensorHom]
state_before: C : Type u
inst✝ : Category.{v, u} C
X Y : C
𝒯 : LimitCone (Functor.empty C)
ℬ : (X Y : C) → LimitCone (pair X Y)
X₁ X₂ : C
f : X₁ ⟶ X₂
⊢ tensorHom ℬ (𝟙 𝒯.cone.pt) f ≫ (BinaryFan.leftUnitor 𝒯.isLimit (ℬ 𝒯.cone.pt X₂).isLimit).hom =
    (BinaryFan.leftUnitor 𝒯.isLimit (ℬ 𝒯.cone.pt X₁).isLimit).hom ≫ f
state_after: C : Type u
inst✝ : Category.{v, u} C
X Y : C
𝒯 : LimitCone (Functor.empty C)
ℬ : (X Y : C) → LimitCone (pair X Y)
X₁ X₂ : C
f : X₁ ⟶ X₂
⊢ (ℬ 𝒯.cone.pt X₂).isLimit.lift
        (BinaryFan.mk (BinaryFan.fst (ℬ 𝒯.cone.pt X₁).cone ≫ 𝟙 𝒯.cone.pt) (BinaryFan.snd (ℬ 𝒯.cone.pt X₁).cone ≫ f)) ≫
      BinaryFan.snd (ℬ 𝒯.cone.pt X₂).cone =
    BinaryFan.snd (ℬ 𝒯.cone.pt X₁).cone ≫ f

tactic: simp
state_before: C : Type u
inst✝ : Category.{v, u} C
X Y : C
𝒯 : LimitCone (Functor.empty C)
ℬ : (X Y : C) → LimitCone (pair X Y)
X₁ X₂ : C
f : X₁ ⟶ X₂
⊢ (ℬ 𝒯.cone.pt X₂).isLimit.lift
        (BinaryFan.mk (BinaryFan.fst (ℬ 𝒯.cone.pt X₁).cone ≫ 𝟙 𝒯.cone.pt) (BinaryFan.snd (ℬ 𝒯.cone.pt X₁).cone ≫ f)) ≫
      BinaryFan.snd (ℬ 𝒯.cone.pt X₂).cone =
    BinaryFan.snd (ℬ 𝒯.cone.pt X₁).cone ≫ f
state_after: no goals
Theorem: CategoryTheory.Limits.limit.pre_π
File: Mathlib/CategoryTheory/Limits/HasLimits.lean

tactic: erw [IsLimit.fac]
state_before: J : Type u₁
inst✝⁴ : Category.{v₁, u₁} J
K : Type u₂
inst✝³ : Category.{v₂, u₂} K
C : Type u
inst✝² : Category.{v, u} C
F : J ⥤ C
inst✝¹ : HasLimit F
E : K ⥤ J
inst✝ : HasLimit (E ⋙ F)
k : K
⊢ pre F E ≫ π (E ⋙ F) k = π F (E.obj k)
state_after: J : Type u₁
inst✝⁴ : Category.{v₁, u₁} J
K : Type u₂
inst✝³ : Category.{v₂, u₂} K
C : Type u
inst✝² : Category.{v, u} C
F : J ⥤ C
inst✝¹ : HasLimit F
E : K ⥤ J
inst✝ : HasLimit (E ⋙ F)
k : K
⊢ (Cone.whisker E (cone F)).π.app k = π F (E.obj k)

tactic: rfl
state_before: J : Type u₁
inst✝⁴ : Category.{v₁, u₁} J
K : Type u₂
inst✝³ : Category.{v₂, u₂} K
C : Type u
inst✝² : Category.{v, u} C
F : J ⥤ C
inst✝¹ : HasLimit F
E : K ⥤ J
inst✝ : HasLimit (E ⋙ F)
k : K
⊢ (Cone.whisker E (cone F)).π.app k = π F (E.obj k)
state_after: no goals
Theorem: geom_sum_neg_iff
File: Mathlib/Algebra/GeomSum.lean

tactic: rw [← not_iff_not, not_lt, le_iff_lt_or_eq, eq_comm,
  or_congr (geom_sum_pos_iff hn) (geom_sum_eq_zero_iff_neg_one hn), Nat.odd_iff_not_even, ←
  add_eq_zero_iff_eq_neg, not_and, not_lt, le_iff_lt_or_eq, eq_comm, ← imp_iff_not_or, or_comm,
  and_comm, Decidable.and_or_imp, or_comm]
state_before: α : Type u
β : Type u_1
n : ℕ
x : α
inst✝ : LinearOrderedRing α
hn : n ≠ 0
⊢ ∑ i ∈ range n, x ^ i < 0 ↔ Even n ∧ x + 1 < 0
state_after: no goals
Theorem: Polynomial.eq_zero_of_degree_lt_of_eval_finset_eq_zero
File: Mathlib/LinearAlgebra/Lagrange.lean

tactic: rw [← mem_degreeLT] at degree_f_lt
state_before: R : Type u_1
inst✝¹ : CommRing R
inst✝ : IsDomain R
f g : R[X]
s : Finset R
degree_f_lt : f.degree < ↑s.card
eval_f : ∀ x ∈ s, eval x f = 0
⊢ f = 0
state_after: R : Type u_1
inst✝¹ : CommRing R
inst✝ : IsDomain R
f g : R[X]
s : Finset R
degree_f_lt : f ∈ degreeLT R s.card
eval_f : ∀ x ∈ s, eval x f = 0
⊢ f = 0

tactic: simp_rw [eval_eq_sum_degreeLTEquiv degree_f_lt] at eval_f
state_before: R : Type u_1
inst✝¹ : CommRing R
inst✝ : IsDomain R
f g : R[X]
s : Finset R
degree_f_lt : f ∈ degreeLT R s.card
eval_f : ∀ x ∈ s, eval x f = 0
⊢ f = 0
state_after: R : Type u_1
inst✝¹ : CommRing R
inst✝ : IsDomain R
f g : R[X]
s : Finset R
degree_f_lt : f ∈ degreeLT R s.card
eval_f : ∀ x ∈ s, ∑ i : Fin s.card, (degreeLTEquiv R s.card) ⟨f, degree_f_lt⟩ i * x ^ ↑i = 0
⊢ f = 0

tactic: rw [← degreeLTEquiv_eq_zero_iff_eq_zero degree_f_lt]
state_before: R : Type u_1
inst✝¹ : CommRing R
inst✝ : IsDomain R
f g : R[X]
s : Finset R
degree_f_lt : f ∈ degreeLT R s.card
eval_f : ∀ x ∈ s, ∑ i : Fin s.card, (degreeLTEquiv R s.card) ⟨f, degree_f_lt⟩ i * x ^ ↑i = 0
⊢ f = 0
state_after: R : Type u_1
inst✝¹ : CommRing R
inst✝ : IsDomain R
f g : R[X]
s : Finset R
degree_f_lt : f ∈ degreeLT R s.card
eval_f : ∀ x ∈ s, ∑ i : Fin s.card, (degreeLTEquiv R s.card) ⟨f, degree_f_lt⟩ i * x ^ ↑i = 0
⊢ (degreeLTEquiv R s.card) ⟨f, degree_f_lt⟩ = 0

tactic: exact
  Matrix.eq_zero_of_forall_index_sum_mul_pow_eq_zero
    (Injective.comp (Embedding.subtype _).inj' (equivFinOfCardEq (card_coe _)).symm.injective)
    fun _ => eval_f _ (Finset.coe_mem _)
state_before: R : Type u_1
inst✝¹ : CommRing R
inst✝ : IsDomain R
f g : R[X]
s : Finset R
degree_f_lt : f ∈ degreeLT R s.card
eval_f : ∀ x ∈ s, ∑ i : Fin s.card, (degreeLTEquiv R s.card) ⟨f, degree_f_lt⟩ i * x ^ ↑i = 0
⊢ (degreeLTEquiv R s.card) ⟨f, degree_f_lt⟩ = 0
state_after: no goals
Theorem: Submonoid.mem_sup_left
File: Mathlib/Algebra/Group/Submonoid/Membership.lean

tactic: rw [← SetLike.le_def]
state_before: M : Type u_1
A : Type u_2
B : Type u_3
inst✝ : MulOneClass M
S T : Submonoid M
⊢ ∀ {x : M}, x ∈ S → x ∈ S ⊔ T
state_after: M : Type u_1
A : Type u_2
B : Type u_3
inst✝ : MulOneClass M
S T : Submonoid M
⊢ S ≤ S ⊔ T

tactic: exact le_sup_left
state_before: M : Type u_1
A : Type u_2
B : Type u_3
inst✝ : MulOneClass M
S T : Submonoid M
⊢ S ≤ S ⊔ T
state_after: no goals
Theorem: Submodule.span_smul_eq
File: Mathlib/RingTheory/Ideal/Operations.lean

tactic: rw [← coe_set_smul, coe_span_smul]
state_before: R : Type u
M : Type v
inst✝² : CommSemiring R
inst✝¹ : AddCommMonoid M
inst✝ : Module R M
s : Set R
N : Submodule R M
⊢ Ideal.span s • N = s • N
state_after: no goals
Theorem: Real.hasStrictDerivAt_log_of_pos
File: Mathlib/Analysis/SpecialFunctions/Log/Deriv.lean

tactic: have : HasStrictDerivAt log (exp <| log x)⁻¹ x :=
  (hasStrictDerivAt_exp <| log x).of_local_left_inverse (continuousAt_log hx.ne')
      (ne_of_gt <| exp_pos _) <|
    Eventually.mono (lt_mem_nhds hx) @exp_log
state_before: x : ℝ
hx : 0 < x
⊢ HasStrictDerivAt log x⁻¹ x
state_after: x : ℝ
hx : 0 < x
this : HasStrictDerivAt log (rexp (log x))⁻¹ x
⊢ HasStrictDerivAt log x⁻¹ x

tactic: rwa [exp_log hx] at this
state_before: x : ℝ
hx : 0 < x
this : HasStrictDerivAt log (rexp (log x))⁻¹ x
⊢ HasStrictDerivAt log x⁻¹ x
state_after: no goals
Theorem: AlgebraicTopology.DoldKan.map_P
File: Mathlib/AlgebraicTopology/DoldKan/Projections.lean

tactic: induction' q with q hq
state_before: C : Type u_1
inst✝⁴ : Category.{u_4, u_1} C
inst✝³ : Preadditive C
X✝ : SimplicialObject C
D : Type u_2
inst✝² : Category.{u_3, u_2} D
inst✝¹ : Preadditive D
G : C ⥤ D
inst✝ : G.Additive
X : SimplicialObject C
q n : ℕ
⊢ G.map ((P q).f n) = (P q).f n
state_after: case zero
C : Type u_1
inst✝⁴ : Category.{u_4, u_1} C
inst✝³ : Preadditive C
X✝ : SimplicialObject C
D : Type u_2
inst✝² : Category.{u_3, u_2} D
inst✝¹ : Preadditive D
G : C ⥤ D
inst✝ : G.Additive
X : SimplicialObject C
n : ℕ
⊢ G.map ((P 0).f n) = (P 0).f n

case succ
C : Type u_1
inst✝⁴ : Category.{u_4, u_1} C
inst✝³ : Preadditive C
X✝ : SimplicialObject C
D : Type u_2
inst✝² : Category.{u_3, u_2} D
inst✝¹ : Preadditive D
G : C ⥤ D
inst✝ : G.Additive
X : SimplicialObject C
n q : ℕ
hq : G.map ((P q).f n) = (P q).f n
⊢ G.map ((P (q + 1)).f n) = (P (q + 1)).f n

tactic: simp only [P_zero]
state_before: case zero
C : Type u_1
inst✝⁴ : Category.{u_4, u_1} C
inst✝³ : Preadditive C
X✝ : SimplicialObject C
D : Type u_2
inst✝² : Category.{u_3, u_2} D
inst✝¹ : Preadditive D
G : C ⥤ D
inst✝ : G.Additive
X : SimplicialObject C
n : ℕ
⊢ G.map ((P 0).f n) = (P 0).f n
state_after: case zero
C : Type u_1
inst✝⁴ : Category.{u_4, u_1} C
inst✝³ : Preadditive C
X✝ : SimplicialObject C
D : Type u_2
inst✝² : Category.{u_3, u_2} D
inst✝¹ : Preadditive D
G : C ⥤ D
inst✝ : G.Additive
X : SimplicialObject C
n : ℕ
⊢ G.map ((𝟙 K[X]).f n) = (𝟙 K[((whiskering C D).obj G).obj X]).f n

tactic: apply G.map_id
state_before: case zero
C : Type u_1
inst✝⁴ : Category.{u_4, u_1} C
inst✝³ : Preadditive C
X✝ : SimplicialObject C
D : Type u_2
inst✝² : Category.{u_3, u_2} D
inst✝¹ : Preadditive D
G : C ⥤ D
inst✝ : G.Additive
X : SimplicialObject C
n : ℕ
⊢ G.map ((𝟙 K[X]).f n) = (𝟙 K[((whiskering C D).obj G).obj X]).f n
state_after: no goals

tactic: simp only [P_succ, comp_add, HomologicalComplex.comp_f, HomologicalComplex.add_f_apply,
  comp_id, Functor.map_add, Functor.map_comp, hq, map_Hσ]
state_before: case succ
C : Type u_1
inst✝⁴ : Category.{u_4, u_1} C
inst✝³ : Preadditive C
X✝ : SimplicialObject C
D : Type u_2
inst✝² : Category.{u_3, u_2} D
inst✝¹ : Preadditive D
G : C ⥤ D
inst✝ : G.Additive
X : SimplicialObject C
n q : ℕ
hq : G.map ((P q).f n) = (P q).f n
⊢ G.map ((P (q + 1)).f n) = (P (q + 1)).f n
state_after: no goals
Theorem: ENNReal.rpow_add_of_nonneg
File: Mathlib/Analysis/SpecialFunctions/Pow/NNReal.lean

tactic: induction x using recTopCoe
state_before: x : ℝ≥0∞
y z : ℝ
hy : 0 ≤ y
hz : 0 ≤ z
⊢ x ^ (y + z) = x ^ y * x ^ z
state_after: case top
y z : ℝ
hy : 0 ≤ y
hz : 0 ≤ z
⊢ ⊤ ^ (y + z) = ⊤ ^ y * ⊤ ^ z

case coe
y z : ℝ
hy : 0 ≤ y
hz : 0 ≤ z
x✝ : ℝ≥0
⊢ ↑x✝ ^ (y + z) = ↑x✝ ^ y * ↑x✝ ^ z

tactic: simp [coe_rpow_of_nonneg, hy, hz, add_nonneg hy hz, NNReal.rpow_add_of_nonneg _ hy hz]
state_before: case coe
y z : ℝ
hy : 0 ≤ y
hz : 0 ≤ z
x✝ : ℝ≥0
⊢ ↑x✝ ^ (y + z) = ↑x✝ ^ y * ↑x✝ ^ z
state_after: no goals

tactic: rcases hy.eq_or_lt with rfl|hy
state_before: case top
y z : ℝ
hy : 0 ≤ y
hz : 0 ≤ z
⊢ ⊤ ^ (y + z) = ⊤ ^ y * ⊤ ^ z
state_after: case top.inl
z : ℝ
hz : 0 ≤ z
hy : 0 ≤ 0
⊢ ⊤ ^ (0 + z) = ⊤ ^ 0 * ⊤ ^ z

case top.inr
y z : ℝ
hy✝ : 0 ≤ y
hz : 0 ≤ z
hy : 0 < y
⊢ ⊤ ^ (y + z) = ⊤ ^ y * ⊤ ^ z

tactic: rcases hz.eq_or_lt with rfl|hz
state_before: case top.inr
y z : ℝ
hy✝ : 0 ≤ y
hz : 0 ≤ z
hy : 0 < y
⊢ ⊤ ^ (y + z) = ⊤ ^ y * ⊤ ^ z
state_after: case top.inr.inl
y : ℝ
hy✝ : 0 ≤ y
hy : 0 < y
hz : 0 ≤ 0
⊢ ⊤ ^ (y + 0) = ⊤ ^ y * ⊤ ^ 0

case top.inr.inr
y z : ℝ
hy✝ : 0 ≤ y
hz✝ : 0 ≤ z
hy : 0 < y
hz : 0 < z
⊢ ⊤ ^ (y + z) = ⊤ ^ y * ⊤ ^ z

tactic: simp [top_rpow_of_pos, hy, hz, add_pos hy hz]
state_before: case top.inr.inr
y z : ℝ
hy✝ : 0 ≤ y
hz✝ : 0 ≤ z
hy : 0 < y
hz : 0 < z
⊢ ⊤ ^ (y + z) = ⊤ ^ y * ⊤ ^ z
state_after: no goals

tactic: rw [rpow_zero, one_mul, zero_add]
state_before: case top.inl
z : ℝ
hz : 0 ≤ z
hy : 0 ≤ 0
⊢ ⊤ ^ (0 + z) = ⊤ ^ 0 * ⊤ ^ z
state_after: no goals

tactic: rw [rpow_zero, mul_one, add_zero]
state_before: case top.inr.inl
y : ℝ
hy✝ : 0 ≤ y
hy : 0 < y
hz : 0 ≤ 0
⊢ ⊤ ^ (y + 0) = ⊤ ^ y * ⊤ ^ 0
state_after: no goals