File: .lake/packages/lean4/src/lean/Lean/Level.lean

full_name: Nat.imax
code: def Nat.imax (n m : Nat) : Nat 
goal: Nat

full_name: Lean.Level.Data
code: /--
 Cached hash code, cached results, and other data for `Level`.
   hash      : 32-bits
   hasMVar   : 1-bit
   hasParam  : 1-bit
   depth     : 24-bits -/
def Level.Data 
goal: Type

full_name: Lean.instInhabitedData
code: instance : Inhabited Level.Data 
goal: Inhabited Lean.Level.Data

full_name: Lean.Level.Data.hash
code: def Level.Data.hash (c : Level.Data) : UInt64 
goal: UInt64

full_name: Lean.instBEqData
code: instance : BEq Level.Data 
goal: BEq Lean.Level.Data

full_name: Lean.Level.Data.depth
code: def Level.Data.depth (c : Level.Data) : UInt32 
goal: UInt32

full_name: Lean.Level.Data.hasMVar
code: def Level.Data.hasMVar (c : Level.Data) : Bool 
goal: Bool

full_name: Lean.Level.Data.hasParam
code: def Level.Data.hasParam (c : Level.Data) : Bool 
goal: Bool

full_name: Lean.Level.mkData
code: def Level.mkData (h : UInt64) (depth : Nat := 0) (hasMVar hasParam : Bool := false) : Level.Data 
goal: Lean.Level.Data

full_name: Lean.instReprData
code: instance : Repr Level.Data 
goal: Repr Lean.Level.Data

full_name: Lean.instHashableLevelMVarId
code: /-- Universe level metavariable Id   -/
structure LevelMVarId where
  name : Name
  deriving Inhabited, BEq, Hashable, Repr
goal: Hashable Lean.LevelMVarId

full_name: Lean.LevelMVarId
code: /-- Universe level metavariable Id   -/
structure LevelMVarId where
  name : Name
  deriving Inhabited, BEq, Hashable, Repr
goal: Type

full_name: Lean.instBEqLevelMVarId
code: /-- Universe level metavariable Id   -/
structure LevelMVarId where
  name : Name
  deriving Inhabited, BEq, Hashable, Repr
goal: BEq Lean.LevelMVarId

full_name: Lean.instReprLevelMVarId
code: /-- Universe level metavariable Id   -/
structure LevelMVarId where
  name : Name
  deriving Inhabited, BEq, Hashable, Repr
goal: Repr Lean.LevelMVarId

full_name: Lean.LevelMVarId.name
code: /-- Universe level metavariable Id   -/
structure LevelMVarId where
  name : Name
  deriving Inhabited, BEq, Hashable, Repr
goal: Lean.Name

full_name: Lean.instInhabitedLevelMVarId
code: /-- Universe level metavariable Id   -/
structure LevelMVarId where
  name : Name
  deriving Inhabited, BEq, Hashable, Repr
goal: Inhabited Lean.LevelMVarId

full_name: Lean.LMVarId
code: /-- Short for `LevelMVarId` -/
abbrev LMVarId 
goal: Type

full_name: Lean.instReprLMVarId
code: instance : Repr LMVarId 
goal: Repr Lean.LMVarId

full_name: Lean.LMVarIdSet
code: def LMVarIdSet 
goal: Type

full_name: Lean.instForInLMVarIdSetLMVarId
code: instance : ForIn m LMVarIdSet LMVarId 
goal: ForIn m Lean.LMVarIdSet Lean.LMVarId

full_name: Lean.LMVarIdMap
code: def LMVarIdMap (α : Type) 
goal: Type

full_name: Lean.instEmptyCollectionLMVarIdMap
code: instance : EmptyCollection (LMVarIdMap α) 
goal: EmptyCollection (Lean.LMVarIdMap α)

full_name: Lean.instForInLMVarIdMapProdLMVarId
code: instance : ForIn m (LMVarIdMap α) (LMVarId × α) 
goal: ForIn m (Lean.LMVarIdMap α) (Lean.LMVarId × α)

full_name: Lean.instInhabitedLMVarIdMap
code: instance : Inhabited (LMVarIdMap α) 
goal: Inhabited (Lean.LMVarIdMap α)

