ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
File: Mathlib/Condensed/Limits.lean

full_name: instHasLimitsCondensedSet
code: instance : HasLimits CondensedSet.{u} 
goal: CategoryTheory.Limits.HasLimits CondensedSet

full_name: instHasLimitsOfSizeCondensedSet
code: instance : HasLimitsOfSize.{u, u + 1} CondensedSet.{u} 
goal: CategoryTheory.Limits.HasLimitsOfSize.{u, u + 1, u + 1, u + 2} CondensedSet

full_name: instHasLimitsCondensedMod
code: instance : HasLimits (CondensedMod.{u} R) 
goal: CategoryTheory.Limits.HasLimits (CondensedMod R)

full_name: instHasLimitsOfSizeCondensedMod
code: instance : HasLimitsOfSize.{u, u + 1} (CondensedMod.{u} R) 
goal: CategoryTheory.Limits.HasLimitsOfSize.{u, u + 1, u + 1, u + 2} (CondensedMod R)
File: Mathlib/Condensed/Basic.lean

full_name: Condensed
code: /--
`Condensed.{u} C` is the category of condensed objects in a category `C`, which are
defined as sheaves on `CompHaus.{u}` with respect to the coherent Grothendieck topology.
-/
def Condensed (C : Type w) [Category.{v} C] 
goal: Type (max (max (max (u + 1) w) u) v)

full_name: instCategoryCondensed
code: instance {C : Type w} [Category.{v} C] : Category (Condensed.{u} C) 
goal: CategoryTheory.Category.{max (u + 1) v, max (max (u + 1) w) v} (Condensed C)

full_name: CondensedSet
code: /--
Condensed sets (types) with the appropriate universe levels, i.e. `Type (u+1)`-valued
sheaves on `CompHaus.{u}`.
-/
abbrev CondensedSet 
goal: Type (u + 2)

full_name: Condensed.id_val
code: @[simp]
lemma id_val (X : Condensed.{u} C) : (𝟙 X : X ⟶ X).val = 𝟙 _ 
goal: (𝟙 X).val = 𝟙 X.val

full_name: Condensed.comp_val
code: @[simp]
lemma comp_val {X Y Z : Condensed.{u} C} (f : X ⟶ Y) (g : Y ⟶ Z) : (f ≫ g).val = f.val ≫ g.val 
goal: (f ≫ g).val = f.val ≫ g.val

full_name: Condensed.hom_ext
code: @[ext]
lemma hom_ext {X Y : Condensed.{u} C} (f g : X ⟶ Y) (h : ∀ S, f.val.app S = g.val.app S) :
    f = g 
goal: f = g

full_name: CondensedSet.hom_naturality_apply
code: @[simp]
lemma hom_naturality_apply {X Y : CondensedSet.{u}} (f : X ⟶ Y)  {S T : CompHausᵒᵖ} (g : S ⟶ T)
    (x : X.val.obj S) : f.val.app T (X.val.map g x) = Y.val.map g (f.val.app S x) 
goal: f.val.app T (X.val.map g x) = Y.val.map g (f.val.app S x)
File: Mathlib/Condensed/Functors.lean

full_name: Condensed.ulift
code: /-- Increase the size of the target category of condensed sets. -/
def Condensed.ulift : Condensed.{u} (Type u) ⥤ CondensedSet.{u} 
goal: Condensed (Type u) ⥤ CondensedSet

full_name: instFullCondensedTypeCondensedSetUlift
code: instance : Condensed.ulift.Full 
goal: Condensed.ulift.Full

full_name: instFaithfulCondensedTypeCondensedSetUlift
code: instance : Condensed.ulift.Faithful 
goal: Condensed.ulift.Faithful

full_name: compHausToCondensed'
code: /-- The functor from `CompHaus` to `Condensed.{u} (Type u)` given by the Yoneda sheaf. -/
def compHausToCondensed' : CompHaus.{u} ⥤ Condensed.{u} (Type u) 
goal: CompHaus ⥤ Condensed (Type u)

