ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
File: Mathlib/GroupTheory/Commensurable.lean

full_name: Commensurable
code: /-- Two subgroups `H K` of `G` are commensurable if `H ⊓ K` has finite index in both `H` and `K` -/
def Commensurable (H K : Subgroup G) : Prop 
goal: Prop

full_name: Commensurable.refl
code: @[refl]
protected theorem refl (H : Subgroup G) : Commensurable H H 
goal: Commensurable H H

full_name: Commensurable.comm
code: theorem comm {H K : Subgroup G} : Commensurable H K ↔ Commensurable K H 
goal: Commensurable H K ↔ Commensurable K H

full_name: Commensurable.symm
code: @[symm]
theorem symm {H K : Subgroup G} : Commensurable H K → Commensurable K H 
goal: Commensurable H K → Commensurable K H

full_name: Commensurable.trans
code: @[trans]
theorem trans {H K L : Subgroup G} (hhk : Commensurable H K) (hkl : Commensurable K L) :
    Commensurable H L 
goal: Commensurable H L

full_name: Commensurable.equivalence
code: theorem equivalence : Equivalence (@Commensurable G _) 
goal: Equivalence Commensurable

full_name: Commensurable.quotConjEquiv
code: /-- Equivalence of `K/H ⊓ K` with `gKg⁻¹/gHg⁻¹ ⊓ gKg⁻¹`-/
def quotConjEquiv (H K : Subgroup G) (g : ConjAct G) :
    K ⧸ H.subgroupOf K ≃ (g • K).1 ⧸ (g • H).subgroupOf (g • K) 
goal: ↥K ⧸ H.subgroupOf K ≃ ↥(g • K).toSubmonoid ⧸ (g • H).subgroupOf (g • K)

full_name: Commensurable.commensurable_conj
code: theorem commensurable_conj {H K : Subgroup G} (g : ConjAct G) :
    Commensurable H K ↔ Commensurable (g • H) (g • K) 
goal: Commensurable H K ↔ Commensurable (g • H) (g • K)

full_name: Commensurable.commensurable_inv
code: theorem commensurable_inv (H : Subgroup G) (g : ConjAct G) :
    Commensurable (g • H) H ↔ Commensurable H (g⁻¹ • H) 
goal: Commensurable (g • H) H ↔ Commensurable H (g⁻¹ • H)

full_name: Commensurable.commensurator'
code: /-- For `H` a subgroup of `G`, this is the subgroup of all elements `g : conjAut G`
such that `Commensurable (g • H) H` -/
def commensurator' (H : Subgroup G) : Subgroup (ConjAct G) 
goal: Subgroup (ConjAct G)

full_name: Commensurable.commensurator
code: /-- For `H` a subgroup of `G`, this is the subgroup of all elements `g : G`
such that `Commensurable (g H g⁻¹) H` -/
def commensurator (H : Subgroup G) : Subgroup G 
goal: Subgroup G

full_name: Commensurable.commensurator'_mem_iff
code: @[simp]
theorem commensurator'_mem_iff (H : Subgroup G) (g : ConjAct G) :
    g ∈ commensurator' H ↔ Commensurable (g • H) H 
goal: g ∈ Commensurable.commensurator' H ↔ Commensurable (g • H) H

full_name: Commensurable.commensurator_mem_iff
code: @[simp]
theorem commensurator_mem_iff (H : Subgroup G) (g : G) :
    g ∈ commensurator H ↔ Commensurable (ConjAct.toConjAct g • H) H 
goal: g ∈ Commensurable.commensurator H ↔ Commensurable (ConjAct.toConjAct g • H) H

full_name: Commensurable.eq
code: theorem eq {H K : Subgroup G} (hk : Commensurable H K) : commensurator H = commensurator K 
goal: Commensurable.commensurator H = Commensurable.commensurator K
File: Mathlib/GroupTheory/Perm/Subgroup.lean

full_name: Equiv.Perm.sumCongrHom.decidableMemRange
code: instance sumCongrHom.decidableMemRange {α β : Type*} [DecidableEq α] [DecidableEq β] [Fintype α]
    [Fintype β] : DecidablePred (· ∈ (sumCongrHom α β).range) 
