ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- MeasureTheory.MeasurePreserving.measure_preimage_emb
theorem measure_preimage_emb {f : α → β} (hf : MeasurePreserving f μa μb)
    (hfe : MeasurableEmbedding f) (s : Set β) : μa (f ⁻¹' s) = μb s 
Arguments: {α : Type u_1} {β : Type u_2} [MeasurableSpace α] [MeasurableSpace β] {μa : MeasureTheory.Measure α} {μb : MeasureTheory.Measure β} {f : α → β} (hf : MeasureTheory.MeasurePreserving f μa μb) (hfe : MeasurableEmbedding f) (s : Set β)
Goal: μa (f ⁻¹' s) = μb s
-- MeasureTheory.MeasurePreserving.measure_preimage_equiv
theorem measure_preimage_equiv {f : α ≃ᵐ β} (hf : MeasurePreserving f μa μb) (s : Set β) :
    μa (f ⁻¹' s) = μb s 
Arguments: {α : Type u_1} {β : Type u_2} [MeasurableSpace α] [MeasurableSpace β] {μa : MeasureTheory.Measure α} {μb : MeasureTheory.Measure β} {f : α ≃ᵐ β} (hf : MeasureTheory.MeasurePreserving (⇑f) μa μb) (s : Set β)
Goal: μa (⇑f ⁻¹' s) = μb s
-- MeasureTheory.MeasurePreserving.iterate
protected theorem iterate {f : α → α} (hf : MeasurePreserving f μa μa) :
    ∀ n, MeasurePreserving f^[n] μa μa
  
Arguments: {α : Type u_1} [MeasurableSpace α] {μa : MeasureTheory.Measure α} {f : α → α} (hf : MeasureTheory.MeasurePreserving f μa μa) (n : ℕ)
Goal: MeasureTheory.MeasurePreserving f^[n] μa μa
-- MeasureTheory.MeasurePreserving.measure_symmDiff_preimage_iterate_le
lemma measure_symmDiff_preimage_iterate_le
    (hf : MeasurePreserving f μ μ) (hs : NullMeasurableSet s μ) (n : ℕ) :
    μ (s ∆ (f^[n] ⁻¹' s)) ≤ n • μ (s ∆ (f ⁻¹' s)) 
Arguments: {α : Type u_1} [MeasurableSpace α] {μ : MeasureTheory.Measure α} {f : α → α} {s : Set α} (hf : MeasureTheory.MeasurePreserving f μ μ) (hs : MeasureTheory.NullMeasurableSet s μ) (n : ℕ)
Goal: μ (symmDiff s (f^[n] ⁻¹' s)) ≤ n • μ (symmDiff s (f ⁻¹' s))
-- MeasureTheory.MeasurePreserving.exists_mem_iterate_mem_of_volume_lt_mul_volume
theorem exists_mem_iterate_mem_of_volume_lt_mul_volume (hf : MeasurePreserving f μ μ)
    (hs : NullMeasurableSet s μ) {n : ℕ} (hvol : μ (Set.univ : Set α) < n * μ s) :
    ∃ x ∈ s, ∃ m ∈ Set.Ioo 0 n, f^[m] x ∈ s 
Arguments: {α : Type u_1} [MeasurableSpace α] {μ : MeasureTheory.Measure α} {f : α → α} {s : Set α} (hf : MeasureTheory.MeasurePreserving f μ μ) (hs : MeasureTheory.NullMeasurableSet s μ) {n : ℕ} (hvol : μ Set.univ < ↑n * μ s)
Goal: ∃ x ∈ s, ∃ m ∈ Set.Ioo 0 n, f^[m] x ∈ s
-- MeasureTheory.MeasurePreserving.exists_mem_iterate_mem
theorem exists_mem_iterate_mem [IsFiniteMeasure μ] (hf : MeasurePreserving f μ μ)
    (hs : NullMeasurableSet s μ) (hs' : μ s ≠ 0) : ∃ x ∈ s, ∃ m ≠ 0, f^[m] x ∈ s 
Arguments: {α : Type u_1} [MeasurableSpace α] {μ : MeasureTheory.Measure α} {f : α → α} {s : Set α} [MeasureTheory.IsFiniteMeasure μ] (hf : MeasureTheory.MeasurePreserving f μ μ) (hs : MeasureTheory.NullMeasurableSet s μ) (hs' : μ s ≠ 0)
Goal: ∃ x ∈ s, ∃ m, m ≠ 0 ∧ f^[m] x ∈ s
-- MeasureTheory.MeasurableEquiv.measurePreserving_symm
theorem measurePreserving_symm (μ : Measure α) (e : α ≃ᵐ β) :
    MeasurePreserving e.symm (map e μ) μ 
Arguments: {α : Type u_1} {β : Type u_2} [MeasurableSpace α] [MeasurableSpace β] (μ : MeasureTheory.Measure α) (e : α ≃ᵐ β)
Goal: MeasureTheory.MeasurePreserving (⇑e.symm) (MeasureTheory.Measure.map (⇑e) μ) μ
-- CategoryTheory.WellPowered.subobject_small
class WellPowered : Prop where
  subobject_small : ∀ X : C, Small.{v} (Subobject X) := by infer_instance
Arguments: {C : Type u₁} [CategoryTheory.Category.{v, u₁} C] [self : CategoryTheory.WellPowered C] (X : C)
Goal: Small.{v, max u₁ v} (CategoryTheory.Subobject X)
-- CategoryTheory.essentiallySmall_monoOver_iff_small_subobject
theorem essentiallySmall_monoOver_iff_small_subobject (X : C) :
    EssentiallySmall.{v} (MonoOver X) ↔ Small.{v} (Subobject X) 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v, u₁} C] (X : C)
Goal: CategoryTheory.EssentiallySmall.{v, v, max u₁ v} (CategoryTheory.MonoOver X) ↔
  Small.{v, max u₁ v} (CategoryTheory.Subobject X)
-- CategoryTheory.wellPowered_of_essentiallySmall_monoOver
theorem wellPowered_of_essentiallySmall_monoOver (h : ∀ X : C, EssentiallySmall.{v} (MonoOver X)) :
    WellPowered C 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v, u₁} C] (h : ∀ (X : C), CategoryTheory.EssentiallySmall.{v, v, max u₁ v} (CategoryTheory.MonoOver X))
Goal: CategoryTheory.WellPowered C
-- CategoryTheory.wellPowered_of_equiv
theorem wellPowered_of_equiv (e : C ≌ D) [WellPowered C] : WellPowered D 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v, u₂} D] (e : C ≌ D) [CategoryTheory.WellPowered C]
Goal: CategoryTheory.WellPowered D
-- CategoryTheory.wellPowered_congr
theorem wellPowered_congr (e : C ≌ D) : WellPowered C ↔ WellPowered D 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v, u₂} D] (e : C ≌ D)
Goal: CategoryTheory.WellPowered C ↔ CategoryTheory.WellPowered D
-- IsInvariantSubfield.smul_mem
class IsInvariantSubfield (S : Subfield F) : Prop where
  smul_mem : ∀ (m : M) {x : F}, x ∈ S → m • x ∈ S
