1337xyz1337xyz/leandojo-benchmark4-v10 huggingface dataset:
Theorem: Polynomial.content_mul_aux
File: Mathlib/RingTheory/Polynomial/Content.lean

tactic: rw [gcd_comm (content _) _, gcd_comm (content _) _]
state_before: R : Type u_1
inst✝² : CommRing R
inst✝¹ : IsDomain R
inst✝ : NormalizedGCDMonoid R
p q : R[X]
⊢ gcd (p * q).eraseLead.content p.leadingCoeff = gcd (p.eraseLead * q).content p.leadingCoeff
state_after: R : Type u_1
inst✝² : CommRing R
inst✝¹ : IsDomain R
inst✝ : NormalizedGCDMonoid R
p q : R[X]
⊢ gcd p.leadingCoeff (p * q).eraseLead.content = gcd p.leadingCoeff (p.eraseLead * q).content

tactic: apply gcd_content_eq_of_dvd_sub
state_before: R : Type u_1
inst✝² : CommRing R
inst✝¹ : IsDomain R
inst✝ : NormalizedGCDMonoid R
p q : R[X]
⊢ gcd p.leadingCoeff (p * q).eraseLead.content = gcd p.leadingCoeff (p.eraseLead * q).content
state_after: case h
R : Type u_1
inst✝² : CommRing R
inst✝¹ : IsDomain R
inst✝ : NormalizedGCDMonoid R
p q : R[X]
⊢ C p.leadingCoeff ∣ (p * q).eraseLead - p.eraseLead * q

tactic: rw [← self_sub_C_mul_X_pow, ← self_sub_C_mul_X_pow, sub_mul, sub_sub, add_comm, sub_add,
  sub_sub_cancel, leadingCoeff_mul, RingHom.map_mul, mul_assoc, mul_assoc]
state_before: case h
R : Type u_1
inst✝² : CommRing R
inst✝¹ : IsDomain R
inst✝ : NormalizedGCDMonoid R
p q : R[X]
⊢ C p.leadingCoeff ∣ (p * q).eraseLead - p.eraseLead * q
state_after: case h
R : Type u_1
inst✝² : CommRing R
inst✝¹ : IsDomain R
inst✝ : NormalizedGCDMonoid R
p q : R[X]
⊢ C p.leadingCoeff ∣
    C p.leadingCoeff * (X ^ p.natDegree * q) - C p.leadingCoeff * (C q.leadingCoeff * X ^ (p * q).natDegree)

tactic: apply dvd_sub (Dvd.intro _ rfl) (Dvd.intro _ rfl)
state_before: case h
R : Type u_1
inst✝² : CommRing R
inst✝¹ : IsDomain R
inst✝ : NormalizedGCDMonoid R
p q : R[X]
⊢ C p.leadingCoeff ∣
    C p.leadingCoeff * (X ^ p.natDegree * q) - C p.leadingCoeff * (C q.leadingCoeff * X ^ (p * q).natDegree)
state_after: no goals
Theorem: Finset.univ_infs_univ
File: Mathlib/Data/Finset/Sups.lean

tactic: simp
state_before: F : Type u_1
α : Type u_2
β : Type u_3
inst✝⁶ : DecidableEq α
inst✝⁵ : DecidableEq β
inst✝⁴ : SemilatticeInf α
inst✝³ : SemilatticeInf β
inst✝² : FunLike F α β
inst✝¹ : InfHomClass F α β
s s₁ s₂ t t₁ t₂ u v : Finset α
a b c : α
inst✝ : Fintype α
⊢ univ ⊼ univ = univ
state_after: no goals
Theorem: KaehlerDifferential.quotKerTotalEquiv_symm_comp_D
File: Mathlib/RingTheory/Kaehler/Basic.lean

tactic: convert (KaehlerDifferential.derivationQuotKerTotal R S).liftKaehlerDifferential_comp
state_before: R : Type u
S : Type v
inst✝⁶ : CommRing R
inst✝⁵ : CommRing S
inst✝⁴ : Algebra R S
M : Type u_1
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : Module S M
inst✝ : IsScalarTower R S M
⊢ (↑(quotKerTotalEquiv R S).symm).compDer (D R S) = derivationQuotKerTotal R S
state_after: no goals
Theorem: smul_top_inf_eq_smul_of_isSMulRegular_on_quot
File: Mathlib/RingTheory/Regular/IsSMulRegular.lean

