1337xyz1337xyz/leandojo-benchmark4-v10 huggingface dataset:
Theorem: HurwitzKernelBounds.f_int_negSucc
File: Mathlib/NumberTheory/ModularForms/JacobiTheta/Bounds.lean

tactic: have : (Int.negSucc n) + a = -(n + (1 - a)) := by { push_cast; ring }
state_before: k : ℕ
a : ℝ
ha : a ≤ 1
t : ℝ
n : ℕ
⊢ f_int k a t (Int.negSucc n) = f_nat k (1 - a) t n
state_after: k : ℕ
a : ℝ
ha : a ≤ 1
t : ℝ
n : ℕ
this : ↑(Int.negSucc n) + a = -(↑n + (1 - a))
⊢ f_int k a t (Int.negSucc n) = f_nat k (1 - a) t n

tactic: rw [f_int, f_nat, this, abs_neg, neg_sq, abs_of_nonneg (by linarith)]
state_before: k : ℕ
a : ℝ
ha : a ≤ 1
t : ℝ
n : ℕ
this : ↑(Int.negSucc n) + a = -(↑n + (1 - a))
⊢ f_int k a t (Int.negSucc n) = f_nat k (1 - a) t n
state_after: no goals

tactic: push_cast
state_before: k : ℕ
a : ℝ
ha : a ≤ 1
t : ℝ
n : ℕ
⊢ ↑(Int.negSucc n) + a = -(↑n + (1 - a))
state_after: k : ℕ
a : ℝ
ha : a ≤ 1
t : ℝ
n : ℕ
⊢ -(↑n + 1) + a = -(↑n + (1 - a))

tactic: ring
state_before: k : ℕ
a : ℝ
ha : a ≤ 1
t : ℝ
n : ℕ
⊢ -(↑n + 1) + a = -(↑n + (1 - a))
state_after: no goals

tactic: linarith
state_before: k : ℕ
a : ℝ
ha : a ≤ 1
t : ℝ
n : ℕ
this : ↑(Int.negSucc n) + a = -(↑n + (1 - a))
⊢ 0 ≤ ↑n + (1 - a)
state_after: no goals
Theorem: LieAlgebra.Orthogonal.soIndefiniteEquiv_apply
File: Mathlib/Algebra/Lie/Classical.lean

