File: Mathlib/Logic/Function/Defs.lean

full_name: Function.flip_def
code: lemma flip_def {f : α → β → φ} : flip f = fun b a => f a b 
goal: flip f = fun b a => f a b

full_name: Function.dcomp
code: /-- Composition of dependent functions: `(f ∘' g) x = f (g x)`, where type of `g x` depends on `x`
and type of `f (g x)` depends on `x` and `g x`. -/
@[inline, reducible]
def dcomp {β : α → Sort u₂} {φ : ∀ {x : α}, β x → Sort u₃} (f : ∀ {x : α} (y : β x), φ y)
    (g : ∀ x, β x) : ∀ x, φ (g x) 
goal: φ (g x)

full_name: Function.«_aux_Mathlib_Logic_Function_Defs___macroRules_Function_term_∘'__1»
code: infixr:80 " ∘' " => Function.dcomp
goal: Lean.Macro

full_name: Function._aux_Mathlib_Logic_Function_Defs___unexpand_Function_dcomp_1
code: infixr:80 " ∘' " => Function.dcomp
goal: Lean.PrettyPrinter.Unexpander

full_name: Function.compRight
code: @[reducible, deprecated (since := "2024-01-13")]
def compRight (f : β → β → β) (g : α → β) : β → α → β 
goal: β → α → β

full_name: Function.compLeft
code: @[reducible, deprecated (since := "2024-01-13")]
def compLeft (f : β → β → β) (g : α → β) : α → β → β 
goal: α → β → β

full_name: Function.onFun
code: /-- Given functions `f : β → β → φ` and `g : α → β`, produce a function `α → α → φ` that evaluates
`g` on each argument, then applies `f` to the results. Can be used, e.g., to transfer a relation
from `β` to `α`. -/
abbrev onFun (f : β → β → φ) (g : α → β) : α → α → φ 
goal: α → α → φ

full_name: Function._aux_Mathlib_Logic_Function_Defs___macroRules_Function_term_On__1
code: @[inherit_doc onFun]
infixl:2 " on " => onFun
goal: Lean.Macro

full_name: Function._aux_Mathlib_Logic_Function_Defs___unexpand_Function_onFun_1
code: @[inherit_doc onFun]
infixl:2 " on " => onFun
goal: Lean.PrettyPrinter.Unexpander

full_name: Function.combine
code: /-- Given functions `f : α → β → φ`, `g : α → β → δ` and a binary operator `op : φ → δ → ζ`,
produce a function `α → β → ζ` that applies `f` and `g` on each argument and then applies
`op` to the results.
-/
-- Porting note: the ζ variable was originally constrained to `Sort u₁`, but this seems to
-- have been an oversight.
@[reducible, deprecated (since := "2024-01-13")]
def combine (f : α → β → φ) (op : φ → δ → ζ) (g : α → β → δ) : α → β → ζ 
goal: α → β → ζ

full_name: Function.swap
code: abbrev swap {φ : α → β → Sort u₃} (f : ∀ x y, φ x y) : ∀ y x, φ x y 
goal: φ x y

full_name: Function.swap_def
code: theorem swap_def {φ : α → β → Sort u₃} (f : ∀ x y, φ x y) : swap f = fun y x => f x y 
goal: Function.swap f = fun y x => f x y

full_name: Function.app
code: @[reducible, deprecated (since := "2024-01-13")]
def app {β : α → Sort u₂} (f : ∀ x, β x) (x : α) : β x 
goal: β x

full_name: Function.id_comp
code: @[simp, mfld_simps]
theorem id_comp (f : α → β) : id ∘ f = f 
goal: id ∘ f = f

full_name: Function.comp_id
code: @[simp, mfld_simps]
theorem comp_id (f : α → β) : f ∘ id = f 
goal: f ∘ id = f

full_name: Function.comp.assoc
code: theorem comp.assoc (f : φ → δ) (g : β → φ) (h : α → β) : (f ∘ g) ∘ h = f ∘ g ∘ h 
goal: (f ∘ g) ∘ h = f ∘ g ∘ h

full_name: Function.const_comp
code: @[simp] theorem const_comp {γ : Sort*} (f : α → β) (c : γ) : const β c ∘ f = const α c 
goal: Function.const β c ∘ f = Function.const α c

full_name: Function.comp_const
code: @[simp] theorem comp_const (f : β → φ) (b : β) : f ∘ const α b = const α (f b) 
goal: f ∘ Function.const α b = Function.const α (f b)

full_name: Function.Injective
code: /-- A function `f : α → β` is called injective if `f x = f y` implies `x = y`. -/
def Injective (f : α → β) : Prop 
goal: Prop

full_name: Function.Injective.comp
code: theorem Injective.comp {g : β → φ} {f : α → β} (hg : Injective g) (hf : Injective f) :
    Injective (g ∘ f) 
