File: .lake/packages/lean4/src/lean/Lean/Compiler/ConstFolding.lean

full_name: Lean.Compiler.mkLcProof
code: def mkLcProof (p : Expr) 
goal: Lean.Expr

full_name: Lean.Compiler.BinFoldFn
code: abbrev BinFoldFn 
goal: Type

full_name: Lean.Compiler.UnFoldFn
code: abbrev UnFoldFn  
goal: Type

full_name: Lean.Compiler.mkUIntTypeName
code: def mkUIntTypeName (nbytes : Nat) : Name 
goal: Lean.Name

full_name: Lean.Compiler.NumScalarTypeInfo.ofNatFn
code: structure NumScalarTypeInfo where
  nbits : Nat
  id : Name      := mkUIntTypeName nbits
  ofNatFn : Name := Name.mkStr id "ofNat"
  toNatFn : Name := Name.mkStr id "toNat"
  size : Nat     := 2^nbits
goal: Lean.Name

full_name: Lean.Compiler.NumScalarTypeInfo.toNatFn
code: structure NumScalarTypeInfo where
  nbits : Nat
  id : Name      := mkUIntTypeName nbits
  ofNatFn : Name := Name.mkStr id "ofNat"
  toNatFn : Name := Name.mkStr id "toNat"
  size : Nat     := 2^nbits
goal: Lean.Name

full_name: Lean.Compiler.NumScalarTypeInfo
code: structure NumScalarTypeInfo where
  nbits : Nat
  id : Name      := mkUIntTypeName nbits
  ofNatFn : Name := Name.mkStr id "ofNat"
  toNatFn : Name := Name.mkStr id "toNat"
  size : Nat     := 2^nbits
goal: Type

full_name: Lean.Compiler.NumScalarTypeInfo.nbits
code: structure NumScalarTypeInfo where
  nbits : Nat
  id : Name      := mkUIntTypeName nbits
  ofNatFn : Name := Name.mkStr id "ofNat"
  toNatFn : Name := Name.mkStr id "toNat"
  size : Nat     := 2^nbits
goal: Nat

full_name: Lean.Compiler.NumScalarTypeInfo.id
code: structure NumScalarTypeInfo where
  nbits : Nat
  id : Name      := mkUIntTypeName nbits
  ofNatFn : Name := Name.mkStr id "ofNat"
  toNatFn : Name := Name.mkStr id "toNat"
  size : Nat     := 2^nbits
goal: Lean.Name

full_name: Lean.Compiler.NumScalarTypeInfo.size
code: structure NumScalarTypeInfo where
  nbits : Nat
  id : Name      := mkUIntTypeName nbits
  ofNatFn : Name := Name.mkStr id "ofNat"
  toNatFn : Name := Name.mkStr id "toNat"
  size : Nat     := 2^nbits
goal: Nat

full_name: Lean.Compiler.numScalarTypes
code: def numScalarTypes : List NumScalarTypeInfo 
goal: List Lean.Compiler.NumScalarTypeInfo

full_name: Lean.Compiler.isOfNat
code: def isOfNat (fn : Name) : Bool 
goal: Bool

full_name: Lean.Compiler.isToNat
code: def isToNat (fn : Name) : Bool 
goal: Bool

full_name: Lean.Compiler.getInfoFromFn
code: def getInfoFromFn (fn : Name) : List NumScalarTypeInfo → Option NumScalarTypeInfo
  
goal: List Lean.Compiler.NumScalarTypeInfo → Option Lean.Compiler.NumScalarTypeInfo

full_name: Lean.Compiler.getInfoFromVal
code: def getInfoFromVal : Expr → Option NumScalarTypeInfo
  
goal: Lean.Expr → Option Lean.Compiler.NumScalarTypeInfo

full_name: Lean.Compiler.getNumLit
code: @[export lean_get_num_lit]
def getNumLit : Expr → Option Nat
  
goal: Lean.Expr → Option Nat

