opaque Lean.Meta.Simp.backward.dsimp.instances : Lean.Option Bool

structure Lean.Meta.Simp.Result : Type

The result of simplifying some expression e.

• expr : Expr

  The simplified version of e

• proof? : Option Expr

  A proof that $e = $expr, where the simplified expression is on the RHS. If none, the proof is assumed to be refl.

• cache : Bool

  If cache := true the result is cached. Warning: we will remove this field in the future. It is currently used by arith := true, but we can now refactor the code to avoid the hack.

def Lean.Meta.Simp.instInhabitedResult.default : Result

@[implicit_reducible]

instance Lean.Meta.Simp.instInhabitedResult : Inhabited Result

def Lean.Meta.Simp.mkEqTransOptProofResult (h? : Option Expr) (cache : Bool) (r : Result) : MetaM Result

def Lean.Meta.Simp.Result.mkEqTrans (r₁ r₂ : Result) : MetaM Result

def Lean.Meta.Simp.Result.mkEqSymm (e : Expr) (r : Result) : MetaM Result

Flip the proof in a Simp.Result.

@[reducible, inline]

abbrev Lean.Meta.Simp.Cache : Type

@[reducible, inline]

abbrev Lean.Meta.Simp.CongrCache : Type

structure Lean.Meta.Simp.Context : Type

• config : Config
• zetaDeltaSet : FVarIdSet

  Local declarations to propagate to Meta.Context

• initUsedZetaDelta : FVarIdSet

  When processing Simp arguments, zetaDelta may be performed if zetaDeltaSet is not empty. We save the local free variable ids in initUsedZetaDelta. initUsedZetaDelta is a subset of zetaDeltaSet.

• metaConfig : ConfigWithKey
• indexConfig : ConfigWithKey
• maxDischargeDepth : UInt32

  maxDischargeDepth from config as an UInt32.

• simpTheorems : SimpTheoremsArray
• congrTheorems : SimpCongrTheorems
• parent? : Option Expr

  Stores the "parent" term for the term being simplified. If a simplification procedure result depends on this value, then it is its responsibility to set Result.cache := false.

  Motivation for this field: Suppose we have a simplification procedure for normalizing arithmetic terms. Then, given a term such as t_1 + ... + t_n, we don't want to apply the procedure to every subterm t_1 + ... + t_i for i < n for performance issues. The procedure can accomplish this by checking whether the parent term is also an arithmetical expression and do nothing if it is. However, it should set Result.cache := false to ensure we don't miss simplification opportunities. For example, consider the following:

  example (x y : Nat) (h : y = 0) : id ((x + x) + y) = id (x + x) := by
    simp +arith only
    ...
  

  If we don't set Result.cache := false for the first x + x, then we get the resulting state:

  ... |- id (2*x + y) = id (x + x)
  

  instead of

  ... |- id (2*x + y) = id (2*x)
  

  as expected.

  Remark: given an application f a b c the "parent" term for f, a, b, and c is f a b c.

• dischargeDepth : UInt32
• lctxInitIndices : Nat

  Number of indices in the local context when starting simp. We use this information to decide which assumptions we can use without invalidating the cache.

• inDSimp : Bool

  If inDSimp := true, then simp is in dsimp mode, and only applying transformations that preserve definitional equality.

@[implicit_reducible]

instance Lean.Meta.Simp.instInhabitedContext : Inhabited Context

def Lean.Meta.Simp.instInhabitedContext.default : Context

def Lean.Meta.Simp.mkContext (config : Config := { }) (simpTheorems : SimpTheoremsArray := ∅) (congrTheorems : SimpCongrTheorems := { }) : MetaM Context

def Lean.Meta.Simp.Context.setConfig (context : Context) (config : Config) : MetaM Context

def Lean.Meta.Simp.Context.setSimpTheorems (c : Context) (simpTheorems : SimpTheoremsArray) : Context

def Lean.Meta.Simp.Context.setLctxInitIndices (c : Context) : MetaM Context

def Lean.Meta.Simp.Context.setAutoUnfold (c : Context) : Context

def Lean.Meta.Simp.Context.setFailIfUnchanged (c : Context) (flag : Bool) : Context

def Lean.Meta.Simp.Context.setMemoize (c : Context) (flag : Bool) : Context

def Lean.Meta.Simp.Context.setZetaDeltaSet (c : Context) (zetaDeltaSet initUsedZetaDelta : FVarIdSet) : Context

def Lean.Meta.Simp.Context.isDeclToUnfold (ctx : Context) (declName : Name) : Bool

