File: .lake/packages/lean4/src/lean/Init/Data/UInt/Basic.lean

full_name: UInt8.ofNat
code: @[extern "lean_uint8_of_nat"]
def UInt8.ofNat (n : @& Nat) : UInt8 
goal: UInt8

full_name: Nat.toUInt8
code: abbrev Nat.toUInt8 
goal: UInt8

full_name: UInt8.toNat
code: @[extern "lean_uint8_to_nat"]
def UInt8.toNat (n : UInt8) : Nat 
goal: Nat

full_name: UInt8.add
code: @[extern "lean_uint8_add"]
def UInt8.add (a b : UInt8) : UInt8 
goal: UInt8

full_name: UInt8.sub
code: @[extern "lean_uint8_sub"]
def UInt8.sub (a b : UInt8) : UInt8 
goal: UInt8

full_name: UInt8.mul
code: @[extern "lean_uint8_mul"]
def UInt8.mul (a b : UInt8) : UInt8 
goal: UInt8

full_name: UInt8.div
code: @[extern "lean_uint8_div"]
def UInt8.div (a b : UInt8) : UInt8 
goal: UInt8

full_name: UInt8.mod
code: @[extern "lean_uint8_mod"]
def UInt8.mod (a b : UInt8) : UInt8 
goal: UInt8

full_name: UInt8.modn
code: @[extern "lean_uint8_modn"]
def UInt8.modn (a : UInt8) (n : @& Nat) : UInt8 
goal: UInt8

full_name: UInt8.land
code: @[extern "lean_uint8_land"]
def UInt8.land (a b : UInt8) : UInt8 
goal: UInt8

full_name: UInt8.lor
code: @[extern "lean_uint8_lor"]
def UInt8.lor (a b : UInt8) : UInt8 
goal: UInt8

full_name: UInt8.xor
code: @[extern "lean_uint8_xor"]
def UInt8.xor (a b : UInt8) : UInt8 
goal: UInt8

full_name: UInt8.shiftLeft
code: @[extern "lean_uint8_shift_left"]
def UInt8.shiftLeft (a b : UInt8) : UInt8 
goal: UInt8

full_name: UInt8.shiftRight
code: @[extern "lean_uint8_shift_right"]
def UInt8.shiftRight (a b : UInt8) : UInt8 
goal: UInt8

full_name: UInt8.lt
code: def UInt8.lt (a b : UInt8) : Prop 
goal: Prop

full_name: UInt8.le
code: def UInt8.le (a b : UInt8) : Prop 
goal: Prop

full_name: UInt8.instOfNat
code: instance UInt8.instOfNat : OfNat UInt8 n 
goal: OfNat UInt8 n

full_name: «instAddUInt8_.lake»
code: instance : Add UInt8       
goal: Add UInt8

full_name: «instSubUInt8_.lake»
code: instance : Sub UInt8       
goal: Sub UInt8

full_name: «instMulUInt8_.lake»
code: instance : Mul UInt8       
goal: Mul UInt8

full_name: «instModUInt8_.lake»
code: instance : Mod UInt8       
goal: Mod UInt8

full_name: «instHModUInt8Nat_.lake»
code: instance : HMod UInt8 Nat UInt8 
goal: HMod UInt8 Nat UInt8

full_name: «instDivUInt8_.lake»
code: instance : Div UInt8       
goal: Div UInt8

full_name: «instLTUInt8_.lake»
code: instance : LT UInt8        
goal: LT UInt8

full_name: «instLEUInt8_.lake»
code: instance : LE UInt8        
goal: LE UInt8

full_name: UInt8.complement
code: @[extern "lean_uint8_complement"]
def UInt8.complement (a:UInt8) : UInt8 
goal: UInt8

full_name: «instComplementUInt8_.lake»
code: instance : Complement UInt8 
goal: Complement UInt8

full_name: «instAndOpUInt8_.lake»
code: instance : AndOp UInt8     
goal: AndOp UInt8

