ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- List.nodupKeys_join
theorem nodupKeys_join {L : List (List (Sigma β))} :
    NodupKeys (join L) ↔ (∀ l ∈ L, NodupKeys l) ∧ Pairwise Disjoint (L.map keys) 
Arguments: {α : Type u} {β : α → Type v} {L : List (List (Sigma β))}
Goal: L.join.NodupKeys ↔ (∀ l ∈ L, l.NodupKeys) ∧ List.Pairwise List.Disjoint (List.map List.keys L)
-- List.nodup_enum_map_fst
theorem nodup_enum_map_fst (l : List α) : (l.enum.map Prod.fst).Nodup 
Arguments: {α : Type u} (l : List α)
Goal: (List.map Prod.fst l.enum).Nodup
-- List.mem_ext
theorem mem_ext {l₀ l₁ : List (Sigma β)} (nd₀ : l₀.Nodup) (nd₁ : l₁.Nodup)
    (h : ∀ x, x ∈ l₀ ↔ x ∈ l₁) : l₀ ~ l₁ 
Arguments: {α : Type u} {β : α → Type v} {l₀ l₁ : List (Sigma β)} (nd₀ : l₀.Nodup) (nd₁ : l₁.Nodup) (h : ∀ (x : Sigma β), x ∈ l₀ ↔ x ∈ l₁)
Goal: l₀.Perm l₁
-- List.dlookup_nil
@[simp]
theorem dlookup_nil (a : α) : dlookup a [] = @none (β a) 
Arguments: {α : Type u} {β : α → Type v} [DecidableEq α] (a : α)
Goal: List.dlookup a [] = none
-- List.dlookup_cons_eq
@[simp]
theorem dlookup_cons_eq (l) (a : α) (b : β a) : dlookup a (⟨a, b⟩ :: l) = some b 
Arguments: {α : Type u} {β : α → Type v} [DecidableEq α] (l : List (Sigma β)) (a : α) (b : β a)
Goal: List.dlookup a (⟨a, b⟩ :: l) = some b
-- List.dlookup_cons_ne
@[simp]
theorem dlookup_cons_ne (l) {a} : ∀ s : Sigma β, a ≠ s.1 → dlookup a (s :: l) = dlookup a l
  
Arguments: {α : Type u} {β : α → Type v} [DecidableEq α] (l : List (Sigma β)) {a : α} (s : Sigma β)
Goal: a ≠ s.fst → List.dlookup a (s :: l) = List.dlookup a l
-- List.dlookup_isSome
theorem dlookup_isSome {a : α} : ∀ {l : List (Sigma β)}, (dlookup a l).isSome ↔ a ∈ l.keys
  
Arguments: {α : Type u} {β : α → Type v} [DecidableEq α] {a : α} {l : List (Sigma β)}
Goal: (List.dlookup a l).isSome = true ↔ a ∈ l.keys
-- List.dlookup_eq_none
theorem dlookup_eq_none {a : α} {l : List (Sigma β)} : dlookup a l = none ↔ a ∉ l.keys 
Arguments: {α : Type u} {β : α → Type v} [DecidableEq α] {a : α} {l : List (Sigma β)}
Goal: List.dlookup a l = none ↔ a ∉ l.keys
-- List.of_mem_dlookup
theorem of_mem_dlookup {a : α} {b : β a} :
    ∀ {l : List (Sigma β)}, b ∈ dlookup a l → Sigma.mk a b ∈ l
  
Arguments: {α : Type u} {β : α → Type v} [DecidableEq α] {a : α} {b : β a} {l : List (Sigma β)}
Goal: b ∈ List.dlookup a l → ⟨a, b⟩ ∈ l
-- List.mem_dlookup
theorem mem_dlookup {a} {b : β a} {l : List (Sigma β)} (nd : l.NodupKeys) (h : Sigma.mk a b ∈ l) :
    b ∈ dlookup a l 
Arguments: {α : Type u} {β : α → Type v} [DecidableEq α] {a : α} {b : β a} {l : List (Sigma β)} (nd : l.NodupKeys) (h : ⟨a, b⟩ ∈ l)
Goal: b ∈ List.dlookup a l
-- List.map_dlookup_eq_find
theorem map_dlookup_eq_find (a : α) :
    ∀ l : List (Sigma β), (dlookup a l).map (Sigma.mk a) = find? (fun s => a = s.1) l
  
Arguments: {α : Type u} {β : α → Type v} [DecidableEq α] (a : α) (l : List (Sigma β))
Goal: Option.map (Sigma.mk a) (List.dlookup a l) = List.find? (fun s => decide (a = s.fst)) l
-- List.mem_dlookup_iff
theorem mem_dlookup_iff {a : α} {b : β a} {l : List (Sigma β)} (nd : l.NodupKeys) :
    b ∈ dlookup a l ↔ Sigma.mk a b ∈ l 
