File: Mathlib/Data/Finset/Grade.lean

full_name: Multiset.covBy_cons
code: @[simp] lemma covBy_cons (s : Multiset α) (a : α) : s ⋖ a ::ₘ s 
goal: s ⋖ a ::ₘ s

full_name: CovBy.exists_multiset_cons
code: lemma _root_.CovBy.exists_multiset_cons (h : s ⋖ t) : ∃ a, a ::ₘ s = t 
goal: ∃ a, a ::ₘ s = t

full_name: Multiset.covBy_iff
code: lemma covBy_iff : s ⋖ t ↔ ∃ a, a ::ₘ s = t 
goal: s ⋖ t ↔ ∃ a, a ::ₘ s = t

full_name: CovBy.card_multiset
code: lemma _root_.CovBy.card_multiset (h : s ⋖ t) : card s ⋖ card t 
goal: Multiset.card s ⋖ Multiset.card t

full_name: Multiset.isAtom_iff
code: lemma isAtom_iff : IsAtom s ↔ ∃ a, s = {a} 
goal: IsAtom s ↔ ∃ a, s = {a}

full_name: Multiset.isAtom_singleton
code: @[simp] lemma isAtom_singleton (a : α) : IsAtom ({a} : Multiset α) 
goal: IsAtom {a}

full_name: Multiset.instGradeMinOrder
code: instance instGradeMinOrder : GradeMinOrder ℕ (Multiset α) 
goal: GradeMinOrder ℕ (Multiset α)

full_name: Multiset.grade_eq
code: @[simp] lemma grade_eq (m : Multiset α) : grade ℕ m = card m 
goal: grade ℕ m = Multiset.card m

full_name: Finset.ordConnected_range_val
code: /-- Finsets form an order-connected suborder of multisets. -/
lemma ordConnected_range_val : Set.OrdConnected (Set.range val : Set <| Multiset α) 
goal: (Set.range Finset.val).OrdConnected

full_name: Finset.ordConnected_range_coe
code: /-- Finsets form an order-connected suborder of sets. -/
lemma ordConnected_range_coe : Set.OrdConnected (Set.range ((↑) : Finset α → Set α)) 
goal: (Set.range Finset.toSet).OrdConnected

full_name: Finset.val_wcovBy_val
code: @[simp] lemma val_wcovBy_val : s.1 ⩿ t.1 ↔ s ⩿ t 
goal: s.val ⩿ t.val ↔ s ⩿ t

full_name: Finset.val_covBy_val
code: @[simp] lemma val_covBy_val : s.1 ⋖ t.1 ↔ s ⋖ t 
goal: s.val ⋖ t.val ↔ s ⋖ t

full_name: Finset.coe_wcovBy_coe
code: @[simp] lemma coe_wcovBy_coe : (s : Set α) ⩿ t ↔ s ⩿ t 
goal: ↑s ⩿ ↑t ↔ s ⩿ t

full_name: Finset.coe_covBy_coe
code: @[simp] lemma coe_covBy_coe : (s : Set α) ⋖ t ↔ s ⋖ t 
goal: ↑s ⋖ ↑t ↔ s ⋖ t

full_name: Finset.covBy_cons
code: @[simp] lemma covBy_cons (ha : a ∉ s) : s ⋖ s.cons a ha 
goal: s ⋖ Finset.cons a s ha

full_name: CovBy.exists_finset_cons
code: lemma _root_.CovBy.exists_finset_cons (h : s ⋖ t) : ∃ a, ∃ ha : a ∉ s, s.cons a ha = t 
goal: ∃ a, ∃ (ha : a ∉ s), Finset.cons a s ha = t

full_name: Finset.covBy_iff_exists_cons
code: lemma covBy_iff_exists_cons : s ⋖ t ↔ ∃ a, ∃ ha : a ∉ s, s.cons a ha = t 
goal: s ⋖ t ↔ ∃ a, ∃ (ha : a ∉ s), Finset.cons a s ha = t

