File: Mathlib/Logic/Small/Defs.lean

full_name: Small
code: /-- A type is `Small.{w}` if there exists an equivalence to some `S : Type w`.
-/
@[mk_iff, pp_with_univ]
class Small (α : Type v) : Prop where
  /-- If a type is `Small.{w}`, then there exists an equivalence with some `S : Type w` -/
  equiv_small : ∃ S : Type w, Nonempty (α ≃ S)
goal: Prop

full_name: small_iff
code: /-- A type is `Small.{w}` if there exists an equivalence to some `S : Type w`.
-/
@[mk_iff, pp_with_univ]
class Small (α : Type v) : Prop where
  /-- If a type is `Small.{w}`, then there exists an equivalence with some `S : Type w` -/
  equiv_small : ∃ S : Type w, Nonempty (α ≃ S)
goal: Small.{w, v} α ↔ ∃ S, Nonempty (α ≃ S)

full_name: Small.equiv_small
code: /-- A type is `Small.{w}` if there exists an equivalence to some `S : Type w`.
-/
@[mk_iff, pp_with_univ]
class Small (α : Type v) : Prop where
  /-- If a type is `Small.{w}`, then there exists an equivalence with some `S : Type w` -/
  equiv_small : ∃ S : Type w, Nonempty (α ≃ S)
goal: ∃ S, Nonempty (α ≃ S)

full_name: Small.mk'
code: /-- Constructor for `Small α` from an explicit witness type and equivalence.
-/
theorem Small.mk' {α : Type v} {S : Type w} (e : α ≃ S) : Small.{w} α 
goal: Small.{w, v} α

full_name: Shrink
code: /-- An arbitrarily chosen model in `Type w` for a `w`-small type.
-/
@[pp_with_univ]
def Shrink (α : Type v) [Small.{w} α] : Type w 
goal: Type w

full_name: equivShrink
code: /-- The noncomputable equivalence between a `w`-small type and a model.
-/
noncomputable def equivShrink (α : Type v) [Small.{w} α] : α ≃ Shrink α 
goal: α ≃ Shrink.{w, v} α

full_name: Shrink.ext
code: @[ext]
theorem Shrink.ext {α : Type v} [Small.{w} α] {x y : Shrink α}
    (w : (equivShrink _).symm x = (equivShrink _).symm y) : x = y 
goal: x = y

full_name: Shrink.rec
code: @[induction_eliminator]
protected noncomputable def Shrink.rec {α : Type*} [Small.{w} α] {F : Shrink α → Sort v}
    (h : ∀ X, F (equivShrink _ X)) : ∀ X, F X 
goal: F X

full_name: small_self
code: instance (priority := 101) small_self (α : Type v) : Small.{v} α 
goal: Small.{v, v} α

full_name: small_map
code: theorem small_map {α : Type*} {β : Type*} [hβ : Small.{w} β] (e : α ≃ β) : Small.{w} α 
goal: Small.{w, u_1} α

full_name: small_lift
code: theorem small_lift (α : Type u) [hα : Small.{v} α] : Small.{max v w} α 
goal: Small.{max v w, u} α

full_name: small_max
code: lemma small_max (α : Type v) : Small.{max w v} α 
goal: Small.{max w v, v} α

full_name: small_zero
code: instance small_zero (α : Type) : Small.{w} α 
goal: Small.{w, 0} α

full_name: small_succ
code: instance (priority := 100) small_succ (α : Type v) : Small.{v+1} α 
goal: Small.{v + 1, v} α

full_name: small_ulift
code: instance small_ulift (α : Type u) [Small.{v} α] : Small.{v} (ULift.{w} α) 
goal: Small.{v, max w u} (ULift.{w, u} α)

full_name: small_type
code: theorem small_type : Small.{max (u + 1) v} (Type u) 
goal: Small.{max (u + 1) v, u + 1} (Type u)

full_name: small_congr
code: theorem small_congr {α : Type*} {β : Type*} (e : α ≃ β) : Small.{w} α ↔ Small.{w} β 
goal: Small.{w, u_1} α ↔ Small.{w, u_2} β

full_name: small_sigma
code: instance small_sigma {α} (β : α → Type*) [Small.{w} α] [∀ a, Small.{w} (β a)] :
    Small.{w} (Σa, β a) 
goal: Small.{w, max u_1 u_2} ((a : α) × β a)

full_name: not_small_type
code: theorem not_small_type : ¬Small.{u} (Type max u v)
  
goal: ¬Small.{u, max (u + 1) (v + 1)} (Type (max u v))