ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- FirstOrder.Language.DirectLimit.lift_quotient_mk'_sigma_mk'
@[simp]
theorem lift_quotient_mk'_sigma_mk' {i} (x : G i) : lift L ι G f g Hg ⟦.mk f i x⟧ = (g i) x 
Arguments: {L : FirstOrder.Language} {ι : Type v} [Preorder ι] {G : ι → Type w} [(i : ι) → L.Structure (G i)] {f : (i j : ι) → i ≤ j → G i ↪[L] G j} [IsDirected ι fun x x_1 => x ≤ x_1] [DirectedSystem G fun i j h => ⇑(f i j h)] [Nonempty ι] {P : Type u₁} [L.Structure P] (g : (i : ι) → G i ↪[L] P) (Hg : ∀ (i j : ι) (hij : i ≤ j) (x : G i), (g j) ((f i j hij) x) = (g i) x) {i : ι} (x : G i)
Goal: (FirstOrder.Language.DirectLimit.lift L ι G f g Hg) ⟦FirstOrder.Language.Structure.Sigma.mk f i x⟧ = (g i) x
-- FirstOrder.Language.DirectLimit.lift_of
theorem lift_of {i} (x : G i) : lift L ι G f g Hg (of L ι G f i x) = g i x 
Arguments: {L : FirstOrder.Language} {ι : Type v} [Preorder ι] {G : ι → Type w} [(i : ι) → L.Structure (G i)] {f : (i j : ι) → i ≤ j → G i ↪[L] G j} [IsDirected ι fun x x_1 => x ≤ x_1] [DirectedSystem G fun i j h => ⇑(f i j h)] [Nonempty ι] {P : Type u₁} [L.Structure P] (g : (i : ι) → G i ↪[L] P) (Hg : ∀ (i j : ι) (hij : i ≤ j) (x : G i), (g j) ((f i j hij) x) = (g i) x) {i : ι} (x : G i)
Goal: (FirstOrder.Language.DirectLimit.lift L ι G f g Hg) ((FirstOrder.Language.DirectLimit.of L ι G f i) x) = (g i) x
-- FirstOrder.Language.DirectLimit.lift_unique
theorem lift_unique (F : DirectLimit G f ↪[L] P) (x) :
    F x =
      lift L ι G f (fun i => F.comp <| of L ι G f i)
        (fun i j hij x => by rw [F.comp_apply, F.comp_apply, of_f]) x 
Arguments: {L : FirstOrder.Language} {ι : Type v} [Preorder ι] {G : ι → Type w} [(i : ι) → L.Structure (G i)] {f : (i j : ι) → i ≤ j → G i ↪[L] G j} [IsDirected ι fun x x_1 => x ≤ x_1] [DirectedSystem G fun i j h => ⇑(f i j h)] [Nonempty ι] {P : Type u₁} [L.Structure P] (F : FirstOrder.Language.DirectLimit G f ↪[L] P) (x : FirstOrder.Language.DirectLimit G f)
Goal: F x =
  (FirstOrder.Language.DirectLimit.lift L ι G f (fun i => F.comp (FirstOrder.Language.DirectLimit.of L ι G f i)) ⋯) x
-- FirstOrder.Language.DirectLimit.range_lift
lemma range_lift : (lift L ι G f g Hg).toHom.range = ⨆ i, (g i).toHom.range 
Arguments: {L : FirstOrder.Language} {ι : Type v} [Preorder ι] {G : ι → Type w} [(i : ι) → L.Structure (G i)] {f : (i j : ι) → i ≤ j → G i ↪[L] G j} [IsDirected ι fun x x_1 => x ≤ x_1] [DirectedSystem G fun i j h => ⇑(f i j h)] [Nonempty ι] {P : Type u₁} [L.Structure P] (g : (i : ι) → G i ↪[L] P) (Hg : ∀ (i j : ι) (hij : i ≤ j) (x : G i), (g j) ((f i j hij) x) = (g i) x)
Goal: (FirstOrder.Language.DirectLimit.lift L ι G f g Hg).toHom.range = ⨆ i, (g i).toHom.range
-- FirstOrder.Language.DirectLimit.equiv_lift_of
theorem equiv_lift_of {i : ι} (x : G i) :
    equiv_lift L ι G f G' f' g H_commuting (of L ι G f i x) = of L ι G' f' i (g i x) 