full_name: Lean.Level.max
code: inductive Level where
  | zero   : Level
  | succ   : Level → Level
  | max    : Level → Level → Level
  | imax   : Level → Level → Level
  | param  : Name → Level
  | mvar   : LMVarId → Level
with
  @[computed_field] data : Level → Data
    | .zero => mkData 2221 0 false false
    | .mvar mvarId => mkData (mixHash 2237 <| hash mvarId) 0 true false
    | .param name => mkData (mixHash 2239 <| hash name) 0 false true
    | .succ u => mkData (mixHash 2243 <| u.data.hash) (u.data.depth.toNat + 1) u.data.hasMVar u.data.hasParam
    | .max u v => mkData (mixHash 2251 <| mixHash (u.data.hash) (v.data.hash)) (Nat.max u.data.depth.toNat v.data.depth.toNat + 1)
       (u.data.hasMVar || v.data.hasMVar) (u.data.hasParam || v.data.hasParam)
    | .imax u v => mkData (mixHash 2267 <| mixHash (u.data.hash) (v.data.hash)) (Nat.max u.data.depth.toNat v.data.depth.toNat + 1)
       (u.data.hasMVar || v.data.hasMVar) (u.data.hasParam || v.data.hasParam)

deriving Inhabited, Repr
goal: Lean.Level → Lean.Level → Lean.Level

full_name: Lean.Level.imax
code: inductive Level where
  | zero   : Level
  | succ   : Level → Level
  | max    : Level → Level → Level
  | imax   : Level → Level → Level
  | param  : Name → Level
  | mvar   : LMVarId → Level
with
  @[computed_field] data : Level → Data
    | .zero => mkData 2221 0 false false
    | .mvar mvarId => mkData (mixHash 2237 <| hash mvarId) 0 true false
    | .param name => mkData (mixHash 2239 <| hash name) 0 false true
    | .succ u => mkData (mixHash 2243 <| u.data.hash) (u.data.depth.toNat + 1) u.data.hasMVar u.data.hasParam
    | .max u v => mkData (mixHash 2251 <| mixHash (u.data.hash) (v.data.hash)) (Nat.max u.data.depth.toNat v.data.depth.toNat + 1)
       (u.data.hasMVar || v.data.hasMVar) (u.data.hasParam || v.data.hasParam)
    | .imax u v => mkData (mixHash 2267 <| mixHash (u.data.hash) (v.data.hash)) (Nat.max u.data.depth.toNat v.data.depth.toNat + 1)
       (u.data.hasMVar || v.data.hasMVar) (u.data.hasParam || v.data.hasParam)

deriving Inhabited, Repr
goal: Lean.Level → Lean.Level → Lean.Level

full_name: Lean.Level
code: inductive Level where
  | zero   : Level
  | succ   : Level → Level
  | max    : Level → Level → Level
  | imax   : Level → Level → Level
  | param  : Name → Level
  | mvar   : LMVarId → Level
with
  @[computed_field] data : Level → Data
    | .zero => mkData 2221 0 false false
    | .mvar mvarId => mkData (mixHash 2237 <| hash mvarId) 0 true false
    | .param name => mkData (mixHash 2239 <| hash name) 0 false true
    | .succ u => mkData (mixHash 2243 <| u.data.hash) (u.data.depth.toNat + 1) u.data.hasMVar u.data.hasParam
    | .max u v => mkData (mixHash 2251 <| mixHash (u.data.hash) (v.data.hash)) (Nat.max u.data.depth.toNat v.data.depth.toNat + 1)
       (u.data.hasMVar || v.data.hasMVar) (u.data.hasParam || v.data.hasParam)
    | .imax u v => mkData (mixHash 2267 <| mixHash (u.data.hash) (v.data.hash)) (Nat.max u.data.depth.toNat v.data.depth.toNat + 1)
       (u.data.hasMVar || v.data.hasMVar) (u.data.hasParam || v.data.hasParam)

deriving Inhabited, Repr
goal: Type

full_name: Lean.Level.zero
code: inductive Level where
  | zero   : Level
  | succ   : Level → Level
  | max    : Level → Level → Level
  | imax   : Level → Level → Level
  | param  : Name → Level
  | mvar   : LMVarId → Level
