data.equiv.fin

# Equivalences for fin n#

def fin_zero_equiv  :

Equivalence between fin 0 and empty.

Equations
def fin_zero_equiv'  :

Equivalence between fin 0 and pempty.

Equations

Equivalence between fin 1 and unit.

Equations

Equivalence between fin 2 and bool.

Equations
@[simp]
theorem pi_fin_two_equiv_symm_apply (α : fin 2Type u) :
((pi_fin_two_equiv α).symm) = λ (p : α 0 × α 1),
def pi_fin_two_equiv (α : fin 2Type u) :
(Π (i : fin 2), α i) α 0 × α 1

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

Equations
@[simp]
theorem pi_fin_two_equiv_apply (α : fin 2Type u) :
= λ (f : Π (i : fin 2), α i), (f 0, f 1)
theorem fin.preimage_apply_01_prod {α : fin 2Type u} (s : set (α 0)) (t : set (α 1)) :
(λ (f : Π (i : fin 2), α i), (f 0, f 1)) ⁻¹' (s ×ˢ t) = set.univ.pi (fin.cons s (fin.cons t fin.elim0))
theorem fin.preimage_apply_01_prod' {α : Type u} (s t : set α) :
(λ (f : fin 2 → α), (f 0, f 1)) ⁻¹' (s ×ˢ t) = set.univ.pi ![s, t]
def prod_equiv_pi_fin_two (α β : Type u) :
α × β Π (i : fin 2), ![α, β] i

A product space α × β is equivalent to the space Π i : fin 2, γ i, where γ = fin.cons α (fin.cons β fin_zero_elim). See also pi_fin_two_equiv and fin_two_arrow_equiv.

Equations
@[simp]
theorem prod_equiv_pi_fin_two_apply (α β : Type u) :
= λ (p : 0 × 1),
@[simp]
theorem prod_equiv_pi_fin_two_symm_apply (α β : Type u) :
β).symm) = λ (f : Π (i : fin 2), i), (f 0, f 1)
@[simp]
theorem fin_two_arrow_equiv_apply (α : Type u_1) :
= (pi_fin_two_equiv (λ (_x : fin 2), α)).to_fun
def fin_two_arrow_equiv (α : Type u_1) :
(fin 2 → α) α × α

The space of functions fin 2 → α is equivalent to α × α. See also pi_fin_two_equiv and prod_equiv_pi_fin_two.

Equations
@[simp]
theorem fin_two_arrow_equiv_symm_apply (α : Type u_1) :
.symm) = λ (x : α × α), ![x.fst, x.snd]
def order_iso.pi_fin_two_iso (α : fin 2Type u) [Π (i : fin 2), preorder (α i)] :
(Π (i : fin 2), α i) ≃o α 0 × α 1

Π i : fin 2, α i is order equivalent to α 0 × α 1. See also order_iso.fin_two_arrow_equiv for a non-dependent version.

Equations
def order_iso.fin_two_arrow_iso (α : Type u_1) [preorder α] :
(fin 2 → α) ≃o α × α

The space of functions fin 2 → α is order equivalent to α × α. See also order_iso.pi_fin_two_iso.

Equations
def fin_congr {n m : } (h : n = m) :
fin n fin m

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

Equations
@[simp]
theorem fin_congr_apply_mk {n m : } (h : n = m) (k : ) (w : k < n) :
(fin_congr h) k, w⟩ = k, _⟩
@[simp]
theorem fin_congr_symm {n m : } (h : n = m) :
@[simp]
theorem fin_congr_apply_coe {n m : } (h : n = m) (k : fin n) :
theorem fin_congr_symm_apply_coe {n m : } (h : n = m) (k : fin m) :
def fin_succ_equiv' {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.pred_above that produces option (fin n) instead of mapping both i.cast_succ and i.succ to i.