full_name: «instOrOpUInt8_.lake»
code: instance : OrOp UInt8      
goal: OrOp UInt8

full_name: «instXorUInt8_.lake»
code: instance : Xor UInt8       
goal: Xor UInt8

full_name: «instShiftLeftUInt8_.lake»
code: instance : ShiftLeft UInt8  
goal: ShiftLeft UInt8

full_name: «instShiftRightUInt8_.lake»
code: instance : ShiftRight UInt8 
goal: ShiftRight UInt8

full_name: UInt8.decLt
code: @[extern "lean_uint8_dec_lt"]
def UInt8.decLt (a b : UInt8) : Decidable (a < b) 
goal: Decidable (a < b)

full_name: UInt8.decLe
code: @[extern "lean_uint8_dec_le"]
def UInt8.decLe (a b : UInt8) : Decidable (a ≤ b) 
goal: Decidable (a ≤ b)

full_name: «instDecidableLtUInt8_.lake»
code: instance (a b : UInt8) : Decidable (a < b) 
goal: Decidable (a < b)

full_name: «instDecidableLeUInt8_.lake»
code: instance (a b : UInt8) : Decidable (a ≤ b) 
goal: Decidable (a ≤ b)

full_name: «instMaxUInt8_.lake»
code: instance : Max UInt8 
goal: Max UInt8

full_name: «instMinUInt8_.lake»
code: instance : Min UInt8 
goal: Min UInt8

full_name: UInt16.ofNat
code: @[extern "lean_uint16_of_nat"]
def UInt16.ofNat (n : @& Nat) : UInt16 
goal: UInt16

full_name: Nat.toUInt16
code: abbrev Nat.toUInt16 
goal: UInt16

full_name: UInt16.toNat
code: @[extern "lean_uint16_to_nat"]
def UInt16.toNat (n : UInt16) : Nat 
goal: Nat

full_name: UInt16.add
code: @[extern "lean_uint16_add"]
def UInt16.add (a b : UInt16) : UInt16 
goal: UInt16

full_name: UInt16.sub
code: @[extern "lean_uint16_sub"]
def UInt16.sub (a b : UInt16) : UInt16 
goal: UInt16

full_name: UInt16.mul
code: @[extern "lean_uint16_mul"]
def UInt16.mul (a b : UInt16) : UInt16 
goal: UInt16

full_name: UInt16.div
code: @[extern "lean_uint16_div"]
def UInt16.div (a b : UInt16) : UInt16 
goal: UInt16

full_name: UInt16.mod
code: @[extern "lean_uint16_mod"]
def UInt16.mod (a b : UInt16) : UInt16 
goal: UInt16

full_name: UInt16.modn
code: @[extern "lean_uint16_modn"]
def UInt16.modn (a : UInt16) (n : @& Nat) : UInt16 
goal: UInt16

full_name: UInt16.land
code: @[extern "lean_uint16_land"]
def UInt16.land (a b : UInt16) : UInt16 
goal: UInt16

full_name: UInt16.lor
code: @[extern "lean_uint16_lor"]
def UInt16.lor (a b : UInt16) : UInt16 
goal: UInt16

full_name: UInt16.xor
code: @[extern "lean_uint16_xor"]
def UInt16.xor (a b : UInt16) : UInt16 
goal: UInt16

full_name: UInt16.shiftLeft
code: @[extern "lean_uint16_shift_left"]
def UInt16.shiftLeft (a b : UInt16) : UInt16 
goal: UInt16

full_name: UInt16.toUInt8
code: @[extern "lean_uint16_to_uint8"]
def UInt16.toUInt8 (a : UInt16) : UInt8 
goal: UInt8

full_name: UInt8.toUInt16
code: @[extern "lean_uint8_to_uint16"]
def UInt8.toUInt16 (a : UInt8) : UInt16 
goal: UInt16

full_name: UInt16.shiftRight
code: @[extern "lean_uint16_shift_right"]
def UInt16.shiftRight (a b : UInt16) : UInt16 
goal: UInt16

