File: Mathlib/Order/SupIndep.lean

full_name: Finset.SupIndep
code: /-- Supremum independence of finite sets. We avoid the "obvious" definition using `s.erase i`
because `erase` would require decidable equality on `ι`. -/
def SupIndep (s : Finset ι) (f : ι → α) : Prop 
goal: Prop

full_name: Finset.instDecidableSupIndepOfDecidableEq
code: instance [DecidableEq ι] [DecidableEq α] : Decidable (SupIndep s f) 
goal: Decidable (s.SupIndep f)

full_name: Finset.SupIndep.subset
code: theorem SupIndep.subset (ht : t.SupIndep f) (h : s ⊆ t) : s.SupIndep f 
goal: s.SupIndep f

full_name: Finset.supIndep_empty
code: @[simp]
theorem supIndep_empty (f : ι → α) : (∅ : Finset ι).SupIndep f 
goal: ∅.SupIndep f

full_name: Finset.supIndep_singleton
code: theorem supIndep_singleton (i : ι) (f : ι → α) : ({i} : Finset ι).SupIndep f 
goal: {i}.SupIndep f

full_name: Finset.SupIndep.pairwiseDisjoint
code: theorem SupIndep.pairwiseDisjoint (hs : s.SupIndep f) : (s : Set ι).PairwiseDisjoint f 
goal: (↑s).PairwiseDisjoint f

full_name: Finset.SupIndep.le_sup_iff
code: theorem SupIndep.le_sup_iff (hs : s.SupIndep f) (hts : t ⊆ s) (hi : i ∈ s) (hf : ∀ i, f i ≠ ⊥) :
    f i ≤ t.sup f ↔ i ∈ t 
goal: f i ≤ t.sup f ↔ i ∈ t

full_name: Finset.supIndep_iff_disjoint_erase
code: /-- The RHS looks like the definition of `CompleteLattice.Independent`. -/
theorem supIndep_iff_disjoint_erase [DecidableEq ι] :
    s.SupIndep f ↔ ∀ i ∈ s, Disjoint (f i) ((s.erase i).sup f) 
goal: s.SupIndep f ↔ ∀ i ∈ s, Disjoint (f i) ((s.erase i).sup f)

full_name: Finset.SupIndep.image
code: theorem SupIndep.image [DecidableEq ι] {s : Finset ι'} {g : ι' → ι} (hs : s.SupIndep (f ∘ g)) :
    (s.image g).SupIndep f 
goal: (Finset.image g s).SupIndep f

full_name: Finset.supIndep_map
code: theorem supIndep_map {s : Finset ι'} {g : ι' ↪ ι} : (s.map g).SupIndep f ↔ s.SupIndep (f ∘ g) 
goal: (Finset.map g s).SupIndep f ↔ s.SupIndep (f ∘ ⇑g)

full_name: Finset.supIndep_pair
code: @[simp]
theorem supIndep_pair [DecidableEq ι] {i j : ι} (hij : i ≠ j) :
    ({i, j} : Finset ι).SupIndep f ↔ Disjoint (f i) (f j) 
goal: {i, j}.SupIndep f ↔ Disjoint (f i) (f j)

full_name: Finset.supIndep_univ_bool
code: theorem supIndep_univ_bool (f : Bool → α) :
    (Finset.univ : Finset Bool).SupIndep f ↔ Disjoint (f false) (f true) 
goal: Finset.univ.SupIndep f ↔ Disjoint (f false) (f true)

full_name: Finset.supIndep_univ_fin_two
code: @[simp]
theorem supIndep_univ_fin_two (f : Fin 2 → α) :
    (Finset.univ : Finset (Fin 2)).SupIndep f ↔ Disjoint (f 0) (f 1) 
goal: Finset.univ.SupIndep f ↔ Disjoint (f 0) (f 1)

full_name: Finset.SupIndep.attach
code: theorem SupIndep.attach (hs : s.SupIndep f) : s.attach.SupIndep fun a => f a 
goal: s.attach.SupIndep fun a => f ↑a

full_name: Finset.supIndep_attach
code: @[simp, nolint simpNF]
theorem supIndep_attach : (s.attach.SupIndep fun a => f a) ↔ s.SupIndep f 
goal: (s.attach.SupIndep fun a => f ↑a) ↔ s.SupIndep f