Arguments: {α : Type u} {β : α → Type v} [DecidableEq α] {a : α} {b : β a} {l : List (Sigma β)} (nd : l.NodupKeys)
Goal: b ∈ List.dlookup a l ↔ ⟨a, b⟩ ∈ l
-- List.perm_dlookup
theorem perm_dlookup (a : α) {l₁ l₂ : List (Sigma β)} (nd₁ : l₁.NodupKeys) (nd₂ : l₂.NodupKeys)
    (p : l₁ ~ l₂) : dlookup a l₁ = dlookup a l₂ 
Arguments: {α : Type u} {β : α → Type v} [DecidableEq α] (a : α) {l₁ l₂ : List (Sigma β)} (nd₁ : l₁.NodupKeys) (nd₂ : l₂.NodupKeys) (p : l₁.Perm l₂)
Goal: List.dlookup a l₁ = List.dlookup a l₂
-- List.lookup_ext
theorem lookup_ext {l₀ l₁ : List (Sigma β)} (nd₀ : l₀.NodupKeys) (nd₁ : l₁.NodupKeys)
    (h : ∀ x y, y ∈ l₀.dlookup x ↔ y ∈ l₁.dlookup x) : l₀ ~ l₁ 
Arguments: {α : Type u} {β : α → Type v} [DecidableEq α] {l₀ l₁ : List (Sigma β)} (nd₀ : l₀.NodupKeys) (nd₁ : l₁.NodupKeys) (h : ∀ (x : α) (y : β x), y ∈ List.dlookup x l₀ ↔ y ∈ List.dlookup x l₁)
Goal: l₀.Perm l₁
-- List.lookupAll_nil
@[simp]
theorem lookupAll_nil (a : α) : lookupAll a [] = @nil (β a) 
Arguments: {α : Type u} {β : α → Type v} [DecidableEq α] (a : α)
Goal: List.lookupAll a [] = []
-- List.lookupAll_cons_eq
@[simp]
theorem lookupAll_cons_eq (l) (a : α) (b : β a) : lookupAll a (⟨a, b⟩ :: l) = b :: lookupAll a l 
Arguments: {α : Type u} {β : α → Type v} [DecidableEq α] (l : List (Sigma β)) (a : α) (b : β a)
Goal: List.lookupAll a (⟨a, b⟩ :: l) = b :: List.lookupAll a l
-- List.lookupAll_cons_ne
@[simp]
theorem lookupAll_cons_ne (l) {a} : ∀ s : Sigma β, a ≠ s.1 → lookupAll a (s :: l) = lookupAll a l
  
Arguments: {α : Type u} {β : α → Type v} [DecidableEq α] (l : List (Sigma β)) {a : α} (s : Sigma β)
Goal: a ≠ s.fst → List.lookupAll a (s :: l) = List.lookupAll a l
-- List.lookupAll_eq_nil
theorem lookupAll_eq_nil {a : α} :
    ∀ {l : List (Sigma β)}, lookupAll a l = [] ↔ ∀ b : β a, Sigma.mk a b ∉ l
  
Arguments: {α : Type u} {β : α → Type v} [DecidableEq α] {a : α} {l : List (Sigma β)}
Goal: List.lookupAll a l = [] ↔ ∀ (b : β a), ⟨a, b⟩ ∉ l
-- List.head?_lookupAll
theorem head?_lookupAll (a : α) : ∀ l : List (Sigma β), head? (lookupAll a l) = dlookup a l
  
Arguments: {α : Type u} {β : α → Type v} [DecidableEq α] (a : α) (l : List (Sigma β))
Goal: (List.lookupAll a l).head? = List.dlookup a l
-- List.mem_lookupAll
theorem mem_lookupAll {a : α} {b : β a} :
    ∀ {l : List (Sigma β)}, b ∈ lookupAll a l ↔ Sigma.mk a b ∈ l
  
Arguments: {α : Type u} {β : α → Type v} [DecidableEq α] {a : α} {b : β a} {l : List (Sigma β)}
Goal: b ∈ List.lookupAll a l ↔ ⟨a, b⟩ ∈ l
-- List.lookupAll_sublist
theorem lookupAll_sublist (a : α) : ∀ l : List (Sigma β), (lookupAll a l).map (Sigma.mk a) <+ l
  
Arguments: {α : Type u} {β : α → Type v} [DecidableEq α] (a : α) (l : List (Sigma β))
Goal: (List.map (Sigma.mk a) (List.lookupAll a l)).Sublist l
-- List.lookupAll_length_le_one
theorem lookupAll_length_le_one (a : α) {l : List (Sigma β)} (h : l.NodupKeys) :
    length (lookupAll a l) ≤ 1 