full_name: UInt16.lt
code: def UInt16.lt (a b : UInt16) : Prop 
goal: Prop

full_name: UInt16.le
code: def UInt16.le (a b : UInt16) : Prop 
goal: Prop

full_name: UInt16.instOfNat
code: instance UInt16.instOfNat : OfNat UInt16 n 
goal: OfNat UInt16 n

full_name: «instAddUInt16_.lake»
code: instance : Add UInt16       
goal: Add UInt16

full_name: «instSubUInt16_.lake»
code: instance : Sub UInt16       
goal: Sub UInt16

full_name: «instMulUInt16_.lake»
code: instance : Mul UInt16       
goal: Mul UInt16

full_name: «instModUInt16_.lake»
code: instance : Mod UInt16       
goal: Mod UInt16

full_name: «instHModUInt16Nat_.lake»
code: instance : HMod UInt16 Nat UInt16 
goal: HMod UInt16 Nat UInt16

full_name: «instDivUInt16_.lake»
code: instance : Div UInt16       
goal: Div UInt16

full_name: «instLTUInt16_.lake»
code: instance : LT UInt16        
goal: LT UInt16

full_name: «instLEUInt16_.lake»
code: instance : LE UInt16        
goal: LE UInt16

full_name: UInt16.complement
code: @[extern "lean_uint16_complement"]
def UInt16.complement (a:UInt16) : UInt16 
goal: UInt16

full_name: «instComplementUInt16_.lake»
code: instance : Complement UInt16 
goal: Complement UInt16

full_name: «instAndOpUInt16_.lake»
code: instance : AndOp UInt16     
goal: AndOp UInt16

full_name: «instOrOpUInt16_.lake»
code: instance : OrOp UInt16      
goal: OrOp UInt16

full_name: «instXorUInt16_.lake»
code: instance : Xor UInt16       
goal: Xor UInt16

full_name: «instShiftLeftUInt16_.lake»
code: instance : ShiftLeft UInt16  
goal: ShiftLeft UInt16

full_name: «instShiftRightUInt16_.lake»
code: instance : ShiftRight UInt16 
goal: ShiftRight UInt16

full_name: UInt16.decLt
code: @[extern "lean_uint16_dec_lt"]
def UInt16.decLt (a b : UInt16) : Decidable (a < b) 
goal: Decidable (a < b)

full_name: UInt16.decLe
code: @[extern "lean_uint16_dec_le"]
def UInt16.decLe (a b : UInt16) : Decidable (a ≤ b) 
goal: Decidable (a ≤ b)

full_name: «instDecidableLtUInt16_.lake»
code: instance (a b : UInt16) : Decidable (a < b) 
goal: Decidable (a < b)

full_name: «instDecidableLeUInt16_.lake»
code: instance (a b : UInt16) : Decidable (a ≤ b) 
goal: Decidable (a ≤ b)

full_name: «instMaxUInt16_.lake»
code: instance : Max UInt16 
goal: Max UInt16

full_name: «instMinUInt16_.lake»
code: instance : Min UInt16 
goal: Min UInt16

full_name: UInt32.ofNat
code: @[extern "lean_uint32_of_nat"]
def UInt32.ofNat (n : @& Nat) : UInt32 
goal: UInt32

full_name: UInt32.ofNat'
code: @[extern "lean_uint32_of_nat"]
def UInt32.ofNat' (n : Nat) (h : n < UInt32.size) : UInt32 
goal: UInt32

full_name: UInt32.ofNatTruncate
code: /--
Converts the given natural number to `UInt32`, but returns `2^32 - 1` for natural numbers `>= 2^32`.
-/
def UInt32.ofNatTruncate (n : Nat) : UInt32 
goal: UInt32

full_name: Nat.toUInt32
code: abbrev Nat.toUInt32 
goal: UInt32

