theorem StrictConvex.preimage_smul (hs : StrictConvex 𝕜 s) (c : 𝕜) :
    StrictConvex 𝕜 ((fun z => c • z) ⁻¹' s) := by
  classical
    obtain rfl | hc := eq_or_ne c 0
    · simp_rw [zero_smul, preimage_const]
      split_ifs
      · exact strictConvex_univ
      · exact strictConvex_empty
    refine' hs.linear_preimage (LinearMap.lsmul _ _ c) _ (smul_right_injective E hc)
    unfold LinearMap.lsmul LinearMap.mk₂ LinearMap.mk₂' LinearMap.mk₂'ₛₗ
    

Proof state:
case inr
𝕜 : Type u_1
𝕝 : Type u_2
E : Type u_3
F : Type u_4
β : Type u_5
inst✝⁵ : OrderedCommSemiring 𝕜
inst✝⁴ : TopologicalSpace E
inst✝³ : AddCommGroup E
inst✝² : Module 𝕜 E
inst✝¹ : NoZeroSMulDivisors 𝕜 E
inst✝ : ContinuousConstSMul 𝕜 E
s : Set E
hs : StrictConvex 𝕜 s
c : 𝕜
hc : c ≠ 0
⊢ Continuous
    ⇑({
          toAddHom :=
            {
              toFun := fun m =>
                {
                  toAddHom :=
                    { toFun := (fun x x_1 => x • x_1) m,
                      map_add' := (_ : ∀ (b₁ b₂ : E), m • (b₁ + b₂) = m • b₁ + m • b₂) },
                  map_smul' := (_ : ∀ (c : 𝕜) (m_1 : E), m • c • m_1 = c • m • m_1) },
              map_add' :=
                (_ :
                  ∀ (m₁ m₂ : 𝕜),
                    (fun m =>
                          {
                            toAddHom :=
                              { toFun := fun x => m • x,
                                map_add' := (_ : ∀ (b₁ b₂ : E), m • (b₁ + b₂) = m • b₁ + m • b₂) },
                            map_smul' := (_ : ∀ (c : 𝕜) (m_1 : E), m • c • m_1 = c • m • m_1) })
                        (m₁ + m₂) =
                      (fun m =>
                            {
                              toAddHom :=
                                { toFun := fun x => m • x,
                                  map_add' := (_ : ∀ (b₁ b₂ : E), m • (b₁ + b₂) = m • b₁ + m • b₂) },
                              map_smul' := (_ : ∀ (c : 𝕜) (m_1 : E), m • c • m_1 = c • m • m_1) })
                          m₁ +
                        (fun m =>
                            {
                              toAddHom :=
                                { toFun := fun x => m • x,
                                  map_add' := (_ : ∀ (b₁ b₂ : E), m • (b₁ + b₂) = m • b₁ + m • b₂) },
                              map_smul' := (_ : ∀ (c : 𝕜) (m_1 : E), m • c • m_1 = c • m • m_1) })
                          m₂) },
          map_smul' :=
            (_ :
              ∀ (c m : 𝕜),
                AddHom.toFun
                    {
                      toFun := fun m =>
                        {
                          toAddHom :=
                            { toFun := fun x => m • x,
                              map_add' := (_ : ∀ (b₁ b₂ : E), m • (b₁ + b₂) = m • b₁ + m • b₂) },
                          map_smul' := (_ : ∀ (c : 𝕜) (m_1 : E), m • c • m_1 = c • m • m_1) },
                      map_add' :=
                        (_ :
                          ∀ (m₁ m₂ : 𝕜),
                            (fun m =>
                                  {
                                    toAddHom :=
                                      { toFun := fun x => m • x,
                                        map_add' := (_ : ∀ (b₁ b₂ : E), m • (b₁ + b₂) = m • b₁ + m • b₂) },
                                    map_smul' := (_ : ∀ (c : 𝕜) (m_1 : E), m • c • m_1 = c • m • m_1) })
                                (m₁ + m₂) =
                              (fun m =>
                                    {
                                      toAddHom :=
                                        { toFun := fun x => m • x,
                                          map_add' := (_ : ∀ (b₁ b₂ : E), m • (b₁ + b₂) = m • b₁ + m • b₂) },
                                      map_smul' := (_ : ∀ (c : 𝕜) (m_1 : E), m • c • m_1 = c • m • m_1) })
                                  m₁ +
                                (fun m =>
                                    {
                                      toAddHom :=
                                        { toFun := fun x => m • x,
                                          map_add' := (_ : ∀ (b₁ b₂ : E), m • (b₁ + b₂) = m • b₁ + m • b₂) },
                                      map_smul' := (_ : ∀ (c : 𝕜) (m_1 : E), m • c • m_1 = c • m • m_1) })
                                  m₂) }
                    (c • m) =
                  (RingHom.id 𝕜) c •
                    AddHom.toFun
                      {
                        toFun := fun m =>
                          {
                            toAddHom :=
                              { toFun := fun x => m • x,
                                map_add' := (_ : ∀ (b₁ b₂ : E), m • (b₁ + b₂) = m • b₁ + m • b₂) },
                            map_smul' := (_ : ∀ (c : 𝕜) (m_1 : E), m • c • m_1 = c • m • m_1) },
                        map_add' :=
                          (_ :
                            ∀ (m₁ m₂ : 𝕜),
                              (fun m =>
                                    {
                                      toAddHom :=
                                        { toFun := fun x => m • x,
                                          map_add' := (_ : ∀ (b₁ b₂ : E), m • (b₁ + b₂) = m • b₁ + m • b₂) },
                                      map_smul' := (_ : ∀ (c : 𝕜) (m_1 : E), m • c • m_1 = c • m • m_1) })
                                  (m₁ + m₂) =
                                (fun m =>
                                      {
                                        toAddHom :=
                                          { toFun := fun x => m • x,
                                            map_add' := (_ : ∀ (b₁ b₂ : E), m • (b₁ + b₂) = m • b₁ + m • b₂) },
                                        map_smul' := (_ : ∀ (c : 𝕜) (m_1 : E), m • c • m_1 = c • m • m_1) })
                                    m₁ +
                                  (fun m =>
                                      {
                                        toAddHom :=
                                          { toFun := fun x => m • x,
                                            map_add' := (_ : ∀ (b₁ b₂ : E), m • (b₁ + b₂) = m • b₁ + m • b₂) },
                                        map_smul' := (_ : ∀ (c : 𝕜) (m_1 : E), m • c • m_1 = c • m • m_1) })
                                    m₂) }
                      m) }
        c)

Next tactic:
exact continuous_const_smul _