Arguments: {M : Type u} [Monoid M] {F : Type v} [Field F] [MulSemiringAction M F] {S : Subfield F} [self : IsInvariantSubfield M S] (m : M) {x : F}
Goal: x ∈ S → m • x ∈ S
-- FixedPoints.smul
@[simp]
theorem smul (m : M) (x : FixedPoints.subfield M F) : m • x = x 
Arguments: (M : Type u) [Monoid M] (F : Type v) [Field F] [MulSemiringAction M F] (m : M) (x : ↥(FixedPoints.subfield M F))
Goal: m • x = x
-- FixedPoints.smul_polynomial
@[simp]
theorem smul_polynomial (m : M) (p : Polynomial (FixedPoints.subfield M F)) : m • p = p 
Arguments: (M : Type u) [Monoid M] (F : Type v) [Field F] [MulSemiringAction M F] (m : M) (p : Polynomial ↥(FixedPoints.subfield M F))
Goal: m • p = p
-- FixedPoints.coe_algebraMap
theorem coe_algebraMap :
    algebraMap (FixedPoints.subfield M F) F = Subfield.subtype (FixedPoints.subfield M F) 
Arguments: (M : Type u) [Monoid M] (F : Type v) [Field F] [MulSemiringAction M F]
Goal: algebraMap (↥(FixedPoints.subfield M F)) F = (FixedPoints.subfield M F).subtype
-- FixedPoints.linearIndependent_smul_of_linearIndependent
theorem linearIndependent_smul_of_linearIndependent {s : Finset F} :
    (LinearIndependent (FixedPoints.subfield G F) fun i : (s : Set F) => (i : F)) →
      LinearIndependent F fun i : (s : Set F) => MulAction.toFun G F i 
