mathlib3 documentation

linear_algebra.affine_space.combination

Affine combinations of points #

THIS FILE IS SYNCHRONIZED WITH MATHLIB4. Any changes to this file require a corresponding PR to mathlib4.

This file defines affine combinations of points.

Main definitions #

weighted_vsub_of_point is a general weighted combination of subtractions with an explicit base point, yielding a vector.
weighted_vsub uses an arbitrary choice of base point and is intended to be used when the sum of weights is 0, in which case the result is independent of the choice of base point.
affine_combination adds the weighted combination to the arbitrary base point, yielding a point rather than a vector, and is intended to be used when the sum of weights is 1, in which case the result is independent of the choice of base point.

These definitions are for sums over a finset; versions for a fintype may be obtained using finset.univ, while versions for a finsupp may be obtained using finsupp.support.

References #

https://en.wikipedia.org/wiki/Affine_space

theorem finset.univ_fin2 :

finset.univ = {0, 1}

def finset.weighted_vsub_of_point {k : Type u_1} {V : Type u_2} {P : Type u_3} [ring k] [add_comm_group V] [module k V] [S : add_torsor V P] {ι : Type u_4} (s : finset ι) (p : ι → P) (b : P) :

(ι → k) →ₗ[k] V

A weighted sum of the results of subtracting a base point from the given points, as a linear map on the weights. The main cases of interest are where the sum of the weights is 0, in which case the sum is independent of the choice of base point, and where the sum of the weights is 1, in which case the sum added to the base point is independent of the choice of base point.

Equations

s.weighted_vsub_of_point p b = s.sum (λ (i : ι), (linear_map.proj i).smul_right (p i -ᵥ b))

@[simp]

theorem finset.weighted_vsub_of_point_apply {k : Type u_1} {V : Type u_2} {P : Type u_3} [ring k] [add_comm_group V] [module k V] [S : add_torsor V P] {ι : Type u_4} (s : finset ι) (w : ι → k) (p : ι → P) (b : P) :

⇑(s.weighted_vsub_of_point p b) w = s.sum (λ (i : ι), w i • (p i -ᵥ b))

@[simp]

theorem finset.weighted_vsub_of_point_apply_const {k : Type u_1} {V : Type u_2} {P : Type u_3} [ring k] [add_comm_group V] [module k V] [S : add_torsor V P] {ι : Type u_4} (s : finset ι) (w : ι → k) (p b : P) :

⇑(s.weighted_vsub_of_point (λ (_x : ι), p) b) w = s.sum (λ (i : ι), w i) • (p -ᵥ b)

The value of weighted_vsub_of_point, where the given points are equal.

theorem finset.weighted_vsub_of_point_congr {k : Type u_1} {V : Type u_2} {P : Type u_3} [ring k] [add_comm_group V] [module k V] [S : add_torsor V P] {ι : Type u_4} (s : finset ι) {w₁ w₂ : ι → k} (hw : ∀ (i : ι), i ∈ s → w₁ i = w₂ i) {p₁ p₂ : ι → P} (hp : ∀ (i : ι), i ∈ s → p₁ i = p₂ i) (b : P) :

⇑(s.weighted_vsub_of_point p₁ b) w₁ = ⇑(s.weighted_vsub_of_point p₂ b) w₂

weighted_vsub_of_point gives equal results for two families of weights and two families of points that are equal on s.

theorem finset.weighted_vsub_of_point_eq_of_weights_eq {k : Type u_1} {V : Type u_2} {P : Type u_3} [ring k] [add_comm_group V] [module k V] [S : add_torsor V P] {ι : Type u_4} (s : finset ι) (p : ι → P) (j : ι) (w₁ w₂ : ι → k) (hw : ∀ (i : ι), i ≠ j → w₁ i = w₂ i) :

⇑(s.weighted_vsub_of_point p (p j)) w₁ = ⇑(s.weighted_vsub_of_point p (p j)) w₂

Given a family of points, if we use a member of the family as a base point, the weighted_vsub_of_point does not depend on the value of the weights at this point.

theorem finset.weighted_vsub_of_point_eq_of_sum_eq_zero {k : Type u_1} {V : Type u_2} {P : Type u_3} [ring k] [add_comm_group V] [module k V] [S : add_torsor V P] {ι : Type u_4} (s : finset ι) (w : ι → k) (p : ι → P) (h : s.sum (λ (i : ι), w i) = 0) (b₁ b₂ : P) :

⇑(s.weighted_vsub_of_point p b₁) w = ⇑(s.weighted_vsub_of_point p b₂) w

The weighted sum is independent of the base point when the sum of the weights is 0.

theorem finset.weighted_vsub_of_point_vadd_eq_of_sum_eq_one {k : Type u_1} {V : Type u_2} {P : Type u_3} [ring k] [add_comm_group V] [module k V] [S : add_torsor V P] {ι : Type u_4} (s : finset ι) (w : ι → k) (p : ι → P) (h : s.sum (λ (i : ι), w i) = 1) (b₁ b₂ : P) :

⇑(s.weighted_vsub_of_point p b₁) w +ᵥ b₁ = ⇑(s.weighted_vsub_of_point p b₂) w +ᵥ b₂

The weighted sum, added to the base point, is independent of the base point when the sum of the weights is 1.

@[simp]

theorem finset.weighted_vsub_of_point_erase {k : Type u_1} {V : Type u_2} {P : Type u_3} [ring k] [add_comm_group V] [module k V] [S : add_torsor V P] {ι : Type u_4} (s : finset ι) [decidable_eq ι] (w : ι → k) (p : ι → P) (i : ι) :

⇑((s.erase i).weighted_vsub_of_point p (p i)) w = ⇑(s.weighted_vsub_of_point p (p i)) w

The weighted sum is unaffected by removing the base point, if present, from the set of points.

@[simp]

theorem finset.weighted_vsub_of_point_insert {k : Type u_1} {V : Type u_2} {P : Type u_3} [ring k] [add_comm_group V] [module k V] [S : add_torsor V P] {ι : Type u_4} (s : finset ι) [decidable_eq ι] (w : ι → k) (p : ι → P) (i : ι) :

⇑((has_insert.insert i s).weighted_vsub_of_point p (p i)) w = ⇑(s.weighted_vsub_of_point p (p i)) w

The weighted sum is unaffected by adding the base point, whether or not present, to the set of points.

theorem finset.weighted_vsub_of_point_indicator_subset {k : Type u_1} {V : Type u_2} {P : Type u_3} [ring k] [add_comm_group V] [module k V] [S : add_torsor V P] {ι : Type u_4} (w : ι → k) (p : ι → P) (b : P) {s₁ s₂ : finset ι} (h : s₁ ⊆ s₂) :

⇑(s₁.weighted_vsub_of_point p b) w = ⇑(s₂.weighted_vsub_of_point p b) (↑s₁.indicator w)

The weighted sum is unaffected by changing the weights to the corresponding indicator function and adding points to the set.

theorem finset.weighted_vsub_of_point_map {k : Type u_1} {V : Type u_2} {P : Type u_3} [ring k] [add_comm_group V] [module k V] [S : add_torsor V P] {ι : Type u_4} {ι₂ : Type u_5} (s₂ : finset ι₂) (e : ι₂ ↪ ι) (w : ι → k) (p : ι → P) (b : P) :

⇑((finset.map e s₂).weighted_vsub_of_point p b) w = ⇑(s₂.weighted_vsub_of_point (p ∘ ⇑e) b) (w ∘ ⇑e)

A weighted sum, over the image of an embedding, equals a weighted sum with the same points and weights over the original finset.

theorem finset.sum_smul_vsub_eq_weighted_vsub_of_point_sub {k : Type u_1} {V : Type u_2} {P : Type u_3} [ring k] [add_comm_group V] [module k V] [S : add_torsor V P] {ι : Type u_4} (s : finset ι) (w : ι → k) (p₁ p₂ : ι → P) (b : P) :