full_name: Finset.supIndep_iff_pairwiseDisjoint
code: theorem supIndep_iff_pairwiseDisjoint : s.SupIndep f ↔ (s : Set ι).PairwiseDisjoint f 
goal: s.SupIndep f ↔ (↑s).PairwiseDisjoint f

full_name: Finset.SupIndep.sup
code: /-- Bind operation for `SupIndep`. -/
theorem SupIndep.sup [DecidableEq ι] {s : Finset ι'} {g : ι' → Finset ι} {f : ι → α}
    (hs : s.SupIndep fun i => (g i).sup f) (hg : ∀ i' ∈ s, (g i').SupIndep f) :
    (s.sup g).SupIndep f 
goal: (s.sup g).SupIndep f

full_name: Finset.SupIndep.biUnion
code: /-- Bind operation for `SupIndep`. -/
theorem SupIndep.biUnion [DecidableEq ι] {s : Finset ι'} {g : ι' → Finset ι} {f : ι → α}
    (hs : s.SupIndep fun i => (g i).sup f) (hg : ∀ i' ∈ s, (g i').SupIndep f) :
    (s.biUnion g).SupIndep f 
goal: (s.biUnion g).SupIndep f

full_name: Finset.SupIndep.sigma
code: /-- Bind operation for `SupIndep`. -/
theorem SupIndep.sigma {β : ι → Type*} {s : Finset ι} {g : ∀ i, Finset (β i)} {f : Sigma β → α}
    (hs : s.SupIndep fun i => (g i).sup fun b => f ⟨i, b⟩)
    (hg : ∀ i ∈ s, (g i).SupIndep fun b => f ⟨i, b⟩) : (s.sigma g).SupIndep f 
goal: (s.sigma g).SupIndep f

full_name: Finset.SupIndep.product
code: theorem SupIndep.product {s : Finset ι} {t : Finset ι'} {f : ι × ι' → α}
    (hs : s.SupIndep fun i => t.sup fun i' => f (i, i'))
    (ht : t.SupIndep fun i' => s.sup fun i => f (i, i')) : (s ×ˢ t).SupIndep f 
goal: (s ×ˢ t).SupIndep f

full_name: Finset.supIndep_product_iff
code: theorem supIndep_product_iff {s : Finset ι} {t : Finset ι'} {f : ι × ι' → α} :
    (s.product t).SupIndep f ↔ (s.SupIndep fun i => t.sup fun i' => f (i, i'))
      ∧ t.SupIndep fun i' => s.sup fun i => f (i, i') 
goal: (s.product t).SupIndep f ↔
  (s.SupIndep fun i => t.sup fun i' => f (i, i')) ∧ t.SupIndep fun i' => s.sup fun i => f (i, i')

full_name: CompleteLattice.SetIndependent
code: /-- An independent set of elements in a complete lattice is one in which every element is disjoint
  from the `Sup` of the rest. -/
def SetIndependent (s : Set α) : Prop 
goal: Prop

full_name: CompleteLattice.setIndependent_empty
code: @[simp]
theorem setIndependent_empty : SetIndependent (∅ : Set α) 
goal: CompleteLattice.SetIndependent ∅

full_name: CompleteLattice.SetIndependent.mono
code: theorem SetIndependent.mono {t : Set α} (hst : t ⊆ s) : SetIndependent t 
goal: CompleteLattice.SetIndependent t

full_name: CompleteLattice.SetIndependent.pairwiseDisjoint
code: /-- If the elements of a set are independent, then any pair within that set is disjoint. -/
theorem SetIndependent.pairwiseDisjoint : s.PairwiseDisjoint id 
goal: s.PairwiseDisjoint id

full_name: CompleteLattice.setIndependent_singleton
code: theorem setIndependent_singleton (a : α) : SetIndependent ({a} : Set α) 
goal: CompleteLattice.SetIndependent {a}

full_name: CompleteLattice.setIndependent_pair
code: theorem setIndependent_pair {a b : α} (hab : a ≠ b) :
    SetIndependent ({a, b} : Set α) ↔ Disjoint a b 
goal: CompleteLattice.SetIndependent {a, b} ↔ Disjoint a b