with
  @[computed_field] data : Level → Data
    | .zero => mkData 2221 0 false false
    | .mvar mvarId => mkData (mixHash 2237 <| hash mvarId) 0 true false
    | .param name => mkData (mixHash 2239 <| hash name) 0 false true
    | .succ u => mkData (mixHash 2243 <| u.data.hash) (u.data.depth.toNat + 1) u.data.hasMVar u.data.hasParam
    | .max u v => mkData (mixHash 2251 <| mixHash (u.data.hash) (v.data.hash)) (Nat.max u.data.depth.toNat v.data.depth.toNat + 1)
       (u.data.hasMVar || v.data.hasMVar) (u.data.hasParam || v.data.hasParam)
    | .imax u v => mkData (mixHash 2267 <| mixHash (u.data.hash) (v.data.hash)) (Nat.max u.data.depth.toNat v.data.depth.toNat + 1)
       (u.data.hasMVar || v.data.hasMVar) (u.data.hasParam || v.data.hasParam)

deriving Inhabited, Repr
goal: Lean.Level

full_name: Lean.Level.succ
code: inductive Level where
  | zero   : Level
  | succ   : Level → Level
  | max    : Level → Level → Level
  | imax   : Level → Level → Level
  | param  : Name → Level
  | mvar   : LMVarId → Level
with
  @[computed_field] data : Level → Data
    | .zero => mkData 2221 0 false false
    | .mvar mvarId => mkData (mixHash 2237 <| hash mvarId) 0 true false
    | .param name => mkData (mixHash 2239 <| hash name) 0 false true
    | .succ u => mkData (mixHash 2243 <| u.data.hash) (u.data.depth.toNat + 1) u.data.hasMVar u.data.hasParam
    | .max u v => mkData (mixHash 2251 <| mixHash (u.data.hash) (v.data.hash)) (Nat.max u.data.depth.toNat v.data.depth.toNat + 1)
       (u.data.hasMVar || v.data.hasMVar) (u.data.hasParam || v.data.hasParam)
    | .imax u v => mkData (mixHash 2267 <| mixHash (u.data.hash) (v.data.hash)) (Nat.max u.data.depth.toNat v.data.depth.toNat + 1)
       (u.data.hasMVar || v.data.hasMVar) (u.data.hasParam || v.data.hasParam)

deriving Inhabited, Repr
goal: Lean.Level → Lean.Level

full_name: Lean.instReprLevel
code: inductive Level where
  | zero   : Level
  | succ   : Level → Level
  | max    : Level → Level → Level
  | imax   : Level → Level → Level
  | param  : Name → Level
  | mvar   : LMVarId → Level
with
  @[computed_field] data : Level → Data
    | .zero => mkData 2221 0 false false
    | .mvar mvarId => mkData (mixHash 2237 <| hash mvarId) 0 true false
    | .param name => mkData (mixHash 2239 <| hash name) 0 false true
    | .succ u => mkData (mixHash 2243 <| u.data.hash) (u.data.depth.toNat + 1) u.data.hasMVar u.data.hasParam
    | .max u v => mkData (mixHash 2251 <| mixHash (u.data.hash) (v.data.hash)) (Nat.max u.data.depth.toNat v.data.depth.toNat + 1)
       (u.data.hasMVar || v.data.hasMVar) (u.data.hasParam || v.data.hasParam)
    | .imax u v => mkData (mixHash 2267 <| mixHash (u.data.hash) (v.data.hash)) (Nat.max u.data.depth.toNat v.data.depth.toNat + 1)
       (u.data.hasMVar || v.data.hasMVar) (u.data.hasParam || v.data.hasParam)

deriving Inhabited, Repr
goal: Repr Lean.Level

full_name: Lean.Level.mvar
code: inductive Level where
  | zero   : Level
  | succ   : Level → Level
  | max    : Level → Level → Level
  | imax   : Level → Level → Level
  | param  : Name → Level
  | mvar   : LMVarId → Level