s.sum (λ (i : ι), w i • (p₁ i -ᵥ p₂ i)) = ⇑(s.weighted_vsub_of_point p₁ b) w - ⇑(s.weighted_vsub_of_point p₂ b) w

A weighted sum of pairwise subtractions, expressed as a subtraction of two weighted_vsub_of_point expressions.

theorem finset.sum_smul_vsub_const_eq_weighted_vsub_of_point_sub {k : Type u_1} {V : Type u_2} {P : Type u_3} [ring k] [add_comm_group V] [module k V] [S : add_torsor V P] {ι : Type u_4} (s : finset ι) (w : ι → k) (p₁ : ι → P) (p₂ b : P) :

s.sum (λ (i : ι), w i • (p₁ i -ᵥ p₂)) = ⇑(s.weighted_vsub_of_point p₁ b) w - s.sum (λ (i : ι), w i) • (p₂ -ᵥ b)

A weighted sum of pairwise subtractions, where the point on the right is constant, expressed as a subtraction involving a weighted_vsub_of_point expression.

theorem finset.sum_smul_const_vsub_eq_sub_weighted_vsub_of_point {k : Type u_1} {V : Type u_2} {P : Type u_3} [ring k] [add_comm_group V] [module k V] [S : add_torsor V P] {ι : Type u_4} (s : finset ι) (w : ι → k) (p₂ : ι → P) (p₁ b : P) :

s.sum (λ (i : ι), w i • (p₁ -ᵥ p₂ i)) = s.sum (λ (i : ι), w i) • (p₁ -ᵥ b) - ⇑(s.weighted_vsub_of_point p₂ b) w

A weighted sum of pairwise subtractions, where the point on the left is constant, expressed as a subtraction involving a weighted_vsub_of_point expression.

theorem finset.weighted_vsub_of_point_sdiff {k : Type u_1} {V : Type u_2} {P : Type u_3} [ring k] [add_comm_group V] [module k V] [S : add_torsor V P] {ι : Type u_4} (s : finset ι) [decidable_eq ι] {s₂ : finset ι} (h : s₂ ⊆ s) (w : ι → k) (p : ι → P) (b : P) :

⇑((s \ s₂).weighted_vsub_of_point p b) w + ⇑(s₂.weighted_vsub_of_point p b) w = ⇑(s.weighted_vsub_of_point p b) w

A weighted sum may be split into such sums over two subsets.

theorem finset.weighted_vsub_of_point_sdiff_sub {k : Type u_1} {V : Type u_2} {P : Type u_3} [ring k] [add_comm_group V] [module k V] [S : add_torsor V P] {ι : Type u_4} (s : finset ι) [decidable_eq ι] {s₂ : finset ι} (h : s₂ ⊆ s) (w : ι → k) (p : ι → P) (b : P) :

⇑((s \ s₂).weighted_vsub_of_point p b) w - ⇑(s₂.weighted_vsub_of_point p b) (-w) = ⇑(s.weighted_vsub_of_point p b) w

A weighted sum may be split into a subtraction of such sums over two subsets.

theorem finset.weighted_vsub_of_point_subtype_eq_filter {k : Type u_1} {V : Type u_2} {P : Type u_3} [ring k] [add_comm_group V] [module k V] [S : add_torsor V P] {ι : Type u_4} (s : finset ι) (w : ι → k) (p : ι → P) (b : P) (pred : ι → Prop) [decidable_pred pred] :

⇑((finset.subtype pred s).weighted_vsub_of_point (λ (i : subtype pred), p ↑i) b) (λ (i : subtype pred), w ↑i) = ⇑((finset.filter pred s).weighted_vsub_of_point p b) w

A weighted sum over s.subtype pred equals one over s.filter pred.

theorem finset.weighted_vsub_of_point_filter_of_ne {k : Type u_1} {V : Type u_2} {P : Type u_3} [ring k] [add_comm_group V] [module k V] [S : add_torsor V P] {ι : Type u_4} (s : finset ι) (w : ι → k) (p : ι → P) (b : P) {pred : ι → Prop} [decidable_pred pred] (h : ∀ (i : ι), i ∈ s → w i ≠ 0 → pred i) :

⇑((finset.filter pred s).weighted_vsub_of_point p b) w = ⇑(s.weighted_vsub_of_point p b) w

A weighted sum over s.filter pred equals one over s if all the weights at indices in s not satisfying pred are zero.

theorem finset.weighted_vsub_of_point_const_smul {k : Type u_1} {V : Type u_2} {P : Type u_3} [ring k] [add_comm_group V] [module k V] [S : add_torsor V P] {ι : Type u_4} (s : finset ι) (w : ι → k) (p : ι → P) (b : P) (c : k) :

⇑(s.weighted_vsub_of_point p b) (c • w) = c • ⇑(s.weighted_vsub_of_point p b) w

A constant multiplier of the weights in weighted_vsub_of_point may be moved outside the sum.

noncomputable def finset.weighted_vsub {k : Type u_1} {V : Type u_2} {P : Type u_3} [ring k] [add_comm_group V] [module k V] [S : add_torsor V P] {ι : Type u_4} (s : finset ι) (p : ι → P) :

(ι → k) →ₗ[k] V

A weighted sum of the results of subtracting a default base point from the given points, as a linear map on the weights. This is intended to be used when the sum of the weights is 0; that condition is specified as a hypothesis on those lemmas that require it.

Equations

s.weighted_vsub p = s.weighted_vsub_of_point p (classical.choice finset.weighted_vsub._proof_1)

theorem finset.weighted_vsub_apply {k : Type u_1} {V : Type u_2} {P : Type u_3} [ring k] [add_comm_group V] [module k V] [S : add_torsor V P] {ι : Type u_4} (s : finset ι) (w : ι → k) (p : ι → P) :

⇑(s.weighted_vsub p) w = s.sum (λ (i : ι), w i • (p i -ᵥ classical.choice add_torsor.nonempty))

Applying weighted_vsub with given weights. This is for the case where a result involving a default base point is OK (for example, when that base point will cancel out later); a more typical use case for weighted_vsub would involve selecting a preferred base point with weighted_vsub_eq_weighted_vsub_of_point_of_sum_eq_zero and then using weighted_vsub_of_point_apply.

theorem finset.weighted_vsub_eq_weighted_vsub_of_point_of_sum_eq_zero {k : Type u_1} {V : Type u_2} {P : Type u_3} [ring k] [add_comm_group V] [module k V] [S : add_torsor V P] {ι : Type u_4} (s : finset ι) (w : ι → k) (p : ι → P) (h : s.sum (λ (i : ι), w i) = 0) (b : P) :

⇑(s.weighted_vsub p) w = ⇑(s.weighted_vsub_of_point p b) w

weighted_vsub gives the sum of the results of subtracting any base point, when the sum of the weights is 0.

@[simp]

theorem finset.weighted_vsub_apply_const {k : Type u_1} {V : Type u_2} {P : Type u_3} [ring k] [add_comm_group V] [module k V] [S : add_torsor V P] {ι : Type u_4} (s : finset ι) (w : ι → k) (p : P) (h : s.sum (λ (i : ι), w i) = 0) :

⇑(s.weighted_vsub (λ (_x : ι), p)) w = 0

The value of weighted_vsub, where the given points are equal and the sum of the weights is 0.

@[simp]

theorem finset.weighted_vsub_empty {k : Type u_1} {V : Type u_2} {P : Type u_3} [ring k] [add_comm_group V] [module k V] [S : add_torsor V P] {ι : Type u_4} (w : ι → k) (p : ι → P) :

