ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: IsDedekindDomain.HeightOneSpectrum.intValuation_le_one
File: Mathlib/RingTheory/DedekindDomain/AdicValuation.lean

Proof steps:
state_before: R : Type u_1
inst✝⁴ : CommRing R
inst✝³ : IsDedekindDomain R
K : Type u_2
inst✝² : Field K
inst✝¹ : Algebra R K
inst✝ : IsFractionRing R K
v : HeightOneSpectrum R
x : R
⊢ v.intValuationDef x ≤ 1
state_after: R : Type u_1
inst✝⁴ : CommRing R
inst✝³ : IsDedekindDomain R
K : Type u_2
inst✝² : Field K
inst✝¹ : Algebra R K
inst✝ : IsFractionRing R K
v : HeightOneSpectrum R
x : R
⊢ (if x = 0 then 0 else ↑(ofAdd (-↑((Associates.mk v.asIdeal).count (Associates.mk (Ideal.span {x})).factors)))) ≤ 1
tactic: rw [intValuationDef]
state_before: R : Type u_1
inst✝⁴ : CommRing R
inst✝³ : IsDedekindDomain R
K : Type u_2
inst✝² : Field K
inst✝¹ : Algebra R K
inst✝ : IsFractionRing R K
v : HeightOneSpectrum R
x : R
⊢ (if x = 0 then 0 else ↑(ofAdd (-↑((Associates.mk v.asIdeal).count (Associates.mk (Ideal.span {x})).factors)))) ≤ 1
state_after: case pos
R : Type u_1
inst✝⁴ : CommRing R
inst✝³ : IsDedekindDomain R
K : Type u_2
inst✝² : Field K
inst✝¹ : Algebra R K
inst✝ : IsFractionRing R K
v : HeightOneSpectrum R
x : R
hx : x = 0
⊢ (if x = 0 then 0 else ↑(ofAdd (-↑((Associates.mk v.asIdeal).count (Associates.mk (Ideal.span {x})).factors)))) ≤ 1

case neg
R : Type u_1
inst✝⁴ : CommRing R
inst✝³ : IsDedekindDomain R
K : Type u_2
inst✝² : Field K
inst✝¹ : Algebra R K
inst✝ : IsFractionRing R K
v : HeightOneSpectrum R
x : R
hx : ¬x = 0
⊢ (if x = 0 then 0 else ↑(ofAdd (-↑((Associates.mk v.asIdeal).count (Associates.mk (Ideal.span {x})).factors)))) ≤ 1
tactic: by_cases hx : x = 0
Theorem: DFinsupp.add_eq_zero_iff
File: Mathlib/Data/DFinsupp/Order.lean

Proof steps:
state_before: ι : Type u_1
α : ι → Type u_2
inst✝ : (i : ι) → CanonicallyOrderedAddCommMonoid (α i)
f g : Π₀ (i : ι), α i
⊢ f + g = 0 ↔ f = 0 ∧ g = 0
state_after: no goals
tactic: simp [DFunLike.ext_iff, forall_and]
Theorem: add_pow_expChar_pow_of_commute
File: Mathlib/Algebra/CharP/ExpChar.lean

Proof steps:
state_before: R : Type u
inst✝ : Semiring R
q : ℕ
hR : ExpChar R q
n : ℕ
x y : R
h : Commute x y
⊢ (x + y) ^ q ^ n = x ^ q ^ n + y ^ q ^ n
state_after: case zero
R : Type u
inst✝¹ : Semiring R
n : ℕ
x y : R
h : Commute x y
inst✝ : CharZero R
⊢ (x + y) ^ 1 ^ n = x ^ 1 ^ n + y ^ 1 ^ n

case prime
R : Type u
inst✝ : Semiring R
q n : ℕ
x y : R
h : Commute x y
hprime : Nat.Prime q
hchar✝ : CharP R q
⊢ (x + y) ^ q ^ n = x ^ q ^ n + y ^ q ^ n
tactic: cases' hR with _ _ hprime _
state_before: case prime
R : Type u
inst✝ : Semiring R
q n : ℕ
x y : R
h : Commute x y
hprime : Nat.Prime q
hchar✝ : CharP R q
⊢ (x + y) ^ q ^ n = x ^ q ^ n + y ^ q ^ n
state_after: case prime
R : Type u
inst✝ : Semiring R
q n : ℕ
x y : R
h : Commute x y
hprime : Nat.Prime q
hchar✝ : CharP R q
this : Fact (Nat.Prime q)
⊢ (x + y) ^ q ^ n = x ^ q ^ n + y ^ q ^ n
tactic: haveI := Fact.mk hprime
state_before: case prime
R : Type u
inst✝ : Semiring R
q n : ℕ
x y : R
h : Commute x y
hprime : Nat.Prime q
hchar✝ : CharP R q
this : Fact (Nat.Prime q)
⊢ (x + y) ^ q ^ n = x ^ q ^ n + y ^ q ^ n
state_after: no goals
tactic: exact add_pow_char_pow_of_commute R x y h
Theorem: Compactum.join_distrib
File: Mathlib/Topology/Category/Compactum.lean

