File: Mathlib/Data/List/Lattice.lean

full_name: List.Disjoint.symm
code: @[symm]
theorem Disjoint.symm (d : Disjoint l₁ l₂) : Disjoint l₂ l₁ 
goal: l₂.Disjoint l₁

full_name: List.mem_union_left
code: theorem mem_union_left (h : a ∈ l₁) (l₂ : List α) : a ∈ l₁ ∪ l₂ 
goal: a ∈ l₁ ∪ l₂

full_name: List.mem_union_right
code: theorem mem_union_right (l₁ : List α) (h : a ∈ l₂) : a ∈ l₁ ∪ l₂ 
goal: a ∈ l₁ ∪ l₂

full_name: List.sublist_suffix_of_union
code: theorem sublist_suffix_of_union : ∀ l₁ l₂ : List α, ∃ t, t <+ l₁ ∧ t ++ l₂ = l₁ ∪ l₂
  
goal: ∃ t, t.Sublist l₁ ∧ t ++ l₂ = l₁ ∪ l₂

full_name: List.suffix_union_right
code: theorem suffix_union_right (l₁ l₂ : List α) : l₂ <:+ l₁ ∪ l₂ 
goal: l₂ <:+ l₁ ∪ l₂

full_name: List.union_sublist_append
code: theorem union_sublist_append (l₁ l₂ : List α) : l₁ ∪ l₂ <+ l₁ ++ l₂ 
goal: (l₁ ∪ l₂).Sublist (l₁ ++ l₂)

full_name: List.forall_mem_union
code: theorem forall_mem_union : (∀ x ∈ l₁ ∪ l₂, p x) ↔ (∀ x ∈ l₁, p x) ∧ ∀ x ∈ l₂, p x 
goal: (∀ (x : α), x ∈ l₁ ∪ l₂ → p x) ↔ (∀ (x : α), x ∈ l₁ → p x) ∧ ∀ (x : α), x ∈ l₂ → p x

full_name: List.forall_mem_of_forall_mem_union_left
code: theorem forall_mem_of_forall_mem_union_left (h : ∀ x ∈ l₁ ∪ l₂, p x) : ∀ x ∈ l₁, p x 
goal: x ∈ l₁ → p x

full_name: List.forall_mem_of_forall_mem_union_right
code: theorem forall_mem_of_forall_mem_union_right (h : ∀ x ∈ l₁ ∪ l₂, p x) : ∀ x ∈ l₂, p x 
goal: x ∈ l₂ → p x

full_name: List.Subset.union_eq_right
code: theorem Subset.union_eq_right {xs ys : List α} (h : xs ⊆ ys) : xs ∪ ys = ys 
goal: xs ∪ ys = ys

full_name: List.inter_nil
code: @[simp]
theorem inter_nil (l : List α) : [] ∩ l = [] 
goal: [] ∩ l = []

full_name: List.inter_cons_of_mem
code: @[simp]
theorem inter_cons_of_mem (l₁ : List α) (h : a ∈ l₂) : (a :: l₁) ∩ l₂ = a :: l₁ ∩ l₂ 
goal: (a :: l₁) ∩ l₂ = a :: l₁ ∩ l₂

full_name: List.inter_cons_of_not_mem
code: @[simp]
theorem inter_cons_of_not_mem (l₁ : List α) (h : a ∉ l₂) : (a :: l₁) ∩ l₂ = l₁ ∩ l₂ 
goal: (a :: l₁) ∩ l₂ = l₁ ∩ l₂

full_name: List.inter_nil'
code: @[simp]
theorem inter_nil' (l : List α) : l ∩ [] = [] 
goal: l ∩ [] = []

full_name: List.mem_of_mem_inter_left
code: theorem mem_of_mem_inter_left : a ∈ l₁ ∩ l₂ → a ∈ l₁ 
goal: a ∈ l₁ ∩ l₂ → a ∈ l₁

full_name: List.mem_of_mem_inter_right
code: theorem mem_of_mem_inter_right (h : a ∈ l₁ ∩ l₂) : a ∈ l₂ 
goal: a ∈ l₂

full_name: List.mem_inter_of_mem_of_mem
code: theorem mem_inter_of_mem_of_mem (h₁ : a ∈ l₁) (h₂ : a ∈ l₂) : a ∈ l₁ ∩ l₂ 
goal: a ∈ l₁ ∩ l₂

