1337xyz1337xyz/leandojo-benchmark4-v10 huggingface dataset:
Theorem: succ_dvd_or_succ_dvd_of_succ_sum_dvd_mul
File: Mathlib/Algebra/Associated.lean

tactic: simpa [mul_comm, pow_add, hx, hy, mul_assoc, mul_left_comm] using hz
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝ : CancelCommMonoidWithZero α
a✝ p : α
hp : Prime p
a b : α
k l : ℕ
x✝² : p ^ k ∣ a
x✝¹ : p ^ l ∣ b
x✝ : p ^ (k + l + 1) ∣ a * b
x : α
hx : a = p ^ k * x
y : α
hy : b = p ^ l * y
z : α
hz : a * b = p ^ (k + l + 1) * z
⊢ p ^ (k + l) * (x * y) = p ^ (k + l) * (p * z)
state_after: no goals

tactic: rwa [mul_right_inj' hp0] at h
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝ : CancelCommMonoidWithZero α
a✝ p : α
hp : Prime p
a b : α
k l : ℕ
x✝² : p ^ k ∣ a
x✝¹ : p ^ l ∣ b
x✝ : p ^ (k + l + 1) ∣ a * b
x : α
hx : a = p ^ k * x
y : α
hy : b = p ^ l * y
z : α
hz : a * b = p ^ (k + l + 1) * z
h : p ^ (k + l) * (x * y) = p ^ (k + l) * (p * z)
hp0 : p ^ (k + l) ≠ 0
⊢ x * y = p * z
state_after: no goals

tactic: simp [*, pow_succ, mul_comm, mul_left_comm, mul_assoc]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝ : CancelCommMonoidWithZero α
a✝ p : α
hp : Prime p
a b : α
k l : ℕ
x✝³ : p ^ k ∣ a
x✝² : p ^ l ∣ b
x✝¹ : p ^ (k + l + 1) ∣ a * b
x : α
hx : a = p ^ k * x
y : α
hy : b = p ^ l * y
z : α
hz : a * b = p ^ (k + l + 1) * z
h : p ^ (k + l) * (x * y) = p ^ (k + l) * (p * z)
hp0 : p ^ (k + l) ≠ 0
hpd : p ∣ x * y
x✝ : p ∣ x
d : α
hd : x = p * d
⊢ a = p ^ (k + 1) * d
state_after: no goals

tactic: simp [*, pow_succ, mul_comm, mul_left_comm, mul_assoc]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝ : CancelCommMonoidWithZero α
a✝ p : α
hp : Prime p
a b : α
k l : ℕ
x✝³ : p ^ k ∣ a
x✝² : p ^ l ∣ b
x✝¹ : p ^ (k + l + 1) ∣ a * b
x : α
hx : a = p ^ k * x
y : α
hy : b = p ^ l * y
z : α
hz : a * b = p ^ (k + l + 1) * z
h : p ^ (k + l) * (x * y) = p ^ (k + l) * (p * z)
hp0 : p ^ (k + l) ≠ 0
hpd : p ∣ x * y
x✝ : p ∣ y
d : α
hd : y = p * d
⊢ b = p ^ (l + 1) * d
state_after: no goals
Theorem: CategoryTheory.tensorRightHomEquiv_symm_coevaluation_comp_whiskerRight
File: Mathlib/CategoryTheory/Monoidal/Rigid/Basic.lean

tactic: dsimp [tensorRightHomEquiv]
state_before: C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
Y Y' Z : C
inst✝ : ExactPairing Y Y'
f : Y ⟶ Z
⊢ (tensorRightHomEquiv (𝟙_ C) Y Y' Z).symm (η_ Y Y' ≫ f ▷ Y') = η_ Y Y' ▷ Y ⊗≫ (f ▷ (Y' ⊗ Y) ≫ Z ◁ ε_ Y Y') ⊗≫ 𝟙 Z
state_after: C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
Y Y' Z : C
inst✝ : ExactPairing Y Y'
f : Y ⟶ Z
⊢ (η_ Y Y' ≫ f ▷ Y') ▷ Y ≫ (α_ Z Y' Y).hom ≫ Z ◁ ε_ Y Y' ≫ (ρ_ Z).hom =
    η_ Y Y' ▷ Y ⊗≫ (f ▷ (Y' ⊗ Y) ≫ Z ◁ ε_ Y Y') ⊗≫ 𝟙 Z

tactic: coherence
state_before: C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
Y Y' Z : C
inst✝ : ExactPairing Y Y'
f : Y ⟶ Z
⊢ (η_ Y Y' ≫ f ▷ Y') ▷ Y ≫ (α_ Z Y' Y).hom ≫ Z ◁ ε_ Y Y' ≫ (ρ_ Z).hom =
    η_ Y Y' ▷ Y ⊗≫ (f ▷ (Y' ⊗ Y) ≫ Z ◁ ε_ Y Y') ⊗≫ 𝟙 Z
state_after: no goals

tactic: rw [← whisker_exchange]
state_before: C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
Y Y' Z : C
inst✝ : ExactPairing Y Y'
f : Y ⟶ Z
⊢ η_ Y Y' ▷ Y ⊗≫ (f ▷ (Y' ⊗ Y) ≫ Z ◁ ε_ Y Y') ⊗≫ 𝟙 Z = (η_ Y Y' ▷ Y ⊗≫ Y ◁ ε_ Y Y') ⊗≫ f
state_after: C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
Y Y' Z : C
inst✝ : ExactPairing Y Y'
f : Y ⟶ Z
⊢ η_ Y Y' ▷ Y ⊗≫ (Y ◁ ε_ Y Y' ≫ f ▷ 𝟙_ C) ⊗≫ 𝟙 Z = (η_ Y Y' ▷ Y ⊗≫ Y ◁ ε_ Y Y') ⊗≫ f

tactic: coherence
state_before: C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
Y Y' Z : C
inst✝ : ExactPairing Y Y'
f : Y ⟶ Z
⊢ η_ Y Y' ▷ Y ⊗≫ (Y ◁ ε_ Y Y' ≫ f ▷ 𝟙_ C) ⊗≫ 𝟙 Z = (η_ Y Y' ▷ Y ⊗≫ Y ◁ ε_ Y Y') ⊗≫ f
state_after: no goals

