ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: integral_smul_const
File: Mathlib/MeasureTheory/Integral/SetIntegral.lean

Proof steps:
state_before: X : Type u_1
Y : Type u_2
E : Type u_3
F : Type u_4
inst✝¹⁰ : MeasurableSpace X
μ : Measure X
𝕜✝ : Type u_5
inst✝⁹ : RCLike 𝕜✝
inst✝⁸ : NormedAddCommGroup E
inst✝⁷ : NormedSpace 𝕜✝ E
inst✝⁶ : NormedAddCommGroup F
inst✝⁵ : NormedSpace 𝕜✝ F
p : ℝ≥0∞
inst✝⁴ : NormedSpace ℝ E
inst✝³ : NormedSpace ℝ F
𝕜 : Type u_6
inst✝² : RCLike 𝕜
inst✝¹ : NormedSpace 𝕜 E
inst✝ : CompleteSpace E
f : X → 𝕜
c : E
⊢ ∫ (x : X), f x • c ∂μ = (∫ (x : X), f x ∂μ) • c
state_after: case pos
X : Type u_1
Y : Type u_2
E : Type u_3
F : Type u_4
inst✝¹⁰ : MeasurableSpace X
μ : Measure X
𝕜✝ : Type u_5
inst✝⁹ : RCLike 𝕜✝
inst✝⁸ : NormedAddCommGroup E
inst✝⁷ : NormedSpace 𝕜✝ E
inst✝⁶ : NormedAddCommGroup F
inst✝⁵ : NormedSpace 𝕜✝ F
p : ℝ≥0∞
inst✝⁴ : NormedSpace ℝ E
inst✝³ : NormedSpace ℝ F
𝕜 : Type u_6
inst✝² : RCLike 𝕜
inst✝¹ : NormedSpace 𝕜 E
inst✝ : CompleteSpace E
f : X → 𝕜
c : E
hf : Integrable f μ
⊢ ∫ (x : X), f x • c ∂μ = (∫ (x : X), f x ∂μ) • c

case neg
X : Type u_1
Y : Type u_2
E : Type u_3
F : Type u_4
inst✝¹⁰ : MeasurableSpace X
μ : Measure X
𝕜✝ : Type u_5
inst✝⁹ : RCLike 𝕜✝
inst✝⁸ : NormedAddCommGroup E
inst✝⁷ : NormedSpace 𝕜✝ E
inst✝⁶ : NormedAddCommGroup F
inst✝⁵ : NormedSpace 𝕜✝ F
p : ℝ≥0∞
inst✝⁴ : NormedSpace ℝ E
inst✝³ : NormedSpace ℝ F
𝕜 : Type u_6
inst✝² : RCLike 𝕜
inst✝¹ : NormedSpace 𝕜 E
inst✝ : CompleteSpace E
f : X → 𝕜
c : E
hf : ¬Integrable f μ
⊢ ∫ (x : X), f x • c ∂μ = (∫ (x : X), f x ∂μ) • c
tactic: by_cases hf : Integrable f μ
Theorem: CochainComplex.HomComplex.Cochain.rightShift_add
File: Mathlib/Algebra/Homology/HomotopyCategory/HomComplexShift.lean

