ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: CategoryTheory.ComposableArrows.exact₁
File: Mathlib/Algebra/Homology/ExactSequence.lean

Proof steps:
state_before: C : Type u_1
inst✝¹ : Category.{u_2, u_1} C
inst✝ : HasZeroMorphisms C
n : ℕ
S✝ : ComposableArrows C n
S : ComposableArrows C 1
i : ℕ
hi : autoParam (i + 2 ≤ 1) _auto✝
⊢ (S.sc ⋯ i ⋯).Exact
state_after: C : Type u_1
inst✝¹ : Category.{u_2, u_1} C
inst✝ : HasZeroMorphisms C
n : ℕ
S✝ : ComposableArrows C n
S : ComposableArrows C 1
i : ℕ
hi : autoParam (i + 2 ≤ 1) _auto✝
⊢ False
tactic: exfalso
state_before: C : Type u_1
inst✝¹ : Category.{u_2, u_1} C
inst✝ : HasZeroMorphisms C
n : ℕ
S✝ : ComposableArrows C n
S : ComposableArrows C 1
i : ℕ
hi : autoParam (i + 2 ≤ 1) _auto✝
⊢ False
state_after: no goals
tactic: omega
Theorem: SeparatedNhds.of_isCompact_isCompact
File: Mathlib/Topology/Separation.lean

Proof steps:
state_before: X : Type u_1
Y : Type u_2
inst✝⁴ : TopologicalSpace X
inst✝³ : FirstCountableTopology X
Z : Type u_3
inst✝² : TopologicalSpace Y
inst✝¹ : TopologicalSpace Z
inst✝ : T2Space X
s t : Set X
hs : IsCompact s
ht : IsCompact t
hst : Disjoint s t
⊢ SeparatedNhds s t
state_after: X : Type u_1
Y : Type u_2
inst✝⁴ : TopologicalSpace X
inst✝³ : FirstCountableTopology X
Z : Type u_3
inst✝² : TopologicalSpace Y
inst✝¹ : TopologicalSpace Z
inst✝ : T2Space X
s t : Set X
hs : IsCompact s
ht : IsCompact t
hst : s ×ˢ t ⊆ (diagonal X)ᶜ
⊢ ∃ U V, IsOpen U ∧ IsOpen V ∧ s ⊆ U ∧ t ⊆ V ∧ U ×ˢ V ⊆ (diagonal X)ᶜ
tactic: simp only [SeparatedNhds, prod_subset_compl_diagonal_iff_disjoint.symm] at hst ⊢
state_before: X : Type u_1
Y : Type u_2
inst✝⁴ : TopologicalSpace X
inst✝³ : FirstCountableTopology X
Z : Type u_3
inst✝² : TopologicalSpace Y
inst✝¹ : TopologicalSpace Z
inst✝ : T2Space X
s t : Set X
hs : IsCompact s
ht : IsCompact t
hst : s ×ˢ t ⊆ (diagonal X)ᶜ
⊢ ∃ U V, IsOpen U ∧ IsOpen V ∧ s ⊆ U ∧ t ⊆ V ∧ U ×ˢ V ⊆ (diagonal X)ᶜ
state_after: no goals
tactic: exact generalized_tube_lemma hs ht isClosed_diagonal.isOpen_compl hst
Theorem: ProbabilityTheory.Kernel.lintegral_deterministic
File: Mathlib/Probability/Kernel/Basic.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
κ : Kernel α β
f : β → ℝ≥0∞
g : α → β
a : α
hg : Measurable g
inst✝ : MeasurableSingletonClass β
⊢ ∫⁻ (x : β), f x ∂(deterministic g hg) a = f (g a)
state_after: no goals
tactic: rw [deterministic_apply, lintegral_dirac (g a) f]
Theorem: AddMonoidHom.precompEquiv_symm_apply
File: Mathlib/Algebra/Category/Grp/ForgetCorepresentable.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
inst✝² : AddMonoid α
inst✝¹ : AddMonoid β
e : α ≃+ β
γ : Type u_3
inst✝ : AddMonoid γ
x✝ : β →+ γ
⊢ (fun g => g.comp ↑e.symm) ((fun f => f.comp ↑e) x✝) = x✝
state_after: case h
α : Type u_1
β : Type u_2
inst✝² : AddMonoid α
inst✝¹ : AddMonoid β
e : α ≃+ β
γ : Type u_3
inst✝ : AddMonoid γ
x✝¹ : β →+ γ
x✝ : β
⊢ ((fun g => g.comp ↑e.symm) ((fun f => f.comp ↑e) x✝¹)) x✝ = x✝¹ x✝
tactic: ext
state_before: case h
α : Type u_1
β : Type u_2
inst✝² : AddMonoid α
inst✝¹ : AddMonoid β
e : α ≃+ β
γ : Type u_3
inst✝ : AddMonoid γ
x✝¹ : β →+ γ
x✝ : β
⊢ ((fun g => g.comp ↑e.symm) ((fun f => f.comp ↑e) x✝¹)) x✝ = x✝¹ x✝
state_after: no goals
tactic: simp
state_before: α : Type u_1
β : Type u_2
inst✝² : AddMonoid α
inst✝¹ : AddMonoid β
e : α ≃+ β
γ : Type u_3
inst✝ : AddMonoid γ
x✝ : α →+ γ
⊢ (fun f => f.comp ↑e) ((fun g => g.comp ↑e.symm) x✝) = x✝
state_after: case h
α : Type u_1
β : Type u_2
inst✝² : AddMonoid α
inst✝¹ : AddMonoid β
e : α ≃+ β
γ : Type u_3
inst✝ : AddMonoid γ
x✝¹ : α →+ γ
x✝ : α
⊢ ((fun f => f.comp ↑e) ((fun g => g.comp ↑e.symm) x✝¹)) x✝ = x✝¹ x✝
tactic: ext
state_before: case h
α : Type u_1
β : Type u_2
inst✝² : AddMonoid α
inst✝¹ : AddMonoid β
e : α ≃+ β
γ : Type u_3
inst✝ : AddMonoid γ
x✝¹ : α →+ γ
x✝ : α
⊢ ((fun f => f.comp ↑e) ((fun g => g.comp ↑e.symm) x✝¹)) x✝ = x✝¹ x✝
state_after: no goals
tactic: simp
Theorem: zsmul_zero_sub
File: Mathlib/Algebra/Group/Basic.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
G : Type u_3
M : Type u_4
inst✝ : DivisionMonoid α
a✝ b c d a : α
n : ℤ
⊢ (1 / a) ^ n = 1 / a ^ n
state_after: no goals
tactic: simp only [one_div, inv_zpow]
Theorem: Polynomial.natDegree_comp
File: Mathlib/Algebra/Polynomial/Degree/Lemmas.lean