goal: DecidablePred fun x => x ∈ (Equiv.Perm.sumCongrHom α β).range

full_name: Equiv.Perm.sumCongrHom.card_range
code: @[simp]
theorem sumCongrHom.card_range {α β : Type*} [Fintype (sumCongrHom α β).range]
    [Fintype (Perm α × Perm β)] :
    Fintype.card (sumCongrHom α β).range = Fintype.card (Perm α × Perm β) 
goal: Fintype.card ↥(Equiv.Perm.sumCongrHom α β).range = Fintype.card (Equiv.Perm α × Equiv.Perm β)

full_name: Equiv.Perm.sigmaCongrRightHom.decidableMemRange
code: instance sigmaCongrRightHom.decidableMemRange {α : Type*} {β : α → Type*} [DecidableEq α]
    [∀ a, DecidableEq (β a)] [Fintype α] [∀ a, Fintype (β a)] :
    DecidablePred (· ∈ (sigmaCongrRightHom β).range) 
goal: DecidablePred fun x => x ∈ (Equiv.Perm.sigmaCongrRightHom β).range

full_name: Equiv.Perm.sigmaCongrRightHom.card_range
code: @[simp]
theorem sigmaCongrRightHom.card_range {α : Type*} {β : α → Type*}
    [Fintype (sigmaCongrRightHom β).range] [Fintype (∀ a, Perm (β a))] :
    Fintype.card (sigmaCongrRightHom β).range = Fintype.card (∀ a, Perm (β a)) 
goal: Fintype.card ↥(Equiv.Perm.sigmaCongrRightHom β).range = Fintype.card ((a : α) → Equiv.Perm (β a))