with
  @[computed_field] data : Level → Data
    | .zero => mkData 2221 0 false false
    | .mvar mvarId => mkData (mixHash 2237 <| hash mvarId) 0 true false
    | .param name => mkData (mixHash 2239 <| hash name) 0 false true
    | .succ u => mkData (mixHash 2243 <| u.data.hash) (u.data.depth.toNat + 1) u.data.hasMVar u.data.hasParam
    | .max u v => mkData (mixHash 2251 <| mixHash (u.data.hash) (v.data.hash)) (Nat.max u.data.depth.toNat v.data.depth.toNat + 1)
       (u.data.hasMVar || v.data.hasMVar) (u.data.hasParam || v.data.hasParam)
    | .imax u v => mkData (mixHash 2267 <| mixHash (u.data.hash) (v.data.hash)) (Nat.max u.data.depth.toNat v.data.depth.toNat + 1)
       (u.data.hasMVar || v.data.hasMVar) (u.data.hasParam || v.data.hasParam)

deriving Inhabited, Repr
goal: Lean.LMVarId → Lean.Level

full_name: Lean.Level.param
code: inductive Level where
  | zero   : Level
  | succ   : Level → Level
  | max    : Level → Level → Level
  | imax   : Level → Level → Level
  | param  : Name → Level
  | mvar   : LMVarId → Level
with
  @[computed_field] data : Level → Data
    | .zero => mkData 2221 0 false false
    | .mvar mvarId => mkData (mixHash 2237 <| hash mvarId) 0 true false
    | .param name => mkData (mixHash 2239 <| hash name) 0 false true
    | .succ u => mkData (mixHash 2243 <| u.data.hash) (u.data.depth.toNat + 1) u.data.hasMVar u.data.hasParam
    | .max u v => mkData (mixHash 2251 <| mixHash (u.data.hash) (v.data.hash)) (Nat.max u.data.depth.toNat v.data.depth.toNat + 1)
       (u.data.hasMVar || v.data.hasMVar) (u.data.hasParam || v.data.hasParam)
    | .imax u v => mkData (mixHash 2267 <| mixHash (u.data.hash) (v.data.hash)) (Nat.max u.data.depth.toNat v.data.depth.toNat + 1)
       (u.data.hasMVar || v.data.hasMVar) (u.data.hasParam || v.data.hasParam)

deriving Inhabited, Repr
goal: Lean.Name → Lean.Level

full_name: Lean.instInhabitedLevel
code: inductive Level where
  | zero   : Level
  | succ   : Level → Level
  | max    : Level → Level → Level
  | imax   : Level → Level → Level
  | param  : Name → Level
  | mvar   : LMVarId → Level
with
  @[computed_field] data : Level → Data
    | .zero => mkData 2221 0 false false
    | .mvar mvarId => mkData (mixHash 2237 <| hash mvarId) 0 true false
    | .param name => mkData (mixHash 2239 <| hash name) 0 false true
    | .succ u => mkData (mixHash 2243 <| u.data.hash) (u.data.depth.toNat + 1) u.data.hasMVar u.data.hasParam
    | .max u v => mkData (mixHash 2251 <| mixHash (u.data.hash) (v.data.hash)) (Nat.max u.data.depth.toNat v.data.depth.toNat + 1)
       (u.data.hasMVar || v.data.hasMVar) (u.data.hasParam || v.data.hasParam)
    | .imax u v => mkData (mixHash 2267 <| mixHash (u.data.hash) (v.data.hash)) (Nat.max u.data.depth.toNat v.data.depth.toNat + 1)
       (u.data.hasMVar || v.data.hasMVar) (u.data.hasParam || v.data.hasParam)

deriving Inhabited, Repr
goal: Inhabited Lean.Level

full_name: Lean.Level.hash
code: protected def hash (u : Level) : UInt64 
goal: UInt64

full_name: Lean.Level.instHashable
code: instance : Hashable Level 
goal: Hashable Lean.Level

full_name: Lean.Level.depth
code: def depth (u : Level) : Nat 
goal: Nat

full_name: Lean.Level.hasMVar
code: def hasMVar (u : Level) : Bool 
goal: Bool

full_name: Lean.Level.hasParam
code: def hasParam (u : Level) : Bool 
goal: Bool

full_name: Lean.Level.hashEx
code: @[export lean_level_hash] def hashEx (u : Level) : UInt32 
goal: UInt32

full_name: Lean.Level.hasMVarEx
code: @[export lean_level_has_mvar] def hasMVarEx : Level → Bool 
goal: Lean.Level → Bool

