ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: HomologicalComplex.unopEquivalence_unitIso
File: Mathlib/Algebra/Homology/Opposite.lean

Proof steps:
state_before: ι : Type u_1
V : Type u_2
inst✝¹ : Category.{?u.66755, u_2} V
c : ComplexShape ι
inst✝ : HasZeroMorphisms V
X : (HomologicalComplex Vᵒᵖ c)ᵒᵖ
⊢ (unopFunctor V c).map ((unopUnitIso V c).hom.app X) ≫ (unopCounitIso V c).hom.app ((unopFunctor V c).obj X) =
    𝟙 ((unopFunctor V c).obj X)
state_after: case h
ι : Type u_1
V : Type u_2
inst✝¹ : Category.{?u.66755, u_2} V
c : ComplexShape ι
inst✝ : HasZeroMorphisms V
X : (HomologicalComplex Vᵒᵖ c)ᵒᵖ
i✝ : ι
⊢ ((unopFunctor V c).map ((unopUnitIso V c).hom.app X) ≫ (unopCounitIso V c).hom.app ((unopFunctor V c).obj X)).f i✝ =
    (𝟙 ((unopFunctor V c).obj X)).f i✝
tactic: ext
state_before: case h
ι : Type u_1
V : Type u_2
inst✝¹ : Category.{?u.66755, u_2} V
c : ComplexShape ι
inst✝ : HasZeroMorphisms V
X : (HomologicalComplex Vᵒᵖ c)ᵒᵖ
i✝ : ι
⊢ ((unopFunctor V c).map ((unopUnitIso V c).hom.app X) ≫ (unopCounitIso V c).hom.app ((unopFunctor V c).obj X)).f i✝ =
    (𝟙 ((unopFunctor V c).obj X)).f i✝
state_after: case h
ι : Type u_1
V : Type u_2
inst✝¹ : Category.{?u.66755, u_2} V
c : ComplexShape ι
inst✝ : HasZeroMorphisms V
X : (HomologicalComplex Vᵒᵖ c)ᵒᵖ
i✝ : ι
⊢ ((unopFunctor V c).map ((unopUnitIso V c).hom.app X)).f i✝ ≫
      ((unopCounitIso V c).hom.app ((unopFunctor V c).obj X)).f i✝ =
    (𝟙 ((unopFunctor V c).obj X)).f i✝
tactic: simp only [opUnitIso, opCounitIso, NatIso.ofComponents_hom_app, Iso.op_hom, comp_f,
      opFunctor_map_f, Quiver.Hom.unop_op, Hom.isoOfComponents_hom_f]
state_before: case h
ι : Type u_1
V : Type u_2
inst✝¹ : Category.{?u.66755, u_2} V
c : ComplexShape ι
inst✝ : HasZeroMorphisms V
X : (HomologicalComplex Vᵒᵖ c)ᵒᵖ
i✝ : ι
⊢ ((unopFunctor V c).map ((unopUnitIso V c).hom.app X)).f i✝ ≫
      ((unopCounitIso V c).hom.app ((unopFunctor V c).obj X)).f i✝ =
    (𝟙 ((unopFunctor V c).obj X)).f i✝
state_after: no goals
tactic: exact Category.comp_id _
Theorem: Set.Iic.coe_iInf
File: Mathlib/Order/CompleteLatticeIntervals.lean