full_name: Lean.Compiler.mkUIntLit
code: def mkUIntLit (info : NumScalarTypeInfo) (n : Nat) : Expr 
goal: Lean.Expr

full_name: Lean.Compiler.mkUInt32Lit
code: def mkUInt32Lit (n : Nat) : Expr 
goal: Lean.Expr

full_name: Lean.Compiler.foldBinUInt
code: def foldBinUInt (fn : NumScalarTypeInfo → Bool → Nat → Nat → Nat) (beforeErasure : Bool) (a₁ a₂ : Expr) : Option Expr 
goal: Option Lean.Expr

full_name: Lean.Compiler.foldUIntAdd
code: def foldUIntAdd 
goal: Option Lean.Expr

full_name: Lean.Compiler.foldUIntMul
code: def foldUIntMul 
goal: Option Lean.Expr

full_name: Lean.Compiler.foldUIntDiv
code: def foldUIntDiv 
goal: Option Lean.Expr

full_name: Lean.Compiler.foldUIntMod
code: def foldUIntMod 
goal: Option Lean.Expr

full_name: Lean.Compiler.foldUIntSub
code: def foldUIntSub 
goal: Option Lean.Expr

full_name: Lean.Compiler.preUIntBinFoldFns
code: def preUIntBinFoldFns : List (Name × BinFoldFn) 
goal: List (Lean.Name × Lean.Compiler.BinFoldFn)

full_name: Lean.Compiler.uintBinFoldFns
code: def uintBinFoldFns : List (Name × BinFoldFn) 
goal: List (Lean.Name × Lean.Compiler.BinFoldFn)

full_name: Lean.Compiler.foldNatBinOp
code: def foldNatBinOp (fn : Nat → Nat → Nat) (a₁ a₂ : Expr) : Option Expr 
goal: Option Lean.Expr

full_name: Lean.Compiler.foldNatAdd
code: def foldNatAdd (_ : Bool) 
goal: Bool → Lean.Expr → Lean.Expr → Option Lean.Expr

full_name: Lean.Compiler.foldNatMul
code: def foldNatMul (_ : Bool) 
goal: Bool → Lean.Expr → Lean.Expr → Option Lean.Expr

full_name: Lean.Compiler.foldNatDiv
code: def foldNatDiv (_ : Bool) 
goal: Bool → Lean.Expr → Lean.Expr → Option Lean.Expr

full_name: Lean.Compiler.foldNatMod
code: def foldNatMod (_ : Bool) 
goal: Bool → Lean.Expr → Lean.Expr → Option Lean.Expr

full_name: Lean.Compiler.natPowThreshold
code: def natPowThreshold 
goal: Nat

full_name: Lean.Compiler.foldNatPow
code: def foldNatPow (_ : Bool) (a₁ a₂ : Expr) : Option Expr 
goal: Bool → Lean.Expr → Lean.Expr → Option Lean.Expr

full_name: Lean.Compiler.mkNatEq
code: def mkNatEq (a b : Expr) : Expr 
goal: Lean.Expr

full_name: Lean.Compiler.mkNatLt
code: def mkNatLt (a b : Expr) : Expr 
goal: Lean.Expr

full_name: Lean.Compiler.mkNatLe
code: def mkNatLe (a b : Expr) : Expr 
goal: Lean.Expr

full_name: Lean.Compiler.toDecidableExpr
code: def toDecidableExpr (beforeErasure : Bool) (pred : Expr) (r : Bool) : Expr 
goal: Lean.Expr

full_name: Lean.Compiler.foldNatBinPred
code: def foldNatBinPred (mkPred : Expr → Expr → Expr) (fn : Nat → Nat → Bool)
    (beforeErasure : Bool) (a₁ a₂ : Expr) : Option Expr 
goal: Option Lean.Expr

full_name: Lean.Compiler.foldNatDecEq
code: def foldNatDecEq 
goal: Option Lean.Expr