full_name: List.inter_subset_left
code: theorem inter_subset_left {l₁ l₂ : List α} : l₁ ∩ l₂ ⊆ l₁ 
goal: l₁ ∩ l₂ ⊆ l₁

full_name: List.inter_subset_right
code: theorem inter_subset_right {l₁ l₂ : List α} : l₁ ∩ l₂ ⊆ l₂ 
goal: l₁ ∩ l₂ ⊆ l₂

full_name: List.subset_inter
code: theorem subset_inter {l l₁ l₂ : List α} (h₁ : l ⊆ l₁) (h₂ : l ⊆ l₂) : l ⊆ l₁ ∩ l₂ 
goal: l ⊆ l₁ ∩ l₂

full_name: List.inter_eq_nil_iff_disjoint
code: theorem inter_eq_nil_iff_disjoint : l₁ ∩ l₂ = [] ↔ Disjoint l₁ l₂ 
goal: l₁ ∩ l₂ = [] ↔ l₁.Disjoint l₂

full_name: List.forall_mem_inter_of_forall_left
code: theorem forall_mem_inter_of_forall_left (h : ∀ x ∈ l₁, p x) (l₂ : List α) :
    ∀ x, x ∈ l₁ ∩ l₂ → p x 
goal: x ∈ l₁ ∩ l₂ → p x

full_name: List.forall_mem_inter_of_forall_right
code: theorem forall_mem_inter_of_forall_right (l₁ : List α) (h : ∀ x ∈ l₂, p x) :
    ∀ x, x ∈ l₁ ∩ l₂ → p x 
goal: x ∈ l₁ ∩ l₂ → p x

full_name: List.inter_reverse
code: @[simp]
theorem inter_reverse {xs ys : List α} : xs.inter ys.reverse = xs.inter ys 
goal: xs.inter ys.reverse = xs.inter ys

full_name: List.Subset.inter_eq_left
code: theorem Subset.inter_eq_left {xs ys : List α} (h : xs ⊆ ys) : xs ∩ ys = xs 
goal: xs ∩ ys = xs

full_name: List.nil_bagInter
code: @[simp]
theorem nil_bagInter (l : List α) : [].bagInter l = [] 
goal: [].bagInter l = []

full_name: List.bagInter_nil
code: @[simp]
theorem bagInter_nil (l : List α) : l.bagInter [] = [] 
goal: l.bagInter [] = []

full_name: List.cons_bagInter_of_pos
code: @[simp]
theorem cons_bagInter_of_pos (l₁ : List α) (h : a ∈ l₂) :
    (a :: l₁).bagInter l₂ = a :: l₁.bagInter (l₂.erase a) 
goal: (a :: l₁).bagInter l₂ = a :: l₁.bagInter (l₂.erase a)

full_name: List.cons_bagInter_of_neg
code: @[simp]
theorem cons_bagInter_of_neg (l₁ : List α) (h : a ∉ l₂) :
    (a :: l₁).bagInter l₂ = l₁.bagInter l₂ 
goal: (a :: l₁).bagInter l₂ = l₁.bagInter l₂

full_name: List.mem_bagInter
code: @[simp]
theorem mem_bagInter {a : α} : ∀ {l₁ l₂ : List α}, a ∈ l₁.bagInter l₂ ↔ a ∈ l₁ ∧ a ∈ l₂
  
goal: a ∈ l₁.bagInter l₂ ↔ a ∈ l₁ ∧ a ∈ l₂

full_name: List.count_bagInter
code: @[simp]
theorem count_bagInter {a : α} :
    ∀ {l₁ l₂ : List α}, count a (l₁.bagInter l₂) = min (count a l₁) (count a l₂)
  
goal: List.count a (l₁.bagInter l₂) = min (List.count a l₁) (List.count a l₂)

full_name: List.bagInter_sublist_left
code: theorem bagInter_sublist_left : ∀ l₁ l₂ : List α, l₁.bagInter l₂ <+ l₁
  
goal: (l₁.bagInter l₂).Sublist l₁

full_name: List.bagInter_nil_iff_inter_nil
code: theorem bagInter_nil_iff_inter_nil : ∀ l₁ l₂ : List α, l₁.bagInter l₂ = [] ↔ l₁ ∩ l₂ = []
  
goal: l₁.bagInter l₂ = [] ↔ l₁ ∩ l₂ = []