full_name: Lean.Level.hasParamEx
code: @[export lean_level_has_param] def hasParamEx : Level → Bool 
goal: Lean.Level → Bool

full_name: Lean.Level.depthEx
code: @[export lean_level_depth] def depthEx (u : Level) : UInt32 
goal: UInt32

full_name: Lean.levelZero
code: def levelZero 
goal: Lean.Level

full_name: Lean.mkLevelMVar
code: def mkLevelMVar (mvarId : LMVarId) 
goal: Lean.Level

full_name: Lean.mkLevelParam
code: def mkLevelParam (name : Name) 
goal: Lean.Level

full_name: Lean.mkLevelSucc
code: def mkLevelSucc (u : Level) 
goal: Lean.Level

full_name: Lean.mkLevelMax
code: def mkLevelMax (u v : Level) 
goal: Lean.Level

full_name: Lean.mkLevelIMax
code: def mkLevelIMax (u v : Level) 
goal: Lean.Level

full_name: Lean.levelOne
code: def levelOne 
goal: Lean.Level

full_name: Lean.mkLevelZeroEx
code: @[export lean_level_mk_zero] def mkLevelZeroEx : Unit → Level 
goal: Unit → Lean.Level

full_name: Lean.mkLevelSuccEx
code: @[export lean_level_mk_succ] def mkLevelSuccEx : Level → Level 
goal: Lean.Level → Lean.Level

full_name: Lean.mkLevelMVarEx
code: @[export lean_level_mk_mvar] def mkLevelMVarEx : LMVarId → Level 
goal: Lean.LMVarId → Lean.Level

full_name: Lean.mkLevelParamEx
code: @[export lean_level_mk_param] def mkLevelParamEx : Name → Level 
goal: Lean.Name → Lean.Level

full_name: Lean.mkLevelMaxEx
code: @[export lean_level_mk_max] def mkLevelMaxEx : Level → Level → Level 
goal: Lean.Level → Lean.Level → Lean.Level

full_name: Lean.mkLevelIMaxEx
code: @[export lean_level_mk_imax] def mkLevelIMaxEx : Level → Level → Level 
goal: Lean.Level → Lean.Level → Lean.Level

full_name: Lean.Level.isZero
code: def isZero : Level → Bool
  
goal: Lean.Level → Bool

full_name: Lean.Level.isSucc
code: def isSucc : Level → Bool
  
goal: Lean.Level → Bool

full_name: Lean.Level.isMax
code: def isMax : Level → Bool
  
goal: Lean.Level → Bool

full_name: Lean.Level.isIMax
code: def isIMax : Level → Bool
  
goal: Lean.Level → Bool

full_name: Lean.Level.isMaxIMax
code: def isMaxIMax : Level → Bool
  
goal: Lean.Level → Bool

full_name: Lean.Level.isParam
code: def isParam : Level → Bool
  
goal: Lean.Level → Bool

full_name: Lean.Level.isMVar
code: def isMVar : Level → Bool
  
goal: Lean.Level → Bool

full_name: Lean.Level.mvarId!
code: def mvarId! : Level → LMVarId
  
goal: Lean.Level → Lean.LMVarId

full_name: Lean.Level.isNeverZero
code: /-- If result is true, then forall assignments `A` which assigns all parameters and metavariables occurring
    in `l`, `l[A] != zero` -/
def isNeverZero : Level → Bool
  
goal: Lean.Level → Bool

full_name: Lean.Level.ofNat
code: def ofNat : Nat → Level
  
goal: Nat → Lean.Level

full_name: Lean.Level.instOfNat
code: instance instOfNat (n : Nat) : OfNat Level n 
goal: OfNat Lean.Level n

full_name: Lean.Level.addOffsetAux
code: def addOffsetAux : Nat → Level → Level
  
goal: Nat → Lean.Level → Lean.Level

full_name: Lean.Level.addOffset
code: def addOffset (u : Level) (n : Nat) : Level 
goal: Lean.Level

full_name: Lean.Level.isExplicit
code: def isExplicit : Level → Bool
  
goal: Lean.Level → Bool

full_name: Lean.Level.getOffsetAux
code: def getOffsetAux : Level → Nat → Nat
  
goal: Lean.Level → Nat → Nat

full_name: Lean.Level.getOffset
code: def getOffset (lvl : Level) : Nat 
goal: Nat

