Documentation

theorem Function.eval_apply {α : Sort u_2} {β : α → Sort u_1} (x : α) (f : (x : α) → β x) :

Function.eval x f = f x

theorem Function.const_def {α : Sort u_1} {β : Sort u_2} {y : β} :

(fun x => y) = Function.const α y

@[simp]

theorem Function.const_comp {α : Sort u_1} {β : Sort u_3} {γ : Sort u_2} {f : α → β} {c : γ} :

Function.const β c ∘ f = Function.const α c

@[simp]

theorem Function.comp_const {α : Sort u_1} {β : Sort u_3} {γ : Sort u_2} {f : β → γ} {b : β} :

f ∘ Function.const α b = Function.const α (f b)

theorem Function.const_injective {α : Sort u_1} {β : Sort u_2} [Nonempty α] :

Function.Injective (Function.const α)

@[simp]

theorem Function.const_inj {α : Sort u_1} {β : Sort u_2} [Nonempty α] {y₁ : β} {y₂ : β} :

Function.const α y₁ = Function.const α y₂ ↔ y₁ = y₂

theorem Function.id_def {α : Sort u_1} :

id = fun x => x

theorem Function.onFun_apply {α : Sort u_2} {β : Sort u_3} {γ : Sort u_1} (f : β → β → γ) (g : α → β) (a : α) (b : α) :

(f on g) a b = f (g a) (g b)

