Equivalences for `Fin n` #

Π i : Fin 2, α i is equivalent to α 0 × α 1. See also finTwoArrowEquiv for a non-dependent version and prodEquivPiFinTwo for a version with inputs α β : Type u.

Equations

One or more equations did not get rendered due to their size.

source

ink

theorem Fin.preimage_apply_01_prod {α : Fin 2 → Type u} (s : Set (α 0)) (t : Set (α 1)) :

(fun f => (f 0, f 1)) ⁻¹' s ×ˢ t = Set.pi Set.univ (Fin.cons s (Fin.cons t finZeroElim))

source

ink

theorem Fin.preimage_apply_01_prod' {α : Type u} (s : Set α) (t : Set α) :

(fun f => (f 0, f 1)) ⁻¹' s ×ˢ t = Set.pi Set.univ (Matrix.vecCons s (Matrix.vecCons t Matrix.vecEmpty))

source

ink

@[simp]

theorem prodEquivPiFinTwo_symm_apply (α : Type u) (β : Type u) :

↑(Equiv.symm (prodEquivPiFinTwo α β)) = fun f => (f 0, f 1)

source

ink

@[simp]

theorem prodEquivPiFinTwo_apply (α : Type u) (β : Type u) :

↑(prodEquivPiFinTwo α β) = fun p => Fin.cons p.fst (Fin.cons p.snd finZeroElim)

source

ink

def prodEquivPiFinTwo (α : Type u) (β : Type u) :

α × β ≃ ((i : Fin 2) → Matrix.vecCons α (Matrix.vecCons β Matrix.vecEmpty) i)

A product space α × β is equivalent to the space Π i : Fin 2, γ i, where γ = Fin.cons α (Fin.cons β finZeroElim). See also piFinTwoEquiv and finTwoArrowEquiv.

Equations

prodEquivPiFinTwo α β = Equiv.symm (piFinTwoEquiv (Fin.cons α (Fin.cons β finZeroElim)))

source

ink

@[simp]

theorem finTwoArrowEquiv_symm_apply (α : Type u_1) :

↑(Equiv.symm (finTwoArrowEquiv α)) = fun x => Matrix.vecCons x.fst (Matrix.vecCons x.snd Matrix.vecEmpty)

source

ink

@[simp]

theorem finTwoArrowEquiv_apply (α : Type u_1) :

↑(finTwoArrowEquiv α) = (piFinTwoEquiv fun x => α).toFun

source

ink

def finTwoArrowEquiv (α : Type u_1) :

(Fin 2 → α) ≃ α × α

The space of functions Fin 2 → α is equivalent to α × α. See also piFinTwoEquiv and prodEquivPiFinTwo.

Equations

One or more equations did not get rendered due to their size.

source

ink

def OrderIso.piFinTwoIso (α : Fin 2 → Type u) [inst : (i : Fin 2) → Preorder (α i)] :

((i : Fin 2) → α i) ≃o α 0 × α 1

Π i : Fin 2, α i is order equivalent to α 0 × α 1. See also OrderIso.finTwoArrowEquiv for a non-dependent version.

Equations