Proof steps:
state_before: R : Type u
S : Type v
ι : Type w
a✝ b : R
m n : ℕ
inst✝¹ : Semiring R
inst✝ : NoZeroDivisors R
p q : R[X]
a : R
⊢ (p.comp q).natDegree = p.natDegree * q.natDegree
state_after: case pos
R : Type u
S : Type v
ι : Type w
a✝ b : R
m n : ℕ
inst✝¹ : Semiring R
inst✝ : NoZeroDivisors R
p q : R[X]
a : R
q0 : q.natDegree = 0
⊢ (p.comp q).natDegree = p.natDegree * q.natDegree

case neg
R : Type u
S : Type v
ι : Type w
a✝ b : R
m n : ℕ
inst✝¹ : Semiring R
inst✝ : NoZeroDivisors R
p q : R[X]
a : R
q0 : ¬q.natDegree = 0
⊢ (p.comp q).natDegree = p.natDegree * q.natDegree
tactic: by_cases q0 : q.natDegree = 0
Theorem: CofiniteTopology.mem_nhds_iff
File: Mathlib/Topology/Constructions.lean

Proof steps:
state_before: X : Type u
Y : Type v
Z : Type u_1
W : Type u_2
ε : Type u_3
ζ : Type u_4
x : CofiniteTopology X
s : Set (CofiniteTopology X)
⊢ s ∈ 𝓝 x ↔ x ∈ s ∧ sᶜ.Finite
state_after: no goals
tactic: simp [nhds_eq]
Theorem: Polynomial.trinomial_monic
File: Mathlib/Algebra/Polynomial/UnitTrinomial.lean

Proof steps:
state_before: R : Type u_1
inst✝ : Semiring R
k m n : ℕ
u v w : R
hkm : k < m
hmn : m < n
⊢ (trinomial k m n u v 1).Monic
state_after: R : Type u_1
inst✝ : Semiring R
k m n : ℕ
u v w : R
hkm : k < m
hmn : m < n
a✝ : Nontrivial R
⊢ (trinomial k m n u v 1).Monic
tactic: nontriviality R
state_before: R : Type u_1
inst✝ : Semiring R
k m n : ℕ
u v w : R
hkm : k < m
hmn : m < n
a✝ : Nontrivial R
⊢ (trinomial k m n u v 1).Monic
state_after: no goals
tactic: exact trinomial_leadingCoeff hkm hmn one_ne_zero
Theorem: HomologicalComplex.homotopyCofiber.d_fstX
File: Mathlib/Algebra/Homology/HomotopyCofiber.lean