tactic: rw [evaluation_coevaluation'']
state_before: C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
Y Y' Z : C
inst✝ : ExactPairing Y Y'
f : Y ⟶ Z
⊢ (η_ Y Y' ▷ Y ⊗≫ Y ◁ ε_ Y Y') ⊗≫ f = (λ_ Y).hom ≫ f
state_after: C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
Y Y' Z : C
inst✝ : ExactPairing Y Y'
f : Y ⟶ Z
⊢  ⊗𝟙 ⊗≫ f = (λ_ Y).hom ≫ f

tactic: coherence
state_before: C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
Y Y' Z : C
inst✝ : ExactPairing Y Y'
f : Y ⟶ Z
⊢  ⊗𝟙 ⊗≫ f = (λ_ Y).hom ≫ f
state_after: no goals
Theorem: SimpleGraph.isNClique_bot_iff
File: Mathlib/Combinatorics/SimpleGraph/Clique.lean

tactic: rw [isNClique_iff, isClique_bot_iff]
state_before: α : Type u_1
β : Type u_2
G H : SimpleGraph α
n : ℕ
s : Finset α
a b c : α
⊢ ⊥.IsNClique n s ↔ n ≤ 1 ∧ s.card = n
state_after: α : Type u_1
β : Type u_2
G H : SimpleGraph α
n : ℕ
s : Finset α
a b c : α
⊢ (↑s).Subsingleton ∧ s.card = n ↔ n ≤ 1 ∧ s.card = n

tactic: refine and_congr_left ?_
state_before: α : Type u_1
β : Type u_2
G H : SimpleGraph α
n : ℕ
s : Finset α
a b c : α
⊢ (↑s).Subsingleton ∧ s.card = n ↔ n ≤ 1 ∧ s.card = n
state_after: α : Type u_1
β : Type u_2
G H : SimpleGraph α
n : ℕ
s : Finset α
a b c : α
⊢ s.card = n → ((↑s).Subsingleton ↔ n ≤ 1)

tactic: rintro rfl
state_before: α : Type u_1
β : Type u_2
G H : SimpleGraph α
n : ℕ
s : Finset α
a b c : α
⊢ s.card = n → ((↑s).Subsingleton ↔ n ≤ 1)
state_after: α : Type u_1
β : Type u_2
G H : SimpleGraph α
s : Finset α
a b c : α
⊢ (↑s).Subsingleton ↔ s.card ≤ 1