full_name: compHausToCondensed
code: /-- The yoneda presheaf as an actual condensed set. -/
def compHausToCondensed : CompHaus.{u} ⥤ CondensedSet.{u} 
goal: CompHaus ⥤ CondensedSet

full_name: CompHaus.toCondensed
code: /-- Dot notation for the value of `compHausToCondensed`. -/
abbrev CompHaus.toCondensed (S : CompHaus.{u}) : CondensedSet.{u} 
goal: CondensedSet

full_name: profiniteToCondensed
code: /-- The yoneda presheaf as a condensed set, restricted to profinite spaces. -/
def profiniteToCondensed : Profinite.{u} ⥤ CondensedSet.{u} 
goal: Profinite ⥤ CondensedSet

full_name: Profinite.toCondensed
code: /-- Dot notation for the value of `profiniteToCondensed`. -/
abbrev Profinite.toCondensed (S : Profinite.{u}) : CondensedSet.{u} 
goal: CondensedSet

full_name: stoneanToCondensed
code: /-- The yoneda presheaf as a condensed set, restricted to Stonean spaces. -/
def stoneanToCondensed : Stonean.{u} ⥤ CondensedSet.{u} 
goal: Stonean ⥤ CondensedSet

full_name: Stonean.toCondensed
code: /-- Dot notation for the value of `stoneanToCondensed`. -/
abbrev Stonean.toCondensed (S : Stonean.{u}) : CondensedSet.{u} 
goal: CondensedSet

full_name: instFullCompHausCondensedTypeCompHausToCondensed'
code: instance : compHausToCondensed'.Full 
goal: compHausToCondensed'.Full

full_name: instFaithfulCompHausCondensedTypeCompHausToCondensed'
code: instance : compHausToCondensed'.Faithful 
goal: compHausToCondensed'.Faithful

full_name: instFullCompHausCondensedSetCompHausToCondensed
code: instance : compHausToCondensed.Full 
goal: compHausToCondensed.Full

full_name: instFaithfulCompHausCondensedSetCompHausToCondensed
code: instance : compHausToCondensed.Faithful 
goal: compHausToCondensed.Faithful
File: Mathlib/Condensed/Equivalence.lean

full_name: Condensed.StoneanCompHaus.equivalence
code: /-- The equivalence from coherent sheaves on `Stonean` to coherent sheaves on `CompHaus`
    (i.e. condensed sets). -/
noncomputable
def equivalence (A : Type*) [Category A]
    [∀ X, HasLimitsOfShape (StructuredArrow X Stonean.toCompHaus.op) A] :
    Sheaf (coherentTopology Stonean) A ≌ Condensed.{u} A 
goal: CategoryTheory.Sheaf (CategoryTheory.coherentTopology Stonean) A ≌ Condensed A

full_name: Condensed.StoneanProfinite.instPreservesEffectiveEpisStoneanProfiniteToProfinite
code: instance : Stonean.toProfinite.PreservesEffectiveEpis 
goal: Stonean.toProfinite.PreservesEffectiveEpis

full_name: Condensed.StoneanProfinite.instReflectsEffectiveEpisStoneanProfiniteToProfinite
code: instance : Stonean.toProfinite.ReflectsEffectiveEpis 
goal: Stonean.toProfinite.ReflectsEffectiveEpis

full_name: Condensed.StoneanProfinite.stoneanToProfiniteEffectivePresentation
code: /--
An effective presentation of an `X : Profinite` with respect to the inclusion functor from `Stonean`
-/
noncomputable def stoneanToProfiniteEffectivePresentation (X : Profinite) :
    Stonean.toProfinite.EffectivePresentation X 
goal: Stonean.toProfinite.EffectivePresentation X

full_name: Condensed.StoneanProfinite.instEffectivelyEnoughStoneanProfiniteToProfinite
code: instance : Stonean.toProfinite.EffectivelyEnough 
goal: Stonean.toProfinite.EffectivelyEnough