⇑(∅.weighted_vsub p) w = 0

The weighted_vsub for an empty set is 0.

theorem finset.weighted_vsub_congr {k : Type u_1} {V : Type u_2} {P : Type u_3} [ring k] [add_comm_group V] [module k V] [S : add_torsor V P] {ι : Type u_4} (s : finset ι) {w₁ w₂ : ι → k} (hw : ∀ (i : ι), i ∈ s → w₁ i = w₂ i) {p₁ p₂ : ι → P} (hp : ∀ (i : ι), i ∈ s → p₁ i = p₂ i) :

⇑(s.weighted_vsub p₁) w₁ = ⇑(s.weighted_vsub p₂) w₂

weighted_vsub gives equal results for two families of weights and two families of points that are equal on s.

theorem finset.weighted_vsub_indicator_subset {k : Type u_1} {V : Type u_2} {P : Type u_3} [ring k] [add_comm_group V] [module k V] [S : add_torsor V P] {ι : Type u_4} (w : ι → k) (p : ι → P) {s₁ s₂ : finset ι} (h : s₁ ⊆ s₂) :

⇑(s₁.weighted_vsub p) w = ⇑(s₂.weighted_vsub p) (↑s₁.indicator w)

The weighted sum is unaffected by changing the weights to the corresponding indicator function and adding points to the set.

theorem finset.weighted_vsub_map {k : Type u_1} {V : Type u_2} {P : Type u_3} [ring k] [add_comm_group V] [module k V] [S : add_torsor V P] {ι : Type u_4} {ι₂ : Type u_5} (s₂ : finset ι₂) (e : ι₂ ↪ ι) (w : ι → k) (p : ι → P) :

⇑((finset.map e s₂).weighted_vsub p) w = ⇑(s₂.weighted_vsub (p ∘ ⇑e)) (w ∘ ⇑e)

A weighted subtraction, over the image of an embedding, equals a weighted subtraction with the same points and weights over the original finset.

theorem finset.sum_smul_vsub_eq_weighted_vsub_sub {k : Type u_1} {V : Type u_2} {P : Type u_3} [ring k] [add_comm_group V] [module k V] [S : add_torsor V P] {ι : Type u_4} (s : finset ι) (w : ι → k) (p₁ p₂ : ι → P) :

s.sum (λ (i : ι), w i • (p₁ i -ᵥ p₂ i)) = ⇑(s.weighted_vsub p₁) w - ⇑(s.weighted_vsub p₂) w

A weighted sum of pairwise subtractions, expressed as a subtraction of two weighted_vsub expressions.

theorem finset.sum_smul_vsub_const_eq_weighted_vsub {k : Type u_1} {V : Type u_2} {P : Type u_3} [ring k] [add_comm_group V] [module k V] [S : add_torsor V P] {ι : Type u_4} (s : finset ι) (w : ι → k) (p₁ : ι → P) (p₂ : P) (h : s.sum (λ (i : ι), w i) = 0) :

s.sum (λ (i : ι), w i • (p₁ i -ᵥ p₂)) = ⇑(s.weighted_vsub p₁) w

A weighted sum of pairwise subtractions, where the point on the right is constant and the sum of the weights is 0.

theorem finset.sum_smul_const_vsub_eq_neg_weighted_vsub {k : Type u_1} {V : Type u_2} {P : Type u_3} [ring k] [add_comm_group V] [module k V] [S : add_torsor V P] {ι : Type u_4} (s : finset ι) (w : ι → k) (p₂ : ι → P) (p₁ : P) (h : s.sum (λ (i : ι), w i) = 0) :

s.sum (λ (i : ι), w i • (p₁ -ᵥ p₂ i)) = -⇑(s.weighted_vsub p₂) w

A weighted sum of pairwise subtractions, where the point on the left is constant and the sum of the weights is 0.

theorem finset.weighted_vsub_sdiff {k : Type u_1} {V : Type u_2} {P : Type u_3} [ring k] [add_comm_group V] [module k V] [S : add_torsor V P] {ι : Type u_4} (s : finset ι) [decidable_eq ι] {s₂ : finset ι} (h : s₂ ⊆ s) (w : ι → k) (p : ι → P) :

⇑((s \ s₂).weighted_vsub p) w + ⇑(s₂.weighted_vsub p) w = ⇑(s.weighted_vsub p) w

A weighted sum may be split into such sums over two subsets.

theorem finset.weighted_vsub_sdiff_sub {k : Type u_1} {V : Type u_2} {P : Type u_3} [ring k] [add_comm_group V] [module k V] [S : add_torsor V P] {ι : Type u_4} (s : finset ι) [decidable_eq ι] {s₂ : finset ι} (h : s₂ ⊆ s) (w : ι → k) (p : ι → P) :

⇑((s \ s₂).weighted_vsub p) w - ⇑(s₂.weighted_vsub p) (-w) = ⇑(s.weighted_vsub p) w

A weighted sum may be split into a subtraction of such sums over two subsets.

theorem finset.weighted_vsub_subtype_eq_filter {k : Type u_1} {V : Type u_2} {P : Type u_3} [ring k] [add_comm_group V] [module k V] [S : add_torsor V P] {ι : Type u_4} (s : finset ι) (w : ι → k) (p : ι → P) (pred : ι → Prop) [decidable_pred pred] :

⇑((finset.subtype pred s).weighted_vsub (λ (i : subtype pred), p ↑i)) (λ (i : subtype pred), w ↑i) = ⇑((finset.filter pred s).weighted_vsub p) w

A weighted sum over s.subtype pred equals one over s.filter pred.

theorem finset.weighted_vsub_filter_of_ne {k : Type u_1} {V : Type u_2} {P : Type u_3} [ring k] [add_comm_group V] [module k V] [S : add_torsor V P] {ι : Type u_4} (s : finset ι) (w : ι → k) (p : ι → P) {pred : ι → Prop} [decidable_pred pred] (h : ∀ (i : ι), i ∈ s → w i ≠ 0 → pred i) :

⇑((finset.filter pred s).weighted_vsub p) w = ⇑(s.weighted_vsub p) w

A weighted sum over s.filter pred equals one over s if all the weights at indices in s not satisfying pred are zero.

theorem finset.weighted_vsub_const_smul {k : Type u_1} {V : Type u_2} {P : Type u_3} [ring k] [add_comm_group V] [module k V] [S : add_torsor V P] {ι : Type u_4} (s : finset ι) (w : ι → k) (p : ι → P) (c : k) :

⇑(s.weighted_vsub p) (c • w) = c • ⇑(s.weighted_vsub p) w

A constant multiplier of the weights in weighted_vsub_of may be moved outside the sum.

noncomputable def finset.affine_combination (k : Type u_1) {V : Type u_2} {P : Type u_3} [ring k] [add_comm_group V] [module k V] [S : add_torsor V P] {ι : Type u_4} (s : finset ι) (p : ι → P) :

(ι → k) →ᵃ[k] P

A weighted sum of the results of subtracting a default base point from the given points, added to that base point, as an affine map on the weights. This is intended to be used when the sum of the weights is 1, in which case it is an affine combination (barycenter) of the points with the given weights; that condition is specified as a hypothesis on those lemmas that require it.

Equations