tactic: convert map_mono ∘ (isSMulRegular_on_quot_iff_lsmul_comap_le N r).mp using 2
state_before: R : Type u_1
S : Type u_2
M : Type u_3
M' : Type u_4
M'' : Type u_5
inst✝⁶ : CommRing R
inst✝⁵ : AddCommGroup M
inst✝⁴ : Module R M
inst✝³ : AddCommGroup M'
inst✝² : Module R M'
inst✝¹ : AddCommGroup M''
inst✝ : Module R M''
I : Ideal R
N : Submodule R M
r : R
⊢ IsSMulRegular (M ⧸ N) r → r • ⊤ ⊓ N ≤ r • N
state_after: case h'.h.e'_3
R : Type u_1
S : Type u_2
M : Type u_3
M' : Type u_4
M'' : Type u_5
inst✝⁶ : CommRing R
inst✝⁵ : AddCommGroup M
inst✝⁴ : Module R M
inst✝³ : AddCommGroup M'
inst✝² : Module R M'
inst✝¹ : AddCommGroup M''
inst✝ : Module R M''
I : Ideal R
N : Submodule R M
r : R
a✝ : IsSMulRegular (M ⧸ N) r
⊢ r • ⊤ ⊓ N = map (DistribMulAction.toLinearMap R M r) (comap ((LinearMap.lsmul R M) r) N)
Theorem: Ordinal.toPGame_moveLeft_hEq
File: Mathlib/SetTheory/Game/Ordinal.lean

tactic: rw [toPGame]
state_before: o : Ordinal.{u_1}
⊢ let_fun this := ⋯;
  HEq o.toPGame.moveLeft fun x => (typein (fun x x_1 => x < x_1) x).toPGame
state_after: o : Ordinal.{u_1}
⊢ let_fun this := ⋯;
  HEq
    (mk (Quotient.out o).α PEmpty.{u_1 + 1}
        (fun x =>
          let_fun this := ⋯;
          (typein (fun x x_1 => x < x_1) x).toPGame)
        PEmpty.elim).moveLeft
    fun x => (typein (fun x x_1 => x < x_1) x).toPGame

tactic: rfl
state_before: o : Ordinal.{u_1}
⊢ let_fun this := ⋯;
  HEq
    (mk (Quotient.out o).α PEmpty.{u_1 + 1}
        (fun x =>
          let_fun this := ⋯;
          (typein (fun x x_1 => x < x_1) x).toPGame)
        PEmpty.elim).moveLeft
    fun x => (typein (fun x x_1 => x < x_1) x).toPGame
state_after: no goals
Theorem: TopCat.inducing_pullback_to_prod
File: Mathlib/Topology/Category/TopCat/Limits/Pullbacks.lean

tactic: simp [topologicalSpace_coe, prod_topology, pullback_topology, induced_compose, ← coe_comp]
state_before: J : Type v
inst✝ : SmallCategory J
X✝ Y✝ Z✝ X Y Z : TopCat
f : X ⟶ Z
g : Y ⟶ Z
⊢ (pullback f g).topologicalSpace_coe = induced (⇑(prod.lift pullback.fst pullback.snd)) (X ⨯ Y).topologicalSpace_coe
state_after: no goals
Theorem: Submodule.linearProjOfIsCompl_apply_eq_zero_iff
File: Mathlib/LinearAlgebra/Projection.lean

tactic: simp [linearProjOfIsCompl]
state_before: R : Type u_1
inst✝⁹ : Ring R
E : Type u_2
inst✝⁸ : AddCommGroup E
inst✝⁷ : Module R E
F : Type u_3
inst✝⁶ : AddCommGroup F
inst✝⁵ : Module R F
G : Type u_4
inst✝⁴ : AddCommGroup G
inst✝³ : Module R G
p q : Submodule R E
S : Type u_5
inst✝² : Semiring S
M : Type u_6
inst✝¹ : AddCommMonoid M
inst✝ : Module S M
m : Submodule S M
h : IsCompl p q
x : E
⊢ (p.linearProjOfIsCompl q h) x = 0 ↔ x ∈ q
state_after: no goals
Theorem: PadicInt.isUnit_iff
File: Mathlib/NumberTheory/Padics/PadicIntegers.lean