Arguments: (G : Type u) [Group G] (F : Type v) [Field F] [MulSemiringAction G F] {s : Finset F}
Goal: (LinearIndependent ↥(FixedPoints.subfield G F) fun (i : ↑↑s) => ↑i) →
  LinearIndependent F fun (i : ↑↑s) => (MulAction.toFun G F) ↑i
-- FixedPoints.minpoly.monic
theorem monic : (minpoly G F x).Monic 
Arguments: (G : Type u) [Group G] (F : Type v) [Field F] [MulSemiringAction G F] [Fintype G] (x : F)
Goal: (FixedPoints.minpoly G F x).Monic
-- FixedPoints.minpoly.eval₂
theorem eval₂ :
    Polynomial.eval₂ (Subring.subtype <| (FixedPoints.subfield G F).toSubring) x (minpoly G F x) =
      0 
Arguments: (G : Type u) [Group G] (F : Type v) [Field F] [MulSemiringAction G F] [Fintype G] (x : F)
Goal: Polynomial.eval₂ (FixedPoints.subfield G F).subtype x (FixedPoints.minpoly G F x) = 0
-- FixedPoints.minpoly.eval₂'
theorem eval₂' :
    Polynomial.eval₂ (Subfield.subtype <| FixedPoints.subfield G F) x (minpoly G F x) = 0 
Arguments: (G : Type u) [Group G] (F : Type v) [Field F] [MulSemiringAction G F] [Fintype G] (x : F)
Goal: Polynomial.eval₂ (FixedPoints.subfield G F).subtype x (FixedPoints.minpoly G F x) = 0
-- FixedPoints.minpoly.ne_one
theorem ne_one : minpoly G F x ≠ (1 : Polynomial (FixedPoints.subfield G F)) 
Arguments: (G : Type u) [Group G] (F : Type v) [Field F] [MulSemiringAction G F] [Fintype G] (x : F)
Goal: FixedPoints.minpoly G F x ≠ 1
-- FixedPoints.minpoly.of_eval₂
theorem of_eval₂ (f : Polynomial (FixedPoints.subfield G F))
    (hf : Polynomial.eval₂ (Subfield.subtype <| FixedPoints.subfield G F) x f = 0) :
    minpoly G F x ∣ f 
Arguments: (G : Type u) [Group G] (F : Type v) [Field F] [MulSemiringAction G F] [Fintype G] (x : F) (f : Polynomial ↥(FixedPoints.subfield G F)) (hf : Polynomial.eval₂ (FixedPoints.subfield G F).subtype x f = 0)
Goal: FixedPoints.minpoly G F x ∣ f
-- FixedPoints.minpoly.irreducible_aux
theorem irreducible_aux (f g : Polynomial (FixedPoints.subfield G F)) (hf : f.Monic) (hg : g.Monic)
    (hfg : f * g = minpoly G F x) : f = 1 ∨ g = 1 