Proof steps:
state_before: C : Type u_1
inst✝³ : Category.{u_3, u_1} C
inst✝² : Preadditive C
ι : Type u_2
c : ComplexShape ι
F G K : HomologicalComplex C c
φ : F ⟶ G
inst✝¹ : HasHomotopyCofiber φ
inst✝ : DecidableRel c.Rel
i j k : ι
hij : c.Rel i j
hjk : c.Rel j k
⊢ d φ i j ≫ fstX φ j k hjk = -fstX φ i j hij ≫ F.d j k
state_after: C : Type u_1
inst✝³ : Category.{u_3, u_1} C
inst✝² : Preadditive C
ι : Type u_2
c : ComplexShape ι
F G K : HomologicalComplex C c
φ : F ⟶ G
inst✝¹ : HasHomotopyCofiber φ
inst✝ : DecidableRel c.Rel
i j : ι
hij : c.Rel i j
hjk : c.Rel j (c.next j)
⊢ d φ i j ≫ fstX φ j (c.next j) hjk = -fstX φ i j hij ≫ F.d j (c.next j)
tactic: obtain rfl := c.next_eq' hjk
state_before: C : Type u_1
inst✝³ : Category.{u_3, u_1} C
inst✝² : Preadditive C
ι : Type u_2
c : ComplexShape ι
F G K : HomologicalComplex C c
φ : F ⟶ G
inst✝¹ : HasHomotopyCofiber φ
inst✝ : DecidableRel c.Rel
i j : ι
hij : c.Rel i j
hjk : c.Rel j (c.next j)
⊢ d φ i j ≫ fstX φ j (c.next j) hjk = -fstX φ i j hij ≫ F.d j (c.next j)
state_after: no goals
tactic: simp [d, dif_pos hij, dif_pos hjk]
Theorem: CategoryTheory.CategoryOfElements.CreatesLimitsAux.liftedCone_pt_fst
File: Mathlib/CategoryTheory/Limits/Elements.lean

Proof steps:
state_before: C : Type u
inst✝⁴ : Category.{v, u} C
A : C ⥤ Type w
I : Type u₁
inst✝³ : Category.{v₁, u₁} I
inst✝² : Small.{w, u₁} I
F : I ⥤ A.Elements
inst✝¹ : HasLimitsOfShape I C
inst✝ : PreservesLimitsOfShape I A
i : I
⊢ A.map (limit.π (F ⋙ π A) i) (((Functor.const I).obj ⟨limit (F ⋙ π A), liftedConeElement F⟩).obj i).snd = (F.obj i).snd
state_after: no goals
tactic: simp
state_before: C : Type u
inst✝⁴ : Category.{v, u} C
A : C ⥤ Type w
I : Type u₁
inst✝³ : Category.{v₁, u₁} I
inst✝² : Small.{w, u₁} I
F : I ⥤ A.Elements
inst✝¹ : HasLimitsOfShape I C
inst✝ : PreservesLimitsOfShape I A
i i' : I
f : i ⟶ i'
⊢ ((Functor.const I).obj ⟨limit (F ⋙ π A), liftedConeElement F⟩).map f ≫ (fun i => ⟨limit.π (F ⋙ π A) i, ⋯⟩) i' =
    (fun i => ⟨limit.π (F ⋙ π A) i, ⋯⟩) i ≫ F.map f