Proof steps:
state_before: X : Compactum
uux : Ultrafilter (Ultrafilter X.A)
⊢ X.str (X.join uux) = X.str (Ultrafilter.map X.str uux)
state_after: X : Compactum
uux : Ultrafilter (Ultrafilter X.A)
⊢ (β.μ.app X.A ≫ X.a) uux = X.str (Ultrafilter.map X.str uux)
tactic: change ((β ).μ.app _ ≫ X.a) _ = _
state_before: X : Compactum
uux : Ultrafilter (Ultrafilter X.A)
⊢ (β.μ.app X.A ≫ X.a) uux = X.str (Ultrafilter.map X.str uux)
state_after: X : Compactum
uux : Ultrafilter (Ultrafilter X.A)
⊢ (β.map X.a ≫ X.a) uux = X.str (Ultrafilter.map X.str uux)
tactic: rw [Monad.Algebra.assoc]
state_before: X : Compactum
uux : Ultrafilter (Ultrafilter X.A)
⊢ (β.map X.a ≫ X.a) uux = X.str (Ultrafilter.map X.str uux)
state_after: no goals
tactic: rfl
Theorem: Real.lt_rpow_iff_log_lt
File: Mathlib/Analysis/SpecialFunctions/Pow/Real.lean

Proof steps:
state_before: x y z : ℝ
n : ℕ
hx : 0 < x
hy : 0 < y
⊢ x < y ^ z ↔ log x < z * log y
state_after: no goals
tactic: rw [← Real.log_lt_log_iff hx (Real.rpow_pos_of_pos hy z), Real.log_rpow hy]
Theorem: Subgroup.subgroupOf_normalizer_eq
File: Mathlib/Algebra/Group/Subgroup/Basic.lean

Proof steps:
state_before: G : Type u_1
G' : Type u_2
G'' : Type u_3
inst✝⁴ : Group G
inst✝³ : Group G'
inst✝² : Group G''
A : Type u_4
inst✝¹ : AddGroup A
N✝ : Type u_5
inst✝ : Group N✝
f : G →* N✝
H N : Subgroup G
h : H.normalizer ≤ N
⊢ H.normalizer.subgroupOf N = (H.subgroupOf N).normalizer
state_after: case hf
G : Type u_1
G' : Type u_2
G'' : Type u_3
inst✝⁴ : Group G
inst✝³ : Group G'
inst✝² : Group G''
A : Type u_4
inst✝¹ : AddGroup A
N✝ : Type u_5
inst✝ : Group N✝
f : G →* N✝
H N : Subgroup G
h : H.normalizer ≤ N
⊢ Injective ⇑N.subtype

case h
G : Type u_1
G' : Type u_2
G'' : Type u_3
inst✝⁴ : Group G
inst✝³ : Group G'
inst✝² : Group G''
A : Type u_4
inst✝¹ : AddGroup A
N✝ : Type u_5
inst✝ : Group N✝
f : G →* N✝
H N : Subgroup G
h : H.normalizer ≤ N
⊢ H.normalizer ≤ N.subtype.range
tactic: apply comap_normalizer_eq_of_injective_of_le_range
state_before: case h
G : Type u_1
G' : Type u_2
G'' : Type u_3
inst✝⁴ : Group G
inst✝³ : Group G'
inst✝² : Group G''
A : Type u_4
inst✝¹ : AddGroup A
N✝ : Type u_5
inst✝ : Group N✝
f : G →* N✝
H N : Subgroup G
h : H.normalizer ≤ N
⊢ H.normalizer ≤ N.subtype.range
state_after: no goals
tactic: simpa
Theorem: UniformSpace.ext_iff
File: Mathlib/Topology/UniformSpace/Basic.lean