Proof steps:
state_before: C : Type u
inst✝³ : Category.{v, u} C
inst✝² : Preadditive C
R : Type u_1
inst✝¹ : Ring R
inst✝ : Linear R C
K L M : CochainComplex C ℤ
n : ℤ
γ γ₁ γ₂ : Cochain K L n
a n' : ℤ
hn' : n' + a = n
⊢ (γ₁ + γ₂).rightShift a n' hn' = γ₁.rightShift a n' hn' + γ₂.rightShift a n' hn'
state_after: case h
C : Type u
inst✝³ : Category.{v, u} C
inst✝² : Preadditive C
R : Type u_1
inst✝¹ : Ring R
inst✝ : Linear R C
K L M : CochainComplex C ℤ
n : ℤ
γ γ₁ γ₂ : Cochain K L n
a n' : ℤ
hn' : n' + a = n
p q : ℤ
hpq : p + n' = q
⊢ ((γ₁ + γ₂).rightShift a n' hn').v p q hpq = (γ₁.rightShift a n' hn' + γ₂.rightShift a n' hn').v p q hpq
tactic: ext p q hpq
state_before: case h
C : Type u
inst✝³ : Category.{v, u} C
inst✝² : Preadditive C
R : Type u_1
inst✝¹ : Ring R
inst✝ : Linear R C
K L M : CochainComplex C ℤ
n : ℤ
γ γ₁ γ₂ : Cochain K L n
a n' : ℤ
hn' : n' + a = n
p q : ℤ
hpq : p + n' = q
⊢ ((γ₁ + γ₂).rightShift a n' hn').v p q hpq = (γ₁.rightShift a n' hn' + γ₂.rightShift a n' hn').v p q hpq
state_after: case h
C : Type u
inst✝³ : Category.{v, u} C
inst✝² : Preadditive C
R : Type u_1
inst✝¹ : Ring R
inst✝ : Linear R C
K L M : CochainComplex C ℤ
n : ℤ
γ γ₁ γ₂ : Cochain K L n
a n' : ℤ
hn' : n' + a = n
p q : ℤ
hpq : p + n' = q
⊢ ((γ₁ + γ₂).rightShift a n' hn').v p q hpq = (γ₁.rightShift a n' hn').v p q hpq + (γ₂.rightShift a n' hn').v p q hpq
tactic: dsimp
state_before: case h
C : Type u
inst✝³ : Category.{v, u} C
inst✝² : Preadditive C
R : Type u_1
inst✝¹ : Ring R
inst✝ : Linear R C
K L M : CochainComplex C ℤ
n : ℤ
γ γ₁ γ₂ : Cochain K L n
a n' : ℤ
hn' : n' + a = n
p q : ℤ
hpq : p + n' = q
⊢ ((γ₁ + γ₂).rightShift a n' hn').v p q hpq = (γ₁.rightShift a n' hn').v p q hpq + (γ₂.rightShift a n' hn').v p q hpq
state_after: no goals
tactic: simp only [rightShift_v _ a n' hn' p q hpq _ rfl, add_v, add_comp]
Theorem: AddCircle.norm_half_period_eq
File: Mathlib/Analysis/Normed/Group/AddCircle.lean

Proof steps:
state_before: p : ℝ
⊢ ‖↑(p / 2)‖ = |p| / 2
state_after: case inl

⊢ ‖↑(0 / 2)‖ = |0| / 2

case inr
p : ℝ
hp : p ≠ 0
⊢ ‖↑(p / 2)‖ = |p| / 2
tactic: rcases eq_or_ne p 0 with (rfl | hp)
state_before: case inr
p : ℝ
hp : p ≠ 0
⊢ ‖↑(p / 2)‖ = |p| / 2
state_after: no goals
tactic: rw [norm_eq, ← mul_div_assoc, inv_mul_cancel hp, one_div, round_two_inv, Int.cast_one,
    one_mul, (by linarith : p / 2 - p = -(p / 2)), abs_neg, abs_div, abs_two]
Theorem: MeasureTheory.Measure.mapₗ_eq_zero_iff
File: Mathlib/MeasureTheory/Measure/MeasureSpace.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
ι : Type u_5
R : Type u_6
R' : Type u_7
m0 : MeasurableSpace α
inst✝¹ : MeasurableSpace β
inst✝ : MeasurableSpace γ
μ μ₁ μ₂ μ₃ ν ν' ν₁ ν₂ : Measure α
s s' t : Set α
f : α → β
hf : Measurable f
⊢ (mapₗ f) μ = 0 ↔ μ = 0
state_after: no goals
tactic: rw [mapₗ_apply_of_measurable hf, map_eq_zero_iff hf.aemeasurable]
Theorem: CategoryTheory.Iso.inv_hom_id_triangle_hom₂
File: Mathlib/CategoryTheory/Triangulated/Basic.lean

Proof steps:
state_before: C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : HasShift C ℤ
T₁ T₂ T₃ A B : Triangle C
e : A ≅ B
⊢ e.inv.hom₂ ≫ e.hom.hom₂ = 𝟙 B.obj₂
state_after: no goals
tactic: rw [← comp_hom₂, e.inv_hom_id, id_hom₂]
Theorem: Combinatorics.Line.toSubspace_isMono
File: Mathlib/Combinatorics/HalesJewett.lean

Proof steps:
state_before: η : Type u_1
α : Type u_2
ι : Type u_3
κ : Type u_4
l✝ : Line α ι
i : ι
a x : α
l : Line (η → α) ι
C : (ι × η → α) → κ
⊢ Subspace.IsMono C l.toSubspace ↔
    IsMono
      (fun x =>
        C fun x_1 =>
          match x_1 with
          | (i, e) => x i e)
      l
state_after: no goals
tactic: simp [Subspace.IsMono, IsMono, funext (toSubspace_apply _ _)]
Theorem: Tuple.comp_perm_comp_sort_eq_comp_sort
File: Mathlib/Data/Fin/Tuple/Sort.lean

