File: Mathlib/Order/Interval/Finset/Fin.lean

full_name: Fin.coe_sup
code: @[simp, norm_cast]
theorem coe_sup : ↑(a ⊔ b) = (a ⊔ b : ℕ) 
goal: ↑(a ⊔ b) = ↑a ⊔ ↑b

full_name: Fin.coe_inf
code: @[simp, norm_cast]
theorem coe_inf : ↑(a ⊓ b) = (a ⊓ b : ℕ) 
goal: ↑(a ⊓ b) = ↑a ⊓ ↑b

full_name: Fin.coe_max
code: @[simp, norm_cast]
theorem coe_max : ↑(max a b) = (max a b : ℕ) 
goal: ↑(max a b) = max ↑a ↑b

full_name: Fin.coe_min
code: @[simp, norm_cast]
theorem coe_min : ↑(min a b) = (min a b : ℕ) 
goal: ↑(min a b) = min ↑a ↑b

full_name: Fin.instLocallyFiniteOrder
code: instance instLocallyFiniteOrder : LocallyFiniteOrder (Fin n) 
goal: LocallyFiniteOrder (Fin n)

full_name: Fin.instLocallyFiniteOrderBot
code: instance instLocallyFiniteOrderBot : LocallyFiniteOrderBot (Fin n) 
goal: LocallyFiniteOrderBot (Fin n)

full_name: Fin.instLocallyFiniteOrderTop
code: instance instLocallyFiniteOrderTop : ∀ n, LocallyFiniteOrderTop (Fin n)
  
goal: LocallyFiniteOrderTop (Fin n)

full_name: Fin.Icc_eq_finset_subtype
code: theorem Icc_eq_finset_subtype : Icc a b = (Icc (a : ℕ) b).fin n 
goal: Finset.Icc a b = Finset.fin n (Finset.Icc ↑a ↑b)

full_name: Fin.Ico_eq_finset_subtype
code: theorem Ico_eq_finset_subtype : Ico a b = (Ico (a : ℕ) b).fin n 
goal: Finset.Ico a b = Finset.fin n (Finset.Ico ↑a ↑b)

full_name: Fin.Ioc_eq_finset_subtype
code: theorem Ioc_eq_finset_subtype : Ioc a b = (Ioc (a : ℕ) b).fin n 
goal: Finset.Ioc a b = Finset.fin n (Finset.Ioc ↑a ↑b)

full_name: Fin.Ioo_eq_finset_subtype
code: theorem Ioo_eq_finset_subtype : Ioo a b = (Ioo (a : ℕ) b).fin n 
goal: Finset.Ioo a b = Finset.fin n (Finset.Ioo ↑a ↑b)

full_name: Fin.uIcc_eq_finset_subtype
code: theorem uIcc_eq_finset_subtype : uIcc a b = (uIcc (a : ℕ) b).fin n 
goal: Finset.uIcc a b = Finset.fin n (Finset.uIcc ↑a ↑b)

full_name: Fin.map_valEmbedding_Icc
code: @[simp]
theorem map_valEmbedding_Icc : (Icc a b).map Fin.valEmbedding = Icc ↑a ↑b 
goal: Finset.map Fin.valEmbedding (Finset.Icc a b) = Finset.Icc ↑a ↑b

full_name: Fin.map_valEmbedding_Ico
code: @[simp]
theorem map_valEmbedding_Ico : (Ico a b).map Fin.valEmbedding = Ico ↑a ↑b 
goal: Finset.map Fin.valEmbedding (Finset.Ico a b) = Finset.Ico ↑a ↑b

full_name: Fin.map_valEmbedding_Ioc
code: @[simp]
theorem map_valEmbedding_Ioc : (Ioc a b).map Fin.valEmbedding = Ioc ↑a ↑b 
goal: Finset.map Fin.valEmbedding (Finset.Ioc a b) = Finset.Ioc ↑a ↑b

full_name: Fin.map_valEmbedding_Ioo
code: @[simp]
theorem map_valEmbedding_Ioo : (Ioo a b).map Fin.valEmbedding = Ioo ↑a ↑b 
goal: Finset.map Fin.valEmbedding (Finset.Ioo a b) = Finset.Ioo ↑a ↑b

full_name: Fin.map_subtype_embedding_uIcc
code: @[simp]
theorem map_subtype_embedding_uIcc : (uIcc a b).map valEmbedding = uIcc ↑a ↑b 
goal: Finset.map Fin.valEmbedding (Finset.uIcc a b) = Finset.uIcc ↑a ↑b

full_name: Fin.card_Icc
code: @[simp]
theorem card_Icc : (Icc a b).card = b + 1 - a 
goal: (Finset.Icc a b).card = ↑b + 1 - ↑a

full_name: Fin.card_Ico
code: @[simp]
theorem card_Ico : (Ico a b).card = b - a 
goal: (Finset.Ico a b).card = ↑b - ↑a

full_name: Fin.card_Ioc
code: @[simp]
theorem card_Ioc : (Ioc a b).card = b - a 
goal: (Finset.Ioc a b).card = ↑b - ↑a

full_name: Fin.card_Ioo
code: @[simp]
theorem card_Ioo : (Ioo a b).card = b - a - 1 
goal: (Finset.Ioo a b).card = ↑b - ↑a - 1