Arguments: (G : Type u) [Group G] (F : Type v) [Field F] [MulSemiringAction G F] [Fintype G] (x : F) (f g : Polynomial ↥(FixedPoints.subfield G F)) (hf : f.Monic) (hg : g.Monic) (hfg : f * g = FixedPoints.minpoly G F x)
Goal: f = 1 ∨ g = 1
-- FixedPoints.minpoly.irreducible
theorem irreducible : Irreducible (minpoly G F x) 
Arguments: (G : Type u) [Group G] (F : Type v) [Field F] [MulSemiringAction G F] [Fintype G] (x : F)
Goal: Irreducible (FixedPoints.minpoly G F x)
-- FixedPoints.isIntegral
theorem isIntegral [Finite G] (x : F) : IsIntegral (FixedPoints.subfield G F) x 
Arguments: (G : Type u) [Group G] (F : Type v) [Field F] [MulSemiringAction G F] [Finite G] (x : F)
Goal: IsIntegral (↥(FixedPoints.subfield G F)) x
-- FixedPoints.minpoly_eq_minpoly
theorem minpoly_eq_minpoly : minpoly G F x = _root_.minpoly (FixedPoints.subfield G F) x 
Arguments: (G : Type u) [Group G] (F : Type v) [Field F] [MulSemiringAction G F] [Fintype G] (x : F)
Goal: FixedPoints.minpoly G F x = minpoly (↥(FixedPoints.subfield G F)) x
-- FixedPoints.rank_le_card
theorem rank_le_card : Module.rank (FixedPoints.subfield G F) F ≤ Fintype.card G 
Arguments: (G : Type u) [Group G] (F : Type v) [Field F] [MulSemiringAction G F] [Fintype G]
Goal: Module.rank (↥(FixedPoints.subfield G F)) F ≤ ↑(Fintype.card G)
-- FixedPoints.finrank_le_card
theorem finrank_le_card [Fintype G] : finrank (subfield G F) F ≤ Fintype.card G 
Arguments: (G : Type u) [Group G] (F : Type v) [Field F] [MulSemiringAction G F] [Fintype G]
Goal: FiniteDimensional.finrank (↥(FixedPoints.subfield G F)) F ≤ Fintype.card G
-- linearIndependent_toLinearMap
theorem linearIndependent_toLinearMap (R : Type u) (A : Type v) (B : Type w) [CommSemiring R]
    [Ring A] [Algebra R A] [CommRing B] [IsDomain B] [Algebra R B] :
    LinearIndependent B (AlgHom.toLinearMap : (A →ₐ[R] B) → A →ₗ[R] B) 
Arguments: (R : Type u) (A : Type v) (B : Type w) [CommSemiring R] [Ring A] [Algebra R A] [CommRing B] [IsDomain B] [Algebra R B]
Goal: LinearIndependent B AlgHom.toLinearMap
-- cardinal_mk_algHom
theorem cardinal_mk_algHom (K : Type u) (V : Type v) (W : Type w) [Field K] [Field V] [Algebra K V]
    [FiniteDimensional K V] [Field W] [Algebra K W] :
    Cardinal.mk (V →ₐ[K] W) ≤ finrank W (V →ₗ[K] W) 
Arguments: (K : Type u) (V : Type v) (W : Type w) [Field K] [Field V] [Algebra K V] [FiniteDimensional K V] [Field W] [Algebra K W]
Goal: Cardinal.mk (V →ₐ[K] W) ≤ ↑(FiniteDimensional.finrank W (V →ₗ[K] W))
-- finrank_algHom
theorem finrank_algHom (K : Type u) (V : Type v) [Field K] [Field V] [Algebra K V]
    [FiniteDimensional K V] : Fintype.card (V →ₐ[K] V) ≤ finrank V (V →ₗ[K] V) 
Arguments: (K : Type u) (V : Type v) [Field K] [Field V] [Algebra K V] [FiniteDimensional K V]
Goal: Fintype.card (V →ₐ[K] V) ≤ FiniteDimensional.finrank V (V →ₗ[K] V)
-- FixedPoints.finrank_eq_card
theorem finrank_eq_card (G : Type u) (F : Type v) [Group G] [Field F] [Fintype G]
    [MulSemiringAction G F] [FaithfulSMul G F] :
    finrank (FixedPoints.subfield G F) F = Fintype.card G 
Arguments: (G : Type u) (F : Type v) [Group G] [Field F] [Fintype G] [MulSemiringAction G F] [FaithfulSMul G F]
Goal: FiniteDimensional.finrank (↥(FixedPoints.subfield G F)) F = Fintype.card G
-- FixedPoints.toAlgHom_bijective
theorem toAlgHom_bijective (G : Type u) (F : Type v) [Group G] [Field F] [Finite G]
    [MulSemiringAction G F] [FaithfulSMul G F] :
    Function.Bijective (MulSemiringAction.toAlgHom _ _ : G → F →ₐ[subfield G F] F) 
Arguments: (G : Type u) (F : Type v) [Group G] [Field F] [Finite G] [MulSemiringAction G F] [FaithfulSMul G F]
Goal: Function.Bijective (MulSemiringAction.toAlgHom (↥(FixedPoints.subfield G F)) F)
-- Polynomial.newtonMap_apply
theorem newtonMap_apply :
    P.newtonMap x = x - (Ring.inverse <| aeval x (derivative P)) * (aeval x P) 