Proof steps:
state_before: ι : Sort u_1
α : Type u_2
s : Set α
inst✝ : CompleteLattice α
a : α
S : Set ↑(Iic a)
f : ι → ↑(Iic a)
p : ι → Prop
⊢ ↑(⨅ i, f i) = a ⊓ ⨅ i, ↑(f i)
state_after: ι : Sort u_1
α : Type u_2
s : Set α
inst✝ : CompleteLattice α
a : α
S : Set ↑(Iic a)
f : ι → ↑(Iic a)
p : ι → Prop
⊢ a ⊓ sInf (Subtype.val '' range fun i => f i) = a ⊓ ⨅ i, ↑(f i)
tactic: rw [iInf, coe_sInf]
state_before: ι : Sort u_1
α : Type u_2
s : Set α
inst✝ : CompleteLattice α
a : α
S : Set ↑(Iic a)
f : ι → ↑(Iic a)
p : ι → Prop
⊢ a ⊓ sInf (Subtype.val '' range fun i => f i) = a ⊓ ⨅ i, ↑(f i)
state_after: case e_a.e_a
ι : Sort u_1
α : Type u_2
s : Set α
inst✝ : CompleteLattice α
a : α
S : Set ↑(Iic a)
f : ι → ↑(Iic a)
p : ι → Prop
⊢ (Subtype.val '' range fun i => f i) = range fun i => ↑(f i)
tactic: congr
state_before: case e_a.e_a
ι : Sort u_1
α : Type u_2
s : Set α
inst✝ : CompleteLattice α
a : α
S : Set ↑(Iic a)
f : ι → ↑(Iic a)
p : ι → Prop
⊢ (Subtype.val '' range fun i => f i) = range fun i => ↑(f i)
state_after: case e_a.e_a.h
ι : Sort u_1
α : Type u_2
s : Set α
inst✝ : CompleteLattice α
a : α
S : Set ↑(Iic a)
f : ι → ↑(Iic a)
p : ι → Prop
x✝ : α
⊢ (x✝ ∈ Subtype.val '' range fun i => f i) ↔ x✝ ∈ range fun i => ↑(f i)
tactic: ext
state_before: case e_a.e_a.h
ι : Sort u_1
α : Type u_2
s : Set α
inst✝ : CompleteLattice α
a : α
S : Set ↑(Iic a)
f : ι → ↑(Iic a)
p : ι → Prop
x✝ : α
⊢ (x✝ ∈ Subtype.val '' range fun i => f i) ↔ x✝ ∈ range fun i => ↑(f i)
state_after: no goals
tactic: simp
Theorem: IsLocalization.ker_map
File: Mathlib/RingTheory/Localization/Algebra.lean