structure Lean.Meta.Simp.UsedSimps : Type

• map : PHashMap Origin Nat
• size : Nat

@[implicit_reducible]

instance Lean.Meta.Simp.instInhabitedUsedSimps : Inhabited UsedSimps

def Lean.Meta.Simp.instInhabitedUsedSimps.default : UsedSimps

def Lean.Meta.Simp.UsedSimps.contains (s : UsedSimps) (thmId : Origin) : Bool

def Lean.Meta.Simp.UsedSimps.insert (s : UsedSimps) (thmId : Origin) : UsedSimps

def Lean.Meta.Simp.UsedSimps.toArray (s : UsedSimps) : Array Origin

structure Lean.Meta.Simp.Diagnostics : Type

• usedThmCounter : PHashMap Origin Nat

  Number of times each simp theorem has been used/applied.

• triedThmCounter : PHashMap Origin Nat

  Number of times each simp theorem has been tried.

• congrThmCounter : PHashMap Name Nat

  Number of times each congr theorem has been tried.

• thmsWithBadKeys : PArray SimpTheorem

  When using Simp.Config.index := false, and set_option diagnostics true, for every theorem used by simp, we check whether the theorem would be also applied if index := true, and we store it here if it would not have been tried.

@[implicit_reducible]

instance Lean.Meta.Simp.instInhabitedDiagnostics : Inhabited Diagnostics

def Lean.Meta.Simp.instInhabitedDiagnostics.default : Diagnostics

structure Lean.Meta.Simp.State : Type

• cache : Cache
• congrCache : CongrCache
• dsimpCache : ExprStructMap Expr
• usedTheorems : UsedSimps
• numSteps : Nat
• diag : Diagnostics

structure Lean.Meta.Simp.Stats : Type

• usedTheorems : UsedSimps
• diag : Diagnostics

def Lean.Meta.Simp.instInhabitedStats.default : Stats

@[implicit_reducible]

instance Lean.Meta.Simp.instInhabitedStats : Inhabited Stats

def Lean.Meta.Simp.MethodsRef : Type

instance Lean.Meta.Simp.instNonemptyMethodsRef : Nonempty MethodsRef

@[reducible, inline]

abbrev Lean.Meta.Simp.SimpM (α : Type) : Type

@[inline]

def Lean.Meta.Simp.withIncDischargeDepth {α : Type} : SimpM α → SimpM α

@[inline]

def Lean.Meta.Simp.withSimpTheorems {α : Type} (s : SimpTheoremsArray) : SimpM α → SimpM α

@[inline]

def Lean.Meta.Simp.withInDSimp {α : Type} : SimpM α → SimpM α

@[inline]

def Lean.Meta.Simp.withInDSimpWithCache {α : Type} (k : ExprStructMap Expr → SimpM (α × ExprStructMap Expr)) : SimpM α

@[inline]

def Lean.Meta.Simp.withSimpIndexConfig {α : Type} (x : SimpM α) : SimpM α

Executes x using a MetaM configuration for indexing terms. It is inferred from Simp.Config. For example, if the user has set simp (config := { zeta := false }), isDefEq and whnf in MetaM should not perform zeta reduction.

@[inline]

def Lean.Meta.Simp.withSimpMetaConfig {α : Type} (x : SimpM α) : SimpM α

Executes x using a MetaM configuration for inferred from Simp.Config.

@[extern lean_simp]

opaque Lean.Meta.Simp.simp (e : Expr) : SimpM Result

@[extern lean_dsimp]

opaque Lean.Meta.Simp.dsimp (e : Expr) : SimpM Expr

@[inline]

def Lean.Meta.Simp.modifyDiag (f : Diagnostics → Diagnostics) : SimpM Unit

inductive Lean.Meta.Simp.Step : Type

Result type for a simplification procedure. We have pre and post simplification procedures.

• done (r : Result) : Step

  For pre procedures, it returns the result without visiting any subexpressions.

  For post procedures, it returns the result.

• visit (e : Result) : Step

  For pre procedures, the resulting expression is passed to pre again.

  For post procedures, the resulting expression is passed to pre again IF Simp.Config.singlePass := false and resulting expression is not equal to initial expression.

• continue (e? : Option Result := none) : Step

  For pre procedures, continue transformation by visiting subexpressions, and then executing post procedures.

  For post procedures, this is equivalent to returning visit.

def Lean.Meta.Simp.instInhabitedStep.default : Step

@[implicit_reducible]

instance Lean.Meta.Simp.instInhabitedStep : Inhabited Step

@[reducible, inline]

abbrev Lean.Meta.Simp.Simproc : Type

