ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- MonoidHom.transfer_def
@[to_additive]
theorem transfer_def [FiniteIndex H] (g : G) : transfer ϕ g = diff ϕ T (g • T) 
Arguments: {G : Type u_1} [Group G] {H : Subgroup G} {A : Type u_2} [CommGroup A] (ϕ : ↥H →* A) (T : ↑(Subgroup.leftTransversals ↑H)) [H.FiniteIndex] (g : G)
Goal: ϕ.transfer g = Subgroup.leftTransversals.diff ϕ T (g • T)
-- MonoidHom.transfer_eq_prod_quotient_orbitRel_zpowers_quot
theorem transfer_eq_prod_quotient_orbitRel_zpowers_quot [FiniteIndex H] (g : G)
    [Fintype (Quotient (orbitRel (zpowers g) (G ⧸ H)))] :
    transfer ϕ g =
      ∏ q : Quotient (orbitRel (zpowers g) (G ⧸ H)),
        ϕ
          ⟨q.out'.out'⁻¹ * g ^ Function.minimalPeriod (g • ·) q.out' * q.out'.out',
            QuotientGroup.out'_conj_pow_minimalPeriod_mem H g q.out'⟩ 
Arguments: {G : Type u_1} [Group G] {H : Subgroup G} {A : Type u_2} [CommGroup A] (ϕ : ↥H →* A) [H.FiniteIndex] (g : G) [Fintype (Quotient (MulAction.orbitRel (↥(Subgroup.zpowers g)) (G ⧸ H)))]
Goal: ϕ.transfer g =
  ∏ q : Quotient (MulAction.orbitRel (↥(Subgroup.zpowers g)) (G ⧸ H)),
    ϕ ⟨(Quotient.out' q.out')⁻¹ * g ^ Function.minimalPeriod (fun x => g • x) q.out' * Quotient.out' q.out', ⋯⟩
-- MonoidHom.transfer_eq_pow_aux
theorem transfer_eq_pow_aux (g : G)
    (key : ∀ (k : ℕ) (g₀ : G), g₀⁻¹ * g ^ k * g₀ ∈ H → g₀⁻¹ * g ^ k * g₀ = g ^ k) :
    g ^ H.index ∈ H 
Arguments: {G : Type u_1} [Group G] {H : Subgroup G} (g : G) (key : ∀ (k : ℕ) (g₀ : G), g₀⁻¹ * g ^ k * g₀ ∈ H → g₀⁻¹ * g ^ k * g₀ = g ^ k)
Goal: g ^ H.index ∈ H
-- MonoidHom.transfer_eq_pow
theorem transfer_eq_pow [FiniteIndex H] (g : G)
    (key : ∀ (k : ℕ) (g₀ : G), g₀⁻¹ * g ^ k * g₀ ∈ H → g₀⁻¹ * g ^ k * g₀ = g ^ k) :
    transfer ϕ g = ϕ ⟨g ^ H.index, transfer_eq_pow_aux g key⟩ 
Arguments: {G : Type u_1} [Group G] {H : Subgroup G} {A : Type u_2} [CommGroup A] (ϕ : ↥H →* A) [H.FiniteIndex] (g : G) (key : ∀ (k : ℕ) (g₀ : G), g₀⁻¹ * g ^ k * g₀ ∈ H → g₀⁻¹ * g ^ k * g₀ = g ^ k)
Goal: ϕ.transfer g = ϕ ⟨g ^ H.index, ⋯⟩
-- MonoidHom.transfer_center_eq_pow
theorem transfer_center_eq_pow [FiniteIndex (center G)] (g : G) :
    transfer (MonoidHom.id (center G)) g = ⟨g ^ (center G).index, (center G).pow_index_mem g⟩ 
Arguments: {G : Type u_1} [Group G] [(Subgroup.center G).FiniteIndex] (g : G)
Goal: (MonoidHom.id ↥(Subgroup.center G)).transfer g = ⟨g ^ (Subgroup.center G).index, ⋯⟩
-- MonoidHom.transferCenterPow_apply
@[simp]
theorem transferCenterPow_apply [FiniteIndex (center G)] (g : G) :
    ↑(transferCenterPow G g) = g ^ (center G).index 
Arguments: {G : Type u_1} [Group G] [(Subgroup.center G).FiniteIndex] (g : G)
Goal: ↑((MonoidHom.transferCenterPow G) g) = g ^ (Subgroup.center G).index
-- MonoidHom.transferSylow_eq_pow_aux
theorem transferSylow_eq_pow_aux (g : G) (hg : g ∈ P) (k : ℕ) (g₀ : G)
    (h : g₀⁻¹ * g ^ k * g₀ ∈ P) : g₀⁻¹ * g ^ k * g₀ = g ^ k 
Arguments: {G : Type u_1} [Group G] {p : ℕ} (P : Sylow p G) (hP : (↑P).normalizer ≤ Subgroup.centralizer ↑P) [Fact (Nat.Prime p)] [Finite (Sylow p G)] (g : G) (hg : g ∈ P) (k : ℕ) (g₀ : G) (h : g₀⁻¹ * g ^ k * g₀ ∈ P)
Goal: g₀⁻¹ * g ^ k * g₀ = g ^ k
-- MonoidHom.transferSylow_eq_pow
theorem transferSylow_eq_pow (g : G) (hg : g ∈ P) :
    transferSylow P hP g =
      ⟨g ^ (P : Subgroup G).index, transfer_eq_pow_aux g (transferSylow_eq_pow_aux P hP g hg)⟩ 
Arguments: {G : Type u_1} [Group G] {p : ℕ} (P : Sylow p G) (hP : (↑P).normalizer ≤ Subgroup.centralizer ↑P) [Fact (Nat.Prime p)] [Finite (Sylow p G)] [(↑P).FiniteIndex] (g : G) (hg : g ∈ P)
Goal: (MonoidHom.transferSylow P hP) g = ⟨g ^ (↑P).index, ⋯⟩
-- MonoidHom.transferSylow_restrict_eq_pow
theorem transferSylow_restrict_eq_pow : ⇑((transferSylow P hP).restrict (P : Subgroup G)) =
    (fun x : P => x ^ (P : Subgroup G).index) 
Arguments: {G : Type u_1} [Group G] {p : ℕ} (P : Sylow p G) (hP : (↑P).normalizer ≤ Subgroup.centralizer ↑P) [Fact (Nat.Prime p)] [Finite (Sylow p G)] [(↑P).FiniteIndex]
Goal: ⇑((MonoidHom.transferSylow P hP).restrict ↑P) = fun x => x ^ (↑P).index
-- MonoidHom.ker_transferSylow_isComplement'
theorem ker_transferSylow_isComplement' : IsComplement' (transferSylow P hP).ker P 
Arguments: {G : Type u_1} [Group G] {p : ℕ} (P : Sylow p G) (hP : (↑P).normalizer ≤ Subgroup.centralizer ↑P) [Fact (Nat.Prime p)] [Finite (Sylow p G)] [(↑P).FiniteIndex]
Goal: (MonoidHom.transferSylow P hP).ker.IsComplement' ↑P
-- MonoidHom.not_dvd_card_ker_transferSylow
theorem not_dvd_card_ker_transferSylow : ¬p ∣ Nat.card (transferSylow P hP).ker 
Arguments: {G : Type u_1} [Group G] {p : ℕ} (P : Sylow p G) (hP : (↑P).normalizer ≤ Subgroup.centralizer ↑P) [Fact (Nat.Prime p)] [Finite (Sylow p G)] [(↑P).FiniteIndex]
Goal: ¬p ∣ Nat.card ↥(MonoidHom.transferSylow P hP).ker
-- MonoidHom.ker_transferSylow_disjoint
theorem ker_transferSylow_disjoint (Q : Subgroup G) (hQ : IsPGroup p Q) :
    Disjoint (transferSylow P hP).ker Q 
Arguments: {G : Type u_1} [Group G] {p : ℕ} (P : Sylow p G) (hP : (↑P).normalizer ≤ Subgroup.centralizer ↑P) [Fact (Nat.Prime p)] [Finite (Sylow p G)] [(↑P).FiniteIndex] (Q : Subgroup G) (hQ : IsPGroup p ↥Q)
Goal: Disjoint (MonoidHom.transferSylow P hP).ker Q
-- Functor.map_id
theorem Functor.map_id : (id <$> ·) = (id : F α → F α) 
Arguments: {F : Type u → Type v} {α : Type u} [Functor F] [LawfulFunctor F]
Goal: (fun x => id <$> x) = id
-- Functor.map_comp_map
theorem Functor.map_comp_map (f : α → β) (g : β → γ) :
    ((g <$> ·) ∘ (f <$> ·) : F α → F γ) = ((g ∘ f) <$> ·) 