Proof steps:
state_before: α : Type ua
β : Type ub
γ : Type uc
δ : Type ud
ι : Sort u_1
u₁ u₂ : UniformSpace α
h : ∀ (s : Set (α × α)), s ∈ 𝓤 α ↔ s ∈ 𝓤 α
⊢ u₁ = u₂
state_after: case h.h
α : Type ua
β : Type ub
γ : Type uc
δ : Type ud
ι : Sort u_1
u₁ u₂ : UniformSpace α
h : ∀ (s : Set (α × α)), s ∈ 𝓤 α ↔ s ∈ 𝓤 α
s✝ : Set (α × α)
⊢ s✝ ∈ 𝓤 α ↔ s✝ ∈ 𝓤 α
tactic: ext
state_before: case h.h
α : Type ua
β : Type ub
γ : Type uc
δ : Type ud
ι : Sort u_1
u₁ u₂ : UniformSpace α
h : ∀ (s : Set (α × α)), s ∈ 𝓤 α ↔ s ∈ 𝓤 α
s✝ : Set (α × α)
⊢ s✝ ∈ 𝓤 α ↔ s✝ ∈ 𝓤 α
state_after: no goals
tactic: exact h _
Theorem: Finset.smul_zero_subset
File: Mathlib/Data/Finset/Pointwise.lean

Proof steps:
state_before: F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
inst✝² : Zero β
inst✝¹ : SMulZeroClass α β
inst✝ : DecidableEq β
s✝ : Finset α
t : Finset β
a : α
s : Finset α
⊢ s • 0 ⊆ 0
state_after: no goals
tactic: simp [subset_iff, mem_smul]
Theorem: Complex.ofReal_exp_ofReal_re
File: Mathlib/Data/Complex/Exponential.lean

Proof steps:
state_before: x✝ y : ℂ
x : ℝ
⊢ (starRingEnd ℂ) (cexp ↑x) = cexp ↑x
state_after: no goals
tactic: rw [← exp_conj, conj_ofReal]
Theorem: CategoryTheory.Presieve.factorsThruAlong_id
File: Mathlib/CategoryTheory/Sites/Coverage.lean

Proof steps:
state_before: C : Type u_2
D : Type ?u.1165
inst✝¹ : Category.{u_1, u_2} C
inst✝ : Category.{?u.1173, ?u.1165} D
X : C
S T : Presieve X
⊢ S.FactorsThruAlong T (𝟙 X) ↔ S.FactorsThru T
state_after: no goals
tactic: simp [FactorsThruAlong, FactorsThru]
Theorem: Polynomial.ofFinsupp_mul
File: Mathlib/Algebra/Polynomial/Basic.lean

Proof steps:
state_before: R : Type u
a✝ b✝ : R
m n : ℕ
inst✝ : Semiring R
p q : R[X]
a b : R[ℕ]
⊢ { toFinsupp := a * b } = Polynomial.mul { toFinsupp := a } { toFinsupp := b }
state_after: no goals
tactic: rw [mul_def]
Theorem: ModelWithCorners.symm_map_nhdsWithin_range
File: Mathlib/Geometry/Manifold/SmoothManifoldWithCorners.lean

Proof steps:
state_before: 𝕜 : Type u_1
inst✝³ : NontriviallyNormedField 𝕜
E : Type u_2
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace 𝕜 E
H : Type u_3
inst✝ : TopologicalSpace H
I : ModelWithCorners 𝕜 E H
x : H
⊢ map (↑I.symm) (𝓝[range ↑I] ↑I x) = 𝓝 x
state_after: no goals
tactic: rw [← I.map_nhds_eq, map_map, I.symm_comp_self, map_id]
Theorem: Set.not_injOn_infinite_finite_image
File: Mathlib/Data/Set/Finite.lean

Proof steps:
state_before: α : Type u
β : Type v
ι : Sort w
γ : Type x
s✝ t : Set α
f : α → β
s : Set α
h_inf : s.Infinite
h_fin : (f '' s).Finite
⊢ ¬InjOn f s
state_after: α : Type u
β : Type v
ι : Sort w
γ : Type x
s✝ t : Set α
f : α → β
s : Set α
h_inf : s.Infinite
h_fin : (f '' s).Finite
this : Finite ↑(f '' s)
⊢ ¬InjOn f s
tactic: have : Finite (f '' s) := finite_coe_iff.mpr h_fin
state_before: α : Type u
β : Type v
ι : Sort w
γ : Type x
s✝ t : Set α
f : α → β
s : Set α
h_inf : s.Infinite
h_fin : (f '' s).Finite
this : Finite ↑(f '' s)
⊢ ¬InjOn f s
state_after: α : Type u
β : Type v
ι : Sort w
γ : Type x
s✝ t : Set α
f : α → β
s : Set α
h_inf : s.Infinite
h_fin : (f '' s).Finite
this✝ : Finite ↑(f '' s)
this : Infinite ↑s
⊢ ¬InjOn f s
tactic: have : Infinite s := infinite_coe_iff.mpr h_inf
state_before: α : Type u
β : Type v
ι : Sort w
γ : Type x
s✝ t : Set α
f : α → β
s : Set α
h_inf : s.Infinite
h_fin : (f '' s).Finite
this✝ : Finite ↑(f '' s)
this : Infinite ↑s
⊢ ¬InjOn f s
state_after: α : Type u
β : Type v
ι : Sort w
γ : Type x
s✝ t : Set α
f : α → β
s : Set α
h_inf : s.Infinite
h_fin : (f '' s).Finite
this✝ : Finite ↑(f '' s)
this : Infinite ↑s
h : ¬Injective (codRestrict (s.restrict f) (f '' s) ⋯)
⊢ ¬InjOn f s
tactic: have h := not_injective_infinite_finite
            ((f '' s).codRestrict (s.restrict f) fun x => ⟨x, x.property, rfl⟩)