tactic: exact card_le_one.symm
state_before: α : Type u_1
β : Type u_2
G H : SimpleGraph α
s : Finset α
a b c : α
⊢ (↑s).Subsingleton ↔ s.card ≤ 1
state_after: no goals
Theorem: Subalgebra.mvPolynomial_aeval_coe
File: Mathlib/RingTheory/MvPolynomial/Tower.lean

tactic: convert aeval_algebraMap_apply A x p
state_before: R : Type u_1
A : Type u_2
B : Type u_3
σ : Type u_4
inst✝² : CommSemiring R
inst✝¹ : CommSemiring A
inst✝ : Algebra R A
S : Subalgebra R A
x : σ → ↥S
p : MvPolynomial σ R
⊢ (aeval fun i => ↑(x i)) p = ↑((aeval x) p)
state_after: no goals
Theorem: partialSups_eq_sup'_range
File: Mathlib/Order/PartialSups.lean

tactic: simp [Nat.lt_succ_iff]
state_before: α : Type u_1
inst✝ : SemilatticeSup α
f : ℕ → α
n : ℕ
x✝ : α
⊢ (partialSups f) n ≤ x✝ ↔ (Finset.range (n + 1)).sup' ⋯ f ≤ x✝
state_after: no goals
Theorem: Nat.nonempty_divisors
File: Mathlib/NumberTheory/Divisors.lean

tactic: simp [hn] at hm
state_before: n : ℕ
x✝ : n.divisors.Nonempty
hn : n = 0
m : ℕ
hm : m ∈ n.divisors
⊢ False
state_after: no goals
Theorem: CategoryTheory.Limits.limit.pre_pre
File: Mathlib/CategoryTheory/Limits/HasLimits.lean

tactic: haveI : HasLimit ((D ⋙ E) ⋙ F) := h
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)
L : Type u₃
inst✝¹ : Category.{v₃, u₃} L
D : L ⥤ K
inst✝ h : HasLimit (D ⋙ E ⋙ F)
⊢ pre F E ≫ pre (E ⋙ F) D = pre F (D ⋙ E)
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)
L : Type u₃
inst✝¹ : Category.{v₃, u₃} L
D : L ⥤ K
inst✝ h : HasLimit (D ⋙ E ⋙ F)
this : HasLimit ((D ⋙ E) ⋙ F)
⊢ pre F E ≫ pre (E ⋙ F) D = pre F (D ⋙ E)

tactic: ext j
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)
L : Type u₃
inst✝¹ : Category.{v₃, u₃} L
D : L ⥤ K
inst✝ h : HasLimit (D ⋙ E ⋙ F)
this : HasLimit ((D ⋙ E) ⋙ F)
⊢ pre F E ≫ pre (E ⋙ F) D = pre F (D ⋙ E)
state_after: case w
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)
L : Type u₃
inst✝¹ : Category.{v₃, u₃} L
D : L ⥤ K
inst✝ h : HasLimit (D ⋙ E ⋙ F)
this : HasLimit ((D ⋙ E) ⋙ F)
j : L
⊢ (pre F E ≫ pre (E ⋙ F) D) ≫ π (D ⋙ E ⋙ F) j = pre F (D ⋙ E) ≫ π (D ⋙ E ⋙ F) j

tactic: erw [assoc, limit.pre_π, limit.pre_π, limit.pre_π]
state_before: case w
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)
L : Type u₃
inst✝¹ : Category.{v₃, u₃} L
D : L ⥤ K
inst✝ h : HasLimit (D ⋙ E ⋙ F)
this : HasLimit ((D ⋙ E) ⋙ F)
j : L
⊢ (pre F E ≫ pre (E ⋙ F) D) ≫ π (D ⋙ E ⋙ F) j = pre F (D ⋙ E) ≫ π (D ⋙ E ⋙ F) j
state_after: case w
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)
L : Type u₃
inst✝¹ : Category.{v₃, u₃} L
D : L ⥤ K
inst✝ h : HasLimit (D ⋙ E ⋙ F)
this : HasLimit ((D ⋙ E) ⋙ F)
j : L
⊢ π F (E.obj (D.obj j)) = π F ((D ⋙ E).obj j)