goal: Function.Injective (g ∘ f)

full_name: Function.Surjective
code: /-- A function `f : α → β` is called surjective if every `b : β` is equal to `f a`
for some `a : α`. -/
def Surjective (f : α → β) : Prop 
goal: Prop

full_name: Function.Surjective.comp
code: theorem Surjective.comp {g : β → φ} {f : α → β} (hg : Surjective g) (hf : Surjective f) :
    Surjective (g ∘ f) 
goal: Function.Surjective (g ∘ f)

full_name: Function.Bijective
code: /-- A function is called bijective if it is both injective and surjective. -/
def Bijective (f : α → β) 
goal: Prop

full_name: Function.Bijective.comp
code: theorem Bijective.comp {g : β → φ} {f : α → β} : Bijective g → Bijective f → Bijective (g ∘ f)
  
goal: Function.Bijective g → Function.Bijective f → Function.Bijective (g ∘ f)

full_name: Function.LeftInverse
code: /-- `LeftInverse g f` means that g is a left inverse to f. That is, `g ∘ f = id`. -/
def LeftInverse (g : β → α) (f : α → β) : Prop 
goal: Prop

full_name: Function.HasLeftInverse
code: /-- `HasLeftInverse f` means that `f` has an unspecified left inverse. -/
def HasLeftInverse (f : α → β) : Prop 
goal: Prop

full_name: Function.RightInverse
code: /-- `RightInverse g f` means that g is a right inverse to f. That is, `f ∘ g = id`. -/
def RightInverse (g : β → α) (f : α → β) : Prop 
goal: Prop

full_name: Function.HasRightInverse
code: /-- `HasRightInverse f` means that `f` has an unspecified right inverse. -/
def HasRightInverse (f : α → β) : Prop 
goal: Prop

full_name: Function.LeftInverse.injective
code: theorem LeftInverse.injective {g : β → α} {f : α → β} : LeftInverse g f → Injective f 
goal: Function.LeftInverse g f → Function.Injective f

full_name: Function.HasLeftInverse.injective
code: theorem HasLeftInverse.injective {f : α → β} : HasLeftInverse f → Injective f 
goal: Function.HasLeftInverse f → Function.Injective f

full_name: Function.rightInverse_of_injective_of_leftInverse
code: theorem rightInverse_of_injective_of_leftInverse {f : α → β} {g : β → α} (injf : Injective f)
    (lfg : LeftInverse f g) : RightInverse f g 
goal: Function.RightInverse f g

full_name: Function.RightInverse.surjective
code: theorem RightInverse.surjective {f : α → β} {g : β → α} (h : RightInverse g f) : Surjective f 
goal: Function.Surjective f

full_name: Function.HasRightInverse.surjective
code: theorem HasRightInverse.surjective {f : α → β} : HasRightInverse f → Surjective f
  
goal: Function.HasRightInverse f → Function.Surjective f

full_name: Function.leftInverse_of_surjective_of_rightInverse
code: theorem leftInverse_of_surjective_of_rightInverse {f : α → β} {g : β → α} (surjf : Surjective f)
    (rfg : RightInverse f g) : LeftInverse f g 
goal: Function.LeftInverse f g

full_name: Function.injective_id
code: theorem injective_id : Injective (@id α) 
goal: Function.Injective id

full_name: Function.surjective_id
code: theorem surjective_id : Surjective (@id α) 
goal: Function.Surjective id

full_name: Function.bijective_id
code: theorem bijective_id : Bijective (@id α) 
goal: Function.Bijective id

full_name: Function.curry
code: /-- Interpret a function on `α × β` as a function with two arguments. -/
@[inline]
def curry : (α × β → φ) → α → β → φ 
goal: (α × β → φ) → α → β → φ

full_name: Function.uncurry
code: /-- Interpret a function with two arguments as a function on `α × β` -/
@[inline]
def uncurry : (α → β → φ) → α × β → φ 
goal: (α → β → φ) → α × β → φ

full_name: Function.curry_uncurry
code: @[simp]
theorem curry_uncurry (f : α → β → φ) : curry (uncurry f) = f 
goal: Function.curry (Function.uncurry f) = f

full_name: Function.uncurry_curry
code: @[simp]
theorem uncurry_curry (f : α × β → φ) : uncurry (curry f) = f 
goal: Function.uncurry (Function.curry f) = f

full_name: Function.LeftInverse.id
code: protected theorem LeftInverse.id {g : β → α} {f : α → β} (h : LeftInverse g f) : g ∘ f = id 
goal: g ∘ f = id

full_name: Function.RightInverse.id
code: protected theorem RightInverse.id {g : β → α} {f : α → β} (h : RightInverse g f) : f ∘ g = id 
goal: f ∘ g = id