state_before: α : Type u
β : Type v
ι : Sort w
γ : Type x
s✝ t : Set α
f : α → β
s : Set α
h_inf : s.Infinite
h_fin : (f '' s).Finite
this✝ : Finite ↑(f '' s)
this : Infinite ↑s
h : ¬Injective (codRestrict (s.restrict f) (f '' s) ⋯)
⊢ ¬InjOn f s
state_after: α : Type u
β : Type v
ι : Sort w
γ : Type x
s✝ t : Set α
f : α → β
s : Set α
h_inf : s.Infinite
h_fin : (f '' s).Finite
this✝ : Finite ↑(f '' s)
this : Infinite ↑s
h : InjOn f s
⊢ Injective (codRestrict (s.restrict f) (f '' s) ⋯)
tactic: contrapose! h
state_before: α : Type u
β : Type v
ι : Sort w
γ : Type x
s✝ t : Set α
f : α → β
s : Set α
h_inf : s.Infinite
h_fin : (f '' s).Finite
this✝ : Finite ↑(f '' s)
this : Infinite ↑s
h : InjOn f s
⊢ Injective (codRestrict (s.restrict f) (f '' s) ⋯)
state_after: no goals
tactic: rwa [injective_codRestrict, ← injOn_iff_injective]
Theorem: CircleDeg1Lift.iterate_eq_of_map_eq_add_int
File: Mathlib/Dynamics/Circle/RotationNumber/TranslationNumber.lean

Proof steps:
state_before: f g : CircleDeg1Lift
x : ℝ
m : ℤ
h : f x = x + ↑m
n : ℕ
⊢ (⇑f)^[n] x = x + ↑n * ↑m
state_after: no goals
tactic: simpa only [nsmul_eq_mul, add_right_iterate] using (f.commute_add_int m).iterate_eq_of_map_eq n h
Theorem: Ideal.map_prodComm_prod
File: Mathlib/RingTheory/Ideal/Prod.lean

Proof steps:
state_before: R : Type u
S : Type v
inst✝¹ : Semiring R
inst✝ : Semiring S
I I' : Ideal R
J J' : Ideal S
⊢ map (↑RingEquiv.prodComm) (I.prod J) = J.prod I
state_after: R : Type u
S : Type v
inst✝¹ : Semiring R
inst✝ : Semiring S
I I' : Ideal R
J J' : Ideal S
⊢ (map (RingHom.fst S R) (map (↑RingEquiv.prodComm) (I.prod J))).prod
      (map (RingHom.snd S R) (map (↑RingEquiv.prodComm) (I.prod J))) =
    J.prod I
tactic: refine Trans.trans (ideal_prod_eq _) ?_
state_before: R : Type u
S : Type v
inst✝¹ : Semiring R
inst✝ : Semiring S
I I' : Ideal R
J J' : Ideal S
⊢ (map (RingHom.fst S R) (map (↑RingEquiv.prodComm) (I.prod J))).prod
      (map (RingHom.snd S R) (map (↑RingEquiv.prodComm) (I.prod J))) =
    J.prod I
state_after: no goals
tactic: simp [map_map]
Theorem: CompHaus.pullback_snd_eq
File: Mathlib/Topology/Category/CompHaus/Limits.lean

Proof steps:
state_before: X Y B : CompHaus
f : X ⟶ B
g : Y ⟶ B
⊢ pullback.snd f g = (pullbackIsoPullback f g).hom ≫ Limits.pullback.snd f g
state_after: X Y B : CompHaus
f : X ⟶ B
g : Y ⟶ B
⊢ pullback.snd f g =
    ((pullback.isLimit f g).conePointUniqueUpToIso (limit.isLimit (cospan f g))).hom ≫ Limits.pullback.snd f g