full_name: Condensed.StoneanProfinite.equivalence
code: /-- The equivalence from coherent sheaves on `Stonean` to coherent sheaves on `Profinite`. -/
noncomputable
def equivalence (A : Type*) [Category A]
    [∀ X, HasLimitsOfShape (StructuredArrow X Stonean.toProfinite.op) A] :
    Sheaf (coherentTopology Stonean) A ≌ Sheaf (coherentTopology Profinite) A 
goal: CategoryTheory.Sheaf (CategoryTheory.coherentTopology Stonean) A ≌
  CategoryTheory.Sheaf (CategoryTheory.coherentTopology Profinite) A

full_name: Condensed.ProfiniteCompHaus.equivalence
code: /-- The equivalence from coherent sheaves on `Profinite` to coherent sheaves on `CompHaus`
    (i.e. condensed sets). -/
noncomputable
def equivalence (A : Type*) [Category A]
    [∀ X, HasLimitsOfShape (StructuredArrow X profiniteToCompHaus.op) A] :
    Sheaf (coherentTopology Profinite) A ≌ Condensed.{u} A 
goal: CategoryTheory.Sheaf (CategoryTheory.coherentTopology Profinite) A ≌ Condensed A

full_name: Condensed.isSheafProfinite
code: lemma isSheafProfinite
    [∀ Y, HasLimitsOfShape (StructuredArrow Y profiniteToCompHaus.{u}.op) A] :
    Presheaf.IsSheaf (coherentTopology Profinite)
    (profiniteToCompHaus.op ⋙ X.val) 
goal: CategoryTheory.Presheaf.IsSheaf (CategoryTheory.coherentTopology Profinite) (profiniteToCompHaus.op ⋙ X.val)

full_name: Condensed.isSheafStonean
code: lemma isSheafStonean
    [∀ Y, HasLimitsOfShape (StructuredArrow Y Stonean.toCompHaus.{u}.op) A] :
    Presheaf.IsSheaf (coherentTopology Stonean)
    (Stonean.toCompHaus.op ⋙ X.val) 
goal: CategoryTheory.Presheaf.IsSheaf (CategoryTheory.coherentTopology Stonean) (Stonean.toCompHaus.op ⋙ X.val)
File: Mathlib/Condensed/Light/Basic.lean

full_name: LightCondensed
code: /--
`LightCondensed.{u} C` is the category of light condensed objects in a category `C`, which are
defined as sheaves on `LightProfinite.{u}` with respect to the coherent Grothendieck topology.
-/
def LightCondensed (C : Type w) [Category.{v} C] 
goal: Type (max (max (max (u + 1) w) u) v)

full_name: instCategoryLightCondensed
code: instance {C : Type w} [Category.{v} C] : Category (LightCondensed.{u} C) 
goal: CategoryTheory.Category.{max (u + 1) v, max (max (u + 1) w) v} (LightCondensed C)

full_name: LightCondSet
code: /--
Light condensed sets. Because `LightProfinite` is an essentially small category, we don't need the
same universe bump as in `CondensedSet`.
-/
abbrev LightCondSet 
goal: Type (u + 1)

full_name: LightCondensed.id_val
code: @[simp]
lemma id_val (X : LightCondensed.{u} C) : (𝟙 X : X ⟶ X).val = 𝟙 _ 
goal: (𝟙 X).val = 𝟙 X.val

full_name: LightCondensed.comp_val
code: @[simp]
lemma comp_val {X Y Z : LightCondensed.{u} C} (f : X ⟶ Y) (g : Y ⟶ Z) :
    (f ≫ g).val = f.val ≫ g.val 
goal: (f ≫ g).val = f.val ≫ g.val

full_name: LightCondensed.hom_ext
code: @[ext]
lemma hom_ext {X Y : LightCondensed.{u} C} (f g : X ⟶ Y) (h : ∀ S, f.val.app S = g.val.app S) :
    f = g 
goal: f = g

