def Std.Tactic.Ext.withExtHyps {α : Type} (struct : Lean.Name) (flat : Lean.Term) (k : Array Lean.Expr → Lean.Expr → Lean.Expr → Array (Lean.Name × Lean.Expr) → Lean.MetaM α) : Lean.MetaM α

Constructs the hypotheses for the extensionality lemma. Calls the continuation k with the list of parameters to the structure, two structure variables x and y, and a list of pairs (field, ty) where ty is x.field = y.field or HEq x.field y.field.

def Std.Tactic.Ext.«termExt_type%___» : Lean.ParserDescr

Creates the type of the extensionality lemma for the given structure, elaborating to x.1 = y.1 → x.2 = y.2 → x = y, for example.

def Std.Tactic.Ext.mkIff (p : Lean.Expr) (q : Lean.Expr) : Lean.Expr

Make an Iff application.

def Std.Tactic.Ext.mkAndN : List Lean.Expr → Lean.Expr

Make an n-ary And application. mkAndN [] returns True.

Equations

• Std.Tactic.Ext.mkAndN [] = Lean.mkConst `True
• Std.Tactic.Ext.mkAndN [p] = p
• Std.Tactic.Ext.mkAndN (p :: ps) = Lean.mkAnd p (Std.Tactic.Ext.mkAndN ps)

def Std.Tactic.Ext.«termExt_iff_type%___» : Lean.ParserDescr

Creates the type of the iff-variant of the extensionality lemma for the given structure, elaborating to x = y ↔ x.1 = y.1 ∧ x.2 = y.2, for example.

def Std.Tactic.Ext.applyExtLemma (goal : Lean.MVarId) : Lean.MetaM (List Lean.MVarId)

Apply a single extensionality lemma to goal.

def Std.Tactic.Ext.tacticApply_ext_lemma : Lean.ParserDescr

Apply a single extensionality lemma to the current goal.

def Std.Tactic.Ext.tryIntros {m : Type → Type u_1} [Monad m] [MonadLiftT Lean.Elab.TermElabM m] (g : Lean.MVarId) (pats : List (Lean.TSyntax `rcasesPat)) (k : Lean.MVarId → List (Lean.TSyntax `rcasesPat) → m Nat) : m Nat

Postprocessor for withExt which runs rintro with the given patterns when the target is a pi type.

Equations

• One or more equations did not get rendered due to their size.
• Std.Tactic.Ext.tryIntros g [] k = do let __do_lift ← liftM (liftM (Lean.MVarId.intros g)) k __do_lift.snd []

def Std.Tactic.Ext.withExt1 {m : Type → Type u_1} [Monad m] [MonadLiftT Lean.Elab.TermElabM m] (g : Lean.MVarId) (pats : List (Lean.TSyntax `rcasesPat)) (k : Lean.MVarId → List (Lean.TSyntax `rcasesPat) → m Nat) : m Nat

Applies a single extensionality lemma, using pats to introduce variables in the result. Runs continuation k on each subgoal.

def Std.Tactic.Ext.withExtN {m : Type → Type u_1} [Monad m] [MonadLiftT Lean.Elab.TermElabM m] [MonadExcept Lean.Exception m] (g : Lean.MVarId) (pats : List (Lean.TSyntax `rcasesPat)) (k : Lean.MVarId → List (Lean.TSyntax `rcasesPat) → m Nat) (depth : optParam Nat 1000000) (failIfUnchanged : optParam Bool true) : m Nat

Applies a extensionality lemmas recursively, using pats to introduce variables in the result. Runs continuation k on each subgoal.

Equations

• One or more equations did not get rendered due to their size.
• Std.Tactic.Ext.withExtN g pats k 0 failIfUnchanged = k g pats

def Std.Tactic.Ext.extCore (g : Lean.MVarId) (pats : List (Lean.TSyntax `rcasesPat)) (depth : optParam Nat 1000000) (failIfUnchanged : optParam Bool true) : Lean.Elab.TermElabM (Nat × Array (Lean.MVarId × List (Lean.TSyntax `rcasesPat)))

Apply extensionality lemmas as much as possible, using pats to introduce the variables in extensionality lemmas like funext. Returns a list of subgoals.

def Std.Tactic.Ext.«tacticExt___:_» : Lean.ParserDescr

• ext pat*: Apply extensionality lemmas as much as possible, using pat* to introduce the variables in extensionality lemmas like funext.
• ext: introduce anonymous variables whenever needed.
• ext pat* : n: apply ext lemmas only up to depth n.

def Std.Tactic.Ext.tacticExt1___ : Lean.ParserDescr

ext1 pat* is like ext pat* except it only applies one extensionality lemma instead of recursing as much as possible.

def Std.Tactic.Ext.tacticExt1?___ : Lean.ParserDescr

ext1? pat* is like ext1 pat* but gives a suggestion on what pattern to use

def Std.Tactic.Ext.«tacticExt?___:_» : Lean.ParserDescr

ext? pat* is like ext pat* but gives a suggestion on what pattern to use

theorem PUnit.ext (x : PUnit) (y : PUnit) : x = y

theorem Unit.ext (x : Unit) (y : Unit) : x = y