Arguments: (L : FirstOrder.Language) (ι : Type v) [Preorder ι] (G : ι → Type w) [(i : ι) → L.Structure (G i)] (f : (i j : ι) → i ≤ j → G i ↪[L] G j) [IsDirected ι fun x x_1 => x ≤ x_1] [DirectedSystem G fun i j h => ⇑(f i j h)] [Nonempty ι] (G' : ι → Type w') [(i : ι) → L.Structure (G' i)] (f' : (i j : ι) → i ≤ j → G' i ↪[L] G' j) (g : (i : ι) → G i ≃[L] G' i) (H_commuting : ∀ (i j : ι) (hij : i ≤ j) (x : G i), (g j) ((f i j hij) x) = (f' i j hij) ((g i) x)) [DirectedSystem G' fun i j h => ⇑(f' i j h)] {i : ι} (x : G i)
Goal: (FirstOrder.Language.DirectLimit.equiv_lift L ι G f G' f' g H_commuting)
    ((FirstOrder.Language.DirectLimit.of L ι G f i) x) =
  (FirstOrder.Language.DirectLimit.of L ι G' f' i) ((g i) x)
-- FirstOrder.Language.DirectLimit.cg
theorem cg {ι : Type*} [Countable ι] [Preorder ι] [IsDirected ι (· ≤ ·)] [Nonempty ι]
    {G : ι → Type w} [∀ i, L.Structure (G i)] (f : ∀ i j, i ≤ j → G i ↪[L] G j)
    (h : ∀ i, Structure.CG L (G i)) [DirectedSystem G fun i j h => f i j h] :
    Structure.CG L (DirectLimit G f) 
Arguments: {L : FirstOrder.Language} {ι : Type u_1} [Countable ι] [Preorder ι] [IsDirected ι fun x x_1 => x ≤ x_1] [Nonempty ι] {G : ι → Type w} [(i : ι) → L.Structure (G i)] (f : (i j : ι) → i ≤ j → G i ↪[L] G j) (h : ∀ (i : ι), FirstOrder.Language.Structure.CG L (G i)) [DirectedSystem G fun i j h => ⇑(f i j h)]
Goal: FirstOrder.Language.Structure.CG L (FirstOrder.Language.DirectLimit G f)
-- FirstOrder.Language.DirectLimit.liftInclusion_of
theorem liftInclusion_of {i : ι} (x : S i) :
    (liftInclusion S) (of L ι _ (fun _ _ h ↦ Substructure.inclusion (S.monotone h)) i x)
    = Substructure.subtype (S i) x 
Arguments: {L : FirstOrder.Language} {ι : Type v} [Preorder ι] [Nonempty ι] [IsDirected ι fun x x_1 => x ≤ x_1] {M : Type u_1} [L.Structure M] (S : ι →o L.Substructure M) {i : ι} (x : ↥(S i))
Goal: (FirstOrder.Language.DirectLimit.liftInclusion S)
    ((FirstOrder.Language.DirectLimit.of L ι (fun x => ↥(S x))
        (fun x x_1 h => FirstOrder.Language.Substructure.inclusion ⋯) i)
      x) =
  (S i).subtype x
-- FirstOrder.Language.DirectLimit.rangeLiftInclusion
lemma rangeLiftInclusion : (liftInclusion S).toHom.range = ⨆ i, S i 
Arguments: {L : FirstOrder.Language} {ι : Type v} [Preorder ι] [Nonempty ι] [IsDirected ι fun x x_1 => x ≤ x_1] {M : Type u_1} [L.Structure M] (S : ι →o L.Substructure M)
Goal: (FirstOrder.Language.DirectLimit.liftInclusion S).toHom.range = ⨆ i, S i
-- FirstOrder.Language.DirectLimit.Equiv_isup_of_apply
theorem Equiv_isup_of_apply {i : ι} (x : S i) :
    Equiv_iSup S (of L ι _ (fun _ _ h ↦ Substructure.inclusion (S.monotone h)) i x)
    = Substructure.inclusion (le_iSup _ _) x 
Arguments: {L : FirstOrder.Language} {ι : Type v} [Preorder ι] [Nonempty ι] [IsDirected ι fun x x_1 => x ≤ x_1] {M : Type u_1} [L.Structure M] (S : ι →o L.Substructure M) {i : ι} (x : ↥(S i))
Goal: (FirstOrder.Language.DirectLimit.Equiv_iSup S)
    ((FirstOrder.Language.DirectLimit.of L ι (fun x => ↥(S x))
        (fun x x_1 h => FirstOrder.Language.Substructure.inclusion ⋯) i)
      x) =
  (FirstOrder.Language.Substructure.inclusion ⋯) x
-- FirstOrder.Language.DirectLimit.Equiv_isup_symm_inclusion_apply
theorem Equiv_isup_symm_inclusion_apply {i : ι} (x : S i) :
    (Equiv_iSup S).symm (Substructure.inclusion (le_iSup _ _) x)
    = of L ι _ (fun _ _ h ↦ Substructure.inclusion (S.monotone h)) i x 