full_name: LightCondSet.hom_naturality_apply
code: @[simp]
lemma hom_naturality_apply {X Y : LightCondSet.{u}} (f : X ⟶ Y)  {S T : LightProfiniteᵒᵖ}
    (g : S ⟶ T) (x : X.val.obj S) : f.val.app T (X.val.map g x) = Y.val.map g (f.val.app S x) 
goal: f.val.app T (X.val.map g x) = Y.val.map g (f.val.app S x)
File: Mathlib/Condensed/Light/Functors.lean

full_name: lightProfiniteToLightCondSet
code: /-- The functor from `LightProfinite.{u}` to `LightCondSet.{u}` given by the Yoneda sheaf. -/
def lightProfiniteToLightCondSet : LightProfinite.{u} ⥤ LightCondSet.{u} 
goal: LightProfinite ⥤ LightCondSet

full_name: LightProfinite.toCondensed
code: /-- Dot notation for the value of `lightProfiniteToLightCondSet`. -/
abbrev LightProfinite.toCondensed (S : LightProfinite.{u}) : LightCondSet.{u} 
goal: LightCondSet

full_name: lightProfiniteToLightCondSetFullyFaithful
code: /-- `lightProfiniteToLightCondSet` is fully faithful. -/
abbrev lightProfiniteToLightCondSetFullyFaithful :
    lightProfiniteToLightCondSet.FullyFaithful 
goal: lightProfiniteToLightCondSet.FullyFaithful

full_name: instFullLightProfiniteLightCondSetLightProfiniteToLightCondSet
code: instance : lightProfiniteToLightCondSet.Full 
goal: lightProfiniteToLightCondSet.Full

full_name: instFaithfulLightProfiniteLightCondSetLightProfiniteToLightCondSet
code: instance : lightProfiniteToLightCondSet.Faithful 
goal: lightProfiniteToLightCondSet.Faithful
File: Mathlib/Analysis/Complex/Conformal.lean

full_name: isConformalMap_conj
code: theorem isConformalMap_conj : IsConformalMap (conjLIE : ℂ →L[ℝ] ℂ) 
goal: IsConformalMap ↑{ toLinearEquiv := Complex.conjLIE.toLinearEquiv, continuous_toFun := ⋯, continuous_invFun := ⋯ }

full_name: isConformalMap_complex_linear
code: theorem isConformalMap_complex_linear {map : ℂ →L[ℂ] E} (nonzero : map ≠ 0) :
    IsConformalMap (map.restrictScalars ℝ) 
goal: IsConformalMap (ContinuousLinearMap.restrictScalars ℝ map)

full_name: isConformalMap_complex_linear_conj
code: theorem isConformalMap_complex_linear_conj {map : ℂ →L[ℂ] E} (nonzero : map ≠ 0) :
    IsConformalMap ((map.restrictScalars ℝ).comp (conjCLE : ℂ →L[ℝ] ℂ)) 
goal: IsConformalMap ((ContinuousLinearMap.restrictScalars ℝ map).comp ↑Complex.conjCLE)

full_name: IsConformalMap.is_complex_or_conj_linear
code: theorem IsConformalMap.is_complex_or_conj_linear (h : IsConformalMap g) :
    (∃ map : ℂ →L[ℂ] ℂ, map.restrictScalars ℝ = g) ∨
      ∃ map : ℂ →L[ℂ] ℂ, map.restrictScalars ℝ = g ∘L ↑conjCLE 
goal: (∃ map, ContinuousLinearMap.restrictScalars ℝ map = g) ∨
  ∃ map, ContinuousLinearMap.restrictScalars ℝ map = g.comp ↑Complex.conjCLE

full_name: isConformalMap_iff_is_complex_or_conj_linear
code: /-- A real continuous linear map on the complex plane is conformal if and only if the map or its
    conjugate is complex linear, and the map is nonvanishing. -/