tactic: dsimp [pullbackIsoPullback]
state_before: X Y B : CompHaus
f : X ⟶ B
g : Y ⟶ B
⊢ pullback.snd f g =
    ((pullback.isLimit f g).conePointUniqueUpToIso (limit.isLimit (cospan f g))).hom ≫ Limits.pullback.snd f g
state_after: no goals
tactic: simp only [Limits.limit.conePointUniqueUpToIso_hom_comp, pullback.cone_pt, pullback.cone_π]
Theorem: AlgebraicGeometry.Scheme.Hom.appIso_inv_appLE
File: Mathlib/AlgebraicGeometry/OpenImmersion.lean

Proof steps:
state_before: C : Type u
inst✝¹ : Category.{v, u} C
X✝ Y✝ : Scheme
f✝ : X✝.Hom Y✝
H : IsOpenImmersion f✝
X Y : Scheme
f : X ⟶ Y
inst✝ : IsOpenImmersion f
U V : X.Opens
e : V ≤ f ⁻¹ᵁ f ''ᵁ U
⊢ V ≤ U
state_after: no goals
tactic: rwa [preimage_image_eq] at e
state_before: C : Type u
inst✝¹ : Category.{v, u} C
X✝ Y✝ : Scheme
f✝ : X✝.Hom Y✝
H : IsOpenImmersion f✝
X Y : Scheme
f : X ⟶ Y
inst✝ : IsOpenImmersion f
U V : X.Opens
e : V ≤ f ⁻¹ᵁ f ''ᵁ U
⊢ (appIso f U).inv ≫ appLE f (f ''ᵁ U) V e = X.presheaf.map (homOfLE ⋯).op
state_after: C : Type u
inst✝¹ : Category.{v, u} C
X✝ Y✝ : Scheme
f✝ : X✝.Hom Y✝
H : IsOpenImmersion f✝
X Y : Scheme
f : X ⟶ Y
inst✝ : IsOpenImmersion f
U V : X.Opens
e : V ≤ f ⁻¹ᵁ f ''ᵁ U
⊢ X.presheaf.map (eqToHom ⋯) ≫ X.presheaf.map (homOfLE e).op = X.presheaf.map (homOfLE ⋯).op
tactic: simp only [appLE, appIso_inv_app_assoc, eqToHom_op]
state_before: C : Type u
inst✝¹ : Category.{v, u} C
X✝ Y✝ : Scheme
f✝ : X✝.Hom Y✝
H : IsOpenImmersion f✝
X Y : Scheme
f : X ⟶ Y
inst✝ : IsOpenImmersion f
U V : X.Opens
e : V ≤ f ⁻¹ᵁ f ''ᵁ U
⊢ X.presheaf.map (eqToHom ⋯) ≫ X.presheaf.map (homOfLE e).op = X.presheaf.map (homOfLE ⋯).op
state_after: C : Type u
inst✝¹ : Category.{v, u} C
X✝ Y✝ : Scheme
f✝ : X✝.Hom Y✝
H : IsOpenImmersion f✝
X Y : Scheme
f : X ⟶ Y
inst✝ : IsOpenImmersion f
U V : X.Opens
e : V ≤ f ⁻¹ᵁ f ''ᵁ U
⊢ X.presheaf.map (eqToHom ⋯ ≫ (homOfLE e).op) = X.presheaf.map (homOfLE ⋯).op
tactic: rw [← Functor.map_comp]
state_before: C : Type u
inst✝¹ : Category.{v, u} C
X✝ Y✝ : Scheme
f✝ : X✝.Hom Y✝
H : IsOpenImmersion f✝
X Y : Scheme
f : X ⟶ Y
inst✝ : IsOpenImmersion f
U V : X.Opens
e : V ≤ f ⁻¹ᵁ f ''ᵁ U
⊢ X.presheaf.map (eqToHom ⋯ ≫ (homOfLE e).op) = X.presheaf.map (homOfLE ⋯).op
state_after: no goals
tactic: rfl
Theorem: CategoryTheory.ShortComplex.SnakeInput.L₀X₂ToP_comp_pullback_snd
File: Mathlib/Algebra/Homology/ShortComplex/SnakeLemma.lean