OrderIso.piFinTwoIso α = { toEquiv := piFinTwoEquiv α, map_rel_iff' := (_ : ∀ {a b : (i : Fin 2) → α i}, ↑(piFinTwoEquiv α) a ≤ ↑(piFinTwoEquiv α) b ↔ a ≤ b) }

source

ink

def OrderIso.finTwoArrowIso (α : Type u_1) [inst : Preorder α] :

(Fin 2 → α) ≃o α × α

The space of functions Fin 2 → α is order equivalent to α × α. See also OrderIso.piFinTwoIso.

Equations

One or more equations did not get rendered due to their size.

source

ink

def finCongr {m : ℕ} {n : ℕ} (h : m = n) :

Fin m ≃ Fin n

The 'identity' equivalence between Fin n and Fin m when n = m.

Equations

finCongr h = (Fin.cast h).toEquiv

source

ink

@[simp]

theorem finCongr_apply_mk {m : ℕ} {n : ℕ} (h : m = n) (k : ℕ) (w : k < m) :

↑(finCongr h) { val := k, isLt := w } = { val := k, isLt := (_ : k < n) }

source

ink

@[simp]

theorem finCongr_symm {m : ℕ} {n : ℕ} (h : m = n) :

Equiv.symm (finCongr h) = finCongr (_ : n = m)

source

ink

@[simp]

theorem finCongr_apply_coe {m : ℕ} {n : ℕ} (h : m = n) (k : Fin m) :

↑(↑(finCongr h) k) = ↑k

source

ink

theorem finCongr_symm_apply_coe {m : ℕ} {n : ℕ} (h : m = n) (k : Fin n) :

↑(↑(Equiv.symm (finCongr h)) k) = ↑k

source

ink

def finSuccEquiv' {n : ℕ} (i : Fin (n + 1)) :

Fin (n + 1) ≃ Option (Fin n)

An equivalence that removes i and maps it to none. This is a version of Fin.predAbove that produces Option (Fin n) instead of mapping both i.cast_succ and i.succ to i.

Equations

One or more equations did not get rendered due to their size.

source

ink

@[simp]

theorem finSuccEquiv'_at {n : ℕ} (i : Fin (n + 1)) :

↑(finSuccEquiv' i) i = none

source

ink

@[simp]

theorem finSuccEquiv'_succAbove {n : ℕ} (i : Fin (n + 1)) (j : Fin n) :

↑(finSuccEquiv' i) (↑(Fin.succAbove i).toEmbedding j) = some j

source

ink

theorem finSuccEquiv'_below {n : ℕ} {i : Fin (n + 1)} {m : Fin n} (h : ↑Fin.castSucc.toEmbedding m < i) :

↑(finSuccEquiv' i) (↑Fin.castSucc.toEmbedding m) = some m

source

ink

theorem finSuccEquiv'_above {n : ℕ} {i : Fin (n + 1)} {m : Fin n} (h : i ≤ ↑Fin.castSucc.toEmbedding m) :

↑(finSuccEquiv' i) (Fin.succ m) = some m

source

ink

@[simp]

theorem finSuccEquiv'_symm_none {n : ℕ} (i : Fin (n + 1)) :

↑(Equiv.symm (finSuccEquiv' i)) none = i

source

ink

@[simp]

theorem finSuccEquiv'_symm_some {n : ℕ} (i : Fin (n + 1)) (j : Fin n) :

↑(Equiv.symm (finSuccEquiv' i)) (some j) = ↑(Fin.succAbove i).toEmbedding j

source

ink

theorem finSuccEquiv'_symm_some_below {n : ℕ} {i : Fin (n + 1)} {m : Fin n} (h : ↑Fin.castSucc.toEmbedding m < i) :

↑(Equiv.symm (finSuccEquiv' i)) (some m) = ↑Fin.castSucc.toEmbedding m

source

ink

theorem finSuccEquiv'_symm_some_above {n : ℕ} {i : Fin (n + 1)} {m : Fin n} (h : i ≤ ↑Fin.castSucc.toEmbedding m) :

↑(Equiv.symm (finSuccEquiv' i)) (some m) = Fin.succ m

source

ink

theorem finSuccEquiv'_symm_coe_below {n : ℕ} {i : Fin (n + 1)} {m : Fin n} (h : ↑Fin.castSucc.toEmbedding m < i) :

↑(Equiv.symm (finSuccEquiv' i)) (some m) = ↑Fin.castSucc.toEmbedding m

source

ink

theorem finSuccEquiv'_symm_coe_above {n : ℕ} {i : Fin (n + 1)} {m : Fin n} (h : i ≤ ↑Fin.castSucc.toEmbedding m) :

↑(Equiv.symm (finSuccEquiv' i)) (some m) = Fin.succ m

source

ink

def finSuccEquiv (n : ℕ) :

Fin (n + 1) ≃ Option (Fin n)

Equivalence between Fin (n + 1) and Option (Fin n). This is a version of Fin.pred that produces Option (Fin n) instead of requiring a proof that the input is not 0.

Equations

finSuccEquiv n = finSuccEquiv' 0

source

ink

@[simp]

theorem finSuccEquiv_zero {n : ℕ} :

↑(finSuccEquiv n) 0 = none

source

ink

@[simp]

theorem finSuccEquiv_succ {n : ℕ} (m : Fin n) :

↑(finSuccEquiv n) (Fin.succ m) = some m

source

ink

@[simp]

theorem finSuccEquiv_symm_none {n : ℕ} :

↑(Equiv.symm (finSuccEquiv n)) none = 0

source

ink

@[simp]

theorem finSuccEquiv_symm_some {n : ℕ} (m : Fin n) :

↑(Equiv.symm (finSuccEquiv n)) (some m) = Fin.succ m

source

ink

theorem finSuccEquiv'_zero {n : ℕ} :

finSuccEquiv' 0 = finSuccEquiv n

The equiv version of Fin.predAbove_zero.

source

ink

theorem finSuccEquiv'_last_apply_castSucc {n : ℕ} (i : Fin n) :

↑(finSuccEquiv' (Fin.last n)) (↑Fin.castSucc.toEmbedding i) = some i

source

ink

theorem finSuccEquiv'_last_apply {n : ℕ} {i : Fin (n + 1)} (h : i ≠ Fin.last n) :

↑(finSuccEquiv' (Fin.last n)) i = some (Fin.castLt i (_ : ↑i < n))

source

ink

theorem finSuccEquiv'_ne_last_apply {n : ℕ} {i : Fin (n + 1)} {j : Fin (n + 1)} (hi : i ≠ Fin.last n) (hj : j ≠ i) :

↑(finSuccEquiv' i) j = some (Fin.predAbove (Fin.castLt i (_ : ↑i < n)) j)

source

ink

def finSuccAboveEquiv {n : ℕ} (p : Fin (n + 1)) :

Fin n ≃o { x // x ≠ p }

Fin.succAbove as an order isomorphism between Fin n and {x : Fin (n + 1) // x ≠ p}.

Equations

One or more equations did not get rendered due to their size.

source

ink

theorem finSuccAboveEquiv_apply {n : ℕ} (p : Fin (n + 1)) (i : Fin n) :

↑(RelIso.toRelEmbedding (finSuccAboveEquiv p)).toEmbedding i = { val := ↑(Fin.succAbove p).toEmbedding i, property := (_ : ↑(Fin.succAbove p).toEmbedding i ≠ p) }

source

ink

theorem finSuccAboveEquiv_symm_apply_last {n : ℕ} (x : { x // x ≠ Fin.last n }) :

↑(RelIso.toRelEmbedding (OrderIso.symm (finSuccAboveEquiv (Fin.last n)))).toEmbedding x = Fin.castLt ↑x (_ : ↑↑x < n)

source

ink

theorem finSuccAboveEquiv_symm_apply_ne_last {n : ℕ} {p : Fin (n + 1)} (h : p ≠ Fin.last n) (x : { x // x ≠ p }) :

↑(RelIso.toRelEmbedding (OrderIso.symm (finSuccAboveEquiv p))).toEmbedding x = Fin.predAbove (Fin.castLt p (_ : ↑p < n)) ↑x

source

ink

def finSuccEquivLast {n : ℕ} :

Fin (n + 1) ≃ Option (Fin n)

Equiv between Fin (n + 1) and Option (Fin n) sending Fin.last n to none

Equations

finSuccEquivLast = finSuccEquiv' (Fin.last n)

source

ink

@[simp]

theorem finSuccEquivLast_castSucc {n : ℕ} (i : Fin n) :

↑finSuccEquivLast (↑Fin.castSucc.toEmbedding i) = some i

source

ink

@[simp]

theorem finSuccEquivLast_last {n : ℕ} :

↑finSuccEquivLast (Fin.last n) = none

source

ink

@[simp]

theorem finSuccEquivLast_symm_some {n : ℕ} (i : Fin n) :

↑(Equiv.symm finSuccEquivLast) (some i) = ↑Fin.castSucc.toEmbedding i

source

ink

@[simp]

theorem finSuccEquivLast_symm_none {n : ℕ} :

↑(Equiv.symm finSuccEquivLast) none = Fin.last n

source

ink

@[simp]

theorem Equiv.piFinSuccAboveEquiv_symm_apply {n : ℕ} (α : Fin (n + 1) → Type u) (i : Fin (n + 1)) :

↑(Equiv.symm (Equiv.piFinSuccAboveEquiv α i)) = fun f => Fin.insertNth i f.fst f.snd

source

ink

@[simp]

theorem Equiv.piFinSuccAboveEquiv_apply {n : ℕ} (α : Fin (n + 1) → Type u) (i : Fin (n + 1)) :

↑(Equiv.piFinSuccAboveEquiv α i) = fun f => (f i, fun j => f (↑(Fin.succAbove i).toEmbedding j))

source

ink

def Equiv.piFinSuccAboveEquiv {n : ℕ} (α : Fin (n + 1) → Type u) (i : Fin (n + 1)) :

((j : Fin (n + 1)) → α j) ≃ α i × ((j : Fin n) → α (↑(Fin.succAbove i).toEmbedding j))

Equivalence between Π j : Fin (n + 1), α j and α i × Π j : Fin n, α (Fin.succAbove i j).

Equations

One or more equations did not get rendered due to their size.

source

ink

def OrderIso.piFinSuccAboveIso {n : ℕ} (α : Fin (n + 1) → Type u) [inst : (i : Fin (n + 1)) → LE (α i)] (i : Fin (n + 1)) :

((j : Fin (n + 1)) → α j) ≃o α i × ((j : Fin n) → α (↑(Fin.succAbove i).toEmbedding j))

Order isomorphism between Π j : Fin (n + 1), α j and α i × Π j : Fin n, α (Fin.succAbove i j).

Equations

One or more equations did not get rendered due to their size.

source

ink

@[simp]

theorem Equiv.piFinSucc_symm_apply (n : ℕ) (β : Type u) :

↑(Equiv.symm (Equiv.piFinSucc n β)) = fun f => Fin.cons f.fst f.snd

source

ink

@[simp]

theorem Equiv.piFinSucc_apply (n : ℕ) (β : Type u) :

↑(Equiv.piFinSucc n β) = fun f => (f 0, fun j => f (Fin.succ j))

source

ink

def Equiv.piFinSucc (n : ℕ) (β : Type u) :

(Fin (n + 1) → β) ≃ β × (Fin n → β)

Equivalence between Fin (n + 1) → β and β × (Fin n → β).

Equations

Equiv.piFinSucc n β = Equiv.piFinSuccAboveEquiv (fun x => β) 0

source

ink

def finSumFinEquiv {m : ℕ} {n : ℕ} :

Fin m ⊕ Fin n ≃ Fin (m + n)

Equivalence between Fin m ⊕ Fin n and Fin (m + n)

Equations

One or more equations did not get rendered due to their size.

source

ink

@[simp]

theorem finSumFinEquiv_apply_left {m : ℕ} {n : ℕ} (i : Fin m) :

↑finSumFinEquiv (Sum.inl i) = ↑(Fin.castAdd n).toEmbedding i

source

ink

@[simp]

theorem finSumFinEquiv_apply_right {m : ℕ} {n : ℕ} (i : Fin n) :

↑finSumFinEquiv (Sum.inr i) = ↑(Fin.natAdd m).toEmbedding i

source

ink

@[simp]

theorem finSumFinEquiv_symm_apply_castAdd {m : ℕ} {n : ℕ} (x : Fin m) :

↑(Equiv.symm finSumFinEquiv) (↑(Fin.castAdd n).toEmbedding x) = Sum.inl x

source

ink

@[simp]

theorem finSumFinEquiv_symm_apply_natAdd {m : ℕ} {n : ℕ} (x : Fin n) :

↑(Equiv.symm finSumFinEquiv) (↑(Fin.natAdd m).toEmbedding x) = Sum.inr x

source

ink

@[simp]

theorem finSumFinEquiv_symm_last {n : ℕ} :

↑(Equiv.symm finSumFinEquiv) (Fin.last n) = Sum.inr 0

source

ink

def finAddFlip {m : ℕ} {n : ℕ} :

Fin (m + n) ≃ Fin (n + m)

The equivalence between Fin (m + n) and Fin (n + m) which rotates by n.

Equations

finAddFlip = Equiv.trans (Equiv.trans (Equiv.symm finSumFinEquiv) (Equiv.sumComm (Fin m) (Fin n))) finSumFinEquiv

source

ink

@[simp]

theorem finAddFlip_apply_castAdd {m : ℕ} (k : Fin m) (n : ℕ) :

↑finAddFlip (↑(Fin.castAdd n).toEmbedding k) = ↑(Fin.natAdd n).toEmbedding k

source

ink

@[simp]

theorem finAddFlip_apply_natAdd {n : ℕ} (k : Fin n) (m : ℕ) :

↑finAddFlip (↑(Fin.natAdd m).toEmbedding k) = ↑(Fin.castAdd m).toEmbedding k

source

ink

@[simp]

theorem finAddFlip_apply_mk_left {m : ℕ} {n : ℕ} {k : ℕ} (h : k < m) (hk : optParam (k < m + n) (_ : k < m + n)) (hnk : optParam (n + k < n + m) (_ : n + k < n + m)) :

↑finAddFlip { val := k, isLt := hk } = { val := n + k, isLt := hnk }

source

ink

@[simp]

theorem finAddFlip_apply_mk_right {m : ℕ} {n : ℕ} {k : ℕ} (h₁ : m ≤ k) (h₂ : k < m + n) :

↑finAddFlip { val := k, isLt := h₂ } = { val := k - m, isLt := (_ : k - m < n + m) }

source

ink

def finRotate (n : ℕ) :

Equiv.Perm (Fin n)

Rotate Fin n one step to the right.

Equations

finRotate x = match x with | 0 => Equiv.refl (Fin 0) | Nat.succ n => Equiv.trans finAddFlip (finCongr (_ : 1 + n = n + 1))

source

ink

@[simp]

theorem finRotate_zero :

finRotate 0 = Equiv.refl (Fin 0)

source

ink

theorem finRotate_succ (n : ℕ) :

finRotate (n + 1) = Equiv.trans finAddFlip (finCongr (_ : 1 + n = n + 1))

source

ink

theorem finRotate_of_lt {n : ℕ} {k : ℕ} (h : k < n) :

↑(finRotate (n + 1)) { val := k, isLt := (_ : k < n + 1) } = { val := k + 1, isLt := (_ : Nat.succ k < Nat.succ n) }

source

ink

theorem finRotate_last' {n : ℕ} :

↑(finRotate (n + 1)) { val := n, isLt := (_ : n < n + 1) } = { val := 0, isLt := (_ : 0 < Nat.succ n) }

source

ink

theorem finRotate_last {n : ℕ} :

↑(finRotate (n + 1)) (Fin.last n) = 0

source

ink

theorem Fin.snoc_eq_cons_rotate {n : ℕ} {α : Type u_1} (v : Fin n → α) (a : α) :

Fin.snoc v a = fun i => Fin.cons a v (↑(finRotate (n + 1)) i)

source

ink

@[simp]

theorem finRotate_one :

finRotate 1 = Equiv.refl (Fin 1)

source

ink

@[simp]

theorem finRotate_succ_apply {n : ℕ} (i : Fin (n + 1)) :

↑(finRotate (n + 1)) i = i + 1

source

ink

theorem finRotate_apply_zero {n : ℕ} :

↑(finRotate (Nat.succ n)) 0 = 1

source

ink

theorem coe_finRotate_of_ne_last {n : ℕ} {i : Fin (Nat.succ n)} (h : i ≠ Fin.last n) :

↑(↑(finRotate (n + 1)) i) = ↑i + 1

source

ink

theorem coe_finRotate {n : ℕ} (i : Fin (Nat.succ n)) :

↑(↑(finRotate (Nat.succ n)) i) = if i = Fin.last n then 0 else ↑i + 1

source

ink

@[simp]

theorem finProdFinEquiv_apply_val {m : ℕ} {n : ℕ} (x : Fin m × Fin n) :

↑(↑finProdFinEquiv x) = ↑x.snd + n * ↑x.fst

source

ink

@[simp]

theorem finProdFinEquiv_symm_apply {m : ℕ} {n : ℕ} (x : Fin (m * n)) :

↑(Equiv.symm finProdFinEquiv) x = (Fin.divNat x, Fin.modNat x)

source

ink

def finProdFinEquiv {m : ℕ} {n : ℕ} :

Fin m × Fin n ≃ Fin (m * n)

Equivalence between Fin m × Fin n and Fin (m * n)

Equations

One or more equations did not get rendered due to their size.

source

ink

@[simp]

theorem Nat.divModEquiv_symm_apply (n : ℕ) [inst : NeZero n] (p : ℕ × Fin n) :

↑(Equiv.symm (Nat.divModEquiv n)) p = p.fst * n + ↑p.snd

source

ink

@[simp]

theorem Nat.divModEquiv_apply (n : ℕ) [inst : NeZero n] (a : ℕ) :

↑(Nat.divModEquiv n) a = (a / n, ↑a)

source

ink

def Nat.divModEquiv (n : ℕ) [inst : NeZero n] :

ℕ ≃ ℕ × Fin n

The equivalence induced by a ↦ (a / n, a % n) for nonzero n. This is like finProdFinEquiv.symm but with m infinite. See Nat.div_mod_unique for a similar propositional statement.

Equations