Arguments: {α : Type u} {β : α → Type v} [DecidableEq α] (a : α) {l : List (Sigma β)} (h : l.NodupKeys)
Goal: (List.lookupAll a l).length ≤ 1
-- List.lookupAll_eq_dlookup
theorem lookupAll_eq_dlookup (a : α) {l : List (Sigma β)} (h : l.NodupKeys) :
    lookupAll a l = (dlookup a l).toList 
Arguments: {α : Type u} {β : α → Type v} [DecidableEq α] (a : α) {l : List (Sigma β)} (h : l.NodupKeys)
Goal: List.lookupAll a l = (List.dlookup a l).toList
-- List.lookupAll_nodup
theorem lookupAll_nodup (a : α) {l : List (Sigma β)} (h : l.NodupKeys) : (lookupAll a l).Nodup 
Arguments: {α : Type u} {β : α → Type v} [DecidableEq α] (a : α) {l : List (Sigma β)} (h : l.NodupKeys)
Goal: (List.lookupAll a l).Nodup
-- List.perm_lookupAll
theorem perm_lookupAll (a : α) {l₁ l₂ : List (Sigma β)} (nd₁ : l₁.NodupKeys) (nd₂ : l₂.NodupKeys)
    (p : l₁ ~ l₂) : lookupAll a l₁ = lookupAll a l₂ 
Arguments: {α : Type u} {β : α → Type v} [DecidableEq α] (a : α) {l₁ l₂ : List (Sigma β)} (nd₁ : l₁.NodupKeys) (nd₂ : l₂.NodupKeys) (p : l₁.Perm l₂)
Goal: List.lookupAll a l₁ = List.lookupAll a l₂
-- List.kreplace_of_forall_not
theorem kreplace_of_forall_not (a : α) (b : β a) {l : List (Sigma β)}
    (H : ∀ b : β a, Sigma.mk a b ∉ l) : kreplace a b l = l 
Arguments: {α : Type u} {β : α → Type v} [DecidableEq α] (a : α) (b : β a) {l : List (Sigma β)} (H : ∀ (b : β a), ⟨a, b⟩ ∉ l)
Goal: List.kreplace a b l = l
-- List.kreplace_self
theorem kreplace_self {a : α} {b : β a} {l : List (Sigma β)} (nd : NodupKeys l)
    (h : Sigma.mk a b ∈ l) : kreplace a b l = l 
Arguments: {α : Type u} {β : α → Type v} [DecidableEq α] {a : α} {b : β a} {l : List (Sigma β)} (nd : l.NodupKeys) (h : ⟨a, b⟩ ∈ l)
Goal: List.kreplace a b l = l
-- List.keys_kreplace
theorem keys_kreplace (a : α) (b : β a) : ∀ l : List (Sigma β), (kreplace a b l).keys = l.keys 
Arguments: {α : Type u} {β : α → Type v} [DecidableEq α] (a : α) (b : β a) (l : List (Sigma β))
Goal: (List.kreplace a b l).keys = l.keys
-- List.kreplace_nodupKeys
theorem kreplace_nodupKeys (a : α) (b : β a) {l : List (Sigma β)} :
    (kreplace a b l).NodupKeys ↔ l.NodupKeys 
Arguments: {α : Type u} {β : α → Type v} [DecidableEq α] (a : α) (b : β a) {l : List (Sigma β)}
Goal: (List.kreplace a b l).NodupKeys ↔ l.NodupKeys
-- List.Perm.kreplace
theorem Perm.kreplace {a : α} {b : β a} {l₁ l₂ : List (Sigma β)} (nd : l₁.NodupKeys) :
    l₁ ~ l₂ → kreplace a b l₁ ~ kreplace a b l₂ 
Arguments: {α : Type u} {β : α → Type v} [DecidableEq α] {a : α} {b : β a} {l₁ l₂ : List (Sigma β)} (nd : l₁.NodupKeys)
Goal: l₁.Perm l₂ → (List.kreplace a b l₁).Perm (List.kreplace a b l₂)
-- List.kerase_nil
theorem kerase_nil {a} : @kerase _ β _ a [] = [] 
Arguments: {α : Type u} {β : α → Type v} [DecidableEq α] {a : α}
Goal: List.kerase a [] = []
-- List.kerase_cons_eq
@[simp]
theorem kerase_cons_eq {a} {s : Sigma β} {l : List (Sigma β)} (h : a = s.1) :
    kerase a (s :: l) = l 
Arguments: {α : Type u} {β : α → Type v} [DecidableEq α] {a : α} {s : Sigma β} {l : List (Sigma β)} (h : a = s.fst)
Goal: List.kerase a (s :: l) = l
-- List.kerase_cons_ne
@[simp]
theorem kerase_cons_ne {a} {s : Sigma β} {l : List (Sigma β)} (h : a ≠ s.1) :
    kerase a (s :: l) = s :: kerase a l 
Arguments: {α : Type u} {β : α → Type v} [DecidableEq α] {a : α} {s : Sigma β} {l : List (Sigma β)} (h : a ≠ s.fst)
Goal: List.kerase a (s :: l) = s :: List.kerase a l
-- List.kerase_of_not_mem_keys
@[simp]
theorem kerase_of_not_mem_keys {a} {l : List (Sigma β)} (h : a ∉ l.keys) : kerase a l = l 
Arguments: {α : Type u} {β : α → Type v} [DecidableEq α] {a : α} {l : List (Sigma β)} (h : a ∉ l.keys)
Goal: List.kerase a l = l
-- List.kerase_sublist
theorem kerase_sublist (a : α) (l : List (Sigma β)) : kerase a l <+ l 
Arguments: {α : Type u} {β : α → Type v} [DecidableEq α] (a : α) (l : List (Sigma β))
Goal: (List.kerase a l).Sublist l
-- List.kerase_keys_subset
theorem kerase_keys_subset (a) (l : List (Sigma β)) : (kerase a l).keys ⊆ l.keys 
Arguments: {α : Type u} {β : α → Type v} [DecidableEq α] (a : α) (l : List (Sigma β))
Goal: (List.kerase a l).keys ⊆ l.keys
-- List.mem_keys_of_mem_keys_kerase
theorem mem_keys_of_mem_keys_kerase {a₁ a₂} {l : List (Sigma β)} :
    a₁ ∈ (kerase a₂ l).keys → a₁ ∈ l.keys 
Arguments: {α : Type u} {β : α → Type v} [DecidableEq α] {a₁ a₂ : α} {l : List (Sigma β)}
Goal: a₁ ∈ (List.kerase a₂ l).keys → a₁ ∈ l.keys
-- List.exists_of_kerase
theorem exists_of_kerase {a : α} {l : List (Sigma β)} (h : a ∈ l.keys) :
    ∃ (b : β a) (l₁ l₂ : List (Sigma β)),
      a ∉ l₁.keys ∧ l = l₁ ++ ⟨a, b⟩ :: l₂ ∧ kerase a l = l₁ ++ l₂ 
Arguments: {α : Type u} {β : α → Type v} [DecidableEq α] {a : α} {l : List (Sigma β)} (h : a ∈ l.keys)
Goal: ∃ b l₁ l₂, a ∉ l₁.keys ∧ l = l₁ ++ ⟨a, b⟩ :: l₂ ∧ List.kerase a l = l₁ ++ l₂
-- List.mem_keys_kerase_of_ne
@[simp]
theorem mem_keys_kerase_of_ne {a₁ a₂} {l : List (Sigma β)} (h : a₁ ≠ a₂) :
    a₁ ∈ (kerase a₂ l).keys ↔ a₁ ∈ l.keys 