Proof steps:
state_before: C : Type u_1
inst✝¹ : Category.{u_2, u_1} C
inst✝ : Abelian C
S : SnakeInput C
⊢ S.L₀X₂ToP ≫ pullback.snd S.L₁.g S.v₀₁.τ₃ = S.L₀.g
state_after: no goals
tactic: simp
Theorem: RCLike.abs_im_le_norm
File: Mathlib/Analysis/RCLike/Basic.lean

Proof steps:
state_before: K : Type u_1
E : Type u_2
inst✝ : RCLike K
z✝ z : K
⊢ |im z| ≤ ‖z‖
state_after: K : Type u_1
E : Type u_2
inst✝ : RCLike K
z✝ z : K
⊢ im z * im z ≤ normSq z
tactic: rw [mul_self_le_mul_self_iff (abs_nonneg _) (norm_nonneg _), abs_mul_abs_self, mul_self_norm]
state_before: K : Type u_1
E : Type u_2
inst✝ : RCLike K
z✝ z : K
⊢ im z * im z ≤ normSq z
state_after: no goals
tactic: apply im_sq_le_normSq
Theorem: CategoryTheory.Limits.IsInitial.epi_to
File: Mathlib/CategoryTheory/Limits/Shapes/Terminal.lean

Proof steps:
state_before: C : Type u₁
inst✝ : Category.{v₁, u₁} C
X Y : C
t : IsInitial X
f : Y ⟶ X
⊢ Epi f
state_after: C : Type u₁
inst✝ : Category.{v₁, u₁} C
X Y : C
t : IsInitial X
f : Y ⟶ X
this : IsSplitEpi f
⊢ Epi f
tactic: haveI := t.isSplitEpi_to f
state_before: C : Type u₁
inst✝ : Category.{v₁, u₁} C
X Y : C
t : IsInitial X
f : Y ⟶ X
this : IsSplitEpi f
⊢ Epi f
state_after: no goals
tactic: infer_instance
Theorem: PowerSeries.rescale_rescale
File: Mathlib/RingTheory/PowerSeries/Basic.lean

Proof steps:
state_before: R : Type u_1
inst✝ : CommSemiring R
f : R⟦X⟧
a b : R
⊢ (rescale b) ((rescale a) f) = (rescale (a * b)) f
state_after: case h
R : Type u_1
inst✝ : CommSemiring R
f : R⟦X⟧
a b : R
n : ℕ
⊢ (coeff R n) ((rescale b) ((rescale a) f)) = (coeff R n) ((rescale (a * b)) f)
tactic: ext n
state_before: case h
R : Type u_1
inst✝ : CommSemiring R
f : R⟦X⟧
a b : R
n : ℕ
⊢ (coeff R n) ((rescale b) ((rescale a) f)) = (coeff R n) ((rescale (a * b)) f)
state_after: case h
R : Type u_1
inst✝ : CommSemiring R
f : R⟦X⟧
a b : R
n : ℕ
⊢ b ^ n * (a ^ n * (coeff R n) f) = (a * b) ^ n * (coeff R n) f
tactic: simp_rw [coeff_rescale]
state_before: case h
R : Type u_1
inst✝ : CommSemiring R
f : R⟦X⟧
a b : R
n : ℕ
⊢ b ^ n * (a ^ n * (coeff R n) f) = (a * b) ^ n * (coeff R n) f
state_after: no goals
tactic: rw [mul_pow, mul_comm _ (b ^ n), mul_assoc]
Theorem: Stream'.WSeq.map_id
File: Mathlib/Data/Seq/WSeq.lean

Proof steps:
state_before: α : Type u
β : Type v
γ : Type w
s : WSeq α
⊢ map id s = s
state_after: no goals
tactic: simp [map]
Theorem: Function.IsFixedPt.birkhoffSum_eq
File: Mathlib/Dynamics/BirkhoffSum/Basic.lean

Proof steps:
state_before: α : Type u_1
M : Type u_2
inst✝ : AddCommMonoid M
f : α → α
x : α
h : IsFixedPt f x
g : α → M
n : ℕ
⊢ birkhoffSum f g n x = n • g x
state_after: no goals
tactic: simp [birkhoffSum, (h.iterate _).eq]
Theorem: MeasureTheory.eLpNormEssSup_const_smul_le
File: Mathlib/MeasureTheory/Function/LpSeminorm/Basic.lean

Proof steps:
state_before: α : Type u_1
E : Type u_2
F : Type u_3
G : Type u_4
m m0 : MeasurableSpace α
p : ℝ≥0∞
q : ℝ
μ ν : Measure α
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedAddCommGroup F
inst✝⁵ : NormedAddCommGroup G
𝕜 : Type u_5
inst✝⁴ : NormedRing 𝕜
inst✝³ : MulActionWithZero 𝕜 E
inst✝² : MulActionWithZero 𝕜 F
inst✝¹ : BoundedSMul 𝕜 E
inst✝ : BoundedSMul 𝕜 F
c : 𝕜
f : α → F
x✝ : α
⊢ ‖(c • f) x✝‖₊ ≤ ‖c‖₊ * ‖f x✝‖₊
state_after: no goals
tactic: simp [nnnorm_smul_le]
Theorem: RatFunc.eval_zero
File: Mathlib/FieldTheory/RatFunc/AsPolynomial.lean

Proof steps:
state_before: K : Type u
inst✝¹ : Field K
L : Type u
inst✝ : Field L
f : K →+* L
a : L
⊢ eval f a 0 = 0
state_after: no goals
tactic: simp [eval]
Theorem: ModelWithCorners.prod_apply
File: Mathlib/Geometry/Manifold/SmoothManifoldWithCorners.lean