Proof steps:
state_before: n : ℕ
α : Type u_1
inst✝ : LinearOrder α
f : Fin n → α
σ : Equiv.Perm (Fin n)
⊢ (f ∘ ⇑σ) ∘ ⇑(sort (f ∘ ⇑σ)) = f ∘ ⇑(sort f)
state_after: n : ℕ
α : Type u_1
inst✝ : LinearOrder α
f : Fin n → α
σ : Equiv.Perm (Fin n)
⊢ f ∘ ⇑(σ * sort (f ∘ ⇑σ)) = f ∘ ⇑(sort f)
tactic: rw [Function.comp.assoc, ← Equiv.Perm.coe_mul]
state_before: n : ℕ
α : Type u_1
inst✝ : LinearOrder α
f : Fin n → α
σ : Equiv.Perm (Fin n)
⊢ f ∘ ⇑(σ * sort (f ∘ ⇑σ)) = f ∘ ⇑(sort f)
state_after: no goals
tactic: exact unique_monotone (monotone_sort (f ∘ σ)) (monotone_sort f)
Theorem: Finset.noncommProd_toFinset
File: Mathlib/Data/Finset/NoncommProd.lean

Proof steps:
state_before: F : Type u_1
ι : Type u_2
α : Type u_3
β : Type u_4
γ : Type u_5
f✝ : α → β → β
op : α → α → α
inst✝² : Monoid β
inst✝¹ : Monoid γ
inst✝ : DecidableEq α
l : List α
f : α → β
comm : (↑l.toFinset).Pairwise fun a b => Commute (f a) (f b)
hl : l.Nodup
⊢ l.toFinset.noncommProd f comm = (List.map f l).prod
state_after: F : Type u_1
ι : Type u_2
α : Type u_3
β : Type u_4
γ : Type u_5
f✝ : α → β → β
op : α → α → α
inst✝² : Monoid β
inst✝¹ : Monoid γ
inst✝ : DecidableEq α
l : List α
f : α → β
comm : (↑l.toFinset).Pairwise fun a b => Commute (f a) (f b)
hl : l.dedup = l
⊢ l.toFinset.noncommProd f comm = (List.map f l).prod
tactic: rw [← List.dedup_eq_self] at hl
state_before: F : Type u_1
ι : Type u_2
α : Type u_3
β : Type u_4
γ : Type u_5
f✝ : α → β → β
op : α → α → α
inst✝² : Monoid β
inst✝¹ : Monoid γ
inst✝ : DecidableEq α
l : List α
f : α → β
comm : (↑l.toFinset).Pairwise fun a b => Commute (f a) (f b)
hl : l.dedup = l
⊢ l.toFinset.noncommProd f comm = (List.map f l).prod
state_after: no goals
tactic: simp [noncommProd, hl]
Theorem: MeasureTheory.AEStronglyMeasurable.stronglyMeasurableAtFilter
File: Mathlib/MeasureTheory/Integral/IntegrableOn.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
E : Type u_3
F : Type u_4
inst✝¹ : MeasurableSpace α
inst✝ : TopologicalSpace β
l l' : Filter α
f g : α → β
μ ν : Measure α
h : AEStronglyMeasurable f μ
⊢ AEStronglyMeasurable f (μ.restrict univ)
state_after: no goals
tactic: rwa [Measure.restrict_univ]
Theorem: Equiv.Perm.length_toList
File: Mathlib/GroupTheory/Perm/Cycle/Concrete.lean

Proof steps:
state_before: α : Type u_1
inst✝¹ : Fintype α
inst✝ : DecidableEq α
p : Perm α
x : α
⊢ (p.toList x).length = (p.cycleOf x).support.card
state_after: no goals
tactic: simp [toList]
Theorem: Algebra.Generators.toExtendScalars_val
File: Mathlib/RingTheory/Generators.lean

