Download data/lean/OAI/Geometry/IsometricImmersion/Energy/MultiplierIntegral.lean from introvoyz045/math: direct link, hf CLI and curl.
- Browser
- Download file 17.5 kB
-
https://huggingface.co/datasets/introvoyz045/math/resolve/main/data/lean/OAI/Geometry/IsometricImmersion/Energy/MultiplierIntegral.lean
- Command line
-
hf download hf://datasets/introvoyz045/math/data/lean/OAI/Geometry/IsometricImmersion/Energy/MultiplierIntegral.lean
-
curl -L -o MultiplierIntegral.lean https://huggingface.co/datasets/introvoyz045/math/resolve/main/data/lean/OAI/Geometry/IsometricImmersion/Energy/MultiplierIntegral.lean
17.5 kB
| import OAI.Geometry.IsometricImmersion.Energy.MultiplierDivergence | |
| import Mathlib.MeasureTheory.Integral.Prod | |
| import Mathlib.MeasureTheory.Integral.IntervalIntegral.FundThmCalculus | |
| import Mathlib.Tactic.FunProp | |
| namespace OAI | |
| noncomputable section | |
| open Set Filter MeasureTheory | |
| open scoped ContDiff Topology Interval | |
| namespace SmoothLocal.Weighted | |
| open SmoothLocal.Geometry | |
| def boxPoint (t s : β) : Coord := | |
| t β’ Pi.single 0 1 + s β’ Pi.single 1 1 | |
| def closedRectangle (tl tr sb st : β) : Set Coord := | |
| {p | p 0 β Icc tl tr β§ p 1 β Icc sb st} | |
| def rectangleIntegral (tl tr sb st : β) (f : Coord β β) : β := | |
| β« s in sb..st, β« t in tl..tr, f (boxPoint t s) | |
| def zeroRectangleBoundary (tl tr sb st : β) (f : Coord β β) : Prop := | |
| (β s β Icc sb st, f (boxPoint tl s) = 0 β§ f (boxPoint tr s) = 0) β§ | |
| (β t β Icc tl tr, f (boxPoint t sb) = 0 β§ f (boxPoint t st) = 0) | |
| theorem boxPoint_mem {tl tr sb st t s : β} | |
| (ht : t β Icc tl tr) (hs : s β Icc sb st) : | |
| boxPoint t s β closedRectangle tl tr sb st := by | |
| simpa [boxPoint, closedRectangle] using And.intro ht hs | |
| theorem boxPoint_hasDerivAt_t (t s : β) : | |
| HasDerivAt (fun x => boxPoint x s) (Pi.single 0 (1 : β) : Coord) t := by | |
| simpa [boxPoint] using | |
| ((hasDerivAt_id t).smul_const (Pi.single 0 (1 : β) : Coord)).add_const | |
| (s β’ (Pi.single 1 (1 : β) : Coord)) | |
| theorem boxPoint_hasDerivAt_s (t s : β) : | |
| HasDerivAt (boxPoint t) (Pi.single 1 (1 : β) : Coord) s := by | |
| change HasDerivAt (fun x : β => t β’ (Pi.single 0 (1 : β) : Coord) + | |
| x β’ (Pi.single 1 (1 : β) : Coord)) (Pi.single 1 (1 : β) : Coord) s | |
| simpa only [id_eq, one_smul] using | |
| ((hasDerivAt_id s).smul_const (Pi.single 1 (1 : β) : Coord)).const_add | |
| (t β’ (Pi.single 0 (1 : β) : Coord)) | |
| variable {tl tr sb st : β} {f g : Coord β β} | |
| theorem rectangle_area_integrable | |
| (hf : ContinuousOn f (closedRectangle tl tr sb st)) : | |
| IntegrableOn (fun p : β Γ β => f (boxPoint p.1 p.2)) | |
| (Ioc tl tr ΓΛ’ Ioc sb st) := by | |
| have hc : ContinuousOn (fun p : β Γ β => f (boxPoint p.1 p.2)) | |
| (Icc tl tr ΓΛ’ Icc sb st) := | |
| hf.comp (by unfold boxPoint; fun_prop) (fun p hp => boxPoint_mem hp.1 hp.2) | |
| exact (hc.integrableOn_compact (isCompact_Icc.prod isCompact_Icc)).mono_set | |
| (Set.prod_mono Ioc_subset_Icc_self Ioc_subset_Icc_self) | |
| theorem rectangleIntegral_swap (ht : tl β€ tr) (hs : sb β€ st) | |
| (hf : ContinuousOn f (closedRectangle tl tr sb st)) : | |
| rectangleIntegral tl tr sb st f = | |
| β« t in tl..tr, β« s in sb..st, f (boxPoint t s) := by | |
| have hi : IntegrableOn (Function.uncurry (fun t s => f (boxPoint t s))) | |
| (uIoc tl tr ΓΛ’ uIoc sb st) := by | |
| simpa only [uIoc_of_le ht, uIoc_of_le hs, Function.uncurry_def] using rectangle_area_integrable hf | |
| exact (intervalIntegral_intervalIntegral_swap hi).symm | |
| theorem rectangleIntegral_eq_area (ht : tl β€ tr) (hs : sb β€ st) | |
| (hf : ContinuousOn f (closedRectangle tl tr sb st)) : | |
| rectangleIntegral tl tr sb st f = | |
| β« p in Ioc tl tr ΓΛ’ Ioc sb st, f (boxPoint p.1 p.2) := by | |
| rw [rectangleIntegral_swap ht hs hf] | |
| simp_rw [intervalIntegral.integral_of_le ht, intervalIntegral.integral_of_le hs] | |
| have hi : IntegrableOn (fun p : β Γ β => f (boxPoint p.1 p.2)) | |
| (Ioc tl tr ΓΛ’ Ioc sb st) (volume.prod volume) := by | |
| simpa only [β Measure.volume_eq_prod] using rectangle_area_integrable hf | |
| simpa only [β Measure.volume_eq_prod] using | |
| (setIntegral_prod (fun p : β Γ β => f (boxPoint p.1 p.2)) hi).symm | |
| theorem rectangleIntegral_congr (ht : tl β€ tr) (hs : sb β€ st) | |
| (heq : EqOn f g (closedRectangle tl tr sb st)) : | |
| rectangleIntegral tl tr sb st f = rectangleIntegral tl tr sb st g := by | |
| unfold rectangleIntegral | |
| apply intervalIntegral.integral_congr | |
| intro s hs' | |
| apply intervalIntegral.integral_congr | |
| intro t ht' | |
| exact heq (boxPoint_mem | |
| (by simpa only [uIcc_of_le ht] using ht') | |
| (by simpa only [uIcc_of_le hs] using hs')) | |
| theorem rectangleIntegral_add (ht : tl β€ tr) (hs : sb β€ st) | |
| (hf : ContinuousOn f (closedRectangle tl tr sb st)) | |
| (hg : ContinuousOn g (closedRectangle tl tr sb st)) : | |
| rectangleIntegral tl tr sb st (fun p => f p + g p) = | |
| rectangleIntegral tl tr sb st f + rectangleIntegral tl tr sb st g := by | |
| have hfg : ContinuousOn (fun p => f p + g p) (closedRectangle tl tr sb st) := hf.add hg | |
| rw [rectangleIntegral_eq_area ht hs hfg, | |
| rectangleIntegral_eq_area ht hs hf, rectangleIntegral_eq_area ht hs hg] | |
| exact integral_add (rectangle_area_integrable hf) (rectangle_area_integrable hg) | |
| variable {U : Set Coord} | |
| theorem rectangleIntegral_partial_t_zero | |
| (ht : tl β€ tr) (hs : sb β€ st) (hU : IsOpen U) | |
| (hf : ContDiffOn β β f U) (hbox : closedRectangle tl tr sb st β U) | |
| (hedge : β s β Icc sb st, f (boxPoint tl s) = 0 β§ f (boxPoint tr s) = 0) : | |
| rectangleIntegral tl tr sb st (coordPartial 0 f) = 0 := by | |
| have hinner (s : β) (hs' : s β Icc sb st) : | |
| (β« t in tl..tr, coordPartial 0 f (boxPoint t s)) = 0 := by | |
| have hcont : ContinuousOn (fun t => coordPartial 0 f (boxPoint t s)) (uIcc tl tr) := by | |
| rw [uIcc_of_le ht] | |
| exact (partial_contDiffOn hf hU 0).continuousOn.comp | |
| (by unfold boxPoint; fun_prop) (fun t ht' => hbox (boxPoint_mem ht' hs')) | |
| have hderiv (t : β) (ht' : t β uIcc tl tr) : | |
| HasDerivAt (fun x => f (boxPoint x s)) (coordPartial 0 f (boxPoint t s)) t := by | |
| have hp : boxPoint t s β U := hbox (boxPoint_mem | |
| (by simpa only [uIcc_of_le ht] using ht') hs') | |
| have hd := (hf.contDiffAt (hU.mem_nhds hp)).differentiableAt (by simp) | |
| exact hd.hasFDerivAt.comp_hasDerivAt t (boxPoint_hasDerivAt_t t s) | |
| have he := intervalIntegral.integral_eq_sub_of_hasDerivAt hderiv hcont.intervalIntegrable | |
| rw [(hedge s hs').1, (hedge s hs').2, sub_self] at he | |
| exact he | |
| unfold rectangleIntegral | |
| calc | |
| (β« s in sb..st, β« t in tl..tr, coordPartial 0 f (boxPoint t s)) = | |
| β« _ in sb..st, (0 : β) := by | |
| apply intervalIntegral.integral_congr | |
| intro s hs' | |
| exact hinner s (by simpa only [uIcc_of_le hs] using hs') | |
| _ = 0 := intervalIntegral.integral_zero | |
| theorem rectangleIntegral_partial_s_zero | |
| (ht : tl β€ tr) (hs : sb β€ st) (hU : IsOpen U) | |
| (hf : ContDiffOn β β f U) (hbox : closedRectangle tl tr sb st β U) | |
| (hedge : β t β Icc tl tr, f (boxPoint t sb) = 0 β§ f (boxPoint t st) = 0) : | |
| rectangleIntegral tl tr sb st (coordPartial 1 f) = 0 := by | |
| rw [rectangleIntegral_swap ht hs ((partial_contDiffOn hf hU 1).continuousOn.mono hbox)] | |
| have hinner (t : β) (ht' : t β Icc tl tr) : | |
| (β« s in sb..st, coordPartial 1 f (boxPoint t s)) = 0 := by | |
| have hcont : ContinuousOn (fun s => coordPartial 1 f (boxPoint t s)) (uIcc sb st) := by | |
| rw [uIcc_of_le hs] | |
| exact (partial_contDiffOn hf hU 1).continuousOn.comp | |
| (by unfold boxPoint; fun_prop) (fun s hs' => hbox (boxPoint_mem ht' hs')) | |
| have hderiv (s : β) (hs' : s β uIcc sb st) : | |
| HasDerivAt (fun y => f (boxPoint t y)) (coordPartial 1 f (boxPoint t s)) s := by | |
| have hp : boxPoint t s β U := hbox (boxPoint_mem ht' | |
| (by simpa only [uIcc_of_le hs] using hs')) | |
| have hd := (hf.contDiffAt (hU.mem_nhds hp)).differentiableAt (by simp) | |
| exact hd.hasFDerivAt.comp_hasDerivAt s (boxPoint_hasDerivAt_s t s) | |
| have he := intervalIntegral.integral_eq_sub_of_hasDerivAt hderiv hcont.intervalIntegrable | |
| rw [(hedge t ht').1, (hedge t ht').2, sub_self] at he | |
| exact he | |
| calc | |
| (β« t in tl..tr, β« s in sb..st, coordPartial 1 f (boxPoint t s)) = | |
| β« _ in tl..tr, (0 : β) := by | |
| apply intervalIntegral.integral_congr | |
| intro t ht' | |
| exact hinner t (by simpa only [uIcc_of_le ht] using ht') | |
| _ = 0 := intervalIntegral.integral_zero | |
| def multiplierQuadratic (A B C m n u : Coord β β) (p : Coord) : β := | |
| multiplierT B m n p * (coordPartial 0 u p) ^ 2 + | |
| multiplierS A C m n p * (coordPartial 1 u p) ^ 2 + | |
| multiplierJ A B C m n p * coordPartial 0 u p * coordPartial 1 u p | |
| theorem multiplierTestProduct_contDiffOn | |
| {A B C m n u : Coord β β} (hU : IsOpen U) | |
| (hA : ContDiffOn β β A U) (hB : ContDiffOn β β B U) | |
| (hC : ContDiffOn β β C U) (hm : ContDiffOn β β m U) | |
| (hn : ContDiffOn β β n U) (hu : ContDiffOn β β u U) : | |
| ContDiffOn β β (fun p => multiplierOperator A B C u p * multiplierTest m n u p) U := by | |
| have ht := partial_contDiffOn hu hU 0 | |
| have hs := partial_contDiffOn hu hU 1 | |
| have htt := partial_contDiffOn ht hU 0 | |
| have hss := partial_contDiffOn hs hU 1 | |
| have hL : ContDiffOn β β (multiplierOperator A B C u) U := | |
| ((htt.add (hA.mul hss)).add (hB.mul ht)).add (hC.mul hs) | |
| have htest : ContDiffOn β β (multiplierTest m n u) U := | |
| (hm.mul hs).add (hn.mul ht) | |
| exact hL.mul htest | |
| theorem multiplierFluxes_contDiffOn | |
| {A m n u : Coord β β} (hU : IsOpen U) | |
| (hA : ContDiffOn β β A U) (hm : ContDiffOn β β m U) | |
| (hn : ContDiffOn β β n U) (hu : ContDiffOn β β u U) : | |
| ContDiffOn β β (multiplierFluxT A m n u) U β§ | |
| ContDiffOn β β (multiplierFluxS A m n u) U := by | |
| have ht := partial_contDiffOn hu hU 0 | |
| have hs := partial_contDiffOn hu hU 1 | |
| constructor | |
| Β· exact (((hm.mul ht).mul hs).add | |
| (contDiffOn_const.mul (hn.mul (ht.pow 2)))).sub | |
| (contDiffOn_const.mul ((hA.mul hn).mul (hs.pow 2))) | |
| Β· exact ((contDiffOn_const.mul ((hA.mul hm).mul (hs.pow 2))).add | |
| (((hA.mul hn).mul ht).mul hs)).sub | |
| (contDiffOn_const.mul (hm.mul (ht.pow 2))) | |
| theorem multiplierQuadratic_contDiffOn | |
| {A B C m n u : Coord β β} (hU : IsOpen U) | |
| (hA : ContDiffOn β β A U) (hB : ContDiffOn β β B U) | |
| (hC : ContDiffOn β β C U) (hm : ContDiffOn β β m U) | |
| (hn : ContDiffOn β β n U) (hu : ContDiffOn β β u U) : | |
| ContDiffOn β β (multiplierQuadratic A B C m n u) U := by | |
| have hhalf {v : Coord β β} (hv : ContDiffOn β β v U) : | |
| ContDiffOn β β (fun p => v p / 2) U := | |
| hv.div contDiffOn_const (fun _ _ => two_ne_zero) | |
| have hmt := partial_contDiffOn hm hU 0 | |
| have hms := partial_contDiffOn hm hU 1 | |
| have hnt := partial_contDiffOn hn hU 0 | |
| have hAms := partial_contDiffOn (hA.mul hm) hU 1 | |
| have hAnt := partial_contDiffOn (hA.mul hn) hU 0 | |
| have hAns := partial_contDiffOn (hA.mul hn) hU 1 | |
| have hT : ContDiffOn β β (multiplierT B m n) U := | |
| (hhalf (hms.sub hnt)).add (hB.mul hn) | |
| have hS : ContDiffOn β β (multiplierS A C m n) U := | |
| ((hhalf hAms.neg).add (hhalf hAnt)).add (hC.mul hm) | |
| have hJ : ContDiffOn β β (multiplierJ A B C m n) U := | |
| ((hmt.neg.add (hB.mul hm)).sub hAns).add (hC.mul hn) | |
| have ht := partial_contDiffOn hu hU 0 | |
| have hs := partial_contDiffOn hu hU 1 | |
| exact ((hT.mul (ht.pow 2)).add (hS.mul (hs.pow 2))).add ((hJ.mul ht).mul hs) | |
| theorem multiplier_integrands_integrable | |
| {A B C m n u : Coord β β} (hU : IsOpen U) | |
| (hA : ContDiffOn β β A U) (hB : ContDiffOn β β B U) | |
| (hC : ContDiffOn β β C U) (hm : ContDiffOn β β m U) | |
| (hn : ContDiffOn β β n U) (hu : ContDiffOn β β u U) | |
| (hbox : closedRectangle tl tr sb st β U) : | |
| IntegrableOn (fun p : β Γ β => | |
| multiplierOperator A B C u (boxPoint p.1 p.2) * multiplierTest m n u (boxPoint p.1 p.2)) | |
| (Ioc tl tr ΓΛ’ Ioc sb st) β§ | |
| IntegrableOn (fun p : β Γ β => multiplierQuadratic A B C m n u (boxPoint p.1 p.2)) | |
| (Ioc tl tr ΓΛ’ Ioc sb st) := | |
| β¨rectangle_area_integrable | |
| ((multiplierTestProduct_contDiffOn hU hA hB hC hm hn hu).continuousOn.mono hbox), | |
| rectangle_area_integrable | |
| ((multiplierQuadratic_contDiffOn hU hA hB hC hm hn hu).continuousOn.mono hbox)β© | |
| theorem integrated_multiplier_identity | |
| {A B C m n u : Coord β β} (ht : tl β€ tr) (hs : sb β€ st) (hU : IsOpen U) | |
| (hA : ContDiffOn β β A U) (hB : ContDiffOn β β B U) | |
| (hC : ContDiffOn β β C U) (hm : ContDiffOn β β m U) | |
| (hn : ContDiffOn β β n U) (hu : ContDiffOn β β u U) | |
| (hbox : closedRectangle tl tr sb st β U) | |
| (hmb : zeroRectangleBoundary tl tr sb st m) | |
| (hnb : zeroRectangleBoundary tl tr sb st n) : | |
| rectangleIntegral tl tr sb st (fun p => | |
| multiplierOperator A B C u p * multiplierTest m n u p) = | |
| rectangleIntegral tl tr sb st (multiplierQuadratic A B C m n u) := by | |
| have hflux := multiplierFluxes_contDiffOn hU hA hm hn hu | |
| have hQ := multiplierQuadratic_contDiffOn hU hA hB hC hm hn hu | |
| have hFt0 : rectangleIntegral tl tr sb st (coordPartial 0 (multiplierFluxT A m n u)) = 0 := by | |
| apply rectangleIntegral_partial_t_zero ht hs hU hflux.1 hbox | |
| intro s hs' | |
| constructor <;> simp [multiplierFluxT, (hmb.1 s hs').1, (hmb.1 s hs').2, | |
| (hnb.1 s hs').1, (hnb.1 s hs').2] | |
| have hFs0 : rectangleIntegral tl tr sb st (coordPartial 1 (multiplierFluxS A m n u)) = 0 := by | |
| apply rectangleIntegral_partial_s_zero ht hs hU hflux.2 hbox | |
| intro t ht' | |
| constructor <;> simp [multiplierFluxS, (hmb.2 t ht').1, (hmb.2 t ht').2, | |
| (hnb.2 t ht').1, (hnb.2 t ht').2] | |
| have hFt := (partial_contDiffOn hflux.1 hU 0).continuousOn.mono hbox | |
| have hFs := (partial_contDiffOn hflux.2 hU 1).continuousOn.mono hbox | |
| calc | |
| rectangleIntegral tl tr sb st (fun p => | |
| multiplierOperator A B C u p * multiplierTest m n u p) = | |
| rectangleIntegral tl tr sb st (fun p => | |
| coordPartial 0 (multiplierFluxT A m n u) p + | |
| coordPartial 1 (multiplierFluxS A m n u) p + multiplierQuadratic A B C m n u p) := by | |
| apply rectangleIntegral_congr ht hs | |
| intro p hp | |
| have hpU := hbox hp | |
| have hd := multiplier_divergence_identity (B := B) (C := C) | |
| ((hA.contDiffAt (hU.mem_nhds hpU)).differentiableAt (by simp)) | |
| ((hm.contDiffAt (hU.mem_nhds hpU)).differentiableAt (by simp)) | |
| ((hn.contDiffAt (hU.mem_nhds hpU)).differentiableAt (by simp)) hu hU hpU | |
| dsimp only | |
| rw [hd] | |
| unfold multiplierQuadratic | |
| ring | |
| _ = rectangleIntegral tl tr sb st (coordPartial 0 (multiplierFluxT A m n u)) + | |
| rectangleIntegral tl tr sb st (coordPartial 1 (multiplierFluxS A m n u)) + | |
| rectangleIntegral tl tr sb st (multiplierQuadratic A B C m n u) := by | |
| have hsum : ContinuousOn (fun p => coordPartial 0 (multiplierFluxT A m n u) p + | |
| coordPartial 1 (multiplierFluxS A m n u) p) (closedRectangle tl tr sb st) := | |
| hFt.add hFs | |
| rw [rectangleIntegral_add ht hs hsum (hQ.continuousOn.mono hbox), | |
| rectangleIntegral_add ht hs hFt hFs] | |
| _ = rectangleIntegral tl tr sb st (multiplierQuadratic A B C m n u) := by | |
| rw [hFt0, hFs0] | |
| ring | |
| def cutoffM (chi : Coord β β) (edge lambda : β) (I : Coord β β) (p : Coord) : β := | |
| chi p * directedM edge lambda I p | |
| def cutoffN (chi : Coord β β) (edge lambda epsilon : β) (I : Coord β β) (p : Coord) : β := | |
| chi p * directedN edge lambda epsilon I p | |
| theorem cutoff_test_factor | |
| (chi I u : Coord β β) (edge lambda epsilon : β) (p : Coord) : | |
| multiplierTest (cutoffM chi edge lambda I) (cutoffN chi edge lambda epsilon I) u p = | |
| chi p * directedWeight edge lambda I p * | |
| (-coordPartial 1 u p + epsilon * p 0 * coordPartial 0 u p) := by | |
| unfold multiplierTest cutoffM cutoffN directedM directedN | |
| ring | |
| theorem integrated_cutoff_directed_identity | |
| {A B C chi I u : Coord β β} (ht : tl β€ tr) (hs : sb β€ st) (hU : IsOpen U) | |
| (hA : ContDiffOn β β A U) (hB : ContDiffOn β β B U) | |
| (hC : ContDiffOn β β C U) (hchi : ContDiffOn β β chi U) | |
| (hI : ContDiffOn β β I U) (hu : ContDiffOn β β u U) | |
| (hbox : closedRectangle tl tr sb st β U) | |
| (hchiSides : β s β Icc sb st, chi (boxPoint tl s) = 0 β§ chi (boxPoint tr s) = 0) | |
| (hchiBottom : β t β Icc tl tr, chi (boxPoint t sb) = 0) | |
| (lambda epsilon : β) : | |
| rectangleIntegral tl tr sb st (fun p => multiplierOperator A B C u p * | |
| multiplierTest (cutoffM chi st lambda I) (cutoffN chi st lambda epsilon I) u p) = | |
| rectangleIntegral tl tr sb st | |
| (multiplierQuadratic A B C (cutoffM chi st lambda I) (cutoffN chi st lambda epsilon I) u) := by | |
| have hW := directedWeight_contDiffOn st lambda hI | |
| have hm : ContDiffOn β β (cutoffM chi st lambda I) U := hchi.mul hW.neg | |
| have htcoord : ContDiffOn β β (fun p : Coord => p 0) U := contDiffOn_apply β β 0 U | |
| have hn : ContDiffOn β β (cutoffN chi st lambda epsilon I) U := | |
| hchi.mul ((contDiffOn_const.mul htcoord).mul hW) | |
| have hedge : zeroRectangleBoundary tl tr sb st (cutoffM chi st lambda I) β§ | |
| zeroRectangleBoundary tl tr sb st (cutoffN chi st lambda epsilon I) := by | |
| constructor | |
| Β· constructor | |
| Β· intro s hs' | |
| simp [cutoffM, (hchiSides s hs').1, (hchiSides s hs').2] | |
| Β· intro t ht' | |
| have hz := directed_mn_edge_zero st lambda epsilon I (boxPoint t st) | |
| (by simp [boxPoint]) | |
| simp [cutoffM, hchiBottom t ht', hz.1] | |
| Β· constructor | |
| Β· intro s hs' | |
| simp [cutoffN, (hchiSides s hs').1, (hchiSides s hs').2] | |
| Β· intro t ht' | |
| have hz := directed_mn_edge_zero st lambda epsilon I (boxPoint t st) | |
| (by simp [boxPoint]) | |
| simp [cutoffN, hchiBottom t ht', hz.2] | |
| exact integrated_multiplier_identity ht hs hU hA hB hC hm hn hu hbox hedge.1 hedge.2 | |
| end SmoothLocal.Weighted | |
| end | |
| end OAI | |