Proof steps:
state_before: R : Type u_1
S : Type u_2
P : Type u_3
Q : Type u_4
inst✝⁷ : CommSemiring R
inst✝⁶ : CommSemiring S
inst✝⁵ : CommSemiring P
inst✝⁴ : CommSemiring Q
M : Submonoid R
T : Submonoid P
inst✝³ : Algebra R S
inst✝² : Algebra P Q
inst✝¹ : IsLocalization M S
inst✝ : IsLocalization T Q
g : R →+* P
hT : Submonoid.map g M = T
⊢ RingHom.ker (map Q g ⋯) = Ideal.map (algebraMap R S) (RingHom.ker g)
state_after: case h
R : Type u_1
S : Type u_2
P : Type u_3
Q : Type u_4
inst✝⁷ : CommSemiring R
inst✝⁶ : CommSemiring S
inst✝⁵ : CommSemiring P
inst✝⁴ : CommSemiring Q
M : Submonoid R
T : Submonoid P
inst✝³ : Algebra R S
inst✝² : Algebra P Q
inst✝¹ : IsLocalization M S
inst✝ : IsLocalization T Q
g : R →+* P
hT : Submonoid.map g M = T
x : S
⊢ x ∈ RingHom.ker (map Q g ⋯) ↔ x ∈ Ideal.map (algebraMap R S) (RingHom.ker g)
tactic: ext x
state_before: case h
R : Type u_1
S : Type u_2
P : Type u_3
Q : Type u_4
inst✝⁷ : CommSemiring R
inst✝⁶ : CommSemiring S
inst✝⁵ : CommSemiring P
inst✝⁴ : CommSemiring Q
M : Submonoid R
T : Submonoid P
inst✝³ : Algebra R S
inst✝² : Algebra P Q
inst✝¹ : IsLocalization M S
inst✝ : IsLocalization T Q
g : R →+* P
hT : Submonoid.map g M = T
x : S
⊢ x ∈ RingHom.ker (map Q g ⋯) ↔ x ∈ Ideal.map (algebraMap R S) (RingHom.ker g)
state_after: case h.intro.intro
R : Type u_1
S : Type u_2
P : Type u_3
Q : Type u_4
inst✝⁷ : CommSemiring R
inst✝⁶ : CommSemiring S
inst✝⁵ : CommSemiring P
inst✝⁴ : CommSemiring Q
M : Submonoid R
T : Submonoid P
inst✝³ : Algebra R S
inst✝² : Algebra P Q
inst✝¹ : IsLocalization M S
inst✝ : IsLocalization T Q
g : R →+* P
hT : Submonoid.map g M = T
x : R
s : ↥M
⊢ mk' S x s ∈ RingHom.ker (map Q g ⋯) ↔ mk' S x s ∈ Ideal.map (algebraMap R S) (RingHom.ker g)
tactic: obtain ⟨x, s, rfl⟩ := IsLocalization.mk'_surjective M x
state_before: case h.intro.intro
R : Type u_1
S : Type u_2
P : Type u_3
Q : Type u_4
inst✝⁷ : CommSemiring R
inst✝⁶ : CommSemiring S
inst✝⁵ : CommSemiring P
inst✝⁴ : CommSemiring Q
M : Submonoid R
T : Submonoid P
inst✝³ : Algebra R S
inst✝² : Algebra P Q
inst✝¹ : IsLocalization M S
inst✝ : IsLocalization T Q
g : R →+* P
hT : Submonoid.map g M = T
x : R
s : ↥M
⊢ mk' S x s ∈ RingHom.ker (map Q g ⋯) ↔ mk' S x s ∈ Ideal.map (algebraMap R S) (RingHom.ker g)
state_after: no goals
tactic: simp [RingHom.mem_ker, IsLocalization.map_mk', IsLocalization.mk'_eq_zero_iff,
    IsLocalization.mk'_mem_map_algebraMap_iff, ← hT]
Theorem: Nat.greatestFib_pos
File: Mathlib/Data/Nat/Fib/Zeckendorf.lean

Proof steps:
state_before: l : List ℕ
a m n : ℕ
⊢ 0 < n.greatestFib ↔ 0 < n
state_after: no goals
tactic: simp [pos_iff_ne_zero]
Theorem: MeasureTheory.IntegrableOn.restrict
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✝ : NormedAddCommGroup E
f g : α → E
s t : Set α
μ ν : Measure α
h : IntegrableOn f s μ
hs : MeasurableSet s
⊢ IntegrableOn f s (μ.restrict t)
state_after: α : Type u_1
β : Type u_2
E : Type u_3
F : Type u_4
inst✝¹ : MeasurableSpace α
inst✝ : NormedAddCommGroup E
f g : α → E
s t : Set α
μ ν : Measure α
h : IntegrableOn f s μ
hs : MeasurableSet s
⊢ Integrable f (μ.restrict (s ∩ t))
tactic: rw [IntegrableOn, Measure.restrict_restrict hs]
state_before: α : Type u_1
β : Type u_2
E : Type u_3
F : Type u_4
inst✝¹ : MeasurableSpace α
inst✝ : NormedAddCommGroup E
f g : α → E
s t : Set α
μ ν : Measure α
h : IntegrableOn f s μ
hs : MeasurableSet s
⊢ Integrable f (μ.restrict (s ∩ t))
state_after: no goals
tactic: exact h.mono_set inter_subset_left
Theorem: AlgebraicGeometry.IsAffineOpen.basicOpen
File: Mathlib/AlgebraicGeometry/AffineScheme.lean

Proof steps:
state_before: X Y : Scheme
U : X.Opens
hU : IsAffineOpen U
f : ↑Γ(X, U)
⊢ IsAffineOpen (X.basicOpen f)
state_after: X Y : Scheme
U : X.Opens
hU : IsAffineOpen U
f : ↑Γ(X, U)
⊢ IsAffineOpen (PrimeSpectrum.basicOpen f)
tactic: rw [← hU.fromSpec_image_basicOpen, Scheme.Hom.isAffineOpen_iff_of_isOpenImmersion]
state_before: X Y : Scheme
U : X.Opens
hU : IsAffineOpen U
f : ↑Γ(X, U)
⊢ IsAffineOpen (PrimeSpectrum.basicOpen f)
state_after: case h.e'_2.h
X Y : Scheme
U : X.Opens
hU : IsAffineOpen U
f : ↑Γ(X, U)
e_1✝ : Spec Γ(X, U) = Spec (CommRingCat.of ↑Γ(X, U))
⊢ PrimeSpectrum.basicOpen f =
    Scheme.Hom.opensRange (Spec.map (CommRingCat.ofHom (algebraMap (↑Γ(X, U)) (Localization.Away f))))
tactic: convert isAffineOpen_opensRange
    (Spec.map (CommRingCat.ofHom <| algebraMap Γ(X, U) (Localization.Away f)))
state_before: case h.e'_2.h
X Y : Scheme
U : X.Opens
hU : IsAffineOpen U
f : ↑Γ(X, U)
e_1✝ : Spec Γ(X, U) = Spec (CommRingCat.of ↑Γ(X, U))
⊢ PrimeSpectrum.basicOpen f =
    Scheme.Hom.opensRange (Spec.map (CommRingCat.ofHom (algebraMap (↑Γ(X, U)) (Localization.Away f))))
state_after: no goals
tactic: exact Opens.ext (PrimeSpectrum.localization_away_comap_range (Localization.Away f) f).symm
Theorem: Nat.factorization_eq_card_pow_dvd
File: Mathlib/Data/Nat/Factorization/Basic.lean

Proof steps:
state_before: a b m n✝ p✝ n p : ℕ
pp : Prime p
⊢ n.factorization p = (Finset.filter (fun i => p ^ i ∣ n) (Ico 1 n)).card
state_after: no goals
tactic: simp [← Icc_factorization_eq_pow_dvd n pp]
Theorem: CategoryTheory.Discrete.equivOfEquivalence_apply
File: Mathlib/CategoryTheory/DiscreteCategory.lean

Proof steps:
state_before: α✝ : Type u₁
C : Type u₂
inst✝ : Category.{v₂, u₂} C
α : Type u₁
β : Type u₂
h : Discrete α ≌ Discrete β
a : α
⊢ (as ∘ h.inverse.obj ∘ mk) ((as ∘ h.functor.obj ∘ mk) a) = a
state_after: no goals
tactic: simpa using eq_of_hom (h.unitIso.app (Discrete.mk a)).2
state_before: α✝ : Type u₁
C : Type u₂
inst✝ : Category.{v₂, u₂} C
α : Type u₁
β : Type u₂
h : Discrete α ≌ Discrete β
a : β
⊢ (as ∘ h.functor.obj ∘ mk) ((as ∘ h.inverse.obj ∘ mk) a) = a
state_after: no goals
tactic: simpa using eq_of_hom (h.counitIso.app (Discrete.mk a)).1
Theorem: MeasureTheory.Measure.haar.prehaar_sup_eq
File: Mathlib/MeasureTheory/Measure/Haar/Basic.lean

Proof steps:
state_before: G : Type u_1
inst✝² : Group G
inst✝¹ : TopologicalSpace G
inst✝ : TopologicalGroup G
K₀ : PositiveCompacts G
U : Set G
K₁ K₂ : Compacts G
hU : (interior U).Nonempty
h : Disjoint (K₁.carrier * U⁻¹) (K₂.carrier * U⁻¹)
⊢ prehaar (↑K₀) U (K₁ ⊔ K₂) = prehaar (↑K₀) U K₁ + prehaar (↑K₀) U K₂
state_after: G : Type u_1
inst✝² : Group G
inst✝¹ : TopologicalSpace G
inst✝ : TopologicalGroup G
K₀ : PositiveCompacts G
U : Set G
K₁ K₂ : Compacts G
hU : (interior U).Nonempty
h : Disjoint (K₁.carrier * U⁻¹) (K₂.carrier * U⁻¹)
⊢ ↑(index (↑(K₁ ⊔ K₂)) U) / ↑(index (↑K₀) U) = ↑(index (↑K₁) U) / ↑(index (↑K₀) U) + ↑(index (↑K₂) U) / ↑(index (↑K₀) U)
tactic: simp only [prehaar]
state_before: G : Type u_1
inst✝² : Group G
inst✝¹ : TopologicalSpace G
inst✝ : TopologicalGroup G
K₀ : PositiveCompacts G
U : Set G
K₁ K₂ : Compacts G
hU : (interior U).Nonempty
h : Disjoint (K₁.carrier * U⁻¹) (K₂.carrier * U⁻¹)
⊢ ↑(index (↑(K₁ ⊔ K₂)) U) / ↑(index (↑K₀) U) = ↑(index (↑K₁) U) / ↑(index (↑K₀) U) + ↑(index (↑K₂) U) / ↑(index (↑K₀) U)
state_after: G : Type u_1
inst✝² : Group G
inst✝¹ : TopologicalSpace G
inst✝ : TopologicalGroup G
K₀ : PositiveCompacts G
U : Set G
K₁ K₂ : Compacts G
hU : (interior U).Nonempty
h : Disjoint (K₁.carrier * U⁻¹) (K₂.carrier * U⁻¹)
⊢ ↑(index (↑(K₁ ⊔ K₂)) U) / ↑(index (↑K₀) U) = (↑(index (↑K₁) U) + ↑(index (↑K₂) U)) / ↑(index (↑K₀) U)
tactic: rw [div_add_div_same]
state_before: G : Type u_1
inst✝² : Group G
inst✝¹ : TopologicalSpace G
inst✝ : TopologicalGroup G
K₀ : PositiveCompacts G
U : Set G
K₁ K₂ : Compacts G
hU : (interior U).Nonempty
h : Disjoint (K₁.carrier * U⁻¹) (K₂.carrier * U⁻¹)
⊢ ↑(index (↑(K₁ ⊔ K₂)) U) / ↑(index (↑K₀) U) = (↑(index (↑K₁) U) + ↑(index (↑K₂) U)) / ↑(index (↑K₀) U)
state_after: G : Type u_1
inst✝² : Group G
inst✝¹ : TopologicalSpace G
inst✝ : TopologicalGroup G
K₀ : PositiveCompacts G
U : Set G
K₁ K₂ : Compacts G
hU : (interior U).Nonempty
h : Disjoint (K₁.carrier * U⁻¹) (K₂.carrier * U⁻¹)
⊢ ↑(index (↑(K₁ ⊔ K₂)) U) = ↑(index (↑K₁) U) + ↑(index (↑K₂) U)
tactic: refine congr_arg (fun x : ℝ => x / index K₀ U) ?_
state_before: G : Type u_1
inst✝² : Group G
inst✝¹ : TopologicalSpace G
inst✝ : TopologicalGroup G
K₀ : PositiveCompacts G
U : Set G
K₁ K₂ : Compacts G
hU : (interior U).Nonempty
h : Disjoint (K₁.carrier * U⁻¹) (K₂.carrier * U⁻¹)
⊢ ↑(index (↑(K₁ ⊔ K₂)) U) = ↑(index (↑K₁) U) + ↑(index (↑K₂) U)
state_after: no goals
tactic: exact mod_cast index_union_eq K₁ K₂ hU h
Theorem: wbtw_swap_right_iff
File: Mathlib/Analysis/Convex/Between.lean

Proof steps:
state_before: R : Type u_1
V : Type u_2
V' : Type u_3
P : Type u_4
P' : Type u_5
inst✝⁷ : OrderedRing R
inst✝⁶ : AddCommGroup V
inst✝⁵ : Module R V
inst✝⁴ : AddTorsor V P
inst✝³ : AddCommGroup V'
inst✝² : Module R V'
inst✝¹ : AddTorsor V' P'
inst✝ : NoZeroSMulDivisors R V
x y z : P
⊢ Wbtw R x y z ∧ Wbtw R x z y ↔ y = z
state_after: R : Type u_1
V : Type u_2
V' : Type u_3
P : Type u_4
P' : Type u_5
inst✝⁷ : OrderedRing R
inst✝⁶ : AddCommGroup V
inst✝⁵ : Module R V
inst✝⁴ : AddTorsor V P
inst✝³ : AddCommGroup V'
inst✝² : Module R V'
inst✝¹ : AddTorsor V' P'
inst✝ : NoZeroSMulDivisors R V
x y z : P
⊢ Wbtw R z y x ∧ Wbtw R y z x ↔ z = y
tactic: rw [wbtw_comm, wbtw_comm (z := y), eq_comm]
state_before: R : Type u_1
V : Type u_2
V' : Type u_3
P : Type u_4
P' : Type u_5
inst✝⁷ : OrderedRing R
inst✝⁶ : AddCommGroup V
inst✝⁵ : Module R V
inst✝⁴ : AddTorsor V P
inst✝³ : AddCommGroup V'
inst✝² : Module R V'
inst✝¹ : AddTorsor V' P'
inst✝ : NoZeroSMulDivisors R V
x y z : P
⊢ Wbtw R z y x ∧ Wbtw R y z x ↔ z = y
state_after: no goals
tactic: exact wbtw_swap_left_iff R x
Theorem: NNRat.num_div_den
File: Mathlib/Data/NNRat/Lemmas.lean

Proof steps:
state_before: p q✝ q : ℚ≥0
⊢ ↑q.num / ↑q.den = q
state_after: case a
p q✝ q : ℚ≥0
⊢ ↑(↑q.num / ↑q.den) = ↑q
tactic: ext : 1
state_before: case a
p q✝ q : ℚ≥0
⊢ ↑(↑q.num / ↑q.den) = ↑q
state_after: case a
p q✝ q : ℚ≥0
⊢ ↑(↑q).num / ↑q.den = ↑q
tactic: rw [coe_div, coe_natCast, coe_natCast, num, ← Int.cast_natCast,
    Int.natAbs_of_nonneg (Rat.num_nonneg.2 q.cast_nonneg)]
state_before: case a
p q✝ q : ℚ≥0
⊢ ↑(↑q).num / ↑q.den = ↑q
state_after: no goals
tactic: exact Rat.num_div_den q
Theorem: CategoryTheory.Equivalence.changeInverse_inverse
File: Mathlib/CategoryTheory/Equivalence.lean

Proof steps:
state_before: C : Type u₁
inst✝² : Category.{v₁, u₁} C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
E : Type u₃
inst✝ : Category.{v₃, u₃} E
e : C ≌ D
G : D ⥤ C
iso : e.inverse ≅ G
X : C
⊢ e.functor.map ((e.unitIso ≪≫ isoWhiskerLeft e.functor iso).hom.app X) ≫
      (isoWhiskerRight iso.symm e.functor ≪≫ e.counitIso).hom.app (e.functor.obj X) =
    𝟙 (e.functor.obj X)
state_after: C : Type u₁
inst✝² : Category.{v₁, u₁} C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
E : Type u₃
inst✝ : Category.{v₃, u₃} E
e : C ≌ D
G : D ⥤ C
iso : e.inverse ≅ G
X : C
⊢ e.functor.map (e.unitIso.hom.app X ≫ iso.hom.app (e.functor.obj X)) ≫
      e.functor.map (iso.inv.app (e.functor.obj X)) ≫ e.counitIso.hom.app (e.functor.obj X) =
    𝟙 (e.functor.obj X)
tactic: dsimp
state_before: C : Type u₁
inst✝² : Category.{v₁, u₁} C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
E : Type u₃
inst✝ : Category.{v₃, u₃} E
e : C ≌ D
G : D ⥤ C
iso : e.inverse ≅ G
X : C
⊢ e.functor.map (e.unitIso.hom.app X ≫ iso.hom.app (e.functor.obj X)) ≫
      e.functor.map (iso.inv.app (e.functor.obj X)) ≫ e.counitIso.hom.app (e.functor.obj X) =
    𝟙 (e.functor.obj X)
state_after: no goals
tactic: rw [← map_comp_assoc, assoc, iso.hom_inv_id_app, comp_id, functor_unit_comp]
Theorem: Finsupp.support_mapRange_of_injective
File: Mathlib/Data/Finsupp/Defs.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
M : Type u_5
M' : Type u_6
N : Type u_7
P : Type u_8
G : Type u_9
H : Type u_10
R : Type u_11
S : Type u_12
inst✝² : Zero M
inst✝¹ : Zero N
inst✝ : Zero P
e : M → N
he0 : e 0 = 0
f : ι →₀ M
he : Injective e
⊢ (mapRange e he0 f).support = f.support
state_after: case a
α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
M : Type u_5
M' : Type u_6
N : Type u_7
P : Type u_8
G : Type u_9
H : Type u_10
R : Type u_11
S : Type u_12
inst✝² : Zero M
inst✝¹ : Zero N
inst✝ : Zero P
e : M → N
he0 : e 0 = 0
f : ι →₀ M
he : Injective e
a✝ : ι
⊢ a✝ ∈ (mapRange e he0 f).support ↔ a✝ ∈ f.support
tactic: ext
state_before: case a
α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
M : Type u_5
M' : Type u_6
N : Type u_7
P : Type u_8
G : Type u_9
H : Type u_10
R : Type u_11
S : Type u_12
inst✝² : Zero M
inst✝¹ : Zero N
inst✝ : Zero P
e : M → N
he0 : e 0 = 0
f : ι →₀ M
he : Injective e
a✝ : ι
⊢ a✝ ∈ (mapRange e he0 f).support ↔ a✝ ∈ f.support
state_after: case a
α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
M : Type u_5
M' : Type u_6
N : Type u_7
P : Type u_8
G : Type u_9
H : Type u_10
R : Type u_11
S : Type u_12
inst✝² : Zero M
inst✝¹ : Zero N
inst✝ : Zero P
e : M → N
he0 : e 0 = 0
f : ι →₀ M
he : Injective e
a✝ : ι
⊢ ¬e (f a✝) = 0 ↔ ¬f a✝ = 0
tactic: simp only [Finsupp.mem_support_iff, Ne, Finsupp.mapRange_apply]
state_before: case a
α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
M : Type u_5
M' : Type u_6
N : Type u_7
P : Type u_8
G : Type u_9
H : Type u_10
R : Type u_11
S : Type u_12
inst✝² : Zero M
inst✝¹ : Zero N
inst✝ : Zero P
e : M → N
he0 : e 0 = 0
f : ι →₀ M
he : Injective e
a✝ : ι
⊢ ¬e (f a✝) = 0 ↔ ¬f a✝ = 0
state_after: no goals
tactic: exact he.ne_iff' he0
Theorem: summable_norm_sum_mul_antidiagonal_of_summable_norm
File: Mathlib/Analysis/Normed/Field/InfiniteSum.lean

Proof steps:
state_before: R : Type u_1
ι : Type u_2
ι' : Type u_3
inst✝ : NormedRing R
f g : ℕ → R
hf : Summable fun x => ‖f x‖
hg : Summable fun x => ‖g x‖
⊢ Summable fun n => ‖∑ kl ∈ antidiagonal n, f kl.1 * g kl.2‖
state_after: R : Type u_1
ι : Type u_2
ι' : Type u_3
inst✝ : NormedRing R
f g : ℕ → R
hf : Summable fun x => ‖f x‖
hg : Summable fun x => ‖g x‖
this : Summable fun n => ∑ kl ∈ antidiagonal n, ‖f kl.1‖ * ‖g kl.2‖
⊢ Summable fun n => ‖∑ kl ∈ antidiagonal n, f kl.1 * g kl.2‖
tactic: have :=
    summable_sum_mul_antidiagonal_of_summable_mul
      (Summable.mul_of_nonneg hf hg (fun _ => norm_nonneg _) fun _ => norm_nonneg _)
state_before: R : Type u_1
ι : Type u_2
ι' : Type u_3
inst✝ : NormedRing R
f g : ℕ → R
hf : Summable fun x => ‖f x‖
hg : Summable fun x => ‖g x‖
this : Summable fun n => ∑ kl ∈ antidiagonal n, ‖f kl.1‖ * ‖g kl.2‖
⊢ Summable fun n => ‖∑ kl ∈ antidiagonal n, f kl.1 * g kl.2‖
state_after: R : Type u_1
ι : Type u_2
ι' : Type u_3
inst✝ : NormedRing R
f g : ℕ → R
hf : Summable fun x => ‖f x‖
hg : Summable fun x => ‖g x‖
this : Summable fun n => ∑ kl ∈ antidiagonal n, ‖f kl.1‖ * ‖g kl.2‖
n : ℕ
⊢ ‖∑ kl ∈ antidiagonal n, f kl.1 * g kl.2‖ ≤ ∑ kl ∈ antidiagonal n, ‖f kl.1‖ * ‖g kl.2‖
tactic: refine this.of_nonneg_of_le (fun _ => norm_nonneg _) (fun n ↦ ?_)
state_before: R : Type u_1
ι : Type u_2
ι' : Type u_3
inst✝ : NormedRing R
f g : ℕ → R
hf : Summable fun x => ‖f x‖
hg : Summable fun x => ‖g x‖
this : Summable fun n => ∑ kl ∈ antidiagonal n, ‖f kl.1‖ * ‖g kl.2‖
n : ℕ
⊢ ‖∑ kl ∈ antidiagonal n, f kl.1 * g kl.2‖ ≤ ∑ kl ∈ antidiagonal n, ‖f kl.1‖ * ‖g kl.2‖
state_after: no goals
tactic: calc
    ‖∑ kl ∈ antidiagonal n, f kl.1 * g kl.2‖ ≤ ∑ kl ∈ antidiagonal n, ‖f kl.1 * g kl.2‖ :=
      norm_sum_le _ _
    _ ≤ ∑ kl ∈ antidiagonal n, ‖f kl.1‖ * ‖g kl.2‖ := by gcongr; apply norm_mul_le
Theorem: Subring.top_prod
File: Mathlib/Algebra/Ring/Subring/Basic.lean

Proof steps:
state_before: R : Type u
S : Type v
T : Type w
inst✝² : Ring R
inst✝¹ : Ring S
inst✝ : Ring T
s : Subring S
x : R × S
⊢ x ∈ ⊤.prod s ↔ x ∈ comap (RingHom.snd R S) s
state_after: no goals
tactic: simp [mem_prod, MonoidHom.coe_snd]
Theorem: Finpartition.parts_top_subset
File: Mathlib/Order/Partition/Finpartition.lean

Proof steps:
state_before: α : Type u_1
inst✝² : Lattice α
inst✝¹ : OrderBot α
a✝ : α
P : Finpartition a✝
a : α
inst✝ : Decidable (a = ⊥)
⊢ ⊤.parts ⊆ {a}
state_after: α : Type u_1
inst✝² : Lattice α
inst✝¹ : OrderBot α
a✝ : α
P : Finpartition a✝
a : α
inst✝ : Decidable (a = ⊥)
b : α
hb : b ∈ ⊤.parts
⊢ b ∈ {a}
tactic: intro b hb
state_before: α : Type u_1
inst✝² : Lattice α
inst✝¹ : OrderBot α
a✝ : α
P : Finpartition a✝
a : α
inst✝ : Decidable (a = ⊥)
b : α
hb : b ∈ ⊤.parts
⊢ b ∈ {a}
state_after: α : Type u_1
inst✝² : Lattice α
inst✝¹ : OrderBot α
a✝ : α
P : Finpartition a✝
a : α
inst✝ : Decidable (a = ⊥)
b : α
hb✝ : b ∈ ⊤.parts
hb : b ∈ (if ha : a = ⊥ then (Finpartition.empty α).copy ⋯ else indiscrete ha).parts
⊢ b ∈ {a}
tactic: have hb : b ∈ Finpartition.parts (dite _ _ _) := hb
state_before: α : Type u_1
inst✝² : Lattice α
inst✝¹ : OrderBot α
a✝ : α
P : Finpartition a✝
a : α
inst✝ : Decidable (a = ⊥)
b : α
hb✝ : b ∈ ⊤.parts
hb : b ∈ (if ha : a = ⊥ then (Finpartition.empty α).copy ⋯ else indiscrete ha).parts
⊢ b ∈ {a}
state_after: case pos
α : Type u_1
inst✝² : Lattice α
inst✝¹ : OrderBot α
a✝ : α
P : Finpartition a✝
a : α
inst✝ : Decidable (a = ⊥)
b : α
hb✝ : b ∈ ⊤.parts
h✝ : a = ⊥
hb : b ∈ ((Finpartition.empty α).copy ⋯).parts
⊢ b ∈ {a}

case neg
α : Type u_1
inst✝² : Lattice α
inst✝¹ : OrderBot α
a✝ : α
P : Finpartition a✝
a : α
inst✝ : Decidable (a = ⊥)
b : α
hb✝ : b ∈ ⊤.parts
h✝ : ¬a = ⊥
hb : b ∈ (indiscrete h✝).parts
⊢ b ∈ {a}
tactic: split_ifs at hb
Theorem: CategoryTheory.isoOpEquiv_symm_apply
File: Mathlib/CategoryTheory/Opposites.lean

Proof steps:
state_before: C : Type u₁
inst✝ : Category.{v₁, u₁} C
A B : Cᵒᵖ
x✝ : A ≅ B
⊢ (fun g => g.op) ((fun f => f.unop) x✝) = x✝
state_after: case w
C : Type u₁
inst✝ : Category.{v₁, u₁} C
A B : Cᵒᵖ
x✝ : A ≅ B
⊢ ((fun g => g.op) ((fun f => f.unop) x✝)).hom = x✝.hom
tactic: ext
state_before: case w
C : Type u₁
inst✝ : Category.{v₁, u₁} C
A B : Cᵒᵖ
x✝ : A ≅ B
⊢ ((fun g => g.op) ((fun f => f.unop) x✝)).hom = x✝.hom
state_after: no goals
tactic: rfl
state_before: C : Type u₁
inst✝ : Category.{v₁, u₁} C
A B : Cᵒᵖ
x✝ : unop B ≅ unop A
⊢ (fun f => f.unop) ((fun g => g.op) x✝) = x✝
state_after: case w
C : Type u₁
inst✝ : Category.{v₁, u₁} C
A B : Cᵒᵖ
x✝ : unop B ≅ unop A
⊢ ((fun f => f.unop) ((fun g => g.op) x✝)).hom = x✝.hom
tactic: ext
state_before: case w
C : Type u₁
inst✝ : Category.{v₁, u₁} C
A B : Cᵒᵖ
x✝ : unop B ≅ unop A
⊢ ((fun f => f.unop) ((fun g => g.op) x✝)).hom = x✝.hom
state_after: no goals
tactic: rfl
Theorem: LeftOrdContinuous.iterate
File: Mathlib/Order/OrdContinuous.lean

Proof steps:
state_before: α : Type u
β : Type v
γ : Type w
ι : Sort x
inst✝² : Preorder α
inst✝¹ : Preorder β
inst✝ : Preorder γ
g : β → γ
f✝ : α → β
f : α → α
hf : LeftOrdContinuous f
n : ℕ
⊢ LeftOrdContinuous f^[n]
state_after: no goals
tactic: induction n with
  | zero => exact LeftOrdContinuous.id α
  | succ n ihn => exact ihn.comp hf
Theorem: CategoryTheory.NatTrans.hcomp_id_app
File: Mathlib/CategoryTheory/Functor/Category.lean

Proof steps:
state_before: C : Type u₁
inst✝² : Category.{v₁, u₁} C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
E : Type u₃
inst✝ : Category.{v₃, u₃} E
F G H✝ I : C ⥤ D
H : D ⥤ E
α : F ⟶ G
X : C
⊢ (α ◫ 𝟙 H).app X = H.map (α.app X)
state_after: no goals
tactic: simp