File: Mathlib/Analysis/Convex/Between.lean

full_name: affineSegment
code: /-- The segment of points weakly between `x` and `y`. When convexity is refactored to support
abstract affine combination spaces, this will no longer need to be a separate definition from
`segment`. However, lemmas involving `+ᵥ` or `-ᵥ` will still be relevant after such a
refactoring, as distinct from versions involving `+` or `-` in a module. -/
def affineSegment (x y : P) 
goal: Set P

full_name: affineSegment_eq_segment
code: theorem affineSegment_eq_segment (x y : V) : affineSegment R x y = segment R x y 
goal: affineSegment R x y = segment R x y

full_name: affineSegment_comm
code: theorem affineSegment_comm (x y : P) : affineSegment R x y = affineSegment R y x 
goal: affineSegment R x y = affineSegment R y x

full_name: left_mem_affineSegment
code: theorem left_mem_affineSegment (x y : P) : x ∈ affineSegment R x y 
goal: x ∈ affineSegment R x y

full_name: right_mem_affineSegment
code: theorem right_mem_affineSegment (x y : P) : y ∈ affineSegment R x y 
goal: y ∈ affineSegment R x y

full_name: affineSegment_same
code: @[simp]
theorem affineSegment_same (x : P) : affineSegment R x x = {x} 
goal: affineSegment R x x = {x}