tactic: rfl
state_before: case w
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)
L : Type u₃
inst✝¹ : Category.{v₃, u₃} L
D : L ⥤ K
inst✝ h : HasLimit (D ⋙ E ⋙ F)
this : HasLimit ((D ⋙ E) ⋙ F)
j : L
⊢ π F (E.obj (D.obj j)) = π F ((D ⋙ E).obj j)
state_after: no goals
Theorem: real_inner_div_norm_mul_norm_eq_one_of_ne_zero_of_pos_mul
File: Mathlib/Analysis/InnerProductSpace/Basic.lean

tactic: rw [real_inner_smul_self_right, norm_smul, Real.norm_eq_abs, ← mul_assoc ‖x‖, mul_comm _ |r|,
  mul_assoc, abs_of_nonneg hr.le, div_self]
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
inst✝⁴ : _root_.RCLike 𝕜
inst✝³ : NormedAddCommGroup E
inst✝² : InnerProductSpace 𝕜 E
inst✝¹ : NormedAddCommGroup F
inst✝ : InnerProductSpace ℝ F
x : F
r : ℝ
hx : x ≠ 0
hr : 0 < r
⊢ ⟪x, r • x⟫_ℝ / (‖x‖ * ‖r • x‖) = 1
state_after: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
inst✝⁴ : _root_.RCLike 𝕜
inst✝³ : NormedAddCommGroup E
inst✝² : InnerProductSpace 𝕜 E
inst✝¹ : NormedAddCommGroup F
inst✝ : InnerProductSpace ℝ F
x : F
r : ℝ
hx : x ≠ 0
hr : 0 < r
⊢ r * (‖x‖ * ‖x‖) ≠ 0

tactic: exact mul_ne_zero hr.ne' (mul_self_ne_zero.2 (norm_ne_zero_iff.2 hx))
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
inst✝⁴ : _root_.RCLike 𝕜
inst✝³ : NormedAddCommGroup E
inst✝² : InnerProductSpace 𝕜 E
inst✝¹ : NormedAddCommGroup F
inst✝ : InnerProductSpace ℝ F
x : F
r : ℝ
hx : x ≠ 0
hr : 0 < r
⊢ r * (‖x‖ * ‖x‖) ≠ 0
state_after: no goals
Theorem: equicontinuousWithinAt_iff_continuousWithinAt
File: Mathlib/Topology/UniformSpace/Equicontinuity.lean

tactic: rw [ContinuousWithinAt, (UniformFun.hasBasis_nhds ι α _).tendsto_right_iff]
state_before: ι : Type u_1
κ : Type u_2
X : Type u_3
X' : Type u_4
Y : Type u_5
Z : Type u_6
α : Type u_7
α' : Type u_8
β : Type u_9
β' : Type u_10
γ : Type u_11
𝓕 : Type u_12
tX : TopologicalSpace X
tY : TopologicalSpace Y
tZ : TopologicalSpace Z
uα : UniformSpace α
uβ : UniformSpace β
uγ : UniformSpace γ
F : ι → X → α
S : Set X
x₀ : X
⊢ EquicontinuousWithinAt F S x₀ ↔ ContinuousWithinAt (⇑UniformFun.ofFun ∘ swap F) S x₀
state_after: ι : Type u_1
κ : Type u_2
X : Type u_3
X' : Type u_4
Y : Type u_5
Z : Type u_6
α : Type u_7
α' : Type u_8
β : Type u_9
β' : Type u_10
γ : Type u_11
𝓕 : Type u_12
tX : TopologicalSpace X
tY : TopologicalSpace Y
tZ : TopologicalSpace Z
uα : UniformSpace α
uβ : UniformSpace β
uγ : UniformSpace γ
F : ι → X → α
S : Set X
x₀ : X
⊢ EquicontinuousWithinAt F S x₀ ↔
    ∀ i ∈ 𝓤 α,
      ∀ᶠ (x : X) in 𝓝[S] x₀,
        (⇑UniformFun.ofFun ∘ swap F) x ∈ {g | ((⇑UniformFun.ofFun ∘ swap F) x₀, g) ∈ UniformFun.gen ι α i}