full_name: CompleteLattice.SetIndependent.disjoint_sSup
code: /-- If the elements of a set are independent, then any element is disjoint from the `sSup` of some
subset of the rest. -/
theorem SetIndependent.disjoint_sSup {x : α} {y : Set α} (hx : x ∈ s) (hy : y ⊆ s) (hxy : x ∉ y) :
    Disjoint x (sSup y) 
goal: Disjoint x (sSup y)

full_name: CompleteLattice.Independent
code: /-- An independent indexed family of elements in a complete lattice is one in which every element
  is disjoint from the `iSup` of the rest.

  Example: an indexed family of non-zero elements in a
  vector space is linearly independent iff the indexed family of subspaces they generate is
  independent in this sense.

  Example: an indexed family of submodules of a module is independent in this sense if
  and only the natural map from the direct sum of the submodules to the module is injective. -/
def Independent {ι : Sort*} {α : Type*} [CompleteLattice α] (t : ι → α) : Prop 
goal: Prop

full_name: CompleteLattice.setIndependent_iff
code: theorem setIndependent_iff {α : Type*} [CompleteLattice α] (s : Set α) :
    SetIndependent s ↔ Independent ((↑) : s → α) 
goal: CompleteLattice.SetIndependent s ↔ CompleteLattice.Independent Subtype.val

full_name: CompleteLattice.independent_def
code: theorem independent_def : Independent t ↔ ∀ i : ι, Disjoint (t i) (⨆ (j) (_ : j ≠ i), t j) 
goal: CompleteLattice.Independent t ↔ ∀ (i : ι), Disjoint (t i) (⨆ j, ⨆ (_ : j ≠ i), t j)

full_name: CompleteLattice.independent_def'
code: theorem independent_def' : Independent t ↔ ∀ i, Disjoint (t i) (sSup (t '' { j | j ≠ i })) 
goal: CompleteLattice.Independent t ↔ ∀ (i : ι), Disjoint (t i) (sSup (t '' {j | j ≠ i}))

full_name: CompleteLattice.independent_def''
code: theorem independent_def'' :
    Independent t ↔ ∀ i, Disjoint (t i) (sSup { a | ∃ j ≠ i, t j = a }) 
goal: CompleteLattice.Independent t ↔ ∀ (i : ι), Disjoint (t i) (sSup {a | ∃ j, j ≠ i ∧ t j = a})

full_name: CompleteLattice.independent_empty
code: @[simp]
theorem independent_empty (t : Empty → α) : Independent t 
goal: CompleteLattice.Independent t

full_name: CompleteLattice.independent_pempty
code: @[simp]
theorem independent_pempty (t : PEmpty → α) : Independent t 
goal: CompleteLattice.Independent t

full_name: CompleteLattice.Independent.pairwiseDisjoint
code: /-- If the elements of a set are independent, then any pair within that set is disjoint. -/
theorem Independent.pairwiseDisjoint : Pairwise (Disjoint on t) 
goal: Pairwise (Disjoint on t)

full_name: CompleteLattice.Independent.mono
code: theorem Independent.mono {s t : ι → α} (hs : Independent s) (hst : t ≤ s) : Independent t 
goal: CompleteLattice.Independent t

full_name: CompleteLattice.Independent.comp
code: /-- Composing an independent indexed family with an injective function on the index results in
another indepedendent indexed family. -/
theorem Independent.comp {ι ι' : Sort*} {t : ι → α} {f : ι' → ι} (ht : Independent t)
    (hf : Injective f) : Independent (t ∘ f) 
goal: CompleteLattice.Independent (t ∘ f)

