General operations on functions

theorem Function.flip_def {α : Sort u₁} {β : Sort u₂} {φ : Sort u₃} {f : α → β → φ} : flip f = fun (b : β) (a : α) => f a b

@[reducible, inline]

def Function.dcomp {α : Sort u₁} {β : α → Sort u₂} {φ : {x : α} → β x → Sort u₃} (f : {x : α} → (y : β x) → φ y) (g : (x : α) → β x) (x : α) : φ (g x)

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.

Equations

• (f ∘' g) x = f (g x)

def Function.«term_∘'_» : Lean.TrailingParserDescr

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.

Equations

• Function.«term_∘'_» = Lean.ParserDescr.trailingNode `Function.«term_∘'_» 80 81 (Lean.ParserDescr.binary `andthen (Lean.ParserDescr.symbol " ∘' ") (Lean.ParserDescr.cat `term 80))

@[reducible, inline]

abbrev Function.onFun {α : Sort u₁} {β : Sort u₂} {φ : Sort u₃} (f : β → β → φ) (g : α → β) : α → α → φ

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 α.

Equations

• Function.onFun f g x y = f (g x) (g y)

def Function.term_On_ : Lean.TrailingParserDescr

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 α.

Equations

• Function.term_On_ = Lean.ParserDescr.trailingNode `Function.term_On_ 2 2 (Lean.ParserDescr.binary `andthen (Lean.ParserDescr.symbol " on ") (Lean.ParserDescr.cat `term 3))

@[reducible, inline]

abbrev Function.swap {α : Sort u₁} {β : Sort u₂} {φ : α → β → Sort u₃} (f : (x : α) → (y : β) → φ x y) (y : β) (x : α) : φ x y

For a two-argument function f, swap f is the same function but taking the arguments in the reverse order. swap f y x = f x y.

Equations

• Function.swap f y x = f x y

theorem Function.swap_def {α : Sort u₁} {β : Sort u₂} {φ : α → β → Sort u₃} (f : (x : α) → (y : β) → φ x y) : swap f = fun (y : β) (x : α) => f x y

theorem Function.comp_assoc {α : Sort u₁} {β : Sort u₂} {φ : Sort u₃} {δ : Sort u₄} (f : φ → δ) (g : β → φ) (h : α → β) : (f ∘ g) ∘ h = f ∘ g ∘ h

def Function.Bijective {α : Sort u₁} {β : Sort u₂} (f : α → β) : Prop

A function is called bijective if it is both injective and surjective.

Equations

• Function.Bijective f = (Function.Injective f ∧ Function.Surjective f)

theorem Function.Bijective.comp {α : Sort u₁} {β : Sort u₂} {φ : Sort u₃} {g : β → φ} {f : α → β} : Bijective g → Bijective f → Bijective (g ∘ f)

theorem Function.bijective_id {α : Sort u₁} : Bijective id

theorem Function.Injective.beq_eq {α : Type u_1} {β : Type u_2} [BEq α] [LawfulBEq α] [BEq β] [LawfulBEq β] {f : α → β} (I : Injective f) {a b : α} : (f a == f b) = (a == b)

def Function.bicompl {α : Type u_1} {β : Type u_2} {γ : Type u_3} {δ : Type u_4} {ε : Type u_5} (f : γ → δ → ε) (g : α → γ) (h : β → δ) (a : α) (b : β) : ε

Compose a binary function f with a pair of unary functions g and h. If both arguments of f have the same type and g = h, then bicompl f g g = f on g.

Equations

• Function.bicompl f g h a b = f (g a) (h b)

def Function.bicompr {α : Type u_1} {β : Type u_2} {γ : Type u_3} {δ : Type u_4} (f : γ → δ) (g : α → β → γ) (a : α) (b : β) : δ

Compose a unary function f with a binary function g.

Equations

• Function.bicompr f g a b = f (g a b)

theorem Function.uncurry_bicompr {α : Type u_1} {β : Type u_2} {γ : Type u_3} {δ : Type u_4} (f : α → β → γ) (g : γ → δ) : uncurry (bicompr g f) = g ∘ uncurry f

theorem Function.uncurry_bicompl {α : Type u_1} {β : Type u_2} {γ : Type u_3} {δ : Type u_4} {ε : Type u_5} (f : γ → δ → ε) (g : α → γ) (h : β → δ) : uncurry (bicompl f g h) = uncurry f ∘ Prod.map g h

def Function.IsFixedPt {α : Type u₁} (f : α → α) (x : α) : Prop

A point x is a fixed point of f : α → α if f x = x.

Equations

• Function.IsFixedPt f x = (f x = x)

theorem Function.IsFixedPt.eq {α : Type u₁} {f : α → α} {x : α} (hf : IsFixedPt f x) : f x = x

If x is a fixed point of f, then f x = x. This is useful, e.g., for rw or simp.

@[implicit_reducible]

instance Function.IsFixedPt.decidable {α : Type u₁} [h : DecidableEq α] {f : α → α} {x : α} : Decidable (IsFixedPt f x)

Equations

• Function.IsFixedPt.decidable = h (f x) x

theorem Function.IsFixedPt.of_subsingleton {α : Type u₁} [Subsingleton α] (f : α → α) (x : α) : IsFixedPt f x

theorem Function.isFixedPt_id {α : Type u₁} (x : α) : IsFixedPt id x

Every point is a fixed point of id.

@[simp]

theorem Function.forall_isFixedPt_iff {α : Type u₁} {f : α → α} : (∀ (x : α), IsFixedPt f x) ↔ f = id

A function fixes every point iff it is the identity.

def Pi.map {ι : Sort u_1} {α : ι → Sort u_2} {β : ι → Sort u_3} (f : (i : ι) → α i → β i) : ((i : ι) → α i) → (i : ι) → β i

Sends a dependent function a : ∀ i, α i to a dependent function Pi.map f a : ∀ i, β i by applying f i to i-th component.

Equations

• Pi.map f a i = f i (a i)

@[simp]

theorem Pi.map_apply {ι : Sort u_1} {α : ι → Sort u_2} {β : ι → Sort u_3} (f : (i : ι) → α i → β i) (a : (i : ι) → α i) (i : ι) : Pi.map f a i = f i (a i)