Download data/lean/OAI/MeasureTheory/CompactFactors/Amenability.lean from introvoyz045/math: direct link, hf CLI and curl.
- Browser
- Download file 18 kB
-
https://huggingface.co/datasets/introvoyz045/math/resolve/main/data/lean/OAI/MeasureTheory/CompactFactors/Amenability.lean
- Command line
-
hf download hf://datasets/introvoyz045/math/data/lean/OAI/MeasureTheory/CompactFactors/Amenability.lean
-
curl -L -o Amenability.lean https://huggingface.co/datasets/introvoyz045/math/resolve/main/data/lean/OAI/MeasureTheory/CompactFactors/Amenability.lean
18 kB
| import Mathlib | |
| namespace OAI | |
| noncomputable section | |
| open MeasureTheory Filter | |
| open scoped ENNReal NNReal | |
| open scoped RealInnerProductSpace BoundedContinuousFunction | |
| namespace EuclideanFiveColor.Amenable | |
| variable (G : Type*) [AddCommGroup G] [TopologicalSpace G] [DiscreteTopology G] | |
| def shift {E : Type*} [PseudoMetricSpace E] (g : G) (f : G āįµ E) : G āįµ E := | |
| f.compContinuous āØfun x => x + g, continuous_of_discreteTopologyā© | |
| @[simp] lemma shift_apply {E : Type*} [PseudoMetricSpace E] (g x : G) (f : G āįµ E) : | |
| shift G g f x = f (x+g) := rfl | |
| /-- A normalized positive translation-invariant real functional. -/ | |
| structure Mean where | |
| map : (G āįµ ā) āL[ā] ā | |
| map_const : ā c, map (BoundedContinuousFunction.const G c) = c | |
| positive : ā f, (ā x, 0 ⤠f x) ā 0 ⤠map f | |
| invariant : ā g f, map (shift G g f) = map f | |
| variable {G} | |
| namespace Mean | |
| variable (M : Mean G) | |
| lemma mono (f h : G āįµ ā) (hf : ā x, f x ⤠h x) : M.map f ⤠M.map h := by | |
| have hm := M.positive (h-f) (fun x => sub_nonneg.mpr (hf x)) | |
| simpa only [map_sub, sub_nonneg] using hm | |
| lemma abs_le (f h : G āįµ ā) (hf : ā x, |f x| ⤠h x) : |M.map f| ⤠M.map h := by | |
| rw [_root_.abs_le] | |
| constructor | |
| Ā· have := M.mono (-h) f (fun x => (_root_.abs_le.mp (hf x)).1) | |
| simpa only [map_neg] using this | |
| Ā· exact M.mono f h fun x => (_root_.abs_le.mp (hf x)).2 | |
| lemma exists_lt {f : G āįµ ā} {ε : ā} (h : M.map f < ε) : ā g, f g < ε := by | |
| by_contra hn | |
| push Not at hn | |
| have := M.mono (BoundedContinuousFunction.const G ε) f hn | |
| rw [M.map_const] at this | |
| exact (not_lt_of_ge this) h | |
| variable {H : Type*} [NormedAddCommGroup H] [InnerProductSpace ā H] [CompleteSpace H] | |
| def normFn (V : G āįµ H) : G āįµ ā := | |
| BoundedContinuousFunction.ofNormedAddCommGroup (fun x => āV xā) | |
| (continuous_norm.comp V.continuous) āVā (fun x => by simpa using V.norm_coe_le_norm x) | |
| omit [AddCommGroup G] [DiscreteTopology G] [InnerProductSpace ā H] [CompleteSpace H] in | |
| @[simp] lemma normFn_apply (V : G āįµ H) (x : G) : normFn V x = āV xā := rfl | |
| def pairing (V : G āįµ H) (v : H) : G āįµ ā := | |
| BoundedContinuousFunction.ofNormedAddCommGroup (fun x => inner ā (V x) v) | |
| (V.continuous.inner continuous_const) (āVā * āvā) | |
| (fun x => (norm_inner_le_norm _ _).trans (mul_le_mul_of_nonneg_right (V.norm_coe_le_norm x) (norm_nonneg v))) | |
| omit [AddCommGroup G] [DiscreteTopology G] [CompleteSpace H] in | |
| @[simp] lemma pairing_apply (V : G āįµ H) (v : H) (x : G) : pairing V v x = inner ā (V x) v := rfl | |
| omit [CompleteSpace H] in | |
| lemma pairing_bound (V : G āįµ H) (v : H) : | |
| |M.map (pairing V v)| ⤠M.map (normFn V) * āvā := by | |
| have he : M.map (āvā ⢠normFn V) = M.map (normFn V) * āvā := by | |
| rw [map_smul]; simp [mul_comm] | |
| rw [ā he] | |
| apply M.abs_le | |
| intro x | |
| simpa [mul_comm] using (norm_inner_le_norm (š := ā) (V x) v) | |
| def pairingMap (V : G āįµ H) : H āL[ā] ā := | |
| LinearMap.mkContinuous | |
| { toFun := fun v => M.map (pairing V v) | |
| map_add' := by | |
| intro v w | |
| have he : pairing V (v+w) = pairing V v + pairing V w := by ext; simp [inner_add_right] | |
| rw [he, map_add] | |
| map_smul' := by | |
| intro c v | |
| have he : pairing V (c ⢠v) = c ⢠pairing V v := by ext; simp [inner_smul_right] | |
| rw [he, map_smul]; rfl } | |
| (M.map (normFn V)) (fun v => M.pairing_bound V v) | |
| def vector (V : G āįµ H) : H := (InnerProductSpace.toDual ā H).symm (M.pairingMap V) | |
| lemma vector_pair (V : G āįµ H) (v : H) : | |
| inner ā (M.vector V) v = M.map (pairing V v) := InnerProductSpace.toDual_symm_apply | |
| lemma vector_norm_le (V : G āįµ H) : āM.vector Vā ⤠M.map (normFn V) := by | |
| rw [vector, LinearIsometryEquiv.norm_map] | |
| apply (M.pairingMap V).opNorm_le_bound (M.positive _ (fun x => by simp)) | |
| exact M.pairing_bound V | |
| lemma vector_add (V W : G āįµ H) : M.vector (V+W) = M.vector V + M.vector W := by | |
| apply ext_inner_right ā; intro v | |
| rw [inner_add_left, M.vector_pair, M.vector_pair, M.vector_pair] | |
| have he : pairing (V+W) v = pairing V v + pairing W v := by ext; simp [inner_add_left] | |
| rw [he, map_add] | |
| lemma vector_smul (c : ā) (V : G āįµ H) : M.vector (c ⢠V) = c ⢠M.vector V := by | |
| apply ext_inner_right ā; intro v | |
| rw [real_inner_smul_left, M.vector_pair, M.vector_pair] | |
| have he : pairing (c ⢠V) v = c ⢠pairing V v := by ext; simp [real_inner_smul_left] | |
| rw [he, map_smul]; rfl | |
| lemma vector_shift (V : G āįµ H) (g : G) : M.vector (shift G g V) = M.vector V := by | |
| apply ext_inner_right ā; intro v | |
| rw [M.vector_pair, M.vector_pair] | |
| exact M.invariant g (pairing V v) | |
| lemma vector_map {J : Type*} [NormedAddCommGroup J] [InnerProductSpace ā J] [CompleteSpace J] | |
| (L : H āL[ā] J) (V : G āįµ H) : | |
| M.vector (L.compLeftContinuousBounded G V) = L (M.vector V) := by | |
| apply ext_inner_right ā; intro v | |
| rw [M.vector_pair, ā L.adjoint_inner_right, M.vector_pair] | |
| congr 1; ext x | |
| exact (L.adjoint_inner_right (V x) v).symm | |
| def squareNorm (V : G āįµ H) : G āįµ ā := normFn V * normFn V | |
| omit [AddCommGroup G] [DiscreteTopology G] [InnerProductSpace ā H] [CompleteSpace H] in | |
| @[simp] lemma squareNorm_apply (V : G āįµ H) (x : G) : squareNorm V x = āV xā^2 := by | |
| simp [squareNorm, pow_two] | |
| lemma jensen (V : G āįµ H) : āM.vector Vā^2 ⤠M.map (squareNorm V) := by | |
| let c := M.vector V | |
| have he : squareNorm (V - BoundedContinuousFunction.const G c) = | |
| squareNorm V - (2 : ā) ⢠pairing V c + BoundedContinuousFunction.const G (ācā^2) := by | |
| ext x | |
| simp only [squareNorm_apply, BoundedContinuousFunction.sub_apply, BoundedContinuousFunction.const_apply, | |
| BoundedContinuousFunction.add_apply, BoundedContinuousFunction.smul_apply, pairing_apply, smul_eq_mul] | |
| rw [norm_sub_sq_real] | |
| have hp := M.positive (squareNorm (V - BoundedContinuousFunction.const G c)) (fun x => by | |
| rw [squareNorm_apply]; positivity) | |
| rw [he, map_add, map_sub, map_smul, M.map_const, ā M.vector_pair] at hp | |
| change 0 ⤠M.map (squareNorm V) - 2 * inner ā c c + ācā^2 at hp | |
| rw [real_inner_self_eq_norm_sq] at hp | |
| dsimp [c] at hp | |
| linarith | |
| end Mean | |
| end EuclideanFiveColor.Amenable | |
| namespace EuclideanFiveColor.Amenable.Mean | |
| section | |
| open scoped BoundedContinuousFunction | |
| variable {G : Type*} [AddCommGroup G] [TopologicalSpace G] [DiscreteTopology G] | |
| variable (M : Mean G) | |
| variable {H : Type*} [NormedAddCommGroup H] [InnerProductSpace ā H] [CompleteSpace H] | |
| def cross (V W : G āįµ H) : G āįµ ā := | |
| BoundedContinuousFunction.ofNormedAddCommGroup (fun x => inner ā (V x) (W x)) | |
| (V.continuous.inner W.continuous) (āVā * āWā) (fun x => by | |
| exact (norm_inner_le_norm (š := ā) _ _).trans | |
| (mul_le_mul (V.norm_coe_le_norm x) (W.norm_coe_le_norm x) (norm_nonneg _) (norm_nonneg _))) | |
| omit [AddCommGroup G] [DiscreteTopology G] [CompleteSpace H] in | |
| @[simp] lemma cross_apply (V W : G āįµ H) (x : G) : cross V W x = inner ā (V x) (W x) := rfl | |
| omit [AddCommGroup G] [DiscreteTopology G] [CompleteSpace H] in | |
| lemma cross_comm (V W : G āįµ H) : cross V W = cross W V := by | |
| ext x; exact real_inner_comm _ _ | |
| omit [AddCommGroup G] [DiscreteTopology G] [CompleteSpace H] in | |
| lemma squareNorm_add (V W : G āįµ H) : | |
| squareNorm (V+W) = squareNorm V + squareNorm W + (2 : ā) ⢠cross V W := by | |
| ext x | |
| simp only [squareNorm_apply, BoundedContinuousFunction.add_apply, | |
| BoundedContinuousFunction.smul_apply, cross_apply, smul_eq_mul] | |
| rw [norm_add_sq_real]; ring | |
| omit [InnerProductSpace ā H] [CompleteSpace H] in | |
| lemma squareNorm_shift (V : G āįµ H) (g : G) : | |
| M.map (squareNorm (shift G g V)) = M.map (squareNorm V) := | |
| M.invariant g (squareNorm V) | |
| def correlation (V W : G āįµ H) : G āįµ ā := | |
| BoundedContinuousFunction.ofNormedAddCommGroup | |
| (fun g => M.map (cross (shift G g V) W)) continuous_of_discreteTopology | |
| (āVā * āWā) (fun g => by | |
| rw [Real.norm_eq_abs, ā M.map_const (āVā * āWā)] | |
| apply M.abs_le | |
| intro x | |
| exact (norm_inner_le_norm (š := ā) _ _).trans | |
| (mul_le_mul (V.norm_coe_le_norm (x+g)) (W.norm_coe_le_norm x) (norm_nonneg _) (norm_nonneg _))) | |
| omit [CompleteSpace H] in | |
| @[simp] lemma correlation_apply (V W : G āįµ H) (g : G) : | |
| M.correlation V W g = M.map (cross (shift G g V) W) := rfl | |
| omit [CompleteSpace H] in | |
| lemma correlation_add (V W Z : G āįµ H) : | |
| M.correlation V (W+Z) = M.correlation V W + M.correlation V Z := by | |
| ext g | |
| simp only [correlation_apply, BoundedContinuousFunction.add_apply] | |
| rw [ā map_add] | |
| congr 1; ext x | |
| simp only [cross_apply, BoundedContinuousFunction.add_apply, inner_add_right] | |
| omit [CompleteSpace H] in | |
| lemma correlation_zero (V : G āįµ H) : M.correlation V 0 = 0 := by | |
| ext g | |
| change M.map (cross (shift G g V) (0 : G āįµ H)) = 0 | |
| have he : cross (shift G g V) (0 : G āįµ H) = 0 := by ext; simp | |
| rw [he, map_zero] | |
| omit [CompleteSpace H] in | |
| lemma correlation_shift (V W : G āįµ H) (g : G) : | |
| M.correlation V (shift G g W) = shift G (-g) (M.correlation V W) := by | |
| ext h | |
| change M.map (cross (shift G h V) (shift G g W)) = | |
| M.map (cross (shift G (h+-g) V) W) | |
| rw [ā M.invariant (-g) (cross (shift G h V) (shift G g W))] | |
| congr 1; ext x | |
| simp only [shift_apply, cross_apply] | |
| congr 2 <;> abel | |
| /-- Invariant-mean van der Corput: positivity and finite translates suffice. | |
| There is no exchange of iterated means. -/ | |
| theorem vector_eq_zero_of_correlation_nonpos (V : G āįµ H) | |
| (hc : M.map (M.correlation V V) ⤠0) : M.vector V = 0 := by | |
| classical | |
| let C : ā := M.map (squareNorm V) + 2 | |
| have hC : 0 < C := by | |
| have := M.positive (squareNorm V) (fun x => by rw [squareNorm_apply]; positivity) | |
| dsimp [C]; linarith | |
| have hW (n : ā) : ā W : G āįµ H, M.vector W = (n : ā) ⢠M.vector V ā§ | |
| M.map (M.correlation V W) ⤠0 ā§ M.map (squareNorm W) ⤠(n : ā)*C := by | |
| induction n with | |
| | zero => | |
| refine āØ0, ?_, ?_, ?_ā© | |
| Ā· have he : M.vector (0 : G āįµ H) = 0 := by | |
| apply ext_inner_right ā; intro v | |
| rw [M.vector_pair, inner_zero_left] | |
| have he : pairing (0 : G āįµ H) v = 0 := by ext; simp | |
| rw [he, map_zero] | |
| simpa using he | |
| Ā· simp [M.correlation_zero] | |
| Ā· have he : squareNorm (0 : G āįµ H) = 0 := by ext; simp | |
| simp [he] | |
| | succ n ih => | |
| obtain āØW, hv, hwc, hweā© := ih | |
| obtain āØg, hgā© := M.exists_lt (lt_of_le_of_lt hwc zero_lt_one) | |
| refine āØW+shift G g V, ?_, ?_, ?_ā© | |
| Ā· rw [M.vector_add, M.vector_shift, hv] | |
| simp [Nat.cast_add, add_smul] | |
| Ā· rw [M.correlation_add, map_add, M.correlation_shift, M.invariant] | |
| linarith | |
| Ā· rw [squareNorm_add, map_add, map_add, map_smul, M.squareNorm_shift, | |
| cross_comm W _, ā M.correlation_apply V W g] | |
| have hn : ((n+1 : ā) : ā) = (n : ā)+1 := by simp | |
| rw [hn] | |
| dsimp [C] at * | |
| change M.map (squareNorm W) + M.map (squareNorm V) + 2 * M.correlation V W g ⤠| |
| ((n : ā)+1) * (M.map (squareNorm V) + 2) | |
| change M.correlation V W g < 1 at hg | |
| nlinarith | |
| have hn (n : ā) (hp : 0 < n) : (n : ā) * āM.vector Vā^2 ⤠C := by | |
| obtain āØW, hw, _, heā© := hW n | |
| have hj := (M.jensen W).trans he | |
| rw [hw, norm_smul, Real.norm_natCast] at hj | |
| have hnr : 0 < (n : ā) := by exact_mod_cast hp | |
| apply (mul_le_mul_iff_rightā hnr).mp | |
| nlinarith | |
| by_contra hv | |
| have hnorm : 0 < āM.vector Vā^2 := sq_pos_of_pos (norm_pos_iff.mpr hv) | |
| obtain āØn, hn'ā© := exists_nat_gt (max 0 (C / āM.vector Vā^2)) | |
| have hn0 : 0 < n := by exact_mod_cast (lt_of_le_of_lt (le_max_left _ _) hn') | |
| have hratio := lt_of_le_of_lt (le_max_right _ _) hn' | |
| have hbad := (div_lt_iffā hnorm).mp hratio | |
| have hgood := hn n hn0 | |
| linarith | |
| end | |
| open scoped BoundedContinuousFunction | |
| variable {G : Type*} [AddCommGroup G] [TopologicalSpace G] [DiscreteTopology G] | |
| variable (M : Mean G) | |
| variable {H : Type*} [NormedAddCommGroup H] [InnerProductSpace ā H] [CompleteSpace H] | |
| def orbit (U : G ā H āāįµ¢[ā] H) (v : H) : G āįµ H := | |
| BoundedContinuousFunction.ofNormedAddCommGroup (fun g => U g v) | |
| continuous_of_discreteTopology āvā (fun g => le_of_eq ((U g).norm_map v)) | |
| omit [AddCommGroup G] [CompleteSpace H] in | |
| @[simp] lemma orbit_apply (U : G ā H āāįµ¢[ā] H) (v : H) (g : G) : orbit U v g = U g v := rfl | |
| lemma vector_orbit_invariant (U : G ā H āāįµ¢[ā] H) | |
| (hU : ā g h v, U (g+h) v = U g (U h v)) (v : H) (g : G) : | |
| U g (M.vector (orbit U v)) = M.vector (orbit U v) := by | |
| change (U g).toLinearIsometry.toContinuousLinearMap (M.vector (orbit U v)) = _ | |
| rw [ā M.vector_map (U g).toLinearIsometry.toContinuousLinearMap] | |
| have he : (U g).toLinearIsometry.toContinuousLinearMap.compLeftContinuousBounded G (orbit U v) = | |
| shift G g (orbit U v) := by | |
| ext h | |
| change U g (U h v) = U (h+g) v | |
| rw [add_comm h g, hU] | |
| rw [he, M.vector_shift] | |
| lemma vector_orbit_pair_fixed (U : G ā H āāįµ¢[ā] H) (v w : H) | |
| (hw : ā g, U g w = w) : inner ā (M.vector (orbit U v)) w = inner ā v w := by | |
| rw [M.vector_pair] | |
| have he : pairing (orbit U v) w = BoundedContinuousFunction.const G (inner ā v w) := by | |
| ext g | |
| change inner ā (U g v) w = inner ā v w | |
| calc | |
| inner ā (U g v) w = inner ā (U g v) (U g w) := by rw [hw g] | |
| _ = inner ā v w := (U g).inner_map_map v w | |
| rw [he, M.map_const] | |
| /-- The mean ergodic projection criterion, valid for every positive invariant | |
| mean and without an assumption that the group has a distinguished generator. -/ | |
| theorem vector_orbit_eq_zero (U : G ā H āāįµ¢[ā] H) | |
| (hU : ā g h v, U (g+h) v = U g (U h v)) (v : H) | |
| (hv : ā w, (ā g, U g w = w) ā inner ā v w = 0) : | |
| M.vector (orbit U v) = 0 := by | |
| have hf := M.vector_orbit_invariant U hU v | |
| have hi := M.vector_orbit_pair_fixed U v (M.vector (orbit U v)) hf | |
| rw [hv _ hf] at hi | |
| exact inner_self_eq_zero.mp hi | |
| end EuclideanFiveColor.Amenable.Mean | |
| namespace EuclideanFiveColor.Amenable.Koopman | |
| open MeasureTheory Filter | |
| section Action | |
| variable {G X E : Type*} [AddCommGroup G] [MeasurableSpace X] | |
| [AddAction G X] [MeasurableConstVAdd G X] (μ : Measure X) | |
| [VAddInvariantMeasure G X μ] | |
| [NormedAddCommGroup E] [InnerProductSpace ā E] | |
| def linear (g : G) : Lp E 2 μ āāįµ¢[ā] Lp E 2 μ := | |
| Lp.compMeasurePreservingāįµ¢ ā (fun x => g +ᵄ x) (measurePreserving_vadd g μ) | |
| lemma linear_add (g h : G) (f : Lp E 2 μ) : | |
| linear μ (g+h) f = linear μ g (linear μ h f) := by | |
| change Lp.compMeasurePreserving (fun x => (g+h) +ᵄ x) _ f = | |
| Lp.compMeasurePreserving (fun x => g +ᵄ x) _ | |
| (Lp.compMeasurePreserving (fun x => h +ᵄ x) _ f) | |
| have he : (fun x : X => (g+h) +ᵄ x) = | |
| (fun x => h +ᵄ x) ā (fun x => g +ᵄ x) := by | |
| funext x | |
| simp only [Function.comp_apply, ā add_vadd, add_comm] | |
| simpa only [he] using Lp.compMeasurePreserving_comp_apply f | |
| (measurePreserving_vadd h μ) (measurePreserving_vadd g μ) | |
| @[simp] lemma linear_zero (f : Lp E 2 μ) : linear μ (0 : G) f = f := by | |
| change Lp.compMeasurePreserving (fun x => (0 : G) +ᵄ x) _ f = f | |
| have he : (fun x : X => (0 : G) +ᵄ x) = id := funext (fun x => zero_vadd G x) | |
| simpa only [he] using Lp.compMeasurePreserving_id_apply f | |
| def action (g : G) : Lp E 2 μ āāįµ¢[ā] Lp E 2 μ := | |
| LinearIsometryEquiv.ofSurjective (linear μ g) (fun f => | |
| āØlinear μ (-g) f, by rw [ā linear_add, add_neg_cancel, linear_zero]ā©) | |
| @[simp] lemma action_apply (g : G) (f : Lp E 2 μ) : action μ g f = linear μ g f := rfl | |
| lemma action_add (g h : G) (f : Lp E 2 μ) : | |
| action μ (g+h) f = action μ g (action μ h f) := linear_add μ g h f | |
| lemma coe_action (g : G) (f : Lp E 2 μ) : | |
| action μ g f =įµ[μ] (fun x => f (g +ᵄ x)) := | |
| Lp.coeFn_compMeasurePreserving f (measurePreserving_vadd g μ) | |
| end Action | |
| variable {G X E : Type*} [AddCommGroup G] [MeasurableSpace X] | |
| [AddAction G X] [MeasurableConstVAdd G X] (μ : Measure X) | |
| [IsProbabilityMeasure μ] [ErgodicVAdd G X μ] | |
| [NormedAddCommGroup E] [InnerProductSpace ā E] [CompleteSpace E] | |
| [MeasurableSpace E] [BorelSpace E] [MeasurableSpace.CountablySeparated E] | |
| omit [IsProbabilityMeasure μ] [CompleteSpace E] in | |
| lemma ae_eq_const_of_fixed (f : Lp E 2 μ) | |
| (hf : ā g : G, action μ g f = f) : ā c : E, f =įµ[μ] fun _ => c := by | |
| apply exists_eventuallyEq_const_of_forall_separating MeasurableSet | |
| intro A hA | |
| have := ErgodicVAdd.aeconst_of_forall_preimage_vadd_ae_eq (G := G) | |
| ((Lp.stronglyMeasurable f).measurable hA) (fun g => by | |
| have ha := coe_action μ g f | |
| rw [hf g] at ha | |
| exact ha.symm.mono (fun x hx => | |
| propext (show f (g +ᵄ x) ā A ā f x ā A by change f (g +ᵄ x) = f x at hx; rw [hx]))) | |
| exact eventuallyEmptyOrUniv_iff.mp this | |
| lemma inner_fixed_zero (v : Lp E 2 μ) | |
| (hv : ā« x, v x āμ = 0) (w : Lp E 2 μ) (hw : ā g : G, action μ g w = w) : | |
| inner ā v w = 0 := by | |
| obtain āØc, hcā© := ae_eq_const_of_fixed (G := G) μ w hw | |
| rw [L2.inner_def] | |
| calc | |
| (ā« x, inner ā (v x) (w x) āμ) = ā« x, inner ā c (v x) āμ := | |
| integral_congr_ae (hc.mono (fun x hx => by dsimp only at hx ā¢; rw [hx, real_inner_comm])) | |
| _ = inner ā c (ā« x, v x āμ) := integral_inner ((Lp.memLp v).integrable (by norm_num)) c | |
| _ = 0 := by rw [hv, inner_zero_right] | |
| variable [TopologicalSpace G] [DiscreteTopology G] | |
| theorem vector_orbit_zero (M : Mean G) (v : Lp E 2 μ) | |
| (hv : ā« x, v x āμ = 0) : M.vector (H := Lp E 2 μ) (Mean.orbit (action (G := G) (E := E) μ) v) = 0 := | |
| by | |
| apply M.vector_orbit_eq_zero (H := Lp E 2 μ) (action (G := G) (E := E) μ) | |
| (action_add (G := G) (E := E) μ) v | |
| exact inner_fixed_zero (G := G) (E := E) μ v hv | |
| end EuclideanFiveColor.Amenable.Koopman | |
| end | |
| end OAI | |