Arguments: {L : FirstOrder.Language} {ι : Type v} [Preorder ι] [Nonempty ι] [IsDirected ι fun x x_1 => x ≤ x_1] {M : Type u_1} [L.Structure M] (S : ι →o L.Substructure M) {i : ι} (x : ↥(S i))
Goal: (FirstOrder.Language.DirectLimit.Equiv_iSup S).symm ((FirstOrder.Language.Substructure.inclusion ⋯) x) =
  (FirstOrder.Language.DirectLimit.of L ι (fun x => ↥(S x))
      (fun x x_1 h => FirstOrder.Language.Substructure.inclusion ⋯) i)
    x
-- FirstOrder.Language.DirectLimit.Equiv_isup_symm_inclusion
@[simp]
theorem Equiv_isup_symm_inclusion (i : ι) :
    (Equiv_iSup S).symm.toEmbedding.comp (Substructure.inclusion (le_iSup _ _))
    = of L ι _ (fun _ _ h ↦ Substructure.inclusion (S.monotone h)) i 
Arguments: {L : FirstOrder.Language} {ι : Type v} [Preorder ι] [Nonempty ι] [IsDirected ι fun x x_1 => x ≤ x_1] {M : Type u_1} [L.Structure M] (S : ι →o L.Substructure M) (i : ι)
Goal: (FirstOrder.Language.DirectLimit.Equiv_iSup S).symm.toEmbedding.comp (FirstOrder.Language.Substructure.inclusion ⋯) =
  FirstOrder.Language.DirectLimit.of L ι (fun x => ↥(S x)) (fun x x_1 h => FirstOrder.Language.Substructure.inclusion ⋯)
    i
-- ModularGroup.bottom_row_coprime
theorem bottom_row_coprime {R : Type*} [CommRing R] (g : SL(2, R)) :
    IsCoprime ((↑g : Matrix (Fin 2) (Fin 2) R) 1 0) ((↑g : Matrix (Fin 2) (Fin 2) R) 1 1) 
Arguments: {R : Type u_1} [CommRing R] (g : SL(2, R))
Goal: IsCoprime (↑g 1 0) (↑g 1 1)
-- ModularGroup.bottom_row_surj
theorem bottom_row_surj {R : Type*} [CommRing R] :
    Set.SurjOn (fun g : SL(2, R) => (↑g : Matrix (Fin 2) (Fin 2) R) 1) Set.univ
      {cd | IsCoprime (cd 0) (cd 1)} 
Arguments: {R : Type u_1} [CommRing R]
Goal: Set.SurjOn (fun g => ↑g 1) Set.univ {cd | IsCoprime (cd 0) (cd 1)}
-- ModularGroup.tendsto_normSq_coprime_pair
theorem tendsto_normSq_coprime_pair :
    Filter.Tendsto (fun p : Fin 2 → ℤ => normSq ((p 0 : ℂ) * z + p 1)) cofinite atTop 
Arguments: (z : ℍ)
Goal: Filter.Tendsto (fun p => Complex.normSq (↑(p 0) * ↑z + ↑(p 1))) Filter.cofinite Filter.atTop
-- ModularGroup.lcRow0_apply
@[simp]
theorem lcRow0_apply (p : Fin 2 → ℤ) (g : Matrix (Fin 2) (Fin 2) ℝ) :
    lcRow0 p g = p 0 * g 0 0 + p 1 * g 0 1 
Arguments: (p : Fin 2 → ℤ) (g : Matrix (Fin 2) (Fin 2) ℝ)
Goal: (ModularGroup.lcRow0 p) g = ↑(p 0) * g 0 0 + ↑(p 1) * g 0 1
-- ModularGroup.lcRow0Extend_apply
@[simps!]
def lcRow0Extend {cd : Fin 2 → ℤ} (hcd : IsCoprime (cd 0) (cd 1)) :
    Matrix (Fin 2) (Fin 2) ℝ ≃ₗ[ℝ] Matrix (Fin 2) (Fin 2) ℝ 
Arguments: {cd : Fin 2 → ℤ} (hcd : IsCoprime (cd 0) (cd 1)) (f : (i : Fin 2) → (fun a => Fin 2 → ℝ) i) (i : Fin 2)
Goal: ∀ (a : Fin 2),
  (ModularGroup.lcRow0Extend hcd) f i a =
    (![(LinearMap.GeneralLinearGroup.generalLinearEquiv ℝ (Fin 2 → ℝ))
            (Matrix.GeneralLinearGroup.toLinear (Matrix.planeConformalMatrix (↑(cd 0)) (-↑(cd 1)) ⋯)),
          LinearEquiv.refl ℝ (Fin 2 → ℝ)]
        i)
      (f i) a
-- ModularGroup.lcRow0Extend_symm_apply
@[simps!]
def lcRow0Extend {cd : Fin 2 → ℤ} (hcd : IsCoprime (cd 0) (cd 1)) :
    Matrix (Fin 2) (Fin 2) ℝ ≃ₗ[ℝ] Matrix (Fin 2) (Fin 2) ℝ 