theorem isConformalMap_iff_is_complex_or_conj_linear :
    IsConformalMap g ↔
      ((∃ map : ℂ →L[ℂ] ℂ, map.restrictScalars ℝ = g) ∨
          ∃ map : ℂ →L[ℂ] ℂ, map.restrictScalars ℝ = g ∘L ↑conjCLE) ∧
        g ≠ 0 
goal: IsConformalMap g ↔
  ((∃ map, ContinuousLinearMap.restrictScalars ℝ map = g) ∨
      ∃ map, ContinuousLinearMap.restrictScalars ℝ map = g.comp ↑Complex.conjCLE) ∧
    g ≠ 0
File: Mathlib/Condensed/Epi.lean

full_name: Condensed.epi_iff_locallySurjective_on_compHaus
code: lemma epi_iff_locallySurjective_on_compHaus : Epi f ↔
    ∀ (S : CompHaus) (y : Y.val.obj ⟨S⟩),
      (∃ (S' : CompHaus) (φ : S' ⟶ S) (_ : Function.Surjective φ) (x : X.val.obj ⟨S'⟩),
        f.val.app ⟨S'⟩ x = Y.val.map ⟨φ⟩ y) 
goal: CategoryTheory.Epi f ↔
  ∀ (S : CompHaus) (y : (CategoryTheory.forget A).obj (Y.val.obj (Opposite.op S))),
    ∃ S' φ, ∃ (_ : Function.Surjective ⇑φ), ∃ x, (f.val.app (Opposite.op S')) x = (Y.val.map (Opposite.op φ)) y

full_name: Condensed.epi_iff_surjective_on_stonean
code: lemma epi_iff_surjective_on_stonean : Epi f ↔
    ∀ (S : Stonean), Function.Surjective (f.val.app (op S.compHaus)) 
goal: CategoryTheory.Epi f ↔ ∀ (S : Stonean), Function.Surjective ⇑(f.val.app (Opposite.op S.compHaus))