Arguments: {α : Type u} {β : α → Type v} [DecidableEq α] {a₁ a₂ : α} {l : List (Sigma β)} (h : a₁ ≠ a₂)
Goal: a₁ ∈ (List.kerase a₂ l).keys ↔ a₁ ∈ l.keys
-- List.keys_kerase
theorem keys_kerase {a} {l : List (Sigma β)} : (kerase a l).keys = l.keys.erase a 
Arguments: {α : Type u} {β : α → Type v} [DecidableEq α] {a : α} {l : List (Sigma β)}
Goal: (List.kerase a l).keys = l.keys.erase a
-- List.kerase_kerase
theorem kerase_kerase {a a'} {l : List (Sigma β)} :
    (kerase a' l).kerase a = (kerase a l).kerase a' 
Arguments: {α : Type u} {β : α → Type v} [DecidableEq α] {a a' : α} {l : List (Sigma β)}
Goal: List.kerase a (List.kerase a' l) = List.kerase a' (List.kerase a l)
-- List.NodupKeys.kerase
theorem NodupKeys.kerase (a : α) : NodupKeys l → (kerase a l).NodupKeys 
Arguments: {α : Type u} {β : α → Type v} {l : List (Sigma β)} [DecidableEq α] (a : α)
Goal: l.NodupKeys → (List.kerase a l).NodupKeys
-- List.Perm.kerase
theorem Perm.kerase {a : α} {l₁ l₂ : List (Sigma β)} (nd : l₁.NodupKeys) :
    l₁ ~ l₂ → kerase a l₁ ~ kerase a l₂ 
Arguments: {α : Type u} {β : α → Type v} [DecidableEq α] {a : α} {l₁ l₂ : List (Sigma β)} (nd : l₁.NodupKeys)
Goal: l₁.Perm l₂ → (List.kerase a l₁).Perm (List.kerase a l₂)
-- List.not_mem_keys_kerase
@[simp]
theorem not_mem_keys_kerase (a) {l : List (Sigma β)} (nd : l.NodupKeys) :
    a ∉ (kerase a l).keys 
Arguments: {α : Type u} {β : α → Type v} [DecidableEq α] (a : α) {l : List (Sigma β)} (nd : l.NodupKeys)
Goal: a ∉ (List.kerase a l).keys
-- List.dlookup_kerase
@[simp]
theorem dlookup_kerase (a) {l : List (Sigma β)} (nd : l.NodupKeys) :
    dlookup a (kerase a l) = none 
Arguments: {α : Type u} {β : α → Type v} [DecidableEq α] (a : α) {l : List (Sigma β)} (nd : l.NodupKeys)
Goal: List.dlookup a (List.kerase a l) = none
-- List.dlookup_kerase_ne
@[simp]
theorem dlookup_kerase_ne {a a'} {l : List (Sigma β)} (h : a ≠ a') :
    dlookup a (kerase a' l) = dlookup a l 
Arguments: {α : Type u} {β : α → Type v} [DecidableEq α] {a a' : α} {l : List (Sigma β)} (h : a ≠ a')
Goal: List.dlookup a (List.kerase a' l) = List.dlookup a l
-- List.kerase_append_left
theorem kerase_append_left {a} :
    ∀ {l₁ l₂ : List (Sigma β)}, a ∈ l₁.keys → kerase a (l₁ ++ l₂) = kerase a l₁ ++ l₂
  
Arguments: {α : Type u} {β : α → Type v} [DecidableEq α] {a : α} {l₁ l₂ : List (Sigma β)}
Goal: a ∈ l₁.keys → List.kerase a (l₁ ++ l₂) = List.kerase a l₁ ++ l₂
-- List.kerase_append_right
theorem kerase_append_right {a} :
    ∀ {l₁ l₂ : List (Sigma β)}, a ∉ l₁.keys → kerase a (l₁ ++ l₂) = l₁ ++ kerase a l₂
  
Arguments: {α : Type u} {β : α → Type v} [DecidableEq α] {a : α} {l₁ l₂ : List (Sigma β)}
Goal: a ∉ l₁.keys → List.kerase a (l₁ ++ l₂) = l₁ ++ List.kerase a l₂
-- List.kerase_comm
theorem kerase_comm (a₁ a₂) (l : List (Sigma β)) :
    kerase a₂ (kerase a₁ l) = kerase a₁ (kerase a₂ l) 
Arguments: {α : Type u} {β : α → Type v} [DecidableEq α] (a₁ a₂ : α) (l : List (Sigma β))
Goal: List.kerase a₂ (List.kerase a₁ l) = List.kerase a₁ (List.kerase a₂ l)
-- List.sizeOf_kerase
theorem sizeOf_kerase [SizeOf (Sigma β)] (x : α)
    (xs : List (Sigma β)) : SizeOf.sizeOf (List.kerase x xs) ≤ SizeOf.sizeOf xs 
Arguments: {α : Type u} {β : α → Type v} [DecidableEq α] [SizeOf (Sigma β)] (x : α) (xs : List (Sigma β))
Goal: sizeOf (List.kerase x xs) ≤ sizeOf xs
-- List.kinsert_def
@[simp]
theorem kinsert_def {a} {b : β a} {l : List (Sigma β)} : kinsert a b l = ⟨a, b⟩ :: kerase a l 
Arguments: {α : Type u} {β : α → Type v} [DecidableEq α] {a : α} {b : β a} {l : List (Sigma β)}
Goal: List.kinsert a b l = ⟨a, b⟩ :: List.kerase a l
-- List.mem_keys_kinsert
theorem mem_keys_kinsert {a a'} {b' : β a'} {l : List (Sigma β)} :
    a ∈ (kinsert a' b' l).keys ↔ a = a' ∨ a ∈ l.keys 
Arguments: {α : Type u} {β : α → Type v} [DecidableEq α] {a a' : α} {b' : β a'} {l : List (Sigma β)}
Goal: a ∈ (List.kinsert a' b' l).keys ↔ a = a' ∨ a ∈ l.keys
-- List.kinsert_nodupKeys
theorem kinsert_nodupKeys (a) (b : β a) {l : List (Sigma β)} (nd : l.NodupKeys) :
    (kinsert a b l).NodupKeys 
Arguments: {α : Type u} {β : α → Type v} [DecidableEq α] (a : α) (b : β a) {l : List (Sigma β)} (nd : l.NodupKeys)
Goal: (List.kinsert a b l).NodupKeys
-- List.Perm.kinsert
theorem Perm.kinsert {a} {b : β a} {l₁ l₂ : List (Sigma β)} (nd₁ : l₁.NodupKeys) (p : l₁ ~ l₂) :
    kinsert a b l₁ ~ kinsert a b l₂ 
Arguments: {α : Type u} {β : α → Type v} [DecidableEq α] {a : α} {b : β a} {l₁ l₂ : List (Sigma β)} (nd₁ : l₁.NodupKeys) (p : l₁.Perm l₂)
Goal: (List.kinsert a b l₁).Perm (List.kinsert a b l₂)
-- List.dlookup_kinsert
theorem dlookup_kinsert {a} {b : β a} (l : List (Sigma β)) :
    dlookup a (kinsert a b l) = some b 
Arguments: {α : Type u} {β : α → Type v} [DecidableEq α] {a : α} {b : β a} (l : List (Sigma β))
Goal: List.dlookup a (List.kinsert a b l) = some b
-- List.dlookup_kinsert_ne
theorem dlookup_kinsert_ne {a a'} {b' : β a'} {l : List (Sigma β)} (h : a ≠ a') :
    dlookup a (kinsert a' b' l) = dlookup a l 
Arguments: {α : Type u} {β : α → Type v} [DecidableEq α] {a a' : α} {b' : β a'} {l : List (Sigma β)} (h : a ≠ a')
Goal: List.dlookup a (List.kinsert a' b' l) = List.dlookup a l
-- List.kextract_eq_dlookup_kerase
@[simp]
theorem kextract_eq_dlookup_kerase (a : α) :
    ∀ l : List (Sigma β), kextract a l = (dlookup a l, kerase a l)
  
Arguments: {α : Type u} {β : α → Type v} [DecidableEq α] (a : α) (l : List (Sigma β))
Goal: List.kextract a l = (List.dlookup a l, List.kerase a l)
-- List.dedupKeys_cons
theorem dedupKeys_cons {x : Sigma β} (l : List (Sigma β)) :
    dedupKeys (x :: l) = kinsert x.1 x.2 (dedupKeys l) 
Arguments: {α : Type u} {β : α → Type v} [DecidableEq α] {x : Sigma β} (l : List (Sigma β))
Goal: (x :: l).dedupKeys = List.kinsert x.fst x.snd l.dedupKeys
-- List.nodupKeys_dedupKeys
theorem nodupKeys_dedupKeys (l : List (Sigma β)) : NodupKeys (dedupKeys l) 
Arguments: {α : Type u} {β : α → Type v} [DecidableEq α] (l : List (Sigma β))
Goal: l.dedupKeys.NodupKeys
-- List.dlookup_dedupKeys
theorem dlookup_dedupKeys (a : α) (l : List (Sigma β)) : dlookup a (dedupKeys l) = dlookup a l 
Arguments: {α : Type u} {β : α → Type v} [DecidableEq α] (a : α) (l : List (Sigma β))
Goal: List.dlookup a l.dedupKeys = List.dlookup a l
-- List.sizeOf_dedupKeys
theorem sizeOf_dedupKeys [SizeOf (Sigma β)]
    (xs : List (Sigma β)) : SizeOf.sizeOf (dedupKeys xs) ≤ SizeOf.sizeOf xs 
Arguments: {α : Type u} {β : α → Type v} [DecidableEq α] [SizeOf (Sigma β)] (xs : List (Sigma β))
Goal: sizeOf xs.dedupKeys ≤ sizeOf xs
-- List.nil_kunion
@[simp]
theorem nil_kunion {l : List (Sigma β)} : kunion [] l = l 
Arguments: {α : Type u} {β : α → Type v} [DecidableEq α] {l : List (Sigma β)}
Goal: [].kunion l = l
-- List.kunion_nil
@[simp]
theorem kunion_nil : ∀ {l : List (Sigma β)}, kunion l [] = l
  
Arguments: {α : Type u} {β : α → Type v} [DecidableEq α] {l : List (Sigma β)}
Goal: l.kunion [] = l
-- List.kunion_cons
@[simp]
theorem kunion_cons {s} {l₁ l₂ : List (Sigma β)} :
    kunion (s :: l₁) l₂ = s :: kunion l₁ (kerase s.1 l₂) 
Arguments: {α : Type u} {β : α → Type v} [DecidableEq α] {s : Sigma β} {l₁ l₂ : List (Sigma β)}
Goal: (s :: l₁).kunion l₂ = s :: l₁.kunion (List.kerase s.fst l₂)
-- List.mem_keys_kunion
@[simp]
theorem mem_keys_kunion {a} {l₁ l₂ : List (Sigma β)} :
    a ∈ (kunion l₁ l₂).keys ↔ a ∈ l₁.keys ∨ a ∈ l₂.keys 
Arguments: {α : Type u} {β : α → Type v} [DecidableEq α] {a : α} {l₁ l₂ : List (Sigma β)}
Goal: a ∈ (l₁.kunion l₂).keys ↔ a ∈ l₁.keys ∨ a ∈ l₂.keys
-- List.kunion_kerase
@[simp]
theorem kunion_kerase {a} :
    ∀ {l₁ l₂ : List (Sigma β)}, kunion (kerase a l₁) (kerase a l₂) = kerase a (kunion l₁ l₂)
  
Arguments: {α : Type u} {β : α → Type v} [DecidableEq α] {a : α} {l₁ l₂ : List (Sigma β)}
Goal: (List.kerase a l₁).kunion (List.kerase a l₂) = List.kerase a (l₁.kunion l₂)
-- List.NodupKeys.kunion
theorem NodupKeys.kunion (nd₁ : l₁.NodupKeys) (nd₂ : l₂.NodupKeys) : (kunion l₁ l₂).NodupKeys 
Arguments: {α : Type u} {β : α → Type v} {l₁ l₂ : List (Sigma β)} [DecidableEq α] (nd₁ : l₁.NodupKeys) (nd₂ : l₂.NodupKeys)
Goal: (l₁.kunion l₂).NodupKeys
-- List.Perm.kunion_right
theorem Perm.kunion_right {l₁ l₂ : List (Sigma β)} (p : l₁ ~ l₂) (l) :
    kunion l₁ l ~ kunion l₂ l 
Arguments: {α : Type u} {β : α → Type v} [DecidableEq α] {l₁ l₂ : List (Sigma β)} (p : l₁.Perm l₂) (l : List (Sigma β))
Goal: (l₁.kunion l).Perm (l₂.kunion l)
-- List.Perm.kunion_left
theorem Perm.kunion_left :
    ∀ (l) {l₁ l₂ : List (Sigma β)}, l₁.NodupKeys → l₁ ~ l₂ → kunion l l₁ ~ kunion l l₂
  
Arguments: {α : Type u} {β : α → Type v} [DecidableEq α] (l : List (Sigma β)) {l₁ l₂ : List (Sigma β)}
Goal: l₁.NodupKeys → l₁.Perm l₂ → (l.kunion l₁).Perm (l.kunion l₂)
-- List.Perm.kunion
theorem Perm.kunion {l₁ l₂ l₃ l₄ : List (Sigma β)} (nd₃ : l₃.NodupKeys) (p₁₂ : l₁ ~ l₂)
    (p₃₄ : l₃ ~ l₄) : kunion l₁ l₃ ~ kunion l₂ l₄ 
Arguments: {α : Type u} {β : α → Type v} [DecidableEq α] {l₁ l₂ l₃ l₄ : List (Sigma β)} (nd₃ : l₃.NodupKeys) (p₁₂ : l₁.Perm l₂) (p₃₄ : l₃.Perm l₄)
Goal: (l₁.kunion l₃).Perm (l₂.kunion l₄)
-- List.dlookup_kunion_left
@[simp]
theorem dlookup_kunion_left {a} {l₁ l₂ : List (Sigma β)} (h : a ∈ l₁.keys) :
    dlookup a (kunion l₁ l₂) = dlookup a l₁ 
Arguments: {α : Type u} {β : α → Type v} [DecidableEq α] {a : α} {l₁ l₂ : List (Sigma β)} (h : a ∈ l₁.keys)
Goal: List.dlookup a (l₁.kunion l₂) = List.dlookup a l₁
-- List.dlookup_kunion_right
@[simp]
theorem dlookup_kunion_right {a} {l₁ l₂ : List (Sigma β)} (h : a ∉ l₁.keys) :
    dlookup a (kunion l₁ l₂) = dlookup a l₂ 
Arguments: {α : Type u} {β : α → Type v} [DecidableEq α] {a : α} {l₁ l₂ : List (Sigma β)} (h : a ∉ l₁.keys)
Goal: List.dlookup a (l₁.kunion l₂) = List.dlookup a l₂
-- List.mem_dlookup_kunion
theorem mem_dlookup_kunion {a} {b : β a} {l₁ l₂ : List (Sigma β)} :
    b ∈ dlookup a (kunion l₁ l₂) ↔ b ∈ dlookup a l₁ ∨ a ∉ l₁.keys ∧ b ∈ dlookup a l₂ 
Arguments: {α : Type u} {β : α → Type v} [DecidableEq α] {a : α} {b : β a} {l₁ l₂ : List (Sigma β)}
Goal: b ∈ List.dlookup a (l₁.kunion l₂) ↔ b ∈ List.dlookup a l₁ ∨ a ∉ l₁.keys ∧ b ∈ List.dlookup a l₂
-- List.dlookup_kunion_eq_some
@[simp]
theorem dlookup_kunion_eq_some {a} {b : β a} {l₁ l₂ : List (Sigma β)} :
    dlookup a (kunion l₁ l₂) = some b ↔
      dlookup a l₁ = some b ∨ a ∉ l₁.keys ∧ dlookup a l₂ = some b 
Arguments: {α : Type u} {β : α → Type v} [DecidableEq α] {a : α} {b : β a} {l₁ l₂ : List (Sigma β)}
Goal: List.dlookup a (l₁.kunion l₂) = some b ↔ List.dlookup a l₁ = some b ∨ a ∉ l₁.keys ∧ List.dlookup a l₂ = some b
-- List.mem_dlookup_kunion_middle
theorem mem_dlookup_kunion_middle {a} {b : β a} {l₁ l₂ l₃ : List (Sigma β)}
    (h₁ : b ∈ dlookup a (kunion l₁ l₃)) (h₂ : a ∉ keys l₂) :
    b ∈ dlookup a (kunion (kunion l₁ l₂) l₃) 
Arguments: {α : Type u} {β : α → Type v} [DecidableEq α] {a : α} {b : β a} {l₁ l₂ l₃ : List (Sigma β)} (h₁ : b ∈ List.dlookup a (l₁.kunion l₃)) (h₂ : a ∉ l₂.keys)
Goal: b ∈ List.dlookup a ((l₁.kunion l₂).kunion l₃)
-- Set.image_list_sum
@[to_additive]
theorem image_list_prod (f : F) :
    ∀ l : List (Set α), (f : α → β) '' l.prod = (l.map fun s => f '' s).prod
  
Arguments: {α : Type u_2} {β : Type u_3} {F : Type u_4} [FunLike F α β] [AddMonoid α] [AddMonoid β] [AddMonoidHomClass F α β] (f : F) (l : List (Set α))
Goal: ⇑f '' l.sum = (List.map (fun s => ⇑f '' s) l).sum
-- Set.image_list_prod
@[to_additive]
theorem image_list_prod (f : F) :
    ∀ l : List (Set α), (f : α → β) '' l.prod = (l.map fun s => f '' s).prod
  
Arguments: {α : Type u_2} {β : Type u_3} {F : Type u_4} [FunLike F α β] [Monoid α] [Monoid β] [MonoidHomClass F α β] (f : F) (l : List (Set α))
Goal: ⇑f '' l.prod = (List.map (fun s => ⇑f '' s) l).prod
-- Set.image_multiset_prod
@[to_additive]
theorem image_multiset_prod (f : F) :
    ∀ m : Multiset (Set α), (f : α → β) '' m.prod = (m.map fun s => f '' s).prod 
Arguments: {α : Type u_2} {β : Type u_3} {F : Type u_4} [FunLike F α β] [CommMonoid α] [CommMonoid β] [MonoidHomClass F α β] (f : F) (m : Multiset (Set α))
Goal: ⇑f '' m.prod = (Multiset.map (fun s => ⇑f '' s) m).prod
-- Set.image_multiset_sum
@[to_additive]
theorem image_multiset_prod (f : F) :
    ∀ m : Multiset (Set α), (f : α → β) '' m.prod = (m.map fun s => f '' s).prod 
Arguments: {α : Type u_2} {β : Type u_3} {F : Type u_4} [FunLike F α β] [AddCommMonoid α] [AddCommMonoid β] [AddMonoidHomClass F α β] (f : F) (m : Multiset (Set α))
Goal: ⇑f '' m.sum = (Multiset.map (fun s => ⇑f '' s) m).sum
-- Set.image_finset_prod
@[to_additive]
theorem image_finset_prod (f : F) (m : Finset ι) (s : ι → Set α) :
    ((f : α → β) '' ∏ i ∈ m, s i) = ∏ i ∈ m, f '' s i 
Arguments: {ι : Type u_1} {α : Type u_2} {β : Type u_3} {F : Type u_4} [FunLike F α β] [CommMonoid α] [CommMonoid β] [MonoidHomClass F α β] (f : F) (m : Finset ι) (s : ι → Set α)
Goal: ⇑f '' ∏ i ∈ m, s i = ∏ i ∈ m, ⇑f '' s i
-- Set.image_finset_sum
@[to_additive]
theorem image_finset_prod (f : F) (m : Finset ι) (s : ι → Set α) :
    ((f : α → β) '' ∏ i ∈ m, s i) = ∏ i ∈ m, f '' s i 
Arguments: {ι : Type u_1} {α : Type u_2} {β : Type u_3} {F : Type u_4} [FunLike F α β] [AddCommMonoid α] [AddCommMonoid β] [AddMonoidHomClass F α β] (f : F) (m : Finset ι) (s : ι → Set α)
Goal: ⇑f '' ∑ i ∈ m, s i = ∑ i ∈ m, ⇑f '' s i
-- Set.mem_finset_prod
@[to_additive " The n-ary version of `Set.mem_add`. "]
theorem mem_finset_prod (t : Finset ι) (f : ι → Set α) (a : α) :
    (a ∈ ∏ i ∈ t, f i) ↔ ∃ (g : ι → α) (_ : ∀ {i}, i ∈ t → g i ∈ f i), ∏ i ∈ t, g i = a 
Arguments: {ι : Type u_1} {α : Type u_2} [CommMonoid α] (t : Finset ι) (f : ι → Set α) (a : α)
Goal: a ∈ ∏ i ∈ t, f i ↔ ∃ g, ∃ (_ : ∀ {i : ι}, i ∈ t → g i ∈ f i), ∏ i ∈ t, g i = a