File: .lake/packages/lean4/src/lean/Lean/Data/PersistentHashMap.lean

full_name: Lean.PersistentHashMap.Entry.null
code: inductive Entry (α : Type u) (β : Type v) (σ : Type w) where
  | entry (key : α) (val : β) : Entry α β σ
  | ref   (node : σ) : Entry α β σ
  | null  : Entry α β σ
goal: Lean.PersistentHashMap.Entry α β σ

full_name: Lean.PersistentHashMap.Entry
code: inductive Entry (α : Type u) (β : Type v) (σ : Type w) where
  | entry (key : α) (val : β) : Entry α β σ
  | ref   (node : σ) : Entry α β σ
  | null  : Entry α β σ
goal: Type (max (max u v) w)

full_name: Lean.PersistentHashMap.Entry.ref
code: inductive Entry (α : Type u) (β : Type v) (σ : Type w) where
  | entry (key : α) (val : β) : Entry α β σ
  | ref   (node : σ) : Entry α β σ
  | null  : Entry α β σ
goal: Lean.PersistentHashMap.Entry α β σ

full_name: Lean.PersistentHashMap.Entry.entry
code: inductive Entry (α : Type u) (β : Type v) (σ : Type w) where
  | entry (key : α) (val : β) : Entry α β σ
  | ref   (node : σ) : Entry α β σ
  | null  : Entry α β σ
goal: Lean.PersistentHashMap.Entry α β σ

full_name: Lean.PersistentHashMap.instInhabitedEntry
code: instance {α β σ} : Inhabited (Entry α β σ) 
goal: Inhabited (Lean.PersistentHashMap.Entry α β σ)

full_name: Lean.PersistentHashMap.Node.collision
code: inductive Node (α : Type u) (β : Type v) : Type (max u v) where
  | entries   (es : Array (Entry α β (Node α β))) : Node α β
  | collision (ks : Array α) (vs : Array β) (h : ks.size = vs.size) : Node α β
goal: Lean.PersistentHashMap.Node α β

full_name: Lean.PersistentHashMap.Node.entries
code: inductive Node (α : Type u) (β : Type v) : Type (max u v) where
  | entries   (es : Array (Entry α β (Node α β))) : Node α β
  | collision (ks : Array α) (vs : Array β) (h : ks.size = vs.size) : Node α β
goal: Lean.PersistentHashMap.Node α β

full_name: Lean.PersistentHashMap.Node
code: inductive Node (α : Type u) (β : Type v) : Type (max u v) where
  | entries   (es : Array (Entry α β (Node α β))) : Node α β
  | collision (ks : Array α) (vs : Array β) (h : ks.size = vs.size) : Node α β
goal: Type (max u v)

full_name: Lean.PersistentHashMap.Node.isEmpty
code: partial def Node.isEmpty : Node α β → Bool
  
goal: Lean.PersistentHashMap.Node α β → Bool

full_name: Lean.PersistentHashMap.instInhabitedNode
code: instance {α β} : Inhabited (Node α β) 
goal: Inhabited (Lean.PersistentHashMap.Node α β)

full_name: Lean.PersistentHashMap.shift
code: abbrev shift         : USize  
goal: USize

full_name: Lean.PersistentHashMap.branching
code: abbrev branching     : USize  
goal: USize

full_name: Lean.PersistentHashMap.maxDepth
code: abbrev maxDepth      : USize  
goal: USize

full_name: Lean.PersistentHashMap.maxCollisions
code: abbrev maxCollisions : Nat    
goal: Nat

full_name: Lean.PersistentHashMap.mkEmptyEntriesArray
code: def mkEmptyEntriesArray {α β} : Array (Entry α β (Node α β)) 
goal: Array (Lean.PersistentHashMap.Entry α β (Lean.PersistentHashMap.Node α β))

full_name: Lean.PersistentHashMap.root
code: structure PersistentHashMap (α : Type u) (β : Type v) [BEq α] [Hashable α] where
  root : PersistentHashMap.Node α β := PersistentHashMap.Node.entries PersistentHashMap.mkEmptyEntriesArray
goal: Lean.PersistentHashMap.Node α β