full_name: Equiv.Perm.subtypeCongrHom.decidableMemRange
code: instance subtypeCongrHom.decidableMemRange {α : Type*} (p : α → Prop) [DecidablePred p]
    [Fintype (Perm { a // p a } × Perm { a // ¬p a })] [DecidableEq (Perm α)] :
    DecidablePred (· ∈ (subtypeCongrHom p).range) 
goal: DecidablePred fun x => x ∈ (Equiv.Perm.subtypeCongrHom p).range

full_name: Equiv.Perm.subtypeCongrHom.card_range
code: @[simp]
theorem subtypeCongrHom.card_range {α : Type*} (p : α → Prop) [DecidablePred p]
    [Fintype (subtypeCongrHom p).range] [Fintype (Perm { a // p a } × Perm { a // ¬p a })] :
    Fintype.card (subtypeCongrHom p).range =
      Fintype.card (Perm { a // p a } × Perm { a // ¬p a }) 
goal: Fintype.card ↥(Equiv.Perm.subtypeCongrHom p).range = Fintype.card (Equiv.Perm { a // p a } × Equiv.Perm { a // ¬p a })

full_name: Equiv.Perm.subgroupOfMulAction
code: /-- **Cayley's theorem**: Every group G is isomorphic to a subgroup of the symmetric group acting on
`G`. Note that we generalize this to an arbitrary "faithful" group action by `G`. Setting `H = G`
recovers the usual statement of Cayley's theorem via `RightCancelMonoid.faithfulSMul` -/
noncomputable def subgroupOfMulAction (G H : Type*) [Group G] [MulAction G H] [FaithfulSMul G H] :
    G ≃* (MulAction.toPermHom G H).range 
goal: G ≃* ↥(MulAction.toPermHom G H).range
File: Mathlib/GroupTheory/Perm/DomMulAct.lean

full_name: DomMulAct.mem_stabilizer_iff
code: lemma mem_stabilizer_iff {g : (Perm α)ᵈᵐᵃ} :
    g ∈ stabilizer (Perm α)ᵈᵐᵃ f ↔ f ∘ (mk.symm g :) = f 
goal: g ∈ MulAction.stabilizer (Equiv.Perm α)ᵈᵐᵃ f ↔ f ∘ ⇑(DomMulAct.mk.symm g) = f

full_name: DomMulAct.stabilizerEquiv_invFun
code: /-- The `invFun` component of `MulEquiv` from `MulAction.stabilizer (Perm α) f`
  to the product of the `Equiv.Perm {a // f a = i} -/
def stabilizerEquiv_invFun (g : ∀ i, Perm {a // f a = i}) (a : α) : α 
goal: α

full_name: DomMulAct.stabilizerEquiv_invFun_eq
code: lemma stabilizerEquiv_invFun_eq (g : ∀ i, Perm {a // f a = i}) {a : α} {i : ι} (h : f a = i) :
    stabilizerEquiv_invFun g a = g i ⟨a, h⟩ 
goal: DomMulAct.stabilizerEquiv_invFun g a = ↑((g i) ⟨a, h⟩)

full_name: DomMulAct.comp_stabilizerEquiv_invFun
code: lemma comp_stabilizerEquiv_invFun (g : ∀ i, Perm {a // f a = i}) (a : α) :
    f (stabilizerEquiv_invFun g a) = f a 
goal: f (DomMulAct.stabilizerEquiv_invFun g a) = f a

full_name: DomMulAct.stabilizerEquiv_invFun_aux
code: /-- The `invFun` component of `MulEquiv` from `MulAction.stabilizer (Perm α) p`
  to the product of the `Equiv.Perm {a | f a = i} (as an `Equiv.Perm α`) -/
def stabilizerEquiv_invFun_aux (g : ∀ i, Perm {a // f a = i}) : Perm α 
goal: Equiv.Perm α

full_name: DomMulAct.stabilizerMulEquiv
code: /-- The `MulEquiv` from the `MulOpposite` of `MulAction.stabilizer (Perm α)ᵈᵐᵃ f`
  to the product of the `Equiv.Perm {a // f a = i}` -/
def stabilizerMulEquiv : (stabilizer (Perm α)ᵈᵐᵃ f)ᵐᵒᵖ ≃* (∀ i, Perm {a // f a = i}) 
goal: (↥(MulAction.stabilizer (Equiv.Perm α)ᵈᵐᵃ f))ᵐᵒᵖ ≃* ((i : ι) → Equiv.Perm { a // f a = i })

full_name: DomMulAct.stabilizerMulEquiv_apply
code: lemma stabilizerMulEquiv_apply (g : (stabilizer (Perm α)ᵈᵐᵃ f)ᵐᵒᵖ) {a : α} {i : ι} (h : f a = i) :
    ((stabilizerMulEquiv f)) g i ⟨a, h⟩ = (mk.symm g.unop : Equiv.Perm α) a 
goal: ↑(((DomMulAct.stabilizerMulEquiv f) g i) ⟨a, h⟩) = (DomMulAct.mk.symm ↑(MulOpposite.unop g)) a

full_name: DomMulAct.stabilizer_card
code: /-- The cardinality of the type of permutations preserving a function -/
theorem stabilizer_card :
    Fintype.card {g : Perm α // f ∘ g = f} = ∏ i, (Fintype.card {a // f a = i})! 
goal: Fintype.card { g // f ∘ ⇑g = f } = ∏ i : ι, (Fintype.card { a // f a = i }).factorial
File: Mathlib/GroupTheory/Perm/Cycle/PossibleTypes.lean

full_name: Equiv.Perm.exists_with_cycleType_iff
code: /-- There are permutations with cycleType `m` if and only if
  its sum is at most `Fintype.card α` and its members are at least 2. -/
theorem Equiv.Perm.exists_with_cycleType_iff {m : Multiset ℕ} :
    (∃ g : Equiv.Perm α, g.cycleType = m) ↔
      (m.sum ≤ Fintype.card α ∧ ∀ a ∈ m, 2 ≤ a) 
goal: (∃ g, g.cycleType = m) ↔ m.sum ≤ Fintype.card α ∧ ∀ a ∈ m, 2 ≤ a
File: Mathlib/GroupTheory/Perm/ViaEmbedding.lean

full_name: Equiv.Perm.viaEmbedding
code: /-- Noncomputable version of `Equiv.Perm.viaFintypeEmbedding` that does not assume `Fintype` -/
noncomputable def viaEmbedding : Perm β 
goal: Equiv.Perm β

full_name: Equiv.Perm.viaEmbedding_apply
code: theorem viaEmbedding_apply (x : α) : e.viaEmbedding ι (ι x) = ι (e x) 
goal: (e.viaEmbedding ι) (ι x) = ι (e x)

full_name: Equiv.Perm.viaEmbedding_apply_of_not_mem
code: theorem viaEmbedding_apply_of_not_mem (x : β) (hx : x ∉ Set.range ι) : e.viaEmbedding ι x = x 
goal: (e.viaEmbedding ι) x = x

full_name: Equiv.Perm.viaEmbeddingHom
code: /-- `viaEmbedding` as a group homomorphism -/
noncomputable def viaEmbeddingHom : Perm α →* Perm β 
goal: Equiv.Perm α →* Equiv.Perm β

full_name: Equiv.Perm.viaEmbeddingHom_apply
code: theorem viaEmbeddingHom_apply : viaEmbeddingHom ι e = viaEmbedding e ι 
goal: (Equiv.Perm.viaEmbeddingHom ι) e = e.viaEmbedding ι

full_name: Equiv.Perm.viaEmbeddingHom_injective
code: theorem viaEmbeddingHom_injective : Function.Injective (viaEmbeddingHom ι) 
goal: Function.Injective ⇑(Equiv.Perm.viaEmbeddingHom ι)
File: Mathlib/GroupTheory/Perm/Closure.lean

full_name: Equiv.Perm.closure_isCycle
code: theorem closure_isCycle : closure { σ : Perm β | IsCycle σ } = ⊤ 
goal: Subgroup.closure {σ | σ.IsCycle} = ⊤

full_name: Equiv.Perm.closure_cycle_adjacent_swap
code: theorem closure_cycle_adjacent_swap {σ : Perm α} (h1 : IsCycle σ) (h2 : σ.support = ⊤) (x : α) :
    closure ({σ, swap x (σ x)} : Set (Perm α)) = ⊤ 
goal: Subgroup.closure {σ, Equiv.swap x (σ x)} = ⊤

full_name: Equiv.Perm.closure_cycle_coprime_swap
code: theorem closure_cycle_coprime_swap {n : ℕ} {σ : Perm α} (h0 : Nat.Coprime n (Fintype.card α))
    (h1 : IsCycle σ) (h2 : σ.support = Finset.univ) (x : α) :
    closure ({σ, swap x ((σ ^ n) x)} : Set (Perm α)) = ⊤ 
goal: Subgroup.closure {σ, Equiv.swap x ((σ ^ n) x)} = ⊤

full_name: Equiv.Perm.closure_prime_cycle_swap
code: theorem closure_prime_cycle_swap {σ τ : Perm α} (h0 : (Fintype.card α).Prime) (h1 : IsCycle σ)
    (h2 : σ.support = Finset.univ) (h3 : IsSwap τ) : closure ({σ, τ} : Set (Perm α)) = ⊤ 
goal: Subgroup.closure {σ, τ} = ⊤
File: Mathlib/Control/Combinators.lean

full_name: joinM
code: def joinM {m : Type u → Type u} [Monad m] {α : Type u} (a : m (m α)) : m α 
goal: m α

full_name: when
code: def when {m : Type → Type} [Monad m] (c : Prop) [Decidable c] (t : m Unit) : m Unit 
goal: m Unit

full_name: condM
code: def condM {m : Type → Type} [Monad m] {α : Type} (mbool : m Bool) (tm fm : m α) : m α 
goal: m α

full_name: whenM
code: def whenM {m : Type → Type} [Monad m] (c : m Bool) (t : m Unit) : m Unit 
goal: m Unit

full_name: Monad.mapM
code: def mapM 
goal: m (List β)

full_name: Monad.mapM'
code: def mapM' 
goal: List α → m (List β)

full_name: Monad.join
code: def join 
goal: m α

full_name: Monad.filter
code: def filter 
goal: m (List α)

full_name: Monad.foldl
code: def foldl 
goal: List α → m s

full_name: Monad.cond
code: def cond 
goal: m α

full_name: Monad.sequence
code: def sequence {m : Type u → Type v} [Monad m] {α : Type u} : List (m α) → m (List α)
  
goal: List (m α) → m (List α)

full_name: Monad.sequence'
code: def sequence' {m : Type → Type u} [Monad m] {α : Type} : List (m α) → m Unit
  
goal: List (m α) → m Unit

full_name: Monad.whenb
code: def whenb {m : Type → Type} [Monad m] (b : Bool) (t : m Unit) : m Unit 
goal: m Unit

full_name: Monad.unlessb
code: def unlessb {m : Type → Type} [Monad m] (b : Bool) (t : m Unit) : m Unit 
goal: m Unit
File: Mathlib/GroupTheory/Archimedean.lean

full_name: AddSubgroup.cyclic_of_min
code: /-- Given a subgroup `H` of a decidable linearly ordered archimedean abelian group `G`, if there
exists a minimal element `a` of `H ∩ G_{>0}` then `H` is generated by `a`. -/
theorem AddSubgroup.cyclic_of_min {H : AddSubgroup G} {a : G}
    (ha : IsLeast { g : G | g ∈ H ∧ 0 < g } a) : H = AddSubgroup.closure {a} 
goal: H = AddSubgroup.closure {a}

full_name: AddSubgroup.exists_isLeast_pos
code: /-- If a nontrivial additive subgroup of a linear ordered additive commutative group is disjoint
with the interval `Set.Ioo 0 a` for some positive `a`, then the set of positive elements of this
group admits the least element. -/
theorem AddSubgroup.exists_isLeast_pos {H : AddSubgroup G} (hbot : H ≠ ⊥) {a : G} (h₀ : 0 < a)
    (hd : Disjoint (H : Set G) (Ioo 0 a)) : ∃ b, IsLeast { g : G | g ∈ H ∧ 0 < g } b 
goal: ∃ b, IsLeast {g | g ∈ H ∧ 0 < g} b

full_name: AddSubgroup.cyclic_of_isolated_zero
code: /-- If an additive subgroup of a linear ordered additive commutative group is disjoint with the
interval `Set.Ioo 0 a` for some positive `a`, then this is a cyclic subgroup. -/
theorem AddSubgroup.cyclic_of_isolated_zero {H : AddSubgroup G} {a : G} (h₀ : 0 < a)
    (hd : Disjoint (H : Set G) (Ioo 0 a)) : ∃ b, H = closure {b} 
goal: ∃ b, H = AddSubgroup.closure {b}

full_name: Int.subgroup_cyclic
code: /-- Every subgroup of `ℤ` is cyclic. -/
theorem Int.subgroup_cyclic (H : AddSubgroup ℤ) : ∃ a, H = AddSubgroup.closure {a} 
goal: ∃ a, H = AddSubgroup.closure {a}
File: Mathlib/GroupTheory/FiniteAbelian.lean

full_name: _private.Mathlib.GroupTheory.FiniteAbelian.0.directSumNeZeroMulHom
code: private def directSumNeZeroMulHom {ι : Type} [DecidableEq ι] (p : ι → ℕ) (n : ι → ℕ) :
    (⨁ i : {i // n i ≠ 0}, ZMod (p i ^ n i)) →+ ⨁ i, ZMod (p i ^ n i) 
goal: (⨁ (i : { i // n i ≠ 0 }), ZMod (p ↑i ^ n ↑i)) →+ ⨁ (i : ι), ZMod (p i ^ n i)

full_name: _private.Mathlib.GroupTheory.FiniteAbelian.0.directSumNeZeroMulEquiv
code: private def directSumNeZeroMulEquiv (ι : Type) [DecidableEq ι] (p : ι → ℕ) (n : ι → ℕ) :
    (⨁ i : {i // n i ≠ 0}, ZMod (p i ^ n i)) ≃+ ⨁ i, ZMod (p i ^ n i) 
goal: (⨁ (i : { i // n i ≠ 0 }), ZMod (p ↑i ^ n ↑i)) ≃+ ⨁ (i : ι), ZMod (p i ^ n i)

full_name: Module.finite_of_fg_torsion
code: theorem finite_of_fg_torsion [AddCommGroup M] [Module ℤ M] [Module.Finite ℤ M]
    (hM : Module.IsTorsion ℤ M) : _root_.Finite M 
goal: Finite M

full_name: AddCommGroup.equiv_free_prod_directSum_zmod
code: /-- **Structure theorem of finitely generated abelian groups** : Any finitely generated abelian
group is the product of a power of `ℤ` and a direct sum of some `ZMod (p i ^ e i)` for some
prime powers `p i ^ e i`. -/
theorem equiv_free_prod_directSum_zmod [hG : AddGroup.FG G] :
    ∃ (n : ℕ) (ι : Type) (_ : Fintype ι) (p : ι → ℕ) (_ : ∀ i, Nat.Prime <| p i) (e : ι → ℕ),
      Nonempty <| G ≃+ (Fin n →₀ ℤ) × ⨁ i : ι, ZMod (p i ^ e i) 
goal: ∃ n ι x p, ∃ (_ : ∀ (i : ι), Nat.Prime (p i)), ∃ e, Nonempty (G ≃+ (Fin n →₀ ℤ) × ⨁ (i : ι), ZMod (p i ^ e i))

full_name: AddCommGroup.equiv_directSum_zmod_of_finite
code: /-- **Structure theorem of finite abelian groups** : Any finite abelian group is a direct sum of
some `ZMod (p i ^ e i)` for some prime powers `p i ^ e i`. -/
theorem equiv_directSum_zmod_of_finite [Finite G] :
    ∃ (ι : Type) (_ : Fintype ι) (p : ι → ℕ) (_ : ∀ i, Nat.Prime <| p i) (e : ι → ℕ),
      Nonempty <| G ≃+ ⨁ i : ι, ZMod (p i ^ e i) 
goal: ∃ ι x p, ∃ (_ : ∀ (i : ι), Nat.Prime (p i)), ∃ e, Nonempty (G ≃+ ⨁ (i : ι), ZMod (p i ^ e i))

full_name: AddCommGroup.equiv_directSum_zmod_of_finite'
code: /-- **Structure theorem of finite abelian groups** : Any finite abelian group is a direct sum of
some `ZMod (q i)` for some prime powers `q i > 1`. -/
lemma equiv_directSum_zmod_of_finite' (G : Type*) [AddCommGroup G] [Finite G] :
    ∃ (ι : Type) (_ : Fintype ι) (n : ι → ℕ),
      (∀ i, 1 < n i) ∧ Nonempty (G ≃+ ⨁ i, ZMod (n i)) 
goal: ∃ ι x n, (∀ (i : ι), 1 < n i) ∧ Nonempty (G ≃+ ⨁ (i : ι), ZMod (n i))

full_name: AddCommGroup.finite_of_fg_torsion
code: theorem finite_of_fg_torsion [hG' : AddGroup.FG G] (hG : AddMonoid.IsTorsion G) : Finite G 
goal: Finite G

full_name: CommGroup.finite_of_fg_torsion
code: theorem finite_of_fg_torsion [CommGroup G] [Group.FG G] (hG : Monoid.IsTorsion G) : Finite G 
goal: Finite G
File: Mathlib/Control/EquivFunctor/Instances.lean

full_name: EquivFunctorUnique
code: instance EquivFunctorUnique : EquivFunctor Unique 
goal: EquivFunctor Unique

full_name: EquivFunctorPerm
code: instance EquivFunctorPerm : EquivFunctor Perm 
goal: EquivFunctor Equiv.Perm

full_name: EquivFunctorFinset
code: instance EquivFunctorFinset : EquivFunctor Finset 
goal: EquivFunctor Finset

full_name: EquivFunctorFintype
code: instance EquivFunctorFintype : EquivFunctor Fintype 
goal: EquivFunctor Fintype
File: Mathlib/Control/Monad/Basic.lean

full_name: map_eq_bind_pure_comp
code: @[monad_norm]
theorem map_eq_bind_pure_comp (m : Type u → Type v) [Monad m] [LawfulMonad m]
    (f : α → β) (x : m α) : f <$> x = x >>= pure ∘ f 
goal: f <$> x = x >>= pure ∘ f

full_name: StateT.eval
code: /-- run a `StateT` program and discard the final state -/
def StateT.eval {m : Type u → Type v} [Functor m] (cmd : StateT σ m α) (s : σ) : m α 
goal: m α

full_name: StateT.equiv
code: /-- reduce the equivalence between two state monads to the equivalence between
their respective function spaces -/
def StateT.equiv {σ₁ α₁ : Type u₀} {σ₂ α₂ : Type u₁}
    {m₁ : Type u₀ → Type v₀} {m₂ : Type u₁ → Type v₁}
    (F : (σ₁ → m₁ (α₁ × σ₁)) ≃ (σ₂ → m₂ (α₂ × σ₂))) : StateT σ₁ m₁ α₁ ≃ StateT σ₂ m₂ α₂ 
goal: StateT σ₁ m₁ α₁ ≃ StateT σ₂ m₂ α₂

full_name: ReaderT.equiv
code: /-- reduce the equivalence between two reader monads to the equivalence between
their respective function spaces -/
def ReaderT.equiv {ρ₁ α₁ : Type u₀} {ρ₂ α₂ : Type u₁}
    {m₁ : Type u₀ → Type v₀} {m₂ : Type u₁ → Type v₁}
    (F : (ρ₁ → m₁ α₁) ≃ (ρ₂ → m₂ α₂)) : ReaderT ρ₁ m₁ α₁ ≃ ReaderT ρ₂ m₂ α₂ 
goal: ReaderT ρ₁ m₁ α₁ ≃ ReaderT ρ₂ m₂ α₂
File: Mathlib/Control/Fix.lean

full_name: Fix.fix
code: /-- `Fix α` provides a `fix` operator to define recursive computation
via the fixed point of function of type `α → α`. -/
class Fix (α : Type*) where
  /-- `fix f` represents the computation of a fixed point for `f`. -/
  fix : (α → α) → α
goal: (α → α) → α

full_name: Fix
code: /-- `Fix α` provides a `fix` operator to define recursive computation
via the fixed point of function of type `α → α`. -/
class Fix (α : Type*) where
  /-- `fix f` represents the computation of a fixed point for `f`. -/
  fix : (α → α) → α
goal: Type u_3

full_name: Part.Fix.approx
code: /-- A series of successive, finite approximation of the fixed point of `f`, defined by
`approx f n = f^[n] ⊥`. The limit of this chain is the fixed point of `f`. -/
def Fix.approx : Stream' (∀ a, Part (β a))
  
goal: Stream' ((a : α) → Part (β a))

full_name: Part.fixAux
code: /-- loop body for finding the fixed point of `f` -/
def fixAux {p : ℕ → Prop} (i : Nat.Upto p) (g : ∀ j : Nat.Upto p, i < j → ∀ a, Part (β a)) :
    ∀ a, Part (β a) 
goal: Part (β a)

full_name: Part.fix
code: /-- The least fixed point of `f`.

If `f` is a continuous function (according to complete partial orders),
it satisfies the equations:

  1. `fix f = f (fix f)`          (is a fixed point)
  2. `∀ X, f X ≤ X → fix f ≤ X`   (least fixed point)
-/
protected def fix (x : α) : Part (β x) 
goal: Part (β x)

full_name: Part.fix_def
code: protected theorem fix_def {x : α} (h' : ∃ i, (Fix.approx f i x).Dom) :
    Part.fix f x = Fix.approx f (Nat.succ (Nat.find h')) x 
goal: Part.fix f x = Part.Fix.approx f (Nat.find h').succ x

full_name: Part.fix_def'
code: theorem fix_def' {x : α} (h' : ¬∃ i, (Fix.approx f i x).Dom) : Part.fix f x = none 
goal: Part.fix f x = Part.none

full_name: Part.hasFix
code: instance hasFix : Fix (Part α) 
goal: Fix (Part α)

full_name: Pi.Part.hasFix
code: instance Part.hasFix {β} : Fix (α → Part β) 
goal: Fix (α → Part β)
File: Mathlib/Control/Lawful.lean

full_name: StateT.mk
code: protected def mk (f : σ → m (α × σ)) : StateT σ m α 
goal: StateT σ m α

full_name: StateT.run_mk
code: @[simp]
theorem run_mk (f : σ → m (α × σ)) (st : σ) : StateT.run (StateT.mk f) st = f st 
goal: (StateT.mk f).run st = f st

full_name: ExceptT.run_mk
code: @[simp]
theorem run_mk (x : m (Except ε α)) : ExceptT.run (ExceptT.mk x) = x 
goal: (ExceptT.mk x).run = x

full_name: ExceptT.run_monadLift
code: @[simp]
theorem run_monadLift {n} [MonadLiftT n m] (x : n α) :
    (monadLift x : ExceptT ε m α).run = Except.ok <$> (monadLift x : m α) 
goal: (monadLift x).run = Except.ok <$> monadLift x

full_name: ExceptT.run_monadMap
code: @[simp]
theorem run_monadMap {n} [MonadFunctorT n m] (f : ∀ {α}, n α → n α) :
    (monadMap (@f) x : ExceptT ε m α).run = monadMap (@f) x.run 
goal: (monadMap f x).run = monadMap f x.run

full_name: ReaderT.mk
code: protected def mk (f : σ → m α) : ReaderT σ m α 
goal: ReaderT σ m α

full_name: ReaderT.run_mk
code: @[simp]
theorem run_mk (f : σ → m α) (r : σ) : ReaderT.run (ReaderT.mk f) r = f r 
goal: (ReaderT.mk f).run r = f r

full_name: OptionT.ext
code: @[ext] theorem ext {x x' : OptionT m α} (h : x.run = x'.run) : x = x' 
goal: x = x'

full_name: OptionT.run_mk
code: @[simp]
theorem run_mk (x : m (Option α)) : OptionT.run (OptionT.mk x) = x 
goal: (OptionT.mk x).run = x

full_name: OptionT.run_pure
code: @[simp]
theorem run_pure (a) : (pure a : OptionT m α).run = pure (some a) 
goal: (pure a).run = pure (some a)

full_name: OptionT.run_bind
code: @[simp]
theorem run_bind (f : α → OptionT m β) :
    (x >>= f).run = x.run >>= fun
                              | some a => OptionT.run (f a)
                              | none   => pure none 
goal: (x >>= f).run = do
  let x ← x.run
  match x with
    | some a => (f a).run
    | none => pure none

full_name: OptionT.run_map
code: @[simp]
theorem run_map (f : α → β) [LawfulMonad m] : (f <$> x).run = Option.map f <$> x.run 
goal: (f <$> x).run = Option.map f <$> x.run

full_name: OptionT.run_monadLift
code: @[simp]
theorem run_monadLift {n} [MonadLiftT n m] (x : n α) :
    (monadLift x : OptionT m α).run = (monadLift x : m α) >>= fun a => pure (some a) 
goal: (monadLift x).run = do
  let a ← monadLift x
  pure (some a)

full_name: OptionT.run_monadMap
code: @[simp]
theorem run_monadMap {n} [MonadFunctorT n m] (f : ∀ {α}, n α → n α) :
    (monadMap (@f) x : OptionT m α).run = monadMap (@f) x.run 
goal: (monadMap f x).run = monadMap f x.run

full_name: instLawfulMonadOptionT_mathlib
code: instance (m : Type u → Type v) [Monad m] [LawfulMonad m] : LawfulMonad (OptionT m) 
goal: LawfulMonad (OptionT m)

full_name: instLawfulMonadEIO_mathlib
code: instance : LawfulMonad (EIO ε) 
goal: LawfulMonad (EIO ε)

full_name: instLawfulMonadBaseIO_mathlib
code: instance : LawfulMonad BaseIO 
goal: LawfulMonad BaseIO

full_name: instLawfulMonadIO_mathlib
code: instance : LawfulMonad IO 
goal: LawfulMonad IO

full_name: instLawfulMonadEST_mathlib
code: instance : LawfulMonad (EST ε σ) 
goal: LawfulMonad (EST ε σ)

full_name: instLawfulMonadST_mathlib
code: instance : LawfulMonad (ST ε) 
goal: LawfulMonad (ST ε)