full_name: Lean.Level.getLevelOffset
code: def getLevelOffset : Level → Level
  
goal: Lean.Level → Lean.Level

full_name: Lean.Level.toNat
code: def toNat (lvl : Level) : Option Nat 
goal: Option Nat

full_name: Lean.Level.beq
code: @[extern "lean_level_eq"]
protected opaque beq (a : @& Level) (b : @& Level) : Bool
goal: Bool

full_name: Lean.Level.instBEq
code: instance : BEq Level 
goal: BEq Lean.Level

full_name: Lean.Level.occurs
code: /-- `occurs u l` return `true` iff `u` occurs in `l`. -/
def occurs : Level → Level → Bool
  
goal: Lean.Level → Lean.Level → Bool

full_name: Lean.Level.ctorToNat
code: def ctorToNat : Level → Nat
  
goal: Lean.Level → Nat

full_name: Lean.Level.normLtAux
code: def normLtAux : Level → Nat → Level → Nat → Bool
  
goal: Lean.Level → Nat → Lean.Level → Nat → Bool

full_name: Lean.Level.normLt
code: /--
  A total order on level expressions that has the following properties
  - `succ l` is an immediate successor of `l`.
  - `zero` is the minimal element.
 This total order is used in the normalization procedure. -/
def normLt (l₁ l₂ : Level) : Bool 
goal: Bool

full_name: _private.«.lake».packages.lean4.src.lean.Lean.Level.0.Lean.Level.isAlreadyNormalizedCheap
code: private def isAlreadyNormalizedCheap : Level → Bool
  
goal: Lean.Level → Bool

full_name: _private.«.lake».packages.lean4.src.lean.Lean.Level.0.Lean.Level.mkIMaxAux
code: private def mkIMaxAux : Level → Level → Level
  
goal: Lean.Level → Lean.Level → Lean.Level

full_name: _private.«.lake».packages.lean4.src.lean.Lean.Level.0.Lean.Level.getMaxArgsAux
code: @[specialize] private partial def getMaxArgsAux (normalize : Level → Level) : Level → Bool → Array Level → Array Level
  
goal: Lean.Level → Bool → Array Lean.Level → Array Lean.Level

full_name: _private.«.lake».packages.lean4.src.lean.Lean.Level.0.Lean.Level.accMax
code: private def accMax (result : Level) (prev : Level) (offset : Nat) : Level 
goal: Lean.Level

full_name: _private.«.lake».packages.lean4.src.lean.Lean.Level.0.Lean.Level.mkMaxAux
code: private partial def mkMaxAux (lvls : Array Level) (extraK : Nat) (i : Nat) (prev : Level) (prevK : Nat) (result : Level) : Level 
goal: Lean.Level

full_name: _private.«.lake».packages.lean4.src.lean.Lean.Level.0.Lean.Level.skipExplicit
code: private partial def skipExplicit (lvls : Array Level) (i : Nat) : Nat 
goal: Nat

full_name: _private.«.lake».packages.lean4.src.lean.Lean.Level.0.Lean.Level.isExplicitSubsumedAux
code: /--
Auxiliary function for `normalize`.
`maxExplicit` is the maximum explicit universe level at `lvls`.
Return true if it finds a level with offset ≥ maxExplicit.
`i` starts at the first non explicit level.
It assumes `lvls` has been sorted using `normLt`.
-/
private partial def isExplicitSubsumedAux (lvls : Array Level) (maxExplicit : Nat) (i : Nat) : Bool 
goal: Bool

full_name: _private.«.lake».packages.lean4.src.lean.Lean.Level.0.Lean.Level.isExplicitSubsumed
code: private def isExplicitSubsumed (lvls : Array Level) (firstNonExplicit : Nat) : Bool 
goal: Bool

full_name: Lean.Level.normalize
code: partial def normalize (l : Level) : Level 
goal: Lean.Level

full_name: Lean.Level.isEquiv
code: /--
Return true if `u` and `v` denote the same level.
Check is currently incomplete.
-/
def isEquiv (u v : Level) : Bool 
goal: Bool

full_name: Lean.Level.dec
code: /-- Reduce (if possible) universe level by 1 -/
def dec : Level → Option Level
  
