| import OAI.Analysis.BackwardIntertwiners.PolarDiagonals |
|
|
| namespace OAI |
|
|
| namespace BackwardIntertwiners |
| open Filter |
| open scoped Topology |
| noncomputable section |
|
|
| open Topology MeasureTheory Set |
| open scoped ENNReal |
|
|
| open scoped Classical |
|
|
| universe u |
| variable {H : Type u} [NormedAddCommGroup H] [InnerProductSpace ℂ H] [CompleteSpace H] |
|
|
|
|
| def polarAlgebra : StarSubalgebra ℂ (GlobalHilbert →L[ℂ] GlobalHilbert) := strongGenerated (Set.range polarDiagonal) |
| lemma polarDiagonal_mem (n : ℤ) : polarDiagonal n ∈ polarAlgebra := subset_strongGenerated _ ⟨n,rfl⟩ |
| lemma polarAlgebra_closed : StronglyClosed polarAlgebra := strongGenerated_closed _ |
| lemma polarAlgebra_le_full : polarAlgebra ≤ fullMultiplierAlgebra := by |
| apply strongGenerated_le fullMultiplier_stronglyClosed |
| rintro _ ⟨n,rfl⟩ |
| exact ⟨betaSymbol n,rfl⟩ |
| lemma polarAlgebra_commutative {A B : GlobalHilbert →L[ℂ] GlobalHilbert} |
| (hA : A ∈ polarAlgebra) (hB : B ∈ polarAlgebra) : A*B=B*A := |
| fullMultiplier_commute (polarAlgebra_le_full hA) (polarAlgebra_le_full hB) |
|
|
| lemma halfExponent_eq_ten_iff (t : ℕ → ℕ) (k : ℕ) : halfExponent t k=10 ↔ k=0 := by |
| constructor |
| · intro h |
| have hl := halfExponent_lower t k |
| rw [h] at hl |
| have hk : (k:ℝ)=0 := by have := Nat.cast_nonneg (α:=ℝ) k; nlinarith |
| exact_mod_cast hk |
| · rintro rfl |
| simp [halfExponent,residueCorrection] |
| lemma explicitBeta_central (x : Base) (j : ℤ) : explicitBeta x j=Real.exp (-10) ↔ j=-1 ∨ j=0 := by |
| have hh (t : ℕ → ℕ) (k : ℕ) : Real.exp (-halfExponent t k)=Real.exp (-10) ↔ k=0 := by |
| rw [Real.exp_eq_exp,neg_inj,halfExponent_eq_ten_iff] |
| cases j with |
| | ofNat k => |
| change Real.exp (-halfExponent (plusResidue x) k)=Real.exp (-10) ↔ _ |
| rw [hh] |
| change k=0 ↔ (k:ℤ) = -1 ∨ (k:ℤ) = 0 |
| omega |
| | negSucc k => |
| change Real.exp (-halfExponent (minusResidue x) k)=Real.exp (-10) ↔ _ |
| rw [hh] |
| omega |
| lemma sliceProjection_central (r : ℤ) : sliceProjection r= |
| levelProjection (-r-1) (Real.exp (-10)) * levelProjection (-r) (Real.exp (-10)) := by |
| rw [sliceProjection_diagonal,levelProjection,levelProjection,diagonalProjection_mul] |
| apply diagonalProjection_ext |
| intro j |
| apply EventuallyEq.of_eq |
| ext x |
| change (x ∈ if j=r then Set.univ else ∅) ↔ |
| (explicitBeta x (j+(-r-1))=Real.exp (-10) ∧ explicitBeta x (j+-r)=Real.exp (-10)) |
| simp only [explicitBeta_central] |
| by_cases hj : j=r <;> simp [hj] <;> omega |
| lemma sliceProjection_mem_polar (r : ℤ) : sliceProjection r ∈ polarAlgebra := by |
| rw [sliceProjection_central] |
| exact polarAlgebra.mul_mem |
| (levelProjection_mem_all polarAlgebra_closed _ _ (polarDiagonal_mem _)) |
| (levelProjection_mem_all polarAlgebra_closed _ _ (polarDiagonal_mem _)) |
|
|
|
|
| def rectangleProjection (r : ℤ) (E : Set Base) (hE : MeasurableSet E) : GlobalHilbert →L[ℂ] GlobalHilbert := |
| diagonalProjection (fun j => if j=r then E else ∅) (fun j => by split_ifs; exact hE; exact MeasurableSet.empty) |
| lemma rectangleProjection_univ (r : ℤ) : rectangleProjection r Set.univ MeasurableSet.univ=sliceProjection r := |
| (sliceProjection_diagonal r).symm |
| lemma rectangleProjection_empty (r : ℤ) : rectangleProjection r ∅ MeasurableSet.empty=0 := by |
| unfold rectangleProjection |
| convert diagonalProjection_empty using 2 |
| ext j x |
| simp |
| lemma rectangleProjection_ext {r : ℤ} {E F : Set Base} {hE : MeasurableSet E} {hF : MeasurableSet F} |
| (he : E=ᵐ[baseMeasure] F) : rectangleProjection r E hE=rectangleProjection r F hF := by |
| apply diagonalProjection_ext |
| intro j |
| by_cases hj : j=r <;> simp only [hj,↓reduceIte] |
| · exact he |
| · exact Filter.EventuallyEq.rfl |
| lemma rectangleProjection_mul (r : ℤ) (E F : Set Base) (hE : MeasurableSet E) (hF : MeasurableSet F) : |
| rectangleProjection r E hE * rectangleProjection r F hF=rectangleProjection r (E∩F) (hE.inter hF) := by |
| rw [rectangleProjection,rectangleProjection,diagonalProjection_mul] |
| apply diagonalProjection_ext |
| intro j |
| apply EventuallyEq.of_eq |
| by_cases hj : j=r <;> simp only [hj,↓reduceIte,Set.inter_empty] |
| lemma rectangleProjection_compl (r : ℤ) (E : Set Base) (hE : MeasurableSet E) : |
| rectangleProjection r Eᶜ hE.compl = sliceProjection r - rectangleProjection r E hE := by |
| rw [sliceProjection_diagonal] |
| change diagonalRepresentation _ = diagonalRepresentation _ - diagonalRepresentation _ |
| rw [←map_sub] |
| congr 1 |
| apply Subtype.ext |
| funext x j |
| change projectionSymbol _ _ x j = projectionSymbol _ _ x j - projectionSymbol _ _ x j |
| by_cases hj : j=r <;> by_cases he : x∈E <;> simp [hj,he] |
| lemma rectangleProjection_union (r : ℤ) (E F : Set Base) (hE : MeasurableSet E) (hF : MeasurableSet F) : |
| rectangleProjection r (E∪F) (hE.union hF) = rectangleProjection r E hE+rectangleProjection r F hF- |
| rectangleProjection r E hE * rectangleProjection r F hF := by |
| change diagonalRepresentation _ = diagonalRepresentation _+diagonalRepresentation _-diagonalRepresentation _*diagonalRepresentation _ |
| rw [←map_mul,←map_add,←map_sub] |
| congr 1 |
| apply Subtype.ext |
| funext x j |
| change projectionSymbol _ _ x j = projectionSymbol _ _ x j + projectionSymbol _ _ x j - projectionSymbol _ _ x j * projectionSymbol _ _ x j |
| by_cases hj : j=r <;> by_cases he : x∈E <;> by_cases hf : x∈F <;> simp [hj,he,hf] |
|
|
| def blockAnchor (m : ℕ) : ℕ := 8^(m-1) |
| lemma blockAnchor_ne_zero (m : ℕ) : blockAnchor m ≠ 0 := pow_ne_zero _ (by norm_num) |
| lemma blockAnchor_block {m : ℕ} (hm : 1 ≤ m) : weightBlock (blockAnchor m)=m := by |
| rw [weightBlock,blockAnchor,Nat.log_pow (by norm_num : 1<8)] |
| omega |
| def residueEigenvalue (m t : ℕ) : ℝ := |
| Real.exp (-(10*((blockAnchor m:ℝ)+1)+100*((2^m:ℝ)-2+(t:ℝ)))) |
| lemma beta_anchor_residue {m : ℕ} (hm : 1 ≤ m) (t : ℕ) (x : Base) : |
| explicitBeta x (blockAnchor m) = residueEigenvalue m t ↔ residue m x=t := by |
| change Real.exp (-halfExponent (plusResidue x) (blockAnchor m))=residueEigenvalue m t ↔ _ |
| rw [residueEigenvalue,Real.exp_eq_exp,neg_inj] |
| simp only [halfExponent,residueCorrection,blockAnchor_ne_zero,↓reduceIte, |
| residueScale,blockAnchor_block hm,plusResidue] |
| push_cast |
| constructor |
| · intro h |
| have he : (residue m x:ℝ)=(t:ℝ) := by linarith |
| exact_mod_cast he |
| · intro h |
| rw [h] |
| lemma residue_rectangle_spectral {m : ℕ} (hm : 1 ≤ m) (t : ℕ) (r : ℤ) : |
| rectangleProjection r (residueClass m t) (measurableSet_residueClass m t) = |
| sliceProjection r * levelProjection ((blockAnchor m:ℤ)-r) (residueEigenvalue m t) := by |
| rw [sliceProjection_diagonal,levelProjection,diagonalProjection_mul] |
| apply diagonalProjection_ext |
| intro j |
| apply EventuallyEq.of_eq |
| ext x |
| by_cases hj : j=r |
| · subst j |
|
|
|
|
| simp only [↓reduceIte,Set.mem_inter_iff,Set.mem_univ,true_and,Set.mem_ofPred_eq] |
| change residue m x=t ↔ explicitBeta x (r+((blockAnchor m:ℤ)-r))=residueEigenvalue m t |
| rw [show r+((blockAnchor m:ℤ)-r)=(blockAnchor m:ℤ) by omega] |
| exact (beta_anchor_residue hm t x).symm |
| · simp [hj] |
| lemma residue_rectangle_mem (m t : ℕ) (r : ℤ) : |
| rectangleProjection r (residueClass m t) (measurableSet_residueClass m t) ∈ polarAlgebra := by |
| by_cases hm : m=0 |
| · subst m |
| have hz (x : Base) : residue 0 x=0 := by have := residue_lt 0 x; norm_num at this; omega |
| by_cases ht : t=0 |
| · have he : residueClass 0 t=Set.univ := by ext x; simp [residueClass,hz,ht] |
| have hr : rectangleProjection r (residueClass 0 t) (measurableSet_residueClass 0 t)=sliceProjection r := by |
| exact (rectangleProjection_ext (EventuallyEq.of_eq he)).trans (rectangleProjection_univ r) |
| rw [hr] |
| exact sliceProjection_mem_polar _ |
| · have he : residueClass 0 t=∅ := by ext x; simp [residueClass,hz,Ne.symm ht] |
| have hr : rectangleProjection r (residueClass 0 t) (measurableSet_residueClass 0 t)=0 := by |
| exact (rectangleProjection_ext (EventuallyEq.of_eq he)).trans (rectangleProjection_empty r) |
| rw [hr] |
| exact polarAlgebra.zero_mem |
| · rw [residue_rectangle_spectral (by omega : 1 ≤ m)] |
| exact polarAlgebra.mul_mem (sliceProjection_mem_polar _) |
| (levelProjection_mem_all polarAlgebra_closed _ _ (polarDiagonal_mem _)) |
|
|
| lemma borel_le_of_residue_measurable (m : MeasurableSpace (PadicInt 2)) |
| (hm : ∀ n t : ℕ, @MeasurableSet (PadicInt 2) m {x | twoResidue n x=t}) : |
| padicBorel ≤ m := by |
| let : MeasurableSpace (PadicInt 2) := padicBorel |
| let R : PadicInt 2 → ℕ → ℕ := fun x n => twoResidue n x |
| have hc : Continuous R := continuous_pi fun n => |
| continuous_of_discreteTopology.comp (continuous_twoResidue n) |
| have hi : Function.Injective R := by |
| intro x y h |
| apply PadicInt.ext_of_toZModPow.mp |
| intro n |
| apply ZMod.val_injective |
| exact congrFun h n |
| have he : MeasurableEmbedding R := (hc.isClosedEmbedding hi).measurableEmbedding |
| have hr : @Measurable _ _ m inferInstance R := by |
| let : MeasurableSpace (PadicInt 2) := m |
| apply Measurable.of_eval |
| intro n |
| exact measurable_to_countable' (hm n) |
| exact he.comap_eq.symm.le.trans hr.comap_le |
| |
| lemma rectangleProjection_finiteUnion_mem (r : ℤ) (E : ℕ → Set Base) |
| (hE : ∀ i, MeasurableSet (E i)) (hmem : ∀ i, rectangleProjection r (E i) (hE i) ∈ polarAlgebra) |
| (s : Finset ℕ) : rectangleProjection r (⋃ i ∈ s, E i) (by measurability) ∈ polarAlgebra := by |
| induction s using Finset.induction_on with |
| | empty => |
| have he : (⋃ i ∈ (∅:Finset ℕ), E i)=∅ := by simp |
| have hp : rectangleProjection r (⋃ i ∈ (∅ : Finset ℕ), E i) (by measurability) = |
| rectangleProjection r ∅ MeasurableSet.empty := rectangleProjection_ext (EventuallyEq.of_eq he) |
| rw [hp, rectangleProjection_empty] |
| exact polarAlgebra.zero_mem |
| | @insert i s hi hs => |
| have he : (⋃ k ∈ insert i s, E k)=E i ∪ ⋃ k ∈ s,E k := by simp |
| have hp : rectangleProjection r (⋃ k ∈ insert i s, E k) (by measurability) = |
| rectangleProjection r (E i ∪ ⋃ k ∈ s, E k) ((hE i).union (by measurability)) := |
| rectangleProjection_ext (EventuallyEq.of_eq he) |
| rw [hp, |
| rectangleProjection_union r (E i) (⋃ k∈s,E k) (hE i) (by measurability)] |
| exact polarAlgebra.sub_mem (polarAlgebra.add_mem (hmem i) hs) (polarAlgebra.mul_mem (hmem i) hs) |
| |
| lemma rectangleProjection_iUnion_mem (r : ℤ) (E : ℕ → Set Base) |
| (hE : ∀ i, MeasurableSet (E i)) (hmem : ∀ i, rectangleProjection r (E i) (hE i) ∈ polarAlgebra) : |
| rectangleProjection r (⋃ i, E i) (MeasurableSet.iUnion hE) ∈ polarAlgebra := by |
| let a (s : Finset ℕ) : DiagonalSymbol := projectionSymbol |
| (fun j => if j=r then ⋃i∈s,E i else ∅) (fun j => by split_ifs <;> measurability) |
| let b : DiagonalSymbol := projectionSymbol |
| (fun j => if j=r then ⋃i,E i else ∅) (fun j => by split_ifs <;> measurability) |
| apply polarAlgebra_closed.mem_of_tendsto (l:=atTop) (T:=fun s => diagonalOperator (a s)) |
| · exact Eventually.of_forall (rectangleProjection_finiteUnion_mem r E hE hmem) |
| · intro f |
| apply diagonalOperator_tendsto (b:=b) a zero_le_one |
| (fun s => projectionSymbol_norm_le _ _) (projectionSymbol_norm_le _ _) |
| apply Eventually.of_forall |
| intro x j |
| apply tendsto_const_nhds.congr' |
| by_cases hj : j=r |
| · by_cases hx : x ∈ ⋃i,E i |
| · obtain ⟨i,hi⟩ := Set.mem_iUnion.mp hx |
| filter_upwards [eventually_ge_atTop ({i}:Finset ℕ)] with s hs |
| have his : i∈s := Finset.singleton_subset_iff.mp hs |
| have hxs : x∈⋃i∈s,E i := Set.mem_iUnion.mpr ⟨i,Set.mem_iUnion.mpr ⟨his,hi⟩⟩ |
| simp [a,b,hj,hx,hxs] |
| · exact Eventually.of_forall (fun s => by |
| have hxs : x ∉ ⋃i∈s,E i := fun h => hx (by |
| obtain ⟨i,hi,hiE⟩ := Set.mem_iUnion.mp h |>.imp (fun i hi => Set.mem_iUnion.mp hi) |
| exact Set.mem_iUnion.mpr ⟨i,hiE⟩) |
| simp [a,b,hj,hx,hxs]) |
| · exact Eventually.of_forall (fun s=>by simp [a,b,hj]) |
|
|
|
|
| @[instance_reducible] |
| def polarProjectionMeasurableSpace (r : ℤ) : MeasurableSpace Base where |
| MeasurableSet' E := ∃ hE : MeasurableSet E, rectangleProjection r E hE ∈ polarAlgebra |
| measurableSet_empty := ⟨MeasurableSet.empty,by rw [rectangleProjection_empty]; exact polarAlgebra.zero_mem⟩ |
| measurableSet_compl E h := by |
| obtain ⟨hE,hm⟩ := h |
| refine ⟨hE.compl,?_⟩ |
| rw [rectangleProjection_compl r E hE] |
| exact polarAlgebra.sub_mem (sliceProjection_mem_polar r) hm |
| measurableSet_iUnion E h := by |
| choose hE hm using h |
| exact ⟨MeasurableSet.iUnion hE,rectangleProjection_iUnion_mem r E hE hm⟩ |
| |
| lemma rectangleProjection_borel_mem (r : ℤ) {E : Set (PadicInt 2)} (hE : MeasurableSet E) : |
| rectangleProjection r E (hE.nullMeasurableSet (μ:=baseHaar)) ∈ polarAlgebra := by |
| have hm : padicBorel ≤ polarProjectionMeasurableSpace r := |
| borel_le_of_residue_measurable _ (fun m t => |
| ⟨measurableSet_residueClass m t,residue_rectangle_mem m t r⟩) |
| exact (hm E hE).choose_spec |
| |
| lemma rectangleProjection_mem (r : ℤ) (E : Set Base) (hE : MeasurableSet E) : |
| rectangleProjection r E hE ∈ polarAlgebra := by |
| obtain ⟨F,hsub,hF,he⟩ := (show NullMeasurableSet (show Set (PadicInt 2) from E) baseHaar from hE).exists_measurable_superset_ae_eq |
| have he' : (show Set Base from F)=ᵐ[baseMeasure] E := he |
| rw [←rectangleProjection_ext (hE:=hF.nullMeasurableSet (μ:=baseHaar)) he'] |
| exact rectangleProjection_borel_mem r hF |
| lemma DiagonalSymbol.sum_apply {ι : Type*} (s : Finset ι) (a : ι → DiagonalSymbol) (x : Base) (j : ℤ) : |
| (∑ i ∈ s, a i) x j = ∑ i ∈ s, a i x j := by |
| induction s using Finset.induction_on with |
| | empty => simp |
| | @insert i s hi hs => simp [Finset.sum_insert,hi,hs] |
| |
| |
| def simpleSliceSymbol (r : ℤ) (f : SimpleFunc Base ℂ) : DiagonalSymbol := |
| ∑ t ∈ f.range, t • projectionSymbol |
| (fun j => if j=r then f ⁻¹' {t} else ∅) |
| (fun j=>by split_ifs; exact f.measurableSet_fiber t; exact MeasurableSet.empty) |
| lemma simpleSliceSymbol_apply (r : ℤ) (f : SimpleFunc Base ℂ) (x : Base) (j : ℤ) : |
| simpleSliceSymbol r f x j=if j=r then f x else 0 := by |
| simp only [simpleSliceSymbol,DiagonalSymbol.sum_apply,DiagonalSymbol.smul_apply,projectionSymbol_apply] |
| by_cases hj : j=r |
| · simp only [hj,↓reduceIte,Set.mem_preimage,Set.mem_singleton_iff,mul_ite,mul_one,mul_zero] |
| rw [Finset.sum_eq_single (f x)] |
| · simp |
| · intro b hb hbx |
| simp [Ne.symm hbx] |
| · exact fun hn => (hn (f.mem_range_self x)).elim |
| · simp [hj] |
| lemma simpleSliceSymbol_mem (r : ℤ) (f : SimpleFunc Base ℂ) : diagonalOperator (simpleSliceSymbol r f) ∈ polarAlgebra := by |
| change diagonalRepresentation (∑ t ∈ f.range, _) ∈ polarAlgebra |
| rw [map_sum] |
| apply polarAlgebra.sum_mem |
| intro t ht |
| rw [map_smul] |
| exact polarAlgebra.smul_mem (rectangleProjection_mem r (f ⁻¹' {t}) (f.measurableSet_fiber t)) t |
| |
| def sliceSymbol (r : ℤ) (a : DiagonalSymbol) : DiagonalSymbol := |
| a * projectionSymbol (fun j=>if j=r then Set.univ else ∅) (fun j=>by split_ifs <;> measurability) |
| lemma sliceSymbol_apply (r : ℤ) (a : DiagonalSymbol) (x : Base) (j : ℤ) : |
| sliceSymbol r a x j=if j=r then a x r else 0 := by |
| by_cases hj : j=r <;> simp [sliceSymbol,hj] |
| lemma sliceSymbol_norm_le (r : ℤ) (a : DiagonalSymbol) (x : Base) (j : ℤ) : |
| ‖sliceSymbol r a x j‖ ≤ a.bound := by |
| rw [sliceSymbol_apply] |
| split_ifs |
| · exact a.norm_le_bound x r |
| · simpa using a.bound_nonneg |
| lemma sliceSymbol_mem (r : ℤ) (a : DiagonalSymbol) : diagonalOperator (sliceSymbol r a) ∈ polarAlgebra := by |
| let f (n : ℕ) : SimpleFunc Base ℂ := SimpleFunc.approxOn (fun x=>a x r) (a.measurable r) Set.univ 0 (Set.mem_univ _) n |
| apply polarAlgebra_closed.mem_of_tendsto (l:=atTop) (T:=fun n=>diagonalOperator (simpleSliceSymbol r (f n))) |
| · exact Eventually.of_forall (fun n=>simpleSliceSymbol_mem r (f n)) |
| · intro v |
| apply diagonalOperator_tendsto (C:=2*a.bound) _ _ (mul_nonneg (by norm_num) a.bound_nonneg) |
| · intro n x j |
| rw [simpleSliceSymbol_apply] |
| split_ifs |
| · exact (SimpleFunc.norm_approxOn_zero_le (a.measurable r) (Set.mem_univ (0:ℂ)) x n).trans |
| (by linarith [a.norm_le_bound x r]) |
| · simpa using mul_nonneg (by norm_num : (0:ℝ) ≤ 2) a.bound_nonneg |
| · intro x j |
| exact (sliceSymbol_norm_le r a x j).trans (by linarith [a.bound_nonneg]) |
| · apply Eventually.of_forall |
| intro x j |
| simp only [simpleSliceSymbol_apply,sliceSymbol_apply] |
| by_cases hj : j=r |
| · simp only [hj,↓reduceIte] |
| exact SimpleFunc.tendsto_approxOn (a.measurable r) (Set.mem_univ (0:ℂ)) (by simp) |
| · simp only [hj,↓reduceIte] |
| exact tendsto_const_nhds |
| |
| lemma finiteSliceSymbol_apply (s : Finset ℤ) (a : DiagonalSymbol) (x : Base) (j : ℤ) : |
| (∑ r ∈ s,sliceSymbol r a) x j=if j∈s then a x j else 0 := by |
| rw [DiagonalSymbol.sum_apply] |
| simp_rw [sliceSymbol_apply] |
| simp |
| lemma diagonalOperator_mem_polar (a : DiagonalSymbol) : diagonalOperator a ∈ polarAlgebra := by |
| let T (s : Finset ℤ) : GlobalHilbert →L[ℂ] GlobalHilbert := diagonalOperator (∑ r ∈ s,sliceSymbol r a) |
| apply polarAlgebra_closed.mem_of_tendsto (l:=atTop) (T:=T) |
| · apply Eventually.of_forall |
| intro s |
| change diagonalRepresentation (∑ r ∈ s,sliceSymbol r a) ∈ polarAlgebra |
| rw [map_sum] |
| exact polarAlgebra.sum_mem (fun r _=>sliceSymbol_mem r a) |
| · intro v |
| apply diagonalOperator_tendsto (C:=a.bound) _ _ a.bound_nonneg |
| · intro s x j |
| rw [finiteSliceSymbol_apply] |
| split_ifs |
| · exact a.norm_le_bound x j |
| · simpa using a.bound_nonneg |
| · exact a.norm_le_bound |
| · apply Eventually.of_forall |
| intro x j |
| apply tendsto_const_nhds.congr' |
| filter_upwards [eventually_ge_atTop ({j}:Finset ℤ)] with s hs |
| rw [finiteSliceSymbol_apply,ite_eq_left (Finset.singleton_subset_iff.mp hs)] |
|
|
|
|
|
|
| theorem polarAlgebra_eq_fullMultiplier : polarAlgebra=fullMultiplierAlgebra := by |
| apply le_antisymm polarAlgebra_le_full |
| rintro T ⟨a,rfl⟩ |
| exact diagonalOperator_mem_polar a |
|
|
|
|
| end |
| end BackwardIntertwiners |
|
|
| end OAI |
|
|
