Tree set lemmas #
This file contains lemmas about Std.ExtTreeSet
.
@[simp]
@[simp]
theorem
Std.ExtTreeSet.insert_ne_empty
{α : Type u}
{cmp : α → α → Ordering}
{t : ExtTreeSet α cmp}
[TransCmp cmp]
{k : α}
:
theorem
Std.ExtTreeSet.contains_congr
{α : Type u}
{cmp : α → α → Ordering}
{t : ExtTreeSet α cmp}
[TransCmp cmp]
{k k' : α}
(hab : cmp k k' = Ordering.eq)
:
theorem
Std.ExtTreeSet.mem_congr
{α : Type u}
{cmp : α → α → Ordering}
{t : ExtTreeSet α cmp}
[TransCmp cmp]
{k k' : α}
(hab : cmp k k' = Ordering.eq)
:
theorem
Std.ExtTreeSet.ne_empty_of_mem
{α : Type u}
{cmp : α → α → Ordering}
{t : ExtTreeSet α cmp}
[TransCmp cmp]
{a : α}
(h : a ∈ t)
:
@[simp]
theorem
Std.ExtTreeSet.insert_eq_insert
{α : Type u}
{cmp : α → α → Ordering}
{t : ExtTreeSet α cmp}
[TransCmp cmp]
{p : α}
:
@[simp]
theorem
Std.ExtTreeSet.contains_insert
{α : Type u}
{cmp : α → α → Ordering}
{t : ExtTreeSet α cmp}
[TransCmp cmp]
{k a : α}
:
@[simp]
theorem
Std.ExtTreeSet.mem_insert
{α : Type u}
{cmp : α → α → Ordering}
{t : ExtTreeSet α cmp}
[TransCmp cmp]
{k a : α}
:
theorem
Std.ExtTreeSet.contains_insert_self
{α : Type u}
{cmp : α → α → Ordering}
{t : ExtTreeSet α cmp}
[TransCmp cmp]
{k : α}
:
theorem
Std.ExtTreeSet.mem_insert_self
{α : Type u}
{cmp : α → α → Ordering}
{t : ExtTreeSet α cmp}
[TransCmp cmp]
{k : α}
:
theorem
Std.ExtTreeSet.contains_of_contains_insert
{α : Type u}
{cmp : α → α → Ordering}
{t : ExtTreeSet α cmp}
[TransCmp cmp]
{k a : α}
:
theorem
Std.ExtTreeSet.mem_of_mem_insert
{α : Type u}
{cmp : α → α → Ordering}
{t : ExtTreeSet α cmp}
[TransCmp cmp]
{k a : α}
:
a ∈ t.insert k → cmp k a ≠ Ordering.eq → a ∈ t
theorem
Std.ExtTreeSet.mem_of_mem_insert'
{α : Type u}
{cmp : α → α → Ordering}
{t : ExtTreeSet α cmp}
[TransCmp cmp]
{k a : α}
:
This is a restatement of mem_of_mem_insert
that is written to exactly match the
proof obligation in the statement of get_insert
.
theorem
Std.ExtTreeSet.isEmpty_eq_size_beq_zero
{α : Type u}
{cmp : α → α → Ordering}
{t : ExtTreeSet α cmp}
:
theorem
Std.ExtTreeSet.size_le_size_insert
{α : Type u}
{cmp : α → α → Ordering}
{t : ExtTreeSet α cmp}
[TransCmp cmp]
{k : α}
:
@[simp]
theorem
Std.ExtTreeSet.contains_erase
{α : Type u}
{cmp : α → α → Ordering}
{t : ExtTreeSet α cmp}
[TransCmp cmp]
{k a : α}
:
@[simp]
theorem
Std.ExtTreeSet.mem_erase
{α : Type u}
{cmp : α → α → Ordering}
{t : ExtTreeSet α cmp}
[TransCmp cmp]
{k a : α}
:
theorem
Std.ExtTreeSet.size_erase_le
{α : Type u}
{cmp : α → α → Ordering}
{t : ExtTreeSet α cmp}
[TransCmp cmp]
{k : α}
:
theorem
Std.ExtTreeSet.contains_eq_isSome_get?
{α : Type u}
{cmp : α → α → Ordering}
{t : ExtTreeSet α cmp}
[TransCmp cmp]
{a : α}
:
@[simp]
theorem
Std.ExtTreeSet.isSome_get?_eq_contains
{α : Type u}
{cmp : α → α → Ordering}
{t : ExtTreeSet α cmp}
[TransCmp cmp]
{a : α}
:
@[simp]
theorem
Std.ExtTreeSet.get?_erase_self
{α : Type u}
{cmp : α → α → Ordering}
{t : ExtTreeSet α cmp}
[TransCmp cmp]
{k : α}
:
theorem
Std.ExtTreeSet.compare_get?_self
{α : Type u}
{cmp : α → α → Ordering}
{t : ExtTreeSet α cmp}
[TransCmp cmp]
{k : α}
:
theorem
Std.ExtTreeSet.get?_congr
{α : Type u}
{cmp : α → α → Ordering}
{t : ExtTreeSet α cmp}
[TransCmp cmp]
{k k' : α}
(h' : cmp k k' = Ordering.eq)
:
theorem
Std.ExtTreeSet.get?_eq_some_of_contains
{α : Type u}
{cmp : α → α → Ordering}
{t : ExtTreeSet α cmp}
[TransCmp cmp]
[LawfulEqCmp cmp]
{k : α}
(h' : t.contains k = true)
:
theorem
Std.ExtTreeSet.get?_eq_some
{α : Type u}
{cmp : α → α → Ordering}
{t : ExtTreeSet α cmp}
[TransCmp cmp]
[LawfulEqCmp cmp]
{k : α}
(h' : k ∈ t)
:
theorem
Std.ExtTreeSet.compare_get_self
{α : Type u}
{cmp : α → α → Ordering}
{t : ExtTreeSet α cmp}
[TransCmp cmp]
{k : α}
(h' : k ∈ t)
:
theorem
Std.ExtTreeSet.get_congr
{α : Type u}
{cmp : α → α → Ordering}
{t : ExtTreeSet α cmp}
[TransCmp cmp]
{k₁ k₂ : α}
(h' : cmp k₁ k₂ = Ordering.eq)
(h₁ : k₁ ∈ t)
:
@[simp]
theorem
Std.ExtTreeSet.get_eq
{α : Type u}
{cmp : α → α → Ordering}
{t : ExtTreeSet α cmp}
[TransCmp cmp]
[LawfulEqCmp cmp]
{k : α}
(h' : k ∈ t)
:
theorem
Std.ExtTreeSet.get!_congr
{α : Type u}
{cmp : α → α → Ordering}
{t : ExtTreeSet α cmp}
[TransCmp cmp]
[Inhabited α]
{k k' : α}
(h' : cmp k k' = Ordering.eq)
:
theorem
Std.ExtTreeSet.get!_eq_of_contains
{α : Type u}
{cmp : α → α → Ordering}
{t : ExtTreeSet α cmp}
[TransCmp cmp]
[LawfulEqCmp cmp]
[Inhabited α]
{k : α}
(h' : t.contains k = true)
:
theorem
Std.ExtTreeSet.get!_eq_of_mem
{α : Type u}
{cmp : α → α → Ordering}
{t : ExtTreeSet α cmp}
[TransCmp cmp]
[LawfulEqCmp cmp]
[Inhabited α]
{k : α}
(h' : k ∈ t)
:
theorem
Std.ExtTreeSet.getD_eq_fallback
{α : Type u}
{cmp : α → α → Ordering}
{t : ExtTreeSet α cmp}
[TransCmp cmp]
{a fallback : α}
:
theorem
Std.ExtTreeSet.getD_erase
{α : Type u}
{cmp : α → α → Ordering}
{t : ExtTreeSet α cmp}
[TransCmp cmp]
{k a fallback : α}
:
@[simp]
theorem
Std.ExtTreeSet.getD_erase_self
{α : Type u}
{cmp : α → α → Ordering}
{t : ExtTreeSet α cmp}
[TransCmp cmp]
{k fallback : α}
:
theorem
Std.ExtTreeSet.getD_eq_getD_get?
{α : Type u}
{cmp : α → α → Ordering}
{t : ExtTreeSet α cmp}
[TransCmp cmp]
{a fallback : α}
:
theorem
Std.ExtTreeSet.get_eq_getD
{α : Type u}
{cmp : α → α → Ordering}
{t : ExtTreeSet α cmp}
[TransCmp cmp]
{a fallback : α}
{h : a ∈ t}
:
theorem
Std.ExtTreeSet.getD_congr
{α : Type u}
{cmp : α → α → Ordering}
{t : ExtTreeSet α cmp}
[TransCmp cmp]
{k k' fallback : α}
(h' : cmp k k' = Ordering.eq)
:
theorem
Std.ExtTreeSet.getD_eq_of_contains
{α : Type u}
{cmp : α → α → Ordering}
{t : ExtTreeSet α cmp}
[TransCmp cmp]
[LawfulEqCmp cmp]
{k fallback : α}
(h' : t.contains k = true)
:
theorem
Std.ExtTreeSet.getD_eq_of_mem
{α : Type u}
{cmp : α → α → Ordering}
{t : ExtTreeSet α cmp}
[TransCmp cmp]
[LawfulEqCmp cmp]
{k fallback : α}
(h' : k ∈ t)
:
@[simp]
theorem
Std.ExtTreeSet.containsThenInsert_fst
{α : Type u}
{cmp : α → α → Ordering}
{t : ExtTreeSet α cmp}
[TransCmp cmp]
{k : α}
:
@[simp]
theorem
Std.ExtTreeSet.containsThenInsert_snd
{α : Type u}
{cmp : α → α → Ordering}
{t : ExtTreeSet α cmp}
[TransCmp cmp]
{k : α}
:
@[simp]
theorem
Std.ExtTreeSet.length_toList
{α : Type u}
{cmp : α → α → Ordering}
{t : ExtTreeSet α cmp}
[TransCmp cmp]
:
@[simp]
theorem
Std.ExtTreeSet.isEmpty_toList
{α : Type u}
{cmp : α → α → Ordering}
{t : ExtTreeSet α cmp}
[TransCmp cmp]
:
@[simp]
theorem
Std.ExtTreeSet.contains_toList
{α : Type u}
{cmp : α → α → Ordering}
{t : ExtTreeSet α cmp}
[BEq α]
[LawfulBEqCmp cmp]
[TransCmp cmp]
{k : α}
:
@[simp]
theorem
Std.ExtTreeSet.mem_toList
{α : Type u}
{cmp : α → α → Ordering}
{t : ExtTreeSet α cmp}
[LawfulEqCmp cmp]
[TransCmp cmp]
{k : α}
:
theorem
Std.ExtTreeSet.distinct_toList
{α : Type u}
{cmp : α → α → Ordering}
{t : ExtTreeSet α cmp}
[TransCmp cmp]
:
List.Pairwise (fun (a b : α) => ¬cmp a b = Ordering.eq) t.toList
theorem
Std.ExtTreeSet.ordered_toList
{α : Type u}
{cmp : α → α → Ordering}
{t : ExtTreeSet α cmp}
[TransCmp cmp]
:
List.Pairwise (fun (a b : α) => cmp a b = Ordering.lt) t.toList
theorem
Std.ExtTreeSet.foldlM_eq_foldlM_toList
{α : Type u}
{cmp : α → α → Ordering}
{t : ExtTreeSet α cmp}
{δ : Type w}
{m : Type w → Type w'}
[TransCmp cmp]
[Monad m]
[LawfulMonad m]
{f : δ → α → m δ}
{init : δ}
:
theorem
Std.ExtTreeSet.foldl_eq_foldl_toList
{α : Type u}
{cmp : α → α → Ordering}
{t : ExtTreeSet α cmp}
{δ : Type w}
[TransCmp cmp]
{f : δ → α → δ}
{init : δ}
:
theorem
Std.ExtTreeSet.foldrM_eq_foldrM_toList
{α : Type u}
{cmp : α → α → Ordering}
{t : ExtTreeSet α cmp}
{δ : Type w}
{m : Type w → Type w'}
[TransCmp cmp]
[Monad m]
[LawfulMonad m]
{f : α → δ → m δ}
{init : δ}
:
theorem
Std.ExtTreeSet.foldr_eq_foldr_toList
{α : Type u}
{cmp : α → α → Ordering}
{t : ExtTreeSet α cmp}
{δ : Type w}
[TransCmp cmp]
{f : α → δ → δ}
{init : δ}
:
@[simp]
theorem
Std.ExtTreeSet.forM_eq_forM
{α : Type u}
{cmp : α → α → Ordering}
{t : ExtTreeSet α cmp}
{m : Type w → Type w'}
[TransCmp cmp]
[Monad m]
[LawfulMonad m]
{f : α → m PUnit}
:
theorem
Std.ExtTreeSet.forM_eq_forM_toList
{α : Type u}
{cmp : α → α → Ordering}
{t : ExtTreeSet α cmp}
{m : Type w → Type w'}
[TransCmp cmp]
[Monad m]
[LawfulMonad m]
{f : α → m PUnit}
:
@[simp]
theorem
Std.ExtTreeSet.forIn_eq_forIn
{α : Type u}
{cmp : α → α → Ordering}
{t : ExtTreeSet α cmp}
{δ : Type w}
{m : Type w → Type w'}
[TransCmp cmp]
[Monad m]
[LawfulMonad m]
{f : α → δ → m (ForInStep δ)}
{init : δ}
:
theorem
Std.ExtTreeSet.forIn_eq_forIn_toList
{α : Type u}
{cmp : α → α → Ordering}
{t : ExtTreeSet α cmp}
{δ : Type w}
{m : Type w → Type w'}
[TransCmp cmp]
[Monad m]
[LawfulMonad m]
{f : α → δ → m (ForInStep δ)}
{init : δ}
:
@[simp]
theorem
Std.ExtTreeSet.insertMany_nil
{α : Type u}
{cmp : α → α → Ordering}
{t : ExtTreeSet α cmp}
[TransCmp cmp]
:
@[simp]
theorem
Std.ExtTreeSet.insertMany_list_singleton
{α : Type u}
{cmp : α → α → Ordering}
{t : ExtTreeSet α cmp}
[TransCmp cmp]
{k : α}
:
theorem
Std.ExtTreeSet.insertMany_cons
{α : Type u}
{cmp : α → α → Ordering}
{t : ExtTreeSet α cmp}
[TransCmp cmp]
{l : List α}
{k : α}
:
theorem
Std.ExtTreeSet.insertMany_append
{α : Type u}
{cmp : α → α → Ordering}
{t : ExtTreeSet α cmp}
[TransCmp cmp]
{l₁ l₂ : List α}
:
@[simp]
theorem
Std.ExtTreeSet.contains_insertMany_list
{α : Type u}
{cmp : α → α → Ordering}
{t : ExtTreeSet α cmp}
[TransCmp cmp]
[BEq α]
[LawfulBEqCmp cmp]
{l : List α}
{k : α}
:
@[simp]
theorem
Std.ExtTreeSet.mem_insertMany_list
{α : Type u}
{cmp : α → α → Ordering}
{t : ExtTreeSet α cmp}
[TransCmp cmp]
[BEq α]
[LawfulBEqCmp cmp]
{l : List α}
{k : α}
:
theorem
Std.ExtTreeSet.mem_of_mem_insertMany_list
{α : Type u}
{cmp : α → α → Ordering}
{t : ExtTreeSet α cmp}
[TransCmp cmp]
[BEq α]
[LawfulBEqCmp cmp]
{l : List α}
{k : α}
(contains_eq_false : l.contains k = false)
:
k ∈ t.insertMany l → k ∈ t
theorem
Std.ExtTreeSet.get?_insertMany_list_of_not_mem_of_contains_eq_false
{α : Type u}
{cmp : α → α → Ordering}
{t : ExtTreeSet α cmp}
[TransCmp cmp]
[BEq α]
[LawfulBEqCmp cmp]
{l : List α}
{k : α}
(not_mem : ¬k ∈ t)
(contains_eq_false : l.contains k = false)
:
theorem
Std.ExtTreeSet.get?_insertMany_list_of_not_mem_of_mem
{α : Type u}
{cmp : α → α → Ordering}
{t : ExtTreeSet α cmp}
[TransCmp cmp]
{l : List α}
{k k' : α}
(k_eq : cmp k k' = Ordering.eq)
(not_mem : ¬k ∈ t)
(distinct : List.Pairwise (fun (a b : α) => ¬cmp a b = Ordering.eq) l)
(mem : k ∈ l)
:
theorem
Std.ExtTreeSet.get?_insertMany_list_of_mem
{α : Type u}
{cmp : α → α → Ordering}
{t : ExtTreeSet α cmp}
[TransCmp cmp]
{l : List α}
{k : α}
(mem : k ∈ t)
:
theorem
Std.ExtTreeSet.get_insertMany_list_of_mem
{α : Type u}
{cmp : α → α → Ordering}
{t : ExtTreeSet α cmp}
[TransCmp cmp]
{l : List α}
{k : α}
{h' : k ∈ t.insertMany l}
(contains : k ∈ t)
:
theorem
Std.ExtTreeSet.get_insertMany_list_of_not_mem_of_mem
{α : Type u}
{cmp : α → α → Ordering}
{t : ExtTreeSet α cmp}
[TransCmp cmp]
{l : List α}
{k k' : α}
(k_eq : cmp k k' = Ordering.eq)
{h' : k' ∈ t.insertMany l}
(not_mem : ¬k ∈ t)
(distinct : List.Pairwise (fun (a b : α) => ¬cmp a b = Ordering.eq) l)
(mem : k ∈ l)
:
theorem
Std.ExtTreeSet.get!_insertMany_list_of_not_mem_of_contains_eq_false
{α : Type u}
{cmp : α → α → Ordering}
{t : ExtTreeSet α cmp}
[TransCmp cmp]
[BEq α]
[LawfulBEqCmp cmp]
[Inhabited α]
{l : List α}
{k : α}
(not_mem : ¬k ∈ t)
(contains_eq_false : l.contains k = false)
:
theorem
Std.ExtTreeSet.get!_insertMany_list_of_not_mem_of_mem
{α : Type u}
{cmp : α → α → Ordering}
{t : ExtTreeSet α cmp}
[TransCmp cmp]
[Inhabited α]
{l : List α}
{k k' : α}
(k_eq : cmp k k' = Ordering.eq)
(not_mem : ¬k ∈ t)
(distinct : List.Pairwise (fun (a b : α) => ¬cmp a b = Ordering.eq) l)
(mem : k ∈ l)
:
theorem
Std.ExtTreeSet.get!_insertMany_list_of_mem
{α : Type u}
{cmp : α → α → Ordering}
{t : ExtTreeSet α cmp}
[TransCmp cmp]
[Inhabited α]
{l : List α}
{k : α}
(mem : k ∈ t)
:
theorem
Std.ExtTreeSet.getD_insertMany_list_of_not_mem_of_contains_eq_false
{α : Type u}
{cmp : α → α → Ordering}
{t : ExtTreeSet α cmp}
[TransCmp cmp]
[BEq α]
[LawfulBEqCmp cmp]
{l : List α}
{k fallback : α}
(not_mem : ¬k ∈ t)
(contains_eq_false : l.contains k = false)
:
theorem
Std.ExtTreeSet.getD_insertMany_list_of_not_mem_of_mem
{α : Type u}
{cmp : α → α → Ordering}
{t : ExtTreeSet α cmp}
[TransCmp cmp]
{l : List α}
{k k' fallback : α}
(k_eq : cmp k k' = Ordering.eq)
(not_mem : ¬k ∈ t)
(distinct : List.Pairwise (fun (a b : α) => ¬cmp a b = Ordering.eq) l)
(mem : k ∈ l)
:
theorem
Std.ExtTreeSet.getD_insertMany_list_of_mem
{α : Type u}
{cmp : α → α → Ordering}
{t : ExtTreeSet α cmp}
[TransCmp cmp]
{l : List α}
{k fallback : α}
(mem : k ∈ t)
:
theorem
Std.ExtTreeSet.size_insertMany_list
{α : Type u}
{cmp : α → α → Ordering}
{t : ExtTreeSet α cmp}
[TransCmp cmp]
[BEq α]
[LawfulBEqCmp cmp]
{l : List α}
(distinct : List.Pairwise (fun (a b : α) => ¬cmp a b = Ordering.eq) l)
:
theorem
Std.ExtTreeSet.size_le_size_insertMany_list
{α : Type u}
{cmp : α → α → Ordering}
{t : ExtTreeSet α cmp}
[TransCmp cmp]
{l : List α}
:
theorem
Std.ExtTreeSet.size_insertMany_list_le
{α : Type u}
{cmp : α → α → Ordering}
{t : ExtTreeSet α cmp}
[TransCmp cmp]
{l : List α}
:
@[simp]
theorem
Std.ExtTreeSet.isEmpty_insertMany_list
{α : Type u}
{cmp : α → α → Ordering}
{t : ExtTreeSet α cmp}
[TransCmp cmp]
{l : List α}
:
theorem
Std.ExtTreeSet.ofList_eq_insertMany_empty
{α : Type u}
{cmp : α → α → Ordering}
[TransCmp cmp]
{l : List α}
:
theorem
Std.ExtTreeSet.get?_ofList_of_mem
{α : Type u}
{cmp : α → α → Ordering}
[TransCmp cmp]
{l : List α}
{k k' : α}
(k_eq : cmp k k' = Ordering.eq)
(distinct : List.Pairwise (fun (a b : α) => ¬cmp a b = Ordering.eq) l)
(mem : k ∈ l)
:
theorem
Std.ExtTreeSet.get_ofList_of_mem
{α : Type u}
{cmp : α → α → Ordering}
[TransCmp cmp]
{l : List α}
{k k' : α}
(k_eq : cmp k k' = Ordering.eq)
(distinct : List.Pairwise (fun (a b : α) => ¬cmp a b = Ordering.eq) l)
(mem : k ∈ l)
{h' : k' ∈ ofList l cmp}
:
theorem
Std.ExtTreeSet.get!_ofList_of_mem
{α : Type u}
{cmp : α → α → Ordering}
[TransCmp cmp]
[Inhabited α]
{l : List α}
{k k' : α}
(k_eq : cmp k k' = Ordering.eq)
(distinct : List.Pairwise (fun (a b : α) => ¬cmp a b = Ordering.eq) l)
(mem : k ∈ l)
:
theorem
Std.ExtTreeSet.getD_ofList_of_mem
{α : Type u}
{cmp : α → α → Ordering}
[TransCmp cmp]
{l : List α}
{k k' fallback : α}
(k_eq : cmp k k' = Ordering.eq)
(distinct : List.Pairwise (fun (a b : α) => ¬cmp a b = Ordering.eq) l)
(mem : k ∈ l)
:
theorem
Std.ExtTreeSet.size_ofList
{α : Type u}
{cmp : α → α → Ordering}
[TransCmp cmp]
{l : List α}
(distinct : List.Pairwise (fun (a b : α) => ¬cmp a b = Ordering.eq) l)
:
@[simp]
theorem
Std.ExtTreeSet.isNone_min?_eq_isEmpty
{α : Type u}
{cmp : α → α → Ordering}
{t : ExtTreeSet α cmp}
[TransCmp cmp]
:
theorem
Std.ExtTreeSet.min?_mem
{α : Type u}
{cmp : α → α → Ordering}
{t : ExtTreeSet α cmp}
[TransCmp cmp]
{km : α}
(hkm : t.min? = some km)
:
theorem
Std.ExtTreeSet.min?_eq_head?_toList
{α : Type u}
{cmp : α → α → Ordering}
{t : ExtTreeSet α cmp}
[TransCmp cmp]
:
theorem
Std.ExtTreeSet.min_mem
{α : Type u}
{cmp : α → α → Ordering}
{t : ExtTreeSet α cmp}
[TransCmp cmp]
{he : t ≠ ∅}
:
theorem
Std.ExtTreeSet.minD_mem
{α : Type u}
{cmp : α → α → Ordering}
{t : ExtTreeSet α cmp}
[TransCmp cmp]
(he : t ≠ ∅)
{fallback : α}
:
theorem
Std.ExtTreeSet.minD_eq_headD_toList
{α : Type u}
{cmp : α → α → Ordering}
{t : ExtTreeSet α cmp}
[TransCmp cmp]
{fallback : α}
:
@[simp]
theorem
Std.ExtTreeSet.isNone_max?_eq_isEmpty
{α : Type u}
{cmp : α → α → Ordering}
{t : ExtTreeSet α cmp}
[TransCmp cmp]
:
theorem
Std.ExtTreeSet.max?_mem
{α : Type u}
{cmp : α → α → Ordering}
{t : ExtTreeSet α cmp}
[TransCmp cmp]
{km : α}
(hkm : t.max? = some km)
:
theorem
Std.ExtTreeSet.max?_eq_getLast?_toList
{α : Type u}
{cmp : α → α → Ordering}
{t : ExtTreeSet α cmp}
[TransCmp cmp]
:
theorem
Std.ExtTreeSet.max_mem
{α : Type u}
{cmp : α → α → Ordering}
{t : ExtTreeSet α cmp}
[TransCmp cmp]
{he : t ≠ ∅}
:
theorem
Std.ExtTreeSet.maxD_mem
{α : Type u}
{cmp : α → α → Ordering}
{t : ExtTreeSet α cmp}
[TransCmp cmp]
(he : t ≠ ∅)
{fallback : α}
:
theorem
Std.ExtTreeSet.maxD_eq_getLastD_toList
{α : Type u}
{cmp : α → α → Ordering}
{t : ExtTreeSet α cmp}
[TransCmp cmp]
{fallback : α}
:
theorem
Std.ExtTreeSet.ext_get?
{α : Type u}
{cmp : α → α → Ordering}
[TransCmp cmp]
{t₁ t₂ : ExtTreeSet α cmp}
(h : ∀ (k : α), t₁.get? k = t₂.get? k)
:
theorem
Std.ExtTreeSet.ext_contains
{α : Type u}
{cmp : α → α → Ordering}
[TransCmp cmp]
[LawfulEqCmp cmp]
{t₁ t₂ : ExtTreeSet α cmp}
(h : ∀ (k : α), t₁.contains k = t₂.contains k)
:
theorem
Std.ExtTreeSet.ext_mem
{α : Type u}
{cmp : α → α → Ordering}
[TransCmp cmp]
[LawfulEqCmp cmp]
{t₁ t₂ : ExtTreeSet α cmp}
(h : ∀ (k : α), k ∈ t₁ ↔ k ∈ t₂)
:
theorem
Std.ExtTreeSet.ext_mem_iff
{α : Type u}
{cmp : α → α → Ordering}
[TransCmp cmp]
[LawfulEqCmp cmp]
{t₁ t₂ : ExtTreeSet α cmp}
:
theorem
Std.ExtTreeSet.ext_toList
{α : Type u}
{cmp : α → α → Ordering}
{t₁ t₂ : ExtTreeSet α cmp}
[TransCmp cmp]
(h : t₁.toList.Perm t₂.toList)
: