IUf I want to use fixed precision I need to understand this:

Block[{$MinPrecision=100, $MaxPrecision=100}, FindRoot[x^2==3, {x, 1}, WorkingPrecision->$MinPrecision]]

prec=100;
$MinPrecision=prec
$MaxPrecision=prec
 FindRoot[x^2==3, {x, 1}]
FindRoot[x^2==3, {x, 1}, WorkingPrecision->prec]

nnerrorList[2π][[-1]]
eProductSym[n]/. t-> 2.π/. n-> 150 2 -38

So at 2π  I need to subtract 38 from 2n to get accurate error.
I wonder what it is

Next time:  Up precision to 23. 
Go to 200 only? 
Add a little to pointsPerLoop:  twice.

What I need to do is delete the entire G function, but save all of them over the interval from [2π, 5 π].  Up the WorkingPrecision a lot. Run to just 100 with mx set to give all to 2π. How can I save the part up to 5π without reinterpolating?: Just delete the last N point of the IntFunc.

prec=22;
$MinPrecision=$MinPrecision=prec;
SetOptions[#, WorkingPrecision->prec, PrecisionGoal-> prec-10]& /@ {FindRoot, FindMinimum, NDSolve, NDSolveValue};
SetOptions[NDSolveValue, MaxSteps-> 3000000];
SetOptions[#, Frame->True,BaseStyle->{ FontFamily-> "Times", 12}]&/@ {ParametricPlot, ListPlot, Plot, ListLinePlot};


Clear[radPlus, FPlus, tStartValue, objFortStartMin, objFortStartSecondMin, GetDESolutionFromGPlusFortValue];
radPlusSym[2]= (Sqrt[(t/(2π))])-(eProductSym[2]/. t-> t-2π);
Options[radPlus] = {PointsPerLoop -> 1000};
radPlus[2, max_, opts___] :=radPlus[2, max, opts]=({res}= { PointsPerLoop} /. {opts} /. Options[radPlus];
Interpolation[Table[{τ, (((Sqrt[(t/(2π))])/. t-> τ)-(eProductSym[2]/. t-> τ-2π))}, {τ, N[2π,prec], max, 2π/res}]][t]);

(* requires GInt[n] defined..so we have the max on that! *) 

radPlus[n_/; n≥3, max_, opts___]:=radPlus[n, max, opts]=Module[{res},{ res}= { PointsPerLoop} /. {opts} /. Options[radPlus];

Interpolation[Table[{t, ((Norm[GInt[n-1]])-(eProductSym[2(n-1)]/. t-> t-2π))}, {t, N[2π,prec] ,max, 2π/res}]][t]];



(* I use the +1 to save some time, but I am using curves below the 4π naive limit *) 
(* 2(n-1)  is important here because each rPlus step is like two F(n) steps so we need to add two to the error formula index 
*) 

FPlus[n_, max_]:=FPlus[n, max]=radPlus[n, max] cs ;


GetDESolutionFromGPlusFortValue[n_, tStart_]:= Module[{s,b}, 
front =FPlus[n,30]; frontDer=D[front,t];
sVal=SetPrecision[s/. FindRoot[Norm[(front/. t-> s) -(front/. t-> tStart) ]==1,{s,tStart+ 2π+ArcTan[(1/(Sqrt[((6 π)/(2 π))]))]}], prec];

init=front/. t-> tStart;
b[t_]:={bx[t],by[t]};
NDSolveValue[{b'[t]==(frontDer/. t-> t+sVal-tStart).(b[t]-(front/. t-> t+sVal-tStart)) (b[t]-(front/. t-> t+sVal-tStart)),b[tStart]==init},b[t],{t,tStart-2π,15}]];

objFortStartMin[n_,tStart_?NumericQ]:=(sol=GetDESolutionFromGPlusFortValue[n,tStart];(sol-{1,0}).(sol-{1,0}));

objFortStartSecondMin[n_Integer,tStart0_?NumericQ]:=SetPrecision[FindMinimum[objFortStartMin[n,tStart0],{t,7}][[1]],prec];
(* this assumes FPlus[n] is defined *) 





tStartValue[n_]:=tStartValue[n]=(mPrint["Getting t Value"];
ans=SetPrecision[
tStart0/.FindMinimum[objFortStartSecondMin[n,tStart0], {tStart0,tStartValueApprox[n]-1/10, tStartValueApprox[n]+1/10 }][[2]], prec];
mPrint["Got  t Value"];ans);


GetNextGInt[n_, tEnd_, opts___]:= GetDEFromPrevious[n,tStartValueFunc[n],tEnd,opts];

GetDEFromPrevious[n_, tStart_,tEnd_]:= Module[{}, 
mPrint["Getting front curve from RPlus"];
front =FPlus[n, tEnd+2π+1]; frontDer=D[front,t];
mPrint["front curve done"];
sVal=s/. FindRoot[Norm[(front/. t-> s) -(front/. t-> tStart) ]==1,{s,tStart+ 2π+ArcTan[(1/(Sqrt[((6 π)/(2 π))]))]}];
init=front/. t-> tStart;
b[t_]:={bx[t],by[t]};
NDSolveValue[{b'[t]==(frontDer/. t-> t+sVal-tStart).(b[t]-(front/. t-> t+sVal-tStart)) (b[t]-(front/. t-> t+sVal-tStart)),b[tStart]==init},b[t],{t,tStart-2π,tEnd}]];

tStartData=SetPrecision[{8.59171244887019369684821867849677801132`22.,6.92485545980640893048985162749886512756`22.,6.78529154677844825727106581325642764568`22.,6.73430439811217773637963546207174658775`22.,6.7110964180005723278554796706885099411`22.,6.69927093723238442635192768648266792297`22.,6.69294900277745963279585339478217065334`22.,6.68956290799763220178419942385517060757`22.,6.68784978198161716989034175639972090721`22.,6.68716374142073100017569231567904353142`22.,6.68708634922282918466862611239776015282`22.,6.68741912525869253158816718496382236481`22.,6.68798071762011581142814975464716553688`22.,6.68879218602708291996350453700870275497`22.,6.68955723682839131782884578569792211056`22.,6.69044190801362859133405436296015977859`22.,6.69136430502738122072514670435339212418`22.,6.69231200428037187322161116753704845905`22.,6.6932391336744689880333680775947868824`22.,6.69413166166759765474125742912292480469`22.,6.69509884735774996045165607938542962074`22.,6.69597339694226256767706217942759394646`22.,6.69683676348076772910644649527966976166`22.,6.69766925760725229110903455875813961029`22.,6.69845357084437509342933481093496084213`22.,6.69933490734318226600407797377556562424`22.,6.70002222728738061618969368282705545425`22.,6.7020528156137189057517389301210641861`22.,6.70224364258621108092484064400196075439`22.,6.70211678452260706251308874925598502159`22.,6.7034331385874539321889642451424151659`22.,6.70255532040704427032551393494941294193`22.,6.70372063321881750397324140067212283611`22.,6.70573065948505320221784131717868149281`22.,6.70486282829259039317548740655183792114`22.,6.70691397975512160201105871237814426422`22.,6.70545528624882170021237470791675150394`22.,6.70749229438851823914546912419609725475`22.,6.70680183481264791112153034191578626633`22.,6.70892469266699009722287883050739765167`22.,6.70903377157565294908181385835632681847`22.,6.70776582482357408565576406545005738735`22.,6.71063389361118645126680348766967654228`22.,6.70797217637654696886784222442656755447`22.,6.71290134594102738674337160773575305939`22.,6.70912654569416577743368179653771221638`22.,6.71312184513795529028357123024761676788`22.,6.71058790834105334255355046479962766171`22.,6.7127857388167910812626359984278678894`22.,6.71124739958930049965601938311010599136`22.,6.71384015315628879250198224326595664024`22.,6.71325757160931502198764064814895391464`22.,6.71501041970508882883450496592558920383`22.,6.71032181337761279849019047105684876442`22.,6.71775301653186751593693770701065659523`22.,6.71324135753411077587315958226099610329`22.,6.71436874937811900565520772943273186684`22.,6.71604748895592962298906059004366397858`22.,6.71577867841261966219690293655730783939`22.,6.71496415790052303407264844281598925591`22.,6.71758612050161652007318480173125863075`22.,6.71411422978118643811740184901282191277`22.,6.72003415492145617093910914263688027859`22.,6.71501437432302950014673115219920873642`22.,6.71640827864642186995070005650632083416`22.,6.71869233995313219764966561342589557171`22.,6.71778639734973204156176507240161299706`22.,6.71755994785179311179490468930453062057`22.,6.71946077065874280975776855484582483768`22.,6.7174366062866806004194586421363055706`22.,6.71964778168255971735334242112003266811`22.,6.71664090593252449679084747913293540478`22.,6.72044693838461082435742355301044881344`22.,6.71898445482084749613704843795858323574`22.,6.72241391287596723458364067482762038708`22.,6.71922603258080552990350042819045484066`22.,6.71870684580107901950896120979450643063`22.,6.71994884018719229601401821128092706203`22.,6.72359915712268119136751920450478792191`22.,6.71836028521908001920337483170442283154`22.,6.72224934504701110427049570716917514801`22.,6.7186358907213117319656703330110758543`22.,6.72155351538505119179944813367910683155`22.,6.72431768163905285717873994144611060619`22.,6.72176298789097792507618578383699059486`22.,6.72038744039955204812031297478824853897`22.,6.72081618005779990454584549297578632832`22.,6.72438414013160379312239456339739263058`22.,6.72395306047643792624057823559269309044`22.,6.72023572009634584389914380153641104698`22.,6.72358410892462821095705294283106923103`22.,6.72102388139155149104908559820614755154`22.,6.7246578981292648435896808223333209753`22.,6.72094824207793184456249946379102766514`22.,6.72207819110297499776152108097448945045`22.,6.72556176322718712867754220496863126755`22.,6.72318017948579349507554070441983640194`22.,6.72802706410312545415308704832568764687`22.,6.72266026285526852035445699584670364857`22.}, prec];

tStartValueApprox[i_]:=Round[100  tStartData[[Min[i-1, Length[tStartData]-1]]]]/ 100;

40 2π 1.+ 2π

GInt[13]

920/2/π //N

mx=3000;mxxxx=920;
resPerLoop=1000;

GInt[2]=
(sol=GetDEFromPrevious[2, tStartValue[2], mx];
angle=t/.FindRoot[sol[[2]]==0, {t, 2π}];
backSolPts=Table[sol,{t,angle,intDomMax[sol[[1]]],2π/resPerLoop}];
old=atn[init];old={1,0};
loops=If[backSolPts[[1,2]]≥0, 1,0];
ans=Interpolation[Table[new=atn[backSolPts[[i]]];If[new<old,loops++];old=new;
{atn[backSolPts[[i]]]+2 π loops,backSolPts[[i]]},{i,Length[backSolPts]}]][t];
Clear[radPlus, FPlus];
radPlus[n_/; n≥3, max_, opts___]:=radPlus[n, max, opts]=Module[{res},{ res}= { PointsPerLoop} /. {opts} /. Options[radPlus];
Interpolation[Table[{t, ((Norm[GInt[n-1]])-(eProductSym[2(n-1)]/. t-> t-2π))}, {t, N[2π,prec] ,max, 2π/res}]][t]];
FPlus[n_, max_]:=FPlus[n, max]=radPlus[n, max] cs ;
ans
);//AbsoluteTiming

2

2

intDomMax[GInt[2]]
GInt[2]/. t-> 10//Precision

The π/3 seems essential here.

functionsToKeep = {64, 128, 256, 100,200,400};
functionsToKeep = Range[2,100];
errorsToStore={2π, 20π};
errorsToStore={};
Do[errorList[x] ={}, {x, errorsToStore}]

Do[Print[{n, intDomMax[GInt[n-1]]}];
GInt[n]=(
sol=GetDEFromPrevious[n, tStartValue[n], intDomMax[GInt[n-1]]-2π-π/3]; 
angle=t/.FindRoot[sol[[2]]==0, {t, 6}];
backSolPts=Table[sol,{t,angle,intDomMax[sol[[1]]],2π/resPerLoop}];
old=atn[init[n]];
loops=If[backSolPts[[1,2]]≥0, 1,0];
Interpolation[Table[new=atn[backSolPts[[i]]];If[new<old,loops++];old=new;
{atn[backSolPts[[i]]]+2 π loops,backSolPts[[i]]},{i,Length[backSolPts]}]][t]);

Clear[radPlus, FPlus];
radPlus[n_/; n≥3, max_, opts___]:=radPlus[n, max, opts]=Module[{res},{ res}= { PointsPerLoop} /. {opts} /. Options[radPlus];
Interpolation[Table[{t, ((Norm[GInt[n-1]])-(eProductSym[2(n-1)]/. t-> t-2π))}, {t, N[2π,prec] ,max, 2π/res}]][t]];
FPlus[n_, max_]:=FPlus[n, max]=radPlus[n, max] cs ;


If[n-2≥3 && !MemberQ[functionsToKeep,n-2], Unset[GInt[n-2]]];
Do[ AppendTo[errorList[x], {n, bikeErrorBetter[GInt[n], D[GInt[n], t], {t, x}]}],{x, errorsToStore}], 
 {n,3,100}]//AbsoluteTiming

47303/3600.

MemoryInUse[]

6124/3600.

errorList[2π]

intDomMax[GInt[115]]

nnn=400;
ParametricPlot[Log10[{t, (Sqrt[(t/(2π ))])-Norm@GInt[nnn]}], {t, 2π, intDomMax[GInt[nnn]]}, PlotRange->All]

Show[Plot[-2.07 -1.5 L, {L, .45, 2.8}, PlotStyle->{at@10,Lighter@ Blue, CapForm->None}],
ListPlot[dL=Log10[errorList[2π]],Mesh->All, PlotStyle->{ap@4.5,Yellow}],
 PlotRange->{{.4, 2.05; 2.8}, {-6.2,-2} },Frame->True, PlotRangePadding->0,GridLines->{{Log10[400],2},{-6, -5} }, GridLinesStyle->White, 
FrameTicks->{{{#,(("10")^(ToString@#))}& /@ {-2,-3,-4,-5,-6,-7},{}},{{#,10^#}& /@ Log10[{2,10,  50, 100, 400}],{}}}, Background->Black,Axes->False, FrameTicksStyle-> White, PlotLabel-> Style[Row[{"Largest index n in (Subscript[G, n]) is ", n, "; fitting curve is (1/114) (n^(-3/2))" }], White, 20], ImageSize-> 700]

Show[Plot[-2.06 -1.5 L, {L, .45, 2.8}, PlotStyle->{at@10,Lighter@ Blue}],
ListPlot[dL=Log10[errorList[20π]],Mesh->All, PlotStyle->{ap@4,Yellow}],
 PlotRange->{{.4, 2.05; 2.8}, {-7.2,-2} },Frame->True, PlotRangePadding->0,GridLines->{{Log10[400],2},{-6, -5} }, GridLinesStyle->White, 
FrameTicks->{{{#,(("10")^(ToString@#))}& /@ {-2,-3,-4,-5,-6,-7},{}},{{#,10^#}& /@ Log10[{2,10,  50, 100, 400}],{}}}, Background->Black, FrameTicksStyle-> White]

fit=Fit[dL[[-35;; -25]], {1,L}, L]

errorList[2π][[-1]]

10^2.06

n=50; 
intDomMax[GInt[400]]
intDomMax[GInt[100]]
Length[GInt[100][[0,3,1]]]/ 100.

τ

n=200;
GIntDer[n] = D[GInt[n], t];
data=Table[{10^τ,bikeErrorBetter[GInt[n],GIntDer[n], {t, 10^τ}, WorkingPrecision-> MachinePrecision, PrecisionGoal-> 5]},{τ,Log10[2.π],Log10[intDomMax[GInt[200]]-10π ],(Log10[intDomMax[GInt[200]]-10π]-Log10[2π])/30}];

ListLinePlot[data//Log10, Mesh->All, FrameTicks->{{{#,(("10")^(ToString@#))}& /@ {-2,-3,-4,-5,-6,-7, -5.5,-6.5},{}},{{#,10^#}& /@ Log10[{2π,10π,50 π, 100 π, 200π}],{}}}, PlotRange->{{Log10[5], Log10[180 π]}, {-7, -5}}, PlotLabel-> "Unibike error for (Subscript[G, 200])"]

, 200 π

functionsToKeep

n=2

errorG2π=Table[{n,bikeErrorBetter[GInt[n],(∂_t)GInt[n],{t,2 π}]},{n,2, 119,1}];
errorG2π[[-1]]//Log10

ListPlot[dL=Log10@errorG2π, Frame->True, PlotRange-> {-6, -2}]

2 is  like 3
3 is like 5
4 like 7
51 is like 20
102 is like 203

try=((((2^(1.5 ))GInt[200]- GInt[100]))/((2^(1.5 ))-1));
intDomMax[GInt[200]]

Show[ParametricPlot[F[t], {t, 2π, 40}, PlotStyle->{at@5,Blue}],
ParametricPlot[try, {t, 2π, 40}, PlotStyle->{at@1,Yellow}], Background->Black, Axes->False, FrameTicksStyle->White]

Show[Plot[Norm[F[t]],{t,2 π,40},PlotStyle->{at[5],Blue}],Plot[Norm[try],{t,2 π,40},PlotStyle->{at[1],Yellow}],Background->Black,Axes->False, PlotRange->All,  FrameTicksStyle->White]

intDomMax[GInt[200]]/π

dataRomberg=Table[{(10^τ),bikeErrorBetter[try,(∂_t)try,{t,(10^τ)},WorkingPrecision->MachinePrecision,PrecisionGoal->6]},{τ,Log10[2. π],Log10[400 π],((Log10[200])/200)}];

10^τ//N

τ//N

ListLinePlot[dataRomberg//Log10, PlotStyle->Yellow, PlotRangePadding->0,GridLines->{{Log10[600],Log10[2π]},{-6, -7} }, GridLinesStyle->White, 
FrameTicks->{{{#,(("10")^(ToString@#))}& /@ {-2,-3,-4,-5,-6,-7},{}},{{#,10^#}& /@ Log10[{2π, 10π,  50π, 100π, 400π}],{}}}, Background->Darker@Blue, 
PlotRangePadding->0,FrameTicksStyle-> White, PlotRange->{Log10@{6, 1400},  {-9, -5.8}}, PlotLabel->Style[ "Error for  \!\(\*FractionBox[\(\*SuperscriptBox[\(2\), \(\(3/2\)\(\\ \)\)]\\ G \((200)\)\\  - \\ G \((100)\)\), \(\*SuperscriptBox[\(2\), \(3/2\)]\\  - \\ 1\)]\)", Yellow]]

dataRomberg[[1]]

n=25;
((intDomMax[GInt[n]])/(2 π))

errorTable[n]=Table[{τ,bikeErrorBetter[GInt[n],(∂_t)GInt[n],{t,τ}]},{τ,2 π,10 π,π/3}];

intDomMax[GInt[35]]

Show[
ListLinePlot[Log10@errorTable[n], PlotRange->All, PlotStyle->Red, Mesh->All], PlotRange->All, Mesh->All, Frame->True]

Show[
ListLinePlot[Log10@dataRomberg, PlotRange->All, Frame->True],
ListLinePlot[Log10@dataG50, PlotRange->All, PlotStyle->Red], PlotRange->All]

Fit[dL[[-8;;-1]], {1,L}, L]

nn=100;
ParametricPlot[GInt[nn], {t, 2π, intDomMax[GInt[nn]]}, PlotPoints-> 500, PlotStyle->{Red, at@1}]

To Do

GInt[50]
96/π //N

nmax = 50;
Show[Table[Plot[(Sqrt[(t/(2π))])- Norm[GInt[n]],{t, 2π, 30 π; 16 π}, PlotPoints->100, Frame->True, PlotStyle->{at@.5, Hue[(n-2)/nmax /2 ]}], {n, 2, nmax; 50}], PlotRange->All, Background->Black, FrameTicksStyle-> White, ImageSize->600, GridLines-> {{4π}, {}}, GridLinesStyle->White, PlotRange->All]

data=Table[{n,(Sqrt[(t/(2 π))]) -Norm[GInt[n]]/. t->4 π},{n,2,40}];
dataΔ=Table[{n,((Sqrt[(t/(2 π))]) -Norm[GInt[n]])-((Sqrt[(t/(2 π))]) -Norm[GInt[n-1]])/. t->4 π},{n,3,40}];

ListPlot[data]
ListPlot[dL=dataΔ//Log10]
Fit[dL[[-4;;-1]], {1,L}, L]

(Sqrt[4π/(2π)])-(data[[-1,-1]]+Sum[(10^(-1.71))(n^(-1.55 )), {n,41, ∞}])
Norm[GInt[40]]/. t-> 4.π

fitData=Table[{τ, seqDiffs=Table[{n, -Norm[GInt[n]]+Norm[GInt[n-1]]/. t->τ}, {n,3,40}];
10^Fit[Log10[seqDiffs][[-5;;-1]], {1,L}, L][[1]]}, {τ, 2π, 4π, π/20}];

fitData

ListLinePlot[fitData, PlotRange->All, Mesh->All]

Sum[(1/((10^2) (n^(3/2)))), {n,1,∞}]

seqDiffs

intDomMax[GInt[100]]/π

nmax=50;
im1=Show[Table[ ParametricPlot[Log10@{t, (Sqrt[(t/(2π))])- Norm[GInt[n]]},{t, 2π, 50 π}, Frame->True, PlotStyle->{at@1, Hue[(n-2)/nmax /2 ]}], {n, 2, nmax, 1}], PlotRange->All, Background->Black, AspectRatio-> .6, FrameTicksStyle->White]

compare=Show[im1, ParametricPlot[Log10[{t, (Sqrt[(t/(2π))])-limFunc}], {t, 2π, 5π}, PlotStyle->{at@1,White}], PlotRange->{{Log10[2π], Log10[5π]}, {-3, -1.4}}]

Show[compare, PlotRange-> {{Log10[5π-.3], Log10[5π]} , {-1.8,-1.65}}]

Show[Table[Plot[Log10[limFunc-Norm[GInt[n]]], {t, 2π, 5π}], {n, 80, 100,  1}], PlotRange->All]

im2=Show[Table[ ParametricPlot[{t, (Sqrt[(t/(2π))])- Norm[GInt[n]]},{t, 15, 50 π}, Frame->True, PlotStyle->{at@1, Hue[(n-2)/nmax /2 ]}], {n, 2, nmax, 10}], PlotRange->All, Background->Black, AspectRatio-> .6, FrameTicksStyle->White]

Try Pochhammer sum to get limit approx.

Here we try to use the Pochhammer estimate to estimate (Subscript[G, n]) by repeatedly subtracting the error. THis is a good idea.

n=.;
term=Normal[Series[eProductSym[n]/. t-> t-2π,{n,∞,2}]]//Simplify
sum=Sum[term, {n,2,∞}]

intDomMax[GInt[100]]/π

sum/. t-> 10.

Show[im2, ParametricPlot[{t,sum }, {t, 15, 30π}, PlotStyle->{at@5, White}],

Graphics[{ap@9,White,Point[Identity[{{t,  (Sqrt[(t/(2π))])- Norm[GInt[43]]},{t,  (Sqrt[(t/(2π))])- Norm[GInt[2]]}}/. t-> 30π]]}], 
 AspectRatio-> .6];

Show[im1, ParametricPlot[Log10[{t, sum /((1/((8)))(((t))^(3/4)))}], {t, 2π, 50π}, PlotStyle->{at@3, White}], 
 AspectRatio-> .6, PlotRange->{ {1.2, 2.25},{ -3.2, -1.8}}, PlotRangePadding->0];

ParametricPlot[Log10[{t, limFunc//Norm}], {t, 2π, 50π}, PlotStyle->{at@3}]

Show[im1, ParametricPlot[Log10[{t, (Sqrt[(t/(2π))])-limFunc}], {t, 2π,5π}, PlotStyle->{at@3, White}], 
 AspectRatio-> .6, PlotRange->{ {Log10[2π],Log10[5π]},{-8,-1}}, PlotRangePadding->0]

I could and should add n=1 to this. Well, that value would be just 0. Not sure.  ReInterpolation is not working at all.

seq=.;
seq[τ_]:= seq[τ]=Table[{n, (Sqrt[(t/(2π))])-Norm[GIntReinterpolate[n]]/. t-> τ}, {n, 2, 100,1}]
SequenceLimit[Last/@seq[80π]]

Length[tt]

τ/π//N

There are method options here. I guess WP is respected. Euler method seems to give a smooth limit.

SequenceLimit[Last/@seq[3π], Method->#]& /@ {"BrezinskiTheta","Euler","WynnEpsilon","NSequenceLimit",Automatic}
Interpolation[tt][3π]

tt=Table[{τ, SequenceLimit[Last/@seq[τ], Method->("Euler")]}, {τ, 2π,5π, π/1000}];//Timing

τ/π 1.

limFunc=(Sqrt[(t/(2π))])-Interpolation[tt][t];
tt[[-1]]
try=limFunc cs;

ParametricPlot[Log10[{t, (Sqrt[(t/(2π))])-limFunc}], {t, 2π, 5π}, PlotStyle->{at@1, Red}]

GIntReinterpolate//Clear
GIntReinterpolate[n_] :=GIntReinterpolate[n]= Interpolation[Table[{t, GInt[n]}, {t, 2π, 5π, π/3000}]][t]

|

bikeErrorBetter[GIntReinterpolate[50], D[GIntReinterpolate[50], t], {t, 2π},InitialLoops->{0}]
bikeErrorBetter[GInt[50], D[GInt[50], t], {t, 2π},InitialLoops->{0}]

limFunc/. t-> 2 π

Show[ParametricPlot[try, {t,2π, 5π}, PlotStyle->{at@8, Blue}], ParametricPlot[Evaluate[try+unit@D[try,t]], {t,2π, 5π}, PlotStyle->Yellow], Background->Black]

5

data=Table[{τ, bikeErrorBetter[try, D[try, t],{t, τ}, InitialLoops->{0},  PrecisionGoal->10]}, {τ, 2π, 50/20 π, π/5}]

bikeErrorBetter[GInt[100], D[GInt[100],t], {t, 2π}]

Show[ListLinePlot[Log10[data], PlotStyle->Red],ListLinePlot[ Log10[Table[{τ,bikeErrorBetter[GInt[50], D[GInt[50],t], {t, τ}]}, {τ, 2π, 5/2 π, π/5}]]], PlotRange->All]

vals=Table[{n, (Sqrt[(t/(2π))])-Norm[GInt[n]]/. t-> 80π}, {n, 2, 100}];

seq=Accumulate[4 Table[(-1)^k/(2 k+1),{k,0,8}]]

lim=SequenceLimit[Last/@ vals]
Last/@vals-lim //Abs//ListLogPlot

vF=Interpolation[vals, InterpolationOrder->1][t];
Plot[vF, {t, 2, 100}, GridLines->{}]

ListPlot[vals/. {x_, y_}:> {x, Log10@y}]

What if I do not correct? Can I get close to 0 error?

Show[ParametricPlot[{t,(1/(((4 (t-2 π)))^1.75))},{t,2 π,30 π},PlotStyle->Red,PlotRange->{0,.04}];ParametricPlot[Log10@{t,-(((Sqrt[(t/(2 π))])-Norm[GInt[20]])-(sum/((t^(3/4))/(2 π))))},{t,2 π,50 π}],PlotRange->All,AspectRatio->.6]

series[sum, 2]//Expand

ParametricPlot[Log10@{t,sum-((Sqrt[(t/(2π))])-Norm[GInt[50]])}, {t, 22π, 30π}, AspectRatio->.6, PlotRange->All]
dL=Table[{Log10@t,Log10@sum-Log10@((Sqrt[(t/(2π))])-Norm[GInt[50]])}, {t, 22π, 30π, π/40}]//N;
fit=Fit[dL[[-10;;-1]], {1,L}, L]
10^fit[[1]]

(10^fit[[1]])

1/30.

{(Sqrt[(t/(2π))]),Norm[GInt[2]], Norm[GInt[3]]}/. t-> 50π

Show[im1, ParametricPlot[{t, sum }, {t, 15, 30π}, PlotStyle->{at@5, White}],

Graphics[{ap@9,White,Point[[{{t,  (Sqrt[(t/(2π))])- Norm[GInt[3]]},{t,  (Sqrt[(t/(2π))])- Norm[GInt[2]]}}/. t-> 30π]]}], 
 AspectRatio-> .6, PlotRange->All]

τ=10.π;n=49;
(Norm[GInt[n]]- Norm[GInt[n+1]]/. t-> τ)//Log10
bikeErrorBetter[GInt[n+1], D[GInt[n+1], t], {t, τ-2π}]//Log10
eProductSym[n+1]/. t-> τ-2π//Log10

intDomMax[GInt[3]]/π

Explaining Pochhammer

Clear[p];
p[1]=ParametricPlot[F[t],{t,2 π,4 π+.88},PlotStyle->Red, PlotPoints-> 500];
p1Front=ParametricPlot[Evaluate[F[t]+unit[(∂_t)F[t]]],{t,2 π-.3,2 π+.88},PlotStyle->Black];
p[i_/; i≥2]:=p[i]=ParametricPlot[FInt[i],{t,2 π,4 π+.8}, PlotPoints-> 500,PlotStyle->{at[1],Black}];
t0=bikeErrorBetterFInt[2, 2π, Output-> loc]

im=Show[p1Front; p/@Range[2],
Graphics[{{Blue,Arrow[{FInt[2], fr=FInt[2]+unit[FIntDer[2]]/. t-> 2π}/. t-> 2π]},
{Red,Arrow[{FInt[1], fr1=FInt[1]+unit[FIntDer[1]]/. t-> 2π}/. t-> 2π]}; 
{EdgeForm[Black], FaceForm[{Opacity[.2],White}],Disk[fr, bikeErrorBetterFInt[2, 2π]]},
{EdgeForm[Black], FaceForm[{Opacity[.2],White}],Disk[fr1, .01365]}; 
{ap[5],Point[FInt[2]/. t-> t0], Point[fr], Point[FInt[2]/. t-> 2π+2π+ArcCot[1]], Text["\!\(\*SubscriptBox[\(F\), \(\(1\)\(\\ \)\)]\)(= Φ((Subscript[F, 2])))", {1.052,1.015}],
Text["(Subscript[F, 2]) (=Ω((Subscript[F, 1])))", {1.036,1.008}]}
}], Frame->True, PlotRange->({{1.02, 1.07}, {.98, 1.03}}), PlotRangePadding->0, Axes->False, BaseStyle->{14, FontFamily->"Times"}]

Caption: THis is all for 2π. For larger the two points on (Subscript[F, 2]) are much much closer. And one could use  an α extension to get closer?

Red curve is (Subscript[F, 1]) near 4π+0.7;
Black curve is (Subscript[F, 2]), near 4π+0.7;  Note: Front((Subscript[F, 2]))=(Subscript[F, 1])
Blue arrow is the bike from (Subscript[F, 2])(2π) to (Subscript[F, 2,front])(2π)
Circle center is (Subscript[F, 2,front])(2π). Circle radius is the error for (Subscript[F, 2]) at 2π. So we learn here that (Subscript[radius, 2])(4π+.7) roughly equals (Subscript[radius, 1])(4π+.7) less error for (Subscript[F, 2]) at 2π.

 (Subscript[r, 2])(t+2π+arccot((Sqrt[(t/(2π))])))≈(Subscript[r, 1])(t+2π+arccot((Sqrt[(t/(2π))])))-(Subscript[E, 2])(t)
 simpler and just as good is 

 (Subscript[r, 2])(t+2π)≈(Subscript[r, 1])(t+2π)-(Subscript[E, 2])(t)  or     (Subscript[r, 2])(t)≈(Subscript[r, 1])(t)-(Subscript[E, 2])(t-2π) .  So different forms here are:
 (Subscript[r, 2])(t)≈(Subscript[r, 1])(t)-(Subscript[E, 2])(t-2π-(cot^(-1))(Sqrt[(t/(2π))]))
 (Subscript[r, 2])(t)≈(Subscript[r, 1])(t)-(Subscript[E, 2])(t-2π-(Sqrt[((2π)/t)]))
 (Subscript[r, 2])(t)≈(Subscript[r, 1])(t)-(Subscript[E, 2])(t-2π)
  
All these are good asymptotically.  This last can be used to define (Subscript[r, 2]) on the domain [4π, M] if we can approximate (Subscript[r, 2])
So I had huge error here re error1 vs error2????

And do a zoom plot on G[large} showing the error at 2π and saying that that is the max.

Options[SequenceLimit]={Method->Automatic};

SequenceLimit[l_List,opts:OptionsPattern[]]:=With[{res=sequenceLimit[OptionValue[Method],l]},
res/;!FailureQ[res]&&Head[res]=!=NumericalMath`NSequenceLimit
]

$crossoverLength=10;
$methods={"BrezinskiTheta","Euler","WynnEpsilon","NSequenceLimit",Automatic};

sequenceLimit["NSequenceLimit",l_]:=builtIn[l]

sequenceLimit[{Automatic|"NSequenceLimit"|"Automatic",mopts___},l_]:=builtIn[l,mopts]

sequenceLimit[Automatic|"Automatic",l_]:=If[VectorQ[l,MachineNumberQ]&&Length[l]≥$crossoverLength,builtIn[l],wynnEpsilon[l,1]]

sequenceLimit["BrezinskiTheta",seq_]:=btheta[seq]

sequenceLimit["WynnEpsilon",seq_]:=wynnEpsilon[seq,1]

sequenceLimit[{"WynnEpsilon",mopts__},seq_]:=wynnEpsilon[seq,"Parameter"/.{mopts}/.{"Parameter"->1}]

sequenceLimit["Euler",seq_]:=eulerKnopp[seq,-1]

sequenceLimit[{"Euler",mopts__},seq_]:=eulerKnopp[seq,"EulerRatio"/.{mopts}/.{"EulerRatio"->-1}]

sequenceLimit[x_,_]:=(
ResourceFunction["ResourceFunctionMessage"][SequenceLimit::moptxn,x,Method->x,$methods];
$Failed
)

builtIn[l_,mopts___]:=NumericalMath`NSequenceLimit[l,Method->{"WynnEpsilon",mopts}]

eulerKnopp[seq_?VectorQ,q_?NumericQ]:=Module[{n=Length[seq],ek},
ek[1]=0;
Do[
ek[k+1]=seq[[k]];
Do[
ek[j]+=(ek[j+1]-ek[j])/(1-q),
{j,k,1,-1}],
{k,n}];
ek[1]]

wynnEpsilon[seq_?VectorQ,h_?NumericQ]:=Module[{n=Length[seq],ep,v,w,pw},
Do[
ep[k]=seq[[k]];w=0;
Do[
v=w;w=ep[j];pw=10^-Precision[w];
ep[j]=v If[OddQ[k-j],h,1]+
If[!TrueQ[Abs[ep[j+1]-w]≤pw],
ep[j+1]-w,
pw
]^-1,
{j,k-1,1,-1}],
{k,n}];
ep[Mod[n,2,1]]]

btheta[seq_?VectorQ]:=Module[{n=Length[seq],de,ef,el,tha,thb,u,v,w,ya},
tha[1]=thb[1]=0;
Do[el=Quotient[2k-1,3];
If[OddQ[k],
v=0;u=tha[1];
tha[1]=seq[[k]];
Do[w=v;v=u;
If[ValueQ[tha[j+1]],u=tha[j+1]];
ef=1;
de=tha[j]-thb[j];
If[EvenQ[j],
ef=de(thb[j-1]-w);
de-=thb[j]-v];
tha[j+1]=(ya=w+ef/de),
{j,1,el}];
tha[el+Boole[EvenQ[el]]],
v=0;u=thb[1];
thb[1]=seq[[k]];
Do[w=v;v=u;
If[ValueQ[thb[j+1]],u=thb[j+1]];
ef=1;
de=thb[j]-tha[j];
If[EvenQ[j],
ef=de(tha[j-1]-w);
de-=tha[j]-v];
thb[j+1]=(ya=w+ef/de),
{j,1,el}];
thb[el+Boole[EvenQ[el]]]],
{k,n}];
If[OddQ[n],
tha[el+Boole[EvenQ[el]]],
thb[el+Boole[EvenQ[el]]]]]