ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- AlgebraicGeometry.iSup_basicOpen_of_span_eq_top
lemma iSup_basicOpen_of_span_eq_top {X : Scheme} (U) (s : Set Γ(X, U))
    (hs : Ideal.span s = ⊤) : (⨆ i ∈ s, X.basicOpen i) = U 
Arguments: {X : AlgebraicGeometry.Scheme} (U : X.Opens) (s : Set ↑(X.presheaf.obj (Opposite.op U))) (hs : Ideal.span s = ⊤)
Goal: ⨆ i ∈ s, X.basicOpen i = U
-- AlgebraicGeometry.of_affine_open_cover
@[elab_as_elim]
theorem of_affine_open_cover {X : Scheme} {P : X.affineOpens → Prop}
    {ι} (U : ι → X.affineOpens) (iSup_U : (⨆ i, U i : X.Opens) = ⊤)
    (V : X.affineOpens)
    (basicOpen : ∀ (U : X.affineOpens) (f : Γ(X, U)), P U → P (X.affineBasicOpen f))
    (openCover :
      ∀ (U : X.affineOpens) (s : Finset (Γ(X, U)))
        (_ : Ideal.span (s : Set (Γ(X, U))) = ⊤),
        (∀ f : s, P (X.affineBasicOpen f.1)) → P U)
    (hU : ∀ i, P (U i)) : P V 
