Module docstring
{"# Finsets in Fin n
A few constructions for Finsets in Fin n.
Main declarations
Finset.attachFin: Turns a Finset of naturals strictly less thanninto aFinset (Fin n). "}
{"# Finsets in Fin n
A few constructions for Finsets in Fin n.
Finset.attachFin: Turns a Finset of naturals strictly less than n into a Finset (Fin n).
"}Finset.attachFin
      definition
     (s : Finset ℕ) {n : ℕ} (h : ∀ m ∈ s, m < n) : Finset (Fin n)
        /-- Given a Finset `s` of `ℕ` contained in `{0,..., n-1}`, the corresponding Finset in `Fin n`
is `s.attachFin h` where `h` is a proof that all elements of `s` are less than `n`. -/
def attachFin (s : Finset ℕ) {n : ℕ} (h : ∀ m ∈ s, m < n) : Finset (Fin n) :=
  ⟨s.1.pmap (fun a ha ↦ ⟨a, ha⟩) h, s.nodup.pmap fun _ _ _ _ ↦ Fin.val_eq_of_eq⟩
        Finset.mem_attachFin
      theorem
     {s : Finset ℕ} (h : ∀ m ∈ s, m < n) {a : Fin n} : a ∈ s.attachFin h ↔ (a : ℕ) ∈ s
        @[simp]
theorem mem_attachFin {s : Finset ℕ} (h : ∀ m ∈ s, m < n) {a : Fin n} :
    a ∈ s.attachFin ha ∈ s.attachFin h ↔ (a : ℕ) ∈ s :=
  ⟨fun h ↦
    let ⟨_, hb₁, hb₂⟩ := Multiset.mem_pmap.1 h
    hb₂ ▸ hb₁,
    fun h ↦ Multiset.mem_pmap.2 ⟨a, h, Fin.eta _ _⟩⟩
        Finset.coe_attachFin
      theorem
     {s : Finset ℕ} (h : ∀ m ∈ s, m < n) : (attachFin s h : Set (Fin n)) = Fin.val ⁻¹' s
        @[simp]
lemma coe_attachFin {s : Finset ℕ} (h : ∀ m ∈ s, m < n) :
    (attachFin s h : Set (Fin n)) = Fin.valFin.val ⁻¹' s := by
  ext; simp
        Finset.card_attachFin
      theorem
     (s : Finset ℕ) (h : ∀ m ∈ s, m < n) : (s.attachFin h).card = s.card
        @[simp]
theorem card_attachFin (s : Finset ℕ) (h : ∀ m ∈ s, m < n) :
    (s.attachFin h).card = s.card :=
  Multiset.card_pmap _ _ _
        Finset.image_val_attachFin
      theorem
     {s : Finset ℕ} (h : ∀ m ∈ s, m < n) : image Fin.val (s.attachFin h) = s
        @[simp]
lemma image_val_attachFin {s : Finset ℕ} (h : ∀ m ∈ s, m < n) :
    image Fin.val (s.attachFin h) = s := by
  apply coe_injective
  rw [coe_image, coe_attachFin, Set.image_preimage_eq_iff]
  exact fun m hm ↦ ⟨⟨m, h m hm⟩, rfl⟩
        Finset.map_valEmbedding_attachFin
      theorem
     {s : Finset ℕ} (h : ∀ m ∈ s, m < n) : map Fin.valEmbedding (s.attachFin h) = s
        @[simp]
lemma map_valEmbedding_attachFin {s : Finset ℕ} (h : ∀ m ∈ s, m < n) :
    map Fin.valEmbedding (s.attachFin h) = s := by
  simp [map_eq_image]
        Finset.attachFin_subset_attachFin_iff
      theorem
     {s t : Finset ℕ} (hs : ∀ m ∈ s, m < n) (ht : ∀ m ∈ t, m < n) : s.attachFin hs ⊆ t.attachFin ht ↔ s ⊆ t
        @[simp]
lemma attachFin_subset_attachFin_iff {s t : Finset ℕ} (hs : ∀ m ∈ s, m < n) (ht : ∀ m ∈ t, m < n) :
    s.attachFin hs ⊆ t.attachFin hts.attachFin hs ⊆ t.attachFin ht ↔ s ⊆ t := by
  simp [← map_subset_map (f := Fin.valEmbedding)]
        Finset.attachFin_subset_attachFin
      theorem
     {s t : Finset ℕ} (hst : s ⊆ t) (ht : ∀ m ∈ t, m < n) : s.attachFin (fun m hm ↦ ht m (hst hm)) ⊆ t.attachFin ht
        @[mono, gcongr]
lemma attachFin_subset_attachFin {s t : Finset ℕ} (hst : s ⊆ t) (ht : ∀ m ∈ t, m < n) :
    s.attachFin (fun m hm ↦ ht m (hst hm)) ⊆ t.attachFin ht := by simpa
        Finset.attachFin_ssubset_attachFin_iff
      theorem
     {s t : Finset ℕ} (hs : ∀ m ∈ s, m < n) (ht : ∀ m ∈ t, m < n) : s.attachFin hs ⊂ t.attachFin ht ↔ s ⊂ t
        @[simp]
lemma attachFin_ssubset_attachFin_iff {s t : Finset ℕ} (hs : ∀ m ∈ s, m < n) (ht : ∀ m ∈ t, m < n) :
    s.attachFin hs ⊂ t.attachFin hts.attachFin hs ⊂ t.attachFin ht ↔ s ⊂ t := by
  simp [← map_ssubset_map (f := Fin.valEmbedding)]
        Finset.attachFin_ssubset_attachFin
      theorem
     {s t : Finset ℕ} (hst : s ⊂ t) (ht : ∀ m ∈ t, m < n) : s.attachFin (fun m hm ↦ ht m (hst.subset hm)) ⊂ t.attachFin ht
        @[mono, gcongr]
lemma attachFin_ssubset_attachFin {s t : Finset ℕ} (hst : s ⊂ t) (ht : ∀ m ∈ t, m < n) :
    s.attachFin (fun m hm ↦ ht m (hst.subset hm)) ⊂ t.attachFin ht := by simpa
        Finset.fin
      definition
     (n : ℕ) (s : Finset ℕ) : Finset (Fin n)
        /-- Given a finset `s` of natural numbers and a bound `n`,
`s.fin n` is the finset of all elements of `s` less than `n`.
This definition was introduced to define a `LocallyFiniteOrder` instance on `Fin n`.
Later, this instance was rewritten using a more efficient `attachFin`.
Since this definition had no other uses in the library, it was deprecated.
-/
@[deprecated attachFin (since := "2025-04-08")]
protected def fin (n : ℕ) (s : Finset ℕ) : Finset (Fin n) :=
  (s.subtype _).map Fin.equivSubtype.symm.toEmbedding
        Finset.mem_fin
      theorem
     {s : Finset ℕ} : ∀ a : Fin n, a ∈ s.fin n ↔ (a : ℕ) ∈ s
        @[simp, deprecated mem_attachFin (since := "2025-04-08")]
theorem mem_fin {s : Finset ℕ} : ∀ a : Fin n, a ∈ s.fin na ∈ s.fin n ↔ (a : ℕ) ∈ s
  | ⟨a, ha⟩ => by simp [Finset.fin, ha, and_comm]
        Finset.coe_fin
      theorem
     (n : ℕ) (s : Finset ℕ) : (s.fin n : Set (Fin n)) = Fin.val ⁻¹' s
        @[simp, deprecated coe_attachFin (since := "2025-04-08")]
theorem coe_fin (n : ℕ) (s : Finset ℕ) : (s.fin n : Set (Fin n)) = Fin.valFin.val ⁻¹' s := by ext; simp
        Finset.fin_mono
      theorem
     : Monotone (Finset.fin n)
        @[mono, deprecated attachFin_subset_attachFin (since := "2025-04-08")]
theorem fin_mono : Monotone (Finset.fin n) := fun s t h x => by simpa using @h x
        Finset.fin_subset_fin
      theorem
     (n : ℕ) {s t : Finset ℕ} (h : s ⊆ t) : s.fin n ⊆ t.fin n
        @[gcongr, deprecated attachFin_subset_attachFin (since := "2025-04-08")]
theorem fin_subset_fin (n : ℕ) {s t : Finset ℕ} (h : s ⊆ t) : s.fin n ⊆ t.fin n := fin_mono h
        Finset.fin_map
      theorem
     {s : Finset ℕ} : (s.fin n).map Fin.valEmbedding = s.filter (· < n)
        @[simp, deprecated map_valEmbedding_attachFin (since := "2025-04-08")]
theorem fin_map {s : Finset ℕ} : (s.fin n).map Fin.valEmbedding = s.filter (· < n) := by
  simp [Finset.fin, Finset.map_map]
        Finset.attachFin_eq_fin
      theorem
     {s : Finset ℕ} (h : ∀ m ∈ s, m < n) : attachFin s h = s.fin n
        @[deprecated "No replacement" (since := "2025-04-08")]
theorem attachFin_eq_fin {s : Finset ℕ} (h : ∀ m ∈ s, m < n) :
    attachFin s h = s.fin n := by
  ext
  simp