File: Mathlib/Lean/Meta/Simp.lean

full_name: Lean.PHashSet.toList
code: def Lean.PHashSet.toList.{u} {α : Type u} [BEq α] [Hashable α] (s : Lean.PHashSet α) : List α 
goal: List α

full_name: Lean.Meta.Simp.instToFormatSimpTheorems_mathlib
code: instance : ToFormat SimpTheorems 
goal: Lean.ToFormat Lean.Meta.SimpTheorems

full_name: Lean.Meta.Simp.Result.ofTrue
code: /--
Constructs a proof that the original expression is true
given a simp result which simplifies the target to `True`.
-/
def Result.ofTrue (r : Simp.Result) : MetaM (Option Expr) 
goal: Lean.MetaM (Option Lean.Expr)

full_name: Lean.Meta.Simp.getPropHyps
code: /-- Return all propositions in the local context. -/
def getPropHyps : MetaM (Array FVarId) 
goal: Lean.MetaM (Array Lean.FVarId)

full_name: Lean.Meta.simpTheoremsOfNames
code: /-- Construct a `SimpTheorems` from a list of names. -/
def simpTheoremsOfNames (lemmas : List Name := []) (simpOnly : Bool := false) :
    MetaM SimpTheorems 
goal: Lean.MetaM Lean.Meta.SimpTheorems

full_name: Lean.Meta.Simp.Context.ofNames
code: /-- Construct a `Simp.Context` from a list of names. -/
def Simp.Context.ofNames (lemmas : List Name := []) (simpOnly : Bool := false)
    (config : Simp.Config := {}) : MetaM Simp.Context 
goal: Lean.MetaM Lean.Meta.Simp.Context

full_name: Lean.Meta.simpOnlyNames
code: /-- Simplify an expression using only a list of lemmas specified by name. -/
def simpOnlyNames (lemmas : List Name) (e : Expr) (config : Simp.Config := {}) :
    MetaM Simp.Result 
goal: Lean.MetaM Lean.Meta.Simp.Result

full_name: Lean.Meta.simpType
code: /--
Given a simplifier `S : Expr → MetaM Simp.Result`,
and an expression `e : Expr`, run `S` on the type of `e`, and then
convert `e` into that simplified type,
using a combination of type hints as well as casting if the proof is not definitional `Eq.mp`.

The optional argument `type?`, if present, must be definitionally equal to the type of `e`.
When it is specified we simplify this type rather than the inferred type of `e`.
-/
def simpType (S : Expr → MetaM Simp.Result) (e : Expr) (type? : Option Expr := none) :
    MetaM Expr 
goal: Lean.MetaM Lean.Expr

full_name: Lean.Meta.simpEq
code: /-- Independently simplify both the left-hand side and the right-hand side
of an equality. The equality is allowed to be under binders.
Returns the simplified equality and a proof of it. -/
def simpEq (S : Expr → MetaM Simp.Result) (type pf : Expr) : MetaM (Expr × Expr) 
goal: Lean.MetaM (Lean.Expr × Lean.Expr)

full_name: Lean.Meta.SimpTheorems.contains
code: /-- Checks whether `declName` is in `SimpTheorems` as either a lemma or definition to unfold. -/
def SimpTheorems.contains (d : SimpTheorems) (declName : Name) 
goal: Bool

full_name: Lean.Meta.isInSimpSet
code: /-- Tests whether `decl` has `simp`-attribute `simpAttr`. Returns `false` is `simpAttr` is not a
valid simp-attribute. -/
def isInSimpSet (simpAttr decl : Name) : CoreM Bool 
goal: Lean.CoreM Bool

full_name: Lean.Meta.getAllSimpDecls
code: /-- Returns all declarations with the `simp`-attribute `simpAttr`.
  Note: this also returns many auxiliary declarations. -/
def getAllSimpDecls (simpAttr : Name) : CoreM (List Name) 
goal: Lean.CoreM (List Lean.Name)

full_name: Lean.Meta.getAllSimpAttrs
code: /-- Gets all simp-attributes given to declaration `decl`. -/
def getAllSimpAttrs (decl : Name) : CoreM (Array Name) 
goal: Lean.CoreM (Array Lean.Name)