full_name: Fin.card_uIcc
code: @[simp]
theorem card_uIcc : (uIcc a b).card = (b - a : ℤ).natAbs + 1 
goal: (Finset.uIcc a b).card = (↑↑b - ↑↑a).natAbs + 1

full_name: Fin.card_fintypeIcc
code: theorem card_fintypeIcc : Fintype.card (Set.Icc a b) = b + 1 - a 
goal: Fintype.card ↑(Set.Icc a b) = ↑b + 1 - ↑a

full_name: Fin.card_fintypeIco
code: theorem card_fintypeIco : Fintype.card (Set.Ico a b) = b - a 
goal: Fintype.card ↑(Set.Ico a b) = ↑b - ↑a

full_name: Fin.card_fintypeIoc
code: theorem card_fintypeIoc : Fintype.card (Set.Ioc a b) = b - a 
goal: Fintype.card ↑(Set.Ioc a b) = ↑b - ↑a

full_name: Fin.card_fintypeIoo
code: theorem card_fintypeIoo : Fintype.card (Set.Ioo a b) = b - a - 1 
goal: Fintype.card ↑(Set.Ioo a b) = ↑b - ↑a - 1

full_name: Fin.card_fintype_uIcc
code: theorem card_fintype_uIcc : Fintype.card (Set.uIcc a b) = (b - a : ℤ).natAbs + 1 
goal: Fintype.card ↑(Set.uIcc a b) = (↑↑b - ↑↑a).natAbs + 1

full_name: Fin.Ici_eq_finset_subtype
code: theorem Ici_eq_finset_subtype : Ici a = (Icc (a : ℕ) n).fin n 
goal: Finset.Ici a = Finset.fin n (Finset.Icc (↑a) n)

full_name: Fin.Ioi_eq_finset_subtype
code: theorem Ioi_eq_finset_subtype : Ioi a = (Ioc (a : ℕ) n).fin n 
goal: Finset.Ioi a = Finset.fin n (Finset.Ioc (↑a) n)

full_name: Fin.Iic_eq_finset_subtype
code: theorem Iic_eq_finset_subtype : Iic b = (Iic (b : ℕ)).fin n 
goal: Finset.Iic b = Finset.fin n (Finset.Iic ↑b)

full_name: Fin.Iio_eq_finset_subtype
code: theorem Iio_eq_finset_subtype : Iio b = (Iio (b : ℕ)).fin n 
goal: Finset.Iio b = Finset.fin n (Finset.Iio ↑b)

full_name: Fin.map_valEmbedding_Ici
code: @[simp]
theorem map_valEmbedding_Ici : (Ici a).map Fin.valEmbedding = Icc ↑a (n - 1) 
goal: Finset.map Fin.valEmbedding (Finset.Ici a) = Finset.Icc (↑a) (n - 1)

full_name: Fin.map_valEmbedding_Ioi
code: @[simp]
theorem map_valEmbedding_Ioi : (Ioi a).map Fin.valEmbedding = Ioc ↑a (n - 1) 
goal: Finset.map Fin.valEmbedding (Finset.Ioi a) = Finset.Ioc (↑a) (n - 1)

full_name: Fin.map_valEmbedding_Iic
code: @[simp]
theorem map_valEmbedding_Iic : (Iic b).map Fin.valEmbedding = Iic ↑b 
goal: Finset.map Fin.valEmbedding (Finset.Iic b) = Finset.Iic ↑b

full_name: Fin.map_valEmbedding_Iio
code: @[simp]
theorem map_valEmbedding_Iio : (Iio b).map Fin.valEmbedding = Iio ↑b 
goal: Finset.map Fin.valEmbedding (Finset.Iio b) = Finset.Iio ↑b

full_name: Fin.card_Ici
code: @[simp]
theorem card_Ici : (Ici a).card = n - a 
goal: (Finset.Ici a).card = n - ↑a

full_name: Fin.card_Ioi
code: @[simp]
theorem card_Ioi : (Ioi a).card = n - 1 - a 
goal: (Finset.Ioi a).card = n - 1 - ↑a

full_name: Fin.card_Iic
code: @[simp]
theorem card_Iic : (Iic b).card = b + 1 
goal: (Finset.Iic b).card = ↑b + 1

full_name: Fin.card_Iio
code: @[simp]
theorem card_Iio : (Iio b).card = b 
goal: (Finset.Iio b).card = ↑b

full_name: Fin.card_fintypeIci
code: theorem card_fintypeIci : Fintype.card (Set.Ici a) = n - a 
goal: Fintype.card ↑(Set.Ici a) = n - ↑a

full_name: Fin.card_fintypeIoi
code: theorem card_fintypeIoi : Fintype.card (Set.Ioi a) = n - 1 - a 
goal: Fintype.card ↑(Set.Ioi a) = n - 1 - ↑a

full_name: Fin.card_fintypeIic
code: theorem card_fintypeIic : Fintype.card (Set.Iic b) = b + 1 
goal: Fintype.card ↑(Set.Iic b) = ↑b + 1

full_name: Fin.card_fintypeIio
code: theorem card_fintypeIio : Fintype.card (Set.Iio b) = b 
goal: Fintype.card ↑(Set.Iio b) = ↑b