full_name: CondensedSet.epi_iff_locallySurjective_on_compHaus
code: lemma epi_iff_locallySurjective_on_compHaus : Epi f ↔
    ∀ (S : CompHaus) (y : Y.val.obj ⟨S⟩),
      (∃ (S' : CompHaus) (φ : S' ⟶ S) (_ : Function.Surjective φ) (x : X.val.obj ⟨S'⟩),
        f.val.app ⟨S'⟩ x = Y.val.map ⟨φ⟩ y) 
goal: CategoryTheory.Epi f ↔
  ∀ (S : CompHaus) (y : Y.val.obj (Opposite.op S)),
    ∃ S' φ, ∃ (_ : Function.Surjective ⇑φ), ∃ x, f.val.app (Opposite.op S') x = Y.val.map (Opposite.op φ) y

full_name: CondensedSet.epi_iff_surjective_on_stonean
code: lemma epi_iff_surjective_on_stonean : Epi f ↔
    ∀ (S : Stonean), Function.Surjective (f.val.app (op S.compHaus)) 
goal: CategoryTheory.Epi f ↔ ∀ (S : Stonean), Function.Surjective (f.val.app (Opposite.op S.compHaus))

full_name: CondensedMod.epi_iff_locallySurjective_on_compHaus
code: lemma epi_iff_locallySurjective_on_compHaus : Epi f ↔
    ∀ (S : CompHaus) (y : Y.val.obj ⟨S⟩),
      (∃ (S' : CompHaus) (φ : S' ⟶ S) (_ : Function.Surjective φ) (x : X.val.obj ⟨S'⟩),
        f.val.app ⟨S'⟩ x = Y.val.map ⟨φ⟩ y) 
goal: CategoryTheory.Epi f ↔
  ∀ (S : CompHaus) (y : ↑(Y.val.obj (Opposite.op S))),
    ∃ S' φ, ∃ (_ : Function.Surjective ⇑φ), ∃ x, (f.val.app (Opposite.op S')) x = (Y.val.map (Opposite.op φ)) y

full_name: CondensedMod.epi_iff_surjective_on_stonean
code: lemma epi_iff_surjective_on_stonean : Epi f ↔
    ∀ (S : Stonean), Function.Surjective (f.val.app (op S.compHaus)) 
goal: CategoryTheory.Epi f ↔ ∀ (S : Stonean), Function.Surjective ⇑(f.val.app (Opposite.op S.compHaus))
File: Mathlib/Condensed/Light/TopComparison.lean

full_name: TopCat.toLightCondSet_val_obj
code: /--
Associate to a `u`-small topological space the corresponding light condensed set, given by
`yonedaPresheaf`.
-/
@[simps! val_obj val_map]
noncomputable def TopCat.toLightCondSet (X : TopCat.{u}) : LightCondSet.{u} 
goal: ∀ (X_1 : LightProfiniteᵒᵖ), X.toLightCondSet.val.obj X_1 = C(↑(Opposite.unop X_1).toTop, ↑X)

full_name: TopCat.toLightCondSet_val_map
code: /--
Associate to a `u`-small topological space the corresponding light condensed set, given by
`yonedaPresheaf`.
-/
@[simps! val_obj val_map]
noncomputable def TopCat.toLightCondSet (X : TopCat.{u}) : LightCondSet.{u} 
goal: ∀ {X_1 Y : LightProfiniteᵒᵖ} (f : X_1 ⟶ Y) (g : C(↑(LightProfinite.toTopCat.obj (Opposite.unop X_1)), ↑X)),
  X.toLightCondSet.val.map f g = g.comp f.unop

full_name: TopCat.toLightCondSet
code: /--
Associate to a `u`-small topological space the corresponding light condensed set, given by
`yonedaPresheaf`.
-/
@[simps! val_obj val_map]
noncomputable def TopCat.toLightCondSet (X : TopCat.{u}) : LightCondSet.{u} 
goal: LightCondSet

full_name: topCatToLightCondSet
code: /--
`TopCat.toLightCondSet` yields a functor from `TopCat.{u}` to `LightCondSet.{u}`.
-/
@[simps]
noncomputable def topCatToLightCondSet : TopCat.{u} ⥤ LightCondSet.{u} 
goal: TopCat ⥤ LightCondSet

full_name: topCatToLightCondSet_obj
code: /--
`TopCat.toLightCondSet` yields a functor from `TopCat.{u}` to `LightCondSet.{u}`.
-/
@[simps]
noncomputable def topCatToLightCondSet : TopCat.{u} ⥤ LightCondSet.{u} 
goal: topCatToLightCondSet.obj X = X.toLightCondSet

full_name: topCatToLightCondSet_map_val_app
code: /--
`TopCat.toLightCondSet` yields a functor from `TopCat.{u}` to `LightCondSet.{u}`.
-/
@[simps]
noncomputable def topCatToLightCondSet : TopCat.{u} ⥤ LightCondSet.{u} 
goal: ∀ {X Y : TopCat} (f : X ⟶ Y) (x : LightProfiniteᵒᵖ) (g : ((fun X => X.toLightCondSet) X).val.obj x),
  (topCatToLightCondSet.map f).val.app x g = ContinuousMap.comp f g
File: Mathlib/Condensed/Light/Module.lean

full_name: LightCondMod
code: /--
The category of condensed `R`-modules, defined as sheaves of `R`-modules over
`CompHaus` with respect to the coherent Grothendieck topology.
-/
abbrev LightCondMod 
goal: Type (u + 1)

full_name: instAbelianLightCondMod
code: noncomputable instance : Abelian (LightCondMod.{u} R) 
goal: CategoryTheory.Abelian (LightCondMod R)

full_name: LightCondensed.forget
code: /-- The forgetful functor from condensed `R`-modules to condensed sets. -/
def LightCondensed.forget : LightCondMod R ⥤ LightCondSet 
goal: LightCondMod R ⥤ LightCondSet

full_name: LightCondensed.free
code: /--
The left adjoint to the forgetful functor. The *free condensed `R`-module* on a condensed set.
-/
noncomputable
def LightCondensed.free : LightCondSet ⥤ LightCondMod R 
goal: LightCondSet ⥤ LightCondMod R

full_name: LightCondensed.freeForgetAdjunction
code: /-- The condensed version of the free-forgetful adjunction. -/
noncomputable
def LightCondensed.freeForgetAdjunction : free R ⊣ forget R 
goal: LightCondensed.free R ⊣ LightCondensed.forget R

full_name: LightCondAb
code: /--
The category of condensed abelian groups, defined as sheaves of abelian groups over
`CompHaus` with respect to the coherent Grothendieck topology.
-/
abbrev LightCondAb 
goal: Type 1

full_name: LightCondMod.hom_naturality_apply
code: @[simp]
lemma hom_naturality_apply {X Y : LightCondMod.{u} R} (f : X ⟶ Y)  {S T : LightProfiniteᵒᵖ}
    (g : S ⟶ T) (x : X.val.obj S) : f.val.app T (X.val.map g x) = Y.val.map g (f.val.app S x) 
goal: (f.val.app T) ((X.val.map g) x) = (Y.val.map g) ((f.val.app S) x)
File: Mathlib/Condensed/Discrete.lean

full_name: Condensed.discrete_map
code: /--
The discrete condensed object associated to an object of `C` is the constant sheaf at that object.
-/
@[simps!]
noncomputable def Condensed.discrete : C ⥤ Condensed.{u} C 
goal: ∀ {X Y : C} (f : X ⟶ Y),
  (Condensed.discrete C).map f =
    (CategoryTheory.presheafToSheaf (CategoryTheory.coherentTopology CompHaus) C).map
      ((CategoryTheory.Functor.const CompHausᵒᵖ).map f)

full_name: Condensed.discrete_obj
code: /--
The discrete condensed object associated to an object of `C` is the constant sheaf at that object.
-/
@[simps!]
noncomputable def Condensed.discrete : C ⥤ Condensed.{u} C 
goal: (Condensed.discrete C).obj X =
  (CategoryTheory.presheafToSheaf (CategoryTheory.coherentTopology CompHaus) C).obj
    ((CategoryTheory.Functor.const CompHausᵒᵖ).obj X)

full_name: Condensed.discrete
code: /--
The discrete condensed object associated to an object of `C` is the constant sheaf at that object.
-/
@[simps!]
noncomputable def Condensed.discrete : C ⥤ Condensed.{u} C 
goal: C ⥤ Condensed C

full_name: Condensed.underlying
code: /--
The underlying object of a condensed object in `C` is the condensed object evaluated at a point.
This can be viewed as a sort of forgetful functor from `Condensed C` to `C`
-/
@[simps!]
noncomputable def Condensed.underlying : Condensed.{u} C ⥤ C 
goal: Condensed C ⥤ C

full_name: Condensed.underlying_obj
code: /--
The underlying object of a condensed object in `C` is the condensed object evaluated at a point.
This can be viewed as a sort of forgetful functor from `Condensed C` to `C`
-/
@[simps!]
noncomputable def Condensed.underlying : Condensed.{u} C ⥤ C 
goal: (Condensed.underlying C).obj j = j.val.obj (Opposite.op (CompHaus.of PUnit.{u + 1}))

full_name: Condensed.underlying_map
code: /--
The underlying object of a condensed object in `C` is the condensed object evaluated at a point.
This can be viewed as a sort of forgetful functor from `Condensed C` to `C`
-/
@[simps!]
noncomputable def Condensed.underlying : Condensed.{u} C ⥤ C 
goal: ∀ {X Y : CategoryTheory.Sheaf (CategoryTheory.coherentTopology CompHaus) C} (f : X ⟶ Y),
  (Condensed.underlying C).map f = f.val.app (Opposite.op (CompHaus.of PUnit.{u + 1}))

full_name: Condensed.discreteUnderlyingAdj
code: /--
Discreteness is left adjoint to the forgetful functor. When `C` is `Type*`, this is analogous to
`TopCat.adj₁ : TopCat.discrete ⊣ forget TopCat`.  
-/
noncomputable def Condensed.discreteUnderlyingAdj : discrete C ⊣ underlying C 
goal: Condensed.discrete C ⊣ Condensed.underlying C
File: Mathlib/Condensed/Solid.lean

full_name: Condensed.finFree
code: /-- The free condensed abelian group on a finite set. -/
abbrev finFree : FintypeCat.{u} ⥤ CondensedMod.{u} R 
goal: FintypeCat ⥤ CondensedMod R

full_name: Condensed.profiniteFree
code: /-- The free condensed abelian group on a profinite space. -/
abbrev profiniteFree : Profinite.{u} ⥤ CondensedMod.{u} R 
goal: Profinite ⥤ CondensedMod R

full_name: Condensed.profiniteSolid
code: /-- The functor sending a profinite space `S` to the condensed abelian group `R[S]^\solid`. -/
def profiniteSolid : Profinite.{u} ⥤ CondensedMod.{u} R 
goal: Profinite ⥤ CondensedMod R

full_name: Condensed.profiniteSolidCounit
code: /-- The natural transformation `FintypeCat.toProfinite ⋙ profiniteSolid R ⟶ finFree R`
which is part of the assertion that `profiniteSolid R` is the (pointwise) right
Kan extension of `finFree R` along `FintypeCat.toProfinite`. -/
def profiniteSolidCounit : FintypeCat.toProfinite ⋙ profiniteSolid R ⟶ finFree R 
goal: FintypeCat.toProfinite ⋙ Condensed.profiniteSolid R ⟶ Condensed.finFree R

full_name: Condensed.instIsRightKanExtensionFintypeCatCondensedModProfiniteProfiniteSolidProfiniteSolidCounit
code: instance : (profiniteSolid R).IsRightKanExtension (profiniteSolidCounit R) 
goal: (Condensed.profiniteSolid R).IsRightKanExtension (Condensed.profiniteSolidCounit R)

full_name: Condensed.profiniteSolidIsPointwiseRightKanExtension
code: /-- The functor `Profinite.{u} ⥤ CondensedMod.{u} R` is a pointwise
right Kan extension of `finFree R : FintypeCat.{u} ⥤ CondensedMod.{u} R`
along `FintypeCat.toProfinite`. -/
def profiniteSolidIsPointwiseRightKanExtension :
    (Functor.RightExtension.mk _ (profiniteSolidCounit R)).IsPointwiseRightKanExtension 
goal: (CategoryTheory.Functor.RightExtension.mk (Condensed.profiniteSolid R)
    (Condensed.profiniteSolidCounit R)).IsPointwiseRightKanExtension

full_name: Condensed.profiniteSolidification
code: /-- The natural transformation `R[S] ⟶ R[S]^\solid`. -/
def profiniteSolidification : profiniteFree R ⟶ profiniteSolid.{u} R 
goal: Condensed.profiniteFree R ⟶ Condensed.profiniteSolid R

full_name: CondensedMod.IsSolid.isIso_solidification_map
code: /-- The predicate on condensed abelian groups describing the property of being solid. -/
class CondensedMod.IsSolid (A : CondensedMod.{u} R) : Prop where
  isIso_solidification_map : ∀ X : Profinite.{u}, IsIso ((yoneda.obj A).map
    ((profiniteSolidification R).app X).op)
goal: CategoryTheory.IsIso ((CategoryTheory.yoneda.obj A).map ((Condensed.profiniteSolidification R).app X).op)

full_name: CondensedMod.IsSolid
code: /-- The predicate on condensed abelian groups describing the property of being solid. -/
class CondensedMod.IsSolid (A : CondensedMod.{u} R) : Prop where
  isIso_solidification_map : ∀ X : Profinite.{u}, IsIso ((yoneda.obj A).map
    ((profiniteSolidification R).app X).op)
goal: Prop