tactic: rfl
state_before: ι : Type u_1
κ : Type u_2
X : Type u_3
X' : Type u_4
Y : Type u_5
Z : Type u_6
α : Type u_7
α' : Type u_8
β : Type u_9
β' : Type u_10
γ : Type u_11
𝓕 : Type u_12
tX : TopologicalSpace X
tY : TopologicalSpace Y
tZ : TopologicalSpace Z
uα : UniformSpace α
uβ : UniformSpace β
uγ : UniformSpace γ
F : ι → X → α
S : Set X
x₀ : X
⊢ EquicontinuousWithinAt F S x₀ ↔
    ∀ i ∈ 𝓤 α,
      ∀ᶠ (x : X) in 𝓝[S] x₀,
        (⇑UniformFun.ofFun ∘ swap F) x ∈ {g | ((⇑UniformFun.ofFun ∘ swap F) x₀, g) ∈ UniformFun.gen ι α i}
state_after: no goals
Theorem: CategoryTheory.Iso.cancel_iso_hom_right_assoc
File: Mathlib/CategoryTheory/Iso.lean

tactic: simp only [← Category.assoc, cancel_mono]
state_before: C : Type u
inst✝ : Category.{v, u} C
X✝ Y✝ Z✝ W X X' Y Z : C
f : W ⟶ X
g : X ⟶ Y
f' : W ⟶ X'
g' : X' ⟶ Y
h : Y ≅ Z
⊢ f ≫ g ≫ h.hom = f' ≫ g' ≫ h.hom ↔ f ≫ g = f' ≫ g'
state_after: no goals
Theorem: Ordinal.nfpBFamily_le_apply
File: Mathlib/SetTheory/Ordinal/FixedPoint.lean

tactic: rw [← not_iff_not]
state_before: o : Ordinal.{u}
f : (b : Ordinal.{u}) → b < o → Ordinal.{max u v} → Ordinal.{max u v}
ho : o ≠ 0
H : ∀ (i : Ordinal.{u}) (hi : i < o), IsNormal (f i hi)
a : Ordinal.{max v u}
b : Ordinal.{max u v}
⊢ (∃ i, ∃ (hi : i < o), o.nfpBFamily f a ≤ f i hi b) ↔ o.nfpBFamily f a ≤ b
state_after: o : Ordinal.{u}
f : (b : Ordinal.{u}) → b < o → Ordinal.{max u v} → Ordinal.{max u v}
ho : o ≠ 0
H : ∀ (i : Ordinal.{u}) (hi : i < o), IsNormal (f i hi)
a : Ordinal.{max v u}
b : Ordinal.{max u v}
⊢ (¬∃ i, ∃ (hi : i < o), o.nfpBFamily f a ≤ f i hi b) ↔ ¬o.nfpBFamily f a ≤ b

tactic: push_neg
state_before: o : Ordinal.{u}
f : (b : Ordinal.{u}) → b < o → Ordinal.{max u v} → Ordinal.{max u v}
ho : o ≠ 0
H : ∀ (i : Ordinal.{u}) (hi : i < o), IsNormal (f i hi)
a : Ordinal.{max v u}
b : Ordinal.{max u v}
⊢ (¬∃ i, ∃ (hi : i < o), o.nfpBFamily f a ≤ f i hi b) ↔ ¬o.nfpBFamily f a ≤ b
state_after: o : Ordinal.{u}
f : (b : Ordinal.{u}) → b < o → Ordinal.{max u v} → Ordinal.{max u v}
ho : o ≠ 0
H : ∀ (i : Ordinal.{u}) (hi : i < o), IsNormal (f i hi)
a : Ordinal.{max v u}
b : Ordinal.{max u v}
⊢ (∀ (i : Ordinal.{u}) (hi : i < o), f i hi b < o.nfpBFamily f a) ↔ b < o.nfpBFamily f a

tactic: exact apply_lt_nfpBFamily_iff.{u, v} ho H
state_before: o : Ordinal.{u}
f : (b : Ordinal.{u}) → b < o → Ordinal.{max u v} → Ordinal.{max u v}
ho : o ≠ 0
H : ∀ (i : Ordinal.{u}) (hi : i < o), IsNormal (f i hi)
a : Ordinal.{max v u}
b : Ordinal.{max u v}
⊢ (∀ (i : Ordinal.{u}) (hi : i < o), f i hi b < o.nfpBFamily f a) ↔ b < o.nfpBFamily f a
state_after: no goals
Theorem: CategoryTheory.Sieve.pullback_eq_top_iff_mem
File: Mathlib/CategoryTheory/Sites/Sieves.lean