full_name: UInt32.add
code: @[extern "lean_uint32_add"]
def UInt32.add (a b : UInt32) : UInt32 
goal: UInt32

full_name: UInt32.sub
code: @[extern "lean_uint32_sub"]
def UInt32.sub (a b : UInt32) : UInt32 
goal: UInt32

full_name: UInt32.mul
code: @[extern "lean_uint32_mul"]
def UInt32.mul (a b : UInt32) : UInt32 
goal: UInt32

full_name: UInt32.div
code: @[extern "lean_uint32_div"]
def UInt32.div (a b : UInt32) : UInt32 
goal: UInt32

full_name: UInt32.mod
code: @[extern "lean_uint32_mod"]
def UInt32.mod (a b : UInt32) : UInt32 
goal: UInt32

full_name: UInt32.modn
code: @[extern "lean_uint32_modn"]
def UInt32.modn (a : UInt32) (n : @& Nat) : UInt32 
goal: UInt32

full_name: UInt32.land
code: @[extern "lean_uint32_land"]
def UInt32.land (a b : UInt32) : UInt32 
goal: UInt32

full_name: UInt32.lor
code: @[extern "lean_uint32_lor"]
def UInt32.lor (a b : UInt32) : UInt32 
goal: UInt32

full_name: UInt32.xor
code: @[extern "lean_uint32_xor"]
def UInt32.xor (a b : UInt32) : UInt32 
goal: UInt32

full_name: UInt32.shiftLeft
code: @[extern "lean_uint32_shift_left"]
def UInt32.shiftLeft (a b : UInt32) : UInt32 
goal: UInt32

full_name: UInt32.shiftRight
code: @[extern "lean_uint32_shift_right"]
def UInt32.shiftRight (a b : UInt32) : UInt32 
goal: UInt32

full_name: UInt32.toUInt8
code: @[extern "lean_uint32_to_uint8"]
def UInt32.toUInt8 (a : UInt32) : UInt8 
goal: UInt8

full_name: UInt32.toUInt16
code: @[extern "lean_uint32_to_uint16"]
def UInt32.toUInt16 (a : UInt32) : UInt16 
goal: UInt16

full_name: UInt8.toUInt32
code: @[extern "lean_uint8_to_uint32"]
def UInt8.toUInt32 (a : UInt8) : UInt32 
goal: UInt32

full_name: UInt16.toUInt32
code: @[extern "lean_uint16_to_uint32"]
def UInt16.toUInt32 (a : UInt16) : UInt32 
goal: UInt32

full_name: UInt32.instOfNat
code: instance UInt32.instOfNat : OfNat UInt32 n 
goal: OfNat UInt32 n

full_name: «instAddUInt32_.lake»
code: instance : Add UInt32       
goal: Add UInt32

full_name: «instSubUInt32_.lake»
code: instance : Sub UInt32       
goal: Sub UInt32

full_name: «instMulUInt32_.lake»
code: instance : Mul UInt32       
goal: Mul UInt32

full_name: «instModUInt32_.lake»
code: instance : Mod UInt32       
goal: Mod UInt32

full_name: «instHModUInt32Nat_.lake»
code: instance : HMod UInt32 Nat UInt32 
goal: HMod UInt32 Nat UInt32

full_name: «instDivUInt32_.lake»
code: instance : Div UInt32       
goal: Div UInt32

full_name: UInt32.complement
code: @[extern "lean_uint32_complement"]
def UInt32.complement (a:UInt32) : UInt32 
goal: UInt32

full_name: «instComplementUInt32_.lake»
code: instance : Complement UInt32 
goal: Complement UInt32

full_name: «instAndOpUInt32_.lake»
code: instance : AndOp UInt32     
goal: AndOp UInt32

full_name: «instOrOpUInt32_.lake»
code: instance : OrOp UInt32      
goal: OrOp UInt32

full_name: «instXorUInt32_.lake»
code: instance : Xor UInt32       
goal: Xor UInt32