goal: Lean.Level → Option Lean.Level

full_name: Lean.Level.PP.Result.offset
code: inductive Result where
  | leaf      : Name → Result
  | num       : Nat → Result
  | offset    : Result → Nat → Result
  | maxNode   : List Result → Result
  | imaxNode  : List Result → Result
goal: Lean.Level.PP.Result → Nat → Lean.Level.PP.Result

full_name: Lean.Level.PP.Result.imaxNode
code: inductive Result where
  | leaf      : Name → Result
  | num       : Nat → Result
  | offset    : Result → Nat → Result
  | maxNode   : List Result → Result
  | imaxNode  : List Result → Result
goal: List Lean.Level.PP.Result → Lean.Level.PP.Result

full_name: Lean.Level.PP.Result.num
code: inductive Result where
  | leaf      : Name → Result
  | num       : Nat → Result
  | offset    : Result → Nat → Result
  | maxNode   : List Result → Result
  | imaxNode  : List Result → Result
goal: Nat → Lean.Level.PP.Result

full_name: Lean.Level.PP.Result
code: inductive Result where
  | leaf      : Name → Result
  | num       : Nat → Result
  | offset    : Result → Nat → Result
  | maxNode   : List Result → Result
  | imaxNode  : List Result → Result
goal: Type

full_name: Lean.Level.PP.Result.leaf
code: inductive Result where
  | leaf      : Name → Result
  | num       : Nat → Result
  | offset    : Result → Nat → Result
  | maxNode   : List Result → Result
  | imaxNode  : List Result → Result
goal: Lean.Name → Lean.Level.PP.Result

full_name: Lean.Level.PP.Result.maxNode
code: inductive Result where
  | leaf      : Name → Result
  | num       : Nat → Result
  | offset    : Result → Nat → Result
  | maxNode   : List Result → Result
  | imaxNode  : List Result → Result
goal: List Lean.Level.PP.Result → Lean.Level.PP.Result

full_name: Lean.Level.PP.Result.succ
code: def Result.succ : Result → Result
  
goal: Lean.Level.PP.Result → Lean.Level.PP.Result

full_name: Lean.Level.PP.Result.max
code: def Result.max : Result → Result → Result
  
goal: Lean.Level.PP.Result → Lean.Level.PP.Result → Lean.Level.PP.Result

full_name: Lean.Level.PP.Result.imax
code: def Result.imax : Result → Result → Result
  
goal: Lean.Level.PP.Result → Lean.Level.PP.Result → Lean.Level.PP.Result

full_name: Lean.Level.PP.toResult
code: def toResult (l : Level) (mvars : Bool) : Result 
goal: Lean.Level.PP.Result

full_name: _private.«.lake».packages.lean4.src.lean.Lean.Level.0.Lean.Level.PP.parenIfFalse
code: private def parenIfFalse : Format → Bool → Format
  
goal: Lean.Format → Bool → Lean.Format

full_name: Lean.Level.PP.Result.quote
code: protected partial def Result.quote (r : Result) (prec : Nat) : Syntax.Level 
goal: Lean.Syntax.Level

full_name: Lean.Level.format
code: protected def format (u : Level) (mvars : Bool) : Format 
goal: Lean.Format

full_name: Lean.Level.instToFormat
code: instance : ToFormat Level 
goal: Lean.ToFormat Lean.Level

full_name: Lean.Level.instToString
code: instance : ToString Level 
goal: ToString Lean.Level

full_name: Lean.Level.quote
code: protected def quote (u : Level) (prec : Nat := 0) (mvars : Bool := true) : Syntax.Level 
goal: Lean.Syntax.Level

full_name: Lean.Level.instQuoteMkStr1
code: instance : Quote Level `level 
goal: Lean.Quote Lean.Level `level

full_name: _private.«.lake».packages.lean4.src.lean.Lean.Level.0.Lean.mkLevelMaxCore
code: @[inline] private def mkLevelMaxCore (u v : Level) (elseK : Unit → Level) : Level 
goal: Lean.Level

full_name: Lean.mkLevelMax'
code: def mkLevelMax' (u v : Level) : Level 
goal: Lean.Level

full_name: Lean.simpLevelMax'
code: def simpLevelMax' (u v : Level) (d : Level) : Level 
goal: Lean.Level