full_name: affineSegment_image
code: @[simp]
theorem affineSegment_image (f : P →ᵃ[R] P') (x y : P) :
    f '' affineSegment R x y = affineSegment R (f x) (f y) 
goal: ⇑f '' affineSegment R x y = affineSegment R (f x) (f y)

full_name: affineSegment_const_vadd_image
code: @[simp]
theorem affineSegment_const_vadd_image (x y : P) (v : V) :
    (v +ᵥ ·) '' affineSegment R x y = affineSegment R (v +ᵥ x) (v +ᵥ y) 
goal: (fun x => v +ᵥ x) '' affineSegment R x y = affineSegment R (v +ᵥ x) (v +ᵥ y)

full_name: affineSegment_vadd_const_image
code: @[simp]
theorem affineSegment_vadd_const_image (x y : V) (p : P) :
    (· +ᵥ p) '' affineSegment R x y = affineSegment R (x +ᵥ p) (y +ᵥ p) 
goal: (fun x => x +ᵥ p) '' affineSegment R x y = affineSegment R (x +ᵥ p) (y +ᵥ p)

full_name: affineSegment_const_vsub_image
code: @[simp]
theorem affineSegment_const_vsub_image (x y p : P) :
    (p -ᵥ ·) '' affineSegment R x y = affineSegment R (p -ᵥ x) (p -ᵥ y) 
goal: (fun x => p -ᵥ x) '' affineSegment R x y = affineSegment R (p -ᵥ x) (p -ᵥ y)

full_name: affineSegment_vsub_const_image
code: @[simp]
theorem affineSegment_vsub_const_image (x y p : P) :
    (· -ᵥ p) '' affineSegment R x y = affineSegment R (x -ᵥ p) (y -ᵥ p) 
goal: (fun x => x -ᵥ p) '' affineSegment R x y = affineSegment R (x -ᵥ p) (y -ᵥ p)

full_name: mem_const_vadd_affineSegment
code: @[simp]
theorem mem_const_vadd_affineSegment {x y z : P} (v : V) :
    v +ᵥ z ∈ affineSegment R (v +ᵥ x) (v +ᵥ y) ↔ z ∈ affineSegment R x y 
goal: v +ᵥ z ∈ affineSegment R (v +ᵥ x) (v +ᵥ y) ↔ z ∈ affineSegment R x y

full_name: mem_vadd_const_affineSegment
code: @[simp]
theorem mem_vadd_const_affineSegment {x y z : V} (p : P) :
    z +ᵥ p ∈ affineSegment R (x +ᵥ p) (y +ᵥ p) ↔ z ∈ affineSegment R x y 
goal: z +ᵥ p ∈ affineSegment R (x +ᵥ p) (y +ᵥ p) ↔ z ∈ affineSegment R x y

full_name: mem_const_vsub_affineSegment
code: @[simp]
theorem mem_const_vsub_affineSegment {x y z : P} (p : P) :
    p -ᵥ z ∈ affineSegment R (p -ᵥ x) (p -ᵥ y) ↔ z ∈ affineSegment R x y 
goal: p -ᵥ z ∈ affineSegment R (p -ᵥ x) (p -ᵥ y) ↔ z ∈ affineSegment R x y

full_name: mem_vsub_const_affineSegment
code: @[simp]
theorem mem_vsub_const_affineSegment {x y z : P} (p : P) :
    z -ᵥ p ∈ affineSegment R (x -ᵥ p) (y -ᵥ p) ↔ z ∈ affineSegment R x y 
goal: z -ᵥ p ∈ affineSegment R (x -ᵥ p) (y -ᵥ p) ↔ z ∈ affineSegment R x y

full_name: Wbtw
code: /-- The point `y` is weakly between `x` and `z`. -/
def Wbtw (x y z : P) : Prop 
goal: Prop

full_name: Sbtw
code: /-- The point `y` is strictly between `x` and `z`. -/
def Sbtw (x y z : P) : Prop 
goal: Prop

full_name: mem_segment_iff_wbtw
code: lemma mem_segment_iff_wbtw {x y z : V} : y ∈ segment R x z ↔ Wbtw R x y z 
goal: y ∈ segment R x z ↔ Wbtw R x y z

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

full_name: Function.Injective.wbtw_map_iff
code: theorem Function.Injective.wbtw_map_iff {x y z : P} {f : P →ᵃ[R] P'} (hf : Function.Injective f) :
    Wbtw R (f x) (f y) (f z) ↔ Wbtw R x y z 
goal: Wbtw R (f x) (f y) (f z) ↔ Wbtw R x y z

full_name: Function.Injective.sbtw_map_iff
code: theorem Function.Injective.sbtw_map_iff {x y z : P} {f : P →ᵃ[R] P'} (hf : Function.Injective f) :
    Sbtw R (f x) (f y) (f z) ↔ Sbtw R x y z 
goal: Sbtw R (f x) (f y) (f z) ↔ Sbtw R x y z

full_name: AffineEquiv.wbtw_map_iff
code: @[simp]
theorem AffineEquiv.wbtw_map_iff {x y z : P} (f : P ≃ᵃ[R] P') :
    Wbtw R (f x) (f y) (f z) ↔ Wbtw R x y z 
goal: Wbtw R (f x) (f y) (f z) ↔ Wbtw R x y z

full_name: AffineEquiv.sbtw_map_iff
code: @[simp]
theorem AffineEquiv.sbtw_map_iff {x y z : P} (f : P ≃ᵃ[R] P') :
    Sbtw R (f x) (f y) (f z) ↔ Sbtw R x y z 
goal: Sbtw R (f x) (f y) (f z) ↔ Sbtw R x y z

full_name: wbtw_const_vadd_iff
code: @[simp]
theorem wbtw_const_vadd_iff {x y z : P} (v : V) :
    Wbtw R (v +ᵥ x) (v +ᵥ y) (v +ᵥ z) ↔ Wbtw R x y z 
goal: Wbtw R (v +ᵥ x) (v +ᵥ y) (v +ᵥ z) ↔ Wbtw R x y z

full_name: wbtw_vadd_const_iff
code: @[simp]
theorem wbtw_vadd_const_iff {x y z : V} (p : P) :
    Wbtw R (x +ᵥ p) (y +ᵥ p) (z +ᵥ p) ↔ Wbtw R x y z 
goal: Wbtw R (x +ᵥ p) (y +ᵥ p) (z +ᵥ p) ↔ Wbtw R x y z

full_name: wbtw_const_vsub_iff
code: @[simp]
theorem wbtw_const_vsub_iff {x y z : P} (p : P) :
    Wbtw R (p -ᵥ x) (p -ᵥ y) (p -ᵥ z) ↔ Wbtw R x y z 
goal: Wbtw R (p -ᵥ x) (p -ᵥ y) (p -ᵥ z) ↔ Wbtw R x y z

full_name: wbtw_vsub_const_iff
code: @[simp]
theorem wbtw_vsub_const_iff {x y z : P} (p : P) :
    Wbtw R (x -ᵥ p) (y -ᵥ p) (z -ᵥ p) ↔ Wbtw R x y z 
goal: Wbtw R (x -ᵥ p) (y -ᵥ p) (z -ᵥ p) ↔ Wbtw R x y z

full_name: sbtw_const_vadd_iff
code: @[simp]
theorem sbtw_const_vadd_iff {x y z : P} (v : V) :
    Sbtw R (v +ᵥ x) (v +ᵥ y) (v +ᵥ z) ↔ Sbtw R x y z 
goal: Sbtw R (v +ᵥ x) (v +ᵥ y) (v +ᵥ z) ↔ Sbtw R x y z

full_name: sbtw_vadd_const_iff
code: @[simp]
theorem sbtw_vadd_const_iff {x y z : V} (p : P) :
    Sbtw R (x +ᵥ p) (y +ᵥ p) (z +ᵥ p) ↔ Sbtw R x y z 
goal: Sbtw R (x +ᵥ p) (y +ᵥ p) (z +ᵥ p) ↔ Sbtw R x y z

full_name: sbtw_const_vsub_iff
code: @[simp]
theorem sbtw_const_vsub_iff {x y z : P} (p : P) :
    Sbtw R (p -ᵥ x) (p -ᵥ y) (p -ᵥ z) ↔ Sbtw R x y z 
goal: Sbtw R (p -ᵥ x) (p -ᵥ y) (p -ᵥ z) ↔ Sbtw R x y z

full_name: sbtw_vsub_const_iff
code: @[simp]
theorem sbtw_vsub_const_iff {x y z : P} (p : P) :
    Sbtw R (x -ᵥ p) (y -ᵥ p) (z -ᵥ p) ↔ Sbtw R x y z 
goal: Sbtw R (x -ᵥ p) (y -ᵥ p) (z -ᵥ p) ↔ Sbtw R x y z

full_name: Sbtw.wbtw
code: theorem Sbtw.wbtw {x y z : P} (h : Sbtw R x y z) : Wbtw R x y z 
goal: Wbtw R x y z

full_name: Sbtw.ne_left
code: theorem Sbtw.ne_left {x y z : P} (h : Sbtw R x y z) : y ≠ x 
goal: y ≠ x

full_name: Sbtw.left_ne
code: theorem Sbtw.left_ne {x y z : P} (h : Sbtw R x y z) : x ≠ y 
goal: x ≠ y

full_name: Sbtw.ne_right
code: theorem Sbtw.ne_right {x y z : P} (h : Sbtw R x y z) : y ≠ z 
goal: y ≠ z

full_name: Sbtw.right_ne
code: theorem Sbtw.right_ne {x y z : P} (h : Sbtw R x y z) : z ≠ y 
goal: z ≠ y

full_name: Sbtw.mem_image_Ioo
code: theorem Sbtw.mem_image_Ioo {x y z : P} (h : Sbtw R x y z) :
    y ∈ lineMap x z '' Set.Ioo (0 : R) 1 
goal: y ∈ ⇑(AffineMap.lineMap x z) '' Set.Ioo 0 1

full_name: Wbtw.mem_affineSpan
code: theorem Wbtw.mem_affineSpan {x y z : P} (h : Wbtw R x y z) : y ∈ line[R, x, z] 
goal: y ∈ affineSpan R {x, z}

full_name: wbtw_comm
code: theorem wbtw_comm {x y z : P} : Wbtw R x y z ↔ Wbtw R z y x 
goal: Wbtw R x y z ↔ Wbtw R z y x

full_name: sbtw_comm
code: theorem sbtw_comm {x y z : P} : Sbtw R x y z ↔ Sbtw R z y x 
goal: Sbtw R x y z ↔ Sbtw R z y x

full_name: wbtw_self_left
code: @[simp]
theorem wbtw_self_left (x y : P) : Wbtw R x x y 
goal: Wbtw R x x y

full_name: wbtw_self_right
code: @[simp]
theorem wbtw_self_right (x y : P) : Wbtw R x y y 
goal: Wbtw R x y y

full_name: wbtw_self_iff
code: @[simp]
theorem wbtw_self_iff {x y : P} : Wbtw R x y x ↔ y = x 
goal: Wbtw R x y x ↔ y = x

full_name: not_sbtw_self_left
code: @[simp]
theorem not_sbtw_self_left (x y : P) : ¬Sbtw R x x y 
goal: ¬Sbtw R x x y

full_name: not_sbtw_self_right
code: @[simp]
theorem not_sbtw_self_right (x y : P) : ¬Sbtw R x y y 
goal: ¬Sbtw R x y y

full_name: Wbtw.left_ne_right_of_ne_left
code: theorem Wbtw.left_ne_right_of_ne_left {x y z : P} (h : Wbtw R x y z) (hne : y ≠ x) : x ≠ z 
goal: x ≠ z

full_name: Wbtw.left_ne_right_of_ne_right
code: theorem Wbtw.left_ne_right_of_ne_right {x y z : P} (h : Wbtw R x y z) (hne : y ≠ z) : x ≠ z 
goal: x ≠ z

full_name: Sbtw.left_ne_right
code: theorem Sbtw.left_ne_right {x y z : P} (h : Sbtw R x y z) : x ≠ z 
goal: x ≠ z

full_name: sbtw_iff_mem_image_Ioo_and_ne
code: theorem sbtw_iff_mem_image_Ioo_and_ne [NoZeroSMulDivisors R V] {x y z : P} :
    Sbtw R x y z ↔ y ∈ lineMap x z '' Set.Ioo (0 : R) 1 ∧ x ≠ z 
goal: Sbtw R x y z ↔ y ∈ ⇑(AffineMap.lineMap x z) '' Set.Ioo 0 1 ∧ x ≠ z

full_name: not_sbtw_self
code: @[simp]
theorem not_sbtw_self (x y : P) : ¬Sbtw R x y x 
goal: ¬Sbtw R x y x

full_name: wbtw_swap_left_iff
code: theorem wbtw_swap_left_iff [NoZeroSMulDivisors R V] {x y : P} (z : P) :
    Wbtw R x y z ∧ Wbtw R y x z ↔ x = y 
goal: Wbtw R x y z ∧ Wbtw R y x z ↔ x = y

full_name: wbtw_swap_right_iff
code: theorem wbtw_swap_right_iff [NoZeroSMulDivisors R V] (x : P) {y z : P} :
    Wbtw R x y z ∧ Wbtw R x z y ↔ y = z 
goal: Wbtw R x y z ∧ Wbtw R x z y ↔ y = z

full_name: wbtw_rotate_iff
code: theorem wbtw_rotate_iff [NoZeroSMulDivisors R V] (x : P) {y z : P} :
    Wbtw R x y z ∧ Wbtw R z x y ↔ x = y 
goal: Wbtw R x y z ∧ Wbtw R z x y ↔ x = y

full_name: Wbtw.swap_left_iff
code: theorem Wbtw.swap_left_iff [NoZeroSMulDivisors R V] {x y z : P} (h : Wbtw R x y z) :
    Wbtw R y x z ↔ x = y 
goal: Wbtw R y x z ↔ x = y

full_name: Wbtw.swap_right_iff
code: theorem Wbtw.swap_right_iff [NoZeroSMulDivisors R V] {x y z : P} (h : Wbtw R x y z) :
    Wbtw R x z y ↔ y = z 
goal: Wbtw R x z y ↔ y = z

full_name: Wbtw.rotate_iff
code: theorem Wbtw.rotate_iff [NoZeroSMulDivisors R V] {x y z : P} (h : Wbtw R x y z) :
    Wbtw R z x y ↔ x = y 
goal: Wbtw R z x y ↔ x = y

full_name: Sbtw.not_swap_left
code: theorem Sbtw.not_swap_left [NoZeroSMulDivisors R V] {x y z : P} (h : Sbtw R x y z) :
    ¬Wbtw R y x z 
goal: ¬Wbtw R y x z

full_name: Sbtw.not_swap_right
code: theorem Sbtw.not_swap_right [NoZeroSMulDivisors R V] {x y z : P} (h : Sbtw R x y z) :
    ¬Wbtw R x z y 
goal: ¬Wbtw R x z y

full_name: Sbtw.not_rotate
code: theorem Sbtw.not_rotate [NoZeroSMulDivisors R V] {x y z : P} (h : Sbtw R x y z) : ¬Wbtw R z x y 
goal: ¬Wbtw R z x y

full_name: wbtw_lineMap_iff
code: @[simp]
theorem wbtw_lineMap_iff [NoZeroSMulDivisors R V] {x y : P} {r : R} :
    Wbtw R x (lineMap x y r) y ↔ x = y ∨ r ∈ Set.Icc (0 : R) 1 
goal: Wbtw R x ((AffineMap.lineMap x y) r) y ↔ x = y ∨ r ∈ Set.Icc 0 1

full_name: sbtw_lineMap_iff
code: @[simp]
theorem sbtw_lineMap_iff [NoZeroSMulDivisors R V] {x y : P} {r : R} :
    Sbtw R x (lineMap x y r) y ↔ x ≠ y ∧ r ∈ Set.Ioo (0 : R) 1 
goal: Sbtw R x ((AffineMap.lineMap x y) r) y ↔ x ≠ y ∧ r ∈ Set.Ioo 0 1

full_name: wbtw_mul_sub_add_iff
code: @[simp]
theorem wbtw_mul_sub_add_iff [NoZeroDivisors R] {x y r : R} :
    Wbtw R x (r * (y - x) + x) y ↔ x = y ∨ r ∈ Set.Icc (0 : R) 1 
goal: Wbtw R x (r * (y - x) + x) y ↔ x = y ∨ r ∈ Set.Icc 0 1

full_name: sbtw_mul_sub_add_iff
code: @[simp]
theorem sbtw_mul_sub_add_iff [NoZeroDivisors R] {x y r : R} :
    Sbtw R x (r * (y - x) + x) y ↔ x ≠ y ∧ r ∈ Set.Ioo (0 : R) 1 
goal: Sbtw R x (r * (y - x) + x) y ↔ x ≠ y ∧ r ∈ Set.Ioo 0 1

full_name: wbtw_zero_one_iff
code: @[simp]
theorem wbtw_zero_one_iff {x : R} : Wbtw R 0 x 1 ↔ x ∈ Set.Icc (0 : R) 1 
goal: Wbtw R 0 x 1 ↔ x ∈ Set.Icc 0 1

full_name: wbtw_one_zero_iff
code: @[simp]
theorem wbtw_one_zero_iff {x : R} : Wbtw R 1 x 0 ↔ x ∈ Set.Icc (0 : R) 1 
goal: Wbtw R 1 x 0 ↔ x ∈ Set.Icc 0 1

full_name: sbtw_zero_one_iff
code: @[simp]
theorem sbtw_zero_one_iff {x : R} : Sbtw R 0 x 1 ↔ x ∈ Set.Ioo (0 : R) 1 
goal: Sbtw R 0 x 1 ↔ x ∈ Set.Ioo 0 1

full_name: sbtw_one_zero_iff
code: @[simp]
theorem sbtw_one_zero_iff {x : R} : Sbtw R 1 x 0 ↔ x ∈ Set.Ioo (0 : R) 1 
goal: Sbtw R 1 x 0 ↔ x ∈ Set.Ioo 0 1

full_name: Wbtw.trans_left
code: theorem Wbtw.trans_left {w x y z : P} (h₁ : Wbtw R w y z) (h₂ : Wbtw R w x y) : Wbtw R w x z 
goal: Wbtw R w x z

full_name: Wbtw.trans_right
code: theorem Wbtw.trans_right {w x y z : P} (h₁ : Wbtw R w x z) (h₂ : Wbtw R x y z) : Wbtw R w y z 
goal: Wbtw R w y z

full_name: Wbtw.trans_sbtw_left
code: theorem Wbtw.trans_sbtw_left [NoZeroSMulDivisors R V] {w x y z : P} (h₁ : Wbtw R w y z)
    (h₂ : Sbtw R w x y) : Sbtw R w x z 
goal: Sbtw R w x z

full_name: Wbtw.trans_sbtw_right
code: theorem Wbtw.trans_sbtw_right [NoZeroSMulDivisors R V] {w x y z : P} (h₁ : Wbtw R w x z)
    (h₂ : Sbtw R x y z) : Sbtw R w y z 
goal: Sbtw R w y z

full_name: Sbtw.trans_left
code: theorem Sbtw.trans_left [NoZeroSMulDivisors R V] {w x y z : P} (h₁ : Sbtw R w y z)
    (h₂ : Sbtw R w x y) : Sbtw R w x z 
goal: Sbtw R w x z

full_name: Sbtw.trans_right
code: theorem Sbtw.trans_right [NoZeroSMulDivisors R V] {w x y z : P} (h₁ : Sbtw R w x z)
    (h₂ : Sbtw R x y z) : Sbtw R w y z 
goal: Sbtw R w y z

full_name: Wbtw.trans_left_ne
code: theorem Wbtw.trans_left_ne [NoZeroSMulDivisors R V] {w x y z : P} (h₁ : Wbtw R w y z)
    (h₂ : Wbtw R w x y) (h : y ≠ z) : x ≠ z 
goal: x ≠ z

full_name: Wbtw.trans_right_ne
code: theorem Wbtw.trans_right_ne [NoZeroSMulDivisors R V] {w x y z : P} (h₁ : Wbtw R w x z)
    (h₂ : Wbtw R x y z) (h : w ≠ x) : w ≠ y 
goal: w ≠ y

full_name: Sbtw.trans_wbtw_left_ne
code: theorem Sbtw.trans_wbtw_left_ne [NoZeroSMulDivisors R V] {w x y z : P} (h₁ : Sbtw R w y z)
    (h₂ : Wbtw R w x y) : x ≠ z 
goal: x ≠ z

full_name: Sbtw.trans_wbtw_right_ne
code: theorem Sbtw.trans_wbtw_right_ne [NoZeroSMulDivisors R V] {w x y z : P} (h₁ : Sbtw R w x z)
    (h₂ : Wbtw R x y z) : w ≠ y 
goal: w ≠ y

full_name: Sbtw.affineCombination_of_mem_affineSpan_pair
code: theorem Sbtw.affineCombination_of_mem_affineSpan_pair [NoZeroDivisors R] [NoZeroSMulDivisors R V]
    {ι : Type*} {p : ι → P} (ha : AffineIndependent R p) {w w₁ w₂ : ι → R} {s : Finset ι}
    (hw : ∑ i ∈ s, w i = 1) (hw₁ : ∑ i ∈ s, w₁ i = 1) (hw₂ : ∑ i ∈ s, w₂ i = 1)
    (h : s.affineCombination R p w ∈
      line[R, s.affineCombination R p w₁, s.affineCombination R p w₂])
    {i : ι} (his : i ∈ s) (hs : Sbtw R (w₁ i) (w i) (w₂ i)) :
    Sbtw R (s.affineCombination R p w₁) (s.affineCombination R p w)
      (s.affineCombination R p w₂) 
goal: Sbtw R ((Finset.affineCombination R s p) w₁) ((Finset.affineCombination R s p) w) ((Finset.affineCombination R s p) w₂)

full_name: Wbtw.sameRay_vsub
code: theorem Wbtw.sameRay_vsub {x y z : P} (h : Wbtw R x y z) : SameRay R (y -ᵥ x) (z -ᵥ y) 
goal: SameRay R (y -ᵥ x) (z -ᵥ y)

full_name: Wbtw.sameRay_vsub_left
code: theorem Wbtw.sameRay_vsub_left {x y z : P} (h : Wbtw R x y z) : SameRay R (y -ᵥ x) (z -ᵥ x) 
goal: SameRay R (y -ᵥ x) (z -ᵥ x)

full_name: Wbtw.sameRay_vsub_right
code: theorem Wbtw.sameRay_vsub_right {x y z : P} (h : Wbtw R x y z) : SameRay R (z -ᵥ x) (z -ᵥ y) 
goal: SameRay R (z -ᵥ x) (z -ᵥ y)

full_name: sbtw_of_sbtw_of_sbtw_of_mem_affineSpan_pair
code: /-- Suppose lines from two vertices of a triangle to interior points of the opposite side meet at
`p`. Then `p` lies in the interior of the first (and by symmetry the other) segment from a
vertex to the point on the opposite side. -/
theorem sbtw_of_sbtw_of_sbtw_of_mem_affineSpan_pair [NoZeroSMulDivisors R V]
    {t : Affine.Triangle R P} {i₁ i₂ i₃ : Fin 3} (h₁₂ : i₁ ≠ i₂) {p₁ p₂ p : P}
    (h₁ : Sbtw R (t.points i₂) p₁ (t.points i₃)) (h₂ : Sbtw R (t.points i₁) p₂ (t.points i₃))
    (h₁' : p ∈ line[R, t.points i₁, p₁]) (h₂' : p ∈ line[R, t.points i₂, p₂]) :
    Sbtw R (t.points i₁) p p₁ 
goal: Sbtw R (t.points i₁) p p₁

full_name: wbtw_iff_left_eq_or_right_mem_image_Ici
code: theorem wbtw_iff_left_eq_or_right_mem_image_Ici {x y z : P} :
    Wbtw R x y z ↔ x = y ∨ z ∈ lineMap x y '' Set.Ici (1 : R) 
goal: Wbtw R x y z ↔ x = y ∨ z ∈ ⇑(AffineMap.lineMap x y) '' Set.Ici 1

full_name: Wbtw.right_mem_image_Ici_of_left_ne
code: theorem Wbtw.right_mem_image_Ici_of_left_ne {x y z : P} (h : Wbtw R x y z) (hne : x ≠ y) :
    z ∈ lineMap x y '' Set.Ici (1 : R) 
goal: z ∈ ⇑(AffineMap.lineMap x y) '' Set.Ici 1

full_name: Wbtw.right_mem_affineSpan_of_left_ne
code: theorem Wbtw.right_mem_affineSpan_of_left_ne {x y z : P} (h : Wbtw R x y z) (hne : x ≠ y) :
    z ∈ line[R, x, y] 
goal: z ∈ affineSpan R {x, y}

full_name: sbtw_iff_left_ne_and_right_mem_image_Ioi
code: theorem sbtw_iff_left_ne_and_right_mem_image_Ioi {x y z : P} :
    Sbtw R x y z ↔ x ≠ y ∧ z ∈ lineMap x y '' Set.Ioi (1 : R) 
goal: Sbtw R x y z ↔ x ≠ y ∧ z ∈ ⇑(AffineMap.lineMap x y) '' Set.Ioi 1

full_name: Sbtw.right_mem_image_Ioi
code: theorem Sbtw.right_mem_image_Ioi {x y z : P} (h : Sbtw R x y z) :
    z ∈ lineMap x y '' Set.Ioi (1 : R) 
goal: z ∈ ⇑(AffineMap.lineMap x y) '' Set.Ioi 1

full_name: Sbtw.right_mem_affineSpan
code: theorem Sbtw.right_mem_affineSpan {x y z : P} (h : Sbtw R x y z) : z ∈ line[R, x, y] 
goal: z ∈ affineSpan R {x, y}

full_name: wbtw_iff_right_eq_or_left_mem_image_Ici
code: theorem wbtw_iff_right_eq_or_left_mem_image_Ici {x y z : P} :
    Wbtw R x y z ↔ z = y ∨ x ∈ lineMap z y '' Set.Ici (1 : R) 
goal: Wbtw R x y z ↔ z = y ∨ x ∈ ⇑(AffineMap.lineMap z y) '' Set.Ici 1

full_name: Wbtw.left_mem_image_Ici_of_right_ne
code: theorem Wbtw.left_mem_image_Ici_of_right_ne {x y z : P} (h : Wbtw R x y z) (hne : z ≠ y) :
    x ∈ lineMap z y '' Set.Ici (1 : R) 
goal: x ∈ ⇑(AffineMap.lineMap z y) '' Set.Ici 1

full_name: Wbtw.left_mem_affineSpan_of_right_ne
code: theorem Wbtw.left_mem_affineSpan_of_right_ne {x y z : P} (h : Wbtw R x y z) (hne : z ≠ y) :
    x ∈ line[R, z, y] 
goal: x ∈ affineSpan R {z, y}

full_name: sbtw_iff_right_ne_and_left_mem_image_Ioi
code: theorem sbtw_iff_right_ne_and_left_mem_image_Ioi {x y z : P} :
    Sbtw R x y z ↔ z ≠ y ∧ x ∈ lineMap z y '' Set.Ioi (1 : R) 
goal: Sbtw R x y z ↔ z ≠ y ∧ x ∈ ⇑(AffineMap.lineMap z y) '' Set.Ioi 1

full_name: Sbtw.left_mem_image_Ioi
code: theorem Sbtw.left_mem_image_Ioi {x y z : P} (h : Sbtw R x y z) :
    x ∈ lineMap z y '' Set.Ioi (1 : R) 
goal: x ∈ ⇑(AffineMap.lineMap z y) '' Set.Ioi 1

full_name: Sbtw.left_mem_affineSpan
code: theorem Sbtw.left_mem_affineSpan {x y z : P} (h : Sbtw R x y z) : x ∈ line[R, z, y] 
goal: x ∈ affineSpan R {z, y}

full_name: wbtw_smul_vadd_smul_vadd_of_nonneg_of_le
code: theorem wbtw_smul_vadd_smul_vadd_of_nonneg_of_le (x : P) (v : V) {r₁ r₂ : R} (hr₁ : 0 ≤ r₁)
    (hr₂ : r₁ ≤ r₂) : Wbtw R x (r₁ • v +ᵥ x) (r₂ • v +ᵥ x) 
goal: Wbtw R x (r₁ • v +ᵥ x) (r₂ • v +ᵥ x)

full_name: wbtw_or_wbtw_smul_vadd_of_nonneg
code: theorem wbtw_or_wbtw_smul_vadd_of_nonneg (x : P) (v : V) {r₁ r₂ : R} (hr₁ : 0 ≤ r₁) (hr₂ : 0 ≤ r₂) :
    Wbtw R x (r₁ • v +ᵥ x) (r₂ • v +ᵥ x) ∨ Wbtw R x (r₂ • v +ᵥ x) (r₁ • v +ᵥ x) 
goal: Wbtw R x (r₁ • v +ᵥ x) (r₂ • v +ᵥ x) ∨ Wbtw R x (r₂ • v +ᵥ x) (r₁ • v +ᵥ x)

full_name: wbtw_smul_vadd_smul_vadd_of_nonpos_of_le
code: theorem wbtw_smul_vadd_smul_vadd_of_nonpos_of_le (x : P) (v : V) {r₁ r₂ : R} (hr₁ : r₁ ≤ 0)
    (hr₂ : r₂ ≤ r₁) : Wbtw R x (r₁ • v +ᵥ x) (r₂ • v +ᵥ x) 
goal: Wbtw R x (r₁ • v +ᵥ x) (r₂ • v +ᵥ x)

full_name: wbtw_or_wbtw_smul_vadd_of_nonpos
code: theorem wbtw_or_wbtw_smul_vadd_of_nonpos (x : P) (v : V) {r₁ r₂ : R} (hr₁ : r₁ ≤ 0) (hr₂ : r₂ ≤ 0) :
    Wbtw R x (r₁ • v +ᵥ x) (r₂ • v +ᵥ x) ∨ Wbtw R x (r₂ • v +ᵥ x) (r₁ • v +ᵥ x) 
goal: Wbtw R x (r₁ • v +ᵥ x) (r₂ • v +ᵥ x) ∨ Wbtw R x (r₂ • v +ᵥ x) (r₁ • v +ᵥ x)

full_name: wbtw_smul_vadd_smul_vadd_of_nonpos_of_nonneg
code: theorem wbtw_smul_vadd_smul_vadd_of_nonpos_of_nonneg (x : P) (v : V) {r₁ r₂ : R} (hr₁ : r₁ ≤ 0)
    (hr₂ : 0 ≤ r₂) : Wbtw R (r₁ • v +ᵥ x) x (r₂ • v +ᵥ x) 
goal: Wbtw R (r₁ • v +ᵥ x) x (r₂ • v +ᵥ x)

full_name: wbtw_smul_vadd_smul_vadd_of_nonneg_of_nonpos
code: theorem wbtw_smul_vadd_smul_vadd_of_nonneg_of_nonpos (x : P) (v : V) {r₁ r₂ : R} (hr₁ : 0 ≤ r₁)
    (hr₂ : r₂ ≤ 0) : Wbtw R (r₁ • v +ᵥ x) x (r₂ • v +ᵥ x) 
goal: Wbtw R (r₁ • v +ᵥ x) x (r₂ • v +ᵥ x)

full_name: Wbtw.trans_left_right
code: theorem Wbtw.trans_left_right {w x y z : P} (h₁ : Wbtw R w y z) (h₂ : Wbtw R w x y) :
    Wbtw R x y z 
goal: Wbtw R x y z

full_name: Wbtw.trans_right_left
code: theorem Wbtw.trans_right_left {w x y z : P} (h₁ : Wbtw R w x z) (h₂ : Wbtw R x y z) :
    Wbtw R w x y 
goal: Wbtw R w x y

full_name: Sbtw.trans_left_right
code: theorem Sbtw.trans_left_right {w x y z : P} (h₁ : Sbtw R w y z) (h₂ : Sbtw R w x y) :
    Sbtw R x y z 
goal: Sbtw R x y z

full_name: Sbtw.trans_right_left
code: theorem Sbtw.trans_right_left {w x y z : P} (h₁ : Sbtw R w x z) (h₂ : Sbtw R x y z) :
    Sbtw R w x y 
goal: Sbtw R w x y

full_name: Wbtw.collinear
code: theorem Wbtw.collinear {x y z : P} (h : Wbtw R x y z) : Collinear R ({x, y, z} : Set P) 
goal: Collinear R {x, y, z}

full_name: Collinear.wbtw_or_wbtw_or_wbtw
code: theorem Collinear.wbtw_or_wbtw_or_wbtw {x y z : P} (h : Collinear R ({x, y, z} : Set P)) :
    Wbtw R x y z ∨ Wbtw R y z x ∨ Wbtw R z x y 
goal: Wbtw R x y z ∨ Wbtw R y z x ∨ Wbtw R z x y

full_name: wbtw_iff_sameRay_vsub
code: theorem wbtw_iff_sameRay_vsub {x y z : P} : Wbtw R x y z ↔ SameRay R (y -ᵥ x) (z -ᵥ y) 
goal: Wbtw R x y z ↔ SameRay R (y -ᵥ x) (z -ᵥ y)

full_name: wbtw_pointReflection
code: theorem wbtw_pointReflection (x y : P) : Wbtw R y x (pointReflection R x y) 
goal: Wbtw R y x ((AffineEquiv.pointReflection R x) y)

full_name: sbtw_pointReflection_of_ne
code: theorem sbtw_pointReflection_of_ne {x y : P} (h : x ≠ y) : Sbtw R y x (pointReflection R x y) 
goal: Sbtw R y x ((AffineEquiv.pointReflection R x) y)

full_name: wbtw_midpoint
code: theorem wbtw_midpoint (x y : P) : Wbtw R x (midpoint R x y) y 
goal: Wbtw R x (midpoint R x y) y

full_name: sbtw_midpoint_of_ne
code: theorem sbtw_midpoint_of_ne {x y : P} (h : x ≠ y) : Sbtw R x (midpoint R x y) y 
goal: Sbtw R x (midpoint R x y) y