full_name: «instShiftLeftUInt32_.lake»
code: instance : ShiftLeft UInt32  
goal: ShiftLeft UInt32

full_name: «instShiftRightUInt32_.lake»
code: instance : ShiftRight UInt32 
goal: ShiftRight UInt32

full_name: UInt64.ofNat
code: @[extern "lean_uint64_of_nat"]
def UInt64.ofNat (n : @& Nat) : UInt64 
goal: UInt64

full_name: Nat.toUInt64
code: abbrev Nat.toUInt64 
goal: UInt64

full_name: UInt64.toNat
code: @[extern "lean_uint64_to_nat"]
def UInt64.toNat (n : UInt64) : Nat 
goal: Nat

full_name: UInt64.add
code: @[extern "lean_uint64_add"]
def UInt64.add (a b : UInt64) : UInt64 
goal: UInt64

full_name: UInt64.sub
code: @[extern "lean_uint64_sub"]
def UInt64.sub (a b : UInt64) : UInt64 
goal: UInt64

full_name: UInt64.mul
code: @[extern "lean_uint64_mul"]
def UInt64.mul (a b : UInt64) : UInt64 
goal: UInt64

full_name: UInt64.div
code: @[extern "lean_uint64_div"]
def UInt64.div (a b : UInt64) : UInt64 
goal: UInt64

full_name: UInt64.mod
code: @[extern "lean_uint64_mod"]
def UInt64.mod (a b : UInt64) : UInt64 
goal: UInt64

full_name: UInt64.modn
code: @[extern "lean_uint64_modn"]
def UInt64.modn (a : UInt64) (n : @& Nat) : UInt64 
goal: UInt64

full_name: UInt64.land
code: @[extern "lean_uint64_land"]
def UInt64.land (a b : UInt64) : UInt64 
goal: UInt64

full_name: UInt64.lor
code: @[extern "lean_uint64_lor"]
def UInt64.lor (a b : UInt64) : UInt64 
goal: UInt64

full_name: UInt64.xor
code: @[extern "lean_uint64_xor"]
def UInt64.xor (a b : UInt64) : UInt64 
goal: UInt64

full_name: UInt64.shiftLeft
code: @[extern "lean_uint64_shift_left"]
def UInt64.shiftLeft (a b : UInt64) : UInt64 
goal: UInt64

full_name: UInt64.shiftRight
code: @[extern "lean_uint64_shift_right"]
def UInt64.shiftRight (a b : UInt64) : UInt64 
goal: UInt64

full_name: UInt64.lt
code: def UInt64.lt (a b : UInt64) : Prop 
goal: Prop

full_name: UInt64.le
code: def UInt64.le (a b : UInt64) : Prop 
goal: Prop

full_name: UInt64.toUInt8
code: @[extern "lean_uint64_to_uint8"]
def UInt64.toUInt8 (a : UInt64) : UInt8 
goal: UInt8

full_name: UInt64.toUInt16
code: @[extern "lean_uint64_to_uint16"]
def UInt64.toUInt16 (a : UInt64) : UInt16 
goal: UInt16

full_name: UInt64.toUInt32
code: @[extern "lean_uint64_to_uint32"]
def UInt64.toUInt32 (a : UInt64) : UInt32 
goal: UInt32

full_name: UInt8.toUInt64
code: @[extern "lean_uint8_to_uint64"]
def UInt8.toUInt64 (a : UInt8) : UInt64 
goal: UInt64

full_name: UInt16.toUInt64
code: @[extern "lean_uint16_to_uint64"]
def UInt16.toUInt64 (a : UInt16) : UInt64 
goal: UInt64

full_name: UInt32.toUInt64
code: @[extern "lean_uint32_to_uint64"]
def UInt32.toUInt64 (a : UInt32) : UInt64 
goal: UInt64

full_name: UInt64.instOfNat
code: instance UInt64.instOfNat : OfNat UInt64 n 
goal: OfNat UInt64 n