Equations
@[simp]
theorem fin_succ_equiv'_at {n : } (i : fin (n + 1)) :
@[simp]
theorem fin_succ_equiv'_succ_above {n : } (i : fin (n + 1)) (j : fin n) :
theorem fin_succ_equiv'_below {n : } {i : fin (n + 1)} {m : fin n} (h : < i) :
theorem fin_succ_equiv'_above {n : } {i : fin (n + 1)} {m : fin n} (h : i ) :
@[simp]
theorem fin_succ_equiv'_symm_none {n : } (i : fin (n + 1)) :
@[simp]
theorem fin_succ_equiv'_symm_some {n : } (i : fin (n + 1)) (j : fin n) :
theorem fin_succ_equiv'_symm_some_below {n : } {i : fin (n + 1)} {m : fin n} (h : < i) :
theorem fin_succ_equiv'_symm_some_above {n : } {i : fin (n + 1)} {m : fin n} (h : i ) :
theorem fin_succ_equiv'_symm_coe_below {n : } {i : fin (n + 1)} {m : fin n} (h : < i) :
theorem fin_succ_equiv'_symm_coe_above {n : } {i : fin (n + 1)} {m : fin n} (h : i ) :
def fin_succ_equiv (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
@[simp]
theorem fin_succ_equiv_zero {n : } :
@[simp]
theorem fin_succ_equiv_succ {n : } (m : fin n) :
@[simp]
@[simp]
theorem fin_succ_equiv_symm_some {n : } (m : fin n) :
@[simp]
theorem fin_succ_equiv_symm_coe {n : } (m : fin n) :
theorem fin_succ_equiv'_zero {n : } :

The equiv version of fin.pred_above_zero.

def fin_succ_equiv_last {n : } :
fin (n + 1) option (fin n)

equiv between fin (n + 1) and option (fin n) sending fin.last n to none

Equations
@[simp]
theorem fin_succ_equiv_last_cast_succ {n : } (i : fin n) :
@[simp]
theorem fin_succ_equiv_last_last {n : } :
@[simp]
theorem fin_succ_equiv_last_symm_some {n : } (i : fin n) :
@[simp]
theorem fin_succ_equiv_last_symm_coe {n : } (i : fin n) :
@[simp]
def fin_sum_fin_equiv {m n : } :
fin m fin n fin (m + n)

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

Equations
@[simp]
theorem fin_sum_fin_equiv_apply_left {m n : } (i : fin m) :
@[simp]
theorem fin_sum_fin_equiv_apply_right {m n : } (i : fin n) :
def fin_add_flip {m n : } :
fin (m + n) fin (n + m)

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

Equations
@[simp]
theorem fin_add_flip_apply_cast_add {m : } (k : fin m) (n : ) :
@[simp]
theorem fin_add_flip_apply_nat_add {n : } (k : fin n) (m : ) :
@[simp]
theorem fin_add_flip_apply_mk_left {m n k : } (h : k < m) (hk : k < m + n := _) (hnk : n + k < n + m := _) :
fin_add_flip k, hk⟩ = n + k, hnk⟩
@[simp]
theorem fin_add_flip_apply_mk_right {m n k : } (h₁ : m k) (h₂ : k < m + n) :
fin_add_flip k, h₂⟩ = k - m, _⟩
def fin_rotate (n : ) :

Rotate fin n one step to the right.

Equations
theorem fin_rotate_of_lt {n k : } (h : k < n) :
(fin_rotate (n + 1)) k, _⟩ = k + 1, _⟩
theorem fin_rotate_last' {n : } :
(fin_rotate (n + 1)) n, _⟩ = 0, _⟩
theorem fin_rotate_last {n : } :
(fin_rotate (n + 1)) (fin.last n) = 0
theorem fin.snoc_eq_cons_rotate {n : } {α : Type u_1} (v : fin n → α) (a : α) :
a = λ (i : fin (n + 1)), v ((fin_rotate (n + 1)) i)
@[simp]
theorem fin_rotate_zero  :
@[simp]
theorem fin_rotate_one  :
@[simp]
theorem fin_rotate_succ_apply {n : } (i : fin n.succ) :
(fin_rotate n.succ) i = i + 1
@[simp]
theorem fin_rotate_apply_zero {n : } :
theorem coe_fin_rotate_of_ne_last {n : } {i : fin n.succ} (h : i ) :
theorem coe_fin_rotate {n : } (i : fin n.succ) :
((fin_rotate n.succ) i) = ite (i = fin.last n) 0 (i + 1)
@[simp]
theorem fin_prod_fin_equiv_apply_coe {m n : } (x : fin m × fin n) :
= (x.snd) + n * (x.fst)
@[simp]
theorem fin_prod_fin_equiv_symm_apply {m n : } (x : fin (m * n)) :
= (x.div_nat, x.mod_nat)
def fin_prod_fin_equiv {m n : } :
fin m × fin n fin (m * n)

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

Equations
@[simp]
theorem fin.cast_le_order_iso_apply {n m : } (h : n m) (i : fin n) :
= (fin.cast_le h) i, _⟩
def fin.cast_le_order_iso {n m : } (h : n m) :
fin n ≃o {i // i < n}

Promote a fin n into a larger fin m, as a subtype where the underlying values are retained. This is the order_iso version of fin.cast_le.

Equations
@[simp]
theorem fin.cast_le_order_iso_symm_apply {n m : } (h : n m) (i : {i // i < n}) :
= i, _⟩
@[protected, instance]

fin 0 is a subsingleton.

@[protected, instance]

fin 1 is a subsingleton.