Proof steps:
state_before: R : Type u
S : Type v
inst✝²⁹ : CommRing R
inst✝²⁸ : CommRing S
inst✝²⁷ : Algebra R S
P✝ : Generators R S
R' : Type ?u.431938
S' : Type ?u.431941
inst✝²⁶ : CommRing R'
inst✝²⁵ : CommRing S'
inst✝²⁴ : Algebra R' S'
P' : Generators R' S'
inst✝²³ : Algebra R R'
inst✝²² : Algebra S S'
inst✝²¹ : Algebra R S'
inst✝²⁰ : IsScalarTower R R' S'
inst✝¹⁹ : IsScalarTower R S S'
R'' : Type ?u.434372
S'' : Type ?u.434375
inst✝¹⁸ : CommRing R''
inst✝¹⁷ : CommRing S''
inst✝¹⁶ : Algebra R'' S''
P'' : Generators R'' S''
inst✝¹⁵ : Algebra R R''
inst✝¹⁴ : Algebra S S''
inst✝¹³ : Algebra R S''
inst✝¹² : IsScalarTower R R'' S''
inst✝¹¹ : IsScalarTower R S S''
inst✝¹⁰ : Algebra R' R''
inst✝⁹ : Algebra S' S''
inst✝⁸ : Algebra R' S''
inst✝⁷ : IsScalarTower R' R'' S''
inst✝⁶ : IsScalarTower R' S' S''
inst✝⁵ : IsScalarTower R R' R''
inst✝⁴ : IsScalarTower S S' S''
T : Type ?u.440232
inst✝³ : CommRing T
inst✝² : Algebra R T
inst✝¹ : Algebra S T
inst✝ : IsScalarTower R S T
P : Generators R T
i : P.vars
⊢ (aeval (extendScalars S P).val) (X i) = (algebraMap T T) (P.val i)
state_after: no goals
tactic: simp
Theorem: _private.Mathlib.Dynamics.PeriodicPts.0.Function.minimalPeriod_iterate_eq_div_gcd_aux
File: Mathlib/Dynamics/PeriodicPts.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
f fa : α → α
fb : β → β
x y : α
m n : ℕ
h : 0 < (minimalPeriod f x).gcd n
⊢ minimalPeriod f^[n] x = minimalPeriod f x / (minimalPeriod f x).gcd n
state_after: case a
α : Type u_1
β : Type u_2
f fa : α → α
fb : β → β
x y : α
m n : ℕ
h : 0 < (minimalPeriod f x).gcd n
⊢ minimalPeriod f^[n] x ∣ minimalPeriod f x / (minimalPeriod f x).gcd n

case a
α : Type u_1
β : Type u_2
f fa : α → α
fb : β → β
x y : α
m n : ℕ
h : 0 < (minimalPeriod f x).gcd n
⊢ minimalPeriod f x / (minimalPeriod f x).gcd n ∣ minimalPeriod f^[n] x
tactic: apply Nat.dvd_antisymm
Theorem: EuclideanDomain.div_dvd_of_dvd
File: Mathlib/Algebra/EuclideanDomain/Basic.lean

Proof steps:
state_before: R : Type u
inst✝ : EuclideanDomain R
p q : R
hpq : q ∣ p
⊢ p / q ∣ p
state_after: case pos
R : Type u
inst✝ : EuclideanDomain R
p q : R
hpq : q ∣ p
hq : q = 0
⊢ p / q ∣ p

case neg
R : Type u
inst✝ : EuclideanDomain R
p q : R
hpq : q ∣ p
hq : ¬q = 0
⊢ p / q ∣ p
tactic: by_cases hq : q = 0
state_before: case neg
R : Type u
inst✝ : EuclideanDomain R
p q : R
hpq : q ∣ p
hq : ¬q = 0
⊢ p / q ∣ p
state_after: case h
R : Type u
inst✝ : EuclideanDomain R
p q : R
hpq : q ∣ p
hq : ¬q = 0
⊢ p = p / q * q
tactic: use q
state_before: case h
R : Type u
inst✝ : EuclideanDomain R
p q : R
hpq : q ∣ p
hq : ¬q = 0
⊢ p = p / q * q
state_after: no goals
tactic: rw [mul_comm, ← EuclideanDomain.mul_div_assoc _ hpq, mul_comm, mul_div_cancel_right₀ _ hq]
Theorem: AlgebraicGeometry.IsLocalAtTarget.of_isPullback
File: Mathlib/AlgebraicGeometry/Morphisms/Basic.lean