Arguments: {X : AlgebraicGeometry.Scheme} {P : ↑X.affineOpens → Prop} {ι : Sort u_2} (U : ι → ↑X.affineOpens) (iSup_U : ⨆ i, ↑(U i) = ⊤) (V : ↑X.affineOpens) (basicOpen : ∀ (U : ↑X.affineOpens) (f : ↑(X.presheaf.obj (Opposite.op ↑U))), P U → P (X.affineBasicOpen f)) (openCover :
  ∀ (U : ↑X.affineOpens) (s : Finset ↑(X.presheaf.obj (Opposite.op ↑U))),
    Ideal.span ↑s = ⊤ → (∀ (f : { x // x ∈ s }), P (X.affineBasicOpen ↑f)) → P U) (hU : ∀ (i : ι), P (U i))
Goal: P V
-- AlgebraicGeometry.Scheme.toΓSpec_preimage_zeroLocus_eq
lemma Scheme.toΓSpec_preimage_zeroLocus_eq {X : Scheme.{u}} (s : Set Γ(X, ⊤)) :
    (ΓSpec.adjunction.unit.app X).val.base ⁻¹' PrimeSpectrum.zeroLocus s = X.zeroLocus s 
Arguments: {X : AlgebraicGeometry.Scheme} (s : Set ↑(X.presheaf.obj (Opposite.op ⊤)))
Goal: ⇑(AlgebraicGeometry.ΓSpec.adjunction.unit.app X).val.base ⁻¹' PrimeSpectrum.zeroLocus s = X.zeroLocus s
-- AlgebraicGeometry.Scheme.toΓSpec_image_zeroLocus_eq_of_isAffine
lemma Scheme.toΓSpec_image_zeroLocus_eq_of_isAffine {X : Scheme.{u}} [IsAffine X]
    (s : Set Γ(X, ⊤)) :
    X.isoSpec.hom.val.base '' X.zeroLocus s = PrimeSpectrum.zeroLocus s 
Arguments: {X : AlgebraicGeometry.Scheme} [AlgebraicGeometry.IsAffine X] (s : Set ↑(X.presheaf.obj (Opposite.op ⊤)))
Goal: ⇑X.isoSpec.hom.val.base '' X.zeroLocus s = PrimeSpectrum.zeroLocus s
-- AlgebraicGeometry.Scheme.eq_zeroLocus_of_isClosed_of_isAffine
lemma Scheme.eq_zeroLocus_of_isClosed_of_isAffine (X : Scheme.{u}) [IsAffine X] (s : Set X) :
    IsClosed s ↔ ∃ I : Ideal (Γ(X, ⊤)), s = X.zeroLocus (I : Set Γ(X, ⊤)) 
Arguments: (X : AlgebraicGeometry.Scheme) [AlgebraicGeometry.IsAffine X] (s : Set ↑↑X.toPresheafedSpace)
Goal: IsClosed s ↔ ∃ I, s = X.zeroLocus ↑I
-- AlgebraicGeometry.Scheme.localRingHom_comp_stalkIso
@[elementwise]
lemma Scheme.localRingHom_comp_stalkIso {R S : CommRingCat.{u}} (f : R ⟶ S) (p : PrimeSpectrum S) :
    (StructureSheaf.stalkIso R (PrimeSpectrum.comap f p)).hom ≫
      (CommRingCat.ofHom <| Localization.localRingHom
        (PrimeSpectrum.comap f p).asIdeal p.asIdeal f rfl) ≫
      (StructureSheaf.stalkIso S p).inv = (Spec.map f).stalkMap p 
Arguments: {R S : CommRingCat} (f : R ⟶ S) (p : PrimeSpectrum ↑S)
Goal: (AlgebraicGeometry.StructureSheaf.stalkIso (↑R) ((PrimeSpectrum.comap f) p)).hom ≫
    CommRingCat.ofHom (Localization.localRingHom ((PrimeSpectrum.comap f) p).asIdeal p.asIdeal f ⋯) ≫
      (AlgebraicGeometry.StructureSheaf.stalkIso (↑S) p).inv =
  AlgebraicGeometry.Scheme.Hom.stalkMap (AlgebraicGeometry.Spec.map f) p
-- AlgebraicGeometry.Scheme.GlueData.f_open
-- Porting note(#5171): @[nolint has_nonempty_instance]; linter not ported yet
structure GlueData extends CategoryTheory.GlueData Scheme where
  f_open : ∀ i j, IsOpenImmersion (f i j)
Arguments: (self : AlgebraicGeometry.Scheme.GlueData) (i j : self.J)
Goal: AlgebraicGeometry.IsOpenImmersion (self.f i j)
-- AlgebraicGeometry.Scheme.GlueData.ι_isoLocallyRingedSpace_inv
theorem ι_isoLocallyRingedSpace_inv (i : D.J) :
    D.toLocallyRingedSpaceGlueData.toGlueData.ι i ≫ D.isoLocallyRingedSpace.inv = 𝖣.ι i 
Arguments: (D : AlgebraicGeometry.Scheme.GlueData) (i : D.J)
Goal: D.toLocallyRingedSpaceGlueData.ι i ≫ D.isoLocallyRingedSpace.inv = D.ι i
-- AlgebraicGeometry.Scheme.GlueData.ι_jointly_surjective
theorem ι_jointly_surjective (x : 𝖣.glued.carrier) :
    ∃ (i : D.J) (y : (D.U i).carrier), (D.ι i).1.base y = x 
Arguments: (D : AlgebraicGeometry.Scheme.GlueData) (x : ↑↑D.glued.toPresheafedSpace)
Goal: ∃ i y, (D.ι i).val.base y = x
-- AlgebraicGeometry.Scheme.GlueData.glue_condition
@[simp (high), reassoc]
theorem glue_condition (i j : D.J) : D.t i j ≫ D.f j i ≫ D.ι j = D.f i j ≫ D.ι i 
Arguments: (D : AlgebraicGeometry.Scheme.GlueData) (i j : D.J)
Goal: D.t i j ≫ D.f j i ≫ D.ι j = D.f i j ≫ D.ι i
-- AlgebraicGeometry.Scheme.GlueData.ι_isoCarrier_inv
@[simp]
theorem ι_isoCarrier_inv (i : D.J) :
    (D_).ι i ≫ D.isoCarrier.inv = (D.ι i).1.base 
Arguments: (D : AlgebraicGeometry.Scheme.GlueData) (i : D.J)
Goal: D.toLocallyRingedSpaceGlueData.toSheafedSpaceGlueData.toPresheafedSpaceGlueData.toTopGlueData.ι i ≫ D.isoCarrier.inv =
  (D.ι i).val.base
-- AlgebraicGeometry.Scheme.GlueData.ι_eq_iff
theorem ι_eq_iff (i j : D.J) (x : (D.U i).carrier) (y : (D.U j).carrier) :
    (𝖣.ι i).1.base x = (𝖣.ι j).1.base y ↔ D.Rel ⟨i, x⟩ ⟨j, y⟩ 
Arguments: (D : AlgebraicGeometry.Scheme.GlueData) (i j : D.J) (x : ↑↑(D.U i).toPresheafedSpace) (y : ↑↑(D.U j).toPresheafedSpace)
Goal: (D.ι i).val.base x = (D.ι j).val.base y ↔ D.Rel ⟨i, x⟩ ⟨j, y⟩
-- AlgebraicGeometry.Scheme.GlueData.isOpen_iff
theorem isOpen_iff (U : Set D.glued.carrier) : IsOpen U ↔ ∀ i, IsOpen ((D.ι i).1.base ⁻¹' U) 
Arguments: (D : AlgebraicGeometry.Scheme.GlueData) (U : Set ↑↑D.glued.toPresheafedSpace)
Goal: IsOpen U ↔ ∀ (i : D.J), IsOpen (⇑(D.ι i).val.base ⁻¹' U)
-- AlgebraicGeometry.Scheme.GlueData.openCover_obj
@[simps (config := .lemmasOnly)]
def openCover (D : Scheme.GlueData) : OpenCover D.glued 
Arguments: (D : AlgebraicGeometry.Scheme.GlueData)
Goal: ∀ (a : D.J), D.openCover.obj a = D.U a
-- AlgebraicGeometry.Scheme.GlueData.openCover_map
@[simps (config := .lemmasOnly)]
def openCover (D : Scheme.GlueData) : OpenCover D.glued 
Arguments: (D : AlgebraicGeometry.Scheme.GlueData) (i : D.J)
Goal: D.openCover.map i = D.ι i
-- AlgebraicGeometry.Scheme.GlueData.openCover_J
@[simps (config := .lemmasOnly)]
def openCover (D : Scheme.GlueData) : OpenCover D.glued 
Arguments: (D : AlgebraicGeometry.Scheme.GlueData)
Goal: D.openCover.J = D.J
-- AlgebraicGeometry.Scheme.GlueData.openCover_f
@[simps (config := .lemmasOnly)]
def openCover (D : Scheme.GlueData) : OpenCover D.glued 
Arguments: (D : AlgebraicGeometry.Scheme.GlueData) (x : ↑↑D.glued.toPresheafedSpace)
Goal: D.openCover.f x = ⋯.choose
-- AlgebraicGeometry.Scheme.OpenCover.gluedCoverT'_fst_fst
@[simp, reassoc]
theorem gluedCoverT'_fst_fst (x y z : 𝒰.J) :
    𝒰.gluedCoverT' x y z ≫ pullback.fst _ _ ≫ pullback.fst _ _ =
      pullback.fst _ _ ≫ pullback.snd _ _ 
Arguments: {X : AlgebraicGeometry.Scheme} (𝒰 : X.OpenCover) (x y z : 𝒰.J)
Goal: 𝒰.gluedCoverT' x y z ≫
    CategoryTheory.Limits.pullback.fst (CategoryTheory.Limits.pullback.fst (𝒰.map y) (𝒰.map z))
        (CategoryTheory.Limits.pullback.fst (𝒰.map y) (𝒰.map x)) ≫
      CategoryTheory.Limits.pullback.fst (𝒰.map y) (𝒰.map z) =
  CategoryTheory.Limits.pullback.fst (CategoryTheory.Limits.pullback.fst (𝒰.map x) (𝒰.map y))
      (CategoryTheory.Limits.pullback.fst (𝒰.map x) (𝒰.map z)) ≫
    CategoryTheory.Limits.pullback.snd (𝒰.map x) (𝒰.map y)
-- AlgebraicGeometry.Scheme.OpenCover.gluedCoverT'_fst_snd
@[simp, reassoc]
theorem gluedCoverT'_fst_snd (x y z : 𝒰.J) :
    gluedCoverT' 𝒰 x y z ≫ pullback.fst _ _ ≫ pullback.snd _ _ =
      pullback.snd _ _ ≫ pullback.snd _ _ 
Arguments: {X : AlgebraicGeometry.Scheme} (𝒰 : X.OpenCover) (x y z : 𝒰.J)
Goal: 𝒰.gluedCoverT' x y z ≫
    CategoryTheory.Limits.pullback.fst (CategoryTheory.Limits.pullback.fst (𝒰.map y) (𝒰.map z))
        (CategoryTheory.Limits.pullback.fst (𝒰.map y) (𝒰.map x)) ≫
      CategoryTheory.Limits.pullback.snd (𝒰.map y) (𝒰.map z) =
  CategoryTheory.Limits.pullback.snd (CategoryTheory.Limits.pullback.fst (𝒰.map x) (𝒰.map y))
      (CategoryTheory.Limits.pullback.fst (𝒰.map x) (𝒰.map z)) ≫
    CategoryTheory.Limits.pullback.snd (𝒰.map x) (𝒰.map z)
-- AlgebraicGeometry.Scheme.OpenCover.gluedCoverT'_snd_fst
@[simp, reassoc]
theorem gluedCoverT'_snd_fst (x y z : 𝒰.J) :
    gluedCoverT' 𝒰 x y z ≫ pullback.snd _ _ ≫ pullback.fst _ _ =
      pullback.fst _ _ ≫ pullback.snd _ _ 
Arguments: {X : AlgebraicGeometry.Scheme} (𝒰 : X.OpenCover) (x y z : 𝒰.J)
Goal: 𝒰.gluedCoverT' x y z ≫
    CategoryTheory.Limits.pullback.snd (CategoryTheory.Limits.pullback.fst (𝒰.map y) (𝒰.map z))
        (CategoryTheory.Limits.pullback.fst (𝒰.map y) (𝒰.map x)) ≫
      CategoryTheory.Limits.pullback.fst (𝒰.map y) (𝒰.map x) =
  CategoryTheory.Limits.pullback.fst (CategoryTheory.Limits.pullback.fst (𝒰.map x) (𝒰.map y))
      (CategoryTheory.Limits.pullback.fst (𝒰.map x) (𝒰.map z)) ≫
    CategoryTheory.Limits.pullback.snd (𝒰.map x) (𝒰.map y)
-- AlgebraicGeometry.Scheme.OpenCover.gluedCoverT'_snd_snd
@[simp, reassoc]
theorem gluedCoverT'_snd_snd (x y z : 𝒰.J) :
    gluedCoverT' 𝒰 x y z ≫ pullback.snd _ _ ≫ pullback.snd _ _ =
      pullback.fst _ _ ≫ pullback.fst _ _ 
Arguments: {X : AlgebraicGeometry.Scheme} (𝒰 : X.OpenCover) (x y z : 𝒰.J)
Goal: 𝒰.gluedCoverT' x y z ≫
    CategoryTheory.Limits.pullback.snd (CategoryTheory.Limits.pullback.fst (𝒰.map y) (𝒰.map z))
        (CategoryTheory.Limits.pullback.fst (𝒰.map y) (𝒰.map x)) ≫
      CategoryTheory.Limits.pullback.snd (𝒰.map y) (𝒰.map x) =
  CategoryTheory.Limits.pullback.fst (CategoryTheory.Limits.pullback.fst (𝒰.map x) (𝒰.map y))
      (CategoryTheory.Limits.pullback.fst (𝒰.map x) (𝒰.map z)) ≫
    CategoryTheory.Limits.pullback.fst (𝒰.map x) (𝒰.map y)
-- AlgebraicGeometry.Scheme.OpenCover.glued_cover_cocycle_fst
theorem glued_cover_cocycle_fst (x y z : 𝒰.J) :
    gluedCoverT' 𝒰 x y z ≫ gluedCoverT' 𝒰 y z x ≫ gluedCoverT' 𝒰 z x y ≫ pullback.fst _ _ =
      pullback.fst _ _ 
Arguments: {X : AlgebraicGeometry.Scheme} (𝒰 : X.OpenCover) (x y z : 𝒰.J)
Goal: 𝒰.gluedCoverT' x y z ≫
    𝒰.gluedCoverT' y z x ≫
      𝒰.gluedCoverT' z x y ≫
        CategoryTheory.Limits.pullback.fst (CategoryTheory.Limits.pullback.fst (𝒰.map x) (𝒰.map y))
          (CategoryTheory.Limits.pullback.fst (𝒰.map x) (𝒰.map z)) =
  CategoryTheory.Limits.pullback.fst (CategoryTheory.Limits.pullback.fst (𝒰.map x) (𝒰.map y))
    (CategoryTheory.Limits.pullback.fst (𝒰.map x) (𝒰.map z))
-- AlgebraicGeometry.Scheme.OpenCover.glued_cover_cocycle_snd
theorem glued_cover_cocycle_snd (x y z : 𝒰.J) :
    gluedCoverT' 𝒰 x y z ≫ gluedCoverT' 𝒰 y z x ≫ gluedCoverT' 𝒰 z x y ≫ pullback.snd _ _ =
      pullback.snd _ _ 
Arguments: {X : AlgebraicGeometry.Scheme} (𝒰 : X.OpenCover) (x y z : 𝒰.J)
Goal: 𝒰.gluedCoverT' x y z ≫
    𝒰.gluedCoverT' y z x ≫
      𝒰.gluedCoverT' z x y ≫
        CategoryTheory.Limits.pullback.snd (CategoryTheory.Limits.pullback.fst (𝒰.map x) (𝒰.map y))
          (CategoryTheory.Limits.pullback.fst (𝒰.map x) (𝒰.map z)) =
  CategoryTheory.Limits.pullback.snd (CategoryTheory.Limits.pullback.fst (𝒰.map x) (𝒰.map y))
    (CategoryTheory.Limits.pullback.fst (𝒰.map x) (𝒰.map z))
-- AlgebraicGeometry.Scheme.OpenCover.glued_cover_cocycle
theorem glued_cover_cocycle (x y z : 𝒰.J) :
    gluedCoverT' 𝒰 x y z ≫ gluedCoverT' 𝒰 y z x ≫ gluedCoverT' 𝒰 z x y = 𝟙 _ 
Arguments: {X : AlgebraicGeometry.Scheme} (𝒰 : X.OpenCover) (x y z : 𝒰.J)
Goal: 𝒰.gluedCoverT' x y z ≫ 𝒰.gluedCoverT' y z x ≫ 𝒰.gluedCoverT' z x y =
  𝟙
    (CategoryTheory.Limits.pullback (CategoryTheory.Limits.pullback.fst (𝒰.map x) (𝒰.map y))
      (CategoryTheory.Limits.pullback.fst (𝒰.map x) (𝒰.map z)))
-- AlgebraicGeometry.Scheme.OpenCover.gluedCover_V
@[simps]
def gluedCover : Scheme.GlueData.{u} 
Arguments: {X : AlgebraicGeometry.Scheme} (𝒰 : X.OpenCover)
Goal: ∀ (x : 𝒰.J × 𝒰.J),
  𝒰.gluedCover.V x =
    match x with
    | (x, y) => CategoryTheory.Limits.pullback (𝒰.map x) (𝒰.map y)
-- AlgebraicGeometry.Scheme.OpenCover.gluedCover_t
@[simps]
def gluedCover : Scheme.GlueData.{u} 
Arguments: {X : AlgebraicGeometry.Scheme} (𝒰 : X.OpenCover) (x y : 𝒰.J)
Goal: 𝒰.gluedCover.t x y = (CategoryTheory.Limits.pullbackSymmetry (𝒰.map x) (𝒰.map y)).hom
-- AlgebraicGeometry.Scheme.OpenCover.gluedCover_J
@[simps]
def gluedCover : Scheme.GlueData.{u} 
Arguments: {X : AlgebraicGeometry.Scheme} (𝒰 : X.OpenCover)
Goal: 𝒰.gluedCover.J = 𝒰.J
-- AlgebraicGeometry.Scheme.OpenCover.gluedCover_t'
@[simps]
def gluedCover : Scheme.GlueData.{u} 
Arguments: {X : AlgebraicGeometry.Scheme} (𝒰 : X.OpenCover) (x y z : 𝒰.J)
Goal: 𝒰.gluedCover.t' x y z = 𝒰.gluedCoverT' x y z
-- AlgebraicGeometry.Scheme.OpenCover.gluedCover_f
@[simps]
def gluedCover : Scheme.GlueData.{u} 
Arguments: {X : AlgebraicGeometry.Scheme} (𝒰 : X.OpenCover) (x y : 𝒰.J)
Goal: 𝒰.gluedCover.f x y = CategoryTheory.Limits.pullback.fst (𝒰.map x) (𝒰.map y)
-- AlgebraicGeometry.Scheme.OpenCover.gluedCover_U
@[simps]
def gluedCover : Scheme.GlueData.{u} 
Arguments: {X : AlgebraicGeometry.Scheme} (𝒰 : X.OpenCover)
Goal: ∀ (a : 𝒰.J), 𝒰.gluedCover.U a = 𝒰.obj a
-- AlgebraicGeometry.Scheme.OpenCover.ι_fromGlued
@[simp, reassoc]
theorem ι_fromGlued (x : 𝒰.J) : 𝒰.gluedCover.ι x ≫ 𝒰.fromGlued = 𝒰.map x 
Arguments: {X : AlgebraicGeometry.Scheme} (𝒰 : X.OpenCover) (x : 𝒰.J)
Goal: 𝒰.gluedCover.ι x ≫ 𝒰.fromGlued = 𝒰.map x
-- AlgebraicGeometry.Scheme.OpenCover.fromGlued_injective
theorem fromGlued_injective : Function.Injective 𝒰.fromGlued.1.base 
Arguments: {X : AlgebraicGeometry.Scheme} (𝒰 : X.OpenCover)
Goal: Function.Injective ⇑𝒰.fromGlued.val.base
-- AlgebraicGeometry.Scheme.OpenCover.fromGlued_open_map
theorem fromGlued_open_map : IsOpenMap 𝒰.fromGlued.1.base 
Arguments: {X : AlgebraicGeometry.Scheme} (𝒰 : X.OpenCover)
Goal: IsOpenMap ⇑𝒰.fromGlued.val.base
-- AlgebraicGeometry.Scheme.OpenCover.fromGlued_openEmbedding
theorem fromGlued_openEmbedding : OpenEmbedding 𝒰.fromGlued.1.base 
Arguments: {X : AlgebraicGeometry.Scheme} (𝒰 : X.OpenCover)
Goal: OpenEmbedding ⇑𝒰.fromGlued.val.base
-- AlgebraicGeometry.Scheme.OpenCover.ι_glueMorphisms
@[simp, reassoc]
theorem ι_glueMorphisms {Y : Scheme} (f : ∀ x, 𝒰.obj x ⟶ Y)
    (hf : ∀ x y, pullback.fst (𝒰.map x) (𝒰.map y) ≫ f x = pullback.snd _ _ ≫ f y)
    (x : 𝒰.J) : 𝒰.map x ≫ 𝒰.glueMorphisms f hf = f x 
Arguments: {X : AlgebraicGeometry.Scheme} (𝒰 : X.OpenCover) {Y : AlgebraicGeometry.Scheme} (f : (x : 𝒰.J) → 𝒰.obj x ⟶ Y) (hf :
  ∀ (x y : 𝒰.J),
    CategoryTheory.Limits.pullback.fst (𝒰.map x) (𝒰.map y) ≫ f x =
      CategoryTheory.Limits.pullback.snd (𝒰.map x) (𝒰.map y) ≫ f y) (x : 𝒰.J)
Goal: 𝒰.map x ≫ 𝒰.glueMorphisms f hf = f x
-- AlgebraicGeometry.Scheme.OpenCover.hom_ext
theorem hom_ext {Y : Scheme} (f₁ f₂ : X ⟶ Y) (h : ∀ x, 𝒰.map x ≫ f₁ = 𝒰.map x ≫ f₂) : f₁ = f₂ 
Arguments: {X : AlgebraicGeometry.Scheme} (𝒰 : X.OpenCover) {Y : AlgebraicGeometry.Scheme} (f₁ f₂ : X ⟶ Y) (h : ∀ (x : 𝒰.J), 𝒰.map x ≫ f₁ = 𝒰.map x ≫ f₂)
Goal: f₁ = f₂
-- Sum.exists_sum
theorem exists_sum {γ : α ⊕ β → Sort*} (p : (∀ ab, γ ab) → Prop) :
    (∃ fab, p fab) ↔ (∃ fa fb, p (Sum.rec fa fb)) 
Arguments: {α : Type u} {β : Type v} {γ : α ⊕ β → Sort u_3} (p : ((ab : α ⊕ β) → γ ab) → Prop)
Goal: (∃ fab, p fab) ↔ ∃ fa fb, p fun t => Sum.rec fa fb t
-- Sum.inl_injective
theorem inl_injective : Function.Injective (inl : α → α ⊕ β) 
Arguments: {α : Type u} {β : Type v}
Goal: Function.Injective Sum.inl
-- Sum.inr_injective
theorem inr_injective : Function.Injective (inr : β → α ⊕ β) 
Arguments: {α : Type u} {β : Type v}
Goal: Function.Injective Sum.inr
-- Sum.sum_rec_congr
theorem sum_rec_congr (P : α ⊕ β → Sort*) (f : ∀ i, P (inl i)) (g : ∀ i, P (inr i))
    {x y : α ⊕ β} (h : x = y) :
    @Sum.rec _ _ _ f g x = cast (congr_arg P h.symm) (@Sum.rec _ _ _ f g y) 
Arguments: {α : Type u} {β : Type v} (P : α ⊕ β → Sort u_3) (f : (i : α) → P (Sum.inl i)) (g : (i : β) → P (Sum.inr i)) {x y : α ⊕ β} (h : x = y)
Goal: Sum.rec f g x = cast ⋯ (Sum.rec f g y)
-- Sum.eq_left_iff_getLeft_eq
theorem eq_left_iff_getLeft_eq {a : α} : x = inl a ↔ ∃ h, x.getLeft h = a 
Arguments: {α : Type u} {β : Type v} {x : α ⊕ β} {a : α}
Goal: x = Sum.inl a ↔ ∃ h, x.getLeft h = a
-- Sum.eq_right_iff_getRight_eq
theorem eq_right_iff_getRight_eq {b : β} : x = inr b ↔ ∃ h, x.getRight h = b 
Arguments: {α : Type u} {β : Type v} {x : α ⊕ β} {b : β}
Goal: x = Sum.inr b ↔ ∃ h, x.getRight h = b
-- Sum.getLeft_eq_getLeft?
theorem getLeft_eq_getLeft? (h₁ : x.isLeft) (h₂ : x.getLeft?.isSome) :
    x.getLeft h₁ = x.getLeft?.get h₂ 
Arguments: {α : Type u} {β : Type v} {x : α ⊕ β} (h₁ : x.isLeft = true) (h₂ : x.getLeft?.isSome = true)
Goal: x.getLeft h₁ = x.getLeft?.get h₂
-- Sum.getRight_eq_getRight?
theorem getRight_eq_getRight? (h₁ : x.isRight) (h₂ : x.getRight?.isSome) :
    x.getRight h₁ = x.getRight?.get h₂ 
Arguments: {α : Type u} {β : Type v} {x : α ⊕ β} (h₁ : x.isRight = true) (h₂ : x.getRight?.isSome = true)
Goal: x.getRight h₁ = x.getRight?.get h₂
-- Sum.isSome_getLeft?_iff_isLeft
@[simp] theorem isSome_getLeft?_iff_isLeft : x.getLeft?.isSome ↔ x.isLeft 
Arguments: {α : Type u} {β : Type v} {x : α ⊕ β}
Goal: x.getLeft?.isSome = true ↔ x.isLeft = true
-- Sum.isSome_getRight?_iff_isRight
@[simp] theorem isSome_getRight?_iff_isRight : x.getRight?.isSome ↔ x.isRight 
Arguments: {α : Type u} {β : Type v} {x : α ⊕ β}
Goal: x.getRight?.isSome = true ↔ x.isRight = true
-- Sum.update_elim_inl
@[simp]
theorem update_elim_inl [DecidableEq α] [DecidableEq (α ⊕ β)] {f : α → γ} {g : β → γ} {i : α}
    {x : γ} : update (Sum.elim f g) (inl i) x = Sum.elim (update f i x) g 
Arguments: {α : Type u} {β : Type v} {γ : Type u_1} [DecidableEq α] [DecidableEq (α ⊕ β)] {f : α → γ} {g : β → γ} {i : α} {x : γ}
Goal: Function.update (Sum.elim f g) (Sum.inl i) x = Sum.elim (Function.update f i x) g
-- Sum.update_elim_inr
@[simp]
theorem update_elim_inr [DecidableEq β] [DecidableEq (α ⊕ β)] {f : α → γ} {g : β → γ} {i : β}
    {x : γ} : update (Sum.elim f g) (inr i) x = Sum.elim f (update g i x) 
Arguments: {α : Type u} {β : Type v} {γ : Type u_1} [DecidableEq β] [DecidableEq (α ⊕ β)] {f : α → γ} {g : β → γ} {i : β} {x : γ}
Goal: Function.update (Sum.elim f g) (Sum.inr i) x = Sum.elim f (Function.update g i x)
-- Sum.update_inl_comp_inl
@[simp]
theorem update_inl_comp_inl [DecidableEq α] [DecidableEq (α ⊕ β)] {f : α ⊕ β → γ} {i : α}
    {x : γ} : update f (inl i) x ∘ inl = update (f ∘ inl) i x 
Arguments: {α : Type u} {β : Type v} {γ : Type u_1} [DecidableEq α] [DecidableEq (α ⊕ β)] {f : α ⊕ β → γ} {i : α} {x : γ}
Goal: Function.update f (Sum.inl i) x ∘ Sum.inl = Function.update (f ∘ Sum.inl) i x
-- Sum.update_inl_apply_inl
@[simp]
theorem update_inl_apply_inl [DecidableEq α] [DecidableEq (α ⊕ β)] {f : α ⊕ β → γ} {i j : α}
    {x : γ} : update f (inl i) x (inl j) = update (f ∘ inl) i x j 
Arguments: {α : Type u} {β : Type v} {γ : Type u_1} [DecidableEq α] [DecidableEq (α ⊕ β)] {f : α ⊕ β → γ} {i j : α} {x : γ}
Goal: Function.update f (Sum.inl i) x (Sum.inl j) = Function.update (f ∘ Sum.inl) i x j
-- Sum.update_inl_comp_inr
@[simp]
theorem update_inl_comp_inr [DecidableEq (α ⊕ β)] {f : α ⊕ β → γ} {i : α} {x : γ} :
    update f (inl i) x ∘ inr = f ∘ inr 
Arguments: {α : Type u} {β : Type v} {γ : Type u_1} [DecidableEq (α ⊕ β)] {f : α ⊕ β → γ} {i : α} {x : γ}
Goal: Function.update f (Sum.inl i) x ∘ Sum.inr = f ∘ Sum.inr
-- Sum.update_inl_apply_inr
theorem update_inl_apply_inr [DecidableEq (α ⊕ β)] {f : α ⊕ β → γ} {i : α} {j : β} {x : γ} :
    update f (inl i) x (inr j) = f (inr j) 
Arguments: {α : Type u} {β : Type v} {γ : Type u_1} [DecidableEq (α ⊕ β)] {f : α ⊕ β → γ} {i : α} {j : β} {x : γ}
Goal: Function.update f (Sum.inl i) x (Sum.inr j) = f (Sum.inr j)
-- Sum.update_inr_comp_inl
@[simp]
theorem update_inr_comp_inl [DecidableEq (α ⊕ β)] {f : α ⊕ β → γ} {i : β} {x : γ} :
    update f (inr i) x ∘ inl = f ∘ inl 
Arguments: {α : Type u} {β : Type v} {γ : Type u_1} [DecidableEq (α ⊕ β)] {f : α ⊕ β → γ} {i : β} {x : γ}
Goal: Function.update f (Sum.inr i) x ∘ Sum.inl = f ∘ Sum.inl
-- Sum.update_inr_apply_inl
theorem update_inr_apply_inl [DecidableEq (α ⊕ β)] {f : α ⊕ β → γ} {i : α} {j : β} {x : γ} :
    update f (inr j) x (inl i) = f (inl i) 
Arguments: {α : Type u} {β : Type v} {γ : Type u_1} [DecidableEq (α ⊕ β)] {f : α ⊕ β → γ} {i : α} {j : β} {x : γ}
Goal: Function.update f (Sum.inr j) x (Sum.inl i) = f (Sum.inl i)
-- Sum.update_inr_comp_inr
@[simp]
theorem update_inr_comp_inr [DecidableEq β] [DecidableEq (α ⊕ β)] {f : α ⊕ β → γ} {i : β}
    {x : γ} : update f (inr i) x ∘ inr = update (f ∘ inr) i x 
Arguments: {α : Type u} {β : Type v} {γ : Type u_1} [DecidableEq β] [DecidableEq (α ⊕ β)] {f : α ⊕ β → γ} {i : β} {x : γ}
Goal: Function.update f (Sum.inr i) x ∘ Sum.inr = Function.update (f ∘ Sum.inr) i x
-- Sum.update_inr_apply_inr
@[simp]
theorem update_inr_apply_inr [DecidableEq β] [DecidableEq (α ⊕ β)] {f : α ⊕ β → γ} {i j : β}
    {x : γ} : update f (inr i) x (inr j) = update (f ∘ inr) i x j 
Arguments: {α : Type u} {β : Type v} {γ : Type u_1} [DecidableEq β] [DecidableEq (α ⊕ β)] {f : α ⊕ β → γ} {i j : β} {x : γ}
Goal: Function.update f (Sum.inr i) x (Sum.inr j) = Function.update (f ∘ Sum.inr) i x j
-- Sum.swap_leftInverse
@[simp]
theorem swap_leftInverse : Function.LeftInverse (@swap α β) swap 
Arguments: {α : Type u} {β : Type v}
Goal: Function.LeftInverse Sum.swap Sum.swap
-- Sum.swap_rightInverse
@[simp]
theorem swap_rightInverse : Function.RightInverse (@swap α β) swap 
Arguments: {α : Type u} {β : Type v}
Goal: Function.RightInverse Sum.swap Sum.swap
-- Sum.LiftRel.isLeft_congr
theorem isLeft_congr (h : LiftRel r s x y) : x.isLeft ↔ y.isLeft 
Arguments: {α : Type u} {β : Type v} {γ : Type u_1} {δ : Type u_2} {r : α → γ → Prop} {s : β → δ → Prop} {x : α ⊕ β} {y : γ ⊕ δ} (h : Sum.LiftRel r s x y)
Goal: x.isLeft = true ↔ y.isLeft = true
-- Sum.LiftRel.isRight_congr
theorem isRight_congr (h : LiftRel r s x y) : x.isRight ↔ y.isRight 
Arguments: {α : Type u} {β : Type v} {γ : Type u_1} {δ : Type u_2} {r : α → γ → Prop} {s : β → δ → Prop} {x : α ⊕ β} {y : γ ⊕ δ} (h : Sum.LiftRel r s x y)
Goal: x.isRight = true ↔ y.isRight = true
-- Sum.LiftRel.isLeft_left
theorem isLeft_left (h : LiftRel r s x (inl c)) : x.isLeft 
Arguments: {α : Type u} {β : Type v} {γ : Type u_1} {δ : Type u_2} {r : α → γ → Prop} {s : β → δ → Prop} {x : α ⊕ β} {c : γ} (h : Sum.LiftRel r s x (Sum.inl c))
Goal: x.isLeft = true
-- Sum.LiftRel.isLeft_right
theorem isLeft_right (h : LiftRel r s (inl a) y) : y.isLeft 
Arguments: {α : Type u} {β : Type v} {γ : Type u_1} {δ : Type u_2} {r : α → γ → Prop} {s : β → δ → Prop} {y : γ ⊕ δ} {a : α} (h : Sum.LiftRel r s (Sum.inl a) y)
Goal: y.isLeft = true
-- Sum.LiftRel.isRight_left
theorem isRight_left (h : LiftRel r s x (inr d)) : x.isRight 
Arguments: {α : Type u} {β : Type v} {γ : Type u_1} {δ : Type u_2} {r : α → γ → Prop} {s : β → δ → Prop} {x : α ⊕ β} {d : δ} (h : Sum.LiftRel r s x (Sum.inr d))
Goal: x.isRight = true
-- Sum.LiftRel.isRight_right
theorem isRight_right (h : LiftRel r s (inr b) y) : y.isRight 
Arguments: {α : Type u} {β : Type v} {γ : Type u_1} {δ : Type u_2} {r : α → γ → Prop} {s : β → δ → Prop} {y : γ ⊕ δ} {b : β} (h : Sum.LiftRel r s (Sum.inr b) y)
Goal: y.isRight = true
-- Sum.LiftRel.exists_of_isLeft_left
theorem exists_of_isLeft_left (h₁ : LiftRel r s x y) (h₂ : x.isLeft) :
    ∃ a c, r a c ∧ x = inl a ∧ y = inl c 
Arguments: {α : Type u} {β : Type v} {γ : Type u_1} {δ : Type u_2} {r : α → γ → Prop} {s : β → δ → Prop} {x : α ⊕ β} {y : γ ⊕ δ} (h₁ : Sum.LiftRel r s x y) (h₂ : x.isLeft = true)
Goal: ∃ a c, r a c ∧ x = Sum.inl a ∧ y = Sum.inl c
-- Sum.LiftRel.exists_of_isLeft_right
theorem exists_of_isLeft_right (h₁ : LiftRel r s x y) (h₂ : y.isLeft) :
    ∃ a c, r a c ∧ x = inl a ∧ y = inl c 
Arguments: {α : Type u} {β : Type v} {γ : Type u_1} {δ : Type u_2} {r : α → γ → Prop} {s : β → δ → Prop} {x : α ⊕ β} {y : γ ⊕ δ} (h₁ : Sum.LiftRel r s x y) (h₂ : y.isLeft = true)
Goal: ∃ a c, r a c ∧ x = Sum.inl a ∧ y = Sum.inl c
-- Sum.LiftRel.exists_of_isRight_left
theorem exists_of_isRight_left (h₁ : LiftRel r s x y) (h₂ : x.isRight) :
    ∃ b d, s b d ∧ x = inr b ∧ y = inr d 
Arguments: {α : Type u} {β : Type v} {γ : Type u_1} {δ : Type u_2} {r : α → γ → Prop} {s : β → δ → Prop} {x : α ⊕ β} {y : γ ⊕ δ} (h₁ : Sum.LiftRel r s x y) (h₂ : x.isRight = true)
Goal: ∃ b d, s b d ∧ x = Sum.inr b ∧ y = Sum.inr d