A simplification procedure. Recall that we have pre and post procedures. See Step.

@[reducible, inline]

abbrev Lean.Meta.Simp.DStep : Type

@[reducible, inline]

abbrev Lean.Meta.Simp.DSimproc : Type

Similar to Simproc, but resulting expression should be definitionally equal to the input one.

def Lean.TransformStep.toStep (s : TransformStep) : Meta.Simp.Step

def Lean.Meta.Simp.mkEqTransResultStep (r : Result) (s : Step) : MetaM Step

@[always_inline]

def Lean.Meta.Simp.andThen (f g : Simproc) : Simproc

"Compose" the two given simplification procedures. We use the following semantics.

• If f produces done or visit, then return f's result.
• If f produces continue, then apply g to new expression returned by f.

See Simp.Step type.

@[implicit_reducible]

instance Lean.Meta.Simp.instAndThenSimproc : AndThen Simproc

@[always_inline]

def Lean.Meta.Simp.dandThen (f g : DSimproc) : DSimproc

@[implicit_reducible]

instance Lean.Meta.Simp.instAndThenDSimproc : AndThen DSimproc

structure Lean.Meta.Simp.SimprocOLeanEntry : Type

Simproc .olean entry.

• declName : Name

  Name of a declaration stored in the environment which has type Simproc.

• post : Bool
• keys : Array SimpTheoremKey

def Lean.Meta.Simp.instInhabitedSimprocOLeanEntry.default : SimprocOLeanEntry

@[implicit_reducible]

instance Lean.Meta.Simp.instInhabitedSimprocOLeanEntry : Inhabited SimprocOLeanEntry

structure Lean.Meta.Simp.SimprocEntryextends Lean.Meta.Simp.SimprocOLeanEntry : Type

Simproc entry. It is the .olean entry plus the actual function.

• declName : Name
• post : Bool
• keys : Array SimpTheoremKey
• proc : Simproc ⊕ DSimproc

  Recall that we cannot store Simproc into .olean files because it is a closure. Given SimprocOLeanEntry.declName, we convert it into a Simproc by using the unsafe function evalConstCheck.

@[reducible, inline]

abbrev Lean.Meta.Simp.SimprocTree : Type

structure Lean.Meta.Simp.Simprocs : Type

• pre : SimprocTree
• post : SimprocTree
• simprocNames : PHashSet Name
• erased : PHashSet Name

def Lean.Meta.Simp.instInhabitedSimprocs.default : Simprocs

@[implicit_reducible]

instance Lean.Meta.Simp.instInhabitedSimprocs : Inhabited Simprocs

structure Lean.Meta.Simp.Methods : Type

• pre : Simproc
• post : Simproc
• dpre : DSimproc
• dpost : DSimproc
• discharge? : Expr → SimpM (Option Expr)
• wellBehavedDischarge : Bool

  wellBehavedDischarge must not be set to true IF discharge? access local declarations with index >= Context.lctxInitIndices when contextual := false. Reason: it would prevent us from aggressively caching simp results.

@[implicit_reducible]

instance Lean.Meta.Simp.instInhabitedMethods : Inhabited Methods

def Lean.Meta.Simp.instInhabitedMethods.default : Methods

unsafe def Lean.Meta.Simp.Methods.toMethodsRefImpl (m : Methods) : MethodsRef

@[implemented_by Lean.Meta.Simp.Methods.toMethodsRefImpl]

opaque Lean.Meta.Simp.Methods.toMethodsRef (m : Methods) : MethodsRef

unsafe def Lean.Meta.Simp.MethodsRef.toMethodsImpl (m : MethodsRef) : Methods

@[implemented_by Lean.Meta.Simp.MethodsRef.toMethodsImpl]

opaque Lean.Meta.Simp.MethodsRef.toMethods (m : MethodsRef) : Methods

def Lean.Meta.Simp.getMethods : SimpM Methods

def Lean.Meta.Simp.pre (e : Expr) : SimpM Step

def Lean.Meta.Simp.post (e : Expr) : SimpM Step

@[inline]

def Lean.Meta.Simp.getContext : SimpM Context

def Lean.Meta.Simp.getConfig : SimpM Config

@[inline]

def Lean.Meta.Simp.withParent {α : Type} (parent : Expr) (f : SimpM α) : SimpM α

def Lean.Meta.Simp.getSimpTheorems : SimpM SimpTheoremsArray

def Lean.Meta.Simp.getSimpCongrTheorems : SimpM SimpCongrTheorems

def Lean.Meta.Simp.inDSimp : SimpM Bool

