File: .lake/packages/lean4/src/lean/Lean/Meta/Tactic/Assert.lean

full_name: Lean.MVarId.assert
code: /--
  Convert the given goal `Ctx |- target` into `Ctx |- type -> target`.
  It assumes `val` has type `type` -/
def _root_.Lean.MVarId.assert (mvarId : MVarId) (name : Name) (type : Expr) (val : Expr) : MetaM MVarId 
goal: Lean.MetaM Lean.MVarId

full_name: Lean.Meta.assert
code: @[deprecated MVarId.assert (since := "2022-07-15")]
def assert (mvarId : MVarId) (name : Name) (type : Expr) (val : Expr) : MetaM MVarId 
goal: Lean.MetaM Lean.MVarId

full_name: Lean.MVarId.note
code: /-- Add the hypothesis `h : t`, given `v : t`, and return the new `FVarId`. -/
def _root_.Lean.MVarId.note (g : MVarId) (h : Name) (v : Expr) (t? : Option Expr := .none) :
    MetaM (FVarId × MVarId) 
goal: Lean.MetaM (Lean.FVarId × Lean.MVarId)

full_name: Lean.MVarId.define
code: /--
  Convert the given goal `Ctx |- target` into `Ctx |- let name : type := val; target`.
  It assumes `val` has type `type` -/
def _root_.Lean.MVarId.define (mvarId : MVarId) (name : Name) (type : Expr) (val : Expr) : MetaM MVarId 
goal: Lean.MetaM Lean.MVarId

full_name: Lean.Meta.define
code: @[deprecated MVarId.define (since := "2022-07-15")]
def define (mvarId : MVarId) (name : Name) (type : Expr) (val : Expr) : MetaM MVarId 
goal: Lean.MetaM Lean.MVarId

full_name: Lean.MVarId.assertExt
code: /--
  Convert the given goal `Ctx |- target` into `Ctx |- (hName : type) -> hName = val -> target`.
  It assumes `val` has type `type` -/
def _root_.Lean.MVarId.assertExt (mvarId : MVarId) (name : Name) (type : Expr) (val : Expr) (hName : Name := `h) : MetaM MVarId 
goal: Lean.MetaM Lean.MVarId

full_name: Lean.Meta.assertExt
code: @[deprecated MVarId.assertExt (since := "2022-07-15")]
def assertExt (mvarId : MVarId) (name : Name) (type : Expr) (val : Expr) (hName : Name := `h) : MetaM MVarId 
goal: Lean.MetaM Lean.MVarId

full_name: Lean.Meta.AssertAfterResult
code: structure AssertAfterResult where
  fvarId : FVarId
  mvarId : MVarId
  subst  : FVarSubst
goal: Type

full_name: Lean.Meta.AssertAfterResult.subst
code: structure AssertAfterResult where
  fvarId : FVarId
  mvarId : MVarId
  subst  : FVarSubst
goal: Lean.Meta.FVarSubst

full_name: Lean.Meta.AssertAfterResult.fvarId
code: structure AssertAfterResult where
  fvarId : FVarId
  mvarId : MVarId
  subst  : FVarSubst
goal: Lean.FVarId

full_name: Lean.Meta.AssertAfterResult.mvarId
code: structure AssertAfterResult where
  fvarId : FVarId
  mvarId : MVarId
  subst  : FVarSubst
goal: Lean.MVarId

full_name: Lean.MVarId.assertAfter
code: /--
  Convert the given goal `Ctx |- target` into a goal containing `(userName : type)` after the local declaration with if `fvarId`.
  It assumes `val` has type `type`, and that `type` is well-formed after `fvarId`.
  Note that `val` does not need to be well-formed after `fvarId`. That is, it may contain variables that are defined after `fvarId`. -/
def _root_.Lean.MVarId.assertAfter (mvarId : MVarId) (fvarId : FVarId) (userName : Name) (type : Expr) (val : Expr) : MetaM AssertAfterResult 
goal: Lean.MetaM Lean.Meta.AssertAfterResult

full_name: Lean.Meta.assertAfter
code: @[deprecated MVarId.assertAfter (since := "2022-07-15")]
def assertAfter (mvarId : MVarId) (fvarId : FVarId) (userName : Name) (type : Expr) (val : Expr) : MetaM AssertAfterResult 
goal: Lean.MetaM Lean.Meta.AssertAfterResult

full_name: Lean.Meta.Hypothesis.type
code: structure Hypothesis where
  userName : Name
  type     : Expr
  value    : Expr
goal: Lean.Expr

full_name: Lean.Meta.Hypothesis.userName
code: structure Hypothesis where
  userName : Name
  type     : Expr
  value    : Expr
goal: Lean.Name

full_name: Lean.Meta.Hypothesis
code: structure Hypothesis where
  userName : Name
  type     : Expr
  value    : Expr
goal: Type

full_name: Lean.Meta.Hypothesis.value
code: structure Hypothesis where
  userName : Name
  type     : Expr
  value    : Expr
goal: Lean.Expr

full_name: Lean.MVarId.assertHypotheses
code: /--
  Convert the given goal `Ctx |- target` into `Ctx, (hs[0].userName : hs[0].type) ... |-target`.
  It assumes `hs[i].val` has type `hs[i].type`. -/
def _root_.Lean.MVarId.assertHypotheses (mvarId : MVarId) (hs : Array Hypothesis) : MetaM (Array FVarId × MVarId) 
goal: Lean.MetaM (Array Lean.FVarId × Lean.MVarId)

full_name: Lean.Meta.assertHypotheses
code: @[deprecated MVarId.assertHypotheses (since := "2022-07-15")]
def assertHypotheses (mvarId : MVarId) (hs : Array Hypothesis) : MetaM (Array FVarId × MVarId) 
goal: Lean.MetaM (Array Lean.FVarId × Lean.MVarId)

full_name: Lean.MVarId.replace.findMaxFVar
code: /--
Replace hypothesis `hyp` in goal `g` with `proof : typeNew`.
The new hypothesis is given the same user name as the original,
it attempts to avoid reordering hypotheses, and the original is cleared if possible.
-/
-- adapted from Lean.Meta.replaceLocalDeclCore
def _root_.Lean.MVarId.replace (g : MVarId) (hyp : FVarId) (proof : Expr) (typeNew : Option Expr := none) :
    MetaM AssertAfterResult 
goal: StateRefT' IO.RealWorld Lean.LocalDecl Lean.MetaM Unit

full_name: Lean.MVarId.replace
code: /--
Replace hypothesis `hyp` in goal `g` with `proof : typeNew`.
The new hypothesis is given the same user name as the original,
it attempts to avoid reordering hypotheses, and the original is cleared if possible.
-/
-- adapted from Lean.Meta.replaceLocalDeclCore
def _root_.Lean.MVarId.replace (g : MVarId) (hyp : FVarId) (proof : Expr) (typeNew : Option Expr := none) :
    MetaM AssertAfterResult 
goal: Lean.MetaM Lean.Meta.AssertAfterResult