tactic: rw [← id_mem_iff_eq_top, pullback_apply, id_comp]
state_before: C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
F : C ⥤ D
X Y Z : C
f✝ : Y ⟶ X
S R : Sieve X
f : Y ⟶ X
⊢ S.arrows f ↔ pullback f S = ⊤
state_after: no goals
Theorem: Polynomial.EisensteinCriterionAux.eval_zero_mem_ideal_of_eq_mul_X_pow
File: Mathlib/RingTheory/EisensteinCriterion.lean

tactic: rw [← coeff_zero_eq_eval_zero, ← eq_zero_iff_mem, ← coeff_map, hq,
  coeff_zero_eq_eval_zero, eval_mul, eval_pow, eval_X, zero_pow hn0, mul_zero]
state_before: R : Type u_1
inst✝ : CommRing R
n : ℕ
P : Ideal R
q : R[X]
c : (R ⧸ P)[X]
hq : map (mk P) q = c * X ^ n
hn0 : n ≠ 0
⊢ eval 0 q ∈ P
state_after: no goals
Theorem: List.modifyNth_eq_take_cons_drop
File: .lake/packages/batteries/Batteries/Data/List/Lemmas.lean

tactic: rw [modifyNth_eq_take_drop, drop_eq_getElem_cons h]
state_before: α : Type u_1
f : α → α
n : Nat
l : List α
h : n < l.length
⊢ modifyNth f n l = take n l ++ f l[n] :: drop (n + 1) l
state_after: α : Type u_1
f : α → α
n : Nat
l : List α
h : n < l.length
⊢ take n l ++ modifyHead f (l[n] :: drop (n + 1) l) = take n l ++ f l[n] :: drop (n + 1) l

tactic: rfl
state_before: α : Type u_1
f : α → α
n : Nat
l : List α
h : n < l.length
⊢ take n l ++ modifyHead f (l[n] :: drop (n + 1) l) = take n l ++ f l[n] :: drop (n + 1) l
state_after: no goals
Theorem: Matroid.comapOn_base_iff
File: Mathlib/Data/Matroid/Map.lean

tactic: rw [comapOn, base_restrict_iff', comap_basis'_iff]
state_before: α : Type u_1
β : Type u_2
f : α → β
E✝ I✝ s : Set α
M : Matroid α
N : Matroid β
E B I : Set α
⊢ (N.comapOn E f).Base B ↔ N.Basis' (f '' B) (f '' E) ∧ InjOn f B ∧ B ⊆ E
state_after: no goals
Theorem: Finset.prod_lt_prod_of_nonempty
File: Mathlib/Algebra/Order/BigOperators/Ring/Finset.lean

tactic: apply prod_lt_prod hf fun i hi => le_of_lt (hfg i hi)
state_before: ι : Type u_1
R : Type u_2
inst✝⁴ : CommMonoidWithZero R
inst✝³ : PartialOrder R
inst✝² : ZeroLEOneClass R
inst✝¹ : PosMulStrictMono R
inst✝ : Nontrivial R
f g : ι → R
s t : Finset ι
hf : ∀ i ∈ s, 0 < f i
hfg : ∀ i ∈ s, f i < g i
h_ne : s.Nonempty
⊢ ∏ i ∈ s, f i < ∏ i ∈ s, g i
state_after: ι : Type u_1
R : Type u_2
inst✝⁴ : CommMonoidWithZero R
inst✝³ : PartialOrder R
inst✝² : ZeroLEOneClass R
inst✝¹ : PosMulStrictMono R
inst✝ : Nontrivial R
f g : ι → R
s t : Finset ι
hf : ∀ i ∈ s, 0 < f i
hfg : ∀ i ∈ s, f i < g i
h_ne : s.Nonempty
⊢ ∃ i ∈ s, f i < g i

tactic: obtain ⟨i, hi⟩ := h_ne
state_before: ι : Type u_1
R : Type u_2
inst✝⁴ : CommMonoidWithZero R
inst✝³ : PartialOrder R
inst✝² : ZeroLEOneClass R
inst✝¹ : PosMulStrictMono R
inst✝ : Nontrivial R
f g : ι → R
s t : Finset ι
hf : ∀ i ∈ s, 0 < f i
hfg : ∀ i ∈ s, f i < g i
h_ne : s.Nonempty
⊢ ∃ i ∈ s, f i < g i
state_after: case intro
ι : Type u_1
R : Type u_2
inst✝⁴ : CommMonoidWithZero R
inst✝³ : PartialOrder R
inst✝² : ZeroLEOneClass R
inst✝¹ : PosMulStrictMono R
inst✝ : Nontrivial R
f g : ι → R
s t : Finset ι
hf : ∀ i ∈ s, 0 < f i
hfg : ∀ i ∈ s, f i < g i
i : ι
hi : i ∈ s
⊢ ∃ i ∈ s, f i < g i