full_name: _private.«.lake».packages.lean4.src.lean.Lean.Level.0.Lean.mkLevelIMaxCore
code: @[inline] private def mkLevelIMaxCore (u v : Level) (elseK : Unit → Level) : Level 
goal: Lean.Level

full_name: Lean.mkLevelIMax'
code: def mkLevelIMax' (u v : Level) : Level 
goal: Lean.Level

full_name: Lean.simpLevelIMax'
code: def simpLevelIMax' (u v : Level) (d : Level) 
goal: Lean.Level

full_name: _private.«.lake».packages.lean4.src.lean.Lean.Level.0.Lean.Level.updateSucc!Impl
code: @[inline] private unsafe def updateSucc!Impl (lvl : Level) (newLvl : Level) : Level 
goal: Lean.Level

full_name: Lean.Level.updateSucc!
code: @[implemented_by updateSucc!Impl]
def updateSucc! (lvl : Level) (newLvl : Level) : Level 
goal: Lean.Level

full_name: _private.«.lake».packages.lean4.src.lean.Lean.Level.0.Lean.Level.updateMax!Impl
code: @[inline] private unsafe def updateMax!Impl (lvl : Level) (newLhs : Level) (newRhs : Level) : Level 
goal: Lean.Level

full_name: Lean.Level.updateMax!
code: @[implemented_by updateMax!Impl]
def updateMax! (lvl : Level) (newLhs : Level) (newRhs : Level) : Level 
goal: Lean.Level

full_name: _private.«.lake».packages.lean4.src.lean.Lean.Level.0.Lean.Level.updateIMax!Impl
code: @[inline] private unsafe def updateIMax!Impl (lvl : Level) (newLhs : Level) (newRhs : Level) : Level 
goal: Lean.Level

full_name: Lean.Level.updateIMax!
code: @[implemented_by updateIMax!Impl]
def updateIMax! (lvl : Level) (newLhs : Level) (newRhs : Level) : Level 
goal: Lean.Level

full_name: Lean.Level.mkNaryMax
code: def mkNaryMax : List Level → Level
  
goal: List Lean.Level → Lean.Level

full_name: Lean.Level.substParams.go
code: @[specialize] def substParams (u : Level) (s : Name → Option Level) : Level 
goal: Lean.Level

full_name: Lean.Level.substParams
code: @[specialize] def substParams (u : Level) (s : Name → Option Level) : Level 
goal: Lean.Level

full_name: Lean.Level.getParamSubst
code: def getParamSubst : List Name → List Level → Name → Option Level
  
goal: List Lean.Name → List Lean.Level → Lean.Name → Option Lean.Level

full_name: Lean.Level.instantiateParams
code: def instantiateParams (u : Level) (paramNames : List Name) (vs : List Level) : Level 
goal: Lean.Level

full_name: Lean.Level.geq.go
code: def geq (u v : Level) : Bool 
goal: Bool

full_name: Lean.Level.geq
code: def geq (u v : Level) : Bool 
goal: Bool

full_name: Lean.LevelMap
code: abbrev LevelMap (α : Type)  
goal: Type

full_name: Lean.PersistentLevelMap
code: abbrev PersistentLevelMap (α : Type) 
goal: Type

full_name: Lean.LevelSet
code: abbrev LevelSet 
goal: Type

full_name: Lean.PersistentLevelSet
code: abbrev PersistentLevelSet 
goal: Type

full_name: Lean.PLevelSet
code: abbrev PLevelSet 
goal: Type

full_name: Lean.Level.collectMVars
code: def Level.collectMVars (u : Level) (s : LMVarIdSet := {}) : LMVarIdSet 
goal: Lean.LMVarIdSet

full_name: Lean.Level.find?.visit
code: def Level.find? (u : Level) (p : Level → Bool) : Option Level 
goal: Option Lean.Level

full_name: Lean.Level.find?
code: def Level.find? (u : Level) (p : Level → Bool) : Option Level 
goal: Option Lean.Level

full_name: Lean.Level.any
code: def Level.any (u : Level) (p : Level → Bool) : Bool 
goal: Bool

full_name: Nat.toLevel
code: abbrev Nat.toLevel (n : Nat) : Lean.Level 
goal: Lean.Level