Theorem: StrictConvex.preimage_smul
File: Mathlib/Analysis/Convex/Strict.lean

tactic: obtain rfl | hc := eq_or_ne c 0
state_before: 𝕜 : Type u_1
𝕝 : Type ?u.115248
E : Type u_2
F : Type ?u.115254
β : Type ?u.115257
inst✝⁵ : OrderedCommSemiring 𝕜
inst✝⁴ : TopologicalSpace E
inst✝³ : AddCommGroup E
inst✝² : Module 𝕜 E
inst✝¹ : NoZeroSMulDivisors 𝕜 E
inst✝ : ContinuousConstSMul 𝕜 E
s : Set E
hs : StrictConvex 𝕜 s
c : 𝕜
⊢ StrictConvex 𝕜 ((fun z => c • z) ⁻¹' s)

tactic: refine' hs.linear_preimage (LinearMap.lsmul _ _ c) _ (smul_right_injective E hc)
state_before: case inr
𝕜 : Type u_1
𝕝 : Type ?u.115248
E : Type u_2
F : Type ?u.115254
β : Type ?u.115257
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
⊢ StrictConvex 𝕜 ((fun z => c • z) ⁻¹' s)

tactic: unfold LinearMap.lsmul LinearMap.mk₂ LinearMap.mk₂' LinearMap.mk₂'ₛₗ
state_before: case inr
𝕜 : Type u_1
𝕝 : Type ?u.115248
E : Type u_2
F : Type ?u.115254
β : Type ?u.115257
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 ↑(↑(LinearMap.lsmul 𝕜 E) c)

tactic: exact continuous_const_smul _
state_before: case inr
𝕜 : Type u_1
𝕝 : Type ?u.115248
E : Type u_2
F : Type ?u.115254
β : Type ?u.115257
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 : 𝕜) (n : E), m • c • n = ↑(RingHom.id 𝕜) c • m • n) },
                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)

tactic: simp_rw [zero_smul, preimage_const]
state_before: case inl
𝕜 : Type u_1
𝕝 : Type ?u.115248
E : Type u_2
F : Type ?u.115254
β : Type ?u.115257
inst✝⁵ : OrderedCommSemiring 𝕜
inst✝⁴ : TopologicalSpace E
inst✝³ : AddCommGroup E
inst✝² : Module 𝕜 E
inst✝¹ : NoZeroSMulDivisors 𝕜 E
inst✝ : ContinuousConstSMul 𝕜 E
s : Set E
hs : StrictConvex 𝕜 s
⊢ StrictConvex 𝕜 ((fun z => 0 • z) ⁻¹' s)

tactic: split_ifs
state_before: case inl
𝕜 : Type u_1
𝕝 : Type ?u.115248
E : Type u_2
F : Type ?u.115254
β : Type ?u.115257
inst✝⁵ : OrderedCommSemiring 𝕜
inst✝⁴ : TopologicalSpace E
inst✝³ : AddCommGroup E
inst✝² : Module 𝕜 E
inst✝¹ : NoZeroSMulDivisors 𝕜 E
inst✝ : ContinuousConstSMul 𝕜 E
s : Set E
hs : StrictConvex 𝕜 s
⊢ StrictConvex 𝕜 (if 0 ∈ s then univ else ∅)

tactic: exact strictConvex_univ
state_before: case inl.inl
𝕜 : Type u_1
𝕝 : Type ?u.115248
E : Type u_2
F : Type ?u.115254
β : Type ?u.115257
inst✝⁵ : OrderedCommSemiring 𝕜
inst✝⁴ : TopologicalSpace E
inst✝³ : AddCommGroup E
inst✝² : Module 𝕜 E
inst✝¹ : NoZeroSMulDivisors 𝕜 E
inst✝ : ContinuousConstSMul 𝕜 E
s : Set E
hs : StrictConvex 𝕜 s
h✝ : 0 ∈ s
⊢ StrictConvex 𝕜 univ

tactic: exact strictConvex_empty
state_before: case inl.inr
𝕜 : Type u_1
𝕝 : Type ?u.115248
E : Type u_2
F : Type ?u.115254
β : Type ?u.115257
inst✝⁵ : OrderedCommSemiring 𝕜
inst✝⁴ : TopologicalSpace E
inst✝³ : AddCommGroup E
inst✝² : Module 𝕜 E
inst✝¹ : NoZeroSMulDivisors 𝕜 E
inst✝ : ContinuousConstSMul 𝕜 E
s : Set E
hs : StrictConvex 𝕜 s
h✝ : ¬0 ∈ s
⊢ StrictConvex 𝕜 ∅