Arguments: {F : Type u → Type v} {α β γ : Type u} [Functor F] [LawfulFunctor F] (f : α → β) (g : β → γ)
Goal: ((fun x => g <$> x) ∘ fun x => f <$> x) = fun x => (g ∘ f) <$> x
-- Functor.ext
theorem Functor.ext {F} :
    ∀ {F1 : Functor F} {F2 : Functor F} [@LawfulFunctor F F1] [@LawfulFunctor F F2],
    (∀ (α β) (f : α → β) (x : F α), @Functor.map _ F1 _ _ f x = @Functor.map _ F2 _ _ f x) →
    F1 = F2
  
Arguments: {F : Type u_1 → Type u_2} {F1 F2 : Functor F} [LawfulFunctor F] [LawfulFunctor F]
Goal: (∀ (α β : Type u_1) (f : α → β) (x : F α), f <$> x = f <$> x) → F1 = F2
-- Functor.Const.ext
protected theorem ext {α β} {x y : Const α β} (h : x.run = y.run) : x = y 
Arguments: {α : Type u_1} {β : Type u_2} {x y : Functor.Const α β} (h : x.run = y.run)
Goal: x = y
-- Functor.Comp.ext
protected theorem ext {α} {x y : Comp F G α} : x.run = y.run → x = y 
Arguments: {F : Type u → Type w} {G : Type v → Type u} {α : Type v} {x y : Functor.Comp F G α}
Goal: x.run = y.run → x = y
-- Functor.Comp.map_mk
@[functor_norm]
theorem map_mk {α β} (h : α → β) (x : F (G α)) : h <$> Comp.mk x = Comp.mk ((h <$> ·) <$> x) 
Arguments: {F : Type u → Type w} {G : Type v → Type u} [Functor F] [Functor G] {α β : Type v} (h : α → β) (x : F (G α))
Goal: h <$> Functor.Comp.mk x = Functor.Comp.mk ((fun x => h <$> x) <$> x)
-- Functor.Comp.run_map
@[simp]
protected theorem run_map {α β} (h : α → β) (x : Comp F G α) :
    (h <$> x).run = (h <$> ·) <$> x.run 
Arguments: {F : Type u → Type w} {G : Type v → Type u} [Functor F] [Functor G] {α β : Type v} (h : α → β) (x : Functor.Comp F G α)
Goal: (h <$> x).run = (fun x => h <$> x) <$> x.run
-- Functor.Comp.id_map
protected theorem id_map : ∀ x : Comp F G α, Comp.map id x = x
  
Arguments: {F : Type u → Type w} {G : Type v → Type u} [Functor F] [Functor G] [LawfulFunctor F] [LawfulFunctor G] {α : Type v} (x : Functor.Comp F G α)
Goal: Functor.Comp.map id x = x
-- Functor.Comp.comp_map
protected theorem comp_map (g' : α → β) (h : β → γ) :
    ∀ x : Comp F G α, Comp.map (h ∘ g') x = Comp.map h (Comp.map g' x)
  
Arguments: {F : Type u → Type w} {G : Type v → Type u} [Functor F] [Functor G] [LawfulFunctor F] [LawfulFunctor G] {α β γ : Type v} (g' : α → β) (h : β → γ) (x : Functor.Comp F G α)
Goal: Functor.Comp.map (h ∘ g') x = Functor.Comp.map h (Functor.Comp.map g' x)
-- Functor.Comp.functor_comp_id
theorem functor_comp_id {F} [AF : Functor F] [LawfulFunctor F] :
    @Comp.functor F Id _ _ = AF 
Arguments: {F : Type u_1 → Type u_2} [AF : Functor F] [LawfulFunctor F]
Goal: Functor.Comp.functor = AF
-- Functor.Comp.functor_id_comp
theorem functor_id_comp {F} [AF : Functor F] [LawfulFunctor F] : @Comp.functor Id F _ _ = AF 
Arguments: {F : Type u_1 → Type u_2} [AF : Functor F] [LawfulFunctor F]
Goal: Functor.Comp.functor = AF
-- Functor.Comp.run_pure
@[simp]
protected theorem run_pure {α : Type v} : ∀ x : α, (pure x : Comp F G α).run = pure (pure x)
  
Arguments: {F : Type u → Type w} {G : Type v → Type u} [Applicative F] [Applicative G] {α : Type v} (x : α)
Goal: (pure x).run = pure (pure x)
-- Functor.Comp.run_seq
@[simp]
protected theorem run_seq {α β : Type v} (f : Comp F G (α → β)) (x : Comp F G α) :
    (f <*> x).run = (· <*> ·) <$> f.run <*> x.run 
Arguments: {F : Type u → Type w} {G : Type v → Type u} [Applicative F] [Applicative G] {α β : Type v} (f : Functor.Comp F G (α → β)) (x : Functor.Comp F G α)
Goal: (Seq.seq f fun x_1 => x).run = Seq.seq ((fun x x_1 => Seq.seq x fun x => x_1) <$> f.run) fun x_1 => x.run
-- Functor.of_mem_supp
theorem of_mem_supp {α : Type u} {x : F α} {p : α → Prop} (h : Liftp p x) : ∀ y ∈ supp x, p y 
Arguments: {F : Type u → Type u} [Functor F] {α : Type u} {x : F α} {p : α → Prop} (h : Functor.Liftp p x) (y : α)
Goal: y ∈ Functor.supp x → p y
-- StateT.run_mk
@[simp]
theorem run_mk (f : σ → m (α × σ)) (st : σ) : StateT.run (StateT.mk f) st = f st 
Arguments: {σ : Type u} {m : Type u → Type v} {α : Type u} (f : σ → m (α × σ)) (st : σ)
Goal: (StateT.mk f).run st = f st
-- ExceptT.run_mk
@[simp]
theorem run_mk (x : m (Except ε α)) : ExceptT.run (ExceptT.mk x) = x 
Arguments: {α ε : Type u} {m : Type u → Type v} (x : m (Except ε α))
Goal: (ExceptT.mk x).run = x
-- ExceptT.run_monadLift
@[simp]
theorem run_monadLift {n} [MonadLiftT n m] (x : n α) :
    (monadLift x : ExceptT ε m α).run = Except.ok <$> (monadLift x : m α) 
Arguments: {α ε : Type u} {m : Type u → Type v} [Monad m] {n : Type u → Type u_1} [MonadLiftT n m] (x : n α)
Goal: (monadLift x).run = Except.ok <$> monadLift x
-- ExceptT.run_monadMap
@[simp]
theorem run_monadMap {n} [MonadFunctorT n m] (f : ∀ {α}, n α → n α) :
    (monadMap (@f) x : ExceptT ε m α).run = monadMap (@f) x.run 
Arguments: {α ε : Type u} {m : Type u → Type v} (x : ExceptT ε m α) {n : Type u → Type u_1} [MonadFunctorT n m] (f : {α : Type u} → n α → n α)
Goal: (monadMap f x).run = monadMap f x.run
-- ReaderT.run_mk
@[simp]
theorem run_mk (f : σ → m α) (r : σ) : ReaderT.run (ReaderT.mk f) r = f r 
Arguments: {m : Type u → Type v} {α σ : Type u} (f : σ → m α) (r : σ)
Goal: (ReaderT.mk f).run r = f r
-- OptionT.ext
@[ext] theorem ext {x x' : OptionT m α} (h : x.run = x'.run) : x = x' 
Arguments: {α : Type u} {m : Type u → Type v} {x x' : OptionT m α} (h : x.run = x'.run)
Goal: x = x'
-- OptionT.run_mk
@[simp]
theorem run_mk (x : m (Option α)) : OptionT.run (OptionT.mk x) = x 
Arguments: {α : Type u} {m : Type u → Type v} (x : m (Option α))
Goal: (OptionT.mk x).run = x
-- OptionT.run_pure
@[simp]
theorem run_pure (a) : (pure a : OptionT m α).run = pure (some a) 
Arguments: {α : Type u} {m : Type u → Type v} [Monad m] (a : α)
Goal: (pure a).run = pure (some a)
-- OptionT.run_bind
@[simp]
theorem run_bind (f : α → OptionT m β) :
    (x >>= f).run = x.run >>= fun
                              | some a => OptionT.run (f a)
                              | none   => pure none 
Arguments: {α β : Type u} {m : Type u → Type v} (x : OptionT m α) [Monad m] (f : α → OptionT m β)
Goal: (x >>= f).run = do
  let x ← x.run
  match x with
    | some a => (f a).run
    | none => pure none
-- OptionT.run_map
@[simp]
theorem run_map (f : α → β) [LawfulMonad m] : (f <$> x).run = Option.map f <$> x.run 
Arguments: {α β : Type u} {m : Type u → Type v} (x : OptionT m α) [Monad m] (f : α → β) [LawfulMonad m]
Goal: (f <$> x).run = Option.map f <$> x.run
-- OptionT.run_monadLift
@[simp]
theorem run_monadLift {n} [MonadLiftT n m] (x : n α) :
    (monadLift x : OptionT m α).run = (monadLift x : m α) >>= fun a => pure (some a) 
Arguments: {α : Type u} {m : Type u → Type v} [Monad m] {n : Type u → Type u_1} [MonadLiftT n m] (x : n α)
Goal: (monadLift x).run = do
  let a ← monadLift x
  pure (some a)
-- OptionT.run_monadMap
@[simp]
theorem run_monadMap {n} [MonadFunctorT n m] (f : ∀ {α}, n α → n α) :
    (monadMap (@f) x : OptionT m α).run = monadMap (@f) x.run 
Arguments: {α : Type u} {m : Type u → Type v} (x : OptionT m α) {n : Type u → Type u_1} [MonadFunctorT n m] (f : {α : Type u} → n α → n α)
Goal: (monadMap f x).run = monadMap f x.run
-- ApplicativeTransformation.preserves_seq'
structure ApplicativeTransformation : Type max (u + 1) v w where
    app : ∀ α : Type u, F α → G α
    preserves_pure' : ∀ {α : Type u} (x : α), app _ (pure x) = pure x
    preserves_seq' : ∀ {α β : Type u} (x : F (α → β)) (y : F α), app _ (x <*> y) = app _ x <*> app _ y
Arguments: {F : Type u → Type v} [Applicative F] {G : Type u → Type w} [Applicative G] (self : ApplicativeTransformation F G) {α β : Type u} (x : F (α → β)) (y : F α)
Goal: self.app β (Seq.seq x fun x => y) = Seq.seq (self.app (α → β) x) fun x => self.app α y
-- ApplicativeTransformation.preserves_pure'
structure ApplicativeTransformation : Type max (u + 1) v w where
    app : ∀ α : Type u, F α → G α
    preserves_pure' : ∀ {α : Type u} (x : α), app _ (pure x) = pure x
    preserves_seq' : ∀ {α β : Type u} (x : F (α → β)) (y : F α), app _ (x <*> y) = app _ x <*> app _ y
Arguments: {F : Type u → Type v} [Applicative F] {G : Type u → Type w} [Applicative G] (self : ApplicativeTransformation F G) {α : Type u} (x : α)
Goal: self.app α (pure x) = pure x
-- ApplicativeTransformation.app_eq_coe
theorem app_eq_coe (η : ApplicativeTransformation F G) : η.app = η 
Arguments: {F : Type u → Type v} [Applicative F] {G : Type u → Type w} [Applicative G] (η : ApplicativeTransformation F G)
Goal: η.app = fun {α} => η.app α
-- ApplicativeTransformation.coe_mk
@[simp]
theorem coe_mk (f : ∀ α : Type u, F α → G α) (pp ps) :
    (ApplicativeTransformation.mk f @pp @ps) = f 
Arguments: {F : Type u → Type v} [Applicative F] {G : Type u → Type w} [Applicative G] (f : (α : Type u) → F α → G α) (pp : ∀ {α : Type u} (x : α), f α (pure x) = pure x) (ps : ∀ {α β : Type u} (x : F (α → β)) (y : F α), f β (Seq.seq x fun x => y) = Seq.seq (f (α → β) x) fun x => f α y)
Goal: (fun {α} => { app := f, preserves_pure' := pp, preserves_seq' := ps }.app α) = f
-- ApplicativeTransformation.congr_fun
protected theorem congr_fun (η η' : ApplicativeTransformation F G) (h : η = η') {α : Type u}
    (x : F α) : η x = η' x 
Arguments: {F : Type u → Type v} [Applicative F] {G : Type u → Type w} [Applicative G] (η η' : ApplicativeTransformation F G) (h : η = η') {α : Type u} (x : F α)
Goal: (fun {α} => η.app α) x = (fun {α} => η'.app α) x
-- ApplicativeTransformation.congr_arg
protected theorem congr_arg (η : ApplicativeTransformation F G) {α : Type u} {x y : F α}
    (h : x = y) : η x = η y 
Arguments: {F : Type u → Type v} [Applicative F] {G : Type u → Type w} [Applicative G] (η : ApplicativeTransformation F G) {α : Type u} {x y : F α} (h : x = y)
Goal: (fun {α} => η.app α) x = (fun {α} => η.app α) y
-- ApplicativeTransformation.coe_inj
theorem coe_inj ⦃η η' : ApplicativeTransformation F G⦄ (h : (η : ∀ α, F α → G α) = η') :
    η = η' 
Arguments: {F : Type u → Type v} [Applicative F] {G : Type u → Type w} [Applicative G] ⦃η η' : ApplicativeTransformation F G⦄ (h : (fun {α} => η.app α) = fun {α} => η'.app α)
Goal: η = η'
-- ApplicativeTransformation.ext
@[ext]
theorem ext ⦃η η' : ApplicativeTransformation F G⦄ (h : ∀ (α : Type u) (x : F α), η x = η' x) :
    η = η' 
Arguments: {F : Type u → Type v} [Applicative F] {G : Type u → Type w} [Applicative G] ⦃η η' : ApplicativeTransformation F G⦄ (h : ∀ (α : Type u) (x : F α), (fun {α} => η.app α) x = (fun {α} => η'.app α) x)
Goal: η = η'
-- ApplicativeTransformation.ext_iff
theorem ext_iff {η η' : ApplicativeTransformation F G} :
    η = η' ↔ ∀ (α : Type u) (x : F α), η x = η' x 
Arguments: {F : Type u → Type v} [Applicative F] {G : Type u → Type w} [Applicative G] {η η' : ApplicativeTransformation F G}
Goal: η = η' ↔ ∀ (α : Type u) (x : F α), (fun {α} => η.app α) x = (fun {α} => η'.app α) x
-- ApplicativeTransformation.preserves_pure
@[functor_norm]
theorem preserves_pure {α} : ∀ x : α, η (pure x) = pure x 
Arguments: {F : Type u → Type v} [Applicative F] {G : Type u → Type w} [Applicative G] (η : ApplicativeTransformation F G) {α : Type u} (x : α)
Goal: (fun {α} => η.app α) (pure x) = pure x
-- ApplicativeTransformation.preserves_seq
@[functor_norm]
theorem preserves_seq {α β : Type u} : ∀ (x : F (α → β)) (y : F α), η (x <*> y) = η x <*> η y 
Arguments: {F : Type u → Type v} [Applicative F] {G : Type u → Type w} [Applicative G] (η : ApplicativeTransformation F G) {α β : Type u} (x : F (α → β)) (y : F α)
Goal: (fun {α} => η.app α) (Seq.seq x fun x => y) = Seq.seq ((fun {α} => η.app α) x) fun x => (fun {α} => η.app α) y
-- ApplicativeTransformation.preserves_map
@[functor_norm]
theorem preserves_map {α β} (x : α → β) (y : F α) : η (x <$> y) = x <$> η y 
Arguments: {F : Type u → Type v} [Applicative F] [LawfulApplicative F] {G : Type u → Type w} [Applicative G] [LawfulApplicative G] (η : ApplicativeTransformation F G) {α β : Type u} (x : α → β) (y : F α)
Goal: (fun {α} => η.app α) (x <$> y) = x <$> (fun {α} => η.app α) y
-- ApplicativeTransformation.preserves_map'
theorem preserves_map' {α β} (x : α → β) : @η _ ∘ Functor.map x = Functor.map x ∘ @η _ 
Arguments: {F : Type u → Type v} [Applicative F] [LawfulApplicative F] {G : Type u → Type w} [Applicative G] [LawfulApplicative G] (η : ApplicativeTransformation F G) {α β : Type u} (x : α → β)
Goal: (fun {α} => η.app α) ∘ Functor.map x = Functor.map x ∘ fun {α} => η.app α
-- ApplicativeTransformation.comp_apply
@[simp]
theorem comp_apply (η' : ApplicativeTransformation G H) (η : ApplicativeTransformation F G)
    {α : Type u} (x : F α) : η'.comp η x = η' (η x) 
Arguments: {F : Type u → Type v} [Applicative F] {G : Type u → Type w} [Applicative G] {H : Type u → Type s} [Applicative H] (η' : ApplicativeTransformation G H) (η : ApplicativeTransformation F G) {α : Type u} (x : F α)
Goal: (fun {α} => (η'.comp η).app α) x = (fun {α} => η'.app α) ((fun {α} => η.app α) x)
-- ApplicativeTransformation.comp_assoc
theorem comp_assoc {I : Type u → Type t} [Applicative I]
    (η'' : ApplicativeTransformation H I) (η' : ApplicativeTransformation G H)
    (η : ApplicativeTransformation F G) : (η''.comp η').comp η = η''.comp (η'.comp η) 
Arguments: {F : Type u → Type v} [Applicative F] {G : Type u → Type w} [Applicative G] {H : Type u → Type s} [Applicative H] {I : Type u → Type t} [Applicative I] (η'' : ApplicativeTransformation H I) (η' : ApplicativeTransformation G H) (η : ApplicativeTransformation F G)
Goal: (η''.comp η').comp η = η''.comp (η'.comp η)
-- ApplicativeTransformation.comp_id
@[simp]
theorem comp_id (η : ApplicativeTransformation F G) : η.comp idTransformation = η 
Arguments: {F : Type u → Type v} [Applicative F] {G : Type u → Type w} [Applicative G] (η : ApplicativeTransformation F G)
Goal: η.comp ApplicativeTransformation.idTransformation = η
-- ApplicativeTransformation.id_comp
@[simp]
theorem id_comp (η : ApplicativeTransformation F G) : idTransformation.comp η = η 
Arguments: {F : Type u → Type v} [Applicative F] {G : Type u → Type w} [Applicative G] (η : ApplicativeTransformation F G)
Goal: ApplicativeTransformation.idTransformation.comp η = η
-- LawfulTraversable.traverse_eq_map_id
class LawfulTraversable (t : Type u → Type u) [Traversable t] extends LawfulFunctor t :
    Prop where
    id_traverse : ∀ {α} (x : t α), traverse (pure : α → Id α) x = x
    comp_traverse :
    ∀ {F G} [Applicative F] [Applicative G] [LawfulApplicative F] [LawfulApplicative G] {α β γ}
      (f : β → F γ) (g : α → G β) (x : t α),
      traverse (Functor.Comp.mk ∘ map f ∘ g) x = Comp.mk (map (traverse f) (traverse g x))
    traverse_eq_map_id : ∀ {α β} (f : α → β) (x : t α),
    traverse ((pure : β → Id β) ∘ f) x = id.mk (f <$> x)
    naturality :
    ∀ {F G} [Applicative F] [Applicative G] [LawfulApplicative F] [LawfulApplicative G]
      (η : ApplicativeTransformation F G) {α β} (f : α → F β) (x : t α),
      η (traverse f x) = traverse (@η _ ∘ f) x
Arguments: {t : Type u → Type u} [Traversable t] [self : LawfulTraversable t] {α β : Type u} (f : α → β) (x : t α)
Goal: traverse (pure ∘ f) x = id.mk (f <$> x)
-- LawfulTraversable.id_traverse
class LawfulTraversable (t : Type u → Type u) [Traversable t] extends LawfulFunctor t :
    Prop where
    id_traverse : ∀ {α} (x : t α), traverse (pure : α → Id α) x = x
    comp_traverse :
    ∀ {F G} [Applicative F] [Applicative G] [LawfulApplicative F] [LawfulApplicative G] {α β γ}
      (f : β → F γ) (g : α → G β) (x : t α),
      traverse (Functor.Comp.mk ∘ map f ∘ g) x = Comp.mk (map (traverse f) (traverse g x))
    traverse_eq_map_id : ∀ {α β} (f : α → β) (x : t α),
    traverse ((pure : β → Id β) ∘ f) x = id.mk (f <$> x)
    naturality :
    ∀ {F G} [Applicative F] [Applicative G] [LawfulApplicative F] [LawfulApplicative G]
      (η : ApplicativeTransformation F G) {α β} (f : α → F β) (x : t α),
      η (traverse f x) = traverse (@η _ ∘ f) x
Arguments: {t : Type u → Type u} [Traversable t] [self : LawfulTraversable t] {α : Type u} (x : t α)
Goal: traverse pure x = x
-- LawfulTraversable.naturality
class LawfulTraversable (t : Type u → Type u) [Traversable t] extends LawfulFunctor t :
    Prop where
    id_traverse : ∀ {α} (x : t α), traverse (pure : α → Id α) x = x
    comp_traverse :
    ∀ {F G} [Applicative F] [Applicative G] [LawfulApplicative F] [LawfulApplicative G] {α β γ}
      (f : β → F γ) (g : α → G β) (x : t α),
      traverse (Functor.Comp.mk ∘ map f ∘ g) x = Comp.mk (map (traverse f) (traverse g x))
    traverse_eq_map_id : ∀ {α β} (f : α → β) (x : t α),
    traverse ((pure : β → Id β) ∘ f) x = id.mk (f <$> x)
    naturality :
    ∀ {F G} [Applicative F] [Applicative G] [LawfulApplicative F] [LawfulApplicative G]
      (η : ApplicativeTransformation F G) {α β} (f : α → F β) (x : t α),
      η (traverse f x) = traverse (@η _ ∘ f) x
Arguments: {t : Type u → Type u} [Traversable t] [self : LawfulTraversable t] {F G : Type u → Type u} [Applicative F] [Applicative G] [LawfulApplicative F] [LawfulApplicative G] (η : ApplicativeTransformation F G) {α β : Type u} (f : α → F β) (x : t α)
Goal: (fun {α} => η.app α) (traverse f x) = traverse ((fun {α} => η.app α) ∘ f) x
-- LawfulTraversable.comp_traverse
class LawfulTraversable (t : Type u → Type u) [Traversable t] extends LawfulFunctor t :
    Prop where
    id_traverse : ∀ {α} (x : t α), traverse (pure : α → Id α) x = x
    comp_traverse :
    ∀ {F G} [Applicative F] [Applicative G] [LawfulApplicative F] [LawfulApplicative G] {α β γ}
      (f : β → F γ) (g : α → G β) (x : t α),
      traverse (Functor.Comp.mk ∘ map f ∘ g) x = Comp.mk (map (traverse f) (traverse g x))
    traverse_eq_map_id : ∀ {α β} (f : α → β) (x : t α),
    traverse ((pure : β → Id β) ∘ f) x = id.mk (f <$> x)
    naturality :
    ∀ {F G} [Applicative F] [Applicative G] [LawfulApplicative F] [LawfulApplicative G]
      (η : ApplicativeTransformation F G) {α β} (f : α → F β) (x : t α),
      η (traverse f x) = traverse (@η _ ∘ f) x
Arguments: {t : Type u → Type u} [Traversable t] [self : LawfulTraversable t] {F G : Type u → Type u} [Applicative F] [Applicative G] [LawfulApplicative F] [LawfulApplicative G] {α β γ : Type u} (f : β → F γ) (g : α → G β) (x : t α)
Goal: traverse (Functor.Comp.mk ∘ Functor.map f ∘ g) x = Functor.Comp.mk (traverse f <$> traverse g x)
-- Subgroup.smul_diff_smul'
theorem smul_diff_smul' [hH : Normal H] (g : Gᵐᵒᵖ) :
    diff (MonoidHom.id H) (g • α) (g • β) =
      ⟨g.unop⁻¹ * (diff (MonoidHom.id H) α β : H) * g.unop,
        hH.mem_comm ((congr_arg (· ∈ H) (mul_inv_cancel_left _ _)).mpr (SetLike.coe_mem _))⟩ 
Arguments: {G : Type u_1} [Group G] (H : Subgroup G) [H.IsCommutative] [H.FiniteIndex] (α β : ↑(Subgroup.leftTransversals ↑H)) [hH : H.Normal] (g : Gᵐᵒᵖ)
Goal: Subgroup.leftTransversals.diff (MonoidHom.id ↥H) (g • α) (g • β) =
  ⟨(MulOpposite.unop g)⁻¹ * ↑(Subgroup.leftTransversals.diff (MonoidHom.id ↥H) α β) * MulOpposite.unop g, ⋯⟩