finset.affine_combination k s p = {to_fun := λ (w : ι → k), ⇑(s.weighted_vsub_of_point p (classical.choice finset.affine_combination._proof_1)) w +ᵥ classical.choice finset.affine_combination._proof_1, linear := s.weighted_vsub p, map_vadd' := _}

@[simp]

theorem finset.affine_combination_linear (k : Type u_1) {V : Type u_2} {P : Type u_3} [ring k] [add_comm_group V] [module k V] [S : add_torsor V P] {ι : Type u_4} (s : finset ι) (p : ι → P) :

(finset.affine_combination k s p).linear = s.weighted_vsub p

The linear map corresponding to affine_combination is weighted_vsub.

theorem finset.affine_combination_apply {k : Type u_1} {V : Type u_2} {P : Type u_3} [ring k] [add_comm_group V] [module k V] [S : add_torsor V P] {ι : Type u_4} (s : finset ι) (w : ι → k) (p : ι → P) :

⇑(finset.affine_combination k s p) w = ⇑(s.weighted_vsub_of_point p (classical.choice add_torsor.nonempty)) w +ᵥ classical.choice add_torsor.nonempty

Applying affine_combination with given weights. This is for the case where a result involving a default base point is OK (for example, when that base point will cancel out later); a more typical use case for affine_combination would involve selecting a preferred base point with affine_combination_eq_weighted_vsub_of_point_vadd_of_sum_eq_one and then using weighted_vsub_of_point_apply.

@[simp]

theorem finset.affine_combination_apply_const {k : Type u_1} {V : Type u_2} {P : Type u_3} [ring k] [add_comm_group V] [module k V] [S : add_torsor V P] {ι : Type u_4} (s : finset ι) (w : ι → k) (p : P) (h : s.sum (λ (i : ι), w i) = 1) :

⇑(finset.affine_combination k s (λ (_x : ι), p)) w = p

The value of affine_combination, where the given points are equal.

theorem finset.affine_combination_congr {k : Type u_1} {V : Type u_2} {P : Type u_3} [ring k] [add_comm_group V] [module k V] [S : add_torsor V P] {ι : Type u_4} (s : finset ι) {w₁ w₂ : ι → k} (hw : ∀ (i : ι), i ∈ s → w₁ i = w₂ i) {p₁ p₂ : ι → P} (hp : ∀ (i : ι), i ∈ s → p₁ i = p₂ i) :

⇑(finset.affine_combination k s p₁) w₁ = ⇑(finset.affine_combination k s p₂) w₂

affine_combination gives equal results for two families of weights and two families of points that are equal on s.

theorem finset.affine_combination_eq_weighted_vsub_of_point_vadd_of_sum_eq_one {k : Type u_1} {V : Type u_2} {P : Type u_3} [ring k] [add_comm_group V] [module k V] [S : add_torsor V P] {ι : Type u_4} (s : finset ι) (w : ι → k) (p : ι → P) (h : s.sum (λ (i : ι), w i) = 1) (b : P) :

⇑(finset.affine_combination k s p) w = ⇑(s.weighted_vsub_of_point p b) w +ᵥ b

affine_combination gives the sum with any base point, when the sum of the weights is 1.

theorem finset.weighted_vsub_vadd_affine_combination {k : Type u_1} {V : Type u_2} {P : Type u_3} [ring k] [add_comm_group V] [module k V] [S : add_torsor V P] {ι : Type u_4} (s : finset ι) (w₁ w₂ : ι → k) (p : ι → P) :

⇑(s.weighted_vsub p) w₁ +ᵥ ⇑(finset.affine_combination k s p) w₂ = ⇑(finset.affine_combination k s p) (w₁ + w₂)

Adding a weighted_vsub to an affine_combination.

theorem finset.affine_combination_vsub {k : Type u_1} {V : Type u_2} {P : Type u_3} [ring k] [add_comm_group V] [module k V] [S : add_torsor V P] {ι : Type u_4} (s : finset ι) (w₁ w₂ : ι → k) (p : ι → P) :

⇑(finset.affine_combination k s p) w₁ -ᵥ ⇑(finset.affine_combination k s p) w₂ = ⇑(s.weighted_vsub p) (w₁ - w₂)

Subtracting two affine_combinations.

theorem finset.attach_affine_combination_of_injective {k : Type u_1} {V : Type u_2} {P : Type u_3} [ring k] [add_comm_group V] [module k V] [S : add_torsor V P] [decidable_eq P] (s : finset P) (w : P → k) (f : ↥s → P) (hf : function.injective f) :

⇑(finset.affine_combination k s.attach f) (w ∘ f) = ⇑(finset.affine_combination k (finset.image f finset.univ) id) w

theorem finset.attach_affine_combination_coe {k : Type u_1} {V : Type u_2} {P : Type u_3} [ring k] [add_comm_group V] [module k V] [S : add_torsor V P] (s : finset P) (w : P → k) :

⇑(finset.affine_combination k s.attach coe) (w ∘ coe) = ⇑(finset.affine_combination k s id) w

@[simp]

theorem finset.weighted_vsub_eq_linear_combination {k : Type u_1} {V : Type u_2} [ring k] [add_comm_group V] [module k V] {ι : Type u_3} (s : finset ι) {w : ι → k} {p : ι → V} (hw : s.sum w = 0) :

⇑(s.weighted_vsub p) w = s.sum (λ (i : ι), w i • p i)

Viewing a module as an affine space modelled on itself, a weighted_vsub is just a linear combination.

@[simp]

theorem finset.affine_combination_eq_linear_combination {k : Type u_1} {V : Type u_2} [ring k] [add_comm_group V] [module k V] {ι : Type u_4} (s : finset ι) (p : ι → V) (w : ι → k) (hw : s.sum (λ (i : ι), w i) = 1) :

⇑(finset.affine_combination k s p) w = s.sum (λ (i : ι), w i • p i)

Viewing a module as an affine space modelled on itself, affine combinations are just linear combinations.

@[simp]

theorem finset.affine_combination_of_eq_one_of_eq_zero {k : Type u_1} {V : Type u_2} {P : Type u_3} [ring k] [add_comm_group V] [module k V] [S : add_torsor V P] {ι : Type u_4} (s : finset ι) (w : ι → k) (p : ι → P) {i : ι} (his : i ∈ s) (hwi : w i = 1) (hw0 : ∀ (i2 : ι), i2 ∈ s → i2 ≠ i → w i2 = 0) :

⇑(finset.affine_combination k s p) w = p i

An affine_combination equals a point if that point is in the set and has weight 1 and the other points in the set have weight 0.

theorem finset.affine_combination_indicator_subset {k : Type u_1} {V : Type u_2} {P : Type u_3} [ring k] [add_comm_group V] [module k V] [S : add_torsor V P] {ι : Type u_4} (w : ι → k) (p : ι → P) {s₁ s₂ : finset ι} (h : s₁ ⊆ s₂) :

⇑(finset.affine_combination k s₁ p) w = ⇑(finset.affine_combination k s₂ p) (↑s₁.indicator w)

An affine combination is unaffected by changing the weights to the corresponding indicator function and adding points to the set.

theorem finset.affine_combination_map {k : Type u_1} {V : Type u_2} {P : Type u_3} [ring k] [add_comm_group V] [module k V] [S : add_torsor V P] {ι : Type u_4} {ι₂ : Type u_5} (s₂ : finset ι₂) (e : ι₂ ↪ ι) (w : ι → k) (p : ι → P) :

⇑(finset.affine_combination k (finset.map e s₂) p) w = ⇑(finset.affine_combination k s₂ (p ∘ ⇑e)) (w ∘ ⇑e)

An affine combination, over the image of an embedding, equals an affine combination with the same points and weights over the original finset.

theorem finset.sum_smul_vsub_eq_affine_combination_vsub {k : Type u_1} {V : Type u_2} {P : Type u_3} [ring k] [add_comm_group V] [module k V] [S : add_torsor V P] {ι : Type u_4} (s : finset ι) (w : ι → k) (p₁ p₂ : ι → P) :

s.sum (λ (i : ι), w i • (p₁ i -ᵥ p₂ i)) = ⇑(finset.affine_combination k s p₁) w -ᵥ ⇑(finset.affine_combination k s p₂) w

A weighted sum of pairwise subtractions, expressed as a subtraction of two affine_combination expressions.

theorem finset.sum_smul_vsub_const_eq_affine_combination_vsub {k : Type u_1} {V : Type u_2} {P : Type u_3} [ring k] [add_comm_group V] [module k V] [S : add_torsor V P] {ι : Type u_4} (s : finset ι) (w : ι → k) (p₁ : ι → P) (p₂ : P) (h : s.sum (λ (i : ι), w i) = 1) :

s.sum (λ (i : ι), w i • (p₁ i -ᵥ p₂)) = ⇑(finset.affine_combination k s p₁) w -ᵥ p₂

A weighted sum of pairwise subtractions, where the point on the right is constant and the sum of the weights is 1.

theorem finset.sum_smul_const_vsub_eq_vsub_affine_combination {k : Type u_1} {V : Type u_2} {P : Type u_3} [ring k] [add_comm_group V] [module k V] [S : add_torsor V P] {ι : Type u_4} (s : finset ι) (w : ι → k) (p₂ : ι → P) (p₁ : P) (h : s.sum (λ (i : ι), w i) = 1) :

s.sum (λ (i : ι), w i • (p₁ -ᵥ p₂ i)) = p₁ -ᵥ ⇑(finset.affine_combination k s p₂) w

A weighted sum of pairwise subtractions, where the point on the left is constant and the sum of the weights is 1.

theorem finset.affine_combination_sdiff_sub {k : Type u_1} {V : Type u_2} {P : Type u_3} [ring k] [add_comm_group V] [module k V] [S : add_torsor V P] {ι : Type u_4} (s : finset ι) [decidable_eq ι] {s₂ : finset ι} (h : s₂ ⊆ s) (w : ι → k) (p : ι → P) :

⇑(finset.affine_combination k (s \ s₂) p) w -ᵥ ⇑(finset.affine_combination k s₂ p) (-w) = ⇑(s.weighted_vsub p) w

A weighted sum may be split into a subtraction of affine combinations over two subsets.

theorem finset.affine_combination_eq_of_weighted_vsub_eq_zero_of_eq_neg_one {k : Type u_1} {V : Type u_2} {P : Type u_3} [ring k] [add_comm_group V] [module k V] [S : add_torsor V P] {ι : Type u_4} (s : finset ι) {w : ι → k} {p : ι → P} (hw : ⇑(s.weighted_vsub p) w = 0) {i : ι} [decidable_pred (λ (_x : ι), _x ≠ i)] (his : i ∈ s) (hwi : w i = -1) :

⇑(finset.affine_combination k (finset.filter (λ (_x : ι), _x ≠ i) s) p) w = p i

If a weighted sum is zero and one of the weights is -1, the corresponding point is the affine combination of the other points with the given weights.

theorem finset.affine_combination_subtype_eq_filter {k : Type u_1} {V : Type u_2} {P : Type u_3} [ring k] [add_comm_group V] [module k V] [S : add_torsor V P] {ι : Type u_4} (s : finset ι) (w : ι → k) (p : ι → P) (pred : ι → Prop) [decidable_pred pred] :

⇑(finset.affine_combination k (finset.subtype pred s) (λ (i : subtype pred), p ↑i)) (λ (i : subtype pred), w ↑i) = ⇑(finset.affine_combination k (finset.filter pred s) p) w

An affine combination over s.subtype pred equals one over s.filter pred.

theorem finset.affine_combination_filter_of_ne {k : Type u_1} {V : Type u_2} {P : Type u_3} [ring k] [add_comm_group V] [module k V] [S : add_torsor V P] {ι : Type u_4} (s : finset ι) (w : ι → k) (p : ι → P) {pred : ι → Prop} [decidable_pred pred] (h : ∀ (i : ι), i ∈ s → w i ≠ 0 → pred i) :

⇑(finset.affine_combination k (finset.filter pred s) p) w = ⇑(finset.affine_combination k s p) w

An affine combination over s.filter pred equals one over s if all the weights at indices in s not satisfying pred are zero.

theorem finset.eq_weighted_vsub_of_point_subset_iff_eq_weighted_vsub_of_point_subtype {k : Type u_1} {V : Type u_2} {P : Type u_3} [ring k] [add_comm_group V] [module k V] [S : add_torsor V P] {ι : Type u_4} {v : V} {x : k} {s : set ι} {p : ι → P} {b : P} :

(∃ (fs : finset ι) (hfs : ↑fs ⊆ s) (w : ι → k) (hw : fs.sum (λ (i : ι), w i) = x), v = ⇑(fs.weighted_vsub_of_point p b) w) ↔ ∃ (fs : finset ↥s) (w : ↥s → k) (hw : fs.sum (λ (i : ↥s), w i) = x), v = ⇑(fs.weighted_vsub_of_point (λ (i : ↥s), p ↑i) b) w

Suppose an indexed family of points is given, along with a subset of the index type. A vector can be expressed as weighted_vsub_of_point using a finset lying within that subset and with a given sum of weights if and only if it can be expressed as weighted_vsub_of_point with that sum of weights for the corresponding indexed family whose index type is the subtype corresponding to that subset.

theorem finset.eq_weighted_vsub_subset_iff_eq_weighted_vsub_subtype (k : Type u_1) {V : Type u_2} {P : Type u_3} [ring k] [add_comm_group V] [module k V] [S : add_torsor V P] {ι : Type u_4} {v : V} {s : set ι} {p : ι → P} :

(∃ (fs : finset ι) (hfs : ↑fs ⊆ s) (w : ι → k) (hw : fs.sum (λ (i : ι), w i) = 0), v = ⇑(fs.weighted_vsub p) w) ↔ ∃ (fs : finset ↥s) (w : ↥s → k) (hw : fs.sum (λ (i : ↥s), w i) = 0), v = ⇑(fs.weighted_vsub (λ (i : ↥s), p ↑i)) w

Suppose an indexed family of points is given, along with a subset of the index type. A vector can be expressed as weighted_vsub using a finset lying within that subset and with sum of weights 0 if and only if it can be expressed as weighted_vsub with sum of weights 0 for the corresponding indexed family whose index type is the subtype corresponding to that subset.

theorem finset.eq_affine_combination_subset_iff_eq_affine_combination_subtype (k : Type u_1) (V : Type u_2) {P : Type u_3} [ring k] [add_comm_group V] [module k V] [S : add_torsor V P] {ι : Type u_4} {p0 : P} {s : set ι} {p : ι → P} :

(∃ (fs : finset ι) (hfs : ↑fs ⊆ s) (w : ι → k) (hw : fs.sum (λ (i : ι), w i) = 1), p0 = ⇑(finset.affine_combination k fs p) w) ↔ ∃ (fs : finset ↥s) (w : ↥s → k) (hw : fs.sum (λ (i : ↥s), w i) = 1), p0 = ⇑(finset.affine_combination k fs (λ (i : ↥s), p ↑i)) w

Suppose an indexed family of points is given, along with a subset of the index type. A point can be expressed as an affine_combination using a finset lying within that subset and with sum of weights 1 if and only if it can be expressed an affine_combination with sum of weights 1 for the corresponding indexed family whose index type is the subtype corresponding to that subset.

theorem finset.map_affine_combination {k : Type u_1} {V : Type u_2} {P : Type u_3} [ring k] [add_comm_group V] [module k V] [S : add_torsor V P] {ι : Type u_4} (s : finset ι) {V₂ : Type u_5} {P₂ : Type u_6} [add_comm_group V₂] [module k V₂] [add_torsor V₂ P₂] (p : ι → P) (w : ι → k) (hw : s.sum w = 1) (f : P →ᵃ[k] P₂) :

⇑f (⇑(finset.affine_combination k s p) w) = ⇑(finset.affine_combination k s (⇑f ∘ p)) w

Affine maps commute with affine combinations.

def finset.affine_combination_single_weights (k : Type u_1) [ring k] {ι : Type u_4} [decidable_eq ι] (i : ι) :

ι → k

Weights for expressing a single point as an affine combination.

Equations

finset.affine_combination_single_weights k i = function.update (function.const ι 0) i 1

@[simp]

theorem finset.affine_combination_single_weights_apply_self (k : Type u_1) [ring k] {ι : Type u_4} [decidable_eq ι] (i : ι) :

finset.affine_combination_single_weights k i i = 1

@[simp]

theorem finset.affine_combination_single_weights_apply_of_ne (k : Type u_1) [ring k] {ι : Type u_4} [decidable_eq ι] {i j : ι} (h : j ≠ i) :

finset.affine_combination_single_weights k i j = 0

@[simp]

theorem finset.sum_affine_combination_single_weights (k : Type u_1) [ring k] {ι : Type u_4} (s : finset ι) [decidable_eq ι] {i : ι} (h : i ∈ s) :

s.sum (λ (j : ι), finset.affine_combination_single_weights k i j) = 1

def finset.weighted_vsub_vsub_weights (k : Type u_1) [ring k] {ι : Type u_4} [decidable_eq ι] (i j : ι) :

ι → k

Weights for expressing the subtraction of two points as a weighted_vsub.

Equations

finset.weighted_vsub_vsub_weights k i j = finset.affine_combination_single_weights k i - finset.affine_combination_single_weights k j

@[simp]

theorem finset.weighted_vsub_vsub_weights_self (k : Type u_1) [ring k] {ι : Type u_4} [decidable_eq ι] (i : ι) :

finset.weighted_vsub_vsub_weights k i i = 0

@[simp]

theorem finset.weighted_vsub_vsub_weights_apply_left (k : Type u_1) [ring k] {ι : Type u_4} [decidable_eq ι] {i j : ι} (h : i ≠ j) :

finset.weighted_vsub_vsub_weights k i j i = 1

@[simp]

theorem finset.weighted_vsub_vsub_weights_apply_right (k : Type u_1) [ring k] {ι : Type u_4} [decidable_eq ι] {i j : ι} (h : i ≠ j) :

finset.weighted_vsub_vsub_weights k i j j = -1

@[simp]

theorem finset.weighted_vsub_vsub_weights_apply_of_ne (k : Type u_1) [ring k] {ι : Type u_4} [decidable_eq ι] {i j t : ι} (hi : t ≠ i) (hj : t ≠ j) :

finset.weighted_vsub_vsub_weights k i j t = 0

@[simp]

theorem finset.sum_weighted_vsub_vsub_weights (k : Type u_1) [ring k] {ι : Type u_4} (s : finset ι) [decidable_eq ι] {i j : ι} (hi : i ∈ s) (hj : j ∈ s) :

s.sum (λ (t : ι), finset.weighted_vsub_vsub_weights k i j t) = 0

def finset.affine_combination_line_map_weights {k : Type u_1} [ring k] {ι : Type u_4} [decidable_eq ι] (i j : ι) (c : k) :

ι → k

Weights for expressing line_map as an affine combination.

Equations

finset.affine_combination_line_map_weights i j c = c • finset.weighted_vsub_vsub_weights k j i + finset.affine_combination_single_weights k i

@[simp]

theorem finset.affine_combination_line_map_weights_self {k : Type u_1} [ring k] {ι : Type u_4} [decidable_eq ι] (i : ι) (c : k) :

finset.affine_combination_line_map_weights i i c = finset.affine_combination_single_weights k i

@[simp]

theorem finset.affine_combination_line_map_weights_apply_left {k : Type u_1} [ring k] {ι : Type u_4} [decidable_eq ι] {i j : ι} (h : i ≠ j) (c : k) :

finset.affine_combination_line_map_weights i j c i = 1 - c

@[simp]

theorem finset.affine_combination_line_map_weights_apply_right {k : Type u_1} [ring k] {ι : Type u_4} [decidable_eq ι] {i j : ι} (h : i ≠ j) (c : k) :

finset.affine_combination_line_map_weights i j c j = c

@[simp]

theorem finset.affine_combination_line_map_weights_apply_of_ne {k : Type u_1} [ring k] {ι : Type u_4} [decidable_eq ι] {i j t : ι} (hi : t ≠ i) (hj : t ≠ j) (c : k) :

finset.affine_combination_line_map_weights i j c t = 0

@[simp]

theorem finset.sum_affine_combination_line_map_weights {k : Type u_1} [ring k] {ι : Type u_4} (s : finset ι) [decidable_eq ι] {i j : ι} (hi : i ∈ s) (hj : j ∈ s) (c : k) :

s.sum (λ (t : ι), finset.affine_combination_line_map_weights i j c t) = 1

@[simp]

theorem finset.affine_combination_affine_combination_single_weights (k : Type u_1) {V : Type u_2} {P : Type u_3} [ring k] [add_comm_group V] [module k V] [S : add_torsor V P] {ι : Type u_4} (s : finset ι) [decidable_eq ι] (p : ι → P) {i : ι} (hi : i ∈ s) :

⇑(finset.affine_combination k s p) (finset.affine_combination_single_weights k i) = p i

An affine combination with affine_combination_single_weights gives the specified point.

@[simp]

theorem finset.weighted_vsub_weighted_vsub_vsub_weights (k : Type u_1) {V : Type u_2} {P : Type u_3} [ring k] [add_comm_group V] [module k V] [S : add_torsor V P] {ι : Type u_4} (s : finset ι) [decidable_eq ι] (p : ι → P) {i j : ι} (hi : i ∈ s) (hj : j ∈ s) :

⇑(s.weighted_vsub p) (finset.weighted_vsub_vsub_weights k i j) = p i -ᵥ p j

A weighted subtraction with weighted_vsub_vsub_weights gives the result of subtracting the specified points.

@[simp]

theorem finset.affine_combination_affine_combination_line_map_weights {k : Type u_1} {V : Type u_2} {P : Type u_3} [ring k] [add_comm_group V] [module k V] [S : add_torsor V P] {ι : Type u_4} (s : finset ι) [decidable_eq ι] (p : ι → P) {i j : ι} (hi : i ∈ s) (hj : j ∈ s) (c : k) :

⇑(finset.affine_combination k s p) (finset.affine_combination_line_map_weights i j c) = ⇑(affine_map.line_map (p i) (p j)) c

An affine combination with affine_combination_line_map_weights gives the result of line_map.

def finset.centroid_weights (k : Type u_1) [division_ring k] {ι : Type u_4} (s : finset ι) :

ι → k

The weights for the centroid of some points.

Equations

finset.centroid_weights k s = function.const ι (↑(s.card))⁻¹

@[simp]

theorem finset.centroid_weights_apply (k : Type u_1) [division_ring k] {ι : Type u_4} (s : finset ι) (i : ι) :

finset.centroid_weights k s i = (↑(s.card))⁻¹

centroid_weights at any point.

theorem finset.centroid_weights_eq_const (k : Type u_1) [division_ring k] {ι : Type u_4} (s : finset ι) :

finset.centroid_weights k s = function.const ι (↑(s.card))⁻¹

centroid_weights equals a constant function.

theorem finset.sum_centroid_weights_eq_one_of_cast_card_ne_zero {k : Type u_1} [division_ring k] {ι : Type u_4} (s : finset ι) (h : ↑(s.card) ≠ 0) :

s.sum (λ (i : ι), finset.centroid_weights k s i) = 1

The weights in the centroid sum to 1, if the number of points, converted to k, is not zero.

theorem finset.sum_centroid_weights_eq_one_of_card_ne_zero (k : Type u_1) [division_ring k] {ι : Type u_4} (s : finset ι) [char_zero k] (h : s.card ≠ 0) :

s.sum (λ (i : ι), finset.centroid_weights k s i) = 1

In the characteristic zero case, the weights in the centroid sum to 1 if the number of points is not zero.

theorem finset.sum_centroid_weights_eq_one_of_nonempty (k : Type u_1) [division_ring k] {ι : Type u_4} (s : finset ι) [char_zero k] (h : s.nonempty) :

s.sum (λ (i : ι), finset.centroid_weights k s i) = 1

In the characteristic zero case, the weights in the centroid sum to 1 if the set is nonempty.

theorem finset.sum_centroid_weights_eq_one_of_card_eq_add_one (k : Type u_1) [division_ring k] {ι : Type u_4} (s : finset ι) [char_zero k] {n : ℕ} (h : s.card = n + 1) :

s.sum (λ (i : ι), finset.centroid_weights k s i) = 1

In the characteristic zero case, the weights in the centroid sum to 1 if the number of points is n + 1.

noncomputable def finset.centroid (k : Type u_1) {V : Type u_2} {P : Type u_3} [division_ring k] [add_comm_group V] [module k V] [add_torsor V P] {ι : Type u_4} (s : finset ι) (p : ι → P) :

P

The centroid of some points. Although defined for any s, this is intended to be used in the case where the number of points, converted to k, is not zero.

Equations

finset.centroid k s p = ⇑(finset.affine_combination k s p) (finset.centroid_weights k s)

theorem finset.centroid_def (k : Type u_1) {V : Type u_2} {P : Type u_3} [division_ring k] [add_comm_group V] [module k V] [add_torsor V P] {ι : Type u_4} (s : finset ι) (p : ι → P) :

finset.centroid k s p = ⇑(finset.affine_combination k s p) (finset.centroid_weights k s)

The definition of the centroid.

theorem finset.centroid_univ (k : Type u_1) {V : Type u_2} {P : Type u_3} [division_ring k] [add_comm_group V] [module k V] [add_torsor V P] (s : finset P) :

finset.centroid k finset.univ coe = finset.centroid k s id

@[simp]

theorem finset.centroid_singleton (k : Type u_1) {V : Type u_2} {P : Type u_3} [division_ring k] [add_comm_group V] [module k V] [add_torsor V P] {ι : Type u_4} (p : ι → P) (i : ι) :

finset.centroid k {i} p = p i

The centroid of a single point.

theorem finset.centroid_pair (k : Type u_1) {V : Type u_2} {P : Type u_3} [division_ring k] [add_comm_group V] [module k V] [add_torsor V P] {ι : Type u_4} [decidable_eq ι] [invertible 2] (p : ι → P) (i₁ i₂ : ι) :

finset.centroid k {i₁, i₂} p = 2⁻¹ • (p i₂ -ᵥ p i₁) +ᵥ p i₁

The centroid of two points, expressed directly as adding a vector to a point.

theorem finset.centroid_pair_fin (k : Type u_1) {V : Type u_2} {P : Type u_3} [division_ring k] [add_comm_group V] [module k V] [add_torsor V P] [invertible 2] (p : fin 2 → P) :

finset.centroid k finset.univ p = 2⁻¹ • (p 1 -ᵥ p 0) +ᵥ p 0

The centroid of two points indexed by fin 2, expressed directly as adding a vector to the first point.

theorem finset.centroid_map (k : Type u_1) {V : Type u_2} {P : Type u_3} [division_ring k] [add_comm_group V] [module k V] [add_torsor V P] {ι : Type u_4} {ι₂ : Type u_5} (s₂ : finset ι₂) (e : ι₂ ↪ ι) (p : ι → P) :

finset.centroid k (finset.map e s₂) p = finset.centroid k s₂ (p ∘ ⇑e)

A centroid, over the image of an embedding, equals a centroid with the same points and weights over the original finset.

noncomputable def finset.centroid_weights_indicator (k : Type u_1) [division_ring k] {ι : Type u_4} (s : finset ι) :

ι → k

centroid_weights gives the weights for the centroid as a constant function, which is suitable when summing over the points whose centroid is being taken. This function gives the weights in a form suitable for summing over a larger set of points, as an indicator function that is zero outside the set whose centroid is being taken. In the case of a fintype, the sum may be over univ.

Equations

finset.centroid_weights_indicator k s = ↑s.indicator (finset.centroid_weights k s)

theorem finset.centroid_weights_indicator_def (k : Type u_1) [division_ring k] {ι : Type u_4} (s : finset ι) :

finset.centroid_weights_indicator k s = ↑s.indicator (finset.centroid_weights k s)

The definition of centroid_weights_indicator.

theorem finset.sum_centroid_weights_indicator (k : Type u_1) [division_ring k] {ι : Type u_4} (s : finset ι) [fintype ι] :

finset.univ.sum (λ (i : ι), finset.centroid_weights_indicator k s i) = s.sum (λ (i : ι), finset.centroid_weights k s i)

The sum of the weights for the centroid indexed by a fintype.

theorem finset.sum_centroid_weights_indicator_eq_one_of_card_ne_zero (k : Type u_1) [division_ring k] {ι : Type u_4} (s : finset ι) [char_zero k] [fintype ι] (h : s.card ≠ 0) :

finset.univ.sum (λ (i : ι), finset.centroid_weights_indicator k s i) = 1

In the characteristic zero case, the weights in the centroid indexed by a fintype sum to 1 if the number of points is not zero.

theorem finset.sum_centroid_weights_indicator_eq_one_of_nonempty (k : Type u_1) [division_ring k] {ι : Type u_4} (s : finset ι) [char_zero k] [fintype ι] (h : s.nonempty) :

finset.univ.sum (λ (i : ι), finset.centroid_weights_indicator k s i) = 1

In the characteristic zero case, the weights in the centroid indexed by a fintype sum to 1 if the set is nonempty.

theorem finset.sum_centroid_weights_indicator_eq_one_of_card_eq_add_one (k : Type u_1) [division_ring k] {ι : Type u_4} (s : finset ι) [char_zero k] [fintype ι] {n : ℕ} (h : s.card = n + 1) :

finset.univ.sum (λ (i : ι), finset.centroid_weights_indicator k s i) = 1

In the characteristic zero case, the weights in the centroid indexed by a fintype sum to 1 if the number of points is n + 1.

theorem finset.centroid_eq_affine_combination_fintype (k : Type u_1) {V : Type u_2} {P : Type u_3} [division_ring k] [add_comm_group V] [module k V] [add_torsor V P] {ι : Type u_4} (s : finset ι) [fintype ι] (p : ι → P) :

finset.centroid k s p = ⇑(finset.affine_combination k finset.univ p) (finset.centroid_weights_indicator k s)

The centroid as an affine combination over a fintype.

theorem finset.centroid_eq_centroid_image_of_inj_on (k : Type u_1) {V : Type u_2} {P : Type u_3} [division_ring k] [add_comm_group V] [module k V] [add_torsor V P] {ι : Type u_4} (s : finset ι) {p : ι → P} (hi : ∀ (i : ι), i ∈ s → ∀ (j : ι), j ∈ s → p i = p j → i = j) {ps : set P} [fintype ↥ps] (hps : ps = p '' ↑s) :

finset.centroid k s p = finset.centroid k finset.univ (λ (x : ↥ps), ↑x)

An indexed family of points that is injective on the given finset has the same centroid as the image of that finset. This is stated in terms of a set equal to the image to provide control of definitional equality for the index type used for the centroid of the image.

theorem finset.centroid_eq_of_inj_on_of_image_eq (k : Type u_1) {V : Type u_2} {P : Type u_3} [division_ring k] [add_comm_group V] [module k V] [add_torsor V P] {ι : Type u_4} (s : finset ι) {ι₂ : Type u_5} (s₂ : finset ι₂) {p : ι → P} (hi : ∀ (i : ι), i ∈ s → ∀ (j : ι), j ∈ s → p i = p j → i = j) {p₂ : ι₂ → P} (hi₂ : ∀ (i : ι₂), i ∈ s₂ → ∀ (j : ι₂), j ∈ s₂ → p₂ i = p₂ j → i = j) (he : p '' ↑s = p₂ '' ↑s₂) :

finset.centroid k s p = finset.centroid k s₂ p₂

Two indexed families of points that are injective on the given finsets and with the same points in the image of those finsets have the same centroid.

theorem weighted_vsub_mem_vector_span {k : Type u_1} {V : Type u_2} {P : Type u_3} [ring k] [add_comm_group V] [module k V] [add_torsor V P] {ι : Type u_4} {s : finset ι} {w : ι → k} (h : s.sum (λ (i : ι), w i) = 0) (p : ι → P) :

⇑(s.weighted_vsub p) w ∈ vector_span k (set.range p)

A weighted_vsub with sum of weights 0 is in the vector_span of an indexed family.

theorem affine_combination_mem_affine_span {k : Type u_1} {V : Type u_2} {P : Type u_3} [ring k] [add_comm_group V] [module k V] [add_torsor V P] {ι : Type u_4} [nontrivial k] {s : finset ι} {w : ι → k} (h : s.sum (λ (i : ι), w i) = 1) (p : ι → P) :

⇑(finset.affine_combination k s p) w ∈ affine_span k (set.range p)

An affine_combination with sum of weights 1 is in the affine_span of an indexed family, if the underlying ring is nontrivial.

theorem mem_vector_span_iff_eq_weighted_vsub (k : Type u_1) {V : Type u_2} {P : Type u_3} [ring k] [add_comm_group V] [module k V] [add_torsor V P] {ι : Type u_4} {v : V} {p : ι → P} :

v ∈ vector_span k (set.range p) ↔ ∃ (s : finset ι) (w : ι → k) (h : s.sum (λ (i : ι), w i) = 0), v = ⇑(s.weighted_vsub p) w

A vector is in the vector_span of an indexed family if and only if it is a weighted_vsub with sum of weights 0.

theorem eq_affine_combination_of_mem_affine_span {k : Type u_1} {V : Type u_2} {P : Type u_3} [ring k] [add_comm_group V] [module k V] [add_torsor V P] {ι : Type u_4} {p1 : P} {p : ι → P} (h : p1 ∈ affine_span k (set.range p)) :

∃ (s : finset ι) (w : ι → k) (hw : s.sum (λ (i : ι), w i) = 1), p1 = ⇑(finset.affine_combination k s p) w

A point in the affine_span of an indexed family is an affine_combination with sum of weights 1. See also eq_affine_combination_of_mem_affine_span_of_fintype.

theorem eq_affine_combination_of_mem_affine_span_of_fintype {k : Type u_1} {V : Type u_2} {P : Type u_3} [ring k] [add_comm_group V] [module k V] [add_torsor V P] {ι : Type u_4} [fintype ι] {p1 : P} {p : ι → P} (h : p1 ∈ affine_span k (set.range p)) :

∃ (w : ι → k) (hw : finset.univ.sum (λ (i : ι), w i) = 1), p1 = ⇑(finset.affine_combination k finset.univ p) w

theorem mem_affine_span_iff_eq_affine_combination (k : Type u_1) (V : Type u_2) {P : Type u_3} [ring k] [add_comm_group V] [module k V] [add_torsor V P] {ι : Type u_4} [nontrivial k] {p1 : P} {p : ι → P} :

p1 ∈ affine_span k (set.range p) ↔ ∃ (s : finset ι) (w : ι → k) (hw : s.sum (λ (i : ι), w i) = 1), p1 = ⇑(finset.affine_combination k s p) w

A point is in the affine_span of an indexed family if and only if it is an affine_combination with sum of weights 1, provided the underlying ring is nontrivial.

theorem mem_affine_span_iff_eq_weighted_vsub_of_point_vadd (k : Type u_1) (V : Type u_2) {P : Type u_3} [ring k] [add_comm_group V] [module k V] [add_torsor V P] {ι : Type u_4} [nontrivial k] (p : ι → P) (j : ι) (q : P) :

q ∈ affine_span k (set.range p) ↔ ∃ (s : finset ι) (w : ι → k), q = ⇑(s.weighted_vsub_of_point p (p j)) w +ᵥ p j

Given a family of points together with a chosen base point in that family, membership of the affine span of this family corresponds to an identity in terms of weighted_vsub_of_point, with weights that are not required to sum to 1.

theorem affine_span_eq_affine_span_line_map_units {k : Type u_1} {V : Type u_2} {P : Type u_3} [ring k] [add_comm_group V] [module k V] [add_torsor V P] [nontrivial k] {s : set P} {p : P} (hp : p ∈ s) (w : ↥s → kˣ) :

affine_span k (set.range (λ (q : ↥s), ⇑(affine_map.line_map p ↑q) ↑(w q))) = affine_span k s

Given a set of points, together with a chosen base point in this set, if we affinely transport all other members of the set along the line joining them to this base point, the affine span is unchanged.

theorem centroid_mem_affine_span_of_cast_card_ne_zero {k : Type u_1} {V : Type u_2} {P : Type u_3} [division_ring k] [add_comm_group V] [module k V] [add_torsor V P] {ι : Type u_4} {s : finset ι} (p : ι → P) (h : ↑(s.card) ≠ 0) :

finset.centroid k s p ∈ affine_span k (set.range p)

The centroid lies in the affine span if the number of points, converted to k, is not zero.

theorem centroid_mem_affine_span_of_card_ne_zero (k : Type u_1) {V : Type u_2} {P : Type u_3} [division_ring k] [add_comm_group V] [module k V] [add_torsor V P] {ι : Type u_4} [char_zero k] {s : finset ι} (p : ι → P) (h : s.card ≠ 0) :

finset.centroid k s p ∈ affine_span k (set.range p)

In the characteristic zero case, the centroid lies in the affine span if the number of points is not zero.

theorem centroid_mem_affine_span_of_nonempty (k : Type u_1) {V : Type u_2} {P : Type u_3} [division_ring k] [add_comm_group V] [module k V] [add_torsor V P] {ι : Type u_4} [char_zero k] {s : finset ι} (p : ι → P) (h : s.nonempty) :

finset.centroid k s p ∈ affine_span k (set.range p)

In the characteristic zero case, the centroid lies in the affine span if the set is nonempty.

theorem centroid_mem_affine_span_of_card_eq_add_one (k : Type u_1) {V : Type u_2} {P : Type u_3} [division_ring k] [add_comm_group V] [module k V] [add_torsor V P] {ι : Type u_4} [char_zero k] {s : finset ι} (p : ι → P) {n : ℕ} (h : s.card = n + 1) :

finset.centroid k s p ∈ affine_span k (set.range p)

In the characteristic zero case, the centroid lies in the affine span if the number of points is n + 1.

def affine_map.weighted_vsub_of_point {k : Type u_1} {V : Type u_2} (P : Type u_3) [comm_ring k] [add_comm_group V] [module k V] [add_torsor V P] {ι : Type u_4} (s : finset ι) (w : ι → k) :

(ι → P) × P →ᵃ[k] V

A weighted sum, as an affine map on the points involved.

Equations

affine_map.weighted_vsub_of_point P s w = {to_fun := λ (p : (ι → P) × P), ⇑(s.weighted_vsub_of_point p.fst p.snd) w, linear := s.sum (λ (i : ι), w i • ((linear_map.proj i).comp (linear_map.fst k (ι → V) V) - linear_map.snd k (ι → V) V)), map_vadd' := _}