/-- Given a map from a rack to a group, lift it to being a map from the enveloping group.
More precisely, the `EnvelGroup` functor is left adjoint to `Quandle.Conj`.
-/
def toEnvelGroup.map {R : Type*} [Rack R] {G : Type*} [Group G] :
    (R →◃ Quandle.Conj G) ≃ (EnvelGroup R →* G)
    where
  toFun f :=
    { toFun := fun x =>
        Quotient.liftOn x (toEnvelGroup.mapAux f) fun a b ⟨hab⟩ =>
          toEnvelGroup.mapAux.well_def f hab
      map_one' := by
        change Quotient.liftOn ⟦Rack.PreEnvelGroup.unit⟧ (toEnvelGroup.mapAux f) _ = 1
        simp only [Quotient.lift_mk, mapAux]
      map_mul' := fun x y =>
        Quotient.inductionOn₂ x y fun x y => by
          simp only [toEnvelGroup.mapAux]
          change Quotient.liftOn ⟦mul x y⟧ (toEnvelGroup.mapAux f) _ = _
          simp [toEnvelGroup.mapAux] }
  invFun F := (Quandle.Conj.map F).comp (toEnvelGroup R)
  left_inv f := by ext; 

Proof state:
case toFun.h
R : Type u_1
inst✝¹ : Rack R
G : Type u_2
inst✝ : Group G
f : R →◃ Quandle.Conj G
x✝ : R
⊢ ShelfHom.toFun
      ((fun F => ShelfHom.comp (Quandle.Conj.map F) (toEnvelGroup R))
        ((fun f =>
            {
              toOneHom :=
                {
                  toFun := fun x =>
                    Quotient.liftOn x (mapAux f) (_ : ∀ (a b : PreEnvelGroup R), a ≈ b → mapAux f a = mapAux f b),
                  map_one' :=
                    (_ :
                      Quotient.liftOn ⟦unit⟧ (mapAux f)
                          (_ : ∀ (a b : PreEnvelGroup R), a ≈ b → mapAux f a = mapAux f b) =
                        1) },
              map_mul' :=
                (_ :
                  ∀ (x y : EnvelGroup R),
                    OneHom.toFun
                        {
                          toFun := fun x =>
                            Quotient.liftOn x (mapAux f)
                              (_ : ∀ (a b : PreEnvelGroup R), a ≈ b → mapAux f a = mapAux f b),
                          map_one' :=
                            (_ :
                              Quotient.liftOn ⟦unit⟧ (mapAux f)
                                  (_ : ∀ (a b : PreEnvelGroup R), a ≈ b → mapAux f a = mapAux f b) =
                                1) }
                        (x * y) =
                      OneHom.toFun
                          {
                            toFun := fun x =>
                              Quotient.liftOn x (mapAux f)
                                (_ : ∀ (a b : PreEnvelGroup R), a ≈ b → mapAux f a = mapAux f b),
                            map_one' :=
                              (_ :
                                Quotient.liftOn ⟦unit⟧ (mapAux f)
                                    (_ : ∀ (a b : PreEnvelGroup R), a ≈ b → mapAux f a = mapAux f b) =
                                  1) }
                          x *
                        OneHom.toFun
                          {
                            toFun := fun x =>
                              Quotient.liftOn x (mapAux f)
                                (_ : ∀ (a b : PreEnvelGroup R), a ≈ b → mapAux f a = mapAux f b),
                            map_one' :=
                              (_ :
                                Quotient.liftOn ⟦unit⟧ (mapAux f)
                                    (_ : ∀ (a b : PreEnvelGroup R), a ≈ b → mapAux f a = mapAux f b) =
                                  1) }
                          y) })
          f))
      x✝ =
    ShelfHom.toFun f x✝

Next tactic:
rfl