full_name: Lean.PersistentHashMap
code: structure PersistentHashMap (α : Type u) (β : Type v) [BEq α] [Hashable α] where
  root : PersistentHashMap.Node α β := PersistentHashMap.Node.entries PersistentHashMap.mkEmptyEntriesArray
goal: Type (max u v)

full_name: Lean.PHashMap
code: abbrev PHashMap (α : Type u) (β : Type v) [BEq α] [Hashable α] 
goal: Type (max u v)

full_name: Lean.PersistentHashMap.empty
code: def empty [BEq α] [Hashable α] : PersistentHashMap α β 
goal: Lean.PersistentHashMap α β

full_name: Lean.PersistentHashMap.isEmpty
code: def isEmpty {_ : BEq α} {_ : Hashable α} : PersistentHashMap α β → Bool
  
goal: {x : BEq α} → {x_1 : Hashable α} → Lean.PersistentHashMap α β → Bool

full_name: Lean.PersistentHashMap.instInhabited
code: instance [BEq α] [Hashable α] : Inhabited (PersistentHashMap α β) 
goal: Inhabited (Lean.PersistentHashMap α β)

full_name: Lean.PersistentHashMap.mkEmptyEntries
code: def mkEmptyEntries {α β} : Node α β 
goal: Lean.PersistentHashMap.Node α β

full_name: Lean.PersistentHashMap.mul2Shift
code: abbrev mul2Shift (i : USize) (shift : USize) : USize 
goal: USize

full_name: Lean.PersistentHashMap.div2Shift
code: abbrev div2Shift (i : USize) (shift : USize) : USize 
goal: USize

full_name: Lean.PersistentHashMap.mod2Shift
code: abbrev mod2Shift (i : USize) (shift : USize) : USize 
goal: USize

full_name: Lean.PersistentHashMap.IsCollisionNode.mk
code: inductive IsCollisionNode : Node α β → Prop where
  | mk (keys : Array α) (vals : Array β) (h : keys.size = vals.size) : IsCollisionNode (Node.collision keys vals h)
goal: Lean.PersistentHashMap.IsCollisionNode (Lean.PersistentHashMap.Node.collision keys vals h)

full_name: Lean.PersistentHashMap.IsCollisionNode
code: inductive IsCollisionNode : Node α β → Prop where
  | mk (keys : Array α) (vals : Array β) (h : keys.size = vals.size) : IsCollisionNode (Node.collision keys vals h)
goal: Lean.PersistentHashMap.Node α β → Prop

full_name: Lean.PersistentHashMap.CollisionNode
code: abbrev CollisionNode (α β) 
goal: Type (max 0 u_2 u_1)

full_name: Lean.PersistentHashMap.IsEntriesNode
code: inductive IsEntriesNode : Node α β → Prop where
  | mk (entries : Array (Entry α β (Node α β))) : IsEntriesNode (Node.entries entries)
goal: Lean.PersistentHashMap.Node α β → Prop

full_name: Lean.PersistentHashMap.IsEntriesNode.mk
code: inductive IsEntriesNode : Node α β → Prop where
  | mk (entries : Array (Entry α β (Node α β))) : IsEntriesNode (Node.entries entries)
goal: Lean.PersistentHashMap.IsEntriesNode (Lean.PersistentHashMap.Node.entries entries)

full_name: Lean.PersistentHashMap.EntriesNode
code: abbrev EntriesNode (α β) 
goal: Type (max 0 u_2 u_1)

full_name: _private.«.lake».packages.lean4.src.lean.Lean.Data.PersistentHashMap.0.Lean.PersistentHashMap.size_set
code: private theorem size_set {ks : Array α} {vs : Array β} (h : ks.size = vs.size) (i : Fin ks.size) (j : Fin vs.size) (k : α) (v : β)
                           : (ks.set i k).size = (vs.set j v).size 
goal: (ks.set i k).size = (vs.set j v).size

full_name: _private.«.lake».packages.lean4.src.lean.Lean.Data.PersistentHashMap.0.Lean.PersistentHashMap.size_push
code: private theorem size_push {ks : Array α} {vs : Array β} (h : ks.size = vs.size) (k : α) (v : β) : (ks.push k).size = (vs.push v).size 
goal: (ks.push k).size = (vs.push v).size