full_name: CompleteLattice.Independent.comp'
code: theorem Independent.comp' {ι ι' : Sort*} {t : ι → α} {f : ι' → ι} (ht : Independent <| t ∘ f)
    (hf : Surjective f) : Independent t 
goal: CompleteLattice.Independent t

full_name: CompleteLattice.Independent.setIndependent_range
code: theorem Independent.setIndependent_range (ht : Independent t) : SetIndependent <| range t 
goal: CompleteLattice.SetIndependent (Set.range t)

full_name: CompleteLattice.independent_ne_bot_iff_independent
code: @[simp]
theorem independent_ne_bot_iff_independent :
    Independent (fun i : {i // t i ≠ ⊥} ↦ t i) ↔ Independent t 
goal: (CompleteLattice.Independent fun i => t ↑i) ↔ CompleteLattice.Independent t

full_name: CompleteLattice.Independent.injOn
code: theorem Independent.injOn (ht : Independent t) : InjOn t {i | t i ≠ ⊥} 
goal: Set.InjOn t {i | t i ≠ ⊥}

full_name: CompleteLattice.Independent.injective
code: theorem Independent.injective (ht : Independent t) (h_ne_bot : ∀ i, t i ≠ ⊥) : Injective t 
goal: Function.Injective t

full_name: CompleteLattice.independent_pair
code: theorem independent_pair {i j : ι} (hij : i ≠ j) (huniv : ∀ k, k = i ∨ k = j) :
    Independent t ↔ Disjoint (t i) (t j) 
goal: CompleteLattice.Independent t ↔ Disjoint (t i) (t j)

full_name: CompleteLattice.Independent.map_orderIso
code: /-- Composing an independent indexed family with an order isomorphism on the elements results in
another independent indexed family. -/
theorem Independent.map_orderIso {ι : Sort*} {α β : Type*} [CompleteLattice α]
    [CompleteLattice β] (f : α ≃o β) {a : ι → α} (ha : Independent a) : Independent (f ∘ a) 
goal: CompleteLattice.Independent (⇑f ∘ a)

full_name: CompleteLattice.independent_map_orderIso_iff
code: @[simp]
theorem independent_map_orderIso_iff {ι : Sort*} {α β : Type*} [CompleteLattice α]
    [CompleteLattice β] (f : α ≃o β) {a : ι → α} : Independent (f ∘ a) ↔ Independent a 
goal: CompleteLattice.Independent (⇑f ∘ a) ↔ CompleteLattice.Independent a

full_name: CompleteLattice.Independent.disjoint_biSup
code: /-- If the elements of a set are independent, then any element is disjoint from the `iSup` of some
subset of the rest. -/
theorem Independent.disjoint_biSup {ι : Type*} {α : Type*} [CompleteLattice α] {t : ι → α}
    (ht : Independent t) {x : ι} {y : Set ι} (hx : x ∉ y) : Disjoint (t x) (⨆ i ∈ y, t i) 
goal: Disjoint (t x) (⨆ i ∈ y, t i)

full_name: CompleteLattice.independent_of_independent_coe_Iic_comp
code: lemma independent_of_independent_coe_Iic_comp {ι : Sort*} {a : α} {t : ι → Set.Iic a}
    (ht : Independent ((↑) ∘ t : ι → α)) : Independent t 
goal: CompleteLattice.Independent t

full_name: CompleteLattice.independent_iff_supIndep
code: theorem CompleteLattice.independent_iff_supIndep [CompleteLattice α] {s : Finset ι} {f : ι → α} :
    CompleteLattice.Independent (f ∘ ((↑) : s → ι)) ↔ s.SupIndep f 
goal: CompleteLattice.Independent (f ∘ Subtype.val) ↔ s.SupIndep f

full_name: CompleteLattice.Independent.supIndep'
code: theorem CompleteLattice.Independent.supIndep' [CompleteLattice α] {f : ι → α} (s : Finset ι)
    (h : CompleteLattice.Independent f) : s.SupIndep f 
goal: s.SupIndep f

full_name: CompleteLattice.independent_iff_supIndep_univ
code: /-- A variant of `CompleteLattice.independent_iff_supIndep` for `Fintype`s. -/
theorem CompleteLattice.independent_iff_supIndep_univ [CompleteLattice α] [Fintype ι] {f : ι → α} :
    CompleteLattice.Independent f ↔ Finset.univ.SupIndep f 
goal: CompleteLattice.Independent f ↔ Finset.univ.SupIndep f

full_name: CompleteLattice.setIndependent_iff_pairwiseDisjoint
code: theorem setIndependent_iff_pairwiseDisjoint {s : Set α} :
    SetIndependent s ↔ s.PairwiseDisjoint id 
goal: CompleteLattice.SetIndependent s ↔ s.PairwiseDisjoint id

full_name: CompleteLattice.independent_iff_pairwiseDisjoint
code: theorem independent_iff_pairwiseDisjoint {f : ι → α} : Independent f ↔ Pairwise (Disjoint on f) 
goal: CompleteLattice.Independent f ↔ Pairwise (Disjoint on f)