File: Mathlib/Analysis/Convex/Side.lean

full_name: AffineSubspace.WSameSide
code: /-- The points `x` and `y` are weakly on the same side of `s`. -/
def WSameSide (s : AffineSubspace R P) (x y : P) : Prop 
goal: Prop

full_name: AffineSubspace.SSameSide
code: /-- The points `x` and `y` are strictly on the same side of `s`. -/
def SSameSide (s : AffineSubspace R P) (x y : P) : Prop 
goal: Prop

full_name: AffineSubspace.WOppSide
code: /-- The points `x` and `y` are weakly on opposite sides of `s`. -/
def WOppSide (s : AffineSubspace R P) (x y : P) : Prop 
goal: Prop

full_name: AffineSubspace.SOppSide
code: /-- The points `x` and `y` are strictly on opposite sides of `s`. -/
def SOppSide (s : AffineSubspace R P) (x y : P) : Prop 
goal: Prop

full_name: AffineSubspace.WSameSide.map
code: theorem WSameSide.map {s : AffineSubspace R P} {x y : P} (h : s.WSameSide x y) (f : P →ᵃ[R] P') :
    (s.map f).WSameSide (f x) (f y) 
goal: (AffineSubspace.map f s).WSameSide (f x) (f y)

full_name: Function.Injective.wSameSide_map_iff
code: theorem _root_.Function.Injective.wSameSide_map_iff {s : AffineSubspace R P} {x y : P}
    {f : P →ᵃ[R] P'} (hf : Function.Injective f) :
    (s.map f).WSameSide (f x) (f y) ↔ s.WSameSide x y 
goal: (AffineSubspace.map f s).WSameSide (f x) (f y) ↔ s.WSameSide x y

full_name: Function.Injective.sSameSide_map_iff
code: theorem _root_.Function.Injective.sSameSide_map_iff {s : AffineSubspace R P} {x y : P}
    {f : P →ᵃ[R] P'} (hf : Function.Injective f) :
    (s.map f).SSameSide (f x) (f y) ↔ s.SSameSide x y 
goal: (AffineSubspace.map f s).SSameSide (f x) (f y) ↔ s.SSameSide x y

full_name: AffineEquiv.wSameSide_map_iff
code: @[simp]
theorem _root_.AffineEquiv.wSameSide_map_iff {s : AffineSubspace R P} {x y : P} (f : P ≃ᵃ[R] P') :
    (s.map ↑f).WSameSide (f x) (f y) ↔ s.WSameSide x y 
goal: (AffineSubspace.map (↑f) s).WSameSide (f x) (f y) ↔ s.WSameSide x y

full_name: AffineEquiv.sSameSide_map_iff
code: @[simp]
theorem _root_.AffineEquiv.sSameSide_map_iff {s : AffineSubspace R P} {x y : P} (f : P ≃ᵃ[R] P') :
    (s.map ↑f).SSameSide (f x) (f y) ↔ s.SSameSide x y 
goal: (AffineSubspace.map (↑f) s).SSameSide (f x) (f y) ↔ s.SSameSide x y

full_name: AffineSubspace.WOppSide.map
code: theorem WOppSide.map {s : AffineSubspace R P} {x y : P} (h : s.WOppSide x y) (f : P →ᵃ[R] P') :
    (s.map f).WOppSide (f x) (f y) 
goal: (AffineSubspace.map f s).WOppSide (f x) (f y)

full_name: Function.Injective.wOppSide_map_iff
code: theorem _root_.Function.Injective.wOppSide_map_iff {s : AffineSubspace R P} {x y : P}
    {f : P →ᵃ[R] P'} (hf : Function.Injective f) :
    (s.map f).WOppSide (f x) (f y) ↔ s.WOppSide x y 
goal: (AffineSubspace.map f s).WOppSide (f x) (f y) ↔ s.WOppSide x y

full_name: Function.Injective.sOppSide_map_iff
code: theorem _root_.Function.Injective.sOppSide_map_iff {s : AffineSubspace R P} {x y : P}
    {f : P →ᵃ[R] P'} (hf : Function.Injective f) :
    (s.map f).SOppSide (f x) (f y) ↔ s.SOppSide x y 
goal: (AffineSubspace.map f s).SOppSide (f x) (f y) ↔ s.SOppSide x y

full_name: AffineEquiv.wOppSide_map_iff
code: @[simp]
theorem _root_.AffineEquiv.wOppSide_map_iff {s : AffineSubspace R P} {x y : P} (f : P ≃ᵃ[R] P') :
    (s.map ↑f).WOppSide (f x) (f y) ↔ s.WOppSide x y 
goal: (AffineSubspace.map (↑f) s).WOppSide (f x) (f y) ↔ s.WOppSide x y

full_name: AffineEquiv.sOppSide_map_iff
code: @[simp]
theorem _root_.AffineEquiv.sOppSide_map_iff {s : AffineSubspace R P} {x y : P} (f : P ≃ᵃ[R] P') :
    (s.map ↑f).SOppSide (f x) (f y) ↔ s.SOppSide x y 
goal: (AffineSubspace.map (↑f) s).SOppSide (f x) (f y) ↔ s.SOppSide x y

full_name: AffineSubspace.WSameSide.nonempty
code: theorem WSameSide.nonempty {s : AffineSubspace R P} {x y : P} (h : s.WSameSide x y) :
    (s : Set P).Nonempty 
goal: (↑s).Nonempty

full_name: AffineSubspace.SSameSide.nonempty
code: theorem SSameSide.nonempty {s : AffineSubspace R P} {x y : P} (h : s.SSameSide x y) :
    (s : Set P).Nonempty 
goal: (↑s).Nonempty

full_name: AffineSubspace.WOppSide.nonempty
code: theorem WOppSide.nonempty {s : AffineSubspace R P} {x y : P} (h : s.WOppSide x y) :
    (s : Set P).Nonempty 
goal: (↑s).Nonempty

full_name: AffineSubspace.SOppSide.nonempty
code: theorem SOppSide.nonempty {s : AffineSubspace R P} {x y : P} (h : s.SOppSide x y) :
    (s : Set P).Nonempty 
goal: (↑s).Nonempty

full_name: AffineSubspace.SSameSide.wSameSide
code: theorem SSameSide.wSameSide {s : AffineSubspace R P} {x y : P} (h : s.SSameSide x y) :
    s.WSameSide x y 
goal: s.WSameSide x y

full_name: AffineSubspace.SSameSide.left_not_mem
code: theorem SSameSide.left_not_mem {s : AffineSubspace R P} {x y : P} (h : s.SSameSide x y) : x ∉ s 
goal: x ∉ s

full_name: AffineSubspace.SSameSide.right_not_mem
code: theorem SSameSide.right_not_mem {s : AffineSubspace R P} {x y : P} (h : s.SSameSide x y) : y ∉ s 
goal: y ∉ s

full_name: AffineSubspace.SOppSide.wOppSide
code: theorem SOppSide.wOppSide {s : AffineSubspace R P} {x y : P} (h : s.SOppSide x y) :
    s.WOppSide x y 
goal: s.WOppSide x y

full_name: AffineSubspace.SOppSide.left_not_mem
code: theorem SOppSide.left_not_mem {s : AffineSubspace R P} {x y : P} (h : s.SOppSide x y) : x ∉ s 
goal: x ∉ s

full_name: AffineSubspace.SOppSide.right_not_mem
code: theorem SOppSide.right_not_mem {s : AffineSubspace R P} {x y : P} (h : s.SOppSide x y) : y ∉ s 
goal: y ∉ s

full_name: AffineSubspace.wSameSide_comm
code: theorem wSameSide_comm {s : AffineSubspace R P} {x y : P} : s.WSameSide x y ↔ s.WSameSide y x 
goal: s.WSameSide x y ↔ s.WSameSide y x

full_name: AffineSubspace.sSameSide_comm
code: theorem sSameSide_comm {s : AffineSubspace R P} {x y : P} : s.SSameSide x y ↔ s.SSameSide y x 
goal: s.SSameSide x y ↔ s.SSameSide y x

full_name: AffineSubspace.wOppSide_comm
code: theorem wOppSide_comm {s : AffineSubspace R P} {x y : P} : s.WOppSide x y ↔ s.WOppSide y x 
goal: s.WOppSide x y ↔ s.WOppSide y x

full_name: AffineSubspace.sOppSide_comm
code: theorem sOppSide_comm {s : AffineSubspace R P} {x y : P} : s.SOppSide x y ↔ s.SOppSide y x 
goal: s.SOppSide x y ↔ s.SOppSide y x

full_name: AffineSubspace.not_wSameSide_bot
code: theorem not_wSameSide_bot (x y : P) : ¬(⊥ : AffineSubspace R P).WSameSide x y 
goal: ¬⊥.WSameSide x y

full_name: AffineSubspace.not_sSameSide_bot
code: theorem not_sSameSide_bot (x y : P) : ¬(⊥ : AffineSubspace R P).SSameSide x y 
goal: ¬⊥.SSameSide x y

full_name: AffineSubspace.not_wOppSide_bot
code: theorem not_wOppSide_bot (x y : P) : ¬(⊥ : AffineSubspace R P).WOppSide x y 
goal: ¬⊥.WOppSide x y

full_name: AffineSubspace.not_sOppSide_bot
code: theorem not_sOppSide_bot (x y : P) : ¬(⊥ : AffineSubspace R P).SOppSide x y 
goal: ¬⊥.SOppSide x y

full_name: AffineSubspace.wSameSide_self_iff
code: @[simp]
theorem wSameSide_self_iff {s : AffineSubspace R P} {x : P} :
    s.WSameSide x x ↔ (s : Set P).Nonempty 
goal: s.WSameSide x x ↔ (↑s).Nonempty

full_name: AffineSubspace.sSameSide_self_iff
code: theorem sSameSide_self_iff {s : AffineSubspace R P} {x : P} :
    s.SSameSide x x ↔ (s : Set P).Nonempty ∧ x ∉ s 
goal: s.SSameSide x x ↔ (↑s).Nonempty ∧ x ∉ s

full_name: AffineSubspace.wSameSide_of_left_mem
code: theorem wSameSide_of_left_mem {s : AffineSubspace R P} {x : P} (y : P) (hx : x ∈ s) :
    s.WSameSide x y 
goal: s.WSameSide x y

full_name: AffineSubspace.wSameSide_of_right_mem
code: theorem wSameSide_of_right_mem {s : AffineSubspace R P} (x : P) {y : P} (hy : y ∈ s) :
    s.WSameSide x y 
goal: s.WSameSide x y

full_name: AffineSubspace.wOppSide_of_left_mem
code: theorem wOppSide_of_left_mem {s : AffineSubspace R P} {x : P} (y : P) (hx : x ∈ s) :
    s.WOppSide x y 
goal: s.WOppSide x y

full_name: AffineSubspace.wOppSide_of_right_mem
code: theorem wOppSide_of_right_mem {s : AffineSubspace R P} (x : P) {y : P} (hy : y ∈ s) :
    s.WOppSide x y 
goal: s.WOppSide x y

full_name: AffineSubspace.wSameSide_vadd_left_iff
code: theorem wSameSide_vadd_left_iff {s : AffineSubspace R P} {x y : P} {v : V} (hv : v ∈ s.direction) :
    s.WSameSide (v +ᵥ x) y ↔ s.WSameSide x y 
goal: s.WSameSide (v +ᵥ x) y ↔ s.WSameSide x y

full_name: AffineSubspace.wSameSide_vadd_right_iff
code: theorem wSameSide_vadd_right_iff {s : AffineSubspace R P} {x y : P} {v : V} (hv : v ∈ s.direction) :
    s.WSameSide x (v +ᵥ y) ↔ s.WSameSide x y 
goal: s.WSameSide x (v +ᵥ y) ↔ s.WSameSide x y

full_name: AffineSubspace.sSameSide_vadd_left_iff
code: theorem sSameSide_vadd_left_iff {s : AffineSubspace R P} {x y : P} {v : V} (hv : v ∈ s.direction) :
    s.SSameSide (v +ᵥ x) y ↔ s.SSameSide x y 
goal: s.SSameSide (v +ᵥ x) y ↔ s.SSameSide x y

full_name: AffineSubspace.sSameSide_vadd_right_iff
code: theorem sSameSide_vadd_right_iff {s : AffineSubspace R P} {x y : P} {v : V} (hv : v ∈ s.direction) :
    s.SSameSide x (v +ᵥ y) ↔ s.SSameSide x y 
goal: s.SSameSide x (v +ᵥ y) ↔ s.SSameSide x y

full_name: AffineSubspace.wOppSide_vadd_left_iff
code: theorem wOppSide_vadd_left_iff {s : AffineSubspace R P} {x y : P} {v : V} (hv : v ∈ s.direction) :
    s.WOppSide (v +ᵥ x) y ↔ s.WOppSide x y 
goal: s.WOppSide (v +ᵥ x) y ↔ s.WOppSide x y

full_name: AffineSubspace.wOppSide_vadd_right_iff
code: theorem wOppSide_vadd_right_iff {s : AffineSubspace R P} {x y : P} {v : V} (hv : v ∈ s.direction) :
    s.WOppSide x (v +ᵥ y) ↔ s.WOppSide x y 
goal: s.WOppSide x (v +ᵥ y) ↔ s.WOppSide x y

full_name: AffineSubspace.sOppSide_vadd_left_iff
code: theorem sOppSide_vadd_left_iff {s : AffineSubspace R P} {x y : P} {v : V} (hv : v ∈ s.direction) :
    s.SOppSide (v +ᵥ x) y ↔ s.SOppSide x y 
goal: s.SOppSide (v +ᵥ x) y ↔ s.SOppSide x y

full_name: AffineSubspace.sOppSide_vadd_right_iff
code: theorem sOppSide_vadd_right_iff {s : AffineSubspace R P} {x y : P} {v : V} (hv : v ∈ s.direction) :
    s.SOppSide x (v +ᵥ y) ↔ s.SOppSide x y 
goal: s.SOppSide x (v +ᵥ y) ↔ s.SOppSide x y

full_name: AffineSubspace.wSameSide_smul_vsub_vadd_left
code: theorem wSameSide_smul_vsub_vadd_left {s : AffineSubspace R P} {p₁ p₂ : P} (x : P) (hp₁ : p₁ ∈ s)
    (hp₂ : p₂ ∈ s) {t : R} (ht : 0 ≤ t) : s.WSameSide (t • (x -ᵥ p₁) +ᵥ p₂) x 
goal: s.WSameSide (t • (x -ᵥ p₁) +ᵥ p₂) x

full_name: AffineSubspace.wSameSide_smul_vsub_vadd_right
code: theorem wSameSide_smul_vsub_vadd_right {s : AffineSubspace R P} {p₁ p₂ : P} (x : P) (hp₁ : p₁ ∈ s)
    (hp₂ : p₂ ∈ s) {t : R} (ht : 0 ≤ t) : s.WSameSide x (t • (x -ᵥ p₁) +ᵥ p₂) 
goal: s.WSameSide x (t • (x -ᵥ p₁) +ᵥ p₂)

full_name: AffineSubspace.wSameSide_lineMap_left
code: theorem wSameSide_lineMap_left {s : AffineSubspace R P} {x : P} (y : P) (h : x ∈ s) {t : R}
    (ht : 0 ≤ t) : s.WSameSide (lineMap x y t) y 
goal: s.WSameSide ((AffineMap.lineMap x y) t) y

full_name: AffineSubspace.wSameSide_lineMap_right
code: theorem wSameSide_lineMap_right {s : AffineSubspace R P} {x : P} (y : P) (h : x ∈ s) {t : R}
    (ht : 0 ≤ t) : s.WSameSide y (lineMap x y t) 
goal: s.WSameSide y ((AffineMap.lineMap x y) t)

full_name: AffineSubspace.wOppSide_smul_vsub_vadd_left
code: theorem wOppSide_smul_vsub_vadd_left {s : AffineSubspace R P} {p₁ p₂ : P} (x : P) (hp₁ : p₁ ∈ s)
    (hp₂ : p₂ ∈ s) {t : R} (ht : t ≤ 0) : s.WOppSide (t • (x -ᵥ p₁) +ᵥ p₂) x 
goal: s.WOppSide (t • (x -ᵥ p₁) +ᵥ p₂) x

full_name: AffineSubspace.wOppSide_smul_vsub_vadd_right
code: theorem wOppSide_smul_vsub_vadd_right {s : AffineSubspace R P} {p₁ p₂ : P} (x : P) (hp₁ : p₁ ∈ s)
    (hp₂ : p₂ ∈ s) {t : R} (ht : t ≤ 0) : s.WOppSide x (t • (x -ᵥ p₁) +ᵥ p₂) 
goal: s.WOppSide x (t • (x -ᵥ p₁) +ᵥ p₂)

full_name: AffineSubspace.wOppSide_lineMap_left
code: theorem wOppSide_lineMap_left {s : AffineSubspace R P} {x : P} (y : P) (h : x ∈ s) {t : R}
    (ht : t ≤ 0) : s.WOppSide (lineMap x y t) y 
goal: s.WOppSide ((AffineMap.lineMap x y) t) y

full_name: AffineSubspace.wOppSide_lineMap_right
code: theorem wOppSide_lineMap_right {s : AffineSubspace R P} {x : P} (y : P) (h : x ∈ s) {t : R}
    (ht : t ≤ 0) : s.WOppSide y (lineMap x y t) 
goal: s.WOppSide y ((AffineMap.lineMap x y) t)

full_name: Wbtw.wSameSide₂₃
code: theorem _root_.Wbtw.wSameSide₂₃ {s : AffineSubspace R P} {x y z : P} (h : Wbtw R x y z)
    (hx : x ∈ s) : s.WSameSide y z 
goal: s.WSameSide y z

full_name: Wbtw.wSameSide₃₂
code: theorem _root_.Wbtw.wSameSide₃₂ {s : AffineSubspace R P} {x y z : P} (h : Wbtw R x y z)
    (hx : x ∈ s) : s.WSameSide z y 
goal: s.WSameSide z y

full_name: Wbtw.wSameSide₁₂
code: theorem _root_.Wbtw.wSameSide₁₂ {s : AffineSubspace R P} {x y z : P} (h : Wbtw R x y z)
    (hz : z ∈ s) : s.WSameSide x y 
goal: s.WSameSide x y

full_name: Wbtw.wSameSide₂₁
code: theorem _root_.Wbtw.wSameSide₂₁ {s : AffineSubspace R P} {x y z : P} (h : Wbtw R x y z)
    (hz : z ∈ s) : s.WSameSide y x 
goal: s.WSameSide y x

full_name: Wbtw.wOppSide₁₃
code: theorem _root_.Wbtw.wOppSide₁₃ {s : AffineSubspace R P} {x y z : P} (h : Wbtw R x y z)
    (hy : y ∈ s) : s.WOppSide x z 
goal: s.WOppSide x z

full_name: Wbtw.wOppSide₃₁
code: theorem _root_.Wbtw.wOppSide₃₁ {s : AffineSubspace R P} {x y z : P} (h : Wbtw R x y z)
    (hy : y ∈ s) : s.WOppSide z x 
goal: s.WOppSide z x

full_name: AffineSubspace.wOppSide_self_iff
code: @[simp]
theorem wOppSide_self_iff {s : AffineSubspace R P} {x : P} : s.WOppSide x x ↔ x ∈ s 
goal: s.WOppSide x x ↔ x ∈ s

full_name: AffineSubspace.not_sOppSide_self
code: theorem not_sOppSide_self (s : AffineSubspace R P) (x : P) : ¬s.SOppSide x x 
goal: ¬s.SOppSide x x

full_name: AffineSubspace.wSameSide_iff_exists_left
code: theorem wSameSide_iff_exists_left {s : AffineSubspace R P} {x y p₁ : P} (h : p₁ ∈ s) :
    s.WSameSide x y ↔ x ∈ s ∨ ∃ p₂ ∈ s, SameRay R (x -ᵥ p₁) (y -ᵥ p₂) 
goal: s.WSameSide x y ↔ x ∈ s ∨ ∃ p₂ ∈ s, SameRay R (x -ᵥ p₁) (y -ᵥ p₂)

full_name: AffineSubspace.wSameSide_iff_exists_right
code: theorem wSameSide_iff_exists_right {s : AffineSubspace R P} {x y p₂ : P} (h : p₂ ∈ s) :
    s.WSameSide x y ↔ y ∈ s ∨ ∃ p₁ ∈ s, SameRay R (x -ᵥ p₁) (y -ᵥ p₂) 
goal: s.WSameSide x y ↔ y ∈ s ∨ ∃ p₁ ∈ s, SameRay R (x -ᵥ p₁) (y -ᵥ p₂)

full_name: AffineSubspace.sSameSide_iff_exists_left
code: theorem sSameSide_iff_exists_left {s : AffineSubspace R P} {x y p₁ : P} (h : p₁ ∈ s) :
    s.SSameSide x y ↔ x ∉ s ∧ y ∉ s ∧ ∃ p₂ ∈ s, SameRay R (x -ᵥ p₁) (y -ᵥ p₂) 
goal: s.SSameSide x y ↔ x ∉ s ∧ y ∉ s ∧ ∃ p₂ ∈ s, SameRay R (x -ᵥ p₁) (y -ᵥ p₂)

full_name: AffineSubspace.sSameSide_iff_exists_right
code: theorem sSameSide_iff_exists_right {s : AffineSubspace R P} {x y p₂ : P} (h : p₂ ∈ s) :
    s.SSameSide x y ↔ x ∉ s ∧ y ∉ s ∧ ∃ p₁ ∈ s, SameRay R (x -ᵥ p₁) (y -ᵥ p₂) 
goal: s.SSameSide x y ↔ x ∉ s ∧ y ∉ s ∧ ∃ p₁ ∈ s, SameRay R (x -ᵥ p₁) (y -ᵥ p₂)

full_name: AffineSubspace.wOppSide_iff_exists_left
code: theorem wOppSide_iff_exists_left {s : AffineSubspace R P} {x y p₁ : P} (h : p₁ ∈ s) :
    s.WOppSide x y ↔ x ∈ s ∨ ∃ p₂ ∈ s, SameRay R (x -ᵥ p₁) (p₂ -ᵥ y) 
goal: s.WOppSide x y ↔ x ∈ s ∨ ∃ p₂ ∈ s, SameRay R (x -ᵥ p₁) (p₂ -ᵥ y)

full_name: AffineSubspace.wOppSide_iff_exists_right
code: theorem wOppSide_iff_exists_right {s : AffineSubspace R P} {x y p₂ : P} (h : p₂ ∈ s) :
    s.WOppSide x y ↔ y ∈ s ∨ ∃ p₁ ∈ s, SameRay R (x -ᵥ p₁) (p₂ -ᵥ y) 
goal: s.WOppSide x y ↔ y ∈ s ∨ ∃ p₁ ∈ s, SameRay R (x -ᵥ p₁) (p₂ -ᵥ y)

full_name: AffineSubspace.sOppSide_iff_exists_left
code: theorem sOppSide_iff_exists_left {s : AffineSubspace R P} {x y p₁ : P} (h : p₁ ∈ s) :
    s.SOppSide x y ↔ x ∉ s ∧ y ∉ s ∧ ∃ p₂ ∈ s, SameRay R (x -ᵥ p₁) (p₂ -ᵥ y) 
goal: s.SOppSide x y ↔ x ∉ s ∧ y ∉ s ∧ ∃ p₂ ∈ s, SameRay R (x -ᵥ p₁) (p₂ -ᵥ y)

full_name: AffineSubspace.sOppSide_iff_exists_right
code: theorem sOppSide_iff_exists_right {s : AffineSubspace R P} {x y p₂ : P} (h : p₂ ∈ s) :
    s.SOppSide x y ↔ x ∉ s ∧ y ∉ s ∧ ∃ p₁ ∈ s, SameRay R (x -ᵥ p₁) (p₂ -ᵥ y) 
goal: s.SOppSide x y ↔ x ∉ s ∧ y ∉ s ∧ ∃ p₁ ∈ s, SameRay R (x -ᵥ p₁) (p₂ -ᵥ y)

full_name: AffineSubspace.WSameSide.trans
code: theorem WSameSide.trans {s : AffineSubspace R P} {x y z : P} (hxy : s.WSameSide x y)
    (hyz : s.WSameSide y z) (hy : y ∉ s) : s.WSameSide x z 
goal: s.WSameSide x z

full_name: AffineSubspace.WSameSide.trans_sSameSide
code: theorem WSameSide.trans_sSameSide {s : AffineSubspace R P} {x y z : P} (hxy : s.WSameSide x y)
    (hyz : s.SSameSide y z) : s.WSameSide x z 
goal: s.WSameSide x z

full_name: AffineSubspace.WSameSide.trans_wOppSide
code: theorem WSameSide.trans_wOppSide {s : AffineSubspace R P} {x y z : P} (hxy : s.WSameSide x y)
    (hyz : s.WOppSide y z) (hy : y ∉ s) : s.WOppSide x z 
goal: s.WOppSide x z

full_name: AffineSubspace.WSameSide.trans_sOppSide
code: theorem WSameSide.trans_sOppSide {s : AffineSubspace R P} {x y z : P} (hxy : s.WSameSide x y)
    (hyz : s.SOppSide y z) : s.WOppSide x z 
goal: s.WOppSide x z

full_name: AffineSubspace.SSameSide.trans_wSameSide
code: theorem SSameSide.trans_wSameSide {s : AffineSubspace R P} {x y z : P} (hxy : s.SSameSide x y)
    (hyz : s.WSameSide y z) : s.WSameSide x z 
goal: s.WSameSide x z

full_name: AffineSubspace.SSameSide.trans
code: theorem SSameSide.trans {s : AffineSubspace R P} {x y z : P} (hxy : s.SSameSide x y)
    (hyz : s.SSameSide y z) : s.SSameSide x z 
goal: s.SSameSide x z

full_name: AffineSubspace.SSameSide.trans_wOppSide
code: theorem SSameSide.trans_wOppSide {s : AffineSubspace R P} {x y z : P} (hxy : s.SSameSide x y)
    (hyz : s.WOppSide y z) : s.WOppSide x z 
goal: s.WOppSide x z

full_name: AffineSubspace.SSameSide.trans_sOppSide
code: theorem SSameSide.trans_sOppSide {s : AffineSubspace R P} {x y z : P} (hxy : s.SSameSide x y)
    (hyz : s.SOppSide y z) : s.SOppSide x z 
goal: s.SOppSide x z

full_name: AffineSubspace.WOppSide.trans_wSameSide
code: theorem WOppSide.trans_wSameSide {s : AffineSubspace R P} {x y z : P} (hxy : s.WOppSide x y)
    (hyz : s.WSameSide y z) (hy : y ∉ s) : s.WOppSide x z 
goal: s.WOppSide x z

full_name: AffineSubspace.WOppSide.trans_sSameSide
code: theorem WOppSide.trans_sSameSide {s : AffineSubspace R P} {x y z : P} (hxy : s.WOppSide x y)
    (hyz : s.SSameSide y z) : s.WOppSide x z 
goal: s.WOppSide x z

full_name: AffineSubspace.WOppSide.trans
code: theorem WOppSide.trans {s : AffineSubspace R P} {x y z : P} (hxy : s.WOppSide x y)
    (hyz : s.WOppSide y z) (hy : y ∉ s) : s.WSameSide x z 
goal: s.WSameSide x z

full_name: AffineSubspace.WOppSide.trans_sOppSide
code: theorem WOppSide.trans_sOppSide {s : AffineSubspace R P} {x y z : P} (hxy : s.WOppSide x y)
    (hyz : s.SOppSide y z) : s.WSameSide x z 
goal: s.WSameSide x z

full_name: AffineSubspace.SOppSide.trans_wSameSide
code: theorem SOppSide.trans_wSameSide {s : AffineSubspace R P} {x y z : P} (hxy : s.SOppSide x y)
    (hyz : s.WSameSide y z) : s.WOppSide x z 
goal: s.WOppSide x z

full_name: AffineSubspace.SOppSide.trans_sSameSide
code: theorem SOppSide.trans_sSameSide {s : AffineSubspace R P} {x y z : P} (hxy : s.SOppSide x y)
    (hyz : s.SSameSide y z) : s.SOppSide x z 
goal: s.SOppSide x z

full_name: AffineSubspace.SOppSide.trans_wOppSide
code: theorem SOppSide.trans_wOppSide {s : AffineSubspace R P} {x y z : P} (hxy : s.SOppSide x y)
    (hyz : s.WOppSide y z) : s.WSameSide x z 
goal: s.WSameSide x z

full_name: AffineSubspace.SOppSide.trans
code: theorem SOppSide.trans {s : AffineSubspace R P} {x y z : P} (hxy : s.SOppSide x y)
    (hyz : s.SOppSide y z) : s.SSameSide x z 
goal: s.SSameSide x z

full_name: AffineSubspace.wSameSide_and_wOppSide_iff
code: theorem wSameSide_and_wOppSide_iff {s : AffineSubspace R P} {x y : P} :
    s.WSameSide x y ∧ s.WOppSide x y ↔ x ∈ s ∨ y ∈ s 
goal: s.WSameSide x y ∧ s.WOppSide x y ↔ x ∈ s ∨ y ∈ s

full_name: AffineSubspace.WSameSide.not_sOppSide
code: theorem WSameSide.not_sOppSide {s : AffineSubspace R P} {x y : P} (h : s.WSameSide x y) :
    ¬s.SOppSide x y 
goal: ¬s.SOppSide x y

full_name: AffineSubspace.SSameSide.not_wOppSide
code: theorem SSameSide.not_wOppSide {s : AffineSubspace R P} {x y : P} (h : s.SSameSide x y) :
    ¬s.WOppSide x y 
goal: ¬s.WOppSide x y

full_name: AffineSubspace.SSameSide.not_sOppSide
code: theorem SSameSide.not_sOppSide {s : AffineSubspace R P} {x y : P} (h : s.SSameSide x y) :
    ¬s.SOppSide x y 
goal: ¬s.SOppSide x y

full_name: AffineSubspace.WOppSide.not_sSameSide
code: theorem WOppSide.not_sSameSide {s : AffineSubspace R P} {x y : P} (h : s.WOppSide x y) :
    ¬s.SSameSide x y 
goal: ¬s.SSameSide x y

full_name: AffineSubspace.SOppSide.not_wSameSide
code: theorem SOppSide.not_wSameSide {s : AffineSubspace R P} {x y : P} (h : s.SOppSide x y) :
    ¬s.WSameSide x y 
goal: ¬s.WSameSide x y

full_name: AffineSubspace.SOppSide.not_sSameSide
code: theorem SOppSide.not_sSameSide {s : AffineSubspace R P} {x y : P} (h : s.SOppSide x y) :
    ¬s.SSameSide x y 
goal: ¬s.SSameSide x y

full_name: AffineSubspace.wOppSide_iff_exists_wbtw
code: theorem wOppSide_iff_exists_wbtw {s : AffineSubspace R P} {x y : P} :
    s.WOppSide x y ↔ ∃ p ∈ s, Wbtw R x p y 
goal: s.WOppSide x y ↔ ∃ p ∈ s, Wbtw R x p y

full_name: AffineSubspace.SOppSide.exists_sbtw
code: theorem SOppSide.exists_sbtw {s : AffineSubspace R P} {x y : P} (h : s.SOppSide x y) :
    ∃ p ∈ s, Sbtw R x p y 
goal: ∃ p ∈ s, Sbtw R x p y

full_name: Sbtw.sOppSide_of_not_mem_of_mem
code: theorem _root_.Sbtw.sOppSide_of_not_mem_of_mem {s : AffineSubspace R P} {x y z : P}
    (h : Sbtw R x y z) (hx : x ∉ s) (hy : y ∈ s) : s.SOppSide x z 
goal: s.SOppSide x z

full_name: AffineSubspace.sSameSide_smul_vsub_vadd_left
code: theorem sSameSide_smul_vsub_vadd_left {s : AffineSubspace R P} {x p₁ p₂ : P} (hx : x ∉ s)
    (hp₁ : p₁ ∈ s) (hp₂ : p₂ ∈ s) {t : R} (ht : 0 < t) : s.SSameSide (t • (x -ᵥ p₁) +ᵥ p₂) x 
goal: s.SSameSide (t • (x -ᵥ p₁) +ᵥ p₂) x

full_name: AffineSubspace.sSameSide_smul_vsub_vadd_right
code: theorem sSameSide_smul_vsub_vadd_right {s : AffineSubspace R P} {x p₁ p₂ : P} (hx : x ∉ s)
    (hp₁ : p₁ ∈ s) (hp₂ : p₂ ∈ s) {t : R} (ht : 0 < t) : s.SSameSide x (t • (x -ᵥ p₁) +ᵥ p₂) 
goal: s.SSameSide x (t • (x -ᵥ p₁) +ᵥ p₂)

full_name: AffineSubspace.sSameSide_lineMap_left
code: theorem sSameSide_lineMap_left {s : AffineSubspace R P} {x y : P} (hx : x ∈ s) (hy : y ∉ s) {t : R}
    (ht : 0 < t) : s.SSameSide (lineMap x y t) y 
goal: s.SSameSide ((AffineMap.lineMap x y) t) y

full_name: AffineSubspace.sSameSide_lineMap_right
code: theorem sSameSide_lineMap_right {s : AffineSubspace R P} {x y : P} (hx : x ∈ s) (hy : y ∉ s) {t : R}
    (ht : 0 < t) : s.SSameSide y (lineMap x y t) 
goal: s.SSameSide y ((AffineMap.lineMap x y) t)

full_name: AffineSubspace.sOppSide_smul_vsub_vadd_left
code: theorem sOppSide_smul_vsub_vadd_left {s : AffineSubspace R P} {x p₁ p₂ : P} (hx : x ∉ s)
    (hp₁ : p₁ ∈ s) (hp₂ : p₂ ∈ s) {t : R} (ht : t < 0) : s.SOppSide (t • (x -ᵥ p₁) +ᵥ p₂) x 
goal: s.SOppSide (t • (x -ᵥ p₁) +ᵥ p₂) x

full_name: AffineSubspace.sOppSide_smul_vsub_vadd_right
code: theorem sOppSide_smul_vsub_vadd_right {s : AffineSubspace R P} {x p₁ p₂ : P} (hx : x ∉ s)
    (hp₁ : p₁ ∈ s) (hp₂ : p₂ ∈ s) {t : R} (ht : t < 0) : s.SOppSide x (t • (x -ᵥ p₁) +ᵥ p₂) 
goal: s.SOppSide x (t • (x -ᵥ p₁) +ᵥ p₂)

full_name: AffineSubspace.sOppSide_lineMap_left
code: theorem sOppSide_lineMap_left {s : AffineSubspace R P} {x y : P} (hx : x ∈ s) (hy : y ∉ s) {t : R}
    (ht : t < 0) : s.SOppSide (lineMap x y t) y 
goal: s.SOppSide ((AffineMap.lineMap x y) t) y

full_name: AffineSubspace.sOppSide_lineMap_right
code: theorem sOppSide_lineMap_right {s : AffineSubspace R P} {x y : P} (hx : x ∈ s) (hy : y ∉ s) {t : R}
    (ht : t < 0) : s.SOppSide y (lineMap x y t) 
goal: s.SOppSide y ((AffineMap.lineMap x y) t)

full_name: AffineSubspace.setOf_wSameSide_eq_image2
code: theorem setOf_wSameSide_eq_image2 {s : AffineSubspace R P} {x p : P} (hx : x ∉ s) (hp : p ∈ s) :
    { y | s.WSameSide x y } = Set.image2 (fun (t : R) q => t • (x -ᵥ p) +ᵥ q) (Set.Ici 0) s 
goal: {y | s.WSameSide x y} = Set.image2 (fun t q => t • (x -ᵥ p) +ᵥ q) (Set.Ici 0) ↑s

full_name: AffineSubspace.setOf_sSameSide_eq_image2
code: theorem setOf_sSameSide_eq_image2 {s : AffineSubspace R P} {x p : P} (hx : x ∉ s) (hp : p ∈ s) :
    { y | s.SSameSide x y } = Set.image2 (fun (t : R) q => t • (x -ᵥ p) +ᵥ q) (Set.Ioi 0) s 
goal: {y | s.SSameSide x y} = Set.image2 (fun t q => t • (x -ᵥ p) +ᵥ q) (Set.Ioi 0) ↑s

full_name: AffineSubspace.setOf_wOppSide_eq_image2
code: theorem setOf_wOppSide_eq_image2 {s : AffineSubspace R P} {x p : P} (hx : x ∉ s) (hp : p ∈ s) :
    { y | s.WOppSide x y } = Set.image2 (fun (t : R) q => t • (x -ᵥ p) +ᵥ q) (Set.Iic 0) s 
goal: {y | s.WOppSide x y} = Set.image2 (fun t q => t • (x -ᵥ p) +ᵥ q) (Set.Iic 0) ↑s

full_name: AffineSubspace.setOf_sOppSide_eq_image2
code: theorem setOf_sOppSide_eq_image2 {s : AffineSubspace R P} {x p : P} (hx : x ∉ s) (hp : p ∈ s) :
    { y | s.SOppSide x y } = Set.image2 (fun (t : R) q => t • (x -ᵥ p) +ᵥ q) (Set.Iio 0) s 
goal: {y | s.SOppSide x y} = Set.image2 (fun t q => t • (x -ᵥ p) +ᵥ q) (Set.Iio 0) ↑s

full_name: AffineSubspace.wOppSide_pointReflection
code: theorem wOppSide_pointReflection {s : AffineSubspace R P} {x : P} (y : P) (hx : x ∈ s) :
    s.WOppSide y (pointReflection R x y) 
goal: s.WOppSide y ((AffineEquiv.pointReflection R x) y)

full_name: AffineSubspace.sOppSide_pointReflection
code: theorem sOppSide_pointReflection {s : AffineSubspace R P} {x y : P} (hx : x ∈ s) (hy : y ∉ s) :
    s.SOppSide y (pointReflection R x y) 
goal: s.SOppSide y ((AffineEquiv.pointReflection R x) y)

full_name: AffineSubspace.isConnected_setOf_wSameSide
code: theorem isConnected_setOf_wSameSide {s : AffineSubspace ℝ P} (x : P) (h : (s : Set P).Nonempty) :
    IsConnected { y | s.WSameSide x y } 
goal: IsConnected {y | s.WSameSide x y}

full_name: AffineSubspace.isPreconnected_setOf_wSameSide
code: theorem isPreconnected_setOf_wSameSide (s : AffineSubspace ℝ P) (x : P) :
    IsPreconnected { y | s.WSameSide x y } 
goal: IsPreconnected {y | s.WSameSide x y}

full_name: AffineSubspace.isConnected_setOf_sSameSide
code: theorem isConnected_setOf_sSameSide {s : AffineSubspace ℝ P} {x : P} (hx : x ∉ s)
    (h : (s : Set P).Nonempty) : IsConnected { y | s.SSameSide x y } 
goal: IsConnected {y | s.SSameSide x y}

full_name: AffineSubspace.isPreconnected_setOf_sSameSide
code: theorem isPreconnected_setOf_sSameSide (s : AffineSubspace ℝ P) (x : P) :
    IsPreconnected { y | s.SSameSide x y } 
goal: IsPreconnected {y | s.SSameSide x y}

full_name: AffineSubspace.isConnected_setOf_wOppSide
code: theorem isConnected_setOf_wOppSide {s : AffineSubspace ℝ P} (x : P) (h : (s : Set P).Nonempty) :
    IsConnected { y | s.WOppSide x y } 
goal: IsConnected {y | s.WOppSide x y}

full_name: AffineSubspace.isPreconnected_setOf_wOppSide
code: theorem isPreconnected_setOf_wOppSide (s : AffineSubspace ℝ P) (x : P) :
    IsPreconnected { y | s.WOppSide x y } 
goal: IsPreconnected {y | s.WOppSide x y}

full_name: AffineSubspace.isConnected_setOf_sOppSide
code: theorem isConnected_setOf_sOppSide {s : AffineSubspace ℝ P} {x : P} (hx : x ∉ s)
    (h : (s : Set P).Nonempty) : IsConnected { y | s.SOppSide x y } 
goal: IsConnected {y | s.SOppSide x y}

full_name: AffineSubspace.isPreconnected_setOf_sOppSide
code: theorem isPreconnected_setOf_sOppSide (s : AffineSubspace ℝ P) (x : P) :
    IsPreconnected { y | s.SOppSide x y } 
goal: IsPreconnected {y | s.SOppSide x y}