Arguments: {R : Type u_1} {S : Type u_2} [CommRing R] [CommRing S] [Algebra R S] (P : Polynomial R) {x : S}
Goal: P.newtonMap x = x - Ring.inverse ((Polynomial.aeval x) (Polynomial.derivative P)) * (Polynomial.aeval x) P
-- Polynomial.newtonMap_apply_of_isUnit
theorem newtonMap_apply_of_isUnit (h : IsUnit <| aeval x (derivative P)) :
    P.newtonMap x = x - h.unit⁻¹ * aeval x P 
Arguments: {R : Type u_1} {S : Type u_2} [CommRing R] [CommRing S] [Algebra R S] {P : Polynomial R} {x : S} (h : IsUnit ((Polynomial.aeval x) (Polynomial.derivative P)))
Goal: P.newtonMap x = x - ↑h.unit⁻¹ * (Polynomial.aeval x) P
-- Polynomial.newtonMap_apply_of_not_isUnit
theorem newtonMap_apply_of_not_isUnit (h : ¬ (IsUnit <| aeval x (derivative P))) :
    P.newtonMap x = x 
Arguments: {R : Type u_1} {S : Type u_2} [CommRing R] [CommRing S] [Algebra R S] {P : Polynomial R} {x : S} (h : ¬IsUnit ((Polynomial.aeval x) (Polynomial.derivative P)))
Goal: P.newtonMap x = x
-- Polynomial.isNilpotent_iterate_newtonMap_sub_of_isNilpotent
theorem isNilpotent_iterate_newtonMap_sub_of_isNilpotent (h : IsNilpotent <| aeval x P) (n : ℕ) :
    IsNilpotent <| P.newtonMap^[n] x - x 
Arguments: {R : Type u_1} {S : Type u_2} [CommRing R] [CommRing S] [Algebra R S] {P : Polynomial R} {x : S} (h : IsNilpotent ((Polynomial.aeval x) P)) (n : ℕ)
Goal: IsNilpotent (P.newtonMap^[n] x - x)
-- Polynomial.isFixedPt_newtonMap_of_aeval_eq_zero
theorem isFixedPt_newtonMap_of_aeval_eq_zero (h : aeval x P = 0) :
    IsFixedPt P.newtonMap x 
Arguments: {R : Type u_1} {S : Type u_2} [CommRing R] [CommRing S] [Algebra R S] {P : Polynomial R} {x : S} (h : (Polynomial.aeval x) P = 0)
Goal: Function.IsFixedPt P.newtonMap x
-- Polynomial.isFixedPt_newtonMap_of_isUnit_iff
theorem isFixedPt_newtonMap_of_isUnit_iff (h : IsUnit <| aeval x (derivative P)) :
    IsFixedPt P.newtonMap x ↔ aeval x P = 0 
