Download data/lean/OAI/Geometry/ComplexBundle/DirectSum.lean from introvoyz045/math: direct link, hf CLI and curl.
- Browser
- Download file 17.9 kB
-
https://huggingface.co/datasets/introvoyz045/math/resolve/main/data/lean/OAI/Geometry/ComplexBundle/DirectSum.lean
- Command line
-
hf download hf://datasets/introvoyz045/math/data/lean/OAI/Geometry/ComplexBundle/DirectSum.lean
-
curl -L -o DirectSum.lean https://huggingface.co/datasets/introvoyz045/math/resolve/main/data/lean/OAI/Geometry/ComplexBundle/DirectSum.lean
17.9 kB
| import Mathlib.Analysis.InnerProductSpace.PiL2 | |
| import Mathlib.Topology.VectorBundle.Basic | |
| namespace OAI | |
| noncomputable section | |
| /-! Finite direct sums of line bundles, metrics, inclusions, and projections. -/ | |
| section | |
| open Bundle Topology | |
| open scoped BigOperators | |
| namespace Kaplansky | |
| variable {B S : Type*} [TopologicalSpace B] [Fintype S] | |
| {J : S β Type*} (C : β s, VectorBundleCore β B β (J s)) | |
| /-- The simultaneous finite cover for the direct sum of actual line cores. -/ | |
| def lineSumBaseSet (a : β s, J s) : Set B := {x | β s, x β (C s).baseSet (a s)} | |
| theorem isOpen_lineSumBaseSet (a : β s, J s) : IsOpen (lineSumBaseSet C a) := by | |
| have he : lineSumBaseSet C a = β s, (C s).baseSet (a s) := by | |
| ext x | |
| simp [lineSumBaseSet] | |
| rw [he] | |
| exact isOpen_iInter_of_finite (fun s => (C s).isOpen_baseSet (a s)) | |
| /-- Componentwise transition on the finite Hilbert direct sum. -/ | |
| def lineSumTransition (a b : β s, J s) (x : B) : | |
| EuclideanSpace β S βL[β] EuclideanSpace β S := | |
| (EuclideanSpace.equiv S β).symm.toContinuousLinearMap.comp | |
| ((ContinuousLinearMap.pi (fun s => | |
| ((C s).coordChange (a s) (b s) x).comp (ContinuousLinearMap.proj s))).comp | |
| (EuclideanSpace.equiv S β).toContinuousLinearMap) | |
| omit [Fintype S] in | |
| @[simp] theorem lineSumTransition_apply (a b : β s, J s) (x : B) | |
| (v : EuclideanSpace β S) (s : S) : | |
| lineSumTransition C a b x v s = (C s).coordChange (a s) (b s) x (v s) := rfl | |
| theorem continuousOn_lineSumTransition (a b : β s, J s) : | |
| ContinuousOn (lineSumTransition C a b) (lineSumBaseSet C a β© lineSumBaseSet C b) := by | |
| apply continuousOn_clm_apply.mpr | |
| intro v | |
| apply (EuclideanSpace.equiv S β).symm.continuous.comp_continuousOn | |
| apply continuousOn_pi.mpr | |
| intro s | |
| exact (((C s).continuousOn_coordChange (a s) (b s)).mono | |
| (fun x hx => β¨hx.1 s,hx.2 sβ©)).clm_apply continuousOn_const | |
| /-- A finite direct sum, with its ordinary vector-bundle topology and | |
| finite Hilbert-space fibers. Neither a trivialization nor a trivial bundle | |
| is asserted by the fact that the core uses a fixed model fiber. -/ | |
| def finiteLineSumCore : VectorBundleCore β B (EuclideanSpace β S) (β s, J s) where | |
| baseSet := lineSumBaseSet C | |
| isOpen_baseSet := isOpen_lineSumBaseSet C | |
| indexAt x s := (C s).indexAt x | |
| mem_baseSet_at x s := (C s).mem_baseSet_at x | |
| coordChange := lineSumTransition C | |
| coordChange_self a x hx v := by | |
| ext s | |
| exact (C s).coordChange_self (a s) x (hx s) (v s) | |
| continuousOn_coordChange := continuousOn_lineSumTransition C | |
| coordChange_comp a b c x hx v := by | |
| ext s | |
| exact (C s).coordChange_comp (a s) (b s) (c s) x | |
| β¨β¨hx.1.1 s,hx.1.2 sβ©,hx.2 sβ© (v s) | |
| /-- The direct sum has the actual line-core fibers as its components. -/ | |
| def finiteLineSumFiberEquiv (x : B) : | |
| (finiteLineSumCore C).Fiber x ββ[β] (β s, (C s).Fiber x) := | |
| (EuclideanSpace.equiv S β).toLinearEquiv | |
| theorem finiteLineSum_finrank (x : B) : | |
| Module.finrank β ((finiteLineSumCore C).Fiber x) = Fintype.card S := by | |
| change Module.finrank β (EuclideanSpace β S) = _ | |
| simp | |
| /-- In every simultaneous chart, components agree with the individual | |
| line-bundle charts, which identifies the direct-sum gluing explicitly. -/ | |
| theorem finiteLineSum_chart_component (a : β s, J s) (x : B) | |
| (v : (finiteLineSumCore C).Fiber x) (s : S) : | |
| (((finiteLineSumCore C).localTriv a) β¨x,vβ©).2 s = | |
| (((C s).localTriv (a s)) β¨x,finiteLineSumFiberEquiv C x v sβ©).2 := rfl | |
| end Kaplansky | |
| end | |
| section | |
| open Bundle Topology | |
| namespace Kaplansky | |
| variable {B S : Type*} [TopologicalSpace B] [Fintype S] | |
| {J : S β Type*} (C : β s, VectorBundleCore β B β (J s)) | |
| def finiteLineSumComponent (s : S) | |
| (z : TotalSpace (EuclideanSpace β S) (finiteLineSumCore C).Fiber) : | |
| TotalSpace β (C s).Fiber := β¨z.proj, finiteLineSumFiberEquiv C z.proj z.2 sβ© | |
| theorem continuous_finiteLineSumComponent (s : S) : | |
| Continuous (finiteLineSumComponent C s) := by | |
| apply continuous_iff_continuousAt.mpr | |
| intro z | |
| rw [FiberBundle.continuousAt_totalSpace] | |
| constructor | |
| Β· exact (FiberBundle.continuous_proj _ _).continuousAt | |
| Β· let a : β s, J s := (finiteLineSumCore C).indexAt z.proj | |
| have hz : z β ((finiteLineSumCore C).localTriv a).source := | |
| ((finiteLineSumCore C).localTriv a).mem_source.mpr | |
| ((finiteLineSumCore C).mem_baseSet_at z.proj) | |
| have h := (((finiteLineSumCore C).localTriv a).continuousAt hz).snd | |
| exact ((continuous_apply s).comp (EuclideanSpace.equiv S β).continuous).continuousAt.comp h | |
| /-- Continuity into the actual finite sum is exactly continuity of its | |
| base and all of its actual line-bundle components. This includes the empty sum. -/ | |
| theorem continuous_finiteLineSum_iff {X : Type*} [TopologicalSpace X] | |
| (f : X β TotalSpace (EuclideanSpace β S) (finiteLineSumCore C).Fiber) : | |
| Continuous f β Continuous (fun x => (f x).proj) β§ | |
| β s, Continuous (fun x => finiteLineSumComponent C s (f x)) := by | |
| constructor | |
| Β· intro hf | |
| exact β¨(FiberBundle.continuous_proj _ _).comp hf, | |
| fun s => (continuous_finiteLineSumComponent C s).comp hfβ© | |
| Β· rintro β¨hb,hcβ© | |
| apply continuous_iff_continuousAt.mpr | |
| intro x | |
| rw [FiberBundle.continuousAt_totalSpace] | |
| refine β¨hb.continuousAt, ?_β© | |
| have h : ContinuousAt (fun y s => | |
| (trivializationAt β (C s).Fiber (f x).proj | |
| (finiteLineSumComponent C s (f y))).2) x := by | |
| apply continuousAt_pi.mpr | |
| intro s | |
| exact (FiberBundle.continuousAt_totalSpace β _).mp ((hc s).continuousAt) |>.2 | |
| exact (EuclideanSpace.equiv S β).symm.continuous.continuousAt.comp h | |
| end Kaplansky | |
| open Bundle Topology | |
| open scoped BigOperators InnerProductSpace | |
| namespace Kaplansky | |
| variable {B S : Type*} [TopologicalSpace B] [Fintype S] | |
| {J : S β Type*} (C : β s, VectorBundleCore β B β (J s)) | |
| instance finiteLineSumFiberNormedAddCommGroup (x : B) : | |
| NormedAddCommGroup ((finiteLineSumCore C).Fiber x) := | |
| inferInstanceAs (NormedAddCommGroup (EuclideanSpace β S)) | |
| instance finiteLineSumFiberInnerProductSpace (x : B) : | |
| InnerProductSpace β ((finiteLineSumCore C).Fiber x) := | |
| inferInstanceAs (InnerProductSpace β (EuclideanSpace β S)) | |
| /-- The ordinary isometry condition on the given line-bundle transitions. -/ | |
| def LineCoreIsUnitary : Prop := β s a b x, | |
| x β (C s).baseSet a β x β (C s).baseSet b β β z w : β, | |
| inner β ((C s).coordChange a b x z) ((C s).coordChange a b x w) = inner β z w | |
| theorem finiteLineSumTransition_inner (hC : LineCoreIsUnitary C) | |
| (a b : β s, J s) (x : B) (ha : x β lineSumBaseSet C a) | |
| (hb : x β lineSumBaseSet C b) (v w : EuclideanSpace β S) : | |
| inner β (lineSumTransition C a b x v) (lineSumTransition C a b x w) = inner β v w := by | |
| simp only [PiLp.inner_apply] | |
| apply Finset.sum_congr rfl | |
| intro s _ | |
| exact hC s (a s) (b s) x (ha s) (hb s) (v s) (w s) | |
| theorem finiteLineSum_chart_inner (hC : LineCoreIsUnitary C) | |
| (a : β s, J s) (x : B) (ha : x β lineSumBaseSet C a) | |
| (v w : (finiteLineSumCore C).Fiber x) : | |
| inner β (((finiteLineSumCore C).localTriv a) β¨x,vβ©).2 | |
| (((finiteLineSumCore C).localTriv a) β¨x,wβ©).2 = inner β v w := | |
| finiteLineSumTransition_inner C hC _ a x ((finiteLineSumCore C).mem_baseSet_at x) ha v w | |
| /-- The fiberwise Hilbert metrics are continuous on the constructed bundle, | |
| proved in local charts. This is the continuous Hermitian metric condition | |
| for arbitrary continuous local sections. -/ | |
| theorem finiteLineSum_inner_continuousOn (hC : LineCoreIsUnitary C) | |
| (A : Set B) (v w : β x, (finiteLineSumCore C).Fiber x) | |
| (hv : ContinuousOn (fun x => TotalSpace.mk' (EuclideanSpace β S) x (v x)) A) | |
| (hw : ContinuousOn (fun x => TotalSpace.mk' (EuclideanSpace β S) x (w x)) A) : | |
| ContinuousOn (fun x => inner β (v x) (w x)) A := by | |
| intro x hx | |
| let a := (finiteLineSumCore C).indexAt x | |
| have hax : x β lineSumBaseSet C a := (finiteLineSumCore C).mem_baseSet_at x | |
| have hcv := ((FiberBundle.continuousWithinAt_totalSpace (EuclideanSpace β S) _).mp (hv x hx)).2 | |
| have hcw := ((FiberBundle.continuousWithinAt_totalSpace (EuclideanSpace β S) _).mp (hw x hx)).2 | |
| apply (hcv.inner hcw).congr_of_eventuallyEq | |
| Β· filter_upwards [Filter.Eventually.filter_mono nhdsWithin_le_nhds | |
| ((isOpen_lineSumBaseSet C a).mem_nhds hax)] with y hy | |
| exact (finiteLineSum_chart_inner C hC a y hy (v y) (w y)).symm | |
| Β· exact (finiteLineSum_chart_inner C hC a x hax (v x) (w x)).symm | |
| end Kaplansky | |
| end | |
| section | |
| open Bundle Topology | |
| namespace Kaplansky | |
| variable {B S T : Type*} [TopologicalSpace B] [Fintype S] [Fintype T] | |
| {J : SβT β Type*} (L : β u, VectorBundleCore β B β (J u)) | |
| def lineSumInl (x : B) : (finiteLineSumCore (fun s => L (Sum.inl s))).Fiber x ββ[β] | |
| (finiteLineSumCore L).Fiber x where | |
| toFun v := WithLp.toLp 2 (Sum.elim (fun s => (show EuclideanSpace β S from v) s) (fun _ => 0)) | |
| map_add' v w := by | |
| apply (EuclideanSpace.equiv (SβT) β).injective | |
| funext u | |
| cases u with | |
| | inl s => rfl | |
| | inr t => exact (zero_add (0 : β)).symm | |
| map_smul' z v := by | |
| apply (EuclideanSpace.equiv (SβT) β).injective | |
| funext u | |
| cases u with | |
| | inl s => rfl | |
| | inr t => exact (smul_zero z : z β’ (0 : β) = 0).symm | |
| def lineSumInr (x : B) : (finiteLineSumCore (fun t => L (Sum.inr t))).Fiber x ββ[β] | |
| (finiteLineSumCore L).Fiber x where | |
| toFun v := WithLp.toLp 2 (Sum.elim (fun _ => 0) (fun t => (show EuclideanSpace β T from v) t)) | |
| map_add' v w := by | |
| apply (EuclideanSpace.equiv (SβT) β).injective | |
| funext u | |
| cases u with | |
| | inl s => exact (zero_add (0 : β)).symm | |
| | inr t => rfl | |
| map_smul' z v := by | |
| apply (EuclideanSpace.equiv (SβT) β).injective | |
| funext u | |
| cases u with | |
| | inl s => exact (smul_zero z : z β’ (0 : β) = 0).symm | |
| | inr t => rfl | |
| theorem lineSumInl_injective (x : B) : Function.Injective (lineSumInl L x) := by | |
| intro v w h | |
| apply (EuclideanSpace.equiv S β).injective | |
| funext s | |
| exact congrArg (fun u : EuclideanSpace β (SβT) => u (Sum.inl s)) h | |
| theorem lineSumInr_injective (x : B) : Function.Injective (lineSumInr L x) := by | |
| intro v w h | |
| apply (EuclideanSpace.equiv T β).injective | |
| funext t | |
| exact congrArg (fun u : EuclideanSpace β (SβT) => u (Sum.inr t)) h | |
| theorem continuous_lineSumInl : Continuous (fun z : TotalSpace (EuclideanSpace β S) | |
| (finiteLineSumCore (fun s => L (Sum.inl s))).Fiber => TotalSpace.mk' (EuclideanSpace β (SβT)) z.proj (lineSumInl L z.proj z.2)) := by | |
| apply (continuous_finiteLineSum_iff _ _).mpr | |
| refine β¨FiberBundle.continuous_proj _ _,?_β© | |
| intro u | |
| cases u with | |
| | inl s => exact continuous_finiteLineSumComponent (fun s => L (Sum.inl s)) s | |
| | inr t => | |
| apply continuous_iff_continuousAt.mpr | |
| intro z | |
| rw [FiberBundle.continuousAt_totalSpace] | |
| refine β¨(FiberBundle.continuous_proj _ _).continuousAt,?_β© | |
| change ContinuousAt (fun x : TotalSpace (EuclideanSpace β S) (finiteLineSumCore (fun s => L (Sum.inl s))).Fiber => | |
| (L (Sum.inr t)).coordChange ((L (Sum.inr t)).indexAt x.proj) ((L (Sum.inr t)).indexAt z.proj) x.proj 0) z | |
| simpa only [map_zero] using (continuousAt_const : ContinuousAt (fun _ : TotalSpace (EuclideanSpace β S) (finiteLineSumCore (fun s => L (Sum.inl s))).Fiber => (0 : β)) z) | |
| theorem continuous_lineSumInr : Continuous (fun z : TotalSpace (EuclideanSpace β T) | |
| (finiteLineSumCore (fun t => L (Sum.inr t))).Fiber => TotalSpace.mk' (EuclideanSpace β (SβT)) z.proj (lineSumInr L z.proj z.2)) := by | |
| apply (continuous_finiteLineSum_iff _ _).mpr | |
| refine β¨FiberBundle.continuous_proj _ _,?_β© | |
| intro u | |
| cases u with | |
| | inr t => exact continuous_finiteLineSumComponent (fun t => L (Sum.inr t)) t | |
| | inl s => | |
| apply continuous_iff_continuousAt.mpr | |
| intro z | |
| rw [FiberBundle.continuousAt_totalSpace] | |
| refine β¨(FiberBundle.continuous_proj _ _).continuousAt,?_β© | |
| change ContinuousAt (fun x : TotalSpace (EuclideanSpace β T) (finiteLineSumCore (fun t => L (Sum.inr t))).Fiber => | |
| (L (Sum.inl s)).coordChange ((L (Sum.inl s)).indexAt x.proj) ((L (Sum.inl s)).indexAt z.proj) x.proj 0) z | |
| simpa only [map_zero] using (continuousAt_const : ContinuousAt (fun _ : TotalSpace (EuclideanSpace β T) (finiteLineSumCore (fun t => L (Sum.inr t))).Fiber => (0 : β)) z) | |
| end Kaplansky | |
| open Bundle Topology | |
| open scoped BigOperators | |
| namespace Kaplansky | |
| variable {B S T : Type*} [TopologicalSpace B] [Fintype S] [Fintype T] | |
| {J : S β Type*} (C : β s, VectorBundleCore β B β (J s)) (e : T β S) | |
| def lineSumReindex (x : B) : (finiteLineSumCore (fun t => C (e t))).Fiber x ββ[β] | |
| (finiteLineSumCore C).Fiber x where | |
| toFun v := WithLp.toLp 2 (fun s => (show EuclideanSpace β T from v) (e.symm s)) | |
| invFun v := WithLp.toLp 2 (fun t => (show EuclideanSpace β S from v) (e t)) | |
| map_add' _ _ := rfl | |
| map_smul' _ _ := rfl | |
| left_inv v := by | |
| apply (EuclideanSpace.equiv T β).injective | |
| funext t | |
| exact congrArg (fun t => (show EuclideanSpace β T from v) t) (e.symm_apply_apply t) | |
| right_inv v := by | |
| apply (EuclideanSpace.equiv S β).injective | |
| funext s | |
| exact congrArg (fun s => (show EuclideanSpace β S from v) s) (e.apply_symm_apply s) | |
| def lineSumReindexTotalHomeomorph : | |
| TotalSpace (EuclideanSpace β T) (finiteLineSumCore (fun t => C (e t))).Fiber ββ | |
| TotalSpace (EuclideanSpace β S) (finiteLineSumCore C).Fiber where | |
| toFun z := β¨z.proj,lineSumReindex C e z.proj z.2β© | |
| invFun z := β¨z.proj,(lineSumReindex C e z.proj).symm z.2β© | |
| left_inv z := by cases z; simp | |
| right_inv z := by cases z; simp | |
| continuous_toFun := by | |
| apply (continuous_finiteLineSum_iff _ _).mpr | |
| refine β¨FiberBundle.continuous_proj _ _,?_β© | |
| intro s | |
| obtain β¨t,rflβ© := e.surjective s | |
| change Continuous (fun z : TotalSpace (EuclideanSpace β T) (finiteLineSumCore (fun t => C (e t))).Fiber => | |
| TotalSpace.mk' β (E := (C (e t)).Fiber) z.proj ((show EuclideanSpace β T from z.2) (e.symm (e t)))) | |
| simp only [Equiv.symm_apply_apply] | |
| exact continuous_finiteLineSumComponent (fun t => C (e t)) t | |
| continuous_invFun := by | |
| apply (continuous_finiteLineSum_iff _ _).mpr | |
| refine β¨FiberBundle.continuous_proj _ _,?_β© | |
| intro t | |
| exact continuous_finiteLineSumComponent C (e t) | |
| theorem lineSumReindex_inner (x : B) | |
| (v w : (finiteLineSumCore (fun t => C (e t))).Fiber x) : | |
| inner β (lineSumReindex C e x v) (lineSumReindex C e x w) = inner β v w := by | |
| change (β s : S, inner β ((show EuclideanSpace β T from v) (e.symm s)) | |
| ((show EuclideanSpace β T from w) (e.symm s))) = | |
| β t : T, inner β ((show EuclideanSpace β T from v) t) ((show EuclideanSpace β T from w) t) | |
| exact Fintype.sum_equiv e.symm _ _ (fun _ => rfl) | |
| end Kaplansky | |
| end | |
| open Bundle Topology | |
| open scoped BigOperators | |
| namespace Kaplansky | |
| variable {B S T : Type*} [TopologicalSpace B] [Fintype S] [Fintype T] | |
| {J : SβT β Type*} (L : β u, VectorBundleCore β B β (J u)) | |
| def lineSumFst (x : B) : (finiteLineSumCore L).Fiber x ββ[β] | |
| (finiteLineSumCore (fun s => L (Sum.inl s))).Fiber x where | |
| toFun v := WithLp.toLp 2 (fun s => (show EuclideanSpace β (SβT) from v) (Sum.inl s)) | |
| map_add' _ _ := rfl | |
| map_smul' _ _ := rfl | |
| def lineSumSnd (x : B) : (finiteLineSumCore L).Fiber x ββ[β] | |
| (finiteLineSumCore (fun t => L (Sum.inr t))).Fiber x where | |
| toFun v := WithLp.toLp 2 (fun t => (show EuclideanSpace β (SβT) from v) (Sum.inr t)) | |
| map_add' _ _ := rfl | |
| map_smul' _ _ := rfl | |
| theorem continuous_lineSumFst : Continuous (fun z : TotalSpace (EuclideanSpace β (SβT)) | |
| (finiteLineSumCore L).Fiber => TotalSpace.mk' (EuclideanSpace β S) z.proj (lineSumFst L z.proj z.2)) := by | |
| apply (continuous_finiteLineSum_iff _ _).mpr | |
| exact β¨FiberBundle.continuous_proj _ _,fun s => continuous_finiteLineSumComponent L (Sum.inl s)β© | |
| theorem continuous_lineSumSnd : Continuous (fun z : TotalSpace (EuclideanSpace β (SβT)) | |
| (finiteLineSumCore L).Fiber => TotalSpace.mk' (EuclideanSpace β T) z.proj (lineSumSnd L z.proj z.2)) := by | |
| apply (continuous_finiteLineSum_iff _ _).mpr | |
| exact β¨FiberBundle.continuous_proj _ _,fun t => continuous_finiteLineSumComponent L (Sum.inr t)β© | |
| theorem lineSumFst_inner (x : B) | |
| (v : (finiteLineSumCore (fun s => L (Sum.inl s))).Fiber x) | |
| (w : (finiteLineSumCore L).Fiber x) : | |
| inner β (lineSumFst L x w) v = inner β w (lineSumInl L x v) := by | |
| change EuclideanSpace β S at v | |
| change EuclideanSpace β (SβT) at w | |
| change (β s, inner β (w (Sum.inl s)) (v s)) = | |
| β u : S β T, inner β (w u) (Sum.elim (fun s => v s) (fun _ => 0) u) | |
| simp [Fintype.sum_sum_type] | |
| theorem lineSumSnd_inner (x : B) | |
| (v : (finiteLineSumCore (fun t => L (Sum.inr t))).Fiber x) | |
| (w : (finiteLineSumCore L).Fiber x) : | |
| inner β (lineSumSnd L x w) v = inner β w (lineSumInr L x v) := by | |
| change EuclideanSpace β T at v | |
| change EuclideanSpace β (SβT) at w | |
| change (β t, inner β (w (Sum.inr t)) (v t)) = | |
| β u : S β T, inner β (w u) (Sum.elim (fun _ => 0) (fun t => v t) u) | |
| simp [Fintype.sum_sum_type] | |
| theorem lineSumFst_comp_inl (x : B) : (lineSumFst L x).comp (lineSumInl L x) = LinearMap.id := by | |
| ext v | |
| rfl | |
| theorem lineSumSnd_comp_inr (x : B) : (lineSumSnd L x).comp (lineSumInr L x) = LinearMap.id := by | |
| ext v | |
| rfl | |
| theorem lineSum_inl_fst_add_inr_snd (x : B) : | |
| (lineSumInl L x).comp (lineSumFst L x) + (lineSumInr L x).comp (lineSumSnd L x) = LinearMap.id := by | |
| ext v | |
| apply (EuclideanSpace.equiv (SβT) β).injective | |
| funext u | |
| cases u with | |
| | inl s => exact add_zero ((show EuclideanSpace β (SβT) from v) (Sum.inl s)) | |
| | inr t => exact zero_add ((show EuclideanSpace β (SβT) from v) (Sum.inr t)) | |
| end Kaplansky | |
| end | |
| end OAI | |