theorem Function.hfunext {α : Sort u} {α' : Sort u} {β : α → Sort v} {β' : α' → Sort v} {f : (a : α) → β a} {f' : (a : α') → β' a} (hα : α = α') (h : ∀ (a : α) (a' : α'), HEq a a' → HEq (f a) (f' a')) :

HEq f f'

theorem Function.funext_iff {α : Sort u_2} {β : α → Sort u_1} {f₁ : (x : α) → β x} {f₂ : (x : α) → β x} :

f₁ = f₂ ↔ ∀ (a : α), f₁ a = f₂ a

theorem Function.ne_iff {α : Sort u_2} {β : α → Sort u_1} {f₁ : (a : α) → β a} {f₂ : (a : α) → β a} :

f₁ ≠ f₂ ↔ ∃ a, f₁ a ≠ f₂ a

theorem Function.Bijective.injective {α : Sort u_1} {β : Sort u_2} {f : α → β} (hf : Function.Bijective f) :

theorem Function.Bijective.surjective {α : Sort u_1} {β : Sort u_2} {f : α → β} (hf : Function.Bijective f) :

theorem Function.Injective.eq_iff {α : Sort u_1} {β : Sort u_2} {f : α → β} (I : Function.Injective f) {a : α} {b : α} :

f a = f b ↔ a = b

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

(f a == f b) = (a == b)

theorem Function.Injective.eq_iff' {α : Sort u_1} {β : Sort u_2} {f : α → β} (I : Function.Injective f) {a : α} {b : α} {c : β} (h : f b = c) :

f a = c ↔ a = b

theorem Function.Injective.ne {α : Sort u_1} {β : Sort u_2} {f : α → β} (hf : Function.Injective f) {a₁ : α} {a₂ : α} :

a₁ ≠ a₂ → f a₁ ≠ f a₂

theorem Function.Injective.ne_iff {α : Sort u_1} {β : Sort u_2} {f : α → β} (hf : Function.Injective f) {x : α} {y : α} :

f x ≠ f y ↔ x ≠ y

theorem Function.Injective.ne_iff' {α : Sort u_1} {β : Sort u_2} {f : α → β} (hf : Function.Injective f) {x : α} {y : α} {z : β} (h : f y = z) :

f x ≠ z ↔ x ≠ y

def Function.Injective.decidableEq {α : Sort u_1} {β : Sort u_2} {f : α → β} [DecidableEq β] (I : Function.Injective f) :

DecidableEq α

If the co-domain β of an injective function f : α → β has decidable equality, then the domain α also has decidable equality.

Instances For

theorem Function.Injective.of_comp {α : Sort u_3} {β : Sort u_2} {γ : Sort u_1} {f : α → β} {g : γ → α} (I : Function.Injective (f ∘ g)) :

Function.Injective g

@[simp]

theorem Function.Injective.of_comp_iff {α : Sort u_1} {β : Sort u_2} {γ : Sort u_3} {f : α → β} (hf : Function.Injective f) (g : γ → α) :

Function.Injective (f ∘ g) ↔ Function.Injective g

@[simp]

theorem Function.Injective.of_comp_iff' {α : Sort u_2} {β : Sort u_3} {γ : Sort u_1} (f : α → β) {g : γ → α} (hg : Function.Bijective g) :

Function.Injective (f ∘ g) ↔ Function.Injective f

theorem Function.Injective.comp_left {α : Sort u_3} {β : Sort u_1} {γ : Sort u_2} {g : β → γ} (hg : Function.Injective g) :

Function.Injective ((fun x x_1 => x ∘ x_1) g)

Composition by an injective function on the left is itself injective.

theorem Function.injective_of_subsingleton {α : Sort u_1} {β : Sort u_2} [Subsingleton α] (f : α → β) :

theorem Function.Injective.dite {α : Sort u_1} {β : Sort u_2} (p : α → Prop) [DecidablePred p] {f : { a // p a } → β} {f' : { a // ¬p a } → β} (hf : Function.Injective f) (hf' : Function.Injective f') (im_disj : ∀ {x x' : α} {hx : p x} {hx' : ¬p x'}, f { val := x, property := hx } ≠ f' { val := x', property := hx' }) :

Function.Injective fun x => if h : p x then f { val := x, property := h } else f' { val := x, property := h }

theorem Function.Surjective.of_comp {α : Sort u_3} {β : Sort u_2} {γ : Sort u_1} {f : α → β} {g : γ → α} (S : Function.Surjective (f ∘ g)) :

@[simp]

theorem Function.Surjective.of_comp_iff {α : Sort u_2} {β : Sort u_3} {γ : Sort u_1} (f : α → β) {g : γ → α} (hg : Function.Surjective g) :

Function.Surjective (f ∘ g) ↔ Function.Surjective f

@[simp]

theorem Function.Surjective.of_comp_iff' {α : Sort u_1} {β : Sort u_2} {γ : Sort u_3} {f : α → β} (hf : Function.Bijective f) (g : γ → α) :

Function.Surjective (f ∘ g) ↔ Function.Surjective g

instance Function.decidableEqPfun (p : Prop) [Decidable p] (α : p → Type u_1) [(hp : p) → DecidableEq (α hp)] :

DecidableEq ((hp : p) → α hp)

theorem Function.Surjective.forall {α : Sort u_1} {β : Sort u_2} {f : α → β} (hf : Function.Surjective f) {p : β → Prop} :

((y : β) → p y) ↔ (x : α) → p (f x)

theorem Function.Surjective.forall₂ {α : Sort u_1} {β : Sort u_2} {f : α → β} (hf : Function.Surjective f) {p : β → β → Prop} :

((y₁ y₂ : β) → p y₁ y₂) ↔ (x₁ x₂ : α) → p (f x₁) (f x₂)

theorem Function.Surjective.forall₃ {α : Sort u_1} {β : Sort u_2} {f : α → β} (hf : Function.Surjective f) {p : β → β → β → Prop} :

((y₁ y₂ y₃ : β) → p y₁ y₂ y₃) ↔ (x₁ x₂ x₃ : α) → p (f x₁) (f x₂) (f x₃)

theorem Function.Surjective.exists {α : Sort u_1} {β : Sort u_2} {f : α → β} (hf : Function.Surjective f) {p : β → Prop} :

(∃ y, p y) ↔ ∃ x, p (f x)

theorem Function.Surjective.exists₂ {α : Sort u_1} {β : Sort u_2} {f : α → β} (hf : Function.Surjective f) {p : β → β → Prop} :

(∃ y₁ y₂, p y₁ y₂) ↔ ∃ x₁ x₂, p (f x₁) (f x₂)

theorem Function.Surjective.exists₃ {α : Sort u_1} {β : Sort u_2} {f : α → β} (hf : Function.Surjective f) {p : β → β → β → Prop} :

(∃ y₁ y₂ y₃, p y₁ y₂ y₃) ↔ ∃ x₁ x₂ x₃, p (f x₁) (f x₂) (f x₃)

theorem Function.Surjective.injective_comp_right {α : Sort u_1} {β : Sort u_2} {γ : Sort u_3} {f : α → β} (hf : Function.Surjective f) :

Function.Injective fun g => g ∘ f

theorem Function.Surjective.right_cancellable {α : Sort u_1} {β : Sort u_2} {γ : Sort u_3} {f : α → β} (hf : Function.Surjective f) {g₁ : β → γ} {g₂ : β → γ} :

g₁ ∘ f = g₂ ∘ f ↔ g₁ = g₂

theorem Function.surjective_of_right_cancellable_Prop {α : Sort u_1} {β : Sort u_2} {f : α → β} (h : ∀ (g₁ g₂ : β → Prop), g₁ ∘ f = g₂ ∘ f → g₁ = g₂) :

theorem Function.bijective_iff_existsUnique {α : Sort u_1} {β : Sort u_2} (f : α → β) :

Function.Bijective f ↔ ∀ (b : β), ∃! a, f a = b

theorem Function.Bijective.existsUnique {α : Sort u_1} {β : Sort u_2} {f : α → β} (hf : Function.Bijective f) (b : β) :

∃! a, f a = b

Shorthand for using projection notation with Function.bijective_iff_existsUnique.

theorem Function.Bijective.existsUnique_iff {α : Sort u_1} {β : Sort u_2} {f : α → β} (hf : Function.Bijective f) {p : β → Prop} :

(∃! y, p y) ↔ ∃! x, p (f x)

theorem Function.Bijective.of_comp_iff {α : Sort u_2} {β : Sort u_3} {γ : Sort u_1} (f : α → β) {g : γ → α} (hg : Function.Bijective g) :

Function.Bijective (f ∘ g) ↔ Function.Bijective f

theorem Function.Bijective.of_comp_iff' {α : Sort u_1} {β : Sort u_2} {γ : Sort u_3} {f : α → β} (hf : Function.Bijective f) (g : γ → α) :

Function.Bijective (f ∘ g) ↔ Function.Bijective g

theorem Function.cantor_surjective {α : Type u_1} (f : α → Set α) :

¬Function.Surjective f

Cantor's diagonal argument implies that there are no surjective functions from α to Set α.

theorem Function.cantor_injective {α : Type u_1} (f : Set α → α) :

¬Function.Injective f

Cantor's diagonal argument implies that there are no injective functions from Set α to α.

theorem Function.not_surjective_Type {α : Type u} (f : α → Type (max u v)) :

¬Function.Surjective f

There is no surjection from α : Type u into Type (max u v). This theorem demonstrates why Type : Type would be inconsistent in Lean.

def Function.IsPartialInv {α : Type u_1} {β : Sort u_2} (f : α → β) (g : β → Option α) :

g is a partial inverse to f (an injective but not necessarily surjective function) if g y = some x implies f x = y, and g y = none implies that y is not in the range of f.

Instances For

theorem Function.isPartialInv_left {α : Type u_1} {β : Sort u_2} {f : α → β} {g : β → Option α} (H : Function.IsPartialInv f g) (x : α) :

g (f x) = some x

theorem Function.injective_of_isPartialInv {α : Type u_1} {β : Sort u_2} {f : α → β} {g : β → Option α} (H : Function.IsPartialInv f g) :

theorem Function.injective_of_isPartialInv_right {α : Type u_1} {β : Sort u_2} {f : α → β} {g : β → Option α} (H : Function.IsPartialInv f g) (x : β) (y : β) (b : α) (h₁ : b ∈ g x) (h₂ : b ∈ g y) :

x = y

theorem Function.LeftInverse.comp_eq_id {α : Sort u_2} {β : Sort u_1} {f : α → β} {g : β → α} (h : Function.LeftInverse f g) :

f ∘ g = id

theorem Function.leftInverse_iff_comp {α : Sort u_2} {β : Sort u_1} {f : α → β} {g : β → α} :

Function.LeftInverse f g ↔ f ∘ g = id

theorem Function.RightInverse.comp_eq_id {α : Sort u_2} {β : Sort u_1} {f : α → β} {g : β → α} (h : Function.RightInverse f g) :

g ∘ f = id

theorem Function.rightInverse_iff_comp {α : Sort u_2} {β : Sort u_1} {f : α → β} {g : β → α} :

Function.RightInverse f g ↔ g ∘ f = id

theorem Function.LeftInverse.comp {α : Sort u_2} {β : Sort u_1} {γ : Sort u_3} {f : α → β} {g : β → α} {h : β → γ} {i : γ → β} (hf : Function.LeftInverse f g) (hh : Function.LeftInverse h i) :

Function.LeftInverse (h ∘ f) (g ∘ i)

theorem Function.RightInverse.comp {α : Sort u_2} {β : Sort u_1} {γ : Sort u_3} {f : α → β} {g : β → α} {h : β → γ} {i : γ → β} (hf : Function.RightInverse f g) (hh : Function.RightInverse h i) :

Function.RightInverse (h ∘ f) (g ∘ i)

theorem Function.LeftInverse.rightInverse {α : Sort u_1} {β : Sort u_2} {f : α → β} {g : β → α} (h : Function.LeftInverse g f) :

Function.RightInverse f g

theorem Function.RightInverse.leftInverse {α : Sort u_1} {β : Sort u_2} {f : α → β} {g : β → α} (h : Function.RightInverse g f) :

Function.LeftInverse f g

theorem Function.LeftInverse.surjective {α : Sort u_2} {β : Sort u_1} {f : α → β} {g : β → α} (h : Function.LeftInverse f g) :

theorem Function.RightInverse.injective {α : Sort u_2} {β : Sort u_1} {f : α → β} {g : β → α} (h : Function.RightInverse f g) :

theorem Function.LeftInverse.rightInverse_of_injective {α : Sort u_2} {β : Sort u_1} {f : α → β} {g : β → α} (h : Function.LeftInverse f g) (hf : Function.Injective f) :

Function.RightInverse f g

theorem Function.LeftInverse.rightInverse_of_surjective {α : Sort u_2} {β : Sort u_1} {f : α → β} {g : β → α} (h : Function.LeftInverse f g) (hg : Function.Surjective g) :

Function.RightInverse f g

theorem Function.RightInverse.leftInverse_of_surjective {α : Sort u_2} {β : Sort u_1} {f : α → β} {g : β → α} :

Function.RightInverse f g → Function.Surjective f → Function.LeftInverse f g

theorem Function.RightInverse.leftInverse_of_injective {α : Sort u_2} {β : Sort u_1} {f : α → β} {g : β → α} :

Function.RightInverse f g → Function.Injective g → Function.LeftInverse f g

theorem Function.LeftInverse.eq_rightInverse {α : Sort u_1} {β : Sort u_2} {f : α → β} {g₁ : β → α} {g₂ : β → α} (h₁ : Function.LeftInverse g₁ f) (h₂ : Function.RightInverse g₂ f) :

g₁ = g₂

noncomputable def Function.partialInv {α : Type u_1} {β : Sort u_2} (f : α → β) (b : β) :

Option α

We can use choice to construct explicitly a partial inverse for a given injective function f.

Instances For

theorem Function.partialInv_of_injective {α : Type u_1} {β : Sort u_2} {f : α → β} (I : Function.Injective f) :

Function.IsPartialInv f (Function.partialInv f)

theorem Function.partialInv_left {α : Type u_1} {β : Sort u_2} {f : α → β} (I : Function.Injective f) (x : α) :

Function.partialInv f (f x) = some x

noncomputable def Function.invFun {α : Sort u} {β : Sort u_3} [Nonempty α] (f : α → β) :

β → α

The inverse of a function (which is a left inverse if f is injective and a right inverse if f is surjective).

Instances For

theorem Function.invFun_eq {α : Sort u_1} {β : Sort u_2} [Nonempty α] {f : α → β} {b : β} (h : ∃ a, f a = b) :

f (Function.invFun f b) = b

theorem Function.apply_invFun_apply {α : Type u₁} {β : Type u₂} {f : α → β} {a : α} :

f (Function.invFun f (f a)) = f a

theorem Function.invFun_neg {α : Sort u_1} {β : Sort u_2} [Nonempty α] {f : α → β} {b : β} (h : ¬∃ a, f a = b) :

Function.invFun f b = Classical.choice inst✝

theorem Function.invFun_eq_of_injective_of_rightInverse {α : Sort u_1} {β : Sort u_2} [Nonempty α] {f : α → β} {g : β → α} (hf : Function.Injective f) (hg : Function.RightInverse g f) :

Function.invFun f = g

theorem Function.rightInverse_invFun {α : Sort u_1} {β : Sort u_2} [Nonempty α] {f : α → β} (hf : Function.Surjective f) :

Function.RightInverse (Function.invFun f) f

theorem Function.leftInverse_invFun {α : Sort u_1} {β : Sort u_2} [Nonempty α] {f : α → β} (hf : Function.Injective f) :

Function.LeftInverse (Function.invFun f) f

theorem Function.invFun_surjective {α : Sort u_1} {β : Sort u_2} [Nonempty α] {f : α → β} (hf : Function.Injective f) :

Function.Surjective (Function.invFun f)

theorem Function.invFun_comp {α : Sort u_1} {β : Sort u_2} [Nonempty α] {f : α → β} (hf : Function.Injective f) :

Function.invFun f ∘ f = id

Function.HasLeftInverse f

theorem Function.Injective.hasLeftInverse {α : Sort u_1} {β : Sort u_2} [Nonempty α] {f : α → β} (hf : Function.Injective f) :

theorem Function.injective_iff_hasLeftInverse {α : Sort u_1} {β : Sort u_2} [Nonempty α] {f : α → β} :

Function.Injective f ↔ Function.HasLeftInverse f

noncomputable def Function.surjInv {α : Sort u} {β : Sort v} {f : α → β} (h : Function.Surjective f) (b : β) :

The inverse of a surjective function. (Unlike invFun, this does not require α to be inhabited.)

Instances For

theorem Function.surjInv_eq {α : Sort u} {β : Sort v} {f : α → β} (h : Function.Surjective f) (b : β) :

f (Function.surjInv h b) = b

theorem Function.rightInverse_surjInv {α : Sort u} {β : Sort v} {f : α → β} (hf : Function.Surjective f) :

Function.RightInverse (Function.surjInv hf) f

theorem Function.leftInverse_surjInv {α : Sort u} {β : Sort v} {f : α → β} (hf : Function.Bijective f) :

Function.LeftInverse (Function.surjInv (_ : Function.Surjective f)) f

Function.HasRightInverse f

theorem Function.Surjective.hasRightInverse {α : Sort u} {β : Sort v} {f : α → β} (hf : Function.Surjective f) :

theorem Function.surjective_iff_hasRightInverse {α : Sort u} {β : Sort v} {f : α → β} :

Function.Surjective f ↔ Function.HasRightInverse f

theorem Function.bijective_iff_has_inverse {α : Sort u} {β : Sort v} {f : α → β} :

Function.Bijective f ↔ ∃ g, Function.LeftInverse g f ∧ Function.RightInverse g f

theorem Function.injective_surjInv {α : Sort u} {β : Sort v} {f : α → β} (h : Function.Surjective f) :

Function.Injective (Function.surjInv h)

theorem Function.surjective_to_subsingleton {α : Sort u} {β : Sort v} [na : Nonempty α] [Subsingleton β] (f : α → β) :

theorem Function.Surjective.comp_left {α : Sort u} {β : Sort v} {γ : Sort w} {g : β → γ} (hg : Function.Surjective g) :

Function.Surjective ((fun x x_1 => x ∘ x_1) g)

Composition by a surjective function on the left is itself surjective.

theorem Function.Bijective.comp_left {α : Sort u} {β : Sort v} {γ : Sort w} {g : β → γ} (hg : Function.Bijective g) :

Function.Bijective ((fun x x_1 => x ∘ x_1) g)

Composition by a bijective function on the left is itself bijective.

def Function.update {α : Sort u} {β : α → Sort v} [DecidableEq α] (f : (a : α) → β a) (a' : α) (v : β a') (a : α) :

β a

Replacing the value of a function at a given point by a given value.

Instances For

@[simp]

theorem Function.update_same {α : Sort u} {β : α → Sort v} [DecidableEq α] (a : α) (v : β a) (f : (a : α) → β a) :

Function.update f a v a = v

@[simp]

theorem Function.update_noteq {α : Sort u} {β : α → Sort v} [DecidableEq α] {a : α} {a' : α} (h : a ≠ a') (v : β a') (f : (a : α) → β a) :

Function.update f a' v a = f a

theorem Function.update_apply {α : Sort u} [DecidableEq α] {β : Sort u_1} (f : α → β) (a' : α) (b : β) (a : α) :

Function.update f a' b a = if a = a' then b else f a

On non-dependent functions, Function.update can be expressed as an ite

theorem Function.update_eq_const_of_subsingleton {α : Sort u} {α' : Sort w} [DecidableEq α] [Subsingleton α] (a : α) (v : α') (f : α → α') :

Function.update f a v = Function.const α v

theorem Function.surjective_eval {α : Sort u} {β : α → Sort v} [h : ∀ (a : α), Nonempty (β a)] (a : α) :

Function.Surjective (Function.eval a)

theorem Function.update_injective {α : Sort u} {β : α → Sort v} [DecidableEq α] (f : (a : α) → β a) (a' : α) :

Function.Injective (Function.update f a')

theorem Function.forall_update_iff {α : Sort u} {β : α → Sort v} [DecidableEq α] (f : (a : α) → β a) {a : α} {b : β a} (p : (a : α) → β a → Prop) :

((x : α) → p x (Function.update f a b x)) ↔ p a b ∧ ((x : α) → x ≠ a → p x (f x))

theorem Function.exists_update_iff {α : Sort u} {β : α → Sort v} [DecidableEq α] (f : (a : α) → β a) {a : α} {b : β a} (p : (a : α) → β a → Prop) :

(∃ x, p x (Function.update f a b x)) ↔ p a b ∨ ∃ x x_1, p x (f x)

theorem Function.update_eq_iff {α : Sort u} {β : α → Sort v} [DecidableEq α] {a : α} {b : β a} {f : (a : α) → β a} {g : (a : α) → β a} :

Function.update f a b = g ↔ b = g a ∧ ∀ (x : α), x ≠ a → f x = g x

theorem Function.eq_update_iff {α : Sort u} {β : α → Sort v} [DecidableEq α] {a : α} {b : β a} {f : (a : α) → β a} {g : (a : α) → β a} :

g = Function.update f a b ↔ g a = b ∧ ∀ (x : α), x ≠ a → g x = f x

@[simp]

theorem Function.update_eq_self_iff {α : Sort u} {β : α → Sort v} [DecidableEq α] {f : (a : α) → β a} {a : α} {b : β a} :

Function.update f a b = f ↔ b = f a

@[simp]

theorem Function.eq_update_self_iff {α : Sort u} {β : α → Sort v} [DecidableEq α] {f : (a : α) → β a} {a : α} {b : β a} :

f = Function.update f a b ↔ f a = b

theorem Function.ne_update_self_iff {α : Sort u} {β : α → Sort v} [DecidableEq α] {f : (a : α) → β a} {a : α} {b : β a} :

f ≠ Function.update f a b ↔ f a ≠ b

theorem Function.update_ne_self_iff {α : Sort u} {β : α → Sort v} [DecidableEq α] {f : (a : α) → β a} {a : α} {b : β a} :

Function.update f a b ≠ f ↔ b ≠ f a

@[simp]

theorem Function.update_eq_self {α : Sort u} {β : α → Sort v} [DecidableEq α] (a : α) (f : (a : α) → β a) :

Function.update f a (f a) = f

theorem Function.update_comp_eq_of_forall_ne' {α : Sort u} {β : α → Sort v} [DecidableEq α] {α' : Sort u_1} (g : (a : α) → β a) {f : α' → α} {i : α} (a : β i) (h : ∀ (x : α'), f x ≠ i) :

(fun j => Function.update g i a (f j)) = fun j => g (f j)

theorem Function.update_comp_eq_of_forall_ne {α' : Sort w} [DecidableEq α'] {α : Sort u_1} {β : Sort u_2} (g : α' → β) {f : α → α'} {i : α'} (a : β) (h : ∀ (x : α), f x ≠ i) :

Function.update g i a ∘ f = g ∘ f

Non-dependent version of Function.update_comp_eq_of_forall_ne'

theorem Function.update_comp_eq_of_injective' {α : Sort u} {β : α → Sort v} {α' : Sort w} [DecidableEq α] [DecidableEq α'] (g : (a : α) → β a) {f : α' → α} (hf : Function.Injective f) (i : α') (a : β (f i)) :

(fun j => Function.update g (f i) a (f j)) = Function.update (fun i => g (f i)) i a

theorem Function.update_comp_eq_of_injective {α : Sort u} {α' : Sort w} [DecidableEq α] [DecidableEq α'] {β : Sort u_1} (g : α' → β) {f : α → α'} (hf : Function.Injective f) (i : α) (a : β) :

Function.update g (f i) a ∘ f = Function.update (g ∘ f) i a

Non-dependent version of Function.update_comp_eq_of_injective'

theorem Function.apply_update {ι : Sort u_1} [DecidableEq ι] {α : ι → Sort u_2} {β : ι → Sort u_3} (f : (i : ι) → α i → β i) (g : (i : ι) → α i) (i : ι) (v : α i) (j : ι) :

f j (Function.update g i v j) = Function.update (fun k => f k (g k)) i (f i v) j

theorem Function.apply_update₂ {ι : Sort u_1} [DecidableEq ι] {α : ι → Sort u_2} {β : ι → Sort u_3} {γ : ι → Sort u_4} (f : (i : ι) → α i → β i → γ i) (g : (i : ι) → α i) (h : (i : ι) → β i) (i : ι) (v : α i) (w : β i) (j : ι) :

f j (Function.update g i v j) (Function.update h i w j) = Function.update (fun k => f k (g k) (h k)) i (f i v w) j

theorem Function.comp_update {α : Sort u} [DecidableEq α] {α' : Sort u_1} {β : Sort u_2} (f : α' → β) (g : α → α') (i : α) (v : α') :

f ∘ Function.update g i v = Function.update (f ∘ g) i (f v)

theorem Function.update_comm {α : Sort u_2} [DecidableEq α] {β : α → Sort u_1} {a : α} {b : α} (h : a ≠ b) (v : β a) (w : β b) (f : (a : α) → β a) :

Function.update (Function.update f a v) b w = Function.update (Function.update f b w) a v

@[simp]

theorem Function.update_idem {α : Sort u_2} [DecidableEq α] {β : α → Sort u_1} {a : α} (v : β a) (w : β a) (f : (a : α) → β a) :

Function.update (Function.update f a v) a w = Function.update f a w

def Function.extend {α : Sort u} {β : Sort u_4} {γ : Sort u_5} (f : α → β) (g : α → γ) (e' : β → γ) :

β → γ

extend f g e' extends a function g : α → γ along a function f : α → β to a function β → γ, by using the values of g on the range of f and the values of an auxiliary function e' : β → γ elsewhere.

Mostly useful when f is injective, or more generally when g.factors_through f

Instances For

def Function.FactorsThrough {α : Sort u_1} {β : Sort u_2} {γ : Sort u_3} (g : α → γ) (f : α → β) :

g factors through f : f a = f b → g a = g b

Instances For

theorem Function.extend_def {α : Sort u_1} {β : Sort u_2} {γ : Sort u_3} (f : α → β) (g : α → γ) (e' : β → γ) (b : β) [Decidable (∃ a, f a = b)] :

Function.extend f g e' b = if h : ∃ a, f a = b then g (Classical.choose h) else e' b

theorem Function.Injective.FactorsThrough {α : Sort u_1} {β : Sort u_2} {γ : Sort u_3} {f : α → β} (hf : Function.Injective f) (g : α → γ) :

Function.FactorsThrough g f

theorem Function.FactorsThrough.extend_apply {α : Sort u_1} {β : Sort u_2} {γ : Sort u_3} {f : α → β} {g : α → γ} (hf : Function.FactorsThrough g f) (e' : β → γ) (a : α) :

Function.extend f g e' (f a) = g a

@[simp]

theorem Function.Injective.extend_apply {α : Sort u_1} {β : Sort u_2} {γ : Sort u_3} {f : α → β} (hf : Function.Injective f) (g : α → γ) (e' : β → γ) (a : α) :

Function.extend f g e' (f a) = g a

@[simp]

theorem Function.extend_apply' {α : Sort u_1} {β : Sort u_2} {γ : Sort u_3} {f : α → β} (g : α → γ) (e' : β → γ) (b : β) (hb : ¬∃ a, f a = b) :

Function.extend f g e' b = e' b

theorem Function.factorsThrough_iff {α : Sort u_1} {β : Sort u_2} {γ : Sort u_3} {f : α → β} (g : α → γ) [Nonempty γ] :

Function.FactorsThrough g f ↔ ∃ e, g = e ∘ f

theorem Function.FactorsThrough.apply_extend {α : Sort u_1} {β : Sort u_2} {γ : Sort u_3} {f : α → β} {δ : Sort u_4} {g : α → γ} (hf : Function.FactorsThrough g f) (F : γ → δ) (e' : β → γ) (b : β) :

F (Function.extend f g e' b) = Function.extend f (F ∘ g) (F ∘ e') b

theorem Function.Injective.apply_extend {α : Sort u_1} {β : Sort u_2} {γ : Sort u_3} {f : α → β} {δ : Sort u_4} (hf : Function.Injective f) (F : γ → δ) (g : α → γ) (e' : β → γ) (b : β) :

F (Function.extend f g e' b) = Function.extend f (F ∘ g) (F ∘ e') b

theorem Function.extend_injective {α : Sort u_1} {β : Sort u_2} {γ : Sort u_3} {f : α → β} (hf : Function.Injective f) (e' : β → γ) :

Function.Injective fun g => Function.extend f g e'

theorem Function.FactorsThrough.extend_comp {α : Sort u_1} {β : Sort u_2} {γ : Sort u_3} {f : α → β} {g : α → γ} (e' : β → γ) (hf : Function.FactorsThrough g f) :

Function.extend f g e' ∘ f = g

@[simp]

theorem Function.extend_comp {α : Sort u_1} {β : Sort u_2} {γ : Sort u_3} {f : α → β} (hf : Function.Injective f) (g : α → γ) (e' : β → γ) :

Function.extend f g e' ∘ f = g

theorem Function.Injective.surjective_comp_right' {α : Sort u_1} {β : Sort u_2} {γ : Sort u_3} {f : α → β} (hf : Function.Injective f) (g₀ : β → γ) :

Function.Surjective fun g => g ∘ f

theorem Function.Injective.surjective_comp_right {α : Sort u_1} {β : Sort u_2} {γ : Sort u_3} {f : α → β} [Nonempty γ] (hf : Function.Injective f) :

Function.Surjective fun g => g ∘ f

theorem Function.Bijective.comp_right {α : Sort u_1} {β : Sort u_2} {γ : Sort u_3} {f : α → β} (hf : Function.Bijective f) :

Function.Bijective fun g => g ∘ f

theorem Function.uncurry_def {α : Type u_1} {β : Type u_2} {γ : Type u_3} (f : α → β → γ) :

Function.uncurry f = fun p => f p.fst p.snd

@[simp]

theorem Function.uncurry_apply_pair {α : Type u_1} {β : Type u_2} {γ : Type u_3} (f : α → β → γ) (x : α) (y : β) :

Function.uncurry f (x, y) = f x y

@[simp]

theorem Function.curry_apply {α : Type u_1} {β : Type u_2} {γ : Type u_3} (f : α × β → γ) (x : α) (y : β) :

Function.curry f x y = f (x, y)

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.

Instances For

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.

Instances For

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

Function.uncurry (Function.bicompr g f) = g ∘ Function.uncurry f

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

Function.uncurry (Function.bicompl f g h) = Function.uncurry f ∘ Prod.map g h

class Function.HasUncurry (α : Type u_5) (β : outParam (Type u_6)) (γ : outParam (Type u_7)) :

Type (max (max u_5 u_6) u_7)

uncurry : α → β → γ
Uncurrying operator. The most generic use is to recursively uncurry. For instance f : α → β → γ → δ will be turned into ↿f : α × β × γ → δ. One can also add instances for bundled maps.

Records a way to turn an element of α into a function from β to γ. The most generic use is to recursively uncurry. For instance f : α → β → γ → δ will be turned into ↿f : α × β × γ → δ. One can also add instances for bundled maps.

Instances

def Function.«term↿_» :

Lean.ParserDescr

Instances For

instance Function.hasUncurryBase {α : Type u_1} {β : Type u_2} :

Function.HasUncurry (α → β) α β

instance Function.hasUncurryInduction {α : Type u_1} {β : Type u_2} {γ : Type u_3} {δ : Type u_4} [Function.HasUncurry β γ δ] :

Function.HasUncurry (α → β) (α × γ) δ

def Function.Involutive {α : Sort u_1} (f : α → α) :

A function is involutive, if f ∘ f = id.

Instances For

theorem Bool.involutive_not :

Function.Involutive not

@[simp]

theorem Function.Involutive.comp_self {α : Sort u} {f : α → α} (h : Function.Involutive f) :

f ∘ f = id

theorem Function.Involutive.leftInverse {α : Sort u} {f : α → α} (h : Function.Involutive f) :

Function.LeftInverse f f

theorem Function.Involutive.rightInverse {α : Sort u} {f : α → α} (h : Function.Involutive f) :

Function.RightInverse f f

theorem Function.Involutive.injective {α : Sort u} {f : α → α} (h : Function.Involutive f) :

theorem Function.Involutive.surjective {α : Sort u} {f : α → α} (h : Function.Involutive f) :

theorem Function.Involutive.bijective {α : Sort u} {f : α → α} (h : Function.Involutive f) :

Function.Bijective f

theorem Function.Involutive.ite_not {α : Sort u} {f : α → α} (h : Function.Involutive f) (P : Prop) [Decidable P] (x : α) :

f (if P then x else f x) = if ¬P then x else f x

Involuting an ite of an involuted value x : α negates the Prop condition in the ite.

theorem Function.Involutive.eq_iff {α : Sort u} {f : α → α} (h : Function.Involutive f) {x : α} {y : α} :

f x = y ↔ x = f y

An involution commutes across an equality. Compare to Function.Injective.eq_iff.

def Function.Injective2 {α : Sort u_1} {β : Sort u_2} {γ : Sort u_3} (f : α → β → γ) :

The property of a binary function f : α → β → γ being injective. Mathematically this should be thought of as the corresponding function α × β → γ being injective.

Instances For

theorem Function.Injective2.left {α : Sort u_1} {β : Sort u_2} {γ : Sort u_3} {f : α → β → γ} (hf : Function.Injective2 f) (b : β) :

Function.Injective fun a => f a b

A binary injective function is injective when only the left argument varies.

theorem Function.Injective2.right {α : Sort u_1} {β : Sort u_2} {γ : Sort u_3} {f : α → β → γ} (hf : Function.Injective2 f) (a : α) :

Function.Injective (f a)

A binary injective function is injective when only the right argument varies.

theorem Function.Injective2.uncurry {α : Type u_4} {β : Type u_5} {γ : Type u_6} {f : α → β → γ} (hf : Function.Injective2 f) :

Function.Injective (Function.uncurry f)

theorem Function.Injective2.left' {α : Sort u_1} {β : Sort u_2} {γ : Sort u_3} {f : α → β → γ} (hf : Function.Injective2 f) [Nonempty β] :

As a map from the left argument to a unary function, f is injective.

theorem Function.Injective2.right' {α : Sort u_1} {β : Sort u_2} {γ : Sort u_3} {f : α → β → γ} (hf : Function.Injective2 f) [Nonempty α] :

Function.Injective fun b a => f a b

As a map from the right argument to a unary function, f is injective.

theorem Function.Injective2.eq_iff {α : Sort u_1} {β : Sort u_2} {γ : Sort u_3} {f : α → β → γ} (hf : Function.Injective2 f) {a₁ : α} {a₂ : α} {b₁ : β} {b₂ : β} :

f a₁ b₁ = f a₂ b₂ ↔ a₁ = a₂ ∧ b₁ = b₂

noncomputable def Function.sometimes {α : Sort u_1} {β : Sort u_2} [Nonempty β] (f : α → β) :

sometimes f evaluates to some value of f, if it exists. This function is especially interesting in the case where α is a proposition, in which case f is necessarily a constant function, so that sometimes f = f a for all a.

Instances For

theorem Function.sometimes_eq {p : Prop} {α : Sort u_1} [Nonempty α] (f : p → α) (a : p) :

Function.sometimes f = f a

theorem Function.sometimes_spec {p : Prop} {α : Sort u_1} [Nonempty α] (P : α → Prop) (f : p → α) (a : p) (h : P (f a)) :

P (Function.sometimes f)

def Set.piecewise {α : Type u} {β : α → Sort v} (s : Set α) (f : (i : α) → β i) (g : (i : α) → β i) [(j : α) → Decidable (j ∈ s)] (i : α) :

β i

s.piecewise f g is the function equal to f on the set s, and to g on its complement.

Instances For

Bijectivity of `Eq.rec`, `Eq.mp`, `Eq.mpr`, and `cast` #

theorem eq_rec_on_bijective {α : Sort u_1} {C : α → Sort u_2} {a : α} {a' : α} (h : a = a') :

Function.Bijective fun x => h ▸ x

theorem eq_mp_bijective {α : Sort u_1} {β : Sort u_1} (h : α = β) :

Function.Bijective (Eq.mp h)

theorem eq_mpr_bijective {α : Sort u_1} {β : Sort u_1} (h : α = β) :

Function.Bijective (Eq.mpr h)

theorem cast_bijective {α : Sort u_1} {β : Sort u_1} (h : α = β) :

Function.Bijective (cast h)

Note these lemmas apply to Type* not Sort*, as the latter interferes with simp, and is trivial anyway.

@[simp]

theorem eq_rec_inj {α : Sort u_1} {a : α} {a' : α} (h : a = a') {C : α → Type u_2} (x : C a) (y : C a) :

h ▸ x = h ▸ y ↔ x = y

@[simp]

theorem cast_inj {α : Type u_1} {β : Type u_1} (h : α = β) {x : α} {y : α} :

cast h x = cast h y ↔ x = y

theorem Function.LeftInverse.eq_rec_eq {α : Sort u_1} {β : Sort u_2} {γ : β → Sort v} {f : α → β} {g : β → α} (h : Function.LeftInverse g f) (C : (a : α) → γ (f a)) (a : α) :

(_ : f (g (f a)) = f a) ▸ C (g (f a)) = C a

theorem Function.LeftInverse.eq_rec_on_eq {α : Sort u_1} {β : Sort u_2} {γ : β → Sort v} {f : α → β} {g : β → α} (h : Function.LeftInverse g f) (C : (a : α) → γ (f a)) (a : α) :

Eq.recOn (_ : f (g (f a)) = f a) (C (g (f a))) = C a

theorem Function.LeftInverse.cast_eq {α : Sort u_1} {β : Sort u_2} {γ : β → Sort v} {f : α → β} {g : β → α} (h : Function.LeftInverse g f) (C : (a : α) → γ (f a)) (a : α) :

cast (_ : γ (f (g (f a))) = γ (f a)) (C (g (f a))) = C a

def Set.SeparatesPoints {α : Type u_1} {β : Type u_2} (A : Set (α → β)) :

A set of functions "separates points" if for each pair of distinct points there is a function taking different values on them.

Instances For

theorem IsSymmOp.flip_eq {α : Type u_1} {β : Type u_2} (op : α → α → β) [IsSymmOp α β op] :

flip op = op

theorem InvImage.equivalence {α : Sort u} {β : Sort v} (r : β → β → Prop) (f : α → β) (h : Equivalence r) :

Equivalence (InvImage r f)

instance instDecidableUncurryProp {α : Type u_1} {β : Type u_2} {r : α → β → Prop} {x : α × β} [Decidable (r x.fst x.snd)] :

Decidable (Function.uncurry r x)