full_name: «instAddUInt64_.lake»
code: instance : Add UInt64       
goal: Add UInt64

full_name: «instSubUInt64_.lake»
code: instance : Sub UInt64       
goal: Sub UInt64

full_name: «instMulUInt64_.lake»
code: instance : Mul UInt64       
goal: Mul UInt64

full_name: «instModUInt64_.lake»
code: instance : Mod UInt64       
goal: Mod UInt64

full_name: «instHModUInt64Nat_.lake»
code: instance : HMod UInt64 Nat UInt64 
goal: HMod UInt64 Nat UInt64

full_name: «instDivUInt64_.lake»
code: instance : Div UInt64       
goal: Div UInt64

full_name: «instLTUInt64_.lake»
code: instance : LT UInt64        
goal: LT UInt64

full_name: «instLEUInt64_.lake»
code: instance : LE UInt64        
goal: LE UInt64

full_name: UInt64.complement
code: @[extern "lean_uint64_complement"]
def UInt64.complement (a:UInt64) : UInt64 
goal: UInt64

full_name: «instComplementUInt64_.lake»
code: instance : Complement UInt64 
goal: Complement UInt64

full_name: «instAndOpUInt64_.lake»
code: instance : AndOp UInt64     
goal: AndOp UInt64

full_name: «instOrOpUInt64_.lake»
code: instance : OrOp UInt64      
goal: OrOp UInt64

full_name: «instXorUInt64_.lake»
code: instance : Xor UInt64       
goal: Xor UInt64

full_name: «instShiftLeftUInt64_.lake»
code: instance : ShiftLeft UInt64  
goal: ShiftLeft UInt64

full_name: «instShiftRightUInt64_.lake»
code: instance : ShiftRight UInt64 
goal: ShiftRight UInt64

full_name: Bool.toUInt64
code: @[extern "lean_bool_to_uint64"]
def Bool.toUInt64 (b : Bool) : UInt64 
goal: UInt64

full_name: UInt64.decLt
code: @[extern "lean_uint64_dec_lt"]
def UInt64.decLt (a b : UInt64) : Decidable (a < b) 
goal: Decidable (a < b)

full_name: UInt64.decLe
code: @[extern "lean_uint64_dec_le"]
def UInt64.decLe (a b : UInt64) : Decidable (a ≤ b) 
goal: Decidable (a ≤ b)

full_name: «instDecidableLtUInt64_.lake»
code: instance (a b : UInt64) : Decidable (a < b) 
goal: Decidable (a < b)

full_name: «instDecidableLeUInt64_.lake»
code: instance (a b : UInt64) : Decidable (a ≤ b) 
goal: Decidable (a ≤ b)

full_name: «instMaxUInt64_.lake»
code: instance : Max UInt64 
goal: Max UInt64

full_name: «instMinUInt64_.lake»
code: instance : Min UInt64 
goal: Min UInt64

full_name: usize_size_gt_zero
code: theorem usize_size_gt_zero : USize.size > 0 
goal: USize.size > 0

full_name: USize.ofNat
code: @[extern "lean_usize_of_nat"]
def USize.ofNat (n : @& Nat) : USize 
goal: USize

full_name: Nat.toUSize
code: abbrev Nat.toUSize 
goal: USize

full_name: USize.toNat
code: @[extern "lean_usize_to_nat"]
def USize.toNat (n : USize) : Nat 
goal: Nat

full_name: USize.add
code: @[extern "lean_usize_add"]
def USize.add (a b : USize) : USize 
goal: USize

full_name: USize.sub
code: @[extern "lean_usize_sub"]
def USize.sub (a b : USize) : USize 
goal: USize

full_name: USize.mul
code: @[extern "lean_usize_mul"]
def USize.mul (a b : USize) : USize 
goal: USize

full_name: USize.div
code: @[extern "lean_usize_div"]
def USize.div (a b : USize) : USize 
goal: USize

full_name: USize.mod
code: @[extern "lean_usize_mod"]
def USize.mod (a b : USize) : USize 
goal: USize