tactic: exact ⟨i, hi, hfg i hi⟩
state_before: case intro
ι : Type u_1
R : Type u_2
inst✝⁴ : CommMonoidWithZero R
inst✝³ : PartialOrder R
inst✝² : ZeroLEOneClass R
inst✝¹ : PosMulStrictMono R
inst✝ : Nontrivial R
f g : ι → R
s t : Finset ι
hf : ∀ i ∈ s, 0 < f i
hfg : ∀ i ∈ s, f i < g i
i : ι
hi : i ∈ s
⊢ ∃ i ∈ s, f i < g i
state_after: no goals
Theorem: Complex.hasSum_taylorSeries_neg_log
File: Mathlib/Analysis/SpecialFunctions/Complex/LogBounds.lean

tactic: conv => enter [1, n]; rw [← neg_neg (z ^ n / n)]
state_before: z : ℂ
hz : ‖z‖ < 1
⊢ HasSum (fun n => z ^ n / ↑n) (-log (1 - z))
state_after: z : ℂ
hz : ‖z‖ < 1
⊢ HasSum (fun n => - -(z ^ n / ↑n)) (-log (1 - z))

tactic: refine HasSum.neg ?_
state_before: z : ℂ
hz : ‖z‖ < 1
⊢ HasSum (fun n => - -(z ^ n / ↑n)) (-log (1 - z))
state_after: z : ℂ
hz : ‖z‖ < 1
⊢ HasSum (fun n => -(z ^ n / ↑n)) (log (1 - z))

tactic: convert hasSum_taylorSeries_log (z := -z) (norm_neg z ▸ hz) using 2 with n
state_before: z : ℂ
hz : ‖z‖ < 1
⊢ HasSum (fun n => -(z ^ n / ↑n)) (log (1 - z))
state_after: case h.e'_5.h
z : ℂ
hz : ‖z‖ < 1
n : ℕ
⊢ -(z ^ n / ↑n) = (-1) ^ (n + 1) * (-z) ^ n / ↑n

tactic: rcases n.eq_zero_or_pos with rfl | hn
state_before: case h.e'_5.h
z : ℂ
hz : ‖z‖ < 1
n : ℕ
⊢ -(z ^ n / ↑n) = (-1) ^ (n + 1) * (-z) ^ n / ↑n
state_after: case h.e'_5.h.inl
z : ℂ
hz : ‖z‖ < 1
⊢ -(z ^ 0 / ↑0) = (-1) ^ (0 + 1) * (-z) ^ 0 / ↑0

case h.e'_5.h.inr
z : ℂ
hz : ‖z‖ < 1
n : ℕ
hn : n > 0
⊢ -(z ^ n / ↑n) = (-1) ^ (n + 1) * (-z) ^ n / ↑n

tactic: field_simp
state_before: case h.e'_5.h.inr
z : ℂ
hz : ‖z‖ < 1
n : ℕ
hn : n > 0
⊢ -(z ^ n / ↑n) = (-1) ^ (n + 1) * (-z) ^ n / ↑n
state_after: case h.e'_5.h.inr
z : ℂ
hz : ‖z‖ < 1
n : ℕ
hn : n > 0
⊢ -z ^ n / ↑n = (-1) ^ (n + 1) * (-z) ^ n / ↑n