Proof steps:
state_before: 𝕜 : Type u
inst✝⁶ : NontriviallyNormedField 𝕜
E : Type v
inst✝⁵ : NormedAddCommGroup E
inst✝⁴ : NormedSpace 𝕜 E
H : Type w
inst✝³ : TopologicalSpace H
I : ModelWithCorners 𝕜 E H
E' : Type v'
inst✝² : NormedAddCommGroup E'
inst✝¹ : NormedSpace 𝕜 E'
H' : Type w'
inst✝ : TopologicalSpace H'
I' : ModelWithCorners 𝕜 E' H'
⊢ { toFun := fun x => (↑I x.1, ↑I' x.2), invFun := fun x => (↑I.symm x.1, ↑I'.symm x.2),
        source := {x | x.1 ∈ I.source ∧ x.2 ∈ I'.source}, target := __src✝.target, map_source' := ⋯, map_target' := ⋯,
        left_inv' := ⋯, right_inv' := ⋯ }.source =
    univ
state_after: no goals
tactic: simp only [setOf_true, mfld_simps]
Theorem: WeierstrassCurve.variableChange_c₄
File: Mathlib/AlgebraicGeometry/EllipticCurve/Weierstrass.lean

Proof steps:
state_before: R : Type u
inst✝ : CommRing R
W : WeierstrassCurve R
C : VariableChange R
⊢ (W.variableChange C).c₄ = ↑C.u⁻¹ ^ 4 * W.c₄
state_after: R : Type u
inst✝ : CommRing R
W : WeierstrassCurve R
C : VariableChange R
⊢ (↑C.u⁻¹ ^ 2 * (W.b₂ + 12 * C.r)) ^ 2 - 24 * (↑C.u⁻¹ ^ 4 * (W.b₄ + C.r * W.b₂ + 6 * C.r ^ 2)) =
    ↑C.u⁻¹ ^ 4 * (W.b₂ ^ 2 - 24 * W.b₄)
tactic: simp only [c₄, variableChange_b₂, variableChange_b₄]
state_before: R : Type u
inst✝ : CommRing R
W : WeierstrassCurve R
C : VariableChange R
⊢ (↑C.u⁻¹ ^ 2 * (W.b₂ + 12 * C.r)) ^ 2 - 24 * (↑C.u⁻¹ ^ 4 * (W.b₄ + C.r * W.b₂ + 6 * C.r ^ 2)) =
    ↑C.u⁻¹ ^ 4 * (W.b₂ ^ 2 - 24 * W.b₄)
state_after: no goals
tactic: ring1
Theorem: Multiset.prod_map_one
File: Mathlib/Algebra/BigOperators/Group/Multiset.lean

Proof steps:
state_before: F : Type u_1
ι : Type u_2
α : Type u_3
β : Type u_4
γ : Type u_5
inst✝¹ : CommMonoid α
inst✝ : CommMonoid β
s t : Multiset α
a : α
m : Multiset ι
f g : ι → α
⊢ (map (fun x => 1) m).prod = 1
state_after: no goals
tactic: rw [map_const', prod_replicate, one_pow]
Theorem: NumberField.Units.regulator_eq_det'
File: Mathlib/NumberTheory/NumberField/Units/Regulator.lean

Proof steps:
state_before: K : Type u_1
inst✝¹ : Field K
inst✝ : NumberField K
e : { w // w ≠ w₀ } ≃ Fin (rank K)
⊢ regulator K = |(Matrix.of fun i => (logEmbedding K) (fundSystem K (e i))).det|
state_after: K : Type u_1
inst✝¹ : Field K
inst✝ : NumberField K
e : { w // w ≠ w₀ } ≃ Fin (rank K)
⊢ |(Matrix.of fun x => ↑((logEmbeddingEquiv K) (Additive.ofMul ⟦fundSystem K (e x)⟧))).det| =
    |(Matrix.of fun i => (logEmbedding K) (fundSystem K (e i))).det|
tactic: simp_rw [regulator, Zlattice.covolume_eq_det _
    (((basisModTorsion K).map (logEmbeddingEquiv K)).reindex e.symm), Basis.coe_reindex,
    Function.comp, Basis.map_apply, ← fundSystem_mk, Equiv.symm_symm]
state_before: K : Type u_1
inst✝¹ : Field K
inst✝ : NumberField K
e : { w // w ≠ w₀ } ≃ Fin (rank K)
⊢ |(Matrix.of fun x => ↑((logEmbeddingEquiv K) (Additive.ofMul ⟦fundSystem K (e x)⟧))).det| =
    |(Matrix.of fun i => (logEmbedding K) (fundSystem K (e i))).det|
state_after: no goals
tactic: rfl
Theorem: LDL.diag_eq_lowerInv_conj
File: Mathlib/LinearAlgebra/Matrix/LDL.lean

Proof steps:
state_before: 𝕜 : Type u_1
inst✝⁴ : RCLike 𝕜
n : Type u_2
inst✝³ : LinearOrder n
inst✝² : IsWellOrder n fun x x_1 => x < x_1
inst✝¹ : LocallyFiniteOrderBot n
S : Matrix n n 𝕜
inst✝ : Fintype n
hS : S.PosDef
⊢ diag hS = lowerInv hS * S * (lowerInv hS)ᴴ
state_after: case a
𝕜 : Type u_1
inst✝⁴ : RCLike 𝕜
n : Type u_2
inst✝³ : LinearOrder n
inst✝² : IsWellOrder n fun x x_1 => x < x_1
inst✝¹ : LocallyFiniteOrderBot n
S : Matrix n n 𝕜
inst✝ : Fintype n
hS : S.PosDef
i j : n
⊢ diag hS i j = (lowerInv hS * S * (lowerInv hS)ᴴ) i j
tactic: ext i j
state_before: case a
𝕜 : Type u_1
inst✝⁴ : RCLike 𝕜
n : Type u_2
inst✝³ : LinearOrder n
inst✝² : IsWellOrder n fun x x_1 => x < x_1
inst✝¹ : LocallyFiniteOrderBot n
S : Matrix n n 𝕜
inst✝ : Fintype n
hS : S.PosDef
i j : n
⊢ diag hS i j = (lowerInv hS * S * (lowerInv hS)ᴴ) i j
state_after: case pos
𝕜 : Type u_1
inst✝⁴ : RCLike 𝕜
n : Type u_2
inst✝³ : LinearOrder n
inst✝² : IsWellOrder n fun x x_1 => x < x_1
inst✝¹ : LocallyFiniteOrderBot n
S : Matrix n n 𝕜
inst✝ : Fintype n
hS : S.PosDef
i j : n
hij : i = j
⊢ diag hS i j = (lowerInv hS * S * (lowerInv hS)ᴴ) i j

case neg
𝕜 : Type u_1
inst✝⁴ : RCLike 𝕜
n : Type u_2
inst✝³ : LinearOrder n
inst✝² : IsWellOrder n fun x x_1 => x < x_1
inst✝¹ : LocallyFiniteOrderBot n
S : Matrix n n 𝕜
inst✝ : Fintype n
hS : S.PosDef
i j : n
hij : ¬i = j
⊢ diag hS i j = (lowerInv hS * S * (lowerInv hS)ᴴ) i j
tactic: by_cases hij : i = j
Theorem: Stream'.WSeq.cons_congr
File: Mathlib/Data/Seq/WSeq.lean

Proof steps:
state_before: α : Type u
β : Type v
γ : Type w
s t : WSeq α
a : α
h : s ~ʷ t
⊢ cons a s ~ʷ cons a t
state_after: α : Type u
β : Type v
γ : Type w
s t : WSeq α
a : α
h : s ~ʷ t
⊢ LiftRel (fun x x_1 => x = x_1) (cons a s) (cons a t)
tactic: unfold Equiv
state_before: α : Type u
β : Type v
γ : Type w
s t : WSeq α
a : α
h : s ~ʷ t
⊢ LiftRel (fun x x_1 => x = x_1) (cons a s) (cons a t)
state_after: no goals
tactic: simpa using h