full_name: Lean.PersistentHashMap.insertAtCollisionNodeAux
code: partial def insertAtCollisionNodeAux [BEq α] : CollisionNode α β → Nat → α → β → CollisionNode α β
  
goal: Lean.PersistentHashMap.CollisionNode α β → Nat → α → β → Lean.PersistentHashMap.CollisionNode α β

full_name: Lean.PersistentHashMap.insertAtCollisionNode
code: def insertAtCollisionNode [BEq α] : CollisionNode α β → α → β → CollisionNode α β 
goal: Lean.PersistentHashMap.CollisionNode α β → α → β → Lean.PersistentHashMap.CollisionNode α β

full_name: Lean.PersistentHashMap.getCollisionNodeSize
code: def getCollisionNodeSize : CollisionNode α β → Nat
  
goal: Lean.PersistentHashMap.CollisionNode α β → Nat

full_name: Lean.PersistentHashMap.mkCollisionNode
code: def mkCollisionNode (k₁ : α) (v₁ : β) (k₂ : α) (v₂ : β) : Node α β 
goal: Lean.PersistentHashMap.Node α β

full_name: Lean.PersistentHashMap.insertAux
code: partial def insertAux [BEq α] [Hashable α] : Node α β → USize → USize → α → β → Node α β
  
goal: Lean.PersistentHashMap.Node α β → USize → USize → α → β → Lean.PersistentHashMap.Node α β

full_name: Lean.PersistentHashMap.insertAux.traverse
code: partial def insertAux [BEq α] [Hashable α] : Node α β → USize → USize → α → β → Node α β
  
goal: Lean.PersistentHashMap.Node α β

full_name: Lean.PersistentHashMap.insert
code: def insert {_ : BEq α} {_ : Hashable α} : PersistentHashMap α β → α → β → PersistentHashMap α β
  
goal: {x : BEq α} → {x_1 : Hashable α} → Lean.PersistentHashMap α β → α → β → Lean.PersistentHashMap α β

full_name: Lean.PersistentHashMap.findAtAux
code: partial def findAtAux [BEq α] (keys : Array α) (vals : Array β) (heq : keys.size = vals.size) (i : Nat) (k : α) : Option β 
goal: Option β

full_name: Lean.PersistentHashMap.findAux
code: partial def findAux [BEq α] : Node α β → USize → α → Option β
  
goal: Lean.PersistentHashMap.Node α β → USize → α → Option β

full_name: Lean.PersistentHashMap.find?
code: def find? {_ : BEq α} {_ : Hashable α} : PersistentHashMap α β → α → Option β
  
goal: {x : BEq α} → {x_1 : Hashable α} → Lean.PersistentHashMap α β → α → Option β

full_name: Lean.PersistentHashMap.instGetElemOptionTrue
code: instance {_ : BEq α} {_ : Hashable α} : GetElem (PersistentHashMap α β) α (Option β) fun _ _ => True 
goal: {x : BEq α} → {x_1 : Hashable α} → GetElem (Lean.PersistentHashMap α β) α (Option β) fun x x => True

full_name: Lean.PersistentHashMap.findD
code: @[inline] def findD {_ : BEq α} {_ : Hashable α} (m : PersistentHashMap α β) (a : α) (b₀ : β) : β 
goal: {x : BEq α} → {x_1 : Hashable α} → Lean.PersistentHashMap α β → α → β → β

full_name: Lean.PersistentHashMap.find!
code: @[inline] def find! {_ : BEq α} {_ : Hashable α} [Inhabited β] (m : PersistentHashMap α β) (a : α) : β 
goal: {x : BEq α} → {x_1 : Hashable α} → [inst : Inhabited β] → Lean.PersistentHashMap α β → α → β

full_name: Lean.PersistentHashMap.findEntryAtAux
code: partial def findEntryAtAux [BEq α] (keys : Array α) (vals : Array β) (heq : keys.size = vals.size) (i : Nat) (k : α) : Option (α × β) 
goal: Option (α × β)