Arguments: {R : Type u_1} {S : Type u_2} [CommRing R] [CommRing S] [Algebra R S] {P : Polynomial R} {x : S} (h : IsUnit ((Polynomial.aeval x) (Polynomial.derivative P)))
Goal: Function.IsFixedPt P.newtonMap x ↔ (Polynomial.aeval x) P = 0
-- Polynomial.aeval_pow_two_pow_dvd_aeval_iterate_newtonMap
theorem aeval_pow_two_pow_dvd_aeval_iterate_newtonMap
    (h : IsNilpotent (aeval x P)) (h' : IsUnit (aeval x <| derivative P)) (n : ℕ) :
    (aeval x P) ^ (2 ^ n) ∣ aeval (P.newtonMap^[n] x) P 
Arguments: {R : Type u_1} {S : Type u_2} [CommRing R] [CommRing S] [Algebra R S] {P : Polynomial R} {x : S} (h : IsNilpotent ((Polynomial.aeval x) P)) (h' : IsUnit ((Polynomial.aeval x) (Polynomial.derivative P))) (n : ℕ)
Goal: (Polynomial.aeval x) P ^ 2 ^ n ∣ (Polynomial.aeval (P.newtonMap^[n] x)) P
-- Polynomial.exists_unique_nilpotent_sub_and_aeval_eq_zero
theorem exists_unique_nilpotent_sub_and_aeval_eq_zero
    (h : IsNilpotent (aeval x P)) (h' : IsUnit (aeval x <| derivative P)) :
    ∃! r, IsNilpotent (x - r) ∧ aeval r P = 0 
Arguments: {R : Type u_1} {S : Type u_2} [CommRing R] [CommRing S] [Algebra R S] {P : Polynomial R} {x : S} (h : IsNilpotent ((Polynomial.aeval x) P)) (h' : IsUnit ((Polynomial.aeval x) (Polynomial.derivative P)))
Goal: ∃! r, IsNilpotent (x - r) ∧ (Polynomial.aeval r) P = 0
-- CategoryTheory.Iso.inv_hom_id
structure Iso {C : Type u} [Category.{v} C] (X Y : C) where
    hom : X ⟶ Y
    inv : Y ⟶ X
    hom_inv_id : hom ≫ inv = 𝟙 X := by aesop_cat
    inv_hom_id : inv ≫ hom = 𝟙 Y := by aesop_cat
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {X Y : C} (self : X ≅ Y)
Goal: CategoryTheory.CategoryStruct.comp self.inv self.hom = CategoryTheory.CategoryStruct.id Y
-- CategoryTheory.Iso.hom_inv_id
structure Iso {C : Type u} [Category.{v} C] (X Y : C) where
    hom : X ⟶ Y
    inv : Y ⟶ X
    hom_inv_id : hom ≫ inv = 𝟙 X := by aesop_cat
    inv_hom_id : inv ≫ hom = 𝟙 Y := by aesop_cat
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {X Y : C} (self : X ≅ Y)
Goal: CategoryTheory.CategoryStruct.comp self.hom self.inv = CategoryTheory.CategoryStruct.id X
-- CategoryTheory.Iso.ext
@[ext]
theorem ext ⦃α β : X ≅ Y⦄ (w : α.hom = β.hom) : α = β 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {X Y : C} ⦃α β : X ≅ Y⦄ (w : α.hom = β.hom)
Goal: α = β
-- CategoryTheory.Iso.symm_hom
@[simp]
theorem symm_hom (α : X ≅ Y) : α.symm.hom = α.inv 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {X Y : C} (α : X ≅ Y)
Goal: α.symm.hom = α.inv
-- CategoryTheory.Iso.symm_inv
@[simp]
theorem symm_inv (α : X ≅ Y) : α.symm.inv = α.hom 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {X Y : C} (α : X ≅ Y)
Goal: α.symm.inv = α.hom
-- CategoryTheory.Iso.symm_mk
@[simp]
theorem symm_mk {X Y : C} (hom : X ⟶ Y) (inv : Y ⟶ X) (hom_inv_id) (inv_hom_id) :
    Iso.symm { hom, inv, hom_inv_id := hom_inv_id, inv_hom_id := inv_hom_id } =
      { hom := inv, inv := hom, hom_inv_id := inv_hom_id, inv_hom_id := hom_inv_id } 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {X Y : C} (hom : X ⟶ Y) (inv : Y ⟶ X) (hom_inv_id : CategoryTheory.CategoryStruct.comp hom inv = CategoryTheory.CategoryStruct.id X) (inv_hom_id : CategoryTheory.CategoryStruct.comp inv hom = CategoryTheory.CategoryStruct.id Y)
Goal: { hom := hom, inv := inv, hom_inv_id := hom_inv_id, inv_hom_id := inv_hom_id }.symm =
  { hom := inv, inv := hom, hom_inv_id := inv_hom_id, inv_hom_id := hom_inv_id }
-- CategoryTheory.Iso.symm_symm_eq
@[simp]
theorem symm_symm_eq {X Y : C} (α : X ≅ Y) : α.symm.symm = α 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {X Y : C} (α : X ≅ Y)
Goal: α.symm.symm = α
-- CategoryTheory.Iso.symm_eq_iff
@[simp]
theorem symm_eq_iff {X Y : C} {α β : X ≅ Y} : α.symm = β.symm ↔ α = β 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {X Y : C} {α β : X ≅ Y}
Goal: α.symm = β.symm ↔ α = β
-- CategoryTheory.Iso.nonempty_iso_symm
theorem nonempty_iso_symm (X Y : C) : Nonempty (X ≅ Y) ↔ Nonempty (Y ≅ X) 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] (X Y : C)
Goal: Nonempty (X ≅ Y) ↔ Nonempty (Y ≅ X)
-- CategoryTheory.Iso.refl_hom
@[refl, simps]
def refl (X : C) : X ≅ X 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] (X : C)
Goal: (CategoryTheory.Iso.refl X).hom = CategoryTheory.CategoryStruct.id X
-- CategoryTheory.Iso.refl_inv
@[refl, simps]
def refl (X : C) : X ≅ X 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] (X : C)
Goal: (CategoryTheory.Iso.refl X).inv = CategoryTheory.CategoryStruct.id X
-- CategoryTheory.Iso.nonempty_iso_refl
theorem nonempty_iso_refl (X : C) : Nonempty (X ≅ X) 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] (X : C)
Goal: Nonempty (X ≅ X)
-- CategoryTheory.Iso.refl_symm
@[simp]
theorem refl_symm (X : C) : (Iso.refl X).symm = Iso.refl X 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] (X : C)
Goal: (CategoryTheory.Iso.refl X).symm = CategoryTheory.Iso.refl X
-- CategoryTheory.Iso.trans_inv
@[trans, simps]
def trans (α : X ≅ Y) (β : Y ≅ Z) : X ≅ Z 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {X Y Z : C} (α : X ≅ Y) (β : Y ≅ Z)
Goal: (α ≪≫ β).inv = CategoryTheory.CategoryStruct.comp β.inv α.inv
-- CategoryTheory.Iso.trans_hom
@[trans, simps]
def trans (α : X ≅ Y) (β : Y ≅ Z) : X ≅ Z 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {X Y Z : C} (α : X ≅ Y) (β : Y ≅ Z)
Goal: (α ≪≫ β).hom = CategoryTheory.CategoryStruct.comp α.hom β.hom
-- CategoryTheory.Iso.instTransIso_trans
@[simps]
instance instTransIso : Trans (α := C) (· ≅ ·) (· ≅ ·) (· ≅ ·) 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C]
Goal: ∀ {a b c : C} (α : a ≅ b) (β : b ≅ c), Trans.trans α β = α ≪≫ β
-- CategoryTheory.Iso.trans_mk
@[simp]
theorem trans_mk {X Y Z : C} (hom : X ⟶ Y) (inv : Y ⟶ X) (hom_inv_id) (inv_hom_id)
    (hom' : Y ⟶ Z) (inv' : Z ⟶ Y) (hom_inv_id') (inv_hom_id') (hom_inv_id'') (inv_hom_id'') :
    Iso.trans ⟨hom, inv, hom_inv_id, inv_hom_id⟩ ⟨hom', inv', hom_inv_id', inv_hom_id'⟩ =
     ⟨hom ≫ hom', inv' ≫ inv, hom_inv_id'', inv_hom_id''⟩ 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {X Y Z : C} (hom : X ⟶ Y) (inv : Y ⟶ X) (hom_inv_id : CategoryTheory.CategoryStruct.comp hom inv = CategoryTheory.CategoryStruct.id X) (inv_hom_id : CategoryTheory.CategoryStruct.comp inv hom = CategoryTheory.CategoryStruct.id Y) (hom' : Y ⟶ Z) (inv' : Z ⟶ Y) (hom_inv_id' : CategoryTheory.CategoryStruct.comp hom' inv' = CategoryTheory.CategoryStruct.id Y) (inv_hom_id' : CategoryTheory.CategoryStruct.comp inv' hom' = CategoryTheory.CategoryStruct.id Z) (hom_inv_id'' :
  CategoryTheory.CategoryStruct.comp (CategoryTheory.CategoryStruct.comp hom hom')
      (CategoryTheory.CategoryStruct.comp inv' inv) =
    CategoryTheory.CategoryStruct.id X) (inv_hom_id'' :
  CategoryTheory.CategoryStruct.comp (CategoryTheory.CategoryStruct.comp inv' inv)
      (CategoryTheory.CategoryStruct.comp hom hom') =
    CategoryTheory.CategoryStruct.id Z)
Goal: { hom := hom, inv := inv, hom_inv_id := hom_inv_id, inv_hom_id := inv_hom_id } ≪≫
    { hom := hom', inv := inv', hom_inv_id := hom_inv_id', inv_hom_id := inv_hom_id' } =
  { hom := CategoryTheory.CategoryStruct.comp hom hom', inv := CategoryTheory.CategoryStruct.comp inv' inv,
    hom_inv_id := hom_inv_id'', inv_hom_id := inv_hom_id'' }
-- CategoryTheory.Iso.trans_symm
@[simp]
theorem trans_symm (α : X ≅ Y) (β : Y ≅ Z) : (α ≪≫ β).symm = β.symm ≪≫ α.symm 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {X Y Z : C} (α : X ≅ Y) (β : Y ≅ Z)
Goal: (α ≪≫ β).symm = β.symm ≪≫ α.symm
-- CategoryTheory.Iso.trans_assoc
@[simp]
theorem trans_assoc {Z' : C} (α : X ≅ Y) (β : Y ≅ Z) (γ : Z ≅ Z') :
    (α ≪≫ β) ≪≫ γ = α ≪≫ β ≪≫ γ 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {X Y Z Z' : C} (α : X ≅ Y) (β : Y ≅ Z) (γ : Z ≅ Z')
Goal: (α ≪≫ β) ≪≫ γ = α ≪≫ β ≪≫ γ
-- CategoryTheory.Iso.refl_trans
@[simp]
theorem refl_trans (α : X ≅ Y) : Iso.refl X ≪≫ α = α 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {X Y : C} (α : X ≅ Y)
Goal: CategoryTheory.Iso.refl X ≪≫ α = α
-- CategoryTheory.Iso.trans_refl
@[simp]
theorem trans_refl (α : X ≅ Y) : α ≪≫ Iso.refl Y = α 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {X Y : C} (α : X ≅ Y)
Goal: α ≪≫ CategoryTheory.Iso.refl Y = α
-- CategoryTheory.Iso.symm_self_id
@[simp]
theorem symm_self_id (α : X ≅ Y) : α.symm ≪≫ α = Iso.refl Y 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {X Y : C} (α : X ≅ Y)
Goal: α.symm ≪≫ α = CategoryTheory.Iso.refl Y
-- CategoryTheory.Iso.self_symm_id
@[simp]
theorem self_symm_id (α : X ≅ Y) : α ≪≫ α.symm = Iso.refl X 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {X Y : C} (α : X ≅ Y)
Goal: α ≪≫ α.symm = CategoryTheory.Iso.refl X
-- CategoryTheory.Iso.symm_self_id_assoc
@[simp]
theorem symm_self_id_assoc (α : X ≅ Y) (β : Y ≅ Z) : α.symm ≪≫ α ≪≫ β = β 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {X Y Z : C} (α : X ≅ Y) (β : Y ≅ Z)
Goal: α.symm ≪≫ α ≪≫ β = β
-- CategoryTheory.Iso.self_symm_id_assoc
@[simp]
theorem self_symm_id_assoc (α : X ≅ Y) (β : X ≅ Z) : α ≪≫ α.symm ≪≫ β = β 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {X Y Z : C} (α : X ≅ Y) (β : X ≅ Z)
Goal: α ≪≫ α.symm ≪≫ β = β
-- CategoryTheory.Iso.inv_comp_eq
theorem inv_comp_eq (α : X ≅ Y) {f : X ⟶ Z} {g : Y ⟶ Z} : α.inv ≫ f = g ↔ f = α.hom ≫ g 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {X Y Z : C} (α : X ≅ Y) {f : X ⟶ Z} {g : Y ⟶ Z}
Goal: CategoryTheory.CategoryStruct.comp α.inv f = g ↔ f = CategoryTheory.CategoryStruct.comp α.hom g
-- CategoryTheory.Iso.eq_inv_comp
theorem eq_inv_comp (α : X ≅ Y) {f : X ⟶ Z} {g : Y ⟶ Z} : g = α.inv ≫ f ↔ α.hom ≫ g = f 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {X Y Z : C} (α : X ≅ Y) {f : X ⟶ Z} {g : Y ⟶ Z}
Goal: g = CategoryTheory.CategoryStruct.comp α.inv f ↔ CategoryTheory.CategoryStruct.comp α.hom g = f
-- CategoryTheory.Iso.comp_inv_eq
theorem comp_inv_eq (α : X ≅ Y) {f : Z ⟶ Y} {g : Z ⟶ X} : f ≫ α.inv = g ↔ f = g ≫ α.hom 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {X Y Z : C} (α : X ≅ Y) {f : Z ⟶ Y} {g : Z ⟶ X}
Goal: CategoryTheory.CategoryStruct.comp f α.inv = g ↔ f = CategoryTheory.CategoryStruct.comp g α.hom