Internal lemmas about the tree map

This file contains internal lemmas about Std.DTreeMap.Internal.Impl. Users of the tree map should not rely on the contents of this file.

@[instance_reducible]

def Std.DTreeMap.Internal.Impl.instCoeTypeForall_2 {α : Type u} : Coe (Type v) (α → Type v)

Equations

• Std.DTreeMap.Internal.Impl.instCoeTypeForall_2 = { coe := fun (γ : Type ?u.1) (x : α) => γ }

def Std.DTreeMap.Internal.Impl.tacticWf_trivial : Lean.ParserDescr

Internal implementation detail of the tree map

Equations

• Std.DTreeMap.Internal.Impl.tacticWf_trivial = Lean.ParserDescr.node `Std.DTreeMap.Internal.Impl.tacticWf_trivial 1024 (Lean.ParserDescr.nonReservedSymbol "wf_trivial" false)

def Std.DTreeMap.Internal.Impl.tacticEmpty : Lean.ParserDescr

Internal implementation detail of the tree map

Equations

• Std.DTreeMap.Internal.Impl.tacticEmpty = Lean.ParserDescr.node `Std.DTreeMap.Internal.Impl.tacticEmpty 1024 (Lean.ParserDescr.nonReservedSymbol "empty" false)

theorem Std.DTreeMap.Internal.Impl.compare_ne_iff_beq_eq_false {α : Type u} {instOrd : Ord α} {a b : α} : compare a b ≠ Ordering.eq ↔ (a == b) = false

def Std.DTreeMap.Internal.Impl.«tacticSimp_to_model[_]Using_» : Lean.ParserDescr

Internal implementation detail of the tree map

Equations

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

theorem Std.DTreeMap.Internal.Impl.isEmpty_empty {α : Type u} {β : α → Type v} : empty.isEmpty = true

theorem Std.DTreeMap.Internal.Impl.isEmpty_insert {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] (h : t.WF) {k : α} {v : β k} : (insert k v t ⋯).impl.isEmpty = false

theorem Std.DTreeMap.Internal.Impl.isEmpty_insert! {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] (h : t.WF) {k : α} {v : β k} : (insert! k v t).isEmpty = false

theorem Std.DTreeMap.Internal.Impl.contains_congr {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] (h : t.WF) {k k' : α} (hab : compare k k' = Ordering.eq) : contains k t = contains k' t

theorem Std.DTreeMap.Internal.Impl.mem_congr {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] (h : t.WF) {k k' : α} (hab : compare k k' = Ordering.eq) : k ∈ t ↔ k' ∈ t

theorem Std.DTreeMap.Internal.Impl.contains_empty {α : Type u} {β : α → Type v} {instOrd : Ord α} {a : α} : contains a empty = false

theorem Std.DTreeMap.Internal.Impl.not_mem_empty {α : Type u} {β : α → Type v} {instOrd : Ord α} {a : α} : ¬a ∈ empty

theorem Std.DTreeMap.Internal.Impl.contains_of_isEmpty {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] (h : t.WF) {a : α} : t.isEmpty = true → contains a t = false

theorem Std.DTreeMap.Internal.Impl.not_mem_of_isEmpty {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] (h : t.WF) {a : α} : t.isEmpty = true → ¬a ∈ t

theorem Std.DTreeMap.Internal.Impl.isEmpty_eq_false_iff_exists_contains_eq_true {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] (h : t.WF) : t.isEmpty = false ↔ ∃ (a : α), contains a t = true

theorem Std.DTreeMap.Internal.Impl.isEmpty_eq_false_iff_exists_mem {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] (h : t.WF) : t.isEmpty = false ↔ ∃ (a : α), a ∈ t

theorem Std.DTreeMap.Internal.Impl.isEmpty_eq_false_of_contains {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] (h : t.WF) {a : α} (hc : contains a t = true) : t.isEmpty = false

theorem Std.DTreeMap.Internal.Impl.isEmpty_iff_forall_contains {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] (h : t.WF) : t.isEmpty = true ↔ ∀ (a : α), contains a t = false

theorem Std.DTreeMap.Internal.Impl.isEmpty_iff_forall_not_mem {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] (h : t.WF) : t.isEmpty = true ↔ ∀ (a : α), ¬a ∈ t

theorem Std.DTreeMap.Internal.Impl.toArray_toList {α : Type u} {β : α → Type v} {t : Impl α β} : t.toList.toArray = t.toArray

theorem Std.DTreeMap.Internal.Impl.toList_toArray {α : Type u} {β : α → Type v} {t : Impl α β} : t.toArray.toList = t.toList

theorem Std.DTreeMap.Internal.Impl.toArray_keys {α : Type u} {β : α → Type v} {t : Impl α β} : t.keys.toArray = t.keysArray

theorem Std.DTreeMap.Internal.Impl.toList_keysArray {α : Type u} {β : α → Type v} {t : Impl α β} : t.keysArray.toList = t.keys

theorem Std.DTreeMap.Internal.Impl.contains_insert {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] (h : t.WF) {k a : α} {v : β k} : contains a (insert k v t ⋯).impl = (compare k a == Ordering.eq || contains a t)

theorem Std.DTreeMap.Internal.Impl.contains_insert! {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] (h : t.WF) {k a : α} {v : β k} : contains a (insert! k v t) = (compare k a == Ordering.eq || contains a t)

theorem Std.DTreeMap.Internal.Impl.mem_insert {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] (h : t.WF) {k a : α} {v : β k} : a ∈ (insert k v t ⋯).impl ↔ compare k a = Ordering.eq ∨ a ∈ t

theorem Std.DTreeMap.Internal.Impl.mem_insert! {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] (h : t.WF) {k a : α} {v : β k} : a ∈ insert! k v t ↔ compare k a = Ordering.eq ∨ a ∈ t

theorem Std.DTreeMap.Internal.Impl.contains_insert_self {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] (h : t.WF) {k : α} {v : β k} : contains k (insert k v t ⋯).impl = true

theorem Std.DTreeMap.Internal.Impl.contains_insert!_self {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] (h : t.WF) {k : α} {v : β k} : contains k (insert! k v t) = true

theorem Std.DTreeMap.Internal.Impl.mem_insert_self {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] (h : t.WF) {k : α} {v : β k} : k ∈ (insert k v t ⋯).impl

theorem Std.DTreeMap.Internal.Impl.mem_insert!_self {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] (h : t.WF) {k : α} {v : β k} : k ∈ insert! k v t

theorem Std.DTreeMap.Internal.Impl.contains_of_contains_insert {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] (h : t.WF) {k a : α} {v : β k} : contains a (insert k v t ⋯).impl = true → compare k a ≠ Ordering.eq → contains a t = true

theorem Std.DTreeMap.Internal.Impl.contains_of_contains_insert! {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] (h : t.WF) {k a : α} {v : β k} : contains a (insert! k v t) = true → compare k a ≠ Ordering.eq → contains a t = true

theorem Std.DTreeMap.Internal.Impl.mem_of_mem_insert {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] (h : t.WF) {k a : α} {v : β k} : a ∈ (insert k v t ⋯).impl → compare k a ≠ Ordering.eq → a ∈ t

theorem Std.DTreeMap.Internal.Impl.mem_of_mem_insert! {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] (h : t.WF) {k a : α} {v : β k} : a ∈ insert! k v t → compare k a ≠ Ordering.eq → a ∈ t

theorem Std.DTreeMap.Internal.Impl.size_empty {α : Type u} {β : α → Type v} : empty.size = 0

theorem Std.DTreeMap.Internal.Impl.isEmpty_eq_size_eq_zero {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} (h : t.WF) : t.isEmpty = (t.size == 0)

theorem Std.DTreeMap.Internal.Impl.size_insert {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] (h : t.WF) {k : α} {v : β k} : (insert k v t ⋯).impl.size = if contains k t = true then t.size else t.size + 1

theorem Std.DTreeMap.Internal.Impl.size_insert! {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] (h : t.WF) {k : α} {v : β k} : (insert! k v t).size = if contains k t = true then t.size else t.size + 1

theorem Std.DTreeMap.Internal.Impl.size_le_size_insert {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] (h : t.WF) {k : α} {v : β k} : t.size ≤ (insert k v t ⋯).impl.size

theorem Std.DTreeMap.Internal.Impl.size_le_size_insert! {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] (h : t.WF) {k : α} {v : β k} : t.size ≤ (insert! k v t).size

theorem Std.DTreeMap.Internal.Impl.size_insert_le {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] (h : t.WF) {k : α} {v : β k} : (insert k v t ⋯).impl.size ≤ t.size + 1

theorem Std.DTreeMap.Internal.Impl.size_insert!_le {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] (h : t.WF) {k : α} {v : β k} : (insert! k v t).size ≤ t.size + 1

theorem Std.DTreeMap.Internal.Impl.erase_empty {α : Type u} {β : α → Type v} {instOrd : Ord α} {k : α} : (erase k empty ⋯).impl = empty

theorem Std.DTreeMap.Internal.Impl.erase!_empty {α : Type u} {β : α → Type v} {instOrd : Ord α} {k : α} : erase! k empty = empty

theorem Std.DTreeMap.Internal.Impl.isEmpty_erase {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] (h : t.WF) {k : α} : (erase k t ⋯).impl.isEmpty = (t.isEmpty || decide (t.size = 1) && contains k t)

theorem Std.DTreeMap.Internal.Impl.isEmpty_erase! {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] (h : t.WF) {k : α} : (erase! k t).isEmpty = (t.isEmpty || decide (t.size = 1) && contains k t)

theorem Std.DTreeMap.Internal.Impl.isEmpty_eq_isEmpty_erase_and_not_contains {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] (h : t.WF) (k : α) : t.isEmpty = ((erase k t ⋯).impl.isEmpty && !contains k t)

theorem Std.DTreeMap.Internal.Impl.isEmpty_eq_isEmpty_erase!_and_not_containsKey {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] (h : t.WF) (k : α) : t.isEmpty = ((erase! k t).isEmpty && !contains k t)

theorem Std.DTreeMap.Internal.Impl.isEmpty_eq_false_of_isEmpty_erase_eq_false {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] (h : t.WF) {k : α} (he : (erase k t ⋯).impl.isEmpty = false) : t.isEmpty = false

theorem Std.DTreeMap.Internal.Impl.isEmpty_eq_false_of_isEmpty_erase!_eq_false {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] (h : t.WF) {k : α} (he : (erase! k t).isEmpty = false) : t.isEmpty = false

theorem Std.DTreeMap.Internal.Impl.contains_erase {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] (h : t.WF) {k a : α} : contains a (erase k t ⋯).impl = (!compare k a == Ordering.eq && contains a t)

theorem Std.DTreeMap.Internal.Impl.contains_erase! {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] (h : t.WF) {k a : α} : contains a (erase! k t) = (!compare k a == Ordering.eq && contains a t)

theorem Std.DTreeMap.Internal.Impl.mem_erase {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] (h : t.WF) {k a : α} : a ∈ (erase k t ⋯).impl ↔ compare k a ≠ Ordering.eq ∧ a ∈ t

theorem Std.DTreeMap.Internal.Impl.mem_erase! {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] (h : t.WF) {k a : α} : a ∈ erase! k t ↔ compare k a ≠ Ordering.eq ∧ a ∈ t

theorem Std.DTreeMap.Internal.Impl.contains_of_contains_erase {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] (h : t.WF) {k a : α} : contains a (erase k t ⋯).impl = true → contains a t = true

theorem Std.DTreeMap.Internal.Impl.contains_of_contains_erase! {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] (h : t.WF) {k a : α} : contains a (erase! k t) = true → contains a t = true

theorem Std.DTreeMap.Internal.Impl.mem_of_mem_erase {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] (h : t.WF) {k a : α} : a ∈ (erase k t ⋯).impl → a ∈ t

theorem Std.DTreeMap.Internal.Impl.mem_of_mem_erase! {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] (h : t.WF) {k a : α} : a ∈ erase! k t → a ∈ t

theorem Std.DTreeMap.Internal.Impl.size_erase {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] (h : t.WF) {k : α} : (erase k t ⋯).impl.size = if contains k t = true then t.size - 1 else t.size

theorem Std.DTreeMap.Internal.Impl.size_erase! {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] (h : t.WF) {k : α} : (erase! k t).size = if contains k t = true then t.size - 1 else t.size

theorem Std.DTreeMap.Internal.Impl.size_erase_le {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] (h : t.WF) {k : α} : (erase k t ⋯).impl.size ≤ t.size

theorem Std.DTreeMap.Internal.Impl.size_erase!_le {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] (h : t.WF) {k : α} : (erase! k t).size ≤ t.size

theorem Std.DTreeMap.Internal.Impl.size_le_size_erase {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] (h : t.WF) {k : α} : t.size ≤ (erase k t ⋯).impl.size + 1

theorem Std.DTreeMap.Internal.Impl.size_le_size_erase! {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] (h : t.WF) {k : α} : t.size ≤ (erase! k t).size + 1

theorem Std.DTreeMap.Internal.Impl.containsThenInsert_fst {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] (h : t.WF) {k : α} {v : β k} : (containsThenInsert k v t ⋯).fst = contains k t

theorem Std.DTreeMap.Internal.Impl.containsThenInsert!_fst {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] (h : t.WF) {k : α} {v : β k} : (containsThenInsert! k v t).fst = contains k t

theorem Std.DTreeMap.Internal.Impl.containsThenInsert_snd {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] (h : t.WF) {k : α} {v : β k} : (containsThenInsert k v t ⋯).snd.impl = (insert k v t ⋯).impl

theorem Std.DTreeMap.Internal.Impl.containsThenInsert!_snd {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] (h : t.WF) {k : α} {v : β k} : (containsThenInsert! k v t).snd = insert! k v t

theorem Std.DTreeMap.Internal.Impl.containsThenInsertIfNew_fst {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] (h : t.WF) {k : α} {v : β k} : (containsThenInsertIfNew k v t ⋯).fst = contains k t

theorem Std.DTreeMap.Internal.Impl.containsThenInsertIfNew!_fst {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] (h : t.WF) {k : α} {v : β k} : (containsThenInsertIfNew! k v t).fst = contains k t

theorem Std.DTreeMap.Internal.Impl.containsThenInsertIfNew_snd {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] (h : t.WF) {k : α} {v : β k} : (containsThenInsertIfNew k v t ⋯).snd.impl = (insertIfNew k v t ⋯).impl

theorem Std.DTreeMap.Internal.Impl.containsThenInsertIfNew!_snd {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] (h : t.WF) {k : α} {v : β k} : (containsThenInsertIfNew! k v t).snd = insertIfNew! k v t

theorem Std.DTreeMap.Internal.Impl.isEmpty_insertIfNew {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] (h : t.WF) {k : α} {v : β k} : (insertIfNew k v t ⋯).impl.isEmpty = false

theorem Std.DTreeMap.Internal.Impl.isEmpty_insertIfNew! {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] (h : t.WF) {k : α} {v : β k} : (insertIfNew! k v t).isEmpty = false

theorem Std.DTreeMap.Internal.Impl.contains_insertIfNew {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] (h : t.WF) {k a : α} {v : β k} : contains a (insertIfNew k v t ⋯).impl = (compare k a == Ordering.eq || contains a t)

theorem Std.DTreeMap.Internal.Impl.contains_insertIfNew! {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] (h : t.WF) {k a : α} {v : β k} : contains a (insertIfNew! k v t) = (compare k a == Ordering.eq || contains a t)

theorem Std.DTreeMap.Internal.Impl.mem_insertIfNew {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] (h : t.WF) {k a : α} {v : β k} : a ∈ (insertIfNew k v t ⋯).impl ↔ compare k a = Ordering.eq ∨ a ∈ t

theorem Std.DTreeMap.Internal.Impl.mem_insertIfNew! {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] (h : t.WF) {k a : α} {v : β k} : a ∈ insertIfNew! k v t ↔ compare k a = Ordering.eq ∨ a ∈ t

theorem Std.DTreeMap.Internal.Impl.contains_insertIfNew_self {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] (h : t.WF) {k : α} {v : β k} : contains k (insertIfNew k v t ⋯).impl = true

theorem Std.DTreeMap.Internal.Impl.contains_insertIfNew!_self {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] (h : t.WF) {k : α} {v : β k} : contains k (insertIfNew! k v t) = true

theorem Std.DTreeMap.Internal.Impl.mem_insertIfNew_self {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] (h : t.WF) {k : α} {v : β k} : k ∈ (insertIfNew k v t ⋯).impl

theorem Std.DTreeMap.Internal.Impl.mem_insertIfNew!_self {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] (h : t.WF) {k : α} {v : β k} : k ∈ insertIfNew! k v t

theorem Std.DTreeMap.Internal.Impl.contains_of_contains_insertIfNew {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] (h : t.WF) {k a : α} {v : β k} : contains a (insertIfNew k v t ⋯).impl = true → compare k a ≠ Ordering.eq → contains a t = true

theorem Std.DTreeMap.Internal.Impl.contains_of_contains_insertIfNew! {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] (h : t.WF) {k a : α} {v : β k} : contains a (insertIfNew! k v t) = true → compare k a ≠ Ordering.eq → contains a t = true

theorem Std.DTreeMap.Internal.Impl.mem_of_mem_insertIfNew {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] (h : t.WF) {k a : α} {v : β k} : a ∈ (insertIfNew k v t ⋯).impl → compare k a ≠ Ordering.eq → a ∈ t

theorem Std.DTreeMap.Internal.Impl.mem_of_mem_insertIfNew! {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] (h : t.WF) {k a : α} {v : β k} : a ∈ insertIfNew! k v t → compare k a ≠ Ordering.eq → a ∈ t

theorem Std.DTreeMap.Internal.Impl.size_insertIfNew {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] {k : α} (h : t.WF) {v : β k} : (insertIfNew k v t ⋯).impl.size = if k ∈ t then t.size else t.size + 1

theorem Std.DTreeMap.Internal.Impl.size_insertIfNew! {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] {k : α} (h : t.WF) {v : β k} : (insertIfNew! k v t).size = if k ∈ t then t.size else t.size + 1

theorem Std.DTreeMap.Internal.Impl.size_le_size_insertIfNew {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] (h : t.WF) {k : α} {v : β k} : t.size ≤ (insertIfNew k v t ⋯).impl.size

theorem Std.DTreeMap.Internal.Impl.size_le_size_insertIfNew! {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] (h : t.WF) {k : α} {v : β k} : t.size ≤ (insertIfNew! k v t).size

theorem Std.DTreeMap.Internal.Impl.size_insertIfNew_le {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] (h : t.WF) {k : α} {v : β k} : (insertIfNew k v t ⋯).impl.size ≤ t.size + 1

theorem Std.DTreeMap.Internal.Impl.size_insertIfNew!_le {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] (h : t.WF) {k : α} {v : β k} : (insertIfNew! k v t).size ≤ t.size + 1

theorem Std.DTreeMap.Internal.Impl.get?_empty {α : Type u} {β : α → Type v} {instOrd : Ord α} [TransOrd α] [LawfulEqOrd α] {a : α} : empty.get? a = none

theorem Std.DTreeMap.Internal.Impl.get?_of_isEmpty {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] [LawfulEqOrd α] (h : t.WF) {a : α} : t.isEmpty = true → t.get? a = none

theorem Std.DTreeMap.Internal.Impl.get?_insert {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] [LawfulEqOrd α] (h : t.WF) {a k : α} {v : β k} : (insert k v t ⋯).impl.get? a = if h : compare k a = Ordering.eq then some (cast ⋯ v) else t.get? a

theorem Std.DTreeMap.Internal.Impl.get?_insert! {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] [LawfulEqOrd α] (h : t.WF) {a k : α} {v : β k} : (insert! k v t).get? a = if h : compare k a = Ordering.eq then some (cast ⋯ v) else t.get? a

theorem Std.DTreeMap.Internal.Impl.get?_insert_self {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] [LawfulEqOrd α] (h : t.WF) {k : α} {v : β k} : (insert k v t ⋯).impl.get? k = some v

theorem Std.DTreeMap.Internal.Impl.get?_insert!_self {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] [LawfulEqOrd α] (h : t.WF) {k : α} {v : β k} : (insert! k v t).get? k = some v

theorem Std.DTreeMap.Internal.Impl.contains_eq_isSome_get? {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] [LawfulEqOrd α] (h : t.WF) {a : α} : contains a t = (t.get? a).isSome

theorem Std.DTreeMap.Internal.Impl.mem_iff_isSome_get? {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] [LawfulEqOrd α] (h : t.WF) {a : α} : a ∈ t ↔ (t.get? a).isSome = true

theorem Std.DTreeMap.Internal.Impl.get?_eq_some_iff {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] [LawfulEqOrd α] (h : t.WF) {k : α} {v : β k} : t.get? k = some v ↔ ∃ (h : k ∈ t), t.get k h = v

theorem Std.DTreeMap.Internal.Impl.get?_eq_none_of_contains_eq_false {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] [LawfulEqOrd α] (h : t.WF) {a : α} : contains a t = false → t.get? a = none

theorem Std.DTreeMap.Internal.Impl.get?_eq_none {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] [LawfulEqOrd α] (h : t.WF) {a : α} : ¬a ∈ t → t.get? a = none

theorem Std.DTreeMap.Internal.Impl.get?_erase {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] [LawfulEqOrd α] (h : t.WF) {k a : α} : (erase k t ⋯).impl.get? a = if compare k a = Ordering.eq then none else t.get? a

theorem Std.DTreeMap.Internal.Impl.get?_erase! {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] [LawfulEqOrd α] (h : t.WF) {k a : α} : (erase! k t).get? a = if compare k a = Ordering.eq then none else t.get? a

theorem Std.DTreeMap.Internal.Impl.get?_erase_self {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] [LawfulEqOrd α] (h : t.WF) {k : α} : (erase k t ⋯).impl.get? k = none

theorem Std.DTreeMap.Internal.Impl.get?_erase!_self {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] [LawfulEqOrd α] (h : t.WF) {k : α} : (erase! k t).get? k = none

theorem Std.DTreeMap.Internal.Impl.Const.toArray_toList {α : Type u} {β : Type v} {t : Impl α fun (x : α) => β} : (toList t).toArray = toArray t

theorem Std.DTreeMap.Internal.Impl.Const.toList_toArray {α : Type u} {β : Type v} {t : Impl α fun (x : α) => β} : (toArray t).toList = toList t

theorem Std.DTreeMap.Internal.Impl.Const.get?_empty {α : Type u} {instOrd : Ord α} {β : Type v} [TransOrd α] {a : α} : get? empty a = none

theorem Std.DTreeMap.Internal.Impl.Const.get?_of_isEmpty {α : Type u} {instOrd : Ord α} {β : Type v} {t : Impl α fun (x : α) => β} [TransOrd α] (h : t.WF) {a : α} : t.isEmpty = true → get? t a = none

theorem Std.DTreeMap.Internal.Impl.Const.get?_insert {α : Type u} {instOrd : Ord α} {β : Type v} {t : Impl α fun (x : α) => β} [TransOrd α] (h : t.WF) {a k : α} {v : β} : get? (insert k v t ⋯).impl a = if compare k a = Ordering.eq then some v else get? t a

theorem Std.DTreeMap.Internal.Impl.Const.get?_insert! {α : Type u} {instOrd : Ord α} {β : Type v} {t : Impl α fun (x : α) => β} [TransOrd α] (h : t.WF) {a k : α} {v : β} : get? (insert! k v t) a = if compare k a = Ordering.eq then some v else get? t a

theorem Std.DTreeMap.Internal.Impl.Const.get?_insert_self {α : Type u} {instOrd : Ord α} {β : Type v} {t : Impl α fun (x : α) => β} [TransOrd α] (h : t.WF) {k : α} {v : β} : get? (insert k v t ⋯).impl k = some v

theorem Std.DTreeMap.Internal.Impl.Const.get?_insert!_self {α : Type u} {instOrd : Ord α} {β : Type v} {t : Impl α fun (x : α) => β} [TransOrd α] (h : t.WF) {k : α} {v : β} : get? (insert! k v t) k = some v

theorem Std.DTreeMap.Internal.Impl.Const.contains_eq_isSome_get? {α : Type u} {instOrd : Ord α} {β : Type v} {t : Impl α fun (x : α) => β} [TransOrd α] (h : t.WF) {a : α} : contains a t = (get? t a).isSome

theorem Std.DTreeMap.Internal.Impl.Const.mem_iff_isSome_get? {α : Type u} {instOrd : Ord α} {β : Type v} {t : Impl α fun (x : α) => β} [TransOrd α] (h : t.WF) {a : α} : a ∈ t ↔ (get? t a).isSome = true

theorem Std.DTreeMap.Internal.Impl.Const.get?_eq_some_iff {α : Type u} {instOrd : Ord α} {β : Type v} {t : Impl α fun (x : α) => β} [TransOrd α] (h : t.WF) {k : α} {v : β} : get? t k = some v ↔ ∃ (h : contains k t = true), get t k h = v

theorem Std.DTreeMap.Internal.Impl.Const.get?_eq_none_of_contains_eq_false {α : Type u} {instOrd : Ord α} {β : Type v} {t : Impl α fun (x : α) => β} [TransOrd α] (h : t.WF) {a : α} : contains a t = false → get? t a = none

theorem Std.DTreeMap.Internal.Impl.Const.get?_eq_none {α : Type u} {instOrd : Ord α} {β : Type v} {t : Impl α fun (x : α) => β} [TransOrd α] (h : t.WF) {a : α} : ¬a ∈ t → get? t a = none

theorem Std.DTreeMap.Internal.Impl.Const.get?_erase {α : Type u} {instOrd : Ord α} {β : Type v} {t : Impl α fun (x : α) => β} [TransOrd α] (h : t.WF) {k a : α} : get? (erase k t ⋯).impl a = if compare k a = Ordering.eq then none else get? t a

theorem Std.DTreeMap.Internal.Impl.Const.get?_erase! {α : Type u} {instOrd : Ord α} {β : Type v} {t : Impl α fun (x : α) => β} [TransOrd α] (h : t.WF) {k a : α} : get? (erase! k t) a = if compare k a = Ordering.eq then none else get? t a

theorem Std.DTreeMap.Internal.Impl.Const.get?_erase_self {α : Type u} {instOrd : Ord α} {β : Type v} {t : Impl α fun (x : α) => β} [TransOrd α] (h : t.WF) {k : α} : get? (erase k t ⋯).impl k = none

theorem Std.DTreeMap.Internal.Impl.Const.get?_erase!_self {α : Type u} {instOrd : Ord α} {β : Type v} {t : Impl α fun (x : α) => β} [TransOrd α] (h : t.WF) {k : α} : get? (erase! k t) k = none

theorem Std.DTreeMap.Internal.Impl.Const.get?_eq_get? {α : Type u} {instOrd : Ord α} {β : Type v} {t : Impl α fun (x : α) => β} [LawfulEqOrd α] [TransOrd α] (h : t.WF) {a : α} : get? t a = t.get? a

theorem Std.DTreeMap.Internal.Impl.Const.get?_congr {α : Type u} {instOrd : Ord α} {β : Type v} {t : Impl α fun (x : α) => β} [TransOrd α] (h : t.WF) {a b : α} (hab : compare a b = Ordering.eq) : get? t a = get? t b

theorem Std.DTreeMap.Internal.Impl.get_insert {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] [LawfulEqOrd α] (h : t.WF) {k a : α} {v : β k} {h₁ : a ∈ (insert k v t ⋯).impl} : (insert k v t ⋯).impl.get a h₁ = if h₂ : compare k a = Ordering.eq then cast ⋯ v else t.get a ⋯

theorem Std.DTreeMap.Internal.Impl.get_insert! {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] [LawfulEqOrd α] (h : t.WF) {k a : α} {v : β k} {h₁ : a ∈ insert! k v t} : (insert! k v t).get a h₁ = if h₂ : compare k a = Ordering.eq then cast ⋯ v else t.get a ⋯

theorem Std.DTreeMap.Internal.Impl.toList_insert_perm {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [BEq α] [TransOrd α] [LawfulBEqOrd α] (h : t.WF) {k : α} {v : β k} : (insert k v t ⋯).impl.toList.Perm (⟨k, v⟩ :: List.filter (fun (x : (a : α) × β a) => decide ¬(k == x.fst) = true) t.toList)

theorem Std.DTreeMap.Internal.Impl.toList_insert!_perm {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [BEq α] [TransOrd α] [LawfulBEqOrd α] (h : t.WF) {k : α} {v : β k} : (insert! k v t).toList.Perm (⟨k, v⟩ :: List.filter (fun (x : (a : α) × β a) => decide ¬(k == x.fst) = true) t.toList)

theorem Std.DTreeMap.Internal.Impl.toArray_insert_perm {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [BEq α] [TransOrd α] [LawfulBEqOrd α] (h : t.WF) {k : α} {v : β k} : (insert k v t ⋯).impl.toArray.Perm ((Array.filter (fun (x : (a : α) × β a) => decide ¬(k == x.fst) = true) t.toArray).push ⟨k, v⟩)

theorem Std.DTreeMap.Internal.Impl.toArray_insert!_perm {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [BEq α] [TransOrd α] [LawfulBEqOrd α] (h : t.WF) {k : α} {v : β k} : (insert! k v t).toArray.Perm ((Array.filter (fun (x : (a : α) × β a) => decide ¬(k == x.fst) = true) t.toArray).push ⟨k, v⟩)

theorem Std.DTreeMap.Internal.Impl.Const.toList_insert_perm {α : Type u} {instOrd : Ord α} {β : Type v} {t : Impl α fun (x : α) => β} [BEq α] [TransOrd α] [LawfulBEqOrd α] (h : t.WF) {k : α} {v : β} : (toList (insert k v t ⋯).impl).Perm ((k, v) :: List.filter (fun (x : α × β) => decide ¬(k == x.fst) = true) (toList t))

theorem Std.DTreeMap.Internal.Impl.Const.toList_insert!_perm {α : Type u} {instOrd : Ord α} {β : Type v} {t : Impl α fun (x : α) => β} [BEq α] [TransOrd α] [LawfulBEqOrd α] (h : t.WF) {k : α} {v : β} : (toList (insert! k v t)).Perm ((k, v) :: List.filter (fun (x : α × β) => decide ¬(k == x.fst) = true) (toList t))

theorem Std.DTreeMap.Internal.Impl.Const.toArray_insert_perm {α : Type u} {instOrd : Ord α} {β : Type v} {t : Impl α fun (x : α) => β} [BEq α] [TransOrd α] [LawfulBEqOrd α] (h : t.WF) {k : α} {v : β} : (toArray (insert k v t ⋯).impl).Perm ((Array.filter (fun (x : α × β) => decide ¬(k == x.fst) = true) (toArray t)).push (k, v))

theorem Std.DTreeMap.Internal.Impl.Const.toArray_insert!_perm {α : Type u} {instOrd : Ord α} {β : Type v} {t : Impl α fun (x : α) => β} [BEq α] [TransOrd α] [LawfulBEqOrd α] (h : t.WF) {k : α} {v : β} : (toArray (insert! k v t)).Perm ((Array.filter (fun (x : α × β) => decide ¬(k == x.fst) = true) (toArray t)).push (k, v))

theorem Std.DTreeMap.Internal.Impl.keys_insertIfNew_perm {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [BEq α] [TransOrd α] [LawfulBEqOrd α] (h : t.WF) {k : α} {v : β k} : (insertIfNew k v t ⋯).impl.keys.Perm (if contains k t = true then t.keys else k :: t.keys)

theorem Std.DTreeMap.Internal.Impl.keysArray_insertIfNew_perm {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [BEq α] [TransOrd α] [LawfulBEqOrd α] (h : t.WF) {k : α} {v : β k} : (insertIfNew k v t ⋯).impl.keysArray.Perm (if contains k t = true then t.keysArray else t.keysArray.push k)

theorem Std.DTreeMap.Internal.Impl.keys_insertIfNew!_perm {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [BEq α] [TransOrd α] [LawfulBEqOrd α] (h : t.WF) {k : α} {v : β k} : (insertIfNew! k v t).keys.Perm (if contains k t = true then t.keys else k :: t.keys)

theorem Std.DTreeMap.Internal.Impl.keysArray_insertIfNew!_perm {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [BEq α] [TransOrd α] [LawfulBEqOrd α] (h : t.WF) {k : α} {v : β k} : (insertIfNew! k v t).keysArray.Perm (if contains k t = true then t.keysArray else t.keysArray.push k)

theorem Std.DTreeMap.Internal.Impl.get_insert_self {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] [LawfulEqOrd α] (h : t.WF) {k : α} {v : β k} : (insert k v t ⋯).impl.get k ⋯ = v

theorem Std.DTreeMap.Internal.Impl.get_insert!_self {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] [LawfulEqOrd α] (h : t.WF) {k : α} {v : β k} : (insert! k v t).get k ⋯ = v

@[simp]

theorem Std.DTreeMap.Internal.Impl.get_erase {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] [LawfulEqOrd α] (h : t.WF) {k a : α} {h' : a ∈ (erase k t ⋯).impl} : (erase k t ⋯).impl.get a h' = t.get a ⋯

theorem Std.DTreeMap.Internal.Impl.get_erase! {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] [LawfulEqOrd α] (h : t.WF) {k a : α} {h' : a ∈ erase! k t} : (erase! k t).get a h' = t.get a ⋯

theorem Std.DTreeMap.Internal.Impl.get?_eq_some_get {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] [LawfulEqOrd α] (h : t.WF) {a : α} {h' : a ∈ t} : t.get? a = some (t.get a h')

theorem Std.DTreeMap.Internal.Impl.Const.get_insert {α : Type u} {instOrd : Ord α} {β : Type v} {t : Impl α fun (x : α) => β} [TransOrd α] (h : t.WF) {k a : α} {v : β} {h₁ : contains a (insert k v t ⋯).impl = true} : get (insert k v t ⋯).impl a h₁ = if h₂ : compare k a = Ordering.eq then v else get t a ⋯

theorem Std.DTreeMap.Internal.Impl.Const.get_insert! {α : Type u} {instOrd : Ord α} {β : Type v} {t : Impl α fun (x : α) => β} [TransOrd α] (h : t.WF) {k a : α} {v : β} {h₁ : contains a (insert! k v t) = true} : get (insert! k v t) a h₁ = if h₂ : compare k a = Ordering.eq then v else get t a ⋯

theorem Std.DTreeMap.Internal.Impl.Const.get_insert_self {α : Type u} {instOrd : Ord α} {β : Type v} {t : Impl α fun (x : α) => β} [TransOrd α] (h : t.WF) {k : α} {v : β} : get (insert k v t ⋯).impl k ⋯ = v

theorem Std.DTreeMap.Internal.Impl.Const.get_insert!_self {α : Type u} {instOrd : Ord α} {β : Type v} {t : Impl α fun (x : α) => β} [TransOrd α] (h : t.WF) {k : α} {v : β} : get (insert! k v t) k ⋯ = v

@[simp]

theorem Std.DTreeMap.Internal.Impl.Const.get_erase {α : Type u} {instOrd : Ord α} {β : Type v} {t : Impl α fun (x : α) => β} [TransOrd α] (h : t.WF) {k a : α} {h' : contains a (erase k t ⋯).impl = true} : get (erase k t ⋯).impl a h' = get t a ⋯

theorem Std.DTreeMap.Internal.Impl.Const.get_erase! {α : Type u} {instOrd : Ord α} {β : Type v} {t : Impl α fun (x : α) => β} [TransOrd α] (h : t.WF) {k a : α} {h' : contains a (erase! k t) = true} : get (erase! k t) a h' = get t a ⋯

theorem Std.DTreeMap.Internal.Impl.Const.get?_eq_some_get {α : Type u} {instOrd : Ord α} {β : Type v} {t : Impl α fun (x : α) => β} [TransOrd α] (h : t.WF) {a : α} {h✝ : contains a t = true} : get? t a = some (get t a h✝)

theorem Std.DTreeMap.Internal.Impl.Const.get_eq_get {α : Type u} {instOrd : Ord α} {β : Type v} {t : Impl α fun (x : α) => β} [TransOrd α] [LawfulEqOrd α] (h : t.WF) {a : α} {h✝ : contains a t = true} : get t a h✝ = t.get a h✝

theorem Std.DTreeMap.Internal.Impl.Const.get_congr {α : Type u} {instOrd : Ord α} {β : Type v} {t : Impl α fun (x : α) => β} [TransOrd α] (h : t.WF) {a b : α} (hab : compare a b = Ordering.eq) {h' : contains a t = true} : get t a h' = get t b ⋯

theorem Std.DTreeMap.Internal.Impl.get!_empty {α : Type u} {β : α → Type v} {instOrd : Ord α} [TransOrd α] [LawfulEqOrd α] {a : α} [Inhabited (β a)] : empty.get! a = default

theorem Std.DTreeMap.Internal.Impl.get!_of_isEmpty {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] [LawfulEqOrd α] (h : t.WF) {a : α} [Inhabited (β a)] : t.isEmpty = true → t.get! a = default

theorem Std.DTreeMap.Internal.Impl.get!_insert {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] [LawfulEqOrd α] (h : t.WF) {k a : α} [Inhabited (β a)] {v : β k} : (insert k v t ⋯).impl.get! a = if h : compare k a = Ordering.eq then cast ⋯ v else t.get! a

theorem Std.DTreeMap.Internal.Impl.get!_insert! {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] [LawfulEqOrd α] (h : t.WF) {k a : α} [Inhabited (β a)] {v : β k} : (insert! k v t).get! a = if h : compare k a = Ordering.eq then cast ⋯ v else t.get! a

theorem Std.DTreeMap.Internal.Impl.get!_insert_self {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] [LawfulEqOrd α] (h : t.WF) {a : α} [Inhabited (β a)] {b : β a} : (insert a b t ⋯).impl.get! a = b

theorem Std.DTreeMap.Internal.Impl.get!_insert!_self {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] [LawfulEqOrd α] (h : t.WF) {a : α} [Inhabited (β a)] {b : β a} : (insert! a b t).get! a = b

theorem Std.DTreeMap.Internal.Impl.get!_eq_default_of_contains_eq_false {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] [LawfulEqOrd α] (h : t.WF) {a : α} [Inhabited (β a)] : contains a t = false → t.get! a = default

theorem Std.DTreeMap.Internal.Impl.get!_eq_default {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] [LawfulEqOrd α] (h : t.WF) {a : α} [Inhabited (β a)] : ¬a ∈ t → t.get! a = default

theorem Std.DTreeMap.Internal.Impl.get!_erase {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] [LawfulEqOrd α] (h : t.WF) {k a : α} [Inhabited (β a)] : (erase k t ⋯).impl.get! a = if compare k a = Ordering.eq then default else t.get! a

theorem Std.DTreeMap.Internal.Impl.get!_erase! {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] [LawfulEqOrd α] (h : t.WF) {k a : α} [Inhabited (β a)] : (erase! k t).get! a = if compare k a = Ordering.eq then default else t.get! a

theorem Std.DTreeMap.Internal.Impl.get!_erase_self {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] [LawfulEqOrd α] (h : t.WF) {k : α} [Inhabited (β k)] : (erase k t ⋯).impl.get! k = default

theorem Std.DTreeMap.Internal.Impl.get!_erase!_self {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] [LawfulEqOrd α] (h : t.WF) {k : α} [Inhabited (β k)] : (erase! k t).get! k = default

theorem Std.DTreeMap.Internal.Impl.get?_eq_some_get!_of_contains {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] [LawfulEqOrd α] (h : t.WF) {a : α} [Inhabited (β a)] : contains a t = true → t.get? a = some (t.get! a)

theorem Std.DTreeMap.Internal.Impl.get?_eq_some_get! {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] [LawfulEqOrd α] (h : t.WF) {a : α} [Inhabited (β a)] : a ∈ t → t.get? a = some (t.get! a)

theorem Std.DTreeMap.Internal.Impl.get!_eq_get!_get? {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] [LawfulEqOrd α] (h : t.WF) {a : α} [Inhabited (β a)] : t.get! a = (t.get? a).get!

theorem Std.DTreeMap.Internal.Impl.get_eq_get! {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] [LawfulEqOrd α] (h : t.WF) {a : α} [Inhabited (β a)] {h✝ : a ∈ t} : t.get a h✝ = t.get! a

theorem Std.DTreeMap.Internal.Impl.Const.get!_empty {α : Type u} {instOrd : Ord α} {β : Type v} [TransOrd α] [Inhabited β] {a : α} : get! empty a = default

theorem Std.DTreeMap.Internal.Impl.Const.get!_of_isEmpty {α : Type u} {instOrd : Ord α} {β : Type v} {t : Impl α fun (x : α) => β} [TransOrd α] [Inhabited β] (h : t.WF) {a : α} : t.isEmpty = true → get! t a = default

theorem Std.DTreeMap.Internal.Impl.Const.get!_insert {α : Type u} {instOrd : Ord α} {β : Type v} {t : Impl α fun (x : α) => β} [TransOrd α] [Inhabited β] (h : t.WF) {k a : α} {v : β} : get! (insert k v t ⋯).impl a = if compare k a = Ordering.eq then v else get! t a

theorem Std.DTreeMap.Internal.Impl.Const.get!_insert! {α : Type u} {instOrd : Ord α} {β : Type v} {t : Impl α fun (x : α) => β} [TransOrd α] [Inhabited β] (h : t.WF) {k a : α} {v : β} : get! (insert! k v t) a = if compare k a = Ordering.eq then v else get! t a

theorem Std.DTreeMap.Internal.Impl.Const.get!_insert_self {α : Type u} {instOrd : Ord α} {β : Type v} {t : Impl α fun (x : α) => β} [TransOrd α] [Inhabited β] (h : t.WF) {k : α} {v : β} : get! (insert k v t ⋯).impl k = v

theorem Std.DTreeMap.Internal.Impl.Const.get!_insert!_self {α : Type u} {instOrd : Ord α} {β : Type v} {t : Impl α fun (x : α) => β} [TransOrd α] [Inhabited β] (h : t.WF) {k : α} {v : β} : get! (insert! k v t) k = v

theorem Std.DTreeMap.Internal.Impl.Const.get!_eq_default_of_contains_eq_false {α : Type u} {instOrd : Ord α} {β : Type v} {t : Impl α fun (x : α) => β} [TransOrd α] [Inhabited β] (h : t.WF) {a : α} : contains a t = false → get! t a = default

theorem Std.DTreeMap.Internal.Impl.Const.get!_eq_default {α : Type u} {instOrd : Ord α} {β : Type v} {t : Impl α fun (x : α) => β} [TransOrd α] [Inhabited β] (h : t.WF) {a : α} : ¬a ∈ t → get! t a = default

theorem Std.DTreeMap.Internal.Impl.Const.get!_erase {α : Type u} {instOrd : Ord α} {β : Type v} {t : Impl α fun (x : α) => β} [TransOrd α] [Inhabited β] (h : t.WF) {k a : α} : get! (erase k t ⋯).impl a = if compare k a = Ordering.eq then default else get! t a

theorem Std.DTreeMap.Internal.Impl.Const.get!_erase! {α : Type u} {instOrd : Ord α} {β : Type v} {t : Impl α fun (x : α) => β} [TransOrd α] [Inhabited β] (h : t.WF) {k a : α} : get! (erase! k t) a = if compare k a = Ordering.eq then default else get! t a

theorem Std.DTreeMap.Internal.Impl.Const.get!_erase_self {α : Type u} {instOrd : Ord α} {β : Type v} {t : Impl α fun (x : α) => β} [TransOrd α] [Inhabited β] (h : t.WF) {k : α} : get! (erase k t ⋯).impl k = default

theorem Std.DTreeMap.Internal.Impl.Const.get!_erase!_self {α : Type u} {instOrd : Ord α} {β : Type v} {t : Impl α fun (x : α) => β} [TransOrd α] [Inhabited β] (h : t.WF) {k : α} : get! (erase! k t) k = default

theorem Std.DTreeMap.Internal.Impl.Const.get?_eq_some_get!_of_contains {α : Type u} {instOrd : Ord α} {β : Type v} {t : Impl α fun (x : α) => β} [TransOrd α] [Inhabited β] (h : t.WF) {a : α} : contains a t = true → get? t a = some (get! t a)

theorem Std.DTreeMap.Internal.Impl.Const.get?_eq_some_get! {α : Type u} {instOrd : Ord α} {β : Type v} {t : Impl α fun (x : α) => β} [TransOrd α] [Inhabited β] (h : t.WF) {a : α} : a ∈ t → get? t a = some (get! t a)

theorem Std.DTreeMap.Internal.Impl.Const.get!_eq_get!_get? {α : Type u} {instOrd : Ord α} {β : Type v} {t : Impl α fun (x : α) => β} [TransOrd α] [Inhabited β] (h : t.WF) {a : α} : get! t a = (get? t a).get!

theorem Std.DTreeMap.Internal.Impl.Const.get_eq_get! {α : Type u} {instOrd : Ord α} {β : Type v} {t : Impl α fun (x : α) => β} [TransOrd α] [Inhabited β] (h : t.WF) {a : α} {h✝ : contains a t = true} : get t a h✝ = get! t a

theorem Std.DTreeMap.Internal.Impl.Const.get!_eq_get! {α : Type u} {instOrd : Ord α} {β : Type v} {t : Impl α fun (x : α) => β} [TransOrd α] [LawfulEqOrd α] [Inhabited β] (h : t.WF) {a : α} : get! t a = t.get! a

theorem Std.DTreeMap.Internal.Impl.Const.get!_congr {α : Type u} {instOrd : Ord α} {β : Type v} {t : Impl α fun (x : α) => β} [TransOrd α] [Inhabited β] (h : t.WF) {a b : α} (hab : compare a b = Ordering.eq) : get! t a = get! t b

theorem Std.DTreeMap.Internal.Impl.getD_empty {α : Type u} {β : α → Type v} {instOrd : Ord α} [TransOrd α] [LawfulEqOrd α] {a : α} {fallback : β a} : empty.getD a fallback = fallback

theorem Std.DTreeMap.Internal.Impl.getD_of_isEmpty {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] [LawfulEqOrd α] (h : t.WF) {a : α} {fallback : β a} : t.isEmpty = true → t.getD a fallback = fallback

theorem Std.DTreeMap.Internal.Impl.getD_insert {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] [LawfulEqOrd α] (h : t.WF) {k a : α} {fallback : β a} {v : β k} : (insert k v t ⋯).impl.getD a fallback = if h : compare k a = Ordering.eq then cast ⋯ v else t.getD a fallback

theorem Std.DTreeMap.Internal.Impl.getD_insert! {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] [LawfulEqOrd α] (h : t.WF) {k a : α} {fallback : β a} {v : β k} : (insert! k v t).getD a fallback = if h : compare k a = Ordering.eq then cast ⋯ v else t.getD a fallback

theorem Std.DTreeMap.Internal.Impl.getD_insert_self {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] [LawfulEqOrd α] (h : t.WF) {a : α} {fallback b : β a} : (insert a b t ⋯).impl.getD a fallback = b

theorem Std.DTreeMap.Internal.Impl.getD_insert!_self {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] [LawfulEqOrd α] (h : t.WF) {a : α} {fallback b : β a} : (insert! a b t).getD a fallback = b

theorem Std.DTreeMap.Internal.Impl.getD_eq_fallback_of_contains_eq_false {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] [LawfulEqOrd α] (h : t.WF) {a : α} {fallback : β a} : contains a t = false → t.getD a fallback = fallback

theorem Std.DTreeMap.Internal.Impl.getD_eq_fallback {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] [LawfulEqOrd α] (h : t.WF) {a : α} {fallback : β a} : ¬a ∈ t → t.getD a fallback = fallback

theorem Std.DTreeMap.Internal.Impl.getD_erase {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] [LawfulEqOrd α] (h : t.WF) {k a : α} {fallback : β a} : (erase k t ⋯).impl.getD a fallback = if compare k a = Ordering.eq then fallback else t.getD a fallback

theorem Std.DTreeMap.Internal.Impl.getD_erase! {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] [LawfulEqOrd α] (h : t.WF) {k a : α} {fallback : β a} : (erase! k t).getD a fallback = if compare k a = Ordering.eq then fallback else t.getD a fallback

theorem Std.DTreeMap.Internal.Impl.getD_erase_self {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] [LawfulEqOrd α] (h : t.WF) {k : α} {fallback : β k} : (erase k t ⋯).impl.getD k fallback = fallback

theorem Std.DTreeMap.Internal.Impl.getD_erase!_self {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] [LawfulEqOrd α] (h : t.WF) {k : α} {fallback : β k} : (erase! k t).getD k fallback = fallback

theorem Std.DTreeMap.Internal.Impl.get?_eq_some_getD_of_contains {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] [LawfulEqOrd α] (h : t.WF) {a : α} {fallback : β a} : contains a t = true → t.get? a = some (t.getD a fallback)

theorem Std.DTreeMap.Internal.Impl.get?_eq_some_getD {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] [LawfulEqOrd α] (h : t.WF) {a : α} {fallback : β a} : a ∈ t → t.get? a = some (t.getD a fallback)

theorem Std.DTreeMap.Internal.Impl.getD_eq_getD_get? {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] [LawfulEqOrd α] (h : t.WF) {a : α} {fallback : β a} : t.getD a fallback = (t.get? a).getD fallback

theorem Std.DTreeMap.Internal.Impl.get_eq_getD {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] [LawfulEqOrd α] (h : t.WF) {a : α} {fallback : β a} {h✝ : a ∈ t} : t.get a h✝ = t.getD a fallback

theorem Std.DTreeMap.Internal.Impl.get!_eq_getD_default {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] [LawfulEqOrd α] (h : t.WF) {a : α} [Inhabited (β a)] : t.get! a = t.getD a default

theorem Std.DTreeMap.Internal.Impl.Const.getD_empty {α : Type u} {instOrd : Ord α} {β : Type v} [TransOrd α] {a : α} {fallback : β} : getD empty a fallback = fallback

theorem Std.DTreeMap.Internal.Impl.Const.getD_of_isEmpty {α : Type u} {instOrd : Ord α} {β : Type v} {t : Impl α fun (x : α) => β} [TransOrd α] (h : t.WF) {a : α} {fallback : β} : t.isEmpty = true → getD t a fallback = fallback

theorem Std.DTreeMap.Internal.Impl.Const.getD_insert {α : Type u} {instOrd : Ord α} {β : Type v} {t : Impl α fun (x : α) => β} [TransOrd α] (h : t.WF) {k a : α} {fallback v : β} : getD (insert k v t ⋯).impl a fallback = if compare k a = Ordering.eq then v else getD t a fallback

theorem Std.DTreeMap.Internal.Impl.Const.getD_insert! {α : Type u} {instOrd : Ord α} {β : Type v} {t : Impl α fun (x : α) => β} [TransOrd α] (h : t.WF) {k a : α} {fallback v : β} : getD (insert! k v t) a fallback = if compare k a = Ordering.eq then v else getD t a fallback

theorem Std.DTreeMap.Internal.Impl.Const.getD_insert_self {α : Type u} {instOrd : Ord α} {β : Type v} {t : Impl α fun (x : α) => β} [TransOrd α] (h : t.WF) {k : α} {fallback v : β} : getD (insert k v t ⋯).impl k fallback = v

theorem Std.DTreeMap.Internal.Impl.Const.getD_insert!_self {α : Type u} {instOrd : Ord α} {β : Type v} {t : Impl α fun (x : α) => β} [TransOrd α] (h : t.WF) {k : α} {fallback v : β} : getD (insert! k v t) k fallback = v

theorem Std.DTreeMap.Internal.Impl.Const.getD_eq_fallback_of_contains_eq_false {α : Type u} {instOrd : Ord α} {β : Type v} {t : Impl α fun (x : α) => β} [TransOrd α] (h : t.WF) {a : α} {fallback : β} : contains a t = false → getD t a fallback = fallback

theorem Std.DTreeMap.Internal.Impl.Const.getD_eq_fallback {α : Type u} {instOrd : Ord α} {β : Type v} {t : Impl α fun (x : α) => β} [TransOrd α] (h : t.WF) {a : α} {fallback : β} : ¬a ∈ t → getD t a fallback = fallback

theorem Std.DTreeMap.Internal.Impl.Const.getD_erase {α : Type u} {instOrd : Ord α} {β : Type v} {t : Impl α fun (x : α) => β} [TransOrd α] (h : t.WF) {k a : α} {fallback : β} : getD (erase k t ⋯).impl a fallback = if compare k a = Ordering.eq then fallback else getD t a fallback

theorem Std.DTreeMap.Internal.Impl.Const.getD_erase! {α : Type u} {instOrd : Ord α} {β : Type v} {t : Impl α fun (x : α) => β} [TransOrd α] (h : t.WF) {k a : α} {fallback : β} : getD (erase! k t) a fallback = if compare k a = Ordering.eq then fallback else getD t a fallback

theorem Std.DTreeMap.Internal.Impl.Const.getD_erase_self {α : Type u} {instOrd : Ord α} {β : Type v} {t : Impl α fun (x : α) => β} [TransOrd α] (h : t.WF) {k : α} {fallback : β} : getD (erase k t ⋯).impl k fallback = fallback

theorem Std.DTreeMap.Internal.Impl.Const.getD_erase!_self {α : Type u} {instOrd : Ord α} {β : Type v} {t : Impl α fun (x : α) => β} [TransOrd α] (h : t.WF) {k : α} {fallback : β} : getD (erase! k t) k fallback = fallback

theorem Std.DTreeMap.Internal.Impl.Const.get?_eq_some_getD_of_contains {α : Type u} {instOrd : Ord α} {β : Type v} {t : Impl α fun (x : α) => β} [TransOrd α] (h : t.WF) {a : α} {fallback : β} : contains a t = true → get? t a = some (getD t a fallback)

theorem Std.DTreeMap.Internal.Impl.Const.get?_eq_some_getD {α : Type u} {instOrd : Ord α} {β : Type v} {t : Impl α fun (x : α) => β} [TransOrd α] (h : t.WF) {a : α} {fallback : β} : a ∈ t → get? t a = some (getD t a fallback)

theorem Std.DTreeMap.Internal.Impl.Const.getD_eq_getD_get? {α : Type u} {instOrd : Ord α} {β : Type v} {t : Impl α fun (x : α) => β} [TransOrd α] (h : t.WF) {a : α} {fallback : β} : getD t a fallback = (get? t a).getD fallback

theorem Std.DTreeMap.Internal.Impl.Const.get_eq_getD {α : Type u} {instOrd : Ord α} {β : Type v} {t : Impl α fun (x : α) => β} [TransOrd α] (h : t.WF) {a : α} {fallback : β} {h✝ : contains a t = true} : get t a h✝ = getD t a fallback

theorem Std.DTreeMap.Internal.Impl.Const.get!_eq_getD_default {α : Type u} {instOrd : Ord α} {β : Type v} {t : Impl α fun (x : α) => β} [TransOrd α] [Inhabited β] (h : t.WF) {a : α} : get! t a = getD t a default

theorem Std.DTreeMap.Internal.Impl.Const.getD_eq_getD {α : Type u} {instOrd : Ord α} {β : Type v} {t : Impl α fun (x : α) => β} [TransOrd α] [LawfulEqOrd α] (h : t.WF) {a : α} {fallback : β} : getD t a fallback = t.getD a fallback

theorem Std.DTreeMap.Internal.Impl.Const.getD_congr {α : Type u} {instOrd : Ord α} {β : Type v} {t : Impl α fun (x : α) => β} [TransOrd α] (h : t.WF) {a b : α} {fallback : β} (hab : compare a b = Ordering.eq) : getD t a fallback = getD t b fallback

theorem Std.DTreeMap.Internal.Impl.getKey?_empty {α : Type u} {β : α → Type v} {instOrd : Ord α} {a : α} : empty.getKey? a = none

theorem Std.DTreeMap.Internal.Impl.getKey?_of_isEmpty {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] (h : t.WF) {a : α} : t.isEmpty = true → t.getKey? a = none

theorem Std.DTreeMap.Internal.Impl.getKey?_insert {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] (h : t.WF) {a k : α} {v : β k} : (insert k v t ⋯).impl.getKey? a = if compare k a = Ordering.eq then some k else t.getKey? a

theorem Std.DTreeMap.Internal.Impl.getKey?_insert! {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] (h : t.WF) {a k : α} {v : β k} : (insert! k v t).getKey? a = if compare k a = Ordering.eq then some k else t.getKey? a

theorem Std.DTreeMap.Internal.Impl.getKey?_insert_self {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] (h : t.WF) {k : α} {v : β k} : (insert k v t ⋯).impl.getKey? k = some k

theorem Std.DTreeMap.Internal.Impl.getKey?_insert!_self {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] (h : t.WF) {k : α} {v : β k} : (insert! k v t).getKey? k = some k

theorem Std.DTreeMap.Internal.Impl.contains_eq_isSome_getKey? {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] (h : t.WF) {a : α} : contains a t = (t.getKey? a).isSome

theorem Std.DTreeMap.Internal.Impl.mem_iff_isSome_getKey? {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] (h : t.WF) {a : α} : a ∈ t ↔ (t.getKey? a).isSome = true

theorem Std.DTreeMap.Internal.Impl.mem_of_getKey?_eq_some {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] {a a' : α} (h : t.WF) : t.getKey? a = some a' → a' ∈ t

theorem Std.DTreeMap.Internal.Impl.getKey?_eq_some_iff {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] {k k' : α} (h : t.WF) : t.getKey? k = some k' ↔ ∃ (h : contains k t = true), t.getKey k h = k'

theorem Std.DTreeMap.Internal.Impl.getKey?_eq_none_of_contains_eq_false {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] (h : t.WF) {a : α} : contains a t = false → t.getKey? a = none

theorem Std.DTreeMap.Internal.Impl.getKey?_eq_none {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] (h : t.WF) {a : α} : ¬a ∈ t → t.getKey? a = none

theorem Std.DTreeMap.Internal.Impl.getKey?_erase {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] (h : t.WF) {k a : α} : (erase k t ⋯).impl.getKey? a = if compare k a = Ordering.eq then none else t.getKey? a

theorem Std.DTreeMap.Internal.Impl.getKey?_erase! {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] (h : t.WF) {k a : α} : (erase! k t).getKey? a = if compare k a = Ordering.eq then none else t.getKey? a

theorem Std.DTreeMap.Internal.Impl.getKey?_erase_self {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] (h : t.WF) {k : α} : (erase k t ⋯).impl.getKey? k = none

theorem Std.DTreeMap.Internal.Impl.getKey?_erase!_self {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] (h : t.WF) {k : α} : (erase! k t).getKey? k = none

theorem Std.DTreeMap.Internal.Impl.compare_getKey?_self {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] (h : t.WF) {k : α} : Option.all (fun (x : α) => decide (compare x k = Ordering.eq)) (t.getKey? k) = true

theorem Std.DTreeMap.Internal.Impl.getKey?_congr {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] (h : t.WF) {k k' : α} (h' : compare k k' = Ordering.eq) : t.getKey? k = t.getKey? k'

theorem Std.DTreeMap.Internal.Impl.getKey?_eq_some_of_contains {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] [LawfulEqOrd α] (h : t.WF) {k : α} (h' : contains k t = true) : t.getKey? k = some k

theorem Std.DTreeMap.Internal.Impl.getKey?_eq_some {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] [LawfulEqOrd α] (h : t.WF) {k : α} (h' : k ∈ t) : t.getKey? k = some k

theorem Std.DTreeMap.Internal.Impl.getKey_insert {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] (h : t.WF) {k a : α} {v : β k} {h₁ : contains a (insert k v t ⋯).impl = true} : (insert k v t ⋯).impl.getKey a h₁ = if h₂ : compare k a = Ordering.eq then k else t.getKey a ⋯

theorem Std.DTreeMap.Internal.Impl.getKey_insert! {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] (h : t.WF) {k a : α} {v : β k} {h₁ : contains a (insert! k v t) = true} : (insert! k v t).getKey a h₁ = if h₂ : compare k a = Ordering.eq then k else t.getKey a ⋯

theorem Std.DTreeMap.Internal.Impl.getKey_insert_self {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] (h : t.WF) {k : α} {v : β k} : (insert k v t ⋯).impl.getKey k ⋯ = k

theorem Std.DTreeMap.Internal.Impl.getKey_insert!_self {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] (h : t.WF) {k : α} {v : β k} : (insert! k v t).getKey k ⋯ = k

@[simp]

theorem Std.DTreeMap.Internal.Impl.getKey_erase {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] (h : t.WF) {k a : α} {h' : contains a (erase k t ⋯).impl = true} : (erase k t ⋯).impl.getKey a h' = t.getKey a ⋯

@[simp]

theorem Std.DTreeMap.Internal.Impl.getKey_erase! {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] (h : t.WF) {k a : α} {h' : contains a (erase! k t) = true} : (erase! k t).getKey a h' = t.getKey a ⋯

theorem Std.DTreeMap.Internal.Impl.getKey?_eq_some_getKey {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] (h : t.WF) {a : α} {h' : contains a t = true} : t.getKey? a = some (t.getKey a h')

theorem Std.DTreeMap.Internal.Impl.compare_getKey_self {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] (h : t.WF) {k : α} (h' : k ∈ t) : compare (t.getKey k h') k = Ordering.eq

theorem Std.DTreeMap.Internal.Impl.getKey_congr {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] (h : t.WF) {k₁ k₂ : α} (h' : compare k₁ k₂ = Ordering.eq) (h₁ : k₁ ∈ t) : t.getKey k₁ h₁ = t.getKey k₂ ⋯

theorem Std.DTreeMap.Internal.Impl.getKey_eq {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] [LawfulEqOrd α] (h : t.WF) {k : α} (h' : k ∈ t) : t.getKey k h' = k

theorem Std.DTreeMap.Internal.Impl.getKey!_empty {α : Type u} {β : α → Type v} {instOrd : Ord α} {a : α} [Inhabited α] : empty.getKey! a = default

theorem Std.DTreeMap.Internal.Impl.getKey!_of_isEmpty {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] [Inhabited α] (h : t.WF) {a : α} : t.isEmpty = true → t.getKey! a = default

theorem Std.DTreeMap.Internal.Impl.getKey!_insert {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] [Inhabited α] (h : t.WF) {k a : α} {v : β k} : (insert k v t ⋯).impl.getKey! a = if compare k a = Ordering.eq then k else t.getKey! a

theorem Std.DTreeMap.Internal.Impl.getKey!_insert! {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] [Inhabited α] (h : t.WF) {k a : α} {v : β k} : (insert! k v t).getKey! a = if compare k a = Ordering.eq then k else t.getKey! a

theorem Std.DTreeMap.Internal.Impl.getKey!_insert_self {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] [Inhabited α] (h : t.WF) {a : α} {b : β a} : (insert a b t ⋯).impl.getKey! a = a

theorem Std.DTreeMap.Internal.Impl.getKey!_insert!_self {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] [Inhabited α] (h : t.WF) {a : α} {b : β a} : (insert! a b t).getKey! a = a

theorem Std.DTreeMap.Internal.Impl.getKey!_eq_default_of_contains_eq_false {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] [Inhabited α] (h : t.WF) {a : α} : contains a t = false → t.getKey! a = default

theorem Std.DTreeMap.Internal.Impl.getKey!_eq_default {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] [Inhabited α] (h : t.WF) {a : α} : ¬a ∈ t → t.getKey! a = default

theorem Std.DTreeMap.Internal.Impl.getKey!_erase {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] [Inhabited α] (h : t.WF) {k a : α} : (erase k t ⋯).impl.getKey! a = if compare k a = Ordering.eq then default else t.getKey! a

theorem Std.DTreeMap.Internal.Impl.getKey!_erase! {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] [Inhabited α] (h : t.WF) {k a : α} : (erase! k t).getKey! a = if compare k a = Ordering.eq then default else t.getKey! a

theorem Std.DTreeMap.Internal.Impl.getKey!_erase_self {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] [Inhabited α] (h : t.WF) {k : α} : (erase k t ⋯).impl.getKey! k = default

theorem Std.DTreeMap.Internal.Impl.getKey!_erase!_self {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] [Inhabited α] (h : t.WF) {k : α} : (erase! k t).getKey! k = default

theorem Std.DTreeMap.Internal.Impl.getKey?_eq_some_getKey!_of_contains {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] [Inhabited α] (h : t.WF) {a : α} : contains a t = true → t.getKey? a = some (t.getKey! a)

theorem Std.DTreeMap.Internal.Impl.getKey?_eq_some_getKey! {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] [Inhabited α] (h : t.WF) {a : α} : a ∈ t → t.getKey? a = some (t.getKey! a)

theorem Std.DTreeMap.Internal.Impl.getKey!_eq_get!_getKey? {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] [Inhabited α] (h : t.WF) {a : α} : t.getKey! a = (t.getKey? a).get!

theorem Std.DTreeMap.Internal.Impl.getKey_eq_getKey! {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] [Inhabited α] (h : t.WF) {a : α} {h✝ : contains a t = true} : t.getKey a h✝ = t.getKey! a

theorem Std.DTreeMap.Internal.Impl.getKey!_congr {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] [Inhabited α] (h : t.WF) {k k' : α} (h' : compare k k' = Ordering.eq) : t.getKey! k = t.getKey! k'

theorem Std.DTreeMap.Internal.Impl.getKey!_eq_of_contains {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] [LawfulEqOrd α] [Inhabited α] (h : t.WF) {k : α} (h' : contains k t = true) : t.getKey! k = k

theorem Std.DTreeMap.Internal.Impl.getKey!_eq_of_mem {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] [LawfulEqOrd α] [Inhabited α] (h : t.WF) {k : α} (h' : k ∈ t) : t.getKey! k = k

theorem Std.DTreeMap.Internal.Impl.getKeyD_empty {α : Type u} {β : α → Type v} {instOrd : Ord α} {a fallback : α} : empty.getKeyD a fallback = fallback

theorem Std.DTreeMap.Internal.Impl.getKeyD_of_isEmpty {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] (h : t.WF) {a fallback : α} : t.isEmpty = true → t.getKeyD a fallback = fallback

theorem Std.DTreeMap.Internal.Impl.getKeyD_insert {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] (h : t.WF) {k a fallback : α} {v : β k} : (insert k v t ⋯).impl.getKeyD a fallback = if compare k a = Ordering.eq then k else t.getKeyD a fallback

theorem Std.DTreeMap.Internal.Impl.getKeyD_insert! {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] (h : t.WF) {k a fallback : α} {v : β k} : (insert! k v t).getKeyD a fallback = if compare k a = Ordering.eq then k else t.getKeyD a fallback

theorem Std.DTreeMap.Internal.Impl.getKeyD_insert_self {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] (h : t.WF) {a fallback : α} {b : β a} : (insert a b t ⋯).impl.getKeyD a fallback = a

theorem Std.DTreeMap.Internal.Impl.getKeyD_insert!_self {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] (h : t.WF) {a fallback : α} {b : β a} : (insert! a b t).getKeyD a fallback = a

theorem Std.DTreeMap.Internal.Impl.getKeyD_eq_fallback_of_contains_eq_false {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] (h : t.WF) {a fallback : α} : contains a t = false → t.getKeyD a fallback = fallback

theorem Std.DTreeMap.Internal.Impl.getKeyD_eq_fallback {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] (h : t.WF) {a fallback : α} : ¬a ∈ t → t.getKeyD a fallback = fallback

theorem Std.DTreeMap.Internal.Impl.getKeyD_erase {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] (h : t.WF) {k a fallback : α} : (erase k t ⋯).impl.getKeyD a fallback = if compare k a = Ordering.eq then fallback else t.getKeyD a fallback

theorem Std.DTreeMap.Internal.Impl.getKeyD_erase! {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] (h : t.WF) {k a fallback : α} : (erase! k t).getKeyD a fallback = if compare k a = Ordering.eq then fallback else t.getKeyD a fallback

theorem Std.DTreeMap.Internal.Impl.getKeyD_erase_self {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] (h : t.WF) {k fallback : α} : (erase k t ⋯).impl.getKeyD k fallback = fallback

theorem Std.DTreeMap.Internal.Impl.getKeyD_erase!_self {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] (h : t.WF) {k fallback : α} : (erase! k t).getKeyD k fallback = fallback

theorem Std.DTreeMap.Internal.Impl.getKey?_eq_some_getKeyD_of_contains {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] (h : t.WF) {a fallback : α} : contains a t = true → t.getKey? a = some (t.getKeyD a fallback)

theorem Std.DTreeMap.Internal.Impl.getKey?_eq_some_getKeyD {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] (h : t.WF) {a fallback : α} : a ∈ t → t.getKey? a = some (t.getKeyD a fallback)

theorem Std.DTreeMap.Internal.Impl.getKeyD_eq_getD_getKey? {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] (h : t.WF) {a fallback : α} : t.getKeyD a fallback = (t.getKey? a).getD fallback

theorem Std.DTreeMap.Internal.Impl.getKey_eq_getKeyD {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] (h : t.WF) {a fallback : α} {h✝ : contains a t = true} : t.getKey a h✝ = t.getKeyD a fallback

theorem Std.DTreeMap.Internal.Impl.getKey!_eq_getKeyD_default {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] [Inhabited α] (h : t.WF) {a : α} : t.getKey! a = t.getKeyD a default

theorem Std.DTreeMap.Internal.Impl.getKeyD_congr {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] (h : t.WF) {k k' fallback : α} (h' : compare k k' = Ordering.eq) : t.getKeyD k fallback = t.getKeyD k' fallback

theorem Std.DTreeMap.Internal.Impl.getKeyD_eq_of_contains {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] [LawfulEqOrd α] (h : t.WF) {k fallback : α} (h' : contains k t = true) : t.getKeyD k fallback = k

theorem Std.DTreeMap.Internal.Impl.getKeyD_eq_of_mem {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] [LawfulEqOrd α] (h : t.WF) {k fallback : α} (h' : k ∈ t) : t.getKeyD k fallback = k

theorem Std.DTreeMap.Internal.Impl.mem_of_mem_insertIfNew' {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] (h : t.WF) {k a : α} {v : β k} : a ∈ (insertIfNew k v t ⋯).impl → ¬(compare k a = Ordering.eq ∧ ¬k ∈ t) → a ∈ t

This is a restatement of mem_of_mem_insertIfNew that is written to exactly match the proof obligation in the statement of get_insertIfNew.

theorem Std.DTreeMap.Internal.Impl.mem_of_mem_insertIfNew!' {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] (h : t.WF) {k a : α} {v : β k} : a ∈ insertIfNew! k v t → ¬(compare k a = Ordering.eq ∧ ¬k ∈ t) → a ∈ t

This is a restatement of mem_of_mem_insertIfNew! that is written to exactly match the proof obligation in the statement of get_insertIfNew!.

theorem Std.DTreeMap.Internal.Impl.get?_insertIfNew {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] [LawfulEqOrd α] (h : t.WF) {k a : α} {v : β k} : (insertIfNew k v t ⋯).impl.get? a = if h : compare k a = Ordering.eq ∧ ¬k ∈ t then some (cast ⋯ v) else t.get? a

theorem Std.DTreeMap.Internal.Impl.get?_insertIfNew! {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] [LawfulEqOrd α] (h : t.WF) {k a : α} {v : β k} : (insertIfNew! k v t).get? a = if h : compare k a = Ordering.eq ∧ ¬k ∈ t then some (cast ⋯ v) else t.get? a

theorem Std.DTreeMap.Internal.Impl.get_insertIfNew {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] [LawfulEqOrd α] (h : t.WF) {k a : α} {v : β k} {h₁ : a ∈ (insertIfNew k v t ⋯).impl} : (insertIfNew k v t ⋯).impl.get a h₁ = if h₂ : compare k a = Ordering.eq ∧ ¬k ∈ t then cast ⋯ v else t.get a ⋯

theorem Std.DTreeMap.Internal.Impl.get_insertIfNew! {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] [LawfulEqOrd α] (h : t.WF) {k a : α} {v : β k} {h₁ : a ∈ insertIfNew! k v t} : (insertIfNew! k v t).get a h₁ = if h₂ : compare k a = Ordering.eq ∧ ¬k ∈ t then cast ⋯ v else t.get a ⋯

theorem Std.DTreeMap.Internal.Impl.get!_insertIfNew {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] [LawfulEqOrd α] (h : t.WF) {k a : α} [Inhabited (β a)] {v : β k} : (insertIfNew k v t ⋯).impl.get! a = if h : compare k a = Ordering.eq ∧ ¬k ∈ t then cast ⋯ v else t.get! a

theorem Std.DTreeMap.Internal.Impl.get!_insertIfNew! {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] [LawfulEqOrd α] (h : t.WF) {k a : α} [Inhabited (β a)] {v : β k} : (insertIfNew! k v t).get! a = if h : compare k a = Ordering.eq ∧ ¬k ∈ t then cast ⋯ v else t.get! a

theorem Std.DTreeMap.Internal.Impl.getD_insertIfNew {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] [LawfulEqOrd α] (h : t.WF) {k a : α} {fallback : β a} {v : β k} : (insertIfNew k v t ⋯).impl.getD a fallback = if h : compare k a = Ordering.eq ∧ ¬k ∈ t then cast ⋯ v else t.getD a fallback

theorem Std.DTreeMap.Internal.Impl.getD_insertIfNew! {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] [LawfulEqOrd α] (h : t.WF) {k a : α} {fallback : β a} {v : β k} : (insertIfNew! k v t).getD a fallback = if h : compare k a = Ordering.eq ∧ ¬k ∈ t then cast ⋯ v else t.getD a fallback

theorem Std.DTreeMap.Internal.Impl.Const.get?_insertIfNew {α : Type u} {instOrd : Ord α} {β : Type v} {t : Impl α fun (x : α) => β} [TransOrd α] (h : t.WF) {k a : α} {v : β} : get? (insertIfNew k v t ⋯).impl a = if compare k a = Ordering.eq ∧ ¬k ∈ t then some v else get? t a

theorem Std.DTreeMap.Internal.Impl.Const.get?_insertIfNew! {α : Type u} {instOrd : Ord α} {β : Type v} {t : Impl α fun (x : α) => β} [TransOrd α] (h : t.WF) {k a : α} {v : β} : get? (insertIfNew! k v t) a = if compare k a = Ordering.eq ∧ ¬k ∈ t then some v else get? t a

theorem Std.DTreeMap.Internal.Impl.Const.get_insertIfNew {α : Type u} {instOrd : Ord α} {β : Type v} {t : Impl α fun (x : α) => β} [TransOrd α] (h : t.WF) {k a : α} {v : β} {h₁ : contains a (insertIfNew k v t ⋯).impl = true} : get (insertIfNew k v t ⋯).impl a h₁ = if h₂ : compare k a = Ordering.eq ∧ ¬k ∈ t then v else get t a ⋯

theorem Std.DTreeMap.Internal.Impl.Const.get_insertIfNew! {α : Type u} {instOrd : Ord α} {β : Type v} {t : Impl α fun (x : α) => β} [TransOrd α] (h : t.WF) {k a : α} {v : β} {h₁ : contains a (insertIfNew! k v t) = true} : get (insertIfNew! k v t) a h₁ = if h₂ : compare k a = Ordering.eq ∧ ¬k ∈ t then v else get t a ⋯

theorem Std.DTreeMap.Internal.Impl.Const.get!_insertIfNew {α : Type u} {instOrd : Ord α} {β : Type v} {t : Impl α fun (x : α) => β} [TransOrd α] [Inhabited β] (h : t.WF) {k a : α} {v : β} : get! (insertIfNew k v t ⋯).impl a = if compare k a = Ordering.eq ∧ ¬k ∈ t then v else get! t a

theorem Std.DTreeMap.Internal.Impl.Const.get!_insertIfNew! {α : Type u} {instOrd : Ord α} {β : Type v} {t : Impl α fun (x : α) => β} [TransOrd α] [Inhabited β] (h : t.WF) {k a : α} {v : β} : get! (insertIfNew! k v t) a = if compare k a = Ordering.eq ∧ ¬k ∈ t then v else get! t a

theorem Std.DTreeMap.Internal.Impl.Const.getD_insertIfNew {α : Type u} {instOrd : Ord α} {β : Type v} {t : Impl α fun (x : α) => β} [TransOrd α] (h : t.WF) {k a : α} {fallback v : β} : getD (insertIfNew k v t ⋯).impl a fallback = if compare k a = Ordering.eq ∧ ¬k ∈ t then v else getD t a fallback

theorem Std.DTreeMap.Internal.Impl.Const.getD_insertIfNew! {α : Type u} {instOrd : Ord α} {β : Type v} {t : Impl α fun (x : α) => β} [TransOrd α] (h : t.WF) {k a : α} {fallback v : β} : getD (insertIfNew! k v t) a fallback = if compare k a = Ordering.eq ∧ ¬k ∈ t then v else getD t a fallback

theorem Std.DTreeMap.Internal.Impl.getKey?_insertIfNew {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] (h : t.WF) {k a : α} {v : β k} : (insertIfNew k v t ⋯).impl.getKey? a = if compare k a = Ordering.eq ∧ ¬k ∈ t then some k else t.getKey? a

theorem Std.DTreeMap.Internal.Impl.getKey?_insertIfNew! {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] (h : t.WF) {k a : α} {v : β k} : (insertIfNew! k v t).getKey? a = if compare k a = Ordering.eq ∧ ¬k ∈ t then some k else t.getKey? a

theorem Std.DTreeMap.Internal.Impl.getKey_insertIfNew {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] (h : t.WF) {k a : α} {v : β k} {h₁ : contains a (insertIfNew k v t ⋯).impl = true} : (insertIfNew k v t ⋯).impl.getKey a h₁ = if h₂ : compare k a = Ordering.eq ∧ ¬k ∈ t then k else t.getKey a ⋯

theorem Std.DTreeMap.Internal.Impl.getKey_insertIfNew! {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] (h : t.WF) {k a : α} {v : β k} {h₁ : contains a (insertIfNew! k v t) = true} : (insertIfNew! k v t).getKey a h₁ = if h₂ : compare k a = Ordering.eq ∧ ¬k ∈ t then k else t.getKey a ⋯

theorem Std.DTreeMap.Internal.Impl.getKey!_insertIfNew {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] [Inhabited α] (h : t.WF) {k a : α} {v : β k} : (insertIfNew k v t ⋯).impl.getKey! a = if compare k a = Ordering.eq ∧ ¬k ∈ t then k else t.getKey! a

theorem Std.DTreeMap.Internal.Impl.getKey!_insertIfNew! {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] [Inhabited α] (h : t.WF) {k a : α} {v : β k} : (insertIfNew! k v t).getKey! a = if compare k a = Ordering.eq ∧ ¬k ∈ t then k else t.getKey! a

theorem Std.DTreeMap.Internal.Impl.getKeyD_insertIfNew {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] (h : t.WF) {k a fallback : α} {v : β k} : (insertIfNew k v t ⋯).impl.getKeyD a fallback = if compare k a = Ordering.eq ∧ ¬k ∈ t then k else t.getKeyD a fallback

theorem Std.DTreeMap.Internal.Impl.getKeyD_insertIfNew! {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] (h : t.WF) {k a fallback : α} {v : β k} : (insertIfNew! k v t).getKeyD a fallback = if compare k a = Ordering.eq ∧ ¬k ∈ t then k else t.getKeyD a fallback

getThenInsertIfNew?

theorem Std.DTreeMap.Internal.Impl.getThenInsertIfNew?_fst {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] [LawfulEqOrd α] (h : t.WF) {k : α} {v : β k} : (t.getThenInsertIfNew? k v ⋯).fst = t.get? k

theorem Std.DTreeMap.Internal.Impl.getThenInsertIfNew?_snd {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] [LawfulEqOrd α] (h : t.WF) {k : α} {v : β k} : (t.getThenInsertIfNew? k v ⋯).snd = (insertIfNew k v t ⋯).impl

getThenInsertIfNew?!

theorem Std.DTreeMap.Internal.Impl.getThenInsertIfNew?!_fst {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] [LawfulEqOrd α] {k : α} {v : β k} : (t.getThenInsertIfNew?! k v).fst = t.get? k

theorem Std.DTreeMap.Internal.Impl.getThenInsertIfNew?!_snd {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] [LawfulEqOrd α] (h : t.WF) {k : α} {v : β k} : (t.getThenInsertIfNew?! k v).snd = insertIfNew! k v t

getThenInsertIfNew?

theorem Std.DTreeMap.Internal.Impl.Const.getThenInsertIfNew?_fst {α : Type u} {instOrd : Ord α} {β : Type v} {t : Impl α fun (x : α) => β} [TransOrd α] (h : t.WF) {k : α} {v : β} : (getThenInsertIfNew? t k v ⋯).fst = get? t k

theorem Std.DTreeMap.Internal.Impl.Const.getThenInsertIfNew?_snd {α : Type u} {instOrd : Ord α} {β : Type v} {t : Impl α fun (x : α) => β} [TransOrd α] (h : t.WF) {k : α} {v : β} : (getThenInsertIfNew? t k v ⋯).snd = (insertIfNew k v t ⋯).impl

getThenInsertIfNew?!

theorem Std.DTreeMap.Internal.Impl.Const.getThenInsertIfNew?!_fst {α : Type u} {instOrd : Ord α} {β : Type v} {t : Impl α fun (x : α) => β} [TransOrd α] {k : α} {v : β} : (getThenInsertIfNew?! t k v).fst = get? t k

theorem Std.DTreeMap.Internal.Impl.Const.getThenInsertIfNew?!_snd {α : Type u} {instOrd : Ord α} {β : Type v} {t : Impl α fun (x : α) => β} [TransOrd α] (h : t.WF) {k : α} {v : β} : (getThenInsertIfNew?! t k v).snd = insertIfNew! k v t

theorem Std.DTreeMap.Internal.Impl.length_keys {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] (h : t.WF) : t.keys.length = t.size

theorem Std.DTreeMap.Internal.Impl.size_keysArray {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] (h : t.WF) : t.keysArray.size = t.size

theorem Std.DTreeMap.Internal.Impl.isEmpty_keys {α : Type u} {β : α → Type v} {t : Impl α β} : t.keys.isEmpty = t.isEmpty

theorem Std.DTreeMap.Internal.Impl.isEmpty_keysArray {α : Type u} {β : α → Type v} {t : Impl α β} : t.keysArray.isEmpty = t.isEmpty

theorem Std.DTreeMap.Internal.Impl.contains_keys {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [BEq α] [beqOrd : LawfulBEqOrd α] [TransOrd α] {k : α} (h : t.WF) : t.keys.contains k = contains k t

theorem Std.DTreeMap.Internal.Impl.contains_keysArray {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [BEq α] [beqOrd : LawfulBEqOrd α] [TransOrd α] {k : α} (h : t.WF) : t.keysArray.contains k = contains k t

theorem Std.DTreeMap.Internal.Impl.mem_keys {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [LawfulEqOrd α] [TransOrd α] {k : α} (h : t.WF) : k ∈ t.keys ↔ k ∈ t

theorem Std.DTreeMap.Internal.Impl.mem_keysArray {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [LawfulEqOrd α] [TransOrd α] {k : α} (h : t.WF) : k ∈ t.keysArray ↔ k ∈ t

theorem Std.DTreeMap.Internal.Impl.mem_of_mem_keys {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] (h : t.WF) {k : α} (h' : k ∈ t.keys) : k ∈ t

theorem Std.DTreeMap.Internal.Impl.mem_of_mem_keysArray {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] (h : t.WF) {k : α} (h' : k ∈ t.keysArray) : k ∈ t

theorem Std.DTreeMap.Internal.Impl.distinct_keys {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] (h : t.WF) : List.Pairwise (fun (a b : α) => ¬compare a b = Ordering.eq) t.keys

theorem Std.DTreeMap.Internal.Impl.ordered_keys {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] (h : t.WF) : List.Pairwise (fun (a b : α) => compare a b = Ordering.lt) t.keys

theorem Std.DTreeMap.Internal.Impl.map_fst_toList_eq_keys {α : Type u} {β : α → Type v} {t : Impl α β} : List.map Sigma.fst t.toList = t.keys

theorem Std.DTreeMap.Internal.Impl.map_fst_toArray_eq_keysArray {α : Type u} {β : α → Type v} {t : Impl α β} : Array.map Sigma.fst t.toArray = t.keysArray

theorem Std.DTreeMap.Internal.Impl.length_toList {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] (h : t.WF) : t.toList.length = t.size

theorem Std.DTreeMap.Internal.Impl.size_toArray {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] (h : t.WF) : t.toArray.size = t.size

theorem Std.DTreeMap.Internal.Impl.isEmpty_toList {α : Type u} {β : α → Type v} {t : Impl α β} : t.toList.isEmpty = t.isEmpty

theorem Std.DTreeMap.Internal.Impl.isEmpty_toArray {α : Type u} {β : α → Type v} {t : Impl α β} : t.toArray.isEmpty = t.isEmpty

theorem Std.DTreeMap.Internal.Impl.mem_toList_iff_get?_eq_some {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] [LawfulEqOrd α] {k : α} {v : β k} (h : t.WF) : ⟨k, v⟩ ∈ t.toList ↔ t.get? k = some v

theorem Std.DTreeMap.Internal.Impl.mem_toArray_iff_get?_eq_some {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] [LawfulEqOrd α] {k : α} {v : β k} (h : t.WF) : ⟨k, v⟩ ∈ t.toArray ↔ t.get? k = some v

theorem Std.DTreeMap.Internal.Impl.find?_toList_eq_some_iff_get?_eq_some {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] [LawfulEqOrd α] {k : α} {v : β k} (h : t.WF) : List.find? (fun (x : (a : α) × β a) => compare x.fst k == Ordering.eq) t.toList = some ⟨k, v⟩ ↔ t.get? k = some v

theorem Std.DTreeMap.Internal.Impl.find?_toArray_eq_some_iff_get?_eq_some {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] [LawfulEqOrd α] {k : α} {v : β k} (h : t.WF) : Array.find? (fun (x : (a : α) × β a) => compare x.fst k == Ordering.eq) t.toArray = some ⟨k, v⟩ ↔ t.get? k = some v

theorem Std.DTreeMap.Internal.Impl.find?_toList_eq_none_iff_contains_eq_false {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] {k : α} (h : t.WF) : List.find? (fun (x : (a : α) × β a) => compare x.fst k == Ordering.eq) t.toList = none ↔ contains k t = false

theorem Std.DTreeMap.Internal.Impl.find?_toArray_eq_none_iff_contains_eq_false {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] {k : α} (h : t.WF) : Array.find? (fun (x : (a : α) × β a) => compare x.fst k == Ordering.eq) t.toArray = none ↔ contains k t = false

theorem Std.DTreeMap.Internal.Impl.find?_toList_eq_none_iff_not_mem {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] {k : α} (h : t.WF) : List.find? (fun (x : (a : α) × β a) => compare x.fst k == Ordering.eq) t.toList = none ↔ ¬k ∈ t

theorem Std.DTreeMap.Internal.Impl.find?_toArray_eq_none_iff_not_mem {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] {k : α} (h : t.WF) : Array.find? (fun (x : (a : α) × β a) => compare x.fst k == Ordering.eq) t.toArray = none ↔ ¬k ∈ t

theorem Std.DTreeMap.Internal.Impl.distinct_keys_toList {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] (h : t.WF) : List.Pairwise (fun (a b : (a : α) × β a) => ¬compare a.fst b.fst = Ordering.eq) t.toList

theorem Std.DTreeMap.Internal.Impl.ordered_keys_toList {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] (h : t.WF) : List.Pairwise (fun (a b : (a : α) × β a) => compare a.fst b.fst = Ordering.lt) t.toList

theorem Std.DTreeMap.Internal.Impl.Const.map_fst_toList_eq_keys {α : Type u} {β : Type v} {t : Impl α fun (x : α) => β} : List.map Prod.fst (toList t) = t.keys

theorem Std.DTreeMap.Internal.Impl.Const.map_fst_toArray_eq_keysArray {α : Type u} {β : Type v} {t : Impl α fun (x : α) => β} : Array.map Prod.fst (toArray t) = t.keysArray

theorem Std.DTreeMap.Internal.Impl.Const.length_toList {α : Type u} {instOrd : Ord α} {β : Type v} {t : Impl α fun (x : α) => β} (h : t.WF) : (toList t).length = t.size

theorem Std.DTreeMap.Internal.Impl.Const.size_toArray {α : Type u} {instOrd : Ord α} {β : Type v} {t : Impl α fun (x : α) => β} (h : t.WF) : (toArray t).size = t.size

theorem Std.DTreeMap.Internal.Impl.Const.isEmpty_toList {α : Type u} {β : Type v} {t : Impl α fun (x : α) => β} : (toList t).isEmpty = t.isEmpty

theorem Std.DTreeMap.Internal.Impl.Const.isEmpty_toArray {α : Type u} {β : Type v} {t : Impl α fun (x : α) => β} : (toArray t).isEmpty = t.isEmpty

theorem Std.DTreeMap.Internal.Impl.Const.mem_toList_iff_get?_eq_some {α : Type u} {instOrd : Ord α} {β : Type v} {t : Impl α fun (x : α) => β} [TransOrd α] [LawfulEqOrd α] {k : α} {v : β} (h : t.WF) : (k, v) ∈ toList t ↔ get? t k = some v

theorem Std.DTreeMap.Internal.Impl.Const.mem_toArray_iff_get?_eq_some {α : Type u} {instOrd : Ord α} {β : Type v} {t : Impl α fun (x : α) => β} [TransOrd α] [LawfulEqOrd α] {k : α} {v : β} (h : t.WF) : (k, v) ∈ toArray t ↔ get? t k = some v

theorem Std.DTreeMap.Internal.Impl.Const.mem_toList_iff_getKey?_eq_some_and_get?_eq_some {α : Type u} {instOrd : Ord α} {β : Type v} {t : Impl α fun (x : α) => β} [TransOrd α] {k : α} {v : β} (h : t.WF) : (k, v) ∈ toList t ↔ t.getKey? k = some k ∧ get? t k = some v

theorem Std.DTreeMap.Internal.Impl.Const.mem_toArray_iff_getKey?_eq_some_and_get?_eq_some {α : Type u} {instOrd : Ord α} {β : Type v} {t : Impl α fun (x : α) => β} [TransOrd α] {k : α} {v : β} (h : t.WF) : (k, v) ∈ toArray t ↔ t.getKey? k = some k ∧ get? t k = some v

theorem Std.DTreeMap.Internal.Impl.Const.get?_eq_some_iff_exists_compare_eq_eq_and_mem_toList {α : Type u} {instOrd : Ord α} {β : Type v} {t : Impl α fun (x : α) => β} [TransOrd α] {k : α} {v : β} (h : t.WF) : get? t k = some v ↔ ∃ (k' : α), compare k k' = Ordering.eq ∧ (k', v) ∈ toList t

theorem Std.DTreeMap.Internal.Impl.Const.get?_eq_some_iff_exists_compare_eq_eq_and_mem_toArray {α : Type u} {instOrd : Ord α} {β : Type v} {t : Impl α fun (x : α) => β} [TransOrd α] {k : α} {v : β} (h : t.WF) : get? t k = some v ↔ ∃ (k' : α), compare k k' = Ordering.eq ∧ (k', v) ∈ toArray t

theorem Std.DTreeMap.Internal.Impl.Const.find?_toList_eq_some_iff_getKey?_eq_some_and_get?_eq_some {α : Type u} {instOrd : Ord α} {β : Type v} {t : Impl α fun (x : α) => β} [TransOrd α] {k k' : α} {v : β} (h : t.WF) : List.find? (fun (a : α × β) => compare a.fst k == Ordering.eq) (toList t) = some (k', v) ↔ t.getKey? k = some k' ∧ get? t k = some v

theorem Std.DTreeMap.Internal.Impl.Const.find?_toArray_eq_some_iff_getKey?_eq_some_and_get?_eq_some {α : Type u} {instOrd : Ord α} {β : Type v} {t : Impl α fun (x : α) => β} [TransOrd α] {k k' : α} {v : β} (h : t.WF) : Array.find? (fun (a : α × β) => compare a.fst k == Ordering.eq) (toArray t) = some (k', v) ↔ t.getKey? k = some k' ∧ get? t k = some v

theorem Std.DTreeMap.Internal.Impl.Const.find?_toList_eq_none_iff_contains_eq_false {α : Type u} {instOrd : Ord α} {β : Type v} {t : Impl α fun (x : α) => β} [TransOrd α] {k : α} (h : t.WF) : List.find? (fun (x : α × β) => compare x.fst k == Ordering.eq) (toList t) = none ↔ contains k t = false

theorem Std.DTreeMap.Internal.Impl.Const.find?_toArray_eq_none_iff_contains_eq_false {α : Type u} {instOrd : Ord α} {β : Type v} {t : Impl α fun (x : α) => β} [TransOrd α] {k : α} (h : t.WF) : Array.find? (fun (x : α × β) => compare x.fst k == Ordering.eq) (toArray t) = none ↔ contains k t = false

theorem Std.DTreeMap.Internal.Impl.Const.find?_toList_eq_none_iff_not_mem {α : Type u} {instOrd : Ord α} {β : Type v} {t : Impl α fun (x : α) => β} [TransOrd α] {k : α} (h : t.WF) : List.find? (fun (x : α × β) => compare x.fst k == Ordering.eq) (toList t) = none ↔ ¬k ∈ t

theorem Std.DTreeMap.Internal.Impl.Const.find?_toArray_eq_none_iff_not_mem {α : Type u} {instOrd : Ord α} {β : Type v} {t : Impl α fun (x : α) => β} [TransOrd α] {k : α} (h : t.WF) : Array.find? (fun (x : α × β) => compare x.fst k == Ordering.eq) (toArray t) = none ↔ ¬k ∈ t

theorem Std.DTreeMap.Internal.Impl.Const.distinct_keys_toList {α : Type u} {instOrd : Ord α} {β : Type v} {t : Impl α fun (x : α) => β} [TransOrd α] (h : t.WF) : List.Pairwise (fun (a b : α × β) => ¬compare a.fst b.fst = Ordering.eq) (toList t)

theorem Std.DTreeMap.Internal.Impl.Const.distinct_keys_toArray {α : Type u} {instOrd : Ord α} {β : Type v} {t : Impl α fun (x : α) => β} [TransOrd α] (h : t.WF) : List.Pairwise (fun (a b : α × β) => ¬compare a.fst b.fst = Ordering.eq) (toArray t).toList

theorem Std.DTreeMap.Internal.Impl.Const.ordered_keys_toList {α : Type u} {instOrd : Ord α} {β : Type v} {t : Impl α fun (x : α) => β} [TransOrd α] (h : t.WF) : List.Pairwise (fun (a b : α × β) => compare a.fst b.fst = Ordering.lt) (toList t)

theorem Std.DTreeMap.Internal.Impl.Const.ordered_keys_toArray {α : Type u} {instOrd : Ord α} {β : Type v} {t : Impl α fun (x : α) => β} [TransOrd α] (h : t.WF) : List.Pairwise (fun (a b : α × β) => compare a.fst b.fst = Ordering.lt) (toArray t).toList

theorem Std.DTreeMap.Internal.Impl.foldlM_eq_foldlM_toList {α : Type u} {β : α → Type v} {t : Impl α β} {δ : Type w} {m : Type w → Type w'} [Monad m] [LawfulMonad m] {f : δ → (a : α) → β a → m δ} {init : δ} : foldlM f init t = List.foldlM (fun (a : δ) (b : (a : α) × β a) => f a b.fst b.snd) init t.toList

theorem Std.DTreeMap.Internal.Impl.foldlM_eq_foldlM_toArray {α : Type u} {β : α → Type v} {t : Impl α β} {δ : Type w} {m : Type w → Type w'} [Monad m] [LawfulMonad m] {f : δ → (a : α) → β a → m δ} {init : δ} : foldlM f init t = Array.foldlM (fun (a : δ) (b : (a : α) × β a) => f a b.fst b.snd) init t.toArray

theorem Std.DTreeMap.Internal.Impl.foldl_eq_foldl_toList {α : Type u} {β : α → Type v} {t : Impl α β} {δ : Type w} {f : δ → (a : α) → β a → δ} {init : δ} : foldl f init t = List.foldl (fun (a : δ) (b : (a : α) × β a) => f a b.fst b.snd) init t.toList

theorem Std.DTreeMap.Internal.Impl.foldl_eq_foldl_toArray {α : Type u} {β : α → Type v} {t : Impl α β} {δ : Type w} {f : δ → (a : α) → β a → δ} {init : δ} : foldl f init t = Array.foldl (fun (a : δ) (b : (a : α) × β a) => f a b.fst b.snd) init t.toArray

theorem Std.DTreeMap.Internal.Impl.foldrM_eq_foldrM_toList {α : Type u} {β : α → Type v} {t : Impl α β} {δ : Type w} {m : Type w → Type w'} [Monad m] [LawfulMonad m] {f : (a : α) → β a → δ → m δ} {init : δ} : foldrM f init t = List.foldrM (fun (a : (a : α) × β a) (b : δ) => f a.fst a.snd b) init t.toList

theorem Std.DTreeMap.Internal.Impl.foldrM_eq_foldrM_toArray {α : Type u} {β : α → Type v} {t : Impl α β} {δ : Type w} {m : Type w → Type w'} [Monad m] [LawfulMonad m] {f : (a : α) → β a → δ → m δ} {init : δ} : foldrM f init t = Array.foldrM (fun (a : (a : α) × β a) (b : δ) => f a.fst a.snd b) init t.toArray

theorem Std.DTreeMap.Internal.Impl.foldr_eq_foldr_toList {α : Type u} {β : α → Type v} {t : Impl α β} {δ : Type w} {f : (a : α) → β a → δ → δ} {init : δ} : foldr f init t = List.foldr (fun (a : (a : α) × β a) (b : δ) => f a.fst a.snd b) init t.toList

theorem Std.DTreeMap.Internal.Impl.foldr_eq_foldr_toArray {α : Type u} {β : α → Type v} {t : Impl α β} {δ : Type w} {f : (a : α) → β a → δ → δ} {init : δ} : foldr f init t = Array.foldr (fun (a : (a : α) × β a) (b : δ) => f a.fst a.snd b) init t.toArray

theorem Std.DTreeMap.Internal.Impl.forM_eq_forM_toList {α : Type u} {β : α → Type v} {t : Impl α β} {m : Type w → Type w'} [Monad m] [LawfulMonad m] {f : (a : α) × β a → m PUnit} : forM (fun (k : α) (v : β k) => f ⟨k, v⟩) t = ForM.forM t.toList f

theorem Std.DTreeMap.Internal.Impl.forM_eq_forM_toArray {α : Type u} {β : α → Type v} {t : Impl α β} {m : Type w → Type w'} [Monad m] [LawfulMonad m] {f : (a : α) × β a → m PUnit} : forM (fun (k : α) (v : β k) => f ⟨k, v⟩) t = ForM.forM t.toArray f

theorem Std.DTreeMap.Internal.Impl.forIn_eq_forIn_toList {α : Type u} {β : α → Type v} {t : Impl α β} {δ : Type w} {m : Type w → Type w'} [Monad m] [LawfulMonad m] {f : (a : α) × β a → δ → m (ForInStep δ)} {init : δ} : forIn (fun (k : α) (v : β k) => f ⟨k, v⟩) init t = ForIn.forIn t.toList init f

theorem Std.DTreeMap.Internal.Impl.forIn_eq_forIn_toArray {α : Type u} {β : α → Type v} {t : Impl α β} {δ : Type w} {m : Type w → Type w'} [Monad m] [LawfulMonad m] {f : (a : α) × β a → δ → m (ForInStep δ)} {init : δ} : forIn (fun (k : α) (v : β k) => f ⟨k, v⟩) init t = ForIn.forIn t.toArray init f

theorem Std.DTreeMap.Internal.Impl.foldlM_eq_foldlM_keys {α : Type u} {β : α → Type v} {t : Impl α β} {δ : Type w} {m : Type w → Type w'} [Monad m] [LawfulMonad m] {f : δ → α → m δ} {init : δ} : foldlM (fun (d : δ) (a : α) (x : β a) => f d a) init t = List.foldlM f init t.keys

theorem Std.DTreeMap.Internal.Impl.foldlM_eq_foldlM_keysArray {α : Type u} {β : α → Type v} {t : Impl α β} {δ : Type w} {m : Type w → Type w'} [Monad m] [LawfulMonad m] {f : δ → α → m δ} {init : δ} : foldlM (fun (d : δ) (a : α) (x : β a) => f d a) init t = Array.foldlM f init t.keysArray

theorem Std.DTreeMap.Internal.Impl.foldl_eq_foldl_keys {α : Type u} {β : α → Type v} {t : Impl α β} {δ : Type w} {f : δ → α → δ} {init : δ} : foldl (fun (d : δ) (a : α) (x : β a) => f d a) init t = List.foldl f init t.keys

theorem Std.DTreeMap.Internal.Impl.foldl_eq_foldl_keysArray {α : Type u} {β : α → Type v} {t : Impl α β} {δ : Type w} {f : δ → α → δ} {init : δ} : foldl (fun (d : δ) (a : α) (x : β a) => f d a) init t = Array.foldl f init t.keysArray

theorem Std.DTreeMap.Internal.Impl.foldrM_eq_foldrM_keys {α : Type u} {β : α → Type v} {t : Impl α β} {δ : Type w} {m : Type w → Type w'} [Monad m] [LawfulMonad m] {f : α → δ → m δ} {init : δ} : foldrM (fun (a : α) (x : β a) (d : δ) => f a d) init t = List.foldrM f init t.keys

theorem Std.DTreeMap.Internal.Impl.foldrM_eq_foldrM_keysArray {α : Type u} {β : α → Type v} {t : Impl α β} {δ : Type w} {m : Type w → Type w'} [Monad m] [LawfulMonad m] {f : α → δ → m δ} {init : δ} : foldrM (fun (a : α) (x : β a) (d : δ) => f a d) init t = Array.foldrM f init t.keysArray

theorem Std.DTreeMap.Internal.Impl.foldr_eq_foldr_keys {α : Type u} {β : α → Type v} {t : Impl α β} {δ : Type w} {f : α → δ → δ} {init : δ} : foldr (fun (a : α) (x : β a) (d : δ) => f a d) init t = List.foldr f init t.keys

theorem Std.DTreeMap.Internal.Impl.foldr_eq_foldr_keysArray {α : Type u} {β : α → Type v} {t : Impl α β} {δ : Type w} {f : α → δ → δ} {init : δ} : foldr (fun (a : α) (x : β a) (d : δ) => f a d) init t = Array.foldr f init t.keysArray

theorem Std.DTreeMap.Internal.Impl.forM_eq_forM_keys {α : Type u} {β : α → Type v} {t : Impl α β} {m : Type w → Type w'} [Monad m] [LawfulMonad m] {f : α → m PUnit} : forM (fun (a : α) (x : β a) => f a) t = t.keys.forM f

theorem Std.DTreeMap.Internal.Impl.forM_eq_forM_keysArray {α : Type u} {β : α → Type v} {t : Impl α β} {m : Type w → Type w'} [Monad m] [LawfulMonad m] {f : α → m PUnit} : forM (fun (a : α) (x : β a) => f a) t = Array.forM f t.keysArray

theorem Std.DTreeMap.Internal.Impl.forIn_eq_forIn_keys {α : Type u} {β : α → Type v} {t : Impl α β} {δ : Type w} {m : Type w → Type w'} [Monad m] [LawfulMonad m] {f : α → δ → m (ForInStep δ)} {init : δ} : forIn (fun (a : α) (x : β a) (d : δ) => f a d) init t = ForIn.forIn t.keys init f

theorem Std.DTreeMap.Internal.Impl.forIn_eq_forIn_keysArray {α : Type u} {β : α → Type v} {t : Impl α β} {δ : Type w} {m : Type w → Type w'} [Monad m] [LawfulMonad m] {f : α → δ → m (ForInStep δ)} {init : δ} : forIn (fun (a : α) (x : β a) (d : δ) => f a d) init t = ForIn.forIn t.keysArray init f

theorem Std.DTreeMap.Internal.Impl.Const.foldlM_eq_foldlM_toList {α : Type u} {δ : Type w} {m : Type w → Type w'} {β : Type v} {t : Impl α fun (x : α) => β} [Monad m] [LawfulMonad m] {f : δ → α → β → m δ} {init : δ} : foldlM f init t = List.foldlM (fun (a : δ) (b : α × β) => f a b.fst b.snd) init (toList t)

theorem Std.DTreeMap.Internal.Impl.Const.foldlM_eq_foldlM_toArray {α : Type u} {δ : Type w} {m : Type w → Type w'} {β : Type v} {t : Impl α fun (x : α) => β} [Monad m] [LawfulMonad m] {f : δ → α → β → m δ} {init : δ} : foldlM f init t = Array.foldlM (fun (a : δ) (b : α × β) => f a b.fst b.snd) init (toArray t)

theorem Std.DTreeMap.Internal.Impl.Const.foldl_eq_foldl_toList {α : Type u} {δ : Type w} {β : Type v} {t : Impl α fun (x : α) => β} {f : δ → α → β → δ} {init : δ} : foldl f init t = List.foldl (fun (a : δ) (b : α × β) => f a b.fst b.snd) init (toList t)

theorem Std.DTreeMap.Internal.Impl.Const.foldl_eq_foldl_toArray {α : Type u} {δ : Type w} {β : Type v} {t : Impl α fun (x : α) => β} {f : δ → α → β → δ} {init : δ} : foldl f init t = Array.foldl (fun (a : δ) (b : α × β) => f a b.fst b.snd) init (toArray t)

theorem Std.DTreeMap.Internal.Impl.Const.foldrM_eq_foldrM_toList {α : Type u} {δ : Type w} {m : Type w → Type w'} {β : Type v} {t : Impl α fun (x : α) => β} [Monad m] [LawfulMonad m] {f : α → β → δ → m δ} {init : δ} : foldrM f init t = List.foldrM (fun (a : α × β) (b : δ) => f a.fst a.snd b) init (toList t)

theorem Std.DTreeMap.Internal.Impl.Const.foldrM_eq_foldrM_toArray {α : Type u} {δ : Type w} {m : Type w → Type w'} {β : Type v} {t : Impl α fun (x : α) => β} [Monad m] [LawfulMonad m] {f : α → β → δ → m δ} {init : δ} : foldrM f init t = Array.foldrM (fun (a : α × β) (b : δ) => f a.fst a.snd b) init (toArray t)

theorem Std.DTreeMap.Internal.Impl.Const.foldr_eq_foldr_toList {α : Type u} {δ : Type w} {β : Type v} {t : Impl α fun (x : α) => β} {f : α → β → δ → δ} {init : δ} : foldr f init t = List.foldr (fun (a : α × β) (b : δ) => f a.fst a.snd b) init (toList t)

theorem Std.DTreeMap.Internal.Impl.Const.foldr_eq_foldr_toArray {α : Type u} {δ : Type w} {β : Type v} {t : Impl α fun (x : α) => β} {f : α → β → δ → δ} {init : δ} : foldr f init t = Array.foldr (fun (a : α × β) (b : δ) => f a.fst a.snd b) init (toArray t)

theorem Std.DTreeMap.Internal.Impl.Const.forM_eq_forM_toList {α : Type u} {m : Type w → Type w'} {β : Type v} {t : Impl α fun (x : α) => β} [Monad m] [LawfulMonad m] {f : α → β → m PUnit} : forM f t = (toList t).forM fun (a : α × β) => f a.fst a.snd

theorem Std.DTreeMap.Internal.Impl.Const.forM_eq_forM_toArray {α : Type u} {m : Type w → Type w'} {β : Type v} {t : Impl α fun (x : α) => β} [Monad m] [LawfulMonad m] {f : α → β → m PUnit} : forM f t = Array.forM (fun (a : α × β) => f a.fst a.snd) (toArray t)

theorem Std.DTreeMap.Internal.Impl.Const.forIn_eq_forIn_toList {α : Type u} {δ : Type w} {m : Type w → Type w'} {β : Type v} {t : Impl α fun (x : α) => β} [Monad m] [LawfulMonad m] {f : α → β → δ → m (ForInStep δ)} {init : δ} : forIn f init t = ForIn.forIn (toList t) init fun (a : α × β) (b : δ) => f a.fst a.snd b

theorem Std.DTreeMap.Internal.Impl.Const.forIn_eq_forIn_toArray {α : Type u} {δ : Type w} {m : Type w → Type w'} {β : Type v} {t : Impl α fun (x : α) => β} [Monad m] [LawfulMonad m] {f : α → β → δ → m (ForInStep δ)} {init : δ} : forIn f init t = ForIn.forIn (toArray t) init fun (a : α × β) (b : δ) => f a.fst a.snd b

theorem Std.DTreeMap.Internal.Impl.insertMany_cons {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} (h : t.WF) {l : List ((a : α) × β a)} {k : α} {v : β k} : (t.insertMany (⟨k, v⟩ :: l) ⋯).val = ((insert k v t ⋯).impl.insertMany l ⋯).val

theorem Std.DTreeMap.Internal.Impl.insertMany!_cons {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} {l : List ((a : α) × β a)} {k : α} {v : β k} : (t.insertMany! (⟨k, v⟩ :: l)).val = ((insert! k v t).insertMany! l).val

@[simp]

theorem Std.DTreeMap.Internal.Impl.contains_insertMany_list {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] [BEq α] [LawfulBEqOrd α] (h : t.WF) {l : List ((a : α) × β a)} {k : α} : contains k (t.insertMany l ⋯).val = (contains k t || (List.map Sigma.fst l).contains k)

@[simp]

theorem Std.DTreeMap.Internal.Impl.mem_insertMany_list {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] [BEq α] [LawfulBEqOrd α] (h : t.WF) {l : List ((a : α) × β a)} {k : α} : k ∈ (t.insertMany l ⋯).val ↔ k ∈ t ∨ (List.map Sigma.fst l).contains k = true

@[simp]

theorem Std.DTreeMap.Internal.Impl.contains_insertMany!_list {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] [BEq α] [LawfulBEqOrd α] (h : t.WF) {l : List ((a : α) × β a)} {k : α} : contains k (t.insertMany! l).val = (contains k t || (List.map Sigma.fst l).contains k)

@[simp]

theorem Std.DTreeMap.Internal.Impl.mem_insertMany!_list {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] [BEq α] [LawfulBEqOrd α] (h : t.WF) {l : List ((a : α) × β a)} {k : α} : k ∈ (t.insertMany! l).val ↔ k ∈ t ∨ (List.map Sigma.fst l).contains k = true

theorem Std.DTreeMap.Internal.Impl.contains_of_contains_insertMany_list {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] [BEq α] [LawfulBEqOrd α] (h : t.WF) {l : List ((a : α) × β a)} {k : α} : contains k (t.insertMany l ⋯).val = true → (List.map Sigma.fst l).contains k = false → contains k t = true

theorem Std.DTreeMap.Internal.Impl.mem_of_mem_insertMany_list {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] [BEq α] [LawfulBEqOrd α] (h : t.WF) {l : List ((a : α) × β a)} {k : α} : k ∈ (t.insertMany l ⋯).val → (List.map Sigma.fst l).contains k = false → k ∈ t

theorem Std.DTreeMap.Internal.Impl.contains_of_contains_insertMany!_list {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] [BEq α] [LawfulBEqOrd α] (h : t.WF) {l : List ((a : α) × β a)} {k : α} : contains k (t.insertMany! l).val = true → (List.map Sigma.fst l).contains k = false → contains k t = true

theorem Std.DTreeMap.Internal.Impl.mem_of_mem_insertMany!_list {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] [BEq α] [LawfulBEqOrd α] (h : t.WF) {l : List ((a : α) × β a)} {k : α} : k ∈ (t.insertMany! l).val → (List.map Sigma.fst l).contains k = false → k ∈ t

theorem Std.DTreeMap.Internal.Impl.get?_insertMany_list_of_contains_eq_false {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] [LawfulEqOrd α] [BEq α] [LawfulBEqOrd α] (h : t.WF) {l : List ((a : α) × β a)} {k : α} (h' : (List.map Sigma.fst l).contains k = false) : (t.insertMany l ⋯).val.get? k = t.get? k

theorem Std.DTreeMap.Internal.Impl.get?_insertMany!_list_of_contains_eq_false {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] [LawfulEqOrd α] [BEq α] [LawfulBEqOrd α] (h : t.WF) {l : List ((a : α) × β a)} {k : α} (h' : (List.map Sigma.fst l).contains k = false) : (t.insertMany! l).val.get? k = t.get? k

theorem Std.DTreeMap.Internal.Impl.get?_insertMany_list_of_mem {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] [LawfulEqOrd α] (h : t.WF) {l : List ((a : α) × β a)} {k k' : α} (k_beq : compare k k' = Ordering.eq) {v : β k} (distinct : List.Pairwise (fun (a b : (a : α) × β a) => ¬compare a.fst b.fst = Ordering.eq) l) (mem : ⟨k, v⟩ ∈ l) : (t.insertMany l ⋯).val.get? k' = some (cast ⋯ v)

theorem Std.DTreeMap.Internal.Impl.get?_insertMany!_list_of_mem {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] [LawfulEqOrd α] (h : t.WF) {l : List ((a : α) × β a)} {k k' : α} (k_beq : compare k k' = Ordering.eq) {v : β k} (distinct : List.Pairwise (fun (a b : (a : α) × β a) => ¬compare a.fst b.fst = Ordering.eq) l) (mem : ⟨k, v⟩ ∈ l) : (t.insertMany! l).val.get? k' = some (cast ⋯ v)

theorem Std.DTreeMap.Internal.Impl.get_insertMany_list_of_contains_eq_false {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] [BEq α] [LawfulBEqOrd α] [LawfulEqOrd α] (h : t.WF) {l : List ((a : α) × β a)} {k : α} (contains : (List.map Sigma.fst l).contains k = false) {h' : k ∈ (t.insertMany l ⋯).val} : (t.insertMany l ⋯).val.get k h' = t.get k ⋯

theorem Std.DTreeMap.Internal.Impl.get_insertMany!_list_of_contains_eq_false {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] [BEq α] [LawfulBEqOrd α] [LawfulEqOrd α] (h : t.WF) {l : List ((a : α) × β a)} {k : α} (contains : (List.map Sigma.fst l).contains k = false) {h' : k ∈ (t.insertMany! l).val} : (t.insertMany! l).val.get k h' = t.get k ⋯

theorem Std.DTreeMap.Internal.Impl.get_insertMany_list_of_mem {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] [LawfulEqOrd α] (h : t.WF) {l : List ((a : α) × β a)} {k k' : α} (k_beq : compare k k' = Ordering.eq) {v : β k} (distinct : List.Pairwise (fun (a b : (a : α) × β a) => ¬compare a.fst b.fst = Ordering.eq) l) (mem : ⟨k, v⟩ ∈ l) {h' : k' ∈ (t.insertMany l ⋯).val} : (t.insertMany l ⋯).val.get k' h' = cast ⋯ v

theorem Std.DTreeMap.Internal.Impl.get_insertMany!_list_of_mem {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] [LawfulEqOrd α] (h : t.WF) {l : List ((a : α) × β a)} {k k' : α} (k_beq : compare k k' = Ordering.eq) {v : β k} (distinct : List.Pairwise (fun (a b : (a : α) × β a) => ¬compare a.fst b.fst = Ordering.eq) l) (mem : ⟨k, v⟩ ∈ l) {h' : k' ∈ (t.insertMany! l).val} : (t.insertMany! l).val.get k' h' = cast ⋯ v

theorem Std.DTreeMap.Internal.Impl.get!_insertMany_list_of_contains_eq_false {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] [BEq α] [LawfulBEqOrd α] [LawfulEqOrd α] (h : t.WF) {l : List ((a : α) × β a)} {k : α} [Inhabited (β k)] (h' : (List.map Sigma.fst l).contains k = false) : (t.insertMany l ⋯).val.get! k = t.get! k

theorem Std.DTreeMap.Internal.Impl.get!_insertMany!_list_of_contains_eq_false {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] [BEq α] [LawfulBEqOrd α] [LawfulEqOrd α] (h : t.WF) {l : List ((a : α) × β a)} {k : α} [Inhabited (β k)] (h' : (List.map Sigma.fst l).contains k = false) : (t.insertMany! l).val.get! k = t.get! k

theorem Std.DTreeMap.Internal.Impl.get!_insertMany_list_of_mem {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] [LawfulEqOrd α] (h : t.WF) {l : List ((a : α) × β a)} {k k' : α} (k_beq : compare k k' = Ordering.eq) {v : β k} [Inhabited (β k')] (distinct : List.Pairwise (fun (a b : (a : α) × β a) => ¬compare a.fst b.fst = Ordering.eq) l) (mem : ⟨k, v⟩ ∈ l) : (t.insertMany l ⋯).val.get! k' = cast ⋯ v

theorem Std.DTreeMap.Internal.Impl.get!_insertMany!_list_of_mem {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] [LawfulEqOrd α] (h : t.WF) {l : List ((a : α) × β a)} {k k' : α} (k_beq : compare k k' = Ordering.eq) {v : β k} [Inhabited (β k')] (distinct : List.Pairwise (fun (a b : (a : α) × β a) => ¬compare a.fst b.fst = Ordering.eq) l) (mem : ⟨k, v⟩ ∈ l) : (t.insertMany! l).val.get! k' = cast ⋯ v

theorem Std.DTreeMap.Internal.Impl.getD_insertMany_list_of_contains_eq_false {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] [BEq α] [LawfulBEqOrd α] [LawfulEqOrd α] (h : t.WF) {l : List ((a : α) × β a)} {k : α} {fallback : β k} (contains_eq_false : (List.map Sigma.fst l).contains k = false) : (t.insertMany l ⋯).val.getD k fallback = t.getD k fallback

theorem Std.DTreeMap.Internal.Impl.getD_insertMany!_list_of_contains_eq_false {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] [BEq α] [LawfulBEqOrd α] [LawfulEqOrd α] (h : t.WF) {l : List ((a : α) × β a)} {k : α} {fallback : β k} (contains_eq_false : (List.map Sigma.fst l).contains k = false) : (t.insertMany! l).val.getD k fallback = t.getD k fallback

theorem Std.DTreeMap.Internal.Impl.getD_insertMany_list_of_mem {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] [LawfulEqOrd α] (h : t.WF) {l : List ((a : α) × β a)} {k k' : α} (k_beq : compare k k' = Ordering.eq) {v : β k} {fallback : β k'} (distinct : List.Pairwise (fun (a b : (a : α) × β a) => ¬compare a.fst b.fst = Ordering.eq) l) (mem : ⟨k, v⟩ ∈ l) : (t.insertMany l ⋯).val.getD k' fallback = cast ⋯ v

theorem Std.DTreeMap.Internal.Impl.getD_insertMany!_list_of_mem {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] [LawfulEqOrd α] (h : t.WF) {l : List ((a : α) × β a)} {k k' : α} (k_beq : compare k k' = Ordering.eq) {v : β k} {fallback : β k'} (distinct : List.Pairwise (fun (a b : (a : α) × β a) => ¬compare a.fst b.fst = Ordering.eq) l) (mem : ⟨k, v⟩ ∈ l) : (t.insertMany! l).val.getD k' fallback = cast ⋯ v

theorem Std.DTreeMap.Internal.Impl.getKey?_insertMany_list_of_contains_eq_false {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] [BEq α] [LawfulBEqOrd α] (h : t.WF) {l : List ((a : α) × β a)} {k : α} (h' : (List.map Sigma.fst l).contains k = false) : (t.insertMany l ⋯).val.getKey? k = t.getKey? k

theorem Std.DTreeMap.Internal.Impl.getKey?_insertMany!_list_of_contains_eq_false {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] [BEq α] [LawfulBEqOrd α] (h : t.WF) {l : List ((a : α) × β a)} {k : α} (h' : (List.map Sigma.fst l).contains k = false) : (t.insertMany! l).val.getKey? k = t.getKey? k

theorem Std.DTreeMap.Internal.Impl.getKey?_insertMany_list_of_mem {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] (h : t.WF) {l : List ((a : α) × β a)} {k k' : α} (k_beq : compare k k' = Ordering.eq) (distinct : List.Pairwise (fun (a b : (a : α) × β a) => ¬compare a.fst b.fst = Ordering.eq) l) (mem : k ∈ List.map Sigma.fst l) : (t.insertMany l ⋯).val.getKey? k' = some k

theorem Std.DTreeMap.Internal.Impl.getKey?_insertMany!_list_of_mem {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] (h : t.WF) {l : List ((a : α) × β a)} {k k' : α} (k_beq : compare k k' = Ordering.eq) (distinct : List.Pairwise (fun (a b : (a : α) × β a) => ¬compare a.fst b.fst = Ordering.eq) l) (mem : k ∈ List.map Sigma.fst l) : (t.insertMany! l).val.getKey? k' = some k

theorem Std.DTreeMap.Internal.Impl.getKey_insertMany_list_of_contains_eq_false {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] [BEq α] [LawfulBEqOrd α] (h : t.WF) {l : List ((a : α) × β a)} {k : α} (h₁ : (List.map Sigma.fst l).contains k = false) {h' : contains k (t.insertMany l ⋯).val = true} : (t.insertMany l ⋯).val.getKey k h' = t.getKey k ⋯

theorem Std.DTreeMap.Internal.Impl.getKey_insertMany!_list_of_contains_eq_false {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] [BEq α] [LawfulBEqOrd α] (h : t.WF) {l : List ((a : α) × β a)} {k : α} (h₁ : (List.map Sigma.fst l).contains k = false) {h' : contains k (t.insertMany! l).val = true} : (t.insertMany! l).val.getKey k h' = t.getKey k ⋯

theorem Std.DTreeMap.Internal.Impl.getKey_insertMany_list_of_mem {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] (h : t.WF) {l : List ((a : α) × β a)} {k k' : α} (k_beq : compare k k' = Ordering.eq) (distinct : List.Pairwise (fun (a b : (a : α) × β a) => ¬compare a.fst b.fst = Ordering.eq) l) (mem : k ∈ List.map Sigma.fst l) {h' : contains k' (t.insertMany l ⋯).val = true} : (t.insertMany l ⋯).val.getKey k' h' = k

theorem Std.DTreeMap.Internal.Impl.getKey_insertMany!_list_of_mem {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] (h : t.WF) {l : List ((a : α) × β a)} {k k' : α} (k_beq : compare k k' = Ordering.eq) (distinct : List.Pairwise (fun (a b : (a : α) × β a) => ¬compare a.fst b.fst = Ordering.eq) l) (mem : k ∈ List.map Sigma.fst l) {h' : contains k' (t.insertMany! l).val = true} : (t.insertMany! l).val.getKey k' h' = k

theorem Std.DTreeMap.Internal.Impl.getKey!_insertMany_list_of_contains_eq_false {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] [BEq α] [LawfulBEqOrd α] [Inhabited α] (h : t.WF) {l : List ((a : α) × β a)} {k : α} (h' : (List.map Sigma.fst l).contains k = false) : (t.insertMany l ⋯).val.getKey! k = t.getKey! k

theorem Std.DTreeMap.Internal.Impl.getKey!_insertMany!_list_of_contains_eq_false {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] [BEq α] [LawfulBEqOrd α] [Inhabited α] (h : t.WF) {l : List ((a : α) × β a)} {k : α} (h' : (List.map Sigma.fst l).contains k = false) : (t.insertMany! l).val.getKey! k = t.getKey! k

theorem Std.DTreeMap.Internal.Impl.getKey!_insertMany_list_of_mem {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] [Inhabited α] (h : t.WF) {l : List ((a : α) × β a)} {k k' : α} (k_beq : compare k k' = Ordering.eq) (distinct : List.Pairwise (fun (a b : (a : α) × β a) => ¬compare a.fst b.fst = Ordering.eq) l) (mem : k ∈ List.map Sigma.fst l) : (t.insertMany l ⋯).val.getKey! k' = k

theorem Std.DTreeMap.Internal.Impl.getKey!_insertMany!_list_of_mem {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] [Inhabited α] (h : t.WF) {l : List ((a : α) × β a)} {k k' : α} (k_beq : compare k k' = Ordering.eq) (distinct : List.Pairwise (fun (a b : (a : α) × β a) => ¬compare a.fst b.fst = Ordering.eq) l) (mem : k ∈ List.map Sigma.fst l) : (t.insertMany! l).val.getKey! k' = k

theorem Std.DTreeMap.Internal.Impl.getKeyD_insertMany_list_of_contains_eq_false {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] [BEq α] [LawfulBEqOrd α] (h : t.WF) {l : List ((a : α) × β a)} {k fallback : α} (h' : (List.map Sigma.fst l).contains k = false) : (t.insertMany l ⋯).val.getKeyD k fallback = t.getKeyD k fallback

theorem Std.DTreeMap.Internal.Impl.getKeyD_insertMany!_list_of_contains_eq_false {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] [BEq α] [LawfulBEqOrd α] (h : t.WF) {l : List ((a : α) × β a)} {k fallback : α} (h' : (List.map Sigma.fst l).contains k = false) : (t.insertMany! l).val.getKeyD k fallback = t.getKeyD k fallback

theorem Std.DTreeMap.Internal.Impl.getKeyD_insertMany_list_of_mem {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] (h : t.WF) {l : List ((a : α) × β a)} {k k' fallback : α} (k_beq : compare k k' = Ordering.eq) (distinct : List.Pairwise (fun (a b : (a : α) × β a) => ¬compare a.fst b.fst = Ordering.eq) l) (mem : k ∈ List.map Sigma.fst l) : (t.insertMany l ⋯).val.getKeyD k' fallback = k

theorem Std.DTreeMap.Internal.Impl.getKeyD_insertMany!_list_of_mem {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] (h : t.WF) {l : List ((a : α) × β a)} {k k' fallback : α} (k_beq : compare k k' = Ordering.eq) (distinct : List.Pairwise (fun (a b : (a : α) × β a) => ¬compare a.fst b.fst = Ordering.eq) l) (mem : k ∈ List.map Sigma.fst l) : (t.insertMany! l).val.getKeyD k' fallback = k

theorem Std.DTreeMap.Internal.Impl.size_insertMany_list {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] [BEq α] [LawfulBEqOrd α] (h : t.WF) {l : List ((a : α) × β a)} (distinct : List.Pairwise (fun (a b : (a : α) × β a) => ¬compare a.fst b.fst = Ordering.eq) l) : (∀ (a : α), contains a t = true → (List.map Sigma.fst l).contains a = false) → (t.insertMany l ⋯).val.size = t.size + l.length

theorem Std.DTreeMap.Internal.Impl.size_insertMany!_list {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] [BEq α] [LawfulBEqOrd α] (h : t.WF) {l : List ((a : α) × β a)} (distinct : List.Pairwise (fun (a b : (a : α) × β a) => ¬compare a.fst b.fst = Ordering.eq) l) : (∀ (a : α), contains a t = true → (List.map Sigma.fst l).contains a = false) → (t.insertMany! l).val.size = t.size + l.length

theorem Std.DTreeMap.Internal.Impl.size_le_size_insertMany_list {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] (h : t.WF) {l : List ((a : α) × β a)} : t.size ≤ (t.insertMany l ⋯).val.size

theorem Std.DTreeMap.Internal.Impl.size_le_size_insertMany!_list {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] (h : t.WF) {l : List ((a : α) × β a)} : t.size ≤ (t.insertMany! l).val.size

theorem Std.DTreeMap.Internal.Impl.size_insertMany_list_le {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] (h : t.WF) {l : List ((a : α) × β a)} : (t.insertMany l ⋯).val.size ≤ t.size + l.length

theorem Std.DTreeMap.Internal.Impl.size_insertMany!_list_le {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] (h : t.WF) {l : List ((a : α) × β a)} : (t.insertMany! l).val.size ≤ t.size + l.length

@[simp]

theorem Std.DTreeMap.Internal.Impl.isEmpty_insertMany_list {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] (h : t.WF) {l : List ((a : α) × β a)} : (t.insertMany l ⋯).val.isEmpty = (t.isEmpty && l.isEmpty)

@[simp]

theorem Std.DTreeMap.Internal.Impl.isEmpty_insertMany!_list {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] (h : t.WF) {l : List ((a : α) × β a)} : (t.insertMany! l).val.isEmpty = (t.isEmpty && l.isEmpty)

theorem Std.DTreeMap.Internal.Impl.ofList_eq_insertMany {α : Type u} {β : α → Type v} {instOrd : Ord α} {l : List ((a : α) × β a)} : ofList l = (empty.insertMany l ⋯).val

theorem Std.DTreeMap.Internal.Impl.ofList_eq_insertMany! {α : Type u} {β : α → Type v} {instOrd : Ord α} {l : List ((a : α) × β a)} : ofList l = (empty.insertMany! l).val

theorem Std.DTreeMap.Internal.Impl.Const.insertMany_cons {α : Type u} {instOrd : Ord α} {β : Type v} {t : Impl α fun (x : α) => β} (h : t.WF) {l : List (α × β)} {k : α} {v : β} : (insertMany t ((k, v) :: l) ⋯).val = (insertMany (insert k v t ⋯).impl l ⋯).val

theorem Std.DTreeMap.Internal.Impl.Const.insertMany!_cons {α : Type u} {instOrd : Ord α} {β : Type v} {t : Impl α fun (x : α) => β} {l : List (α × β)} {k : α} {v : β} : (insertMany! t ((k, v) :: l)).val = (insertMany! (insert! k v t) l).val

@[simp]

theorem Std.DTreeMap.Internal.Impl.Const.contains_insertMany_list {α : Type u} {instOrd : Ord α} {β : Type v} {t : Impl α fun (x : α) => β} [TransOrd α] [BEq α] [LawfulBEqOrd α] (h : t.WF) {l : List (α × β)} {k : α} : contains k (insertMany t l ⋯).val = (contains k t || (List.map Prod.fst l).contains k)

@[simp]

theorem Std.DTreeMap.Internal.Impl.Const.contains_insertMany!_list {α : Type u} {instOrd : Ord α} {β : Type v} {t : Impl α fun (x : α) => β} [TransOrd α] [BEq α] [LawfulBEqOrd α] (h : t.WF) {l : List (α × β)} {k : α} : contains k (insertMany! t l).val = (contains k t || (List.map Prod.fst l).contains k)

@[simp]

theorem Std.DTreeMap.Internal.Impl.Const.mem_insertMany_list {α : Type u} {instOrd : Ord α} {β : Type v} {t : Impl α fun (x : α) => β} [TransOrd α] [BEq α] [LawfulBEqOrd α] (h : t.WF) {l : List (α × β)} {k : α} : k ∈ (insertMany t l ⋯).val ↔ k ∈ t ∨ (List.map Prod.fst l).contains k = true

@[simp]

theorem Std.DTreeMap.Internal.Impl.Const.mem_insertMany!_list {α : Type u} {instOrd : Ord α} {β : Type v} {t : Impl α fun (x : α) => β} [TransOrd α] [BEq α] [LawfulBEqOrd α] (h : t.WF) {l : List (α × β)} {k : α} : k ∈ (insertMany! t l).val ↔ k ∈ t ∨ (List.map Prod.fst l).contains k = true

theorem Std.DTreeMap.Internal.Impl.Const.contains_of_contains_insertMany_list {α : Type u} {instOrd : Ord α} {β : Type v} {t : Impl α fun (x : α) => β} [TransOrd α] [BEq α] [LawfulBEqOrd α] (h : t.WF) {l : List (α × β)} {k : α} : contains k (insertMany t l ⋯).val = true → (List.map Prod.fst l).contains k = false → contains k t = true

theorem Std.DTreeMap.Internal.Impl.Const.mem_of_mem_insertMany_list {α : Type u} {instOrd : Ord α} {β : Type v} {t : Impl α fun (x : α) => β} [TransOrd α] [BEq α] [LawfulBEqOrd α] (h : t.WF) {l : List (α × β)} {k : α} : k ∈ (insertMany t l ⋯).val → (List.map Prod.fst l).contains k = false → k ∈ t

theorem Std.DTreeMap.Internal.Impl.Const.contains_of_contains_insertMany!_list {α : Type u} {instOrd : Ord α} {β : Type v} {t : Impl α fun (x : α) => β} [TransOrd α] [BEq α] [LawfulBEqOrd α] (h : t.WF) {l : List (α × β)} {k : α} : contains k (insertMany! t l).val = true → (List.map Prod.fst l).contains k = false → contains k t = true

theorem Std.DTreeMap.Internal.Impl.Const.mem_of_mem_insertMany!_list {α : Type u} {instOrd : Ord α} {β : Type v} {t : Impl α fun (x : α) => β} [TransOrd α] [BEq α] [LawfulBEqOrd α] (h : t.WF) {l : List (α × β)} {k : α} : k ∈ (insertMany! t l).val → (List.map Prod.fst l).contains k = false → k ∈ t

theorem Std.DTreeMap.Internal.Impl.Const.getKey?_insertMany_list_of_contains_eq_false {α : Type u} {instOrd : Ord α} {β : Type v} {t : Impl α fun (x : α) => β} [TransOrd α] [BEq α] [LawfulBEqOrd α] (h : t.WF) {l : List (α × β)} {k : α} (h' : (List.map Prod.fst l).contains k = false) : (insertMany t l ⋯).val.getKey? k = t.getKey? k

theorem Std.DTreeMap.Internal.Impl.Const.getKey?_insertMany!_list_of_contains_eq_false {α : Type u} {instOrd : Ord α} {β : Type v} {t : Impl α fun (x : α) => β} [TransOrd α] [BEq α] [LawfulBEqOrd α] (h : t.WF) {l : List (α × β)} {k : α} (h' : (List.map Prod.fst l).contains k = false) : (insertMany! t l).val.getKey? k = t.getKey? k

theorem Std.DTreeMap.Internal.Impl.Const.getKey?_insertMany_list_of_mem {α : Type u} {instOrd : Ord α} {β : Type v} {t : Impl α fun (x : α) => β} [TransOrd α] (h : t.WF) {l : List (α × β)} {k k' : α} (k_beq : compare k k' = Ordering.eq) (distinct : List.Pairwise (fun (a b : α × β) => ¬compare a.fst b.fst = Ordering.eq) l) (mem : k ∈ List.map Prod.fst l) : (insertMany t l ⋯).val.getKey? k' = some k

theorem Std.DTreeMap.Internal.Impl.Const.getKey?_insertMany!_list_of_mem {α : Type u} {instOrd : Ord α} {β : Type v} {t : Impl α fun (x : α) => β} [TransOrd α] (h : t.WF) {l : List (α × β)} {k k' : α} (k_beq : compare k k' = Ordering.eq) (distinct : List.Pairwise (fun (a b : α × β) => ¬compare a.fst b.fst = Ordering.eq) l) (mem : k ∈ List.map Prod.fst l) : (insertMany! t l).val.getKey? k' = some k

theorem Std.DTreeMap.Internal.Impl.Const.getKey_insertMany_list_of_contains_eq_false {α : Type u} {instOrd : Ord α} {β : Type v} {t : Impl α fun (x : α) => β} [TransOrd α] [BEq α] [LawfulBEqOrd α] (h : t.WF) {l : List (α × β)} {k : α} (h₁ : (List.map Prod.fst l).contains k = false) {h' : contains k (insertMany t l ⋯).val = true} : (insertMany t l ⋯).val.getKey k h' = t.getKey k ⋯

theorem Std.DTreeMap.Internal.Impl.Const.getKey_insertMany!_list_of_contains_eq_false {α : Type u} {instOrd : Ord α} {β : Type v} {t : Impl α fun (x : α) => β} [TransOrd α] [BEq α] [LawfulBEqOrd α] (h : t.WF) {l : List (α × β)} {k : α} (h₁ : (List.map Prod.fst l).contains k = false) {h' : contains k (insertMany! t l).val = true} : (insertMany! t l).val.getKey k h' = t.getKey k ⋯

theorem Std.DTreeMap.Internal.Impl.Const.getKey_insertMany_list_of_mem {α : Type u} {instOrd : Ord α} {β : Type v} {t : Impl α fun (x : α) => β} [TransOrd α] (h : t.WF) {l : List (α × β)} {k k' : α} (k_beq : compare k k' = Ordering.eq) (distinct : List.Pairwise (fun (a b : α × β) => ¬compare a.fst b.fst = Ordering.eq) l) (mem : k ∈ List.map Prod.fst l) {h' : contains k' (insertMany t l ⋯).val = true} : (insertMany t l ⋯).val.getKey k' h' = k

theorem Std.DTreeMap.Internal.Impl.Const.getKey_insertMany!_list_of_mem {α : Type u} {instOrd : Ord α} {β : Type v} {t : Impl α fun (x : α) => β} [TransOrd α] (h : t.WF) {l : List (α × β)} {k k' : α} (k_beq : compare k k' = Ordering.eq) (distinct : List.Pairwise (fun (a b : α × β) => ¬compare a.fst b.fst = Ordering.eq) l) (mem : k ∈ List.map Prod.fst l) {h' : contains k' (insertMany! t l).val = true} : (insertMany! t l).val.getKey k' h' = k

theorem Std.DTreeMap.Internal.Impl.Const.getKey!_insertMany_list_of_contains_eq_false {α : Type u} {instOrd : Ord α} {β : Type v} {t : Impl α fun (x : α) => β} [TransOrd α] [BEq α] [LawfulBEqOrd α] [Inhabited α] (h : t.WF) {l : List (α × β)} {k : α} (h' : (List.map Prod.fst l).contains k = false) : (insertMany t l ⋯).val.getKey! k = t.getKey! k

theorem Std.DTreeMap.Internal.Impl.Const.getKey!_insertMany!_list_of_contains_eq_false {α : Type u} {instOrd : Ord α} {β : Type v} {t : Impl α fun (x : α) => β} [TransOrd α] [BEq α] [LawfulBEqOrd α] [Inhabited α] (h : t.WF) {l : List (α × β)} {k : α} (h' : (List.map Prod.fst l).contains k = false) : (insertMany! t l).val.getKey! k = t.getKey! k

theorem Std.DTreeMap.Internal.Impl.Const.getKey!_insertMany_list_of_mem {α : Type u} {instOrd : Ord α} {β : Type v} {t : Impl α fun (x : α) => β} [TransOrd α] [Inhabited α] (h : t.WF) {l : List (α × β)} {k k' : α} (k_beq : compare k k' = Ordering.eq) (distinct : List.Pairwise (fun (a b : α × β) => ¬compare a.fst b.fst = Ordering.eq) l) (mem : k ∈ List.map Prod.fst l) : (insertMany t l ⋯).val.getKey! k' = k

theorem Std.DTreeMap.Internal.Impl.Const.getKey!_insertMany!_list_of_mem {α : Type u} {instOrd : Ord α} {β : Type v} {t : Impl α fun (x : α) => β} [TransOrd α] [Inhabited α] (h : t.WF) {l : List (α × β)} {k k' : α} (k_beq : compare k k' = Ordering.eq) (distinct : List.Pairwise (fun (a b : α × β) => ¬compare a.fst b.fst = Ordering.eq) l) (mem : k ∈ List.map Prod.fst l) : (insertMany! t l).val.getKey! k' = k

theorem Std.DTreeMap.Internal.Impl.Const.getKeyD_insertMany_list_of_contains_eq_false {α : Type u} {instOrd : Ord α} {β : Type v} {t : Impl α fun (x : α) => β} [TransOrd α] [BEq α] [LawfulBEqOrd α] (h : t.WF) {l : List (α × β)} {k fallback : α} (h' : (List.map Prod.fst l).contains k = false) : (insertMany t l ⋯).val.getKeyD k fallback = t.getKeyD k fallback

theorem Std.DTreeMap.Internal.Impl.Const.getKeyD_insertMany!_list_of_contains_eq_false {α : Type u} {instOrd : Ord α} {β : Type v} {t : Impl α fun (x : α) => β} [TransOrd α] [BEq α] [LawfulBEqOrd α] (h : t.WF) {l : List (α × β)} {k fallback : α} (h' : (List.map Prod.fst l).contains k = false) : (insertMany! t l).val.getKeyD k fallback = t.getKeyD k fallback

theorem Std.DTreeMap.Internal.Impl.Const.getKeyD_insertMany_list_of_mem {α : Type u} {instOrd : Ord α} {β : Type v} {t : Impl α fun (x : α) => β} [TransOrd α] (h : t.WF) {l : List (α × β)} {k k' fallback : α} (k_beq : compare k k' = Ordering.eq) (distinct : List.Pairwise (fun (a b : α × β) => ¬compare a.fst b.fst = Ordering.eq) l) (mem : k ∈ List.map Prod.fst l) : (insertMany t l ⋯).val.getKeyD k' fallback = k

theorem Std.DTreeMap.Internal.Impl.Const.getKeyD_insertMany!_list_of_mem {α : Type u} {instOrd : Ord α} {β : Type v} {t : Impl α fun (x : α) => β} [TransOrd α] (h : t.WF) {l : List (α × β)} {k k' fallback : α} (k_beq : compare k k' = Ordering.eq) (distinct : List.Pairwise (fun (a b : α × β) => ¬compare a.fst b.fst = Ordering.eq) l) (mem : k ∈ List.map Prod.fst l) : (insertMany! t l).val.getKeyD k' fallback = k

theorem Std.DTreeMap.Internal.Impl.Const.size_insertMany_list {α : Type u} {instOrd : Ord α} {β : Type v} {t : Impl α fun (x : α) => β} [TransOrd α] [BEq α] [LawfulBEqOrd α] (h : t.WF) {l : List (α × β)} (distinct : List.Pairwise (fun (a b : α × β) => ¬compare a.fst b.fst = Ordering.eq) l) : (∀ (a : α), contains a t = true → (List.map Prod.fst l).contains a = false) → (insertMany t l ⋯).val.size = t.size + l.length

theorem Std.DTreeMap.Internal.Impl.Const.size_insertMany!_list {α : Type u} {instOrd : Ord α} {β : Type v} {t : Impl α fun (x : α) => β} [TransOrd α] [BEq α] [LawfulBEqOrd α] (h : t.WF) {l : List (α × β)} (distinct : List.Pairwise (fun (a b : α × β) => ¬compare a.fst b.fst = Ordering.eq) l) : (∀ (a : α), contains a t = true → (List.map Prod.fst l).contains a = false) → (insertMany! t l).val.size = t.size + l.length

theorem Std.DTreeMap.Internal.Impl.Const.size_le_size_insertMany_list {α : Type u} {instOrd : Ord α} {β : Type v} {t : Impl α fun (x : α) => β} [TransOrd α] (h : t.WF) {l : List (α × β)} : t.size ≤ (insertMany t l ⋯).val.size

theorem Std.DTreeMap.Internal.Impl.Const.size_le_size_insertMany!_list {α : Type u} {instOrd : Ord α} {β : Type v} {t : Impl α fun (x : α) => β} [TransOrd α] (h : t.WF) {l : List (α × β)} : t.size ≤ (insertMany! t l).val.size

theorem Std.DTreeMap.Internal.Impl.Const.size_insertMany_list_le {α : Type u} {instOrd : Ord α} {β : Type v} {t : Impl α fun (x : α) => β} [TransOrd α] (h : t.WF) {l : List (α × β)} : (insertMany t l ⋯).val.size ≤ t.size + l.length

theorem Std.DTreeMap.Internal.Impl.Const.size_insertMany!_list_le {α : Type u} {instOrd : Ord α} {β : Type v} {t : Impl α fun (x : α) => β} [TransOrd α] (h : t.WF) {l : List (α × β)} : (insertMany! t l).val.size ≤ t.size + l.length

@[simp]

theorem Std.DTreeMap.Internal.Impl.Const.isEmpty_insertMany_list {α : Type u} {instOrd : Ord α} {β : Type v} {t : Impl α fun (x : α) => β} [TransOrd α] (h : t.WF) {l : List (α × β)} : (insertMany t l ⋯).val.isEmpty = (t.isEmpty && l.isEmpty)

@[simp]

theorem Std.DTreeMap.Internal.Impl.Const.isEmpty_insertMany!_list {α : Type u} {instOrd : Ord α} {β : Type v} {t : Impl α fun (x : α) => β} [TransOrd α] (h : t.WF) {l : List (α × β)} : (insertMany! t l).val.isEmpty = (t.isEmpty && l.isEmpty)

theorem Std.DTreeMap.Internal.Impl.Const.get?_insertMany_list_of_contains_eq_false {α : Type u} {instOrd : Ord α} {β : Type v} {t : Impl α fun (x : α) => β} [TransOrd α] [BEq α] [LawfulBEqOrd α] (h : t.WF) {l : List (α × β)} {k : α} (h' : (List.map Prod.fst l).contains k = false) : get? (insertMany t l ⋯).val k = get? t k

theorem Std.DTreeMap.Internal.Impl.Const.get?_insertMany!_list_of_contains_eq_false {α : Type u} {instOrd : Ord α} {β : Type v} {t : Impl α fun (x : α) => β} [TransOrd α] [BEq α] [LawfulBEqOrd α] (h : t.WF) {l : List (α × β)} {k : α} (h' : (List.map Prod.fst l).contains k = false) : get? (insertMany! t l).val k = get? t k

theorem Std.DTreeMap.Internal.Impl.Const.get?_insertMany_list_of_mem {α : Type u} {instOrd : Ord α} {β : Type v} {t : Impl α fun (x : α) => β} [TransOrd α] (h : t.WF) {l : List (α × β)} {k k' : α} (k_beq : compare k k' = Ordering.eq) {v : β} (distinct : List.Pairwise (fun (a b : α × β) => ¬compare a.fst b.fst = Ordering.eq) l) (mem : (k, v) ∈ l) : get? (insertMany t l ⋯).val k' = some v

theorem Std.DTreeMap.Internal.Impl.Const.get?_insertMany!_list_of_mem {α : Type u} {instOrd : Ord α} {β : Type v} {t : Impl α fun (x : α) => β} [TransOrd α] (h : t.WF) {l : List (α × β)} {k k' : α} (k_beq : compare k k' = Ordering.eq) {v : β} (distinct : List.Pairwise (fun (a b : α × β) => ¬compare a.fst b.fst = Ordering.eq) l) (mem : (k, v) ∈ l) : get? (insertMany! t l).val k' = some v

theorem Std.DTreeMap.Internal.Impl.Const.get?_insertMany_list {α : Type u} {instOrd : Ord α} {β : Type v} {t : Impl α fun (x : α) => β} [TransOrd α] [BEq α] [LawfulBEqOrd α] (h : t.WF) {l : List (α × β)} {k : α} : get? (insertMany t l ⋯).val k = (List.findSomeRev? (fun (x : α × β) => match x with | (a, b) => if compare a k = Ordering.eq then some b else none) l).or (get? t k)

theorem Std.DTreeMap.Internal.Impl.Const.get?_insertMany!_list {α : Type u} {instOrd : Ord α} {β : Type v} {t : Impl α fun (x : α) => β} [TransOrd α] [BEq α] [LawfulBEqOrd α] (h : t.WF) {l : List (α × β)} {k : α} : get? (insertMany! t l).val k = (List.findSomeRev? (fun (x : α × β) => match x with | (a, b) => if compare a k = Ordering.eq then some b else none) l).or (get? t k)

theorem Std.DTreeMap.Internal.Impl.Const.get_insertMany_list_of_contains_eq_false {α : Type u} {instOrd : Ord α} {β : Type v} {t : Impl α fun (x : α) => β} [TransOrd α] [BEq α] [LawfulBEqOrd α] (h : t.WF) {l : List (α × β)} {k : α} (h₁ : (List.map Prod.fst l).contains k = false) {h' : contains k (insertMany t l ⋯).val = true} : get (insertMany t l ⋯).val k h' = get t k ⋯

theorem Std.DTreeMap.Internal.Impl.Const.get_insertMany!_list_of_contains_eq_false {α : Type u} {instOrd : Ord α} {β : Type v} {t : Impl α fun (x : α) => β} [TransOrd α] [BEq α] [LawfulBEqOrd α] (h : t.WF) {l : List (α × β)} {k : α} (h₁ : (List.map Prod.fst l).contains k = false) {h' : contains k (insertMany! t l).val = true} : get (insertMany! t l).val k h' = get t k ⋯

theorem Std.DTreeMap.Internal.Impl.Const.get_insertMany_list_of_mem {α : Type u} {instOrd : Ord α} {β : Type v} {t : Impl α fun (x : α) => β} [TransOrd α] (h : t.WF) {l : List (α × β)} {k k' : α} (k_beq : compare k k' = Ordering.eq) {v : β} (distinct : List.Pairwise (fun (a b : α × β) => ¬compare a.fst b.fst = Ordering.eq) l) (mem : (k, v) ∈ l) {h' : contains k' (insertMany t l ⋯).val = true} : get (insertMany t l ⋯).val k' h' = v

theorem Std.DTreeMap.Internal.Impl.Const.get_insertMany!_list_of_mem {α : Type u} {instOrd : Ord α} {β : Type v} {t : Impl α fun (x : α) => β} [TransOrd α] (h : t.WF) {l : List (α × β)} {k k' : α} (k_beq : compare k k' = Ordering.eq) {v : β} (distinct : List.Pairwise (fun (a b : α × β) => ¬compare a.fst b.fst = Ordering.eq) l) (mem : (k, v) ∈ l) {h' : contains k' (insertMany! t l).val = true} : get (insertMany! t l).val k' h' = v

theorem Std.DTreeMap.Internal.Impl.Const.contains_of_contains_insertMany_list' {α : Type u} {instOrd : Ord α} {β : Type v} {t : Impl α fun (x : α) => β} [TransOrd α] [BEq α] [LawfulBEqOrd α] (h : t.WF) {l : List (α × β)} {k : α} (h' : contains k (insertMany t l ⋯).val = true) (w : List.findSomeRev? (fun (x : α × β) => match x with | (a, b) => if compare a k = Ordering.eq then some b else none) l = none) : contains k t = true

A variant of contains_of_contains_insertMany_list used in get_insertMany_list.

theorem Std.DTreeMap.Internal.Impl.Const.get_insertMany_list {α : Type u} {instOrd : Ord α} {β : Type v} {t : Impl α fun (x : α) => β} [TransOrd α] [BEq α] [LawfulBEqOrd α] (h : t.WF) {l : List (α × β)} {k : α} (h' : contains k (insertMany t l ⋯).val = true) : get (insertMany t l ⋯).val k h' = match w : List.findSomeRev? (fun (x : α × β) => match x with | (a, b) => if compare a k = Ordering.eq then some b else none) l with | some v => v | none => get t k ⋯

theorem Std.DTreeMap.Internal.Impl.Const.get_insertMany!_list {α : Type u} {instOrd : Ord α} {β : Type v} {t : Impl α fun (x : α) => β} [TransOrd α] [BEq α] [LawfulBEqOrd α] (h : t.WF) {l : List (α × β)} {k : α} {h' : contains k (insertMany! t l).val = true} : get (insertMany! t l).val k h' = match w : List.findSomeRev? (fun (x : α × β) => match x with | (a, b) => if compare a k = Ordering.eq then some b else none) l with | some v => v | none => get t k ⋯

theorem Std.DTreeMap.Internal.Impl.Const.get!_insertMany_list_of_contains_eq_false {α : Type u} {instOrd : Ord α} {β : Type v} {t : Impl α fun (x : α) => β} [TransOrd α] [BEq α] [LawfulBEqOrd α] [Inhabited β] (h : t.WF) {l : List (α × β)} {k : α} (h' : (List.map Prod.fst l).contains k = false) : get! (insertMany t l ⋯).val k = get! t k

theorem Std.DTreeMap.Internal.Impl.Const.get!_insertMany!_list_of_contains_eq_false {α : Type u} {instOrd : Ord α} {β : Type v} {t : Impl α fun (x : α) => β} [TransOrd α] [BEq α] [LawfulBEqOrd α] [Inhabited β] (h : t.WF) {l : List (α × β)} {k : α} (h' : (List.map Prod.fst l).contains k = false) : get! (insertMany! t l).val k = get! t k

theorem Std.DTreeMap.Internal.Impl.Const.get!_insertMany_list_of_mem {α : Type u} {instOrd : Ord α} {β : Type v} {t : Impl α fun (x : α) => β} [TransOrd α] [Inhabited β] (h : t.WF) {l : List (α × β)} {k k' : α} {v : β} (k_beq : compare k k' = Ordering.eq) (distinct : List.Pairwise (fun (a b : α × β) => ¬compare a.fst b.fst = Ordering.eq) l) (mem : (k, v) ∈ l) : get! (insertMany t l ⋯).val k' = v

theorem Std.DTreeMap.Internal.Impl.Const.get!_insertMany!_list_of_mem {α : Type u} {instOrd : Ord α} {β : Type v} {t : Impl α fun (x : α) => β} [TransOrd α] [Inhabited β] (h : t.WF) {l : List (α × β)} {k k' : α} {v : β} (k_beq : compare k k' = Ordering.eq) (distinct : List.Pairwise (fun (a b : α × β) => ¬compare a.fst b.fst = Ordering.eq) l) (mem : (k, v) ∈ l) : get! (insertMany! t l).val k' = v

theorem Std.DTreeMap.Internal.Impl.Const.getD_insertMany_list_of_contains_eq_false {α : Type u} {instOrd : Ord α} {β : Type v} {t : Impl α fun (x : α) => β} [TransOrd α] [BEq α] [LawfulBEqOrd α] (h : t.WF) {l : List (α × β)} {k : α} {fallback : β} (h' : (List.map Prod.fst l).contains k = false) : getD (insertMany t l ⋯).val k fallback = getD t k fallback

theorem Std.DTreeMap.Internal.Impl.Const.getD_insertMany!_list_of_contains_eq_false {α : Type u} {instOrd : Ord α} {β : Type v} {t : Impl α fun (x : α) => β} [TransOrd α] [BEq α] [LawfulBEqOrd α] (h : t.WF) {l : List (α × β)} {k : α} {fallback : β} (h' : (List.map Prod.fst l).contains k = false) : getD (insertMany! t l).val k fallback = getD t k fallback

theorem Std.DTreeMap.Internal.Impl.Const.getD_insertMany_list_of_mem {α : Type u} {instOrd : Ord α} {β : Type v} {t : Impl α fun (x : α) => β} [TransOrd α] (h : t.WF) {l : List (α × β)} {k k' : α} {v fallback : β} (k_beq : compare k k' = Ordering.eq) (distinct : List.Pairwise (fun (a b : α × β) => ¬compare a.fst b.fst = Ordering.eq) l) (mem : (k, v) ∈ l) : getD (insertMany t l ⋯).val k' fallback = v

theorem Std.DTreeMap.Internal.Impl.Const.getD_insertMany!_list_of_mem {α : Type u} {instOrd : Ord α} {β : Type v} {t : Impl α fun (x : α) => β} [TransOrd α] (h : t.WF) {l : List (α × β)} {k k' : α} {v fallback : β} (k_beq : compare k k' = Ordering.eq) (distinct : List.Pairwise (fun (a b : α × β) => ¬compare a.fst b.fst = Ordering.eq) l) (mem : (k, v) ∈ l) : getD (insertMany! t l).val k' fallback = v

theorem Std.DTreeMap.Internal.Impl.Const.getD_insertMany_list {α : Type u} {instOrd : Ord α} {β : Type v} {t : Impl α fun (x : α) => β} [TransOrd α] [BEq α] [LawfulBEqOrd α] (h : t.WF) {l : List (α × β)} {k : α} (fallback : β) : getD (insertMany t l ⋯).val k fallback = (List.findSomeRev? (fun (x : α × β) => match x with | (a, b) => if compare a k = Ordering.eq then some b else none) l).getD (getD t k fallback)

theorem Std.DTreeMap.Internal.Impl.Const.getD_insertMany!_list {α : Type u} {instOrd : Ord α} {β : Type v} {t : Impl α fun (x : α) => β} [TransOrd α] [BEq α] [LawfulBEqOrd α] (h : t.WF) {l : List (α × β)} {k : α} (fallback : β) : getD (insertMany! t l).val k fallback = (List.findSomeRev? (fun (x : α × β) => match x with | (a, b) => if compare a k = Ordering.eq then some b else none) l).getD (getD t k fallback)

theorem Std.DTreeMap.Internal.Impl.Const.get!_insertMany_list {α : Type u} {instOrd : Ord α} {β : Type v} {t : Impl α fun (x : α) => β} [TransOrd α] [BEq α] [LawfulBEqOrd α] [Inhabited β] (h : t.WF) {l : List (α × β)} {k : α} : get! (insertMany t l ⋯).val k = (List.findSomeRev? (fun (x : α × β) => match x with | (a, b) => if compare a k = Ordering.eq then some b else none) l).getD (get! t k)

theorem Std.DTreeMap.Internal.Impl.Const.get!_insertMany!_list {α : Type u} {instOrd : Ord α} {β : Type v} {t : Impl α fun (x : α) => β} [TransOrd α] [BEq α] [LawfulBEqOrd α] [Inhabited β] (h : t.WF) {l : List (α × β)} {k : α} : get! (insertMany! t l).val k = (List.findSomeRev? (fun (x : α × β) => match x with | (a, b) => if compare a k = Ordering.eq then some b else none) l).getD (get! t k)

theorem Std.DTreeMap.Internal.Impl.Const.ofList_eq_insertMany {α : Type u} {instOrd : Ord α} {β : Type v} {l : List (α × β)} : ofList l = (insertMany empty l ⋯).val

theorem Std.DTreeMap.Internal.Impl.Const.ofList_eq_insertMany! {α : Type u} {instOrd : Ord α} {β : Type v} {l : List (α × β)} : ofList l = (insertMany! empty l).val

theorem Std.DTreeMap.Internal.Impl.Const.insertManyIfNewUnit_cons {α : Type u} {instOrd : Ord α} {t : Impl α fun (x : α) => Unit} (h : t.WF) {l : List α} {k : α} : (insertManyIfNewUnit t (k :: l) ⋯).val = (insertManyIfNewUnit (insertIfNew k () t ⋯).impl l ⋯).val

theorem Std.DTreeMap.Internal.Impl.Const.insertManyIfNewUnit!_cons {α : Type u} {instOrd : Ord α} {t : Impl α fun (x : α) => Unit} {l : List α} {k : α} : (insertManyIfNewUnit! t (k :: l)).val = (insertManyIfNewUnit! (insertIfNew! k () t) l).val

@[simp]

theorem Std.DTreeMap.Internal.Impl.Const.contains_insertManyIfNewUnit_list {α : Type u} {instOrd : Ord α} {t : Impl α fun (x : α) => Unit} [TransOrd α] [BEq α] [LawfulBEqOrd α] (h : t.WF) {l : List α} {k : α} : contains k (insertManyIfNewUnit t l ⋯).val = (contains k t || l.contains k)

@[simp]

theorem Std.DTreeMap.Internal.Impl.Const.contains_insertManyIfNewUnit!_list {α : Type u} {instOrd : Ord α} {t : Impl α fun (x : α) => Unit} [TransOrd α] [BEq α] [LawfulBEqOrd α] (h : t.WF) {l : List α} {k : α} : contains k (insertManyIfNewUnit! t l).val = (contains k t || l.contains k)

@[simp]

theorem Std.DTreeMap.Internal.Impl.Const.mem_insertManyIfNewUnit_list {α : Type u} {instOrd : Ord α} {t : Impl α fun (x : α) => Unit} [TransOrd α] [BEq α] [LawfulBEqOrd α] (h : t.WF) {l : List α} {k : α} : k ∈ (insertManyIfNewUnit t l ⋯).val ↔ k ∈ t ∨ l.contains k = true

@[simp]

theorem Std.DTreeMap.Internal.Impl.Const.mem_insertManyIfNewUnit!_list {α : Type u} {instOrd : Ord α} {t : Impl α fun (x : α) => Unit} [TransOrd α] [BEq α] [LawfulBEqOrd α] (h : t.WF) {l : List α} {k : α} : k ∈ (insertManyIfNewUnit! t l).val ↔ k ∈ t ∨ l.contains k = true

theorem Std.DTreeMap.Internal.Impl.Const.contains_of_contains_insertManyIfNewUnit_list {α : Type u} {instOrd : Ord α} {t : Impl α fun (x : α) => Unit} [TransOrd α] [BEq α] [LawfulBEqOrd α] (h : t.WF) {l : List α} {k : α} (h₂ : l.contains k = false) : contains k (insertManyIfNewUnit t l ⋯).val = true → contains k t = true

theorem Std.DTreeMap.Internal.Impl.Const.contains_of_contains_insertManyIfNewUnit!_list {α : Type u} {instOrd : Ord α} {t : Impl α fun (x : α) => Unit} [TransOrd α] [BEq α] [LawfulBEqOrd α] (h : t.WF) {l : List α} {k : α} (h₂ : l.contains k = false) : contains k (insertManyIfNewUnit! t l).val = true → contains k t = true

theorem Std.DTreeMap.Internal.Impl.Const.mem_of_mem_insertManyIfNewUnit_list {α : Type u} {instOrd : Ord α} {t : Impl α fun (x : α) => Unit} [TransOrd α] [BEq α] [LawfulBEqOrd α] (h : t.WF) {l : List α} {k : α} (contains_eq_false : l.contains k = false) : k ∈ (insertManyIfNewUnit t l ⋯).val → k ∈ t

theorem Std.DTreeMap.Internal.Impl.Const.mem_of_mem_insertManyIfNewUnit!_list {α : Type u} {instOrd : Ord α} {t : Impl α fun (x : α) => Unit} [TransOrd α] [BEq α] [LawfulBEqOrd α] (h : t.WF) {l : List α} {k : α} (contains_eq_false : l.contains k = false) : k ∈ (insertManyIfNewUnit! t l).val → k ∈ t

theorem Std.DTreeMap.Internal.Impl.Const.getKey?_insertManyIfNewUnit_list_of_not_mem_of_contains_eq_false {α : Type u} {instOrd : Ord α} {t : Impl α fun (x : α) => Unit} [TransOrd α] [BEq α] [LawfulBEqOrd α] (h : t.WF) {l : List α} {k : α} : ¬k ∈ t → l.contains k = false → (insertManyIfNewUnit t l ⋯).val.getKey? k = none

theorem Std.DTreeMap.Internal.Impl.Const.getKey?_insertManyIfNewUnit!_list_of_not_mem_of_contains_eq_false {α : Type u} {instOrd : Ord α} {t : Impl α fun (x : α) => Unit} [TransOrd α] [BEq α] [LawfulBEqOrd α] (h : t.WF) {l : List α} {k : α} : ¬k ∈ t → l.contains k = false → (insertManyIfNewUnit! t l).val.getKey? k = none

theorem Std.DTreeMap.Internal.Impl.Const.getKey?_insertManyIfNewUnit_list_of_not_mem_of_mem {α : Type u} {instOrd : Ord α} {t : Impl α fun (x : α) => Unit} [TransOrd α] (h : t.WF) {l : List α} {k k' : α} (k_beq : compare k k' = Ordering.eq) : ¬k ∈ t → List.Pairwise (fun (a b : α) => ¬compare a b = Ordering.eq) l → k ∈ l → (insertManyIfNewUnit t l ⋯).val.getKey? k' = some k

theorem Std.DTreeMap.Internal.Impl.Const.getKey?_insertManyIfNewUnit!_list_of_not_mem_of_mem {α : Type u} {instOrd : Ord α} {t : Impl α fun (x : α) => Unit} [TransOrd α] (h : t.WF) {l : List α} {k k' : α} (k_beq : compare k k' = Ordering.eq) : ¬k ∈ t → List.Pairwise (fun (a b : α) => ¬compare a b = Ordering.eq) l → k ∈ l → (insertManyIfNewUnit! t l).val.getKey? k' = some k

theorem Std.DTreeMap.Internal.Impl.Const.getKey?_insertManyIfNewUnit_list_of_mem {α : Type u} {instOrd : Ord α} {t : Impl α fun (x : α) => Unit} [TransOrd α] (h : t.WF) {l : List α} {k : α} : k ∈ t → (insertManyIfNewUnit t l ⋯).val.getKey? k = t.getKey? k

theorem Std.DTreeMap.Internal.Impl.Const.getKey?_insertManyIfNewUnit!_list_of_mem {α : Type u} {instOrd : Ord α} {t : Impl α fun (x : α) => Unit} [TransOrd α] (h : t.WF) {l : List α} {k : α} : k ∈ t → (insertManyIfNewUnit! t l).val.getKey? k = t.getKey? k

theorem Std.DTreeMap.Internal.Impl.Const.getKey_insertManyIfNewUnit_list_of_mem {α : Type u} {instOrd : Ord α} {t : Impl α fun (x : α) => Unit} [TransOrd α] (h : t.WF) {l : List α} {k : α} {h' : contains k (insertManyIfNewUnit t l ⋯).val = true} (contains : k ∈ t) : (insertManyIfNewUnit t l ⋯).val.getKey k h' = t.getKey k contains

theorem Std.DTreeMap.Internal.Impl.Const.getKey_insertManyIfNewUnit!_list_of_mem {α : Type u} {instOrd : Ord α} {t : Impl α fun (x : α) => Unit} [TransOrd α] (h : t.WF) {l : List α} {k : α} {h' : contains k (insertManyIfNewUnit! t l).val = true} (contains : k ∈ t) : (insertManyIfNewUnit! t l).val.getKey k h' = t.getKey k contains

theorem Std.DTreeMap.Internal.Impl.Const.getKey_insertManyIfNewUnit_list_of_not_mem_of_mem {α : Type u} {instOrd : Ord α} {t : Impl α fun (x : α) => Unit} [TransOrd α] (h : t.WF) {l : List α} {k k' : α} (k_beq : compare k k' = Ordering.eq) {h' : contains k' (insertManyIfNewUnit t l ⋯).val = true} : ¬k ∈ t → List.Pairwise (fun (a b : α) => ¬compare a b = Ordering.eq) l → k ∈ l → (insertManyIfNewUnit t l ⋯).val.getKey k' h' = k

theorem Std.DTreeMap.Internal.Impl.Const.getKey_insertManyIfNewUnit!_list_of_not_mem_of_mem {α : Type u} {instOrd : Ord α} {t : Impl α fun (x : α) => Unit} [TransOrd α] (h : t.WF) {l : List α} {k k' : α} (k_beq : compare k k' = Ordering.eq) {h' : contains k' (insertManyIfNewUnit! t l).val = true} : ¬k ∈ t → List.Pairwise (fun (a b : α) => ¬compare a b = Ordering.eq) l → k ∈ l → (insertManyIfNewUnit! t l).val.getKey k' h' = k

theorem Std.DTreeMap.Internal.Impl.Const.getKey!_insertManyIfNewUnit_list_of_not_mem_of_contains_eq_false {α : Type u} {instOrd : Ord α} {t : Impl α fun (x : α) => Unit} [BEq α] [LawfulBEqOrd α] [TransOrd α] [Inhabited α] (h : t.WF) {l : List α} {k : α} : ¬k ∈ t → l.contains k = false → (insertManyIfNewUnit t l ⋯).val.getKey! k = default

theorem Std.DTreeMap.Internal.Impl.Const.getKey!_insertManyIfNewUnit!_list_of_not_mem_of_contains_eq_false {α : Type u} {instOrd : Ord α} {t : Impl α fun (x : α) => Unit} [BEq α] [LawfulBEqOrd α] [TransOrd α] [Inhabited α] (h : t.WF) {l : List α} {k : α} : ¬k ∈ t → l.contains k = false → (insertManyIfNewUnit! t l).val.getKey! k = default

theorem Std.DTreeMap.Internal.Impl.Const.getKey!_insertManyIfNewUnit_list_of_not_mem_of_mem {α : Type u} {instOrd : Ord α} {t : Impl α fun (x : α) => Unit} [TransOrd α] [Inhabited α] (h : t.WF) {l : List α} {k k' : α} (k_beq : compare k k' = Ordering.eq) : ¬k ∈ t → List.Pairwise (fun (a b : α) => ¬compare a b = Ordering.eq) l → k ∈ l → (insertManyIfNewUnit t l ⋯).val.getKey! k' = k

theorem Std.DTreeMap.Internal.Impl.Const.getKey!_insertManyIfNewUnit!_list_of_not_mem_of_mem {α : Type u} {instOrd : Ord α} {t : Impl α fun (x : α) => Unit} [TransOrd α] [Inhabited α] (h : t.WF) {l : List α} {k k' : α} (k_beq : compare k k' = Ordering.eq) : ¬k ∈ t → List.Pairwise (fun (a b : α) => ¬compare a b = Ordering.eq) l → k ∈ l → (insertManyIfNewUnit! t l).val.getKey! k' = k

theorem Std.DTreeMap.Internal.Impl.Const.getKey!_insertManyIfNewUnit_list_of_mem {α : Type u} {instOrd : Ord α} {t : Impl α fun (x : α) => Unit} [TransOrd α] [Inhabited α] (h : t.WF) {l : List α} {k : α} : k ∈ t → (insertManyIfNewUnit t l ⋯).val.getKey! k = t.getKey! k

theorem Std.DTreeMap.Internal.Impl.Const.getKey!_insertManyIfNewUnit!_list_of_mem {α : Type u} {instOrd : Ord α} {t : Impl α fun (x : α) => Unit} [TransOrd α] [Inhabited α] (h : t.WF) {l : List α} {k : α} : k ∈ t → (insertManyIfNewUnit! t l).val.getKey! k = t.getKey! k

theorem Std.DTreeMap.Internal.Impl.Const.getKeyD_insertManyIfNewUnit_list_of_not_mem_of_contains_eq_false {α : Type u} {instOrd : Ord α} {t : Impl α fun (x : α) => Unit} [BEq α] [LawfulBEqOrd α] [TransOrd α] (h : t.WF) {l : List α} {k fallback : α} : ¬k ∈ t → l.contains k = false → (insertManyIfNewUnit t l ⋯).val.getKeyD k fallback = fallback

theorem Std.DTreeMap.Internal.Impl.Const.getKeyD_insertManyIfNewUnit!_list_of_not_mem_of_contains_eq_false {α : Type u} {instOrd : Ord α} {t : Impl α fun (x : α) => Unit} [BEq α] [LawfulBEqOrd α] [TransOrd α] (h : t.WF) {l : List α} {k fallback : α} : ¬k ∈ t → l.contains k = false → (insertManyIfNewUnit! t l).val.getKeyD k fallback = fallback

theorem Std.DTreeMap.Internal.Impl.Const.getKeyD_insertManyIfNewUnit_list_of_not_mem_of_mem {α : Type u} {instOrd : Ord α} {t : Impl α fun (x : α) => Unit} [TransOrd α] (h : t.WF) {l : List α} {k k' fallback : α} (k_beq : compare k k' = Ordering.eq) : ¬k ∈ t → List.Pairwise (fun (a b : α) => ¬compare a b = Ordering.eq) l → k ∈ l → (insertManyIfNewUnit t l ⋯).val.getKeyD k' fallback = k

theorem Std.DTreeMap.Internal.Impl.Const.getKeyD_insertManyIfNewUnit!_list_of_not_mem_of_mem {α : Type u} {instOrd : Ord α} {t : Impl α fun (x : α) => Unit} [TransOrd α] (h : t.WF) {l : List α} {k k' fallback : α} (k_beq : compare k k' = Ordering.eq) : ¬k ∈ t → List.Pairwise (fun (a b : α) => ¬compare a b = Ordering.eq) l → k ∈ l → (insertManyIfNewUnit! t l).val.getKeyD k' fallback = k

theorem Std.DTreeMap.Internal.Impl.Const.getKeyD_insertManyIfNewUnit_list_of_mem {α : Type u} {instOrd : Ord α} {t : Impl α fun (x : α) => Unit} [TransOrd α] (h : t.WF) {l : List α} {k fallback : α} : k ∈ t → (insertManyIfNewUnit t l ⋯).val.getKeyD k fallback = t.getKeyD k fallback

theorem Std.DTreeMap.Internal.Impl.Const.getKeyD_insertManyIfNewUnit!_list_of_mem {α : Type u} {instOrd : Ord α} {t : Impl α fun (x : α) => Unit} [TransOrd α] (h : t.WF) {l : List α} {k fallback : α} : k ∈ t → (insertManyIfNewUnit! t l).val.getKeyD k fallback = t.getKeyD k fallback

theorem Std.DTreeMap.Internal.Impl.Const.size_insertManyIfNewUnit_list {α : Type u} {instOrd : Ord α} {t : Impl α fun (x : α) => Unit} [TransOrd α] [BEq α] [LawfulBEqOrd α] (h : t.WF) {l : List α} (distinct : List.Pairwise (fun (a b : α) => ¬compare a b = Ordering.eq) l) : (∀ (a : α), a ∈ t → l.contains a = false) → (insertManyIfNewUnit t l ⋯).val.size = t.size + l.length

theorem Std.DTreeMap.Internal.Impl.Const.size_insertManyIfNewUnit!_list {α : Type u} {instOrd : Ord α} {t : Impl α fun (x : α) => Unit} [TransOrd α] [BEq α] [LawfulBEqOrd α] (h : t.WF) {l : List α} (distinct : List.Pairwise (fun (a b : α) => ¬compare a b = Ordering.eq) l) : (∀ (a : α), a ∈ t → l.contains a = false) → (insertManyIfNewUnit! t l).val.size = t.size + l.length

theorem Std.DTreeMap.Internal.Impl.Const.size_le_size_insertManyIfNewUnit_list {α : Type u} {instOrd : Ord α} {t : Impl α fun (x : α) => Unit} [TransOrd α] (h : t.WF) {l : List α} : t.size ≤ (insertManyIfNewUnit t l ⋯).val.size

theorem Std.DTreeMap.Internal.Impl.Const.size_le_size_insertManyIfNewUnit!_list {α : Type u} {instOrd : Ord α} {t : Impl α fun (x : α) => Unit} [TransOrd α] (h : t.WF) {l : List α} : t.size ≤ (insertManyIfNewUnit! t l).val.size

theorem Std.DTreeMap.Internal.Impl.Const.size_insertManyIfNewUnit_list_le {α : Type u} {instOrd : Ord α} {t : Impl α fun (x : α) => Unit} [TransOrd α] (h : t.WF) {l : List α} : (insertManyIfNewUnit t l ⋯).val.size ≤ t.size + l.length

theorem Std.DTreeMap.Internal.Impl.Const.size_insertManyIfNewUnit!_list_le {α : Type u} {instOrd : Ord α} {t : Impl α fun (x : α) => Unit} [TransOrd α] (h : t.WF) {l : List α} : (insertManyIfNewUnit! t l).val.size ≤ t.size + l.length

@[simp]

theorem Std.DTreeMap.Internal.Impl.Const.isEmpty_insertManyIfNewUnit_list {α : Type u} {instOrd : Ord α} {t : Impl α fun (x : α) => Unit} [TransOrd α] (h : t.WF) {l : List α} : (insertManyIfNewUnit t l ⋯).val.isEmpty = (t.isEmpty && l.isEmpty)

@[simp]

theorem Std.DTreeMap.Internal.Impl.Const.isEmpty_insertManyIfNewUnit!_list {α : Type u} {instOrd : Ord α} {t : Impl α fun (x : α) => Unit} [TransOrd α] (h : t.WF) {l : List α} : (insertManyIfNewUnit! t l).val.isEmpty = (t.isEmpty && l.isEmpty)

theorem Std.DTreeMap.Internal.Impl.Const.get?_insertManyIfNewUnit_list {α : Type u} {instOrd : Ord α} {t : Impl α fun (x : α) => Unit} [TransOrd α] [BEq α] [LawfulBEqOrd α] (h : t.WF) {l : List α} {k : α} : get? (insertManyIfNewUnit t l ⋯).val k = if k ∈ t ∨ l.contains k = true then some () else none

theorem Std.DTreeMap.Internal.Impl.Const.get?_insertManyIfNewUnit!_list {α : Type u} {instOrd : Ord α} {t : Impl α fun (x : α) => Unit} [TransOrd α] [BEq α] [LawfulBEqOrd α] (h : t.WF) {l : List α} {k : α} : get? (insertManyIfNewUnit! t l).val k = if k ∈ t ∨ l.contains k = true then some () else none

theorem Std.DTreeMap.Internal.Impl.Const.get_insertManyIfNewUnit_list {α : Type u} {instOrd : Ord α} {t : Impl α fun (x : α) => Unit} (h : t.WF) {l : List α} {k : α} {h' : contains k (insertManyIfNewUnit t l ⋯).val = true} : get (insertManyIfNewUnit t l ⋯).val k h' = ()

theorem Std.DTreeMap.Internal.Impl.Const.get_insertManyIfNewUnit!_list {α : Type u} {instOrd : Ord α} {t : Impl α fun (x : α) => Unit} {l : List α} {k : α} {h' : contains k (insertManyIfNewUnit! t l).val = true} : get (insertManyIfNewUnit! t l).val k h' = ()

theorem Std.DTreeMap.Internal.Impl.Const.get!_insertManyIfNewUnit_list {α : Type u} {instOrd : Ord α} {t : Impl α fun (x : α) => Unit} (h : t.WF) {l : List α} {k : α} : get! (insertManyIfNewUnit t l ⋯).val k = ()

theorem Std.DTreeMap.Internal.Impl.Const.get!_insertManyIfNewUnit!_list {α : Type u} {instOrd : Ord α} {t : Impl α fun (x : α) => Unit} {l : List α} {k : α} : get! (insertManyIfNewUnit! t l).val k = ()

theorem Std.DTreeMap.Internal.Impl.Const.getD_insertManyIfNewUnit_list {α : Type u} {instOrd : Ord α} {t : Impl α fun (x : α) => Unit} (h : t.WF) {l : List α} {k : α} {fallback : Unit} : getD (insertManyIfNewUnit t l ⋯).val k fallback = ()

theorem Std.DTreeMap.Internal.Impl.Const.getD_insertManyIfNewUnit!_list {α : Type u} {instOrd : Ord α} {t : Impl α fun (x : α) => Unit} {l : List α} {k : α} {fallback : Unit} : getD (insertManyIfNewUnit! t l).val k fallback = ()

theorem Std.DTreeMap.Internal.Impl.Const.unitOfList_eq_insertManyIfNewUnit {α : Type u} {instOrd : Ord α} {l : List α} : unitOfList l = (insertManyIfNewUnit empty l ⋯).val

theorem Std.DTreeMap.Internal.Impl.Const.unitOfList_eq_insertManyIfNewUnit! {α : Type u} {instOrd : Ord α} {l : List α} : unitOfList l = (insertManyIfNewUnit! empty l).val

@[simp]

theorem Std.DTreeMap.Internal.Impl.insertMany_empty_list_nil {α : Type u} {β : α → Type v} {instOrd : Ord α} : (empty.insertMany [] ⋯).val = empty

@[simp]

theorem Std.DTreeMap.Internal.Impl.insertMany!_empty_list_nil {α : Type u} {β : α → Type v} {instOrd : Ord α} : (empty.insertMany! []).val = empty

@[simp]

theorem Std.DTreeMap.Internal.Impl.insertMany_empty_list_singleton {α : Type u} {β : α → Type v} {instOrd : Ord α} {k : α} {v : β k} : (empty.insertMany [⟨k, v⟩] ⋯).val = (insert k v empty ⋯).impl

@[simp]

theorem Std.DTreeMap.Internal.Impl.insertMany!_empty_list_singleton {α : Type u} {β : α → Type v} {instOrd : Ord α} {k : α} {v : β k} : (empty.insertMany! [⟨k, v⟩]).val = (insert k v empty ⋯).impl

theorem Std.DTreeMap.Internal.Impl.insertMany_empty_list_cons {α : Type u} {β : α → Type v} {instOrd : Ord α} {k : α} {v : β k} {tl : List ((a : α) × β a)} : (empty.insertMany (⟨k, v⟩ :: tl) ⋯).val = ((insert k v empty ⋯).impl.insertMany tl ⋯).val

theorem Std.DTreeMap.Internal.Impl.insertMany_empty_list_cons_eq_insertMany! {α : Type u} {β : α → Type v} {instOrd : Ord α} {k : α} {v : β k} {tl : List ((a : α) × β a)} : (empty.insertMany (⟨k, v⟩ :: tl) ⋯).val = ((insert! k v empty).insertMany! tl).val

theorem Std.DTreeMap.Internal.Impl.contains_insertMany_empty_list {α : Type u} {β : α → Type v} {instOrd : Ord α} [TransOrd α] [BEq α] [LawfulBEqOrd α] {l : List ((a : α) × β a)} {k : α} : contains k (empty.insertMany l ⋯).val = (List.map Sigma.fst l).contains k

theorem Std.DTreeMap.Internal.Impl.get?_insertMany_empty_list_of_contains_eq_false {α : Type u} {β : α → Type v} {instOrd : Ord α} [TransOrd α] [BEq α] [LawfulBEqOrd α] [LawfulEqOrd α] {l : List ((a : α) × β a)} {k : α} (h : (List.map Sigma.fst l).contains k = false) : (empty.insertMany l ⋯).val.get? k = none

theorem Std.DTreeMap.Internal.Impl.get?_insertMany_empty_list_of_mem {α : Type u} {β : α → Type v} {instOrd : Ord α} [TransOrd α] [LawfulEqOrd α] {l : List ((a : α) × β a)} {k k' : α} (k_beq : compare k k' = Ordering.eq) {v : β k} (distinct : List.Pairwise (fun (a b : (a : α) × β a) => ¬compare a.fst b.fst = Ordering.eq) l) (mem : ⟨k, v⟩ ∈ l) : (empty.insertMany l ⋯).val.get? k' = some (cast ⋯ v)

theorem Std.DTreeMap.Internal.Impl.get_insertMany_empty_list_of_mem {α : Type u} {β : α → Type v} {instOrd : Ord α} [TransOrd α] [LawfulEqOrd α] {l : List ((a : α) × β a)} {k k' : α} (k_beq : compare k k' = Ordering.eq) {v : β k} (distinct : List.Pairwise (fun (a b : (a : α) × β a) => ¬compare a.fst b.fst = Ordering.eq) l) (mem : ⟨k, v⟩ ∈ l) {h : k' ∈ (empty.insertMany l ⋯).val} : (empty.insertMany l ⋯).val.get k' h = cast ⋯ v

theorem Std.DTreeMap.Internal.Impl.get!_insertMany_empty_list_of_contains_eq_false {α : Type u} {β : α → Type v} {instOrd : Ord α} [TransOrd α] [BEq α] [LawfulBEqOrd α] [LawfulEqOrd α] {l : List ((a : α) × β a)} {k : α} [Inhabited (β k)] (h : (List.map Sigma.fst l).contains k = false) : (empty.insertMany l ⋯).val.get! k = default

theorem Std.DTreeMap.Internal.Impl.get!_insertMany_empty_list_of_mem {α : Type u} {β : α → Type v} {instOrd : Ord α} [TransOrd α] [LawfulEqOrd α] {l : List ((a : α) × β a)} {k k' : α} (k_beq : compare k k' = Ordering.eq) {v : β k} [Inhabited (β k')] (distinct : List.Pairwise (fun (a b : (a : α) × β a) => ¬compare a.fst b.fst = Ordering.eq) l) (mem : ⟨k, v⟩ ∈ l) : (empty.insertMany l ⋯).val.get! k' = cast ⋯ v

theorem Std.DTreeMap.Internal.Impl.getD_insertMany_empty_list_of_contains_eq_false {α : Type u} {β : α → Type v} {instOrd : Ord α} [TransOrd α] [BEq α] [LawfulBEqOrd α] [LawfulEqOrd α] {l : List ((a : α) × β a)} {k : α} {fallback : β k} (contains_eq_false : (List.map Sigma.fst l).contains k = false) : (empty.insertMany l ⋯).val.getD k fallback = fallback

theorem Std.DTreeMap.Internal.Impl.getD_insertMany_empty_list_of_mem {α : Type u} {β : α → Type v} {instOrd : Ord α} [TransOrd α] [LawfulEqOrd α] {l : List ((a : α) × β a)} {k k' : α} (k_beq : compare k k' = Ordering.eq) {v : β k} {fallback : β k'} (distinct : List.Pairwise (fun (a b : (a : α) × β a) => ¬compare a.fst b.fst = Ordering.eq) l) (mem : ⟨k, v⟩ ∈ l) : (empty.insertMany l ⋯).val.getD k' fallback = cast ⋯ v

theorem Std.DTreeMap.Internal.Impl.getKey?_insertMany_empty_list_of_contains_eq_false {α : Type u} {β : α → Type v} {instOrd : Ord α} [TransOrd α] [BEq α] [LawfulBEqOrd α] {l : List ((a : α) × β a)} {k : α} (h : (List.map Sigma.fst l).contains k = false) : (empty.insertMany l ⋯).val.getKey? k = none

theorem Std.DTreeMap.Internal.Impl.getKey?_insertMany_empty_list_of_mem {α : Type u} {β : α → Type v} {instOrd : Ord α} [TransOrd α] {l : List ((a : α) × β a)} {k k' : α} (k_beq : compare k k' = Ordering.eq) (distinct : List.Pairwise (fun (a b : (a : α) × β a) => ¬compare a.fst b.fst = Ordering.eq) l) (mem : k ∈ List.map Sigma.fst l) : (empty.insertMany l ⋯).val.getKey? k' = some k

theorem Std.DTreeMap.Internal.Impl.getKey_insertMany_empty_list_of_mem {α : Type u} {β : α → Type v} {instOrd : Ord α} [TransOrd α] {l : List ((a : α) × β a)} {k k' : α} (k_beq : compare k k' = Ordering.eq) (distinct : List.Pairwise (fun (a b : (a : α) × β a) => ¬compare a.fst b.fst = Ordering.eq) l) (mem : k ∈ List.map Sigma.fst l) {h' : contains k' (empty.insertMany l ⋯).val = true} : (empty.insertMany l ⋯).val.getKey k' h' = k

theorem Std.DTreeMap.Internal.Impl.getKey!_insertMany_empty_list_of_contains_eq_false {α : Type u} {β : α → Type v} {instOrd : Ord α} [TransOrd α] [BEq α] [LawfulBEqOrd α] [Inhabited α] {l : List ((a : α) × β a)} {k : α} (h : (List.map Sigma.fst l).contains k = false) : (empty.insertMany l ⋯).val.getKey! k = default

theorem Std.DTreeMap.Internal.Impl.getKey!_insertMany_empty_list_of_mem {α : Type u} {β : α → Type v} {instOrd : Ord α} [TransOrd α] [Inhabited α] {l : List ((a : α) × β a)} {k k' : α} (k_beq : compare k k' = Ordering.eq) (distinct : List.Pairwise (fun (a b : (a : α) × β a) => ¬compare a.fst b.fst = Ordering.eq) l) (mem : k ∈ List.map Sigma.fst l) : (empty.insertMany l ⋯).val.getKey! k' = k

theorem Std.DTreeMap.Internal.Impl.getKeyD_insertMany_empty_list_of_contains_eq_false {α : Type u} {β : α → Type v} {instOrd : Ord α} [TransOrd α] [BEq α] [LawfulBEqOrd α] {l : List ((a : α) × β a)} {k fallback : α} (h : (List.map Sigma.fst l).contains k = false) : (empty.insertMany l ⋯).val.getKeyD k fallback = fallback

theorem Std.DTreeMap.Internal.Impl.getKeyD_insertMany_empty_list_of_mem {α : Type u} {β : α → Type v} {instOrd : Ord α} [TransOrd α] {l : List ((a : α) × β a)} {k k' fallback : α} (k_beq : compare k k' = Ordering.eq) (distinct : List.Pairwise (fun (a b : (a : α) × β a) => ¬compare a.fst b.fst = Ordering.eq) l) (mem : k ∈ List.map Sigma.fst l) : (empty.insertMany l ⋯).val.getKeyD k' fallback = k

theorem Std.DTreeMap.Internal.Impl.size_insertMany_empty_list {α : Type u} {β : α → Type v} {instOrd : Ord α} [TransOrd α] {l : List ((a : α) × β a)} (distinct : List.Pairwise (fun (a b : (a : α) × β a) => ¬compare a.fst b.fst = Ordering.eq) l) : (empty.insertMany l ⋯).val.size = l.length

theorem Std.DTreeMap.Internal.Impl.size_insertMany_empty_list_le {α : Type u} {β : α → Type v} {instOrd : Ord α} [TransOrd α] {l : List ((a : α) × β a)} : (empty.insertMany l ⋯).val.size ≤ l.length

theorem Std.DTreeMap.Internal.Impl.isEmpty_insertMany_empty_list {α : Type u} {β : α → Type v} {instOrd : Ord α} [TransOrd α] {l : List ((a : α) × β a)} : (empty.insertMany l ⋯).val.isEmpty = l.isEmpty

@[simp]

theorem Std.DTreeMap.Internal.Impl.Const.insertMany_empty_list_nil {α : Type u} {instOrd : Ord α} {β : Type v} : (insertMany empty [] ⋯).val = empty

@[simp]

theorem Std.DTreeMap.Internal.Impl.Const.insertMany_empty_list_singleton {α : Type u} {instOrd : Ord α} {β : Type v} {k : α} {v : β} : (insertMany empty [(k, v)] ⋯).val = (insert k v empty ⋯).impl

theorem Std.DTreeMap.Internal.Impl.Const.insertMany_empty_list_cons {α : Type u} {instOrd : Ord α} {β : Type v} {k : α} {v : β} {tl : List (α × β)} : (insertMany empty ((k, v) :: tl) ⋯).val = (insertMany (insert k v empty ⋯).impl tl ⋯).val

theorem Std.DTreeMap.Internal.Impl.Const.insertMany_empty_list_cons_eq_insertMany! {α : Type u} {instOrd : Ord α} {β : Type v} {k : α} {v : β} {tl : List (α × β)} : (insertMany empty ((k, v) :: tl) ⋯).val = (insertMany! (insert! k v empty) tl).val

theorem Std.DTreeMap.Internal.Impl.Const.contains_insertMany_empty_list {α : Type u} {instOrd : Ord α} {β : Type v} [TransOrd α] [BEq α] [LawfulBEqOrd α] {l : List (α × β)} {k : α} : contains k (insertMany empty l ⋯).val = (List.map Prod.fst l).contains k

theorem Std.DTreeMap.Internal.Impl.Const.get?_insertMany_empty_list_of_contains_eq_false {α : Type u} {instOrd : Ord α} {β : Type v} [TransOrd α] [BEq α] [LawfulBEqOrd α] {l : List (α × β)} {k : α} (h : (List.map Prod.fst l).contains k = false) : get? (insertMany empty l ⋯).val k = none

theorem Std.DTreeMap.Internal.Impl.Const.get?_insertMany_empty_list_of_mem {α : Type u} {instOrd : Ord α} {β : Type v} [TransOrd α] {l : List (α × β)} {k k' : α} (k_beq : compare k k' = Ordering.eq) {v : β} (distinct : List.Pairwise (fun (a b : α × β) => ¬compare a.fst b.fst = Ordering.eq) l) (mem : (k, v) ∈ l) : get? (insertMany empty l ⋯).val k' = some v

theorem Std.DTreeMap.Internal.Impl.Const.get_insertMany_empty_list_of_mem {α : Type u} {instOrd : Ord α} {β : Type v} [TransOrd α] {l : List (α × β)} {k k' : α} (k_beq : compare k k' = Ordering.eq) {v : β} (distinct : List.Pairwise (fun (a b : α × β) => ¬compare a.fst b.fst = Ordering.eq) l) (mem : (k, v) ∈ l) {h : contains k' (insertMany empty l ⋯).val = true} : get (insertMany empty l ⋯).val k' h = v

theorem Std.DTreeMap.Internal.Impl.Const.get!_insertMany_empty_list_of_contains_eq_false {α : Type u} {instOrd : Ord α} {β : Type v} [TransOrd α] [BEq α] [LawfulBEqOrd α] {l : List (α × β)} {k : α} [Inhabited β] (h : (List.map Prod.fst l).contains k = false) : get! (insertMany empty l ⋯).val k = default

theorem Std.DTreeMap.Internal.Impl.Const.get!_insertMany_empty_list_of_mem {α : Type u} {instOrd : Ord α} {β : Type v} [TransOrd α] {l : List (α × β)} {k k' : α} (k_beq : compare k k' = Ordering.eq) {v : β} [Inhabited β] (distinct : List.Pairwise (fun (a b : α × β) => ¬compare a.fst b.fst = Ordering.eq) l) (mem : (k, v) ∈ l) : get! (insertMany empty l ⋯).val k' = v

theorem Std.DTreeMap.Internal.Impl.Const.getD_insertMany_empty_list_of_contains_eq_false {α : Type u} {instOrd : Ord α} {β : Type v} [TransOrd α] [BEq α] [LawfulBEqOrd α] {l : List (α × β)} {k : α} {fallback : β} (contains_eq_false : (List.map Prod.fst l).contains k = false) : getD (insertMany empty l ⋯).val k fallback = fallback

theorem Std.DTreeMap.Internal.Impl.Const.getD_insertMany_empty_list_of_mem {α : Type u} {instOrd : Ord α} {β : Type v} [TransOrd α] {l : List (α × β)} {k k' : α} (k_beq : compare k k' = Ordering.eq) {v fallback : β} (distinct : List.Pairwise (fun (a b : α × β) => ¬compare a.fst b.fst = Ordering.eq) l) (mem : (k, v) ∈ l) : getD (insertMany empty l ⋯).val k' fallback = v

theorem Std.DTreeMap.Internal.Impl.Const.getKey?_insertMany_empty_list_of_contains_eq_false {α : Type u} {instOrd : Ord α} {β : Type v} [TransOrd α] [BEq α] [LawfulBEqOrd α] {l : List (α × β)} {k : α} (h : (List.map Prod.fst l).contains k = false) : (insertMany empty l ⋯).val.getKey? k = none

theorem Std.DTreeMap.Internal.Impl.Const.getKey?_insertMany_empty_list_of_mem {α : Type u} {instOrd : Ord α} {β : Type v} [TransOrd α] {l : List (α × β)} {k k' : α} (k_beq : compare k k' = Ordering.eq) (distinct : List.Pairwise (fun (a b : α × β) => ¬compare a.fst b.fst = Ordering.eq) l) (mem : k ∈ List.map Prod.fst l) : (insertMany empty l ⋯).val.getKey? k' = some k

theorem Std.DTreeMap.Internal.Impl.Const.getKey_insertMany_empty_list_of_mem {α : Type u} {instOrd : Ord α} {β : Type v} [TransOrd α] {l : List (α × β)} {k k' : α} (k_beq : compare k k' = Ordering.eq) (distinct : List.Pairwise (fun (a b : α × β) => ¬compare a.fst b.fst = Ordering.eq) l) (mem : k ∈ List.map Prod.fst l) {h' : contains k' (insertMany empty l ⋯).val = true} : (insertMany empty l ⋯).val.getKey k' h' = k

theorem Std.DTreeMap.Internal.Impl.Const.getKey!_insertMany_empty_list_of_contains_eq_false {α : Type u} {instOrd : Ord α} {β : Type v} [TransOrd α] [BEq α] [LawfulBEqOrd α] [Inhabited α] {l : List (α × β)} {k : α} (h : (List.map Prod.fst l).contains k = false) : (insertMany empty l ⋯).val.getKey! k = default

theorem Std.DTreeMap.Internal.Impl.Const.getKey!_insertMany_empty_list_of_mem {α : Type u} {instOrd : Ord α} {β : Type v} [TransOrd α] [Inhabited α] {l : List (α × β)} {k k' : α} (k_beq : compare k k' = Ordering.eq) (distinct : List.Pairwise (fun (a b : α × β) => ¬compare a.fst b.fst = Ordering.eq) l) (mem : k ∈ List.map Prod.fst l) : (insertMany empty l ⋯).val.getKey! k' = k

theorem Std.DTreeMap.Internal.Impl.Const.getKeyD_insertMany_empty_list_of_contains_eq_false {α : Type u} {instOrd : Ord α} {β : Type v} [TransOrd α] [BEq α] [LawfulBEqOrd α] {l : List (α × β)} {k fallback : α} (h : (List.map Prod.fst l).contains k = false) : (insertMany empty l ⋯).val.getKeyD k fallback = fallback

theorem Std.DTreeMap.Internal.Impl.Const.getKeyD_insertMany_empty_list_of_mem {α : Type u} {instOrd : Ord α} {β : Type v} [TransOrd α] {l : List (α × β)} {k k' fallback : α} (k_beq : compare k k' = Ordering.eq) (distinct : List.Pairwise (fun (a b : α × β) => ¬compare a.fst b.fst = Ordering.eq) l) (mem : k ∈ List.map Prod.fst l) : (insertMany empty l ⋯).val.getKeyD k' fallback = k

theorem Std.DTreeMap.Internal.Impl.Const.size_insertMany_empty_list {α : Type u} {instOrd : Ord α} {β : Type v} [TransOrd α] {l : List (α × β)} (distinct : List.Pairwise (fun (a b : α × β) => ¬compare a.fst b.fst = Ordering.eq) l) : (insertMany empty l ⋯).val.size = l.length

theorem Std.DTreeMap.Internal.Impl.Const.size_insertMany_empty_list_le {α : Type u} {instOrd : Ord α} {β : Type v} [TransOrd α] {l : List (α × β)} : (insertMany empty l ⋯).val.size ≤ l.length

theorem Std.DTreeMap.Internal.Impl.Const.isEmpty_insertMany_empty_list {α : Type u} {instOrd : Ord α} {β : Type v} [TransOrd α] {l : List (α × β)} : (insertMany empty l ⋯).val.isEmpty = l.isEmpty

@[simp]

theorem Std.DTreeMap.Internal.Impl.Const.insertManyIfNewUnit_empty_list_nil {α : Type u} {instOrd : Ord α} : (insertManyIfNewUnit empty [] ⋯).val = empty

@[simp]

theorem Std.DTreeMap.Internal.Impl.Const.insertManyIfNewUnit_empty_list_singleton {α : Type u} {instOrd : Ord α} {k : α} : (insertManyIfNewUnit empty [k] ⋯).val = (insertIfNew k () empty ⋯).impl

theorem Std.DTreeMap.Internal.Impl.Const.insertManyIfNewUnit_empty_list_cons {α : Type u} {instOrd : Ord α} {hd : α} {tl : List α} : (insertManyIfNewUnit empty (hd :: tl) ⋯).val = (insertManyIfNewUnit (insertIfNew hd () empty ⋯).impl tl ⋯).val

theorem Std.DTreeMap.Internal.Impl.Const.insertManyIfNewUnit_empty_list_cons_eq_insertManyIfNewUnit! {α : Type u} {instOrd : Ord α} {hd : α} {tl : List α} : (insertManyIfNewUnit empty (hd :: tl) ⋯).val = (insertManyIfNewUnit! (insertIfNew! hd () empty) tl).val

theorem Std.DTreeMap.Internal.Impl.Const.contains_insertManyIfNewUnit_empty_list {α : Type u} {instOrd : Ord α} [TransOrd α] [BEq α] [LawfulBEqOrd α] {l : List α} {k : α} : contains k (insertManyIfNewUnit empty l ⋯).val = l.contains k

theorem Std.DTreeMap.Internal.Impl.Const.getKey?_insertManyIfNewUnit_empty_list_of_contains_eq_false {α : Type u} {instOrd : Ord α} [TransOrd α] [BEq α] [LawfulBEqOrd α] {l : List α} {k : α} (h' : l.contains k = false) : (insertManyIfNewUnit empty l ⋯).val.getKey? k = none

theorem Std.DTreeMap.Internal.Impl.Const.getKey?_insertManyIfNewUnit_empty_list_of_mem {α : Type u} {instOrd : Ord α} [TransOrd α] {l : List α} {k k' : α} (k_beq : compare k k' = Ordering.eq) (distinct : List.Pairwise (fun (a b : α) => ¬compare a b = Ordering.eq) l) (mem : k ∈ l) : (insertManyIfNewUnit empty l ⋯).val.getKey? k' = some k

theorem Std.DTreeMap.Internal.Impl.Const.getKey_insertManyIfNewUnit_empty_list_of_mem {α : Type u} {instOrd : Ord α} [TransOrd α] {l : List α} {k k' : α} (k_beq : compare k k' = Ordering.eq) (distinct : List.Pairwise (fun (a b : α) => ¬compare a b = Ordering.eq) l) (mem : k ∈ l) {h' : contains k' (insertManyIfNewUnit empty l ⋯).val = true} : (insertManyIfNewUnit empty l ⋯).val.getKey k' h' = k

theorem Std.DTreeMap.Internal.Impl.Const.getKey!_insertManyIfNewUnit_empty_list_of_contains_eq_false {α : Type u} {instOrd : Ord α} [TransOrd α] [BEq α] [LawfulBEqOrd α] [Inhabited α] {l : List α} {k : α} (h' : l.contains k = false) : (insertManyIfNewUnit empty l ⋯).val.getKey! k = default

theorem Std.DTreeMap.Internal.Impl.Const.getKey!_insertManyIfNewUnit_empty_list_of_mem {α : Type u} {instOrd : Ord α} [TransOrd α] [Inhabited α] {l : List α} {k k' : α} (k_beq : compare k k' = Ordering.eq) (distinct : List.Pairwise (fun (a b : α) => ¬compare a b = Ordering.eq) l) (mem : k ∈ l) : (insertManyIfNewUnit empty l ⋯).val.getKey! k' = k

theorem Std.DTreeMap.Internal.Impl.Const.getKeyD_insertManyIfNewUnit_empty_list_of_contains_eq_false {α : Type u} {instOrd : Ord α} [TransOrd α] [BEq α] [LawfulBEqOrd α] {l : List α} {k fallback : α} (h' : l.contains k = false) : (insertManyIfNewUnit empty l ⋯).val.getKeyD k fallback = fallback

theorem Std.DTreeMap.Internal.Impl.Const.getKeyD_insertManyIfNewUnit_empty_list_of_mem {α : Type u} {instOrd : Ord α} [TransOrd α] {l : List α} {k k' fallback : α} (k_beq : compare k k' = Ordering.eq) (distinct : List.Pairwise (fun (a b : α) => ¬compare a b = Ordering.eq) l) (mem : k ∈ l) : (insertManyIfNewUnit empty l ⋯).val.getKeyD k' fallback = k

theorem Std.DTreeMap.Internal.Impl.Const.size_insertManyIfNewUnit_empty_list {α : Type u} {instOrd : Ord α} [TransOrd α] {l : List α} (distinct : List.Pairwise (fun (a b : α) => ¬compare a b = Ordering.eq) l) : (insertManyIfNewUnit empty l ⋯).val.size = l.length

theorem Std.DTreeMap.Internal.Impl.Const.size_insertManyIfNewUnit_empty_list_le {α : Type u} {instOrd : Ord α} [TransOrd α] {l : List α} : (insertManyIfNewUnit empty l ⋯).val.size ≤ l.length

theorem Std.DTreeMap.Internal.Impl.Const.isEmpty_insertManyIfNewUnit_empty_list {α : Type u} {instOrd : Ord α} [TransOrd α] {l : List α} : (insertManyIfNewUnit empty l ⋯).val.isEmpty = l.isEmpty

theorem Std.DTreeMap.Internal.Impl.Const.get?_insertManyIfNewUnit_empty_list {α : Type u} {instOrd : Ord α} [TransOrd α] [BEq α] [LawfulBEqOrd α] {l : List α} {k : α} : get? (insertManyIfNewUnit empty l ⋯).val k = if l.contains k = true then some () else none

theorem Std.DTreeMap.Internal.Impl.Const.get_insertManyIfNewUnit_empty_list {α : Type u} {instOrd : Ord α} {l : List α} {k : α} {h : contains k (insertManyIfNewUnit empty l ⋯).val = true} : get (insertManyIfNewUnit empty l ⋯).val k h = ()

theorem Std.DTreeMap.Internal.Impl.Const.get!_insertManyIfNewUnit_empty_list {α : Type u} {instOrd : Ord α} {l : List α} {k : α} : get! (insertManyIfNewUnit empty l ⋯).val k = ()

theorem Std.DTreeMap.Internal.Impl.Const.getD_insertManyIfNewUnit_empty_list {α : Type u} {instOrd : Ord α} {l : List α} {k : α} {fallback : Unit} : getD (insertManyIfNewUnit empty l ⋯).val k fallback = ()

theorem Std.DTreeMap.Internal.Impl.contains_union_of_left {α : Type u} {β : α → Type v} {instOrd : Ord α} {m₁ m₂ : Impl α β} [TransOrd α] (h₁ : m₁.WF) (h₂ : m₂.WF) {k : α} : contains k m₁ = true → contains k (m₁.union m₂ ⋯ ⋯) = true

theorem Std.DTreeMap.Internal.Impl.contains_union!_of_left {α : Type u} {β : α → Type v} {instOrd : Ord α} {m₁ m₂ : Impl α β} [TransOrd α] (h₁ : m₁.WF) (h₂ : m₂.WF) {k : α} : contains k m₁ = true → contains k (m₁.union! m₂) = true

theorem Std.DTreeMap.Internal.Impl.contains_union_of_right {α : Type u} {β : α → Type v} {instOrd : Ord α} {m₁ m₂ : Impl α β} [TransOrd α] (h₁ : m₁.WF) (h₂ : m₂.WF) {k : α} : contains k m₂ = true → contains k (m₁.union m₂ ⋯ ⋯) = true

theorem Std.DTreeMap.Internal.Impl.contains_union!_of_right {α : Type u} {β : α → Type v} {instOrd : Ord α} {m₁ m₂ : Impl α β} [TransOrd α] (h₁ : m₁.WF) (h₂ : m₂.WF) {k : α} : contains k m₂ = true → contains k (m₁.union! m₂) = true

@[simp]

theorem Std.DTreeMap.Internal.Impl.contains_union {α : Type u} {β : α → Type v} {instOrd : Ord α} {m₁ m₂ : Impl α β} [TransOrd α] (h₁ : m₁.WF) (h₂ : m₂.WF) {k : α} : contains k (m₁.union m₂ ⋯ ⋯) = (contains k m₁ || contains k m₂)

@[simp]

theorem Std.DTreeMap.Internal.Impl.contains_union! {α : Type u} {β : α → Type v} {instOrd : Ord α} {m₁ m₂ : Impl α β} [TransOrd α] (h₁ : m₁.WF) (h₂ : m₂.WF) {k : α} : contains k (m₁.union! m₂) = (contains k m₁ || contains k m₂)

theorem Std.DTreeMap.Internal.Impl.contains_union_iff {α : Type u} {β : α → Type v} {instOrd : Ord α} {m₁ m₂ : Impl α β} [TransOrd α] (h₁ : m₁.WF) (h₂ : m₂.WF) {k : α} : contains k (m₁.union m₂ ⋯ ⋯) = true ↔ contains k m₁ = true ∨ contains k m₂ = true

theorem Std.DTreeMap.Internal.Impl.contains_union!_iff {α : Type u} {β : α → Type v} {instOrd : Ord α} {m₁ m₂ : Impl α β} [TransOrd α] (h₁ : m₁.WF) (h₂ : m₂.WF) {k : α} : contains k (m₁.union! m₂) = true ↔ contains k m₁ = true ∨ contains k m₂ = true

theorem Std.DTreeMap.Internal.Impl.contains_of_contains_union_of_contains_eq_false_right {α : Type u} {β : α → Type v} {instOrd : Ord α} {m₁ m₂ : Impl α β} [TransOrd α] (h₁ : m₁.WF) (h₂ : m₂.WF) {k : α} : contains k (m₁.union m₂ ⋯ ⋯) = true → contains k m₂ = false → contains k m₁ = true

theorem Std.DTreeMap.Internal.Impl.contains_of_contains_union!_of_contains_eq_false_right {α : Type u} {β : α → Type v} {instOrd : Ord α} {m₁ m₂ : Impl α β} [TransOrd α] (h₁ : m₁.WF) (h₂ : m₂.WF) {k : α} : contains k (m₁.union! m₂) = true → contains k m₂ = false → contains k m₁ = true

theorem Std.DTreeMap.Internal.Impl.contains_of_contains_union_of_contains_eq_false_left {α : Type u} {β : α → Type v} {instOrd : Ord α} {m₁ m₂ : Impl α β} [TransOrd α] (h₁ : m₁.WF) (h₂ : m₂.WF) {k : α} : contains k (m₁.union m₂ ⋯ ⋯) = true → contains k m₁ = false → contains k m₂ = true

theorem Std.DTreeMap.Internal.Impl.contains_of_contains_union!_of_contains_eq_false_left {α : Type u} {β : α → Type v} {instOrd : Ord α} {m₁ m₂ : Impl α β} [TransOrd α] (h₁ : m₁.WF) (h₂ : m₂.WF) {k : α} : contains k (m₁.union! m₂) = true → contains k m₁ = false → contains k m₂ = true

theorem Std.DTreeMap.Internal.Impl.union_insert_right_equiv_insert_union {α : Type u} {β : α → Type v} {instOrd : Ord α} {m₁ m₂ : Impl α β} [TransOrd α] {p : (a : α) × β a} (h₁ : m₁.WF) (h₂ : m₂.WF) : (m₁.union (insert p.fst p.snd m₂ ⋯).impl ⋯ ⋯).Equiv (insert p.fst p.snd (m₁.union m₂ ⋯ ⋯) ⋯).impl

theorem Std.DTreeMap.Internal.Impl.union!_insert_right_equiv_insert_union! {α : Type u} {β : α → Type v} {instOrd : Ord α} {m₁ m₂ : Impl α β} [TransOrd α] {p : (a : α) × β a} (h₁ : m₁.WF) (h₂ : m₂.WF) : (m₁.union! (insert! p.fst p.snd m₂)).Equiv (insert! p.fst p.snd (m₁.union! m₂))

theorem Std.DTreeMap.Internal.Impl.Equiv.union_left {α : Type u} {β : α → Type v} {instOrd : Ord α} {m₁ m₂ m₃ : Impl α β} [TransOrd α] (h₁ : m₁.WF) (h₂ : m₂.WF) (h₃ : m₃.WF) (equiv : m₁.Equiv m₂) : (m₁.union m₃ ⋯ ⋯).Equiv (m₂.union m₃ ⋯ ⋯)

theorem Std.DTreeMap.Internal.Impl.union!_equiv_congr_left {α : Type u} {β : α → Type v} {instOrd : Ord α} {m₁ m₂ m₃ : Impl α β} [TransOrd α] (h₁ : m₁.WF) (h₂ : m₂.WF) (h₃ : m₃.WF) (equiv : m₁.Equiv m₂) : (m₁.union! m₃).Equiv (m₂.union! m₃)

theorem Std.DTreeMap.Internal.Impl.Equiv.union_right {α : Type u} {β : α → Type v} {instOrd : Ord α} {m₁ m₂ m₃ : Impl α β} [TransOrd α] (h₁ : m₁.WF) (h₂ : m₂.WF) (h₃ : m₃.WF) (equiv : m₂.Equiv m₃) : (m₁.union m₂ ⋯ ⋯).Equiv (m₁.union m₃ ⋯ ⋯)

theorem Std.DTreeMap.Internal.Impl.union!_equiv_congr_right {α : Type u} {β : α → Type v} {instOrd : Ord α} {m₁ m₂ m₃ : Impl α β} [TransOrd α] (h₁ : m₁.WF) (h₂ : m₂.WF) (h₃ : m₃.WF) (equiv : m₂.Equiv m₃) : (m₁.union! m₂).Equiv (m₁.union! m₃)

theorem Std.DTreeMap.Internal.Impl.Equiv.union_congr {α : Type u} {β : α → Type v} {instOrd : Ord α} {m₁ m₂ m₃ m₄ : Impl α β} [TransOrd α] (h₁ : m₁.WF) (h₂ : m₂.WF) (h₃ : m₃.WF) (h₄ : m₄.WF) (equiv₁ : m₁.Equiv m₃) (equiv₂ : m₂.Equiv m₄) : (m₁.union m₂ ⋯ ⋯).Equiv (m₃.union m₄ ⋯ ⋯)

theorem Std.DTreeMap.Internal.Impl.union!_equiv_congr {α : Type u} {β : α → Type v} {instOrd : Ord α} {m₁ m₂ m₃ m₄ : Impl α β} [TransOrd α] (h₁ : m₁.WF) (h₂ : m₂.WF) (h₃ : m₃.WF) (h₄ : m₄.WF) (equiv₁ : m₁.Equiv m₃) (equiv₂ : m₂.Equiv m₄) : (m₁.union! m₂).Equiv (m₃.union! m₄)

theorem Std.DTreeMap.Internal.Impl.get?_union {α : Type u} {β : α → Type v} {instOrd : Ord α} {m₁ m₂ : Impl α β} [TransOrd α] [LawfulEqOrd α] (h₁ : m₁.WF) (h₂ : m₂.WF) {k : α} : (m₁.union m₂ ⋯ ⋯).get? k = (m₂.get? k).or (m₁.get? k)

theorem Std.DTreeMap.Internal.Impl.get?_union! {α : Type u} {β : α → Type v} {instOrd : Ord α} {m₁ m₂ : Impl α β} [TransOrd α] [LawfulEqOrd α] (h₁ : m₁.WF) (h₂ : m₂.WF) {k : α} : (m₁.union! m₂).get? k = (m₂.get? k).or (m₁.get? k)

theorem Std.DTreeMap.Internal.Impl.get?_union_of_contains_eq_false_left {α : Type u} {β : α → Type v} {instOrd : Ord α} {m₁ m₂ : Impl α β} [TransOrd α] [LawfulEqOrd α] (h₁ : m₁.WF) (h₂ : m₂.WF) {k : α} (contains_eq_false : contains k m₁ = false) : (m₁.union m₂ ⋯ ⋯).get? k = m₂.get? k

theorem Std.DTreeMap.Internal.Impl.get?_union!_of_contains_eq_false_left {α : Type u} {β : α → Type v} {instOrd : Ord α} {m₁ m₂ : Impl α β} [TransOrd α] [LawfulEqOrd α] (h₁ : m₁.WF) (h₂ : m₂.WF) {k : α} (contains_eq_false : contains k m₁ = false) : (m₁.union! m₂).get? k = m₂.get? k

theorem Std.DTreeMap.Internal.Impl.get?_union_of_contains_eq_false_right {α : Type u} {β : α → Type v} {instOrd : Ord α} {m₁ m₂ : Impl α β} [TransOrd α] [LawfulEqOrd α] (h₁ : m₁.WF) (h₂ : m₂.WF) {k : α} (contains_eq_false : contains k m₂ = false) : (m₁.union m₂ ⋯ ⋯).get? k = m₁.get? k

theorem Std.DTreeMap.Internal.Impl.get?_union!_of_contains_eq_false_right {α : Type u} {β : α → Type v} {instOrd : Ord α} {m₁ m₂ : Impl α β} [TransOrd α] [LawfulEqOrd α] (h₁ : m₁.WF) (h₂ : m₂.WF) {k : α} (contains_eq_false : contains k m₂ = false) : (m₁.union! m₂).get? k = m₁.get? k

theorem Std.DTreeMap.Internal.Impl.get_union_of_contains_right {α : Type u} {β : α → Type v} {instOrd : Ord α} {m₁ m₂ : Impl α β} [TransOrd α] [LawfulEqOrd α] (h₁ : m₁.WF) (h₂ : m₂.WF) {k : α} (contains_right : contains k m₂ = true) : (m₁.union m₂ ⋯ ⋯).get k ⋯ = m₂.get k contains_right

theorem Std.DTreeMap.Internal.Impl.get_union!_of_contains_right {α : Type u} {β : α → Type v} {instOrd : Ord α} {m₁ m₂ : Impl α β} [TransOrd α] [LawfulEqOrd α] (h₁ : m₁.WF) (h₂ : m₂.WF) {k : α} (contains_right : contains k m₂ = true) : (m₁.union! m₂).get k ⋯ = m₂.get k contains_right

theorem Std.DTreeMap.Internal.Impl.get_union_of_contains_eq_false_left {α : Type u} {β : α → Type v} {instOrd : Ord α} {m₁ m₂ : Impl α β} [TransOrd α] [LawfulEqOrd α] (h₁ : m₁.WF) (h₂ : m₂.WF) {k : α} (contains_eq_false : contains k m₁ = false) {h' : k ∈ m₁.union m₂ ⋯ ⋯} : (m₁.union m₂ ⋯ ⋯).get k h' = m₂.get k ⋯

theorem Std.DTreeMap.Internal.Impl.get_union!_of_contains_eq_false_left {α : Type u} {β : α → Type v} {instOrd : Ord α} {m₁ m₂ : Impl α β} [TransOrd α] [LawfulEqOrd α] (h₁ : m₁.WF) (h₂ : m₂.WF) {k : α} (contains_eq_false : contains k m₁ = false) {h' : k ∈ m₁.union! m₂} : (m₁.union! m₂).get k h' = m₂.get k ⋯

theorem Std.DTreeMap.Internal.Impl.get_union_of_contains_eq_false_right {α : Type u} {β : α → Type v} {instOrd : Ord α} {m₁ m₂ : Impl α β} [TransOrd α] [LawfulEqOrd α] (h₁ : m₁.WF) (h₂ : m₂.WF) {k : α} (contains_eq_false : contains k m₂ = false) {h' : k ∈ m₁.union m₂ ⋯ ⋯} : (m₁.union m₂ ⋯ ⋯).get k h' = m₁.get k ⋯

theorem Std.DTreeMap.Internal.Impl.get_union!_of_contains_eq_false_right {α : Type u} {β : α → Type v} {instOrd : Ord α} {m₁ m₂ : Impl α β} [TransOrd α] [LawfulEqOrd α] (h₁ : m₁.WF) (h₂ : m₂.WF) {k : α} (contains_eq_false : contains k m₂ = false) {h' : k ∈ m₁.union! m₂} : (m₁.union! m₂).get k h' = m₁.get k ⋯

theorem Std.DTreeMap.Internal.Impl.getD_union {α : Type u} {β : α → Type v} {instOrd : Ord α} {m₁ m₂ : Impl α β} [TransOrd α] [LawfulEqOrd α] (h₁ : m₁.WF) (h₂ : m₂.WF) {k : α} {fallback : β k} : (m₁.union m₂ ⋯ ⋯).getD k fallback = m₂.getD k (m₁.getD k fallback)

theorem Std.DTreeMap.Internal.Impl.getD_union! {α : Type u} {β : α → Type v} {instOrd : Ord α} {m₁ m₂ : Impl α β} [TransOrd α] [LawfulEqOrd α] (h₁ : m₁.WF) (h₂ : m₂.WF) {k : α} {fallback : β k} : (m₁.union! m₂).getD k fallback = m₂.getD k (m₁.getD k fallback)

theorem Std.DTreeMap.Internal.Impl.getD_union_of_contains_eq_false_left {α : Type u} {β : α → Type v} {instOrd : Ord α} {m₁ m₂ : Impl α β} [TransOrd α] [LawfulEqOrd α] (h₁ : m₁.WF) (h₂ : m₂.WF) {k : α} {fallback : β k} (contains_eq_false : contains k m₁ = false) : (m₁.union m₂ ⋯ ⋯).getD k fallback = m₂.getD k fallback

theorem Std.DTreeMap.Internal.Impl.getD_union!_of_contains_eq_false_left {α : Type u} {β : α → Type v} {instOrd : Ord α} {m₁ m₂ : Impl α β} [TransOrd α] [LawfulEqOrd α] (h₁ : m₁.WF) (h₂ : m₂.WF) {k : α} {fallback : β k} (contains_eq_false : contains k m₁ = false) : (m₁.union! m₂).getD k fallback = m₂.getD k fallback

theorem Std.DTreeMap.Internal.Impl.getD_union_of_contains_eq_false_right {α : Type u} {β : α → Type v} {instOrd : Ord α} {m₁ m₂ : Impl α β} [TransOrd α] [LawfulEqOrd α] (h₁ : m₁.WF) (h₂ : m₂.WF) {k : α} {fallback : β k} (contains_eq_false : contains k m₂ = false) : (m₁.union m₂ ⋯ ⋯).getD k fallback = m₁.getD k fallback

theorem Std.DTreeMap.Internal.Impl.getD_union!_of_contains_eq_false_right {α : Type u} {β : α → Type v} {instOrd : Ord α} {m₁ m₂ : Impl α β} [TransOrd α] [LawfulEqOrd α] (h₁ : m₁.WF) (h₂ : m₂.WF) {k : α} {fallback : β k} (contains_eq_false : contains k m₂ = false) : (m₁.union! m₂).getD k fallback = m₁.getD k fallback

theorem Std.DTreeMap.Internal.Impl.get!_union {α : Type u} {β : α → Type v} {instOrd : Ord α} {m₁ m₂ : Impl α β} [TransOrd α] [LawfulEqOrd α] (h₁ : m₁.WF) (h₂ : m₂.WF) {k : α} [Inhabited (β k)] : (m₁.union m₂ ⋯ ⋯).get! k = m₂.getD k (m₁.get! k)

theorem Std.DTreeMap.Internal.Impl.get!_union! {α : Type u} {β : α → Type v} {instOrd : Ord α} {m₁ m₂ : Impl α β} [TransOrd α] [LawfulEqOrd α] (h₁ : m₁.WF) (h₂ : m₂.WF) {k : α} [Inhabited (β k)] : (m₁.union! m₂).get! k = m₂.getD k (m₁.get! k)

theorem Std.DTreeMap.Internal.Impl.get!_union_of_contains_eq_false_left {α : Type u} {β : α → Type v} {instOrd : Ord α} {m₁ m₂ : Impl α β} [TransOrd α] [LawfulEqOrd α] (h₁ : m₁.WF) (h₂ : m₂.WF) {k : α} [Inhabited (β k)] (contains_eq_false : contains k m₁ = false) : (m₁.union m₂ ⋯ ⋯).get! k = m₂.get! k

theorem Std.DTreeMap.Internal.Impl.get!_union!_of_contains_eq_false_left {α : Type u} {β : α → Type v} {instOrd : Ord α} {m₁ m₂ : Impl α β} [TransOrd α] [LawfulEqOrd α] (h₁ : m₁.WF) (h₂ : m₂.WF) {k : α} [Inhabited (β k)] (contains_eq_false : contains k m₁ = false) : (m₁.union! m₂).get! k = m₂.get! k

theorem Std.DTreeMap.Internal.Impl.get!_union_of_contains_eq_false_right {α : Type u} {β : α → Type v} {instOrd : Ord α} {m₁ m₂ : Impl α β} [TransOrd α] [LawfulEqOrd α] (h₁ : m₁.WF) (h₂ : m₂.WF) {k : α} [Inhabited (β k)] (contains_eq_false : contains k m₂ = false) : (m₁.union m₂ ⋯ ⋯).get! k = m₁.get! k

theorem Std.DTreeMap.Internal.Impl.get!_union!_of_contains_eq_false_right {α : Type u} {β : α → Type v} {instOrd : Ord α} {m₁ m₂ : Impl α β} [TransOrd α] [LawfulEqOrd α] (h₁ : m₁.WF) (h₂ : m₂.WF) {k : α} [Inhabited (β k)] (contains_eq_false : contains k m₂ = false) : (m₁.union! m₂).get! k = m₁.get! k

theorem Std.DTreeMap.Internal.Impl.getKey?_union {α : Type u} {β : α → Type v} {instOrd : Ord α} {m₁ m₂ : Impl α β} [TransOrd α] (h₁ : m₁.WF) (h₂ : m₂.WF) {k : α} : (m₁.union m₂ ⋯ ⋯).getKey? k = (m₂.getKey? k).or (m₁.getKey? k)

theorem Std.DTreeMap.Internal.Impl.getKey?_union! {α : Type u} {β : α → Type v} {instOrd : Ord α} {m₁ m₂ : Impl α β} [TransOrd α] (h₁ : m₁.WF) (h₂ : m₂.WF) {k : α} : (m₁.union! m₂).getKey? k = (m₂.getKey? k).or (m₁.getKey? k)

theorem Std.DTreeMap.Internal.Impl.getKey?_union_of_contains_eq_false_left {α : Type u} {β : α → Type v} {instOrd : Ord α} {m₁ m₂ : Impl α β} [TransOrd α] (h₁ : m₁.WF) (h₂ : m₂.WF) {k : α} (not_mem : contains k m₁ = false) : (m₁.union m₂ ⋯ ⋯).getKey? k = m₂.getKey? k

theorem Std.DTreeMap.Internal.Impl.getKey?_union!_of_contains_eq_false_left {α : Type u} {β : α → Type v} {instOrd : Ord α} {m₁ m₂ : Impl α β} [TransOrd α] (h₁ : m₁.WF) (h₂ : m₂.WF) {k : α} (not_mem : contains k m₁ = false) : (m₁.union! m₂).getKey? k = m₂.getKey? k

theorem Std.DTreeMap.Internal.Impl.getKey?_union_of_contains_eq_false_right {α : Type u} {β : α → Type v} {instOrd : Ord α} {m₁ m₂ : Impl α β} [TransOrd α] (h₁ : m₁.WF) (h₂ : m₂.WF) {k : α} (not_mem : contains k m₂ = false) : (m₁.union m₂ ⋯ ⋯).getKey? k = m₁.getKey? k

theorem Std.DTreeMap.Internal.Impl.getKey?_union!_of_contains_eq_false_right {α : Type u} {β : α → Type v} {instOrd : Ord α} {m₁ m₂ : Impl α β} [TransOrd α] (h₁ : m₁.WF) (h₂ : m₂.WF) {k : α} (not_mem : contains k m₂ = false) : (m₁.union! m₂).getKey? k = m₁.getKey? k

theorem Std.DTreeMap.Internal.Impl.getKey_union_of_contains_right {α : Type u} {β : α → Type v} {instOrd : Ord α} {m₁ m₂ : Impl α β} [TransOrd α] (h₁ : m₁.WF) (h₂ : m₂.WF) {k : α} (mem : contains k m₂ = true) : (m₁.union m₂ ⋯ ⋯).getKey k ⋯ = m₂.getKey k mem

theorem Std.DTreeMap.Internal.Impl.getKey_union!_of_contains_right {α : Type u} {β : α → Type v} {instOrd : Ord α} {m₁ m₂ : Impl α β} [TransOrd α] (h₁ : m₁.WF) (h₂ : m₂.WF) {k : α} (mem : contains k m₂ = true) : (m₁.union! m₂).getKey k ⋯ = m₂.getKey k mem

theorem Std.DTreeMap.Internal.Impl.getKey_union_of_contains_eq_false_left {α : Type u} {β : α → Type v} {instOrd : Ord α} {m₁ m₂ : Impl α β} [TransOrd α] (h₁ : m₁.WF) (h₂ : m₂.WF) {k : α} (contains_eq_false : contains k m₁ = false) {h' : contains k (m₁.union m₂ ⋯ ⋯) = true} : (m₁.union m₂ ⋯ ⋯).getKey k h' = m₂.getKey k ⋯

theorem Std.DTreeMap.Internal.Impl.getKey_union!_of_contains_eq_false_left {α : Type u} {β : α → Type v} {instOrd : Ord α} {m₁ m₂ : Impl α β} [TransOrd α] (h₁ : m₁.WF) (h₂ : m₂.WF) {k : α} (contains_eq_false : contains k m₁ = false) {h' : contains k (m₁.union! m₂) = true} : (m₁.union! m₂).getKey k h' = m₂.getKey k ⋯

theorem Std.DTreeMap.Internal.Impl.getKey_union_of_contains_eq_false_right {α : Type u} {β : α → Type v} {instOrd : Ord α} {m₁ m₂ : Impl α β} [TransOrd α] (h₁ : m₁.WF) (h₂ : m₂.WF) {k : α} (contains_eq_false : contains k m₂ = false) {h' : contains k (m₁.union m₂ ⋯ ⋯) = true} : (m₁.union m₂ ⋯ ⋯).getKey k h' = m₁.getKey k ⋯

theorem Std.DTreeMap.Internal.Impl.getKey_union!_of_contains_eq_false_right {α : Type u} {β : α → Type v} {instOrd : Ord α} {m₁ m₂ : Impl α β} [TransOrd α] (h₁ : m₁.WF) (h₂ : m₂.WF) {k : α} (contains_eq_false : contains k m₂ = false) {h' : contains k (m₁.union! m₂) = true} : (m₁.union! m₂).getKey k h' = m₁.getKey k ⋯

theorem Std.DTreeMap.Internal.Impl.getKeyD_union {α : Type u} {β : α → Type v} {instOrd : Ord α} {m₁ m₂ : Impl α β} [TransOrd α] (h₁ : m₁.WF) (h₂ : m₂.WF) {k fallback : α} : (m₁.union m₂ ⋯ ⋯).getKeyD k fallback = m₂.getKeyD k (m₁.getKeyD k fallback)

theorem Std.DTreeMap.Internal.Impl.getKeyD_union! {α : Type u} {β : α → Type v} {instOrd : Ord α} {m₁ m₂ : Impl α β} [TransOrd α] (h₁ : m₁.WF) (h₂ : m₂.WF) {k fallback : α} : (m₁.union! m₂).getKeyD k fallback = m₂.getKeyD k (m₁.getKeyD k fallback)

theorem Std.DTreeMap.Internal.Impl.getKeyD_union_of_contains_eq_false_left {α : Type u} {β : α → Type v} {instOrd : Ord α} {m₁ m₂ : Impl α β} [TransOrd α] (h₁ : m₁.WF) (h₂ : m₂.WF) {k fallback : α} (h' : contains k m₁ = false) : (m₁.union m₂ ⋯ ⋯).getKeyD k fallback = m₂.getKeyD k fallback

theorem Std.DTreeMap.Internal.Impl.getKeyD_union!_of_contains_eq_false_left {α : Type u} {β : α → Type v} {instOrd : Ord α} {m₁ m₂ : Impl α β} [TransOrd α] (h₁ : m₁.WF) (h₂ : m₂.WF) {k fallback : α} (h' : contains k m₁ = false) : (m₁.union! m₂).getKeyD k fallback = m₂.getKeyD k fallback

theorem Std.DTreeMap.Internal.Impl.getKeyD_union_of_contains_eq_false_right {α : Type u} {β : α → Type v} {instOrd : Ord α} {m₁ m₂ : Impl α β} [TransOrd α] (h₁ : m₁.WF) (h₂ : m₂.WF) {k fallback : α} (h' : contains k m₂ = false) : (m₁.union m₂ ⋯ ⋯).getKeyD k fallback = m₁.getKeyD k fallback

theorem Std.DTreeMap.Internal.Impl.getKeyD_union!_of_contains_eq_false_right {α : Type u} {β : α → Type v} {instOrd : Ord α} {m₁ m₂ : Impl α β} [TransOrd α] (h₁ : m₁.WF) (h₂ : m₂.WF) {k fallback : α} (h' : contains k m₂ = false) : (m₁.union! m₂).getKeyD k fallback = m₁.getKeyD k fallback

theorem Std.DTreeMap.Internal.Impl.getKey!_union {α : Type u} {β : α → Type v} {instOrd : Ord α} {m₁ m₂ : Impl α β} [Inhabited α] [TransOrd α] (h₁ : m₁.WF) (h₂ : m₂.WF) {k : α} : (m₁.union m₂ ⋯ ⋯).getKey! k = m₂.getKeyD k (m₁.getKey! k)

theorem Std.DTreeMap.Internal.Impl.getKey!_union! {α : Type u} {β : α → Type v} {instOrd : Ord α} {m₁ m₂ : Impl α β} [Inhabited α] [TransOrd α] (h₁ : m₁.WF) (h₂ : m₂.WF) {k : α} : (m₁.union! m₂).getKey! k = m₂.getKeyD k (m₁.getKey! k)

theorem Std.DTreeMap.Internal.Impl.getKey!_union_of_contains_eq_false_left {α : Type u} {β : α → Type v} {instOrd : Ord α} {m₁ m₂ : Impl α β} [Inhabited α] [TransOrd α] (h₁ : m₁.WF) (h₂ : m₂.WF) {k : α} (h' : contains k m₁ = false) : (m₁.union m₂ ⋯ ⋯).getKey! k = m₂.getKey! k

theorem Std.DTreeMap.Internal.Impl.getKey!_union!_of_contains_eq_false_left {α : Type u} {β : α → Type v} {instOrd : Ord α} {m₁ m₂ : Impl α β} [Inhabited α] [TransOrd α] (h₁ : m₁.WF) (h₂ : m₂.WF) {k : α} (h' : contains k m₁ = false) : (m₁.union! m₂).getKey! k = m₂.getKey! k

theorem Std.DTreeMap.Internal.Impl.getKey!_union_of_contains_eq_false_right {α : Type u} {β : α → Type v} {instOrd : Ord α} {m₁ m₂ : Impl α β} [Inhabited α] [TransOrd α] (h₁ : m₁.WF) (h₂ : m₂.WF) {k : α} (h' : contains k m₂ = false) : (m₁.union m₂ ⋯ ⋯).getKey! k = m₁.getKey! k

theorem Std.DTreeMap.Internal.Impl.getKey!_union!_of_contains_eq_false_right {α : Type u} {β : α → Type v} {instOrd : Ord α} {m₁ m₂ : Impl α β} [Inhabited α] [TransOrd α] (h₁ : m₁.WF) (h₂ : m₂.WF) {k : α} (h' : contains k m₂ = false) : (m₁.union! m₂).getKey! k = m₁.getKey! k

theorem Std.DTreeMap.Internal.Impl.size_union_of_not_mem {α : Type u} {β : α → Type v} {instOrd : Ord α} {m₁ m₂ : Impl α β} [TransOrd α] (h₁ : m₁.WF) (h₂ : m₂.WF) : (∀ (a : α), contains a m₁ = true → contains a m₂ = false) → (m₁.union m₂ ⋯ ⋯).size = m₁.size + m₂.size

theorem Std.DTreeMap.Internal.Impl.size_union!_of_not_mem {α : Type u} {β : α → Type v} {instOrd : Ord α} {m₁ m₂ : Impl α β} [TransOrd α] (h₁ : m₁.WF) (h₂ : m₂.WF) : (∀ (a : α), contains a m₁ = true → contains a m₂ = false) → (m₁.union! m₂).size = m₁.size + m₂.size

theorem Std.DTreeMap.Internal.Impl.size_left_le_size_union {α : Type u} {β : α → Type v} {instOrd : Ord α} {m₁ m₂ : Impl α β} [TransOrd α] (h₁ : m₁.WF) (h₂ : m₂.WF) : m₁.size ≤ (m₁.union m₂ ⋯ ⋯).size

theorem Std.DTreeMap.Internal.Impl.size_left_le_size_union! {α : Type u} {β : α → Type v} {instOrd : Ord α} {m₁ m₂ : Impl α β} [TransOrd α] (h₁ : m₁.WF) (h₂ : m₂.WF) : m₁.size ≤ (m₁.union! m₂).size

theorem Std.DTreeMap.Internal.Impl.size_right_le_size_union {α : Type u} {β : α → Type v} {instOrd : Ord α} {m₁ m₂ : Impl α β} [TransOrd α] (h₁ : m₁.WF) (h₂ : m₂.WF) : m₂.size ≤ (m₁.union m₂ ⋯ ⋯).size

theorem Std.DTreeMap.Internal.Impl.size_right_le_size_union! {α : Type u} {β : α → Type v} {instOrd : Ord α} {m₁ m₂ : Impl α β} [TransOrd α] (h₁ : m₁.WF) (h₂ : m₂.WF) : m₂.size ≤ (m₁.union! m₂).size

theorem Std.DTreeMap.Internal.Impl.size_union_le_size_add_size {α : Type u} {β : α → Type v} {instOrd : Ord α} {m₁ m₂ : Impl α β} [TransOrd α] (h₁ : m₁.WF) (h₂ : m₂.WF) : (m₁.union m₂ ⋯ ⋯).size ≤ m₁.size + m₂.size

theorem Std.DTreeMap.Internal.Impl.size_union!_le_size_add_size {α : Type u} {β : α → Type v} {instOrd : Ord α} {m₁ m₂ : Impl α β} [TransOrd α] (h₁ : m₁.WF) (h₂ : m₂.WF) : (m₁.union! m₂).size ≤ m₁.size + m₂.size

@[simp]

theorem Std.DTreeMap.Internal.Impl.isEmpty_union {α : Type u} {β : α → Type v} {instOrd : Ord α} {m₁ m₂ : Impl α β} [TransOrd α] (h₁ : m₁.WF) (h₂ : m₂.WF) : (m₁.union m₂ ⋯ ⋯).isEmpty = (m₁.isEmpty && m₂.isEmpty)

@[simp]

theorem Std.DTreeMap.Internal.Impl.isEmpty_union! {α : Type u} {β : α → Type v} {instOrd : Ord α} {m₁ m₂ : Impl α β} [TransOrd α] (h₁ : m₁.WF) (h₂ : m₂.WF) : (m₁.union! m₂).isEmpty = (m₁.isEmpty && m₂.isEmpty)

theorem Std.DTreeMap.Internal.Impl.Const.get?_union {α : Type u} {instOrd : Ord α} {β : Type v} {m₁ m₂ : Impl α fun (x : α) => β} [TransOrd α] (h₁ : m₁.WF) (h₂ : m₂.WF) {k : α} : get? (m₁.union m₂ ⋯ ⋯) k = (get? m₂ k).or (get? m₁ k)

theorem Std.DTreeMap.Internal.Impl.Const.get?_union! {α : Type u} {instOrd : Ord α} {β : Type v} {m₁ m₂ : Impl α fun (x : α) => β} [TransOrd α] (h₁ : m₁.WF) (h₂ : m₂.WF) {k : α} : get? (m₁.union! m₂) k = (get? m₂ k).or (get? m₁ k)

theorem Std.DTreeMap.Internal.Impl.Const.get?_union_of_contains_eq_false_left {α : Type u} {instOrd : Ord α} {β : Type v} {m₁ m₂ : Impl α fun (x : α) => β} [TransOrd α] (h₁ : m₁.WF) (h₂ : m₂.WF) {k : α} (contains_eq_false : contains k m₁ = false) : get? (m₁.union m₂ ⋯ ⋯) k = get? m₂ k

theorem Std.DTreeMap.Internal.Impl.Const.get?_union!_of_contains_eq_false_left {α : Type u} {instOrd : Ord α} {β : Type v} {m₁ m₂ : Impl α fun (x : α) => β} [TransOrd α] (h₁ : m₁.WF) (h₂ : m₂.WF) {k : α} (contains_eq_false : contains k m₁ = false) : get? (m₁.union! m₂) k = get? m₂ k

theorem Std.DTreeMap.Internal.Impl.Const.get?_union_of_contains_eq_false_right {α : Type u} {instOrd : Ord α} {β : Type v} {m₁ m₂ : Impl α fun (x : α) => β} [TransOrd α] (h₁ : m₁.WF) (h₂ : m₂.WF) {k : α} (contains_eq_false : contains k m₂ = false) : get? (m₁.union m₂ ⋯ ⋯) k = get? m₁ k

theorem Std.DTreeMap.Internal.Impl.Const.get?_union!_of_contains_eq_false_right {α : Type u} {instOrd : Ord α} {β : Type v} {m₁ m₂ : Impl α fun (x : α) => β} [TransOrd α] (h₁ : m₁.WF) (h₂ : m₂.WF) {k : α} (contains_eq_false : contains k m₂ = false) : get? (m₁.union! m₂) k = get? m₁ k

theorem Std.DTreeMap.Internal.Impl.Const.get_union_of_contains_right {α : Type u} {instOrd : Ord α} {β : Type v} {m₁ m₂ : Impl α fun (x : α) => β} [TransOrd α] (h₁ : m₁.WF) (h₂ : m₂.WF) {k : α} (h : contains k m₂ = true) : get (m₁.union m₂ ⋯ ⋯) k ⋯ = get m₂ k h

theorem Std.DTreeMap.Internal.Impl.Const.get_union!_of_contains_right {α : Type u} {instOrd : Ord α} {β : Type v} {m₁ m₂ : Impl α fun (x : α) => β} [TransOrd α] (h₁ : m₁.WF) (h₂ : m₂.WF) {k : α} (h : contains k m₂ = true) : get (m₁.union! m₂) k ⋯ = get m₂ k h

theorem Std.DTreeMap.Internal.Impl.Const.get_union_of_contains_eq_false_left {α : Type u} {instOrd : Ord α} {β : Type v} {m₁ m₂ : Impl α fun (x : α) => β} [TransOrd α] (h₁ : m₁.WF) (h₂ : m₂.WF) {k : α} (contains_eq_false : contains k m₁ = false) {h' : contains k (m₁.union m₂ ⋯ ⋯) = true} : get (m₁.union m₂ ⋯ ⋯) k h' = get m₂ k ⋯

theorem Std.DTreeMap.Internal.Impl.Const.get_union!_of_contains_eq_false_left {α : Type u} {instOrd : Ord α} {β : Type v} {m₁ m₂ : Impl α fun (x : α) => β} [TransOrd α] (h₁ : m₁.WF) (h₂ : m₂.WF) {k : α} (contains_eq_false : contains k m₁ = false) {h' : contains k (m₁.union! m₂) = true} : get (m₁.union! m₂) k h' = get m₂ k ⋯

theorem Std.DTreeMap.Internal.Impl.Const.get_union_of_contains_eq_false_right {α : Type u} {instOrd : Ord α} {β : Type v} {m₁ m₂ : Impl α fun (x : α) => β} [TransOrd α] (h₁ : m₁.WF) (h₂ : m₂.WF) {k : α} (contains_eq_false : contains k m₂ = false) {h' : contains k (m₁.union m₂ ⋯ ⋯) = true} : get (m₁.union m₂ ⋯ ⋯) k h' = get m₁ k ⋯

theorem Std.DTreeMap.Internal.Impl.Const.get_union!_of_contains_eq_false_right {α : Type u} {instOrd : Ord α} {β : Type v} {m₁ m₂ : Impl α fun (x : α) => β} [TransOrd α] (h₁ : m₁.WF) (h₂ : m₂.WF) {k : α} (contains_eq_false : contains k m₂ = false) {h' : contains k (m₁.union! m₂) = true} : get (m₁.union! m₂) k h' = get m₁ k ⋯

theorem Std.DTreeMap.Internal.Impl.Const.getD_union {α : Type u} {instOrd : Ord α} {β : Type v} {m₁ m₂ : Impl α fun (x : α) => β} [TransOrd α] (h₁ : m₁.WF) (h₂ : m₂.WF) {k : α} {fallback : β} : getD (m₁.union m₂ ⋯ ⋯) k fallback = getD m₂ k (getD m₁ k fallback)

theorem Std.DTreeMap.Internal.Impl.Const.getD_union! {α : Type u} {instOrd : Ord α} {β : Type v} {m₁ m₂ : Impl α fun (x : α) => β} [TransOrd α] (h₁ : m₁.WF) (h₂ : m₂.WF) {k : α} {fallback : β} : getD (m₁.union! m₂) k fallback = getD m₂ k (getD m₁ k fallback)

theorem Std.DTreeMap.Internal.Impl.Const.getD_union_of_contains_eq_false_left {α : Type u} {instOrd : Ord α} {β : Type v} {m₁ m₂ : Impl α fun (x : α) => β} [TransOrd α] (h₁ : m₁.WF) (h₂ : m₂.WF) {k : α} {fallback : β} (contains_eq_false : contains k m₁ = false) : getD (m₁.union m₂ ⋯ ⋯) k fallback = getD m₂ k fallback

theorem Std.DTreeMap.Internal.Impl.Const.getD_union!_of_contains_eq_false_left {α : Type u} {instOrd : Ord α} {β : Type v} {m₁ m₂ : Impl α fun (x : α) => β} [TransOrd α] (h₁ : m₁.WF) (h₂ : m₂.WF) {k : α} {fallback : β} (contains_eq_false : contains k m₁ = false) : getD (m₁.union! m₂) k fallback = getD m₂ k fallback

theorem Std.DTreeMap.Internal.Impl.Const.getD_union_of_contains_eq_false_right {α : Type u} {instOrd : Ord α} {β : Type v} {m₁ m₂ : Impl α fun (x : α) => β} [TransOrd α] (h₁ : m₁.WF) (h₂ : m₂.WF) {k : α} {fallback : β} (contains_eq_false : contains k m₂ = false) : getD (m₁.union m₂ ⋯ ⋯) k fallback = getD m₁ k fallback

theorem Std.DTreeMap.Internal.Impl.Const.getD_union!_of_contains_eq_false_right {α : Type u} {instOrd : Ord α} {β : Type v} {m₁ m₂ : Impl α fun (x : α) => β} [TransOrd α] (h₁ : m₁.WF) (h₂ : m₂.WF) {k : α} {fallback : β} (contains_eq_false : contains k m₂ = false) : getD (m₁.union! m₂) k fallback = getD m₁ k fallback

theorem Std.DTreeMap.Internal.Impl.Const.get!_union {α : Type u} {instOrd : Ord α} {β : Type v} {m₁ m₂ : Impl α fun (x : α) => β} [TransOrd α] [Inhabited β] (h₁ : m₁.WF) (h₂ : m₂.WF) {k : α} : get! (m₁.union m₂ ⋯ ⋯) k = getD m₂ k (get! m₁ k)

theorem Std.DTreeMap.Internal.Impl.Const.get!_union! {α : Type u} {instOrd : Ord α} {β : Type v} {m₁ m₂ : Impl α fun (x : α) => β} [TransOrd α] [Inhabited β] (h₁ : m₁.WF) (h₂ : m₂.WF) {k : α} : get! (m₁.union! m₂) k = getD m₂ k (get! m₁ k)

theorem Std.DTreeMap.Internal.Impl.Const.get!_union_of_contains_eq_false_left {α : Type u} {instOrd : Ord α} {β : Type v} {m₁ m₂ : Impl α fun (x : α) => β} [TransOrd α] [Inhabited β] (h₁ : m₁.WF) (h₂ : m₂.WF) {k : α} (contains_eq_false : contains k m₁ = false) : get! (m₁.union m₂ ⋯ ⋯) k = get! m₂ k

theorem Std.DTreeMap.Internal.Impl.Const.get!_union!_of_contains_eq_false_left {α : Type u} {instOrd : Ord α} {β : Type v} {m₁ m₂ : Impl α fun (x : α) => β} [TransOrd α] [Inhabited β] (h₁ : m₁.WF) (h₂ : m₂.WF) {k : α} (contains_eq_false : contains k m₁ = false) : get! (m₁.union! m₂) k = get! m₂ k

theorem Std.DTreeMap.Internal.Impl.Const.get!_union_of_contains_eq_false_right {α : Type u} {instOrd : Ord α} {β : Type v} {m₁ m₂ : Impl α fun (x : α) => β} [TransOrd α] [Inhabited β] (h₁ : m₁.WF) (h₂ : m₂.WF) {k : α} (contains_eq_false : contains k m₂ = false) : get! (m₁.union m₂ ⋯ ⋯) k = get! m₁ k

theorem Std.DTreeMap.Internal.Impl.Const.get!_union!_of_contains_eq_false_right {α : Type u} {instOrd : Ord α} {β : Type v} {m₁ m₂ : Impl α fun (x : α) => β} [TransOrd α] [Inhabited β] (h₁ : m₁.WF) (h₂ : m₂.WF) {k : α} (contains_eq_false : contains k m₂ = false) : get! (m₁.union! m₂) k = get! m₁ k

theorem Std.DTreeMap.Internal.Impl.contains_inter {α : Type u} {β : α → Type v} {instOrd : Ord α} {m₁ m₂ : Impl α β} [TransOrd α] (h₁ : m₁.WF) (h₂ : m₂.WF) {k : α} : contains k (m₁.inter m₂ ⋯) = (contains k m₁ && contains k m₂)

theorem Std.DTreeMap.Internal.Impl.contains_inter! {α : Type u} {β : α → Type v} {instOrd : Ord α} {m₁ m₂ : Impl α β} [TransOrd α] (h₁ : m₁.WF) (h₂ : m₂.WF) {k : α} : contains k (m₁.inter! m₂) = (contains k m₁ && contains k m₂)

theorem Std.DTreeMap.Internal.Impl.contains_inter_iff {α : Type u} {β : α → Type v} {instOrd : Ord α} {m₁ m₂ : Impl α β} [TransOrd α] (h₁ : m₁.WF) (h₂ : m₂.WF) {k : α} : contains k (m₁.inter m₂ ⋯) = true ↔ contains k m₁ = true ∧ contains k m₂ = true

theorem Std.DTreeMap.Internal.Impl.contains_inter!_iff {α : Type u} {β : α → Type v} {instOrd : Ord α} {m₁ m₂ : Impl α β} [TransOrd α] (h₁ : m₁.WF) (h₂ : m₂.WF) {k : α} : contains k (m₁.inter! m₂) = true ↔ contains k m₁ = true ∧ contains k m₂ = true

theorem Std.DTreeMap.Internal.Impl.contains_inter_eq_false_of_contains_eq_false_left {α : Type u} {β : α → Type v} {instOrd : Ord α} {m₁ m₂ : Impl α β} [TransOrd α] (h₁ : m₁.WF) (h₂ : m₂.WF) {k : α} (h : contains k m₁ = false) : contains k (m₁.inter m₂ ⋯) = false

theorem Std.DTreeMap.Internal.Impl.contains_inter!_eq_false_of_contains_eq_false_left {α : Type u} {β : α → Type v} {instOrd : Ord α} {m₁ m₂ : Impl α β} [TransOrd α] (h₁ : m₁.WF) (h₂ : m₂.WF) {k : α} (h : contains k m₁ = false) : contains k (m₁.inter! m₂) = false

theorem Std.DTreeMap.Internal.Impl.contains_inter_eq_false_of_contains_eq_false_right {α : Type u} {β : α → Type v} {instOrd : Ord α} {m₁ m₂ : Impl α β} [TransOrd α] (h₁ : m₁.WF) (h₂ : m₂.WF) {k : α} (h : contains k m₂ = false) : contains k (m₁.inter m₂ ⋯) = false

theorem Std.DTreeMap.Internal.Impl.contains_inter!_eq_false_of_contains_eq_false_right {α : Type u} {β : α → Type v} {instOrd : Ord α} {m₁ m₂ : Impl α β} [TransOrd α] (h₁ : m₁.WF) (h₂ : m₂.WF) {k : α} (h : contains k m₂ = false) : contains k (m₁.inter! m₂) = false

theorem Std.DTreeMap.Internal.Impl.Equiv.inter_left {α : Type u} {β : α → Type v} {instOrd : Ord α} {m₁ m₂ m₃ : Impl α β} [TransOrd α] (h₁ : m₁.WF) (h₂ : m₂.WF) (h₃ : m₃.WF) (equiv : m₁.Equiv m₂) : (m₁.inter m₃ ⋯).Equiv (m₂.inter m₃ ⋯)

theorem Std.DTreeMap.Internal.Impl.Equiv.inter!_left {α : Type u} {β : α → Type v} {instOrd : Ord α} {m₁ m₂ m₃ : Impl α β} [TransOrd α] (h₁ : m₁.WF) (h₂ : m₂.WF) (h₃ : m₃.WF) (equiv : m₁.Equiv m₂) : (m₁.inter! m₃).Equiv (m₂.inter! m₃)

theorem Std.DTreeMap.Internal.Impl.Equiv.inter_right {α : Type u} {β : α → Type v} {instOrd : Ord α} {m₁ m₂ m₃ : Impl α β} [TransOrd α] (h₁ : m₁.WF) (h₂ : m₂.WF) (h₃ : m₃.WF) (equiv : m₂.Equiv m₃) : (m₁.inter m₂ ⋯).Equiv (m₁.inter m₃ ⋯)

theorem Std.DTreeMap.Internal.Impl.Equiv.inter!_right {α : Type u} {β : α → Type v} {instOrd : Ord α} {m₁ m₂ m₃ : Impl α β} [TransOrd α] (h₁ : m₁.WF) (h₂ : m₂.WF) (h₃ : m₃.WF) (equiv : m₂.Equiv m₃) : (m₁.inter! m₂).Equiv (m₁.inter! m₃)

theorem Std.DTreeMap.Internal.Impl.Equiv.inter_congr {α : Type u} {β : α → Type v} {instOrd : Ord α} {m₁ m₂ m₃ m₄ : Impl α β} [TransOrd α] (h₁ : m₁.WF) (h₂ : m₂.WF) (h₃ : m₃.WF) (h₄ : m₄.WF) (equiv₁ : m₁.Equiv m₃) (equiv₂ : m₂.Equiv m₄) : (m₁.inter m₂ ⋯).Equiv (m₃.inter m₄ ⋯)

theorem Std.DTreeMap.Internal.Impl.Equiv.inter!_congr {α : Type u} {β : α → Type v} {instOrd : Ord α} {m₁ m₂ m₃ m₄ : Impl α β} [TransOrd α] (h₁ : m₁.WF) (h₂ : m₂.WF) (h₃ : m₃.WF) (h₄ : m₄.WF) (equiv₁ : m₁.Equiv m₃) (equiv₂ : m₂.Equiv m₄) : (m₁.inter! m₂).Equiv (m₃.inter! m₄)

theorem Std.DTreeMap.Internal.Impl.get?_inter {α : Type u} {β : α → Type v} {instOrd : Ord α} {m₁ m₂ : Impl α β} [TransOrd α] [LawfulEqOrd α] (h₁ : m₁.WF) (h₂ : m₂.WF) {k : α} : (m₁.inter m₂ ⋯).get? k = if contains k m₂ = true then m₁.get? k else none

theorem Std.DTreeMap.Internal.Impl.get?_inter! {α : Type u} {β : α → Type v} {instOrd : Ord α} {m₁ m₂ : Impl α β} [TransOrd α] [LawfulEqOrd α] (h₁ : m₁.WF) (h₂ : m₂.WF) {k : α} : (m₁.inter! m₂).get? k = if contains k m₂ = true then m₁.get? k else none

theorem Std.DTreeMap.Internal.Impl.get?_inter_of_contains_right {α : Type u} {β : α → Type v} {instOrd : Ord α} {m₁ m₂ : Impl α β} [TransOrd α] [LawfulEqOrd α] (h₁ : m₁.WF) (h₂ : m₂.WF) {k : α} (h : contains k m₂ = true) : (m₁.inter m₂ ⋯).get? k = m₁.get? k

theorem Std.DTreeMap.Internal.Impl.get?_inter!_of_contains_right {α : Type u} {β : α → Type v} {instOrd : Ord α} {m₁ m₂ : Impl α β} [TransOrd α] [LawfulEqOrd α] (h₁ : m₁.WF) (h₂ : m₂.WF) {k : α} (h : contains k m₂ = true) : (m₁.inter! m₂).get? k = m₁.get? k

theorem Std.DTreeMap.Internal.Impl.get?_inter_of_contains_eq_false_left {α : Type u} {β : α → Type v} {instOrd : Ord α} {m₁ m₂ : Impl α β} [TransOrd α] [LawfulEqOrd α] (h₁ : m₁.WF) (h₂ : m₂.WF) {k : α} (h : contains k m₁ = false) : (m₁.inter m₂ ⋯).get? k = none

theorem Std.DTreeMap.Internal.Impl.get?_inter!_of_contains_eq_false_left {α : Type u} {β : α → Type v} {instOrd : Ord α} {m₁ m₂ : Impl α β} [TransOrd α] [LawfulEqOrd α] (h₁ : m₁.WF) (h₂ : m₂.WF) {k : α} (h : contains k m₁ = false) : (m₁.inter! m₂).get? k = none

theorem Std.DTreeMap.Internal.Impl.get?_inter_of_contains_eq_false_right {α : Type u} {β : α → Type v} {instOrd : Ord α} {m₁ m₂ : Impl α β} [TransOrd α] [LawfulEqOrd α] (h₁ : m₁.WF) (h₂ : m₂.WF) {k : α} (h : contains k m₂ = false) : (m₁.inter m₂ ⋯).get? k = none

theorem Std.DTreeMap.Internal.Impl.get?_inter!_of_contains_eq_false_right {α : Type u} {β : α → Type v} {instOrd : Ord α} {m₁ m₂ : Impl α β} [TransOrd α] [LawfulEqOrd α] (h₁ : m₁.WF) (h₂ : m₂.WF) {k : α} (h : contains k m₂ = false) : (m₁.inter! m₂).get? k = none

@[simp]

theorem Std.DTreeMap.Internal.Impl.get_inter {α : Type u} {β : α → Type v} {instOrd : Ord α} {m₁ m₂ : Impl α β} [TransOrd α] [LawfulEqOrd α] (h₁ : m₁.WF) (h₂ : m₂.WF) {k : α} {h_contains : contains k (m₁.inter m₂ ⋯) = true} : (m₁.inter m₂ ⋯).get k h_contains = m₁.get k ⋯

@[simp]

theorem Std.DTreeMap.Internal.Impl.get_inter! {α : Type u} {β : α → Type v} {instOrd : Ord α} {m₁ m₂ : Impl α β} [TransOrd α] [LawfulEqOrd α] (h₁ : m₁.WF) (h₂ : m₂.WF) {k : α} {h_contains : contains k (m₁.inter! m₂) = true} : (m₁.inter! m₂).get k h_contains = m₁.get k ⋯

theorem Std.DTreeMap.Internal.Impl.getD_inter {α : Type u} {β : α → Type v} {instOrd : Ord α} {m₁ m₂ : Impl α β} [TransOrd α] [LawfulEqOrd α] (h₁ : m₁.WF) (h₂ : m₂.WF) {k : α} {fallback : β k} : (m₁.inter m₂ ⋯).getD k fallback = if contains k m₂ = true then m₁.getD k fallback else fallback

theorem Std.DTreeMap.Internal.Impl.getD_inter! {α : Type u} {β : α → Type v} {instOrd : Ord α} {m₁ m₂ : Impl α β} [TransOrd α] [LawfulEqOrd α] (h₁ : m₁.WF) (h₂ : m₂.WF) {k : α} {fallback : β k} : (m₁.inter! m₂).getD k fallback = if contains k m₂ = true then m₁.getD k fallback else fallback

theorem Std.DTreeMap.Internal.Impl.getD_inter_of_contains_right {α : Type u} {β : α → Type v} {instOrd : Ord α} {m₁ m₂ : Impl α β} [TransOrd α] [LawfulEqOrd α] (h₁ : m₁.WF) (h₂ : m₂.WF) {k : α} {fallback : β k} (h : contains k m₂ = true) : (m₁.inter m₂ ⋯).getD k fallback = m₁.getD k fallback

theorem Std.DTreeMap.Internal.Impl.getD_inter!_of_contains_right {α : Type u} {β : α → Type v} {instOrd : Ord α} {m₁ m₂ : Impl α β} [TransOrd α] [LawfulEqOrd α] (h₁ : m₁.WF) (h₂ : m₂.WF) {k : α} {fallback : β k} (h : contains k m₂ = true) : (m₁.inter! m₂).getD k fallback = m₁.getD k fallback

theorem Std.DTreeMap.Internal.Impl.getD_inter_of_contains_eq_false_right {α : Type u} {β : α → Type v} {instOrd : Ord α} {m₁ m₂ : Impl α β} [TransOrd α] [LawfulEqOrd α] (h₁ : m₁.WF) (h₂ : m₂.WF) {k : α} {fallback : β k} (h : contains k m₂ = false) : (m₁.inter m₂ ⋯).getD k fallback = fallback

theorem Std.DTreeMap.Internal.Impl.getD_inter!_of_contains_eq_false_right {α : Type u} {β : α → Type v} {instOrd : Ord α} {m₁ m₂ : Impl α β} [TransOrd α] [LawfulEqOrd α] (h₁ : m₁.WF) (h₂ : m₂.WF) {k : α} {fallback : β k} (h : contains k m₂ = false) : (m₁.inter! m₂).getD k fallback = fallback

theorem Std.DTreeMap.Internal.Impl.getD_inter_of_contains_eq_false_left {α : Type u} {β : α → Type v} {instOrd : Ord α} {m₁ m₂ : Impl α β} [TransOrd α] [LawfulEqOrd α] (h₁ : m₁.WF) (h₂ : m₂.WF) {k : α} {fallback : β k} (h : contains k m₁ = false) : (m₁.inter m₂ ⋯).getD k fallback = fallback

theorem Std.DTreeMap.Internal.Impl.getD_inter!_of_contains_eq_false_left {α : Type u} {β : α → Type v} {instOrd : Ord α} {m₁ m₂ : Impl α β} [TransOrd α] [LawfulEqOrd α] (h₁ : m₁.WF) (h₂ : m₂.WF) {k : α} {fallback : β k} (h : contains k m₁ = false) : (m₁.inter! m₂).getD k fallback = fallback

theorem Std.DTreeMap.Internal.Impl.get!_inter {α : Type u} {β : α → Type v} {instOrd : Ord α} {m₁ m₂ : Impl α β} [TransOrd α] [LawfulEqOrd α] (h₁ : m₁.WF) (h₂ : m₂.WF) {k : α} [Inhabited (β k)] : (m₁.inter m₂ ⋯).get! k = if contains k m₂ = true then m₁.get! k else default

theorem Std.DTreeMap.Internal.Impl.get!_inter! {α : Type u} {β : α → Type v} {instOrd : Ord α} {m₁ m₂ : Impl α β} [TransOrd α] [LawfulEqOrd α] (h₁ : m₁.WF) (h₂ : m₂.WF) {k : α} [Inhabited (β k)] : (m₁.inter! m₂).get! k = if contains k m₂ = true then m₁.get! k else default

theorem Std.DTreeMap.Internal.Impl.get!_inter_of_contains_right {α : Type u} {β : α → Type v} {instOrd : Ord α} {m₁ m₂ : Impl α β} [TransOrd α] [LawfulEqOrd α] (h₁ : m₁.WF) (h₂ : m₂.WF) {k : α} [Inhabited (β k)] (h : contains k m₂ = true) : (m₁.inter m₂ ⋯).get! k = m₁.get! k

theorem Std.DTreeMap.Internal.Impl.get!_inter!_of_contains_right {α : Type u} {β : α → Type v} {instOrd : Ord α} {m₁ m₂ : Impl α β} [TransOrd α] [LawfulEqOrd α] (h₁ : m₁.WF) (h₂ : m₂.WF) {k : α} [Inhabited (β k)] (h : contains k m₂ = true) : (m₁.inter! m₂).get! k = m₁.get! k

theorem Std.DTreeMap.Internal.Impl.get!_inter_of_contains_eq_false_right {α : Type u} {β : α → Type v} {instOrd : Ord α} {m₁ m₂ : Impl α β} [TransOrd α] [LawfulEqOrd α] (h₁ : m₁.WF) (h₂ : m₂.WF) {k : α} [Inhabited (β k)] (h : contains k m₂ = false) : (m₁.inter m₂ ⋯).get! k = default

theorem Std.DTreeMap.Internal.Impl.get!_inter!_of_contains_eq_false_right {α : Type u} {β : α → Type v} {instOrd : Ord α} {m₁ m₂ : Impl α β} [TransOrd α] [LawfulEqOrd α] (h₁ : m₁.WF) (h₂ : m₂.WF) {k : α} [Inhabited (β k)] (h : contains k m₂ = false) : (m₁.inter! m₂).get! k = default

theorem Std.DTreeMap.Internal.Impl.get!_inter_of_contains_eq_false_left {α : Type u} {β : α → Type v} {instOrd : Ord α} {m₁ m₂ : Impl α β} [TransOrd α] [LawfulEqOrd α] (h₁ : m₁.WF) (h₂ : m₂.WF) {k : α} [Inhabited (β k)] (h : contains k m₁ = false) : (m₁.inter m₂ ⋯).get! k = default

theorem Std.DTreeMap.Internal.Impl.get!_inter!_of_contains_eq_false_left {α : Type u} {β : α → Type v} {instOrd : Ord α} {m₁ m₂ : Impl α β} [TransOrd α] [LawfulEqOrd α] (h₁ : m₁.WF) (h₂ : m₂.WF) {k : α} [Inhabited (β k)] (h : contains k m₁ = false) : (m₁.inter! m₂).get! k = default

theorem Std.DTreeMap.Internal.Impl.getKey?_inter {α : Type u} {β : α → Type v} {instOrd : Ord α} {m₁ m₂ : Impl α β} [TransOrd α] (h₁ : m₁.WF) (h₂ : m₂.WF) {k : α} : (m₁.inter m₂ ⋯).getKey? k = if contains k m₂ = true then m₁.getKey? k else none

theorem Std.DTreeMap.Internal.Impl.getKey?_inter! {α : Type u} {β : α → Type v} {instOrd : Ord α} {m₁ m₂ : Impl α β} [TransOrd α] (h₁ : m₁.WF) (h₂ : m₂.WF) {k : α} : (m₁.inter! m₂).getKey? k = if contains k m₂ = true then m₁.getKey? k else none

theorem Std.DTreeMap.Internal.Impl.getKey?_inter_of_contains_right {α : Type u} {β : α → Type v} {instOrd : Ord α} {m₁ m₂ : Impl α β} [TransOrd α] (h₁ : m₁.WF) (h₂ : m₂.WF) {k : α} (h : contains k m₂ = true) : (m₁.inter m₂ ⋯).getKey? k = m₁.getKey? k

theorem Std.DTreeMap.Internal.Impl.getKey?_inter!_of_contains_right {α : Type u} {β : α → Type v} {instOrd : Ord α} {m₁ m₂ : Impl α β} [TransOrd α] (h₁ : m₁.WF) (h₂ : m₂.WF) {k : α} (h : contains k m₂ = true) : (m₁.inter! m₂).getKey? k = m₁.getKey? k

theorem Std.DTreeMap.Internal.Impl.getKey?_inter_of_contains_eq_false_right {α : Type u} {β : α → Type v} {instOrd : Ord α} {m₁ m₂ : Impl α β} [TransOrd α] (h₁ : m₁.WF) (h₂ : m₂.WF) {k : α} (h : contains k m₂ = false) : (m₁.inter m₂ ⋯).getKey? k = none

theorem Std.DTreeMap.Internal.Impl.getKey?_inter!_of_contains_eq_false_right {α : Type u} {β : α → Type v} {instOrd : Ord α} {m₁ m₂ : Impl α β} [TransOrd α] (h₁ : m₁.WF) (h₂ : m₂.WF) {k : α} (h : contains k m₂ = false) : (m₁.inter! m₂).getKey? k = none

theorem Std.DTreeMap.Internal.Impl.getKey?_inter_of_contains_eq_false_left {α : Type u} {β : α → Type v} {instOrd : Ord α} {m₁ m₂ : Impl α β} [TransOrd α] (h₁ : m₁.WF) (h₂ : m₂.WF) {k : α} (h : contains k m₁ = false) : (m₁.inter m₂ ⋯).getKey? k = none

theorem Std.DTreeMap.Internal.Impl.getKey?_inter!_of_contains_eq_false_left {α : Type u} {β : α → Type v} {instOrd : Ord α} {m₁ m₂ : Impl α β} [TransOrd α] (h₁ : m₁.WF) (h₂ : m₂.WF) {k : α} (h : contains k m₁ = false) : (m₁.inter! m₂).getKey? k = none

@[simp]

theorem Std.DTreeMap.Internal.Impl.getKey_inter {α : Type u} {β : α → Type v} {instOrd : Ord α} {m₁ m₂ : Impl α β} [TransOrd α] (h₁ : m₁.WF) (h₂ : m₂.WF) {k : α} {h_contains : contains k (m₁.inter m₂ ⋯) = true} : (m₁.inter m₂ ⋯).getKey k h_contains = m₁.getKey k ⋯

@[simp]

theorem Std.DTreeMap.Internal.Impl.getKey_inter! {α : Type u} {β : α → Type v} {instOrd : Ord α} {m₁ m₂ : Impl α β} [TransOrd α] (h₁ : m₁.WF) (h₂ : m₂.WF) {k : α} {h_contains : contains k (m₁.inter! m₂) = true} : (m₁.inter! m₂).getKey k h_contains = m₁.getKey k ⋯

theorem Std.DTreeMap.Internal.Impl.getKeyD_inter {α : Type u} {β : α → Type v} {instOrd : Ord α} {m₁ m₂ : Impl α β} [TransOrd α] (h₁ : m₁.WF) (h₂ : m₂.WF) {k fallback : α} : (m₁.inter m₂ ⋯).getKeyD k fallback = if contains k m₂ = true then m₁.getKeyD k fallback else fallback

theorem Std.DTreeMap.Internal.Impl.getKeyD_inter! {α : Type u} {β : α → Type v} {instOrd : Ord α} {m₁ m₂ : Impl α β} [TransOrd α] (h₁ : m₁.WF) (h₂ : m₂.WF) {k fallback : α} : (m₁.inter! m₂).getKeyD k fallback = if contains k m₂ = true then m₁.getKeyD k fallback else fallback

theorem Std.DTreeMap.Internal.Impl.getKeyD_inter_of_contains_right {α : Type u} {β : α → Type v} {instOrd : Ord α} {m₁ m₂ : Impl α β} [TransOrd α] (h₁ : m₁.WF) (h₂ : m₂.WF) {k fallback : α} (h : contains k m₂ = true) : (m₁.inter m₂ ⋯).getKeyD k fallback = m₁.getKeyD k fallback

theorem Std.DTreeMap.Internal.Impl.getKeyD_inter!_of_contains_right {α : Type u} {β : α → Type v} {instOrd : Ord α} {m₁ m₂ : Impl α β} [TransOrd α] (h₁ : m₁.WF) (h₂ : m₂.WF) {k fallback : α} (h : contains k m₂ = true) : (m₁.inter! m₂).getKeyD k fallback = m₁.getKeyD k fallback

theorem Std.DTreeMap.Internal.Impl.getKeyD_inter_of_contains_eq_false_right {α : Type u} {β : α → Type v} {instOrd : Ord α} {m₁ m₂ : Impl α β} [TransOrd α] (h₁ : m₁.WF) (h₂ : m₂.WF) {k fallback : α} (h : contains k m₂ = false) : (m₁.inter m₂ ⋯).getKeyD k fallback = fallback

theorem Std.DTreeMap.Internal.Impl.getKeyD_inter!_of_contains_eq_false_right {α : Type u} {β : α → Type v} {instOrd : Ord α} {m₁ m₂ : Impl α β} [TransOrd α] (h₁ : m₁.WF) (h₂ : m₂.WF) {k fallback : α} (h : contains k m₂ = false) : (m₁.inter! m₂).getKeyD k fallback = fallback

theorem Std.DTreeMap.Internal.Impl.getKeyD_inter_of_contains_eq_false_left {α : Type u} {β : α → Type v} {instOrd : Ord α} {m₁ m₂ : Impl α β} [TransOrd α] (h₁ : m₁.WF) (h₂ : m₂.WF) {k fallback : α} (h : contains k m₁ = false) : (m₁.inter m₂ ⋯).getKeyD k fallback = fallback

theorem Std.DTreeMap.Internal.Impl.getKeyD_inter!_of_contains_eq_false_left {α : Type u} {β : α → Type v} {instOrd : Ord α} {m₁ m₂ : Impl α β} [TransOrd α] (h₁ : m₁.WF) (h₂ : m₂.WF) {k fallback : α} (h : contains k m₁ = false) : (m₁.inter! m₂).getKeyD k fallback = fallback

theorem Std.DTreeMap.Internal.Impl.getKey!_inter {α : Type u} {β : α → Type v} {instOrd : Ord α} {m₁ m₂ : Impl α β} [Inhabited α] [TransOrd α] (h₁ : m₁.WF) (h₂ : m₂.WF) {k : α} : (m₁.inter m₂ ⋯).getKey! k = if contains k m₂ = true then m₁.getKey! k else default

theorem Std.DTreeMap.Internal.Impl.getKey!_inter! {α : Type u} {β : α → Type v} {instOrd : Ord α} {m₁ m₂ : Impl α β} [Inhabited α] [TransOrd α] (h₁ : m₁.WF) (h₂ : m₂.WF) {k : α} : (m₁.inter! m₂).getKey! k = if contains k m₂ = true then m₁.getKey! k else default

theorem Std.DTreeMap.Internal.Impl.getKey!_inter_of_contains_right {α : Type u} {β : α → Type v} {instOrd : Ord α} {m₁ m₂ : Impl α β} [Inhabited α] [TransOrd α] (h₁ : m₁.WF) (h₂ : m₂.WF) {k : α} (h : contains k m₂ = true) : (m₁.inter m₂ ⋯).getKey! k = m₁.getKey! k

theorem Std.DTreeMap.Internal.Impl.getKey!_inter!_of_contains_right {α : Type u} {β : α → Type v} {instOrd : Ord α} {m₁ m₂ : Impl α β} [Inhabited α] [TransOrd α] (h₁ : m₁.WF) (h₂ : m₂.WF) {k : α} (h : contains k m₂ = true) : (m₁.inter! m₂).getKey! k = m₁.getKey! k

theorem Std.DTreeMap.Internal.Impl.getKey!_inter_of_contains_eq_false_right {α : Type u} {β : α → Type v} {instOrd : Ord α} {m₁ m₂ : Impl α β} [Inhabited α] [TransOrd α] (h₁ : m₁.WF) (h₂ : m₂.WF) {k : α} (h : contains k m₂ = false) : (m₁.inter m₂ ⋯).getKey! k = default

theorem Std.DTreeMap.Internal.Impl.getKey!_inter!_of_contains_eq_false_right {α : Type u} {β : α → Type v} {instOrd : Ord α} {m₁ m₂ : Impl α β} [Inhabited α] [TransOrd α] (h₁ : m₁.WF) (h₂ : m₂.WF) {k : α} (h : contains k m₂ = false) : (m₁.inter! m₂).getKey! k = default

theorem Std.DTreeMap.Internal.Impl.getKey!_inter_of_contains_eq_false_left {α : Type u} {β : α → Type v} {instOrd : Ord α} {m₁ m₂ : Impl α β} [Inhabited α] [TransOrd α] (h₁ : m₁.WF) (h₂ : m₂.WF) {k : α} (h : contains k m₁ = false) : (m₁.inter m₂ ⋯).getKey! k = default

theorem Std.DTreeMap.Internal.Impl.getKey!_inter!_of_contains_eq_false_left {α : Type u} {β : α → Type v} {instOrd : Ord α} {m₁ m₂ : Impl α β} [Inhabited α] [TransOrd α] (h₁ : m₁.WF) (h₂ : m₂.WF) {k : α} (h : contains k m₁ = false) : (m₁.inter! m₂).getKey! k = default

theorem Std.DTreeMap.Internal.Impl.size_inter_le_size_left {α : Type u} {β : α → Type v} {instOrd : Ord α} {m₁ m₂ : Impl α β} [TransOrd α] (h₁ : m₁.WF) (h₂ : m₂.WF) : (m₁.inter m₂ ⋯).size ≤ m₁.size

theorem Std.DTreeMap.Internal.Impl.size_inter!_le_size_left {α : Type u} {β : α → Type v} {instOrd : Ord α} {m₁ m₂ : Impl α β} [TransOrd α] (h₁ : m₁.WF) (h₂ : m₂.WF) : (m₁.inter! m₂).size ≤ m₁.size

theorem Std.DTreeMap.Internal.Impl.size_inter_le_size_right {α : Type u} {β : α → Type v} {instOrd : Ord α} {m₁ m₂ : Impl α β} [TransOrd α] (h₁ : m₁.WF) (h₂ : m₂.WF) : (m₁.inter m₂ ⋯).size ≤ m₂.size

theorem Std.DTreeMap.Internal.Impl.size_inter!_le_size_right {α : Type u} {β : α → Type v} {instOrd : Ord α} {m₁ m₂ : Impl α β} [TransOrd α] (h₁ : m₁.WF) (h₂ : m₂.WF) : (m₁.inter! m₂).size ≤ m₂.size

theorem Std.DTreeMap.Internal.Impl.size_inter_eq_size_left {α : Type u} {β : α → Type v} {instOrd : Ord α} {m₁ m₂ : Impl α β} [TransOrd α] (h₁ : m₁.WF) (h₂ : m₂.WF) (h : ∀ (a : α), contains a m₁ = true → contains a m₂ = true) : (m₁.inter m₂ ⋯).size = m₁.size

theorem Std.DTreeMap.Internal.Impl.size_inter!_eq_size_left {α : Type u} {β : α → Type v} {instOrd : Ord α} {m₁ m₂ : Impl α β} [TransOrd α] (h₁ : m₁.WF) (h₂ : m₂.WF) (h : ∀ (a : α), contains a m₁ = true → contains a m₂ = true) : (m₁.inter! m₂).size = m₁.size

theorem Std.DTreeMap.Internal.Impl.size_inter_eq_size_right {α : Type u} {β : α → Type v} {instOrd : Ord α} {m₁ m₂ : Impl α β} [TransOrd α] (h₁ : m₁.WF) (h₂ : m₂.WF) (h : ∀ (a : α), contains a m₂ = true → contains a m₁ = true) : (m₁.inter m₂ ⋯).size = m₂.size

theorem Std.DTreeMap.Internal.Impl.size_inter!_eq_size_right {α : Type u} {β : α → Type v} {instOrd : Ord α} {m₁ m₂ : Impl α β} [TransOrd α] (h₁ : m₁.WF) (h₂ : m₂.WF) (h : ∀ (a : α), contains a m₂ = true → contains a m₁ = true) : (m₁.inter! m₂).size = m₂.size

theorem Std.DTreeMap.Internal.Impl.size_add_size_eq_size_union_add_size_inter {α : Type u} {β : α → Type v} {instOrd : Ord α} {m₁ m₂ : Impl α β} [TransOrd α] (h₁ : m₁.WF) (h₂ : m₂.WF) : m₁.size + m₂.size = (m₁.union m₂ ⋯ ⋯).size + (m₁.inter m₂ ⋯).size

theorem Std.DTreeMap.Internal.Impl.size_add_size_eq_size_union!_add_size_inter! {α : Type u} {β : α → Type v} {instOrd : Ord α} {m₁ m₂ : Impl α β} [TransOrd α] (h₁ : m₁.WF) (h₂ : m₂.WF) : m₁.size + m₂.size = (m₁.union! m₂).size + (m₁.inter! m₂).size

@[simp]

theorem Std.DTreeMap.Internal.Impl.isEmpty_inter_left {α : Type u} {β : α → Type v} {instOrd : Ord α} {m₁ m₂ : Impl α β} [TransOrd α] (h₁ : m₁.WF) (h₂ : m₂.WF) (h : m₁.isEmpty = true) : (m₁.inter m₂ ⋯).isEmpty = true

@[simp]

theorem Std.DTreeMap.Internal.Impl.isEmpty_inter!_left {α : Type u} {β : α → Type v} {instOrd : Ord α} {m₁ m₂ : Impl α β} [TransOrd α] (h₁ : m₁.WF) (h₂ : m₂.WF) (h : m₁.isEmpty = true) : (m₁.inter! m₂).isEmpty = true

@[simp]

theorem Std.DTreeMap.Internal.Impl.isEmpty_inter_right {α : Type u} {β : α → Type v} {instOrd : Ord α} {m₁ m₂ : Impl α β} [TransOrd α] (h₁ : m₁.WF) (h₂ : m₂.WF) (h : m₂.isEmpty = true) : (m₁.inter m₂ ⋯).isEmpty = true

@[simp]

theorem Std.DTreeMap.Internal.Impl.isEmpty_inter!_right {α : Type u} {β : α → Type v} {instOrd : Ord α} {m₁ m₂ : Impl α β} [TransOrd α] (h₁ : m₁.WF) (h₂ : m₂.WF) (h : m₂.isEmpty = true) : (m₁.inter! m₂).isEmpty = true

theorem Std.DTreeMap.Internal.Impl.isEmpty_inter_iff {α : Type u} {β : α → Type v} {instOrd : Ord α} {m₁ m₂ : Impl α β} [TransOrd α] (h₁ : m₁.WF) (h₂ : m₂.WF) : (m₁.inter m₂ ⋯).isEmpty = true ↔ ∀ (k : α), contains k m₁ = true → contains k m₂ = false

theorem Std.DTreeMap.Internal.Impl.isEmpty_inter_comm {α : Type u} {β : α → Type v} {instOrd : Ord α} {m₁ m₂ : Impl α β} [TransOrd α] (h₁ : m₁.WF) (h₂ : m₂.WF) : (m₁.inter m₂ ⋯).isEmpty = (m₂.inter m₁ ⋯).isEmpty

theorem Std.DTreeMap.Internal.Impl.isEmpty_inter!_iff {α : Type u} {β : α → Type v} {instOrd : Ord α} {m₁ m₂ : Impl α β} [TransOrd α] (h₁ : m₁.WF) (h₂ : m₂.WF) : (m₁.inter! m₂).isEmpty = true ↔ ∀ (k : α), contains k m₁ = true → contains k m₂ = false

theorem Std.DTreeMap.Internal.Impl.isEmpty_inter!_comm {α : Type u} {β : α → Type v} {instOrd : Ord α} {m₁ m₂ : Impl α β} [TransOrd α] (h₁ : m₁.WF) (h₂ : m₂.WF) : (m₁.inter! m₂).isEmpty = (m₂.inter! m₁).isEmpty

theorem Std.DTreeMap.Internal.Impl.Const.get?_inter {α : Type u} {instOrd : Ord α} {β : Type v} {m₁ m₂ : Impl α fun (x : α) => β} [TransOrd α] (h₁ : m₁.WF) (h₂ : m₂.WF) {k : α} : get? (m₁.inter m₂ ⋯) k = if contains k m₂ = true then get? m₁ k else none

theorem Std.DTreeMap.Internal.Impl.Const.get?_inter! {α : Type u} {instOrd : Ord α} {β : Type v} {m₁ m₂ : Impl α fun (x : α) => β} [TransOrd α] (h₁ : m₁.WF) (h₂ : m₂.WF) {k : α} : get? (m₁.inter! m₂) k = if contains k m₂ = true then get? m₁ k else none

theorem Std.DTreeMap.Internal.Impl.Const.get?_inter_of_contains_right {α : Type u} {instOrd : Ord α} {β : Type v} {m₁ m₂ : Impl α fun (x : α) => β} [TransOrd α] (h₁ : m₁.WF) (h₂ : m₂.WF) {k : α} (h : contains k m₂ = true) : get? (m₁.inter m₂ ⋯) k = get? m₁ k

theorem Std.DTreeMap.Internal.Impl.Const.get?_inter!_of_contains_right {α : Type u} {instOrd : Ord α} {β : Type v} {m₁ m₂ : Impl α fun (x : α) => β} [TransOrd α] (h₁ : m₁.WF) (h₂ : m₂.WF) {k : α} (h : contains k m₂ = true) : get? (m₁.inter! m₂) k = get? m₁ k

theorem Std.DTreeMap.Internal.Impl.Const.get?_inter_of_contains_eq_false_left {α : Type u} {instOrd : Ord α} {β : Type v} {m₁ m₂ : Impl α fun (x : α) => β} [TransOrd α] (h₁ : m₁.WF) (h₂ : m₂.WF) {k : α} (h : contains k m₁ = false) : get? (m₁.inter m₂ ⋯) k = none

theorem Std.DTreeMap.Internal.Impl.Const.get?_inter!_of_contains_eq_false_left {α : Type u} {instOrd : Ord α} {β : Type v} {m₁ m₂ : Impl α fun (x : α) => β} [TransOrd α] (h₁ : m₁.WF) (h₂ : m₂.WF) {k : α} (h : contains k m₁ = false) : get? (m₁.inter! m₂) k = none

theorem Std.DTreeMap.Internal.Impl.Const.get?_inter_of_contains_eq_false_right {α : Type u} {instOrd : Ord α} {β : Type v} {m₁ m₂ : Impl α fun (x : α) => β} [TransOrd α] (h₁ : m₁.WF) (h₂ : m₂.WF) {k : α} (h : contains k m₂ = false) : get? (m₁.inter m₂ ⋯) k = none

theorem Std.DTreeMap.Internal.Impl.Const.get?_inter!_of_contains_eq_false_right {α : Type u} {instOrd : Ord α} {β : Type v} {m₁ m₂ : Impl α fun (x : α) => β} [TransOrd α] (h₁ : m₁.WF) (h₂ : m₂.WF) {k : α} (h : contains k m₂ = false) : get? (m₁.inter! m₂) k = none

@[simp]

theorem Std.DTreeMap.Internal.Impl.Const.get_inter {α : Type u} {instOrd : Ord α} {β : Type v} {m₁ m₂ : Impl α fun (x : α) => β} [TransOrd α] (h₁ : m₁.WF) (h₂ : m₂.WF) {k : α} {h_contains : contains k (m₁.inter m₂ ⋯) = true} : get (m₁.inter m₂ ⋯) k h_contains = get m₁ k ⋯

@[simp]

theorem Std.DTreeMap.Internal.Impl.Const.get_inter! {α : Type u} {instOrd : Ord α} {β : Type v} {m₁ m₂ : Impl α fun (x : α) => β} [TransOrd α] (h₁ : m₁.WF) (h₂ : m₂.WF) {k : α} {h_contains : contains k (m₁.inter! m₂) = true} : get (m₁.inter! m₂) k h_contains = get m₁ k ⋯

theorem Std.DTreeMap.Internal.Impl.Const.getD_inter {α : Type u} {instOrd : Ord α} {β : Type v} {m₁ m₂ : Impl α fun (x : α) => β} [TransOrd α] (h₁ : m₁.WF) (h₂ : m₂.WF) {k : α} {fallback : β} : getD (m₁.inter m₂ ⋯) k fallback = if contains k m₂ = true then getD m₁ k fallback else fallback

theorem Std.DTreeMap.Internal.Impl.Const.getD_inter! {α : Type u} {instOrd : Ord α} {β : Type v} {m₁ m₂ : Impl α fun (x : α) => β} [TransOrd α] (h₁ : m₁.WF) (h₂ : m₂.WF) {k : α} {fallback : β} : getD (m₁.inter! m₂) k fallback = if contains k m₂ = true then getD m₁ k fallback else fallback

theorem Std.DTreeMap.Internal.Impl.Const.getD_inter_of_contains_right {α : Type u} {instOrd : Ord α} {β : Type v} {m₁ m₂ : Impl α fun (x : α) => β} [TransOrd α] (h₁ : m₁.WF) (h₂ : m₂.WF) {k : α} {fallback : β} (h : contains k m₂ = true) : getD (m₁.inter m₂ ⋯) k fallback = getD m₁ k fallback

theorem Std.DTreeMap.Internal.Impl.Const.getD_inter!_of_contains_right {α : Type u} {instOrd : Ord α} {β : Type v} {m₁ m₂ : Impl α fun (x : α) => β} [TransOrd α] (h₁ : m₁.WF) (h₂ : m₂.WF) {k : α} {fallback : β} (h : contains k m₂ = true) : getD (m₁.inter! m₂) k fallback = getD m₁ k fallback

theorem Std.DTreeMap.Internal.Impl.Const.getD_inter_of_contains_eq_false_right {α : Type u} {instOrd : Ord α} {β : Type v} {m₁ m₂ : Impl α fun (x : α) => β} [TransOrd α] (h₁ : m₁.WF) (h₂ : m₂.WF) {k : α} {fallback : β} (h : contains k m₂ = false) : getD (m₁.inter m₂ ⋯) k fallback = fallback

theorem Std.DTreeMap.Internal.Impl.Const.getD_inter!_of_contains_eq_false_right {α : Type u} {instOrd : Ord α} {β : Type v} {m₁ m₂ : Impl α fun (x : α) => β} [TransOrd α] (h₁ : m₁.WF) (h₂ : m₂.WF) {k : α} {fallback : β} (h : contains k m₂ = false) : getD (m₁.inter! m₂) k fallback = fallback

theorem Std.DTreeMap.Internal.Impl.Const.getD_inter_of_contains_eq_false_left {α : Type u} {instOrd : Ord α} {β : Type v} {m₁ m₂ : Impl α fun (x : α) => β} [TransOrd α] (h₁ : m₁.WF) (h₂ : m₂.WF) {k : α} {fallback : β} (h : contains k m₁ = false) : getD (m₁.inter m₂ ⋯) k fallback = fallback

theorem Std.DTreeMap.Internal.Impl.Const.getD_inter!_of_contains_eq_false_left {α : Type u} {instOrd : Ord α} {β : Type v} {m₁ m₂ : Impl α fun (x : α) => β} [TransOrd α] (h₁ : m₁.WF) (h₂ : m₂.WF) {k : α} {fallback : β} (h : contains k m₁ = false) : getD (m₁.inter! m₂) k fallback = fallback

theorem Std.DTreeMap.Internal.Impl.Const.get!_inter {α : Type u} {instOrd : Ord α} {β : Type v} {m₁ m₂ : Impl α fun (x : α) => β} [TransOrd α] [Inhabited β] (h₁ : m₁.WF) (h₂ : m₂.WF) {k : α} : get! (m₁.inter m₂ ⋯) k = if contains k m₂ = true then get! m₁ k else default

theorem Std.DTreeMap.Internal.Impl.Const.get!_inter! {α : Type u} {instOrd : Ord α} {β : Type v} {m₁ m₂ : Impl α fun (x : α) => β} [TransOrd α] [Inhabited β] (h₁ : m₁.WF) (h₂ : m₂.WF) {k : α} : get! (m₁.inter! m₂) k = if contains k m₂ = true then get! m₁ k else default

theorem Std.DTreeMap.Internal.Impl.Const.get!_inter_of_contains_right {α : Type u} {instOrd : Ord α} {β : Type v} {m₁ m₂ : Impl α fun (x : α) => β} [TransOrd α] [Inhabited β] (h₁ : m₁.WF) (h₂ : m₂.WF) {k : α} (h : contains k m₂ = true) : get! (m₁.inter m₂ ⋯) k = get! m₁ k

theorem Std.DTreeMap.Internal.Impl.Const.get!_inter!_of_contains_right {α : Type u} {instOrd : Ord α} {β : Type v} {m₁ m₂ : Impl α fun (x : α) => β} [TransOrd α] [Inhabited β] (h₁ : m₁.WF) (h₂ : m₂.WF) {k : α} (h : contains k m₂ = true) : get! (m₁.inter! m₂) k = get! m₁ k

theorem Std.DTreeMap.Internal.Impl.Const.get!_inter_of_contains_eq_false_right {α : Type u} {instOrd : Ord α} {β : Type v} {m₁ m₂ : Impl α fun (x : α) => β} [TransOrd α] [Inhabited β] (h₁ : m₁.WF) (h₂ : m₂.WF) {k : α} (h : contains k m₂ = false) : get! (m₁.inter m₂ ⋯) k = default

theorem Std.DTreeMap.Internal.Impl.Const.get!_inter!_of_contains_eq_false_right {α : Type u} {instOrd : Ord α} {β : Type v} {m₁ m₂ : Impl α fun (x : α) => β} [TransOrd α] [Inhabited β] (h₁ : m₁.WF) (h₂ : m₂.WF) {k : α} (h : contains k m₂ = false) : get! (m₁.inter! m₂) k = default

theorem Std.DTreeMap.Internal.Impl.Const.get!_inter_of_contains_eq_false_left {α : Type u} {instOrd : Ord α} {β : Type v} {m₁ m₂ : Impl α fun (x : α) => β} [TransOrd α] [Inhabited β] (h₁ : m₁.WF) (h₂ : m₂.WF) {k : α} (h : contains k m₁ = false) : get! (m₁.inter m₂ ⋯) k = default

theorem Std.DTreeMap.Internal.Impl.Const.get!_inter!_of_contains_eq_false_left {α : Type u} {instOrd : Ord α} {β : Type v} {m₁ m₂ : Impl α fun (x : α) => β} [TransOrd α] [Inhabited β] (h₁ : m₁.WF) (h₂ : m₂.WF) {k : α} (h : contains k m₁ = false) : get! (m₁.inter! m₂) k = default

theorem Std.DTreeMap.Internal.Impl.Equiv.beq {α : Type u} {β : α → Type v} {instOrd : Ord α} {m₁ m₂ : Impl α β} [TransOrd α] [LawfulEqOrd α] [(k : α) → BEq (β k)] [∀ (k : α), ReflBEq (β k)] (h₁ : m₁.WF) (h₂ : m₂.WF) : m₁.Equiv m₂ → m₁.beq m₂ = true

theorem Std.DTreeMap.Internal.Impl.equiv_of_beq {α : Type u} {β : α → Type v} {instOrd : Ord α} {m₁ m₂ : Impl α β} [TransOrd α] [LawfulEqOrd α] [(k : α) → BEq (β k)] [∀ (k : α), LawfulBEq (β k)] (h₁ : m₁.WF) (h₂ : m₂.WF) : m₁.beq m₂ = true → m₁.Equiv m₂

theorem Std.DTreeMap.Internal.Impl.beq_iff_equiv {α : Type u} {β : α → Type v} {instOrd : Ord α} {m₁ m₂ : Impl α β} [TransOrd α] [LawfulEqOrd α] [(k : α) → BEq (β k)] [∀ (k : α), LawfulBEq (β k)] (h₁ : m₁.WF) (h₂ : m₂.WF) : m₁.beq m₂ = true ↔ m₁.Equiv m₂

theorem Std.DTreeMap.Internal.Impl.Equiv.beq_congr {α : Type u} {β : α → Type v} {instOrd : Ord α} {m₁ m₂ : Impl α β} [TransOrd α] [LawfulEqOrd α] [(k : α) → BEq (β k)] {m₃ m₄ : Impl α β} (h₁ : m₁.WF) (h₂ : m₂.WF) (h₃ : m₃.WF) (h₄ : m₄.WF) : m₁.Equiv m₃ → m₂.Equiv m₄ → m₁.beq m₂ = m₃.beq m₄

theorem Std.DTreeMap.Internal.Impl.Const.Equiv.beq {α : Type u} {instOrd : Ord α} {β : Type v} [BEq β] {m₁ m₂ : Impl α fun (x : α) => β} [TransOrd α] [ReflBEq β] (h₁ : m₁.WF) (h₂ : m₂.WF) : m₁.Equiv m₂ → Const.beq m₁ m₂ = true

theorem Std.DTreeMap.Internal.Impl.Const.equiv_of_beq {α : Type u} {instOrd : Ord α} {β : Type v} [BEq β] {m₁ m₂ : Impl α fun (x : α) => β} [TransOrd α] [LawfulEqOrd α] [LawfulBEq β] (h₁ : m₁.WF) (h₂ : m₂.WF) : beq m₁ m₂ = true → m₁.Equiv m₂

theorem Std.DTreeMap.Internal.Impl.Const.beq_iff_equiv {α : Type u} {instOrd : Ord α} {β : Type v} [BEq β] {m₁ m₂ : Impl α fun (x : α) => β} [TransOrd α] [LawfulEqOrd α] [LawfulBEq β] (h₁ : m₁.WF) (h₂ : m₂.WF) : beq m₁ m₂ = true ↔ m₁.Equiv m₂

theorem Std.DTreeMap.Internal.Impl.Const.Equiv.beq_congr {α : Type u} {instOrd : Ord α} {β : Type v} [BEq β] {m₁ m₂ : Impl α fun (x : α) => β} [TransOrd α] {m₃ m₄ : Impl α fun (x : α) => β} (h₁ : m₁.WF) (h₂ : m₂.WF) (h₃ : m₃.WF) (h₄ : m₄.WF) : m₁.Equiv m₃ → m₂.Equiv m₄ → Const.beq m₁ m₂ = Const.beq m₃ m₄

theorem Std.DTreeMap.Internal.Impl.contains_diff {α : Type u} {β : α → Type v} {instOrd : Ord α} {m₁ m₂ : Impl α β} [TransOrd α] (h₁ : m₁.WF) (h₂ : m₂.WF) {k : α} : contains k (m₁.diff m₂ ⋯) = (contains k m₁ && !contains k m₂)

theorem Std.DTreeMap.Internal.Impl.contains_diff! {α : Type u} {β : α → Type v} {instOrd : Ord α} {m₁ m₂ : Impl α β} [TransOrd α] (h₁ : m₁.WF) (h₂ : m₂.WF) {k : α} : contains k (m₁.diff! m₂) = (contains k m₁ && !contains k m₂)

theorem Std.DTreeMap.Internal.Impl.contains_diff_iff {α : Type u} {β : α → Type v} {instOrd : Ord α} {m₁ m₂ : Impl α β} [TransOrd α] (h₁ : m₁.WF) (h₂ : m₂.WF) {k : α} : contains k (m₁.diff m₂ ⋯) = true ↔ contains k m₁ = true ∧ ¬contains k m₂ = true

theorem Std.DTreeMap.Internal.Impl.contains_diff!_iff {α : Type u} {β : α → Type v} {instOrd : Ord α} {m₁ m₂ : Impl α β} [TransOrd α] (h₁ : m₁.WF) (h₂ : m₂.WF) {k : α} : contains k (m₁.diff! m₂) = true ↔ contains k m₁ = true ∧ ¬contains k m₂ = true

theorem Std.DTreeMap.Internal.Impl.contains_diff_eq_false_of_contains_eq_false_left {α : Type u} {β : α → Type v} {instOrd : Ord α} {m₁ m₂ : Impl α β} [TransOrd α] (h₁ : m₁.WF) (h₂ : m₂.WF) {k : α} (h : contains k m₁ = false) : contains k (m₁.diff m₂ ⋯) = false

theorem Std.DTreeMap.Internal.Impl.contains_diff!_eq_false_of_contains_eq_false_left {α : Type u} {β : α → Type v} {instOrd : Ord α} {m₁ m₂ : Impl α β} [TransOrd α] (h₁ : m₁.WF) (h₂ : m₂.WF) {k : α} (h : contains k m₁ = false) : contains k (m₁.diff! m₂) = false

theorem Std.DTreeMap.Internal.Impl.contains_diff_eq_false_of_contains_right {α : Type u} {β : α → Type v} {instOrd : Ord α} {m₁ m₂ : Impl α β} [TransOrd α] (h₁ : m₁.WF) (h₂ : m₂.WF) {k : α} (h : contains k m₂ = true) : contains k (m₁.diff m₂ ⋯) = false

theorem Std.DTreeMap.Internal.Impl.contains_diff!_eq_false_of_contains_right {α : Type u} {β : α → Type v} {instOrd : Ord α} {m₁ m₂ : Impl α β} [TransOrd α] (h₁ : m₁.WF) (h₂ : m₂.WF) {k : α} (h : contains k m₂ = true) : contains k (m₁.diff! m₂) = false

theorem Std.DTreeMap.Internal.Impl.Equiv.diff_left {α : Type u} {β : α → Type v} {instOrd : Ord α} {m₁ m₂ m₃ : Impl α β} [TransOrd α] (h₁ : m₁.WF) (h₂ : m₂.WF) (h₃ : m₃.WF) (equiv : m₁.Equiv m₂) : (m₁.diff m₃ ⋯).Equiv (m₂.diff m₃ ⋯)

theorem Std.DTreeMap.Internal.Impl.Equiv.diff!_left {α : Type u} {β : α → Type v} {instOrd : Ord α} {m₁ m₂ m₃ : Impl α β} [TransOrd α] (h₁ : m₁.WF) (h₂ : m₂.WF) (h₃ : m₃.WF) (equiv : m₁.Equiv m₂) : (m₁.diff! m₃).Equiv (m₂.diff! m₃)

theorem Std.DTreeMap.Internal.Impl.Equiv.diff_right {α : Type u} {β : α → Type v} {instOrd : Ord α} {m₁ m₂ m₃ : Impl α β} [TransOrd α] (h₁ : m₁.WF) (h₂ : m₂.WF) (h₃ : m₃.WF) (equiv : m₂.Equiv m₃) : (m₁.diff m₂ ⋯).Equiv (m₁.diff m₃ ⋯)

theorem Std.DTreeMap.Internal.Impl.Equiv.diff!_right {α : Type u} {β : α → Type v} {instOrd : Ord α} {m₁ m₂ m₃ : Impl α β} [TransOrd α] (h₁ : m₁.WF) (h₂ : m₂.WF) (h₃ : m₃.WF) (equiv : m₂.Equiv m₃) : (m₁.diff! m₂).Equiv (m₁.diff! m₃)

theorem Std.DTreeMap.Internal.Impl.Equiv.diff_congr {α : Type u} {β : α → Type v} {instOrd : Ord α} {m₁ m₂ m₃ m₄ : Impl α β} [TransOrd α] (h₁ : m₁.WF) (h₂ : m₂.WF) (h₃ : m₃.WF) (h₄ : m₄.WF) (equiv₁ : m₁.Equiv m₃) (equiv₂ : m₂.Equiv m₄) : (m₁.diff m₂ ⋯).Equiv (m₃.diff m₄ ⋯)

theorem Std.DTreeMap.Internal.Impl.Equiv.diff!_congr {α : Type u} {β : α → Type v} {instOrd : Ord α} {m₁ m₂ m₃ m₄ : Impl α β} [TransOrd α] (h₁ : m₁.WF) (h₂ : m₂.WF) (h₃ : m₃.WF) (h₄ : m₄.WF) (equiv₁ : m₁.Equiv m₃) (equiv₂ : m₂.Equiv m₄) : (m₁.diff! m₂).Equiv (m₃.diff! m₄)

theorem Std.DTreeMap.Internal.Impl.get?_diff {α : Type u} {β : α → Type v} {instOrd : Ord α} {m₁ m₂ : Impl α β} [TransOrd α] [LawfulEqOrd α] (h₁ : m₁.WF) (h₂ : m₂.WF) {k : α} : (m₁.diff m₂ ⋯).get? k = if contains k m₂ = true then none else m₁.get? k

theorem Std.DTreeMap.Internal.Impl.get?_diff! {α : Type u} {β : α → Type v} {instOrd : Ord α} {m₁ m₂ : Impl α β} [TransOrd α] [LawfulEqOrd α] (h₁ : m₁.WF) (h₂ : m₂.WF) {k : α} : (m₁.diff! m₂).get? k = if contains k m₂ = true then none else m₁.get? k

theorem Std.DTreeMap.Internal.Impl.get?_diff_of_contains_eq_false_right {α : Type u} {β : α → Type v} {instOrd : Ord α} {m₁ m₂ : Impl α β} [TransOrd α] [LawfulEqOrd α] (h₁ : m₁.WF) (h₂ : m₂.WF) {k : α} (h : contains k m₂ = false) : (m₁.diff m₂ ⋯).get? k = m₁.get? k

theorem Std.DTreeMap.Internal.Impl.get?_diff!_of_contains_eq_false_right {α : Type u} {β : α → Type v} {instOrd : Ord α} {m₁ m₂ : Impl α β} [TransOrd α] [LawfulEqOrd α] (h₁ : m₁.WF) (h₂ : m₂.WF) {k : α} (h : contains k m₂ = false) : (m₁.diff! m₂).get? k = m₁.get? k

theorem Std.DTreeMap.Internal.Impl.get?_diff_of_contains_eq_false_left {α : Type u} {β : α → Type v} {instOrd : Ord α} {m₁ m₂ : Impl α β} [TransOrd α] [LawfulEqOrd α] (h₁ : m₁.WF) (h₂ : m₂.WF) {k : α} (h : contains k m₁ = false) : (m₁.diff m₂ ⋯).get? k = none

theorem Std.DTreeMap.Internal.Impl.get?_diff!_of_contains_eq_false_left {α : Type u} {β : α → Type v} {instOrd : Ord α} {m₁ m₂ : Impl α β} [TransOrd α] [LawfulEqOrd α] (h₁ : m₁.WF) (h₂ : m₂.WF) {k : α} (h : contains k m₁ = false) : (m₁.diff! m₂).get? k = none

theorem Std.DTreeMap.Internal.Impl.get?_diff_of_contains_right {α : Type u} {β : α → Type v} {instOrd : Ord α} {m₁ m₂ : Impl α β} [TransOrd α] [LawfulEqOrd α] (h₁ : m₁.WF) (h₂ : m₂.WF) {k : α} (h : contains k m₂ = true) : (m₁.diff m₂ ⋯).get? k = none

theorem Std.DTreeMap.Internal.Impl.get?_diff!_of_contains_right {α : Type u} {β : α → Type v} {instOrd : Ord α} {m₁ m₂ : Impl α β} [TransOrd α] [LawfulEqOrd α] (h₁ : m₁.WF) (h₂ : m₂.WF) {k : α} (h : contains k m₂ = true) : (m₁.diff! m₂).get? k = none

theorem Std.DTreeMap.Internal.Impl.get_diff {α : Type u} {β : α → Type v} {instOrd : Ord α} {m₁ m₂ : Impl α β} [TransOrd α] [LawfulEqOrd α] (h₁ : m₁.WF) (h₂ : m₂.WF) {k : α} {h_contains : contains k (m₁.diff m₂ ⋯) = true} : (m₁.diff m₂ ⋯).get k h_contains = m₁.get k ⋯

theorem Std.DTreeMap.Internal.Impl.get_diff! {α : Type u} {β : α → Type v} {instOrd : Ord α} {m₁ m₂ : Impl α β} [TransOrd α] [LawfulEqOrd α] (h₁ : m₁.WF) (h₂ : m₂.WF) {k : α} {h_contains : contains k (m₁.diff! m₂) = true} : (m₁.diff! m₂).get k h_contains = m₁.get k ⋯

theorem Std.DTreeMap.Internal.Impl.getD_diff {α : Type u} {β : α → Type v} {instOrd : Ord α} {m₁ m₂ : Impl α β} [TransOrd α] [LawfulEqOrd α] (h₁ : m₁.WF) (h₂ : m₂.WF) {k : α} {fallback : β k} : (m₁.diff m₂ ⋯).getD k fallback = if contains k m₂ = true then fallback else m₁.getD k fallback

theorem Std.DTreeMap.Internal.Impl.getD_diff! {α : Type u} {β : α → Type v} {instOrd : Ord α} {m₁ m₂ : Impl α β} [TransOrd α] [LawfulEqOrd α] (h₁ : m₁.WF) (h₂ : m₂.WF) {k : α} {fallback : β k} : (m₁.diff! m₂).getD k fallback = if contains k m₂ = true then fallback else m₁.getD k fallback

theorem Std.DTreeMap.Internal.Impl.getD_diff_of_contains_eq_false_right {α : Type u} {β : α → Type v} {instOrd : Ord α} {m₁ m₂ : Impl α β} [TransOrd α] [LawfulEqOrd α] (h₁ : m₁.WF) (h₂ : m₂.WF) {k : α} {fallback : β k} (h : contains k m₂ = false) : (m₁.diff m₂ ⋯).getD k fallback = m₁.getD k fallback

theorem Std.DTreeMap.Internal.Impl.getD_diff!_of_contains_eq_false_right {α : Type u} {β : α → Type v} {instOrd : Ord α} {m₁ m₂ : Impl α β} [TransOrd α] [LawfulEqOrd α] (h₁ : m₁.WF) (h₂ : m₂.WF) {k : α} {fallback : β k} (h : contains k m₂ = false) : (m₁.diff! m₂).getD k fallback = m₁.getD k fallback

theorem Std.DTreeMap.Internal.Impl.getD_diff_of_contains_right {α : Type u} {β : α → Type v} {instOrd : Ord α} {m₁ m₂ : Impl α β} [TransOrd α] [LawfulEqOrd α] (h₁ : m₁.WF) (h₂ : m₂.WF) {k : α} {fallback : β k} (h : contains k m₂ = true) : (m₁.diff m₂ ⋯).getD k fallback = fallback

theorem Std.DTreeMap.Internal.Impl.getD_diff!_of_contains_right {α : Type u} {β : α → Type v} {instOrd : Ord α} {m₁ m₂ : Impl α β} [TransOrd α] [LawfulEqOrd α] (h₁ : m₁.WF) (h₂ : m₂.WF) {k : α} {fallback : β k} (h : contains k m₂ = true) : (m₁.diff! m₂).getD k fallback = fallback

theorem Std.DTreeMap.Internal.Impl.getD_diff_of_contains_eq_false_left {α : Type u} {β : α → Type v} {instOrd : Ord α} {m₁ m₂ : Impl α β} [TransOrd α] [LawfulEqOrd α] (h₁ : m₁.WF) (h₂ : m₂.WF) {k : α} {fallback : β k} (h : contains k m₁ = false) : (m₁.diff m₂ ⋯).getD k fallback = fallback

theorem Std.DTreeMap.Internal.Impl.getD_diff!_of_contains_eq_false_left {α : Type u} {β : α → Type v} {instOrd : Ord α} {m₁ m₂ : Impl α β} [TransOrd α] [LawfulEqOrd α] (h₁ : m₁.WF) (h₂ : m₂.WF) {k : α} {fallback : β k} (h : contains k m₁ = false) : (m₁.diff! m₂).getD k fallback = fallback

theorem Std.DTreeMap.Internal.Impl.get!_diff {α : Type u} {β : α → Type v} {instOrd : Ord α} {m₁ m₂ : Impl α β} [TransOrd α] [LawfulEqOrd α] (h₁ : m₁.WF) (h₂ : m₂.WF) {k : α} [Inhabited (β k)] : (m₁.diff m₂ ⋯).get! k = if contains k m₂ = true then default else m₁.get! k

theorem Std.DTreeMap.Internal.Impl.get!_diff! {α : Type u} {β : α → Type v} {instOrd : Ord α} {m₁ m₂ : Impl α β} [TransOrd α] [LawfulEqOrd α] (h₁ : m₁.WF) (h₂ : m₂.WF) {k : α} [Inhabited (β k)] : (m₁.diff! m₂).get! k = if contains k m₂ = true then default else m₁.get! k

theorem Std.DTreeMap.Internal.Impl.get!_diff_of_contains_eq_false_right {α : Type u} {β : α → Type v} {instOrd : Ord α} {m₁ m₂ : Impl α β} [TransOrd α] [LawfulEqOrd α] (h₁ : m₁.WF) (h₂ : m₂.WF) {k : α} [Inhabited (β k)] (h : contains k m₂ = false) : (m₁.diff m₂ ⋯).get! k = m₁.get! k

theorem Std.DTreeMap.Internal.Impl.get!_diff!_of_contains_eq_false_right {α : Type u} {β : α → Type v} {instOrd : Ord α} {m₁ m₂ : Impl α β} [TransOrd α] [LawfulEqOrd α] (h₁ : m₁.WF) (h₂ : m₂.WF) {k : α} [Inhabited (β k)] (h : contains k m₂ = false) : (m₁.diff! m₂).get! k = m₁.get! k

theorem Std.DTreeMap.Internal.Impl.get!_diff_of_contains_right {α : Type u} {β : α → Type v} {instOrd : Ord α} {m₁ m₂ : Impl α β} [TransOrd α] [LawfulEqOrd α] (h₁ : m₁.WF) (h₂ : m₂.WF) {k : α} [Inhabited (β k)] (h : contains k m₂ = true) : (m₁.diff m₂ ⋯).get! k = default

theorem Std.DTreeMap.Internal.Impl.get!_diff!_of_contains_right {α : Type u} {β : α → Type v} {instOrd : Ord α} {m₁ m₂ : Impl α β} [TransOrd α] [LawfulEqOrd α] (h₁ : m₁.WF) (h₂ : m₂.WF) {k : α} [Inhabited (β k)] (h : contains k m₂ = true) : (m₁.diff! m₂).get! k = default

theorem Std.DTreeMap.Internal.Impl.get!_diff_of_contains_eq_false_left {α : Type u} {β : α → Type v} {instOrd : Ord α} {m₁ m₂ : Impl α β} [TransOrd α] [LawfulEqOrd α] (h₁ : m₁.WF) (h₂ : m₂.WF) {k : α} [Inhabited (β k)] (h : contains k m₁ = false) : (m₁.diff m₂ ⋯).get! k = default

theorem Std.DTreeMap.Internal.Impl.get!_diff!_of_contains_eq_false_left {α : Type u} {β : α → Type v} {instOrd : Ord α} {m₁ m₂ : Impl α β} [TransOrd α] [LawfulEqOrd α] (h₁ : m₁.WF) (h₂ : m₂.WF) {k : α} [Inhabited (β k)] (h : contains k m₁ = false) : (m₁.diff! m₂).get! k = default

theorem Std.DTreeMap.Internal.Impl.getKey?_diff {α : Type u} {β : α → Type v} {instOrd : Ord α} {m₁ m₂ : Impl α β} [TransOrd α] (h₁ : m₁.WF) (h₂ : m₂.WF) {k : α} : (m₁.diff m₂ ⋯).getKey? k = if contains k m₂ = true then none else m₁.getKey? k

theorem Std.DTreeMap.Internal.Impl.getKey?_diff! {α : Type u} {β : α → Type v} {instOrd : Ord α} {m₁ m₂ : Impl α β} [TransOrd α] (h₁ : m₁.WF) (h₂ : m₂.WF) {k : α} : (m₁.diff! m₂).getKey? k = if contains k m₂ = true then none else m₁.getKey? k

theorem Std.DTreeMap.Internal.Impl.getKey?_diff_of_contains_eq_false_right {α : Type u} {β : α → Type v} {instOrd : Ord α} {m₁ m₂ : Impl α β} [TransOrd α] (h₁ : m₁.WF) (h₂ : m₂.WF) {k : α} (h : contains k m₂ = false) : (m₁.diff m₂ ⋯).getKey? k = m₁.getKey? k

theorem Std.DTreeMap.Internal.Impl.getKey?_diff!_of_contains_eq_false_right {α : Type u} {β : α → Type v} {instOrd : Ord α} {m₁ m₂ : Impl α β} [TransOrd α] (h₁ : m₁.WF) (h₂ : m₂.WF) {k : α} (h : contains k m₂ = false) : (m₁.diff! m₂).getKey? k = m₁.getKey? k

theorem Std.DTreeMap.Internal.Impl.getKey?_diff_of_contains_eq_false_left {α : Type u} {β : α → Type v} {instOrd : Ord α} {m₁ m₂ : Impl α β} [TransOrd α] (h₁ : m₁.WF) (h₂ : m₂.WF) {k : α} (h : contains k m₁ = false) : (m₁.diff m₂ ⋯).getKey? k = none

theorem Std.DTreeMap.Internal.Impl.getKey?_diff!_of_contains_eq_false_left {α : Type u} {β : α → Type v} {instOrd : Ord α} {m₁ m₂ : Impl α β} [TransOrd α] (h₁ : m₁.WF) (h₂ : m₂.WF) {k : α} (h : contains k m₁ = false) : (m₁.diff! m₂).getKey? k = none

theorem Std.DTreeMap.Internal.Impl.getKey?_diff_of_contains_right {α : Type u} {β : α → Type v} {instOrd : Ord α} {m₁ m₂ : Impl α β} [TransOrd α] (h₁ : m₁.WF) (h₂ : m₂.WF) {k : α} (h : contains k m₂ = true) : (m₁.diff m₂ ⋯).getKey? k = none

theorem Std.DTreeMap.Internal.Impl.getKey?_diff!_of_contains_right {α : Type u} {β : α → Type v} {instOrd : Ord α} {m₁ m₂ : Impl α β} [TransOrd α] (h₁ : m₁.WF) (h₂ : m₂.WF) {k : α} (h : contains k m₂ = true) : (m₁.diff! m₂).getKey? k = none

theorem Std.DTreeMap.Internal.Impl.getKey_diff {α : Type u} {β : α → Type v} {instOrd : Ord α} {m₁ m₂ : Impl α β} [TransOrd α] (h₁ : m₁.WF) (h₂ : m₂.WF) {k : α} {h_contains : contains k (m₁.diff m₂ ⋯) = true} : (m₁.diff m₂ ⋯).getKey k h_contains = m₁.getKey k ⋯

theorem Std.DTreeMap.Internal.Impl.getKey_diff! {α : Type u} {β : α → Type v} {instOrd : Ord α} {m₁ m₂ : Impl α β} [TransOrd α] (h₁ : m₁.WF) (h₂ : m₂.WF) {k : α} {h_contains : contains k (m₁.diff! m₂) = true} : (m₁.diff! m₂).getKey k h_contains = m₁.getKey k ⋯

theorem Std.DTreeMap.Internal.Impl.getKeyD_diff {α : Type u} {β : α → Type v} {instOrd : Ord α} {m₁ m₂ : Impl α β} [TransOrd α] (h₁ : m₁.WF) (h₂ : m₂.WF) {k fallback : α} : (m₁.diff m₂ ⋯).getKeyD k fallback = if contains k m₂ = true then fallback else m₁.getKeyD k fallback

theorem Std.DTreeMap.Internal.Impl.getKeyD_diff! {α : Type u} {β : α → Type v} {instOrd : Ord α} {m₁ m₂ : Impl α β} [TransOrd α] (h₁ : m₁.WF) (h₂ : m₂.WF) {k fallback : α} : (m₁.diff! m₂).getKeyD k fallback = if contains k m₂ = true then fallback else m₁.getKeyD k fallback

theorem Std.DTreeMap.Internal.Impl.getKeyD_diff_of_contains_eq_false_right {α : Type u} {β : α → Type v} {instOrd : Ord α} {m₁ m₂ : Impl α β} [TransOrd α] (h₁ : m₁.WF) (h₂ : m₂.WF) {k fallback : α} (h : contains k m₂ = false) : (m₁.diff m₂ ⋯).getKeyD k fallback = m₁.getKeyD k fallback

theorem Std.DTreeMap.Internal.Impl.getKeyD_diff!_of_contains_eq_false_right {α : Type u} {β : α → Type v} {instOrd : Ord α} {m₁ m₂ : Impl α β} [TransOrd α] (h₁ : m₁.WF) (h₂ : m₂.WF) {k fallback : α} (h : contains k m₂ = false) : (m₁.diff! m₂).getKeyD k fallback = m₁.getKeyD k fallback

theorem Std.DTreeMap.Internal.Impl.getKeyD_diff_of_contains_right {α : Type u} {β : α → Type v} {instOrd : Ord α} {m₁ m₂ : Impl α β} [TransOrd α] (h₁ : m₁.WF) (h₂ : m₂.WF) {k fallback : α} (h : contains k m₂ = true) : (m₁.diff m₂ ⋯).getKeyD k fallback = fallback

theorem Std.DTreeMap.Internal.Impl.getKeyD_diff!_of_contains_right {α : Type u} {β : α → Type v} {instOrd : Ord α} {m₁ m₂ : Impl α β} [TransOrd α] (h₁ : m₁.WF) (h₂ : m₂.WF) {k fallback : α} (h : contains k m₂ = true) : (m₁.diff! m₂).getKeyD k fallback = fallback

theorem Std.DTreeMap.Internal.Impl.getKeyD_diff_of_contains_eq_false_left {α : Type u} {β : α → Type v} {instOrd : Ord α} {m₁ m₂ : Impl α β} [TransOrd α] (h₁ : m₁.WF) (h₂ : m₂.WF) {k fallback : α} (h : contains k m₁ = false) : (m₁.diff m₂ ⋯).getKeyD k fallback = fallback

theorem Std.DTreeMap.Internal.Impl.getKeyD_diff!_of_contains_eq_false_left {α : Type u} {β : α → Type v} {instOrd : Ord α} {m₁ m₂ : Impl α β} [TransOrd α] (h₁ : m₁.WF) (h₂ : m₂.WF) {k fallback : α} (h : contains k m₁ = false) : (m₁.diff! m₂).getKeyD k fallback = fallback

theorem Std.DTreeMap.Internal.Impl.getKey!_diff {α : Type u} {β : α → Type v} {instOrd : Ord α} {m₁ m₂ : Impl α β} [Inhabited α] [TransOrd α] (h₁ : m₁.WF) (h₂ : m₂.WF) {k : α} : (m₁.diff m₂ ⋯).getKey! k = if contains k m₂ = true then default else m₁.getKey! k

theorem Std.DTreeMap.Internal.Impl.getKey!_diff! {α : Type u} {β : α → Type v} {instOrd : Ord α} {m₁ m₂ : Impl α β} [Inhabited α] [TransOrd α] (h₁ : m₁.WF) (h₂ : m₂.WF) {k : α} : (m₁.diff! m₂).getKey! k = if contains k m₂ = true then default else m₁.getKey! k

theorem Std.DTreeMap.Internal.Impl.getKey!_diff_of_contains_eq_false_right {α : Type u} {β : α → Type v} {instOrd : Ord α} {m₁ m₂ : Impl α β} [Inhabited α] [TransOrd α] (h₁ : m₁.WF) (h₂ : m₂.WF) {k : α} (h : contains k m₂ = false) : (m₁.diff m₂ ⋯).getKey! k = m₁.getKey! k

theorem Std.DTreeMap.Internal.Impl.getKey!_diff!_of_contains_eq_false_right {α : Type u} {β : α → Type v} {instOrd : Ord α} {m₁ m₂ : Impl α β} [Inhabited α] [TransOrd α] (h₁ : m₁.WF) (h₂ : m₂.WF) {k : α} (h : contains k m₂ = false) : (m₁.diff! m₂).getKey! k = m₁.getKey! k

theorem Std.DTreeMap.Internal.Impl.getKey!_diff_of_contains_right {α : Type u} {β : α → Type v} {instOrd : Ord α} {m₁ m₂ : Impl α β} [Inhabited α] [TransOrd α] (h₁ : m₁.WF) (h₂ : m₂.WF) {k : α} (h : contains k m₂ = true) : (m₁.diff m₂ ⋯).getKey! k = default

theorem Std.DTreeMap.Internal.Impl.getKey!_diff!_of_contains_right {α : Type u} {β : α → Type v} {instOrd : Ord α} {m₁ m₂ : Impl α β} [Inhabited α] [TransOrd α] (h₁ : m₁.WF) (h₂ : m₂.WF) {k : α} (h : contains k m₂ = true) : (m₁.diff! m₂).getKey! k = default

theorem Std.DTreeMap.Internal.Impl.getKey!_diff_of_contains_eq_false_left {α : Type u} {β : α → Type v} {instOrd : Ord α} {m₁ m₂ : Impl α β} [Inhabited α] [TransOrd α] (h₁ : m₁.WF) (h₂ : m₂.WF) {k : α} (h : contains k m₁ = false) : (m₁.diff m₂ ⋯).getKey! k = default

theorem Std.DTreeMap.Internal.Impl.getKey!_diff!_of_contains_eq_false_left {α : Type u} {β : α → Type v} {instOrd : Ord α} {m₁ m₂ : Impl α β} [Inhabited α] [TransOrd α] (h₁ : m₁.WF) (h₂ : m₂.WF) {k : α} (h : contains k m₁ = false) : (m₁.diff! m₂).getKey! k = default

theorem Std.DTreeMap.Internal.Impl.size_diff_le_size_left {α : Type u} {β : α → Type v} {instOrd : Ord α} {m₁ m₂ : Impl α β} [TransOrd α] (h₁ : m₁.WF) (h₂ : m₂.WF) : (m₁.diff m₂ ⋯).size ≤ m₁.size

theorem Std.DTreeMap.Internal.Impl.size_diff!_le_size_left {α : Type u} {β : α → Type v} {instOrd : Ord α} {m₁ m₂ : Impl α β} [TransOrd α] (h₁ : m₁.WF) (h₂ : m₂.WF) : (m₁.diff! m₂).size ≤ m₁.size

theorem Std.DTreeMap.Internal.Impl.size_diff_eq_size_left {α : Type u} {β : α → Type v} {instOrd : Ord α} {m₁ m₂ : Impl α β} [TransOrd α] (h₁ : m₁.WF) (h₂ : m₂.WF) (h : ∀ (a : α), contains a m₁ = true → contains a m₂ = false) : (m₁.diff m₂ ⋯).size = m₁.size

theorem Std.DTreeMap.Internal.Impl.size_diff!_eq_size_left {α : Type u} {β : α → Type v} {instOrd : Ord α} {m₁ m₂ : Impl α β} [TransOrd α] (h₁ : m₁.WF) (h₂ : m₂.WF) (h : ∀ (a : α), contains a m₁ = true → contains a m₂ = false) : (m₁.diff! m₂).size = m₁.size

theorem Std.DTreeMap.Internal.Impl.size_diff_add_size_inter_eq_size_left {α : Type u} {β : α → Type v} {instOrd : Ord α} {m₁ m₂ : Impl α β} [TransOrd α] (h₁ : m₁.WF) (h₂ : m₂.WF) : (m₁.diff m₂ ⋯).size + (m₁.inter m₂ ⋯).size = m₁.size

theorem Std.DTreeMap.Internal.Impl.size_diff!_add_size_inter!_eq_size_left {α : Type u} {β : α → Type v} {instOrd : Ord α} {m₁ m₂ : Impl α β} [TransOrd α] (h₁ : m₁.WF) (h₂ : m₂.WF) : (m₁.diff! m₂).size + (m₁.inter! m₂).size = m₁.size

@[simp]

theorem Std.DTreeMap.Internal.Impl.isEmpty_diff_left {α : Type u} {β : α → Type v} {instOrd : Ord α} {m₁ m₂ : Impl α β} [TransOrd α] (h₁ : m₁.WF) (h₂ : m₂.WF) (h : m₁.isEmpty = true) : (m₁.diff m₂ ⋯).isEmpty = true

@[simp]

theorem Std.DTreeMap.Internal.Impl.isEmpty_diff!_left {α : Type u} {β : α → Type v} {instOrd : Ord α} {m₁ m₂ : Impl α β} [TransOrd α] (h₁ : m₁.WF) (h₂ : m₂.WF) (h : m₁.isEmpty = true) : (m₁.diff! m₂).isEmpty = true

theorem Std.DTreeMap.Internal.Impl.isEmpty_diff_iff {α : Type u} {β : α → Type v} {instOrd : Ord α} {m₁ m₂ : Impl α β} [TransOrd α] (h₁ : m₁.WF) (h₂ : m₂.WF) : (m₁.diff m₂ ⋯).isEmpty = true ↔ ∀ (k : α), contains k m₁ = true → contains k m₂ = true

theorem Std.DTreeMap.Internal.Impl.isEmpty_diff!_iff {α : Type u} {β : α → Type v} {instOrd : Ord α} {m₁ m₂ : Impl α β} [TransOrd α] (h₁ : m₁.WF) (h₂ : m₂.WF) : (m₁.diff! m₂).isEmpty = true ↔ ∀ (k : α), contains k m₁ = true → contains k m₂ = true

theorem Std.DTreeMap.Internal.Impl.Const.get?_diff {α : Type u} {instOrd : Ord α} {β : Type v} {m₁ m₂ : Impl α fun (x : α) => β} [TransOrd α] (h₁ : m₁.WF) (h₂ : m₂.WF) {k : α} : get? (m₁.diff m₂ ⋯) k = if contains k m₂ = true then none else get? m₁ k

theorem Std.DTreeMap.Internal.Impl.Const.get?_diff! {α : Type u} {instOrd : Ord α} {β : Type v} {m₁ m₂ : Impl α fun (x : α) => β} [TransOrd α] (h₁ : m₁.WF) (h₂ : m₂.WF) {k : α} : get? (m₁.diff! m₂) k = if contains k m₂ = true then none else get? m₁ k

theorem Std.DTreeMap.Internal.Impl.Const.get?_diff_of_contains_eq_false_right {α : Type u} {instOrd : Ord α} {β : Type v} {m₁ m₂ : Impl α fun (x : α) => β} [TransOrd α] (h₁ : m₁.WF) (h₂ : m₂.WF) {k : α} (h : contains k m₂ = false) : get? (m₁.diff m₂ ⋯) k = get? m₁ k

theorem Std.DTreeMap.Internal.Impl.Const.get?_diff!_of_contains_eq_false_right {α : Type u} {instOrd : Ord α} {β : Type v} {m₁ m₂ : Impl α fun (x : α) => β} [TransOrd α] (h₁ : m₁.WF) (h₂ : m₂.WF) {k : α} (h : contains k m₂ = false) : get? (m₁.diff! m₂) k = get? m₁ k

theorem Std.DTreeMap.Internal.Impl.Const.get?_diff_of_contains_eq_false_left {α : Type u} {instOrd : Ord α} {β : Type v} {m₁ m₂ : Impl α fun (x : α) => β} [TransOrd α] (h₁ : m₁.WF) (h₂ : m₂.WF) {k : α} (h : contains k m₁ = false) : get? (m₁.diff m₂ ⋯) k = none

theorem Std.DTreeMap.Internal.Impl.Const.get?_diff!_of_contains_eq_false_left {α : Type u} {instOrd : Ord α} {β : Type v} {m₁ m₂ : Impl α fun (x : α) => β} [TransOrd α] (h₁ : m₁.WF) (h₂ : m₂.WF) {k : α} (h : contains k m₁ = false) : get? (m₁.diff! m₂) k = none

theorem Std.DTreeMap.Internal.Impl.Const.get?_diff_of_contains_right {α : Type u} {instOrd : Ord α} {β : Type v} {m₁ m₂ : Impl α fun (x : α) => β} [TransOrd α] (h₁ : m₁.WF) (h₂ : m₂.WF) {k : α} (h : contains k m₂ = true) : get? (m₁.diff m₂ ⋯) k = none

theorem Std.DTreeMap.Internal.Impl.Const.get?_diff!_of_contains_right {α : Type u} {instOrd : Ord α} {β : Type v} {m₁ m₂ : Impl α fun (x : α) => β} [TransOrd α] (h₁ : m₁.WF) (h₂ : m₂.WF) {k : α} (h : contains k m₂ = true) : get? (m₁.diff! m₂) k = none

theorem Std.DTreeMap.Internal.Impl.Const.get_diff {α : Type u} {instOrd : Ord α} {β : Type v} {m₁ m₂ : Impl α fun (x : α) => β} [TransOrd α] (h₁ : m₁.WF) (h₂ : m₂.WF) {k : α} {h_contains : contains k (m₁.diff m₂ ⋯) = true} : get (m₁.diff m₂ ⋯) k h_contains = get m₁ k ⋯

theorem Std.DTreeMap.Internal.Impl.Const.get_diff! {α : Type u} {instOrd : Ord α} {β : Type v} {m₁ m₂ : Impl α fun (x : α) => β} [TransOrd α] (h₁ : m₁.WF) (h₂ : m₂.WF) {k : α} {h_contains : contains k (m₁.diff! m₂) = true} : get (m₁.diff! m₂) k h_contains = get m₁ k ⋯

theorem Std.DTreeMap.Internal.Impl.Const.getD_diff {α : Type u} {instOrd : Ord α} {β : Type v} {m₁ m₂ : Impl α fun (x : α) => β} [TransOrd α] (h₁ : m₁.WF) (h₂ : m₂.WF) {k : α} {fallback : β} : getD (m₁.diff m₂ ⋯) k fallback = if contains k m₂ = true then fallback else getD m₁ k fallback

theorem Std.DTreeMap.Internal.Impl.Const.getD_diff! {α : Type u} {instOrd : Ord α} {β : Type v} {m₁ m₂ : Impl α fun (x : α) => β} [TransOrd α] (h₁ : m₁.WF) (h₂ : m₂.WF) {k : α} {fallback : β} : getD (m₁.diff! m₂) k fallback = if contains k m₂ = true then fallback else getD m₁ k fallback

theorem Std.DTreeMap.Internal.Impl.Const.getD_diff_of_contains_eq_false_right {α : Type u} {instOrd : Ord α} {β : Type v} {m₁ m₂ : Impl α fun (x : α) => β} [TransOrd α] (h₁ : m₁.WF) (h₂ : m₂.WF) {k : α} {fallback : β} (h : contains k m₂ = false) : getD (m₁.diff m₂ ⋯) k fallback = getD m₁ k fallback

theorem Std.DTreeMap.Internal.Impl.Const.getD_diff!_of_contains_eq_false_right {α : Type u} {instOrd : Ord α} {β : Type v} {m₁ m₂ : Impl α fun (x : α) => β} [TransOrd α] (h₁ : m₁.WF) (h₂ : m₂.WF) {k : α} {fallback : β} (h : contains k m₂ = false) : getD (m₁.diff! m₂) k fallback = getD m₁ k fallback

theorem Std.DTreeMap.Internal.Impl.Const.getD_diff_of_contains_right {α : Type u} {instOrd : Ord α} {β : Type v} {m₁ m₂ : Impl α fun (x : α) => β} [TransOrd α] (h₁ : m₁.WF) (h₂ : m₂.WF) {k : α} {fallback : β} (h : contains k m₂ = true) : getD (m₁.diff m₂ ⋯) k fallback = fallback

theorem Std.DTreeMap.Internal.Impl.Const.getD_diff!_of_contains_right {α : Type u} {instOrd : Ord α} {β : Type v} {m₁ m₂ : Impl α fun (x : α) => β} [TransOrd α] (h₁ : m₁.WF) (h₂ : m₂.WF) {k : α} {fallback : β} (h : contains k m₂ = true) : getD (m₁.diff! m₂) k fallback = fallback

theorem Std.DTreeMap.Internal.Impl.Const.getD_diff_of_contains_eq_false_left {α : Type u} {instOrd : Ord α} {β : Type v} {m₁ m₂ : Impl α fun (x : α) => β} [TransOrd α] (h₁ : m₁.WF) (h₂ : m₂.WF) {k : α} {fallback : β} (h : contains k m₁ = false) : getD (m₁.diff m₂ ⋯) k fallback = fallback

theorem Std.DTreeMap.Internal.Impl.Const.getD_diff!_of_contains_eq_false_left {α : Type u} {instOrd : Ord α} {β : Type v} {m₁ m₂ : Impl α fun (x : α) => β} [TransOrd α] (h₁ : m₁.WF) (h₂ : m₂.WF) {k : α} {fallback : β} (h : contains k m₁ = false) : getD (m₁.diff! m₂) k fallback = fallback

theorem Std.DTreeMap.Internal.Impl.Const.get!_diff {α : Type u} {instOrd : Ord α} {β : Type v} {m₁ m₂ : Impl α fun (x : α) => β} [TransOrd α] [Inhabited β] (h₁ : m₁.WF) (h₂ : m₂.WF) {k : α} : get! (m₁.diff m₂ ⋯) k = if contains k m₂ = true then default else get! m₁ k

theorem Std.DTreeMap.Internal.Impl.Const.get!_diff! {α : Type u} {instOrd : Ord α} {β : Type v} {m₁ m₂ : Impl α fun (x : α) => β} [TransOrd α] [Inhabited β] (h₁ : m₁.WF) (h₂ : m₂.WF) {k : α} : get! (m₁.diff! m₂) k = if contains k m₂ = true then default else get! m₁ k

theorem Std.DTreeMap.Internal.Impl.Const.get!_diff_of_contains_eq_false_right {α : Type u} {instOrd : Ord α} {β : Type v} {m₁ m₂ : Impl α fun (x : α) => β} [TransOrd α] [Inhabited β] (h₁ : m₁.WF) (h₂ : m₂.WF) {k : α} (h : contains k m₂ = false) : get! (m₁.diff m₂ ⋯) k = get! m₁ k

theorem Std.DTreeMap.Internal.Impl.Const.get!_diff!_of_contains_eq_false_right {α : Type u} {instOrd : Ord α} {β : Type v} {m₁ m₂ : Impl α fun (x : α) => β} [TransOrd α] [Inhabited β] (h₁ : m₁.WF) (h₂ : m₂.WF) {k : α} (h : contains k m₂ = false) : get! (m₁.diff! m₂) k = get! m₁ k

theorem Std.DTreeMap.Internal.Impl.Const.get!_diff_of_contains_right {α : Type u} {instOrd : Ord α} {β : Type v} {m₁ m₂ : Impl α fun (x : α) => β} [TransOrd α] [Inhabited β] (h₁ : m₁.WF) (h₂ : m₂.WF) {k : α} (h : contains k m₂ = true) : get! (m₁.diff m₂ ⋯) k = default

theorem Std.DTreeMap.Internal.Impl.Const.get!_diff!_of_contains_right {α : Type u} {instOrd : Ord α} {β : Type v} {m₁ m₂ : Impl α fun (x : α) => β} [TransOrd α] [Inhabited β] (h₁ : m₁.WF) (h₂ : m₂.WF) {k : α} (h : contains k m₂ = true) : get! (m₁.diff! m₂) k = default

theorem Std.DTreeMap.Internal.Impl.Const.get!_diff_of_contains_eq_false_left {α : Type u} {instOrd : Ord α} {β : Type v} {m₁ m₂ : Impl α fun (x : α) => β} [TransOrd α] [Inhabited β] (h₁ : m₁.WF) (h₂ : m₂.WF) {k : α} (h : contains k m₁ = false) : get! (m₁.diff m₂ ⋯) k = default

theorem Std.DTreeMap.Internal.Impl.Const.get!_diff!_of_contains_eq_false_left {α : Type u} {instOrd : Ord α} {β : Type v} {m₁ m₂ : Impl α fun (x : α) => β} [TransOrd α] [Inhabited β] (h₁ : m₁.WF) (h₂ : m₂.WF) {k : α} (h : contains k m₁ = false) : get! (m₁.diff! m₂) k = default

theorem Std.DTreeMap.Internal.Impl.isEmpty_alter_eq_isEmpty_erase {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] [LawfulEqOrd α] (h : t.WF) {k : α} {f : Option (β k) → Option (β k)} : (alter k f t ⋯).impl.isEmpty = ((erase k t ⋯).impl.isEmpty && (f (t.get? k)).isNone)

theorem Std.DTreeMap.Internal.Impl.isEmpty_alter!_eq_isEmpty_erase {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] [LawfulEqOrd α] (h : t.WF) {k : α} {f : Option (β k) → Option (β k)} : (alter! k f t).isEmpty = ((erase! k t).isEmpty && (f (t.get? k)).isNone)

@[simp]

theorem Std.DTreeMap.Internal.Impl.isEmpty_alter {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] [LawfulEqOrd α] (h : t.WF) {k : α} {f : Option (β k) → Option (β k)} : (alter k f t ⋯).impl.isEmpty = ((t.isEmpty || t.size == 1 && contains k t) && (f (t.get? k)).isNone)

@[simp]

theorem Std.DTreeMap.Internal.Impl.isEmpty_alter! {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] [LawfulEqOrd α] (h : t.WF) {k : α} {f : Option (β k) → Option (β k)} : (alter! k f t).isEmpty = ((t.isEmpty || t.size == 1 && contains k t) && (f (t.get? k)).isNone)

theorem Std.DTreeMap.Internal.Impl.contains_alter {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] [LawfulEqOrd α] (h : t.WF) {k k' : α} {f : Option (β k) → Option (β k)} : contains k' (alter k f t ⋯).impl = if compare k k' = Ordering.eq then (f (t.get? k)).isSome else contains k' t

theorem Std.DTreeMap.Internal.Impl.contains_alter! {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] [LawfulEqOrd α] (h : t.WF) {k k' : α} {f : Option (β k) → Option (β k)} : contains k' (alter! k f t) = if compare k k' = Ordering.eq then (f (t.get? k)).isSome else contains k' t

theorem Std.DTreeMap.Internal.Impl.mem_alter {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] [LawfulEqOrd α] (h : t.WF) {k k' : α} {f : Option (β k) → Option (β k)} : k' ∈ (alter k f t ⋯).impl ↔ if compare k k' = Ordering.eq then (f (t.get? k)).isSome = true else k' ∈ t

theorem Std.DTreeMap.Internal.Impl.mem_alter! {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] [LawfulEqOrd α] (h : t.WF) {k k' : α} {f : Option (β k) → Option (β k)} : k' ∈ alter! k f t ↔ if compare k k' = Ordering.eq then (f (t.get? k)).isSome = true else k' ∈ t

theorem Std.DTreeMap.Internal.Impl.mem_alter_of_compare_eq {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] [LawfulEqOrd α] (h : t.WF) {k k' : α} {f : Option (β k) → Option (β k)} (he : compare k k' = Ordering.eq) : k' ∈ (alter k f t ⋯).impl ↔ (f (t.get? k)).isSome = true

theorem Std.DTreeMap.Internal.Impl.mem_alter!_of_compare_eq {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] [LawfulEqOrd α] (h : t.WF) {k k' : α} {f : Option (β k) → Option (β k)} (he : compare k k' = Ordering.eq) : k' ∈ alter! k f t ↔ (f (t.get? k)).isSome = true

@[simp]

theorem Std.DTreeMap.Internal.Impl.contains_alter_self {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] [LawfulEqOrd α] {k : α} (h : t.WF) {f : Option (β k) → Option (β k)} : contains k (alter k f t ⋯).impl = (f (t.get? k)).isSome

@[simp]

theorem Std.DTreeMap.Internal.Impl.contains_alter!_self {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] [LawfulEqOrd α] (h : t.WF) {k : α} {f : Option (β k) → Option (β k)} : contains k (alter! k f t) = (f (t.get? k)).isSome

@[simp]

theorem Std.DTreeMap.Internal.Impl.mem_alter_self {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] [LawfulEqOrd α] (h : t.WF) {k : α} {f : Option (β k) → Option (β k)} : k ∈ (alter k f t ⋯).impl ↔ (f (t.get? k)).isSome = true

@[simp]

theorem Std.DTreeMap.Internal.Impl.mem_alter!_self {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] [LawfulEqOrd α] (h : t.WF) {k : α} {f : Option (β k) → Option (β k)} : k ∈ alter! k f t ↔ (f (t.get? k)).isSome = true

theorem Std.DTreeMap.Internal.Impl.contains_alter_of_not_compare_eq {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] [LawfulEqOrd α] (h : t.WF) {k k' : α} {f : Option (β k) → Option (β k)} (he : ¬compare k k' = Ordering.eq) : contains k' (alter k f t ⋯).impl = contains k' t

theorem Std.DTreeMap.Internal.Impl.contains_alter!_of_not_compare_eq {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] [LawfulEqOrd α] (h : t.WF) {k k' : α} {f : Option (β k) → Option (β k)} (he : ¬compare k k' = Ordering.eq) : contains k' (alter! k f t) = contains k' t

theorem Std.DTreeMap.Internal.Impl.mem_alter_of_not_compare_eq {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] [LawfulEqOrd α] (h : t.WF) {k k' : α} {f : Option (β k) → Option (β k)} (he : ¬compare k k' = Ordering.eq) : k' ∈ (alter k f t ⋯).impl ↔ k' ∈ t

theorem Std.DTreeMap.Internal.Impl.mem_alter!_of_not_compare_eq {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] [LawfulEqOrd α] (h : t.WF) {k k' : α} {f : Option (β k) → Option (β k)} (he : ¬compare k k' = Ordering.eq) : k' ∈ alter! k f t ↔ k' ∈ t

theorem Std.DTreeMap.Internal.Impl.size_alter {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] [LawfulEqOrd α] (h : t.WF) {k : α} {f : Option (β k) → Option (β k)} : (alter k f t ⋯).impl.size = if k ∈ t ∧ (f (t.get? k)).isNone = true then t.size - 1 else if ¬k ∈ t ∧ (f (t.get? k)).isSome = true then t.size + 1 else t.size

theorem Std.DTreeMap.Internal.Impl.size_alter! {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] [LawfulEqOrd α] (h : t.WF) {k : α} {f : Option (β k) → Option (β k)} : (alter! k f t).size = if k ∈ t ∧ (f (t.get? k)).isNone = true then t.size - 1 else if ¬k ∈ t ∧ (f (t.get? k)).isSome = true then t.size + 1 else t.size

theorem Std.DTreeMap.Internal.Impl.size_alter_eq_add_one {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] [LawfulEqOrd α] (h : t.WF) {k : α} {f : Option (β k) → Option (β k)} (h₁ : ¬k ∈ t) (h₂ : (f (t.get? k)).isSome = true) : (alter k f t ⋯).impl.size = t.size + 1

theorem Std.DTreeMap.Internal.Impl.size_alter!_eq_add_one {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] [LawfulEqOrd α] (h : t.WF) {k : α} {f : Option (β k) → Option (β k)} (h₁ : ¬k ∈ t) (h₂ : (f (t.get? k)).isSome = true) : (alter! k f t).size = t.size + 1

theorem Std.DTreeMap.Internal.Impl.size_alter_eq_sub_one {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] [LawfulEqOrd α] (h : t.WF) {k : α} {f : Option (β k) → Option (β k)} (h₁ : k ∈ t) (h₂ : (f (t.get? k)).isNone = true) : (alter k f t ⋯).impl.size = t.size - 1

theorem Std.DTreeMap.Internal.Impl.size_alter!_eq_sub_one {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] [LawfulEqOrd α] (h : t.WF) {k : α} {f : Option (β k) → Option (β k)} (h₁ : k ∈ t) (h₂ : (f (t.get? k)).isNone = true) : (alter! k f t).size = t.size - 1

theorem Std.DTreeMap.Internal.Impl.size_alter_eq_self_of_not_mem {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] [LawfulEqOrd α] (h : t.WF) {k : α} {f : Option (β k) → Option (β k)} (h₁ : ¬k ∈ t) (h₂ : (f (t.get? k)).isNone = true) : (alter k f t ⋯).impl.size = t.size

theorem Std.DTreeMap.Internal.Impl.size_alter!_eq_self_of_not_mem {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] [LawfulEqOrd α] (h : t.WF) {k : α} {f : Option (β k) → Option (β k)} (h₁ : ¬k ∈ t) (h₂ : (f (t.get? k)).isNone = true) : (alter! k f t).size = t.size

theorem Std.DTreeMap.Internal.Impl.size_alter_eq_self_of_mem {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] [LawfulEqOrd α] (h : t.WF) {k : α} {f : Option (β k) → Option (β k)} (h₁ : k ∈ t) (h₂ : (f (t.get? k)).isSome = true) : (alter k f t ⋯).impl.size = t.size

theorem Std.DTreeMap.Internal.Impl.size_alter!_eq_self_of_mem {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] [LawfulEqOrd α] (h : t.WF) {k : α} {f : Option (β k) → Option (β k)} (h₁ : k ∈ t) (h₂ : (f (t.get? k)).isSome = true) : (alter! k f t).size = t.size

theorem Std.DTreeMap.Internal.Impl.size_alter_le_size {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] [LawfulEqOrd α] (h : t.WF) {k : α} {f : Option (β k) → Option (β k)} : (alter k f t ⋯).impl.size ≤ t.size + 1

theorem Std.DTreeMap.Internal.Impl.size_alter!_le_size {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] [LawfulEqOrd α] (h : t.WF) {k : α} {f : Option (β k) → Option (β k)} : (alter! k f t).size ≤ t.size + 1

theorem Std.DTreeMap.Internal.Impl.size_le_size_alter {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] [LawfulEqOrd α] (h : t.WF) {k : α} {f : Option (β k) → Option (β k)} : t.size - 1 ≤ (alter k f t ⋯).impl.size

theorem Std.DTreeMap.Internal.Impl.size_le_size_alter! {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] [LawfulEqOrd α] (h : t.WF) {k : α} {f : Option (β k) → Option (β k)} : t.size - 1 ≤ (alter! k f t).size

theorem Std.DTreeMap.Internal.Impl.get?_alter {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] [LawfulEqOrd α] (h : t.WF) {k k' : α} {f : Option (β k) → Option (β k)} : (alter k f t ⋯).impl.get? k' = if h : compare k k' = Ordering.eq then cast ⋯ (f (t.get? k)) else t.get? k'

theorem Std.DTreeMap.Internal.Impl.get?_alter! {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] [LawfulEqOrd α] (h : t.WF) {k k' : α} {f : Option (β k) → Option (β k)} : (alter! k f t).get? k' = if h : compare k k' = Ordering.eq then cast ⋯ (f (t.get? k)) else t.get? k'

@[simp]

theorem Std.DTreeMap.Internal.Impl.get?_alter_self {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] [LawfulEqOrd α] (h : t.WF) {k : α} {f : Option (β k) → Option (β k)} : (alter k f t ⋯).impl.get? k = f (t.get? k)

@[simp]

theorem Std.DTreeMap.Internal.Impl.get?_alter!_self {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] [LawfulEqOrd α] (h : t.WF) {k : α} {f : Option (β k) → Option (β k)} : (alter! k f t).get? k = f (t.get? k)

theorem Std.DTreeMap.Internal.Impl.get_alter {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] [LawfulEqOrd α] (h : t.WF) {k k' : α} {f : Option (β k) → Option (β k)} {hc : k' ∈ (alter k f t ⋯).impl} : (alter k f t ⋯).impl.get k' hc = if heq : compare k k' = Ordering.eq then cast ⋯ ((f (t.get? k)).get ⋯) else t.get k' ⋯

theorem Std.DTreeMap.Internal.Impl.get_alter! {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] [LawfulEqOrd α] (h : t.WF) {k k' : α} {f : Option (β k) → Option (β k)} {hc : k' ∈ alter! k f t} : (alter! k f t).get k' hc = if heq : compare k k' = Ordering.eq then cast ⋯ ((f (t.get? k)).get ⋯) else t.get k' ⋯

@[simp]

theorem Std.DTreeMap.Internal.Impl.get_alter_self {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] [LawfulEqOrd α] (h : t.WF) {k : α} {f : Option (β k) → Option (β k)} {hc : k ∈ (alter k f t ⋯).impl} : (alter k f t ⋯).impl.get k hc = (f (t.get? k)).get ⋯

@[simp]

theorem Std.DTreeMap.Internal.Impl.get_alter!_self {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] [LawfulEqOrd α] (h : t.WF) {k : α} {f : Option (β k) → Option (β k)} {hc : k ∈ alter! k f t} : (alter! k f t).get k hc = (f (t.get? k)).get ⋯

theorem Std.DTreeMap.Internal.Impl.get!_alter {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] [LawfulEqOrd α] (h : t.WF) {k k' : α} [Inhabited (β k')] {f : Option (β k) → Option (β k)} : (alter k f t ⋯).impl.get! k' = if heq : compare k k' = Ordering.eq then (Option.map (cast ⋯) (f (t.get? k))).get! else t.get! k'

theorem Std.DTreeMap.Internal.Impl.get!_alter! {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] [LawfulEqOrd α] (h : t.WF) {k k' : α} [Inhabited (β k')] {f : Option (β k) → Option (β k)} : (alter! k f t).get! k' = if heq : compare k k' = Ordering.eq then (Option.map (cast ⋯) (f (t.get? k))).get! else t.get! k'

@[simp]

theorem Std.DTreeMap.Internal.Impl.get!_alter_self {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] [LawfulEqOrd α] (h : t.WF) {k : α} [Inhabited (β k)] {f : Option (β k) → Option (β k)} : (alter k f t ⋯).impl.get! k = (f (t.get? k)).get!

@[simp]

theorem Std.DTreeMap.Internal.Impl.get!_alter!_self {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] [LawfulEqOrd α] (h : t.WF) {k : α} [Inhabited (β k)] {f : Option (β k) → Option (β k)} : (alter! k f t).get! k = (f (t.get? k)).get!

theorem Std.DTreeMap.Internal.Impl.getD_alter {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] [LawfulEqOrd α] (h : t.WF) {k k' : α} {fallback : β k'} {f : Option (β k) → Option (β k)} : (alter k f t ⋯).impl.getD k' fallback = if heq : compare k k' = Ordering.eq then (Option.map (cast ⋯) (f (t.get? k))).getD fallback else t.getD k' fallback

theorem Std.DTreeMap.Internal.Impl.getD_alter! {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] [LawfulEqOrd α] (h : t.WF) {k k' : α} {fallback : β k'} {f : Option (β k) → Option (β k)} : (alter! k f t).getD k' fallback = if heq : compare k k' = Ordering.eq then (Option.map (cast ⋯) (f (t.get? k))).getD fallback else t.getD k' fallback

@[simp]

theorem Std.DTreeMap.Internal.Impl.getD_alter_self {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] [LawfulEqOrd α] (h : t.WF) {k : α} {fallback : β k} {f : Option (β k) → Option (β k)} : (alter k f t ⋯).impl.getD k fallback = (f (t.get? k)).getD fallback

@[simp]

theorem Std.DTreeMap.Internal.Impl.getD_alter!_self {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] [LawfulEqOrd α] (h : t.WF) {k : α} {fallback : β k} {f : Option (β k) → Option (β k)} : (alter! k f t).getD k fallback = (f (t.get? k)).getD fallback

theorem Std.DTreeMap.Internal.Impl.getKey?_alter {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] [LawfulEqOrd α] (h : t.WF) {k k' : α} {f : Option (β k) → Option (β k)} : (alter k f t ⋯).impl.getKey? k' = if compare k k' = Ordering.eq then if (f (t.get? k)).isSome = true then some k else none else t.getKey? k'

theorem Std.DTreeMap.Internal.Impl.getKey?_alter! {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] [LawfulEqOrd α] (h : t.WF) {k k' : α} {f : Option (β k) → Option (β k)} : (alter! k f t).getKey? k' = if compare k k' = Ordering.eq then if (f (t.get? k)).isSome = true then some k else none else t.getKey? k'

theorem Std.DTreeMap.Internal.Impl.getKey?_alter_self {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] [LawfulEqOrd α] (h : t.WF) {k : α} {f : Option (β k) → Option (β k)} : (alter k f t ⋯).impl.getKey? k = if (f (t.get? k)).isSome = true then some k else none

theorem Std.DTreeMap.Internal.Impl.getKey?_alter!_self {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] [LawfulEqOrd α] (h : t.WF) {k : α} {f : Option (β k) → Option (β k)} : (alter! k f t).getKey? k = if (f (t.get? k)).isSome = true then some k else none

theorem Std.DTreeMap.Internal.Impl.getKey!_alter {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] [LawfulEqOrd α] [Inhabited α] (h : t.WF) {k k' : α} {f : Option (β k) → Option (β k)} : (alter k f t ⋯).impl.getKey! k' = if compare k k' = Ordering.eq then if (f (t.get? k)).isSome = true then k else default else t.getKey! k'

theorem Std.DTreeMap.Internal.Impl.getKey!_alter! {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] [LawfulEqOrd α] [Inhabited α] (h : t.WF) {k k' : α} {f : Option (β k) → Option (β k)} : (alter! k f t).getKey! k' = if compare k k' = Ordering.eq then if (f (t.get? k)).isSome = true then k else default else t.getKey! k'

theorem Std.DTreeMap.Internal.Impl.getKey!_alter_self {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] [LawfulEqOrd α] [Inhabited α] (h : t.WF) {k : α} {f : Option (β k) → Option (β k)} : (alter k f t ⋯).impl.getKey! k = if (f (t.get? k)).isSome = true then k else default

theorem Std.DTreeMap.Internal.Impl.getKey!_alter!_self {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] [LawfulEqOrd α] [Inhabited α] (h : t.WF) {k : α} {f : Option (β k) → Option (β k)} : (alter! k f t).getKey! k = if (f (t.get? k)).isSome = true then k else default

theorem Std.DTreeMap.Internal.Impl.getKey_alter {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] [LawfulEqOrd α] [Inhabited α] (h : t.WF) {k k' : α} {f : Option (β k) → Option (β k)} {hc : k' ∈ (alter k f t ⋯).impl} : (alter k f t ⋯).impl.getKey k' hc = if heq : compare k k' = Ordering.eq then k else t.getKey k' ⋯

theorem Std.DTreeMap.Internal.Impl.getKey_alter! {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] [LawfulEqOrd α] [Inhabited α] (h : t.WF) {k k' : α} {f : Option (β k) → Option (β k)} {hc : k' ∈ alter! k f t} : (alter! k f t).getKey k' hc = if heq : compare k k' = Ordering.eq then k else t.getKey k' ⋯

@[simp]

theorem Std.DTreeMap.Internal.Impl.getKey_alter_self {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] [LawfulEqOrd α] [Inhabited α] (h : t.WF) {k : α} {f : Option (β k) → Option (β k)} {hc : k ∈ (alter k f t ⋯).impl} : (alter k f t ⋯).impl.getKey k hc = k

@[simp]

theorem Std.DTreeMap.Internal.Impl.getKey_alter!_self {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] [LawfulEqOrd α] [Inhabited α] (h : t.WF) {k : α} {f : Option (β k) → Option (β k)} {hc : k ∈ alter! k f t} : (alter! k f t).getKey k hc = k

theorem Std.DTreeMap.Internal.Impl.getKeyD_alter {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] [LawfulEqOrd α] (h : t.WF) {k k' fallback : α} {f : Option (β k) → Option (β k)} : (alter k f t ⋯).impl.getKeyD k' fallback = if compare k k' = Ordering.eq then if (f (t.get? k)).isSome = true then k else fallback else t.getKeyD k' fallback

theorem Std.DTreeMap.Internal.Impl.getKeyD_alter! {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] [LawfulEqOrd α] (h : t.WF) {k k' fallback : α} {f : Option (β k) → Option (β k)} : (alter! k f t).getKeyD k' fallback = if compare k k' = Ordering.eq then if (f (t.get? k)).isSome = true then k else fallback else t.getKeyD k' fallback

@[simp]

theorem Std.DTreeMap.Internal.Impl.getKeyD_alter_self {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] [LawfulEqOrd α] [Inhabited α] (h : t.WF) {k fallback : α} {f : Option (β k) → Option (β k)} : (alter k f t ⋯).impl.getKeyD k fallback = if (f (t.get? k)).isSome = true then k else fallback

@[simp]

theorem Std.DTreeMap.Internal.Impl.getKeyD_alter!_self {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] [LawfulEqOrd α] [Inhabited α] (h : t.WF) {k fallback : α} {f : Option (β k) → Option (β k)} : (alter! k f t).getKeyD k fallback = if (f (t.get? k)).isSome = true then k else fallback

theorem Std.DTreeMap.Internal.Impl.Const.isEmpty_alter_eq_isEmpty_erase {α : Type u} {instOrd : Ord α} {β : Type v} {t : Impl α fun (x : α) => β} [TransOrd α] (h : t.WF) {k : α} {f : Option β → Option β} : (alter k f t ⋯).impl.isEmpty = ((erase k t ⋯).impl.isEmpty && (f (get? t k)).isNone)

theorem Std.DTreeMap.Internal.Impl.Const.isEmpty_alter!_eq_isEmpty_erase {α : Type u} {instOrd : Ord α} {β : Type v} {t : Impl α fun (x : α) => β} [TransOrd α] (h : t.WF) {k : α} {f : Option β → Option β} : (alter! k f t).isEmpty = ((erase! k t).isEmpty && (f (get? t k)).isNone)

@[simp]

theorem Std.DTreeMap.Internal.Impl.Const.isEmpty_alter {α : Type u} {instOrd : Ord α} {β : Type v} {t : Impl α fun (x : α) => β} [TransOrd α] (h : t.WF) {k : α} {f : Option β → Option β} : (alter k f t ⋯).impl.isEmpty = ((t.isEmpty || t.size == 1 && contains k t) && (f (get? t k)).isNone)

@[simp]

theorem Std.DTreeMap.Internal.Impl.Const.isEmpty_alter! {α : Type u} {instOrd : Ord α} {β : Type v} {t : Impl α fun (x : α) => β} [TransOrd α] (h : t.WF) {k : α} {f : Option β → Option β} : (alter! k f t).isEmpty = ((t.isEmpty || t.size == 1 && contains k t) && (f (get? t k)).isNone)

theorem Std.DTreeMap.Internal.Impl.Const.contains_alter {α : Type u} {instOrd : Ord α} {β : Type v} {t : Impl α fun (x : α) => β} [TransOrd α] (h : t.WF) {k k' : α} {f : Option β → Option β} : contains k' (alter k f t ⋯).impl = if compare k k' = Ordering.eq then (f (get? t k)).isSome else contains k' t

theorem Std.DTreeMap.Internal.Impl.Const.contains_alter! {α : Type u} {instOrd : Ord α} {β : Type v} {t : Impl α fun (x : α) => β} [TransOrd α] (h : t.WF) {k k' : α} {f : Option β → Option β} : contains k' (alter! k f t) = if compare k k' = Ordering.eq then (f (get? t k)).isSome else contains k' t

theorem Std.DTreeMap.Internal.Impl.Const.mem_alter {α : Type u} {instOrd : Ord α} {β : Type v} {t : Impl α fun (x : α) => β} [TransOrd α] (h : t.WF) {k k' : α} {f : Option β → Option β} : k' ∈ (alter k f t ⋯).impl ↔ if compare k k' = Ordering.eq then (f (get? t k)).isSome = true else k' ∈ t

theorem Std.DTreeMap.Internal.Impl.Const.mem_alter! {α : Type u} {instOrd : Ord α} {β : Type v} {t : Impl α fun (x : α) => β} [TransOrd α] (h : t.WF) {k k' : α} {f : Option β → Option β} : k' ∈ alter! k f t ↔ if compare k k' = Ordering.eq then (f (get? t k)).isSome = true else k' ∈ t

theorem Std.DTreeMap.Internal.Impl.Const.mem_alter_of_compare_eq {α : Type u} {instOrd : Ord α} {β : Type v} {t : Impl α fun (x : α) => β} [TransOrd α] (h : t.WF) {k k' : α} {f : Option β → Option β} (he : compare k k' = Ordering.eq) : k' ∈ (alter k f t ⋯).impl ↔ (f (get? t k)).isSome = true

theorem Std.DTreeMap.Internal.Impl.Const.mem_alter!_of_compare_eq {α : Type u} {instOrd : Ord α} {β : Type v} {t : Impl α fun (x : α) => β} [TransOrd α] (h : t.WF) {k k' : α} {f : Option β → Option β} (he : compare k k' = Ordering.eq) : k' ∈ alter! k f t ↔ (f (get? t k)).isSome = true

@[simp]

theorem Std.DTreeMap.Internal.Impl.Const.contains_alter_self {α : Type u} {instOrd : Ord α} {β : Type v} {t : Impl α fun (x : α) => β} [TransOrd α] {k : α} (h : t.WF) {f : Option β → Option β} : contains k (alter k f t ⋯).impl = (f (get? t k)).isSome

@[simp]

theorem Std.DTreeMap.Internal.Impl.Const.contains_alter!_self {α : Type u} {instOrd : Ord α} {β : Type v} {t : Impl α fun (x : α) => β} [TransOrd α] (h : t.WF) {k : α} {f : Option β → Option β} : contains k (alter! k f t) = (f (get? t k)).isSome

@[simp]

theorem Std.DTreeMap.Internal.Impl.Const.mem_alter_self {α : Type u} {instOrd : Ord α} {β : Type v} {t : Impl α fun (x : α) => β} [TransOrd α] (h : t.WF) {k : α} {f : Option β → Option β} : k ∈ (alter k f t ⋯).impl ↔ (f (get? t k)).isSome = true

@[simp]

theorem Std.DTreeMap.Internal.Impl.Const.mem_alter!_self {α : Type u} {instOrd : Ord α} {β : Type v} {t : Impl α fun (x : α) => β} [TransOrd α] (h : t.WF) {k : α} {f : Option β → Option β} : k ∈ alter! k f t ↔ (f (get? t k)).isSome = true

theorem Std.DTreeMap.Internal.Impl.Const.contains_alter_of_not_compare_eq {α : Type u} {instOrd : Ord α} {β : Type v} {t : Impl α fun (x : α) => β} [TransOrd α] (h : t.WF) {k k' : α} {f : Option β → Option β} (he : ¬compare k k' = Ordering.eq) : contains k' (alter k f t ⋯).impl = contains k' t

theorem Std.DTreeMap.Internal.Impl.Const.contains_alter!_of_not_compare_eq {α : Type u} {instOrd : Ord α} {β : Type v} {t : Impl α fun (x : α) => β} [TransOrd α] (h : t.WF) {k k' : α} {f : Option β → Option β} (he : ¬compare k k' = Ordering.eq) : contains k' (alter! k f t) = contains k' t

theorem Std.DTreeMap.Internal.Impl.Const.mem_alter_of_not_compare_eq {α : Type u} {instOrd : Ord α} {β : Type v} {t : Impl α fun (x : α) => β} [TransOrd α] (h : t.WF) {k k' : α} {f : Option β → Option β} (he : ¬compare k k' = Ordering.eq) : k' ∈ (alter k f t ⋯).impl ↔ k' ∈ t

theorem Std.DTreeMap.Internal.Impl.Const.mem_alter!_of_not_compare_eq {α : Type u} {instOrd : Ord α} {β : Type v} {t : Impl α fun (x : α) => β} [TransOrd α] (h : t.WF) {k k' : α} {f : Option β → Option β} (he : ¬compare k k' = Ordering.eq) : k' ∈ alter! k f t ↔ k' ∈ t

theorem Std.DTreeMap.Internal.Impl.Const.size_alter {α : Type u} {instOrd : Ord α} {β : Type v} {t : Impl α fun (x : α) => β} [TransOrd α] (h : t.WF) {k : α} {f : Option β → Option β} : (alter k f t ⋯).impl.size = if k ∈ t ∧ (f (get? t k)).isNone = true then t.size - 1 else if ¬k ∈ t ∧ (f (get? t k)).isSome = true then t.size + 1 else t.size

theorem Std.DTreeMap.Internal.Impl.Const.size_alter! {α : Type u} {instOrd : Ord α} {β : Type v} {t : Impl α fun (x : α) => β} [TransOrd α] (h : t.WF) {k : α} {f : Option β → Option β} : (alter! k f t).size = if k ∈ t ∧ (f (get? t k)).isNone = true then t.size - 1 else if ¬k ∈ t ∧ (f (get? t k)).isSome = true then t.size + 1 else t.size

theorem Std.DTreeMap.Internal.Impl.Const.size_alter_eq_add_one {α : Type u} {instOrd : Ord α} {β : Type v} {t : Impl α fun (x : α) => β} [TransOrd α] (h : t.WF) {k : α} {f : Option β → Option β} (h₁ : ¬k ∈ t) (h₂ : (f (get? t k)).isSome = true) : (alter k f t ⋯).impl.size = t.size + 1

theorem Std.DTreeMap.Internal.Impl.Const.size_alter!_eq_add_one {α : Type u} {instOrd : Ord α} {β : Type v} {t : Impl α fun (x : α) => β} [TransOrd α] (h : t.WF) {k : α} {f : Option β → Option β} (h₁ : ¬k ∈ t) (h₂ : (f (get? t k)).isSome = true) : (alter! k f t).size = t.size + 1

theorem Std.DTreeMap.Internal.Impl.Const.size_alter_eq_sub_one {α : Type u} {instOrd : Ord α} {β : Type v} {t : Impl α fun (x : α) => β} [TransOrd α] (h : t.WF) {k : α} {f : Option β → Option β} (h₁ : k ∈ t) (h₂ : (f (get? t k)).isNone = true) : (alter k f t ⋯).impl.size = t.size - 1

theorem Std.DTreeMap.Internal.Impl.Const.size_alter!_eq_sub_one {α : Type u} {instOrd : Ord α} {β : Type v} {t : Impl α fun (x : α) => β} [TransOrd α] (h : t.WF) {k : α} {f : Option β → Option β} (h₁ : k ∈ t) (h₂ : (f (get? t k)).isNone = true) : (alter! k f t).size = t.size - 1

theorem Std.DTreeMap.Internal.Impl.Const.size_alter_eq_self_of_not_mem {α : Type u} {instOrd : Ord α} {β : Type v} {t : Impl α fun (x : α) => β} [TransOrd α] (h : t.WF) {k : α} {f : Option β → Option β} (h₁ : ¬k ∈ t) (h₂ : (f (get? t k)).isNone = true) : (alter k f t ⋯).impl.size = t.size

theorem Std.DTreeMap.Internal.Impl.Const.size_alter!_eq_self_of_not_mem {α : Type u} {instOrd : Ord α} {β : Type v} {t : Impl α fun (x : α) => β} [TransOrd α] (h : t.WF) {k : α} {f : Option β → Option β} (h₁ : ¬k ∈ t) (h₂ : (f (get? t k)).isNone = true) : (alter! k f t).size = t.size

theorem Std.DTreeMap.Internal.Impl.Const.size_alter_eq_self_of_mem {α : Type u} {instOrd : Ord α} {β : Type v} {t : Impl α fun (x : α) => β} [TransOrd α] (h : t.WF) {k : α} {f : Option β → Option β} (h₁ : k ∈ t) (h₂ : (f (get? t k)).isSome = true) : (alter k f t ⋯).impl.size = t.size

theorem Std.DTreeMap.Internal.Impl.Const.size_alter!_eq_self_of_mem {α : Type u} {instOrd : Ord α} {β : Type v} {t : Impl α fun (x : α) => β} [TransOrd α] (h : t.WF) {k : α} {f : Option β → Option β} (h₁ : k ∈ t) (h₂ : (f (get? t k)).isSome = true) : (alter! k f t).size = t.size

theorem Std.DTreeMap.Internal.Impl.Const.size_alter_le_size {α : Type u} {instOrd : Ord α} {β : Type v} {t : Impl α fun (x : α) => β} [TransOrd α] (h : t.WF) {k : α} {f : Option β → Option β} : (alter k f t ⋯).impl.size ≤ t.size + 1

theorem Std.DTreeMap.Internal.Impl.Const.size_alter!_le_size {α : Type u} {instOrd : Ord α} {β : Type v} {t : Impl α fun (x : α) => β} [TransOrd α] (h : t.WF) {k : α} {f : Option β → Option β} : (alter! k f t).size ≤ t.size + 1

theorem Std.DTreeMap.Internal.Impl.Const.size_le_size_alter {α : Type u} {instOrd : Ord α} {β : Type v} {t : Impl α fun (x : α) => β} [TransOrd α] (h : t.WF) {k : α} {f : Option β → Option β} : t.size - 1 ≤ (alter k f t ⋯).impl.size

theorem Std.DTreeMap.Internal.Impl.Const.size_le_size_alter! {α : Type u} {instOrd : Ord α} {β : Type v} {t : Impl α fun (x : α) => β} [TransOrd α] (h : t.WF) {k : α} {f : Option β → Option β} : t.size - 1 ≤ (alter! k f t).size

theorem Std.DTreeMap.Internal.Impl.Const.get?_alter {α : Type u} {instOrd : Ord α} {β : Type v} {t : Impl α fun (x : α) => β} [TransOrd α] (h : t.WF) {k k' : α} {f : Option β → Option β} : get? (alter k f t ⋯).impl k' = if compare k k' = Ordering.eq then f (get? t k) else get? t k'

theorem Std.DTreeMap.Internal.Impl.Const.get?_alter! {α : Type u} {instOrd : Ord α} {β : Type v} {t : Impl α fun (x : α) => β} [TransOrd α] (h : t.WF) {k k' : α} {f : Option β → Option β} : get? (alter! k f t) k' = if compare k k' = Ordering.eq then f (get? t k) else get? t k'

@[simp]

theorem Std.DTreeMap.Internal.Impl.Const.get?_alter_self {α : Type u} {instOrd : Ord α} {β : Type v} {t : Impl α fun (x : α) => β} [TransOrd α] (h : t.WF) {k : α} {f : Option β → Option β} : get? (alter k f t ⋯).impl k = f (get? t k)

@[simp]

theorem Std.DTreeMap.Internal.Impl.Const.get?_alter!_self {α : Type u} {instOrd : Ord α} {β : Type v} {t : Impl α fun (x : α) => β} [TransOrd α] (h : t.WF) {k : α} {f : Option β → Option β} : get? (alter! k f t) k = f (get? t k)

theorem Std.DTreeMap.Internal.Impl.Const.get_alter {α : Type u} {instOrd : Ord α} {β : Type v} {t : Impl α fun (x : α) => β} [TransOrd α] (h : t.WF) {k k' : α} {f : Option β → Option β} {hc : k' ∈ (alter k f t ⋯).impl} : get (alter k f t ⋯).impl k' hc = if heq : compare k k' = Ordering.eq then (f (get? t k)).get ⋯ else get t k' ⋯

theorem Std.DTreeMap.Internal.Impl.Const.get_alter! {α : Type u} {instOrd : Ord α} {β : Type v} {t : Impl α fun (x : α) => β} [TransOrd α] (h : t.WF) {k k' : α} {f : Option β → Option β} {hc : k' ∈ alter! k f t} : get (alter! k f t) k' hc = if heq : compare k k' = Ordering.eq then (f (get? t k)).get ⋯ else get t k' ⋯

@[simp]

theorem Std.DTreeMap.Internal.Impl.Const.get_alter_self {α : Type u} {instOrd : Ord α} {β : Type v} {t : Impl α fun (x : α) => β} [TransOrd α] (h : t.WF) {k : α} {f : Option β → Option β} {hc : k ∈ (alter k f t ⋯).impl} : get (alter k f t ⋯).impl k hc = (f (get? t k)).get ⋯

@[simp]

theorem Std.DTreeMap.Internal.Impl.Const.get_alter!_self {α : Type u} {instOrd : Ord α} {β : Type v} {t : Impl α fun (x : α) => β} [TransOrd α] (h : t.WF) {k : α} {f : Option β → Option β} {hc : k ∈ alter! k f t} : get (alter! k f t) k hc = (f (get? t k)).get ⋯

theorem Std.DTreeMap.Internal.Impl.Const.get!_alter {α : Type u} {instOrd : Ord α} {β : Type v} {t : Impl α fun (x : α) => β} [TransOrd α] (h : t.WF) {k k' : α} [Inhabited β] {f : Option β → Option β} : get! (alter k f t ⋯).impl k' = if compare k k' = Ordering.eq then (f (get? t k)).get! else get! t k'

theorem Std.DTreeMap.Internal.Impl.Const.get!_alter! {α : Type u} {instOrd : Ord α} {β : Type v} {t : Impl α fun (x : α) => β} [TransOrd α] (h : t.WF) {k k' : α} [Inhabited β] {f : Option β → Option β} : get! (alter! k f t) k' = if compare k k' = Ordering.eq then (f (get? t k)).get! else get! t k'

@[simp]

theorem Std.DTreeMap.Internal.Impl.Const.get!_alter_self {α : Type u} {instOrd : Ord α} {β : Type v} {t : Impl α fun (x : α) => β} [TransOrd α] (h : t.WF) {k : α} [Inhabited β] {f : Option β → Option β} : get! (alter k f t ⋯).impl k = (f (get? t k)).get!

@[simp]

theorem Std.DTreeMap.Internal.Impl.Const.get!_alter!_self {α : Type u} {instOrd : Ord α} {β : Type v} {t : Impl α fun (x : α) => β} [TransOrd α] (h : t.WF) {k : α} [Inhabited β] {f : Option β → Option β} : get! (alter! k f t) k = (f (get? t k)).get!

theorem Std.DTreeMap.Internal.Impl.Const.getD_alter {α : Type u} {instOrd : Ord α} {β : Type v} {t : Impl α fun (x : α) => β} [TransOrd α] (h : t.WF) {k k' : α} {fallback : β} {f : Option β → Option β} : getD (alter k f t ⋯).impl k' fallback = if compare k k' = Ordering.eq then (f (get? t k)).getD fallback else getD t k' fallback

theorem Std.DTreeMap.Internal.Impl.Const.getD_alter! {α : Type u} {instOrd : Ord α} {β : Type v} {t : Impl α fun (x : α) => β} [TransOrd α] (h : t.WF) {k k' : α} {fallback : β} {f : Option β → Option β} : getD (alter! k f t) k' fallback = if compare k k' = Ordering.eq then (f (get? t k)).getD fallback else getD t k' fallback

@[simp]

theorem Std.DTreeMap.Internal.Impl.Const.getD_alter_self {α : Type u} {instOrd : Ord α} {β : Type v} {t : Impl α fun (x : α) => β} [TransOrd α] (h : t.WF) {k : α} {fallback : β} {f : Option β → Option β} : getD (alter k f t ⋯).impl k fallback = (f (get? t k)).getD fallback

@[simp]

theorem Std.DTreeMap.Internal.Impl.Const.getD_alter!_self {α : Type u} {instOrd : Ord α} {β : Type v} {t : Impl α fun (x : α) => β} [TransOrd α] (h : t.WF) {k : α} {fallback : β} {f : Option β → Option β} : getD (alter! k f t) k fallback = (f (get? t k)).getD fallback

theorem Std.DTreeMap.Internal.Impl.Const.getKey?_alter {α : Type u} {instOrd : Ord α} {β : Type v} {t : Impl α fun (x : α) => β} [TransOrd α] (h : t.WF) {k k' : α} {f : Option β → Option β} : (alter k f t ⋯).impl.getKey? k' = if compare k k' = Ordering.eq then if (f (get? t k)).isSome = true then some k else none else t.getKey? k'

theorem Std.DTreeMap.Internal.Impl.Const.getKey?_alter! {α : Type u} {instOrd : Ord α} {β : Type v} {t : Impl α fun (x : α) => β} [TransOrd α] (h : t.WF) {k k' : α} {f : Option β → Option β} : (alter! k f t).getKey? k' = if compare k k' = Ordering.eq then if (f (get? t k)).isSome = true then some k else none else t.getKey? k'

theorem Std.DTreeMap.Internal.Impl.Const.getKey?_alter_self {α : Type u} {instOrd : Ord α} {β : Type v} {t : Impl α fun (x : α) => β} [TransOrd α] (h : t.WF) {k : α} {f : Option β → Option β} : (alter k f t ⋯).impl.getKey? k = if (f (get? t k)).isSome = true then some k else none

theorem Std.DTreeMap.Internal.Impl.Const.getKey?_alter!_self {α : Type u} {instOrd : Ord α} {β : Type v} {t : Impl α fun (x : α) => β} [TransOrd α] (h : t.WF) {k : α} {f : Option β → Option β} : (alter! k f t).getKey? k = if (f (get? t k)).isSome = true then some k else none

theorem Std.DTreeMap.Internal.Impl.Const.getKey!_alter {α : Type u} {instOrd : Ord α} {β : Type v} {t : Impl α fun (x : α) => β} [TransOrd α] [Inhabited α] (h : t.WF) {k k' : α} {f : Option β → Option β} : (alter k f t ⋯).impl.getKey! k' = if compare k k' = Ordering.eq then if (f (get? t k)).isSome = true then k else default else t.getKey! k'

theorem Std.DTreeMap.Internal.Impl.Const.getKey!_alter! {α : Type u} {instOrd : Ord α} {β : Type v} {t : Impl α fun (x : α) => β} [TransOrd α] [Inhabited α] (h : t.WF) {k k' : α} {f : Option β → Option β} : (alter! k f t).getKey! k' = if compare k k' = Ordering.eq then if (f (get? t k)).isSome = true then k else default else t.getKey! k'

theorem Std.DTreeMap.Internal.Impl.Const.getKey!_alter_self {α : Type u} {instOrd : Ord α} {β : Type v} {t : Impl α fun (x : α) => β} [TransOrd α] [Inhabited α] (h : t.WF) {k : α} {f : Option β → Option β} : (alter k f t ⋯).impl.getKey! k = if (f (get? t k)).isSome = true then k else default

theorem Std.DTreeMap.Internal.Impl.Const.getKey!_alter!_self {α : Type u} {instOrd : Ord α} {β : Type v} {t : Impl α fun (x : α) => β} [TransOrd α] [Inhabited α] (h : t.WF) {k : α} {f : Option β → Option β} : (alter! k f t).getKey! k = if (f (get? t k)).isSome = true then k else default

theorem Std.DTreeMap.Internal.Impl.Const.getKey_alter {α : Type u} {instOrd : Ord α} {β : Type v} {t : Impl α fun (x : α) => β} [TransOrd α] [Inhabited α] (h : t.WF) {k k' : α} {f : Option β → Option β} {hc : k' ∈ (alter k f t ⋯).impl} : (alter k f t ⋯).impl.getKey k' hc = if heq : compare k k' = Ordering.eq then k else t.getKey k' ⋯

theorem Std.DTreeMap.Internal.Impl.Const.getKey_alter! {α : Type u} {instOrd : Ord α} {β : Type v} {t : Impl α fun (x : α) => β} [TransOrd α] [Inhabited α] (h : t.WF) {k k' : α} {f : Option β → Option β} {hc : k' ∈ alter! k f t} : (alter! k f t).getKey k' hc = if heq : compare k k' = Ordering.eq then k else t.getKey k' ⋯

@[simp]

theorem Std.DTreeMap.Internal.Impl.Const.getKey_alter_self {α : Type u} {instOrd : Ord α} {β : Type v} {t : Impl α fun (x : α) => β} [TransOrd α] [Inhabited α] (h : t.WF) {k : α} {f : Option β → Option β} {hc : k ∈ (alter k f t ⋯).impl} : (alter k f t ⋯).impl.getKey k hc = k

@[simp]

theorem Std.DTreeMap.Internal.Impl.Const.getKey_alter!_self {α : Type u} {instOrd : Ord α} {β : Type v} {t : Impl α fun (x : α) => β} [TransOrd α] [Inhabited α] (h : t.WF) {k : α} {f : Option β → Option β} {hc : k ∈ alter! k f t} : (alter! k f t).getKey k hc = k

theorem Std.DTreeMap.Internal.Impl.Const.getKeyD_alter {α : Type u} {instOrd : Ord α} {β : Type v} {t : Impl α fun (x : α) => β} [TransOrd α] (h : t.WF) {k k' fallback : α} {f : Option β → Option β} : (alter k f t ⋯).impl.getKeyD k' fallback = if compare k k' = Ordering.eq then if (f (get? t k)).isSome = true then k else fallback else t.getKeyD k' fallback

theorem Std.DTreeMap.Internal.Impl.Const.getKeyD_alter! {α : Type u} {instOrd : Ord α} {β : Type v} {t : Impl α fun (x : α) => β} [TransOrd α] (h : t.WF) {k k' fallback : α} {f : Option β → Option β} : (alter! k f t).getKeyD k' fallback = if compare k k' = Ordering.eq then if (f (get? t k)).isSome = true then k else fallback else t.getKeyD k' fallback

@[simp]

theorem Std.DTreeMap.Internal.Impl.Const.getKeyD_alter_self {α : Type u} {instOrd : Ord α} {β : Type v} {t : Impl α fun (x : α) => β} [TransOrd α] [Inhabited α] (h : t.WF) {k fallback : α} {f : Option β → Option β} : (alter k f t ⋯).impl.getKeyD k fallback = if (f (get? t k)).isSome = true then k else fallback

@[simp]

theorem Std.DTreeMap.Internal.Impl.Const.getKeyD_alter!_self {α : Type u} {instOrd : Ord α} {β : Type v} {t : Impl α fun (x : α) => β} [TransOrd α] [Inhabited α] (h : t.WF) {k fallback : α} {f : Option β → Option β} : (alter! k f t).getKeyD k fallback = if (f (get? t k)).isSome = true then k else fallback

@[simp]

theorem Std.DTreeMap.Internal.Impl.isEmpty_modify {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] [LawfulEqOrd α] (h : t.WF) {k : α} {f : β k → β k} : (modify k f t).isEmpty = t.isEmpty

theorem Std.DTreeMap.Internal.Impl.contains_modify {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] [LawfulEqOrd α] (h : t.WF) {k k' : α} {f : β k → β k} : contains k' (modify k f t) = contains k' t

theorem Std.DTreeMap.Internal.Impl.mem_modify {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] [LawfulEqOrd α] (h : t.WF) {k k' : α} {f : β k → β k} : k' ∈ modify k f t ↔ k' ∈ t

theorem Std.DTreeMap.Internal.Impl.size_modify {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] [LawfulEqOrd α] (h : t.WF) {k : α} {f : β k → β k} : (modify k f t).size = t.size

theorem Std.DTreeMap.Internal.Impl.get?_modify {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] [LawfulEqOrd α] (h : t.WF) {k k' : α} {f : β k → β k} : (modify k f t).get? k' = if h : compare k k' = Ordering.eq then cast ⋯ (Option.map f (t.get? k)) else t.get? k'

@[simp]

theorem Std.DTreeMap.Internal.Impl.get?_modify_self {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] [LawfulEqOrd α] (h : t.WF) {k : α} {f : β k → β k} : (modify k f t).get? k = Option.map f (t.get? k)

theorem Std.DTreeMap.Internal.Impl.get_modify {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] [LawfulEqOrd α] (h : t.WF) {k k' : α} {f : β k → β k} {hc : k' ∈ modify k f t} : (modify k f t).get k' hc = if heq : compare k k' = Ordering.eq then cast ⋯ (f (t.get k ⋯)) else t.get k' ⋯

@[simp]

theorem Std.DTreeMap.Internal.Impl.get_modify_self {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] [LawfulEqOrd α] (h : t.WF) {k : α} {f : β k → β k} {hc : k ∈ modify k f t} : (modify k f t).get k hc = f (t.get k ⋯)

theorem Std.DTreeMap.Internal.Impl.get!_modify {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] [LawfulEqOrd α] (h : t.WF) {k k' : α} [hi : Inhabited (β k')] {f : β k → β k} : (modify k f t).get! k' = if heq : compare k k' = Ordering.eq then (Option.map (cast ⋯) (Option.map f (t.get? k))).get! else t.get! k'

@[simp]

theorem Std.DTreeMap.Internal.Impl.get!_modify_self {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] [LawfulEqOrd α] (h : t.WF) {k : α} [Inhabited (β k)] {f : β k → β k} : (modify k f t).get! k = (Option.map f (t.get? k)).get!

theorem Std.DTreeMap.Internal.Impl.getD_modify {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] [LawfulEqOrd α] (h : t.WF) {k k' : α} {fallback : β k'} {f : β k → β k} : (modify k f t).getD k' fallback = if heq : compare k k' = Ordering.eq then (Option.map (cast ⋯) (Option.map f (t.get? k))).getD fallback else t.getD k' fallback

@[simp]

theorem Std.DTreeMap.Internal.Impl.getD_modify_self {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] [LawfulEqOrd α] (h : t.WF) {k : α} {fallback : β k} {f : β k → β k} : (modify k f t).getD k fallback = (Option.map f (t.get? k)).getD fallback

theorem Std.DTreeMap.Internal.Impl.getKey?_modify {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] [LawfulEqOrd α] (h : t.WF) {k k' : α} {f : β k → β k} : (modify k f t).getKey? k' = if compare k k' = Ordering.eq then if k ∈ t then some k else none else t.getKey? k'

theorem Std.DTreeMap.Internal.Impl.getKey?_modify_self {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] [LawfulEqOrd α] (h : t.WF) {k : α} {f : β k → β k} : (modify k f t).getKey? k = if k ∈ t then some k else none

theorem Std.DTreeMap.Internal.Impl.getKey!_modify {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] [LawfulEqOrd α] (h : t.WF) [Inhabited α] {k k' : α} {f : β k → β k} : (modify k f t).getKey! k' = if compare k k' = Ordering.eq then if k ∈ t then k else default else t.getKey! k'

theorem Std.DTreeMap.Internal.Impl.getKey!_modify_self {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] [LawfulEqOrd α] (h : t.WF) [Inhabited α] {k : α} {f : β k → β k} : (modify k f t).getKey! k = if k ∈ t then k else default

theorem Std.DTreeMap.Internal.Impl.getKey_modify {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] [LawfulEqOrd α] (h : t.WF) [Inhabited α] {k k' : α} {f : β k → β k} {hc : k' ∈ modify k f t} : (modify k f t).getKey k' hc = if compare k k' = Ordering.eq then k else t.getKey k' ⋯

@[simp]

theorem Std.DTreeMap.Internal.Impl.getKey_modify_self {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] [LawfulEqOrd α] (h : t.WF) [Inhabited α] {k : α} {f : β k → β k} {hc : k ∈ modify k f t} : (modify k f t).getKey k hc = k

theorem Std.DTreeMap.Internal.Impl.getKeyD_modify {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] [LawfulEqOrd α] (h : t.WF) {k k' fallback : α} {f : β k → β k} : (modify k f t).getKeyD k' fallback = if compare k k' = Ordering.eq then if k ∈ t then k else fallback else t.getKeyD k' fallback

theorem Std.DTreeMap.Internal.Impl.getKeyD_modify_self {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] [LawfulEqOrd α] (h : t.WF) [Inhabited α] {k fallback : α} {f : β k → β k} : (modify k f t).getKeyD k fallback = if k ∈ t then k else fallback

@[simp]

theorem Std.DTreeMap.Internal.Impl.Const.isEmpty_modify {α : Type u} {instOrd : Ord α} [TransOrd α] {β : Type v} {t : Impl α fun (x : α) => β} (h : t.WF) {k : α} {f : β → β} : (modify k f t).isEmpty = t.isEmpty

theorem Std.DTreeMap.Internal.Impl.Const.contains_modify {α : Type u} {instOrd : Ord α} [TransOrd α] {β : Type v} {t : Impl α fun (x : α) => β} (h : t.WF) {k k' : α} {f : β → β} : contains k' (modify k f t) = contains k' t

theorem Std.DTreeMap.Internal.Impl.Const.mem_modify {α : Type u} {instOrd : Ord α} [TransOrd α] {β : Type v} {t : Impl α fun (x : α) => β} (h : t.WF) {k k' : α} {f : β → β} : k' ∈ modify k f t ↔ k' ∈ t

theorem Std.DTreeMap.Internal.Impl.Const.size_modify {α : Type u} {instOrd : Ord α} [TransOrd α] {β : Type v} {t : Impl α fun (x : α) => β} (h : t.WF) {k : α} {f : β → β} : (modify k f t).size = t.size

theorem Std.DTreeMap.Internal.Impl.Const.get?_modify {α : Type u} {instOrd : Ord α} [TransOrd α] {β : Type v} {t : Impl α fun (x : α) => β} (h : t.WF) {k k' : α} {f : β → β} : get? (modify k f t) k' = if compare k k' = Ordering.eq then Option.map f (get? t k) else get? t k'

@[simp]

theorem Std.DTreeMap.Internal.Impl.Const.get?_modify_self {α : Type u} {instOrd : Ord α} [TransOrd α] {β : Type v} {t : Impl α fun (x : α) => β} (h : t.WF) {k : α} {f : β → β} : get? (modify k f t) k = Option.map f (get? t k)

theorem Std.DTreeMap.Internal.Impl.Const.get_modify {α : Type u} {instOrd : Ord α} [TransOrd α] {β : Type v} {t : Impl α fun (x : α) => β} (h : t.WF) {k k' : α} {f : β → β} {hc : k' ∈ modify k f t} : get (modify k f t) k' hc = if heq : compare k k' = Ordering.eq then f (get t k ⋯) else get t k' ⋯

@[simp]

theorem Std.DTreeMap.Internal.Impl.Const.get_modify_self {α : Type u} {instOrd : Ord α} [TransOrd α] {β : Type v} {t : Impl α fun (x : α) => β} (h : t.WF) {k : α} {f : β → β} {hc : k ∈ modify k f t} : get (modify k f t) k hc = f (get t k ⋯)

theorem Std.DTreeMap.Internal.Impl.Const.get!_modify {α : Type u} {instOrd : Ord α} [TransOrd α] {β : Type v} {t : Impl α fun (x : α) => β} (h : t.WF) {k k' : α} [hi : Inhabited β] {f : β → β} : get! (modify k f t) k' = if compare k k' = Ordering.eq then (Option.map f (get? t k)).get! else get! t k'

@[simp]

theorem Std.DTreeMap.Internal.Impl.Const.get!_modify_self {α : Type u} {instOrd : Ord α} [TransOrd α] {β : Type v} {t : Impl α fun (x : α) => β} (h : t.WF) {k : α} [Inhabited β] {f : β → β} : get! (modify k f t) k = (Option.map f (get? t k)).get!

theorem Std.DTreeMap.Internal.Impl.Const.getD_modify {α : Type u} {instOrd : Ord α} [TransOrd α] {β : Type v} {t : Impl α fun (x : α) => β} (h : t.WF) {k k' : α} {fallback : β} {f : β → β} : getD (modify k f t) k' fallback = if compare k k' = Ordering.eq then (Option.map f (get? t k)).getD fallback else getD t k' fallback

@[simp]

theorem Std.DTreeMap.Internal.Impl.Const.getD_modify_self {α : Type u} {instOrd : Ord α} [TransOrd α] {β : Type v} {t : Impl α fun (x : α) => β} (h : t.WF) {k : α} {fallback : β} {f : β → β} : getD (modify k f t) k fallback = (Option.map f (get? t k)).getD fallback

theorem Std.DTreeMap.Internal.Impl.Const.getKey?_modify {α : Type u} {instOrd : Ord α} [TransOrd α] {β : Type v} {t : Impl α fun (x : α) => β} (h : t.WF) {k k' : α} {f : β → β} : (modify k f t).getKey? k' = if compare k k' = Ordering.eq then if k ∈ t then some k else none else t.getKey? k'

theorem Std.DTreeMap.Internal.Impl.Const.getKey?_modify_self {α : Type u} {instOrd : Ord α} [TransOrd α] {β : Type v} {t : Impl α fun (x : α) => β} (h : t.WF) {k : α} {f : β → β} : (modify k f t).getKey? k = if k ∈ t then some k else none

theorem Std.DTreeMap.Internal.Impl.Const.getKey!_modify {α : Type u} {instOrd : Ord α} [TransOrd α] {β : Type v} {t : Impl α fun (x : α) => β} (h : t.WF) [Inhabited α] {k k' : α} {f : β → β} : (modify k f t).getKey! k' = if compare k k' = Ordering.eq then if k ∈ t then k else default else t.getKey! k'

theorem Std.DTreeMap.Internal.Impl.Const.getKey!_modify_self {α : Type u} {instOrd : Ord α} [TransOrd α] {β : Type v} {t : Impl α fun (x : α) => β} (h : t.WF) [Inhabited α] {k : α} {f : β → β} : (modify k f t).getKey! k = if k ∈ t then k else default

theorem Std.DTreeMap.Internal.Impl.Const.getKey_modify {α : Type u} {instOrd : Ord α} [TransOrd α] {β : Type v} {t : Impl α fun (x : α) => β} (h : t.WF) [Inhabited α] {k k' : α} {f : β → β} {hc : k' ∈ modify k f t} : (modify k f t).getKey k' hc = if compare k k' = Ordering.eq then k else t.getKey k' ⋯

@[simp]

theorem Std.DTreeMap.Internal.Impl.Const.getKey_modify_self {α : Type u} {instOrd : Ord α} [TransOrd α] {β : Type v} {t : Impl α fun (x : α) => β} (h : t.WF) [Inhabited α] {k : α} {f : β → β} {hc : k ∈ modify k f t} : (modify k f t).getKey k hc = k

theorem Std.DTreeMap.Internal.Impl.Const.getKeyD_modify {α : Type u} {instOrd : Ord α} [TransOrd α] {β : Type v} {t : Impl α fun (x : α) => β} (h : t.WF) {k k' fallback : α} {f : β → β} : (modify k f t).getKeyD k' fallback = if compare k k' = Ordering.eq then if k ∈ t then k else fallback else t.getKeyD k' fallback

theorem Std.DTreeMap.Internal.Impl.Const.getKeyD_modify_self {α : Type u} {instOrd : Ord α} [TransOrd α] {β : Type v} {t : Impl α fun (x : α) => β} (h : t.WF) [Inhabited α] {k fallback : α} {f : β → β} : (modify k f t).getKeyD k fallback = if k ∈ t then k else fallback

theorem Std.DTreeMap.Internal.Impl.minKey?_empty {α : Type u} {β : α → Type v} : empty.minKey? = none

theorem Std.DTreeMap.Internal.Impl.minKey?_of_isEmpty {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] (h : t.WF) (he : t.isEmpty = true) : t.minKey? = none

theorem Std.DTreeMap.Internal.Impl.minKey?_eq_none_iff {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] (h : t.WF) : t.minKey? = none ↔ t.isEmpty = true

theorem Std.DTreeMap.Internal.Impl.minKey?_eq_some_iff_getKey?_eq_self_and_forall {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] (h : t.WF) {km : α} : t.minKey? = some km ↔ t.getKey? km = some km ∧ ∀ (k : α), k ∈ t → (compare km k).isLE = true

theorem Std.DTreeMap.Internal.Impl.minKey?_eq_some_iff_mem_and_forall {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] [LawfulEqOrd α] (h : t.WF) {km : α} : t.minKey? = some km ↔ km ∈ t ∧ ∀ (k : α), k ∈ t → (compare km k).isLE = true

theorem Std.DTreeMap.Internal.Impl.isNone_minKey?_eq_isEmpty {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] (h : t.WF) : t.minKey?.isNone = t.isEmpty

theorem Std.DTreeMap.Internal.Impl.isSome_minKey?_eq_not_isEmpty {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] (h : t.WF) : t.minKey?.isSome = !t.isEmpty

theorem Std.DTreeMap.Internal.Impl.isSome_minKey?_iff_isEmpty_eq_false {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] (h : t.WF) : t.minKey?.isSome = true ↔ t.isEmpty = false

theorem Std.DTreeMap.Internal.Impl.minKey?_insert {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] (h : t.WF) {k : α} {v : β k} : (insert k v t ⋯).impl.minKey? = some (t.minKey?.elim k fun (k' : α) => if (compare k k').isLE = true then k else k')

theorem Std.DTreeMap.Internal.Impl.minKey?_insert! {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] (h : t.WF) {k : α} {v : β k} : (insert! k v t).minKey? = some (t.minKey?.elim k fun (k' : α) => if (compare k k').isLE = true then k else k')

theorem Std.DTreeMap.Internal.Impl.isSome_minKey?_insert {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] (h : t.WF) {k : α} {v : β k} : (insert k v t ⋯).impl.minKey?.isSome = true

theorem Std.DTreeMap.Internal.Impl.isSome_minKey?_insert! {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] (h : t.WF) {k : α} {v : β k} : (insert! k v t).minKey?.isSome = true

theorem Std.DTreeMap.Internal.Impl.minKey_insert_of_isEmpty {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] (h : t.WF) {k : α} {v : β k} (he : t.isEmpty = true) : (insert k v t ⋯).impl.minKey ⋯ = k

theorem Std.DTreeMap.Internal.Impl.minKey_insert!_of_isEmpty {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] (h : t.WF) {k : α} {v : β k} (he : t.isEmpty = true) : (insert! k v t).minKey ⋯ = k

theorem Std.DTreeMap.Internal.Impl.minKey?_insert_of_isEmpty {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] (h : t.WF) {k : α} {v : β k} (he : t.isEmpty = true) : (insert k v t ⋯).impl.minKey? = some k

theorem Std.DTreeMap.Internal.Impl.minKey?_insert!_of_isEmpty {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] (h : t.WF) {k : α} {v : β k} (he : t.isEmpty = true) : (insert! k v t).minKey? = some k

theorem Std.DTreeMap.Internal.Impl.minKey!_insert_of_isEmpty {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] [Inhabited α] (h : t.WF) {k : α} {v : β k} (he : t.isEmpty = true) : (insert k v t ⋯).impl.minKey! = k

theorem Std.DTreeMap.Internal.Impl.minKey!_insert!_of_isEmpty {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] [Inhabited α] (h : t.WF) {k : α} {v : β k} (he : t.isEmpty = true) : (insert! k v t).minKey! = k

theorem Std.DTreeMap.Internal.Impl.minKeyD_insert_of_isEmpty {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] (h : t.WF) {k : α} {v : β k} (he : t.isEmpty = true) {fallback : α} : (insert k v t ⋯).impl.minKeyD fallback = k

theorem Std.DTreeMap.Internal.Impl.minKeyD_insert!_of_isEmpty {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] (h : t.WF) {k : α} {v : β k} (he : t.isEmpty = true) {fallback : α} : (insert! k v t).minKeyD fallback = k

theorem Std.DTreeMap.Internal.Impl.minKey_insertIfNew_of_isEmpty {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] (h : t.WF) {k : α} {v : β k} (he : t.isEmpty = true) : (insertIfNew k v t ⋯).impl.minKey ⋯ = k

theorem Std.DTreeMap.Internal.Impl.minKey_insertIfNew!_of_isEmpty {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] (h : t.WF) {k : α} {v : β k} (he : t.isEmpty = true) : (insertIfNew! k v t).minKey ⋯ = k

theorem Std.DTreeMap.Internal.Impl.minKey?_insertIfNew_of_isEmpty {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] (h : t.WF) {k : α} {v : β k} (he : t.isEmpty = true) : (insertIfNew k v t ⋯).impl.minKey? = some k

theorem Std.DTreeMap.Internal.Impl.minKey?_insertIfNew!_of_isEmpty {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] (h : t.WF) {k : α} {v : β k} (he : t.isEmpty = true) : (insertIfNew! k v t).minKey? = some k

theorem Std.DTreeMap.Internal.Impl.minKey!_insertIfNew_of_isEmpty {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] [Inhabited α] (h : t.WF) {k : α} {v : β k} (he : t.isEmpty = true) : (insertIfNew k v t ⋯).impl.minKey! = k

theorem Std.DTreeMap.Internal.Impl.minKey!_insertIfNew!_of_isEmpty {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] [Inhabited α] (h : t.WF) {k : α} {v : β k} (he : t.isEmpty = true) : (insertIfNew! k v t).minKey! = k

theorem Std.DTreeMap.Internal.Impl.minKeyD_insertIfNew_of_isEmpty {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] (h : t.WF) {k : α} {v : β k} (he : t.isEmpty = true) {fallback : α} : (insertIfNew k v t ⋯).impl.minKeyD fallback = k

theorem Std.DTreeMap.Internal.Impl.minKeyD_insertIfNew!_of_isEmpty {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] (h : t.WF) {k : α} {v : β k} (he : t.isEmpty = true) {fallback : α} : (insertIfNew! k v t).minKeyD fallback = k

theorem Std.DTreeMap.Internal.Impl.minKey?_insert_le_minKey? {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] (h : t.WF) {k : α} {v : β k} {km kmi : α} (hkm : t.minKey? = some km) (hkmi : (insert k v t ⋯).impl.minKey?.get ⋯ = kmi) : (compare kmi km).isLE = true

theorem Std.DTreeMap.Internal.Impl.minKey?_insert!_le_minKey? {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] (h : t.WF) {k : α} {v : β k} {km kmi : α} (hkm : t.minKey? = some km) (hkmi : (insert! k v t).minKey?.get ⋯ = kmi) : (compare kmi km).isLE = true

theorem Std.DTreeMap.Internal.Impl.minKey?_insert_le_self {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] (h : t.WF) {k : α} {v : β k} {kmi : α} (hkmi : (insert k v t ⋯).impl.minKey?.get ⋯ = kmi) : (compare kmi k).isLE = true

theorem Std.DTreeMap.Internal.Impl.minKey?_insert!_le_self {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] (h : t.WF) {k : α} {v : β k} {kmi : α} (hkmi : (insert! k v t).minKey?.get ⋯ = kmi) : (compare kmi k).isLE = true

theorem Std.DTreeMap.Internal.Impl.contains_minKey? {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] (h : t.WF) {km : α} (hkm : t.minKey? = some km) : contains km t = true

theorem Std.DTreeMap.Internal.Impl.minKey?_mem {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] (h : t.WF) {km : α} (hkm : t.minKey? = some km) : km ∈ t

theorem Std.DTreeMap.Internal.Impl.min?_keys {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] [Min α] [LE α] [LawfulOrderOrd α] [LawfulOrderMin α] [LawfulOrderLeftLeaningMin α] [LawfulEqOrd α] (h : t.WF) : t.keys.min? = t.minKey?

theorem Std.DTreeMap.Internal.Impl.head?_keys {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] [Min α] [LE α] [LawfulOrderOrd α] [LawfulOrderMin α] [LawfulOrderLeftLeaningMin α] [LawfulEqOrd α] (h : t.WF) : t.keys.head? = t.minKey?

theorem Std.DTreeMap.Internal.Impl.isSome_minKey?_of_contains {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] (h : t.WF) {k : α} (hc : contains k t = true) : t.minKey?.isSome = true

theorem Std.DTreeMap.Internal.Impl.isSome_minKey?_of_mem {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] (h : t.WF) {k : α} : k ∈ t → t.minKey?.isSome = true

theorem Std.DTreeMap.Internal.Impl.minKey?_le_of_contains {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] (h : t.WF) {k km : α} (hc : contains k t = true) (hkm : t.minKey?.get ⋯ = km) : (compare km k).isLE = true

theorem Std.DTreeMap.Internal.Impl.minKey?_le_of_mem {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] (h : t.WF) {k km : α} (hc : k ∈ t) (hkm : t.minKey?.get ⋯ = km) : (compare km k).isLE = true

theorem Std.DTreeMap.Internal.Impl.le_minKey? {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] {k : α} (h : t.WF) : (∀ (k' : α), t.minKey? = some k' → (compare k k').isLE = true) ↔ ∀ (k' : α), k' ∈ t → (compare k k').isLE = true

theorem Std.DTreeMap.Internal.Impl.getKey?_minKey? {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] (h : t.WF) {km : α} (hkm : t.minKey? = some km) : t.getKey? km = some km

theorem Std.DTreeMap.Internal.Impl.getKey_minKey? {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] (h : t.WF) {km : α} {hc : contains km t = true} (hkm : t.minKey?.get ⋯ = km) : t.getKey km hc = km

theorem Std.DTreeMap.Internal.Impl.getKey!_minKey? {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] [Inhabited α] (h : t.WF) {km : α} (hkm : t.minKey? = some km) : t.getKey! km = km

theorem Std.DTreeMap.Internal.Impl.getKeyD_minKey? {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] (h : t.WF) {km fallback : α} (hkm : t.minKey? = some km) : t.getKeyD km fallback = km

@[simp]

theorem Std.DTreeMap.Internal.Impl.minKey?_bind_getKey? {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] (h : t.WF) : t.minKey?.bind t.getKey? = t.minKey?

theorem Std.DTreeMap.Internal.Impl.minKey?_erase_eq_iff_not_compare_eq_minKey? {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] (h : t.WF) {k : α} : (erase k t ⋯).impl.minKey? = t.minKey? ↔ ∀ {km : α}, t.minKey? = some km → ¬compare k km = Ordering.eq

theorem Std.DTreeMap.Internal.Impl.minKey?_erase!_eq_iff_not_compare_eq_minKey? {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] (h : t.WF) {k : α} : (erase! k t).minKey? = t.minKey? ↔ ∀ {km : α}, t.minKey? = some km → ¬compare k km = Ordering.eq

theorem Std.DTreeMap.Internal.Impl.minKey?_erase_eq_of_not_compare_eq_minKey? {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] (h : t.WF) {k : α} (hc : ∀ {km : α}, t.minKey? = some km → ¬compare k km = Ordering.eq) : (erase k t ⋯).impl.minKey? = t.minKey?

theorem Std.DTreeMap.Internal.Impl.minKey?_erase!_eq_of_not_compare_eq_minKey? {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] (h : t.WF) {k : α} (hc : ∀ {km : α}, t.minKey? = some km → ¬compare k km = Ordering.eq) : (erase! k t).minKey? = t.minKey?

theorem Std.DTreeMap.Internal.Impl.isSome_minKey?_of_isSome_minKey?_erase {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] (h : t.WF) {k : α} (hs : (erase k t ⋯).impl.minKey?.isSome = true) : t.minKey?.isSome = true

theorem Std.DTreeMap.Internal.Impl.isSome_minKey?_of_isSome_minKey?_erase! {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] (h : t.WF) {k : α} (hs : (erase! k t).minKey?.isSome = true) : t.minKey?.isSome = true

theorem Std.DTreeMap.Internal.Impl.minKey?_le_minKey?_erase {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] (h : t.WF) {k km kme : α} (hkme : (erase k t ⋯).impl.minKey? = some kme) (hkm : t.minKey?.get ⋯ = km) : (compare km kme).isLE = true

theorem Std.DTreeMap.Internal.Impl.minKey?_le_minKey?_erase! {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] (h : t.WF) {k km kme : α} (hkme : (erase! k t).minKey? = some kme) (hkm : t.minKey?.get ⋯ = km) : (compare km kme).isLE = true

theorem Std.DTreeMap.Internal.Impl.minKey?_insertIfNew {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] (h : t.WF) {k : α} {v : β k} : (insertIfNew k v t ⋯).impl.minKey? = some (t.minKey?.elim k fun (k' : α) => if compare k k' = Ordering.lt then k else k')

theorem Std.DTreeMap.Internal.Impl.minKey?_insertIfNew! {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] (h : t.WF) {k : α} {v : β k} : (insertIfNew! k v t).minKey? = some (t.minKey?.elim k fun (k' : α) => if compare k k' = Ordering.lt then k else k')

theorem Std.DTreeMap.Internal.Impl.isSome_minKey?_insertIfNew {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] (h : t.WF) {k : α} {v : β k} : (insertIfNew k v t ⋯).impl.minKey?.isSome = true

theorem Std.DTreeMap.Internal.Impl.isSome_minKey?_insertIfNew! {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] (h : t.WF) {k : α} {v : β k} : (insertIfNew! k v t).minKey?.isSome = true

theorem Std.DTreeMap.Internal.Impl.minKey?_insertIfNew_le_minKey? {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] (h : t.WF) {k : α} {v : β k} {km kmi : α} (hkm : t.minKey? = some km) (hkmi : (insertIfNew k v t ⋯).impl.minKey?.get ⋯ = kmi) : (compare kmi km).isLE = true

theorem Std.DTreeMap.Internal.Impl.minKey?_insertIfNew!_le_minKey? {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] (h : t.WF) {k : α} {v : β k} {km kmi : α} (hkm : t.minKey? = some km) (hkmi : (insertIfNew! k v t).minKey?.get ⋯ = kmi) : (compare kmi km).isLE = true

theorem Std.DTreeMap.Internal.Impl.minKey?_insertIfNew_le_self {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] (h : t.WF) {k : α} {v : β k} {kmi : α} (hkmi : (insertIfNew k v t ⋯).impl.minKey?.get ⋯ = kmi) : (compare kmi k).isLE = true

theorem Std.DTreeMap.Internal.Impl.minKey?_insertIfNew!_le_self {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] (h : t.WF) {k : α} {v : β k} {kmi : α} (hkmi : (insertIfNew! k v t).minKey?.get ⋯ = kmi) : (compare kmi k).isLE = true

theorem Std.DTreeMap.Internal.Impl.minKey?_eq_head?_keys {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] (h : t.WF) : t.minKey? = t.keys.head?

theorem Std.DTreeMap.Internal.Impl.minKey?_eq_getElem?_keysArray {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] (h : t.WF) : t.minKey? = t.keysArray[0]?

theorem Std.DTreeMap.Internal.Impl.minKey?_modify {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] [LawfulEqOrd α] {k : α} {f : β k → β k} (h : t.WF) : (modify k f t).minKey? = t.minKey?

theorem Std.DTreeMap.Internal.Impl.minKey?_alter_eq_self {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] [LawfulEqOrd α] (h : t.WF) {k : α} {f : Option (β k) → Option (β k)} : (alter k f t ⋯).impl.minKey? = some k ↔ (f (t.get? k)).isSome = true ∧ ∀ (k' : α), k' ∈ t → (compare k k').isLE = true

theorem Std.DTreeMap.Internal.Impl.minKey?_alter!_eq_self {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] [LawfulEqOrd α] (h : t.WF) {k : α} {f : Option (β k) → Option (β k)} : (alter! k f t).minKey? = some k ↔ (f (t.get? k)).isSome = true ∧ ∀ (k' : α), k' ∈ t → (compare k k').isLE = true

theorem Std.DTreeMap.Internal.Impl.Const.minKey?_modify {α : Type u} {instOrd : Ord α} {β : Type v} {t : Impl α fun (x : α) => β} [TransOrd α] (h : t.WF) {k : α} {f : β → β} : (modify k f t).minKey? = Option.map (fun (km : α) => if compare km k = Ordering.eq then k else km) t.minKey?

theorem Std.DTreeMap.Internal.Impl.Const.minKey?_modify_eq_minKey? {α : Type u} {instOrd : Ord α} {β : Type v} {t : Impl α fun (x : α) => β} [TransOrd α] [LawfulEqOrd α] (h : t.WF) {k : α} {f : β → β} : (modify k f t).minKey? = t.minKey?

theorem Std.DTreeMap.Internal.Impl.Const.isSome_minKey?_modify {α : Type u} {instOrd : Ord α} {β : Type v} {t : Impl α fun (x : α) => β} [TransOrd α] {k : α} {f : β → β} (h : t.WF) : (modify k f t).minKey?.isSome = !t.isEmpty

theorem Std.DTreeMap.Internal.Impl.Const.isSome_minKey?_modify_eq_isSome {α : Type u} {instOrd : Ord α} {β : Type v} {t : Impl α fun (x : α) => β} [TransOrd α] (h : t.WF) {k : α} {f : β → β} : (modify k f t).minKey?.isSome = t.minKey?.isSome

theorem Std.DTreeMap.Internal.Impl.Const.compare_minKey?_modify_eq {α : Type u} {instOrd : Ord α} {β : Type v} {t : Impl α fun (x : α) => β} [TransOrd α] (h : t.WF) {k : α} {f : β → β} {km kmm : α} (hkm : t.minKey? = some km) (hkmm : (modify k f t).minKey?.get ⋯ = kmm) : compare kmm km = Ordering.eq

theorem Std.DTreeMap.Internal.Impl.Const.minKey?_alter_eq_self {α : Type u} {instOrd : Ord α} {β : Type v} {t : Impl α fun (x : α) => β} [TransOrd α] (h : t.WF) {k : α} {f : Option β → Option β} : (alter k f t ⋯).impl.minKey? = some k ↔ (f (get? t k)).isSome = true ∧ ∀ (k' : α), k' ∈ t → (compare k k').isLE = true

theorem Std.DTreeMap.Internal.Impl.Const.minKey?_alter!_eq_self {α : Type u} {instOrd : Ord α} {β : Type v} {t : Impl α fun (x : α) => β} [TransOrd α] (h : t.WF) {k : α} {f : Option β → Option β} : (alter! k f t).minKey? = some k ↔ (f (get? t k)).isSome = true ∧ ∀ (k' : α), k' ∈ t → (compare k k').isLE = true

theorem Std.DTreeMap.Internal.Impl.minKey_eq_get_minKey? {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] (h : t.WF) {he : t.isEmpty = false} : t.minKey he = t.minKey?.get ⋯

theorem Std.DTreeMap.Internal.Impl.minKey?_eq_some_minKey {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] (h : t.WF) {he : t.isEmpty = false} : t.minKey? = some (t.minKey he)

theorem Std.DTreeMap.Internal.Impl.minKey_eq_iff_getKey?_eq_self_and_forall {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] (h : t.WF) {he : t.isEmpty = false} {km : α} : t.minKey he = km ↔ t.getKey? km = some km ∧ ∀ (k : α), k ∈ t → (compare km k).isLE = true

theorem Std.DTreeMap.Internal.Impl.minKey_eq_iff_mem_and_forall {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] [LawfulEqOrd α] (h : t.WF) {he : t.isEmpty = false} {km : α} : t.minKey he = km ↔ km ∈ t ∧ ∀ (k : α), k ∈ t → (compare km k).isLE = true

theorem Std.DTreeMap.Internal.Impl.minKey_insert {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] (h : t.WF) {k : α} {v : β k} : (insert k v t ⋯).impl.minKey ⋯ = t.minKey?.elim k fun (k' : α) => if (compare k k').isLE = true then k else k'

theorem Std.DTreeMap.Internal.Impl.minKey_insert_le_minKey {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] (h : t.WF) {k : α} {v : β k} {he : t.isEmpty = false} : (compare ((insert k v t ⋯).impl.minKey ⋯) (t.minKey he)).isLE = true

theorem Std.DTreeMap.Internal.Impl.minKey_insert_le_self {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] (h : t.WF) {k : α} {v : β k} : (compare ((insert k v t ⋯).impl.minKey ⋯) k).isLE = true

theorem Std.DTreeMap.Internal.Impl.contains_minKey {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] (h : t.WF) {he : t.isEmpty = false} : contains (t.minKey he) t = true

theorem Std.DTreeMap.Internal.Impl.minKey_mem {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] (h : t.WF) {he : t.isEmpty = false} : t.minKey he ∈ t

theorem Std.DTreeMap.Internal.Impl.minKey_le_of_contains {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] (h : t.WF) {k : α} (hc : contains k t = true) : (compare (t.minKey ⋯) k).isLE = true

theorem Std.DTreeMap.Internal.Impl.minKey_le_of_mem {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] (h : t.WF) {k : α} (hc : k ∈ t) : (compare (t.minKey ⋯) k).isLE = true

theorem Std.DTreeMap.Internal.Impl.le_minKey {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] (h : t.WF) {k : α} {he : t.isEmpty = false} : (compare k (t.minKey he)).isLE = true ↔ ∀ (k' : α), k' ∈ t → (compare k k').isLE = true

theorem Std.DTreeMap.Internal.Impl.getKey?_minKey {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] (h : t.WF) {he : t.isEmpty = false} : t.getKey? (t.minKey he) = some (t.minKey he)

theorem Std.DTreeMap.Internal.Impl.getKey_minKey {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] (h : t.WF) {he : t.isEmpty = false} {hc : contains (t.minKey he) t = true} : t.getKey (t.minKey he) hc = t.minKey he

theorem Std.DTreeMap.Internal.Impl.getKey!_minKey {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] [Inhabited α] (h : t.WF) {he : t.isEmpty = false} : t.getKey! (t.minKey he) = t.minKey he

theorem Std.DTreeMap.Internal.Impl.getKeyD_minKey {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] (h : t.WF) {he : t.isEmpty = false} {fallback : α} : t.getKeyD (t.minKey he) fallback = t.minKey he

theorem Std.DTreeMap.Internal.Impl.minKey_erase_eq_iff_not_compare_eq_minKey {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] (h : t.WF) {k : α} {he : (erase k t ⋯).impl.isEmpty = false} : (erase k t ⋯).impl.minKey he = t.minKey ⋯ ↔ ¬compare k (t.minKey ⋯) = Ordering.eq

theorem Std.DTreeMap.Internal.Impl.minKey_erase_eq_of_not_compare_eq_minKey {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] (h : t.WF) {k : α} {he : (erase k t ⋯).impl.isEmpty = false} (hc : ¬compare k (t.minKey ⋯) = Ordering.eq) : (erase k t ⋯).impl.minKey he = t.minKey ⋯

theorem Std.DTreeMap.Internal.Impl.minKey_le_minKey_erase {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] (h : t.WF) {k : α} {he : (erase k t ⋯).impl.isEmpty = false} : (compare (t.minKey ⋯) ((erase k t ⋯).impl.minKey he)).isLE = true

theorem Std.DTreeMap.Internal.Impl.minKey_insertIfNew {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] (h : t.WF) {k : α} {v : β k} : (insertIfNew k v t ⋯).impl.minKey ⋯ = t.minKey?.elim k fun (k' : α) => if compare k k' = Ordering.lt then k else k'

theorem Std.DTreeMap.Internal.Impl.minKey_insertIfNew_le_minKey {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] (h : t.WF) {k : α} {v : β k} {he : t.isEmpty = false} : (compare ((insertIfNew k v t ⋯).impl.minKey ⋯) (t.minKey he)).isLE = true

theorem Std.DTreeMap.Internal.Impl.minKey_insertIfNew_le_self {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] (h : t.WF) {k : α} {v : β k} : (compare ((insertIfNew k v t ⋯).impl.minKey ⋯) k).isLE = true

theorem Std.DTreeMap.Internal.Impl.minKey_eq_head_keys {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] (h : t.WF) {he : t.isEmpty = false} : t.minKey he = t.keys.head ⋯

theorem Std.DTreeMap.Internal.Impl.minKey_eq_getElem_keysArray {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] (h : t.WF) {he : t.isEmpty = false} : t.minKey he = t.keysArray[0]

theorem Std.DTreeMap.Internal.Impl.minKey_modify {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] [LawfulEqOrd α] (h : t.WF) {k : α} {f : β k → β k} {he : (modify k f t).isEmpty = false} : (modify k f t).minKey he = t.minKey ⋯

theorem Std.DTreeMap.Internal.Impl.minKey_alter_eq_self {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] [LawfulEqOrd α] (h : t.WF) {k : α} {f : Option (β k) → Option (β k)} {he : (alter k f t ⋯).impl.isEmpty = false} : (alter k f t ⋯).impl.minKey he = k ↔ (f (t.get? k)).isSome = true ∧ ∀ (k' : α), k' ∈ t → (compare k k').isLE = true

theorem Std.DTreeMap.Internal.Impl.Const.minKey_modify {α : Type u} {instOrd : Ord α} {β : Type v} {t : Impl α fun (x : α) => β} [TransOrd α] (h : t.WF) {k : α} {f : β → β} {he : (modify k f t).isEmpty = false} : (modify k f t).minKey he = if compare (t.minKey ⋯) k = Ordering.eq then k else t.minKey ⋯

theorem Std.DTreeMap.Internal.Impl.Const.minKey_modify_eq_minKey {α : Type u} {instOrd : Ord α} {β : Type v} {t : Impl α fun (x : α) => β} [TransOrd α] [LawfulEqOrd α] (h : t.WF) {k : α} {f : β → β} {he : (modify k f t).isEmpty = false} : (modify k f t).minKey he = t.minKey ⋯

theorem Std.DTreeMap.Internal.Impl.Const.compare_minKey_modify_eq {α : Type u} {instOrd : Ord α} {β : Type v} {t : Impl α fun (x : α) => β} [TransOrd α] (h : t.WF) {k : α} {f : β → β} {he : (modify k f t).isEmpty = false} : compare ((modify k f t).minKey he) (t.minKey ⋯) = Ordering.eq

theorem Std.DTreeMap.Internal.Impl.Const.minKey_alter_eq_self {α : Type u} {instOrd : Ord α} {β : Type v} {t : Impl α fun (x : α) => β} [TransOrd α] (h : t.WF) {k : α} {f : Option β → Option β} {he : (alter k f t ⋯).impl.isEmpty = false} : (alter k f t ⋯).impl.minKey he = k ↔ (f (get? t k)).isSome = true ∧ ∀ (k' : α), k' ∈ t → (compare k k').isLE = true

theorem Std.DTreeMap.Internal.Impl.minKey_eq_minKey! {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] [Inhabited α] (h : t.WF) {he : t.isEmpty = false} : t.minKey he = t.minKey!

theorem Std.DTreeMap.Internal.Impl.minKey?_eq_some_minKey! {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] [Inhabited α] (h : t.WF) (he : t.isEmpty = false) : t.minKey? = some t.minKey!

theorem Std.DTreeMap.Internal.Impl.minKey!_eq_default {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] [Inhabited α] (h : t.WF) (he : t.isEmpty = true) : t.minKey! = default

theorem Std.DTreeMap.Internal.Impl.minKey!_eq_iff_getKey?_eq_self_and_forall {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] [Inhabited α] (h : t.WF) (he : t.isEmpty = false) {km : α} : t.minKey! = km ↔ t.getKey? km = some km ∧ ∀ (k : α), k ∈ t → (compare km k).isLE = true

theorem Std.DTreeMap.Internal.Impl.minKey!_eq_iff_mem_and_forall {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] [LawfulEqOrd α] [Inhabited α] (h : t.WF) (he : t.isEmpty = false) {km : α} : t.minKey! = km ↔ km ∈ t ∧ ∀ (k : α), k ∈ t → (compare km k).isLE = true

theorem Std.DTreeMap.Internal.Impl.minKey!_insert {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] [Inhabited α] (h : t.WF) {k : α} {v : β k} : (insert k v t ⋯).impl.minKey! = t.minKey?.elim k fun (k' : α) => if (compare k k').isLE = true then k else k'

theorem Std.DTreeMap.Internal.Impl.minKey!_insert! {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] [Inhabited α] (h : t.WF) {k : α} {v : β k} : (insert! k v t).minKey! = t.minKey?.elim k fun (k' : α) => if (compare k k').isLE = true then k else k'

theorem Std.DTreeMap.Internal.Impl.minKey!_insert_le_minKey! {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] [Inhabited α] (h : t.WF) (he : t.isEmpty = false) {k : α} {v : β k} : (compare (insert k v t ⋯).impl.minKey! t.minKey!).isLE = true

theorem Std.DTreeMap.Internal.Impl.minKey!_insert!_le_minKey! {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] [Inhabited α] (h : t.WF) (he : t.isEmpty = false) {k : α} {v : β k} : (compare (insert! k v t).minKey! t.minKey!).isLE = true

theorem Std.DTreeMap.Internal.Impl.minKey!_insert_le_self {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] [Inhabited α] (h : t.WF) {k : α} {v : β k} : (compare (insert k v t ⋯).impl.minKey! k).isLE = true

theorem Std.DTreeMap.Internal.Impl.minKey!_insert!_le_self {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] [Inhabited α] (h : t.WF) {k : α} {v : β k} : (compare (insert! k v t).minKey! k).isLE = true

theorem Std.DTreeMap.Internal.Impl.contains_minKey! {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] [Inhabited α] (h : t.WF) (he : t.isEmpty = false) : contains t.minKey! t = true

theorem Std.DTreeMap.Internal.Impl.minKey!_mem {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] [Inhabited α] (h : t.WF) (he : t.isEmpty = false) : t.minKey! ∈ t

theorem Std.DTreeMap.Internal.Impl.minKey!_le_of_contains {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] [Inhabited α] (h : t.WF) {k : α} (hc : contains k t = true) : (compare t.minKey! k).isLE = true

theorem Std.DTreeMap.Internal.Impl.minKey!_le_of_mem {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] [Inhabited α] (h : t.WF) {k : α} (hc : k ∈ t) : (compare t.minKey! k).isLE = true

theorem Std.DTreeMap.Internal.Impl.le_minKey! {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] [Inhabited α] (h : t.WF) (he : t.isEmpty = false) {k : α} : (compare k t.minKey!).isLE = true ↔ ∀ (k' : α), k' ∈ t → (compare k k').isLE = true

theorem Std.DTreeMap.Internal.Impl.getKey?_minKey! {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] [Inhabited α] (h : t.WF) (he : t.isEmpty = false) : t.getKey? t.minKey! = some t.minKey!

theorem Std.DTreeMap.Internal.Impl.getKey_minKey! {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] [Inhabited α] (h : t.WF) {he : contains t.minKey! t = true} : t.getKey t.minKey! he = t.minKey!

theorem Std.DTreeMap.Internal.Impl.getKey_minKey!_eq_minKey {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] [Inhabited α] (h : t.WF) {hc : contains t.minKey! t = true} : t.getKey t.minKey! hc = t.minKey ⋯

theorem Std.DTreeMap.Internal.Impl.getKey!_minKey! {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] [Inhabited α] (h : t.WF) (he : t.isEmpty = false) : t.getKey! t.minKey! = t.minKey!

theorem Std.DTreeMap.Internal.Impl.getKeyD_minKey! {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] [Inhabited α] (h : t.WF) (he : t.isEmpty = false) {fallback : α} : t.getKeyD t.minKey! fallback = t.minKey!

theorem Std.DTreeMap.Internal.Impl.minKey!_erase_eq_iff_not_compare_minKey!_eq {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] [Inhabited α] (h : t.WF) {k : α} (he : (erase k t ⋯).impl.isEmpty = false) : (erase k t ⋯).impl.minKey! = t.minKey! ↔ ¬compare k t.minKey! = Ordering.eq

theorem Std.DTreeMap.Internal.Impl.minKey!_erase!_eq_iff_not_compare_minKey!_eq {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] [Inhabited α] (h : t.WF) {k : α} (he : (erase! k t).isEmpty = false) : (erase! k t).minKey! = t.minKey! ↔ ¬compare k t.minKey! = Ordering.eq

theorem Std.DTreeMap.Internal.Impl.minKey!_erase_eq_of_not_compare_minKey!_eq {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] [Inhabited α] (h : t.WF) {k : α} (he : (erase k t ⋯).impl.isEmpty = false) (heq : ¬compare k t.minKey! = Ordering.eq) : (erase k t ⋯).impl.minKey! = t.minKey!

theorem Std.DTreeMap.Internal.Impl.minKey!_erase!_eq_of_not_compare_minKey!_eq {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] [Inhabited α] (h : t.WF) {k : α} (he : (erase! k t).isEmpty = false) (heq : ¬compare k t.minKey! = Ordering.eq) : (erase! k t).minKey! = t.minKey!

theorem Std.DTreeMap.Internal.Impl.minKey!_le_minKey!_erase {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] [Inhabited α] (h : t.WF) {k : α} (he : (erase k t ⋯).impl.isEmpty = false) : (compare t.minKey! (erase k t ⋯).impl.minKey!).isLE = true

theorem Std.DTreeMap.Internal.Impl.minKey!_le_minKey!_erase! {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] [Inhabited α] (h : t.WF) {k : α} (he : (erase! k t).isEmpty = false) : (compare t.minKey! (erase! k t).minKey!).isLE = true

theorem Std.DTreeMap.Internal.Impl.minKey!_insertIfNew {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] [Inhabited α] (h : t.WF) {k : α} {v : β k} : (insertIfNew k v t ⋯).impl.minKey! = t.minKey?.elim k fun (k' : α) => if compare k k' = Ordering.lt then k else k'

theorem Std.DTreeMap.Internal.Impl.minKey!_insertIfNew! {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] [Inhabited α] (h : t.WF) {k : α} {v : β k} : (insertIfNew! k v t).minKey! = t.minKey?.elim k fun (k' : α) => if compare k k' = Ordering.lt then k else k'

theorem Std.DTreeMap.Internal.Impl.minKey!_insertIfNew_le_minKey! {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] [Inhabited α] (h : t.WF) (he : t.isEmpty = false) {k : α} {v : β k} : (compare (insertIfNew k v t ⋯).impl.minKey! t.minKey!).isLE = true

theorem Std.DTreeMap.Internal.Impl.minKey!_insertIfNew!_le_minKey! {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] [Inhabited α] (h : t.WF) (he : t.isEmpty = false) {k : α} {v : β k} : (compare (insertIfNew! k v t).minKey! t.minKey!).isLE = true

theorem Std.DTreeMap.Internal.Impl.minKey!_insertIfNew_le_self {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] [Inhabited α] (h : t.WF) {k : α} {v : β k} : (compare (insertIfNew k v t ⋯).impl.minKey! k).isLE = true

theorem Std.DTreeMap.Internal.Impl.minKey!_insertIfNew!_le_self {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] [Inhabited α] (h : t.WF) {k : α} {v : β k} : (compare (insertIfNew! k v t).minKey! k).isLE = true

theorem Std.DTreeMap.Internal.Impl.minKey!_eq_head!_keys {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] [Inhabited α] (h : t.WF) : t.minKey! = t.keys.head!

theorem Std.DTreeMap.Internal.Impl.minKey!_eq_getElem!_keysArray {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] [Inhabited α] (h : t.WF) : t.minKey! = t.keysArray[0]!

theorem Std.DTreeMap.Internal.Impl.minKey!_modify {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] [LawfulEqOrd α] [Inhabited α] (h : t.WF) {k : α} {f : β k → β k} : (modify k f t).minKey! = t.minKey!

theorem Std.DTreeMap.Internal.Impl.minKey!_alter_eq_self {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] [LawfulEqOrd α] [Inhabited α] (h : t.WF) {k : α} {f : Option (β k) → Option (β k)} (he : (alter k f t ⋯).impl.isEmpty = false) : (alter k f t ⋯).impl.minKey! = k ↔ (f (t.get? k)).isSome = true ∧ ∀ (k' : α), k' ∈ t → (compare k k').isLE = true

theorem Std.DTreeMap.Internal.Impl.minKey!_alter!_eq_self {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] [LawfulEqOrd α] [Inhabited α] (h : t.WF) {k : α} {f : Option (β k) → Option (β k)} (he : (alter! k f t).isEmpty = false) : (alter! k f t).minKey! = k ↔ (f (t.get? k)).isSome = true ∧ ∀ (k' : α), k' ∈ t → (compare k k').isLE = true

theorem Std.DTreeMap.Internal.Impl.Const.minKey!_modify {α : Type u} {instOrd : Ord α} {β : Type v} {t : Impl α fun (x : α) => β} [TransOrd α] [Inhabited α] (h : t.WF) {k : α} {f : β → β} (he : (modify k f t).isEmpty = false) : (modify k f t).minKey! = if compare t.minKey! k = Ordering.eq then k else t.minKey!

theorem Std.DTreeMap.Internal.Impl.Const.minKey!_modify_eq_minKey! {α : Type u} {instOrd : Ord α} {β : Type v} {t : Impl α fun (x : α) => β} [TransOrd α] [LawfulEqOrd α] [Inhabited α] (h : t.WF) {k : α} {f : β → β} : (modify k f t).minKey! = t.minKey!

theorem Std.DTreeMap.Internal.Impl.Const.compare_minKey!_modify_eq {α : Type u} {instOrd : Ord α} {β : Type v} {t : Impl α fun (x : α) => β} [TransOrd α] [Inhabited α] (h : t.WF) {k : α} {f : β → β} : compare (modify k f t).minKey! t.minKey! = Ordering.eq

theorem Std.DTreeMap.Internal.Impl.Const.minKey!_alter_eq_self {α : Type u} {instOrd : Ord α} {β : Type v} {t : Impl α fun (x : α) => β} [TransOrd α] [Inhabited α] (h : t.WF) {k : α} {f : Option β → Option β} (he : (alter k f t ⋯).impl.isEmpty = false) : (alter k f t ⋯).impl.minKey! = k ↔ (f (get? t k)).isSome = true ∧ ∀ (k' : α), k' ∈ t → (compare k k').isLE = true

theorem Std.DTreeMap.Internal.Impl.Const.minKey!_alter!_eq_self {α : Type u} {instOrd : Ord α} {β : Type v} {t : Impl α fun (x : α) => β} [TransOrd α] [Inhabited α] (h : t.WF) {k : α} {f : Option β → Option β} (he : (alter! k f t).isEmpty = false) : (alter! k f t).minKey! = k ↔ (f (get? t k)).isSome = true ∧ ∀ (k' : α), k' ∈ t → (compare k k').isLE = true

theorem Std.DTreeMap.Internal.Impl.minKey_eq_minKeyD {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] (h : t.WF) {he : t.isEmpty = false} {fallback : α} : t.minKey he = t.minKeyD fallback

theorem Std.DTreeMap.Internal.Impl.minKey?_eq_some_minKeyD {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] (h : t.WF) {fallback : α} (he : t.isEmpty = false) : t.minKey? = some (t.minKeyD fallback)

theorem Std.DTreeMap.Internal.Impl.minKeyD_eq_fallback {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] (h : t.WF) {fallback : α} (he : t.isEmpty = true) : t.minKeyD fallback = fallback

theorem Std.DTreeMap.Internal.Impl.minKey!_eq_minKeyD_default {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] [Inhabited α] (h : t.WF) : t.minKey! = t.minKeyD default

theorem Std.DTreeMap.Internal.Impl.minKeyD_eq_iff_getKey?_eq_self_and_forall {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] (h : t.WF) (he : t.isEmpty = false) {km fallback : α} : t.minKeyD fallback = km ↔ t.getKey? km = some km ∧ ∀ (k : α), k ∈ t → (compare km k).isLE = true

theorem Std.DTreeMap.Internal.Impl.minKeyD_eq_iff_mem_and_forall {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] [LawfulEqOrd α] (h : t.WF) (he : t.isEmpty = false) {km fallback : α} : t.minKeyD fallback = km ↔ km ∈ t ∧ ∀ (k : α), k ∈ t → (compare km k).isLE = true

theorem Std.DTreeMap.Internal.Impl.minKeyD_insert {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] (h : t.WF) {k : α} {v : β k} {fallback : α} : (insert k v t ⋯).impl.minKeyD fallback = t.minKey?.elim k fun (k' : α) => if (compare k k').isLE = true then k else k'

theorem Std.DTreeMap.Internal.Impl.minKeyD_insert! {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] (h : t.WF) {k : α} {v : β k} {fallback : α} : (insert! k v t).minKeyD fallback = t.minKey?.elim k fun (k' : α) => if (compare k k').isLE = true then k else k'

theorem Std.DTreeMap.Internal.Impl.minKeyD_insert_le_minKeyD {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] (h : t.WF) (he : t.isEmpty = false) {k : α} {v : β k} {fallback : α} : (compare ((insert k v t ⋯).impl.minKeyD fallback) (t.minKeyD fallback)).isLE = true

theorem Std.DTreeMap.Internal.Impl.minKeyD_insert!_le_minKeyD {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] (h : t.WF) (he : t.isEmpty = false) {k : α} {v : β k} {fallback : α} : (compare ((insert! k v t).minKeyD fallback) (t.minKeyD fallback)).isLE = true

theorem Std.DTreeMap.Internal.Impl.minKeyD_insert_le_self {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] (h : t.WF) {k : α} {v : β k} {fallback : α} : (compare ((insert k v t ⋯).impl.minKeyD fallback) k).isLE = true

theorem Std.DTreeMap.Internal.Impl.minKeyD_insert!_le_self {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] (h : t.WF) {k : α} {v : β k} {fallback : α} : (compare ((insert! k v t).minKeyD fallback) k).isLE = true

theorem Std.DTreeMap.Internal.Impl.contains_minKeyD {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] (h : t.WF) (he : t.isEmpty = false) {fallback : α} : contains (t.minKeyD fallback) t = true

theorem Std.DTreeMap.Internal.Impl.minKeyD_mem {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] (h : t.WF) (he : t.isEmpty = false) {fallback : α} : t.minKeyD fallback ∈ t

theorem Std.DTreeMap.Internal.Impl.minKeyD_le_of_contains {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] (h : t.WF) {k : α} (hc : contains k t = true) {fallback : α} : (compare (t.minKeyD fallback) k).isLE = true

theorem Std.DTreeMap.Internal.Impl.minKeyD_le_of_mem {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] (h : t.WF) {k : α} (hc : k ∈ t) {fallback : α} : (compare (t.minKeyD fallback) k).isLE = true

theorem Std.DTreeMap.Internal.Impl.le_minKeyD {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] (h : t.WF) (he : t.isEmpty = false) {k fallback : α} : (compare k (t.minKeyD fallback)).isLE = true ↔ ∀ (k' : α), k' ∈ t → (compare k k').isLE = true

theorem Std.DTreeMap.Internal.Impl.getKey?_minKeyD {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] (h : t.WF) (he : t.isEmpty = false) {fallback : α} : t.getKey? (t.minKeyD fallback) = some (t.minKeyD fallback)

theorem Std.DTreeMap.Internal.Impl.getKey_minKeyD {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] (h : t.WF) {fallback : α} {he : contains (t.minKeyD fallback) t = true} : t.getKey (t.minKeyD fallback) he = t.minKeyD fallback

theorem Std.DTreeMap.Internal.Impl.getKey_minKeyD_eq_minKey {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] (h : t.WF) {fallback : α} {hc : contains (t.minKeyD fallback) t = true} : t.getKey (t.minKeyD fallback) hc = t.minKey ⋯

theorem Std.DTreeMap.Internal.Impl.getKey!_minKeyD {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] [Inhabited α] (h : t.WF) (he : t.isEmpty = false) {fallback : α} : t.getKey! (t.minKeyD fallback) = t.minKeyD fallback

theorem Std.DTreeMap.Internal.Impl.getKeyD_minKeyD {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] (h : t.WF) (he : t.isEmpty = false) {fallback fallback' : α} : t.getKeyD (t.minKeyD fallback) fallback' = t.minKeyD fallback

theorem Std.DTreeMap.Internal.Impl.minKeyD_erase_eq_iff_not_compare_minKeyD_eq {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] (h : t.WF) {k fallback : α} (he : (erase k t ⋯).impl.isEmpty = false) : (erase k t ⋯).impl.minKeyD fallback = t.minKeyD fallback ↔ ¬compare k (t.minKeyD fallback) = Ordering.eq

theorem Std.DTreeMap.Internal.Impl.minKeyD_erase!_eq_iff_not_compare_minKeyD_eq {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] (h : t.WF) {k fallback : α} (he : (erase! k t).isEmpty = false) : (erase! k t).minKeyD fallback = t.minKeyD fallback ↔ ¬compare k (t.minKeyD fallback) = Ordering.eq

theorem Std.DTreeMap.Internal.Impl.minKeyD_erase_eq_of_not_compare_minKeyD_eq {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] (h : t.WF) {k fallback : α} (he : (erase k t ⋯).impl.isEmpty = false) (heq : ¬compare k (t.minKeyD fallback) = Ordering.eq) : (erase k t ⋯).impl.minKeyD fallback = t.minKeyD fallback

theorem Std.DTreeMap.Internal.Impl.minKeyD_erase!_eq_of_not_compare_minKeyD_eq {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] (h : t.WF) {k fallback : α} (he : (erase! k t).isEmpty = false) (heq : ¬compare k (t.minKeyD fallback) = Ordering.eq) : (erase! k t).minKeyD fallback = t.minKeyD fallback

theorem Std.DTreeMap.Internal.Impl.minKeyD_le_minKeyD_erase {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] (h : t.WF) {k : α} (he : (erase k t ⋯).impl.isEmpty = false) {fallback : α} : (compare (t.minKeyD fallback) ((erase k t ⋯).impl.minKeyD fallback)).isLE = true

theorem Std.DTreeMap.Internal.Impl.minKeyD_le_minKeyD_erase! {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] (h : t.WF) {k : α} (he : (erase! k t).isEmpty = false) {fallback : α} : (compare (t.minKeyD fallback) ((erase! k t).minKeyD fallback)).isLE = true

theorem Std.DTreeMap.Internal.Impl.minKeyD_insertIfNew {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] (h : t.WF) {k : α} {v : β k} {fallback : α} : (insertIfNew k v t ⋯).impl.minKeyD fallback = t.minKey?.elim k fun (k' : α) => if compare k k' = Ordering.lt then k else k'

theorem Std.DTreeMap.Internal.Impl.minKeyD_insertIfNew! {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] (h : t.WF) {k : α} {v : β k} {fallback : α} : (insertIfNew! k v t).minKeyD fallback = t.minKey?.elim k fun (k' : α) => if compare k k' = Ordering.lt then k else k'

theorem Std.DTreeMap.Internal.Impl.minKeyD_insertIfNew_le_minKeyD {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] (h : t.WF) (he : t.isEmpty = false) {k : α} {v : β k} {fallback : α} : (compare ((insertIfNew k v t ⋯).impl.minKeyD fallback) (t.minKeyD fallback)).isLE = true

theorem Std.DTreeMap.Internal.Impl.minKeyD_insertIfNew!_le_minKeyD {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] (h : t.WF) (he : t.isEmpty = false) {k : α} {v : β k} {fallback : α} : (compare ((insertIfNew! k v t).minKeyD fallback) (t.minKeyD fallback)).isLE = true

theorem Std.DTreeMap.Internal.Impl.minKeyD_insertIfNew_le_self {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] (h : t.WF) {k : α} {v : β k} {fallback : α} : (compare ((insertIfNew k v t ⋯).impl.minKeyD fallback) k).isLE = true

theorem Std.DTreeMap.Internal.Impl.minKeyD_insertIfNew!_le_self {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] (h : t.WF) {k : α} {v : β k} {fallback : α} : (compare ((insertIfNew! k v t).minKeyD fallback) k).isLE = true

theorem Std.DTreeMap.Internal.Impl.minKeyD_eq_headD_keys {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] (h : t.WF) {fallback : α} : t.minKeyD fallback = t.keys.headD fallback

theorem Std.DTreeMap.Internal.Impl.minKeyD_eq_getD_keysArray {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] (h : t.WF) {fallback : α} : t.minKeyD fallback = t.keysArray.getD 0 fallback

theorem Std.DTreeMap.Internal.Impl.minKeyD_modify {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] [LawfulEqOrd α] (h : t.WF) {k : α} {f : β k → β k} {fallback : α} : (modify k f t).minKeyD fallback = t.minKeyD fallback

theorem Std.DTreeMap.Internal.Impl.minKeyD_alter_eq_self {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] [LawfulEqOrd α] (h : t.WF) {k : α} {f : Option (β k) → Option (β k)} {fallback : α} (he : (alter k f t ⋯).impl.isEmpty = false) : (alter k f t ⋯).impl.minKeyD fallback = k ↔ (f (t.get? k)).isSome = true ∧ ∀ (k' : α), k' ∈ t → (compare k k').isLE = true

theorem Std.DTreeMap.Internal.Impl.minKeyD_alter!_eq_self {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] [LawfulEqOrd α] (h : t.WF) {k : α} {f : Option (β k) → Option (β k)} {fallback : α} (he : (alter! k f t).isEmpty = false) : (alter! k f t).minKeyD fallback = k ↔ (f (t.get? k)).isSome = true ∧ ∀ (k' : α), k' ∈ t → (compare k k').isLE = true

theorem Std.DTreeMap.Internal.Impl.Const.minKeyD_modify {α : Type u} {instOrd : Ord α} {β : Type v} {t : Impl α fun (x : α) => β} [TransOrd α] (h : t.WF) {k : α} {f : β → β} (he : (modify k f t).isEmpty = false) {fallback : α} : (modify k f t).minKeyD fallback = if compare (t.minKeyD fallback) k = Ordering.eq then k else t.minKeyD fallback

theorem Std.DTreeMap.Internal.Impl.Const.minKeyD_modify_eq_minKeyD {α : Type u} {instOrd : Ord α} {β : Type v} {t : Impl α fun (x : α) => β} [TransOrd α] [LawfulEqOrd α] (h : t.WF) {k : α} {f : β → β} {fallback : α} : (modify k f t).minKeyD fallback = t.minKeyD fallback

theorem Std.DTreeMap.Internal.Impl.Const.compare_minKeyD_modify_eq {α : Type u} {instOrd : Ord α} {β : Type v} {t : Impl α fun (x : α) => β} [TransOrd α] (h : t.WF) {k : α} {f : β → β} {fallback : α} : compare ((modify k f t).minKeyD fallback) (t.minKeyD fallback) = Ordering.eq

theorem Std.DTreeMap.Internal.Impl.Const.minKeyD_alter_eq_self {α : Type u} {instOrd : Ord α} {β : Type v} {t : Impl α fun (x : α) => β} [TransOrd α] (h : t.WF) {k : α} {f : Option β → Option β} (he : (alter k f t ⋯).impl.isEmpty = false) {fallback : α} : (alter k f t ⋯).impl.minKeyD fallback = k ↔ (f (get? t k)).isSome = true ∧ ∀ (k' : α), k' ∈ t → (compare k k').isLE = true

theorem Std.DTreeMap.Internal.Impl.Const.minKeyD_alter!_eq_self {α : Type u} {instOrd : Ord α} {β : Type v} {t : Impl α fun (x : α) => β} [TransOrd α] (h : t.WF) {k : α} {f : Option β → Option β} (he : (alter! k f t).isEmpty = false) {fallback : α} : (alter! k f t).minKeyD fallback = k ↔ (f (get? t k)).isSome = true ∧ ∀ (k' : α), k' ∈ t → (compare k k').isLE = true

theorem Std.DTreeMap.Internal.Impl.maxKey?_empty {α : Type u} {β : α → Type v} : empty.maxKey? = none

theorem Std.DTreeMap.Internal.Impl.maxKey?_of_isEmpty {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] (h : t.WF) (he : t.isEmpty = true) : t.maxKey? = none

theorem Std.DTreeMap.Internal.Impl.maxKey?_eq_none_iff {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] (h : t.WF) : t.maxKey? = none ↔ t.isEmpty = true

theorem Std.DTreeMap.Internal.Impl.maxKey?_eq_some_iff_getKey?_eq_self_and_forall {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] (h : t.WF) {km : α} : t.maxKey? = some km ↔ t.getKey? km = some km ∧ ∀ (k : α), k ∈ t → (compare k km).isLE = true

theorem Std.DTreeMap.Internal.Impl.maxKey?_eq_some_iff_mem_and_forall {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] [LawfulEqOrd α] (h : t.WF) {km : α} : t.maxKey? = some km ↔ km ∈ t ∧ ∀ (k : α), k ∈ t → (compare k km).isLE = true

theorem Std.DTreeMap.Internal.Impl.isNone_maxKey?_eq_isEmpty {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] (h : t.WF) : t.maxKey?.isNone = t.isEmpty

theorem Std.DTreeMap.Internal.Impl.isSome_maxKey?_eq_not_isEmpty {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] (h : t.WF) : t.maxKey?.isSome = !t.isEmpty

theorem Std.DTreeMap.Internal.Impl.isSome_maxKey?_iff_isEmpty_eq_false {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] (h : t.WF) : t.maxKey?.isSome = true ↔ t.isEmpty = false

theorem Std.DTreeMap.Internal.Impl.maxKey?_insert {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] (h : t.WF) {k : α} {v : β k} : (insert k v t ⋯).impl.maxKey? = some (t.maxKey?.elim k fun (k' : α) => if (compare k' k).isLE = true then k else k')

theorem Std.DTreeMap.Internal.Impl.maxKey?_insert! {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] (h : t.WF) {k : α} {v : β k} : (insert! k v t).maxKey? = some (t.maxKey?.elim k fun (k' : α) => if (compare k' k).isLE = true then k else k')

theorem Std.DTreeMap.Internal.Impl.isSome_maxKey?_insert {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] (h : t.WF) {k : α} {v : β k} : (insert k v t ⋯).impl.maxKey?.isSome = true

theorem Std.DTreeMap.Internal.Impl.isSome_maxKey?_insert! {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] (h : t.WF) {k : α} {v : β k} : (insert! k v t).maxKey?.isSome = true

theorem Std.DTreeMap.Internal.Impl.maxKey?_le_maxKey?_insert {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] (h : t.WF) {k : α} {v : β k} {km kmi : α} (hkm : t.maxKey? = some km) (hkmi : (insert k v t ⋯).impl.maxKey?.get ⋯ = kmi) : (compare km kmi).isLE = true

theorem Std.DTreeMap.Internal.Impl.maxKey?_le_maxKey?_insert! {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] (h : t.WF) {k : α} {v : β k} {km kmi : α} (hkm : t.maxKey? = some km) (hkmi : (insert! k v t).maxKey?.get ⋯ = kmi) : (compare km kmi).isLE = true

theorem Std.DTreeMap.Internal.Impl.self_le_maxKey?_insert {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] (h : t.WF) {k : α} {v : β k} {kmi : α} (hkmi : (insert k v t ⋯).impl.maxKey?.get ⋯ = kmi) : (compare k kmi).isLE = true

theorem Std.DTreeMap.Internal.Impl.self_le_maxKey?_insert! {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] (h : t.WF) {k : α} {v : β k} {kmi : α} (hkmi : (insert! k v t).maxKey?.get ⋯ = kmi) : (compare k kmi).isLE = true

theorem Std.DTreeMap.Internal.Impl.contains_maxKey? {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] (h : t.WF) {km : α} (hkm : t.maxKey? = some km) : contains km t = true

theorem Std.DTreeMap.Internal.Impl.maxKey?_mem {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] (h : t.WF) {km : α} (hkm : t.maxKey? = some km) : km ∈ t

theorem Std.DTreeMap.Internal.Impl.isSome_maxKey?_of_contains {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] (h : t.WF) {k : α} (hc : contains k t = true) : t.maxKey?.isSome = true

theorem Std.DTreeMap.Internal.Impl.isSome_maxKey?_of_mem {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] (h : t.WF) {k : α} : k ∈ t → t.maxKey?.isSome = true

theorem Std.DTreeMap.Internal.Impl.le_maxKey?_of_contains {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] (h : t.WF) {k km : α} (hc : contains k t = true) (hkm : t.maxKey?.get ⋯ = km) : (compare k km).isLE = true

theorem Std.DTreeMap.Internal.Impl.le_maxKey?_of_mem {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] (h : t.WF) {k km : α} (hc : k ∈ t) (hkm : t.maxKey?.get ⋯ = km) : (compare k km).isLE = true

theorem Std.DTreeMap.Internal.Impl.maxKey?_le {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] {k : α} (h : t.WF) : (∀ (k' : α), t.maxKey? = some k' → (compare k' k).isLE = true) ↔ ∀ (k' : α), k' ∈ t → (compare k' k).isLE = true

theorem Std.DTreeMap.Internal.Impl.getKey?_maxKey? {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] (h : t.WF) {km : α} (hkm : t.maxKey? = some km) : t.getKey? km = some km

theorem Std.DTreeMap.Internal.Impl.getKey_maxKey? {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] (h : t.WF) {km : α} {hc : contains km t = true} (hkm : t.maxKey?.get ⋯ = km) : t.getKey km hc = km

theorem Std.DTreeMap.Internal.Impl.getKey!_maxKey? {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] [Inhabited α] (h : t.WF) {km : α} (hkm : t.maxKey? = some km) : t.getKey! km = km

theorem Std.DTreeMap.Internal.Impl.getKeyD_maxKey? {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] (h : t.WF) {km fallback : α} (hkm : t.maxKey? = some km) : t.getKeyD km fallback = km

@[simp]

theorem Std.DTreeMap.Internal.Impl.maxKey?_bind_getKey? {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] (h : t.WF) : t.maxKey?.bind t.getKey? = t.maxKey?

theorem Std.DTreeMap.Internal.Impl.maxKey?_erase_eq_iff_not_compare_eq_maxKey? {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] (h : t.WF) {k : α} : (erase k t ⋯).impl.maxKey? = t.maxKey? ↔ ∀ {km : α}, t.maxKey? = some km → ¬compare k km = Ordering.eq

theorem Std.DTreeMap.Internal.Impl.maxKey?_erase!_eq_iff_not_compare_eq_maxKey? {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] (h : t.WF) {k : α} : (erase! k t).maxKey? = t.maxKey? ↔ ∀ {km : α}, t.maxKey? = some km → ¬compare k km = Ordering.eq

theorem Std.DTreeMap.Internal.Impl.maxKey?_erase_eq_of_not_compare_eq_maxKey? {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] (h : t.WF) {k : α} (hc : ∀ {km : α}, t.maxKey? = some km → ¬compare k km = Ordering.eq) : (erase k t ⋯).impl.maxKey? = t.maxKey?

theorem Std.DTreeMap.Internal.Impl.maxKey?_erase!_eq_of_not_compare_eq_maxKey? {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] (h : t.WF) {k : α} (hc : ∀ {km : α}, t.maxKey? = some km → ¬compare k km = Ordering.eq) : (erase! k t).maxKey? = t.maxKey?

theorem Std.DTreeMap.Internal.Impl.isSome_maxKey?_of_isSome_maxKey?_erase {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] (h : t.WF) {k : α} (hs : (erase k t ⋯).impl.maxKey?.isSome = true) : t.maxKey?.isSome = true

theorem Std.DTreeMap.Internal.Impl.isSome_maxKey?_of_isSome_maxKey?_erase! {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] (h : t.WF) {k : α} (hs : (erase! k t).maxKey?.isSome = true) : t.maxKey?.isSome = true

theorem Std.DTreeMap.Internal.Impl.maxKey?_erase_le_maxKey? {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] (h : t.WF) {k km kme : α} (hkme : (erase k t ⋯).impl.maxKey? = some kme) (hkm : t.maxKey?.get ⋯ = km) : (compare kme km).isLE = true

theorem Std.DTreeMap.Internal.Impl.maxKey?_erase!_le_maxKey? {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] (h : t.WF) {k km kme : α} (hkme : (erase! k t).maxKey? = some kme) (hkm : t.maxKey?.get ⋯ = km) : (compare kme km).isLE = true

theorem Std.DTreeMap.Internal.Impl.maxKey?_insertIfNew {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] (h : t.WF) {k : α} {v : β k} : (insertIfNew k v t ⋯).impl.maxKey? = some (t.maxKey?.elim k fun (k' : α) => if compare k' k = Ordering.lt then k else k')

theorem Std.DTreeMap.Internal.Impl.maxKey?_insertIfNew! {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] (h : t.WF) {k : α} {v : β k} : (insertIfNew! k v t).maxKey? = some (t.maxKey?.elim k fun (k' : α) => if compare k' k = Ordering.lt then k else k')

theorem Std.DTreeMap.Internal.Impl.isSome_maxKey?_insertIfNew {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] (h : t.WF) {k : α} {v : β k} : (insertIfNew k v t ⋯).impl.maxKey?.isSome = true

theorem Std.DTreeMap.Internal.Impl.isSome_maxKey?_insertIfNew! {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] (h : t.WF) {k : α} {v : β k} : (insertIfNew! k v t).maxKey?.isSome = true

theorem Std.DTreeMap.Internal.Impl.maxKey?_le_maxKey?_insertIfNew {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] (h : t.WF) {k : α} {v : β k} {km kmi : α} (hkm : t.maxKey? = some km) (hkmi : (insertIfNew k v t ⋯).impl.maxKey?.get ⋯ = kmi) : (compare km kmi).isLE = true

theorem Std.DTreeMap.Internal.Impl.maxKey?_le_maxKey?_insertIfNew! {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] (h : t.WF) {k : α} {v : β k} {km kmi : α} (hkm : t.maxKey? = some km) (hkmi : (insertIfNew! k v t).maxKey?.get ⋯ = kmi) : (compare km kmi).isLE = true

theorem Std.DTreeMap.Internal.Impl.self_le_maxKey?_insertIfNew {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] (h : t.WF) {k : α} {v : β k} {kmi : α} (hkmi : (insertIfNew k v t ⋯).impl.maxKey?.get ⋯ = kmi) : (compare k kmi).isLE = true

theorem Std.DTreeMap.Internal.Impl.self_le_maxKey?_insertIfNew! {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] (h : t.WF) {k : α} {v : β k} {kmi : α} (hkmi : (insertIfNew! k v t).maxKey?.get ⋯ = kmi) : (compare k kmi).isLE = true

theorem Std.DTreeMap.Internal.Impl.maxKey?_eq_getLast?_keys {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] (h : t.WF) : t.maxKey? = t.keys.getLast?

theorem Std.DTreeMap.Internal.Impl.maxKey?_eq_back?_keysArray {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] (h : t.WF) : t.maxKey? = t.keysArray.back?

theorem Std.DTreeMap.Internal.Impl.maxKey?_modify {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] [LawfulEqOrd α] {k : α} {f : β k → β k} (h : t.WF) : (modify k f t).maxKey? = t.maxKey?

theorem Std.DTreeMap.Internal.Impl.maxKey?_alter_eq_self {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] [LawfulEqOrd α] (h : t.WF) {k : α} {f : Option (β k) → Option (β k)} : (alter k f t ⋯).impl.maxKey? = some k ↔ (f (t.get? k)).isSome = true ∧ ∀ (k' : α), k' ∈ t → (compare k' k).isLE = true

theorem Std.DTreeMap.Internal.Impl.maxKey?_alter!_eq_self {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] [LawfulEqOrd α] (h : t.WF) {k : α} {f : Option (β k) → Option (β k)} : (alter! k f t).maxKey? = some k ↔ (f (t.get? k)).isSome = true ∧ ∀ (k' : α), k' ∈ t → (compare k' k).isLE = true

theorem Std.DTreeMap.Internal.Impl.Const.maxKey?_modify {α : Type u} {instOrd : Ord α} {β : Type v} {t : Impl α fun (x : α) => β} [TransOrd α] (h : t.WF) {k : α} {f : β → β} : (modify k f t).maxKey? = Option.map (fun (km : α) => if compare km k = Ordering.eq then k else km) t.maxKey?

theorem Std.DTreeMap.Internal.Impl.Const.maxKey?_modify_eq_maxKey? {α : Type u} {instOrd : Ord α} {β : Type v} {t : Impl α fun (x : α) => β} [TransOrd α] [LawfulEqOrd α] (h : t.WF) {k : α} {f : β → β} : (modify k f t).maxKey? = t.maxKey?

theorem Std.DTreeMap.Internal.Impl.Const.isSome_maxKey?_modify {α : Type u} {instOrd : Ord α} {β : Type v} {t : Impl α fun (x : α) => β} [TransOrd α] {k : α} {f : β → β} (h : t.WF) : (modify k f t).maxKey?.isSome = !t.isEmpty

theorem Std.DTreeMap.Internal.Impl.Const.isSome_maxKey?_modify_eq_isSome {α : Type u} {instOrd : Ord α} {β : Type v} {t : Impl α fun (x : α) => β} [TransOrd α] (h : t.WF) {k : α} {f : β → β} : (modify k f t).maxKey?.isSome = t.maxKey?.isSome

theorem Std.DTreeMap.Internal.Impl.Const.compare_maxKey?_modify_eq {α : Type u} {instOrd : Ord α} {β : Type v} {t : Impl α fun (x : α) => β} [TransOrd α] (h : t.WF) {k : α} {f : β → β} {km kmm : α} (hkm : t.maxKey? = some km) (hkmm : (modify k f t).maxKey?.get ⋯ = kmm) : compare kmm km = Ordering.eq

theorem Std.DTreeMap.Internal.Impl.Const.maxKey?_alter_eq_self {α : Type u} {instOrd : Ord α} {β : Type v} {t : Impl α fun (x : α) => β} [TransOrd α] (h : t.WF) {k : α} {f : Option β → Option β} : (alter k f t ⋯).impl.maxKey? = some k ↔ (f (get? t k)).isSome = true ∧ ∀ (k' : α), k' ∈ t → (compare k' k).isLE = true

theorem Std.DTreeMap.Internal.Impl.Const.maxKey?_alter!_eq_self {α : Type u} {instOrd : Ord α} {β : Type v} {t : Impl α fun (x : α) => β} [TransOrd α] (h : t.WF) {k : α} {f : Option β → Option β} : (alter! k f t).maxKey? = some k ↔ (f (get? t k)).isSome = true ∧ ∀ (k' : α), k' ∈ t → (compare k' k).isLE = true

theorem Std.DTreeMap.Internal.Impl.maxKey?_eq_some_maxKey {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] (h : t.WF) {he : t.isEmpty = false} : t.maxKey? = some (t.maxKey he)

theorem Std.DTreeMap.Internal.Impl.maxKey_eq_iff_getKey?_eq_self_and_forall {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] (h : t.WF) {he : t.isEmpty = false} {km : α} : t.maxKey he = km ↔ t.getKey? km = some km ∧ ∀ (k : α), k ∈ t → (compare k km).isLE = true

theorem Std.DTreeMap.Internal.Impl.maxKey_eq_iff_mem_and_forall {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] [LawfulEqOrd α] (h : t.WF) {he : t.isEmpty = false} {km : α} : t.maxKey he = km ↔ km ∈ t ∧ ∀ (k : α), k ∈ t → (compare k km).isLE = true

theorem Std.DTreeMap.Internal.Impl.maxKey_insert {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] (h : t.WF) {k : α} {v : β k} : (insert k v t ⋯).impl.maxKey ⋯ = t.maxKey?.elim k fun (k' : α) => if (compare k' k).isLE = true then k else k'

theorem Std.DTreeMap.Internal.Impl.maxKey_le_maxKey_insert {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] (h : t.WF) {k : α} {v : β k} {he : t.isEmpty = false} : (compare (t.maxKey he) ((insert k v t ⋯).impl.maxKey ⋯)).isLE = true

theorem Std.DTreeMap.Internal.Impl.self_le_maxKey_insert {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] (h : t.WF) {k : α} {v : β k} : (compare k ((insert k v t ⋯).impl.maxKey ⋯)).isLE = true

theorem Std.DTreeMap.Internal.Impl.contains_maxKey {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] (h : t.WF) {he : t.isEmpty = false} : contains (t.maxKey he) t = true

theorem Std.DTreeMap.Internal.Impl.maxKey_mem {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] (h : t.WF) {he : t.isEmpty = false} : t.maxKey he ∈ t

theorem Std.DTreeMap.Internal.Impl.le_maxKey_of_contains {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] (h : t.WF) {k : α} (hc : contains k t = true) : (compare k (t.maxKey ⋯)).isLE = true

theorem Std.DTreeMap.Internal.Impl.le_maxKey_of_mem {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] (h : t.WF) {k : α} (hc : k ∈ t) : (compare k (t.maxKey ⋯)).isLE = true

theorem Std.DTreeMap.Internal.Impl.maxKey_le {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] (h : t.WF) {k : α} {he : t.isEmpty = false} : (compare (t.maxKey he) k).isLE = true ↔ ∀ (k' : α), k' ∈ t → (compare k' k).isLE = true

theorem Std.DTreeMap.Internal.Impl.getKey?_maxKey {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] (h : t.WF) {he : t.isEmpty = false} : t.getKey? (t.maxKey he) = some (t.maxKey he)

theorem Std.DTreeMap.Internal.Impl.getKey_maxKey {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] (h : t.WF) {he : t.isEmpty = false} {hc : contains (t.maxKey he) t = true} : t.getKey (t.maxKey he) hc = t.maxKey he

theorem Std.DTreeMap.Internal.Impl.getKey!_maxKey {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] [Inhabited α] (h : t.WF) {he : t.isEmpty = false} : t.getKey! (t.maxKey he) = t.maxKey he

theorem Std.DTreeMap.Internal.Impl.getKeyD_maxKey {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] (h : t.WF) {he : t.isEmpty = false} {fallback : α} : t.getKeyD (t.maxKey he) fallback = t.maxKey he

theorem Std.DTreeMap.Internal.Impl.maxKey_erase_eq_iff_not_compare_eq_maxKey {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] (h : t.WF) {k : α} {he : (erase k t ⋯).impl.isEmpty = false} : (erase k t ⋯).impl.maxKey he = t.maxKey ⋯ ↔ ¬compare k (t.maxKey ⋯) = Ordering.eq

theorem Std.DTreeMap.Internal.Impl.maxKey_erase_eq_of_not_compare_eq_maxKey {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] (h : t.WF) {k : α} {he : (erase k t ⋯).impl.isEmpty = false} (hc : ¬compare k (t.maxKey ⋯) = Ordering.eq) : (erase k t ⋯).impl.maxKey he = t.maxKey ⋯

theorem Std.DTreeMap.Internal.Impl.maxKey_erase_le_maxKey {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] (h : t.WF) {k : α} {he : (erase k t ⋯).impl.isEmpty = false} : (compare ((erase k t ⋯).impl.maxKey he) (t.maxKey ⋯)).isLE = true

theorem Std.DTreeMap.Internal.Impl.maxKey_insertIfNew {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] (h : t.WF) {k : α} {v : β k} : (insertIfNew k v t ⋯).impl.maxKey ⋯ = t.maxKey?.elim k fun (k' : α) => if compare k' k = Ordering.lt then k else k'

theorem Std.DTreeMap.Internal.Impl.maxKey_le_maxKey_insertIfNew {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] (h : t.WF) {k : α} {v : β k} {he : t.isEmpty = false} : (compare (t.maxKey he) ((insertIfNew k v t ⋯).impl.maxKey ⋯)).isLE = true

theorem Std.DTreeMap.Internal.Impl.self_le_maxKey_insertIfNew {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] (h : t.WF) {k : α} {v : β k} : (compare k ((insertIfNew k v t ⋯).impl.maxKey ⋯)).isLE = true

theorem Std.DTreeMap.Internal.Impl.maxKey_eq_getLast_keys {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] (h : t.WF) {he : t.isEmpty = false} : t.maxKey he = t.keys.getLast ⋯

theorem Std.DTreeMap.Internal.Impl.maxKey_eq_back_keysArray {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] (h : t.WF) {he : t.isEmpty = false} : t.maxKey he = t.keysArray.back ⋯

theorem Std.DTreeMap.Internal.Impl.maxKey_modify {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] [LawfulEqOrd α] (h : t.WF) {k : α} {f : β k → β k} {he : (modify k f t).isEmpty = false} : (modify k f t).maxKey he = t.maxKey ⋯

theorem Std.DTreeMap.Internal.Impl.maxKey_alter_eq_self {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] [LawfulEqOrd α] (h : t.WF) {k : α} {f : Option (β k) → Option (β k)} {he : (alter k f t ⋯).impl.isEmpty = false} : (alter k f t ⋯).impl.maxKey he = k ↔ (f (t.get? k)).isSome = true ∧ ∀ (k' : α), k' ∈ t → (compare k' k).isLE = true

theorem Std.DTreeMap.Internal.Impl.Const.maxKey_modify {α : Type u} {instOrd : Ord α} {β : Type v} {t : Impl α fun (x : α) => β} [TransOrd α] (h : t.WF) {k : α} {f : β → β} {he : (modify k f t).isEmpty = false} : (modify k f t).maxKey he = if compare (t.maxKey ⋯) k = Ordering.eq then k else t.maxKey ⋯

theorem Std.DTreeMap.Internal.Impl.Const.maxKey_modify_eq_maxKey {α : Type u} {instOrd : Ord α} {β : Type v} {t : Impl α fun (x : α) => β} [TransOrd α] [LawfulEqOrd α] (h : t.WF) {k : α} {f : β → β} {he : (modify k f t).isEmpty = false} : (modify k f t).maxKey he = t.maxKey ⋯

theorem Std.DTreeMap.Internal.Impl.Const.compare_maxKey_modify_eq {α : Type u} {instOrd : Ord α} {β : Type v} {t : Impl α fun (x : α) => β} [TransOrd α] (h : t.WF) {k : α} {f : β → β} {he : (modify k f t).isEmpty = false} : compare ((modify k f t).maxKey he) (t.maxKey ⋯) = Ordering.eq

theorem Std.DTreeMap.Internal.Impl.Const.maxKey_alter_eq_self {α : Type u} {instOrd : Ord α} {β : Type v} {t : Impl α fun (x : α) => β} [TransOrd α] (h : t.WF) {k : α} {f : Option β → Option β} {he : (alter k f t ⋯).impl.isEmpty = false} : (alter k f t ⋯).impl.maxKey he = k ↔ (f (get? t k)).isSome = true ∧ ∀ (k' : α), k' ∈ t → (compare k' k).isLE = true

theorem Std.DTreeMap.Internal.Impl.maxKey_eq_maxKey! {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] [Inhabited α] (h : t.WF) {he : t.isEmpty = false} : t.maxKey he = t.maxKey!

theorem Std.DTreeMap.Internal.Impl.maxKey?_eq_some_maxKey! {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] [Inhabited α] (h : t.WF) (he : t.isEmpty = false) : t.maxKey? = some t.maxKey!

theorem Std.DTreeMap.Internal.Impl.maxKey!_eq_default {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] [Inhabited α] (h : t.WF) (he : t.isEmpty = true) : t.maxKey! = default

theorem Std.DTreeMap.Internal.Impl.maxKey!_eq_iff_getKey?_eq_self_and_forall {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] [Inhabited α] (h : t.WF) (he : t.isEmpty = false) {km : α} : t.maxKey! = km ↔ t.getKey? km = some km ∧ ∀ (k : α), k ∈ t → (compare k km).isLE = true

theorem Std.DTreeMap.Internal.Impl.maxKey!_eq_iff_mem_and_forall {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] [LawfulEqOrd α] [Inhabited α] (h : t.WF) (he : t.isEmpty = false) {km : α} : t.maxKey! = km ↔ km ∈ t ∧ ∀ (k : α), k ∈ t → (compare k km).isLE = true

theorem Std.DTreeMap.Internal.Impl.maxKey!_insert {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] [Inhabited α] (h : t.WF) {k : α} {v : β k} : (insert k v t ⋯).impl.maxKey! = t.maxKey?.elim k fun (k' : α) => if (compare k' k).isLE = true then k else k'

theorem Std.DTreeMap.Internal.Impl.maxKey!_insert! {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] [Inhabited α] (h : t.WF) {k : α} {v : β k} : (insert! k v t).maxKey! = t.maxKey?.elim k fun (k' : α) => if (compare k' k).isLE = true then k else k'

theorem Std.DTreeMap.Internal.Impl.maxKey!_le_maxKey!_insert {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] [Inhabited α] (h : t.WF) (he : t.isEmpty = false) {k : α} {v : β k} : (compare t.maxKey! (insert k v t ⋯).impl.maxKey!).isLE = true

theorem Std.DTreeMap.Internal.Impl.maxKey!_le_maxKey!_insert! {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] [Inhabited α] (h : t.WF) (he : t.isEmpty = false) {k : α} {v : β k} : (compare t.maxKey! (insert! k v t).maxKey!).isLE = true

theorem Std.DTreeMap.Internal.Impl.self_le_maxKey!_insert {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] [Inhabited α] (h : t.WF) {k : α} {v : β k} : (compare k (insert k v t ⋯).impl.maxKey!).isLE = true

theorem Std.DTreeMap.Internal.Impl.self_le_maxKey!_insert! {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] [Inhabited α] (h : t.WF) {k : α} {v : β k} : (compare k (insert! k v t).maxKey!).isLE = true

theorem Std.DTreeMap.Internal.Impl.contains_maxKey! {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] [Inhabited α] (h : t.WF) (he : t.isEmpty = false) : contains t.maxKey! t = true

theorem Std.DTreeMap.Internal.Impl.maxKey!_mem {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] [Inhabited α] (h : t.WF) (he : t.isEmpty = false) : t.maxKey! ∈ t

theorem Std.DTreeMap.Internal.Impl.le_maxKey!_of_contains {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] [Inhabited α] (h : t.WF) {k : α} (hc : contains k t = true) : (compare k t.maxKey!).isLE = true

theorem Std.DTreeMap.Internal.Impl.le_maxKey!_of_mem {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] [Inhabited α] (h : t.WF) {k : α} (hc : k ∈ t) : (compare k t.maxKey!).isLE = true

theorem Std.DTreeMap.Internal.Impl.maxKey!_le {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] [Inhabited α] (h : t.WF) (he : t.isEmpty = false) {k : α} : (compare t.maxKey! k).isLE = true ↔ ∀ (k' : α), k' ∈ t → (compare k' k).isLE = true

theorem Std.DTreeMap.Internal.Impl.getKey?_maxKey! {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] [Inhabited α] (h : t.WF) (he : t.isEmpty = false) : t.getKey? t.maxKey! = some t.maxKey!

theorem Std.DTreeMap.Internal.Impl.getKey_maxKey! {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] [Inhabited α] (h : t.WF) {he : contains t.maxKey! t = true} : t.getKey t.maxKey! he = t.maxKey!

theorem Std.DTreeMap.Internal.Impl.getKey_maxKey!_eq_maxKey {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] [Inhabited α] (h : t.WF) {hc : contains t.maxKey! t = true} : t.getKey t.maxKey! hc = t.maxKey ⋯

theorem Std.DTreeMap.Internal.Impl.getKey!_maxKey! {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] [Inhabited α] (h : t.WF) (he : t.isEmpty = false) : t.getKey! t.maxKey! = t.maxKey!

theorem Std.DTreeMap.Internal.Impl.getKeyD_maxKey! {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] [Inhabited α] (h : t.WF) (he : t.isEmpty = false) {fallback : α} : t.getKeyD t.maxKey! fallback = t.maxKey!

theorem Std.DTreeMap.Internal.Impl.maxKey!_erase_eq_iff_not_compare_maxKey!_eq {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] [Inhabited α] (h : t.WF) {k : α} (he : (erase k t ⋯).impl.isEmpty = false) : (erase k t ⋯).impl.maxKey! = t.maxKey! ↔ ¬compare k t.maxKey! = Ordering.eq

theorem Std.DTreeMap.Internal.Impl.maxKey!_erase!_eq_iff_not_compare_maxKey!_eq {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] [Inhabited α] (h : t.WF) {k : α} (he : (erase! k t).isEmpty = false) : (erase! k t).maxKey! = t.maxKey! ↔ ¬compare k t.maxKey! = Ordering.eq

theorem Std.DTreeMap.Internal.Impl.maxKey!_erase_eq_of_not_compare_maxKey!_eq {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] [Inhabited α] (h : t.WF) {k : α} (he : (erase k t ⋯).impl.isEmpty = false) (heq : ¬compare k t.maxKey! = Ordering.eq) : (erase k t ⋯).impl.maxKey! = t.maxKey!

theorem Std.DTreeMap.Internal.Impl.maxKey!_erase!_eq_of_not_compare_maxKey!_eq {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] [Inhabited α] (h : t.WF) {k : α} (he : (erase! k t).isEmpty = false) (heq : ¬compare k t.maxKey! = Ordering.eq) : (erase! k t).maxKey! = t.maxKey!

theorem Std.DTreeMap.Internal.Impl.maxKey!_erase_le_maxKey! {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] [Inhabited α] (h : t.WF) {k : α} (he : (erase k t ⋯).impl.isEmpty = false) : (compare (erase k t ⋯).impl.maxKey! t.maxKey!).isLE = true

theorem Std.DTreeMap.Internal.Impl.maxKey!_erase!_le_maxKey! {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] [Inhabited α] (h : t.WF) {k : α} (he : (erase! k t).isEmpty = false) : (compare (erase! k t).maxKey! t.maxKey!).isLE = true

theorem Std.DTreeMap.Internal.Impl.maxKey!_insertIfNew {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] [Inhabited α] (h : t.WF) {k : α} {v : β k} : (insertIfNew k v t ⋯).impl.maxKey! = t.maxKey?.elim k fun (k' : α) => if compare k' k = Ordering.lt then k else k'

theorem Std.DTreeMap.Internal.Impl.maxKey!_insertIfNew! {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] [Inhabited α] (h : t.WF) {k : α} {v : β k} : (insertIfNew! k v t).maxKey! = t.maxKey?.elim k fun (k' : α) => if compare k' k = Ordering.lt then k else k'

theorem Std.DTreeMap.Internal.Impl.maxKey!_le_maxKey!_insertIfNew {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] [Inhabited α] (h : t.WF) (he : t.isEmpty = false) {k : α} {v : β k} : (compare t.maxKey! (insertIfNew k v t ⋯).impl.maxKey!).isLE = true

theorem Std.DTreeMap.Internal.Impl.maxKey!_le_maxKey!_insertIfNew! {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] [Inhabited α] (h : t.WF) (he : t.isEmpty = false) {k : α} {v : β k} : (compare t.maxKey! (insertIfNew! k v t).maxKey!).isLE = true

theorem Std.DTreeMap.Internal.Impl.self_le_maxKey!_insertIfNew {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] [Inhabited α] (h : t.WF) {k : α} {v : β k} : (compare k (insertIfNew k v t ⋯).impl.maxKey!).isLE = true

theorem Std.DTreeMap.Internal.Impl.self_le_maxKey!_insertIfNew! {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] [Inhabited α] (h : t.WF) {k : α} {v : β k} : (compare k (insertIfNew! k v t).maxKey!).isLE = true

theorem Std.DTreeMap.Internal.Impl.maxKey!_eq_getLast!_keys {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] [Inhabited α] (h : t.WF) : t.maxKey! = t.keys.getLast!

theorem Std.DTreeMap.Internal.Impl.maxKey!_eq_back!_keysArray {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] [Inhabited α] (h : t.WF) : t.maxKey! = t.keysArray.back!

theorem Std.DTreeMap.Internal.Impl.maxKey!_modify {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] [LawfulEqOrd α] [Inhabited α] (h : t.WF) {k : α} {f : β k → β k} : (modify k f t).maxKey! = t.maxKey!

theorem Std.DTreeMap.Internal.Impl.maxKey!_alter_eq_self {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] [LawfulEqOrd α] [Inhabited α] (h : t.WF) {k : α} {f : Option (β k) → Option (β k)} (he : (alter k f t ⋯).impl.isEmpty = false) : (alter k f t ⋯).impl.maxKey! = k ↔ (f (t.get? k)).isSome = true ∧ ∀ (k' : α), k' ∈ t → (compare k' k).isLE = true

theorem Std.DTreeMap.Internal.Impl.maxKey!_alter!_eq_self {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] [LawfulEqOrd α] [Inhabited α] (h : t.WF) {k : α} {f : Option (β k) → Option (β k)} (he : (alter! k f t).isEmpty = false) : (alter! k f t).maxKey! = k ↔ (f (t.get? k)).isSome = true ∧ ∀ (k' : α), k' ∈ t → (compare k' k).isLE = true

theorem Std.DTreeMap.Internal.Impl.Const.maxKey!_modify {α : Type u} {instOrd : Ord α} {β : Type v} {t : Impl α fun (x : α) => β} [TransOrd α] [Inhabited α] (h : t.WF) {k : α} {f : β → β} (he : (modify k f t).isEmpty = false) : (modify k f t).maxKey! = if compare t.maxKey! k = Ordering.eq then k else t.maxKey!

theorem Std.DTreeMap.Internal.Impl.Const.maxKey!_modify_eq_maxKey! {α : Type u} {instOrd : Ord α} {β : Type v} {t : Impl α fun (x : α) => β} [TransOrd α] [LawfulEqOrd α] [Inhabited α] (h : t.WF) {k : α} {f : β → β} : (modify k f t).maxKey! = t.maxKey!

theorem Std.DTreeMap.Internal.Impl.Const.compare_maxKey!_modify_eq {α : Type u} {instOrd : Ord α} {β : Type v} {t : Impl α fun (x : α) => β} [TransOrd α] [Inhabited α] (h : t.WF) {k : α} {f : β → β} : compare (modify k f t).maxKey! t.maxKey! = Ordering.eq

theorem Std.DTreeMap.Internal.Impl.Const.maxKey!_alter_eq_self {α : Type u} {instOrd : Ord α} {β : Type v} {t : Impl α fun (x : α) => β} [TransOrd α] [Inhabited α] (h : t.WF) {k : α} {f : Option β → Option β} (he : (alter k f t ⋯).impl.isEmpty = false) : (alter k f t ⋯).impl.maxKey! = k ↔ (f (get? t k)).isSome = true ∧ ∀ (k' : α), k' ∈ t → (compare k' k).isLE = true

theorem Std.DTreeMap.Internal.Impl.Const.maxKey!_alter!_eq_self {α : Type u} {instOrd : Ord α} {β : Type v} {t : Impl α fun (x : α) => β} [TransOrd α] [Inhabited α] (h : t.WF) {k : α} {f : Option β → Option β} (he : (alter! k f t).isEmpty = false) : (alter! k f t).maxKey! = k ↔ (f (get? t k)).isSome = true ∧ ∀ (k' : α), k' ∈ t → (compare k' k).isLE = true

theorem Std.DTreeMap.Internal.Impl.maxKey_eq_maxKeyD {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] (h : t.WF) {he : t.isEmpty = false} {fallback : α} : t.maxKey he = t.maxKeyD fallback

theorem Std.DTreeMap.Internal.Impl.maxKey?_eq_some_maxKeyD {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] (h : t.WF) {fallback : α} (he : t.isEmpty = false) : t.maxKey? = some (t.maxKeyD fallback)

theorem Std.DTreeMap.Internal.Impl.maxKeyD_eq_fallback {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] (h : t.WF) {fallback : α} (he : t.isEmpty = true) : t.maxKeyD fallback = fallback

theorem Std.DTreeMap.Internal.Impl.maxKey!_eq_maxKeyD_default {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] [Inhabited α] (h : t.WF) : t.maxKey! = t.maxKeyD default

theorem Std.DTreeMap.Internal.Impl.maxKeyD_eq_iff_getKey?_eq_self_and_forall {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] (h : t.WF) (he : t.isEmpty = false) {km fallback : α} : t.maxKeyD fallback = km ↔ t.getKey? km = some km ∧ ∀ (k : α), k ∈ t → (compare k km).isLE = true

theorem Std.DTreeMap.Internal.Impl.maxKeyD_eq_iff_mem_and_forall {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] [LawfulEqOrd α] (h : t.WF) (he : t.isEmpty = false) {km fallback : α} : t.maxKeyD fallback = km ↔ km ∈ t ∧ ∀ (k : α), k ∈ t → (compare k km).isLE = true

theorem Std.DTreeMap.Internal.Impl.maxKeyD_insert {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] (h : t.WF) {k : α} {v : β k} {fallback : α} : (insert k v t ⋯).impl.maxKeyD fallback = t.maxKey?.elim k fun (k' : α) => if (compare k' k).isLE = true then k else k'

theorem Std.DTreeMap.Internal.Impl.maxKeyD_insert! {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] (h : t.WF) {k : α} {v : β k} {fallback : α} : (insert! k v t).maxKeyD fallback = t.maxKey?.elim k fun (k' : α) => if (compare k' k).isLE = true then k else k'

theorem Std.DTreeMap.Internal.Impl.maxKeyD_le_maxKeyD_insert {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] (h : t.WF) (he : t.isEmpty = false) {k : α} {v : β k} {fallback : α} : (compare (t.maxKeyD fallback) ((insert k v t ⋯).impl.maxKeyD fallback)).isLE = true

theorem Std.DTreeMap.Internal.Impl.maxKeyD_le_maxKeyD_insert! {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] (h : t.WF) (he : t.isEmpty = false) {k : α} {v : β k} {fallback : α} : (compare (t.maxKeyD fallback) ((insert! k v t).maxKeyD fallback)).isLE = true

theorem Std.DTreeMap.Internal.Impl.self_le_maxKeyD_insert {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] (h : t.WF) {k : α} {v : β k} {fallback : α} : (compare k ((insert k v t ⋯).impl.maxKeyD fallback)).isLE = true

theorem Std.DTreeMap.Internal.Impl.self_le_maxKeyD_insert! {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] (h : t.WF) {k : α} {v : β k} {fallback : α} : (compare k ((insert! k v t).maxKeyD fallback)).isLE = true

theorem Std.DTreeMap.Internal.Impl.contains_maxKeyD {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] (h : t.WF) (he : t.isEmpty = false) {fallback : α} : contains (t.maxKeyD fallback) t = true

theorem Std.DTreeMap.Internal.Impl.maxKeyD_mem {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] (h : t.WF) (he : t.isEmpty = false) {fallback : α} : t.maxKeyD fallback ∈ t

theorem Std.DTreeMap.Internal.Impl.le_maxKeyD_of_contains {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] (h : t.WF) {k : α} (hc : contains k t = true) {fallback : α} : (compare k (t.maxKeyD fallback)).isLE = true

theorem Std.DTreeMap.Internal.Impl.le_maxKeyD_of_mem {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] (h : t.WF) {k : α} (hc : k ∈ t) {fallback : α} : (compare k (t.maxKeyD fallback)).isLE = true

theorem Std.DTreeMap.Internal.Impl.maxKeyD_le {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] (h : t.WF) (he : t.isEmpty = false) {k fallback : α} : (compare (t.maxKeyD fallback) k).isLE = true ↔ ∀ (k' : α), k' ∈ t → (compare k' k).isLE = true

theorem Std.DTreeMap.Internal.Impl.getKey?_maxKeyD {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] (h : t.WF) (he : t.isEmpty = false) {fallback : α} : t.getKey? (t.maxKeyD fallback) = some (t.maxKeyD fallback)

theorem Std.DTreeMap.Internal.Impl.getKey_maxKeyD {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] (h : t.WF) {fallback : α} {he : contains (t.maxKeyD fallback) t = true} : t.getKey (t.maxKeyD fallback) he = t.maxKeyD fallback

theorem Std.DTreeMap.Internal.Impl.getKey_maxKeyD_eq_maxKey {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] (h : t.WF) {fallback : α} {hc : contains (t.maxKeyD fallback) t = true} : t.getKey (t.maxKeyD fallback) hc = t.maxKey ⋯

theorem Std.DTreeMap.Internal.Impl.getKey!_maxKeyD {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] [Inhabited α] (h : t.WF) (he : t.isEmpty = false) {fallback : α} : t.getKey! (t.maxKeyD fallback) = t.maxKeyD fallback

theorem Std.DTreeMap.Internal.Impl.getKeyD_maxKeyD {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] (h : t.WF) (he : t.isEmpty = false) {fallback fallback' : α} : t.getKeyD (t.maxKeyD fallback) fallback' = t.maxKeyD fallback

theorem Std.DTreeMap.Internal.Impl.maxKeyD_erase_eq_iff_not_compare_maxKeyD_eq {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] (h : t.WF) {k fallback : α} (he : (erase k t ⋯).impl.isEmpty = false) : (erase k t ⋯).impl.maxKeyD fallback = t.maxKeyD fallback ↔ ¬compare k (t.maxKeyD fallback) = Ordering.eq

theorem Std.DTreeMap.Internal.Impl.maxKeyD_erase!_eq_iff_not_compare_maxKeyD_eq {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] (h : t.WF) {k fallback : α} (he : (erase! k t).isEmpty = false) : (erase! k t).maxKeyD fallback = t.maxKeyD fallback ↔ ¬compare k (t.maxKeyD fallback) = Ordering.eq

theorem Std.DTreeMap.Internal.Impl.maxKeyD_erase_eq_of_not_compare_maxKeyD_eq {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] (h : t.WF) {k fallback : α} (he : (erase k t ⋯).impl.isEmpty = false) (heq : ¬compare k (t.maxKeyD fallback) = Ordering.eq) : (erase k t ⋯).impl.maxKeyD fallback = t.maxKeyD fallback

theorem Std.DTreeMap.Internal.Impl.maxKeyD_erase!_eq_of_not_compare_maxKeyD_eq {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] (h : t.WF) {k fallback : α} (he : (erase! k t).isEmpty = false) (heq : ¬compare k (t.maxKeyD fallback) = Ordering.eq) : (erase! k t).maxKeyD fallback = t.maxKeyD fallback

theorem Std.DTreeMap.Internal.Impl.maxKeyD_erase_le_maxKeyD {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] (h : t.WF) {k : α} (he : (erase k t ⋯).impl.isEmpty = false) {fallback : α} : (compare ((erase k t ⋯).impl.maxKeyD fallback) (t.maxKeyD fallback)).isLE = true

theorem Std.DTreeMap.Internal.Impl.maxKeyD_erase!_le_maxKeyD {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] (h : t.WF) {k : α} (he : (erase! k t).isEmpty = false) {fallback : α} : (compare ((erase! k t).maxKeyD fallback) (t.maxKeyD fallback)).isLE = true

theorem Std.DTreeMap.Internal.Impl.maxKeyD_insertIfNew {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] (h : t.WF) {k : α} {v : β k} {fallback : α} : (insertIfNew k v t ⋯).impl.maxKeyD fallback = t.maxKey?.elim k fun (k' : α) => if compare k' k = Ordering.lt then k else k'

theorem Std.DTreeMap.Internal.Impl.maxKeyD_insertIfNew! {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] (h : t.WF) {k : α} {v : β k} {fallback : α} : (insertIfNew! k v t).maxKeyD fallback = t.maxKey?.elim k fun (k' : α) => if compare k' k = Ordering.lt then k else k'

theorem Std.DTreeMap.Internal.Impl.maxKeyD_le_maxKeyD_insertIfNew {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] (h : t.WF) (he : t.isEmpty = false) {k : α} {v : β k} {fallback : α} : (compare (t.maxKeyD fallback) ((insertIfNew k v t ⋯).impl.maxKeyD fallback)).isLE = true

theorem Std.DTreeMap.Internal.Impl.maxKeyD_le_maxKeyD_insertIfNew! {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] (h : t.WF) (he : t.isEmpty = false) {k : α} {v : β k} {fallback : α} : (compare (t.maxKeyD fallback) ((insertIfNew! k v t).maxKeyD fallback)).isLE = true

theorem Std.DTreeMap.Internal.Impl.self_le_maxKeyD_insertIfNew {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] (h : t.WF) {k : α} {v : β k} {fallback : α} : (compare k ((insertIfNew k v t ⋯).impl.maxKeyD fallback)).isLE = true

theorem Std.DTreeMap.Internal.Impl.self_le_maxKeyD_insertIfNew! {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] (h : t.WF) {k : α} {v : β k} {fallback : α} : (compare k ((insertIfNew! k v t).maxKeyD fallback)).isLE = true

theorem Std.DTreeMap.Internal.Impl.maxKeyD_eq_getLastD_keys {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] (h : t.WF) {fallback : α} : t.maxKeyD fallback = t.keys.getLastD fallback

theorem Std.DTreeMap.Internal.Impl.maxKeyD_eq_getD_back?_keysArray {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] (h : t.WF) {fallback : α} : t.maxKeyD fallback = t.keysArray.back?.getD fallback

theorem Std.DTreeMap.Internal.Impl.maxKeyD_modify {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] [LawfulEqOrd α] (h : t.WF) {k : α} {f : β k → β k} {fallback : α} : (modify k f t).maxKeyD fallback = t.maxKeyD fallback

theorem Std.DTreeMap.Internal.Impl.maxKeyD_alter_eq_self {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] [LawfulEqOrd α] (h : t.WF) {k : α} {f : Option (β k) → Option (β k)} {fallback : α} (he : (alter k f t ⋯).impl.isEmpty = false) : (alter k f t ⋯).impl.maxKeyD fallback = k ↔ (f (t.get? k)).isSome = true ∧ ∀ (k' : α), k' ∈ t → (compare k' k).isLE = true

theorem Std.DTreeMap.Internal.Impl.maxKeyD_alter!_eq_self {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] [LawfulEqOrd α] (h : t.WF) {k : α} {f : Option (β k) → Option (β k)} {fallback : α} (he : (alter! k f t).isEmpty = false) : (alter! k f t).maxKeyD fallback = k ↔ (f (t.get? k)).isSome = true ∧ ∀ (k' : α), k' ∈ t → (compare k' k).isLE = true

theorem Std.DTreeMap.Internal.Impl.Const.maxKeyD_modify {α : Type u} {instOrd : Ord α} {β : Type v} {t : Impl α fun (x : α) => β} [TransOrd α] (h : t.WF) {k : α} {f : β → β} (he : (modify k f t).isEmpty = false) {fallback : α} : (modify k f t).maxKeyD fallback = if compare (t.maxKeyD fallback) k = Ordering.eq then k else t.maxKeyD fallback

theorem Std.DTreeMap.Internal.Impl.Const.maxKeyD_modify_eq_maxKeyD {α : Type u} {instOrd : Ord α} {β : Type v} {t : Impl α fun (x : α) => β} [TransOrd α] [LawfulEqOrd α] (h : t.WF) {k : α} {f : β → β} {fallback : α} : (modify k f t).maxKeyD fallback = t.maxKeyD fallback

theorem Std.DTreeMap.Internal.Impl.Const.compare_maxKeyD_modify_eq {α : Type u} {instOrd : Ord α} {β : Type v} {t : Impl α fun (x : α) => β} [TransOrd α] (h : t.WF) {k : α} {f : β → β} {fallback : α} : compare ((modify k f t).maxKeyD fallback) (t.maxKeyD fallback) = Ordering.eq

theorem Std.DTreeMap.Internal.Impl.Const.maxKeyD_alter_eq_self {α : Type u} {instOrd : Ord α} {β : Type v} {t : Impl α fun (x : α) => β} [TransOrd α] (h : t.WF) {k : α} {f : Option β → Option β} (he : (alter k f t ⋯).impl.isEmpty = false) {fallback : α} : (alter k f t ⋯).impl.maxKeyD fallback = k ↔ (f (get? t k)).isSome = true ∧ ∀ (k' : α), k' ∈ t → (compare k' k).isLE = true

theorem Std.DTreeMap.Internal.Impl.Const.maxKeyD_alter!_eq_self {α : Type u} {instOrd : Ord α} {β : Type v} {t : Impl α fun (x : α) => β} [TransOrd α] (h : t.WF) {k : α} {f : Option β → Option β} (he : (alter! k f t).isEmpty = false) {fallback : α} : (alter! k f t).maxKeyD fallback = k ↔ (f (get? t k)).isSome = true ∧ ∀ (k' : α), k' ∈ t → (compare k' k).isLE = true

@[simp]

theorem Std.DTreeMap.Internal.Impl.Equiv.rfl {α : Type u} {β : α → Type v} {t : Impl α β} : t.Equiv t

theorem Std.DTreeMap.Internal.Impl.Equiv.symm {α : Type u} {β : α → Type v} {t₁ t₂ : Impl α β} : t₁.Equiv t₂ → t₂.Equiv t₁

theorem Std.DTreeMap.Internal.Impl.Equiv.trans {α : Type u} {β : α → Type v} {t₁ t₂ t₃ : Impl α β} : t₁.Equiv t₂ → t₂.Equiv t₃ → t₁.Equiv t₃

@[instance_reducible]

instance Std.DTreeMap.Internal.Impl.Equiv.instTrans {α : Type u} {β : α → Type v} : Trans Equiv Equiv Equiv

Equations

• Std.DTreeMap.Internal.Impl.Equiv.instTrans = { trans := ⋯ }

theorem Std.DTreeMap.Internal.Impl.Equiv.comm {α : Type u} {β : α → Type v} {t₁ t₂ : Impl α β} : t₁.Equiv t₂ ↔ t₂.Equiv t₁

theorem Std.DTreeMap.Internal.Impl.Equiv.congr_left {α : Type u} {β : α → Type v} {t₁ t₂ t₃ : Impl α β} (h : t₁.Equiv t₂) : t₁.Equiv t₃ ↔ t₂.Equiv t₃

theorem Std.DTreeMap.Internal.Impl.Equiv.congr_right {α : Type u} {β : α → Type v} {t₁ t₂ t₃ : Impl α β} (h : t₁.Equiv t₂) : t₃.Equiv t₁ ↔ t₃.Equiv t₂

theorem Std.DTreeMap.Internal.Impl.Equiv.isEmpty_eq {α : Type u} {β : α → Type v} {t₁ t₂ : Impl α β} (h : t₁.Equiv t₂) : t₁.isEmpty = t₂.isEmpty

theorem Std.DTreeMap.Internal.Impl.Equiv.contains_eq {α : Type u} {β : α → Type v} {instOrd : Ord α} {t₁ t₂ : Impl α β} [TransOrd α] (h₁ : t₁.WF) (h₂ : t₂.WF) (h : t₁.Equiv t₂) {k : α} : contains k t₁ = contains k t₂

theorem Std.DTreeMap.Internal.Impl.Equiv.mem_iff {α : Type u} {β : α → Type v} {instOrd : Ord α} {t₁ t₂ : Impl α β} [TransOrd α] (h₁ : t₁.WF) (h₂ : t₂.WF) (h : t₁.Equiv t₂) {k : α} : k ∈ t₁ ↔ k ∈ t₂

theorem Std.DTreeMap.Internal.Impl.Equiv.size_eq {α : Type u} {β : α → Type v} {instOrd : Ord α} {t₁ t₂ : Impl α β} (h₁ : t₁.WF) (h₂ : t₂.WF) (h : t₁.Equiv t₂) : t₁.size = t₂.size

theorem Std.DTreeMap.Internal.Impl.Equiv.get?_eq {α : Type u} {β : α → Type v} {instOrd : Ord α} {t₁ t₂ : Impl α β} [TransOrd α] [LawfulEqOrd α] (h₁ : t₁.WF) (h₂ : t₂.WF) (h : t₁.Equiv t₂) {k : α} : t₁.get? k = t₂.get? k

theorem Std.DTreeMap.Internal.Impl.Equiv.get_eq {α : Type u} {β : α → Type v} {instOrd : Ord α} {t₁ t₂ : Impl α β} [TransOrd α] [LawfulEqOrd α] (h₁ : t₁.WF) (h₂ : t₂.WF) (h : t₁.Equiv t₂) {k : α} (hk : k ∈ t₁) : t₁.get k hk = t₂.get k ⋯

theorem Std.DTreeMap.Internal.Impl.Equiv.get!_eq {α : Type u} {β : α → Type v} {instOrd : Ord α} {t₁ t₂ : Impl α β} [TransOrd α] [LawfulEqOrd α] (h₁ : t₁.WF) (h₂ : t₂.WF) (h : t₁.Equiv t₂) {k : α} [Inhabited (β k)] : t₁.get! k = t₂.get! k

theorem Std.DTreeMap.Internal.Impl.Equiv.getD_eq {α : Type u} {β : α → Type v} {instOrd : Ord α} {t₁ t₂ : Impl α β} [TransOrd α] [LawfulEqOrd α] (h₁ : t₁.WF) (h₂ : t₂.WF) (h : t₁.Equiv t₂) {k : α} {fallback : β k} : t₁.getD k fallback = t₂.getD k fallback

theorem Std.DTreeMap.Internal.Impl.Equiv.getKey?_eq {α : Type u} {β : α → Type v} {instOrd : Ord α} {t₁ t₂ : Impl α β} [TransOrd α] (h₁ : t₁.WF) (h₂ : t₂.WF) (h : t₁.Equiv t₂) {k : α} : t₁.getKey? k = t₂.getKey? k

theorem Std.DTreeMap.Internal.Impl.Equiv.getKey_eq {α : Type u} {β : α → Type v} {instOrd : Ord α} {t₁ t₂ : Impl α β} [TransOrd α] (h₁ : t₁.WF) (h₂ : t₂.WF) (h : t₁.Equiv t₂) {k : α} (hk : k ∈ t₁) : t₁.getKey k hk = t₂.getKey k ⋯

theorem Std.DTreeMap.Internal.Impl.Equiv.getKey!_eq {α : Type u} {β : α → Type v} {instOrd : Ord α} {t₁ t₂ : Impl α β} [TransOrd α] [Inhabited α] (h₁ : t₁.WF) (h₂ : t₂.WF) (h : t₁.Equiv t₂) {k : α} : t₁.getKey! k = t₂.getKey! k

theorem Std.DTreeMap.Internal.Impl.Equiv.getKeyD_eq {α : Type u} {β : α → Type v} {instOrd : Ord α} {t₁ t₂ : Impl α β} [TransOrd α] (h₁ : t₁.WF) (h₂ : t₂.WF) (h : t₁.Equiv t₂) {k fallback : α} : t₁.getKeyD k fallback = t₂.getKeyD k fallback

theorem Std.DTreeMap.Internal.Impl.Equiv.toList_eq {α : Type u} {β : α → Type v} {instOrd : Ord α} {t₁ t₂ : Impl α β} [TransOrd α] (h₁ : t₁.WF) (h₂ : t₂.WF) (h : t₁.Equiv t₂) : t₁.toList = t₂.toList

theorem Std.DTreeMap.Internal.Impl.Equiv.toArray_eq {α : Type u} {β : α → Type v} {instOrd : Ord α} {t₁ t₂ : Impl α β} [TransOrd α] (h₁ : t₁.WF) (h₂ : t₂.WF) (h : t₁.Equiv t₂) : t₁.toArray = t₂.toArray

theorem Std.DTreeMap.Internal.Impl.Equiv.keys_eq {α : Type u} {β : α → Type v} {instOrd : Ord α} {t₁ t₂ : Impl α β} [TransOrd α] (h₁ : t₁.WF) (h₂ : t₂.WF) (h : t₁.Equiv t₂) : t₁.keys = t₂.keys

theorem Std.DTreeMap.Internal.Impl.Equiv.keysArray_eq {α : Type u} {β : α → Type v} {instOrd : Ord α} {t₁ t₂ : Impl α β} [TransOrd α] (h₁ : t₁.WF) (h₂ : t₂.WF) (h : t₁.Equiv t₂) : t₁.keysArray = t₂.keysArray

theorem Std.DTreeMap.Internal.Impl.Equiv.foldlM_eq {α : Type u} {β : α → Type v} {instOrd : Ord α} {t₁ t₂ : Impl α β} {δ : Type w} {m : Type w → Type w'} [TransOrd α] [Monad m] [LawfulMonad m] (h₁ : t₁.WF) (h₂ : t₂.WF) (h : t₁.Equiv t₂) {f : δ → (a : α) → β a → m δ} {init : δ} : foldlM f init t₁ = foldlM f init t₂

theorem Std.DTreeMap.Internal.Impl.Equiv.foldl_eq {α : Type u} {β : α → Type v} {instOrd : Ord α} {t₁ t₂ : Impl α β} {δ : Type w} [TransOrd α] (h₁ : t₁.WF) (h₂ : t₂.WF) (h : t₁.Equiv t₂) {f : δ → (a : α) → β a → δ} {init : δ} : foldl f init t₁ = foldl f init t₂

theorem Std.DTreeMap.Internal.Impl.Equiv.foldrM_eq {α : Type u} {β : α → Type v} {instOrd : Ord α} {t₁ t₂ : Impl α β} {δ : Type w} {m : Type w → Type w'} [TransOrd α] [Monad m] [LawfulMonad m] (h₁ : t₁.WF) (h₂ : t₂.WF) (h : t₁.Equiv t₂) {f : (a : α) → β a → δ → m δ} {init : δ} : foldrM f init t₁ = foldrM f init t₂

theorem Std.DTreeMap.Internal.Impl.Equiv.foldr_eq {α : Type u} {β : α → Type v} {instOrd : Ord α} {t₁ t₂ : Impl α β} {δ : Type w} [TransOrd α] (h₁ : t₁.WF) (h₂ : t₂.WF) (h : t₁.Equiv t₂) {f : (a : α) → β a → δ → δ} {init : δ} : foldr f init t₁ = foldr f init t₂

theorem Std.DTreeMap.Internal.Impl.Equiv.forIn_eq {α : Type u} {β : α → Type v} {instOrd : Ord α} {t₁ t₂ : Impl α β} {δ : Type w} {m : Type w → Type w'} [TransOrd α] [Monad m] [LawfulMonad m] (h₁ : t₁.WF) (h₂ : t₂.WF) (h : t₁.Equiv t₂) {f : (a : α) → β a → δ → m (ForInStep δ)} {init : δ} : forIn f init t₁ = forIn f init t₂

theorem Std.DTreeMap.Internal.Impl.Equiv.forM_eq {α : Type u} {β : α → Type v} {instOrd : Ord α} {t₁ t₂ : Impl α β} {m : Type w → Type w'} [TransOrd α] [Monad m] [LawfulMonad m] (h₁ : t₁.WF) (h₂ : t₂.WF) (h : t₁.Equiv t₂) {f : (a : α) → β a → m PUnit} : forM f t₁ = forM f t₂

theorem Std.DTreeMap.Internal.Impl.Equiv.minKey?_eq {α : Type u} {β : α → Type v} {instOrd : Ord α} {t₁ t₂ : Impl α β} [TransOrd α] (h₁ : t₁.WF) (h₂ : t₂.WF) (h : t₁.Equiv t₂) : t₁.minKey? = t₂.minKey?

theorem Std.DTreeMap.Internal.Impl.Equiv.minKey_eq {α : Type u} {β : α → Type v} {instOrd : Ord α} {t₁ t₂ : Impl α β} [TransOrd α] (h₁ : t₁.WF) (h₂ : t₂.WF) (h : t₁.Equiv t₂) (h' : t₁.isEmpty = false) : t₁.minKey h' = t₂.minKey ⋯

theorem Std.DTreeMap.Internal.Impl.Equiv.minKey!_eq {α : Type u} {β : α → Type v} {instOrd : Ord α} {t₁ t₂ : Impl α β} [TransOrd α] [Inhabited α] (h₁ : t₁.WF) (h₂ : t₂.WF) (h : t₁.Equiv t₂) : t₁.minKey! = t₂.minKey!

theorem Std.DTreeMap.Internal.Impl.Equiv.minKeyD_eq {α : Type u} {β : α → Type v} {instOrd : Ord α} {t₁ t₂ : Impl α β} [TransOrd α] (h₁ : t₁.WF) (h₂ : t₂.WF) (h : t₁.Equiv t₂) {fallback : α} : t₁.minKeyD fallback = t₂.minKeyD fallback

theorem Std.DTreeMap.Internal.Impl.Equiv.maxKey?_eq {α : Type u} {β : α → Type v} {instOrd : Ord α} {t₁ t₂ : Impl α β} [TransOrd α] (h₁ : t₁.WF) (h₂ : t₂.WF) (h : t₁.Equiv t₂) : t₁.maxKey? = t₂.maxKey?

theorem Std.DTreeMap.Internal.Impl.Equiv.maxKey_eq {α : Type u} {β : α → Type v} {instOrd : Ord α} {t₁ t₂ : Impl α β} [TransOrd α] (h₁ : t₁.WF) (h₂ : t₂.WF) (h : t₁.Equiv t₂) (h' : t₁.isEmpty = false) : t₁.maxKey h' = t₂.maxKey ⋯

theorem Std.DTreeMap.Internal.Impl.Equiv.maxKey!_eq {α : Type u} {β : α → Type v} {instOrd : Ord α} {t₁ t₂ : Impl α β} [TransOrd α] [Inhabited α] (h₁ : t₁.WF) (h₂ : t₂.WF) (h : t₁.Equiv t₂) : t₁.maxKey! = t₂.maxKey!

theorem Std.DTreeMap.Internal.Impl.Equiv.maxKeyD_eq {α : Type u} {β : α → Type v} {instOrd : Ord α} {t₁ t₂ : Impl α β} [TransOrd α] (h₁ : t₁.WF) (h₂ : t₂.WF) (h : t₁.Equiv t₂) {fallback : α} : t₁.maxKeyD fallback = t₂.maxKeyD fallback

theorem Std.DTreeMap.Internal.Impl.Equiv.minEntry?_eq {α : Type u} {β : α → Type v} {instOrd : Ord α} {t₁ t₂ : Impl α β} [TransOrd α] (h₁ : t₁.WF) (h₂ : t₂.WF) (h : t₁.Equiv t₂) : t₁.minEntry? = t₂.minEntry?

theorem Std.DTreeMap.Internal.Impl.Equiv.minEntry_eq {α : Type u} {β : α → Type v} {instOrd : Ord α} {t₁ t₂ : Impl α β} [TransOrd α] (h₁ : t₁.WF) (h₂ : t₂.WF) (h : t₁.Equiv t₂) {he : t₁.isEmpty = false} : t₁.minEntry he = t₂.minEntry ⋯

theorem Std.DTreeMap.Internal.Impl.Equiv.minEntry!_eq {α : Type u} {β : α → Type v} {instOrd : Ord α} {t₁ t₂ : Impl α β} [TransOrd α] [Inhabited ((a : α) × β a)] (h₁ : t₁.WF) (h₂ : t₂.WF) (h : t₁.Equiv t₂) : t₁.minEntry! = t₂.minEntry!

theorem Std.DTreeMap.Internal.Impl.Equiv.minEntryD_eq {α : Type u} {β : α → Type v} {instOrd : Ord α} {t₁ t₂ : Impl α β} [TransOrd α] (h₁ : t₁.WF) (h₂ : t₂.WF) (h : t₁.Equiv t₂) {fallback : (a : α) × β a} : t₁.minEntryD fallback = t₂.minEntryD fallback

theorem Std.DTreeMap.Internal.Impl.Equiv.maxEntry?_eq {α : Type u} {β : α → Type v} {instOrd : Ord α} {t₁ t₂ : Impl α β} [TransOrd α] (h₁ : t₁.WF) (h₂ : t₂.WF) (h : t₁.Equiv t₂) : t₁.maxEntry? = t₂.maxEntry?

theorem Std.DTreeMap.Internal.Impl.Equiv.maxEntry_eq {α : Type u} {β : α → Type v} {instOrd : Ord α} {t₁ t₂ : Impl α β} [TransOrd α] (h₁ : t₁.WF) (h₂ : t₂.WF) (h : t₁.Equiv t₂) {he : t₁.isEmpty = false} : t₁.maxEntry he = t₂.maxEntry ⋯

theorem Std.DTreeMap.Internal.Impl.Equiv.maxEntry!_eq {α : Type u} {β : α → Type v} {instOrd : Ord α} {t₁ t₂ : Impl α β} [TransOrd α] [Inhabited ((a : α) × β a)] (h₁ : t₁.WF) (h₂ : t₂.WF) (h : t₁.Equiv t₂) : t₁.maxEntry! = t₂.maxEntry!

theorem Std.DTreeMap.Internal.Impl.Equiv.maxEntryD_eq {α : Type u} {β : α → Type v} {instOrd : Ord α} {t₁ t₂ : Impl α β} [TransOrd α] (h₁ : t₁.WF) (h₂ : t₂.WF) (h : t₁.Equiv t₂) {fallback : (a : α) × β a} : t₁.maxEntryD fallback = t₂.maxEntryD fallback

theorem Std.DTreeMap.Internal.Impl.Equiv.entryAtIdx?_eq {α : Type u} {β : α → Type v} {instOrd : Ord α} {t₁ t₂ : Impl α β} [TransOrd α] (h₁ : t₁.WF) (h₂ : t₂.WF) (h : t₁.Equiv t₂) {i : Nat} : t₁.entryAtIdx? i = t₂.entryAtIdx? i

theorem Std.DTreeMap.Internal.Impl.Equiv.entryAtIdx_eq {α : Type u} {β : α → Type v} {instOrd : Ord α} {t₁ t₂ : Impl α β} [TransOrd α] (h₁ : t₁.WF) (h₂ : t₂.WF) (h : t₁.Equiv t₂) {i : Nat} {h' : i < t₁.size} : t₁.entryAtIdx ⋯ i h' = t₂.entryAtIdx ⋯ i ⋯

theorem Std.DTreeMap.Internal.Impl.Equiv.entryAtIdx!_eq {α : Type u} {β : α → Type v} {instOrd : Ord α} {t₁ t₂ : Impl α β} [TransOrd α] (h₁ : t₁.WF) (h₂ : t₂.WF) (h : t₁.Equiv t₂) {i : Nat} [Inhabited ((a : α) × β a)] : t₁.entryAtIdx! i = t₂.entryAtIdx! i

theorem Std.DTreeMap.Internal.Impl.Equiv.entryAtIdxD_eq {α : Type u} {β : α → Type v} {instOrd : Ord α} {t₁ t₂ : Impl α β} [TransOrd α] (h₁ : t₁.WF) (h₂ : t₂.WF) (h : t₁.Equiv t₂) {i : Nat} {fallback : (a : α) × β a} : t₁.entryAtIdxD i fallback = t₂.entryAtIdxD i fallback

theorem Std.DTreeMap.Internal.Impl.Equiv.keyAtIdx?_eq {α : Type u} {β : α → Type v} {instOrd : Ord α} {t₁ t₂ : Impl α β} [TransOrd α] (h₁ : t₁.WF) (h₂ : t₂.WF) (h : t₁.Equiv t₂) {i : Nat} : t₁.keyAtIdx? i = t₂.keyAtIdx? i

theorem Std.DTreeMap.Internal.Impl.Equiv.keyAtIdx_eq {α : Type u} {β : α → Type v} {instOrd : Ord α} {t₁ t₂ : Impl α β} [TransOrd α] (h₁ : t₁.WF) (h₂ : t₂.WF) (h : t₁.Equiv t₂) {i : Nat} {h' : i < t₁.size} : t₁.keyAtIdx ⋯ i h' = t₂.keyAtIdx ⋯ i ⋯

theorem Std.DTreeMap.Internal.Impl.Equiv.keyAtIdx!_eq {α : Type u} {β : α → Type v} {instOrd : Ord α} {t₁ t₂ : Impl α β} [TransOrd α] (h₁ : t₁.WF) (h₂ : t₂.WF) (h : t₁.Equiv t₂) {i : Nat} [Inhabited α] : t₁.keyAtIdx! i = t₂.keyAtIdx! i

theorem Std.DTreeMap.Internal.Impl.Equiv.keyAtIdxD_eq {α : Type u} {β : α → Type v} {instOrd : Ord α} {t₁ t₂ : Impl α β} [TransOrd α] (h₁ : t₁.WF) (h₂ : t₂.WF) (h : t₁.Equiv t₂) {i : Nat} {fallback : α} : t₁.keyAtIdxD i fallback = t₂.keyAtIdxD i fallback

theorem Std.DTreeMap.Internal.Impl.Equiv.getEntryGE?_eq {α : Type u} {β : α → Type v} {instOrd : Ord α} {t₁ t₂ : Impl α β} [TransOrd α] (h₁ : t₁.WF) (h₂ : t₂.WF) (h : t₁.Equiv t₂) {k : α} : getEntryGE? k t₁ = getEntryGE? k t₂

theorem Std.DTreeMap.Internal.Impl.Equiv.getEntryGE_eq {α : Type u} {β : α → Type v} {instOrd : Ord α} {t₁ t₂ : Impl α β} [TransOrd α] (h₁ : t₁.WF) (h₂ : t₂.WF) (h : t₁.Equiv t₂) {k : α} {he : ∃ (a : α), a ∈ t₁ ∧ (compare a k).isGE = true} : getEntryGE k t₁ ⋯ he = getEntryGE k t₂ ⋯ ⋯

theorem Std.DTreeMap.Internal.Impl.Equiv.getEntryGE!_eq {α : Type u} {β : α → Type v} {instOrd : Ord α} {t₁ t₂ : Impl α β} [TransOrd α] (h₁ : t₁.WF) (h₂ : t₂.WF) (h : t₁.Equiv t₂) {k : α} [Inhabited ((a : α) × β a)] : getEntryGE! k t₁ = getEntryGE! k t₂

theorem Std.DTreeMap.Internal.Impl.Equiv.getEntryGED_eq {α : Type u} {β : α → Type v} {instOrd : Ord α} {t₁ t₂ : Impl α β} [TransOrd α] (h₁ : t₁.WF) (h₂ : t₂.WF) (h : t₁.Equiv t₂) {k : α} {fallback : (a : α) × β a} : getEntryGED k t₁ fallback = getEntryGED k t₂ fallback

theorem Std.DTreeMap.Internal.Impl.Equiv.getEntryGT?_eq {α : Type u} {β : α → Type v} {instOrd : Ord α} {t₁ t₂ : Impl α β} [TransOrd α] (h₁ : t₁.WF) (h₂ : t₂.WF) (h : t₁.Equiv t₂) {k : α} : getEntryGT? k t₁ = getEntryGT? k t₂

theorem Std.DTreeMap.Internal.Impl.Equiv.getEntryGT_eq {α : Type u} {β : α → Type v} {instOrd : Ord α} {t₁ t₂ : Impl α β} [TransOrd α] (h₁ : t₁.WF) (h₂ : t₂.WF) (h : t₁.Equiv t₂) {k : α} {he : ∃ (a : α), a ∈ t₁ ∧ compare a k = Ordering.gt} : getEntryGT k t₁ ⋯ he = getEntryGT k t₂ ⋯ ⋯

theorem Std.DTreeMap.Internal.Impl.Equiv.getEntryGT!_eq {α : Type u} {β : α → Type v} {instOrd : Ord α} {t₁ t₂ : Impl α β} [TransOrd α] (h₁ : t₁.WF) (h₂ : t₂.WF) (h : t₁.Equiv t₂) {k : α} [Inhabited ((a : α) × β a)] : getEntryGT! k t₁ = getEntryGT! k t₂

theorem Std.DTreeMap.Internal.Impl.Equiv.getEntryGTD_eq {α : Type u} {β : α → Type v} {instOrd : Ord α} {t₁ t₂ : Impl α β} [TransOrd α] (h₁ : t₁.WF) (h₂ : t₂.WF) (h : t₁.Equiv t₂) {k : α} {fallback : (a : α) × β a} : getEntryGTD k t₁ fallback = getEntryGTD k t₂ fallback

theorem Std.DTreeMap.Internal.Impl.Equiv.getEntryLE?_eq {α : Type u} {β : α → Type v} {instOrd : Ord α} {t₁ t₂ : Impl α β} [TransOrd α] (h₁ : t₁.WF) (h₂ : t₂.WF) (h : t₁.Equiv t₂) {k : α} : getEntryLE? k t₁ = getEntryLE? k t₂

theorem Std.DTreeMap.Internal.Impl.Equiv.getEntryLE_eq {α : Type u} {β : α → Type v} {instOrd : Ord α} {t₁ t₂ : Impl α β} [TransOrd α] (h₁ : t₁.WF) (h₂ : t₂.WF) (h : t₁.Equiv t₂) {k : α} {he : ∃ (a : α), a ∈ t₁ ∧ (compare a k).isLE = true} : getEntryLE k t₁ ⋯ he = getEntryLE k t₂ ⋯ ⋯

theorem Std.DTreeMap.Internal.Impl.Equiv.getEntryLE!_eq {α : Type u} {β : α → Type v} {instOrd : Ord α} {t₁ t₂ : Impl α β} [TransOrd α] (h₁ : t₁.WF) (h₂ : t₂.WF) (h : t₁.Equiv t₂) {k : α} [Inhabited ((a : α) × β a)] : getEntryLE! k t₁ = getEntryLE! k t₂

theorem Std.DTreeMap.Internal.Impl.Equiv.getEntryLED_eq {α : Type u} {β : α → Type v} {instOrd : Ord α} {t₁ t₂ : Impl α β} [TransOrd α] (h₁ : t₁.WF) (h₂ : t₂.WF) (h : t₁.Equiv t₂) {k : α} {fallback : (a : α) × β a} : getEntryLED k t₁ fallback = getEntryLED k t₂ fallback

theorem Std.DTreeMap.Internal.Impl.Equiv.getEntryLT?_eq {α : Type u} {β : α → Type v} {instOrd : Ord α} {t₁ t₂ : Impl α β} [TransOrd α] (h₁ : t₁.WF) (h₂ : t₂.WF) (h : t₁.Equiv t₂) {k : α} : getEntryLT? k t₁ = getEntryLT? k t₂

theorem Std.DTreeMap.Internal.Impl.Equiv.getEntryLT_eq {α : Type u} {β : α → Type v} {instOrd : Ord α} {t₁ t₂ : Impl α β} [TransOrd α] (h₁ : t₁.WF) (h₂ : t₂.WF) (h : t₁.Equiv t₂) {k : α} {he : ∃ (a : α), a ∈ t₁ ∧ compare a k = Ordering.lt} : getEntryLT k t₁ ⋯ he = getEntryLT k t₂ ⋯ ⋯

theorem Std.DTreeMap.Internal.Impl.Equiv.getEntryLT!_eq {α : Type u} {β : α → Type v} {instOrd : Ord α} {t₁ t₂ : Impl α β} [TransOrd α] (h₁ : t₁.WF) (h₂ : t₂.WF) (h : t₁.Equiv t₂) {k : α} [Inhabited ((a : α) × β a)] : getEntryLT! k t₁ = getEntryLT! k t₂

theorem Std.DTreeMap.Internal.Impl.Equiv.getEntryLTD_eq {α : Type u} {β : α → Type v} {instOrd : Ord α} {t₁ t₂ : Impl α β} [TransOrd α] (h₁ : t₁.WF) (h₂ : t₂.WF) (h : t₁.Equiv t₂) {k : α} {fallback : (a : α) × β a} : getEntryLTD k t₁ fallback = getEntryLTD k t₂ fallback

theorem Std.DTreeMap.Internal.Impl.Equiv.getKeyGE?_eq {α : Type u} {β : α → Type v} {instOrd : Ord α} {t₁ t₂ : Impl α β} [TransOrd α] (h₁ : t₁.WF) (h₂ : t₂.WF) (h : t₁.Equiv t₂) {k : α} : getKeyGE? k t₁ = getKeyGE? k t₂

theorem Std.DTreeMap.Internal.Impl.Equiv.getKeyGE_eq {α : Type u} {β : α → Type v} {instOrd : Ord α} {t₁ t₂ : Impl α β} [TransOrd α] (h₁ : t₁.WF) (h₂ : t₂.WF) (h : t₁.Equiv t₂) {k : α} {he : ∃ (a : α), a ∈ t₁ ∧ (compare a k).isGE = true} : getKeyGE k t₁ ⋯ he = getKeyGE k t₂ ⋯ ⋯

theorem Std.DTreeMap.Internal.Impl.Equiv.getKeyGE!_eq {α : Type u} {β : α → Type v} {instOrd : Ord α} {t₁ t₂ : Impl α β} [TransOrd α] (h₁ : t₁.WF) (h₂ : t₂.WF) (h : t₁.Equiv t₂) {k : α} [Inhabited α] : getKeyGE! k t₁ = getKeyGE! k t₂

theorem Std.DTreeMap.Internal.Impl.Equiv.getKeyGED_eq {α : Type u} {β : α → Type v} {instOrd : Ord α} {t₁ t₂ : Impl α β} [TransOrd α] (h₁ : t₁.WF) (h₂ : t₂.WF) (h : t₁.Equiv t₂) {k fallback : α} : getKeyGED k t₁ fallback = getKeyGED k t₂ fallback

theorem Std.DTreeMap.Internal.Impl.Equiv.getKeyGT?_eq {α : Type u} {β : α → Type v} {instOrd : Ord α} {t₁ t₂ : Impl α β} [TransOrd α] (h₁ : t₁.WF) (h₂ : t₂.WF) (h : t₁.Equiv t₂) {k : α} : getKeyGT? k t₁ = getKeyGT? k t₂

theorem Std.DTreeMap.Internal.Impl.Equiv.getKeyGT_eq {α : Type u} {β : α → Type v} {instOrd : Ord α} {t₁ t₂ : Impl α β} [TransOrd α] (h₁ : t₁.WF) (h₂ : t₂.WF) (h : t₁.Equiv t₂) {k : α} {he : ∃ (a : α), a ∈ t₁ ∧ compare a k = Ordering.gt} : getKeyGT k t₁ ⋯ he = getKeyGT k t₂ ⋯ ⋯

theorem Std.DTreeMap.Internal.Impl.Equiv.getKeyGT!_eq {α : Type u} {β : α → Type v} {instOrd : Ord α} {t₁ t₂ : Impl α β} [TransOrd α] (h₁ : t₁.WF) (h₂ : t₂.WF) (h : t₁.Equiv t₂) {k : α} [Inhabited α] : getKeyGT! k t₁ = getKeyGT! k t₂

theorem Std.DTreeMap.Internal.Impl.Equiv.getKeyGTD_eq {α : Type u} {β : α → Type v} {instOrd : Ord α} {t₁ t₂ : Impl α β} [TransOrd α] (h₁ : t₁.WF) (h₂ : t₂.WF) (h : t₁.Equiv t₂) {k fallback : α} : getKeyGTD k t₁ fallback = getKeyGTD k t₂ fallback

theorem Std.DTreeMap.Internal.Impl.Equiv.getKeyLE?_eq {α : Type u} {β : α → Type v} {instOrd : Ord α} {t₁ t₂ : Impl α β} [TransOrd α] (h₁ : t₁.WF) (h₂ : t₂.WF) (h : t₁.Equiv t₂) {k : α} : getKeyLE? k t₁ = getKeyLE? k t₂

theorem Std.DTreeMap.Internal.Impl.Equiv.getKeyLE_eq {α : Type u} {β : α → Type v} {instOrd : Ord α} {t₁ t₂ : Impl α β} [TransOrd α] (h₁ : t₁.WF) (h₂ : t₂.WF) (h : t₁.Equiv t₂) {k : α} {he : ∃ (a : α), a ∈ t₁ ∧ (compare a k).isLE = true} : getKeyLE k t₁ ⋯ he = getKeyLE k t₂ ⋯ ⋯

theorem Std.DTreeMap.Internal.Impl.Equiv.getKeyLE!_eq {α : Type u} {β : α → Type v} {instOrd : Ord α} {t₁ t₂ : Impl α β} [TransOrd α] (h₁ : t₁.WF) (h₂ : t₂.WF) (h : t₁.Equiv t₂) {k : α} [Inhabited α] : getKeyLE! k t₁ = getKeyLE! k t₂

theorem Std.DTreeMap.Internal.Impl.Equiv.getKeyLED_eq {α : Type u} {β : α → Type v} {instOrd : Ord α} {t₁ t₂ : Impl α β} [TransOrd α] (h₁ : t₁.WF) (h₂ : t₂.WF) (h : t₁.Equiv t₂) {k fallback : α} : getKeyLED k t₁ fallback = getKeyLED k t₂ fallback

theorem Std.DTreeMap.Internal.Impl.Equiv.getKeyLT?_eq {α : Type u} {β : α → Type v} {instOrd : Ord α} {t₁ t₂ : Impl α β} [TransOrd α] (h₁ : t₁.WF) (h₂ : t₂.WF) (h : t₁.Equiv t₂) {k : α} : getKeyLT? k t₁ = getKeyLT? k t₂

theorem Std.DTreeMap.Internal.Impl.Equiv.getKeyLT_eq {α : Type u} {β : α → Type v} {instOrd : Ord α} {t₁ t₂ : Impl α β} [TransOrd α] (h₁ : t₁.WF) (h₂ : t₂.WF) (h : t₁.Equiv t₂) {k : α} {he : ∃ (a : α), a ∈ t₁ ∧ compare a k = Ordering.lt} : getKeyLT k t₁ ⋯ he = getKeyLT k t₂ ⋯ ⋯

theorem Std.DTreeMap.Internal.Impl.Equiv.getKeyLT!_eq {α : Type u} {β : α → Type v} {instOrd : Ord α} {t₁ t₂ : Impl α β} [TransOrd α] (h₁ : t₁.WF) (h₂ : t₂.WF) (h : t₁.Equiv t₂) {k : α} [Inhabited α] : getKeyLT! k t₁ = getKeyLT! k t₂

theorem Std.DTreeMap.Internal.Impl.Equiv.getKeyLTD_eq {α : Type u} {β : α → Type v} {instOrd : Ord α} {t₁ t₂ : Impl α β} [TransOrd α] (h₁ : t₁.WF) (h₂ : t₂.WF) (h : t₁.Equiv t₂) {k fallback : α} : getKeyLTD k t₁ fallback = getKeyLTD k t₂ fallback

theorem Std.DTreeMap.Internal.Impl.Equiv.insert {α : Type u} {β : α → Type v} {instOrd : Ord α} {t₁ t₂ : Impl α β} [TransOrd α] (h₁ : t₁.WF) (h₂ : t₂.WF) (h : t₁.Equiv t₂) {k : α} {v : β k} : (Impl.insert k v t₁ ⋯).impl.Equiv (Impl.insert k v t₂ ⋯).impl

theorem Std.DTreeMap.Internal.Impl.Equiv.insert! {α : Type u} {β : α → Type v} {instOrd : Ord α} {t₁ t₂ : Impl α β} [TransOrd α] (h₁ : t₁.WF) (h₂ : t₂.WF) (h : t₁.Equiv t₂) {k : α} {v : β k} : (Impl.insert! k v t₁).Equiv (Impl.insert! k v t₂)

theorem Std.DTreeMap.Internal.Impl.Equiv.erase {α : Type u} {β : α → Type v} {instOrd : Ord α} {t₁ t₂ : Impl α β} [TransOrd α] (h₁ : t₁.WF) (h₂ : t₂.WF) (h : t₁.Equiv t₂) {k : α} : (Impl.erase k t₁ ⋯).impl.Equiv (Impl.erase k t₂ ⋯).impl

theorem Std.DTreeMap.Internal.Impl.Equiv.erase! {α : Type u} {β : α → Type v} {instOrd : Ord α} {t₁ t₂ : Impl α β} [TransOrd α] (h₁ : t₁.WF) (h₂ : t₂.WF) (h : t₁.Equiv t₂) {k : α} : (Impl.erase! k t₁).Equiv (Impl.erase! k t₂)

theorem Std.DTreeMap.Internal.Impl.Equiv.insertIfNew {α : Type u} {β : α → Type v} {instOrd : Ord α} {t₁ t₂ : Impl α β} [TransOrd α] (h₁ : t₁.WF) (h₂ : t₂.WF) (h : t₁.Equiv t₂) {k : α} {v : β k} : (Impl.insertIfNew k v t₁ ⋯).impl.Equiv (Impl.insertIfNew k v t₂ ⋯).impl

theorem Std.DTreeMap.Internal.Impl.Equiv.insertIfNew! {α : Type u} {β : α → Type v} {instOrd : Ord α} {t₁ t₂ : Impl α β} [TransOrd α] (h₁ : t₁.WF) (h₂ : t₂.WF) (h : t₁.Equiv t₂) {k : α} {v : β k} : (Impl.insertIfNew! k v t₁).Equiv (Impl.insertIfNew! k v t₂)

theorem Std.DTreeMap.Internal.Impl.Equiv.alter {α : Type u} {β : α → Type v} {instOrd : Ord α} {t₁ t₂ : Impl α β} [TransOrd α] [LawfulEqOrd α] (h₁ : t₁.WF) (h₂ : t₂.WF) (h : t₁.Equiv t₂) {k : α} {f : Option (β k) → Option (β k)} : (Impl.alter k f t₁ ⋯).impl.Equiv (Impl.alter k f t₂ ⋯).impl

theorem Std.DTreeMap.Internal.Impl.Equiv.alter! {α : Type u} {β : α → Type v} {instOrd : Ord α} {t₁ t₂ : Impl α β} [TransOrd α] [LawfulEqOrd α] (h₁ : t₁.WF) (h₂ : t₂.WF) (h : t₁.Equiv t₂) {k : α} {f : Option (β k) → Option (β k)} : (Impl.alter! k f t₁).Equiv (Impl.alter! k f t₂)

theorem Std.DTreeMap.Internal.Impl.Equiv.modify {α : Type u} {β : α → Type v} {instOrd : Ord α} {t₁ t₂ : Impl α β} [TransOrd α] [LawfulEqOrd α] (h₁ : t₁.WF) (h₂ : t₂.WF) (h : t₁.Equiv t₂) {k : α} {f : β k → β k} : (Impl.modify k f t₁).Equiv (Impl.modify k f t₂)

theorem Std.DTreeMap.Internal.Impl.Equiv.filter {α : Type u} {β : α → Type v} {instOrd : Ord α} {t₁ t₂ : Impl α β} (h₁ : t₁.WF) (h₂ : t₂.WF) (h : t₁.Equiv t₂) {f : (a : α) → β a → Bool} : (Impl.filter f t₁ ⋯).impl.Equiv (Impl.filter f t₂ ⋯).impl

theorem Std.DTreeMap.Internal.Impl.Equiv.filter! {α : Type u} {β : α → Type v} {instOrd : Ord α} {t₁ t₂ : Impl α β} (h₁ : t₁.WF) (h₂ : t₂.WF) (h : t₁.Equiv t₂) {f : (a : α) → β a → Bool} : (Impl.filter! f t₁).Equiv (Impl.filter! f t₂)

theorem Std.DTreeMap.Internal.Impl.Equiv.map {α : Type u} {β : α → Type v} {γ : α → Type w} {instOrd : Ord α} {t₁ t₂ : Impl α β} (h : t₁.Equiv t₂) {f : (a : α) → β a → γ a} : (Impl.map f t₁).Equiv (Impl.map f t₂)

theorem Std.DTreeMap.Internal.Impl.Equiv.filterMap {α : Type u} {β : α → Type v} {γ : α → Type w} {instOrd : Ord α} {t₁ t₂ : Impl α β} (h₁ : t₁.WF) (h₂ : t₂.WF) (h : t₁.Equiv t₂) {f : (a : α) → β a → Option (γ a)} : (Impl.filterMap f t₁ ⋯).impl.Equiv (Impl.filterMap f t₂ ⋯).impl

theorem Std.DTreeMap.Internal.Impl.Equiv.filterMap! {α : Type u} {β : α → Type v} {γ : α → Type w} {instOrd : Ord α} {t₁ t₂ : Impl α β} (h₁ : t₁.WF) (h₂ : t₂.WF) (h : t₁.Equiv t₂) {f : (a : α) → β a → Option (γ a)} : (Impl.filterMap! f t₁).Equiv (Impl.filterMap! f t₂)

theorem Std.DTreeMap.Internal.Impl.Equiv.insertMany_list {α : Type u} {β : α → Type v} {instOrd : Ord α} {t₁ t₂ : Impl α β} [TransOrd α] (h₁ : t₁.WF) (h₂ : t₂.WF) (h : t₁.Equiv t₂) {l : List ((a : α) × β a)} : (t₁.insertMany l ⋯).val.Equiv (t₂.insertMany l ⋯).val

theorem Std.DTreeMap.Internal.Impl.Equiv.insertMany!_list {α : Type u} {β : α → Type v} {instOrd : Ord α} {t₁ t₂ : Impl α β} [TransOrd α] (h₁ : t₁.WF) (h₂ : t₂.WF) (h : t₁.Equiv t₂) {l : List ((a : α) × β a)} : (t₁.insertMany! l).val.Equiv (t₂.insertMany! l).val

theorem Std.DTreeMap.Internal.Impl.Equiv.eraseMany_list {α : Type u} {β : α → Type v} {instOrd : Ord α} {t₁ t₂ : Impl α β} [TransOrd α] (h₁ : t₁.WF) (h₂ : t₂.WF) (h : t₁.Equiv t₂) {l : List α} : (t₁.eraseMany l ⋯).val.Equiv (t₂.eraseMany l ⋯).val

theorem Std.DTreeMap.Internal.Impl.Equiv.eraseMany!_list {α : Type u} {β : α → Type v} {instOrd : Ord α} {t₁ t₂ : Impl α β} [TransOrd α] (h₁ : t₁.WF) (h₂ : t₂.WF) (h : t₁.Equiv t₂) {l : List α} : (t₁.eraseMany! l).val.Equiv (t₂.eraseMany! l).val

theorem Std.DTreeMap.Internal.Impl.Equiv.mergeWith {α : Type u} {β : α → Type v} {instOrd : Ord α} {t₁ t₂ t₃ t₄ : Impl α β} [TransOrd α] [LawfulEqOrd α] (h : t₁.Equiv t₂) (h' : t₃.Equiv t₄) (h₁ : t₁.WF) (h₂ : t₂.WF) (h₃ : t₃.WF) (h₄ : t₄.WF) {f : (a : α) → β a → β a → β a} : (Impl.mergeWith f t₁ t₃ ⋯).impl.Equiv (Impl.mergeWith f t₂ t₄ ⋯).impl

theorem Std.DTreeMap.Internal.Impl.Equiv.mergeWith! {α : Type u} {β : α → Type v} {instOrd : Ord α} {t₁ t₂ t₃ t₄ : Impl α β} [TransOrd α] [LawfulEqOrd α] (h : t₁.Equiv t₂) (h' : t₃.Equiv t₄) (h₁ : t₁.WF) (h₂ : t₂.WF) (h₃ : t₃.WF) (h₄ : t₄.WF) {f : (a : α) → β a → β a → β a} : (Impl.mergeWith! f t₁ t₃).Equiv (Impl.mergeWith! f t₂ t₄)

theorem Std.DTreeMap.Internal.Impl.Equiv.constGet?_eq {α : Type u} {instOrd : Ord α} {β : Type v} {t₁ t₂ : Impl α fun (x : α) => β} [TransOrd α] (h₁ : t₁.WF) (h₂ : t₂.WF) (h : t₁.Equiv t₂) {k : α} : Const.get? t₁ k = Const.get? t₂ k

theorem Std.DTreeMap.Internal.Impl.Equiv.constGet_eq {α : Type u} {instOrd : Ord α} {β : Type v} {t₁ t₂ : Impl α fun (x : α) => β} [TransOrd α] (h₁ : t₁.WF) (h₂ : t₂.WF) (h : t₁.Equiv t₂) {k : α} (hk : k ∈ t₁) : Const.get t₁ k hk = Const.get t₂ k ⋯

theorem Std.DTreeMap.Internal.Impl.Equiv.constGet!_eq {α : Type u} {instOrd : Ord α} {β : Type v} {t₁ t₂ : Impl α fun (x : α) => β} [TransOrd α] (h₁ : t₁.WF) (h₂ : t₂.WF) (h : t₁.Equiv t₂) {k : α} [Inhabited β] : Const.get! t₁ k = Const.get! t₂ k

theorem Std.DTreeMap.Internal.Impl.Equiv.constGetD_eq {α : Type u} {instOrd : Ord α} {β : Type v} {t₁ t₂ : Impl α fun (x : α) => β} [TransOrd α] (h₁ : t₁.WF) (h₂ : t₂.WF) (h : t₁.Equiv t₂) {k : α} {fallback : β} : Const.getD t₁ k fallback = Const.getD t₂ k fallback

theorem Std.DTreeMap.Internal.Impl.Equiv.constToList_eq {α : Type u} {instOrd : Ord α} {β : Type v} {t₁ t₂ : Impl α fun (x : α) => β} [TransOrd α] (h₁ : t₁.WF) (h₂ : t₂.WF) (h : t₁.Equiv t₂) : Const.toList t₁ = Const.toList t₂

theorem Std.DTreeMap.Internal.Impl.Equiv.constToArray_eq {α : Type u} {instOrd : Ord α} {β : Type v} {t₁ t₂ : Impl α fun (x : α) => β} [TransOrd α] (h₁ : t₁.WF) (h₂ : t₂.WF) (h : t₁.Equiv t₂) : Const.toArray t₁ = Const.toArray t₂

theorem Std.DTreeMap.Internal.Impl.Equiv.values_eq {α : Type u} {instOrd : Ord α} {β : Type v} {t₁ t₂ : Impl α fun (x : α) => β} [TransOrd α] (h₁ : t₁.WF) (h₂ : t₂.WF) (h : t₁.Equiv t₂) : t₁.values = t₂.values

theorem Std.DTreeMap.Internal.Impl.Equiv.valuesArray_eq {α : Type u} {instOrd : Ord α} {β : Type v} {t₁ t₂ : Impl α fun (x : α) => β} [TransOrd α] (h₁ : t₁.WF) (h₂ : t₂.WF) (h : t₁.Equiv t₂) : t₁.valuesArray = t₂.valuesArray

theorem Std.DTreeMap.Internal.Impl.Equiv.constMinEntry?_eq {α : Type u} {instOrd : Ord α} {β : Type v} {t₁ t₂ : Impl α fun (x : α) => β} [TransOrd α] (h₁ : t₁.WF) (h₂ : t₂.WF) (h : t₁.Equiv t₂) : Const.minEntry? t₁ = Const.minEntry? t₂

theorem Std.DTreeMap.Internal.Impl.Equiv.constMinEntry_eq {α : Type u} {instOrd : Ord α} {β : Type v} {t₁ t₂ : Impl α fun (x : α) => β} [TransOrd α] (h₁ : t₁.WF) (h₂ : t₂.WF) (h : t₁.Equiv t₂) {he : t₁.isEmpty = false} : Const.minEntry t₁ he = Const.minEntry t₂ ⋯

theorem Std.DTreeMap.Internal.Impl.Equiv.constMinEntry!_eq {α : Type u} {instOrd : Ord α} {β : Type v} {t₁ t₂ : Impl α fun (x : α) => β} [TransOrd α] [Inhabited (α × β)] (h₁ : t₁.WF) (h₂ : t₂.WF) (h : t₁.Equiv t₂) : Const.minEntry! t₁ = Const.minEntry! t₂

theorem Std.DTreeMap.Internal.Impl.Equiv.constMinEntryD_eq {α : Type u} {instOrd : Ord α} {β : Type v} {t₁ t₂ : Impl α fun (x : α) => β} [TransOrd α] (h₁ : t₁.WF) (h₂ : t₂.WF) (h : t₁.Equiv t₂) {fallback : α × β} : Const.minEntryD t₁ fallback = Const.minEntryD t₂ fallback

theorem Std.DTreeMap.Internal.Impl.Equiv.constMaxEntry?_eq {α : Type u} {instOrd : Ord α} {β : Type v} {t₁ t₂ : Impl α fun (x : α) => β} [TransOrd α] (h₁ : t₁.WF) (h₂ : t₂.WF) (h : t₁.Equiv t₂) : Const.maxEntry? t₁ = Const.maxEntry? t₂

theorem Std.DTreeMap.Internal.Impl.Equiv.constMaxEntry_eq {α : Type u} {instOrd : Ord α} {β : Type v} {t₁ t₂ : Impl α fun (x : α) => β} [TransOrd α] (h₁ : t₁.WF) (h₂ : t₂.WF) (h : t₁.Equiv t₂) {he : t₁.isEmpty = false} : Const.maxEntry t₁ he = Const.maxEntry t₂ ⋯

theorem Std.DTreeMap.Internal.Impl.Equiv.constMaxEntry!_eq {α : Type u} {instOrd : Ord α} {β : Type v} {t₁ t₂ : Impl α fun (x : α) => β} [TransOrd α] [Inhabited (α × β)] (h₁ : t₁.WF) (h₂ : t₂.WF) (h : t₁.Equiv t₂) : Const.maxEntry! t₁ = Const.maxEntry! t₂

theorem Std.DTreeMap.Internal.Impl.Equiv.constMaxEntryD_eq {α : Type u} {instOrd : Ord α} {β : Type v} {t₁ t₂ : Impl α fun (x : α) => β} [TransOrd α] (h₁ : t₁.WF) (h₂ : t₂.WF) (h : t₁.Equiv t₂) {fallback : α × β} : Const.maxEntryD t₁ fallback = Const.maxEntryD t₂ fallback

theorem Std.DTreeMap.Internal.Impl.Equiv.constEntryAtIdx?_eq {α : Type u} {instOrd : Ord α} {β : Type v} {t₁ t₂ : Impl α fun (x : α) => β} [TransOrd α] (h₁ : t₁.WF) (h₂ : t₂.WF) (h : t₁.Equiv t₂) {i : Nat} : Const.entryAtIdx? t₁ i = Const.entryAtIdx? t₂ i

theorem Std.DTreeMap.Internal.Impl.Equiv.constEntryAtIdx_eq {α : Type u} {instOrd : Ord α} {β : Type v} {t₁ t₂ : Impl α fun (x : α) => β} [TransOrd α] (h₁ : t₁.WF) (h₂ : t₂.WF) (h : t₁.Equiv t₂) {i : Nat} {h' : i < t₁.size} : Const.entryAtIdx t₁ ⋯ i h' = Const.entryAtIdx t₂ ⋯ i ⋯

theorem Std.DTreeMap.Internal.Impl.Equiv.constEntryAtIdx!_eq {α : Type u} {instOrd : Ord α} {β : Type v} {t₁ t₂ : Impl α fun (x : α) => β} [TransOrd α] (h₁ : t₁.WF) (h₂ : t₂.WF) (h : t₁.Equiv t₂) {i : Nat} [Inhabited (α × β)] : Const.entryAtIdx! t₁ i = Const.entryAtIdx! t₂ i

theorem Std.DTreeMap.Internal.Impl.Equiv.constEntryAtIdxD_eq {α : Type u} {instOrd : Ord α} {β : Type v} {t₁ t₂ : Impl α fun (x : α) => β} [TransOrd α] (h₁ : t₁.WF) (h₂ : t₂.WF) (h : t₁.Equiv t₂) {i : Nat} {fallback : α × β} : Const.entryAtIdxD t₁ i fallback = Const.entryAtIdxD t₂ i fallback

theorem Std.DTreeMap.Internal.Impl.Equiv.constGetEntryGE?_eq {α : Type u} {instOrd : Ord α} {β : Type v} {t₁ t₂ : Impl α fun (x : α) => β} [TransOrd α] (h₁ : t₁.WF) (h₂ : t₂.WF) (h : t₁.Equiv t₂) {k : α} : Const.getEntryGE? k t₁ = Const.getEntryGE? k t₂

theorem Std.DTreeMap.Internal.Impl.Equiv.constGetEntryGE_eq {α : Type u} {instOrd : Ord α} {β : Type v} {t₁ t₂ : Impl α fun (x : α) => β} [TransOrd α] (h₁ : t₁.WF) (h₂ : t₂.WF) (h : t₁.Equiv t₂) {k : α} {he : ∃ (a : α), a ∈ t₁ ∧ (compare a k).isGE = true} : Const.getEntryGE k t₁ ⋯ he = Const.getEntryGE k t₂ ⋯ ⋯

theorem Std.DTreeMap.Internal.Impl.Equiv.constGetEntryGE!_eq {α : Type u} {instOrd : Ord α} {β : Type v} {t₁ t₂ : Impl α fun (x : α) => β} [TransOrd α] (h₁ : t₁.WF) (h₂ : t₂.WF) (h : t₁.Equiv t₂) {k : α} [Inhabited (α × β)] : Const.getEntryGE! k t₁ = Const.getEntryGE! k t₂

theorem Std.DTreeMap.Internal.Impl.Equiv.constGetEntryGED_eq {α : Type u} {instOrd : Ord α} {β : Type v} {t₁ t₂ : Impl α fun (x : α) => β} [TransOrd α] (h₁ : t₁.WF) (h₂ : t₂.WF) (h : t₁.Equiv t₂) {k : α} {fallback : α × β} : Const.getEntryGED k t₁ fallback = Const.getEntryGED k t₂ fallback

theorem Std.DTreeMap.Internal.Impl.Equiv.constGetEntryGT?_eq {α : Type u} {instOrd : Ord α} {β : Type v} {t₁ t₂ : Impl α fun (x : α) => β} [TransOrd α] (h₁ : t₁.WF) (h₂ : t₂.WF) (h : t₁.Equiv t₂) {k : α} : Const.getEntryGT? k t₁ = Const.getEntryGT? k t₂

theorem Std.DTreeMap.Internal.Impl.Equiv.constGetEntryGT_eq {α : Type u} {instOrd : Ord α} {β : Type v} {t₁ t₂ : Impl α fun (x : α) => β} [TransOrd α] (h₁ : t₁.WF) (h₂ : t₂.WF) (h : t₁.Equiv t₂) {k : α} {he : ∃ (a : α), a ∈ t₁ ∧ compare a k = Ordering.gt} : Const.getEntryGT k t₁ ⋯ he = Const.getEntryGT k t₂ ⋯ ⋯

theorem Std.DTreeMap.Internal.Impl.Equiv.constGetEntryGT!_eq {α : Type u} {instOrd : Ord α} {β : Type v} {t₁ t₂ : Impl α fun (x : α) => β} [TransOrd α] (h₁ : t₁.WF) (h₂ : t₂.WF) (h : t₁.Equiv t₂) {k : α} [Inhabited (α × β)] : Const.getEntryGT! k t₁ = Const.getEntryGT! k t₂

theorem Std.DTreeMap.Internal.Impl.Equiv.constGetEntryGTD_eq {α : Type u} {instOrd : Ord α} {β : Type v} {t₁ t₂ : Impl α fun (x : α) => β} [TransOrd α] (h₁ : t₁.WF) (h₂ : t₂.WF) (h : t₁.Equiv t₂) {k : α} {fallback : α × β} : Const.getEntryGTD k t₁ fallback = Const.getEntryGTD k t₂ fallback

theorem Std.DTreeMap.Internal.Impl.Equiv.constGetEntryLE?_eq {α : Type u} {instOrd : Ord α} {β : Type v} {t₁ t₂ : Impl α fun (x : α) => β} [TransOrd α] (h₁ : t₁.WF) (h₂ : t₂.WF) (h : t₁.Equiv t₂) {k : α} : Const.getEntryLE? k t₁ = Const.getEntryLE? k t₂

theorem Std.DTreeMap.Internal.Impl.Equiv.constGetEntryLE_eq {α : Type u} {instOrd : Ord α} {β : Type v} {t₁ t₂ : Impl α fun (x : α) => β} [TransOrd α] (h₁ : t₁.WF) (h₂ : t₂.WF) (h : t₁.Equiv t₂) {k : α} {he : ∃ (a : α), a ∈ t₁ ∧ (compare a k).isLE = true} : Const.getEntryLE k t₁ ⋯ he = Const.getEntryLE k t₂ ⋯ ⋯

theorem Std.DTreeMap.Internal.Impl.Equiv.constGetEntryLE!_eq {α : Type u} {instOrd : Ord α} {β : Type v} {t₁ t₂ : Impl α fun (x : α) => β} [TransOrd α] (h₁ : t₁.WF) (h₂ : t₂.WF) (h : t₁.Equiv t₂) {k : α} [Inhabited (α × β)] : Const.getEntryLE! k t₁ = Const.getEntryLE! k t₂

theorem Std.DTreeMap.Internal.Impl.Equiv.constGetEntryLED_eq {α : Type u} {instOrd : Ord α} {β : Type v} {t₁ t₂ : Impl α fun (x : α) => β} [TransOrd α] (h₁ : t₁.WF) (h₂ : t₂.WF) (h : t₁.Equiv t₂) {k : α} {fallback : α × β} : Const.getEntryLED k t₁ fallback = Const.getEntryLED k t₂ fallback

theorem Std.DTreeMap.Internal.Impl.Equiv.constGetEntryLT?_eq {α : Type u} {instOrd : Ord α} {β : Type v} {t₁ t₂ : Impl α fun (x : α) => β} [TransOrd α] (h₁ : t₁.WF) (h₂ : t₂.WF) (h : t₁.Equiv t₂) {k : α} : Const.getEntryLT? k t₁ = Const.getEntryLT? k t₂

theorem Std.DTreeMap.Internal.Impl.Equiv.constGetEntryLT_eq {α : Type u} {instOrd : Ord α} {β : Type v} {t₁ t₂ : Impl α fun (x : α) => β} [TransOrd α] (h₁ : t₁.WF) (h₂ : t₂.WF) (h : t₁.Equiv t₂) {k : α} {he : ∃ (a : α), a ∈ t₁ ∧ compare a k = Ordering.lt} : Const.getEntryLT k t₁ ⋯ he = Const.getEntryLT k t₂ ⋯ ⋯

theorem Std.DTreeMap.Internal.Impl.Equiv.constGetEntryLT!_eq {α : Type u} {instOrd : Ord α} {β : Type v} {t₁ t₂ : Impl α fun (x : α) => β} [TransOrd α] (h₁ : t₁.WF) (h₂ : t₂.WF) (h : t₁.Equiv t₂) {k : α} [Inhabited (α × β)] : Const.getEntryLT! k t₁ = Const.getEntryLT! k t₂

theorem Std.DTreeMap.Internal.Impl.Equiv.constGetEntryLTD_eq {α : Type u} {instOrd : Ord α} {β : Type v} {t₁ t₂ : Impl α fun (x : α) => β} [TransOrd α] (h₁ : t₁.WF) (h₂ : t₂.WF) (h : t₁.Equiv t₂) {k : α} {fallback : α × β} : Const.getEntryLTD k t₁ fallback = Const.getEntryLTD k t₂ fallback

theorem Std.DTreeMap.Internal.Impl.Equiv.constAlter {α : Type u} {instOrd : Ord α} {β : Type v} {t₁ t₂ : Impl α fun (x : α) => β} [TransOrd α] (h₁ : t₁.WF) (h₂ : t₂.WF) (h : t₁.Equiv t₂) {k : α} {f : Option β → Option β} : (Const.alter k f t₁ ⋯).impl.Equiv (Const.alter k f t₂ ⋯).impl

theorem Std.DTreeMap.Internal.Impl.Equiv.constAlter! {α : Type u} {instOrd : Ord α} {β : Type v} {t₁ t₂ : Impl α fun (x : α) => β} [TransOrd α] (h₁ : t₁.WF) (h₂ : t₂.WF) (h : t₁.Equiv t₂) {k : α} {f : Option β → Option β} : (Const.alter! k f t₁).Equiv (Const.alter! k f t₂)

theorem Std.DTreeMap.Internal.Impl.Equiv.constModify {α : Type u} {instOrd : Ord α} {β : Type v} {t₁ t₂ : Impl α fun (x : α) => β} [TransOrd α] (h₁ : t₁.WF) (h₂ : t₂.WF) (h : t₁.Equiv t₂) {k : α} {f : β → β} : (Const.modify k f t₁).Equiv (Const.modify k f t₂)

theorem Std.DTreeMap.Internal.Impl.Equiv.constInsertMany_list {α : Type u} {instOrd : Ord α} {β : Type v} {t₁ t₂ : Impl α fun (x : α) => β} [TransOrd α] (h₁ : t₁.WF) (h₂ : t₂.WF) (h : t₁.Equiv t₂) {l : List (α × β)} : (Const.insertMany t₁ l ⋯).val.Equiv (Const.insertMany t₂ l ⋯).val

theorem Std.DTreeMap.Internal.Impl.Equiv.constInsertMany!_list {α : Type u} {instOrd : Ord α} {β : Type v} {t₁ t₂ : Impl α fun (x : α) => β} [TransOrd α] (h₁ : t₁.WF) (h₂ : t₂.WF) (h : t₁.Equiv t₂) {l : List (α × β)} : (Const.insertMany! t₁ l).val.Equiv (Const.insertMany! t₂ l).val

theorem Std.DTreeMap.Internal.Impl.Equiv.constInsertManyIfNewUnit_list {α : Type u} {instOrd : Ord α} [TransOrd α] {t₁ t₂ : Impl α fun (x : α) => Unit} (h₁ : t₁.WF) (h₂ : t₂.WF) (h : t₁.Equiv t₂) {l : List α} : (Const.insertManyIfNewUnit t₁ l ⋯).val.Equiv (Const.insertManyIfNewUnit t₂ l ⋯).val

theorem Std.DTreeMap.Internal.Impl.Equiv.constInsertManyIfNewUnit!_list {α : Type u} {instOrd : Ord α} [TransOrd α] {t₁ t₂ : Impl α fun (x : α) => Unit} (h₁ : t₁.WF) (h₂ : t₂.WF) (h : t₁.Equiv t₂) {l : List α} : (Const.insertManyIfNewUnit! t₁ l).val.Equiv (Const.insertManyIfNewUnit! t₂ l).val

theorem Std.DTreeMap.Internal.Impl.Equiv.constMergeWith {α : Type u} {instOrd : Ord α} {β : Type v} {t₁ t₂ t₃ t₄ : Impl α fun (x : α) => β} [TransOrd α] (h : t₁.Equiv t₂) (h' : t₃.Equiv t₄) (h₁ : t₁.WF) (h₂ : t₂.WF) (h₃ : t₃.WF) (h₄ : t₄.WF) {f : α → β → β → β} : (Const.mergeWith f t₁ t₃ ⋯).impl.Equiv (Const.mergeWith f t₂ t₄ ⋯).impl

theorem Std.DTreeMap.Internal.Impl.Equiv.constMergeWith! {α : Type u} {instOrd : Ord α} {β : Type v} {t₁ t₂ t₃ t₄ : Impl α fun (x : α) => β} [TransOrd α] (h : t₁.Equiv t₂) (h' : t₃.Equiv t₄) (h₁ : t₁.WF) (h₂ : t₂.WF) (h₃ : t₃.WF) (h₄ : t₄.WF) {f : α → β → β → β} : (Const.mergeWith! f t₁ t₃).Equiv (Const.mergeWith! f t₂ t₄)

theorem Std.DTreeMap.Internal.Impl.Equiv.of_forall_get?_eq {α : Type u} {β : α → Type v} {instOrd : Ord α} {t₁ t₂ : Impl α β} [TransOrd α] [LawfulEqOrd α] (h₁ : t₁.WF) (h₂ : t₂.WF) : (∀ (k : α), t₁.get? k = t₂.get? k) → t₁.Equiv t₂

theorem Std.DTreeMap.Internal.Impl.Equiv.of_forall_getKey_eq_of_forall_constGet?_eq {α : Type u} {instOrd : Ord α} {β : Type v} {t₁ t₂ : Impl α fun (x : α) => β} [TransOrd α] (h₁ : t₁.WF) (h₂ : t₂.WF) : (∀ (k : α) (hk : contains k t₁ = true) (hk' : contains k t₂ = true), t₁.getKey k hk = t₂.getKey k hk') → (∀ (k : α), Const.get? t₁ k = Const.get? t₂ k) → t₁.Equiv t₂

theorem Std.DTreeMap.Internal.Impl.Equiv.of_forall_constGet?_eq {α : Type u} {instOrd : Ord α} {β : Type v} {t₁ t₂ : Impl α fun (x : α) => β} [TransOrd α] [LawfulEqOrd α] (h₁ : t₁.WF) (h₂ : t₂.WF) : (∀ (k : α), Const.get? t₁ k = Const.get? t₂ k) → t₁.Equiv t₂

theorem Std.DTreeMap.Internal.Impl.Equiv.of_forall_getKey?_unit_eq {α : Type u} {instOrd : Ord α} [TransOrd α] {t₁ t₂ : Impl α fun (x : α) => Unit} (h₁ : t₁.WF) (h₂ : t₂.WF) : (∀ (k : α), t₁.getKey? k = t₂.getKey? k) → t₁.Equiv t₂

theorem Std.DTreeMap.Internal.Impl.Equiv.of_forall_contains_unit_eq {α : Type u} {instOrd : Ord α} [TransOrd α] [LawfulEqOrd α] {t₁ t₂ : Impl α fun (x : α) => Unit} (h₁ : t₁.WF) (h₂ : t₂.WF) : (∀ (k : α), contains k t₁ = contains k t₂) → t₁.Equiv t₂

theorem Std.DTreeMap.Internal.Impl.Equiv.of_forall_mem_unit_iff {α : Type u} {instOrd : Ord α} [TransOrd α] [LawfulEqOrd α] {t₁ t₂ : Impl α fun (x : α) => Unit} (h₁ : t₁.WF) (h₂ : t₂.WF) : (∀ (k : α), k ∈ t₁ ↔ k ∈ t₂) → t₁.Equiv t₂

theorem Std.DTreeMap.Internal.Impl.equiv_empty_iff_isEmpty {α : Type u} {β : α → Type v} {t : Impl α β} : t.Equiv empty ↔ t.isEmpty = true

theorem Std.DTreeMap.Internal.Impl.empty_equiv_iff_isEmpty {α : Type u} {β : α → Type v} {t : Impl α β} : empty.Equiv t ↔ t.isEmpty = true

theorem Std.DTreeMap.Internal.Impl.equiv_iff_toList_perm {α : Type u} {β : α → Type v} {t₁ t₂ : Impl α β} : t₁.Equiv t₂ ↔ t₁.toList.Perm t₂.toList

theorem Std.DTreeMap.Internal.Impl.equiv_iff_toArray_perm {α : Type u} {β : α → Type v} {t₁ t₂ : Impl α β} : t₁.Equiv t₂ ↔ t₁.toArray.Perm t₂.toArray

theorem Std.DTreeMap.Internal.Impl.Equiv.of_toList_perm {α : Type u} {β : α → Type v} {t₁ t₂ : Impl α β} : t₁.toList.Perm t₂.toList → t₁.Equiv t₂

theorem Std.DTreeMap.Internal.Impl.Equiv.of_toArray_perm {α : Type u} {β : α → Type v} {t₁ t₂ : Impl α β} : t₁.toArray.Perm t₂.toArray → t₁.Equiv t₂

theorem Std.DTreeMap.Internal.Impl.equiv_iff_toList_eq {α : Type u} {β : α → Type v} {instOrd : Ord α} {t₁ t₂ : Impl α β} [TransOrd α] (h₁ : t₁.WF) (h₂ : t₂.WF) : t₁.Equiv t₂ ↔ t₁.toList = t₂.toList

theorem Std.DTreeMap.Internal.Impl.equiv_iff_toArray_eq {α : Type u} {β : α → Type v} {instOrd : Ord α} {t₁ t₂ : Impl α β} [TransOrd α] (h₁ : t₁.WF) (h₂ : t₂.WF) : t₁.Equiv t₂ ↔ t₁.toArray = t₂.toArray

theorem Std.DTreeMap.Internal.Impl.insertMany_list_equiv_foldl {α : Type u} {β : α → Type v} {instOrd : Ord α} {t₁ : Impl α β} {l : List ((a : α) × β a)} (h : t₁.WF) : (t₁.insertMany l ⋯).val.Equiv (List.foldl (fun (acc : Impl α β) (p : (a : α) × β a) => insert! p.fst p.snd acc) t₁ l)

theorem Std.DTreeMap.Internal.Impl.insertMany!_list_equiv_foldl {α : Type u} {β : α → Type v} {instOrd : Ord α} {t₁ : Impl α β} {l : List ((a : α) × β a)} : (t₁.insertMany! l).val.Equiv (List.foldl (fun (acc : Impl α β) (p : (a : α) × β a) => insert! p.fst p.snd acc) t₁ l)

theorem Std.DTreeMap.Internal.Impl.insertManyIfNew_list_equiv_foldl {α : Type u} {β : α → Type v} {instOrd : Ord α} {t₁ : Impl α β} {l : List ((a : α) × β a)} (h : t₁.WF) : (t₁.insertManyIfNew l ⋯).val.Equiv (List.foldl (fun (acc : Impl α β) (p : (a : α) × β a) => insertIfNew! p.fst p.snd acc) t₁ l)

theorem Std.DTreeMap.Internal.Impl.insertManyIfNew!_list_equiv_foldl {α : Type u} {β : α → Type v} {instOrd : Ord α} {t₁ : Impl α β} {l : List ((a : α) × β a)} : (t₁.insertManyIfNew! l).val.Equiv (List.foldl (fun (acc : Impl α β) (p : (a : α) × β a) => insertIfNew! p.fst p.snd acc) t₁ l)

theorem Std.DTreeMap.Internal.Impl.Const.equiv_iff_toList_perm {α : Type u} {β : Type v} {t₁ t₂ : Impl α fun (x : α) => β} : t₁.Equiv t₂ ↔ (toList t₁).Perm (toList t₂)

theorem Std.DTreeMap.Internal.Impl.Const.equiv_iff_toArray_perm {α : Type u} {β : Type v} {t₁ t₂ : Impl α fun (x : α) => β} : t₁.Equiv t₂ ↔ (toArray t₁).Perm (toArray t₂)

theorem Std.DTreeMap.Internal.Impl.Const.equiv_iff_toList_eq {α : Type u} {instOrd : Ord α} {β : Type v} {t₁ t₂ : Impl α fun (x : α) => β} [TransOrd α] (h₁ : t₁.WF) (h₂ : t₂.WF) : t₁.Equiv t₂ ↔ toList t₁ = toList t₂

theorem Std.DTreeMap.Internal.Impl.Const.equiv_iff_toArray_eq {α : Type u} {instOrd : Ord α} {β : Type v} {t₁ t₂ : Impl α fun (x : α) => β} [TransOrd α] (h₁ : t₁.WF) (h₂ : t₂.WF) : t₁.Equiv t₂ ↔ toArray t₁ = toArray t₂

theorem Std.DTreeMap.Internal.Impl.Const.equiv_iff_keys_perm {α : Type u} {t₁ t₂ : Impl α fun (x : α) => Unit} : t₁.Equiv t₂ ↔ t₁.keys.Perm t₂.keys

theorem Std.DTreeMap.Internal.Impl.Const.Equiv.of_keys_perm {α : Type u} {t₁ t₂ : Impl α fun (x : α) => Unit} : t₁.keys.Perm t₂.keys → t₁.Equiv t₂

theorem Std.DTreeMap.Internal.Impl.Const.equiv_iff_keysArray_perm {α : Type u} {t₁ t₂ : Impl α fun (x : α) => Unit} : t₁.Equiv t₂ ↔ t₁.keysArray.Perm t₂.keysArray

theorem Std.DTreeMap.Internal.Impl.Const.Equiv.of_keysArray_perm {α : Type u} {t₁ t₂ : Impl α fun (x : α) => Unit} : t₁.keysArray.Perm t₂.keysArray → t₁.Equiv t₂

theorem Std.DTreeMap.Internal.Impl.Const.equiv_iff_keys_eq {α : Type u} {instOrd : Ord α} {t₁ t₂ : Impl α fun (x : α) => Unit} [TransOrd α] (h₁ : t₁.WF) (h₂ : t₂.WF) : t₁.Equiv t₂ ↔ t₁.keys = t₂.keys

theorem Std.DTreeMap.Internal.Impl.Const.equiv_iff_keysArray_eq {α : Type u} {instOrd : Ord α} {t₁ t₂ : Impl α fun (x : α) => Unit} [TransOrd α] (h₁ : t₁.WF) (h₂ : t₂.WF) : t₁.Equiv t₂ ↔ t₁.keysArray = t₂.keysArray

theorem Std.DTreeMap.Internal.Impl.Const.insertMany_list_equiv_foldl {α : Type u} {instOrd : Ord α} {β : Type v} {t₁ : Impl α fun (x : α) => β} {l : List (α × β)} (h : t₁.WF) : (insertMany t₁ l ⋯).val.Equiv (List.foldl (fun (acc : Impl α fun (x : α) => β) (p : α × β) => insert! p.fst p.snd acc) t₁ l)

theorem Std.DTreeMap.Internal.Impl.Const.insertMany!_list_equiv_foldl {α : Type u} {instOrd : Ord α} {β : Type v} {t₁ : Impl α fun (x : α) => β} {l : List (α × β)} : (insertMany! t₁ l).val.Equiv (List.foldl (fun (acc : Impl α fun (x : α) => β) (p : α × β) => insert! p.fst p.snd acc) t₁ l)

theorem Std.DTreeMap.Internal.Impl.Const.insertManyIfNewUnit_list_equiv_foldl {α : Type u} {instOrd : Ord α} {t₁ : Impl α fun (x : α) => Unit} {l : List α} (h : t₁.WF) : (insertManyIfNewUnit t₁ l ⋯).val.Equiv (List.foldl (fun (acc : Impl α fun (a : α) => Unit) (a : α) => insertIfNew! a () acc) t₁ l)

theorem Std.DTreeMap.Internal.Impl.Const.insertManyIfNewUnit!_list_equiv_foldl {α : Type u} {instOrd : Ord α} {t₁ : Impl α fun (x : α) => Unit} {l : List α} : (insertManyIfNewUnit! t₁ l).val.Equiv (List.foldl (fun (acc : Impl α fun (a : α) => Unit) (a : α) => insertIfNew! a () acc) t₁ l)

theorem Std.DTreeMap.Internal.Impl.toList_filterMap {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} {γ : α → Type w} {f : (a : α) → β a → Option (γ a)} (h : t.WF) : (filterMap f t ⋯).impl.toList = List.filterMap (fun (p : (a : α) × β a) => Option.map (fun (x : γ p.fst) => ⟨p.fst, x⟩) (f p.fst p.snd)) t.toList

theorem Std.DTreeMap.Internal.Impl.toArray_filterMap {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} {γ : α → Type w} {f : (a : α) → β a → Option (γ a)} (h : t.WF) : (filterMap f t ⋯).impl.toArray = Array.filterMap (fun (p : (a : α) × β a) => Option.map (fun (x : γ p.fst) => ⟨p.fst, x⟩) (f p.fst p.snd)) t.toArray

theorem Std.DTreeMap.Internal.Impl.toList_filterMap! {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} {γ : α → Type w} {f : (a : α) → β a → Option (γ a)} (h : t.WF) : (filterMap! f t).toList = List.filterMap (fun (p : (a : α) × β a) => Option.map (fun (x : γ p.fst) => ⟨p.fst, x⟩) (f p.fst p.snd)) t.toList

theorem Std.DTreeMap.Internal.Impl.toArray_filterMap! {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} {γ : α → Type w} {f : (a : α) → β a → Option (γ a)} (h : t.WF) : (filterMap! f t).toArray = Array.filterMap (fun (p : (a : α) × β a) => Option.map (fun (x : γ p.fst) => ⟨p.fst, x⟩) (f p.fst p.snd)) t.toArray

theorem Std.DTreeMap.Internal.Impl.isEmpty_filterMap_iff {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} {γ : α → Type w} [TransOrd α] [LawfulEqOrd α] {f : (a : α) → β a → Option (γ a)} (h : t.WF) : (filterMap f t ⋯).impl.isEmpty = true ↔ ∀ (k : α) (h : contains k t = true), f k (t.get k h) = none

theorem Std.DTreeMap.Internal.Impl.isEmpty_filterMap!_iff {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} {γ : α → Type w} [TransOrd α] [LawfulEqOrd α] {f : (a : α) → β a → Option (γ a)} (h : t.WF) : (filterMap! f t).isEmpty = true ↔ ∀ (k : α) (h : contains k t = true), f k (t.get k h) = none

theorem Std.DTreeMap.Internal.Impl.isEmpty_filterMap_eq_false_iff {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} {γ : α → Type w} [TransOrd α] [LawfulEqOrd α] {f : (a : α) → β a → Option (γ a)} (h : t.WF) : (filterMap f t ⋯).impl.isEmpty = false ↔ ∃ (k : α), ∃ (h : contains k t = true), (f k (t.get k h)).isSome = true

theorem Std.DTreeMap.Internal.Impl.isEmpty_filterMap!_eq_false_iff {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} {γ : α → Type w} [TransOrd α] [LawfulEqOrd α] {f : (a : α) → β a → Option (γ a)} (h : t.WF) : (filterMap! f t).isEmpty = false ↔ ∃ (k : α), ∃ (h : contains k t = true), (f k (t.get k h)).isSome = true

theorem Std.DTreeMap.Internal.Impl.contains_filterMap {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} {γ : α → Type w} [TransOrd α] [LawfulEqOrd α] {f : (a : α) → β a → Option (γ a)} {k : α} (h : t.WF) : contains k (filterMap f t ⋯).impl = Option.any (fun (x : β k) => (f k x).isSome) (t.get? k)

theorem Std.DTreeMap.Internal.Impl.contains_filterMap! {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} {γ : α → Type w} [TransOrd α] [LawfulEqOrd α] {f : (a : α) → β a → Option (γ a)} {k : α} (h : t.WF) : contains k (filterMap! f t) = Option.any (fun (x : β k) => (f k x).isSome) (t.get? k)

theorem Std.DTreeMap.Internal.Impl.contains_of_contains_filterMap {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} {γ : α → Type w} [TransOrd α] {f : (a : α) → β a → Option (γ a)} {k : α} (h : t.WF) : contains k (filterMap f t ⋯).impl = true → contains k t = true

theorem Std.DTreeMap.Internal.Impl.contains_of_contains_filterMap! {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} {γ : α → Type w} [TransOrd α] {f : (a : α) → β a → Option (γ a)} {k : α} (h : t.WF) : contains k (filterMap! f t) = true → contains k t = true

theorem Std.DTreeMap.Internal.Impl.size_filterMap_le_size {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} {γ : α → Type w} [TransOrd α] {f : (a : α) → β a → Option (γ a)} (h : t.WF) : (filterMap f t ⋯).impl.size ≤ t.size

theorem Std.DTreeMap.Internal.Impl.size_filterMap!_le_size {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} {γ : α → Type w} [TransOrd α] {f : (a : α) → β a → Option (γ a)} (h : t.WF) : (filterMap! f t).size ≤ t.size

theorem Std.DTreeMap.Internal.Impl.size_filterMap_eq_size_iff {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} {γ : α → Type w} [TransOrd α] [LawfulEqOrd α] {f : (a : α) → β a → Option (γ a)} (h : t.WF) : (filterMap f t ⋯).impl.size = t.size ↔ ∀ (a : α) (h : contains a t = true), (f a (t.get a h)).isSome = true

theorem Std.DTreeMap.Internal.Impl.size_filterMap!_eq_size_iff {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} {γ : α → Type w} [TransOrd α] [LawfulEqOrd α] {f : (a : α) → β a → Option (γ a)} (h : t.WF) : (filterMap! f t).size = t.size ↔ ∀ (a : α) (h : contains a t = true), (f a (t.get a h)).isSome = true

theorem Std.DTreeMap.Internal.Impl.get?_filterMap {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} {γ : α → Type w} [TransOrd α] [LawfulEqOrd α] {f : (a : α) → β a → Option (γ a)} {k : α} (h : t.WF) : (filterMap f t ⋯).impl.get? k = (t.get? k).bind (f k)

theorem Std.DTreeMap.Internal.Impl.get?_filterMap! {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} {γ : α → Type w} [TransOrd α] [LawfulEqOrd α] {f : (a : α) → β a → Option (γ a)} {k : α} (h : t.WF) : (filterMap! f t).get? k = (t.get? k).bind (f k)

theorem Std.DTreeMap.Internal.Impl.isSome_apply_of_contains_filterMap {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} {γ : α → Type w} [TransOrd α] [LawfulEqOrd α] {f : (a : α) → β a → Option (γ a)} {k : α} (h : t.WF) (h' : contains k (filterMap f t ⋯).impl = true) : (f k (t.get k ⋯)).isSome = true

theorem Std.DTreeMap.Internal.Impl.isSome_apply_of_contains_filterMap! {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} {γ : α → Type w} [TransOrd α] [LawfulEqOrd α] {f : (a : α) → β a → Option (γ a)} {k : α} (h : t.WF) (h' : contains k (filterMap! f t) = true) : (f k (t.get k ⋯)).isSome = true

theorem Std.DTreeMap.Internal.Impl.get_filterMap {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} {γ : α → Type w} [TransOrd α] [LawfulEqOrd α] {f : (a : α) → β a → Option (γ a)} {k : α} (h : t.WF) {h' : k ∈ (filterMap f t ⋯).impl} : (filterMap f t ⋯).impl.get k h' = (f k (t.get k ⋯)).get ⋯

theorem Std.DTreeMap.Internal.Impl.get_filterMap! {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} {γ : α → Type w} [TransOrd α] [LawfulEqOrd α] {f : (a : α) → β a → Option (γ a)} {k : α} (h : t.WF) {h' : k ∈ filterMap! f t} : (filterMap! f t).get k h' = (f k (t.get k ⋯)).get ⋯

theorem Std.DTreeMap.Internal.Impl.get!_filterMap {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} {γ : α → Type w} [TransOrd α] [LawfulEqOrd α] {f : (a : α) → β a → Option (γ a)} {k : α} [Inhabited (γ k)] (h : t.WF) : (filterMap f t ⋯).impl.get! k = ((t.get? k).bind (f k)).get!

theorem Std.DTreeMap.Internal.Impl.get!_filterMap! {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} {γ : α → Type w} [TransOrd α] [LawfulEqOrd α] {f : (a : α) → β a → Option (γ a)} {k : α} [Inhabited (γ k)] (h : t.WF) : (filterMap! f t).get! k = ((t.get? k).bind (f k)).get!

theorem Std.DTreeMap.Internal.Impl.getD_filterMap {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} {γ : α → Type w} [TransOrd α] [LawfulEqOrd α] {f : (a : α) → β a → Option (γ a)} {k : α} {fallback : γ k} (h : t.WF) : (filterMap f t ⋯).impl.getD k fallback = ((t.get? k).bind (f k)).getD fallback

theorem Std.DTreeMap.Internal.Impl.getD_filterMap! {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} {γ : α → Type w} [TransOrd α] [LawfulEqOrd α] {f : (a : α) → β a → Option (γ a)} {k : α} {fallback : γ k} (h : t.WF) : (filterMap! f t).getD k fallback = ((t.get? k).bind (f k)).getD fallback

theorem Std.DTreeMap.Internal.Impl.getKey?_filterMap {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} {γ : α → Type w} [TransOrd α] [LawfulEqOrd α] {f : (a : α) → β a → Option (γ a)} {k : α} (h : t.WF) : (filterMap f t ⋯).impl.getKey? k = (t.getKey? k).pfilter fun (x : α) (h' : t.getKey? k = some x) => (f x (t.get x ⋯)).isSome

theorem Std.DTreeMap.Internal.Impl.getKey?_filterMap! {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} {γ : α → Type w} [TransOrd α] [LawfulEqOrd α] {f : (a : α) → β a → Option (γ a)} {k : α} (h : t.WF) : (filterMap! f t).getKey? k = (t.getKey? k).pfilter fun (x : α) (h' : t.getKey? k = some x) => (f x (t.get x ⋯)).isSome

theorem Std.DTreeMap.Internal.Impl.getKey_filterMap {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} {γ : α → Type w} [TransOrd α] {f : (a : α) → β a → Option (γ a)} {k : α} (h : t.WF) {h' : contains k (filterMap f t ⋯).impl = true} : (filterMap f t ⋯).impl.getKey k h' = t.getKey k ⋯

theorem Std.DTreeMap.Internal.Impl.getKey_filterMap! {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} {γ : α → Type w} [TransOrd α] {f : (a : α) → β a → Option (γ a)} {k : α} (h : t.WF) {h' : contains k (filterMap! f t) = true} : (filterMap! f t).getKey k h' = t.getKey k ⋯

theorem Std.DTreeMap.Internal.Impl.getKey!_filterMap {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} {γ : α → Type w} [TransOrd α] [LawfulEqOrd α] [Inhabited α] {f : (a : α) → β a → Option (γ a)} {k : α} (h : t.WF) : (filterMap f t ⋯).impl.getKey! k = ((t.getKey? k).pfilter fun (x : α) (h' : t.getKey? k = some x) => (f x (t.get x ⋯)).isSome).get!

theorem Std.DTreeMap.Internal.Impl.getKey!_filterMap! {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} {γ : α → Type w} [TransOrd α] [LawfulEqOrd α] [Inhabited α] {f : (a : α) → β a → Option (γ a)} {k : α} (h : t.WF) : (filterMap! f t).getKey! k = ((t.getKey? k).pfilter fun (x : α) (h' : t.getKey? k = some x) => (f x (t.get x ⋯)).isSome).get!

theorem Std.DTreeMap.Internal.Impl.getKeyD_filterMap {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} {γ : α → Type w} [TransOrd α] [LawfulEqOrd α] {f : (a : α) → β a → Option (γ a)} {k fallback : α} (h : t.WF) : (filterMap f t ⋯).impl.getKeyD k fallback = ((t.getKey? k).pfilter fun (x : α) (h' : t.getKey? k = some x) => (f x (t.get x ⋯)).isSome).getD fallback

theorem Std.DTreeMap.Internal.Impl.getKeyD_filterMap! {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} {γ : α → Type w} [TransOrd α] [LawfulEqOrd α] {f : (a : α) → β a → Option (γ a)} {k fallback : α} (h : t.WF) : (filterMap! f t).getKeyD k fallback = ((t.getKey? k).pfilter fun (x : α) (h' : t.getKey? k = some x) => (f x (t.get x ⋯)).isSome).getD fallback

theorem Std.DTreeMap.Internal.Impl.Const.isEmpty_filterMap_iff {α : Type u} {instOrd : Ord α} {β : Type v} {γ : Type w} {t : Impl α fun (x : α) => β} [TransOrd α] {f : α → β → Option γ} (h : t.WF) : (filterMap f t ⋯).impl.isEmpty = true ↔ ∀ (k : α) (h : contains k t = true), f (t.getKey k h) (get t k h) = none

theorem Std.DTreeMap.Internal.Impl.Const.isEmpty_filterMap!_iff {α : Type u} {instOrd : Ord α} {β : Type v} {γ : Type w} {t : Impl α fun (x : α) => β} [TransOrd α] {f : α → β → Option γ} (h : t.WF) : (filterMap! f t).isEmpty = true ↔ ∀ (k : α) (h : contains k t = true), f (t.getKey k h) (get t k h) = none

theorem Std.DTreeMap.Internal.Impl.Const.isEmpty_filterMap_eq_false_iff {α : Type u} {instOrd : Ord α} {β : Type v} {γ : Type w} {t : Impl α fun (x : α) => β} [TransOrd α] {f : α → β → Option γ} (h : t.WF) : (filterMap f t ⋯).impl.isEmpty = false ↔ ∃ (k : α), ∃ (h : contains k t = true), (f (t.getKey k h) (get t k h)).isSome = true

theorem Std.DTreeMap.Internal.Impl.Const.isEmpty_filterMap!_eq_false_iff {α : Type u} {instOrd : Ord α} {β : Type v} {γ : Type w} {t : Impl α fun (x : α) => β} [TransOrd α] {f : α → β → Option γ} (h : t.WF) : (filterMap! f t).isEmpty = false ↔ ∃ (k : α), ∃ (h : contains k t = true), (f (t.getKey k h) (get t k h)).isSome = true

theorem Std.DTreeMap.Internal.Impl.Const.contains_filterMap_iff {α : Type u} {instOrd : Ord α} {β : Type v} {γ : Type w} {t : Impl α fun (x : α) => β} [TransOrd α] {f : α → β → Option γ} {k : α} (h : t.WF) : contains k (filterMap f t ⋯).impl = true ↔ ∃ (h' : contains k t = true), (f (t.getKey k h') (get t k h')).isSome = true

theorem Std.DTreeMap.Internal.Impl.Const.contains_filterMap!_iff {α : Type u} {instOrd : Ord α} {β : Type v} {γ : Type w} {t : Impl α fun (x : α) => β} [TransOrd α] {f : α → β → Option γ} {k : α} (h : t.WF) : contains k (filterMap! f t) = true ↔ ∃ (h' : contains k t = true), (f (t.getKey k h') (get t k h')).isSome = true

theorem Std.DTreeMap.Internal.Impl.Const.size_filterMap_eq_size_iff {α : Type u} {instOrd : Ord α} {β : Type v} {γ : Type w} {t : Impl α fun (x : α) => β} [TransOrd α] {f : α → β → Option γ} (h : t.WF) : (filterMap f t ⋯).impl.size = t.size ↔ ∀ (a : α) (h : contains a t = true), (f (t.getKey a h) (get t a h)).isSome = true

theorem Std.DTreeMap.Internal.Impl.Const.size_filterMap!_eq_size_iff {α : Type u} {instOrd : Ord α} {β : Type v} {γ : Type w} {t : Impl α fun (x : α) => β} [TransOrd α] {f : α → β → Option γ} (h : t.WF) : (filterMap! f t).size = t.size ↔ ∀ (a : α) (h : contains a t = true), (f (t.getKey a h) (get t a h)).isSome = true

theorem Std.DTreeMap.Internal.Impl.Const.get?_filterMap {α : Type u} {instOrd : Ord α} {β : Type v} {γ : Type w} {t : Impl α fun (x : α) => β} [TransOrd α] {f : α → β → Option γ} {k : α} (h : t.WF) : get? (filterMap f t ⋯).impl k = (get? t k).pbind fun (x : β) (h' : get? t k = some x) => f (t.getKey k ⋯) x

theorem Std.DTreeMap.Internal.Impl.Const.get?_filterMap! {α : Type u} {instOrd : Ord α} {β : Type v} {γ : Type w} {t : Impl α fun (x : α) => β} [TransOrd α] {f : α → β → Option γ} {k : α} (h : t.WF) : get? (filterMap! f t) k = (get? t k).pbind fun (x : β) (h' : get? t k = some x) => f (t.getKey k ⋯) x

theorem Std.DTreeMap.Internal.Impl.Const.get?_filterMap_of_getKey?_eq_some {α : Type u} {instOrd : Ord α} {β : Type v} {γ : Type w} {t : Impl α fun (x : α) => β} [TransOrd α] {f : α → β → Option γ} {k k' : α} (h : t.WF) : t.getKey? k = some k' → get? (filterMap f t ⋯).impl k = (get? t k).bind fun (x : β) => f k' x

theorem Std.DTreeMap.Internal.Impl.Const.get?_filterMap!_of_getKey?_eq_some {α : Type u} {instOrd : Ord α} {β : Type v} {γ : Type w} {t : Impl α fun (x : α) => β} [TransOrd α] {f : α → β → Option γ} {k k' : α} (h : t.WF) : t.getKey? k = some k' → get? (filterMap! f t) k = (get? t k).bind fun (x : β) => f k' x

theorem Std.DTreeMap.Internal.Impl.Const.isSome_apply_of_contains_filterMap {α : Type u} {instOrd : Ord α} {β : Type v} {γ : Type w} {t : Impl α fun (x : α) => β} [TransOrd α] {f : α → β → Option γ} {k : α} (h : t.WF) (h' : contains k (filterMap f t ⋯).impl = true) : (f (t.getKey k ⋯) (get t k ⋯)).isSome = true

theorem Std.DTreeMap.Internal.Impl.Const.isSome_apply_of_contains_filterMap! {α : Type u} {instOrd : Ord α} {β : Type v} {γ : Type w} {t : Impl α fun (x : α) => β} [TransOrd α] {f : α → β → Option γ} {k : α} (h : t.WF) (h' : contains k (filterMap! f t) = true) : (f (t.getKey k ⋯) (get t k ⋯)).isSome = true

theorem Std.DTreeMap.Internal.Impl.Const.get_filterMap {α : Type u} {instOrd : Ord α} {β : Type v} {γ : Type w} {t : Impl α fun (x : α) => β} [TransOrd α] {f : α → β → Option γ} {k : α} (h : t.WF) {h' : contains k (filterMap f t ⋯).impl = true} : get (filterMap f t ⋯).impl k h' = (f (t.getKey k ⋯) (get t k ⋯)).get ⋯

theorem Std.DTreeMap.Internal.Impl.Const.get_filterMap! {α : Type u} {instOrd : Ord α} {β : Type v} {γ : Type w} {t : Impl α fun (x : α) => β} [TransOrd α] {f : α → β → Option γ} {k : α} (h : t.WF) {h' : contains k (filterMap! f t) = true} : get (filterMap! f t) k h' = (f (t.getKey k ⋯) (get t k ⋯)).get ⋯

theorem Std.DTreeMap.Internal.Impl.Const.get!_filterMap {α : Type u} {instOrd : Ord α} {β : Type v} {γ : Type w} {t : Impl α fun (x : α) => β} [TransOrd α] [Inhabited γ] {f : α → β → Option γ} {k : α} (h : t.WF) : get! (filterMap f t ⋯).impl k = ((get? t k).pbind fun (x : β) (h' : get? t k = some x) => f (t.getKey k ⋯) x).get!

theorem Std.DTreeMap.Internal.Impl.Const.get!_filterMap! {α : Type u} {instOrd : Ord α} {β : Type v} {γ : Type w} {t : Impl α fun (x : α) => β} [TransOrd α] [Inhabited γ] {f : α → β → Option γ} {k : α} (h : t.WF) : get! (filterMap! f t) k = ((get? t k).pbind fun (x : β) (h' : get? t k = some x) => f (t.getKey k ⋯) x).get!

theorem Std.DTreeMap.Internal.Impl.Const.get!_filterMap_of_getKey?_eq_some {α : Type u} {instOrd : Ord α} {β : Type v} {γ : Type w} {t : Impl α fun (x : α) => β} [TransOrd α] [Inhabited γ] {f : α → β → Option γ} {k k' : α} (h : t.WF) : t.getKey? k = some k' → get! (filterMap f t ⋯).impl k = ((get? t k).bind fun (x : β) => f k' x).get!

theorem Std.DTreeMap.Internal.Impl.Const.get!_filterMap!_of_getKey?_eq_some {α : Type u} {instOrd : Ord α} {β : Type v} {γ : Type w} {t : Impl α fun (x : α) => β} [TransOrd α] [Inhabited γ] {f : α → β → Option γ} {k k' : α} (h : t.WF) : t.getKey? k = some k' → get! (filterMap! f t) k = ((get? t k).bind fun (x : β) => f k' x).get!

theorem Std.DTreeMap.Internal.Impl.Const.getD_filterMap {α : Type u} {instOrd : Ord α} {β : Type v} {γ : Type w} {t : Impl α fun (x : α) => β} [TransOrd α] {f : α → β → Option γ} {k : α} {fallback : γ} (h : t.WF) : getD (filterMap f t ⋯).impl k fallback = ((get? t k).pbind fun (x : β) (h' : get? t k = some x) => f (t.getKey k ⋯) x).getD fallback

theorem Std.DTreeMap.Internal.Impl.Const.getD_filterMap! {α : Type u} {instOrd : Ord α} {β : Type v} {γ : Type w} {t : Impl α fun (x : α) => β} [TransOrd α] {f : α → β → Option γ} {k : α} {fallback : γ} (h : t.WF) : getD (filterMap! f t) k fallback = ((get? t k).pbind fun (x : β) (h' : get? t k = some x) => f (t.getKey k ⋯) x).getD fallback

theorem Std.DTreeMap.Internal.Impl.Const.getD_filterMap_of_getKey?_eq_some {α : Type u} {instOrd : Ord α} {β : Type v} {γ : Type w} {t : Impl α fun (x : α) => β} [TransOrd α] {f : α → β → Option γ} {k k' : α} {fallback : γ} (h : t.WF) : t.getKey? k = some k' → getD (filterMap f t ⋯).impl k fallback = ((get? t k).bind fun (x : β) => f k' x).getD fallback

theorem Std.DTreeMap.Internal.Impl.Const.getD_filterMap!_of_getKey?_eq_some {α : Type u} {instOrd : Ord α} {β : Type v} {γ : Type w} {t : Impl α fun (x : α) => β} [TransOrd α] {f : α → β → Option γ} {k k' : α} {fallback : γ} (h : t.WF) : t.getKey? k = some k' → getD (filterMap! f t) k fallback = ((get? t k).bind fun (x : β) => f k' x).getD fallback

theorem Std.DTreeMap.Internal.Impl.Const.toList_filterMap {α : Type u} {instOrd : Ord α} {β : Type v} {γ : Type w} {t : Impl α fun (x : α) => β} {f : α → β → Option γ} (h : t.WF) : toList (filterMap f t ⋯).impl = List.filterMap (fun (p : α × β) => Option.map (fun (x : γ) => (p.fst, x)) (f p.fst p.snd)) (toList t)

theorem Std.DTreeMap.Internal.Impl.Const.toArray_filterMap {α : Type u} {instOrd : Ord α} {β : Type v} {γ : Type w} {t : Impl α fun (x : α) => β} {f : α → β → Option γ} (h : t.WF) : toArray (filterMap f t ⋯).impl = Array.filterMap (fun (p : α × β) => Option.map (fun (x : γ) => (p.fst, x)) (f p.fst p.snd)) (toArray t)

theorem Std.DTreeMap.Internal.Impl.Const.toList_filterMap! {α : Type u} {instOrd : Ord α} {β : Type v} {γ : Type w} {t : Impl α fun (x : α) => β} {f : α → β → Option γ} (h : t.WF) : toList (filterMap! f t) = List.filterMap (fun (p : α × β) => Option.map (fun (x : γ) => (p.fst, x)) (f p.fst p.snd)) (toList t)

theorem Std.DTreeMap.Internal.Impl.Const.toArray_filterMap! {α : Type u} {instOrd : Ord α} {β : Type v} {γ : Type w} {t : Impl α fun (x : α) => β} {f : α → β → Option γ} (h : t.WF) : toArray (filterMap! f t) = Array.filterMap (fun (p : α × β) => Option.map (fun (x : γ) => (p.fst, x)) (f p.fst p.snd)) (toArray t)

theorem Std.DTreeMap.Internal.Impl.Const.getKey?_filterMap {α : Type u} {instOrd : Ord α} {β : Type v} {γ : Type w} {t : Impl α fun (x : α) => β} [TransOrd α] {f : α → β → Option γ} {k : α} (h : t.WF) : (filterMap f t ⋯).impl.getKey? k = (t.getKey? k).pfilter fun (x : α) (h' : t.getKey? k = some x) => (f x (get t x ⋯)).isSome

theorem Std.DTreeMap.Internal.Impl.Const.getKey?_filterMap! {α : Type u} {instOrd : Ord α} {β : Type v} {γ : Type w} {t : Impl α fun (x : α) => β} [TransOrd α] {f : α → β → Option γ} {k : α} (h : t.WF) : (filterMap! f t).getKey? k = (t.getKey? k).pfilter fun (x : α) (h' : t.getKey? k = some x) => (f x (get t x ⋯)).isSome

theorem Std.DTreeMap.Internal.Impl.Const.getKey!_filterMap {α : Type u} {instOrd : Ord α} {β : Type v} {γ : Type w} {t : Impl α fun (x : α) => β} [TransOrd α] [Inhabited α] {f : α → β → Option γ} {k : α} (h : t.WF) : (filterMap f t ⋯).impl.getKey! k = ((t.getKey? k).pfilter fun (x : α) (h' : t.getKey? k = some x) => (f x (get t x ⋯)).isSome).get!

theorem Std.DTreeMap.Internal.Impl.Const.getKey!_filterMap! {α : Type u} {instOrd : Ord α} {β : Type v} {γ : Type w} {t : Impl α fun (x : α) => β} [TransOrd α] [Inhabited α] {f : α → β → Option γ} {k : α} (h : t.WF) : (filterMap! f t).getKey! k = ((t.getKey? k).pfilter fun (x : α) (h' : t.getKey? k = some x) => (f x (get t x ⋯)).isSome).get!

theorem Std.DTreeMap.Internal.Impl.Const.getKeyD_filterMap {α : Type u} {instOrd : Ord α} {β : Type v} {γ : Type w} {t : Impl α fun (x : α) => β} [TransOrd α] {f : α → β → Option γ} {k fallback : α} (h : t.WF) : (filterMap f t ⋯).impl.getKeyD k fallback = ((t.getKey? k).pfilter fun (x : α) (h' : t.getKey? k = some x) => (f x (get t x ⋯)).isSome).getD fallback

theorem Std.DTreeMap.Internal.Impl.Const.getKeyD_filterMap! {α : Type u} {instOrd : Ord α} {β : Type v} {γ : Type w} {t : Impl α fun (x : α) => β} [TransOrd α] {f : α → β → Option γ} {k fallback : α} (h : t.WF) : (filterMap! f t).getKeyD k fallback = ((t.getKey? k).pfilter fun (x : α) (h' : t.getKey? k = some x) => (f x (get t x ⋯)).isSome).getD fallback

theorem Std.DTreeMap.Internal.Impl.filterMap_equiv_filter {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} {f : (a : α) → β a → Bool} (h : t.WF) : (filterMap (fun (k : α) => Option.guard fun (v : β k) => f k v) t ⋯).impl.Equiv (filter f t ⋯).impl

theorem Std.DTreeMap.Internal.Impl.filterMap!_equiv_filter! {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} {f : (a : α) → β a → Bool} (h : t.WF) : (filterMap! (fun (k : α) => Option.guard fun (v : β k) => f k v) t).Equiv (filter! f t)

theorem Std.DTreeMap.Internal.Impl.toList_filter {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} {f : (a : α) → β a → Bool} (h : t.WF) : (filter f t ⋯).impl.toList = List.filter (fun (p : (a : α) × β a) => f p.fst p.snd) t.toList

theorem Std.DTreeMap.Internal.Impl.toArray_filter {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} {f : (a : α) → β a → Bool} (h : t.WF) : (filter f t ⋯).impl.toArray = Array.filter (fun (p : (a : α) × β a) => f p.fst p.snd) t.toArray

theorem Std.DTreeMap.Internal.Impl.toList_filter! {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} {f : (a : α) → β a → Bool} (h : t.WF) : (filter! f t).toList = List.filter (fun (p : (a : α) × β a) => f p.fst p.snd) t.toList

theorem Std.DTreeMap.Internal.Impl.toArray_filter! {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} {f : (a : α) → β a → Bool} (h : t.WF) : (filter! f t).toArray = Array.filter (fun (p : (a : α) × β a) => f p.fst p.snd) t.toArray

theorem Std.DTreeMap.Internal.Impl.keys_filter_key {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} {f : α → Bool} (h : t.WF) : (filter (fun (k : α) (x : β k) => f k) t ⋯).impl.keys = List.filter f t.keys

theorem Std.DTreeMap.Internal.Impl.keysArray_filter_key {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} {f : α → Bool} (h : t.WF) : (filter (fun (k : α) (x : β k) => f k) t ⋯).impl.keysArray = Array.filter f t.keysArray

theorem Std.DTreeMap.Internal.Impl.keys_filter!_key {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} {f : α → Bool} (h : t.WF) : (filter! (fun (k : α) (x : β k) => f k) t).keys = List.filter f t.keys

theorem Std.DTreeMap.Internal.Impl.keysArray_filter!_key {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} {f : α → Bool} (h : t.WF) : (filter! (fun (k : α) (x : β k) => f k) t).keysArray = Array.filter f t.keysArray

theorem Std.DTreeMap.Internal.Impl.isEmpty_filter_iff {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] [LawfulEqOrd α] {f : (a : α) → β a → Bool} (h : t.WF) : (filter f t ⋯).impl.isEmpty = true ↔ ∀ (k : α) (h : contains k t = true), f k (t.get k h) = false

theorem Std.DTreeMap.Internal.Impl.isEmpty_filter!_iff {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] [LawfulEqOrd α] {f : (a : α) → β a → Bool} (h : t.WF) : (filter! f t).isEmpty = true ↔ ∀ (k : α) (h : contains k t = true), f k (t.get k h) = false

theorem Std.DTreeMap.Internal.Impl.isEmpty_filter_eq_false_iff {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] [LawfulEqOrd α] {f : (a : α) → β a → Bool} (h : t.WF) : (filter f t ⋯).impl.isEmpty = false ↔ ∃ (k : α), ∃ (h : contains k t = true), f k (t.get k h) = true

theorem Std.DTreeMap.Internal.Impl.isEmpty_filter!_eq_false_iff {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] [LawfulEqOrd α] {f : (a : α) → β a → Bool} (h : t.WF) : (filter! f t).isEmpty = false ↔ ∃ (k : α), ∃ (h : contains k t = true), f k (t.get k h) = true

theorem Std.DTreeMap.Internal.Impl.isEmpty_filter_key_iff {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] {f : α → Bool} (h : t.WF) : (filter (fun (a : α) (x : β a) => f a) t ⋯).impl.isEmpty = true ↔ ∀ (k : α) (h : contains k t = true), f (t.getKey k h) = false

theorem Std.DTreeMap.Internal.Impl.isEmpty_filter!_key_iff {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] {f : α → Bool} (h : t.WF) : (filter! (fun (a : α) (x : β a) => f a) t).isEmpty = true ↔ ∀ (k : α) (h : contains k t = true), f (t.getKey k h) = false

theorem Std.DTreeMap.Internal.Impl.isEmpty_filter_key_eq_false_iff {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] {f : α → Bool} (h : t.WF) : (filter (fun (a : α) (x : β a) => f a) t ⋯).impl.isEmpty = false ↔ ∃ (k : α), ∃ (h : contains k t = true), f (t.getKey k h) = true

theorem Std.DTreeMap.Internal.Impl.isEmpty_filter!_key_eq_false_iff {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] {f : α → Bool} (h : t.WF) : (filter! (fun (a : α) (x : β a) => f a) t).isEmpty = false ↔ ∃ (k : α), ∃ (h : contains k t = true), f (t.getKey k h) = true

theorem Std.DTreeMap.Internal.Impl.contains_filter {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] [LawfulEqOrd α] {f : (a : α) → β a → Bool} {k : α} (h : t.WF) : contains k (filter f t ⋯).impl = Option.any (f k) (t.get? k)

theorem Std.DTreeMap.Internal.Impl.contains_filter! {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] [LawfulEqOrd α] {f : (a : α) → β a → Bool} {k : α} (h : t.WF) : contains k (filter! f t) = Option.any (f k) (t.get? k)

theorem Std.DTreeMap.Internal.Impl.contains_filter_key_iff {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] {f : α → Bool} {k : α} (h : t.WF) : contains k (filter (fun (a : α) (x : β a) => f a) t ⋯).impl = true ↔ ∃ (h : contains k t = true), f (t.getKey k h) = true

theorem Std.DTreeMap.Internal.Impl.contains_filter!_key_iff {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] {f : α → Bool} {k : α} (h : t.WF) : contains k (filter! (fun (a : α) (x : β a) => f a) t) = true ↔ ∃ (h : contains k t = true), f (t.getKey k h) = true

theorem Std.DTreeMap.Internal.Impl.contains_of_contains_filter {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] {f : (a : α) → β a → Bool} {k : α} (h : t.WF) : contains k (filter f t ⋯).impl = true → contains k t = true

theorem Std.DTreeMap.Internal.Impl.contains_of_contains_filter! {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] {f : (a : α) → β a → Bool} {k : α} (h : t.WF) : contains k (filter! f t) = true → contains k t = true

theorem Std.DTreeMap.Internal.Impl.size_filter_le_size {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] {f : (a : α) → β a → Bool} (h : t.WF) : (filter f t ⋯).impl.size ≤ t.size

theorem Std.DTreeMap.Internal.Impl.size_filter!_le_size {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] {f : (a : α) → β a → Bool} (h : t.WF) : (filter! f t).size ≤ t.size

theorem Std.DTreeMap.Internal.Impl.size_filter_eq_size_iff {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] [LawfulEqOrd α] {f : (a : α) → β a → Bool} (h : t.WF) : (filter f t ⋯).impl.size = t.size ↔ ∀ (a : α) (h : contains a t = true), f a (t.get a h) = true

theorem Std.DTreeMap.Internal.Impl.size_filter!_eq_size_iff {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] [LawfulEqOrd α] {f : (a : α) → β a → Bool} (h : t.WF) : (filter! f t).size = t.size ↔ ∀ (a : α) (h : contains a t = true), f a (t.get a h) = true

theorem Std.DTreeMap.Internal.Impl.filter_equiv_self_iff {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] [LawfulEqOrd α] {f : (a : α) → β a → Bool} (h : t.WF) : (filter f t ⋯).impl.Equiv t ↔ ∀ (a : α) (h : contains a t = true), f a (t.get a h) = true

theorem Std.DTreeMap.Internal.Impl.filter!_equiv_self_iff {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] [LawfulEqOrd α] {f : (a : α) → β a → Bool} (h : t.WF) : (filter! f t).Equiv t ↔ ∀ (a : α) (h : contains a t = true), f a (t.get a h) = true

theorem Std.DTreeMap.Internal.Impl.filter_key_equiv_self_iff {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] {f : α → Bool} (h : t.WF) : (filter (fun (k : α) (x : β k) => f k) t ⋯).impl.Equiv t ↔ ∀ (a : α) (h : contains a t = true), f (t.getKey a h) = true

theorem Std.DTreeMap.Internal.Impl.filter!_key_equiv_self_iff {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] {f : α → Bool} (h : t.WF) : (filter! (fun (k : α) (x : β k) => f k) t).Equiv t ↔ ∀ (a : α) (h : contains a t = true), f (t.getKey a h) = true

theorem Std.DTreeMap.Internal.Impl.size_filter_key_eq_size_iff {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] {f : α → Bool} (h : t.WF) : (filter (fun (k : α) (x : β k) => f k) t ⋯).impl.size = t.size ↔ ∀ (k : α) (h : contains k t = true), f (t.getKey k h) = true

theorem Std.DTreeMap.Internal.Impl.size_filter!_key_eq_size_iff {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] {f : α → Bool} (h : t.WF) : (filter! (fun (k : α) (x : β k) => f k) t).size = t.size ↔ ∀ (k : α) (h : contains k t = true), f (t.getKey k h) = true

theorem Std.DTreeMap.Internal.Impl.get?_filter {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] [LawfulEqOrd α] {f : (a : α) → β a → Bool} {k : α} (h : t.WF) : (filter f t ⋯).impl.get? k = Option.filter (f k) (t.get? k)

theorem Std.DTreeMap.Internal.Impl.get?_filter! {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] [LawfulEqOrd α] {f : (a : α) → β a → Bool} {k : α} (h : t.WF) : (filter! f t).get? k = Option.filter (f k) (t.get? k)

theorem Std.DTreeMap.Internal.Impl.get_filter {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] [LawfulEqOrd α] {f : (a : α) → β a → Bool} {k : α} (h : t.WF) {h' : k ∈ (filter f t ⋯).impl} : (filter f t ⋯).impl.get k h' = t.get k ⋯

theorem Std.DTreeMap.Internal.Impl.get_filter! {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] [LawfulEqOrd α] {f : (a : α) → β a → Bool} {k : α} (h : t.WF) {h' : k ∈ filter! f t} : (filter! f t).get k h' = t.get k ⋯

theorem Std.DTreeMap.Internal.Impl.get!_filter {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] [LawfulEqOrd α] {f : (a : α) → β a → Bool} {k : α} [Inhabited (β k)] (h : t.WF) : (filter f t ⋯).impl.get! k = (Option.filter (f k) (t.get? k)).get!

theorem Std.DTreeMap.Internal.Impl.get!_filter! {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] [LawfulEqOrd α] {f : (a : α) → β a → Bool} {k : α} [Inhabited (β k)] (h : t.WF) : (filter! f t).get! k = (Option.filter (f k) (t.get? k)).get!

theorem Std.DTreeMap.Internal.Impl.getD_filter {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] [LawfulEqOrd α] {f : (a : α) → β a → Bool} {k : α} {fallback : β k} (h : t.WF) : (filter f t ⋯).impl.getD k fallback = (Option.filter (f k) (t.get? k)).getD fallback

theorem Std.DTreeMap.Internal.Impl.getD_filter! {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] [LawfulEqOrd α] {f : (a : α) → β a → Bool} {k : α} {fallback : β k} (h : t.WF) : (filter! f t).getD k fallback = (Option.filter (f k) (t.get? k)).getD fallback

theorem Std.DTreeMap.Internal.Impl.keys_filter {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] [LawfulEqOrd α] {f : (a : α) → β a → Bool} (h : t.WF) : (filter f t ⋯).impl.keys = (List.filter (fun (x : { x : α // x ∈ t.keys }) => match x with | ⟨x, h'⟩ => f x (t.get x ⋯)) t.keys.attach).unattach

theorem Std.DTreeMap.Internal.Impl.keysArray_filter {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] [LawfulEqOrd α] {f : (a : α) → β a → Bool} (h : t.WF) : (filter f t ⋯).impl.keysArray = (Array.filter (fun (x : { x : α // x ∈ t.keysArray }) => match x with | ⟨x, h'⟩ => f x (t.get x ⋯)) t.keysArray.attach).unattach

theorem Std.DTreeMap.Internal.Impl.keys_filter! {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] [LawfulEqOrd α] {f : (a : α) → β a → Bool} (h : t.WF) : (filter! f t).keys = (List.filter (fun (x : { x : α // x ∈ t.keys }) => match x with | ⟨x, h'⟩ => f x (t.get x ⋯)) t.keys.attach).unattach

theorem Std.DTreeMap.Internal.Impl.keysArray_filter! {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] [LawfulEqOrd α] {f : (a : α) → β a → Bool} (h : t.WF) : (filter! f t).keysArray = (Array.filter (fun (x : { x : α // x ∈ t.keysArray }) => match x with | ⟨x, h'⟩ => f x (t.get x ⋯)) t.keysArray.attach).unattach

theorem Std.DTreeMap.Internal.Impl.getKey?_filter {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] [LawfulEqOrd α] {f : (a : α) → β a → Bool} {k : α} (h : t.WF) : (filter f t ⋯).impl.getKey? k = (t.getKey? k).pfilter fun (x : α) (h' : t.getKey? k = some x) => f x (t.get x ⋯)

theorem Std.DTreeMap.Internal.Impl.getKey?_filter! {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] [LawfulEqOrd α] {f : (a : α) → β a → Bool} {k : α} (h : t.WF) : (filter! f t).getKey? k = (t.getKey? k).pfilter fun (x : α) (h' : t.getKey? k = some x) => f x (t.get x ⋯)

theorem Std.DTreeMap.Internal.Impl.getKey?_filter_key {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] {f : α → Bool} {k : α} (h : t.WF) : (filter (fun (k : α) (x : β k) => f k) t ⋯).impl.getKey? k = Option.filter f (t.getKey? k)

theorem Std.DTreeMap.Internal.Impl.getKey?_filter!_key {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] {f : α → Bool} {k : α} (h : t.WF) : (filter! (fun (k : α) (x : β k) => f k) t).getKey? k = Option.filter f (t.getKey? k)

theorem Std.DTreeMap.Internal.Impl.getKey_filter {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] {f : (a : α) → β a → Bool} {k : α} (h : t.WF) {h' : contains k (filter f t ⋯).impl = true} : (filter f t ⋯).impl.getKey k h' = t.getKey k ⋯

theorem Std.DTreeMap.Internal.Impl.getKey_filter! {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] {f : (a : α) → β a → Bool} {k : α} (h : t.WF) {h' : contains k (filter! f t) = true} : (filter! f t).getKey k h' = t.getKey k ⋯

theorem Std.DTreeMap.Internal.Impl.getKey!_filter {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] [LawfulEqOrd α] [Inhabited α] {f : (a : α) → β a → Bool} {k : α} (h : t.WF) : (filter f t ⋯).impl.getKey! k = ((t.getKey? k).pfilter fun (x : α) (h' : t.getKey? k = some x) => f x (t.get x ⋯)).get!

theorem Std.DTreeMap.Internal.Impl.getKey!_filter! {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] [LawfulEqOrd α] [Inhabited α] {f : (a : α) → β a → Bool} {k : α} (h : t.WF) : (filter! f t).getKey! k = ((t.getKey? k).pfilter fun (x : α) (h' : t.getKey? k = some x) => f x (t.get x ⋯)).get!

theorem Std.DTreeMap.Internal.Impl.getKey!_filter_key {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] [Inhabited α] {f : α → Bool} {k : α} (h : t.WF) : (filter (fun (k : α) (x : β k) => f k) t ⋯).impl.getKey! k = (Option.filter f (t.getKey? k)).get!

theorem Std.DTreeMap.Internal.Impl.getKey!_filter!_key {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] [Inhabited α] {f : α → Bool} {k : α} (h : t.WF) : (filter! (fun (k : α) (x : β k) => f k) t).getKey! k = (Option.filter f (t.getKey? k)).get!

theorem Std.DTreeMap.Internal.Impl.getKeyD_filter {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] [LawfulEqOrd α] {f : (a : α) → β a → Bool} {k fallback : α} (h : t.WF) : (filter f t ⋯).impl.getKeyD k fallback = ((t.getKey? k).pfilter fun (x : α) (h' : t.getKey? k = some x) => f x (t.get x ⋯)).getD fallback

theorem Std.DTreeMap.Internal.Impl.getKeyD_filter! {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] [LawfulEqOrd α] {f : (a : α) → β a → Bool} {k fallback : α} (h : t.WF) : (filter! f t).getKeyD k fallback = ((t.getKey? k).pfilter fun (x : α) (h' : t.getKey? k = some x) => f x (t.get x ⋯)).getD fallback

theorem Std.DTreeMap.Internal.Impl.getKeyD_filter_key {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] {f : α → Bool} {k fallback : α} (h : t.WF) : (filter (fun (k : α) (x : β k) => f k) t ⋯).impl.getKeyD k fallback = (Option.filter f (t.getKey? k)).getD fallback

theorem Std.DTreeMap.Internal.Impl.getKeyD_filter!_key {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} [TransOrd α] {f : α → Bool} {k fallback : α} (h : t.WF) : (filter! (fun (k : α) (x : β k) => f k) t).getKeyD k fallback = (Option.filter f (t.getKey? k)).getD fallback

theorem Std.DTreeMap.Internal.Impl.Const.isEmpty_filter_iff {α : Type u} {instOrd : Ord α} {β : Type v} {t : Impl α fun (x : α) => β} [TransOrd α] {f : α → β → Bool} (h : t.WF) : (filter f t ⋯).impl.isEmpty = true ↔ ∀ (k : α) (h : contains k t = true), f (t.getKey k h) (get t k h) = false

theorem Std.DTreeMap.Internal.Impl.Const.isEmpty_filter!_iff {α : Type u} {instOrd : Ord α} {β : Type v} {t : Impl α fun (x : α) => β} [TransOrd α] {f : α → β → Bool} (h : t.WF) : (filter! f t).isEmpty = true ↔ ∀ (k : α) (h : contains k t = true), f (t.getKey k h) (get t k h) = false

theorem Std.DTreeMap.Internal.Impl.Const.isEmpty_filter_eq_false_iff {α : Type u} {instOrd : Ord α} {β : Type v} {t : Impl α fun (x : α) => β} [TransOrd α] {f : α → β → Bool} (h : t.WF) : (filter f t ⋯).impl.isEmpty = false ↔ ∃ (k : α), ∃ (h : contains k t = true), f (t.getKey k h) (get t k h) = true

theorem Std.DTreeMap.Internal.Impl.Const.isEmpty_filter!_eq_false_iff {α : Type u} {instOrd : Ord α} {β : Type v} {t : Impl α fun (x : α) => β} [TransOrd α] {f : α → β → Bool} (h : t.WF) : (filter! f t).isEmpty = false ↔ ∃ (k : α), ∃ (h : contains k t = true), f (t.getKey k h) (get t k h) = true

theorem Std.DTreeMap.Internal.Impl.Const.contains_filter_iff {α : Type u} {instOrd : Ord α} {β : Type v} {t : Impl α fun (x : α) => β} [TransOrd α] {f : α → β → Bool} {k : α} (h : t.WF) : contains k (filter f t ⋯).impl = true ↔ ∃ (h' : contains k t = true), f (t.getKey k h') (get t k h') = true

theorem Std.DTreeMap.Internal.Impl.Const.contains_filter!_iff {α : Type u} {instOrd : Ord α} {β : Type v} {t : Impl α fun (x : α) => β} [TransOrd α] {f : α → β → Bool} {k : α} (h : t.WF) : contains k (filter! f t) = true ↔ ∃ (h' : contains k t = true), f (t.getKey k h') (get t k h') = true

theorem Std.DTreeMap.Internal.Impl.Const.size_filter_le_size {α : Type u} {instOrd : Ord α} {β : Type v} {t : Impl α fun (x : α) => β} [TransOrd α] {f : α → β → Bool} (h : t.WF) : (filter f t ⋯).impl.size ≤ t.size

theorem Std.DTreeMap.Internal.Impl.Const.size_filter!_le_size {α : Type u} {instOrd : Ord α} {β : Type v} {t : Impl α fun (x : α) => β} [TransOrd α] {f : α → β → Bool} (h : t.WF) : (filter! f t).size ≤ t.size

theorem Std.DTreeMap.Internal.Impl.Const.size_filter_eq_size_iff {α : Type u} {instOrd : Ord α} {β : Type v} {t : Impl α fun (x : α) => β} [TransOrd α] {f : α → β → Bool} (h : t.WF) : (filter f t ⋯).impl.size = t.size ↔ ∀ (a : α) (h : contains a t = true), f (t.getKey a h) (get t a h) = true

theorem Std.DTreeMap.Internal.Impl.Const.size_filter!_eq_size_iff {α : Type u} {instOrd : Ord α} {β : Type v} {t : Impl α fun (x : α) => β} [TransOrd α] {f : α → β → Bool} (h : t.WF) : (filter! f t).size = t.size ↔ ∀ (a : α) (h : contains a t = true), f (t.getKey a h) (get t a h) = true

theorem Std.DTreeMap.Internal.Impl.Const.filter_equiv_self_iff {α : Type u} {instOrd : Ord α} {β : Type v} {t : Impl α fun (x : α) => β} [TransOrd α] {f : α → β → Bool} (h : t.WF) : (filter f t ⋯).impl.Equiv t ↔ ∀ (a : α) (h : contains a t = true), f (t.getKey a h) (get t a h) = true

theorem Std.DTreeMap.Internal.Impl.Const.filter!_equiv_self_iff {α : Type u} {instOrd : Ord α} {β : Type v} {t : Impl α fun (x : α) => β} [TransOrd α] {f : α → β → Bool} (h : t.WF) : (filter! f t).Equiv t ↔ ∀ (a : α) (h : contains a t = true), f (t.getKey a h) (get t a h) = true

theorem Std.DTreeMap.Internal.Impl.Const.get?_filter {α : Type u} {instOrd : Ord α} {β : Type v} {t : Impl α fun (x : α) => β} [TransOrd α] {f : α → β → Bool} {k : α} (h : t.WF) : get? (filter f t ⋯).impl k = (get? t k).pfilter fun (x : β) (h' : get? t k = some x) => f (t.getKey k ⋯) x

theorem Std.DTreeMap.Internal.Impl.Const.get?_filter! {α : Type u} {instOrd : Ord α} {β : Type v} {t : Impl α fun (x : α) => β} [TransOrd α] {f : α → β → Bool} {k : α} (h : t.WF) : get? (filter! f t) k = (get? t k).pfilter fun (x : β) (h' : get? t k = some x) => f (t.getKey k ⋯) x

theorem Std.DTreeMap.Internal.Impl.Const.get?_filter_of_getKey?_eq_some {α : Type u} {instOrd : Ord α} {β : Type v} {t : Impl α fun (x : α) => β} [TransOrd α] {f : α → β → Bool} {k k' : α} (h : t.WF) : t.getKey? k = some k' → get? (filter f t ⋯).impl k = Option.filter (fun (x : β) => f k' x) (get? t k)

theorem Std.DTreeMap.Internal.Impl.Const.get?_filter!_of_getKey?_eq_some {α : Type u} {instOrd : Ord α} {β : Type v} {t : Impl α fun (x : α) => β} [TransOrd α] {f : α → β → Bool} {k k' : α} (h : t.WF) : t.getKey? k = some k' → get? (filter! f t) k = Option.filter (fun (x : β) => f k' x) (get? t k)

theorem Std.DTreeMap.Internal.Impl.Const.get_filter {α : Type u} {instOrd : Ord α} {β : Type v} {t : Impl α fun (x : α) => β} [TransOrd α] {f : α → β → Bool} {k : α} (h : t.WF) {h' : contains k (filter f t ⋯).impl = true} : get (filter f t ⋯).impl k h' = get t k ⋯

theorem Std.DTreeMap.Internal.Impl.Const.get_filter! {α : Type u} {instOrd : Ord α} {β : Type v} {t : Impl α fun (x : α) => β} [TransOrd α] {f : α → β → Bool} {k : α} (h : t.WF) {h' : contains k (filter! f t) = true} : get (filter! f t) k h' = get t k ⋯

theorem Std.DTreeMap.Internal.Impl.Const.get!_filter {α : Type u} {instOrd : Ord α} {β : Type v} {t : Impl α fun (x : α) => β} [TransOrd α] [Inhabited β] {f : α → β → Bool} {k : α} (h : t.WF) : get! (filter f t ⋯).impl k = ((get? t k).pfilter fun (x : β) (h' : get? t k = some x) => f (t.getKey k ⋯) x).get!

theorem Std.DTreeMap.Internal.Impl.Const.get!_filter! {α : Type u} {instOrd : Ord α} {β : Type v} {t : Impl α fun (x : α) => β} [TransOrd α] [Inhabited β] {f : α → β → Bool} {k : α} (h : t.WF) : get! (filter! f t) k = ((get? t k).pfilter fun (x : β) (h' : get? t k = some x) => f (t.getKey k ⋯) x).get!

theorem Std.DTreeMap.Internal.Impl.Const.get!_filter_of_getKey?_eq_some {α : Type u} {instOrd : Ord α} {β : Type v} {t : Impl α fun (x : α) => β} [TransOrd α] [Inhabited β] {f : α → β → Bool} {k k' : α} (h : t.WF) : t.getKey? k = some k' → get! (filter f t ⋯).impl k = (Option.filter (fun (x : β) => f k' x) (get? t k)).get!

theorem Std.DTreeMap.Internal.Impl.Const.get!_filter!_of_getKey?_eq_some {α : Type u} {instOrd : Ord α} {β : Type v} {t : Impl α fun (x : α) => β} [TransOrd α] [Inhabited β] {f : α → β → Bool} {k k' : α} (h : t.WF) : t.getKey? k = some k' → get! (filter! f t) k = (Option.filter (fun (x : β) => f k' x) (get? t k)).get!

theorem Std.DTreeMap.Internal.Impl.Const.getD_filter {α : Type u} {instOrd : Ord α} {β : Type v} {t : Impl α fun (x : α) => β} [TransOrd α] {f : α → β → Bool} {k : α} {fallback : β} (h : t.WF) : getD (filter f t ⋯).impl k fallback = ((get? t k).pfilter fun (x : β) (h' : get? t k = some x) => f (t.getKey k ⋯) x).getD fallback

theorem Std.DTreeMap.Internal.Impl.Const.getD_filter! {α : Type u} {instOrd : Ord α} {β : Type v} {t : Impl α fun (x : α) => β} [TransOrd α] {f : α → β → Bool} {k : α} {fallback : β} (h : t.WF) : getD (filter! f t) k fallback = ((get? t k).pfilter fun (x : β) (h' : get? t k = some x) => f (t.getKey k ⋯) x).getD fallback

theorem Std.DTreeMap.Internal.Impl.Const.getD_filter_of_getKey?_eq_some {α : Type u} {instOrd : Ord α} {β : Type v} {t : Impl α fun (x : α) => β} [TransOrd α] {f : α → β → Bool} {k k' : α} {fallback : β} (h : t.WF) : t.getKey? k = some k' → getD (filter f t ⋯).impl k fallback = (Option.filter (fun (x : β) => f k' x) (get? t k)).getD fallback

theorem Std.DTreeMap.Internal.Impl.Const.getD_filter!_of_getKey?_eq_some {α : Type u} {instOrd : Ord α} {β : Type v} {t : Impl α fun (x : α) => β} [TransOrd α] {f : α → β → Bool} {k k' : α} {fallback : β} (h : t.WF) : t.getKey? k = some k' → getD (filter! f t) k fallback = (Option.filter (fun (x : β) => f k' x) (get? t k)).getD fallback

theorem Std.DTreeMap.Internal.Impl.Const.toList_filter {α : Type u} {instOrd : Ord α} {β : Type v} {t : Impl α fun (x : α) => β} {f : α → β → Bool} (h : t.WF) : toList (filter f t ⋯).impl = List.filter (fun (p : α × β) => f p.fst p.snd) (toList t)

theorem Std.DTreeMap.Internal.Impl.Const.toArray_filter {α : Type u} {instOrd : Ord α} {β : Type v} {t : Impl α fun (x : α) => β} {f : α → β → Bool} (h : t.WF) : toArray (filter f t ⋯).impl = Array.filter (fun (p : α × β) => f p.fst p.snd) (toArray t)

theorem Std.DTreeMap.Internal.Impl.Const.toList_filter! {α : Type u} {instOrd : Ord α} {β : Type v} {t : Impl α fun (x : α) => β} {f : α → β → Bool} (h : t.WF) : toList (filter! f t) = List.filter (fun (p : α × β) => f p.fst p.snd) (toList t)

theorem Std.DTreeMap.Internal.Impl.Const.toArray_filter! {α : Type u} {instOrd : Ord α} {β : Type v} {t : Impl α fun (x : α) => β} {f : α → β → Bool} (h : t.WF) : toArray (filter! f t) = Array.filter (fun (p : α × β) => f p.fst p.snd) (toArray t)

theorem Std.DTreeMap.Internal.Impl.Const.keys_filter {α : Type u} {instOrd : Ord α} {β : Type v} {t : Impl α fun (x : α) => β} [TransOrd α] {f : α → β → Bool} (h : t.WF) : (filter f t ⋯).impl.keys = (List.filter (fun (x : { x : α // x ∈ t.keys }) => match x with | ⟨x, h'⟩ => f x (get t x ⋯)) t.keys.attach).unattach

theorem Std.DTreeMap.Internal.Impl.Const.keysArray_filter {α : Type u} {instOrd : Ord α} {β : Type v} {t : Impl α fun (x : α) => β} [TransOrd α] {f : α → β → Bool} (h : t.WF) : (filter f t ⋯).impl.keysArray = (Array.filter (fun (x : { x : α // x ∈ t.keysArray }) => match x with | ⟨x, h'⟩ => f x (get t x ⋯)) t.keysArray.attach).unattach

theorem Std.DTreeMap.Internal.Impl.Const.keys_filter! {α : Type u} {instOrd : Ord α} {β : Type v} {t : Impl α fun (x : α) => β} [TransOrd α] {f : α → β → Bool} (h : t.WF) : (filter! f t).keys = (List.filter (fun (x : { x : α // x ∈ t.keys }) => match x with | ⟨x, h'⟩ => f x (get t x ⋯)) t.keys.attach).unattach

theorem Std.DTreeMap.Internal.Impl.Const.keysArray_filter! {α : Type u} {instOrd : Ord α} {β : Type v} {t : Impl α fun (x : α) => β} [TransOrd α] {f : α → β → Bool} (h : t.WF) : (filter! f t).keysArray = (Array.filter (fun (x : { x : α // x ∈ t.keysArray }) => match x with | ⟨x, h'⟩ => f x (get t x ⋯)) t.keysArray.attach).unattach

theorem Std.DTreeMap.Internal.Impl.Const.getKey?_filter {α : Type u} {instOrd : Ord α} {β : Type v} {t : Impl α fun (x : α) => β} [TransOrd α] {f : α → β → Bool} {k : α} (h : t.WF) : (filter f t ⋯).impl.getKey? k = (t.getKey? k).pfilter fun (x : α) (h' : t.getKey? k = some x) => f x (get t x ⋯)

theorem Std.DTreeMap.Internal.Impl.Const.getKey?_filter! {α : Type u} {instOrd : Ord α} {β : Type v} {t : Impl α fun (x : α) => β} [TransOrd α] {f : α → β → Bool} {k : α} (h : t.WF) : (filter! f t).getKey? k = (t.getKey? k).pfilter fun (x : α) (h' : t.getKey? k = some x) => f x (get t x ⋯)

theorem Std.DTreeMap.Internal.Impl.Const.getKey!_filter {α : Type u} {instOrd : Ord α} {β : Type v} {t : Impl α fun (x : α) => β} [TransOrd α] [Inhabited α] {f : α → β → Bool} {k : α} (h : t.WF) : (filter f t ⋯).impl.getKey! k = ((t.getKey? k).pfilter fun (x : α) (h' : t.getKey? k = some x) => f x (get t x ⋯)).get!

theorem Std.DTreeMap.Internal.Impl.Const.getKey!_filter! {α : Type u} {instOrd : Ord α} {β : Type v} {t : Impl α fun (x : α) => β} [TransOrd α] [Inhabited α] {f : α → β → Bool} {k : α} (h : t.WF) : (filter! f t).getKey! k = ((t.getKey? k).pfilter fun (x : α) (h' : t.getKey? k = some x) => f x (get t x ⋯)).get!

theorem Std.DTreeMap.Internal.Impl.Const.getKeyD_filter {α : Type u} {instOrd : Ord α} {β : Type v} {t : Impl α fun (x : α) => β} [TransOrd α] {f : α → β → Bool} {k fallback : α} (h : t.WF) : (filter f t ⋯).impl.getKeyD k fallback = ((t.getKey? k).pfilter fun (x : α) (h' : t.getKey? k = some x) => f x (get t x ⋯)).getD fallback

theorem Std.DTreeMap.Internal.Impl.Const.getKeyD_filter! {α : Type u} {instOrd : Ord α} {β : Type v} {t : Impl α fun (x : α) => β} [TransOrd α] {f : α → β → Bool} {k fallback : α} (h : t.WF) : (filter! f t).getKeyD k fallback = ((t.getKey? k).pfilter fun (x : α) (h' : t.getKey? k = some x) => f x (get t x ⋯)).getD fallback

theorem Std.DTreeMap.Internal.Impl.map_id_equiv {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} : (map (fun (x : α) (v : β x) => v) t).Equiv t

theorem Std.DTreeMap.Internal.Impl.map_map_equiv {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} {γ : α → Type w} {δ : α → Type w'} {f : (a : α) → β a → γ a} {g : (a : α) → γ a → δ a} : (map g (map f t)).Equiv (map (fun (k : α) (v : β k) => g k (f k v)) t)

theorem Std.DTreeMap.Internal.Impl.toList_map {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} {γ : α → Type w} {f : (a : α) → β a → γ a} : (map f t).toList = List.map (fun (p : (a : α) × β a) => ⟨p.fst, f p.fst p.snd⟩) t.toList

theorem Std.DTreeMap.Internal.Impl.toArray_map {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} {γ : α → Type w} {f : (a : α) → β a → γ a} : (map f t).toArray = Array.map (fun (p : (a : α) × β a) => ⟨p.fst, f p.fst p.snd⟩) t.toArray

theorem Std.DTreeMap.Internal.Impl.keys_map {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} {γ : α → Type w} {f : (a : α) → β a → γ a} : (map f t).keys = t.keys

theorem Std.DTreeMap.Internal.Impl.keysArray_map {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} {γ : α → Type w} {f : (a : α) → β a → γ a} : (map f t).keysArray = t.keysArray

theorem Std.DTreeMap.Internal.Impl.filterMap_equiv_map {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} {γ : α → Type w} {f : (a : α) → β a → γ a} (h : t.WF) : (filterMap (fun (k : α) (v : β k) => some (f k v)) t ⋯).impl.Equiv (map f t)

theorem Std.DTreeMap.Internal.Impl.filterMap!_equiv_map {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} {γ : α → Type w} {f : (a : α) → β a → γ a} (h : t.WF) : (filterMap! (fun (k : α) (v : β k) => some (f k v)) t).Equiv (map f t)

theorem Std.DTreeMap.Internal.Impl.isEmpty_map {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} {γ : α → Type w} {f : (a : α) → β a → γ a} : (map f t).isEmpty = t.isEmpty

theorem Std.DTreeMap.Internal.Impl.contains_map {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} {γ : α → Type w} [TransOrd α] {f : (a : α) → β a → γ a} {k : α} (h : t.WF) : contains k (map f t) = contains k t

theorem Std.DTreeMap.Internal.Impl.contains_of_contains_map {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} {γ : α → Type w} [TransOrd α] {f : (a : α) → β a → γ a} {k : α} (h : t.WF) : contains k (map f t) = true → contains k t = true

theorem Std.DTreeMap.Internal.Impl.get?_map {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} {γ : α → Type w} [TransOrd α] [LawfulEqOrd α] {f : (a : α) → β a → γ a} {k : α} (h : t.WF) : (map f t).get? k = Option.map (f k) (t.get? k)

theorem Std.DTreeMap.Internal.Impl.get_map {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} {γ : α → Type w} [TransOrd α] [LawfulEqOrd α] {f : (a : α) → β a → γ a} {k : α} (h : t.WF) {h' : k ∈ map f t} : (map f t).get k h' = f k (t.get k ⋯)

theorem Std.DTreeMap.Internal.Impl.get!_map {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} {γ : α → Type w} [TransOrd α] [LawfulEqOrd α] {f : (a : α) → β a → γ a} {k : α} [Inhabited (γ k)] (h : t.WF) : (map f t).get! k = (Option.map (f k) (t.get? k)).get!

theorem Std.DTreeMap.Internal.Impl.getD_map {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} {γ : α → Type w} [TransOrd α] [LawfulEqOrd α] {f : (a : α) → β a → γ a} {k : α} {fallback : γ k} (h : t.WF) : (map f t).getD k fallback = (Option.map (f k) (t.get? k)).getD fallback

theorem Std.DTreeMap.Internal.Impl.getKey?_map {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} {γ : α → Type w} [TransOrd α] {f : (a : α) → β a → γ a} {k : α} (h : t.WF) : (map f t).getKey? k = t.getKey? k

theorem Std.DTreeMap.Internal.Impl.getKey_map {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} {γ : α → Type w} [TransOrd α] {f : (a : α) → β a → γ a} {k : α} (h : t.WF) {h' : contains k (map f t) = true} : (map f t).getKey k h' = t.getKey k ⋯

theorem Std.DTreeMap.Internal.Impl.getKey!_map {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} {γ : α → Type w} [TransOrd α] [Inhabited α] {f : (a : α) → β a → γ a} {k : α} (h : t.WF) : (map f t).getKey! k = t.getKey! k

theorem Std.DTreeMap.Internal.Impl.getKeyD_map {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Impl α β} {γ : α → Type w} [TransOrd α] {f : (a : α) → β a → γ a} {k fallback : α} (h : t.WF) : (map f t).getKeyD k fallback = t.getKeyD k fallback

theorem Std.DTreeMap.Internal.Impl.Const.get?_map' {α : Type u} {instOrd : Ord α} {β : Type v} {γ : Type w} {t : Impl α fun (x : α) => β} [TransOrd α] {f : α → β → γ} {k : α} (h : t.WF) : get? (map f t) k = Option.pmap (fun (v : β) (h' : contains k t = true) => f (t.getKey k h') v) (get? t k) ⋯

Variant of get?_map that holds without LawfulEqOrd.

theorem Std.DTreeMap.Internal.Impl.Const.get?_map {α : Type u} {instOrd : Ord α} {β : Type v} {γ : Type w} {t : Impl α fun (x : α) => β} [TransOrd α] [LawfulEqOrd α] {f : α → β → γ} {k : α} (h : t.WF) : get? (map f t) k = Option.map (f k) (get? t k)

theorem Std.DTreeMap.Internal.Impl.Const.get?_map_of_getKey?_eq_some {α : Type u} {instOrd : Ord α} {β : Type v} {γ : Type w} {t : Impl α fun (x : α) => β} [TransOrd α] {f : α → β → γ} {k k' : α} (h : t.WF) : t.getKey? k = some k' → get? (map f t) k = Option.map (f k') (get? t k)

theorem Std.DTreeMap.Internal.Impl.Const.get_map' {α : Type u} {instOrd : Ord α} {β : Type v} {γ : Type w} {t : Impl α fun (x : α) => β} [TransOrd α] {f : α → β → γ} {k : α} (h : t.WF) {h' : contains k (map f t) = true} : get (map f t) k h' = f (t.getKey k ⋯) (get t k ⋯)

Variant of get_map that holds without LawfulEqOrd.

theorem Std.DTreeMap.Internal.Impl.Const.get_map {α : Type u} {instOrd : Ord α} {β : Type v} {γ : Type w} {t : Impl α fun (x : α) => β} [TransOrd α] [LawfulEqOrd α] {f : α → β → γ} {k : α} (h : t.WF) {h' : contains k (map f t) = true} : get (map f t) k h' = f k (get t k ⋯)

theorem Std.DTreeMap.Internal.Impl.Const.get!_map' {α : Type u} {instOrd : Ord α} {β : Type v} {γ : Type w} {t : Impl α fun (x : α) => β} [TransOrd α] [Inhabited γ] {f : α → β → γ} {k : α} (h : t.WF) : get! (map f t) k = (Option.pmap (fun (v : β) (h : contains k t = true) => f (t.getKey k h) v) (get? t k) ⋯).get!

Variant of get!_map that holds without LawfulEqOrd.

theorem Std.DTreeMap.Internal.Impl.Const.get!_map {α : Type u} {instOrd : Ord α} {β : Type v} {γ : Type w} {t : Impl α fun (x : α) => β} [TransOrd α] [LawfulEqOrd α] [Inhabited γ] {f : α → β → γ} {k : α} (h : t.WF) : get! (map f t) k = (Option.map (f k) (get? t k)).get!

theorem Std.DTreeMap.Internal.Impl.Const.get!_map_of_getKey?_eq_some {α : Type u} {instOrd : Ord α} {β : Type v} {γ : Type w} {t : Impl α fun (x : α) => β} [TransOrd α] [Inhabited γ] {f : α → β → γ} {k k' : α} (h : t.WF) : t.getKey? k = some k' → get! (map f t) k = (Option.map (f k') (get? t k)).get!

theorem Std.DTreeMap.Internal.Impl.Const.getD_map' {α : Type u} {instOrd : Ord α} {β : Type v} {γ : Type w} {t : Impl α fun (x : α) => β} [TransOrd α] {f : α → β → γ} {k : α} {fallback : γ} (h : t.WF) : getD (map f t) k fallback = (Option.pmap (fun (v : β) (h : contains k t = true) => f (t.getKey k h) v) (get? t k) ⋯).getD fallback

Variant of getD_map that holds without LawfulEqOrd.

theorem Std.DTreeMap.Internal.Impl.Const.getD_map {α : Type u} {instOrd : Ord α} {β : Type v} {γ : Type w} {t : Impl α fun (x : α) => β} [TransOrd α] [LawfulEqOrd α] {f : α → β → γ} {k : α} {fallback : γ} (h : t.WF) : getD (map f t) k fallback = (Option.map (f k) (get? t k)).getD fallback

theorem Std.DTreeMap.Internal.Impl.Const.getD_map_of_getKey?_eq_some {α : Type u} {instOrd : Ord α} {β : Type v} {γ : Type w} {t : Impl α fun (x : α) => β} [TransOrd α] {f : α → β → γ} {k k' : α} {fallback : γ} (h : t.WF) : t.getKey? k = some k' → getD (map f t) k fallback = (Option.map (f k') (get? t k)).getD fallback

theorem Std.DTreeMap.Internal.Impl.Const.toList_map {α : Type u} {instOrd : Ord α} {β : Type v} {γ : Type w} {t : Impl α fun (x : α) => β} {f : α → β → γ} : toList (map f t) = List.map (fun (p : α × β) => (p.fst, f p.fst p.snd)) (toList t)

theorem Std.DTreeMap.Internal.Impl.Const.toArray_map {α : Type u} {instOrd : Ord α} {β : Type v} {γ : Type w} {t : Impl α fun (x : α) => β} {f : α → β → γ} : toArray (map f t) = Array.map (fun (p : α × β) => (p.fst, f p.fst p.snd)) (toArray t)

def Std.DTreeMap.Internal.Impl.decidableEquiv {α : Type u} {β : α → Type v} [Ord α] [TransOrd α] [LawfulEqOrd α] [(k : α) → BEq (β k)] [∀ (k : α), LawfulBEq (β k)] (t₁ t₂ : Impl α β) (h₁ : t₁.WF) (h₂ : t₂.WF) : Decidable (t₁.Equiv t₂)

Internal implementation detail

Equations

• t₁.decidableEquiv t₂ h₁ h₂ = decidable_of_iff (t₁.beq t₂ = true) ⋯