Finite sets

Terms of type Finset α are one way of talking about finite subsets of α in mathlib. Below, Finset α is defined as a structure with 2 fields:

1. val is a Multiset α of elements;
2. nodup is a proof that val has no duplicates.

Finsets in Lean are constructive in that they have an underlying List that enumerates their elements. In particular, any function that uses the data of the underlying list cannot depend on its ordering. This is handled on the Multiset level by multiset API, so in most cases one needn't worry about it explicitly.

Finsets give a basic foundation for defining finite sums and products over types:

1. ∑ i in (s : Finset α), f i∑ i in (s : Finset α), f i;
2. ∏ i in (s : Finset α), f i∏ i in (s : Finset α), f i.

Lean refers to these operations as big operators. More information can be found in Mathlib.Algebra.BigOperators.Basic.

Finsets are directly used to define fintypes in Lean. A Fintype α instance for a type α consists of a universal Finset α containing every term of α, called univ. See Mathlib.Data.Fintype.Basic. There is also univ', the noncomputable partner to univ, which is defined to be α as a finset if α is finite, and the empty finset otherwise. See Mathlib.Data.Fintype.Basic.

Finset.card, the size of a finset is defined in Mathlib.Data.Finset.Card. This is then used to define Fintype.card, the size of a type.

Main declarations

Main definitions

• Finset: Defines a type for the finite subsets of α. Constructing a Finset requires two pieces of data: val, a Multiset α of elements, and nodup, a proof that val has no duplicates.
• Finset.instMembershipFinset: Defines membership a ∈ (s : Finset α)∈ (s : Finset α).
• Finset.instCoeTCFinsetSet: Provides a coercion s : Finset α to s : Set α.
• Finset.instCoeSortFinsetType: Coerce s : Finset α to the type of all x ∈ s∈ s.
• Finset.induction_on: Induction on finsets. To prove a proposition about an arbitrary Finset α, it suffices to prove it for the empty finset, and to show that if it holds for some Finset α, then it holds for the finset obtained by inserting a new element.
• Finset.choose: Given a proof h of existence and uniqueness of a certain element satisfying a predicate, choose s h returns the element of s satisfying that predicate.

Finset constructions

