structure Lean.Meta.Simp.Result : Type

The result of simplifying some expression e.

• expr : Lean.Expr

  The simplified version of e

• proof? : Option Lean.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.

instance Lean.Meta.Simp.instInhabitedResult : Inhabited Lean.Meta.Simp.Result

Equations

• Lean.Meta.Simp.instInhabitedResult = { default := { expr := default, proof? := default, cache := default } }

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

Equations

• One or more equations did not get rendered due to their size.
• Lean.Meta.Simp.mkEqTransOptProofResult none true r = pure r
• Lean.Meta.Simp.mkEqTransOptProofResult none false r = pure { expr := r.expr, proof? := r.proof?, cache := false }

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

Equations

• r₁.mkEqTrans r₂ = Lean.Meta.Simp.mkEqTransOptProofResult r₁.proof? r₁.cache r₂

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

Flip the proof in a Simp.Result.

Equations

• One or more equations did not get rendered due to their size.

@[reducible, inline]

abbrev Lean.Meta.Simp.Cache : Type

Equations

• Lean.Meta.Simp.Cache = Lean.SExprMap Lean.Meta.Simp.Result

@[reducible, inline]

abbrev Lean.Meta.Simp.CongrCache : Type

Equations

• Lean.Meta.Simp.CongrCache = Lean.ExprMap (Option Lean.Meta.CongrTheorem)

structure Lean.Meta.Simp.Context : Type

• config : Lean.Meta.Simp.Config
• maxDischargeDepth : UInt32

  maxDischargeDepth from config as an UInt32.

• simpTheorems : Lean.Meta.SimpTheoremsArray
• congrTheorems : Lean.Meta.SimpCongrTheorems
• parent? : Option Lean.Expr

  Stores the "parent" term for the term being simplified. If a simplification procedure result depends on this value, then it is its reponsability 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 presereve definitional equality.

instance Lean.Meta.Simp.instInhabitedContext : Inhabited Lean.Meta.Simp.Context

Equations

• One or more equations did not get rendered due to their size.

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

Equations

• ctx.isDeclToUnfold declName = ctx.simpTheorems.isDeclToUnfold declName

structure Lean.Meta.Simp.UsedSimps : Type

• map : Lean.PHashMap Lean.Meta.Origin Nat
• size : Nat

instance Lean.Meta.Simp.instInhabitedUsedSimps : Inhabited Lean.Meta.Simp.UsedSimps

Equations

• Lean.Meta.Simp.instInhabitedUsedSimps = { default := { map := default, size := default } }

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

Equations

• One or more equations did not get rendered due to their size.

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

Equations

• s.toArray = Array.map (fun (x : Lean.Meta.Origin × Nat) => x.fst) ((Lean.PersistentHashMap.toArray s.map).qsort fun (x1 x2 : Lean.Meta.Origin × Nat) => decide (x1.snd < x2.snd))

structure Lean.Meta.Simp.Diagnostics : Type

• usedThmCounter : Lean.PHashMap Lean.Meta.Origin Nat

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

• triedThmCounter : Lean.PHashMap Lean.Meta.Origin Nat

  Number of times each simp theorem has been tried.

• congrThmCounter : Lean.PHashMap Lean.Name Nat

  Number of times each congr theorem has been tried.

• thmsWithBadKeys : Lean.PArray Lean.Meta.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.

instance Lean.Meta.Simp.instInhabitedDiagnostics : Inhabited Lean.Meta.Simp.Diagnostics

Equations

• Lean.Meta.Simp.instInhabitedDiagnostics = { default := { usedThmCounter := default, triedThmCounter := default, congrThmCounter := default, thmsWithBadKeys := default } }

structure Lean.Meta.Simp.State : Type

• cache : Lean.Meta.Simp.Cache
• congrCache : Lean.Meta.Simp.CongrCache
• usedTheorems : Lean.Meta.Simp.UsedSimps
• numSteps : Nat
• diag : Lean.Meta.Simp.Diagnostics

structure Lean.Meta.Simp.Stats : Type

• usedTheorems : Lean.Meta.Simp.UsedSimps
• diag : Lean.Meta.Simp.Diagnostics

instance Lean.Meta.Simp.instInhabitedStats : Inhabited Lean.Meta.Simp.Stats

Equations

• Lean.Meta.Simp.instInhabitedStats = { default := { usedTheorems := default, diag := default } }