tactic: rw [div_eq_div_iff, pow_succ', mul_assoc (-1), ← mul_pow, neg_mul_neg, neg_one_mul, one_mul]
state_before: case h.e'_5.h.inr
z : ℂ
hz : ‖z‖ < 1
n : ℕ
hn : n > 0
⊢ -z ^ n / ↑n = (-1) ^ (n + 1) * (-z) ^ n / ↑n
state_after: case h.e'_5.h.inr.hb
z : ℂ
hz : ‖z‖ < 1
n : ℕ
hn : n > 0
⊢ ↑n ≠ 0

case h.e'_5.h.inr.hd
z : ℂ
hz : ‖z‖ < 1
n : ℕ
hn : n > 0
⊢ ↑n ≠ 0

tactic: all_goals {norm_cast; exact hn.ne'}
state_before: case h.e'_5.h.inr.hb
z : ℂ
hz : ‖z‖ < 1
n : ℕ
hn : n > 0
⊢ ↑n ≠ 0

case h.e'_5.h.inr.hd
z : ℂ
hz : ‖z‖ < 1
n : ℕ
hn : n > 0
⊢ ↑n ≠ 0
state_after: no goals

tactic: simp
state_before: case h.e'_5.h.inl
z : ℂ
hz : ‖z‖ < 1
⊢ -(z ^ 0 / ↑0) = (-1) ^ (0 + 1) * (-z) ^ 0 / ↑0
state_after: no goals

tactic: norm_cast
state_before: case h.e'_5.h.inr.hd
z : ℂ
hz : ‖z‖ < 1
n : ℕ
hn : n > 0
⊢ ↑n ≠ 0
state_after: case h.e'_5.h.inr.hd
z : ℂ
hz : ‖z‖ < 1
n : ℕ
hn : n > 0
⊢ ¬n = 0

tactic: exact hn.ne'
state_before: case h.e'_5.h.inr.hd
z : ℂ
hz : ‖z‖ < 1
n : ℕ
hn : n > 0
⊢ ¬n = 0
state_after: no goals
Theorem: Equiv.Perm.cycleFactorsFinset_one
File: Mathlib/GroupTheory/Perm/Cycle/Factors.lean

tactic: simp [cycleFactorsFinset_eq_empty_iff]
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
inst✝¹ : DecidableEq α
inst✝ : Fintype α
f : Perm α
⊢ cycleFactorsFinset 1 = ∅
state_after: no goals
Theorem: ZMod.valMinAbs_zero
File: Mathlib/Data/ZMod/Basic.lean

tactic: simp only [valMinAbs_def_zero]
state_before: ⊢ valMinAbs 0 = 0
state_after: no goals

tactic: simp only [valMinAbs_def_pos, if_true, Int.ofNat_zero, zero_le, val_zero]
state_before: n : ℕ
⊢ valMinAbs 0 = 0
state_after: no goals
Theorem: AffineIsometry.edist_map
File: Mathlib/Analysis/NormedSpace/AffineIsometry.lean

tactic: simp [edist_dist]
state_before: 𝕜 : Type u_1
V : Type u_2
V₁ : Type u_3
V₁' : Type u_4
V₂ : Type u_5
V₃ : Type u_6
V₄ : Type u_7
P₁ : Type u_8
P₁' : Type u_9
P : Type u_10
P₂ : Type u_11
P₃ : Type u_12
P₄ : Type u_13
inst✝²⁴ : NormedField 𝕜
inst✝²³ : SeminormedAddCommGroup V
inst✝²² : NormedSpace 𝕜 V
inst✝²¹ : PseudoMetricSpace P
inst✝²⁰ : NormedAddTorsor V P
inst✝¹⁹ : SeminormedAddCommGroup V₁
inst✝¹⁸ : NormedSpace 𝕜 V₁
inst✝¹⁷ : PseudoMetricSpace P₁
inst✝¹⁶ : NormedAddTorsor V₁ P₁
inst✝¹⁵ : SeminormedAddCommGroup V₁'
inst✝¹⁴ : NormedSpace 𝕜 V₁'
inst✝¹³ : MetricSpace P₁'
inst✝¹² : NormedAddTorsor V₁' P₁'
inst✝¹¹ : SeminormedAddCommGroup V₂
inst✝¹⁰ : NormedSpace 𝕜 V₂
inst✝⁹ : PseudoMetricSpace P₂
inst✝⁸ : NormedAddTorsor V₂ P₂
inst✝⁷ : SeminormedAddCommGroup V₃
inst✝⁶ : NormedSpace 𝕜 V₃
inst✝⁵ : PseudoMetricSpace P₃
inst✝⁴ : NormedAddTorsor V₃ P₃
inst✝³ : SeminormedAddCommGroup V₄
inst✝² : NormedSpace 𝕜 V₄
inst✝¹ : PseudoMetricSpace P₄
inst✝ : NormedAddTorsor V₄ P₄
f : P →ᵃⁱ[𝕜] P₂
f₁ : P₁' →ᵃⁱ[𝕜] P₂
x y : P
⊢ edist (f x) (f y) = edist x y
state_after: no goals