inductive Std.PairingHeapImp.Heap (α : Type u) : Type u

• nil: {α : Type u} → Std.PairingHeapImp.Heap α

  An empty forest, which has depth 0.

• node: {α : Type u} → α → Std.PairingHeapImp.Heap α → Std.PairingHeapImp.Heap α → Std.PairingHeapImp.Heap α

  A forest consists of a root a, a forest child elements greater than a, and another forest sibling.

A Heap is the nodes of the pairing heap. Each node have two pointers: child going to the first child of this node, and sibling goes to the next sibling of this tree. So it actually encodes a forest where each node has children node.child, node.child.sibling, node.child.sibling.sibling, etc.

Each edge in this forest denotes a le a b relation that has been checked, so the root is smaller than everything else under it.

instance Std.PairingHeapImp.instReprHeap : {α : Type u_1} → [inst : Repr α] → Repr (Std.PairingHeapImp.Heap α)

Equations

• Std.PairingHeapImp.instReprHeap = { reprPrec := Std.PairingHeapImp.reprHeap✝ }

def Std.PairingHeapImp.Heap.size {α : Type u_1} : Std.PairingHeapImp.Heap α → Nat

O(n). The number of elements in the heap.

Equations

• Std.PairingHeapImp.Heap.size Std.PairingHeapImp.Heap.nil = 0
• Std.PairingHeapImp.Heap.size (Std.PairingHeapImp.Heap.node a a_1 a_2) = Std.PairingHeapImp.Heap.size a_1 + 1 + Std.PairingHeapImp.Heap.size a_2

def Std.PairingHeapImp.Heap.singleton {α : Type u_1} (a : α) : Std.PairingHeapImp.Heap α

A node containing a single element a.

Equations

• Std.PairingHeapImp.Heap.singleton a = Std.PairingHeapImp.Heap.node a Std.PairingHeapImp.Heap.nil Std.PairingHeapImp.Heap.nil

def Std.PairingHeapImp.Heap.isEmpty {α : Type u_1} : Std.PairingHeapImp.Heap α → Bool

O(1). Is the heap empty?

Equations

• Std.PairingHeapImp.Heap.isEmpty x = match x with | Std.PairingHeapImp.Heap.nil => true | x => false