tactic: rw [soIndefiniteEquiv, LieEquiv.trans_apply, LieEquiv.ofEq_apply]
state_before: n : Type u_1
p : Type u_2
q : Type u_3
l : Type u_4
R : Type u₂
inst✝⁶ : DecidableEq n
inst✝⁵ : DecidableEq p
inst✝⁴ : DecidableEq q
inst✝³ : DecidableEq l
inst✝² : CommRing R
inst✝¹ : Fintype p
inst✝ : Fintype q
i : R
hi : i * i = -1
A : ↥(so' p q R)
⊢ ↑((soIndefiniteEquiv p q R hi) A) = (Pso p q R i)⁻¹ * ↑A * Pso p q R i
state_after: n : Type u_1
p : Type u_2
q : Type u_3
l : Type u_4
R : Type u₂
inst✝⁶ : DecidableEq n
inst✝⁵ : DecidableEq p
inst✝⁴ : DecidableEq q
inst✝³ : DecidableEq l
inst✝² : CommRing R
inst✝¹ : Fintype p
inst✝ : Fintype q
i : R
hi : i * i = -1
A : ↥(so' p q R)
⊢ ↑((skewAdjointMatricesLieSubalgebraEquiv (indefiniteDiagonal p q R) (Pso p q R i) (invertiblePso p q R hi)) A) =
    (Pso p q R i)⁻¹ * ↑A * Pso p q R i

tactic: erw [skewAdjointMatricesLieSubalgebraEquiv_apply]
state_before: n : Type u_1
p : Type u_2
q : Type u_3
l : Type u_4
R : Type u₂
inst✝⁶ : DecidableEq n
inst✝⁵ : DecidableEq p
inst✝⁴ : DecidableEq q
inst✝³ : DecidableEq l
inst✝² : CommRing R
inst✝¹ : Fintype p
inst✝ : Fintype q
i : R
hi : i * i = -1
A : ↥(so' p q R)
⊢ ↑((skewAdjointMatricesLieSubalgebraEquiv (indefiniteDiagonal p q R) (Pso p q R i) (invertiblePso p q R hi)) A) =
    (Pso p q R i)⁻¹ * ↑A * Pso p q R i
state_after: no goals
Theorem: Int.cast_injOn_of_ringChar_ne_two
File: Mathlib/Algebra/CharP/Defs.lean

tactic: rintro _ (rfl | rfl | rfl) _ (rfl | rfl | rfl) h <;>
simp only
  [cast_neg, cast_one, cast_zero, neg_eq_zero, one_ne_zero, zero_ne_one, zero_eq_neg] at h ⊢
state_before: R✝ : Type u_1
R : Type u_2
inst✝¹ : NonAssocRing R
inst✝ : Nontrivial R
hR : ringChar R ≠ 2
⊢ Set.InjOn Int.cast {0, 1, -1}
state_after: case inr.inl.inr.inr
R✝ : Type u_1
R : Type u_2
inst✝¹ : NonAssocRing R
inst✝ : Nontrivial R
hR : ringChar R ≠ 2
h : 1 = -1
⊢ False

case inr.inr.inr.inl
R✝ : Type u_1
R : Type u_2
inst✝¹ : NonAssocRing R
inst✝ : Nontrivial R
hR : ringChar R ≠ 2
h : -1 = 1
⊢ False

tactic: exact ((Ring.neg_one_ne_one_of_char_ne_two hR).symm h).elim
state_before: case inr.inl.inr.inr
R✝ : Type u_1
R : Type u_2
inst✝¹ : NonAssocRing R
inst✝ : Nontrivial R
hR : ringChar R ≠ 2
h : 1 = -1
⊢ False
state_after: no goals

tactic: exact ((Ring.neg_one_ne_one_of_char_ne_two hR) h).elim
state_before: case inr.inr.inr.inl
R✝ : Type u_1
R : Type u_2
inst✝¹ : NonAssocRing R
inst✝ : Nontrivial R
hR : ringChar R ≠ 2
h : -1 = 1
⊢ False
state_after: no goals
Theorem: Units.eq_inv_mul_iff_mul_eq
File: Mathlib/Algebra/Group/Units.lean

tactic: rw [h, mul_inv_cancel_left]
state_before: α : Type u
inst✝ : Monoid α
a✝ b c✝ u : αˣ
a c : α
h : a = ↑b⁻¹ * c
⊢ ↑b * a = c
state_after: no goals

tactic: rw [← h, inv_mul_cancel_left]
state_before: α : Type u
inst✝ : Monoid α
a✝ b c✝ u : αˣ
a c : α
h : ↑b * a = c
⊢ a = ↑b⁻¹ * c
state_after: no goals
Theorem: log_le_harmonic_floor
File: Mathlib/NumberTheory/Harmonic/Bounds.lean

tactic: by_cases h0 : y = 0
state_before: y : ℝ
hy : 0 ≤ y
⊢ Real.log y ≤ ↑(harmonic ⌊y⌋₊)
state_after: case pos
y : ℝ
hy : 0 ≤ y
h0 : y = 0
⊢ Real.log y ≤ ↑(harmonic ⌊y⌋₊)

case neg
y : ℝ
hy : 0 ≤ y
h0 : ¬y = 0
⊢ Real.log y ≤ ↑(harmonic ⌊y⌋₊)

tactic: simp [h0]
state_before: case pos
y : ℝ
hy : 0 ≤ y
h0 : y = 0
⊢ Real.log y ≤ ↑(harmonic ⌊y⌋₊)
state_after: no goals

tactic: calc
  _ ≤ Real.log ↑(Nat.floor y + 1) := ?_
  _ ≤ _ := log_add_one_le_harmonic _
state_before: case neg
y : ℝ
hy : 0 ≤ y
h0 : ¬y = 0
⊢ Real.log y ≤ ↑(harmonic ⌊y⌋₊)
state_after: case neg
y : ℝ
hy : 0 ≤ y
h0 : ¬y = 0
⊢ Real.log y ≤ Real.log ↑(⌊y⌋₊ + 1)

tactic: gcongr
state_before: case neg
y : ℝ
hy : 0 ≤ y
h0 : ¬y = 0
⊢ Real.log y ≤ Real.log ↑(⌊y⌋₊ + 1)
state_after: case neg.hxy
y : ℝ
hy : 0 ≤ y
h0 : ¬y = 0
⊢ y ≤ ↑(⌊y⌋₊ + 1)

tactic: apply (Nat.le_ceil y).trans
state_before: case neg.hxy
y : ℝ
hy : 0 ≤ y
h0 : ¬y = 0
⊢ y ≤ ↑(⌊y⌋₊ + 1)
state_after: case neg.hxy
y : ℝ
hy : 0 ≤ y
h0 : ¬y = 0
⊢ ↑⌈y⌉₊ ≤ ↑(⌊y⌋₊ + 1)

tactic: norm_cast
state_before: case neg.hxy
y : ℝ
hy : 0 ≤ y
h0 : ¬y = 0
⊢ ↑⌈y⌉₊ ≤ ↑(⌊y⌋₊ + 1)
state_after: case neg.hxy
y : ℝ
hy : 0 ≤ y
h0 : ¬y = 0
⊢ ⌈y⌉₊ ≤ ⌊y⌋₊ + 1

tactic: exact Nat.ceil_le_floor_add_one y
state_before: case neg.hxy
y : ℝ
hy : 0 ≤ y
h0 : ¬y = 0
⊢ ⌈y⌉₊ ≤ ⌊y⌋₊ + 1
state_after: no goals
Theorem: ContinuousLinearMap.isBoundedBilinearMap
File: Mathlib/Analysis/NormedSpace/BoundedLinearMaps.lean

tactic: apply_rules [mul_le_mul_of_nonneg_right, norm_nonneg, le_max_left]
state_before: 𝕜 : Type u_1
inst✝⁶ : NontriviallyNormedField 𝕜
E : Type u_2
inst✝⁵ : NormedAddCommGroup E
inst✝⁴ : NormedSpace 𝕜 E
F : Type u_3
inst✝³ : NormedAddCommGroup F
inst✝² : NormedSpace 𝕜 F
G : Type u_4
inst✝¹ : NormedAddCommGroup G
inst✝ : NormedSpace 𝕜 G
f✝ : E × F → G
f : E →L[𝕜] F →L[𝕜] G
x : E
y : F
⊢ ‖f‖ * ‖x‖ * ‖y‖ ≤ max ‖f‖ 1 * ‖x‖ * ‖y‖
state_after: no goals
Theorem: Ordinal.add_le_nadd
File: Mathlib/SetTheory/Ordinal/NaturalOps.lean

tactic: induction b using limitRecOn with
| H₁ => simp
| H₂ c h =>
  rwa [add_succ, nadd_succ, succ_le_succ_iff]
| H₃ c hc H =>
  simp_rw [← IsNormal.blsub_eq.{u, u} (add_isNormal a) hc, blsub_le_iff]
  exact fun i hi => (H i hi).trans_lt (nadd_lt_nadd_left hi a)
state_before: a b c : Ordinal.{u}
⊢ a + b ≤ a ♯ b
state_after: no goals

tactic: simp
state_before: case H₁
a b c : Ordinal.{u}
⊢ a + 0 ≤ a ♯ 0
state_after: no goals

tactic: rwa [add_succ, nadd_succ, succ_le_succ_iff]
state_before: case H₂
a b c✝ c : Ordinal.{u}
h : a + c ≤ a ♯ c
⊢ a + succ c ≤ a ♯ succ c
state_after: no goals

tactic: simp_rw [← IsNormal.blsub_eq.{u, u} (add_isNormal a) hc, blsub_le_iff]
state_before: case H₃
a b c✝ c : Ordinal.{u}
hc : c.IsLimit
H : ∀ o' < c, a + o' ≤ a ♯ o'
⊢ a + c ≤ a ♯ c
state_after: case H₃
a b c✝ c : Ordinal.{u}
hc : c.IsLimit
H : ∀ o' < c, a + o' ≤ a ♯ o'
⊢ ∀ i < c, a + i < a ♯ c

tactic: exact fun i hi => (H i hi).trans_lt (nadd_lt_nadd_left hi a)
state_before: case H₃
a b c✝ c : Ordinal.{u}
hc : c.IsLimit
H : ∀ o' < c, a + o' ≤ a ♯ o'
⊢ ∀ i < c, a + i < a ♯ c
state_after: no goals
Theorem: MvPolynomial.rename_eval₂
File: Mathlib/Algebra/MvPolynomial/Rename.lean

tactic: intros
state_before: case h_X
σ : Type u_1
τ : Type u_2
α : Type u_3
R : Type u_4
S : Type u_5
inst✝¹ : CommSemiring R
inst✝ : CommSemiring S
f : R →+* S
k : σ → τ
g✝ : τ → S
p : MvPolynomial σ R
g : τ → MvPolynomial σ R
⊢ ∀ (p : MvPolynomial σ R) (n : σ),
    (rename k) (eval₂ C (g ∘ k) p) = eval₂ C (⇑(rename k) ∘ g) ((rename k) p) →
      (rename k) (eval₂ C (g ∘ k) (p * X n)) = eval₂ C (⇑(rename k) ∘ g) ((rename k) (p * X n))
state_after: case h_X
σ : Type u_1
τ : Type u_2
α : Type u_3
R : Type u_4
S : Type u_5
inst✝¹ : CommSemiring R
inst✝ : CommSemiring S
f : R →+* S
k : σ → τ
g✝ : τ → S
p : MvPolynomial σ R
g : τ → MvPolynomial σ R
p✝ : MvPolynomial σ R
n✝ : σ
a✝ : (rename k) (eval₂ C (g ∘ k) p✝) = eval₂ C (⇑(rename k) ∘ g) ((rename k) p✝)
⊢ (rename k) (eval₂ C (g ∘ k) (p✝ * X n✝)) = eval₂ C (⇑(rename k) ∘ g) ((rename k) (p✝ * X n✝))

tactic: simp [*]
state_before: case h_X
σ : Type u_1
τ : Type u_2
α : Type u_3
R : Type u_4
S : Type u_5
inst✝¹ : CommSemiring R
inst✝ : CommSemiring S
f : R →+* S
k : σ → τ
g✝ : τ → S
p : MvPolynomial σ R
g : τ → MvPolynomial σ R
p✝ : MvPolynomial σ R
n✝ : σ
a✝ : (rename k) (eval₂ C (g ∘ k) p✝) = eval₂ C (⇑(rename k) ∘ g) ((rename k) p✝)
⊢ (rename k) (eval₂ C (g ∘ k) (p✝ * X n✝)) = eval₂ C (⇑(rename k) ∘ g) ((rename k) (p✝ * X n✝))
state_after: no goals
Theorem: CategoryTheory.GradedObject.ι_mapBifunctorMapMap
File: Mathlib/CategoryTheory/GradedObject/Bifunctor.lean

tactic: simp [ιMapBifunctorMapObj, mapBifunctorMapMap]
state_before: C₁ : Type u_1
C₂ : Type u_2
C₃ : Type u_3
inst✝⁴ : Category.{u_7, u_1} C₁
inst✝³ : Category.{u_8, u_2} C₂
inst✝² : Category.{u_9, u_3} C₃
F : C₁ ⥤ C₂ ⥤ C₃
I : Type u_4
J : Type u_5
K : Type u_6
p : I × J → K
X₁ X₂ : GradedObject I C₁
f : X₁ ⟶ X₂
Y₁ Y₂ : GradedObject J C₂
g : Y₁ ⟶ Y₂
inst✝¹ : (((mapBifunctor F I J).obj X₁).obj Y₁).HasMap p
inst✝ : (((mapBifunctor F I J).obj X₂).obj Y₂).HasMap p
i : I
j : J
k : K
h : p (i, j) = k
⊢ ιMapBifunctorMapObj F p X₁ Y₁ i j k h ≫ mapBifunctorMapMap F p f g k =
    (F.map (f i)).app (Y₁ j) ≫ (F.obj (X₂ i)).map (g j) ≫ ιMapBifunctorMapObj F p X₂ Y₂ i j k h
state_after: no goals
Theorem: SetTheory.PGame.birthday_add_nat
File: Mathlib/SetTheory/Game/Birthday.lean

tactic: simp
state_before: a b x : PGame
n : ℕ
⊢ (a + ↑n).birthday = a.birthday + ↑n
state_after: no goals
Theorem: Asymptotics.isLittleO_norm_left
File: Mathlib/Analysis/Asymptotics/Asymptotics.lean

tactic: simp only [IsLittleO_def]
state_before: α : Type u_1
β : Type u_2
E : Type u_3
F : Type u_4
G : Type u_5
E' : Type u_6
F' : Type u_7
G' : Type u_8
E'' : Type u_9
F'' : Type u_10
G'' : Type u_11
E''' : Type u_12
R : Type u_13
R' : Type u_14
𝕜 : Type u_15
𝕜' : Type u_16
inst✝¹³ : Norm E
inst✝¹² : Norm F
inst✝¹¹ : Norm G
inst✝¹⁰ : SeminormedAddCommGroup E'
inst✝⁹ : SeminormedAddCommGroup F'
inst✝⁸ : SeminormedAddCommGroup G'
inst✝⁷ : NormedAddCommGroup E''
inst✝⁶ : NormedAddCommGroup F''
inst✝⁵ : NormedAddCommGroup G''
inst✝⁴ : SeminormedRing R
inst✝³ : SeminormedAddGroup E'''
inst✝² : SeminormedRing R'
inst✝¹ : NormedDivisionRing 𝕜
inst✝ : NormedDivisionRing 𝕜'
c c' c₁ c₂ : ℝ
f : α → E
g : α → F
k : α → G
f' : α → E'
g' : α → F'
k' : α → G'
f'' : α → E''
g'' : α → F''
k'' : α → G''
l l' : Filter α
u v : α → ℝ
⊢ (fun x => ‖f' x‖) =o[l] g ↔ f' =o[l] g
state_after: α : Type u_1
β : Type u_2
E : Type u_3
F : Type u_4
G : Type u_5
E' : Type u_6
F' : Type u_7
G' : Type u_8
E'' : Type u_9
F'' : Type u_10
G'' : Type u_11
E''' : Type u_12
R : Type u_13
R' : Type u_14
𝕜 : Type u_15
𝕜' : Type u_16
inst✝¹³ : Norm E
inst✝¹² : Norm F
inst✝¹¹ : Norm G
inst✝¹⁰ : SeminormedAddCommGroup E'
inst✝⁹ : SeminormedAddCommGroup F'
inst✝⁸ : SeminormedAddCommGroup G'
inst✝⁷ : NormedAddCommGroup E''
inst✝⁶ : NormedAddCommGroup F''
inst✝⁵ : NormedAddCommGroup G''
inst✝⁴ : SeminormedRing R
inst✝³ : SeminormedAddGroup E'''
inst✝² : SeminormedRing R'
inst✝¹ : NormedDivisionRing 𝕜
inst✝ : NormedDivisionRing 𝕜'
c c' c₁ c₂ : ℝ
f : α → E
g : α → F
k : α → G
f' : α → E'
g' : α → F'
k' : α → G'
f'' : α → E''
g'' : α → F''
k'' : α → G''
l l' : Filter α
u v : α → ℝ
⊢ (∀ ⦃c : ℝ⦄, 0 < c → IsBigOWith c l (fun x => ‖f' x‖) g) ↔ ∀ ⦃c : ℝ⦄, 0 < c → IsBigOWith c l f' g

tactic: exact forall₂_congr fun _ _ => isBigOWith_norm_left
state_before: α : Type u_1
β : Type u_2
E : Type u_3
F : Type u_4
G : Type u_5
E' : Type u_6
F' : Type u_7
G' : Type u_8
E'' : Type u_9
F'' : Type u_10
G'' : Type u_11
E''' : Type u_12
R : Type u_13
R' : Type u_14
𝕜 : Type u_15
𝕜' : Type u_16
inst✝¹³ : Norm E
inst✝¹² : Norm F
inst✝¹¹ : Norm G
inst✝¹⁰ : SeminormedAddCommGroup E'
inst✝⁹ : SeminormedAddCommGroup F'
inst✝⁸ : SeminormedAddCommGroup G'
inst✝⁷ : NormedAddCommGroup E''
inst✝⁶ : NormedAddCommGroup F''
inst✝⁵ : NormedAddCommGroup G''
inst✝⁴ : SeminormedRing R
inst✝³ : SeminormedAddGroup E'''
inst✝² : SeminormedRing R'
inst✝¹ : NormedDivisionRing 𝕜
inst✝ : NormedDivisionRing 𝕜'
c c' c₁ c₂ : ℝ
f : α → E
g : α → F
k : α → G
f' : α → E'
g' : α → F'
k' : α → G'
f'' : α → E''
g'' : α → F''
k'' : α → G''
l l' : Filter α
u v : α → ℝ
⊢ (∀ ⦃c : ℝ⦄, 0 < c → IsBigOWith c l (fun x => ‖f' x‖) g) ↔ ∀ ⦃c : ℝ⦄, 0 < c → IsBigOWith c l f' g
state_after: no goals
Theorem: IsUpperSet.cthickening'
File: Mathlib/Analysis/Normed/Order/UpperLower.lean

tactic: rw [cthickening_eq_iInter_thickening'']
state_before: α : Type u_1
ι : Type u_2
inst✝ : NormedOrderedGroup α
s : Set α
hs : IsUpperSet s
ε : ℝ
⊢ IsUpperSet (cthickening ε s)
state_after: α : Type u_1
ι : Type u_2
inst✝ : NormedOrderedGroup α
s : Set α
hs : IsUpperSet s
ε : ℝ
⊢ IsUpperSet (⋂ ε_1, ⋂ (_ : max 0 ε < ε_1), thickening ε_1 s)

tactic: exact isUpperSet_iInter₂ fun δ _ => hs.thickening' _
state_before: α : Type u_1
ι : Type u_2
inst✝ : NormedOrderedGroup α
s : Set α
hs : IsUpperSet s
ε : ℝ
⊢ IsUpperSet (⋂ ε_1, ⋂ (_ : max 0 ε < ε_1), thickening ε_1 s)
state_after: no goals
Theorem: pi_Ico_mem_nhds
File: Mathlib/Topology/Order/Basic.lean

tactic: refine mem_of_superset (set_pi_mem_nhds Set.finite_univ fun i _ => ?_) (pi_univ_Ico_subset a b)
state_before: α : Type u
β : Type v
γ : Type w
inst✝⁷ : TopologicalSpace α
inst✝⁶ : LinearOrder α
inst✝⁵ : OrderTopology α
ι : Type u_1
π : ι → Type u_2
inst✝⁴ : Finite ι
inst✝³ : (i : ι) → LinearOrder (π i)
inst✝² : (i : ι) → TopologicalSpace (π i)
inst✝¹ : ∀ (i : ι), OrderTopology (π i)
a b x : (i : ι) → π i
a' b' x' : ι → α
inst✝ : Nonempty ι
ha : ∀ (i : ι), a i < x i
hb : ∀ (i : ι), x i < b i
⊢ Ico a b ∈ 𝓝 x
state_after: α : Type u
β : Type v
γ : Type w
inst✝⁷ : TopologicalSpace α
inst✝⁶ : LinearOrder α
inst✝⁵ : OrderTopology α
ι : Type u_1
π : ι → Type u_2
inst✝⁴ : Finite ι
inst✝³ : (i : ι) → LinearOrder (π i)
inst✝² : (i : ι) → TopologicalSpace (π i)
inst✝¹ : ∀ (i : ι), OrderTopology (π i)
a b x : (i : ι) → π i
a' b' x' : ι → α
inst✝ : Nonempty ι
ha : ∀ (i : ι), a i < x i
hb : ∀ (i : ι), x i < b i
i : ι
x✝ : i ∈ univ
⊢ Ico (a i) (b i) ∈ 𝓝 (x i)

tactic: exact Ico_mem_nhds (ha i) (hb i)
state_before: α : Type u
β : Type v
γ : Type w
inst✝⁷ : TopologicalSpace α
inst✝⁶ : LinearOrder α
inst✝⁵ : OrderTopology α
ι : Type u_1
π : ι → Type u_2
inst✝⁴ : Finite ι
inst✝³ : (i : ι) → LinearOrder (π i)
inst✝² : (i : ι) → TopologicalSpace (π i)
inst✝¹ : ∀ (i : ι), OrderTopology (π i)
a b x : (i : ι) → π i
a' b' x' : ι → α
inst✝ : Nonempty ι
ha : ∀ (i : ι), a i < x i
hb : ∀ (i : ι), x i < b i
i : ι
x✝ : i ∈ univ
⊢ Ico (a i) (b i) ∈ 𝓝 (x i)
state_after: no goals
Theorem: Equiv.Perm.isConj_swap
File: Mathlib/GroupTheory/Perm/Sign.lean

tactic: rw [mul_inv_rev, swap_inv, swap_inv, mul_assoc (swap w y), mul_assoc (swap w y), ←
  mul_assoc _ (swap x z), swap_mul_swap_mul_swap hwx hwz, ← mul_assoc,
  swap_mul_swap_mul_swap hwz.symm hyz.symm]
state_before: α : Type u
inst✝ : DecidableEq α
β : Type v
w x y✝ z✝ : α
hwx : w ≠ x
hyz✝ : y✝ ≠ z✝
y z : α
hyz : y ≠ z
hwz : w ≠ z
⊢ swap w y * swap x z * swap w x * (swap w y * swap x z)⁻¹ = swap y z
state_after: no goals

tactic: rw [hwz]
state_before: α : Type u
inst✝ : DecidableEq α
β : Type v
w x y z : α
hwx : w ≠ x
hyz : y ≠ z
h : ∀ {y z : α}, y ≠ z → w ≠ z → swap w y * swap x z * swap w x * (swap w y * swap x z)⁻¹ = swap y z
hwz : w = z
⊢ w ≠ y
state_after: α : Type u
inst✝ : DecidableEq α
β : Type v
w x y z : α
hwx : w ≠ x
hyz : y ≠ z
h : ∀ {y z : α}, y ≠ z → w ≠ z → swap w y * swap x z * swap w x * (swap w y * swap x z)⁻¹ = swap y z
hwz : w = z
⊢ z ≠ y

tactic: exact hyz.symm
state_before: α : Type u
inst✝ : DecidableEq α
β : Type v
w x y z : α
hwx : w ≠ x
hyz : y ≠ z
h : ∀ {y z : α}, y ≠ z → w ≠ z → swap w y * swap x z * swap w x * (swap w y * swap x z)⁻¹ = swap y z
hwz : w = z
⊢ z ≠ y
state_after: no goals

tactic: rw [swap_comm y z, h hyz.symm hwy]
state_before: α : Type u
inst✝ : DecidableEq α
β : Type v
w x y z : α
hwx : w ≠ x
hyz : y ≠ z
h : ∀ {y z : α}, y ≠ z → w ≠ z → swap w y * swap x z * swap w x * (swap w y * swap x z)⁻¹ = swap y z
hwz : w = z
hwy : w ≠ y
⊢ swap w z * swap x y * swap w x * (swap w z * swap x y)⁻¹ = swap y z
state_after: no goals
Theorem: Finset.sup'_univ_eq_ciSup
File: Mathlib/Order/ConditionallyCompleteLattice/Finset.lean

tactic: simp [sup'_eq_csSup_image, iSup]
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
inst✝² : ConditionallyCompleteLattice α
inst✝¹ : Fintype ι
inst✝ : Nonempty ι
f : ι → α
⊢ univ.sup' ⋯ f = ⨆ i, f i
state_after: no goals
Theorem: Finset.sum_antidiagonal_choose_succ_mul
File: Mathlib/Data/Nat/Choose/Sum.lean

tactic: simpa only [nsmul_eq_mul] using sum_antidiagonal_choose_succ_nsmul f n
state_before: R✝ : Type u_1
M : Type u_2
R : Type u_3
inst✝¹ : CommMonoid M
inst✝ : NonAssocSemiring R
f : ℕ → ℕ → R
n : ℕ
⊢ ∑ ij ∈ antidiagonal (n + 1), ↑((n + 1).choose ij.1) * f ij.1 ij.2 =
    ∑ ij ∈ antidiagonal n, ↑(n.choose ij.1) * f ij.1 (ij.2 + 1) +
      ∑ ij ∈ antidiagonal n, ↑(n.choose ij.2) * f (ij.1 + 1) ij.2
state_after: no goals
Theorem: NNRat.mul_den_eq_num
File: Mathlib/Data/NNRat/Defs.lean

tactic: ext
state_before: p q✝ : ℚ≥0
n₁ n₂ d₁ d₂ d : ℕ
q : ℚ≥0
⊢ q * ↑q.den = ↑q.num
state_after: case a
p q✝ : ℚ≥0
n₁ n₂ d₁ d₂ d : ℕ
q : ℚ≥0
⊢ ↑(q * ↑q.den) = ↑↑q.num

tactic: push_cast
state_before: case a
p q✝ : ℚ≥0
n₁ n₂ d₁ d₂ d : ℕ
q : ℚ≥0
⊢ ↑(q * ↑q.den) = ↑↑q.num
state_after: case a
p q✝ : ℚ≥0
n₁ n₂ d₁ d₂ d : ℕ
q : ℚ≥0
⊢ ↑q * ↑q.den = ↑q.num

tactic: rw [← Int.cast_natCast, ← den_coe, ← Int.cast_natCast q.num, ← num_coe]
state_before: case a
p q✝ : ℚ≥0
n₁ n₂ d₁ d₂ d : ℕ
q : ℚ≥0
⊢ ↑q * ↑q.den = ↑q.num
state_after: case a
p q✝ : ℚ≥0
n₁ n₂ d₁ d₂ d : ℕ
q : ℚ≥0
⊢ ↑q * ↑↑(↑q).den = ↑(↑q).num

tactic: exact Rat.mul_den_eq_num _
state_before: case a
p q✝ : ℚ≥0
n₁ n₂ d₁ d₂ d : ℕ
q : ℚ≥0
⊢ ↑q * ↑↑(↑q).den = ↑(↑q).num
state_after: no goals
Theorem: Int.neg_modEq_neg
File: Mathlib/Data/Int/ModEq.lean

tactic: simp [-sub_neg_eq_add, neg_sub_neg, modEq_iff_dvd, dvd_sub_comm]
state_before: m n a b c d : ℤ
⊢ -a ≡ -b [ZMOD n] ↔ a ≡ b [ZMOD n]
state_after: no goals
Theorem: holderOnWith_univ
File: Mathlib/Topology/MetricSpace/Holder.lean

tactic: simp only [HolderOnWith, HolderWith, mem_univ, true_imp_iff]
state_before: X : Type u_1
Y : Type u_2
Z : Type u_3
inst✝² : PseudoEMetricSpace X
inst✝¹ : PseudoEMetricSpace Y
inst✝ : PseudoEMetricSpace Z
C r : ℝ≥0
f : X → Y
⊢ HolderOnWith C r f univ ↔ HolderWith C r f
state_after: no goals
Theorem: Batteries.BinomialHeap.Imp.HeapNode.rankTR_eq
File: .lake/packages/batteries/Batteries/Data/BinomialHeap/Basic.lean

tactic: funext α s
state_before: ⊢ @Batteries.BinomialHeap.Imp.HeapNode.rankTR = @rank
state_after: case h.h
α : Type u_1
s : HeapNode α
⊢ Batteries.BinomialHeap.Imp.HeapNode.rankTR s = s.rank

tactic: exact go s 0
state_before: case h.h
α : Type u_1
s : HeapNode α
⊢ Batteries.BinomialHeap.Imp.HeapNode.rankTR s = s.rank
state_after: no goals

tactic: simp_arith only [rankTR.go, go, rank]
state_before: α : Type ?u.2530
a✝ : α
child✝ sibling✝ : HeapNode α
x✝ : Nat
⊢ Batteries.BinomialHeap.Imp.HeapNode.rankTR.go (node a✝ child✝ sibling✝) x✝ = (node a✝ child✝ sibling✝).rank + x✝
state_after: no goals
Theorem: Nat.Prime.factors_pow
File: Mathlib/Data/Nat/Factors.lean

tactic: symm
state_before: p : ℕ
hp : Prime p
n : ℕ
⊢ (p ^ n).factors = replicate n p
state_after: p : ℕ
hp : Prime p
n : ℕ
⊢ replicate n p = (p ^ n).factors

tactic: rw [← List.replicate_perm]
state_before: p : ℕ
hp : Prime p
n : ℕ
⊢ replicate n p = (p ^ n).factors
state_after: p : ℕ
hp : Prime p
n : ℕ
⊢ replicate n p ~ (p ^ n).factors

tactic: apply Nat.factors_unique (List.prod_replicate n p)
state_before: p : ℕ
hp : Prime p
n : ℕ
⊢ replicate n p ~ (p ^ n).factors
state_after: p : ℕ
hp : Prime p
n : ℕ
⊢ ∀ p_1 ∈ replicate n p, Prime p_1

tactic: intro q hq
state_before: p : ℕ
hp : Prime p
n : ℕ
⊢ ∀ p_1 ∈ replicate n p, Prime p_1
state_after: p : ℕ
hp : Prime p
n q : ℕ
hq : q ∈ replicate n p
⊢ Prime q

tactic: rwa [eq_of_mem_replicate hq]
state_before: p : ℕ
hp : Prime p
n q : ℕ
hq : q ∈ replicate n p
⊢ Prime q
state_after: no goals
Theorem: List.mem_permutations_of_perm_lemma
File: Mathlib/Data/List/Perm.lean

tactic: simpa [permutations, perm_nil] using H
state_before: α : Type u_1
β : Type u_2
l✝ l₁ l₂ : List α
a : α
is l : List α
H : l ~ [] ++ is → (∃ ts', ∃ (_ : ts' ~ []), l = ts' ++ is) ∨ l ∈ is.permutationsAux []
⊢ l ~ is → l ∈ is.permutations
state_after: no goals
Theorem: IsPrimitiveRoot.card_quotient_toInteger_sub_one
File: Mathlib/NumberTheory/Cyclotomic/Rat.lean

tactic: have := hζ.finite_quotient_toInteger_sub_one hk
state_before: p : ℕ+
k✝ : ℕ
K : Type u
inst✝² : Field K
inst✝¹ : CharZero K
ζ : K
hp : Fact (Nat.Prime ↑p)
inst✝ : NumberField K
k : ℕ+
hk : 1 < k
hζ : IsPrimitiveRoot ζ ↑k
⊢ Nat.card (𝓞 K ⧸ Ideal.span {hζ.toInteger - 1}) = ((Algebra.norm ℤ) (hζ.toInteger - 1)).natAbs
state_after: p : ℕ+
k✝ : ℕ
K : Type u
inst✝² : Field K
inst✝¹ : CharZero K
ζ : K
hp : Fact (Nat.Prime ↑p)
inst✝ : NumberField K
k : ℕ+
hk : 1 < k
hζ : IsPrimitiveRoot ζ ↑k
this : Finite (𝓞 K ⧸ Ideal.span {hζ.toInteger - 1})
⊢ Nat.card (𝓞 K ⧸ Ideal.span {hζ.toInteger - 1}) = ((Algebra.norm ℤ) (hζ.toInteger - 1)).natAbs

tactic: let _ := Fintype.ofFinite (𝓞 K ⧸ Ideal.span {hζ.toInteger - 1})
state_before: p : ℕ+
k✝ : ℕ
K : Type u
inst✝² : Field K
inst✝¹ : CharZero K
ζ : K
hp : Fact (Nat.Prime ↑p)
inst✝ : NumberField K
k : ℕ+
hk : 1 < k
hζ : IsPrimitiveRoot ζ ↑k
this : Finite (𝓞 K ⧸ Ideal.span {hζ.toInteger - 1})
⊢ Nat.card (𝓞 K ⧸ Ideal.span {hζ.toInteger - 1}) = ((Algebra.norm ℤ) (hζ.toInteger - 1)).natAbs
state_after: p : ℕ+
k✝ : ℕ
K : Type u
inst✝² : Field K
inst✝¹ : CharZero K
ζ : K
hp : Fact (Nat.Prime ↑p)
inst✝ : NumberField K
k : ℕ+
hk : 1 < k
hζ : IsPrimitiveRoot ζ ↑k
this : Finite (𝓞 K ⧸ Ideal.span {hζ.toInteger - 1})
x✝ : Fintype (𝓞 K ⧸ Ideal.span {hζ.toInteger - 1}) := Fintype.ofFinite (𝓞 K ⧸ Ideal.span {hζ.toInteger - 1})
⊢ Nat.card (𝓞 K ⧸ Ideal.span {hζ.toInteger - 1}) = ((Algebra.norm ℤ) (hζ.toInteger - 1)).natAbs

tactic: rw [Nat.card_eq_fintype_card, ← Submodule.cardQuot_apply, ← Ideal.absNorm_apply,
  Ideal.absNorm_span_singleton]
state_before: p : ℕ+
k✝ : ℕ
K : Type u
inst✝² : Field K
inst✝¹ : CharZero K
ζ : K
hp : Fact (Nat.Prime ↑p)
inst✝ : NumberField K
k : ℕ+
hk : 1 < k
hζ : IsPrimitiveRoot ζ ↑k
this : Finite (𝓞 K ⧸ Ideal.span {hζ.toInteger - 1})
x✝ : Fintype (𝓞 K ⧸ Ideal.span {hζ.toInteger - 1}) := Fintype.ofFinite (𝓞 K ⧸ Ideal.span {hζ.toInteger - 1})
⊢ Nat.card (𝓞 K ⧸ Ideal.span {hζ.toInteger - 1}) = ((Algebra.norm ℤ) (hζ.toInteger - 1)).natAbs
state_after: no goals
Theorem: catalan_succ'
File: Mathlib/Combinatorics/Enumerative/Catalan.lean

tactic: rw [catalan_succ, Nat.sum_antidiagonal_eq_sum_range_succ (fun x y => catalan x * catalan y) n,
  sum_range]
state_before: n : ℕ
⊢ catalan (n + 1) = ∑ ij ∈ antidiagonal n, catalan ij.1 * catalan ij.2
state_after: no goals
Theorem: IsCompact.div_closedBall
File: Mathlib/Analysis/Normed/Group/Pointwise.lean

tactic: simp [div_eq_mul_inv, mul_comm, hs.mul_closedBall hδ]
state_before: E : Type u_1
inst✝ : SeminormedCommGroup E
ε δ : ℝ
s t : Set E
x✝ y : E
hs : IsCompact s
hδ : 0 ≤ δ
x : E
⊢ s / closedBall x δ = x⁻¹ • cthickening δ s
state_after: no goals
Theorem: Orientation.two_zsmul_oangle_of_span_eq_of_span_eq
File: Mathlib/Geometry/Euclidean/Angle/Oriented/Basic.lean

tactic: rw [o.two_zsmul_oangle_left_of_span_eq y hwx, o.two_zsmul_oangle_right_of_span_eq x hyz]
state_before: V : Type u_1
V' : Type u_2
inst✝⁵ : NormedAddCommGroup V
inst✝⁴ : NormedAddCommGroup V'
inst✝³ : InnerProductSpace ℝ V
inst✝² : InnerProductSpace ℝ V'
inst✝¹ : Fact (finrank ℝ V = 2)
inst✝ : Fact (finrank ℝ V' = 2)
o : Orientation ℝ V (Fin 2)
w x y z : V
hwx : Submodule.span ℝ {w} = Submodule.span ℝ {x}
hyz : Submodule.span ℝ {y} = Submodule.span ℝ {z}
⊢ 2 • o.oangle w y = 2 • o.oangle x z
state_after: no goals