tactic: rcases isUnit_iff_dvd_one.1 h with ⟨w, eq⟩
state_before: p : ℕ
hp : Fact (Nat.Prime p)
z : ℤ_[p]
h : IsUnit z
⊢ ‖z‖ = 1
state_after: case intro
p : ℕ
hp : Fact (Nat.Prime p)
z : ℤ_[p]
h : IsUnit z
w : ℤ_[p]
eq : 1 = z * w
⊢ ‖z‖ = 1

tactic: refine le_antisymm (norm_le_one _) ?_
state_before: case intro
p : ℕ
hp : Fact (Nat.Prime p)
z : ℤ_[p]
h : IsUnit z
w : ℤ_[p]
eq : 1 = z * w
⊢ ‖z‖ = 1
state_after: case intro
p : ℕ
hp : Fact (Nat.Prime p)
z : ℤ_[p]
h : IsUnit z
w : ℤ_[p]
eq : 1 = z * w
⊢ 1 ≤ ‖z‖

tactic: have := mul_le_mul_of_nonneg_left (norm_le_one w) (norm_nonneg z)
state_before: case intro
p : ℕ
hp : Fact (Nat.Prime p)
z : ℤ_[p]
h : IsUnit z
w : ℤ_[p]
eq : 1 = z * w
⊢ 1 ≤ ‖z‖
state_after: case intro
p : ℕ
hp : Fact (Nat.Prime p)
z : ℤ_[p]
h : IsUnit z
w : ℤ_[p]
eq : 1 = z * w
this : ‖z‖ * ‖w‖ ≤ ‖z‖ * 1
⊢ 1 ≤ ‖z‖

tactic: rwa [mul_one, ← norm_mul, ← eq, norm_one] at this
state_before: case intro
p : ℕ
hp : Fact (Nat.Prime p)
z : ℤ_[p]
h : IsUnit z
w : ℤ_[p]
eq : 1 = z * w
this : ‖z‖ * ‖w‖ ≤ ‖z‖ * 1
⊢ 1 ≤ ‖z‖
state_after: no goals
Theorem: div_eq_div_iff_comm
File: Mathlib/Algebra/Group/Basic.lean

tactic: simp only [inv_div]
state_before: α : Type u_1
β : Type u_2
G : Type u_3
M : Type u_4
inst✝ : DivisionMonoid α
a b c d : α
⊢ (a / b)⁻¹ = (c / d)⁻¹ ↔ b / a = d / c
state_after: no goals
Theorem: Composition.ones_blocksFun
File: Mathlib/Combinatorics/Enumerative/Composition.lean

tactic: simp only [blocksFun, ones, get_eq_getElem, getElem_replicate]
state_before: n✝ : ℕ
c : Composition n✝
n : ℕ
i : Fin (ones n).length
⊢ (ones n).blocksFun i = 1
state_after: no goals
Theorem: Finset.erase_eq_iff_eq_insert
File: Mathlib/Data/Finset/Basic.lean

tactic: aesop
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
inst✝ : DecidableEq α
s t u v : Finset α
a b : α
hs : a ∈ s
ht : a ∉ t
⊢ s.erase a = t ↔ s = insert a t
state_after: no goals
Theorem: Polynomial.natSepDegree_X_sub_C_pow
File: Mathlib/FieldTheory/SeparableDegree.lean

tactic: simp only [natSepDegree_pow, natSepDegree_X_sub_C]
state_before: F : Type u
E : Type v
inst✝⁴ : Field F
inst✝³ : Field E
inst✝² : Algebra F E
K : Type w
inst✝¹ : Field K
inst✝ : Algebra F K
f : F[X]
x : F
n : ℕ
⊢ ((X - C x) ^ n).natSepDegree = if n = 0 then 0 else 1
state_after: no goals
Theorem: Set.restrictPreimage_inducing
File: Mathlib/Topology/LocalAtTarget.lean

tactic: simp_rw [← inducing_subtype_val.of_comp_iff, inducing_iff_nhds, restrictPreimage,
  MapsTo.coe_restrict, restrict_eq, ← @Filter.comap_comap _ _ _ _ _ f, Function.comp_apply] at h ⊢
