1337xyz1337xyz/leandojo-benchmark4-v10 huggingface dataset:
Theorem: MvPolynomial.coeff_C_mul
File: Mathlib/Algebra/MvPolynomial/Basic.lean

tactic: rw [mul_def, sum_C]
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
m : σ →₀ ℕ
a : R
p : MvPolynomial σ R
⊢ coeff m (C a * p) = a * coeff m p
state_after: 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
m : σ →₀ ℕ
a : R
p : MvPolynomial σ R
⊢ coeff m (sum p fun n b => (monomial (0 + n)) (a * b)) = a * coeff m p

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
m : σ →₀ ℕ
a : R
p : MvPolynomial σ R
⊢ (sum p fun n b => (monomial (0 + n)) (0 * b)) = 0

tactic: simp
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
m : σ →₀ ℕ
a : R
p : MvPolynomial σ R
⊢ (sum p fun n b => (monomial (0 + n)) (0 * b)) = 0
state_after: no goals

tactic: simp (config := { contextual := true }) [sum_def, coeff_sum]
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
m : σ →₀ ℕ
a : R
p : MvPolynomial σ R
⊢ coeff m (sum p fun n b => (monomial (0 + n)) (a * b)) = a * coeff m p
state_after: no goals
Theorem: Commute.mul_geom_sum₂
File: Mathlib/Algebra/GeomSum.lean

tactic: rw [← neg_sub (y ^ n), ← h.mul_neg_geom_sum₂, ← neg_mul, neg_sub]
state_before: α : Type u
inst✝ : Ring α
x y : α
h : Commute x y
n : ℕ
⊢ (x - y) * ∑ i ∈ range n, x ^ i * y ^ (n - 1 - i) = x ^ n - y ^ n
state_after: no goals
Theorem: Set.sInter_iUnion
File: Mathlib/Data/Set/Lattice.lean

tactic: simp only [sInter_eq_biInter, biInter_iUnion]
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
s : ι → Set (Set α)
⊢ ⋂₀ ⋃ i, s i = ⋂ i, ⋂₀ s i
state_after: no goals
Theorem: map_pow
File: Mathlib/Algebra/Group/Hom/Defs.lean

tactic: rw [pow_zero, pow_zero, map_one]
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
M : Type u_4
N : Type u_5
P : Type u_6
G : Type u_7
H : Type u_8
F : Type u_9
inst✝⁶ : MulOneClass M
inst✝⁵ : MulOneClass N
inst✝⁴ : FunLike F M N
inst✝³ : FunLike F G H
inst✝² : Monoid G
inst✝¹ : Monoid H
inst✝ : MonoidHomClass F G H
f : F
a : G
⊢ f (a ^ 0) = f a ^ 0
state_after: no goals

tactic: rw [pow_succ, pow_succ, map_mul, map_pow f a n]
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
M : Type u_4
N : Type u_5
P : Type u_6
G : Type u_7
H : Type u_8
F : Type u_9
inst✝⁶ : MulOneClass M
inst✝⁵ : MulOneClass N
inst✝⁴ : FunLike F M N
inst✝³ : FunLike F G H
inst✝² : Monoid G
inst✝¹ : Monoid H
inst✝ : MonoidHomClass F G H
f : F
a : G
n : ℕ
⊢ f (a ^ (n + 1)) = f a ^ (n + 1)
state_after: no goals
Theorem: ENNReal.iUnion_Icc_coe_nat
File: Mathlib/Data/ENNReal/Basic.lean

tactic: simp only [← Ici_inter_Iic, ← inter_iUnion, iUnion_Iic_coe_nat, diff_eq]
state_before: α : Type u_1
a b c d : ℝ≥0∞
r p q : ℝ≥0
⊢ ⋃ n, Icc a ↑n = Ici a \ {⊤}
state_after: no goals
Theorem: omegaLimit_eq_iInter_inter
File: Mathlib/Dynamics/OmegaLimit.lean

tactic: rw [omegaLimit_eq_biInter_inter _ _ _ hv]
state_before: τ : Type u_1
α : Type u_2
β : Type u_3
ι : Type u_4
inst✝ : TopologicalSpace β
f : Filter τ
ϕ : τ → α → β
s s₁ s₂ : Set α
v : Set τ
hv : v ∈ f
⊢ ω f ϕ s = ⋂ u, closure (image2 ϕ (↑u ∩ v) s)
state_after: τ : Type u_1
α : Type u_2
β : Type u_3
ι : Type u_4
inst✝ : TopologicalSpace β
f : Filter τ
ϕ : τ → α → β
s s₁ s₂ : Set α
v : Set τ
hv : v ∈ f
⊢ ⋂ u ∈ f, closure (image2 ϕ (u ∩ v) s) = ⋂ u, closure (image2 ϕ (↑u ∩ v) s)

tactic: apply biInter_eq_iInter
state_before: τ : Type u_1
α : Type u_2
β : Type u_3
ι : Type u_4
inst✝ : TopologicalSpace β
f : Filter τ
ϕ : τ → α → β
s s₁ s₂ : Set α
v : Set τ
hv : v ∈ f
⊢ ⋂ u ∈ f, closure (image2 ϕ (u ∩ v) s) = ⋂ u, closure (image2 ϕ (↑u ∩ v) s)
state_after: no goals
Theorem: Bool.apply_apply_apply
File: Mathlib/Data/Bool/Basic.lean

tactic: cases x <;> cases h₁ : f true <;> cases h₂ : f false <;> simp only [h₁, h₂]
state_before: f : Bool → Bool
x : Bool
⊢ f (f (f x)) = f x
state_after: no goals
Theorem: Finset.weightedVSubOfPoint_sdiff
File: Mathlib/LinearAlgebra/AffineSpace/Combination.lean

tactic: simp_rw [weightedVSubOfPoint_apply, sum_sdiff h]
state_before: k : Type u_1
V : Type u_2
P : Type u_3
inst✝³ : Ring k
inst✝² : AddCommGroup V
inst✝¹ : Module k V
S : AffineSpace V P
ι : Type u_4
s : Finset ι
ι₂ : Type u_5
s₂✝ : Finset ι₂
inst✝ : DecidableEq ι
s₂ : Finset ι
h : s₂ ⊆ s
w : ι → k
p : ι → P
b : P
⊢ ((s \ s₂).weightedVSubOfPoint p b) w + (s₂.weightedVSubOfPoint p b) w = (s.weightedVSubOfPoint p b) w
state_after: no goals
Theorem: StieltjesFunction.countable_leftLim_ne
File: Mathlib/MeasureTheory/Measure/Stieltjes.lean

tactic: refine Countable.mono ?_ f.mono.countable_not_continuousAt
state_before: f✝ f : StieltjesFunction
⊢ {x | leftLim (↑f) x ≠ ↑f x}.Countable
state_after: f✝ f : StieltjesFunction
⊢ {x | leftLim (↑f) x ≠ ↑f x} ⊆ {x | ¬ContinuousAt (↑f) x}

tactic: intro x hx h'x
state_before: f✝ f : StieltjesFunction
⊢ {x | leftLim (↑f) x ≠ ↑f x} ⊆ {x | ¬ContinuousAt (↑f) x}
state_after: f✝ f : StieltjesFunction
x : ℝ
hx : x ∈ {x | leftLim (↑f) x ≠ ↑f x}
h'x : ContinuousAt (↑f) x
⊢ False

tactic: apply hx
state_before: f✝ f : StieltjesFunction
x : ℝ
hx : x ∈ {x | leftLim (↑f) x ≠ ↑f x}
h'x : ContinuousAt (↑f) x
⊢ False
state_after: f✝ f : StieltjesFunction
x : ℝ
hx : x ∈ {x | leftLim (↑f) x ≠ ↑f x}
h'x : ContinuousAt (↑f) x
⊢ leftLim (↑f) x = ↑f x