@[specialize #[]]

def Std.PairingHeapImp.Heap.merge {α : Type u_1} (le : α → α → Bool) : Std.PairingHeapImp.Heap α → Std.PairingHeapImp.Heap α → Std.PairingHeapImp.Heap α

O(1). Merge two heaps. Ignore siblings.

Equations

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

@[specialize #[]]

def Std.PairingHeapImp.Heap.combine {α : Type u_1} (le : α → α → Bool) : Std.PairingHeapImp.Heap α → Std.PairingHeapImp.Heap α

Auxiliary for Heap.deleteMin: merge the forest in pairs.

Equations

• One or more equations did not get rendered due to their size.
• Std.PairingHeapImp.Heap.combine le x = x

@[inline]

def Std.PairingHeapImp.Heap.headD {α : Type u_1} (a : α) : Std.PairingHeapImp.Heap α → α

O(1). Get the smallest element in the heap, including the passed in value a.

Equations

• Std.PairingHeapImp.Heap.headD a x = match x with | Std.PairingHeapImp.Heap.nil => a | Std.PairingHeapImp.Heap.node a child sibling => a

@[inline]

def Std.PairingHeapImp.Heap.head? {α : Type u_1} : Std.PairingHeapImp.Heap α → Option α

O(1). Get the smallest element in the heap, if it has an element.

Equations

• Std.PairingHeapImp.Heap.head? x = match x with | Std.PairingHeapImp.Heap.nil => none | Std.PairingHeapImp.Heap.node a child sibling => some a

@[inline]

def Std.PairingHeapImp.Heap.deleteMin {α : Type u_1} (le : α → α → Bool) : Std.PairingHeapImp.Heap α → Option (α × Std.PairingHeapImp.Heap α)

Amortized O(log n). Find and remove the the minimum element from the heap.

Equations

• Std.PairingHeapImp.Heap.deleteMin le x = match x with | Std.PairingHeapImp.Heap.nil => none | Std.PairingHeapImp.Heap.node a c sibling => some (a, Std.PairingHeapImp.Heap.combine le c)

@[inline]

def Std.PairingHeapImp.Heap.tail? {α : Type u_1} (le : α → α → Bool) (h : Std.PairingHeapImp.Heap α) : Option (Std.PairingHeapImp.Heap α)

Amortized O(log n). Get the tail of the pairing heap after removing the minimum element.

Equations

• Std.PairingHeapImp.Heap.tail? le h = Option.map (fun x => x.snd) (Std.PairingHeapImp.Heap.deleteMin le h)

@[inline]

def Std.PairingHeapImp.Heap.tail {α : Type u_1} (le : α → α → Bool) (h : Std.PairingHeapImp.Heap α) : Std.PairingHeapImp.Heap α

Amortized O(log n). Remove the minimum element of the heap.

Equations

• Std.PairingHeapImp.Heap.tail le h = Option.getD (Std.PairingHeapImp.Heap.tail? le h) Std.PairingHeapImp.Heap.nil

inductive Std.PairingHeapImp.Heap.NoSibling {α : Type u_1} : Std.PairingHeapImp.Heap α → Prop

• nil: ∀ {α : Type u_1}, Std.PairingHeapImp.Heap.NoSibling Std.PairingHeapImp.Heap.nil

  An empty heap is no more than one tree.

• node: ∀ {α : Type u_1} (a : α) (c : Std.PairingHeapImp.Heap α), Std.PairingHeapImp.Heap.NoSibling (Std.PairingHeapImp.Heap.node a c Std.PairingHeapImp.Heap.nil)

  Or there is exactly one tree.

A predicate says there is no more than one tree.

instance Std.PairingHeapImp.instDecidableNoSibling : {α : Type u_1} → {s : Std.PairingHeapImp.Heap α} → Decidable (Std.PairingHeapImp.Heap.NoSibling s)

Equations

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

theorem Std.PairingHeapImp.Heap.noSibling_merge {α : Type u_1} (le : α → α → Bool) (s₁ : Std.PairingHeapImp.Heap α) (s₂ : Std.PairingHeapImp.Heap α) : Std.PairingHeapImp.Heap.NoSibling (Std.PairingHeapImp.Heap.merge le s₁ s₂)

theorem Std.PairingHeapImp.Heap.noSibling_combine {α : Type u_1} (le : α → α → Bool) (s : Std.PairingHeapImp.Heap α) : Std.PairingHeapImp.Heap.NoSibling (Std.PairingHeapImp.Heap.combine le s)

theorem Std.PairingHeapImp.Heap.noSibling_deleteMin {α : Type u_1} {le : α → α → Bool} {a : α} {s' : Std.PairingHeapImp.Heap α} {s : Std.PairingHeapImp.Heap α} (eq : Std.PairingHeapImp.Heap.deleteMin le s = some (a, s')) : Std.PairingHeapImp.Heap.NoSibling s'

theorem Std.PairingHeapImp.Heap.noSibling_tail? {α : Type u_1} {le : α → α → Bool} {s' : Std.PairingHeapImp.Heap α} {s : Std.PairingHeapImp.Heap α} : Std.PairingHeapImp.Heap.tail? le s = some s' → Std.PairingHeapImp.Heap.NoSibling s'

theorem Std.PairingHeapImp.Heap.noSibling_tail {α : Type u_1} (le : α → α → Bool) (s : Std.PairingHeapImp.Heap α) : Std.PairingHeapImp.Heap.NoSibling (Std.PairingHeapImp.Heap.tail le s)

theorem Std.PairingHeapImp.Heap.size_merge_node {α : Type u_1} (le : α → α → Bool) (a₁ : α) (c₁ : Std.PairingHeapImp.Heap α) (s₁ : Std.PairingHeapImp.Heap α) (a₂ : α) (c₂ : Std.PairingHeapImp.Heap α) (s₂ : Std.PairingHeapImp.Heap α) : Std.PairingHeapImp.Heap.size (Std.PairingHeapImp.Heap.merge le (Std.PairingHeapImp.Heap.node a₁ c₁ s₁) (Std.PairingHeapImp.Heap.node a₂ c₂ s₂)) = Std.PairingHeapImp.Heap.size c₁ + Std.PairingHeapImp.Heap.size c₂ + 2

theorem Std.PairingHeapImp.Heap.size_merge {α : Type u_1} (le : α → α → Bool) {s₁ : Std.PairingHeapImp.Heap α} {s₂ : Std.PairingHeapImp.Heap α} (h₁ : Std.PairingHeapImp.Heap.NoSibling s₁) (h₂ : Std.PairingHeapImp.Heap.NoSibling s₂) : Std.PairingHeapImp.Heap.size (Std.PairingHeapImp.Heap.merge le s₁ s₂) = Std.PairingHeapImp.Heap.size s₁ + Std.PairingHeapImp.Heap.size s₂

theorem Std.PairingHeapImp.Heap.size_combine {α : Type u_1} (le : α → α → Bool) (s : Std.PairingHeapImp.Heap α) : Std.PairingHeapImp.Heap.size (Std.PairingHeapImp.Heap.combine le s) = Std.PairingHeapImp.Heap.size s

theorem Std.PairingHeapImp.Heap.size_deleteMin {α : Type u_1} {le : α → α → Bool} {a : α} {s' : Std.PairingHeapImp.Heap α} {s : Std.PairingHeapImp.Heap α} (h : Std.PairingHeapImp.Heap.NoSibling s) (eq : Std.PairingHeapImp.Heap.deleteMin le s = some (a, s')) : Std.PairingHeapImp.Heap.size s = Std.PairingHeapImp.Heap.size s' + 1

theorem Std.PairingHeapImp.Heap.size_tail? {α : Type u_1} {le : α → α → Bool} {s' : Std.PairingHeapImp.Heap α} {s : Std.PairingHeapImp.Heap α} (h : Std.PairingHeapImp.Heap.NoSibling s) : Std.PairingHeapImp.Heap.tail? le s = some s' → Std.PairingHeapImp.Heap.size s = Std.PairingHeapImp.Heap.size s' + 1

theorem Std.PairingHeapImp.Heap.size_tail {α : Type u_1} (le : α → α → Bool) {s : Std.PairingHeapImp.Heap α} (h : Std.PairingHeapImp.Heap.NoSibling s) : Std.PairingHeapImp.Heap.size (Std.PairingHeapImp.Heap.tail le s) = Std.PairingHeapImp.Heap.size s - 1

theorem Std.PairingHeapImp.Heap.size_deleteMin_lt {α : Type u_1} {le : α → α → Bool} {a : α} {s' : Std.PairingHeapImp.Heap α} {s : Std.PairingHeapImp.Heap α} (eq : Std.PairingHeapImp.Heap.deleteMin le s = some (a, s')) : Std.PairingHeapImp.Heap.size s' < Std.PairingHeapImp.Heap.size s

theorem Std.PairingHeapImp.Heap.size_tail?_lt {α : Type u_1} {le : α → α → Bool} {s' : Std.PairingHeapImp.Heap α} {s : Std.PairingHeapImp.Heap α} : Std.PairingHeapImp.Heap.tail? le s = some s' → Std.PairingHeapImp.Heap.size s' < Std.PairingHeapImp.Heap.size s

@[specialize #[]]

def Std.PairingHeapImp.Heap.foldM {m : Type u_1 → Type u_2} {α : Type u_3} {β : Type u_1} [Monad m] (le : α → α → Bool) (s : Std.PairingHeapImp.Heap α) (init : β) (f : β → α → m β) : m β

O(n log n). Monadic fold over the elements of a heap in increasing order, by repeatedly pulling the minimum element out of the heap.

Equations

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

@[inline]

def Std.PairingHeapImp.Heap.fold {α : Type u_1} {β : Type u_2} (le : α → α → Bool) (s : Std.PairingHeapImp.Heap α) (init : β) (f : β → α → β) : β

O(n log n). Fold over the elements of a heap in increasing order, by repeatedly pulling the minimum element out of the heap.

Equations

• Std.PairingHeapImp.Heap.fold le s init f = Id.run (Std.PairingHeapImp.Heap.foldM le s init f)

@[inline]

def Std.PairingHeapImp.Heap.toArray {α : Type u_1} (le : α → α → Bool) (s : Std.PairingHeapImp.Heap α) : Array α

O(n log n). Convert the heap to an array in increasing order.

Equations

• Std.PairingHeapImp.Heap.toArray le s = Std.PairingHeapImp.Heap.fold le s #[] Array.push

@[inline]

def Std.PairingHeapImp.Heap.toList {α : Type u_1} (le : α → α → Bool) (s : Std.PairingHeapImp.Heap α) : List α

O(n log n). Convert the heap to a list in increasing order.

Equations

• Std.PairingHeapImp.Heap.toList le s = Array.toList (Std.PairingHeapImp.Heap.toArray le s)

@[specialize #[]]

def Std.PairingHeapImp.Heap.foldTreeM {m : Type u_1 → Type u_2} {β : Type u_1} {α : Type u_3} [Monad m] (nil : β) (join : α → β → β → m β) : Std.PairingHeapImp.Heap α → m β

O(n). Fold a monadic function over the tree structure to accumulate a value.

Equations

• One or more equations did not get rendered due to their size.
• Std.PairingHeapImp.Heap.foldTreeM nil join Std.PairingHeapImp.Heap.nil = pure nil

@[inline]

def Std.PairingHeapImp.Heap.foldTree {β : Type u_1} {α : Type u_2} (nil : β) (join : α → β → β → β) (s : Std.PairingHeapImp.Heap α) : β

O(n). Fold a function over the tree structure to accumulate a value.

Equations

• Std.PairingHeapImp.Heap.foldTree nil join s = Id.run (Std.PairingHeapImp.Heap.foldTreeM nil join s)

def Std.PairingHeapImp.Heap.toListUnordered {α : Type u_1} (s : Std.PairingHeapImp.Heap α) : List α

O(n). Convert the heap to a list in arbitrary order.

Equations

• Std.PairingHeapImp.Heap.toListUnordered s = Std.PairingHeapImp.Heap.foldTree id (fun a c s l => a :: c (s l)) s []

def Std.PairingHeapImp.Heap.toArrayUnordered {α : Type u_1} (s : Std.PairingHeapImp.Heap α) : Array α

O(n). Convert the heap to an array in arbitrary order.

Equations

• Std.PairingHeapImp.Heap.toArrayUnordered s = Std.PairingHeapImp.Heap.foldTree id (fun a c s r => s (c (Array.push r a))) s #[]

def Std.PairingHeapImp.Heap.NodeWF {α : Type u_1} (le : α → α → Bool) (a : α) : Std.PairingHeapImp.Heap α → Prop

The well formedness predicate for a heap node. It asserts that:

• If a is added at the top to make the forest into a tree, the resulting tree is a le-min-heap (if le is well-behaved)

Equations

• One or more equations did not get rendered due to their size.
• Std.PairingHeapImp.Heap.NodeWF le a Std.PairingHeapImp.Heap.nil = True

inductive Std.PairingHeapImp.Heap.WF {α : Type u_1} (le : α → α → Bool) : Std.PairingHeapImp.Heap α → Prop

• nil: ∀ {α : Type u_1} {le : α → α → Bool}, Std.PairingHeapImp.Heap.WF le Std.PairingHeapImp.Heap.nil

  It is an empty heap.

• node: ∀ {α : Type u_1} {le : α → α → Bool} {a : α} {c : Std.PairingHeapImp.Heap α}, Std.PairingHeapImp.Heap.NodeWF le a c → Std.PairingHeapImp.Heap.WF le (Std.PairingHeapImp.Heap.node a c Std.PairingHeapImp.Heap.nil)

  There is exactly one tree and it is a le-min-heap.

The well formedness predicate for a pairing heap. It asserts that:

• There is no more than one tree.
• It is a le-min-heap (if le is well-behaved)

theorem Std.PairingHeapImp.Heap.WF.singleton : ∀ {α : Type u_1} {a : α} {le : α → α → Bool}, Std.PairingHeapImp.Heap.WF le (Std.PairingHeapImp.Heap.singleton a)

theorem Std.PairingHeapImp.Heap.WF.merge_node : ∀ {α : Type u_1} {le : α → α → Bool} {a₁ : α} {c₁ : Std.PairingHeapImp.Heap α} {a₂ : α} {c₂ s₁ s₂ : Std.PairingHeapImp.Heap α}, Std.PairingHeapImp.Heap.NodeWF le a₁ c₁ → Std.PairingHeapImp.Heap.NodeWF le a₂ c₂ → Std.PairingHeapImp.Heap.WF le (Std.PairingHeapImp.Heap.merge le (Std.PairingHeapImp.Heap.node a₁ c₁ s₁) (Std.PairingHeapImp.Heap.node a₂ c₂ s₂))

theorem Std.PairingHeapImp.Heap.WF.merge : ∀ {α : Type u_1} {le : α → α → Bool} {s₁ s₂ : Std.PairingHeapImp.Heap α}, Std.PairingHeapImp.Heap.WF le s₁ → Std.PairingHeapImp.Heap.WF le s₂ → Std.PairingHeapImp.Heap.WF le (Std.PairingHeapImp.Heap.merge le s₁ s₂)

theorem Std.PairingHeapImp.Heap.WF.combine : ∀ {α : Type u_1} {le : α → α → Bool} {s : Std.PairingHeapImp.Heap α} {a : α}, Std.PairingHeapImp.Heap.NodeWF le a s → Std.PairingHeapImp.Heap.WF le (Std.PairingHeapImp.Heap.combine le s)

theorem Std.PairingHeapImp.Heap.WF.deleteMin {α : Type u_1} {le : α → α → Bool} {a : α} {s' : Std.PairingHeapImp.Heap α} {s : Std.PairingHeapImp.Heap α} (h : Std.PairingHeapImp.Heap.WF le s) (eq : Std.PairingHeapImp.Heap.deleteMin le s = some (a, s')) : Std.PairingHeapImp.Heap.WF le s'

theorem Std.PairingHeapImp.Heap.WF.tail? {α : Type u_1} {s : Std.PairingHeapImp.Heap α} {le : α → α → Bool} {tl : Std.PairingHeapImp.Heap α} (hwf : Std.PairingHeapImp.Heap.WF le s) : Std.PairingHeapImp.Heap.tail? le s = some tl → Std.PairingHeapImp.Heap.WF le tl

theorem Std.PairingHeapImp.Heap.WF.tail {α : Type u_1} {s : Std.PairingHeapImp.Heap α} {le : α → α → Bool} (hwf : Std.PairingHeapImp.Heap.WF le s) : Std.PairingHeapImp.Heap.WF le (Std.PairingHeapImp.Heap.tail le s)

theorem Std.PairingHeapImp.Heap.deleteMin_fst {α : Type u_1} {s : Std.PairingHeapImp.Heap α} {le : α → α → Bool} : Option.map (fun x => x.fst) (Std.PairingHeapImp.Heap.deleteMin le s) = Std.PairingHeapImp.Heap.head? s

def Std.PairingHeap (α : Type u) (le : α → α → Bool) : Type u

A pairing heap is a data structure which supports the following primary operations:

• insert : α → PairingHeap α → PairingHeap α: add an element to the heap
• deleteMin : PairingHeap α → Option (α × PairingHeap α): remove the minimum element from the heap
• merge : PairingHeap α → PairingHeap α → PairingHeap α: combine two heaps

The first two operations are known as a "priority queue", so this could be called a "mergeable priority queue". The standard choice for a priority queue is a binary heap, which supports insert and deleteMin in O(log n), but merge is O(n). With a PairingHeap, insert and merge are O(1), deleteMin is amortized O(log n).

Note that deleteMin may be O(n) in a single operation. So if you need an efficient persistent priority queue, you should use other data structures with better worst-case time.

Equations

• Std.PairingHeap α le = { h // Std.PairingHeapImp.Heap.WF le h }

@[inline]

def Std.mkPairingHeap (α : Type u) (le : α → α → Bool) : Std.PairingHeap α le

O(1). Make a new empty pairing heap.

Equations

• Std.mkPairingHeap α le = { val := Std.PairingHeapImp.Heap.nil, property := (_ : Std.PairingHeapImp.Heap.WF le Std.PairingHeapImp.Heap.nil) }

@[inline]

def Std.PairingHeap.empty {α : Type u} {le : α → α → Bool} : Std.PairingHeap α le

O(1). Make a new empty pairing heap.

Equations

• Std.PairingHeap.empty = Std.mkPairingHeap α le

instance Std.PairingHeap.instInhabitedPairingHeap {α : Type u} {le : α → α → Bool} : Inhabited (Std.PairingHeap α le)

Equations

• Std.PairingHeap.instInhabitedPairingHeap = { default := Std.PairingHeap.empty }

@[inline]

def Std.PairingHeap.isEmpty {α : Type u} {le : α → α → Bool} (b : Std.PairingHeap α le) : Bool

O(1). Is the heap empty?

Equations

• Std.PairingHeap.isEmpty b = Std.PairingHeapImp.Heap.isEmpty b.val

@[inline]

def Std.PairingHeap.size {α : Type u} {le : α → α → Bool} (b : Std.PairingHeap α le) : Nat

O(n). The number of elements in the heap.

Equations

• Std.PairingHeap.size b = Std.PairingHeapImp.Heap.size b.val

@[inline]

def Std.PairingHeap.singleton {α : Type u} {le : α → α → Bool} (a : α) : Std.PairingHeap α le

O(1). Make a new heap containing a.

Equations

• Std.PairingHeap.singleton a = { val := Std.PairingHeapImp.Heap.singleton a, property := (_ : Std.PairingHeapImp.Heap.WF le (Std.PairingHeapImp.Heap.singleton a)) }

@[inline]

def Std.PairingHeap.merge {α : Type u} {le : α → α → Bool} : Std.PairingHeap α le → Std.PairingHeap α le → Std.PairingHeap α le

O(1). Merge the contents of two heaps.

Equations

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

@[inline]

def Std.PairingHeap.insert {α : Type u} {le : α → α → Bool} (a : α) (h : Std.PairingHeap α le) : Std.PairingHeap α le

O(1). Add element a to the given heap h.

Equations

• Std.PairingHeap.insert a h = Std.PairingHeap.merge (Std.PairingHeap.singleton a) h

def Std.PairingHeap.ofList {α : Type u} (le : α → α → Bool) (as : List α) : Std.PairingHeap α le

O(n log n). Construct a heap from a list by inserting all the elements.

Equations

• Std.PairingHeap.ofList le as = List.foldl (flip Std.PairingHeap.insert) Std.PairingHeap.empty as

def Std.PairingHeap.ofArray {α : Type u} (le : α → α → Bool) (as : Array α) : Std.PairingHeap α le

O(n log n). Construct a heap from a list by inserting all the elements.

Equations

• Std.PairingHeap.ofArray le as = Array.foldl (flip Std.PairingHeap.insert) Std.PairingHeap.empty as 0 (Array.size as)

@[inline]

def Std.PairingHeap.deleteMin {α : Type u} {le : α → α → Bool} (b : Std.PairingHeap α le) : Option (α × Std.PairingHeap α le)

Amortized O(log n). Remove and return the minimum element from the heap.

Equations

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

@[inline]

def Std.PairingHeap.head? {α : Type u} {le : α → α → Bool} (b : Std.PairingHeap α le) : Option α

O(1). Returns the smallest element in the heap, or none if the heap is empty.

Equations

• Std.PairingHeap.head? b = Std.PairingHeapImp.Heap.head? b.val

@[inline]

def Std.PairingHeap.head! {α : Type u} {le : α → α → Bool} [Inhabited α] (b : Std.PairingHeap α le) : α

O(1). Returns the smallest element in the heap, or panics if the heap is empty.

Equations

• Std.PairingHeap.head! b = Option.get! (Std.PairingHeap.head? b)

@[inline]

def Std.PairingHeap.headI {α : Type u} {le : α → α → Bool} [Inhabited α] (b : Std.PairingHeap α le) : α

O(1). Returns the smallest element in the heap, or default if the heap is empty.

Equations

• Std.PairingHeap.headI b = Option.getD (Std.PairingHeap.head? b) default

@[inline]

def Std.PairingHeap.tail? {α : Type u} {le : α → α → Bool} (b : Std.PairingHeap α le) : Option (Std.PairingHeap α le)

Amortized O(log n). Removes the smallest element from the heap, or none if the heap is empty.

Equations

• Std.PairingHeap.tail? b = match eq : Std.PairingHeapImp.Heap.tail? le b.val with | none => none | some tl => some { val := tl, property := (_ : Std.PairingHeapImp.Heap.WF le tl) }

@[inline]

def Std.PairingHeap.tail {α : Type u} {le : α → α → Bool} (b : Std.PairingHeap α le) : Std.PairingHeap α le

Amortized O(log n). Removes the smallest element from the heap, if possible.

Equations

• Std.PairingHeap.tail b = { val := Std.PairingHeapImp.Heap.tail le b.val, property := (_ : Std.PairingHeapImp.Heap.WF le (Std.PairingHeapImp.Heap.tail le b.val)) }

@[inline]

def Std.PairingHeap.toList {α : Type u} {le : α → α → Bool} (b : Std.PairingHeap α le) : List α

O(n log n). Convert the heap to a list in increasing order.

Equations

• Std.PairingHeap.toList b = Std.PairingHeapImp.Heap.toList le b.val

@[inline]

def Std.PairingHeap.toArray {α : Type u} {le : α → α → Bool} (b : Std.PairingHeap α le) : Array α

O(n log n). Convert the heap to an array in increasing order.

Equations

• Std.PairingHeap.toArray b = Std.PairingHeapImp.Heap.toArray le b.val

@[inline]

def Std.PairingHeap.toListUnordered {α : Type u} {le : α → α → Bool} (b : Std.PairingHeap α le) : List α

O(n). Convert the heap to a list in arbitrary order.

Equations

• Std.PairingHeap.toListUnordered b = Std.PairingHeapImp.Heap.toListUnordered b.val

@[inline]

def Std.PairingHeap.toArrayUnordered {α : Type u} {le : α → α → Bool} (b : Std.PairingHeap α le) : Array α

O(n). Convert the heap to an array in arbitrary order.

Equations

• Std.PairingHeap.toArrayUnordered b = Std.PairingHeapImp.Heap.toArrayUnordered b.val