File: Mathlib/Data/FunLike/Basic.lean

full_name: DFunLike.coe_injective'
code: /-- The class `DFunLike F α β` expresses that terms of type `F` have an
injective coercion to (dependent) functions from `α` to `β`.

For non-dependent functions you can also use the abbreviation `FunLike`.

This typeclass is used in the definition of the homomorphism typeclasses,
such as `ZeroHomClass`, `MulHomClass`, `MonoidHomClass`, ....
-/
@[notation_class * toFun Simps.findCoercionArgs]
class DFunLike (F : Sort*) (α : outParam (Sort*)) (β : outParam <| α → Sort*) where
  /-- The coercion from `F` to a function. -/
  coe : F → ∀ a : α, β a
  /-- The coercion to functions must be injective. -/
  coe_injective' : Function.Injective coe
goal: Function.Injective DFunLike.coe

full_name: DFunLike.coe
code: /-- The class `DFunLike F α β` expresses that terms of type `F` have an
injective coercion to (dependent) functions from `α` to `β`.

For non-dependent functions you can also use the abbreviation `FunLike`.

This typeclass is used in the definition of the homomorphism typeclasses,
such as `ZeroHomClass`, `MulHomClass`, `MonoidHomClass`, ....
-/
@[notation_class * toFun Simps.findCoercionArgs]
class DFunLike (F : Sort*) (α : outParam (Sort*)) (β : outParam <| α → Sort*) where
  /-- The coercion from `F` to a function. -/
  coe : F → ∀ a : α, β a
  /-- The coercion to functions must be injective. -/
  coe_injective' : Function.Injective coe
goal: F → (a : α) → β a

full_name: DFunLike
code: /-- The class `DFunLike F α β` expresses that terms of type `F` have an
injective coercion to (dependent) functions from `α` to `β`.

For non-dependent functions you can also use the abbreviation `FunLike`.

This typeclass is used in the definition of the homomorphism typeclasses,
such as `ZeroHomClass`, `MulHomClass`, `MonoidHomClass`, ....
-/
@[notation_class * toFun Simps.findCoercionArgs]
class DFunLike (F : Sort*) (α : outParam (Sort*)) (β : outParam <| α → Sort*) where
  /-- The coercion from `F` to a function. -/
  coe : F → ∀ a : α, β a
  /-- The coercion to functions must be injective. -/
  coe_injective' : Function.Injective coe
goal: Sort (max (max (max 1 u_1) u_2) u_3)

full_name: FunLike
code: /-- The class `FunLike F α β` (`Fun`ction-`Like`) expresses that terms of type `F`
have an injective coercion to functions from `α` to `β`.
`FunLike` is the non-dependent version of `DFunLike`.
This typeclass is used in the definition of the homomorphism typeclasses,
such as `ZeroHomClass`, `MulHomClass`, `MonoidHomClass`, ....
-/
abbrev FunLike F α β 
goal: Sort (max (max (max 1 u_1) u_2) u_3)

full_name: DFunLike.hasCoeToFun
code: instance (priority := 100) hasCoeToFun : CoeFun F (fun _ ↦ ∀ a : α, β a) 
goal: CoeFun F fun x => (a : α) → β a

full_name: DFunLike.coe_eq_coe_fn
code: theorem coe_eq_coe_fn : (DFunLike.coe (F := F)) = (fun f => ↑f) 
goal: DFunLike.coe = fun f => ⇑f

full_name: DFunLike.coe_injective
code: theorem coe_injective : Function.Injective (fun f : F ↦ (f : ∀ a : α, β a)) 
goal: Function.Injective fun f => ⇑f

full_name: DFunLike.coe_fn_eq
code: @[simp]
theorem coe_fn_eq {f g : F} : (f : ∀ a : α, β a) = (g : ∀ a : α, β a) ↔ f = g 
goal: ⇑f = ⇑g ↔ f = g

full_name: DFunLike.ext'
code: theorem ext' {f g : F} (h : (f : ∀ a : α, β a) = (g : ∀ a : α, β a)) : f = g 
goal: f = g

full_name: DFunLike.ext'_iff
code: theorem ext'_iff {f g : F} : f = g ↔ (f : ∀ a : α, β a) = (g : ∀ a : α, β a) 
goal: f = g ↔ ⇑f = ⇑g

full_name: DFunLike.ext
code: theorem ext (f g : F) (h : ∀ x : α, f x = g x) : f = g 
goal: f = g

full_name: DFunLike.ext_iff
code: theorem ext_iff {f g : F} : f = g ↔ ∀ x, f x = g x 
goal: f = g ↔ ∀ (x : α), f x = g x

full_name: DFunLike.congr_fun
code: protected theorem congr_fun {f g : F} (h₁ : f = g) (x : α) : f x = g x 
goal: f x = g x

full_name: DFunLike.ne_iff
code: theorem ne_iff {f g : F} : f ≠ g ↔ ∃ a, f a ≠ g a 
goal: f ≠ g ↔ ∃ a, f a ≠ g a

full_name: DFunLike.exists_ne
code: theorem exists_ne {f g : F} (h : f ≠ g) : ∃ x, f x ≠ g x 
goal: ∃ x, f x ≠ g x

full_name: DFunLike.subsingleton_cod
code: /-- This is not an instance to avoid slowing down every single `Subsingleton` typeclass search. -/
lemma subsingleton_cod [∀ a, Subsingleton (β a)] : Subsingleton F 
goal: Subsingleton F

full_name: DFunLike.congr
code: protected theorem congr {f g : F} {x y : α} (h₁ : f = g) (h₂ : x = y) : f x = g y 
goal: f x = g y

full_name: DFunLike.congr_arg
code: protected theorem congr_arg (f : F) {x y : α} (h₂ : x = y) : f x = f y 
goal: f x = f y