Returns true if simp is in dsimp mode. That is, only transformations that preserve definitional equality should be applied.

@[inline]

def Lean.Meta.Simp.withPreservedCache {α : Type} (x : SimpM α) : SimpM α

@[inline]

def Lean.Meta.Simp.withFreshCache {α : Type} (x : SimpM α) : SimpM α

Save current cache, reset it, execute x, and then restore original cache.

@[inline]

def Lean.Meta.Simp.withDischarger {α : Type} (discharge? : Expr → SimpM (Option Expr)) (wellBehavedDischarge : Bool) (x : SimpM α) : SimpM α

def Lean.Meta.Simp.recordTriedSimpTheorem (thmId : Origin) : SimpM Unit

def Lean.Meta.Simp.recordSimpTheorem (thmId : Origin) : SimpM Unit

def Lean.Meta.Simp.recordCongrTheorem (declName : Name) : SimpM Unit

def Lean.Meta.Simp.recordTheoremWithBadKeys (thm : SimpTheorem) : SimpM Unit

def Lean.Meta.Simp.Result.getProof (r : Result) : MetaM Expr

def Lean.Meta.Simp.Result.getProof' (source : Expr) (r : Result) : MetaM Expr

Similar to Result.getProof, but adds a mkExpectedTypeHint if proof? is none (i.e., result is definitionally equal to input), but we cannot establish that source and r.expr are definitionally when using TransparencyMode.reducible.

def Lean.Meta.Simp.Result.mkCast (r : Result) (e : Expr) : MetaM Expr

Construct the Expr cast h e, from a Simp.Result with proof h.

def Lean.Meta.Simp.Result.mkEqMPR (r : Result) (e : Expr) : MetaM Expr

Construct the Expr h.mpr e, from a Simp.Result with proof h.

def Lean.Meta.Simp.Result.mkEqMP (r : Result) (e : Expr) : MetaM Expr

Construct the Expr h.mp e, from a Simp.Result with proof h.

def Lean.Meta.Simp.mkCongrFun (r : Result) (a : Expr) : MetaM Result

def Lean.Meta.Simp.mkCongrArg (f : Expr) (r : Result) : MetaM Result

def Lean.Meta.Simp.mkCongr (r₁ r₂ : Result) : MetaM Result

def Lean.Meta.Simp.mkImpCongr (src : Expr) (r₁ r₂ : Result) : MetaM Result

def Lean.Meta.Simp.removeUnnecessaryCasts (e : Expr) : MetaM Expr

Given the application e, remove unnecessary casts of the form Eq.rec a rfl and Eq.ndrec a rfl.

def Lean.Meta.Simp.congrArgs (r : Result) (args : Array Expr) : SimpM Result

Given a simplified function result r and arguments args, simplify arguments using simp and dsimp. The resulting proof is built using congr and congrFun theorems.

def Lean.Meta.Simp.simpAppUsingCongr (e : Expr) : SimpM Result

Given an application e, recursively simplifies its function and arguments and constructs a proof using congrArg, congrFun, congrFun' and congr.

def Lean.Meta.Simp.mkCongrSimp? (f : Expr) : SimpM (Option CongrTheorem)

Retrieve auto-generated congruence lemma for f.

Remark: If all argument kinds are fixed or eq, it returns none because using simple congruence theorems congr, congrArg, and congrFun produces a more compact proof.

def Lean.Meta.Simp.tryAutoCongrTheorem? (e : Expr) : SimpM (Option Result)

Try to use automatically generated congruence theorems. See mkCongrSimp?.

def Lean.Meta.Simp.Result.addExtraArgs (r : Result) (extraArgs : Array Expr) : MetaM Result

def Lean.Meta.Simp.Step.addExtraArgs (s : Step) (extraArgs : Array Expr) : MetaM Step

def Lean.Meta.Simp.DStep.addExtraArgs (s : DStep) (extraArgs : Array Expr) : DStep

def Lean.Meta.Simp.Result.addLambdas (r : Result) (xs : Array Expr) : MetaM Result

def Lean.Meta.Simp.Result.addForalls (r : Result) (xs : Array Expr) : MetaM Result

def Lean.Meta.Simp.SimpM.run {α : Type} (ctx : Context) (s : State := { }) (methods : Methods := { }) (k : SimpM α) : MetaM (α × State)

def Lean.Meta.applySimpResultToTarget (mvarId : MVarId) (target : Expr) (r : Simp.Result) : MetaM MVarId

Auxiliary method. Given the current target of mvarId, apply r which is a new target and proof that it is equal to the current one.