full_name: Lean.PersistentHashMap.findEntryAux
code: partial def findEntryAux [BEq α] : Node α β → USize → α → Option (α × β)
  
goal: Lean.PersistentHashMap.Node α β → USize → α → Option (α × β)

full_name: Lean.PersistentHashMap.findEntry?
code: def findEntry? {_ : BEq α} {_ : Hashable α} : PersistentHashMap α β → α → Option (α × β)
  
goal: {x : BEq α} → {x_1 : Hashable α} → Lean.PersistentHashMap α β → α → Option (α × β)

full_name: Lean.PersistentHashMap.containsAtAux
code: partial def containsAtAux [BEq α] (keys : Array α) (vals : Array β) (heq : keys.size = vals.size) (i : Nat) (k : α) : Bool 
goal: Bool

full_name: Lean.PersistentHashMap.containsAux
code: partial def containsAux [BEq α] : Node α β → USize → α → Bool
  
goal: Lean.PersistentHashMap.Node α β → USize → α → Bool

full_name: Lean.PersistentHashMap.contains
code: def contains [BEq α] [Hashable α] : PersistentHashMap α β → α → Bool
  
goal: Lean.PersistentHashMap α β → α → Bool

full_name: Lean.PersistentHashMap.isUnaryEntries
code: partial def isUnaryEntries (a : Array (Entry α β (Node α β))) (i : Nat) (acc : Option (α × β)) : Option (α × β) 
goal: Option (α × β)

full_name: Lean.PersistentHashMap.isUnaryNode
code: def isUnaryNode : Node α β → Option (α × β)
  
goal: Lean.PersistentHashMap.Node α β → Option (α × β)

full_name: Lean.PersistentHashMap.eraseAux
code: partial def eraseAux [BEq α] : Node α β → USize → α → Node α β
  
goal: Lean.PersistentHashMap.Node α β → USize → α → Lean.PersistentHashMap.Node α β

full_name: Lean.PersistentHashMap.erase
code: def erase {_ : BEq α} {_ : Hashable α} : PersistentHashMap α β → α → PersistentHashMap α β
  
goal: {x : BEq α} → {x_1 : Hashable α} → Lean.PersistentHashMap α β → α → Lean.PersistentHashMap α β

full_name: Lean.PersistentHashMap.foldlMAux.traverse
code: partial def foldlMAux (f : σ → α → β → m σ) : Node α β → σ → m σ
  
goal: m σ

full_name: Lean.PersistentHashMap.foldlMAux
code: partial def foldlMAux (f : σ → α → β → m σ) : Node α β → σ → m σ
  
goal: Lean.PersistentHashMap.Node α β → σ → m σ

full_name: Lean.PersistentHashMap.foldlM
code: def foldlM {_ : BEq α} {_ : Hashable α} (map : PersistentHashMap α β) (f : σ → α → β → m σ) (init : σ) : m σ 
goal: {x : BEq α} → {x_1 : Hashable α} → Lean.PersistentHashMap α β → (σ → α → β → m σ) → σ → m σ

full_name: Lean.PersistentHashMap.forM
code: def forM {_ : BEq α} {_ : Hashable α} (map : PersistentHashMap α β) (f : α → β → m PUnit) : m PUnit 
goal: {x : BEq α} → {x_1 : Hashable α} → Lean.PersistentHashMap α β → (α → β → m PUnit) → m PUnit

full_name: Lean.PersistentHashMap.foldl
code: def foldl {_ : BEq α} {_ : Hashable α} (map : PersistentHashMap α β) (f : σ → α → β → σ) (init : σ) : σ 
goal: {x : BEq α} → {x_1 : Hashable α} → Lean.PersistentHashMap α β → (σ → α → β → σ) → σ → σ

full_name: Lean.PersistentHashMap.forIn
code: protected def forIn {_ : BEq α} {_ : Hashable α} [Monad m]
    (map : PersistentHashMap α β) (init : σ) (f : α × β → σ → m (ForInStep σ)) : m σ 
goal: {x : BEq α} →
  {x_1 : Hashable α} → [inst : Monad m] → Lean.PersistentHashMap α β → σ → (α × β → σ → m (ForInStep σ)) → m σ