• Finset.instSingletonFinset: Denoted by {a}; the finset consisting of one element.
• Finset.empty: Denoted by ∅∅. The finset associated to any type consisting of no elements.
• Finset.range: For any n : ℕ, range n is equal to {0, 1, ... , n - 1} ⊆ ℕ⊆ ℕ. This convention is consistent with other languages and normalizes card (range n) = n. Beware, n is not in range n.
• Finset.attach: Given s : Finset α, attach s forms a finset of elements of the subtype {a // a ∈ s}∈ s}; in other words, it attaches elements to a proof of membership in the set.

Finsets from functions

• Finset.filter: Given a decidable predicate p : α → Prop→ Prop, s.filter p is the finset consisting of those elements in s satisfying the predicate p.

The lattice structure on subsets of finsets

There is a natural lattice structure on the subsets of a set. In Lean, we use lattice notation to talk about things involving unions and intersections. See Mathlib.Order.Lattice. For the lattice structure on finsets, ⊥⊥ is called bot with ⊥ = ∅⊥ = ∅∅ and ⊤⊤ is called top with ⊤ = univ⊤ = univ.

• Finset.instHasSubsetFinset: Lots of API about lattices, otherwise behaves as one would expect.
• Finset.instUnionFinset: Defines s ∪ t∪ t (or s ⊔ t⊔ t) as the union of s and t. See Finset.sup/Finset.bunionᵢ for finite unions.
• Finset.instInterFinset: Defines s ∩ t∩ t (or s ⊓ t⊓ t) as the intersection of s and t. See Finset.inf for finite intersections.
• Finset.disjUnion: Given a hypothesis h which states that finsets s and t are disjoint, s.disjUnion t h is the set such that a ∈ disjUnion s t h∈ disjUnion s t h iff a ∈ s∈ s or a ∈ t∈ t; this does not require decidable equality on the type α.

Operations on two or more finsets

• insert and Finset.cons: For any a : α, insert s a returns s ∪ {a}∪ {a}. cons s a h returns the same except that it requires a hypothesis stating that a is not already in s. This does not require decidable equality on the type α.
• Finset.instUnionFinset: see "The lattice structure on subsets of finsets"
• Finset.instInterFinset: see "The lattice structure on subsets of finsets"
• Finset.erase: For any a : α, erase s a returns s with the element a removed.
• Finset.instSDiffFinset: Defines the set difference s \ t for finsets s and t.
• Finset.product: Given finsets of α and β, defines finsets of α × β× β. For arbitrary dependent products, see Mathlib.Data.Finset.Pi.
• Finset.bunionᵢ: Finite unions of finsets; given an indexing function f : α → Finset β→ Finset β and a s : Finset α, s.bunionᵢ f is the union of all finsets of the form f a for a ∈ s∈ s.
• Finset.bInter: TODO: Implemement finite intersections.

Maps constructed using finsets

• Finset.piecewise: Given two functions f, g, s.piecewise f g is a function which is equal to f on s and g on the complement.

Predicates on finsets

• Disjoint: defined via the lattice structure on finsets; two sets are disjoint if their intersection is empty.
• Finset.Nonempty: A finset is nonempty if it has elements. This is equivalent to saying s ≠ ∅≠ ∅∅. TODO: Decide on the simp normal form.

Equivalences between finsets

• The Mathlib.Data.Equiv files describe a general type of equivalence, so look in there for any lemmas. There is some API for rewriting sums and products from s to t given that s ≃ t≃ t. TODO: examples

Tags

finite sets, finset

ink

structure Finset (α : Type u_1) : Type u_1

• The underlying multiset

  val : Multiset α

• val contains no duplicates

  nodup : Multiset.Nodup val

Finset α is the type of finite sets of elements of α. It is implemented as a multiset (a list up to permutation) which has no duplicate elements.

ink

instance Multiset.canLiftFinset {α : Type u_1} : CanLift (Multiset α) (Finset α) Finset.val Multiset.Nodup

Equations

• Multiset.canLiftFinset = { prf := (_ : ∀ (m : Multiset α), Multiset.Nodup m → ∃ y, y.val = m) }

ink

theorem Finset.eq_of_veq {α : Type u_1} {s : Finset α} {t : Finset α} : s.val = t.val → s = t

ink

theorem Finset.val_injective {α : Type u_1} : Function.Injective Finset.val

ink

@[simp]

theorem Finset.val_inj {α : Type u_1} {s : Finset α} {t : Finset α} : s.val = t.val ↔ s = t

ink

@[simp]

theorem Finset.dedup_eq_self {α : Type u_1} [inst : DecidableEq α] (s : Finset α) : Multiset.dedup s.val = s.val

ink

instance Finset.decidableEq {α : Type u_1} [inst : DecidableEq α] : DecidableEq (Finset α)

Equations

• Finset.decidableEq x x = match x, x with | x, x_1 => decidable_of_iff (x.val = x_1.val) (_ : x.val = x_1.val ↔ x = x_1)

membership

ink

instance Finset.instMembershipFinset {α : Type u_1} : Membership α (Finset α)

Equations

• Finset.instMembershipFinset = { mem := fun a s => a ∈ s.val }

ink

theorem Finset.mem_def {α : Type u_1} {a : α} {s : Finset α} : a ∈ s ↔ a ∈ s.val

ink

@[simp]

theorem Finset.mem_val {α : Type u_1} {a : α} {s : Finset α} : a ∈ s.val ↔ a ∈ s

ink

@[simp]

theorem Finset.mem_mk {α : Type u_1} {a : α} {s : Multiset α} {nd : Multiset.Nodup s} : a ∈ { val := s, nodup := nd } ↔ a ∈ s

ink

instance Finset.decidableMem {α : Type u_1} [_h : DecidableEq α] (a : α) (s : Finset α) : Decidable (a ∈ s)

Equations

• Finset.decidableMem a s = Multiset.decidableMem a s.val

set coercion

ink

def Finset.toSet {α : Type u_1} (s : Finset α) : Set α

Convert a finset to a set in the natural way.

Equations

• ↑s = { a | a ∈ s }

ink

instance Finset.instCoeTCFinsetSet {α : Type u_1} : CoeTC (Finset α) (Set α)

Convert a finset to a set in the natural way.

Equations

• Finset.instCoeTCFinsetSet = { coe := Finset.toSet }

ink

@[simp]

theorem Finset.mem_coe {α : Type u_1} {a : α} {s : Finset α} : a ∈ ↑s ↔ a ∈ s

ink

@[simp]

theorem Finset.setOf_mem {α : Type u_1} {s : Finset α} : { a | a ∈ s } = ↑s

ink

@[simp]

theorem Finset.coe_mem {α : Type u_1} {s : Finset α} (x : ↑↑s) : ↑x ∈ s

ink

theorem Finset.mk_coe {α : Type u_1} {s : Finset α} (x : ↑↑s) {h : ↑x ∈ ↑s} : { val := ↑x, property := h } = x

ink

instance Finset.decidableMem' {α : Type u_1} [inst : DecidableEq α] (a : α) (s : Finset α) : Decidable (a ∈ ↑s)

Equations

• Finset.decidableMem' a s = Finset.decidableMem a s

extensionality

ink

theorem Finset.ext_iff {α : Type u_1} {s₁ : Finset α} {s₂ : Finset α} : s₁ = s₂ ↔ ∀ (a : α), a ∈ s₁ ↔ a ∈ s₂

ink

theorem Finset.ext {α : Type u_1} {s₁ : Finset α} {s₂ : Finset α} : (∀ (a : α), a ∈ s₁ ↔ a ∈ s₂) → s₁ = s₂

ink

@[simp]

theorem Finset.coe_inj {α : Type u_1} {s₁ : Finset α} {s₂ : Finset α} : ↑s₁ = ↑s₂ ↔ s₁ = s₂

ink

theorem Finset.coe_injective {α : Type u_1} : Function.Injective Finset.toSet

type coercion

ink

instance Finset.instCoeSortFinsetType {α : Type u} : CoeSort (Finset α) (Type u)

Coercion from a finset to the corresponding subtype.

Equations

• Finset.instCoeSortFinsetType = { coe := fun s => { x // x ∈ s } }

ink

theorem Finset.forall_coe {α : Type u_1} (s : Finset α) (p : { x // x ∈ s } → Prop) : ((x : { x // x ∈ s }) → p x) ↔ (x : α) → (h : x ∈ s) → p { val := x, property := h }

ink

theorem Finset.exists_coe {α : Type u_1} (s : Finset α) (p : { x // x ∈ s } → Prop) : (∃ x, p x) ↔ ∃ x h, p { val := x, property := h }

ink

instance Finset.PiFinsetCoe.canLift (ι : Type u_1) (α : ι → Type u_2) [_ne : ∀ (i : ι), Nonempty (α i)] (s : Finset ι) : CanLift ((i : { x // x ∈ s }) → α ↑i) ((i : ι) → α i) (fun f i => f ↑i) fun x => True

Equations

• Finset.PiFinsetCoe.canLift ι α s = PiSubtype.canLift ι α fun x => x ∈ s

ink

instance Finset.PiFinsetCoe.canLift' (ι : Type u_1) (α : Type u_2) [_ne : Nonempty α] (s : Finset ι) : CanLift ({ x // x ∈ s } → α) (ι → α) (fun f i => f ↑i) fun x => True

Equations

• Finset.PiFinsetCoe.canLift' ι α s = Finset.PiFinsetCoe.canLift ι (fun x => α) s

ink

instance Finset.FinsetCoe.canLift {α : Type u_1} (s : Finset α) : CanLift α { x // x ∈ s } Subtype.val fun a => a ∈ s

Equations

• Finset.FinsetCoe.canLift s = { prf := (_ : ∀ (a : α), a ∈ s → ∃ y, ↑y = a) }

ink

@[simp]

theorem Finset.coe_sort_coe {α : Type u_1} (s : Finset α) : ↑↑s = { x // x ∈ s }

Subset and strict subset relations

ink

instance Finset.instHasSubsetFinset {α : Type u_1} : HasSubset (Finset α)

Equations

• Finset.instHasSubsetFinset = { Subset := fun s t => ∀ ⦃a : α⦄, a ∈ s → a ∈ t }

ink

instance Finset.instHasSSubsetFinset {α : Type u_1} : HasSSubset (Finset α)

Equations

• Finset.instHasSSubsetFinset = { SSubset := fun s t => s ⊆ t ∧ ¬t ⊆ s }

ink

instance Finset.partialOrder {α : Type u_1} : PartialOrder (Finset α)

Equations

• Finset.partialOrder = PartialOrder.mk (_ : ∀ (s t : Finset α), s ≤ t → t ≤ s → s = t)

ink

instance Finset.instIsReflFinsetSubsetInstHasSubsetFinset {α : Type u_1} : IsRefl (Finset α) fun x x_1 => x ⊆ x_1

Equations

• @Finset.instIsReflFinsetSubsetInstHasSubsetFinset = @Finset.instIsReflFinsetSubsetInstHasSubsetFinset.proof_1

ink

instance Finset.instIsTransFinsetSubsetInstHasSubsetFinset {α : Type u_1} : IsTrans (Finset α) fun x x_1 => x ⊆ x_1

Equations

• @Finset.instIsTransFinsetSubsetInstHasSubsetFinset = @Finset.instIsTransFinsetSubsetInstHasSubsetFinset.proof_1

ink

instance Finset.instIsAntisymmFinsetSubsetInstHasSubsetFinset {α : Type u_1} : IsAntisymm (Finset α) fun x x_1 => x ⊆ x_1

Equations

• @Finset.instIsAntisymmFinsetSubsetInstHasSubsetFinset = @Finset.instIsAntisymmFinsetSubsetInstHasSubsetFinset.proof_1

ink

instance Finset.instIsIrreflFinsetSSubsetInstHasSSubsetFinset {α : Type u_1} : IsIrrefl (Finset α) fun x x_1 => x ⊂ x_1

Equations

• @Finset.instIsIrreflFinsetSSubsetInstHasSSubsetFinset = @Finset.instIsIrreflFinsetSSubsetInstHasSSubsetFinset.proof_1

ink

instance Finset.instIsTransFinsetSSubsetInstHasSSubsetFinset {α : Type u_1} : IsTrans (Finset α) fun x x_1 => x ⊂ x_1

Equations

• @Finset.instIsTransFinsetSSubsetInstHasSSubsetFinset = @Finset.instIsTransFinsetSSubsetInstHasSSubsetFinset.proof_1

ink

instance Finset.instIsAsymmFinsetSSubsetInstHasSSubsetFinset {α : Type u_1} : IsAsymm (Finset α) fun x x_1 => x ⊂ x_1

Equations

• @Finset.instIsAsymmFinsetSSubsetInstHasSSubsetFinset = @Finset.instIsAsymmFinsetSSubsetInstHasSSubsetFinset.proof_1

ink

instance Finset.instIsNonstrictStrictOrderFinsetSubsetInstHasSubsetFinsetSSubsetInstHasSSubsetFinset {α : Type u_1} : IsNonstrictStrictOrder (Finset α) (fun x x_1 => x ⊆ x_1) fun x x_1 => x ⊂ x_1

Equations

• Finset.instIsNonstrictStrictOrderFinsetSubsetInstHasSubsetFinsetSSubsetInstHasSSubsetFinset = { right_iff_left_not_left := (_ : ∀ (x x_1 : Finset α), x ⊂ x_1 ↔ x ⊂ x_1) }

ink

theorem Finset.subset_def {α : Type u_1} {s : Finset α} {t : Finset α} : s ⊆ t ↔ s.val ⊆ t.val

ink

theorem Finset.ssubset_def {α : Type u_1} {s : Finset α} {t : Finset α} : s ⊂ t ↔ s ⊆ t ∧ ¬t ⊆ s

ink

@[simp]

theorem Finset.Subset.refl {α : Type u_1} (s : Finset α) : s ⊆ s

ink

theorem Finset.Subset.rfl {α : Type u_1} {s : Finset α} : s ⊆ s

ink

theorem Finset.subset_of_eq {α : Type u_1} {s : Finset α} {t : Finset α} (h : s = t) : s ⊆ t

ink

theorem Finset.Subset.trans {α : Type u_1} {s₁ : Finset α} {s₂ : Finset α} {s₃ : Finset α} : s₁ ⊆ s₂ → s₂ ⊆ s₃ → s₁ ⊆ s₃

ink

theorem Finset.Superset.trans {α : Type u_1} {s₁ : Finset α} {s₂ : Finset α} {s₃ : Finset α} : s₁ ⊇ s₂ → s₂ ⊇ s₃ → s₁ ⊇ s₃

ink

theorem Finset.mem_of_subset {α : Type u_1} {s₁ : Finset α} {s₂ : Finset α} {a : α} : s₁ ⊆ s₂ → a ∈ s₁ → a ∈ s₂

ink

theorem Finset.not_mem_mono {α : Type u_1} {s : Finset α} {t : Finset α} (h : s ⊆ t) {a : α} : ¬a ∈ t → ¬a ∈ s

ink

theorem Finset.Subset.antisymm {α : Type u_1} {s₁ : Finset α} {s₂ : Finset α} (H₁ : s₁ ⊆ s₂) (H₂ : s₂ ⊆ s₁) : s₁ = s₂

ink

theorem Finset.subset_iff {α : Type u_1} {s₁ : Finset α} {s₂ : Finset α} : s₁ ⊆ s₂ ↔ ∀ ⦃x : α⦄, x ∈ s₁ → x ∈ s₂

ink

@[simp]

theorem Finset.coe_subset {α : Type u_1} {s₁ : Finset α} {s₂ : Finset α} : ↑s₁ ⊆ ↑s₂ ↔ s₁ ⊆ s₂

ink

@[simp]

theorem Finset.val_le_iff {α : Type u_1} {s₁ : Finset α} {s₂ : Finset α} : s₁.val ≤ s₂.val ↔ s₁ ⊆ s₂

ink

theorem Finset.Subset.antisymm_iff {α : Type u_1} {s₁ : Finset α} {s₂ : Finset α} : s₁ = s₂ ↔ s₁ ⊆ s₂ ∧ s₂ ⊆ s₁

ink

theorem Finset.not_subset {α : Type u_1} {s : Finset α} {t : Finset α} : ¬s ⊆ t ↔ ∃ x, x ∈ s ∧ ¬x ∈ t

ink

@[simp]

theorem Finset.le_eq_subset {α : Type u_1} : (fun x x_1 => x ≤ x_1) = fun x x_1 => x ⊆ x_1

ink

@[simp]

theorem Finset.lt_eq_subset {α : Type u_1} : (fun x x_1 => x < x_1) = fun x x_1 => x ⊂ x_1

ink

theorem Finset.le_iff_subset {α : Type u_1} {s₁ : Finset α} {s₂ : Finset α} : s₁ ≤ s₂ ↔ s₁ ⊆ s₂

ink

theorem Finset.lt_iff_ssubset {α : Type u_1} {s₁ : Finset α} {s₂ : Finset α} : s₁ < s₂ ↔ s₁ ⊂ s₂

ink

@[simp]

theorem Finset.coe_ssubset {α : Type u_1} {s₁ : Finset α} {s₂ : Finset α} : ↑s₁ ⊂ ↑s₂ ↔ s₁ ⊂ s₂

ink

@[simp]

theorem Finset.val_lt_iff {α : Type u_1} {s₁ : Finset α} {s₂ : Finset α} : s₁.val < s₂.val ↔ s₁ ⊂ s₂

ink

theorem Finset.ssubset_iff_subset_ne {α : Type u_1} {s : Finset α} {t : Finset α} : s ⊂ t ↔ s ⊆ t ∧ s ≠ t

ink

theorem Finset.ssubset_iff_of_subset {α : Type u_1} {s₁ : Finset α} {s₂ : Finset α} (h : s₁ ⊆ s₂) : s₁ ⊂ s₂ ↔ ∃ x, x ∈ s₂ ∧ ¬x ∈ s₁

ink

theorem Finset.ssubset_of_ssubset_of_subset {α : Type u_1} {s₁ : Finset α} {s₂ : Finset α} {s₃ : Finset α} (hs₁s₂ : s₁ ⊂ s₂) (hs₂s₃ : s₂ ⊆ s₃) : s₁ ⊂ s₃

ink

theorem Finset.ssubset_of_subset_of_ssubset {α : Type u_1} {s₁ : Finset α} {s₂ : Finset α} {s₃ : Finset α} (hs₁s₂ : s₁ ⊆ s₂) (hs₂s₃ : s₂ ⊂ s₃) : s₁ ⊂ s₃

ink

theorem Finset.exists_of_ssubset {α : Type u_1} {s₁ : Finset α} {s₂ : Finset α} (h : s₁ ⊂ s₂) : ∃ x, x ∈ s₂ ∧ ¬x ∈ s₁

ink

instance Finset.isWellFounded_ssubset {α : Type u_1} : IsWellFounded (Finset α) fun x x_1 => x ⊂ x_1

Equations

• @Finset.isWellFounded_ssubset = @Finset.isWellFounded_ssubset.proof_1

ink

instance Finset.wellFoundedLT {α : Type u_1} : WellFoundedLT (Finset α)

Equations

• @Finset.wellFoundedLT = @Finset.wellFoundedLT.proof_1

Order embedding from Finset α to Set α

ink

def Finset.coeEmb {α : Type u_1} : Finset α ↪o Set α

Coercion to Set α as an OrderEmbedding.

Equations

• Finset.coeEmb = { toEmbedding := { toFun := Finset.toSet, inj' := (_ : Function.Injective Finset.toSet) }, map_rel_iff' := (_ : ∀ {a b : Finset α}, ↑a ⊆ ↑b ↔ a ⊆ b) }

ink

@[simp]

theorem Finset.coe_coeEmb {α : Type u_1} : ↑Finset.coeEmb.toEmbedding = Finset.toSet

Nonempty

ink

def Finset.Nonempty {α : Type u_1} (s : Finset α) : Prop

The property s.Nonempty expresses the fact that the finset s is not empty. It should be used in theorem assumptions instead of ∃ x, x ∈ s∃ x, x ∈ s∈ s or s ≠ ∅≠ ∅∅ as it gives access to a nice API thanks to the dot notation.

Equations

• Finset.Nonempty s = ∃ x, x ∈ s

ink

instance Finset.decidableNonempty {α : Type u_1} {s : Finset α} : Decidable (Finset.Nonempty s)

Equations

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

ink

@[simp]

theorem Finset.coe_nonempty {α : Type u_1} {s : Finset α} : Set.Nonempty ↑s ↔ Finset.Nonempty s

ink

theorem Finset.nonempty_coe_sort {α : Type u_1} {s : Finset α} : Nonempty { x // x ∈ s } ↔ Finset.Nonempty s

ink

theorem Finset.Nonempty.to_set {α : Type u_1} {s : Finset α} : Finset.Nonempty s → Set.Nonempty ↑s

Alias of the reverse direction of Finset.coe_nonempty.

ink

theorem Finset.Nonempty.coe_sort {α : Type u_1} {s : Finset α} : Finset.Nonempty s → Nonempty { x // x ∈ s }

Alias of the reverse direction of Finset.nonempty_coe_sort.

ink

theorem Finset.Nonempty.bex {α : Type u_1} {s : Finset α} (h : Finset.Nonempty s) : ∃ x, x ∈ s

ink

theorem Finset.Nonempty.mono {α : Type u_1} {s : Finset α} {t : Finset α} (hst : s ⊆ t) (hs : Finset.Nonempty s) : Finset.Nonempty t

ink

theorem Finset.Nonempty.forall_const {α : Type u_1} {s : Finset α} (h : Finset.Nonempty s) {p : Prop} : ((x : α) → x ∈ s → p) ↔ p

ink

theorem Finset.Nonempty.to_subtype {α : Type u_1} {s : Finset α} : Finset.Nonempty s → Nonempty { x // x ∈ s }

ink

theorem Finset.Nonempty.to_type {α : Type u_1} {s : Finset α} : Finset.Nonempty s → Nonempty α

empty

ink

def Finset.empty {α : Type u_1} : Finset α

The empty finset

Equations

• Finset.empty = { val := 0, nodup := (_ : Multiset.Nodup 0) }

ink

instance Finset.instEmptyCollectionFinset {α : Type u_1} : EmptyCollection (Finset α)

Equations

• Finset.instEmptyCollectionFinset = { emptyCollection := Finset.empty }

ink

instance Finset.inhabitedFinset {α : Type u_1} : Inhabited (Finset α)

Equations

• Finset.inhabitedFinset = { default := ∅ }

ink

@[simp]

theorem Finset.empty_val {α : Type u_1} : ∅.val = 0

ink

@[simp]

theorem Finset.not_mem_empty {α : Type u_1} (a : α) : ¬a ∈ ∅

ink

@[simp]

theorem Finset.not_nonempty_empty {α : Type u_1} : ¬Finset.Nonempty ∅

ink

@[simp]

theorem Finset.mk_zero {α : Type u_1} : { val := 0, nodup := (_ : Multiset.Nodup 0) } = ∅

ink

theorem Finset.ne_empty_of_mem {α : Type u_1} {a : α} {s : Finset α} (h : a ∈ s) : s ≠ ∅

ink

theorem Finset.Nonempty.ne_empty {α : Type u_1} {s : Finset α} (h : Finset.Nonempty s) : s ≠ ∅

ink

@[simp]

theorem Finset.empty_subset {α : Type u_1} (s : Finset α) : ∅ ⊆ s

ink

theorem Finset.eq_empty_of_forall_not_mem {α : Type u_1} {s : Finset α} (H : ∀ (x : α), ¬x ∈ s) : s = ∅

ink

theorem Finset.eq_empty_iff_forall_not_mem {α : Type u_1} {s : Finset α} : s = ∅ ↔ ∀ (x : α), ¬x ∈ s

ink

@[simp]

theorem Finset.val_eq_zero {α : Type u_1} {s : Finset α} : s.val = 0 ↔ s = ∅

ink

theorem Finset.subset_empty {α : Type u_1} {s : Finset α} : s ⊆ ∅ ↔ s = ∅

ink

@[simp]

theorem Finset.not_ssubset_empty {α : Type u_1} (s : Finset α) : ¬s ⊂ ∅

ink

theorem Finset.nonempty_of_ne_empty {α : Type u_1} {s : Finset α} (h : s ≠ ∅) : Finset.Nonempty s

ink

theorem Finset.nonempty_iff_ne_empty {α : Type u_1} {s : Finset α} : Finset.Nonempty s ↔ s ≠ ∅

ink

@[simp]

theorem Finset.not_nonempty_iff_eq_empty {α : Type u_1} {s : Finset α} : ¬Finset.Nonempty s ↔ s = ∅

ink

theorem Finset.eq_empty_or_nonempty {α : Type u_1} (s : Finset α) : s = ∅ ∨ Finset.Nonempty s

ink

@[simp]

theorem Finset.coe_empty {α : Type u_1} : ↑∅ = ∅

ink

@[simp]

theorem Finset.coe_eq_empty {α : Type u_1} {s : Finset α} : ↑s = ∅ ↔ s = ∅

ink

theorem Finset.isEmpty_coe_sort {α : Type u_1} {s : Finset α} : IsEmpty { x // x ∈ s } ↔ s = ∅

ink

instance Finset.instIsEmptySubtypeMemFinsetInstMembershipFinsetEmptyCollectionInstEmptyCollectionFinset {α : Type u_1} : IsEmpty { x // x ∈ ∅ }

Equations

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

ink

theorem Finset.eq_empty_of_isEmpty {α : Type u_1} [inst : IsEmpty α] (s : Finset α) : s = ∅

A Finset for an empty type is empty.

ink

instance Finset.instOrderBotFinsetToLEToPreorderPartialOrder {α : Type u_1} : OrderBot (Finset α)

Equations

• Finset.instOrderBotFinsetToLEToPreorderPartialOrder = OrderBot.mk (_ : ∀ (s : Finset α), ∅ ⊆ s)

ink

@[simp]

theorem Finset.bot_eq_empty {α : Type u_1} : ⊥ = ∅

ink

@[simp]

theorem Finset.empty_ssubset {α : Type u_1} {s : Finset α} : ∅ ⊂ s ↔ Finset.Nonempty s

ink

theorem Finset.Nonempty.empty_ssubset {α : Type u_1} {s : Finset α} : Finset.Nonempty s → ∅ ⊂ s

Alias of the reverse direction of Finset.empty_ssubset.

singleton

ink

instance Finset.instSingletonFinset {α : Type u_1} : Singleton α (Finset α)

{a} : Finset a is the set {a} containing a and nothing else.

This differs from insert a ∅∅ in that it does not require a DecidableEq instance for α.

Equations

• Finset.instSingletonFinset = { singleton := fun a => { val := {a}, nodup := (_ : Multiset.Nodup {a}) } }

ink

@[simp]

theorem Finset.singleton_val {α : Type u_1} (a : α) : {a}.val = {a}

ink

@[simp]

theorem Finset.mem_singleton {α : Type u_1} {a : α} {b : α} : b ∈ {a} ↔ b = a

ink

theorem Finset.eq_of_mem_singleton {α : Type u_1} {x : α} {y : α} (h : x ∈ {y}) : x = y

ink

theorem Finset.not_mem_singleton {α : Type u_1} {a : α} {b : α} : ¬a ∈ {b} ↔ a ≠ b

ink

theorem Finset.mem_singleton_self {α : Type u_1} (a : α) : a ∈ {a}

ink

@[simp]

theorem Finset.val_eq_singleton_iff {α : Type u_1} {a : α} {s : Finset α} : s.val = {a} ↔ s = {a}

ink

theorem Finset.singleton_injective {α : Type u_1} : Function.Injective singleton

ink

@[simp]

theorem Finset.singleton_inj {α : Type u_1} {a : α} {b : α} : {a} = {b} ↔ a = b

ink

@[simp]

theorem Finset.singleton_nonempty {α : Type u_1} (a : α) : Finset.Nonempty {a}

ink

@[simp]

theorem Finset.singleton_ne_empty {α : Type u_1} (a : α) : {a} ≠ ∅

ink

theorem Finset.empty_ssubset_singleton {α : Type u_1} {a : α} : ∅ ⊂ {a}

ink

@[simp]

theorem Finset.coe_singleton {α : Type u_1} (a : α) : ↑{a} = {a}

ink

@[simp]

theorem Finset.coe_eq_singleton {α : Type u_1} {s : Finset α} {a : α} : ↑s = {a} ↔ s = {a}

ink

theorem Finset.eq_singleton_iff_unique_mem {α : Type u_1} {s : Finset α} {a : α} : s = {a} ↔ a ∈ s ∧ ∀ (x : α), x ∈ s → x = a

ink

theorem Finset.eq_singleton_iff_nonempty_unique_mem {α : Type u_1} {s : Finset α} {a : α} : s = {a} ↔ Finset.Nonempty s ∧ ∀ (x : α), x ∈ s → x = a

ink

theorem Finset.nonempty_iff_eq_singleton_default {α : Type u_1} [inst : Unique α] {s : Finset α} : Finset.Nonempty s ↔ s = {default}

ink

theorem Finset.Nonempty.eq_singleton_default {α : Type u_1} [inst : Unique α] {s : Finset α} : Finset.Nonempty s → s = {default}

Alias of the forward direction of Finset.nonempty_iff_eq_singleton_default.

ink

theorem Finset.singleton_iff_unique_mem {α : Type u_1} (s : Finset α) : (∃ a, s = {a}) ↔ ∃! a, a ∈ s

ink

theorem Finset.singleton_subset_set_iff {α : Type u_1} {s : Set α} {a : α} : ↑{a} ⊆ s ↔ a ∈ s

ink

@[simp]

theorem Finset.singleton_subset_iff {α : Type u_1} {s : Finset α} {a : α} : {a} ⊆ s ↔ a ∈ s

ink

@[simp]

theorem Finset.subset_singleton_iff {α : Type u_1} {s : Finset α} {a : α} : s ⊆ {a} ↔ s = ∅ ∨ s = {a}

ink

theorem Finset.singleton_subset_singleton {α : Type u_1} {a : α} {b : α} : {a} ⊆ {b} ↔ a = b

ink

theorem Finset.Nonempty.subset_singleton_iff {α : Type u_1} {s : Finset α} {a : α} (h : Finset.Nonempty s) : s ⊆ {a} ↔ s = {a}

ink

theorem Finset.subset_singleton_iff' {α : Type u_1} {s : Finset α} {a : α} : s ⊆ {a} ↔ ∀ (b : α), b ∈ s → b = a

ink

@[simp]

theorem Finset.ssubset_singleton_iff {α : Type u_1} {s : Finset α} {a : α} : s ⊂ {a} ↔ s = ∅

ink

theorem Finset.eq_empty_of_ssubset_singleton {α : Type u_1} {s : Finset α} {x : α} (hs : s ⊂ {x}) : s = ∅

ink

theorem Finset.eq_singleton_or_nontrivial {α : Type u_1} {s : Finset α} {a : α} (ha : a ∈ s) : s = {a} ∨ Set.Nontrivial ↑s

ink

theorem Finset.Nonempty.exists_eq_singleton_or_nontrivial {α : Type u_1} {s : Finset α} : Finset.Nonempty s → (∃ a, s = {a}) ∨ Set.Nontrivial ↑s

ink

instance Finset.instNontrivialFinset {α : Type u_1} [inst : Nonempty α] : Nontrivial (Finset α)

Equations

• @Finset.instNontrivialFinset = @Finset.instNontrivialFinset.proof_1

ink

instance Finset.instUniqueFinset {α : Type u_1} [inst : IsEmpty α] : Unique (Finset α)

Equations

• Finset.instUniqueFinset = { toInhabited := { default := ∅ }, uniq := (_ : ∀ (x : Finset α), x = ∅) }

cons

ink

def Finset.cons {α : Type u_1} (a : α) (s : Finset α) (h : ¬a ∈ s) : Finset α

cons a s h is the set {a} ∪ s∪ s containing a and the elements of s. It is the same as insert a s when it is defined, but unlike insert a s it does not require DecidableEq α, and the union is guaranteed to be disjoint.

Equations

• Finset.cons a s h = { val := a ::ₘ s.val, nodup := (_ : Multiset.Nodup (a ::ₘ s.val)) }

ink

@[simp]

theorem Finset.mem_cons {α : Type u_1} {s : Finset α} {a : α} {b : α} {h : ¬a ∈ s} : b ∈ Finset.cons a s h ↔ b = a ∨ b ∈ s

ink

theorem Finset.mem_cons_self {α : Type u_1} (a : α) (s : Finset α) {h : ¬a ∈ s} : a ∈ Finset.cons a s h

ink

@[simp]

theorem Finset.cons_val {α : Type u_1} {s : Finset α} {a : α} (h : ¬a ∈ s) : (Finset.cons a s h).val = a ::ₘ s.val

ink

theorem Finset.forall_mem_cons {α : Type u_1} {s : Finset α} {a : α} (h : ¬a ∈ s) (p : α → Prop) : ((x : α) → x ∈ Finset.cons a s h → p x) ↔ p a ∧ ((x : α) → x ∈ s → p x)

ink

@[simp]

theorem Finset.mk_cons {α : Type u_1} {a : α} {s : Multiset α} (h : Multiset.Nodup (a ::ₘ s)) : { val := a ::ₘ s, nodup := h } = Finset.cons a { val := s, nodup := (_ : Multiset.Nodup s) } (_ : ¬a ∈ s)

ink

@[simp]

theorem Finset.nonempty_cons {α : Type u_1} {s : Finset α} {a : α} (h : ¬a ∈ s) : Finset.Nonempty (Finset.cons a s h)

ink

@[simp]

theorem Finset.nonempty_mk {α : Type u_1} {m : Multiset α} {hm : Multiset.Nodup m} : Finset.Nonempty { val := m, nodup := hm } ↔ m ≠ 0

ink

@[simp]

theorem Finset.coe_cons {α : Type u_1} {a : α} {s : Finset α} {h : ¬a ∈ s} : ↑(Finset.cons a s h) = insert a ↑s

ink

theorem Finset.subset_cons {α : Type u_1} {s : Finset α} {a : α} (h : ¬a ∈ s) : s ⊆ Finset.cons a s h

ink

theorem Finset.ssubset_cons {α : Type u_1} {s : Finset α} {a : α} (h : ¬a ∈ s) : s ⊂ Finset.cons a s h

ink

theorem Finset.cons_subset {α : Type u_1} {s : Finset α} {t : Finset α} {a : α} {h : ¬a ∈ s} : Finset.cons a s h ⊆ t ↔ a ∈ t ∧ s ⊆ t

ink

@[simp]

theorem Finset.cons_subset_cons {α : Type u_1} {s : Finset α} {t : Finset α} {a : α} {hs : ¬a ∈ s} {ht : ¬a ∈ t} : Finset.cons a s hs ⊆ Finset.cons a t ht ↔ s ⊆ t

ink

theorem Finset.ssubset_iff_exists_cons_subset {α : Type u_1} {s : Finset α} {t : Finset α} : s ⊂ t ↔ ∃ a h, Finset.cons a s h ⊆ t

disjoint

ink

theorem Finset.disjoint_left {α : Type u_1} {s : Finset α} {t : Finset α} : Disjoint s t ↔ ∀ ⦃a : α⦄, a ∈ s → ¬a ∈ t

ink

theorem Finset.disjoint_right {α : Type u_1} {s : Finset α} {t : Finset α} : Disjoint s t ↔ ∀ ⦃a : α⦄, a ∈ t → ¬a ∈ s

ink

theorem Finset.disjoint_iff_ne {α : Type u_1} {s : Finset α} {t : Finset α} : Disjoint s t ↔ ∀ (a : α), a ∈ s → ∀ (b : α), b ∈ t → a ≠ b

ink

@[simp]

theorem Finset.disjoint_val {α : Type u_1} {s : Finset α} {t : Finset α} : Multiset.Disjoint s.val t.val ↔ Disjoint s t

ink

theorem Disjoint.forall_ne_finset {α : Type u_1} {s : Finset α} {t : Finset α} {a : α} {b : α} (h : Disjoint s t) (ha : a ∈ s) (hb : b ∈ t) : a ≠ b

ink

theorem Finset.not_disjoint_iff {α : Type u_1} {s : Finset α} {t : Finset α} : ¬Disjoint s t ↔ ∃ a, a ∈ s ∧ a ∈ t

ink

theorem Finset.disjoint_of_subset_left {α : Type u_1} {s : Finset α} {t : Finset α} {u : Finset α} (h : s ⊆ u) (d : Disjoint u t) : Disjoint s t

ink

theorem Finset.disjoint_of_subset_right {α : Type u_1} {s : Finset α} {t : Finset α} {u : Finset α} (h : t ⊆ u) (d : Disjoint s u) : Disjoint s t

ink

@[simp]

theorem Finset.disjoint_empty_left {α : Type u_1} (s : Finset α) : Disjoint ∅ s

ink

@[simp]

theorem Finset.disjoint_empty_right {α : Type u_1} (s : Finset α) : Disjoint s ∅

ink

@[simp]

theorem Finset.disjoint_singleton_left {α : Type u_1} {s : Finset α} {a : α} : Disjoint {a} s ↔ ¬a ∈ s

ink

@[simp]

theorem Finset.disjoint_singleton_right {α : Type u_1} {s : Finset α} {a : α} : Disjoint s {a} ↔ ¬a ∈ s

ink

theorem Finset.disjoint_singleton {α : Type u_1} {a : α} {b : α} : Disjoint {a} {b} ↔ a ≠ b

ink

theorem Finset.disjoint_self_iff_empty {α : Type u_1} (s : Finset α) : Disjoint s s ↔ s = ∅

ink

@[simp]

theorem Finset.disjoint_coe {α : Type u_1} {s : Finset α} {t : Finset α} : Disjoint ↑s ↑t ↔ Disjoint s t

ink

@[simp]

theorem Finset.pairwiseDisjoint_coe {α : Type u_2} {ι : Type u_1} {s : Set ι} {f : ι → Finset α} : (Set.PairwiseDisjoint s fun i => ↑(f i)) ↔ Set.PairwiseDisjoint s f

disjoint union

ink

def Finset.disjUnion {α : Type u_1} (s : Finset α) (t : Finset α) (h : Disjoint s t) : Finset α

disjUnion s t h is the set such that a ∈ disjUnion s t h∈ disjUnion s t h iff a ∈ s∈ s or a ∈ t∈ t. It is the same as s ∪ t∪ t, but it does not require decidable equality on the type. The hypothesis ensures that the sets are disjoint.

Equations

• Finset.disjUnion s t h = { val := s.val + t.val, nodup := (_ : Multiset.Nodup (s.val + t.val)) }

ink

@[simp]

theorem Finset.mem_disjUnion {α : Type u_1} {s : Finset α} {t : Finset α} {h : Disjoint s t} {a : α} : a ∈ Finset.disjUnion s t h ↔ a ∈ s ∨ a ∈ t

ink

theorem Finset.disjUnion_comm {α : Type u_1} (s : Finset α) (t : Finset α) (h : Disjoint s t) : Finset.disjUnion s t h = Finset.disjUnion t s (_ : Disjoint t s)

ink

@[simp]

theorem Finset.empty_disjUnion {α : Type u_1} (t : Finset α) (h : optParam (Disjoint ∅ t) (_ : Disjoint ⊥ t)) : Finset.disjUnion ∅ t h = t

ink

@[simp]

theorem Finset.disjUnion_empty {α : Type u_1} (s : Finset α) (h : optParam (Disjoint s ∅) (_ : Disjoint s ⊥)) : Finset.disjUnion s ∅ h = s

ink

theorem Finset.singleton_disjUnion {α : Type u_1} (a : α) (t : Finset α) (h : Disjoint {a} t) : Finset.disjUnion {a} t h = Finset.cons a t (_ : ¬a ∈ t)

ink

theorem Finset.disjUnion_singleton {α : Type u_1} (s : Finset α) (a : α) (h : Disjoint s {a}) : Finset.disjUnion s {a} h = Finset.cons a s (_ : ¬a ∈ s)

insert

ink

instance Finset.instInsertFinset {α : Type u_1} [inst : DecidableEq α] : Insert α (Finset α)

insert a s is the set {a} ∪ s∪ s containing a and the elements of s.

Equations

• Finset.instInsertFinset = { insert := fun a s => { val := Multiset.ndinsert a s.val, nodup := (_ : Multiset.Nodup (Multiset.ndinsert a s.val)) } }

ink

theorem Finset.insert_def {α : Type u_1} [inst : DecidableEq α] (a : α) (s : Finset α) : insert a s = { val := Multiset.ndinsert a s.val, nodup := (_ : Multiset.Nodup (Multiset.ndinsert a s.val)) }

ink

@[simp]

theorem Finset.insert_val {α : Type u_1} [inst : DecidableEq α] (a : α) (s : Finset α) : (insert a s).val = Multiset.ndinsert a s.val

ink

theorem Finset.insert_val' {α : Type u_1} [inst : DecidableEq α] (a : α) (s : Finset α) : (insert a s).val = Multiset.dedup (a ::ₘ s.val)

ink

theorem Finset.insert_val_of_not_mem {α : Type u_1} [inst : DecidableEq α] {a : α} {s : Finset α} (h : ¬a ∈ s) : (insert a s).val = a ::ₘ s.val

ink

@[simp]

theorem Finset.mem_insert {α : Type u_1} [inst : DecidableEq α] {s : Finset α} {a : α} {b : α} : a ∈ insert b s ↔ a = b ∨ a ∈ s

ink

theorem Finset.mem_insert_self {α : Type u_1} [inst : DecidableEq α] (a : α) (s : Finset α) : a ∈ insert a s

ink

theorem Finset.mem_insert_of_mem {α : Type u_1} [inst : DecidableEq α] {s : Finset α} {a : α} {b : α} (h : a ∈ s) : a ∈ insert b s

ink

theorem Finset.mem_of_mem_insert_of_ne {α : Type u_1} [inst : DecidableEq α] {s : Finset α} {a : α} {b : α} (h : b ∈ insert a s) : b ≠ a → b ∈ s

ink

theorem Finset.eq_of_not_mem_of_mem_insert {α : Type u_1} [inst : DecidableEq α] {s : Finset α} {a : α} {b : α} (ha : b ∈ insert a s) (hb : ¬b ∈ s) : b = a

ink

@[simp]

theorem Finset.cons_eq_insert {α : Type u_1} [inst : DecidableEq α] (a : α) (s : Finset α) (h : ¬a ∈ s) : Finset.cons a s h = insert a s

ink

@[simp]

theorem Finset.coe_insert {α : Type u_1} [inst : DecidableEq α] (a : α) (s : Finset α) : ↑(insert a s) = insert a ↑s

ink

theorem Finset.mem_insert_coe {α : Type u_1} [inst : DecidableEq α] {s : Finset α} {x : α} {y : α} : x ∈ insert y s ↔ x ∈ insert y ↑s

ink

instance Finset.instIsLawfulSingletonFinsetInstEmptyCollectionFinsetInstInsertFinsetInstSingletonFinset {α : Type u_1} [inst : DecidableEq α] : IsLawfulSingleton α (Finset α)

Equations

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

ink

@[simp]

theorem Finset.insert_eq_of_mem {α : Type u_1} [inst : DecidableEq α] {s : Finset α} {a : α} (h : a ∈ s) : insert a s = s

ink

@[simp]

theorem Finset.insert_eq_self {α : Type u_1} [inst : DecidableEq α] {s : Finset α} {a : α} : insert a s = s ↔ a ∈ s

ink

theorem Finset.insert_ne_self {α : Type u_1} [inst : DecidableEq α] {s : Finset α} {a : α} : insert a s ≠ s ↔ ¬a ∈ s

ink

theorem Finset.pair_eq_singleton {α : Type u_1} [inst : DecidableEq α] (a : α) : {a, a} = {a}

ink

theorem Finset.Insert.comm {α : Type u_1} [inst : DecidableEq α] (a : α) (b : α) (s : Finset α) : insert a (insert b s) = insert b (insert a s)

ink

theorem Finset.coe_pair {α : Type u_1} [inst : DecidableEq α] {a : α} {b : α} : ↑{a, b} = {a, b}

ink

@[simp]

theorem Finset.coe_eq_pair {α : Type u_1} [inst : DecidableEq α] {s : Finset α} {a : α} {b : α} : ↑s = {a, b} ↔ s = {a, b}

ink

theorem Finset.pair_comm {α : Type u_1} [inst : DecidableEq α] (a : α) (b : α) : {a, b} = {b, a}

ink

theorem Finset.insert_idem {α : Type u_1} [inst : DecidableEq α] (a : α) (s : Finset α) : insert a (insert a s) = insert a s

ink

@[simp]

theorem Finset.insert_nonempty {α : Type u_1} [inst : DecidableEq α] (a : α) (s : Finset α) : Finset.Nonempty (insert a s)

ink

@[simp]

theorem Finset.insert_ne_empty {α : Type u_1} [inst : DecidableEq α] (a : α) (s : Finset α) : insert a s ≠ ∅

ink

instance Finset.instNonemptyElemToSetInsertFinsetInstInsertFinset {α : Type u_1} [inst : DecidableEq α] (i : α) (s : Finset α) : Nonempty ↑↑(insert i s)

Equations

• @Finset.instNonemptyElemToSetInsertFinsetInstInsertFinset = @Finset.instNonemptyElemToSetInsertFinsetInstInsertFinset.proof_1

ink

theorem Finset.ne_insert_of_not_mem {α : Type u_1} [inst : DecidableEq α] (s : Finset α) (t : Finset α) {a : α} (h : ¬a ∈ s) : s ≠ insert a t

ink

theorem Finset.insert_subset {α : Type u_1} [inst : DecidableEq α] {s : Finset α} {t : Finset α} {a : α} : insert a s ⊆ t ↔ a ∈ t ∧ s ⊆ t

ink

theorem Finset.subset_insert {α : Type u_1} [inst : DecidableEq α] (a : α) (s : Finset α) : s ⊆ insert a s

ink

theorem Finset.insert_subset_insert {α : Type u_1} [inst : DecidableEq α] (a : α) {s : Finset α} {t : Finset α} (h : s ⊆ t) : insert a s ⊆ insert a t

ink

theorem Finset.insert_inj {α : Type u_1} [inst : DecidableEq α] {s : Finset α} {a : α} {b : α} (ha : ¬a ∈ s) : insert a s = insert b s ↔ a = b

ink

theorem Finset.insert_inj_on {α : Type u_1} [inst : DecidableEq α] (s : Finset α) : Set.InjOn (fun a => insert a s) (↑sᶜ)

ink

theorem Finset.ssubset_iff {α : Type u_1} [inst : DecidableEq α] {s : Finset α} {t : Finset α} : s ⊂ t ↔ ∃ a x, insert a s ⊆ t

ink

theorem Finset.ssubset_insert {α : Type u_1} [inst : DecidableEq α] {s : Finset α} {a : α} (h : ¬a ∈ s) : s ⊂ insert a s

ink

theorem Finset.cons_induction {α : Type u_1} {p : Finset α → Prop} (h₁ : p ∅) (h₂ : ⦃a : α⦄ → {s : Finset α} → (h : ¬a ∈ s) → p s → p (Finset.cons a s h)) (s : Finset α) : p s

ink

theorem Finset.cons_induction_on {α : Type u_1} {p : Finset α → Prop} (s : Finset α) (h₁ : p ∅) (h₂ : ⦃a : α⦄ → {s : Finset α} → (h : ¬a ∈ s) → p s → p (Finset.cons a s h)) : p s

ink

theorem Finset.induction {α : Type u_1} {p : Finset α → Prop} [inst : DecidableEq α] (h₁ : p ∅) (h₂ : ⦃a : α⦄ → {s : Finset α} → ¬a ∈ s → p s → p (insert a s)) (s : Finset α) : p s

ink

theorem Finset.induction_on {α : Type u_1} {p : Finset α → Prop} [inst : DecidableEq α] (s : Finset α) (empty : p ∅) (insert : ⦃a : α⦄ → {s : Finset α} → ¬a ∈ s → p s → p (insert a s)) : p s

To prove a proposition about an arbitrary Finset α, it suffices to prove it for the empty Finset, and to show that if it holds for some Finset α, then it holds for the Finset obtained by inserting a new element.

ink

theorem Finset.induction_on' {α : Type u_1} {p : Finset α → Prop} [inst : DecidableEq α] (S : Finset α) (h₁ : p ∅) (h₂ : {a : α} → {s : Finset α} → a ∈ S → s ⊆ S → ¬a ∈ s → p s → p (insert a s)) : p S

To prove a proposition about S : Finset α, it suffices to prove it for the empty Finset, and to show that if it holds for some Finset α ⊆ S⊆ S, then it holds for the Finset obtained by inserting a new element of S.

ink

theorem Finset.Nonempty.cons_induction {α : Type u_1} {p : (s : Finset α) → Finset.Nonempty s → Prop} (h₀ : (a : α) → p {a} (_ : Finset.Nonempty {a})) (h₁ : ⦃a : α⦄ → (s : Finset α) → (h : ¬a ∈ s) → (hs : Finset.Nonempty s) → p s hs → p (Finset.cons a s h) (_ : Finset.Nonempty (Finset.cons a s h))) {s : Finset α} (hs : Finset.Nonempty s) : p s hs

To prove a proposition about a nonempty s : Finset α, it suffices to show it holds for all singletons and that if it holds for nonempty t : Finset α, then it also holds for the Finset obtained by inserting an element in t.

ink

def Finset.subtypeInsertEquivOption {α : Type u_1} [inst : DecidableEq α] {t : Finset α} {x : α} (h : ¬x ∈ t) : { i // i ∈ insert x t } ≃ Option { i // i ∈ t }

Inserting an element to a finite set is equivalent to the option type.

Equations

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

ink

@[simp]

theorem Finset.disjoint_insert_left {α : Type u_1} [inst : DecidableEq α] {s : Finset α} {t : Finset α} {a : α} : Disjoint (insert a s) t ↔ ¬a ∈ t ∧ Disjoint s t

ink

@[simp]

theorem Finset.disjoint_insert_right {α : Type u_1} [inst : DecidableEq α] {s : Finset α} {t : Finset α} {a : α} : Disjoint s (insert a t) ↔ ¬a ∈ s ∧ Disjoint s t

Lattice structure

ink

instance Finset.instUnionFinset {α : Type u_1} [inst : DecidableEq α] : Union (Finset α)

s ∪ t∪ t is the set such that a ∈ s ∪ t∈ s ∪ t∪ t iff a ∈ s∈ s or a ∈ t∈ t.

Equations

• Finset.instUnionFinset = { union := fun s t => { val := Multiset.ndunion s.val t.val, nodup := (_ : Multiset.Nodup (Multiset.ndunion s.val t.val)) } }

ink

instance Finset.instInterFinset {α : Type u_1} [inst : DecidableEq α] : Inter (Finset α)

s ∩ t∩ t is the set such that a ∈ s ∩ t∈ s ∩ t∩ t iff a ∈ s∈ s and a ∈ t∈ t.

Equations

• Finset.instInterFinset = { inter := fun s t => { val := Multiset.ndinter s.val t.val, nodup := (_ : Multiset.Nodup (Multiset.ndinter s.val t.val)) } }

ink

instance Finset.instLatticeFinset {α : Type u_1} [inst : DecidableEq α] : Lattice (Finset α)

Equations

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

ink

@[simp]

theorem Finset.sup_eq_union {α : Type u_1} [inst : DecidableEq α] : Sup.sup = Union.union

ink

@[simp]

theorem Finset.inf_eq_inter {α : Type u_1} [inst : DecidableEq α] : Inf.inf = Inter.inter

ink

theorem Finset.disjoint_iff_inter_eq_empty {α : Type u_1} [inst : DecidableEq α] {s : Finset α} {t : Finset α} : Disjoint s t ↔ s ∩ t = ∅

ink

instance Finset.decidableDisjoint {α : Type u_1} [inst : DecidableEq α] (U : Finset α) (V : Finset α) : Decidable (Disjoint U V)

Equations

• Finset.decidableDisjoint U V = decidable_of_iff (∀ ⦃a : α⦄, a ∈ U → ¬a ∈ V) (_ : (∀ ⦃a : α⦄, a ∈ U → ¬a ∈ V) ↔ Disjoint U V)

union

ink

theorem Finset.union_val_nd {α : Type u_1} [inst : DecidableEq α] (s : Finset α) (t : Finset α) : (s ∪ t).val = Multiset.ndunion s.val t.val

ink

@[simp]

theorem Finset.union_val {α : Type u_1} [inst : DecidableEq α] (s : Finset α) (t : Finset α) : (s ∪ t).val = s.val ∪ t.val

ink

@[simp]

theorem Finset.mem_union {α : Type u_1} [inst : DecidableEq α] {s : Finset α} {t : Finset α} {a : α} : a ∈ s ∪ t ↔ a ∈ s ∨ a ∈ t

ink

@[simp]

theorem Finset.disjUnion_eq_union {α : Type u_1} [inst : DecidableEq α] (s : Finset α) (t : Finset α) (h : Disjoint s t) : Finset.disjUnion s t h = s ∪ t

ink

theorem Finset.mem_union_left {α : Type u_1} [inst : DecidableEq α] {s : Finset α} {a : α} (t : Finset α) (h : a ∈ s) : a ∈ s ∪ t

ink

theorem Finset.mem_union_right {α : Type u_1} [inst : DecidableEq α] {t : Finset α} {a : α} (s : Finset α) (h : a ∈ t) : a ∈ s ∪ t

ink

theorem Finset.forall_mem_union {α : Type u_1} [inst : DecidableEq α] {s : Finset α} {t : Finset α} {p : α → Prop} : ((a : α) → a ∈ s ∪ t → p a) ↔ ((a : α) → a ∈ s → p a) ∧ ((a : α) → a ∈ t → p a)

ink

theorem Finset.not_mem_union {α : Type u_1} [inst : DecidableEq α] {s : Finset α} {t : Finset α} {a : α} : ¬a ∈ s ∪ t ↔ ¬a ∈ s ∧ ¬a ∈ t

ink

@[simp]

theorem Finset.coe_union {α : Type u_1} [inst : DecidableEq α] (s₁ : Finset α) (s₂ : Finset α) : ↑(s₁ ∪ s₂) = ↑s₁ ∪ ↑s₂

ink

theorem Finset.union_subset {α : Type u_1} [inst : DecidableEq α] {s : Finset α} {t : Finset α} {u : Finset α} (hs : s ⊆ u) : t ⊆ u → s ∪ t ⊆ u

ink

theorem Finset.subset_union_left {α : Type u_1} [inst : DecidableEq α] (s₁ : Finset α) (s₂ : Finset α) : s₁ ⊆ s₁ ∪ s₂

ink

theorem Finset.subset_union_right {α : Type u_1} [inst : DecidableEq α] (s₁ : Finset α) (s₂ : Finset α) : s₂ ⊆ s₁ ∪ s₂

ink

theorem Finset.union_subset_union {α : Type u_1} [inst : DecidableEq α] {s : Finset α} {t : Finset α} {u : Finset α} {v : Finset α} (hsu : s ⊆ u) (htv : t ⊆ v) : s ∪ t ⊆ u ∪ v

ink

theorem Finset.union_comm {α : Type u_1} [inst : DecidableEq α] (s₁ : Finset α) (s₂ : Finset α) : s₁ ∪ s₂ = s₂ ∪ s₁

ink

instance Finset.instIsCommutativeFinsetUnionInstUnionFinset {α : Type u_1} [inst : DecidableEq α] : IsCommutative (Finset α) fun x x_1 => x ∪ x_1

Equations

• @Finset.instIsCommutativeFinsetUnionInstUnionFinset = @Finset.instIsCommutativeFinsetUnionInstUnionFinset.proof_1

ink

@[simp]

theorem Finset.union_assoc {α : Type u_1} [inst : DecidableEq α] (s₁ : Finset α) (s₂ : Finset α) (s₃ : Finset α) : s₁ ∪ s₂ ∪ s₃ = s₁ ∪ (s₂ ∪ s₃)

ink

instance Finset.instIsAssociativeFinsetUnionInstUnionFinset {α : Type u_1} [inst : DecidableEq α] : IsAssociative (Finset α) fun x x_1 => x ∪ x_1

Equations

• @Finset.instIsAssociativeFinsetUnionInstUnionFinset = @Finset.instIsAssociativeFinsetUnionInstUnionFinset.proof_1

ink

@[simp]

theorem Finset.union_idempotent {α : Type u_1} [inst : DecidableEq α] (s : Finset α) : s ∪ s = s

ink

instance Finset.instIsIdempotentFinsetUnionInstUnionFinset {α : Type u_1} [inst : DecidableEq α] : IsIdempotent (Finset α) fun x x_1 => x ∪ x_1

Equations

• @Finset.instIsIdempotentFinsetUnionInstUnionFinset = @Finset.instIsIdempotentFinsetUnionInstUnionFinset.proof_1

ink

theorem Finset.union_subset_left {α : Type u_1} [inst : DecidableEq α] {s : Finset α} {t : Finset α} {u : Finset α} (h : s ∪ t ⊆ u) : s ⊆ u

ink

theorem Finset.union_subset_right {α : Type u_1} [inst : DecidableEq α] {s : Finset α} {t : Finset α} {u : Finset α} (h : s ∪ t ⊆ u) : t ⊆ u

ink

theorem Finset.union_left_comm {α : Type u_1} [inst : DecidableEq α] (s : Finset α) (t : Finset α) (u : Finset α) : s ∪ (t ∪ u) = t ∪ (s ∪ u)

ink

theorem Finset.union_right_comm {α : Type u_1} [inst : DecidableEq α] (s : Finset α) (t : Finset α) (u : Finset α) : s ∪ t ∪ u = s ∪ u ∪ t

ink

theorem Finset.union_self {α : Type u_1} [inst : DecidableEq α] (s : Finset α) : s ∪ s = s

ink

@[simp]

theorem Finset.union_empty {α : Type u_1} [inst : DecidableEq α] (s : Finset α) : s ∪ ∅ = s

ink

@[simp]

theorem Finset.empty_union {α : Type u_1} [inst : DecidableEq α] (s : Finset α) : ∅ ∪ s = s

ink

theorem Finset.insert_eq {α : Type u_1} [inst : DecidableEq α] (a : α) (s : Finset α) : insert a s = {a} ∪ s

ink

@[simp]

theorem Finset.insert_union {α : Type u_1} [inst : DecidableEq α] (a : α) (s : Finset α) (t : Finset α) : insert a s ∪ t = insert a (s ∪ t)

ink

@[simp]

theorem Finset.union_insert {α : Type u_1} [inst : DecidableEq α] (a : α) (s : Finset α) (t : Finset α) : s ∪ insert a t = insert a (s ∪ t)

ink

theorem Finset.insert_union_distrib {α : Type u_1} [inst : DecidableEq α] (a : α) (s : Finset α) (t : Finset α) : insert a (s ∪ t) = insert a s ∪ insert a t

ink

@[simp]

theorem Finset.union_eq_left_iff_subset {α : Type u_1} [inst : DecidableEq α] {s : Finset α} {t : Finset α} : s ∪ t = s ↔ t ⊆ s

ink

@[simp]

theorem Finset.left_eq_union_iff_subset {α : Type u_1} [inst : DecidableEq α] {s : Finset α} {t : Finset α} : s = s ∪ t ↔ t ⊆ s

ink

@[simp]

theorem Finset.union_eq_right_iff_subset {α : Type u_1} [inst : DecidableEq α] {s : Finset α} {t : Finset α} : s ∪ t = t ↔ s ⊆ t

ink

@[simp]

theorem Finset.right_eq_union_iff_subset {α : Type u_1} [inst : DecidableEq α] {s : Finset α} {t : Finset α} : s = t ∪ s ↔ t ⊆ s

ink

theorem Finset.union_congr_left {α : Type u_1} [inst : DecidableEq α] {s : Finset α} {t : Finset α} {u : Finset α} (ht : t ⊆ s ∪ u) (hu : u ⊆ s ∪ t) : s ∪ t = s ⊔ u

ink

theorem Finset.union_congr_right {α : Type u_1} [inst : DecidableEq α] {s : Finset α} {t : Finset α} {u : Finset α} (hs : s ⊆ t ∪ u) (ht : t ⊆ s ∪ u) : s ∪ u = t ∪ u

ink

theorem Finset.union_eq_union_iff_left {α : Type u_1} [inst : DecidableEq α] {s : Finset α} {t : Finset α} {u : Finset α} : s ∪ t = s ∪ u ↔ t ⊆ s ∪ u ∧ u ⊆ s ∪ t

ink

theorem Finset.union_eq_union_iff_right {α : Type u_1} [inst : DecidableEq α] {s : Finset α} {t : Finset α} {u : Finset α} : s ∪ u = t ∪ u ↔ s ⊆ t ∪ u ∧ t ⊆ s ∪ u

ink

@[simp]

theorem Finset.disjoint_union_left {α : Type u_1} [inst : DecidableEq α] {s : Finset α} {t : Finset α} {u : Finset α} : Disjoint (s ∪ t) u ↔ Disjoint s u ∧ Disjoint t u

ink

@[simp]

theorem Finset.disjoint_union_right {α : Type u_1} [inst : DecidableEq α] {s : Finset α} {t : Finset α} {u : Finset α} : Disjoint s (t ∪ u) ↔ Disjoint s t ∧ Disjoint s u

ink

theorem Finset.induction_on_union {α : Type u_1} [inst : DecidableEq α] (P : Finset α → Finset α → Prop) (symm : {a b : Finset α} → P a b → P b a) (empty_right : {a : Finset α} → P a ∅) (singletons : {a b : α} → P {a} {b}) (union_of : {a b c : Finset α} → P a c → P b c → P (a ∪ b) c) (a : Finset α) (b : Finset α) : P a b

To prove a relation on pairs of Finset X, it suffices to show that it is

• symmetric,
• it holds when one of the Finsets is empty,
• it holds for pairs of singletons,
• if it holds for [a, c] and for [b, c], then it holds for [a ∪ b, c]∪ b, c].

ink

theorem Directed.exists_mem_subset_of_finset_subset_bunionᵢ {α : Type u_1} {ι : Type u_2} [hn : Nonempty ι] {f : ι → Set α} (h : Directed (fun x x_1 => x ⊆ x_1) f) {s : Finset α} (hs : ↑s ⊆ Set.unionᵢ fun i => f i) : ∃ i, ↑s ⊆ f i

ink

theorem DirectedOn.exists_mem_subset_of_finset_subset_bunionᵢ {α : Type u_1} {ι : Type u_2} {f : ι → Set α} {c : Set ι} (hn : Set.Nonempty c) (hc : DirectedOn (fun i j => f i ⊆ f j) c) {s : Finset α} (hs : ↑s ⊆ Set.unionᵢ fun i => Set.unionᵢ fun h => f i) : ∃ i, i ∈ c ∧ ↑s ⊆ f i

inter

ink

theorem Finset.inter_val_nd {α : Type u_1} [inst : DecidableEq α] (s₁ : Finset α) (s₂ : Finset α) : (s₁ ∩ s₂).val = Multiset.ndinter s₁.val s₂.val

ink

@[simp]

theorem Finset.inter_val {α : Type u_1} [inst : DecidableEq α] (s₁ : Finset α) (s₂ : Finset α) : (s₁ ∩ s₂).val = s₁.val ∩ s₂.val

ink

@[simp]

theorem Finset.mem_inter {α : Type u_1} [inst : DecidableEq α] {a : α} {s₁ : Finset α} {s₂ : Finset α} : a ∈ s₁ ∩ s₂ ↔ a ∈ s₁ ∧ a ∈ s₂

ink

theorem Finset.mem_of_mem_inter_left {α : Type u_1} [inst : DecidableEq α] {a : α} {s₁ : Finset α} {s₂ : Finset α} (h : a ∈ s₁ ∩ s₂) : a ∈ s₁

ink

theorem Finset.mem_of_mem_inter_right {α : Type u_1} [inst : DecidableEq α] {a : α} {s₁ : Finset α} {s₂ : Finset α} (h : a ∈ s₁ ∩ s₂) : a ∈ s₂

ink

theorem Finset.mem_inter_of_mem {α : Type u_1} [inst : DecidableEq α] {a : α} {s₁ : Finset α} {s₂ : Finset α} : a ∈ s₁ → a ∈ s₂ → a ∈ s₁ ∩ s₂

ink

theorem Finset.inter_subset_left {α : Type u_1} [inst : DecidableEq α] (s₁ : Finset α) (s₂ : Finset α) : s₁ ∩ s₂ ⊆ s₁

ink

theorem Finset.inter_subset_right {α : Type u_1} [inst : DecidableEq α] (s₁ : Finset α) (s₂ : Finset α) : s₁ ∩ s₂ ⊆ s₂

ink

theorem Finset.subset_inter {α : Type u_1} [inst : DecidableEq α] {s₁ : Finset α} {s₂ : Finset α} {u : Finset α} : s₁ ⊆ s₂ → s₁ ⊆ u → s₁ ⊆ s₂ ∩ u

ink

@[simp]

theorem Finset.coe_inter {α : Type u_1} [inst : DecidableEq α] (s₁ : Finset α) (s₂ : Finset α) : ↑(s₁ ∩ s₂) = ↑s₁ ∩ ↑s₂

ink

@[simp]

theorem Finset.union_inter_cancel_left {α : Type u_1} [inst : DecidableEq α] {s : Finset α} {t : Finset α} : (s ∪ t) ∩ s = s

ink

@[simp]

theorem Finset.union_inter_cancel_right {α : Type u_1} [inst : DecidableEq α] {s : Finset α} {t : Finset α} : (s ∪ t) ∩ t = t

ink

theorem Finset.inter_comm {α : Type u_1} [inst : DecidableEq α] (s₁ : Finset α) (s₂ : Finset α) : s₁ ∩ s₂ = s₂ ∩ s₁

ink

@[simp]

theorem Finset.inter_assoc {α : Type u_1} [inst : DecidableEq α] (s₁ : Finset α) (s₂ : Finset α) (s₃ : Finset α) : s₁ ∩ s₂ ∩ s₃ = s₁ ∩ (s₂ ∩ s₃)

ink

theorem Finset.inter_left_comm {α : Type u_1} [inst : DecidableEq α] (s₁ : Finset α) (s₂ : Finset α) (s₃ : Finset α) : s₁ ∩ (s₂ ∩ s₃) = s₂ ∩ (s₁ ∩ s₃)

ink

theorem Finset.inter_right_comm {α : Type u_1} [inst : DecidableEq α] (s₁ : Finset α) (s₂ : Finset α) (s₃ : Finset α) : s₁ ∩ s₂ ∩ s₃ = s₁ ∩ s₃ ∩ s₂

ink

@[simp]

theorem Finset.inter_self {α : Type u_1} [inst : DecidableEq α] (s : Finset α) : s ∩ s = s

ink

@[simp]

theorem Finset.inter_empty {α : Type u_1} [inst : DecidableEq α] (s : Finset α) : s ∩ ∅ = ∅

ink

@[simp]

theorem Finset.empty_inter {α : Type u_1} [inst : DecidableEq α] (s : Finset α) : ∅ ∩ s = ∅

ink

@[simp]

theorem Finset.inter_union_self {α : Type u_1} [inst : DecidableEq α] (s : Finset α) (t : Finset α) : s ∩ (t ∪ s) = s

ink

@[simp]

theorem Finset.insert_inter_of_mem {α : Type u_1} [inst : DecidableEq α] {s₁ : Finset α} {s₂ : Finset α} {a : α} (h : a ∈ s₂) : insert a s₁ ∩ s₂ = insert a (s₁ ∩ s₂)

ink

@[simp]

theorem Finset.inter_insert_of_mem {α : Type u_1} [inst : DecidableEq α] {s₁ : Finset α} {s₂ : Finset α} {a : α} (h : a ∈ s₁) : s₁ ∩ insert a s₂ = insert a (s₁ ∩ s₂)

ink

@[simp]

theorem Finset.insert_inter_of_not_mem {α : Type u_1} [inst : DecidableEq α] {s₁ : Finset α} {s₂ : Finset α} {a : α} (h : ¬a ∈ s₂) : insert a s₁ ∩ s₂ = s₁ ∩ s₂

ink

@[simp]

theorem Finset.inter_insert_of_not_mem {α : Type u_1} [inst : DecidableEq α] {s₁ : Finset α} {s₂ : Finset α} {a : α} (h : ¬a ∈ s₁) : s₁ ∩ insert a s₂ = s₁ ∩ s₂

ink

@[simp]

theorem Finset.singleton_inter_of_mem {α : Type u_1} [inst : DecidableEq α] {a : α} {s : Finset α} (H : a ∈ s) : {a} ∩ s = {a}

ink

@[simp]

theorem Finset.singleton_inter_of_not_mem {α : Type u_1} [inst : DecidableEq α] {a : α} {s : Finset α} (H : ¬a ∈ s) : {a} ∩ s = ∅

ink

@[simp]

theorem Finset.inter_singleton_of_mem {α : Type u_1} [inst : DecidableEq α] {a : α} {s : Finset α} (h : a ∈ s) : s ∩ {a} = {a}

ink

@[simp]

theorem Finset.inter_singleton_of_not_mem {α : Type u_1} [inst : DecidableEq α] {a : α} {s : Finset α} (h : ¬a ∈ s) : s ∩ {a} = ∅

ink

theorem Finset.inter_subset_inter {α : Type u_1} [inst : DecidableEq α] {x : Finset α} {y : Finset α} {s : Finset α} {t : Finset α} (h : x ⊆ y) (h' : s ⊆ t) : x ∩ s ⊆ y ∩ t

ink

theorem Finset.inter_subset_inter_left {α : Type u_1} [inst : DecidableEq α] {s : Finset α} {t : Finset α} {u : Finset α} (h : t ⊆ u) : s ∩ t ⊆ s ∩ u

ink

theorem Finset.inter_subset_inter_right {α : Type u_1} [inst : DecidableEq α] {s : Finset α} {t : Finset α} {u : Finset α} (h : s ⊆ t) : s ∩ u ⊆ t ∩ u

ink

theorem Finset.inter_subset_union {α : Type u_1} [inst : DecidableEq α] {s : Finset α} {t : Finset α} : s ∩ t ⊆ s ∪ t

ink

instance Finset.instDistribLatticeFinset {α : Type u_1} [inst : DecidableEq α] : DistribLattice (Finset α)

Equations

• Finset.instDistribLatticeFinset = DistribLattice.mk (_ : ∀ (a b c : Finset α), (a ∪ b) ∩ (a ∪ c) ⊆ a ∪ b ∩ c)

ink

@[simp]

theorem Finset.union_left_idem {α : Type u_1} [inst : DecidableEq α] (s : Finset α) (t : Finset α) : s ∪ (s ∪ t) = s ∪ t

ink

theorem Finset.union_right_idem {α : Type u_1} [inst : DecidableEq α] (s : Finset α) (t : Finset α) : s ∪ t ∪ t = s ∪ t

ink

@[simp]

theorem Finset.inter_left_idem {α : Type u_1} [inst : DecidableEq α] (s : Finset α) (t : Finset α) : s ∩ (s ∩ t) = s ∩ t

ink

theorem Finset.inter_right_idem {α : Type u_1} [inst : DecidableEq α] (s : Finset α) (t : Finset α) : s ∩ t ∩ t = s ∩ t

ink

theorem Finset.inter_distrib_left {α : Type u_1} [inst : DecidableEq α] (s : Finset α) (t : Finset α) (u : Finset α) : s ∩ (t ∪ u) = s ∩ t ∪ s ∩ u

ink

theorem Finset.inter_distrib_right {α : Type u_1} [inst : DecidableEq α] (s : Finset α) (t : Finset α) (u : Finset α) : (s ∪ t) ∩ u = s ∩ u ∪ t ∩ u

ink

theorem Finset.union_distrib_left {α : Type u_1} [inst : DecidableEq α] (s : Finset α) (t : Finset α) (u : Finset α) : s ∪ t ∩ u = (s ∪ t) ∩ (s ∪ u)

ink

theorem Finset.union_distrib_right {α : Type u_1} [inst : DecidableEq α] (s : Finset α) (t : Finset α) (u : Finset α) : s ∩ t ∪ u = (s ∪ u) ∩ (t ∪ u)

ink

theorem Finset.union_union_distrib_left {α : Type u_1} [inst : DecidableEq α] (s : Finset α) (t : Finset α) (u : Finset α) : s ∪ (t ∪ u) = s ∪ t ∪ (s ∪ u)

ink

theorem Finset.union_union_distrib_right {α : Type u_1} [inst : DecidableEq α] (s : Finset α) (t : Finset α) (u : Finset α) : s ∪ t ∪ u = s ∪ u ∪ (t ∪ u)

ink

theorem Finset.inter_inter_distrib_left {α : Type u_1} [inst : DecidableEq α] (s : Finset α) (t : Finset α) (u : Finset α) : s ∩ (t ∩ u) = s ∩ t ∩ (s ∩ u)

ink

theorem Finset.inter_inter_distrib_right {α : Type u_1} [inst : DecidableEq α] (s : Finset α) (t : Finset α) (u : Finset α) : s ∩ t ∩ u = s ∩ u ∩ (t ∩ u)

ink

theorem Finset.union_union_union_comm {α : Type u_1} [inst : DecidableEq α] (s : Finset α) (t : Finset α) (u : Finset α) (v : Finset α) : s ∪ t ∪ (u ∪ v) = s ∪ u ∪ (t ∪ v)

ink

theorem Finset.inter_inter_inter_comm {α : Type u_1} [inst : DecidableEq α] (s : Finset α) (t : Finset α) (u : Finset α) (v : Finset α) : s ∩ t ∩ (u ∩ v) = s ∩ u ∩ (t ∩ v)

ink

theorem Finset.union_eq_empty_iff {α : Type u_1} [inst : DecidableEq α] (A : Finset α) (B : Finset α) : A ∪ B = ∅ ↔ A = ∅ ∧ B = ∅

ink

theorem Finset.union_subset_iff {α : Type u_1} [inst : DecidableEq α] {s : Finset α} {t : Finset α} {u : Finset α} : s ∪ t ⊆ u ↔ s ⊆ u ∧ t ⊆ u

ink

theorem Finset.subset_inter_iff {α : Type u_1} [inst : DecidableEq α] {s : Finset α} {t : Finset α} {u : Finset α} : s ⊆ t ∩ u ↔ s ⊆ t ∧ s ⊆ u

ink

@[simp]

theorem Finset.inter_eq_left_iff_subset {α : Type u_1} [inst : DecidableEq α] (s : Finset α) (t : Finset α) : s ∩ t = s ↔ s ⊆ t

ink

@[simp]

theorem Finset.inter_eq_right_iff_subset {α : Type u_1} [inst : DecidableEq α] (s : Finset α) (t : Finset α) : t ∩ s = s ↔ s ⊆ t

ink

theorem Finset.inter_congr_left {α : Type u_1} [inst : DecidableEq α] {s : Finset α} {t : Finset α} {u : Finset α} (ht : s ∩ u ⊆ t) (hu : s ∩ t ⊆ u) : s ∩ t = s ∩ u

ink

theorem Finset.inter_congr_right {α : Type u_1} [inst : DecidableEq α] {s : Finset α} {t : Finset α} {u : Finset α} (hs : t ∩ u ⊆ s) (ht : s ∩ u ⊆ t) : s ∩ u = t ∩ u

ink

theorem Finset.inter_eq_inter_iff_left {α : Type u_1} [inst : DecidableEq α] {s : Finset α} {t : Finset α} {u : Finset α} : s ∩ t = s ∩ u ↔ s ∩ u ⊆ t ∧ s ∩ t ⊆ u

ink

theorem Finset.inter_eq_inter_iff_right {α : Type u_1} [inst : DecidableEq α] {s : Finset α} {t : Finset α} {u : Finset α} : s ∩ u = t ∩ u ↔ t ∩ u ⊆ s ∧ s ∩ u ⊆ t

ink

theorem Finset.ite_subset_union {α : Type u_1} [inst : DecidableEq α] (s : Finset α) (s' : Finset α) (P : Prop) [inst : Decidable P] : (if P then s else s') ⊆ s ∪ s'

ink

theorem Finset.inter_subset_ite {α : Type u_1} [inst : DecidableEq α] (s : Finset α) (s' : Finset α) (P : Prop) [inst : Decidable P] : s ∩ s' ⊆ if P then s else s'

ink

theorem Finset.not_disjoint_iff_nonempty_inter {α : Type u_1} [inst : DecidableEq α] {s : Finset α} {t : Finset α} : ¬Disjoint s t ↔ Finset.Nonempty (s ∩ t)

ink

theorem Finset.Nonempty.not_disjoint {α : Type u_1} [inst : DecidableEq α] {s : Finset α} {t : Finset α} : Finset.Nonempty (s ∩ t) → ¬Disjoint s t

Alias of the reverse direction of Finset.not_disjoint_iff_nonempty_inter.

ink

theorem Finset.disjoint_or_nonempty_inter {α : Type u_1} [inst : DecidableEq α] (s : Finset α) (t : Finset α) : Disjoint s t ∨ Finset.Nonempty (s ∩ t)

erase

ink

def Finset.erase {α : Type u_1} [inst : DecidableEq α] (s : Finset α) (a : α) : Finset α

erase s a is the set s - {a}, that is, the elements of s which are not equal to a.

Equations

• Finset.erase s a = { val := Multiset.erase s.val a, nodup := (_ : Multiset.Nodup (Multiset.erase s.val a)) }

ink

@[simp]

theorem Finset.erase_val {α : Type u_1} [inst : DecidableEq α] (s : Finset α) (a : α) : (Finset.erase s a).val = Multiset.erase s.val a

ink

@[simp]

theorem Finset.mem_erase {α : Type u_1} [inst : DecidableEq α] {a : α} {b : α} {s : Finset α} : a ∈ Finset.erase s b ↔ a ≠ b ∧ a ∈ s

ink

theorem Finset.not_mem_erase {α : Type u_1} [inst : DecidableEq α] (a : α) (s : Finset α) : ¬a ∈ Finset.erase s a

ink

@[simp]

theorem Finset.erase_empty {α : Type u_1} [inst : DecidableEq α] (a : α) : Finset.erase ∅ a = ∅

ink

@[simp]

theorem Finset.erase_singleton {α : Type u_1} [inst : DecidableEq α] (a : α) : Finset.erase {a} a = ∅

ink

theorem Finset.ne_of_mem_erase {α : Type u_1} [inst : DecidableEq α] {s : Finset α} {a : α} {b : α} : b ∈ Finset.erase s a → b ≠ a

ink

theorem Finset.mem_of_mem_erase {α : Type u_1} [inst : DecidableEq α] {s : Finset α} {a : α} {b : α} : b ∈ Finset.erase s a → b ∈ s

ink

theorem Finset.mem_erase_of_ne_of_mem {α : Type u_1} [inst : DecidableEq α] {s : Finset α} {a : α} {b : α} : a ≠ b → a ∈ s → a ∈ Finset.erase s b

ink

theorem Finset.eq_of_mem_of_not_mem_erase {α : Type u_1} [inst : DecidableEq α] {s : Finset α} {a : α} {b : α} (hs : b ∈ s) (hsa : ¬b ∈ Finset.erase s a) : b = a

An element of s that is not an element of erase s a must bea.

ink

@[simp]

theorem Finset.erase_eq_of_not_mem {α : Type u_1} [inst : DecidableEq α] {a : α} {s : Finset α} (h : ¬a ∈ s) : Finset.erase s a = s

ink

@[simp]

theorem Finset.erase_eq_self {α : Type u_1} [inst : DecidableEq α] {s : Finset α} {a : α} : Finset.erase s a = s ↔ ¬a ∈ s

ink

@[simp]

theorem Finset.erase_insert_eq_erase {α : Type u_1} [inst : DecidableEq α] (s : Finset α) (a : α) : Finset.erase (insert a s) a = Finset.erase s a

ink

theorem Finset.erase_insert {α : Type u_1} [inst : DecidableEq α] {a : α} {s : Finset α} (h : ¬a ∈ s) : Finset.erase (insert a s) a = s

ink

theorem Finset.erase_insert_of_ne {α : Type u_1} [inst : DecidableEq α] {a : α} {b : α} {s : Finset α} (h : a ≠ b) : Finset.erase (insert a s) b = insert a (Finset.erase s b)

ink

theorem Finset.erase_cons_of_ne {α : Type u_1} [inst : DecidableEq α] {a : α} {b : α} {s : Finset α} (ha : ¬a ∈ s) (hb : a ≠ b) : Finset.erase (Finset.cons a s ha) b = Finset.cons a (Finset.erase s b) fun h => ha (_ : a ∈ s.val)

ink

theorem Finset.insert_erase {α : Type u_1} [inst : DecidableEq α] {a : α} {s : Finset α} (h : a ∈ s) : insert a (Finset.erase s a) = s

ink

theorem Finset.erase_subset_erase {α : Type u_1} [inst : DecidableEq α] (a : α) {s : Finset α} {t : Finset α} (h : s ⊆ t) : Finset.erase s a ⊆ Finset.erase t a

ink

theorem Finset.erase_subset {α : Type u_1} [inst : DecidableEq α] (a : α) (s : Finset α) : Finset.erase s a ⊆ s

ink

theorem Finset.subset_erase {α : Type u_1} [inst : DecidableEq α] {a : α} {s : Finset α} {t : Finset α} : s ⊆ Finset.erase t a ↔ s ⊆ t ∧ ¬a ∈ s

ink

@[simp]

theorem Finset.coe_erase {α : Type u_1} [inst : DecidableEq α] (a : α) (s : Finset α) : ↑(Finset.erase s a) = ↑s \ {a}

ink

theorem Finset.erase_ssubset {α : Type u_1} [inst : DecidableEq α] {a : α} {s : Finset α} (h : a ∈ s) : Finset.erase s a ⊂ s

ink

theorem Finset.ssubset_iff_exists_subset_erase {α : Type u_1} [inst : DecidableEq α] {s : Finset α} {t : Finset α} : s ⊂ t ↔ ∃ a, a ∈ t ∧ s ⊆ Finset.erase t a

ink

theorem Finset.erase_ssubset_insert {α : Type u_1} [inst : DecidableEq α] (s : Finset α) (a : α) : Finset.erase s a ⊂ insert a s

ink

theorem Finset.erase_ne_self {α : Type u_1} [inst : DecidableEq α] {s : Finset α} {a : α} : Finset.erase s a ≠ s ↔ a ∈ s

ink

theorem Finset.erase_cons {α : Type u_1} [inst : DecidableEq α] {s : Finset α} {a : α} (h : ¬a ∈ s) : Finset.erase (Finset.cons a s h) a = s

ink

theorem Finset.erase_idem {α : Type u_1} [inst : DecidableEq α] {a : α} {s : Finset α} : Finset.erase (Finset.erase s a) a = Finset.erase s a

ink

theorem Finset.erase_right_comm {α : Type u_1} [inst : DecidableEq α] {a : α} {b : α} {s : Finset α} : Finset.erase (Finset.erase s a) b = Finset.erase (Finset.erase s b) a

ink

theorem Finset.subset_insert_iff {α : Type u_1} [inst : DecidableEq α] {a : α} {s : Finset α} {t : Finset α} : s ⊆ insert a t ↔ Finset.erase s a ⊆ t

ink

theorem Finset.erase_insert_subset {α : Type u_1} [inst : DecidableEq α] (a : α) (s : Finset α) : Finset.erase (insert a s) a ⊆ s

ink

theorem Finset.insert_erase_subset {α : Type u_1} [inst : DecidableEq α] (a : α) (s : Finset α) : s ⊆ insert a (Finset.erase s a)

ink

theorem Finset.subset_insert_iff_of_not_mem {α : Type u_1} [inst : DecidableEq α] {s : Finset α} {t : Finset α} {a : α} (h : ¬a ∈ s) : s ⊆ insert a t ↔ s ⊆ t

ink

theorem Finset.erase_subset_iff_of_mem {α : Type u_1} [inst : DecidableEq α] {s : Finset α} {t : Finset α} {a : α} (h : a ∈ t) : Finset.erase s a ⊆ t ↔ s ⊆ t

ink

theorem Finset.erase_inj {α : Type u_1} [inst : DecidableEq α] {x : α} {y : α} (s : Finset α) (hx : x ∈ s) : Finset.erase s x = Finset.erase s y ↔ x = y

ink

theorem Finset.erase_injOn {α : Type u_1} [inst : DecidableEq α] (s : Finset α) : Set.InjOn (Finset.erase s) ↑s

ink

theorem Finset.erase_injOn' {α : Type u_1} [inst : DecidableEq α] (a : α) : Set.InjOn (fun s => Finset.erase s a) { s | a ∈ s }

sdiff

ink

instance Finset.instSDiffFinset {α : Type u_1} [inst : DecidableEq α] : SDiff (Finset α)

s \ t is the set consisting of the elements of s that are not in t.

Equations

• Finset.instSDiffFinset = { sdiff := fun s₁ s₂ => { val := s₁.val - s₂.val, nodup := (_ : Multiset.Nodup (s₁.val - s₂.val)) } }

ink

@[simp]

theorem Finset.sdiff_val {α : Type u_1} [inst : DecidableEq α] (s₁ : Finset α) (s₂ : Finset α) : (s₁ \ s₂).val = s₁.val - s₂.val

ink

@[simp]

theorem Finset.mem_sdiff {α : Type u_1} [inst : DecidableEq α] {s : Finset α} {t : Finset α} {a : α} : a ∈ s \ t ↔ a ∈ s ∧ ¬a ∈ t

ink

@[simp]

theorem Finset.inter_sdiff_self {α : Type u_1} [inst : DecidableEq α] (s₁ : Finset α) (s₂ : Finset α) : s₁ ∩ (s₂ \ s₁) = ∅

ink

instance Finset.instGeneralizedBooleanAlgebraFinset {α : Type u_1} [inst : DecidableEq α] : GeneralizedBooleanAlgebra (Finset α)

Equations

• Finset.instGeneralizedBooleanAlgebraFinset = GeneralizedBooleanAlgebra.mk (_ : ∀ (x y : Finset α), x ∩ y ∪ x \ y = x) (_ : ∀ (x y : Finset α), x ∩ y ∩ (x \ y) = ∅)

ink

theorem Finset.not_mem_sdiff_of_mem_right {α : Type u_1} [inst : DecidableEq α] {s : Finset α} {t : Finset α} {a : α} (h : a ∈ t) : ¬a ∈ s \ t

ink

theorem Finset.not_mem_sdiff_of_not_mem_left {α : Type u_1} [inst : DecidableEq α] {s : Finset α} {t : Finset α} {a : α} (h : ¬a ∈ s) : ¬a ∈ s \ t

ink

theorem Finset.union_sdiff_of_subset {α : Type u_1} [inst : DecidableEq α] {s : Finset α} {t : Finset α} (h : s ⊆ t) : s ∪ t \ s = t

ink

theorem Finset.sdiff_union_of_subset {α : Type u_1} [inst : DecidableEq α] {s₁ : Finset α} {s₂ : Finset α} (h : s₁ ⊆ s₂) : s₂ \ s₁ ∪ s₁ = s₂

ink

theorem Finset.inter_sdiff {α : Type u_1} [inst : DecidableEq α] (s : Finset α) (t : Finset α) (u : Finset α) : s ∩ (t \ u) = (s ∩ t) \ u

ink

@[simp]

theorem Finset.sdiff_inter_self {α : Type u_1} [inst : DecidableEq α] (s₁ : Finset α) (s₂ : Finset α) : s₂ \ s₁ ∩ s₁ = ∅

ink

theorem Finset.sdiff_self {α : Type u_1} [inst : DecidableEq α] (s₁ : Finset α) : s₁ \ s₁ = ∅

ink

theorem Finset.sdiff_inter_distrib_right {α : Type u_1} [inst : DecidableEq α] (s : Finset α) (t : Finset α) (u : Finset α) : s \ (t ∩ u) = s \ t ∪ s \ u

ink

@[simp]

theorem Finset.sdiff_inter_self_left {α : Type u_1} [inst : DecidableEq α] (s : Finset α) (t : Finset α) : s \ (s ∩ t) = s \ t

ink

@[simp]

theorem Finset.sdiff_inter_self_right {α : Type u_1} [inst : DecidableEq α] (s : Finset α) (t : Finset α) : s \ (t ∩ s) = s \ t

ink

@[simp]

theorem Finset.sdiff_empty {α : Type u_1} [inst : DecidableEq α] {s : Finset α} : s \ ∅ = s

ink

theorem Finset.sdiff_subset_sdiff {α : Type u_1} [inst : DecidableEq α] {s : Finset α} {t : Finset α} {u : Finset α} {v : Finset α} (hst : s ⊆ t) (hvu : v ⊆ u) : s \ u ⊆ t \ v

ink

@[simp]

theorem Finset.coe_sdiff {α : Type u_1} [inst : DecidableEq α] (s₁ : Finset α) (s₂ : Finset α) : ↑(s₁ \ s₂) = ↑s₁ \ ↑s₂

ink

@[simp]

theorem Finset.union_sdiff_self_eq_union {α : Type u_1} [inst : DecidableEq α] {s : Finset α} {t : Finset α} : s ∪ t \ s = s ∪ t

ink

@[simp]

theorem Finset.sdiff_union_self_eq_union {α : Type u_1} [inst : DecidableEq α] {s : Finset α} {t : Finset α} : s \ t ∪ t = s ∪ t

ink

theorem Finset.union_sdiff_left {α : Type u_1} [inst : DecidableEq α] (s : Finset α) (t : Finset α) : (s ∪ t) \ s = t \ s

ink

theorem Finset.union_sdiff_right {α : Type u_1} [inst : DecidableEq α] (s : Finset α) (t : Finset α) : (s ∪ t) \ t = s \ t

ink

theorem Finset.union_sdiff_symm {α : Type u_1} [inst : DecidableEq α] {s : Finset α} {t : Finset α} : s ∪ t \ s = t ∪ s \ t

ink

theorem Finset.sdiff_union_inter {α : Type u_1} [inst : DecidableEq α] (s : Finset α) (t : Finset α) : s \ t ∪ s ∩ t = s

ink

theorem Finset.sdiff_idem {α : Type u_1} [inst : DecidableEq α] (s : Finset α) (t : Finset α) : (s \ t) \ t = s \ t

ink

theorem Finset.subset_sdiff {α : Type u_1} [inst : DecidableEq α] {s : Finset α} {t : Finset α} {u : Finset α} : s ⊆ t \ u ↔ s ⊆ t ∧ Disjoint s u

ink

@[simp]

theorem Finset.sdiff_eq_empty_iff_subset {α : Type u_1} [inst : DecidableEq α] {s : Finset α} {t : Finset α} : s \ t = ∅ ↔ s ⊆ t

ink

theorem Finset.sdiff_nonempty {α : Type u_1} [inst : DecidableEq α] {s : Finset α} {t : Finset α} : Finset.Nonempty (s \ t) ↔ ¬s ⊆ t

ink

@[simp]

theorem Finset.empty_sdiff {α : Type u_1} [inst : DecidableEq α] (s : Finset α) : ∅ \ s = ∅

ink

theorem Finset.insert_sdiff_of_not_mem {α : Type u_1} [inst : DecidableEq α] (s : Finset α) {t : Finset α} {x : α} (h : ¬x ∈ t) : insert x s \ t = insert x (s \ t)

ink

theorem Finset.insert_sdiff_of_mem {α : Type u_1} [inst : DecidableEq α] {t : Finset α} (s : Finset α) {x : α} (h : x ∈ t) : insert x s \ t = s \ t

ink

@[simp]

theorem Finset.insert_sdiff_insert {α : Type u_1} [inst : DecidableEq α] (s : Finset α) (t : Finset α) (x : α) : insert x s \ insert x t = s \ insert x t

ink

theorem Finset.sdiff_insert_of_not_mem {α : Type u_1} [inst : DecidableEq α] {s : Finset α} {x : α} (h : ¬x ∈ s) (t : Finset α) : s \ insert x t = s \ t

ink

@[simp]

theorem Finset.sdiff_subset {α : Type u_1} [inst : DecidableEq α] (s : Finset α) (t : Finset α) : s \ t ⊆ s

ink

theorem Finset.sdiff_ssubset {α : Type u_1} [inst : DecidableEq α] {s : Finset α} {t : Finset α} (h : t ⊆ s) (ht : Finset.Nonempty t) : s \ t ⊂ s

ink

theorem Finset.union_sdiff_distrib {α : Type u_1} [inst : DecidableEq α] (s₁ : Finset α) (s₂ : Finset α) (t : Finset α) : (s₁ ∪ s₂) \ t = s₁ \ t ∪ s₂ \ t

ink

theorem Finset.sdiff_union_distrib {α : Type u_1} [inst : DecidableEq α] (s : Finset α) (t₁ : Finset α) (t₂ : Finset α) : s \ (t₁ ∪ t₂) = s \ t₁ ∩ (s \ t₂)

ink

theorem Finset.union_sdiff_self {α : Type u_1} [inst : DecidableEq α] (s : Finset α) (t : Finset α) : (s ∪ t) \ t = s \ t

ink

theorem Finset.sdiff_singleton_eq_erase {α : Type u_1} [inst : DecidableEq α] (a : α) (s : Finset α) : s \ {a} = Finset.erase s a

ink

@[simp]

theorem Finset.sdiff_singleton_not_mem_eq_self {α : Type u_1} [inst : DecidableEq α] (s : Finset α) {a : α} (ha : ¬a ∈ s) : s \ {a} = s

ink

theorem Finset.sdiff_sdiff_left' {α : Type u_1} [inst : DecidableEq α] (s : Finset α) (t : Finset α) (u : Finset α) : (s \ t) \ u = s \ t ∩ (s \ u)

ink

theorem Finset.sdiff_insert {α : Type u_1} [inst : DecidableEq α] (s : Finset α) (t : Finset α) (x : α) : s \ insert x t = Finset.erase (s \ t) x

ink

theorem Finset.sdiff_insert_insert_of_mem_of_not_mem {α : Type u_1} [inst : DecidableEq α] {s : Finset α} {t : Finset α} {x : α} (hxs : x ∈ s) (hxt : ¬x ∈ t) : insert x (s \ insert x t) = s \ t

ink

theorem Finset.sdiff_erase {α : Type u_1} [inst : DecidableEq α] {s : Finset α} {x : α} (hx : x ∈ s) : s \ Finset.erase s x = {x}

ink

theorem Finset.sdiff_sdiff_self_left {α : Type u_1} [inst : DecidableEq α] (s : Finset α) (t : Finset α) : s \ (s \ t) = s ∩ t

ink

theorem Finset.sdiff_sdiff_eq_self {α : Type u_1} [inst : DecidableEq α] {s : Finset α} {t : Finset α} (h : t ⊆ s) : s \ (s \ t) = t

ink

theorem Finset.sdiff_eq_sdiff_iff_inter_eq_inter {α : Type u_1} [inst : DecidableEq α] {s : Finset α} {t₁ : Finset α} {t₂ : Finset α} : s \ t₁ = s \ t₂ ↔ s ∩ t₁ = s ∩ t₂

ink

theorem Finset.union_eq_sdiff_union_sdiff_union_inter {α : Type u_1} [inst : DecidableEq α] (s : Finset α) (t : Finset α) : s ∪ t = s \ t ∪ t \ s ∪ s ∩ t

ink

theorem Finset.erase_eq_empty_iff {α : Type u_1} [inst : DecidableEq α] (s : Finset α) (a : α) : Finset.erase s a = ∅ ↔ s = ∅ ∨ s = {a}

ink

theorem Finset.sdiff_disjoint {α : Type u_1} [inst : DecidableEq α] {s : Finset α} {t : Finset α} : Disjoint (t \ s) s

ink

theorem Finset.disjoint_sdiff {α : Type u_1} [inst : DecidableEq α] {s : Finset α} {t : Finset α} : Disjoint s (t \ s)

ink

theorem Finset.disjoint_sdiff_inter {α : Type u_1} [inst : DecidableEq α] (s : Finset α) (t : Finset α) : Disjoint (s \ t) (s ∩ t)

ink

theorem Finset.sdiff_eq_self_iff_disjoint {α : Type u_1} [inst : DecidableEq α] {s : Finset α} {t : Finset α} : s \ t = s ↔ Disjoint s t

ink

theorem Finset.sdiff_eq_self_of_disjoint {α : Type u_1} [inst : DecidableEq α] {s : Finset α} {t : Finset α} (h : Disjoint s t) : s \ t = s

Symmetric difference

ink

theorem Finset.mem_symmDiff {α : Type u_1} [inst : DecidableEq α] {s : Finset α} {t : Finset α} {a : α} : a ∈ s ∆ t ↔ a ∈ s ∧ ¬a ∈ t ∨ a ∈ t ∧ ¬a ∈ s

ink

@[simp]

theorem Finset.coe_symmDiff {α : Type u_1} [inst : DecidableEq α] {s : Finset α} {t : Finset α} : ↑(s ∆ t) = ↑s ∆ ↑t

attach

ink

def Finset.attach {α : Type u_1} (s : Finset α) : Finset { x // x ∈ s }

attach s takes the elements of s and forms a new set of elements of the subtype {x // x ∈ s}∈ s}.

Equations

• Finset.attach s = { val := Multiset.attach s.val, nodup := (_ : Multiset.Nodup (Multiset.attach s.val)) }

ink

theorem Finset.sizeOf_lt_sizeOf_of_mem {α : Type u_1} [inst : SizeOf α] {x : α} {s : Finset α} (hx : x ∈ s) : sizeOf x < sizeOf s

ink

@[simp]

theorem Finset.attach_val {α : Type u_1} (s : Finset α) : (Finset.attach s).val = Multiset.attach s.val

ink

@[simp]

theorem Finset.mem_attach {α : Type u_1} (s : Finset α) (x : { x // x ∈ s }) : x ∈ Finset.attach s

ink

@[simp]

theorem Finset.attach_empty {α : Type u_1} : Finset.attach ∅ = ∅

ink

@[simp]

theorem Finset.attach_nonempty_iff {α : Type u_1} (s : Finset α) : Finset.Nonempty (Finset.attach s) ↔ Finset.Nonempty s

ink

@[simp]

theorem Finset.attach_eq_empty_iff {α : Type u_1} (s : Finset α) : Finset.attach s = ∅ ↔ s = ∅

piecewise

ink

def Finset.piecewise {α : Type u_1} {δ : α → Sort u_2} (s : Finset α) (f : (i : α) → δ i) (g : (i : α) → δ i) [inst : (j : α) → Decidable (j ∈ s)] (i : α) : δ i

s.piecewise f g is the function equal to f on the finset s, and to g on its complement.

Equations

• Finset.piecewise s f g i = if i ∈ s then f i else g i

ink

theorem Finset.piecewise_insert_self {α : Type u_1} {δ : α → Sort u_2} (s : Finset α) (f : (i : α) → δ i) (g : (i : α) → δ i) [inst : DecidableEq α] {j : α} [inst : (i : α) → Decidable (i ∈ insert j s)] : Finset.piecewise (insert j s) f g j = f j

ink

@[simp]

theorem Finset.piecewise_empty {α : Type u_1} {δ : α → Sort u_2} (f : (i : α) → δ i) (g : (i : α) → δ i) [inst : (i : α) → Decidable (i ∈ ∅)] : Finset.piecewise ∅ f g = g

ink

theorem Finset.piecewise_coe {α : Type u_1} {δ : α → Sort u_2} (s : Finset α) (f : (i : α) → δ i) (g : (i : α) → δ i) [inst : (j : α) → Decidable (j ∈ s)] [inst : (j : α) → Decidable (j ∈ ↑s)] : Set.piecewise (↑s) f g = Finset.piecewise s f g

ink

@[simp]

theorem Finset.piecewise_eq_of_mem {α : Type u_1} {δ : α → Sort u_2} (s : Finset α) (f : (i : α) → δ i) (g : (i : α) → δ i) [inst : (j : α) → Decidable (j ∈ s)] {i : α} (hi : i ∈ s) : Finset.piecewise s f g i = f i

ink

@[simp]

theorem Finset.piecewise_eq_of_not_mem {α : Type u_1} {δ : α → Sort u_2} (s : Finset α) (f : (i : α) → δ i) (g : (i : α) → δ i) [inst : (j : α) → Decidable (j ∈ s)] {i : α} (hi : ¬i ∈ s) : Finset.piecewise s f g i = g i

ink

theorem Finset.piecewise_congr {α : Type u_1} {δ : α → Sort u_2} (s : Finset α) [inst : (j : α) → Decidable (j ∈ s)] {f : (i : α) → δ i} {f' : (i : α) → δ i} {g : (i : α) → δ i} {g' : (i : α) → δ i} (hf : ∀ (i : α), i ∈ s → f i = f' i) (hg : ∀ (i : α), ¬i ∈ s → g i = g' i) : Finset.piecewise s f g = Finset.piecewise s f' g'

ink

@[simp]

theorem Finset.piecewise_insert_of_ne {α : Type u_1} {δ : α → Sort u_2} (s : Finset α) (f : (i : α) → δ i) (g : (i : α) → δ i) [inst : (j : α) → Decidable (j ∈ s)] [inst : DecidableEq α] {i : α} {j : α} [inst : (i : α) → Decidable (i ∈ insert j s)] (h : i ≠ j) : Finset.piecewise (insert j s) f g i = Finset.piecewise s f g i

ink

theorem Finset.piecewise_insert {α : Type u_1} {δ : α → Sort u_2} (s : Finset α) (f : (i : α) → δ i) (g : (i : α) → δ i) [inst : (j : α) → Decidable (j ∈ s)] [inst : DecidableEq α] (j : α) [inst : (i : α) → Decidable (i ∈ insert j s)] : Finset.piecewise (insert j s) f g = Function.update (Finset.piecewise s f g) j (f j)

ink

theorem Finset.piecewise_cases {α : Type u_1} {δ : α → Sort u_2} (s : Finset α) (f : (i : α) → δ i) (g : (i : α) → δ i) [inst : (j : α) → Decidable (j ∈ s)] {i : α} (p : δ i → Prop) (hf : p (f i)) (hg : p (g i)) : p (Finset.piecewise s f g i)

ink

theorem Finset.piecewise_mem_set_pi {α : Type u_2} (s : Finset α) [inst : (j : α) → Decidable (j ∈ s)] {δ : α → Type u_1} {t : Set α} {t' : (i : α) → Set (δ i)} {f : (i : α) → δ i} {g : (i : α) → δ i} (hf : f ∈ Set.pi t t') (hg : g ∈ Set.pi t t') : Finset.piecewise s f g ∈ Set.pi t t'

ink

theorem Finset.piecewise_singleton {α : Type u_1} {δ : α → Sort u_2} (f : (i : α) → δ i) (g : (i : α) → δ i) [inst : DecidableEq α] (i : α) : Finset.piecewise {i} f g = Function.update g i (f i)

ink

theorem Finset.piecewise_piecewise_of_subset_left {α : Type u_1} {δ : α → Sort u_2} {s : Finset α} {t : Finset α} [inst : (i : α) → Decidable (i ∈ s)] [inst : (i : α) → Decidable (i ∈ t)] (h : s ⊆ t) (f₁ : (a : α) → δ a) (f₂ : (a : α) → δ a) (g : (a : α) → δ a) : Finset.piecewise s (Finset.piecewise t f₁ f₂) g = Finset.piecewise s f₁ g

ink

@[simp]

theorem Finset.piecewise_idem_left {α : Type u_1} {δ : α → Sort u_2} (s : Finset α) [inst : (j : α) → Decidable (j ∈ s)] (f₁ : (a : α) → δ a) (f₂ : (a : α) → δ a) (g : (a : α) → δ a) : Finset.piecewise s (Finset.piecewise s f₁ f₂) g = Finset.piecewise s f₁ g

ink

theorem Finset.piecewise_piecewise_of_subset_right {α : Type u_1} {δ : α → Sort u_2} {s : Finset α} {t : Finset α} [inst : (i : α) → Decidable (i ∈ s)] [inst : (i : α) → Decidable (i ∈ t)] (h : t ⊆ s) (f : (a : α) → δ a) (g₁ : (a : α) → δ a) (g₂ : (a : α) → δ a) : Finset.piecewise s f (Finset.piecewise t g₁ g₂) = Finset.piecewise s f g₂

ink

@[simp]

theorem Finset.piecewise_idem_right {α : Type u_1} {δ : α → Sort u_2} (s : Finset α) [inst : (j : α) → Decidable (j ∈ s)] (f : (a : α) → δ a) (g₁ : (a : α) → δ a) (g₂ : (a : α) → δ a) : Finset.piecewise s f (Finset.piecewise s g₁ g₂) = Finset.piecewise s f g₂

ink

theorem Finset.update_eq_piecewise {α : Type u_2} {β : Type u_1} [inst : DecidableEq α] (f : α → β) (i : α) (v : β) : Function.update f i v = Finset.piecewise {i} (fun x => v) f

ink

theorem Finset.update_piecewise {α : Type u_1} {δ : α → Sort u_2} (s : Finset α) (f : (i : α) → δ i) (g : (i : α) → δ i) [inst : (j : α) → Decidable (j ∈ s)] [inst : DecidableEq α] (i : α) (v : δ i) : Function.update (Finset.piecewise s f g) i v = Finset.piecewise s (Function.update f i v) (Function.update g i v)

ink

theorem Finset.update_piecewise_of_mem {α : Type u_1} {δ : α → Sort u_2} (s : Finset α) (f : (i : α) → δ i) (g : (i : α) → δ i) [inst : (j : α) → Decidable (j ∈ s)] [inst : DecidableEq α] {i : α} (hi : i ∈ s) (v : δ i) : Function.update (Finset.piecewise s f g) i v = Finset.piecewise s (Function.update f i v) g

ink

theorem Finset.update_piecewise_of_not_mem {α : Type u_1} {δ : α → Sort u_2} (s : Finset α) (f : (i : α) → δ i) (g : (i : α) → δ i) [inst : (j : α) → Decidable (j ∈ s)] [inst : DecidableEq α] {i : α} (hi : ¬