full_name: USize.modn
code: @[extern "lean_usize_modn"]
def USize.modn (a : USize) (n : @& Nat) : USize 
goal: USize

full_name: USize.land
code: @[extern "lean_usize_land"]
def USize.land (a b : USize) : USize 
goal: USize

full_name: USize.lor
code: @[extern "lean_usize_lor"]
def USize.lor (a b : USize) : USize 
goal: USize

full_name: USize.xor
code: @[extern "lean_usize_xor"]
def USize.xor (a b : USize) : USize 
goal: USize

full_name: USize.shiftLeft
code: @[extern "lean_usize_shift_left"]
def USize.shiftLeft (a b : USize) : USize 
goal: USize

full_name: USize.shiftRight
code: @[extern "lean_usize_shift_right"]
def USize.shiftRight (a b : USize) : USize 
goal: USize

full_name: UInt32.toUSize
code: @[extern "lean_uint32_to_usize"]
def UInt32.toUSize (a : UInt32) : USize 
goal: USize

full_name: USize.toUInt32
code: @[extern "lean_usize_to_uint32"]
def USize.toUInt32 (a : USize) : UInt32 
goal: UInt32

full_name: USize.lt
code: def USize.lt (a b : USize) : Prop 
goal: Prop

full_name: USize.le
code: def USize.le (a b : USize) : Prop 
goal: Prop

full_name: USize.instOfNat
code: instance USize.instOfNat : OfNat USize n 
goal: OfNat USize n

full_name: «instAddUSize_.lake»
code: instance : Add USize       
goal: Add USize

full_name: «instSubUSize_.lake»
code: instance : Sub USize       
goal: Sub USize

full_name: «instMulUSize_.lake»
code: instance : Mul USize       
goal: Mul USize

full_name: «instModUSize_.lake»
code: instance : Mod USize       
goal: Mod USize

full_name: «instHModUSizeNat_.lake»
code: instance : HMod USize Nat USize 
goal: HMod USize Nat USize

full_name: «instDivUSize_.lake»
code: instance : Div USize       
goal: Div USize

full_name: «instLTUSize_.lake»
code: instance : LT USize        
goal: LT USize

full_name: «instLEUSize_.lake»
code: instance : LE USize        
goal: LE USize

full_name: USize.complement
code: @[extern "lean_usize_complement"]
def USize.complement (a:USize) : USize 
goal: USize

full_name: «instComplementUSize_.lake»
code: instance : Complement USize 
goal: Complement USize

full_name: «instAndOpUSize_.lake»
code: instance : AndOp USize      
goal: AndOp USize

full_name: «instOrOpUSize_.lake»
code: instance : OrOp USize       
goal: OrOp USize

full_name: «instXorUSize_.lake»
code: instance : Xor USize        
goal: Xor USize

full_name: «instShiftLeftUSize_.lake»
code: instance : ShiftLeft USize  
goal: ShiftLeft USize

full_name: «instShiftRightUSize_.lake»
code: instance : ShiftRight USize 
goal: ShiftRight USize

full_name: USize.decLt
code: @[extern "lean_usize_dec_lt"]
def USize.decLt (a b : USize) : Decidable (a < b) 
goal: Decidable (a < b)

full_name: USize.decLe
code: @[extern "lean_usize_dec_le"]
def USize.decLe (a b : USize) : Decidable (a ≤ b) 
goal: Decidable (a ≤ b)

full_name: «instDecidableLtUSize_.lake»
code: instance (a b : USize) : Decidable (a < b) 
goal: Decidable (a < b)

full_name: «instDecidableLeUSize_.lake»
code: instance (a b : USize) : Decidable (a ≤ b) 
goal: Decidable (a ≤ b)

full_name: «instMaxUSize_.lake»
code: instance : Max USize 
goal: Max USize

full_name: «instMinUSize_.lake»
code: instance : Min USize 
goal: Min USize