Proof steps:
state_before: P : MorphismProperty Scheme
hP : IsLocalAtTarget P
X Y U V : Scheme
f : X ⟶ Y
g : U ⟶ Y
inst✝¹ : IsOpenImmersion g
𝒰 : Y.OpenCover
UX UY : Scheme
iY : UY ⟶ Y
inst✝ : IsOpenImmersion iY
iX : UX ⟶ X
f' : UX ⟶ UY
h : IsPullback iX f' f iY
H : P f
⊢ P f'
state_after: P : MorphismProperty Scheme
hP : IsLocalAtTarget P
X Y U V : Scheme
f : X ⟶ Y
g : U ⟶ Y
inst✝¹ : IsOpenImmersion g
𝒰 : Y.OpenCover
UX UY : Scheme
iY : UY ⟶ Y
inst✝ : IsOpenImmersion iY
iX : UX ⟶ X
f' : UX ⟶ UY
h : IsPullback iX f' f iY
H : P f
⊢ P (pullback.snd f iY)
tactic: rw [← P.cancel_left_of_respectsIso h.isoPullback.inv, h.isoPullback_inv_snd]
state_before: P : MorphismProperty Scheme
hP : IsLocalAtTarget P
X Y U V : Scheme
f : X ⟶ Y
g : U ⟶ Y
inst✝¹ : IsOpenImmersion g
𝒰 : Y.OpenCover
UX UY : Scheme
iY : UY ⟶ Y
inst✝ : IsOpenImmersion iY
iX : UX ⟶ X
f' : UX ⟶ UY
h : IsPullback iX f' f iY
H : P f
⊢ P (pullback.snd f iY)
state_after: no goals
tactic: exact (iff_of_openCover' f (Y.affineCover.add iY)).mp H .none
Theorem: Algebra.adjoin_res_eq_adjoin_res
File: Mathlib/RingTheory/Adjoin/Tower.lean

Proof steps:
state_before: R : Type u
S✝ : Type v
A : Type w
B : Type u₁
C : Type u_1
D : Type u_2
E : Type u_3
F : Type u_4
inst✝¹⁰ : CommSemiring C
inst✝⁹ : CommSemiring D
inst✝⁸ : CommSemiring E
inst✝⁷ : CommSemiring F
inst✝⁶ : Algebra C D
inst✝⁵ : Algebra C E
inst✝⁴ : Algebra C F
inst✝³ : Algebra D F
inst✝² : Algebra E F
inst✝¹ : IsScalarTower C D F
inst✝ : IsScalarTower C E F
S : Set D
T : Set E
hS : adjoin C S = ⊤
hT : adjoin C T = ⊤
⊢ Subalgebra.restrictScalars C (adjoin E (⇑(algebraMap D F) '' S)) =
    Subalgebra.restrictScalars C (adjoin D (⇑(algebraMap E F) '' T))
state_after: no goals
tactic: rw [adjoin_restrictScalars C E, adjoin_restrictScalars C D, ← hS, ← hT, ← Algebra.adjoin_image,
    ← Algebra.adjoin_image, ← AlgHom.coe_toRingHom, ← AlgHom.coe_toRingHom,
    IsScalarTower.coe_toAlgHom, IsScalarTower.coe_toAlgHom, ← adjoin_union_eq_adjoin_adjoin, ←
    adjoin_union_eq_adjoin_adjoin, Set.union_comm]
Theorem: map_mul_right_nhds_one₀
File: Mathlib/Topology/Algebra/GroupWithZero.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
G₀ : Type u_3
inst✝² : TopologicalSpace G₀
inst✝¹ : GroupWithZero G₀
inst✝ : ContinuousMul G₀
a : G₀
ha : a ≠ 0
⊢ map (fun x => x * a) (𝓝 1) = 𝓝 a
state_after: no goals
tactic: rw [map_mul_right_nhds₀ ha, one_mul]
Theorem: Complex.HadamardThreeLines.norm_le_sSupNormIm
File: Mathlib/Analysis/Complex/Hadamard.lean

Proof steps:
state_before: E : Type u_1
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace ℂ E
f✝ : ℂ → E
z✝ : ℂ
f : ℂ → E
z : ℂ
hD : z ∈ verticalClosedStrip 0 1
hB : BddAbove (norm ∘ f '' verticalClosedStrip 0 1)
⊢ ‖f z‖ ≤ sSupNormIm f z.re
state_after: case refine_1
E : Type u_1
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace ℂ E
f✝ : ℂ → E
z✝ : ℂ
f : ℂ → E
z : ℂ
hD : z ∈ verticalClosedStrip 0 1
hB : BddAbove (norm ∘ f '' verticalClosedStrip 0 1)
⊢ BddAbove (norm ∘ f '' (re ⁻¹' {z.re}))

case refine_2
E : Type u_1
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace ℂ E
f✝ : ℂ → E
z✝ : ℂ
f : ℂ → E
z : ℂ
hD : z ∈ verticalClosedStrip 0 1
hB : BddAbove (norm ∘ f '' verticalClosedStrip 0 1)
⊢ ‖f z‖ ∈ norm ∘ f '' (re ⁻¹' {z.re})
tactic: refine le_csSup ?_ ?_
Theorem: CategoryTheory.Limits.prodComparisonNatTrans_app
File: Mathlib/CategoryTheory/Limits/Shapes/BinaryProducts.lean

Proof steps:
state_before: C : Type u
inst✝¹⁰ : Category.{v, u} C
X Y : C
D : Type u₂
inst✝⁹ : Category.{w, u₂} D
E : Type u₃
inst✝⁸ : Category.{w', u₃} E
F✝ : C ⥤ D
G : D ⥤ E
A✝ A' B B' : C
inst✝⁷ : HasBinaryProduct A✝ B
inst✝⁶ : HasBinaryProduct A' B'
inst✝⁵ : HasBinaryProduct (F✝.obj A✝) (F✝.obj B)
inst✝⁴ : HasBinaryProduct (F✝.obj A') (F✝.obj B')
inst✝³ : HasBinaryProduct (G.obj (F✝.obj A✝)) (G.obj (F✝.obj B))
inst✝² : HasBinaryProduct ((F✝ ⋙ G).obj A✝) ((F✝ ⋙ G).obj B)
inst✝¹ : HasBinaryProducts C
inst✝ : HasBinaryProducts D
F : C ⥤ D
A f : C
⊢ ∀ ⦃Y : C⦄ (f_1 : f ⟶ Y),
    (prod.functor.obj A ⋙ F).map f_1 ≫ (fun B => prodComparison F A B) Y =
      (fun B => prodComparison F A B) f ≫ (F ⋙ prod.functor.obj (F.obj A)).map f_1
state_after: no goals
tactic: simp [prodComparison_natural]
Theorem: Real.cos_sub_pi_div_two
File: Mathlib/Analysis/SpecialFunctions/Trigonometric/Basic.lean

Proof steps:
state_before: x : ℝ
⊢ cos (x - π / 2) = sin x
state_after: no goals
tactic: simp [sub_eq_add_neg, cos_add]
Theorem: Nat.divisors_filter_squarefree
File: Mathlib/Data/Nat/Squarefree.lean

Proof steps:
state_before: s : Finset ℕ
m n✝ p n : ℕ
h0 : n ≠ 0
⊢ (filter Squarefree n.divisors).val = Multiset.map (fun x => x.val.prod) (normalizedFactors n).toFinset.powerset.val
state_after: s : Finset ℕ
m n✝ p n : ℕ
h0 : n ≠ 0
⊢ ∀ (a : ℕ),
    a ∈ (filter Squarefree n.divisors).val ↔
      a ∈ Multiset.map (fun x => x.val.prod) (normalizedFactors n).toFinset.powerset.val

s : Finset ℕ
m n✝ p n : ℕ
h0 : n ≠ 0
⊢ ∀ x ∈ (normalizedFactors n).toFinset.powerset.val,
    ∀ y ∈ (normalizedFactors n).toFinset.powerset.val, x.val.prod = y.val.prod → x = y
tactic: rw [(Finset.nodup _).ext ((Finset.nodup _).map_on _)]
Theorem: WeierstrassCurve.Affine.CoordinateRing.mk_ψ
File: Mathlib/AlgebraicGeometry/EllipticCurve/DivisionPolynomial/Basic.lean

Proof steps:
state_before: R : Type r
S : Type s
inst✝¹ : CommRing R
inst✝ : CommRing S
W : WeierstrassCurve R
n : ℤ
⊢ (mk W) (W.ψ n) = (mk W) (W.Ψ n)
state_after: no goals
tactic: simp only [ψ, normEDS, Ψ, preΨ, map_mul, map_pow, map_preNormEDS, ← mk_ψ₂_sq, ← pow_mul]
Theorem: Finset.mem_inv'
File: Mathlib/Data/Finset/Pointwise.lean

Proof steps:
state_before: F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
inst✝¹ : DecidableEq α
inst✝ : InvolutiveInv α
s : Finset α
a : α
⊢ a ∈ s⁻¹ ↔ a⁻¹ ∈ s
state_after: no goals
tactic: simp [mem_inv, inv_eq_iff_eq_inv]
Theorem: List.Duplicate.ne_singleton
File: Mathlib/Data/List/Duplicate.lean

Proof steps:
state_before: α : Type u_1
l : List α
x : α
h : x ∈+ l
y : α
⊢ l ≠ [y]
state_after: case cons_mem
α : Type u_1
l : List α
x y : α
l' : List α
h : x ∈ l'
⊢ x :: l' ≠ [y]

case cons_duplicate
α : Type u_1
l : List α
x y z : α
l' : List α
h : x ∈+ l'
a_ih✝ : l' ≠ [y]
⊢ z :: l' ≠ [y]
tactic: induction' h with l' h z l' h _
Theorem: ThreeAPFree.vadd_set
File: Mathlib/Combinatorics/Additive/AP/Three/Defs.lean

Proof steps:
state_before: F : Type u_1
α : Type u_2
β : Type u_3
𝕜 : Type u_4
E : Type u_5
inst✝ : CancelCommMonoid α
s : Set α
a : α
hs : ThreeGPFree s
⊢ ThreeGPFree (a • s)
state_after: case intro.intro.intro.intro.intro.intro
F : Type u_1
α : Type u_2
β : Type u_3
𝕜 : Type u_4
E : Type u_5
inst✝ : CancelCommMonoid α
s : Set α
a : α
hs : ThreeGPFree s
b : α
hb : b ∈ s
c : α
hc : c ∈ s
d : α
hd : d ∈ s
h : (fun x => a • x) b * (fun x => a • x) d = (fun x => a • x) c * (fun x => a • x) c
⊢ (fun x => a • x) b = (fun x => a • x) c
tactic: rintro _ ⟨b, hb, rfl⟩ _ ⟨c, hc, rfl⟩ _ ⟨d, hd, rfl⟩ h
Theorem: MvPolynomial.aevalTower_id
File: Mathlib/Algebra/MvPolynomial/Basic.lean

Proof steps:
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
S : Type u_2
A : Type u_3
B : Type u_4
inst✝⁵ : CommSemiring S
inst✝⁴ : CommSemiring A
inst✝³ : CommSemiring B
inst✝² : Algebra S R
inst✝¹ : Algebra S A
inst✝ : Algebra S B
g : R →ₐ[S] A
y : σ → A
⊢ aevalTower (AlgHom.id S S) = aeval
state_after: case h.hf
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
S : Type u_2
A : Type u_3
B : Type u_4
inst✝⁵ : CommSemiring S
inst✝⁴ : CommSemiring A
inst✝³ : CommSemiring B
inst✝² : Algebra S R
inst✝¹ : Algebra S A
inst✝ : Algebra S B
g : R →ₐ[S] A
y : σ → A
x✝ : σ → S
i✝ : σ
⊢ (aevalTower (AlgHom.id S S) x✝) (X i✝) = (aeval x✝) (X i✝)
tactic: ext
state_before: case h.hf
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
S : Type u_2
A : Type u_3
B : Type u_4
inst✝⁵ : CommSemiring S
inst✝⁴ : CommSemiring A
inst✝³ : CommSemiring B
inst✝² : Algebra S R
inst✝¹ : Algebra S A
inst✝ : Algebra S B
g : R →ₐ[S] A
y : σ → A
x✝ : σ → S
i✝ : σ
⊢ (aevalTower (AlgHom.id S S) x✝) (X i✝) = (aeval x✝) (X i✝)
state_after: no goals
tactic: simp only [aevalTower_X, aeval_X]
Theorem: Matrix.nondegenerate_toBilin_iff
File: Mathlib/LinearAlgebra/Matrix/BilinearForm.lean

Proof steps:
state_before: R : Type u_1
M✝ : Type u_2
inst✝¹⁹ : CommSemiring R
inst✝¹⁸ : AddCommMonoid M✝
inst✝¹⁷ : Module R M✝
R₁ : Type u_3
M₁ : Type u_4
inst✝¹⁶ : CommRing R₁
inst✝¹⁵ : AddCommGroup M₁
inst✝¹⁴ : Module R₁ M₁
R₂ : Type u_5
M₂ : Type u_6
inst✝¹³ : CommSemiring R₂
inst✝¹² : AddCommMonoid M₂
inst✝¹¹ : Module R₂ M₂
R₃ : Type u_7
M₃ : Type u_8
inst✝¹⁰ : CommRing R₃
inst✝⁹ : AddCommGroup M₃
inst✝⁸ : Module R₃ M₃
V : Type u_9
K : Type u_10
inst✝⁷ : Field K
inst✝⁶ : AddCommGroup V
inst✝⁵ : Module K V
B : BilinForm R M✝
B₁ : BilinForm R₁ M₁
B₂ : BilinForm R₂ M₂
A : Type u_11
inst✝⁴ : CommRing A
inst✝³ : IsDomain A
inst✝² : Module A M₃
B₃ : BilinForm A M₃
ι : Type u_12
inst✝¹ : DecidableEq ι
inst✝ : Fintype ι
M : Matrix ι ι R₃
b : Basis ι R₃ M₃
⊢ ((Matrix.toBilin b) M).Nondegenerate ↔ M.Nondegenerate
state_after: no goals
tactic: rw [← Matrix.nondegenerate_toBilin'_iff_nondegenerate_toBilin, Matrix.nondegenerate_toBilin'_iff]
Theorem: ENNReal.mul_inv_cancel
File: Mathlib/Data/ENNReal/Inv.lean

Proof steps:
state_before: a b c d : ℝ≥0∞
r p q : ℝ≥0
h0 : a ≠ 0
ht : a ≠ ⊤
⊢ a * a⁻¹ = 1
state_after: case intro
b c d : ℝ≥0∞
r p q a : ℝ≥0
h0 : ↑a ≠ 0
⊢ ↑a * (↑a)⁻¹ = 1
tactic: lift a to ℝ≥0 using ht
state_before: case intro
b c d : ℝ≥0∞
r p q a : ℝ≥0
h0 : ↑a ≠ 0
⊢ ↑a * (↑a)⁻¹ = 1
state_after: case intro
b c d : ℝ≥0∞
r p q a : ℝ≥0
h0 : ¬a = 0
⊢ ↑a * (↑a)⁻¹ = 1
tactic: norm_cast at h0
state_before: case intro
b c d : ℝ≥0∞
r p q a : ℝ≥0
h0 : ¬a = 0
⊢ ↑a * (↑a)⁻¹ = 1
state_after: case intro
b c d : ℝ≥0∞
r p q a : ℝ≥0
h0 : ¬a = 0
⊢ a * a⁻¹ = 1
tactic: norm_cast
state_before: case intro
b c d : ℝ≥0∞
r p q a : ℝ≥0
h0 : ¬a = 0
⊢ a * a⁻¹ = 1
state_after: no goals
tactic: exact mul_inv_cancel h0
Theorem: Finsupp.toDFinsupp_single
File: Mathlib/Data/Finsupp/ToDFinsupp.lean

Proof steps:
state_before: ι : Type u_1
R : Type u_2
M : Type u_3
inst✝¹ : DecidableEq ι
inst✝ : Zero M
i : ι
m : M
⊢ (single i m).toDFinsupp = DFinsupp.single i m
state_after: case h
ι : Type u_1
R : Type u_2
M : Type u_3
inst✝¹ : DecidableEq ι
inst✝ : Zero M
i : ι
m : M
i✝ : ι
⊢ (single i m).toDFinsupp i✝ = (DFinsupp.single i m) i✝
tactic: ext
state_before: case h
ι : Type u_1
R : Type u_2
M : Type u_3
inst✝¹ : DecidableEq ι
inst✝ : Zero M
i : ι
m : M
i✝ : ι
⊢ (single i m).toDFinsupp i✝ = (DFinsupp.single i m) i✝
state_after: no goals
tactic: simp [Finsupp.single_apply, DFinsupp.single_apply]
Theorem: Trivialization.zeroSection
File: Mathlib/Topology/VectorBundle/Basic.lean

Proof steps:
state_before: R : Type u_1
B : Type u_2
F : Type u_3
E : B → Type u_4
inst✝⁹ : NontriviallyNormedField R
inst✝⁸ : (x : B) → AddCommMonoid (E x)
inst✝⁷ : (x : B) → Module R (E x)
inst✝⁶ : NormedAddCommGroup F
inst✝⁵ : NormedSpace R F
inst✝⁴ : TopologicalSpace B
inst✝³ : TopologicalSpace (TotalSpace F E)
inst✝² : (x : B) → TopologicalSpace (E x)
inst✝¹ : FiberBundle F E
e : Trivialization F TotalSpace.proj
inst✝ : Trivialization.IsLinear R e
x : B
hx : x ∈ e.baseSet
⊢ ↑e (zeroSection F E x) = (x, 0)
state_after: no goals
tactic: simp_rw [zeroSection, e.apply_eq_prod_continuousLinearEquivAt R x hx 0, map_zero]
Theorem: Ordinal.bfamilyOfFamily'_typein
File: Mathlib/SetTheory/Ordinal/Arithmetic.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
r✝ : α → α → Prop
s : β → β → Prop
t : γ → γ → Prop
ι : Type u_4
r : ι → ι → Prop
inst✝ : IsWellOrder ι r
f : ι → α
i : ι
⊢ bfamilyOfFamily' r f (typein r i) ⋯ = f i
state_after: no goals
tactic: simp only [bfamilyOfFamily', enum_typein]
Theorem: Matrix.smul_eq_mul_diagonal
File: Mathlib/Data/Matrix/Basic.lean

Proof steps:
state_before: l : Type u_1
m : Type u_2
n : Type u_3
o : Type u_4
m' : o → Type u_5
n' : o → Type u_6
R : Type u_7
S : Type u_8
α : Type v
β : Type w
γ : Type u_9
inst✝² : CommSemiring α
inst✝¹ : Fintype n
inst✝ : DecidableEq n
M : Matrix m n α
a : α
⊢ a • M = M * diagonal fun x => a
state_after: case a
l : Type u_1
m : Type u_2
n : Type u_3
o : Type u_4
m' : o → Type u_5
n' : o → Type u_6
R : Type u_7
S : Type u_8
α : Type v
β : Type w
γ : Type u_9
inst✝² : CommSemiring α
inst✝¹ : Fintype n
inst✝ : DecidableEq n
M : Matrix m n α
a : α
i✝ : m
j✝ : n
⊢ (a • M) i✝ j✝ = (M * diagonal fun x => a) i✝ j✝
tactic: ext
state_before: case a
l : Type u_1
m : Type u_2
n : Type u_3
o : Type u_4
m' : o → Type u_5
n' : o → Type u_6
R : Type u_7
S : Type u_8
α : Type v
β : Type w
γ : Type u_9
inst✝² : CommSemiring α
inst✝¹ : Fintype n
inst✝ : DecidableEq n
M : Matrix m n α
a : α
i✝ : m
j✝ : n
⊢ (a • M) i✝ j✝ = (M * diagonal fun x => a) i✝ j✝
state_after: no goals
tactic: simp [mul_comm]