full_name: Lean.Compiler.foldNatDecLt
code: def foldNatDecLt 
goal: Option Lean.Expr

full_name: Lean.Compiler.foldNatDecLe
code: def foldNatDecLe 
goal: Option Lean.Expr

full_name: Lean.Compiler.foldNatBinBoolPred
code: def foldNatBinBoolPred (fn : Nat → Nat → Bool) (a₁ a₂ : Expr) : Option Expr 
goal: Option Lean.Expr

full_name: Lean.Compiler.foldNatBeq
code: def foldNatBeq 
goal: Bool → Lean.Expr → Lean.Expr → Option Lean.Expr

full_name: Lean.Compiler.foldNatBle
code: def foldNatBle 
goal: Bool → Lean.Expr → Lean.Expr → Option Lean.Expr

full_name: Lean.Compiler.foldNatBlt
code: def foldNatBlt 
goal: Bool → Lean.Expr → Lean.Expr → Option Lean.Expr

full_name: Lean.Compiler.natFoldFns
code: def natFoldFns : List (Name × BinFoldFn) 
goal: List (Lean.Name × Lean.Compiler.BinFoldFn)

full_name: Lean.Compiler.getBoolLit
code: def getBoolLit : Expr → Option Bool
  
goal: Lean.Expr → Option Bool

full_name: Lean.Compiler.foldStrictAnd
code: def foldStrictAnd (_ : Bool) (a₁ a₂ : Expr) : Option Expr 
goal: Bool → Lean.Expr → Lean.Expr → Option Lean.Expr

full_name: Lean.Compiler.foldStrictOr
code: def foldStrictOr (_ : Bool) (a₁ a₂ : Expr) : Option Expr 
goal: Bool → Lean.Expr → Lean.Expr → Option Lean.Expr

full_name: Lean.Compiler.boolFoldFns
code: def boolFoldFns : List (Name × BinFoldFn) 
goal: List (Lean.Name × Lean.Compiler.BinFoldFn)

full_name: Lean.Compiler.binFoldFns
code: def binFoldFns : List (Name × BinFoldFn) 
goal: List (Lean.Name × Lean.Compiler.BinFoldFn)

full_name: Lean.Compiler.foldNatSucc
code: def foldNatSucc (_ : Bool) (a : Expr) : Option Expr 
goal: Bool → Lean.Expr → Option Lean.Expr

full_name: Lean.Compiler.foldCharOfNat
code: def foldCharOfNat (beforeErasure : Bool) (a : Expr) : Option Expr 
goal: Option Lean.Expr

full_name: Lean.Compiler.foldToNat
code: def foldToNat (size : Nat) (_ : Bool) (a : Expr) : Option Expr 
goal: Bool → Lean.Expr → Option Lean.Expr

full_name: Lean.Compiler.uintFoldToNatFns
code: def uintFoldToNatFns : List (Name × UnFoldFn) 
goal: List (Lean.Name × Lean.Compiler.UnFoldFn)

full_name: Lean.Compiler.unFoldFns
code: def unFoldFns : List (Name × UnFoldFn) 
goal: List (Lean.Name × Lean.Compiler.UnFoldFn)

full_name: Lean.Compiler.findBinFoldFn
code: def findBinFoldFn (fn : Name) : Option BinFoldFn 
goal: Option Lean.Compiler.BinFoldFn

full_name: Lean.Compiler.findUnFoldFn
code: def findUnFoldFn (fn : Name) : Option UnFoldFn 
goal: Option Lean.Compiler.UnFoldFn

full_name: Lean.Compiler.foldBinOp
code: @[export lean_fold_bin_op]
def foldBinOp (beforeErasure : Bool) (f : Expr) (a : Expr) (b : Expr) : Option Expr 
goal: Option Lean.Expr

full_name: Lean.Compiler.foldUnOp
code: @[export lean_fold_un_op]
def foldUnOp (beforeErasure : Bool) (f : Expr) (a : Expr) : Option Expr 
goal: Option Lean.Expr