tactic: exact tendsto_nhds_unique (f.mono.tendsto_leftLim x) (h'x.tendsto.mono_left nhdsWithin_le_nhds)
state_before: f✝ f : StieltjesFunction
x : ℝ
hx : x ∈ {x | leftLim (↑f) x ≠ ↑f x}
h'x : ContinuousAt (↑f) x
⊢ leftLim (↑f) x = ↑f x
state_after: no goals
Theorem: Rat.mul_den_dvd
File: Mathlib/Data/Rat/Lemmas.lean

tactic: rw [mul_def, normalize_eq]
state_before: q₁ q₂ : ℚ
⊢ (q₁ * q₂).den ∣ q₁.den * q₂.den
state_after: q₁ q₂ : ℚ
⊢ { num := q₁.num * q₂.num / ↑((q₁.num * q₂.num).natAbs.gcd (q₁.den * q₂.den)),
        den := q₁.den * q₂.den / (q₁.num * q₂.num).natAbs.gcd (q₁.den * q₂.den), den_nz := ⋯, reduced := ⋯ }.den ∣
    q₁.den * q₂.den

tactic: apply Nat.div_dvd_of_dvd
state_before: q₁ q₂ : ℚ
⊢ { num := q₁.num * q₂.num / ↑((q₁.num * q₂.num).natAbs.gcd (q₁.den * q₂.den)),
        den := q₁.den * q₂.den / (q₁.num * q₂.num).natAbs.gcd (q₁.den * q₂.den), den_nz := ⋯, reduced := ⋯ }.den ∣
    q₁.den * q₂.den
state_after: case h
q₁ q₂ : ℚ
⊢ (q₁.num * q₂.num).natAbs.gcd (q₁.den * q₂.den) ∣ q₁.den * q₂.den

tactic: apply Nat.gcd_dvd_right
state_before: case h
q₁ q₂ : ℚ
⊢ (q₁.num * q₂.num).natAbs.gcd (q₁.den * q₂.den) ∣ q₁.den * q₂.den
state_after: no goals
Theorem: AbsoluteValue.IsAdmissible.exists_partition
File: Mathlib/NumberTheory/ClassNumber/AdmissibleAbsoluteValue.lean

tactic: rcases Finite.exists_equiv_fin ι with ⟨n, ⟨e⟩⟩
state_before: R : Type u_1
inst✝¹ : EuclideanDomain R
abv : AbsoluteValue R ℤ
ι : Type u_2
inst✝ : Finite ι
ε : ℝ
hε : 0 < ε
b : R
hb : b ≠ 0
A : ι → R
h : abv.IsAdmissible
⊢ ∃ t, ∀ (i₀ i₁ : ι), t i₀ = t i₁ → ↑(abv (A i₁ % b - A i₀ % b)) < abv b • ε
state_after: case intro.intro
R : Type u_1
inst✝¹ : EuclideanDomain R
abv : AbsoluteValue R ℤ
ι : Type u_2
inst✝ : Finite ι
ε : ℝ
hε : 0 < ε
b : R
hb : b ≠ 0
A : ι → R
h : abv.IsAdmissible
n : ℕ
e : ι ≃ Fin n
⊢ ∃ t, ∀ (i₀ i₁ : ι), t i₀ = t i₁ → ↑(abv (A i₁ % b - A i₀ % b)) < abv b • ε

tactic: obtain ⟨t, ht⟩ := h.exists_partition' n hε hb (A ∘ e.symm)
state_before: case intro.intro
R : Type u_1
inst✝¹ : EuclideanDomain R
abv : AbsoluteValue R ℤ
ι : Type u_2
inst✝ : Finite ι
ε : ℝ
hε : 0 < ε
b : R
hb : b ≠ 0
A : ι → R
h : abv.IsAdmissible
n : ℕ
e : ι ≃ Fin n
⊢ ∃ t, ∀ (i₀ i₁ : ι), t i₀ = t i₁ → ↑(abv (A i₁ % b - A i₀ % b)) < abv b • ε
state_after: case intro.intro.intro
R : Type u_1
inst✝¹ : EuclideanDomain R
abv : AbsoluteValue R ℤ
ι : Type u_2
inst✝ : Finite ι
ε : ℝ
hε : 0 < ε
b : R
hb : b ≠ 0
A : ι → R
h : abv.IsAdmissible
n : ℕ
e : ι ≃ Fin n
t : Fin n → Fin (h.card ε)
ht : ∀ (i₀ i₁ : Fin n), t i₀ = t i₁ → ↑(abv ((A ∘ ⇑e.symm) i₁ % b - (A ∘ ⇑e.symm) i₀ % b)) < abv b • ε
⊢ ∃ t, ∀ (i₀ i₁ : ι), t i₀ = t i₁ → ↑(abv (A i₁ % b - A i₀ % b)) < abv b • ε

tactic: refine ⟨t ∘ e, fun i₀ i₁ h ↦ ?_⟩
state_before: case intro.intro.intro
R : Type u_1
inst✝¹ : EuclideanDomain R
abv : AbsoluteValue R ℤ
ι : Type u_2
inst✝ : Finite ι
ε : ℝ
hε : 0 < ε
b : R
hb : b ≠ 0
A : ι → R
h : abv.IsAdmissible
n : ℕ
e : ι ≃ Fin n
t : Fin n → Fin (h.card ε)
ht : ∀ (i₀ i₁ : Fin n), t i₀ = t i₁ → ↑(abv ((A ∘ ⇑e.symm) i₁ % b - (A ∘ ⇑e.symm) i₀ % b)) < abv b • ε
⊢ ∃ t, ∀ (i₀ i₁ : ι), t i₀ = t i₁ → ↑(abv (A i₁ % b - A i₀ % b)) < abv b • ε
state_after: case intro.intro.intro
R : Type u_1
inst✝¹ : EuclideanDomain R
abv : AbsoluteValue R ℤ
ι : Type u_2
inst✝ : Finite ι
ε : ℝ
hε : 0 < ε
b : R
hb : b ≠ 0
A : ι → R
h✝ : abv.IsAdmissible
n : ℕ
e : ι ≃ Fin n
t : Fin n → Fin (h✝.card ε)
ht : ∀ (i₀ i₁ : Fin n), t i₀ = t i₁ → ↑(abv ((A ∘ ⇑e.symm) i₁ % b - (A ∘ ⇑e.symm) i₀ % b)) < abv b • ε
i₀ i₁ : ι
h : (t ∘ ⇑e) i₀ = (t ∘ ⇑e) i₁
⊢ ↑(abv (A i₁ % b - A i₀ % b)) < abv b • ε

tactic: convert (config := {transparency := .default})
  ht (e i₀) (e i₁) h <;> simp only [e.symm_apply_apply]
state_before: case intro.intro.intro
R : Type u_1
inst✝¹ : EuclideanDomain R
abv : AbsoluteValue R ℤ
ι : Type u_2
inst✝ : Finite ι
ε : ℝ
hε : 0 < ε
b : R
hb : b ≠ 0
A : ι → R
h✝ : abv.IsAdmissible
n : ℕ
e : ι ≃ Fin n
t : Fin n → Fin (h✝.card ε)
ht : ∀ (i₀ i₁ : Fin n), t i₀ = t i₁ → ↑(abv ((A ∘ ⇑e.symm) i₁ % b - (A ∘ ⇑e.symm) i₀ % b)) < abv b • ε
i₀ i₁ : ι
h : (t ∘ ⇑e) i₀ = (t ∘ ⇑e) i₁
⊢ ↑(abv (A i₁ % b - A i₀ % b)) < abv b • ε
state_after: no goals
Theorem: MulChar.IsQuadratic.comp
File: Mathlib/NumberTheory/MulChar/Basic.lean

tactic: intro a
state_before: R : Type u_1
inst✝² : CommMonoid R
R' : Type u_2
inst✝¹ : CommRing R'
R'' : Type u_3
inst✝ : CommRing R''
χ : MulChar R R'
hχ : χ.IsQuadratic
f : R' →+* R''
⊢ (χ.ringHomComp f).IsQuadratic
state_after: R : Type u_1
inst✝² : CommMonoid R
R' : Type u_2
inst✝¹ : CommRing R'
R'' : Type u_3
inst✝ : CommRing R''
χ : MulChar R R'
hχ : χ.IsQuadratic
f : R' →+* R''
a : R
⊢ (χ.ringHomComp f) a = 0 ∨ (χ.ringHomComp f) a = 1 ∨ (χ.ringHomComp f) a = -1

tactic: rcases hχ a with (ha | ha | ha) <;> simp [ha]
state_before: R : Type u_1
inst✝² : CommMonoid R
R' : Type u_2
inst✝¹ : CommRing R'
R'' : Type u_3
inst✝ : CommRing R''
χ : MulChar R R'
hχ : χ.IsQuadratic
f : R' →+* R''
a : R
⊢ (χ.ringHomComp f) a = 0 ∨ (χ.ringHomComp f) a = 1 ∨ (χ.ringHomComp f) a = -1
state_after: no goals
Theorem: lipschitzOnWith_iff_dist_le_mul
File: Mathlib/Topology/MetricSpace/Lipschitz.lean

tactic: simp only [LipschitzOnWith, edist_nndist, dist_nndist]
state_before: α : Type u
β : Type v
γ : Type w
ι : Type x
inst✝¹ : PseudoMetricSpace α
inst✝ : PseudoMetricSpace β
K : ℝ≥0
s : Set α
f : α → β
⊢ LipschitzOnWith K f s ↔ ∀ x ∈ s, ∀ y ∈ s, dist (f x) (f y) ≤ ↑K * dist x y
state_after: α : Type u
β : Type v
γ : Type w
ι : Type x
inst✝¹ : PseudoMetricSpace α
inst✝ : PseudoMetricSpace β
K : ℝ≥0
s : Set α
f : α → β
⊢ (∀ ⦃x : α⦄, x ∈ s → ∀ ⦃y : α⦄, y ∈ s → ↑(nndist (f x) (f y)) ≤ ↑K * ↑(nndist x y)) ↔
    ∀ x ∈ s, ∀ y ∈ s, ↑(nndist (f x) (f y)) ≤ ↑K * ↑(nndist x y)

tactic: norm_cast
state_before: α : Type u
β : Type v
γ : Type w
ι : Type x
inst✝¹ : PseudoMetricSpace α
inst✝ : PseudoMetricSpace β
K : ℝ≥0
s : Set α
f : α → β
⊢ (∀ ⦃x : α⦄, x ∈ s → ∀ ⦃y : α⦄, y ∈ s → ↑(nndist (f x) (f y)) ≤ ↑K * ↑(nndist x y)) ↔
    ∀ x ∈ s, ∀ y ∈ s, ↑(nndist (f x) (f y)) ≤ ↑K * ↑(nndist x y)
state_after: no goals
Theorem: SmoothBumpFunction.eventuallyEq_one
File: Mathlib/Geometry/Manifold/BumpFunction.lean

tactic: rw [dist_self]
state_before: E : Type uE
inst✝⁶ : NormedAddCommGroup E
inst✝⁵ : NormedSpace ℝ E
inst✝⁴ : FiniteDimensional ℝ E
H : Type uH
inst✝³ : TopologicalSpace H
I : ModelWithCorners ℝ E H
M : Type uM
inst✝² : TopologicalSpace M
inst✝¹ : ChartedSpace H M
inst✝ : SmoothManifoldWithCorners I M
c : M
f : SmoothBumpFunction I c
x : M
⊢ dist (↑(extChartAt I c) c) (↑(extChartAt I c) c) < f.rIn
state_after: E : Type uE
inst✝⁶ : NormedAddCommGroup E
inst✝⁵ : NormedSpace ℝ E
inst✝⁴ : FiniteDimensional ℝ E
H : Type uH
inst✝³ : TopologicalSpace H
I : ModelWithCorners ℝ E H
M : Type uM
inst✝² : TopologicalSpace M
inst✝¹ : ChartedSpace H M
inst✝ : SmoothManifoldWithCorners I M
c : M
f : SmoothBumpFunction I c
x : M
⊢ 0 < f.rIn

tactic: exact f.rIn_pos
state_before: E : Type uE
inst✝⁶ : NormedAddCommGroup E
inst✝⁵ : NormedSpace ℝ E
inst✝⁴ : FiniteDimensional ℝ E
H : Type uH
inst✝³ : TopologicalSpace H
I : ModelWithCorners ℝ E H
M : Type uM
inst✝² : TopologicalSpace M
inst✝¹ : ChartedSpace H M
inst✝ : SmoothManifoldWithCorners I M
c : M
f : SmoothBumpFunction I c
x : M
⊢ 0 < f.rIn
state_after: no goals
Theorem: quotient_norm_neg
File: Mathlib/Analysis/Normed/Group/Quotient.lean

tactic: simp only [AddSubgroup.quotient_norm_eq]
state_before: M : Type u_1
N : Type u_2
inst✝¹ : SeminormedAddCommGroup M
inst✝ : SeminormedAddCommGroup N
S : AddSubgroup M
x : M ⧸ S
⊢ ‖-x‖ = ‖x‖
state_after: M : Type u_1
N : Type u_2
inst✝¹ : SeminormedAddCommGroup M
inst✝ : SeminormedAddCommGroup N
S : AddSubgroup M
x : M ⧸ S
⊢ sInf (norm '' {m | ↑m = -x}) = sInf (norm '' {m | ↑m = x})

tactic: congr 1 with r
state_before: M : Type u_1
N : Type u_2
inst✝¹ : SeminormedAddCommGroup M
inst✝ : SeminormedAddCommGroup N
S : AddSubgroup M
x : M ⧸ S
⊢ sInf (norm '' {m | ↑m = -x}) = sInf (norm '' {m | ↑m = x})
state_after: case e_a.h
M : Type u_1
N : Type u_2
inst✝¹ : SeminormedAddCommGroup M
inst✝ : SeminormedAddCommGroup N
S : AddSubgroup M
x : M ⧸ S
r : ℝ
⊢ r ∈ norm '' {m | ↑m = -x} ↔ r ∈ norm '' {m | ↑m = x}

tactic: constructor <;> { rintro ⟨m, hm, rfl⟩; use -m; simpa [neg_eq_iff_eq_neg] using hm }
state_before: case e_a.h
M : Type u_1
N : Type u_2
inst✝¹ : SeminormedAddCommGroup M
inst✝ : SeminormedAddCommGroup N
S : AddSubgroup M
x : M ⧸ S
r : ℝ
⊢ r ∈ norm '' {m | ↑m = -x} ↔ r ∈ norm '' {m | ↑m = x}
state_after: no goals

tactic: rintro ⟨m, hm, rfl⟩
state_before: case e_a.h.mpr
M : Type u_1
N : Type u_2
inst✝¹ : SeminormedAddCommGroup M
inst✝ : SeminormedAddCommGroup N
S : AddSubgroup M
x : M ⧸ S
r : ℝ
⊢ r ∈ norm '' {m | ↑m = x} → r ∈ norm '' {m | ↑m = -x}
state_after: case e_a.h.mpr.intro.intro
M : Type u_1
N : Type u_2
inst✝¹ : SeminormedAddCommGroup M
inst✝ : SeminormedAddCommGroup N
S : AddSubgroup M
x : M ⧸ S
m : M
hm : m ∈ {m | ↑m = x}
⊢ ‖m‖ ∈ norm '' {m | ↑m = -x}

tactic: use -m
state_before: case e_a.h.mpr.intro.intro
M : Type u_1
N : Type u_2
inst✝¹ : SeminormedAddCommGroup M
inst✝ : SeminormedAddCommGroup N
S : AddSubgroup M
x : M ⧸ S
m : M
hm : m ∈ {m | ↑m = x}
⊢ ‖m‖ ∈ norm '' {m | ↑m = -x}
state_after: case h
M : Type u_1
N : Type u_2
inst✝¹ : SeminormedAddCommGroup M
inst✝ : SeminormedAddCommGroup N
S : AddSubgroup M
x : M ⧸ S
m : M
hm : m ∈ {m | ↑m = x}
⊢ -m ∈ {m | ↑m = -x} ∧ ‖-m‖ = ‖m‖

tactic: simpa [neg_eq_iff_eq_neg] using hm
state_before: case h
M : Type u_1
N : Type u_2
inst✝¹ : SeminormedAddCommGroup M
inst✝ : SeminormedAddCommGroup N
S : AddSubgroup M
x : M ⧸ S
m : M
hm : m ∈ {m | ↑m = x}
⊢ -m ∈ {m | ↑m = -x} ∧ ‖-m‖ = ‖m‖
state_after: no goals
Theorem: MeasureTheory.AEEqFun.coeFn_comp
File: Mathlib/MeasureTheory/Function/AEEqFun.lean

tactic: rw [comp_eq_mk]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝³ : MeasurableSpace α
μ ν : Measure α
inst✝² : TopologicalSpace β
inst✝¹ : TopologicalSpace γ
inst✝ : TopologicalSpace δ
g : β → γ
hg : Continuous g
f : α →ₘ[μ] β
⊢ ↑(comp g hg f) =ᶠ[ae μ] g ∘ ↑f
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝³ : MeasurableSpace α
μ ν : Measure α
inst✝² : TopologicalSpace β
inst✝¹ : TopologicalSpace γ
inst✝ : TopologicalSpace δ
g : β → γ
hg : Continuous g
f : α →ₘ[μ] β
⊢ ↑(mk (g ∘ ↑f) ⋯) =ᶠ[ae μ] g ∘ ↑f

tactic: apply coeFn_mk
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝³ : MeasurableSpace α
μ ν : Measure α
inst✝² : TopologicalSpace β
inst✝¹ : TopologicalSpace γ
inst✝ : TopologicalSpace δ
g : β → γ
hg : Continuous g
f : α →ₘ[μ] β
⊢ ↑(mk (g ∘ ↑f) ⋯) =ᶠ[ae μ] g ∘ ↑f
state_after: no goals
Theorem: CategoryTheory.Limits.WidePullback.π_arrow
File: Mathlib/CategoryTheory/Limits/Shapes/WidePullbacks.lean

tactic: apply limit.w (WidePullbackShape.wideCospan _ _ _) (WidePullbackShape.Hom.term j)
state_before: J : Type w
C✝ : Type u
inst✝² : Category.{v, u} C✝
C : Type u
inst✝¹ : Category.{v, u} C
B : C
objs : J → C
arrows : (j : J) → objs j ⟶ B
inst✝ : HasWidePullback B objs arrows
j : J
⊢ π arrows j ≫ arrows j = base arrows
state_after: no goals
Theorem: Metric.inseparable_iff
File: Mathlib/Topology/MetricSpace/Pseudo/Defs.lean

tactic: rw [EMetric.inseparable_iff, edist_nndist, dist_nndist, ENNReal.coe_eq_zero, NNReal.coe_eq_zero]
state_before: α : Type u
β : Type v
X : Type u_1
ι : Type u_2
inst✝ : PseudoMetricSpace α
x y : α
⊢ Inseparable x y ↔ dist x y = 0
state_after: no goals
Theorem: Subgroup.relindex_self
File: Mathlib/GroupTheory/Index.lean

tactic: rw [relindex, subgroupOf_self, index_top]
state_before: G : Type u_1
inst✝ : Group G
H K L : Subgroup G
⊢ H.relindex H = 1
state_after: no goals
Theorem: WithTop.mul_eq_top_iff
File: Mathlib/Algebra/Order/Ring/WithTop.lean

tactic: rw [mul_def]
state_before: α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : MulZeroClass α
a b : WithTop α
⊢ a * b = ⊤ ↔ a ≠ 0 ∧ b = ⊤ ∨ a = ⊤ ∧ b ≠ 0
state_after: α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : MulZeroClass α
a b : WithTop α
⊢ (if a = 0 ∨ b = 0 then 0 else map₂ (fun x x_1 => x * x_1) a b) = ⊤ ↔ a ≠ 0 ∧ b = ⊤ ∨ a = ⊤ ∧ b ≠ 0

tactic: aesop
state_before: α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : MulZeroClass α
a b : WithTop α
⊢ (if a = 0 ∨ b = 0 then 0 else map₂ (fun x x_1 => x * x_1) a b) = ⊤ ↔ a ≠ 0 ∧ b = ⊤ ∨ a = ⊤ ∧ b ≠ 0
state_after: no goals
Theorem: Complex.closure_reProdIm
File: Mathlib/Analysis/Complex/ReImTopology.lean

tactic: simpa only [← preimage_eq_preimage equivRealProdCLM.symm.toHomeomorph.surjective,
  equivRealProdCLM.symm.toHomeomorph.preimage_closure] using @closure_prod_eq _ _ _ _ s t
state_before: s t : Set ℝ
⊢ closure (s ×ℂ t) = closure s ×ℂ closure t
state_after: no goals
Theorem: RingHom.domain_nontrivial
File: Mathlib/Algebra/Ring/Hom/Defs.lean

tactic: rw [h, map_zero]
state_before: F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
x✝¹ : NonAssocSemiring α
x✝ : NonAssocSemiring β
f : α →+* β
x y : α
inst✝ : Nontrivial β
h : 1 = 0
⊢ f 1 = 0
state_after: no goals
Theorem: UpperHalfPlane.zero_at_im_infty
File: Mathlib/Analysis/Complex/UpperHalfPlane/FunctionsBoundedAtInfty.lean

tactic: simp only [true_and, mem_closedBall_zero_iff]
state_before: f : ℍ → ℂ
⊢ (∀ (ib : ℝ), 0 < ib → ∃ ia, True ∧ ∀ x ∈ im ⁻¹' Set.Ici ia, f x ∈ Metric.closedBall 0 ib) ↔
    ∀ (ε : ℝ), 0 < ε → ∃ A, ∀ (z : ℍ), A ≤ z.im → Complex.abs (f z) ≤ ε
state_after: f : ℍ → ℂ
⊢ (∀ (ib : ℝ), 0 < ib → ∃ ia, ∀ x ∈ im ⁻¹' Set.Ici ia, ‖f x‖ ≤ ib) ↔
    ∀ (ε : ℝ), 0 < ε → ∃ A, ∀ (z : ℍ), A ≤ z.im → Complex.abs (f z) ≤ ε

tactic: rfl
state_before: f : ℍ → ℂ
⊢ (∀ (ib : ℝ), 0 < ib → ∃ ia, ∀ x ∈ im ⁻¹' Set.Ici ia, ‖f x‖ ≤ ib) ↔
    ∀ (ε : ℝ), 0 < ε → ∃ A, ∀ (z : ℍ), A ≤ z.im → Complex.abs (f z) ≤ ε
state_after: no goals
Theorem: Polynomial.dickson_two
File: Mathlib/RingTheory/Polynomial/Dickson.lean

tactic: simp only [dickson, sq]
state_before: R : Type u_1
S : Type u_2
inst✝¹ : CommRing R
inst✝ : CommRing S
k : ℕ
a : R
⊢ dickson k a 2 = X ^ 2 - C a * (3 - ↑k)
state_after: no goals
Theorem: Batteries.UnionFind.equiv_rootD_r
File: .lake/packages/batteries/Batteries/Data/UnionFind/Lemmas.lean

tactic: simp [Equiv, rootD_rootD]
state_before: self : UnionFind
a b : Nat
⊢ self.Equiv a (self.rootD b) ↔ self.Equiv a b
state_after: no goals
Theorem: Polynomial.natDegree_modByMonic_lt
File: Mathlib/Algebra/Polynomial/Div.lean

tactic: by_cases hpq : p %ₘ q = 0
state_before: R : Type u
S : Type v
T : Type w
A : Type z
a b : R
n : ℕ
inst✝ : Ring R
p✝ q✝ p q : R[X]
hmq : q.Monic
hq : q ≠ 1
⊢ (p %ₘ q).natDegree < q.natDegree
state_after: case pos
R : Type u
S : Type v
T : Type w
A : Type z
a b : R
n : ℕ
inst✝ : Ring R
p✝ q✝ p q : R[X]
hmq : q.Monic
hq : q ≠ 1
hpq : p %ₘ q = 0
⊢ (p %ₘ q).natDegree < q.natDegree

case neg
R : Type u
S : Type v
T : Type w
A : Type z
a b : R
n : ℕ
inst✝ : Ring R
p✝ q✝ p q : R[X]
hmq : q.Monic
hq : q ≠ 1
hpq : ¬p %ₘ q = 0
⊢ (p %ₘ q).natDegree < q.natDegree

tactic: rw [hpq, natDegree_zero, Nat.pos_iff_ne_zero]
state_before: case pos
R : Type u
S : Type v
T : Type w
A : Type z
a b : R
n : ℕ
inst✝ : Ring R
p✝ q✝ p q : R[X]
hmq : q.Monic
hq : q ≠ 1
hpq : p %ₘ q = 0
⊢ (p %ₘ q).natDegree < q.natDegree
state_after: case pos
R : Type u
S : Type v
T : Type w
A : Type z
a b : R
n : ℕ
inst✝ : Ring R
p✝ q✝ p q : R[X]
hmq : q.Monic
hq : q ≠ 1
hpq : p %ₘ q = 0
⊢ q.natDegree ≠ 0

tactic: contrapose! hq
state_before: case pos
R : Type u
S : Type v
T : Type w
A : Type z
a b : R
n : ℕ
inst✝ : Ring R
p✝ q✝ p q : R[X]
hmq : q.Monic
hq : q ≠ 1
hpq : p %ₘ q = 0
⊢ q.natDegree ≠ 0
state_after: case pos
R : Type u
S : Type v
T : Type w
A : Type z
a b : R
n : ℕ
inst✝ : Ring R
p✝ q✝ p q : R[X]
hmq : q.Monic
hpq : p %ₘ q = 0
hq : q.natDegree = 0
⊢ q = 1

tactic: exact eq_one_of_monic_natDegree_zero hmq hq
state_before: case pos
R : Type u
S : Type v
T : Type w
A : Type z
a b : R
n : ℕ
inst✝ : Ring R
p✝ q✝ p q : R[X]
hmq : q.Monic
hpq : p %ₘ q = 0
hq : q.natDegree = 0
⊢ q = 1
state_after: no goals

tactic: haveI := Nontrivial.of_polynomial_ne hpq
state_before: case neg
R : Type u
S : Type v
T : Type w
A : Type z
a b : R
n : ℕ
inst✝ : Ring R
p✝ q✝ p q : R[X]
hmq : q.Monic
hq : q ≠ 1
hpq : ¬p %ₘ q = 0
⊢ (p %ₘ q).natDegree < q.natDegree
state_after: case neg
R : Type u
S : Type v
T : Type w
A : Type z
a b : R
n : ℕ
inst✝ : Ring R
p✝ q✝ p q : R[X]
hmq : q.Monic
hq : q ≠ 1
hpq : ¬p %ₘ q = 0
this : Nontrivial R
⊢ (p %ₘ q).natDegree < q.natDegree

tactic: exact natDegree_lt_natDegree hpq (degree_modByMonic_lt p hmq)
state_before: case neg
R : Type u
S : Type v
T : Type w
A : Type z
a b : R
n : ℕ
inst✝ : Ring R
p✝ q✝ p q : R[X]
hmq : q.Monic
hq : q ≠ 1
hpq : ¬p %ₘ q = 0
this : Nontrivial R
⊢ (p %ₘ q).natDegree < q.natDegree
state_after: no goals
Theorem: ArithmeticFunction.const_one_eq_zeta
File: Mathlib/NumberTheory/LSeries/Dirichlet.lean

tactic: simp only [Pi.one_apply, zeta_apply, hn, ↓reduceIte, cast_one]
state_before: R : Type u_1
inst✝ : Semiring R
n : ℕ
hn : n ≠ 0
⊢ 1 n = ↑((fun x => ζ x) n)
state_after: no goals
Theorem: Multiset.revzip_powersetAux_perm_aux'
File: Mathlib/Data/Multiset/Powerset.lean

tactic: haveI := Classical.decEq α
state_before: α : Type u_1
l : List α
⊢ (powersetAux l).revzip ~ (powersetAux' l).revzip
state_after: α : Type u_1
l : List α
this : DecidableEq α
⊢ (powersetAux l).revzip ~ (powersetAux' l).revzip

tactic: rw [revzip_powersetAux_lemma l revzip_powersetAux, revzip_powersetAux_lemma l revzip_powersetAux']
state_before: α : Type u_1
l : List α
this : DecidableEq α
⊢ (powersetAux l).revzip ~ (powersetAux' l).revzip
state_after: α : Type u_1
l : List α
this : DecidableEq α
⊢ List.map (fun x => (x, ↑l - x)) (powersetAux l) ~ List.map (fun x => (x, ↑l - x)) (powersetAux' l)

tactic: exact powersetAux_perm_powersetAux'.map _
state_before: α : Type u_1
l : List α
this : DecidableEq α
⊢ List.map (fun x => (x, ↑l - x)) (powersetAux l) ~ List.map (fun x => (x, ↑l - x)) (powersetAux' l)
state_after: no goals
Theorem: Nat.add_div_le_add_div
File: Mathlib/Data/Nat/ModEq.lean

tactic: simp [hc0]
state_before: m n a✝ b✝ c✝ d a b c : ℕ
hc0 : c = 0
⊢ a / c + b / c ≤ (a + b) / c
state_after: no goals

tactic: rw [Nat.add_div (Nat.pos_of_ne_zero hc0)]
state_before: m n a✝ b✝ c✝ d a b c : ℕ
hc0 : ¬c = 0
⊢ a / c + b / c ≤ (a + b) / c
state_after: m n a✝ b✝ c✝ d a b c : ℕ
hc0 : ¬c = 0
⊢ a / c + b / c ≤ a / c + b / c + if c ≤ a % c + b % c then 1 else 0

tactic: exact Nat.le_add_right _ _
state_before: m n a✝ b✝ c✝ d a b c : ℕ
hc0 : ¬c = 0
⊢ a / c + b / c ≤ a / c + b / c + if c ≤ a % c + b % c then 1 else 0
state_after: no goals