full_name: Lean.PersistentHashMap.instForInProd
code: instance {_ : BEq α} {_ : Hashable α} : ForIn m (PersistentHashMap α β) (α × β) 
goal: {x : BEq α} → {x_1 : Hashable α} → ForIn m (Lean.PersistentHashMap α β) (α × β)

full_name: Lean.PersistentHashMap.mapMAux
code: partial def mapMAux {α : Type u} {β : Type v} {σ : Type u} {m : Type u → Type w} [Monad m] (f : β → m σ) (n : Node α β) : m (Node α σ) 
goal: m (Lean.PersistentHashMap.Node α σ)

full_name: Lean.PersistentHashMap.mapM
code: def mapM {α : Type u} {β : Type v} {σ : Type u} {m : Type u → Type w} [Monad m] {_ : BEq α} {_ : Hashable α} (pm : PersistentHashMap α β) (f : β → m σ) : m (PersistentHashMap α σ) 
goal: {x : BEq α} → {x_1 : Hashable α} → Lean.PersistentHashMap α β → (β → m σ) → m (Lean.PersistentHashMap α σ)

full_name: Lean.PersistentHashMap.map
code: def map {α : Type u} {β : Type v} {σ : Type u} {_ : BEq α} {_ : Hashable α} (pm : PersistentHashMap α β) (f : β → σ) : PersistentHashMap α σ 
goal: {x : BEq α} → {x_1 : Hashable α} → Lean.PersistentHashMap α β → (β → σ) → Lean.PersistentHashMap α σ

full_name: Lean.PersistentHashMap.toList
code: def toList {_ : BEq α} {_ : Hashable α} (m : PersistentHashMap α β) : List (α × β) 
goal: {x : BEq α} → {x_1 : Hashable α} → Lean.PersistentHashMap α β → List (α × β)

full_name: Lean.PersistentHashMap.toArray
code: def toArray {_ : BEq α} {_ : Hashable α} (m : PersistentHashMap α β) : Array (α × β) 
goal: {x : BEq α} → {x_1 : Hashable α} → Lean.PersistentHashMap α β → Array (α × β)

full_name: Lean.PersistentHashMap.Stats
code: structure Stats where
  numNodes      : Nat := 0
  numNull       : Nat := 0
  numCollisions : Nat := 0
  maxDepth      : Nat := 0
goal: Type

full_name: Lean.PersistentHashMap.Stats.maxDepth
code: structure Stats where
  numNodes      : Nat := 0
  numNull       : Nat := 0
  numCollisions : Nat := 0
  maxDepth      : Nat := 0
goal: Nat

full_name: Lean.PersistentHashMap.Stats.numNodes
code: structure Stats where
  numNodes      : Nat := 0
  numNull       : Nat := 0
  numCollisions : Nat := 0
  maxDepth      : Nat := 0
goal: Nat

full_name: Lean.PersistentHashMap.Stats.numNull
code: structure Stats where
  numNodes      : Nat := 0
  numNull       : Nat := 0
  numCollisions : Nat := 0
  maxDepth      : Nat := 0
goal: Nat

full_name: Lean.PersistentHashMap.Stats.numCollisions
code: structure Stats where
  numNodes      : Nat := 0
  numNull       : Nat := 0
  numCollisions : Nat := 0
  maxDepth      : Nat := 0
goal: Nat

full_name: Lean.PersistentHashMap.collectStats
code: partial def collectStats : Node α β → Stats → Nat → Stats
  
goal: Lean.PersistentHashMap.Node α β → Lean.PersistentHashMap.Stats → Nat → Lean.PersistentHashMap.Stats

full_name: Lean.PersistentHashMap.stats
code: def stats {_ : BEq α} {_ : Hashable α} (m : PersistentHashMap α β) : Stats 
goal: {x : BEq α} → {x_1 : Hashable α} → Lean.PersistentHashMap α β → Lean.PersistentHashMap.Stats

full_name: Lean.PersistentHashMap.Stats.toString
code: def Stats.toString (s : Stats) : String 
goal: String

full_name: Lean.PersistentHashMap.instToStringStats
code: instance : ToString Stats 
goal: ToString Lean.PersistentHashMap.Stats