full_name: CovBy.card_finset
code: lemma _root_.CovBy.card_finset (h : s ⋖ t) : s.card ⋖ t.card 
goal: s.card ⋖ t.card

full_name: Finset.wcovBy_insert
code: @[simp] lemma wcovBy_insert (s : Finset α) (a : α) : s ⩿ insert a s 
goal: s ⩿ insert a s

full_name: Finset.erase_wcovBy
code: @[simp] lemma erase_wcovBy (s : Finset α) (a : α) : s.erase a ⩿ s 
goal: s.erase a ⩿ s

full_name: Finset.covBy_insert
code: lemma covBy_insert (ha : a ∉ s) : s ⋖ insert a s 
goal: s ⋖ insert a s

full_name: Finset.erase_covBy
code: @[simp] lemma erase_covBy (ha : a ∈ s) : s.erase a ⋖ s 
goal: s.erase a ⋖ s

full_name: CovBy.exists_finset_insert
code: lemma _root_.CovBy.exists_finset_insert (h : s ⋖ t) : ∃ a ∉ s, insert a s = t 
goal: ∃ a ∉ s, insert a s = t

full_name: CovBy.exists_finset_erase
code: lemma _root_.CovBy.exists_finset_erase (h : s ⋖ t) : ∃ a ∈ t, t.erase a = s 
goal: ∃ a ∈ t, t.erase a = s

full_name: Finset.covBy_iff_exists_insert
code: lemma covBy_iff_exists_insert : s ⋖ t ↔ ∃ a ∉ s, insert a s = t 
goal: s ⋖ t ↔ ∃ a ∉ s, insert a s = t

full_name: Finset.covBy_iff_card_sdiff_eq_one
code: lemma covBy_iff_card_sdiff_eq_one : t ⋖ s ↔ t ⊆ s ∧ (s \ t).card = 1 
goal: t ⋖ s ↔ t ⊆ s ∧ (s \ t).card = 1

full_name: Finset.covBy_iff_exists_erase
code: lemma covBy_iff_exists_erase : s ⋖ t ↔ ∃ a ∈ t, t.erase a = s 
goal: s ⋖ t ↔ ∃ a ∈ t, t.erase a = s

full_name: Finset.isAtom_singleton
code: @[simp] lemma isAtom_singleton (a : α) : IsAtom ({a} : Finset α) 
goal: IsAtom {a}

full_name: Finset.isAtom_iff
code: protected lemma isAtom_iff : IsAtom s ↔ ∃ a, s = {a} 
goal: IsAtom s ↔ ∃ a, s = {a}

full_name: Finset.isCoatom_compl_singleton
code: lemma isCoatom_compl_singleton (a : α) : IsCoatom ({a}ᶜ : Finset α) 
goal: IsCoatom {a}ᶜ

full_name: Finset.isCoatom_iff
code: protected lemma isCoatom_iff : IsCoatom s ↔ ∃ a, s = {a}ᶜ 
goal: IsCoatom s ↔ ∃ a, s = {a}ᶜ

full_name: Finset.instGradeMinOrder_multiset
code: /-- Finsets are multiset-graded. This is not very meaningful mathematically but rather a handy way
to record that the inclusion `Finset α ↪ Multiset α` preserves the covering relation. -/
instance instGradeMinOrder_multiset : GradeMinOrder (Multiset α) (Finset α) 
goal: GradeMinOrder (Multiset α) (Finset α)

full_name: Finset.grade_multiset_eq
code: @[simp] lemma grade_multiset_eq (s : Finset α) : grade (Multiset α) s = s.1 
goal: grade (Multiset α) s = s.val

full_name: Finset.instGradeMinOrder_nat
code: instance instGradeMinOrder_nat : GradeMinOrder ℕ (Finset α) 
goal: GradeMinOrder ℕ (Finset α)

full_name: Finset.grade_eq
code: @[simp] lemma grade_eq (s : Finset α) : grade ℕ s = s.card 
goal: grade ℕ s = s.card