Arguments: {cd : Fin 2 → ℤ} (hcd : IsCoprime (cd 0) (cd 1)) (f : (i : Fin 2) → (fun a => Fin 2 → ℝ) i) (i : Fin 2)
Goal: ∀ (a : Fin 2),
  (ModularGroup.lcRow0Extend hcd).symm f i a =
    (![(LinearMap.GeneralLinearGroup.generalLinearEquiv ℝ (Fin 2 → ℝ))
              (Matrix.GeneralLinearGroup.toLinear (Matrix.planeConformalMatrix (↑(cd 0)) (-↑(cd 1)) ⋯)),
            LinearEquiv.refl ℝ (Fin 2 → ℝ)]
          i).symm
      (f i) a
-- ModularGroup.tendsto_lcRow0
theorem tendsto_lcRow0 {cd : Fin 2 → ℤ} (hcd : IsCoprime (cd 0) (cd 1)) :
    Tendsto (fun g : { g : SL(2, ℤ) // (↑ₘg) 1 = cd } => lcRow0 cd ↑(↑g : SL(2, ℝ))) cofinite
      (cocompact ℝ) 
Arguments: {cd : Fin 2 → ℤ} (hcd : IsCoprime (cd 0) (cd 1))
Goal: Filter.Tendsto (fun g => (ModularGroup.lcRow0 cd) ↑((Matrix.SpecialLinearGroup.map (Int.castRingHom ℝ)) ↑g))
  Filter.cofinite (Filter.cocompact ℝ)
-- ModularGroup.smul_eq_lcRow0_add
theorem smul_eq_lcRow0_add {p : Fin 2 → ℤ} (hp : IsCoprime (p 0) (p 1)) (hg : (↑ₘg) 1 = p) :
    ↑(g • z) =
      (lcRow0 p ↑(g : SL(2, ℝ)) : ℂ) / ((p 0 : ℂ) ^ 2 + (p 1 : ℂ) ^ 2) +
        ((p 1 : ℂ) * z - p 0) / (((p 0 : ℂ) ^ 2 + (p 1 : ℂ) ^ 2) * (p 0 * z + p 1)) 
Arguments: {g : SL(2, ℤ)} (z : ℍ) {p : Fin 2 → ℤ} (hp : IsCoprime (p 0) (p 1)) (hg : ↑g 1 = p)
Goal: ↑(g • z) =
  ↑((ModularGroup.lcRow0 p) ↑((Matrix.SpecialLinearGroup.map (Int.castRingHom ℝ)) g)) / (↑(p 0) ^ 2 + ↑(p 1) ^ 2) +
    (↑(p 1) * ↑z - ↑(p 0)) / ((↑(p 0) ^ 2 + ↑(p 1) ^ 2) * (↑(p 0) * ↑z + ↑(p 1)))
-- ModularGroup.tendsto_abs_re_smul
theorem tendsto_abs_re_smul {p : Fin 2 → ℤ} (hp : IsCoprime (p 0) (p 1)) :
    Tendsto
      (fun g : { g : SL(2, ℤ) // (↑ₘg) 1 = p } => |((g : SL(2, ℤ)) • z).re|) cofinite atTop 
Arguments: (z : ℍ) {p : Fin 2 → ℤ} (hp : IsCoprime (p 0) (p 1))
Goal: Filter.Tendsto (fun g => |(↑g • z).re|) Filter.cofinite Filter.atTop
-- ModularGroup.exists_max_im
theorem exists_max_im : ∃ g : SL(2, ℤ), ∀ g' : SL(2, ℤ), (g' • z).im ≤ (g • z).im 
Arguments: (z : ℍ)
Goal: ∃ g, ∀ (g' : SL(2, ℤ)), (g' • z).im ≤ (g • z).im
-- ModularGroup.exists_row_one_eq_and_min_re
theorem exists_row_one_eq_and_min_re {cd : Fin 2 → ℤ} (hcd : IsCoprime (cd 0) (cd 1)) :
    ∃ g : SL(2, ℤ), (↑ₘg) 1 = cd ∧ ∀ g' : SL(2, ℤ), (↑ₘg) 1 = (↑ₘg') 1 →
      |(g • z).re| ≤ |(g' • z).re| 
Arguments: (z : ℍ) {cd : Fin 2 → ℤ} (hcd : IsCoprime (cd 0) (cd 1))
Goal: ∃ g, ↑g 1 = cd ∧ ∀ (g' : SL(2, ℤ)), ↑g 1 = ↑g' 1 → |(g • z).re| ≤ |(g' • z).re|
-- ModularGroup.coe_T_zpow_smul_eq
theorem coe_T_zpow_smul_eq {n : ℤ} : (↑(T ^ n • z) : ℂ) = z + n 
Arguments: (z : ℍ) {n : ℤ}
Goal: ↑(ModularGroup.T ^ n • z) = ↑z + ↑n
-- ModularGroup.re_T_zpow_smul
theorem re_T_zpow_smul (n : ℤ) : (T ^ n • z).re = z.re + n 
Arguments: (z : ℍ) (n : ℤ)
Goal: (ModularGroup.T ^ n • z).re = z.re + ↑n
-- ModularGroup.im_T_zpow_smul
theorem im_T_zpow_smul (n : ℤ) : (T ^ n • z).im = z.im 
Arguments: (z : ℍ) (n : ℤ)
Goal: (ModularGroup.T ^ n • z).im = z.im
-- ModularGroup.re_T_smul
theorem re_T_smul : (T • z).re = z.re + 1 
Arguments: (z : ℍ)
Goal: (ModularGroup.T • z).re = z.re + 1
-- ModularGroup.im_T_smul
theorem im_T_smul : (T • z).im = z.im 
Arguments: (z : ℍ)
Goal: (ModularGroup.T • z).im = z.im
-- ModularGroup.re_T_inv_smul
theorem re_T_inv_smul : (T⁻¹ • z).re = z.re - 1 
Arguments: (z : ℍ)
Goal: (ModularGroup.T⁻¹ • z).re = z.re - 1
-- ModularGroup.im_T_inv_smul
theorem im_T_inv_smul : (T⁻¹ • z).im = z.im 
Arguments: (z : ℍ)
Goal: (ModularGroup.T⁻¹ • z).im = z.im
-- ModularGroup.exists_eq_T_zpow_of_c_eq_zero
theorem exists_eq_T_zpow_of_c_eq_zero (hc : (↑ₘg) 1 0 = 0) :
    ∃ n : ℤ, ∀ z : ℍ, g • z = T ^ n • z 
Arguments: {g : SL(2, ℤ)} (hc : ↑g 1 0 = 0)
Goal: ∃ n, ∀ (z : ℍ), g • z = ModularGroup.T ^ n • z
-- ModularGroup.g_eq_of_c_eq_one
theorem g_eq_of_c_eq_one (hc : (↑ₘg) 1 0 = 1) : g = T ^ (↑ₘg) 0 0 * S * T ^ (↑ₘg) 1 1 
Arguments: {g : SL(2, ℤ)} (hc : ↑g 1 0 = 1)
Goal: g = ModularGroup.T ^ ↑g 0 0 * ModularGroup.S * ModularGroup.T ^ ↑g 1 1
-- ModularGroup.normSq_S_smul_lt_one
theorem normSq_S_smul_lt_one (h : 1 < normSq z) : normSq ↑(S • z) < 1 
Arguments: {z : ℍ} (h : 1 < Complex.normSq ↑z)
Goal: Complex.normSq ↑(ModularGroup.S • z) < 1
-- ModularGroup.im_lt_im_S_smul
theorem im_lt_im_S_smul (h : normSq z < 1) : z.im < (S • z).im 
Arguments: {z : ℍ} (h : Complex.normSq ↑z < 1)
Goal: z.im < (ModularGroup.S • z).im
-- ModularGroup.abs_two_mul_re_lt_one_of_mem_fdo
theorem abs_two_mul_re_lt_one_of_mem_fdo (h : z ∈ 𝒟ᵒ) : |2 * z.re| < 1 
Arguments: {z : ℍ} (h : z ∈ ModularGroup.fdo)
Goal: |2 * z.re| < 1
-- ModularGroup.three_lt_four_mul_im_sq_of_mem_fdo
theorem three_lt_four_mul_im_sq_of_mem_fdo (h : z ∈ 𝒟ᵒ) : 3 < 4 * z.im ^ 2 
Arguments: {z : ℍ} (h : z ∈ ModularGroup.fdo)
Goal: 3 < 4 * z.im ^ 2
-- ModularGroup.one_lt_normSq_T_zpow_smul
theorem one_lt_normSq_T_zpow_smul (hz : z ∈ 𝒟ᵒ) (n : ℤ) : 1 < normSq (T ^ n • z : ℍ) 
Arguments: {z : ℍ} (hz : z ∈ ModularGroup.fdo) (n : ℤ)
Goal: 1 < Complex.normSq ↑(ModularGroup.T ^ n • z)
-- ModularGroup.eq_zero_of_mem_fdo_of_T_zpow_mem_fdo
theorem eq_zero_of_mem_fdo_of_T_zpow_mem_fdo {n : ℤ} (hz : z ∈ 𝒟ᵒ) (hg : T ^ n • z ∈ 𝒟ᵒ) :
    n = 0 
Arguments: {z : ℍ} {n : ℤ} (hz : z ∈ ModularGroup.fdo) (hg : ModularGroup.T ^ n • z ∈ ModularGroup.fdo)
Goal: n = 0
-- ModularGroup.exists_smul_mem_fd
theorem exists_smul_mem_fd (z : ℍ) : ∃ g : SL(2, ℤ), g • z ∈ 𝒟 
Arguments: (z : ℍ)
Goal: ∃ g, g • z ∈ ModularGroup.fd
-- ModularGroup.abs_c_le_one
theorem abs_c_le_one (hz : z ∈ 𝒟ᵒ) (hg : g • z ∈ 𝒟ᵒ) : |(↑ₘg) 1 0| ≤ 1 
Arguments: {g : SL(2, ℤ)} {z : ℍ} (hz : z ∈ ModularGroup.fdo) (hg : g • z ∈ ModularGroup.fdo)
Goal: |↑g 1 0| ≤ 1
-- ModularGroup.c_eq_zero
theorem c_eq_zero (hz : z ∈ 𝒟ᵒ) (hg : g • z ∈ 𝒟ᵒ) : (↑ₘg) 1 0 = 0 
Arguments: {g : SL(2, ℤ)} {z : ℍ} (hz : z ∈ ModularGroup.fdo) (hg : g • z ∈ ModularGroup.fdo)
Goal: ↑g 1 0 = 0
-- ModularGroup.eq_smul_self_of_mem_fdo_mem_fdo
theorem eq_smul_self_of_mem_fdo_mem_fdo (hz : z ∈ 𝒟ᵒ) (hg : g • z ∈ 𝒟ᵒ) : z = g • z 
Arguments: {g : SL(2, ℤ)} {z : ℍ} (hz : z ∈ ModularGroup.fdo) (hg : g • z ∈ ModularGroup.fdo)
Goal: z = g • z
-- Action.tensorUnit_v
@[simp]
theorem tensorUnit_v : (𝟙_ (Action V G)).V = 𝟙_ V 
Arguments: {V : Type (u + 1)} [CategoryTheory.LargeCategory V] {G : MonCat} [CategoryTheory.MonoidalCategory V]
Goal: (𝟙_ (Action V G)).V = 𝟙_ V
-- Action.tensorUnit_rho
theorem tensorUnit_rho {g : G} : (𝟙_ (Action V G)).ρ g = 𝟙 (𝟙_ V) 
Arguments: {V : Type (u + 1)} [CategoryTheory.LargeCategory V] {G : MonCat} [CategoryTheory.MonoidalCategory V] {g : ↑G}
Goal: (𝟙_ (Action V G)).ρ g = 𝟙 (𝟙_ V)
-- Action.tensor_v
@[simp]
theorem tensor_v {X Y : Action V G} : (X ⊗ Y).V = X.V ⊗ Y.V 
Arguments: {V : Type (u + 1)} [CategoryTheory.LargeCategory V] {G : MonCat} [CategoryTheory.MonoidalCategory V] {X Y : Action V G}
Goal: (CategoryTheory.MonoidalCategory.tensorObj X Y).V = CategoryTheory.MonoidalCategory.tensorObj X.V Y.V
-- Action.tensor_rho
theorem tensor_rho {X Y : Action V G} {g : G} : (X ⊗ Y).ρ g = X.ρ g ⊗ Y.ρ g 
Arguments: {V : Type (u + 1)} [CategoryTheory.LargeCategory V] {G : MonCat} [CategoryTheory.MonoidalCategory V] {X Y : Action V G} {g : ↑G}
Goal: (CategoryTheory.MonoidalCategory.tensorObj X Y).ρ g = CategoryTheory.MonoidalCategory.tensorHom (X.ρ g) (Y.ρ g)
-- Action.tensor_hom
@[simp]
theorem tensor_hom {W X Y Z : Action V G} (f : W ⟶ X) (g : Y ⟶ Z) : (f ⊗ g).hom = f.hom ⊗ g.hom 
Arguments: {V : Type (u + 1)} [CategoryTheory.LargeCategory V] {G : MonCat} [CategoryTheory.MonoidalCategory V] {W X Y Z : Action V G} (f : W ⟶ X) (g : Y ⟶ Z)
Goal: (CategoryTheory.MonoidalCategory.tensorHom f g).hom = CategoryTheory.MonoidalCategory.tensorHom f.hom g.hom
-- Action.whiskerLeft_hom
@[simp]
theorem whiskerLeft_hom (X : Action V G) {Y Z : Action V G} (f : Y ⟶ Z) :
    (X ◁ f).hom = X.V ◁ f.hom 
Arguments: {V : Type (u + 1)} [CategoryTheory.LargeCategory V] {G : MonCat} [CategoryTheory.MonoidalCategory V] (X : Action V G) {Y Z : Action V G} (f : Y ⟶ Z)
Goal: (CategoryTheory.MonoidalCategory.whiskerLeft X f).hom = CategoryTheory.MonoidalCategory.whiskerLeft X.V f.hom
-- Action.whiskerRight_hom
@[simp]
theorem whiskerRight_hom {X Y : Action V G} (f : X ⟶ Y) (Z : Action V G) :
    (f ▷ Z).hom = f.hom ▷ Z.V 
Arguments: {V : Type (u + 1)} [CategoryTheory.LargeCategory V] {G : MonCat} [CategoryTheory.MonoidalCategory V] {X Y : Action V G} (f : X ⟶ Y) (Z : Action V G)
Goal: (CategoryTheory.MonoidalCategory.whiskerRight f Z).hom = CategoryTheory.MonoidalCategory.whiskerRight f.hom Z.V
-- Action.associator_hom_hom
theorem associator_hom_hom {X Y Z : Action V G} :
    Hom.hom (α_ X Y Z).hom = (α_ X.V Y.V Z.V).hom 
Arguments: {V : Type (u + 1)} [CategoryTheory.LargeCategory V] {G : MonCat} [CategoryTheory.MonoidalCategory V] {X Y Z : Action V G}
Goal: (CategoryTheory.MonoidalCategory.associator X Y Z).hom.hom =
  (CategoryTheory.MonoidalCategory.associator X.V Y.V Z.V).hom
-- Action.associator_inv_hom
theorem associator_inv_hom {X Y Z : Action V G} :
    Hom.hom (α_ X Y Z).inv = (α_ X.V Y.V Z.V).inv 
Arguments: {V : Type (u + 1)} [CategoryTheory.LargeCategory V] {G : MonCat} [CategoryTheory.MonoidalCategory V] {X Y Z : Action V G}
Goal: (CategoryTheory.MonoidalCategory.associator X Y Z).inv.hom =
  (CategoryTheory.MonoidalCategory.associator X.V Y.V Z.V).inv
-- Action.leftUnitor_hom_hom
theorem leftUnitor_hom_hom {X : Action V G} : Hom.hom (λ_ X).hom = (λ_ X.V).hom 
Arguments: {V : Type (u + 1)} [CategoryTheory.LargeCategory V] {G : MonCat} [CategoryTheory.MonoidalCategory V] {X : Action V G}
Goal: (CategoryTheory.MonoidalCategory.leftUnitor X).hom.hom = (CategoryTheory.MonoidalCategory.leftUnitor X.V).hom
-- Action.leftUnitor_inv_hom
theorem leftUnitor_inv_hom {X : Action V G} : Hom.hom (λ_ X).inv = (λ_ X.V).inv 
Arguments: {V : Type (u + 1)} [CategoryTheory.LargeCategory V] {G : MonCat} [CategoryTheory.MonoidalCategory V] {X : Action V G}
Goal: (CategoryTheory.MonoidalCategory.leftUnitor X).inv.hom = (CategoryTheory.MonoidalCategory.leftUnitor X.V).inv
-- Action.rightUnitor_hom_hom
theorem rightUnitor_hom_hom {X : Action V G} : Hom.hom (ρ_ X).hom = (ρ_ X.V).hom 
Arguments: {V : Type (u + 1)} [CategoryTheory.LargeCategory V] {G : MonCat} [CategoryTheory.MonoidalCategory V] {X : Action V G}
Goal: (CategoryTheory.MonoidalCategory.rightUnitor X).hom.hom = (CategoryTheory.MonoidalCategory.rightUnitor X.V).hom
-- Action.rightUnitor_inv_hom
theorem rightUnitor_inv_hom {X : Action V G} : Hom.hom (ρ_ X).inv = (ρ_ X.V).inv 
Arguments: {V : Type (u + 1)} [CategoryTheory.LargeCategory V] {G : MonCat} [CategoryTheory.MonoidalCategory V] {X : Action V G}
Goal: (CategoryTheory.MonoidalCategory.rightUnitor X).inv.hom = (CategoryTheory.MonoidalCategory.rightUnitor X.V).inv
-- Action.forgetMonoidal_toLaxMonoidalFunctor_ε
@[simps]
def forgetMonoidal : MonoidalFunctor (Action V G) V 
Arguments: (V : Type (u + 1)) [CategoryTheory.LargeCategory V] (G : MonCat) [CategoryTheory.MonoidalCategory V]
Goal: (Action.forgetMonoidal V G).ε = 𝟙 (𝟙_ V)
-- Action.forgetMonoidal_toLaxMonoidalFunctor_toFunctor
@[simps]
def forgetMonoidal : MonoidalFunctor (Action V G) V 
Arguments: (V : Type (u + 1)) [CategoryTheory.LargeCategory V] (G : MonCat) [CategoryTheory.MonoidalCategory V]
Goal: (Action.forgetMonoidal V G).toFunctor = Action.forget V G
-- Action.forgetMonoidal_toLaxMonoidalFunctor_μ
@[simps]
def forgetMonoidal : MonoidalFunctor (Action V G) V 
Arguments: (V : Type (u + 1)) [CategoryTheory.LargeCategory V] (G : MonCat) [CategoryTheory.MonoidalCategory V] (X Y : Action V G)
Goal: (Action.forgetMonoidal V G).μ X Y =
  𝟙 (CategoryTheory.MonoidalCategory.tensorObj ((Action.forget V G).obj X) ((Action.forget V G).obj Y))
-- Action.forgetBraided_ε
@[simps!]
def forgetBraided : BraidedFunctor (Action V G) V 
Arguments: (V : Type (u + 1)) [CategoryTheory.LargeCategory V] (G : MonCat) [CategoryTheory.MonoidalCategory V] [CategoryTheory.BraidedCategory V]
Goal: (Action.forgetBraided V G).ε = 𝟙 (𝟙_ V)
-- Action.forgetBraided_map
@[simps!]
def forgetBraided : BraidedFunctor (Action V G) V 
Arguments: (V : Type (u + 1)) [CategoryTheory.LargeCategory V] (G : MonCat) [CategoryTheory.MonoidalCategory V] [CategoryTheory.BraidedCategory V]
Goal: ∀ {X Y : Action V G} (f : X ⟶ Y), (Action.forgetBraided V G).map f = f.hom
-- Action.forgetBraided_μ
@[simps!]
def forgetBraided : BraidedFunctor (Action V G) V 
Arguments: (V : Type (u + 1)) [CategoryTheory.LargeCategory V] (G : MonCat) [CategoryTheory.MonoidalCategory V] [CategoryTheory.BraidedCategory V] (X Y : Action V G)
Goal: (Action.forgetBraided V G).μ X Y = 𝟙 (CategoryTheory.MonoidalCategory.tensorObj X.V Y.V)
-- Action.forgetBraided_obj
@[simps!]
def forgetBraided : BraidedFunctor (Action V G) V 
Arguments: (V : Type (u + 1)) [CategoryTheory.LargeCategory V] (G : MonCat) [CategoryTheory.MonoidalCategory V] [CategoryTheory.BraidedCategory V] (M : Action V G)
Goal: (Action.forgetBraided V G).obj M = M.V
-- Action.functorCategoryMonoidalEquivalence.μ_app
@[simp]
theorem functorCategoryMonoidalEquivalence.μ_app (A B : Action V G) :
    ((functorCategoryMonoidalEquivalence V G).μ A B).app PUnit.unit = 𝟙 _ 
Arguments: (V : Type (u + 1)) [CategoryTheory.LargeCategory V] (G : MonCat) [CategoryTheory.MonoidalCategory V] (A B : Action V G)
Goal: ((Action.functorCategoryMonoidalEquivalence V G).μ A B).app PUnit.unit =
  𝟙
    ((CategoryTheory.MonoidalCategory.tensorObj ((Action.functorCategoryMonoidalEquivalence V G).obj A)
          ((Action.functorCategoryMonoidalEquivalence V G).obj B)).obj
      PUnit.unit)
-- Action.functorCategoryMonoidalEquivalence.μIso_inv_app
@[simp]
theorem functorCategoryMonoidalEquivalence.μIso_inv_app (A B : Action V G) :
    ((functorCategoryMonoidalEquivalence V G).μIso A B).inv.app PUnit.unit = 𝟙 _ 
Arguments: (V : Type (u + 1)) [CategoryTheory.LargeCategory V] (G : MonCat) [CategoryTheory.MonoidalCategory V] (A B : Action V G)
Goal: ((Action.functorCategoryMonoidalEquivalence V G).μIso A B).inv.app PUnit.unit =
  𝟙
    (((Action.functorCategoryMonoidalEquivalence V G).obj (CategoryTheory.MonoidalCategory.tensorObj A B)).obj
      PUnit.unit)
-- Action.functorCategoryMonoidalEquivalence.ε_app
@[simp]
theorem functorCategoryMonoidalEquivalence.ε_app :
    (functorCategoryMonoidalEquivalence V G).ε.app PUnit.unit = 𝟙 _ 
Arguments: (V : Type (u + 1)) [CategoryTheory.LargeCategory V] (G : MonCat) [CategoryTheory.MonoidalCategory V]
Goal: (Action.functorCategoryMonoidalEquivalence V G).ε.app PUnit.unit =
  𝟙 ((𝟙_ (CategoryTheory.SingleObj ↑G ⥤ V)).obj PUnit.unit)
-- Action.functorCategoryMonoidalAdjunction.unit_app_hom
@[simp]
theorem functorCategoryMonoidalAdjunction.unit_app_hom (A : Action V G) :
    ((functorCategoryMonoidalAdjunction _ _).unit.app A).hom = 𝟙 _ 
Arguments: (V : Type (u + 1)) [CategoryTheory.LargeCategory V] (G : MonCat) [CategoryTheory.MonoidalCategory V] (A : Action V G)
Goal: ((Action.functorCategoryMonoidalAdjunction V G).unit.app A).hom = 𝟙 ((𝟭 (Action V G)).obj A).V