state_after: case w
C : Type u
inst✝⁴ : Category.{v, u} C
A : C ⥤ Type w
I : Type u₁
inst✝³ : Category.{v₁, u₁} I
inst✝² : Small.{w, u₁} I
F : I ⥤ A.Elements
inst✝¹ : HasLimitsOfShape I C
inst✝ : PreservesLimitsOfShape I A
i i' : I
f : i ⟶ i'
⊢ ↑(((Functor.const I).obj ⟨limit (F ⋙ π A), liftedConeElement F⟩).map f ≫ (fun i => ⟨limit.π (F ⋙ π A) i, ⋯⟩) i') =
    ↑((fun i => ⟨limit.π (F ⋙ π A) i, ⋯⟩) i ≫ F.map f)
tactic: ext
state_before: case w
C : Type u
inst✝⁴ : Category.{v, u} C
A : C ⥤ Type w
I : Type u₁
inst✝³ : Category.{v₁, u₁} I
inst✝² : Small.{w, u₁} I
F : I ⥤ A.Elements
inst✝¹ : HasLimitsOfShape I C
inst✝ : PreservesLimitsOfShape I A
i i' : I
f : i ⟶ i'
⊢ ↑(((Functor.const I).obj ⟨limit (F ⋙ π A), liftedConeElement F⟩).map f ≫ (fun i => ⟨limit.π (F ⋙ π A) i, ⋯⟩) i') =
    ↑((fun i => ⟨limit.π (F ⋙ π A) i, ⋯⟩) i ≫ F.map f)
state_after: no goals
tactic: simpa using (limit.w _ _).symm
Theorem: DifferentiableOn.add_iff_right
File: Mathlib/Analysis/Calculus/FDeriv/Add.lean

Proof steps:
state_before: 𝕜 : Type u_1
inst✝⁸ : NontriviallyNormedField 𝕜
E : Type u_2
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type u_3
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type u_4
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
G' : Type u_5
inst✝¹ : NormedAddCommGroup G'
inst✝ : NormedSpace 𝕜 G'
f f₀ f₁ g : E → F
f' f₀' f₁' g' e : E →L[𝕜] F
x : E
s t : Set E
L L₁ L₂ : Filter E
hg : DifferentiableOn 𝕜 f s
⊢ DifferentiableOn 𝕜 (fun y => f y + g y) s ↔ DifferentiableOn 𝕜 g s
state_after: no goals
tactic: simp only [add_comm (f _), hg.add_iff_left]
Theorem: CategoryTheory.Idempotents.functorExtension₁CompWhiskeringLeftToKaroubiIso_inv_app_app_f
File: Mathlib/CategoryTheory/Idempotents/FunctorExtension.lean

Proof steps:
state_before: C : Type u_1
D : Type u_2
E : Type u_3
inst✝² : Category.{?u.29860, u_1} C
inst✝¹ : Category.{?u.29864, u_2} D
inst✝ : Category.{?u.29868, u_3} E
F : C ⥤ Karoubi D
X Y : C
f : X ⟶ Y
⊢ ((functorExtension₁ C D ⋙ (whiskeringLeft C (Karoubi C) (Karoubi D)).obj (toKaroubi C)).obj F).map f ≫
      ((fun X =>
            { hom := { f := (F.obj X).p, comm := ⋯ }, inv := { f := (F.obj X).p, comm := ⋯ }, hom_inv_id := ⋯,
              inv_hom_id := ⋯ })
          Y).hom =
    ((fun X =>
            { hom := { f := (F.obj X).p, comm := ⋯ }, inv := { f := (F.obj X).p, comm := ⋯ }, hom_inv_id := ⋯,
              inv_hom_id := ⋯ })
          X).hom ≫
      ((𝟭 (C ⥤ Karoubi D)).obj F).map f
state_after: no goals
tactic: aesop_cat
state_before: C : Type u_1
D : Type u_2
E : Type u_3
inst✝² : Category.{?u.29860, u_1} C
inst✝¹ : Category.{?u.29864, u_2} D
inst✝ : Category.{?u.29868, u_3} E
⊢ ∀ {X Y : C ⥤ Karoubi D} (f : X ⟶ Y),
    (functorExtension₁ C D ⋙ (whiskeringLeft C (Karoubi C) (Karoubi D)).obj (toKaroubi C)).map f ≫
        ((fun F =>
              NatIso.ofComponents
                (fun X =>
                  { hom := { f := (F.obj X).p, comm := ⋯ }, inv := { f := (F.obj X).p, comm := ⋯ }, hom_inv_id := ⋯,
                    inv_hom_id := ⋯ })
                ⋯)
            Y).hom =
      ((fun F =>
              NatIso.ofComponents
                (fun X =>
                  { hom := { f := (F.obj X).p, comm := ⋯ }, inv := { f := (F.obj X).p, comm := ⋯ }, hom_inv_id := ⋯,
                    inv_hom_id := ⋯ })
                ⋯)
            X).hom ≫
        (𝟭 (C ⥤ Karoubi D)).map f
state_after: no goals
tactic: aesop_cat
Theorem: PiTensorProduct.injectiveSeminorm_apply
File: Mathlib/Analysis/NormedSpace/PiTensorProduct/InjectiveSeminorm.lean

Proof steps:
state_before: ι : Type uι
inst✝⁵ : Fintype ι
𝕜 : Type u𝕜
inst✝⁴ : NontriviallyNormedField 𝕜
E : ι → Type uE
inst✝³ : (i : ι) → SeminormedAddCommGroup (E i)
inst✝² : (i : ι) → NormedSpace 𝕜 (E i)
F : Type uF
inst✝¹ : SeminormedAddCommGroup F
inst✝ : NormedSpace 𝕜 F
x : ⨂[𝕜] (i : ι), E i
⊢ injectiveSeminorm x = ⨆ p, ↑p x
state_after: no goals
tactic: simpa only [injectiveSeminorm, Set.coe_setOf, Set.mem_setOf_eq]
    using Seminorm.sSup_apply dualSeminorms_bounded
Theorem: dvd_prime_pow
File: Mathlib/Algebra/Associated/Basic.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝ : CancelCommMonoidWithZero α
p q : α
hp : Prime p
n : ℕ
⊢ q ∣ p ^ n ↔ ∃ i, i ≤ n ∧ q ~ᵤ p ^ i
state_after: case zero
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝ : CancelCommMonoidWithZero α
p : α
hp : Prime p
q : α
⊢ q ∣ p ^ 0 ↔ ∃ i, i ≤ 0 ∧ q ~ᵤ p ^ i

case succ
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝ : CancelCommMonoidWithZero α
p : α
hp : Prime p
n : ℕ
ih : ∀ {q : α}, q ∣ p ^ n ↔ ∃ i, i ≤ n ∧ q ~ᵤ p ^ i
q : α
⊢ q ∣ p ^ (n + 1) ↔ ∃ i, i ≤ n + 1 ∧ q ~ᵤ p ^ i
tactic: induction' n with n ih generalizing q
state_before: case succ
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝ : CancelCommMonoidWithZero α
p : α
hp : Prime p
n : ℕ
ih : ∀ {q : α}, q ∣ p ^ n ↔ ∃ i, i ≤ n ∧ q ~ᵤ p ^ i
q : α
⊢ q ∣ p ^ (n + 1) ↔ ∃ i, i ≤ n + 1 ∧ q ~ᵤ p ^ i
state_after: case succ
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝ : CancelCommMonoidWithZero α
p : α
hp : Prime p
n : ℕ
ih : ∀ {q : α}, q ∣ p ^ n ↔ ∃ i, i ≤ n ∧ q ~ᵤ p ^ i
q : α
h : q ∣ p ^ (n + 1)
⊢ ∃ i, i ≤ n + 1 ∧ q ~ᵤ p ^ i
tactic: refine ⟨fun h => ?_, fun ⟨i, hi, hq⟩ => hq.dvd.trans (pow_dvd_pow p hi)⟩
state_before: case succ
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝ : CancelCommMonoidWithZero α
p : α
hp : Prime p
n : ℕ
ih : ∀ {q : α}, q ∣ p ^ n ↔ ∃ i, i ≤ n ∧ q ~ᵤ p ^ i
q : α
h : q ∣ p ^ (n + 1)
⊢ ∃ i, i ≤ n + 1 ∧ q ~ᵤ p ^ i
state_after: case succ
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝ : CancelCommMonoidWithZero α
p : α
hp : Prime p
n : ℕ
ih : ∀ {q : α}, q ∣ p ^ n ↔ ∃ i, i ≤ n ∧ q ~ᵤ p ^ i
q : α
h : q ∣ p * p ^ n
⊢ ∃ i, i ≤ n + 1 ∧ q ~ᵤ p ^ i
tactic: rw [pow_succ'] at h
state_before: case succ
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝ : CancelCommMonoidWithZero α
p : α
hp : Prime p
n : ℕ
ih : ∀ {q : α}, q ∣ p ^ n ↔ ∃ i, i ≤ n ∧ q ~ᵤ p ^ i
q : α
h : q ∣ p * p ^ n
⊢ ∃ i, i ≤ n + 1 ∧ q ~ᵤ p ^ i
state_after: case succ.inl.intro
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝ : CancelCommMonoidWithZero α
p : α
hp : Prime p
n : ℕ
ih : ∀ {q : α}, q ∣ p ^ n ↔ ∃ i, i ≤ n ∧ q ~ᵤ p ^ i
q : α
h : p * q ∣ p * p ^ n
⊢ ∃ i, i ≤ n + 1 ∧ p * q ~ᵤ p ^ i

case succ.inr
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝ : CancelCommMonoidWithZero α
p : α
hp : Prime p
n : ℕ
ih : ∀ {q : α}, q ∣ p ^ n ↔ ∃ i, i ≤ n ∧ q ~ᵤ p ^ i
q : α
h : q ∣ p * p ^ n
hno : q ∣ p ^ n
⊢ ∃ i, i ≤ n + 1 ∧ q ~ᵤ p ^ i
tactic: rcases hp.left_dvd_or_dvd_right_of_dvd_mul h with (⟨q, rfl⟩ | hno)
Theorem: Nat.pair_lt_pair_right
File: Mathlib/Data/Nat/Pairing.lean

Proof steps:
state_before: a b₁ b₂ : ℕ
h : b₁ < b₂
⊢ pair a b₁ < pair a b₂
state_after: case pos
a b₁ b₂ : ℕ
h : b₁ < b₂
h₁ : a < b₁
⊢ pair a b₁ < pair a b₂

case neg
a b₁ b₂ : ℕ
h : b₁ < b₂
h₁ : ¬a < b₁
⊢ pair a b₁ < pair a b₂
tactic: by_cases h₁ : a < b₁
Theorem: VectorFourier.integrable_fourierPowSMulRight
File: Mathlib/Analysis/Fourier/FourierTransformDeriv.lean

Proof steps:
state_before: E : Type u_1
inst✝⁸ : NormedAddCommGroup E
inst✝⁷ : NormedSpace ℂ E
V : Type u_2
W : Type u_3
inst✝⁶ : NormedAddCommGroup V
inst✝⁵ : NormedSpace ℝ V
inst✝⁴ : NormedAddCommGroup W
inst✝³ : NormedSpace ℝ W
L : V →L[ℝ] W →L[ℝ] ℝ
f : V → E
inst✝² : SecondCountableTopology V
inst✝¹ : MeasurableSpace V
inst✝ : BorelSpace V
μ : Measure V
n : ℕ
hf : Integrable (fun v => ‖v‖ ^ n * ‖f v‖) μ
h'f : AEStronglyMeasurable f μ
⊢ Integrable (fun v => fourierPowSMulRight L f v n) μ
state_after: E : Type u_1
inst✝⁸ : NormedAddCommGroup E
inst✝⁷ : NormedSpace ℂ E
V : Type u_2
W : Type u_3
inst✝⁶ : NormedAddCommGroup V
inst✝⁵ : NormedSpace ℝ V
inst✝⁴ : NormedAddCommGroup W
inst✝³ : NormedSpace ℝ W
L : V →L[ℝ] W →L[ℝ] ℝ
f : V → E
inst✝² : SecondCountableTopology V
inst✝¹ : MeasurableSpace V
inst✝ : BorelSpace V
μ : Measure V
n : ℕ
hf : Integrable (fun v => ‖v‖ ^ n * ‖f v‖) μ
h'f : AEStronglyMeasurable f μ
⊢ ∀ᵐ (a : V) ∂μ, ‖fourierPowSMulRight L f a n‖ ≤ (2 * π * ‖L‖) ^ n * (‖a‖ ^ n * ‖f a‖)
tactic: refine (hf.const_mul ((2 * π * ‖L‖) ^ n)).mono' (h'f.fourierPowSMulRight L n) ?_
state_before: E : Type u_1
inst✝⁸ : NormedAddCommGroup E
inst✝⁷ : NormedSpace ℂ E
V : Type u_2
W : Type u_3
inst✝⁶ : NormedAddCommGroup V
inst✝⁵ : NormedSpace ℝ V
inst✝⁴ : NormedAddCommGroup W
inst✝³ : NormedSpace ℝ W
L : V →L[ℝ] W →L[ℝ] ℝ
f : V → E
inst✝² : SecondCountableTopology V
inst✝¹ : MeasurableSpace V
inst✝ : BorelSpace V
μ : Measure V
n : ℕ
hf : Integrable (fun v => ‖v‖ ^ n * ‖f v‖) μ
h'f : AEStronglyMeasurable f μ
⊢ ∀ᵐ (a : V) ∂μ, ‖fourierPowSMulRight L f a n‖ ≤ (2 * π * ‖L‖) ^ n * (‖a‖ ^ n * ‖f a‖)
state_after: case h
E : Type u_1
inst✝⁸ : NormedAddCommGroup E
inst✝⁷ : NormedSpace ℂ E
V : Type u_2
W : Type u_3
inst✝⁶ : NormedAddCommGroup V
inst✝⁵ : NormedSpace ℝ V
inst✝⁴ : NormedAddCommGroup W
inst✝³ : NormedSpace ℝ W
L : V →L[ℝ] W →L[ℝ] ℝ
f : V → E
inst✝² : SecondCountableTopology V
inst✝¹ : MeasurableSpace V
inst✝ : BorelSpace V
μ : Measure V
n : ℕ
hf : Integrable (fun v => ‖v‖ ^ n * ‖f v‖) μ
h'f : AEStronglyMeasurable f μ
v : V
⊢ ‖fourierPowSMulRight L f v n‖ ≤ (2 * π * ‖L‖) ^ n * (‖v‖ ^ n * ‖f v‖)
tactic: filter_upwards with v
state_before: case h
E : Type u_1
inst✝⁸ : NormedAddCommGroup E
inst✝⁷ : NormedSpace ℂ E
V : Type u_2
W : Type u_3
inst✝⁶ : NormedAddCommGroup V
inst✝⁵ : NormedSpace ℝ V
inst✝⁴ : NormedAddCommGroup W
inst✝³ : NormedSpace ℝ W
L : V →L[ℝ] W →L[ℝ] ℝ
f : V → E
inst✝² : SecondCountableTopology V
inst✝¹ : MeasurableSpace V
inst✝ : BorelSpace V
μ : Measure V
n : ℕ
hf : Integrable (fun v => ‖v‖ ^ n * ‖f v‖) μ
h'f : AEStronglyMeasurable f μ
v : V
⊢ ‖fourierPowSMulRight L f v n‖ ≤ (2 * π * ‖L‖) ^ n * (‖v‖ ^ n * ‖f v‖)
state_after: no goals
tactic: exact (norm_fourierPowSMulRight_le L f v n).trans (le_of_eq (by ring))
Theorem: FirstOrder.Language.Embedding.subtype_equivRange
File: Mathlib/ModelTheory/Substructures.lean

Proof steps:
state_before: L : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝² : L.Structure M
inst✝¹ : L.Structure N
inst✝ : L.Structure P
S : L.Substructure M
f : M ↪[L] N
⊢ f.toHom.range.subtype.comp f.equivRange.toEmbedding = f
state_after: case h
L : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝² : L.Structure M
inst✝¹ : L.Structure N
inst✝ : L.Structure P
S : L.Substructure M
f : M ↪[L] N
x✝ : M
⊢ (f.toHom.range.subtype.comp f.equivRange.toEmbedding) x✝ = f x✝
tactic: ext
state_before: case h
L : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝² : L.Structure M
inst✝¹ : L.Structure N
inst✝ : L.Structure P
S : L.Substructure M
f : M ↪[L] N
x✝ : M
⊢ (f.toHom.range.subtype.comp f.equivRange.toEmbedding) x✝ = f x✝
state_after: no goals
tactic: rfl
Theorem: NormedSpace.dualPairing_separatingLeft
File: Mathlib/Analysis/Normed/Module/Dual.lean

Proof steps:
state_before: 𝕜 : Type u_1
inst✝⁴ : NontriviallyNormedField 𝕜
E : Type u_2
inst✝³ : SeminormedAddCommGroup E
inst✝² : NormedSpace 𝕜 E
F : Type u_3
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedSpace 𝕜 F
⊢ (dualPairing 𝕜 E).SeparatingLeft
state_after: 𝕜 : Type u_1
inst✝⁴ : NontriviallyNormedField 𝕜
E : Type u_2
inst✝³ : SeminormedAddCommGroup E
inst✝² : NormedSpace 𝕜 E
F : Type u_3
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedSpace 𝕜 F
⊢ Function.Injective ⇑(dualPairing 𝕜 E)
tactic: rw [LinearMap.separatingLeft_iff_ker_eq_bot, LinearMap.ker_eq_bot]
state_before: 𝕜 : Type u_1
inst✝⁴ : NontriviallyNormedField 𝕜
E : Type u_2
inst✝³ : SeminormedAddCommGroup E
inst✝² : NormedSpace 𝕜 E
F : Type u_3
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedSpace 𝕜 F
⊢ Function.Injective ⇑(dualPairing 𝕜 E)
state_after: no goals
tactic: exact ContinuousLinearMap.coe_injective
Theorem: Metric.preimage_smul_sphere
File: Mathlib/Topology/MetricSpace/IsometricSMul.lean

Proof steps:
state_before: M : Type u
G : Type v
X : Type w
inst✝³ : PseudoMetricSpace X
inst✝² : Group G
inst✝¹ : MulAction G X
inst✝ : IsometricSMul G X
c : G
x : X
r : ℝ
⊢ (fun x => c • x) ⁻¹' sphere x r = sphere (c⁻¹ • x) r
state_after: no goals
tactic: rw [preimage_smul, smul_sphere]
Theorem: Subbimodule.smul_mem
File: Mathlib/Algebra/Module/Bimodule.lean

Proof steps:
state_before: R : Type u_1
A : Type u_2
B : Type u_3
M : Type u_4
inst✝¹¹ : CommSemiring R
inst✝¹⁰ : AddCommMonoid M
inst✝⁹ : Module R M
inst✝⁸ : Semiring A
inst✝⁷ : Semiring B
inst✝⁶ : Module A M
inst✝⁵ : Module B M
inst✝⁴ : Algebra R A
inst✝³ : Algebra R B
inst✝² : IsScalarTower R A M
inst✝¹ : IsScalarTower R B M
inst✝ : SMulCommClass A B M
p : Submodule (A ⊗[R] B) M
a : A
m : M
hm : m ∈ p
⊢ a • m ∈ p
state_after: R : Type u_1
A : Type u_2
B : Type u_3
M : Type u_4
inst✝¹¹ : CommSemiring R
inst✝¹⁰ : AddCommMonoid M
inst✝⁹ : Module R M
inst✝⁸ : Semiring A
inst✝⁷ : Semiring B
inst✝⁶ : Module A M
inst✝⁵ : Module B M
inst✝⁴ : Algebra R A
inst✝³ : Algebra R B
inst✝² : IsScalarTower R A M
inst✝¹ : IsScalarTower R B M
inst✝ : SMulCommClass A B M
p : Submodule (A ⊗[R] B) M
a : A
m : M
hm : m ∈ p
⊢ a • m = a ⊗ₜ[R] 1 • m
tactic: suffices a • m = a ⊗ₜ[R] (1 : B) • m by exact this.symm ▸ p.smul_mem _ hm
state_before: R : Type u_1
A : Type u_2
B : Type u_3
M : Type u_4
inst✝¹¹ : CommSemiring R
inst✝¹⁰ : AddCommMonoid M
inst✝⁹ : Module R M
inst✝⁸ : Semiring A
inst✝⁷ : Semiring B
inst✝⁶ : Module A M
inst✝⁵ : Module B M
inst✝⁴ : Algebra R A
inst✝³ : Algebra R B
inst✝² : IsScalarTower R A M
inst✝¹ : IsScalarTower R B M
inst✝ : SMulCommClass A B M
p : Submodule (A ⊗[R] B) M
a : A
m : M
hm : m ∈ p
⊢ a • m = a ⊗ₜ[R] 1 • m
state_after: no goals
tactic: simp [TensorProduct.Algebra.smul_def]
Theorem: FreeGroup.Red.cons_nil_iff_singleton
File: Mathlib/GroupTheory/FreeGroup/Basic.lean

Proof steps:
state_before: α : Type u
L L₁ L₂ L₃ L₄ : List (α × Bool)
x : α
b : Bool
h : Red ((x, b) :: L) []
⊢ Red L [(x, !b)]
state_after: α : Type u
L L₁ L₂ L₃ L₄ : List (α × Bool)
x : α
b : Bool
h : Red ((x, b) :: L) []
h₁ : Red ((x, !b) :: (x, b) :: L) [(x, !b)]
⊢ Red L [(x, !b)]
tactic: have h₁ : Red ((x, not b) :: (x, b) :: L) [(x, not b)] := cons_cons h
state_before: α : Type u
L L₁ L₂ L₃ L₄ : List (α × Bool)
x : α
b : Bool
h : Red ((x, b) :: L) []
h₁ : Red ((x, !b) :: (x, b) :: L) [(x, !b)]
⊢ Red L [(x, !b)]
state_after: α : Type u
L L₁ L₂ L₃ L₄ : List (α × Bool)
x : α
b : Bool
h : Red ((x, b) :: L) []
h₁ : Red ((x, !b) :: (x, b) :: L) [(x, !b)]
h₂ : Red ((x, !b) :: (x, b) :: L) L
⊢ Red L [(x, !b)]
tactic: have h₂ : Red ((x, not b) :: (x, b) :: L) L := ReflTransGen.single Step.cons_not_rev
state_before: α : Type u
L L₁ L₂ L₃ L₄ : List (α × Bool)
x : α
b : Bool
h : Red ((x, b) :: L) []
h₁ : Red ((x, !b) :: (x, b) :: L) [(x, !b)]
h₂ : Red ((x, !b) :: (x, b) :: L) L
⊢ Red L [(x, !b)]
state_after: α : Type u
L L₁ L₂ L₃ L₄ : List (α × Bool)
x : α
b : Bool
h : Red ((x, b) :: L) []
h₁✝ : Red ((x, !b) :: (x, b) :: L) [(x, !b)]
h₂✝ : Red ((x, !b) :: (x, b) :: L) L
L' : List (α × Bool)
h₁ : Red [(x, !b)] L'
h₂ : Red L L'
⊢ Red L [(x, !b)]
tactic: let ⟨L', h₁, h₂⟩ := church_rosser h₁ h₂
state_before: α : Type u
L L₁ L₂ L₃ L₄ : List (α × Bool)
x : α
b : Bool
h : Red ((x, b) :: L) []
h₁✝ : Red ((x, !b) :: (x, b) :: L) [(x, !b)]
h₂✝ : Red ((x, !b) :: (x, b) :: L) L
L' : List (α × Bool)
h₁ : Red [(x, !b)] L'
h₂ : Red L L'
⊢ Red L [(x, !b)]
state_after: α : Type u
L L₁ L₂ L₃ L₄ : List (α × Bool)
x : α
b : Bool
h : Red ((x, b) :: L) []
h₁✝ : Red ((x, !b) :: (x, b) :: L) [(x, !b)]
h₂✝ : Red ((x, !b) :: (x, b) :: L) L
L' : List (α × Bool)
h₁ : L' = [(x, !b)]
h₂ : Red L L'
⊢ Red L [(x, !b)]
tactic: rw [singleton_iff] at h₁
state_before: α : Type u
L L₁ L₂ L₃ L₄ : List (α × Bool)
x : α
b : Bool
h : Red ((x, b) :: L) []
h₁✝ : Red ((x, !b) :: (x, b) :: L) [(x, !b)]
h₂✝ : Red ((x, !b) :: (x, b) :: L) L
L' : List (α × Bool)
h₁ : L' = [(x, !b)]
h₂ : Red L L'
⊢ Red L [(x, !b)]
state_after: α : Type u
L L₁ L₂ L₃ L₄ : List (α × Bool)
x : α
b : Bool
h : Red ((x, b) :: L) []
h₁ : Red ((x, !b) :: (x, b) :: L) [(x, !b)]
h₂✝ : Red ((x, !b) :: (x, b) :: L) L
h₂ : Red L [(x, !b)]
⊢ Red L [(x, !b)]
tactic: subst L'
state_before: α : Type u
L L₁ L₂ L₃ L₄ : List (α × Bool)
x : α
b : Bool
h : Red ((x, b) :: L) []
h₁ : Red ((x, !b) :: (x, b) :: L) [(x, !b)]
h₂✝ : Red ((x, !b) :: (x, b) :: L) L
h₂ : Red L [(x, !b)]
⊢ Red L [(x, !b)]
state_after: no goals
tactic: assumption