instance Lean.Meta.Simp.instNonemptyMethodsRef : Nonempty Lean.Meta.Simp.MethodsRef

Equations

• Lean.Meta.Simp.instNonemptyMethodsRef = ⋯

@[reducible, inline]

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

Equations

• Lean.Meta.SimpM = ReaderT Lean.Meta.Simp.MethodsRef (ReaderT Lean.Meta.Simp.Context (StateRefT' IO.RealWorld Lean.Meta.Simp.State Lean.MetaM))

@[extern lean_simp]

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

@[extern lean_dsimp]

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

@[inline]

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

Equations

• One or more equations did not get rendered due to their size.

inductive Lean.Meta.Simp.Step : Type

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

• done: Lean.Meta.Simp.Result → Lean.Meta.Simp.Step

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

  For post procedures, it returns the result.

• visit: Lean.Meta.Simp.Result → Lean.Meta.Simp.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: optParam (Option Lean.Meta.Simp.Result) none → Lean.Meta.Simp.Step

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

  For post procedures, this is equivalent to returning visit.

instance Lean.Meta.Simp.instInhabitedStep : Inhabited Lean.Meta.Simp.Step

Equations

• Lean.Meta.Simp.instInhabitedStep = { default := Lean.Meta.Simp.Step.done default }

@[reducible, inline]

abbrev Lean.Meta.Simp.Simproc : Type

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

Equations

• Lean.Meta.Simp.Simproc = (Lean.Expr → Lean.Meta.SimpM Lean.Meta.Simp.Step)

@[reducible, inline]

abbrev Lean.Meta.Simp.DStep : Type

Equations

• Lean.Meta.Simp.DStep = Lean.TransformStep

@[reducible, inline]

abbrev Lean.Meta.Simp.DSimproc : Type

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

Equations

• Lean.Meta.Simp.DSimproc = (Lean.Expr → Lean.Meta.SimpM Lean.Meta.Simp.DStep)

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

Equations

• (Lean.TransformStep.done e).toStep = Lean.Meta.Simp.Step.done { expr := e, proof? := none, cache := true }
• (Lean.TransformStep.visit e).toStep = Lean.Meta.Simp.Step.visit { expr := e, proof? := none, cache := true }
• (Lean.TransformStep.continue (some e)).toStep = Lean.Meta.Simp.Step.continue (some { expr := e, proof? := none, cache := true })
• Lean.TransformStep.continue.toStep = Lean.Meta.Simp.Step.continue

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

Equations

• One or more equations did not get rendered due to their size.
• Lean.Meta.Simp.mkEqTransResultStep r (Lean.Meta.Simp.Step.done r') = do let __do_lift ← Lean.Meta.Simp.mkEqTransOptProofResult r.proof? r.cache r' pure (Lean.Meta.Simp.Step.done __do_lift)
• Lean.Meta.Simp.mkEqTransResultStep r (Lean.Meta.Simp.Step.visit r') = do let __do_lift ← Lean.Meta.Simp.mkEqTransOptProofResult r.proof? r.cache r' pure (Lean.Meta.Simp.Step.visit __do_lift)
• Lean.Meta.Simp.mkEqTransResultStep r Lean.Meta.Simp.Step.continue = pure (Lean.Meta.Simp.Step.continue (some r))

@[always_inline]

def Lean.Meta.Simp.andThen (f g : Lean.Meta.Simp.Simproc) : Lean.Meta.Simp.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.

Equations

• One or more equations did not get rendered due to their size.

instance Lean.Meta.Simp.instAndThenSimproc : AndThen Lean.Meta.Simp.Simproc

Equations

• Lean.Meta.Simp.instAndThenSimproc = { andThen := fun (s₁ : Lean.Meta.Simp.Simproc) (s₂ : Unit → Lean.Meta.Simp.Simproc) => Lean.Meta.Simp.andThen s₁ (s₂ ()) }

@[always_inline]

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

Equations

• One or more equations did not get rendered due to their size.

instance Lean.Meta.Simp.instAndThenDSimproc : AndThen Lean.Meta.Simp.DSimproc

Equations

• Lean.Meta.Simp.instAndThenDSimproc = { andThen := fun (s₁ : Lean.Meta.Simp.DSimproc) (s₂ : Unit → Lean.Meta.Simp.DSimproc) => Lean.Meta.Simp.dandThen s₁ (s₂ ()) }

structure Lean.Meta.Simp.SimprocOLeanEntry : Type

Simproc .olean entry.

• declName : Lean.Name

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

• post : Bool
• keys : Array Lean.Meta.SimpTheoremKey

instance Lean.Meta.Simp.instInhabitedSimprocOLeanEntry : Inhabited Lean.Meta.Simp.SimprocOLeanEntry

Equations

• Lean.Meta.Simp.instInhabitedSimprocOLeanEntry = { default := { declName := default, post := default, keys := default } }

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

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

• declName : Lean.Name
• post : Bool
• keys : Array Lean.Meta.SimpTheoremKey
• proc : Lean.Meta.Simp.Simproc ⊕ Lean.Meta.Simp.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

Equations

• Lean.Meta.Simp.SimprocTree = Lean.Meta.DiscrTree Lean.Meta.Simp.SimprocEntry

structure Lean.Meta.Simp.Simprocs : Type

• pre : Lean.Meta.Simp.SimprocTree
• post : Lean.Meta.Simp.SimprocTree
• simprocNames : Lean.PHashSet Lean.Name
• erased : Lean.PHashSet Lean.Name

instance Lean.Meta.Simp.instInhabitedSimprocs : Inhabited Lean.Meta.Simprocs

Equations

• Lean.Meta.Simp.instInhabitedSimprocs = { default := { pre := default, post := default, simprocNames := default, erased := default } }

structure Lean.Meta.Simp.Methods : Type

• pre : Lean.Meta.Simp.Simproc
• post : Lean.Meta.Simp.Simproc
• dpre : Lean.Meta.Simp.DSimproc
• dpost : Lean.Meta.Simp.DSimproc
• discharge? : Lean.Expr → Lean.Meta.SimpM (Option Lean.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.

instance Lean.Meta.Simp.instInhabitedMethods : Inhabited Lean.Meta.Simp.Methods

Equations

• Lean.Meta.Simp.instInhabitedMethods = { default := { pre := default, post := default, dpre := default, dpost := default, discharge? := default, wellBehavedDischarge := default } }

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

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

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

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

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

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

def Lean.Meta.Simp.getMethods : Lean.Meta.SimpM Lean.Meta.Simp.Methods

Equations

• Lean.Meta.Simp.getMethods = do let __do_lift ← read pure (Lean.Meta.Simp.MethodsRef.toMethods __do_lift)

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

Equations

• Lean.Meta.Simp.pre e = do let __do_lift ← Lean.Meta.Simp.getMethods __do_lift.pre e

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

Equations

• Lean.Meta.Simp.post e = do let __do_lift ← Lean.Meta.Simp.getMethods __do_lift.post e

@[inline]

def Lean.Meta.Simp.getContext : Lean.Meta.SimpM Lean.Meta.Simp.Context

Equations

• Lean.Meta.Simp.getContext = readThe Lean.Meta.Simp.Context

def Lean.Meta.Simp.getConfig : Lean.Meta.SimpM Lean.Meta.Simp.Config

Equations

• Lean.Meta.Simp.getConfig = do let __do_lift ← Lean.Meta.Simp.getContext pure __do_lift.config

@[inline]

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

Equations

• One or more equations did not get rendered due to their size.

def Lean.Meta.Simp.getSimpTheorems : Lean.Meta.SimpM Lean.Meta.SimpTheoremsArray

Equations

• Lean.Meta.Simp.getSimpTheorems = do let __do_lift ← readThe Lean.Meta.Simp.Context pure __do_lift.simpTheorems

def Lean.Meta.Simp.getSimpCongrTheorems : Lean.Meta.SimpM Lean.Meta.SimpCongrTheorems

Equations

• Lean.Meta.Simp.getSimpCongrTheorems = do let __do_lift ← readThe Lean.Meta.Simp.Context pure __do_lift.congrTheorems

def Lean.Meta.Simp.inDSimp : Lean.Meta.SimpM Bool

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

Equations

• Lean.Meta.Simp.inDSimp = do let __do_lift ← readThe Lean.Meta.Simp.Context pure __do_lift.inDSimp

@[inline]

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

Equations

• One or more equations did not get rendered due to their size.

@[inline]

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

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

Equations

• One or more equations did not get rendered due to their size.

@[inline]

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

Equations

• One or more equations did not get rendered due to their size.

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

Equations

• One or more equations did not get rendered due to their size.

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

Equations

• One or more equations did not get rendered due to their size.

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

Equations

• One or more equations did not get rendered due to their size.

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

Equations

• One or more equations did not get rendered due to their size.

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

Equations

• r.getProof = match r.proof? with | some p => pure p | none => Lean.Meta.mkEqRefl r.expr

def Lean.Meta.Simp.Result.getProof' (source : Lean.Expr) (r : Lean.Meta.Simp.Result) : Lean.MetaM Lean.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.

Equations

• One or more equations did not get rendered due to their size.

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

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

Equations

• r.mkCast e = do let __do_lift ← r.getProof Lean.Meta.mkAppM `cast #[__do_lift, e]

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

Equations

• One or more equations did not get rendered due to their size.

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

Equations

• One or more equations did not get rendered due to their size.

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

Equations

• One or more equations did not get rendered due to their size.

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

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

Equations

• One or more equations did not get rendered due to their size.

def Lean.Meta.Simp.removeUnnecessaryCasts.isDummyEqRec (e : Lean.Expr) : Bool

Equations

• Lean.Meta.Simp.removeUnnecessaryCasts.isDummyEqRec e = ((e.isAppOfArity `Eq.rec 6 || e.isAppOfArity `Eq.ndrec 6) && e.appArg!.isAppOf `Eq.refl)

partial def Lean.Meta.Simp.removeUnnecessaryCasts.elimDummyEqRec (e : Lean.Expr) : Lean.Expr

def Lean.Meta.Simp.congrArgs (r : Lean.Meta.Simp.Result) (args : Array Lean.Expr) : Lean.Meta.SimpM Lean.Meta.Simp.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.

Equations

• One or more equations did not get rendered due to their size.

def Lean.Meta.Simp.mkCongrSimp? (f : Lean.Expr) : Lean.Meta.SimpM (Option Lean.Meta.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.

Equations

• One or more equations did not get rendered due to their size.

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

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

Equations

• One or more equations did not get rendered due to their size.

def Lean.Meta.Simp.getDtConfig (cfg : Lean.Meta.Simp.Config) : Lean.Meta.WhnfCoreConfig

Return a WHNF configuration for retrieving [simp] from the discrimination tree. If user has disabled zeta and/or beta reduction in the simplifier, or enabled zetaDelta, we must also disable/enable them when retrieving lemmas from discrimination tree. See issues: #2669 and #2281

Equations

• One or more equations did not get rendered due to their size.

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

Equations

• One or more equations did not get rendered due to their size.

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

Equations

• (Lean.Meta.Simp.Step.visit r).addExtraArgs extraArgs = do let __do_lift ← r.addExtraArgs extraArgs pure (Lean.Meta.Simp.Step.visit __do_lift)
• (Lean.Meta.Simp.Step.done r).addExtraArgs extraArgs = do let __do_lift ← r.addExtraArgs extraArgs pure (Lean.Meta.Simp.Step.done __do_lift)
• Lean.Meta.Simp.Step.continue.addExtraArgs extraArgs = pure Lean.Meta.Simp.Step.continue
• (Lean.Meta.Simp.Step.continue (some r)).addExtraArgs extraArgs = do let __do_lift ← r.addExtraArgs extraArgs pure (Lean.Meta.Simp.Step.continue (some __do_lift))

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

Equations

• Lean.Meta.Simp.DStep.addExtraArgs (Lean.TransformStep.visit eNew) extraArgs = Lean.TransformStep.visit (Lean.mkAppN eNew extraArgs)
• Lean.Meta.Simp.DStep.addExtraArgs (Lean.TransformStep.done eNew) extraArgs = Lean.TransformStep.done (Lean.mkAppN eNew extraArgs)
• Lean.Meta.Simp.DStep.addExtraArgs Lean.TransformStep.continue extraArgs = Lean.TransformStep.continue
• Lean.Meta.Simp.DStep.addExtraArgs (Lean.TransformStep.continue (some eNew)) extraArgs = Lean.TransformStep.continue (some (Lean.mkAppN eNew extraArgs))

def Lean.Meta.applySimpResultToTarget (mvarId : Lean.MVarId) (target : Lean.Expr) (r : Lean.Meta.Simp.Result) : Lean.MetaM Lean.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.

Equations

• One or more equations did not get rendered due to their size.