state_before: α : Type u_1
β : Type u_2
inst✝¹ : TopologicalSpace α
inst✝ : TopologicalSpace β
f : α → β
s✝ : Set β
ι : Type u_3
U : ι → Opens β
hU : iSup U = ⊤
s : Set β
h : Inducing f
⊢ Inducing (s.restrictPreimage f)
state_after: α : Type u_1
β : Type u_2
inst✝¹ : TopologicalSpace α
inst✝ : TopologicalSpace β
f : α → β
s✝ : Set β
ι : Type u_3
U : ι → Opens β
hU : iSup U = ⊤
s : Set β
h : ∀ (x : α), 𝓝 x = comap f (𝓝 (f x))
⊢ ∀ (x : ↑(f ⁻¹' s)), 𝓝 x = comap Subtype.val (comap f (𝓝 (f ↑x)))

tactic: intro a
state_before: α : Type u_1
β : Type u_2
inst✝¹ : TopologicalSpace α
inst✝ : TopologicalSpace β
f : α → β
s✝ : Set β
ι : Type u_3
U : ι → Opens β
hU : iSup U = ⊤
s : Set β
h : ∀ (x : α), 𝓝 x = comap f (𝓝 (f x))
⊢ ∀ (x : ↑(f ⁻¹' s)), 𝓝 x = comap Subtype.val (comap f (𝓝 (f ↑x)))
state_after: α : Type u_1
β : Type u_2
inst✝¹ : TopologicalSpace α
inst✝ : TopologicalSpace β
f : α → β
s✝ : Set β
ι : Type u_3
U : ι → Opens β
hU : iSup U = ⊤
s : Set β
h : ∀ (x : α), 𝓝 x = comap f (𝓝 (f x))
a : ↑(f ⁻¹' s)
⊢ 𝓝 a = comap Subtype.val (comap f (𝓝 (f ↑a)))

tactic: rw [← h, ← inducing_subtype_val.nhds_eq_comap]
state_before: α : Type u_1
β : Type u_2
inst✝¹ : TopologicalSpace α
inst✝ : TopologicalSpace β
f : α → β
s✝ : Set β
ι : Type u_3
U : ι → Opens β
hU : iSup U = ⊤
s : Set β
h : ∀ (x : α), 𝓝 x = comap f (𝓝 (f x))
a : ↑(f ⁻¹' s)
⊢ 𝓝 a = comap Subtype.val (comap f (𝓝 (f ↑a)))
state_after: no goals
Theorem: neg_sq
File: Mathlib/Algebra/Ring/Commute.lean

tactic: simp [sq]
state_before: α : Type u
β : Type v
γ : Type w
R : Type x
inst✝¹ : Monoid R
inst✝ : HasDistribNeg R
a : R
⊢ (-a) ^ 2 = a ^ 2
state_after: no goals
Theorem: MvPolynomial.eval₂_add
File: Mathlib/Algebra/MvPolynomial/Basic.lean

tactic: classical exact Finsupp.sum_add_index (by simp [f.map_zero]) (by simp [add_mul, f.map_add])
state_before: R : Type u
S₁ : Type v
S₂ : Type w
S₃ : Type x
σ : Type u_1
a a' a₁ a₂ : R
e : ℕ
n m : σ
s : σ →₀ ℕ
inst✝¹ : CommSemiring R
inst✝ : CommSemiring S₁
p q : MvPolynomial σ R
f : R →+* S₁
g : σ → S₁
⊢ eval₂ f g (p + q) = eval₂ f g p + eval₂ f g q
state_after: no goals

tactic: exact Finsupp.sum_add_index (by simp [f.map_zero]) (by simp [add_mul, f.map_add])
state_before: R : Type u
S₁ : Type v
S₂ : Type w
S₃ : Type x
σ : Type u_1
a a' a₁ a₂ : R
e : ℕ
n m : σ
s : σ →₀ ℕ
inst✝¹ : CommSemiring R
inst✝ : CommSemiring S₁
p q : MvPolynomial σ R
f : R →+* S₁
g : σ → S₁
⊢ eval₂ f g (p + q) = eval₂ f g p + eval₂ f g q
state_after: no goals

tactic: simp [f.map_zero]
state_before: R : Type u
S₁ : Type v
S₂ : Type w
S₃ : Type x
σ : Type u_1
a a' a₁ a₂ : R
e : ℕ
n m : σ
s : σ →₀ ℕ
inst✝¹ : CommSemiring R
inst✝ : CommSemiring S₁
p q : MvPolynomial σ R
f : R →+* S₁
g : σ → S₁
⊢ ∀ a ∈ p.support ∪ q.support, (f 0 * a.prod fun n e => g n ^ e) = 0
state_after: no goals

tactic: simp [add_mul, f.map_add]
state_before: R : Type u
S₁ : Type v
S₂ : Type w
S₃ : Type x
σ : Type u_1
a a' a₁ a₂ : R
e : ℕ
n m : σ
s : σ →₀ ℕ
inst✝¹ : CommSemiring R
inst✝ : CommSemiring S₁
p q : MvPolynomial σ R
f : R →+* S₁
g : σ → S₁
⊢ ∀ a ∈ p.support ∪ q.support,
    ∀ (b₁ b₂ : R),
      (f (b₁ + b₂) * a.prod fun n e => g n ^ e) = (f b₁ * a.prod fun n e => g n ^ e) + f b₂ * a.prod fun n e => g n ^ e
state_after: no goals
Theorem: TopologicalSpace.IsTopologicalBasis.isOpen_iff
File: Mathlib/Topology/Bases.lean

tactic: simp [isOpen_iff_mem_nhds, hb.mem_nhds_iff]
state_before: α : Type u
β : Type u_1
t : TopologicalSpace α
B : Set (Set α)
s✝ s : Set α
b : Set (Set α)
hb : IsTopologicalBasis b
⊢ IsOpen s ↔ ∀ a ∈ s, ∃ t ∈ b, a ∈ t ∧ t ⊆ s
state_after: no goals
Theorem: upperClosure_singleton
File: Mathlib/Order/UpperLower/Basic.lean

tactic: ext
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
κ : ι → Sort u_5
inst✝¹ : Preorder α
inst✝ : Preorder β
s t : Set α
x a : α
⊢ upperClosure {a} = UpperSet.Ici a
state_after: case a.h
α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
κ : ι → Sort u_5
inst✝¹ : Preorder α
inst✝ : Preorder β
s t : Set α
x a x✝ : α
⊢ x✝ ∈ ↑(upperClosure {a}) ↔ x✝ ∈ ↑(UpperSet.Ici a)

tactic: simp
state_before: case a.h
α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
κ : ι → Sort u_5
inst✝¹ : Preorder α
inst✝ : Preorder β
s t : Set α
x a x✝ : α
⊢ x✝ ∈ ↑(upperClosure {a}) ↔ x✝ ∈ ↑(UpperSet.Ici a)
state_after: no goals
Theorem: Ordnode.Raised.dist_le'
File: Mathlib/Data/Ordmap/Ordset.lean

tactic: rw [Nat.dist_comm]
state_before: α : Type u_1
n m : ℕ
H : Raised n m
⊢ m.dist n ≤ 1
state_after: α : Type u_1
n m : ℕ
H : Raised n m
⊢ n.dist m ≤ 1

tactic: exact H.dist_le
state_before: α : Type u_1
n m : ℕ
H : Raised n m
⊢ n.dist m ≤ 1
state_after: no goals
Theorem: nhdsWithin_prod
File: Mathlib/Topology/ContinuousOn.lean

tactic: rw [nhdsWithin_prod_eq]
state_before: α✝ : Type u_1
β✝ : Type u_2
γ : Type u_3
δ : Type u_4
inst✝² : TopologicalSpace α✝
α : Type u_5
inst✝¹ : TopologicalSpace α
β : Type u_6
inst✝ : TopologicalSpace β
s u : Set α
t v : Set β
a : α
b : β
hu : u ∈ 𝓝[s] a
hv : v ∈ 𝓝[t] b
⊢ u ×ˢ v ∈ 𝓝[s ×ˢ t] (a, b)
state_after: α✝ : Type u_1
β✝ : Type u_2
γ : Type u_3
δ : Type u_4
inst✝² : TopologicalSpace α✝
α : Type u_5
inst✝¹ : TopologicalSpace α
β : Type u_6
inst✝ : TopologicalSpace β
s u : Set α
t v : Set β
a : α
b : β
hu : u ∈ 𝓝[s] a
hv : v ∈ 𝓝[t] b
⊢ u ×ˢ v ∈ 𝓝[s] a ×ˢ 𝓝[t] b

tactic: exact prod_mem_prod hu hv
state_before: α✝ : Type u_1
β✝ : Type u_2
γ : Type u_3
δ : Type u_4
inst✝² : TopologicalSpace α✝
α : Type u_5
inst✝¹ : TopologicalSpace α
β : Type u_6
inst✝ : TopologicalSpace β
s u : Set α
t v : Set β
a : α
b : β
hu : u ∈ 𝓝[s] a
hv : v ∈ 𝓝[t] b
⊢ u ×ˢ v ∈ 𝓝[s] a ×ˢ 𝓝[t] b
state_after: no goals
Theorem: RingHom.FiniteType.comp_surjective
File: Mathlib/RingTheory/FiniteType.lean

tactic: let _ : Algebra A B := f.toAlgebra
state_before: A : Type u_1
B : Type u_2
C : Type u_3
inst✝² : CommRing A
inst✝¹ : CommRing B
inst✝ : CommRing C
f : A →+* B
g : B →+* C
hf : f.FiniteType
hg : Surjective ⇑g
⊢ (g.comp f).FiniteType
state_after: A : Type u_1
B : Type u_2
C : Type u_3
inst✝² : CommRing A
inst✝¹ : CommRing B
inst✝ : CommRing C
f : A →+* B
g : B →+* C
hf : f.FiniteType
hg : Surjective ⇑g
x✝ : Algebra A B := f.toAlgebra
⊢ (g.comp f).FiniteType

tactic: let _ : Algebra A C := (g.comp f).toAlgebra
state_before: A : Type u_1
B : Type u_2
C : Type u_3
inst✝² : CommRing A
inst✝¹ : CommRing B
inst✝ : CommRing C
f : A →+* B
g : B →+* C
hf : f.FiniteType
hg : Surjective ⇑g
x✝ : Algebra A B := f.toAlgebra
⊢ (g.comp f).FiniteType
state_after: A : Type u_1
B : Type u_2
C : Type u_3
inst✝² : CommRing A
inst✝¹ : CommRing B
inst✝ : CommRing C
f : A →+* B
g : B →+* C
hf : f.FiniteType
hg : Surjective ⇑g
x✝¹ : Algebra A B := f.toAlgebra
x✝ : Algebra A C := (g.comp f).toAlgebra
⊢ (g.comp f).FiniteType

tactic: exact Algebra.FiniteType.of_surjective hf
  { g with
    toFun := g
    commutes' := fun a => rfl }
  hg
state_before: A : Type u_1
B : Type u_2
C : Type u_3
inst✝² : CommRing A
inst✝¹ : CommRing B
inst✝ : CommRing C
f : A →+* B
g : B →+* C
hf : f.FiniteType
hg : Surjective ⇑g
x✝¹ : Algebra A B := f.toAlgebra
x✝ : Algebra A C := (g.comp f).toAlgebra
⊢ (g.comp f).FiniteType
state_after: no goals
Theorem: Complex.norm_eventually_eq_of_isLocalMax
File: Mathlib/Analysis/Complex/AbsMax.lean

tactic: rcases nhds_basis_closedBall.eventually_iff.1 (hd.and hc) with ⟨r, hr₀, hr⟩
state_before: E : Type u
inst✝³ : NormedAddCommGroup E
inst✝² : NormedSpace ℂ E
F : Type v
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedSpace ℂ F
f : E → F
c : E
hd : ∀ᶠ (z : E) in 𝓝 c, DifferentiableAt ℂ f z
hc : IsLocalMax (norm ∘ f) c
⊢ ∀ᶠ (y : E) in 𝓝 c, ‖f y‖ = ‖f c‖
state_after: case intro.intro
E : Type u
inst✝³ : NormedAddCommGroup E
inst✝² : NormedSpace ℂ E
F : Type v
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedSpace ℂ F
f : E → F
c : E
hd : ∀ᶠ (z : E) in 𝓝 c, DifferentiableAt ℂ f z
hc : IsLocalMax (norm ∘ f) c
r : ℝ
hr₀ : 0 < r
hr : ∀ ⦃x : E⦄, x ∈ closedBall c r → DifferentiableAt ℂ f x ∧ (norm ∘ f) x ≤ (norm ∘ f) c
⊢ ∀ᶠ (y : E) in 𝓝 c, ‖f y‖ = ‖f c‖

tactic: exact nhds_basis_closedBall.eventually_iff.2
  ⟨r, hr₀, norm_eqOn_closedBall_of_isMaxOn (DifferentiableOn.diffContOnCl fun x hx =>
      (hr <| closure_ball_subset_closedBall hx).1.differentiableWithinAt) fun x hx =>
    (hr <| ball_subset_closedBall hx).2⟩
state_before: case intro.intro
E : Type u
inst✝³ : NormedAddCommGroup E
inst✝² : NormedSpace ℂ E
F : Type v
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedSpace ℂ F
f : E → F
c : E
hd : ∀ᶠ (z : E) in 𝓝 c, DifferentiableAt ℂ f z
hc : IsLocalMax (norm ∘ f) c
r : ℝ
hr₀ : 0 < r
hr : ∀ ⦃x : E⦄, x ∈ closedBall c r → DifferentiableAt ℂ f x ∧ (norm ∘ f) x ≤ (norm ∘ f) c
⊢ ∀ᶠ (y : E) in 𝓝 c, ‖f y‖ = ‖f c‖
state_after: no goals
Theorem: Nat.sqrt_add_eq'
File: Mathlib/Data/Nat/Defs.lean

tactic: simpa [Nat.pow_two] using sqrt_add_eq n h
state_before: a b c d m n✝ k : ℕ
p q : ℕ → Prop
n : ℕ
h : a ≤ n + n
⊢ (n ^ 2 + a).sqrt = n
state_after: no goals
Theorem: Complex.cpow_int_mul
File: Mathlib/Analysis/SpecialFunctions/Pow/Complex.lean

tactic: rcases eq_or_ne x 0 with rfl | hx
state_before: x : ℂ
n : ℤ
y : ℂ
⊢ x ^ (↑n * y) = (x ^ y) ^ n
state_after: case inl
n : ℤ
y : ℂ
⊢ 0 ^ (↑n * y) = (0 ^ y) ^ n

case inr
x : ℂ
n : ℤ
y : ℂ
hx : x ≠ 0
⊢ x ^ (↑n * y) = (x ^ y) ^ n

tactic: rcases eq_or_ne n 0 with rfl | hn
state_before: case inl
n : ℤ
y : ℂ
⊢ 0 ^ (↑n * y) = (0 ^ y) ^ n
state_after: case inl.inl
y : ℂ
⊢ 0 ^ (↑0 * y) = (0 ^ y) ^ 0

case inl.inr
n : ℤ
y : ℂ
hn : n ≠ 0
⊢ 0 ^ (↑n * y) = (0 ^ y) ^ n

tactic: simp
state_before: case inl.inl
y : ℂ
⊢ 0 ^ (↑0 * y) = (0 ^ y) ^ 0
state_after: no goals

tactic: rcases eq_or_ne y 0 with rfl | hy <;> simp [*, zero_zpow]
state_before: case inl.inr
n : ℤ
y : ℂ
hn : n ≠ 0
⊢ 0 ^ (↑n * y) = (0 ^ y) ^ n
state_after: no goals

tactic: rw [cpow_def_of_ne_zero hx, cpow_def_of_ne_zero hx, mul_left_comm, exp_int_mul]
state_before: case inr
x : ℂ
n : ℤ
y : ℂ
hx : x ≠ 0
⊢ x ^ (↑n * y) = (x ^ y) ^ n
state_after: no goals
Theorem: absorbs_union
File: Mathlib/Topology/Bornology/Absorbs.lean

tactic: simp [Absorbs]
state_before: M : Type u_1
α : Type u_2
inst✝¹ : Bornology M
inst✝ : SMul M α
s s₁ s₂ t t₁ t₂ : Set α
S T : Set (Set α)
⊢ Absorbs M s (t₁ ∪ t₂) ↔ Absorbs M s t₁ ∧ Absorbs M s t₂
state_after: no goals
Theorem: Real.cos_pi_div_thirty_two
File: Mathlib/Analysis/SpecialFunctions/Trigonometric/Basic.lean

tactic: trans cos (π / 2 ^ 5)
state_before: x : ℝ
⊢ cos (π / 32) = √(2 + √(2 + √(2 + √2))) / 2
state_after: x : ℝ
⊢ cos (π / 32) = cos (π / 2 ^ 5)

x : ℝ
⊢ cos (π / 2 ^ 5) = √(2 + √(2 + √(2 + √2))) / 2

tactic: congr
state_before: x : ℝ
⊢ cos (π / 32) = cos (π / 2 ^ 5)
state_after: case e_x.e_a
x : ℝ
⊢ 32 = 2 ^ 5

tactic: norm_num
state_before: case e_x.e_a
x : ℝ
⊢ 32 = 2 ^ 5
state_after: no goals

tactic: simp
state_before: x : ℝ
⊢ cos (π / 2 ^ 5) = √(2 + √(2 + √(2 + √2))) / 2
state_after: no goals
Theorem: CategoryTheory.Limits.colimit.post_desc
File: Mathlib/CategoryTheory/Limits/HasLimits.lean

tactic: ext
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
D : Type u'
inst✝² : Category.{v', u'} D
inst✝¹ : HasColimit F
G : C ⥤ D
inst✝ : HasColimit (F ⋙ G)
c : Cocone F
⊢ post F G ≫ G.map (desc F c) = desc (F ⋙ G) (G.mapCocone c)
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
D : Type u'
inst✝² : Category.{v', u'} D
inst✝¹ : HasColimit F
G : C ⥤ D
inst✝ : HasColimit (F ⋙ G)
c : Cocone F
j✝ : J
⊢ ι (F ⋙ G) j✝ ≫ post F G ≫ G.map (desc F c) = ι (F ⋙ G) j✝ ≫ desc (F ⋙ G) (G.mapCocone c)

tactic: rw [← assoc, colimit.ι_post, ← G.map_comp, colimit.ι_desc, colimit.ι_desc]
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
D : Type u'
inst✝² : Category.{v', u'} D
inst✝¹ : HasColimit F
G : C ⥤ D
inst✝ : HasColimit (F ⋙ G)
c : Cocone F
j✝ : J
⊢ ι (F ⋙ G) j✝ ≫ post F G ≫ G.map (desc F c) = ι (F ⋙ G) j✝ ≫ desc (F ⋙ G) (G.mapCocone c)
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
D : Type u'
inst✝² : Category.{v', u'} D
inst✝¹ : HasColimit F
G : C ⥤ D
inst✝ : HasColimit (F ⋙ G)
c : Cocone F
j✝ : J
⊢ G.map (c.ι.app j✝) = (G.mapCocone c).ι.app 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
D : Type u'
inst✝² : Category.{v', u'} D
inst✝¹ : HasColimit F
G : C ⥤ D
inst✝ : HasColimit (F ⋙ G)
c : Cocone F
j✝ : J
⊢ G.map (c.ι.app j✝) = (G.mapCocone c).ι.app j✝
state_after: no goals
Theorem: Algebra.Generators.σ_injective
File: Mathlib/RingTheory/Generators.lean

tactic: intro x y e
state_before: R : Type u
S : Type v
inst✝² : CommRing R
inst✝¹ : CommRing S
inst✝ : Algebra R S
P : Generators R S
⊢ Function.Injective P.σ
state_after: R : Type u
S : Type v
inst✝² : CommRing R
inst✝¹ : CommRing S
inst✝ : Algebra R S
P : Generators R S
x y : S
e : P.σ x = P.σ y
⊢ x = y

tactic: rw [← P.aeval_val_σ x, ← P.aeval_val_σ y, e]
state_before: R : Type u
S : Type v
inst✝² : CommRing R
inst✝¹ : CommRing S
inst✝ : Algebra R S
P : Generators R S
x y : S
e : P.σ x = P.σ y
⊢ x = y
state_after: no goals
Theorem: Polynomial.card_supp_le_succ_natDegree
File: Mathlib/Algebra/Polynomial/Degree/Definitions.lean

tactic: rw [← Finset.card_range (p.natDegree + 1)]
state_before: R : Type u
S : Type v
a b c d : R
n m : ℕ
inst✝ : Semiring R
p✝ q r p : R[X]
⊢ p.support.card ≤ p.natDegree + 1
state_after: R : Type u
S : Type v
a b c d : R
n m : ℕ
inst✝ : Semiring R
p✝ q r p : R[X]
⊢ p.support.card ≤ (range (p.natDegree + 1)).card

tactic: exact Finset.card_le_card supp_subset_range_natDegree_succ
state_before: R : Type u
S : Type v
a b c d : R
n m : ℕ
inst✝ : Semiring R
p✝ q r p : R[X]
⊢ p.support.card ≤ (range (p.natDegree + 1)).card
state_after: no goals