ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
File: .lake/packages/lean4/src/lean/Lean/Elab/Deriving/Repr.lean

full_name: Lean.Elab.Deriving.Repr.mkReprHeader
code: def mkReprHeader (indVal : InductiveVal) : TermElabM Header 
goal: Lean.Elab.TermElabM Lean.Elab.Deriving.Header

full_name: Lean.Elab.Deriving.Repr.mkBodyForStruct
code: def mkBodyForStruct (header : Header) (indVal : InductiveVal) : TermElabM Term 
goal: Lean.Elab.TermElabM Lean.Term

full_name: Lean.Elab.Deriving.Repr.mkBodyForInduct.mkAlts
code: def mkBodyForInduct (header : Header) (indVal : InductiveVal) (auxFunName : Name) : TermElabM Term 
goal: Lean.Elab.TermElabM (Array (Lean.TSyntax `Lean.Parser.Term.matchAlt))

full_name: Lean.Elab.Deriving.Repr.mkBodyForInduct
code: def mkBodyForInduct (header : Header) (indVal : InductiveVal) (auxFunName : Name) : TermElabM Term 
goal: Lean.Elab.TermElabM Lean.Term

full_name: Lean.Elab.Deriving.Repr.mkBody
code: def mkBody (header : Header) (indVal : InductiveVal) (auxFunName : Name) : TermElabM Term 
goal: Lean.Elab.TermElabM Lean.Term

full_name: Lean.Elab.Deriving.Repr.mkAuxFunction
code: def mkAuxFunction (ctx : Context) (i : Nat) : TermElabM Command 
goal: Lean.Elab.TermElabM Lean.Command

full_name: Lean.Elab.Deriving.Repr.mkMutualBlock
code: def mkMutualBlock (ctx : Context) : TermElabM Syntax 
goal: Lean.Elab.TermElabM Lean.Syntax

full_name: _private.«.lake».packages.lean4.src.lean.Lean.Elab.Deriving.Repr.0.Lean.Elab.Deriving.Repr.mkReprInstanceCmd
code: private def mkReprInstanceCmd (declName : Name) : TermElabM (Array Syntax) 
goal: Lean.Elab.TermElabM (Array Lean.Syntax)

full_name: Lean.Elab.Deriving.Repr.mkReprInstanceHandler
code: def mkReprInstanceHandler (declNames : Array Name) : CommandElabM Bool 
goal: Lean.Elab.Command.CommandElabM Bool

full_name: Lean.Elab.Deriving.Repr.initFn._@..lake.packages.lean4.src.lean.Lean.Elab.Deriving.Repr._hyg.3532
code: builtin_initialize
  registerDerivingHandler `Repr mkReprInstanceHandler
  registerTraceClass `Elab.Deriving.repr
goal: IO Unit
File: .lake/packages/lean4/src/lean/Lean/Elab/Deriving/BEq.lean

full_name: Lean.Elab.Deriving.BEq.mkBEqHeader
code: def mkBEqHeader (indVal : InductiveVal) : TermElabM Header 
goal: Lean.Elab.TermElabM Lean.Elab.Deriving.Header

full_name: Lean.Elab.Deriving.BEq.mkMatch.mkElseAlt
code: def mkMatch (header : Header) (indVal : InductiveVal) (auxFunName : Name) : TermElabM Term 
goal: Lean.Elab.TermElabM (Lean.TSyntax `Lean.Parser.Term.matchAltExpr)

full_name: Lean.Elab.Deriving.BEq.mkMatch.mkAlts
code: def mkMatch (header : Header) (indVal : InductiveVal) (auxFunName : Name) : TermElabM Term 
goal: Lean.Elab.TermElabM (Array (Lean.TSyntax `Lean.Parser.Term.matchAlt))

full_name: Lean.Elab.Deriving.BEq.mkMatch
code: def mkMatch (header : Header) (indVal : InductiveVal) (auxFunName : Name) : TermElabM Term 
goal: Lean.Elab.TermElabM Lean.Term

full_name: Lean.Elab.Deriving.BEq.mkAuxFunction
code: def mkAuxFunction (ctx : Context) (i : Nat) : TermElabM Command 
goal: Lean.Elab.TermElabM Lean.Command

full_name: Lean.Elab.Deriving.BEq.mkMutualBlock
code: def mkMutualBlock (ctx : Context) : TermElabM Syntax 
goal: Lean.Elab.TermElabM Lean.Syntax

full_name: _private.«.lake».packages.lean4.src.lean.Lean.Elab.Deriving.BEq.0.Lean.Elab.Deriving.BEq.mkBEqInstanceCmds
code: private def mkBEqInstanceCmds (declName : Name) : TermElabM (Array Syntax) 
goal: Lean.Elab.TermElabM (Array Lean.Syntax)

full_name: _private.«.lake».packages.lean4.src.lean.Lean.Elab.Deriving.BEq.0.Lean.Elab.Deriving.BEq.mkBEqEnumFun
code: private def mkBEqEnumFun (ctx : Context) (name : Name) : TermElabM Syntax 
goal: Lean.Elab.TermElabM Lean.Syntax

full_name: _private.«.lake».packages.lean4.src.lean.Lean.Elab.Deriving.BEq.0.Lean.Elab.Deriving.BEq.mkBEqEnumCmd
code: private def mkBEqEnumCmd (name : Name): TermElabM (Array Syntax) 
goal: Lean.Elab.TermElabM (Array Lean.Syntax)

full_name: Lean.Elab.Deriving.BEq.mkBEqInstance
code: def mkBEqInstance (declName : Name) : CommandElabM Unit 
goal: Lean.Elab.Command.CommandElabM Unit

full_name: Lean.Elab.Deriving.BEq.mkBEqInstanceHandler
code: def mkBEqInstanceHandler (declNames : Array Name) : CommandElabM Bool 
goal: Lean.Elab.Command.CommandElabM Bool

full_name: Lean.Elab.Deriving.BEq.initFn._@..lake.packages.lean4.src.lean.Lean.Elab.Deriving.BEq._hyg.3388
code: builtin_initialize
  registerDerivingHandler `BEq mkBEqInstanceHandler
  registerTraceClass `Elab.Deriving.beq
goal: IO Unit
File: .lake/packages/lean4/src/lean/Lean/Elab/Deriving/Ord.lean

full_name: Lean.Elab.Deriving.Ord.mkOrdHeader
code: def mkOrdHeader (indVal : InductiveVal) : TermElabM Header 
goal: Lean.Elab.TermElabM Lean.Elab.Deriving.Header

full_name: Lean.Elab.Deriving.Ord.mkMatch.mkAlts
code: def mkMatch (header : Header) (indVal : InductiveVal) : TermElabM Term 
goal: Lean.Elab.TermElabM (Array (Lean.TSyntax `Lean.Parser.Term.matchAlt))

full_name: Lean.Elab.Deriving.Ord.mkMatch
code: def mkMatch (header : Header) (indVal : InductiveVal) : TermElabM Term 
goal: Lean.Elab.TermElabM Lean.Term

full_name: Lean.Elab.Deriving.Ord.mkAuxFunction
code: def mkAuxFunction (ctx : Context) (i : Nat) : TermElabM Command 
goal: Lean.Elab.TermElabM Lean.Command

full_name: Lean.Elab.Deriving.Ord.mkMutualBlock
code: def mkMutualBlock (ctx : Context) : TermElabM Syntax 
goal: Lean.Elab.TermElabM Lean.Syntax

full_name: _private.«.lake».packages.lean4.src.lean.Lean.Elab.Deriving.Ord.0.Lean.Elab.Deriving.Ord.mkOrdInstanceCmds
code: private def mkOrdInstanceCmds (declName : Name) : TermElabM (Array Syntax) 
goal: Lean.Elab.TermElabM (Array Lean.Syntax)

full_name: Lean.Elab.Deriving.Ord.mkOrdInstanceHandler
code: def mkOrdInstanceHandler (declNames : Array Name) : CommandElabM Bool 
goal: Lean.Elab.Command.CommandElabM Bool

full_name: Lean.Elab.Deriving.Ord.initFn._@..lake.packages.lean4.src.lean.Lean.Elab.Deriving.Ord._hyg.2786
code: builtin_initialize
  registerDerivingHandler `Ord mkOrdInstanceHandler
  registerTraceClass `Elab.Deriving.ord
goal: IO Unit
File: .lake/packages/lean4/src/lean/Lean/Elab/Deriving/DecEq.lean

full_name: Lean.Elab.Deriving.DecEq.mkDecEqHeader
code: def mkDecEqHeader (indVal : InductiveVal) : TermElabM Header 
goal: Lean.Elab.TermElabM Lean.Elab.Deriving.Header

full_name: Lean.Elab.Deriving.DecEq.mkMatch.mkAlts
code: def mkMatch (ctx : Context) (header : Header) (indVal : InductiveVal) : TermElabM Term 
goal: Lean.Elab.TermElabM (Array (Lean.TSyntax `Lean.Parser.Term.matchAlt))

full_name: Lean.Elab.Deriving.DecEq.mkMatch
code: def mkMatch (ctx : Context) (header : Header) (indVal : InductiveVal) : TermElabM Term 
goal: Lean.Elab.TermElabM Lean.Term

full_name: Lean.Elab.Deriving.DecEq.mkMatch.mkSameCtorRhs
code: def mkMatch (ctx : Context) (header : Header) (indVal : InductiveVal) : TermElabM Term 
goal: List (Lean.Ident × Lean.Ident × Option Lean.Name × Bool) → Lean.Elab.TermElabM Lean.Term

full_name: Lean.Elab.Deriving.DecEq.mkAuxFunction
code: def mkAuxFunction (ctx : Context) (auxFunName : Name) (indVal : InductiveVal): TermElabM (TSyntax `command) 
goal: Lean.Elab.TermElabM (Lean.TSyntax `command)

full_name: Lean.Elab.Deriving.DecEq.mkAuxFunctions
code: def mkAuxFunctions (ctx : Context) : TermElabM (TSyntax `command) 
goal: Lean.Elab.TermElabM (Lean.TSyntax `command)

full_name: Lean.Elab.Deriving.DecEq.mkDecEqCmds
code: def mkDecEqCmds (indVal : InductiveVal) : TermElabM (Array Syntax) 
goal: Lean.Elab.TermElabM (Array Lean.Syntax)

full_name: Lean.Elab.Deriving.DecEq.mkDecEq
code: def mkDecEq (declName : Name) : CommandElabM Bool 
goal: Lean.Elab.Command.CommandElabM Bool

full_name: Lean.Elab.Deriving.DecEq.mkEnumOfNat.mkDecTree
code: partial def mkEnumOfNat (declName : Name) : MetaM Unit 
goal: Lean.Expr

full_name: Lean.Elab.Deriving.DecEq.mkEnumOfNat
code: partial def mkEnumOfNat (declName : Name) : MetaM Unit 
goal: Lean.MetaM Unit

full_name: Lean.Elab.Deriving.DecEq.mkEnumOfNatThm
code: def mkEnumOfNatThm (declName : Name) : MetaM Unit 
goal: Lean.MetaM Unit

full_name: Lean.Elab.Deriving.DecEq.mkDecEqEnum
code: def mkDecEqEnum (declName : Name) : CommandElabM Unit 
goal: Lean.Elab.Command.CommandElabM Unit

full_name: Lean.Elab.Deriving.DecEq.mkDecEqInstance
code: def mkDecEqInstance (declName : Name) : CommandElabM Bool 
goal: Lean.Elab.Command.CommandElabM Bool

full_name: Lean.Elab.Deriving.DecEq.mkDecEqInstanceHandler
code: def mkDecEqInstanceHandler (declNames : Array Name) : CommandElabM Bool 
goal: Lean.Elab.Command.CommandElabM Bool

full_name: Lean.Elab.Deriving.DecEq.initFn._@..lake.packages.lean4.src.lean.Lean.Elab.Deriving.DecEq._hyg.4725
code: builtin_initialize
  registerDerivingHandler `DecidableEq mkDecEqInstanceHandler
  registerTraceClass `Elab.Deriving.decEq
goal: IO Unit
File: .lake/packages/lean4/src/lean/Lean/Elab/Open.lean

full_name: Lean.Elab.OpenDecl.State.currNamespace
code: /--
A local copy of name resolution state that allows us to immediately use new open decls
in further name resolution as in `open Lean Elab`.
-/
structure State where
  openDecls     : List OpenDecl
  currNamespace : Name
goal: Lean.Name

full_name: Lean.Elab.OpenDecl.State.openDecls
code: /--
A local copy of name resolution state that allows us to immediately use new open decls
in further name resolution as in `open Lean Elab`.
-/
structure State where
  openDecls     : List OpenDecl
  currNamespace : Name
goal: List Lean.OpenDecl

full_name: Lean.Elab.OpenDecl.State
code: /--
A local copy of name resolution state that allows us to immediately use new open decls
in further name resolution as in `open Lean Elab`.
-/
structure State where
  openDecls     : List OpenDecl
  currNamespace : Name
goal: Type

full_name: Lean.Elab.OpenDecl.M
code: abbrev M 
goal: Type

full_name: Lean.Elab.OpenDecl.instMonadResolveNameM
code: instance : MonadResolveName (M (m := m)) 
goal: Lean.MonadResolveName Lean.Elab.OpenDecl.M

full_name: Lean.Elab.OpenDecl.resolveId
code: def resolveId (ns : Name) (idStx : Syntax) : M (m := m) Name 
goal: Lean.Elab.OpenDecl.M Lean.Name

full_name: _private.«.lake».packages.lean4.src.lean.Lean.Elab.Open.0.Lean.Elab.OpenDecl.addOpenDecl
code: private def addOpenDecl (decl : OpenDecl) : M (m:=m) Unit 
goal: Lean.Elab.OpenDecl.M Unit

full_name: _private.«.lake».packages.lean4.src.lean.Lean.Elab.Open.0.Lean.Elab.OpenDecl.resolveNameUsingNamespacesCore
code: private def resolveNameUsingNamespacesCore (nss : List Name) (idStx : Syntax) : M (m:=m) Name 
goal: Lean.Elab.OpenDecl.M Lean.Name

full_name: Lean.Elab.OpenDecl.elabOpenDecl
code: def elabOpenDecl [MonadResolveName m] [MonadInfoTree m] (stx : TSyntax ``Parser.Command.openDecl) : m (List OpenDecl) 
goal: m (List Lean.OpenDecl)

full_name: Lean.Elab.OpenDecl.resolveNameUsingNamespaces
code: def resolveNameUsingNamespaces [MonadResolveName m] (nss : List Name) (idStx : Ident) : m Name 
goal: m Lean.Name
File: .lake/packages/lean4/src/lean/Lean/Elab/Deriving/FromToJson.lean

full_name: Lean.Elab.Deriving.FromToJson.mkJsonField
code: def mkJsonField (n : Name) : CoreM (Bool × Term) 
goal: Lean.CoreM (Bool × Lean.Term)

full_name: Lean.Elab.Deriving.FromToJson.mkToJsonInstance.mkAlts
code: def mkToJsonInstance (declName : Name) : CommandElabM Bool 
goal: Lean.Elab.TermElabM (Array (Lean.TSyntax `Lean.Parser.Term.matchAlt))

full_name: Lean.Elab.Deriving.FromToJson.mkToJsonInstance
code: def mkToJsonInstance (declName : Name) : CommandElabM Bool 
goal: Lean.Elab.Command.CommandElabM Bool

full_name: Lean.Elab.Deriving.FromToJson.mkFromJsonInstance
code: def mkFromJsonInstance (declName : Name) : CommandElabM Bool 
goal: Lean.Elab.Command.CommandElabM Bool

full_name: Lean.Elab.Deriving.FromToJson.mkFromJsonInstance.mkAlts
code: def mkFromJsonInstance (declName : Name) : CommandElabM Bool 
goal: Lean.Elab.TermElabM (Array Lean.Term)

full_name: Lean.Elab.Deriving.FromToJson.mkToJsonInstanceHandler
code: def mkToJsonInstanceHandler (declNames : Array Name) : CommandElabM Bool 
goal: Lean.Elab.Command.CommandElabM Bool

full_name: Lean.Elab.Deriving.FromToJson.mkFromJsonInstanceHandler
code: def mkFromJsonInstanceHandler (declNames : Array Name) : CommandElabM Bool 
goal: Lean.Elab.Command.CommandElabM Bool

full_name: Lean.Elab.Deriving.FromToJson.initFn._@..lake.packages.lean4.src.lean.Lean.Elab.Deriving.FromToJson._hyg.6240
code: builtin_initialize
  registerDerivingHandler ``ToJson mkToJsonInstanceHandler
  registerDerivingHandler ``FromJson mkFromJsonInstanceHandler
goal: IO Unit
File: .lake/packages/lean4/src/lean/Lean/Elab/SetOption.lean

full_name: Lean.Elab.elabSetOption
code: def elabSetOption (id : Syntax) (val : Syntax) : m Options 
goal: m Lean.Options

full_name: Lean.Elab.elabSetOption.setOption
code: def elabSetOption (id : Syntax) (val : Syntax) : m Options 
goal: m Lean.Options
File: .lake/packages/lean4/src/lean/Lean/ReservedNameAction.lean

full_name: Lean.ReservedNameAction
code: /--
When trying to resolve a reserved name, an action can be executed to generate the actual definition/theorem.
The action returns `true` if it "handled" the given name.

Remark: usually when one install a reserved name predicate, an associated action is also installed.
-/
def ReservedNameAction 
goal: Type

full_name: Lean.initFn._@..lake.packages.lean4.src.lean.Lean.ReservedNameAction._hyg.11
code: private builtin_initialize reservedNameActionsRef : IO.Ref (Array ReservedNameAction) ← IO.mkRef #[]
goal: IO (IO.Ref (Array Lean.ReservedNameAction))

full_name: _private.«.lake».packages.lean4.src.lean.Lean.ReservedNameAction.0.Lean.reservedNameActionsRef
code: private builtin_initialize reservedNameActionsRef : IO.Ref (Array ReservedNameAction) ← IO.mkRef #[]
goal: IO.Ref (Array Lean.ReservedNameAction)

full_name: Lean.registerReservedNameAction
code: /--
Register a new function that is invoked when trying to resolve a reserved name.
-/
def registerReservedNameAction (act : ReservedNameAction) : IO Unit 
goal: IO Unit

full_name: Lean.executeReservedNameAction
code: /--
Execute a registered reserved action for the given reserved name.
Note that the handler can throw an exception.
-/
def executeReservedNameAction (name : Name) : CoreM Unit 
goal: Lean.CoreM Unit

full_name: Lean.realizeGlobalName
code: /--
Similar to `resolveGlobalName`, but also executes reserved name actions.
-/
def realizeGlobalName (id : Name) : CoreM (List (Name × List String)) 
goal: Lean.CoreM (List (Lean.Name × List String))

full_name: Lean.realizeGlobalConstCore
code: /--
Similar to `resolveGlobalConstCore`, but also executes reserved name actions.
-/
def realizeGlobalConstCore (n : Name) : CoreM (List Name) 
goal: Lean.CoreM (List Lean.Name)

full_name: Lean.realizeGlobalConstNoOverloadCore
code: /--
Similar to `realizeGlobalConstNoOverloadCore`, but also executes reserved name actions.
-/
def realizeGlobalConstNoOverloadCore (n : Name) : CoreM Name 
goal: Lean.CoreM Lean.Name

full_name: Lean.realizeGlobalConst
code: /--
Similar to `resolveGlobalConst`, but also executes reserved name actions.

Consider using `realizeGlobalConstWithInfo` if you want the syntax to show the resulting name's info
on hover.
-/
def realizeGlobalConst (stx : Syntax) : CoreM (List Name) 
goal: Lean.CoreM (List Lean.Name)

full_name: Lean.realizeGlobalConstNoOverload
code: /--
Similar to `realizeGlobalConstNoOverload`, but also executes reserved name actions.

Consider using `realizeGlobalConstNoOverloadWithInfo` if you want the syntax to show the resulting
name's info on hover.
-/
def realizeGlobalConstNoOverload (id : Syntax) : CoreM Name 
goal: Lean.CoreM Lean.Name
File: Mathlib/GroupTheory/Subsemigroup/Center.lean

full_name: AddSubsemigroup.center
code: /-- The center of a semigroup `M` is the set of elements that commute with everything in `M` -/
@[to_additive
      "The center of a semigroup `M` is the set of elements that commute with everything in `M`"]
def center : Subsemigroup M 
goal: AddSubsemigroup M

full_name: Subsemigroup.center
code: /-- The center of a semigroup `M` is the set of elements that commute with everything in `M` -/
@[to_additive
      "The center of a semigroup `M` is the set of elements that commute with everything in `M`"]
def center : Subsemigroup M 
goal: Subsemigroup M

full_name: Subsemigroup.center.commSemigroup
code: /-- The center of a magma is commutative and associative. -/
@[to_additive "The center of an additive magma is commutative and associative."]
instance center.commSemigroup : CommSemigroup (center M) 
goal: CommSemigroup ↥(Subsemigroup.center M)

full_name: AddSubsemigroup.center.addCommSemigroup
code: /-- The center of a magma is commutative and associative. -/
@[to_additive "The center of an additive magma is commutative and associative."]
instance center.commSemigroup : CommSemigroup (center M) 
goal: AddCommSemigroup ↥(AddSubsemigroup.center M)

full_name: AddSubsemigroup.mem_center_iff
code: @[to_additive]
theorem mem_center_iff {z : M} : z ∈ center M ↔ ∀ g, g * z = z * g 
goal: z ∈ AddSubsemigroup.center M ↔ ∀ (g : M), g + z = z + g

full_name: Subsemigroup.mem_center_iff
code: @[to_additive]
theorem mem_center_iff {z : M} : z ∈ center M ↔ ∀ g, g * z = z * g 
goal: z ∈ Subsemigroup.center M ↔ ∀ (g : M), g * z = z * g

full_name: Subsemigroup.decidableMemCenter
code: @[to_additive]
instance decidableMemCenter (a) [Decidable <| ∀ b : M, b * a = a * b] :
    Decidable (a ∈ center M) 
goal: Decidable (a ∈ Subsemigroup.center M)

full_name: AddSubsemigroup.decidableMemCenter
code: @[to_additive]
instance decidableMemCenter (a) [Decidable <| ∀ b : M, b * a = a * b] :
    Decidable (a ∈ center M) 
goal: Decidable (a ∈ AddSubsemigroup.center M)

full_name: Subsemigroup.center_eq_top
code: @[to_additive (attr := simp)]
theorem center_eq_top : center M = ⊤ 
goal: Subsemigroup.center M = ⊤

full_name: AddSubsemigroup.center_eq_top
code: @[to_additive (attr := simp)]
theorem center_eq_top : center M = ⊤ 
goal: AddSubsemigroup.center M = ⊤
File: Mathlib/GroupTheory/Subgroup/Simple.lean

full_name: IsSimpleGroup
code: /-- A `Group` is simple when it has exactly two normal `Subgroup`s. -/
class IsSimpleGroup extends Nontrivial G : Prop where
  /-- Any normal subgroup is either `⊥` or `⊤` -/
  eq_bot_or_eq_top_of_normal : ∀ H : Subgroup G, H.Normal → H = ⊥ ∨ H = ⊤
goal: Prop

full_name: IsSimpleGroup.eq_bot_or_eq_top_of_normal
code: /-- A `Group` is simple when it has exactly two normal `Subgroup`s. -/
class IsSimpleGroup extends Nontrivial G : Prop where
  /-- Any normal subgroup is either `⊥` or `⊤` -/
  eq_bot_or_eq_top_of_normal : ∀ H : Subgroup G, H.Normal → H = ⊥ ∨ H = ⊤
goal: H.Normal → H = ⊥ ∨ H = ⊤

full_name: IsSimpleAddGroup.eq_bot_or_eq_top_of_normal
code: /-- An `AddGroup` is simple when it has exactly two normal `AddSubgroup`s. -/
class IsSimpleAddGroup extends Nontrivial A : Prop where
  /-- Any normal additive subgroup is either `⊥` or `⊤` -/
  eq_bot_or_eq_top_of_normal : ∀ H : AddSubgroup A, H.Normal → H = ⊥ ∨ H = ⊤
goal: H.Normal → H = ⊥ ∨ H = ⊤

full_name: IsSimpleAddGroup
code: /-- An `AddGroup` is simple when it has exactly two normal `AddSubgroup`s. -/
class IsSimpleAddGroup extends Nontrivial A : Prop where
  /-- Any normal additive subgroup is either `⊥` or `⊤` -/
  eq_bot_or_eq_top_of_normal : ∀ H : AddSubgroup A, H.Normal → H = ⊥ ∨ H = ⊤
goal: Prop

full_name: AddSubgroup.Normal.eq_bot_or_eq_top
code: @[to_additive]
theorem Subgroup.Normal.eq_bot_or_eq_top [IsSimpleGroup G] {H : Subgroup G} (Hn : H.Normal) :
    H = ⊥ ∨ H = ⊤ 
goal: H = ⊥ ∨ H = ⊤

full_name: Subgroup.Normal.eq_bot_or_eq_top
code: @[to_additive]
theorem Subgroup.Normal.eq_bot_or_eq_top [IsSimpleGroup G] {H : Subgroup G} (Hn : H.Normal) :
    H = ⊥ ∨ H = ⊤ 
goal: H = ⊥ ∨ H = ⊤

full_name: IsSimpleGroup.instIsSimpleOrderSubgroup
code: @[to_additive]
instance {C : Type*} [CommGroup C] [IsSimpleGroup C] : IsSimpleOrder (Subgroup C) 
goal: IsSimpleOrder (Subgroup C)

full_name: IsSimpleAddGroup.instIsSimpleOrderAddSubgroup
code: @[to_additive]
instance {C : Type*} [CommGroup C] [IsSimpleGroup C] : IsSimpleOrder (Subgroup C) 
goal: IsSimpleOrder (AddSubgroup C)

full_name: IsSimpleAddGroup.isSimpleAddGroup_of_surjective
code: @[to_additive]
theorem isSimpleGroup_of_surjective {H : Type*} [Group H] [IsSimpleGroup G] [Nontrivial H]
    (f : G →* H) (hf : Function.Surjective f) : IsSimpleGroup H 
goal: IsSimpleAddGroup H

full_name: IsSimpleGroup.isSimpleGroup_of_surjective
code: @[to_additive]
theorem isSimpleGroup_of_surjective {H : Type*} [Group H] [IsSimpleGroup G] [Nontrivial H]
    (f : G →* H) (hf : Function.Surjective f) : IsSimpleGroup H 
goal: IsSimpleGroup H
File: Mathlib/GroupTheory/FixedPointFree.lean

full_name: MonoidHom.FixedPointFree
code: /-- A function `φ : G → G` is fixed-point-free if `1 : G` is the only fixed point of `φ`. -/
def FixedPointFree [One G] 
goal: Prop

full_name: MonoidHom.commutatorMap
code: /-- The commutator map `g ↦ g / φ g`. If `φ g = h * g * h⁻¹`, then `g / φ g` is exactly the
  commutator `[g, h] = g * h * g⁻¹ * h⁻¹`. -/
def commutatorMap [Div G] (g : G) 
goal: G

full_name: MonoidHom.commutatorMap_apply
code: @[simp] theorem commutatorMap_apply [Div G] (g : G) : commutatorMap φ g = g / φ g 
goal: MonoidHom.commutatorMap φ g = g / φ g

full_name: MonoidHom.FixedPointFree.commutatorMap_injective
code: theorem commutatorMap_injective (hφ : FixedPointFree φ) : Function.Injective (commutatorMap φ) 
goal: Function.Injective (MonoidHom.commutatorMap ⇑φ)

full_name: MonoidHom.FixedPointFree.commutatorMap_surjective
code: theorem commutatorMap_surjective (hφ : FixedPointFree φ) : Function.Surjective (commutatorMap φ) 
goal: Function.Surjective (MonoidHom.commutatorMap ⇑φ)

full_name: MonoidHom.FixedPointFree.prod_pow_eq_one
code: theorem prod_pow_eq_one (hφ : FixedPointFree φ) {n : ℕ} (hn : φ^[n] = _root_.id) (g : G) :
    ((List.range n).map (fun k ↦ φ^[k] g)).prod = 1 
goal: (List.map (fun k => (⇑φ)^[k] g) (List.range n)).prod = 1

full_name: MonoidHom.FixedPointFree.coe_eq_inv_of_sq_eq_one
code: theorem coe_eq_inv_of_sq_eq_one (hφ : FixedPointFree φ) (h2 : φ^[2] = _root_.id) : ⇑φ = (·⁻¹) 
goal: ⇑φ = fun x => x⁻¹

full_name: MonoidHom.FixedPointFree.coe_eq_inv_of_involutive
code: theorem coe_eq_inv_of_involutive (hφ : FixedPointFree φ) (h2 : Function.Involutive φ) :
    ⇑φ = (·⁻¹) 
goal: ⇑φ = fun x => x⁻¹

full_name: MonoidHom.FixedPointFree.commute_all_of_involutive
code: theorem commute_all_of_involutive (hφ : FixedPointFree φ) (h2 : Function.Involutive φ) (g h : G) :
    Commute g h 
goal: Commute g h

full_name: MonoidHom.FixedPointFree.commGroupOfInvolutive
code: /-- If a finite group admits a fixed-point-free involution, then it is commutative. -/
def commGroupOfInvolutive (hφ : FixedPointFree φ) (h2 : Function.Involutive φ):
    CommGroup G 
goal: CommGroup G

full_name: MonoidHom.FixedPointFree.orderOf_ne_two_of_involutive
code: theorem orderOf_ne_two_of_involutive (hφ : FixedPointFree φ) (h2 : Function.Involutive φ) (g : G) :
    orderOf g ≠ 2 
goal: orderOf g ≠ 2

full_name: MonoidHom.FixedPointFree.odd_card_of_involutive
code: theorem odd_card_of_involutive (hφ : FixedPointFree φ) (h2 : Function.Involutive φ) :
    Odd (Nat.card G) 
goal: Odd (Nat.card G)

full_name: MonoidHom.FixedPointFree.odd_orderOf_of_involutive
code: theorem odd_orderOf_of_involutive (hφ : FixedPointFree φ) (h2 : Function.Involutive φ) (g : G) :
    Odd (orderOf g) 
goal: Odd (orderOf g)