Making the table  for T=(5/7),1,2.

Validating the  top of  the table, by loading the  zeros

Andrew[5/7,0,0]=42;
Andrew[5/7,0,1]=172;
Andrew[5/7,0,2]=934;
Andrew[5/7,1,0]=16;
Andrew[5/7,1,1]=66;
Andrew[5/7,1,2]=934;

Andrew[1,0,0]=36;
Andrew[1,0,1]=148;
Andrew[1,0,2]=844;
Andrew[1,1,0]=12;
Andrew[1,1,1]=42;
Andrew[1,1,2]=408;
Andrew[1,1,3]=844;

Andrew[2,0,0]=16;
Andrew[2,0,1]=28;
Andrew[2,0,2]=120;
Andrew[2,0,3]=330;
Andrew[2,0,4]=634;
Andrew[2,1,0]=10;
Andrew[2,1,1]=18;
Andrew[2,1,2]=64;
Andrew[2,1,3]=210;
Andrew[2,1,4]=630;
Andrew[2,1,5]=634;

Andrew[T_,a_,k_]:=Andrew[T,a,k-1];

<<DirichletCharacters`

(*PC[q] is a list of primitive characters with conductor q, including 1 from  each conjugate pair *)
(*PC[q,0] is a list of primitive characters with conductor q that are even, including just 1 from each conjugate pair, and PC[q,1] is the same for odd characters *)
PC[q_]:=PC[q]=Select[PrimitiveCharacters[q],ConreyIndex[#]≤ConreyIndex[ConjugateCharacter[#]]&];
PC[q_,0]:=PC[q,0]=Select[PC[q],EvenQ];
PC[q_,1]:=PC[q,1]=Complement[PC[q],PC[q,0]];

AbsoluteTiming[Monitor[Do[PC[q];PC[q,0];PC[q,1],{q,1,934}],q]]

(* This version of NTchi only works for characters in PC. *)
NTchi[T_,chi_]:=Block[{max,zeros},
zeros=CharacterData[chi][[Key["zeros"]]];Count[zeros,_?(Abs[#]≤T&)]]

The entries in the Table are correct

(* The function Andrew[(5/7),0,k] is defined correctly *)
(* T = 5/7 , 0≤k≤2 , a=0*)
Monitor[Block[{T=(5/7),a=0},
Table[Max[Table[Max[Map[NTchi[T,#]&,PC[q,a]]],{q,If[k==0,1,Andrew[T,a,k-1]+1],Andrew[T,a,k]}]],{k,0,2}]],q]

(* The function Andrew[(5/7),1,k] is defined correctly  *)
(* T = 5/7 , 0≤k≤2 , a=1*)
Block[{T=5/7,a=1},
Table[Max[Table[Max[Map[NTchi[T,#]&,PC[q,a]]],{q,If[k==0,1,Andrew[T,a,k-1]+1],Andrew[T,a,k]}]],{k,0,2}]]

(* The function Andrew[1,a,k] is defined correctly  *)
(* T = 1 *)
Block[{T=1,a=0},
Table[Max[Table[Max[Map[NTchi[T,#]&,PC[q,a]]],{q,If[k==0,1,Andrew[T,a,k-1]+1],Andrew[T,a,k]}]],{k,0,2}]]

Block[{T=1,a=1},
Table[Max[Table[Max[Map[NTchi[T,#]&,PC[q,a]]],{q,If[k==0,1,Andrew[T,a,k-1]+1],Andrew[T,a,k]}]],{k,0,3}]]

(* The function Andrew[2,a,k] is defined correctly  *)
(* T = 2 *)
Block[{T=2,a=0},
Table[Max[Table[Max[Map[NTchi[T,#]&,PC[q,a]]],{q,If[k==0,1,Andrew[T,a,k-1]+1],Andrew[T,a,k]}]],{k,0,4}]]

Block[{T=2,a=1},
Table[Max[Table[Max[Map[NTchi[T,#]&,PC[q,a]]],{q,If[k==0,1,Andrew[T,a,k-1]+1],Andrew[T,a,k]}]],{k,0,5}]]

The number of characters and zeros being handled

Sum[Length[PC[q]],{q,3,933}]

Monitor[Sum[Total[Map[Length[CharacterData[#][[Key["zeros"]]]]&,PC[q]]],{q,Select[Range[3,933],Mod[#,4]≠2&]}],q]

N(T,χ)=0

Monitor[smallestells=Flatten[Table[(*for each q*)
Table[(*for each chi*)
max=CharacterData[chi][["maxheight"]];
zeros=CharacterData[chi][["zeros"]];
{q,Log[((q(If[Length[zeros]==0,max,Abs[zeros[[1]]]]+2))/(2π))]},
{chi,PC[q]}],
{q,Select[Range[3,934],Mod[#,4]≠2&]}],1];,q]

ListPlot[smallestells,PlotRange->{0,7}]
ListPlot[smallestells,PlotRange->{{0,30},{0,4}},PlotStyle->PointSize[Medium]]

The (ell/(log(2+ell))) bound

flaws={};
Monitor[Do[
chars=PC[q,a];
Do[(*for each character*)
zeros=CharacterData[chi][["zeros"]];
real=CharacterData[chi][["real"]];
Do[(*for each zero*)
{zl,zu}=Abs[zeros[[k]]]+(10^(-12)){-2,2};
lterml=((Log[((q (zl+2))/(2π))])/(Log[2+Log[((q (zl+2))/(2π))]]));
Tterml=(zl/π)Log[((q zl)/(2π E))]+(a/2)-(1/4);
If[Not[If[real,2,1]*k≤Tterml+lterml],AppendTo[flaws,{chi,zeros[[k]]}]],
{k,Length[zeros]}],
{chi,chars}],
{q,Select[Range[3,934],Mod[#,4]≠2&]},{a,0,1}],{q,flaws}];
flaws

<<IntervalTools`

flaws={};
Do[
chars=PC[q,a];
Do[(*for each character*)
zeros=CharacterData[chi][["zeros"]];
real=CharacterData[chi][["real"]];
Do[(*for each zero*)
maxz=Abs[zeros[[k]]]+2 (10^(-12));
If[maxz≥(5/7)&&maxz≥((2 ((E^(197/125)) π-q))/q),
lower=Max[If[k==1,0,Abs[zeros[[k-1]]]-(2/(10^12))],(5/7),((2 ((E^(197/125)) π-q))/q)];
upper=maxz;
lterm[g_Interval]:=Interval[{((Log[((q (Min[g]+2))/(2π))])/(Log[2+Log[((q (Min[g]+2))/(2π))]])),((Log[((q (Max[g]+2))/(2π))])/(Log[2+Log[((q (Max[g]+2))/(2π))]]))}];
Tterm[g_Interval]:=If[Min[g]≥((2 π)/q)||Max[g]≤((2 π)/q),Interval[{((Min[g])/π)Log[((q Min[g])/(2π E))]+(a/2)-(1/4),((Max[g])/π)Log[((q Max[g])/(2π E))]+(a/2)-(1/4)}],
Interval[(a/2)-(1/4)+{0,Max[((Min[g])/π)Log[((q Min[g])/(2π E))],((Max[g])/π)Log[((q Max[g])/(2π E))]]}]];

target=If[real,2k-2,k-1];
F[T_]:=target-((T/π)Log[((q T)/(2π E))]+(a/2)-(1/4)-((Log[((q (T+2))/(2π))])/(Log[2+Log[((q (T+2))/(2π))]])));
gapF[g_Interval]:=target-(Tterm[g]-lterm[g]);

cert=ProveNonNegative[F,gapF,{Interval[{lower,upper}]},MaxDepth->10];

If[Length[cert[[1]]]+Length[cert[[2]]]>0,AppendTo[flaws,{chi,zeros[[k]]}]]],
{k,Length[zeros]}],
{chi,chars}],
{q,Select[Range[3,933],Mod[#,4]≠2&]},{a,0,1}]

flaws

Finding the best c,r.

We will use the stronger version of  Backlund’s Trick, and only check afterwards that its hypotheses are  satisfied.

The Gamma Spread: E(a,d,T)

Er[a_,d_,T_]=((4 (4+3 π))/(45 ((((((17+2 a))^2)+4 (T^2)))^(3/2))))-((4 T)/(3 ((((17+2 a))^2)+4 (T^2))))+((8+6 π)/(45 ((((((17+2 a-2 d))^2)+4 (T^2)))^(3/2))))+((2 T)/(3 ((((17+2 a-2 d))^2)+4 (T^2))))+((8+6 π)/(45 ((((((17+2 a+2 d))^2)+4 (T^2)))^(3/2))))+((2 T)/(3 ((((17+2 a+2 d))^2)+4 (T^2))))+2 ArcTan[((1+2 a)/(2 T))]+2 ArcTan[((5+2 a)/(2 T))]+2 ArcTan[((9+2 a)/(2 T))]+2 ArcTan[((13+2 a)/(2 T))]-(1/2) (15+2 a) ArcTan[((17+2 a)/(2 T))]-ArcTan[((1+2 a-2 d)/(2 T))]-ArcTan[((5+2 a-2 d)/(2 T))]-ArcTan[((9+2 a-2 d)/(2 T))]-ArcTan[((13+2 a-2 d)/(2 T))]+(1/4) (15+2 a-2 d) ArcTan[((17+2 a-2 d)/(2 T))]-ArcTan[((1+2 a+2 d)/(2 T))]-ArcTan[((5+2 a+2 d)/(2 T))]-ArcTan[((9+2 a+2 d)/(2 T))]-ArcTan[((13+2 a+2 d)/(2 T))]+(1/4) (15+2 a+2 d) ArcTan[((17+2 a+2 d)/(2 T))]+(1/2) T Log[1+((((17+2 a))^2)/(4 (T^2)))]-(1/4) T Log[1+((((17+2 a-2 d))^2)/(4 (T^2)))]-(1/4) T Log[1+((((17+2 a+2 d))^2)/(4 (T^2)))];

Jensen Integral

F[ell_,T_,c_,r_,theta_]:=Module[{η,σ,t,bs},
η=Min[(18/(10+9ell)),(1/2)];

σ=c+r Cos[theta];
t=r Sin[theta];

Which[
σ≥1+η,
	Log[Zeta[σ]],
-η≤σ≤1+η,
	Log[Zeta[1+η]]+((1+η-σ)/2)ell+((1+η-σ)/4)Log[(((((σ+1))^2)+(((Abs[t]+T))^2))/(((T+2))^2))],
σ<-η,
	bs=Round[σ];
	Log[Zeta[1-σ]]+(((1-2σ)/2))ell+(((1-2σ+2bs)/4))Log[(((((σ-bs+1))^2)+(((Abs[t]+T))^2))/(((T+2))^2))]+(1/2)Sum[Log[(((((σ+k-1))^2)+(((Abs[t]+T))^2))/(((T+2))^2))],{k,1,-bs}]
](*end Which*)
];

Theta[c_,r_,sigma_]:=Which[sigma≥c+r,0,sigma≤c-r,π,True,ArcCos[((sigma-c)/r)]];

JensenIntegral[ell_,T_,c_,r_,Method->"NumericalSimpleSplit"]:=
Module[{η,p1,p2,p3,p4,howfar},
η=Min[(18/(10+9ell)),(1/2)];

p1=NIntegrate[Hold[F[ell,T,c,r,theta]],{theta,0,Theta[c,r,1+η]},PrecisionGoal->8,WorkingPrecision->30];
p2=NIntegrate[Hold[F[ell,T,c,r,theta]],{theta,Theta[c,r,1+η],Theta[c,r,-η]},PrecisionGoal->8,WorkingPrecision->30];
p3=NIntegrate[Hold[F[ell,T,c,r,theta]],{theta,Theta[c,r,-η],Theta[c,r,-1/2]},PrecisionGoal->8,WorkingPrecision->30];
howfar=-Round[c-r];
p4=Sum[NIntegrate[Hold[F[ell,T,c,r,theta]],{theta,Theta[c,r,-j+1/2],Theta[c,r,-j-1/2]},PrecisionGoal->8,WorkingPrecision->30],{j,1,howfar}];

p1+p2+p3+p4];

JensenIntegral[ell_,T_,c_,r_,Method->"Rigorous"]:=
Module[{η,Th,κ,σ,t,theta,L,p,howfar,zeta},
(*Need  an interval version of Zeta; the special cases should never occur, but whatever *)
zeta[g_Interval/;Min[g]≥1]:=Interval[{If[Max[g]==Infinity,1,Zeta[Max[g]]],If[Min[g]==1,∞,Zeta[Min[g]]]}];

η=Min[(18/(10+9ell)),(1/2)];
Th[σ_]:=Theta[c,r,σ];
(Subscript[κ, 1])=(Th[-η]-Th[1+η])(((1+η-c))/2)-(π-Th[-η])(c-(1/2))+(r/2)(Sin[Th[-η]]+Sin[Th[1+η]]);

L[j_,theta_]=Log[((((((c+r Cos[theta])+j))^2)+(((Abs[r Sin[theta]]+T))^2))/(((T+2))^2))];
p[1]=(Subscript[κ, 1])*ell;
p[2]=(Th[-η]-Th[1+η])Log[Zeta[1+η]];

p[3]=IntervalIntegrate[Log[zeta[c+r Cos[#]]]&,Interval[{0,Theta[c,r,1+η]}]];

p[4]=IntervalIntegrate[Log[zeta[1-(c+r Cos[#])]]&,Interval[{Theta[c,r,-η],π}]];

p[5]=IntervalIntegrate[(((1+η-(c+r Cos[#]))/4)L[1,#])&,Interval[{Theta[c,r,1+η],Theta[c,r,-η]}]];
p[6]=IntervalIntegrate[(((1-2(c+r Cos[#]))/4)L[1,#])&,Interval[{Theta[c,r,-η],Theta[c,r,-1/2]}]];

howfar=-Round[c-r];

p[7]=Sum[IntervalIntegrate[(((1-2(c+r Cos[#])-2j)/4)L[j+1,#]+(1/2)Sum[L[k-1,#],{k,1,j}])&,Interval[{Theta[c,r,-j+1/2],Theta[c,r,-j-1/2]}]],{j,1,howfar}];

Max[Sum[p[i],{i,7}]]]

Assembled Bound

NTchiUpperBound[a_,q_,T_,c_,r_,Method->method_String]:=Block[{σ1,δ,Eδ,Eσ,S,integral},
σ1=(1/2)+Sqrt[2](c-(1/2));
δ=2c-σ1-(1/2);
Eδ=Er[a,δ,T];
Eσ=Er[a,σ1-(1/2),T];
(* σ1 > 1*)
(* c > 1 *)
(* r > (1+Sqrt[2])(c-(1/2)) *)
(* (1/4) ≤ δ ≤ (3/4) *)

integral=JensenIntegral[Log[((q(T+2))/(2π))],T,c,r,Method-> method];

S=Log[((Zeta[c])/(Zeta[2c]))]+(1/π)integral;


(T/π)Log[(q/π)]+(2/π)Im[LogGamma[(1/4)+(a/2)+I*(T/2)]]+(2/π)Log[Zeta[σ1]]+(2/π)(((π  S)/(2Log[(r/(c-1/2))]))+((Eδ)/2)+((Eσ-Eδ)/2)(1-((Log[1+Sqrt[2]])/(Log[(r/(c-1/2))]))))]

AbsoluteTiming[NTchiUpperBound[0,1000,5/7,1.21`,1.9`,Method->"Rigorous"]]
AbsoluteTiming[NTchiUpperBound[0,1000,5/7,1.21`,1.9`,Method->"NumericalSimpleSplit"]]

ListPlot[Table[{c,NTchiUpperBound[0,1000,5/7,c,1.9`,Method->"NumericalSimpleSplit"]},{c,1.2,1.36,0.02}]]

Finding the Bounds

Clear[Boundq];

Boundq[a_Integer,k_,T_]:=Boundq[a,k,T]=
Module[{c=1+1/8,r=2+1/8,q,val,newval,done=False,newpairs,bests,newc,newr,newq,verbose=0},

{q,c,r}=Which[
{a,k,T}=={0,3,5/7},{172,1.542`,2.905`},
{a,k,T}=={0,4,5/7},{724,1.446`,2.642`},
{a,k,T}=={0,5,5/7},{3291,1.378`,2.444`},
{a,k,T}=={0,6,5/7},{15978,1.328,2.292},
{a,k,T}=={0,7,5/7},{82163,1.289`,2.171`},
{a,k,T}=={0,8,5/7},{443025,1.259`,2.074`},
{a,k,T}=={0,9,5/7},{2487302,1.234`,1.993},

{a,k,T}=={1,3,5/7},{108,1.727,3.03},
{a,k,T}=={1,4,5/7},{435,1.508,2.741},
{a,k,T}=={1,5,5/7},{1908,1.414,2.527`},
{a,k,T}=={1,6,5/7},{9000,1.352,2.361},
{a,k,T}=={1,7,5/7},{45099,1.307,2.229},
{a,k,T}=={1,8,5/7},{237798,1.273,2.123},
{a,k,T}=={1,9,5/7},{1309289,1.245,2.035},

{a,k,T}=={0,3,1},{126,1.584,2.981},
{a,k,T}=={0,4,1},{438,1.481,2.736},
{a,k,T}=={0,5,1},{1615,1.409,2.545`},
{a,k,T}=={0,6,1},{6252,1.356 ,2.393`},
{a,k,T}=={0,7,1},{25234,1.316,2.271`},
{a,k,T}=={0,8,1},{105519,1.283,2.17},
{a,k,T}=={0,9,1},{454852,1.257,2.086`},

{a,k,T}=={1,3,1},{75,1.701,3.117},
{a,k,T}=={1,4,1},{252,1.539`,2.842`},
{a,k,T}=={1,5,1},{905,1.446,2.631`},
{a,k,T}=={1,6,1},{3422,1.382,2.464`},
{a,k,T}=={1,7,1},{13544,1.335,2.33`},
{a,k,T}=={1,8,1},{55686,1.299,2.22},
{a,k,T}=={1,9,1},{236533,1.27,2.128`},

{a,k,T}=={0,3,2},{46,(213/125),(3223/1000)},
{a,k,T}=={0,4,2},{110,(791/500),(3013/1000)},
{a,k,T}=={0,5,2},{266,(1503/1000),(2829/1000)},
{a,k,T}=={0,6,2},{660,(1443/1000),(669/250)},
{a,k,T}=={0,7,2},{1668,(1397/1000),(2549/1000)},
{a,k,T}=={0,8,2},{4287,(34/25),(1221/500)},
{a,k,T}=={0,9,2},{11179,(133/100),(47/20)},

{a,k,T}=={1,3,2},{30,(9/5),(419/125)},
{a,k,T}=={1,4,2},{71,(327/200),(1561/500)},
{a,k,T}=={1,5,2},{171,(77/50),(729/250)},
{a,k,T}=={1,6,2},{419,(1471/1000),(2749/1000)},
{a,k,T}=={1,7,2},{1049,(1419/1000),(261/100)},
{a,k,T}=={1,8,2},{2676,(689/500),(1247/500)},
{a,k,T}=={1,9,2},{6928,(168/125),(1197/500)},

True,{724,1.446`,2.642`}

];
c=Round[c*(2^11)]/(2^11);
r=Round[r*(2^11)]/(2^11);

If[verbose>1,Print["inside code"]];
val=NTchiUpperBound[a,q,T,c,r,Method->"NumericalSimpleSplit"];
While[val>k+1-(2^(-11)),
q=Round[0.95q];
val=NTchiUpperBound[a,q,T,c,r,Method->"NumericalSimpleSplit"]];

If[verbose>1,Print["Established  initial q of ",q]];
While[Not[done],

(*climb q up as much as possible*)
newq=Ceiling[1.01q];
newval=NTchiUpperBound[a,newq,T,c,r,Method->"NumericalSimpleSplit"];
While[newval≤k+1-(2^(-11)),
If[verbose>3,Print["EConsidering q of ",newq," as newval = ",newval]];
q=newq;val=newval;newq=Ceiling[1.01q];
newval=NTchiUpperBound[a,newq,T,c,r,Method->"NumericalSimpleSplit"]];

newq=q+1;
newval=NTchiUpperBound[a,newq,T,c,r,Method->"NumericalSimpleSplit"];
While[newval≤k+1-(2^(-11)),
If[verbose>3,Print["EConsidering q of ",newq," as newval = ",newval]];
q=newq;val=newval;newq=q+1;newval=NTchiUpperBound[a,newq,T,c,r,Method->"NumericalSimpleSplit"]];


If[verbose>1,Print["Bumped q to ",q," with {c,r} of ",{c,r}]];

(*so at this point  I have a reasonable q  *)
newpairs=Select[{{-(1/2048)+c,-(1/2048)+r},{-(1/2048)+c,-(1/128)+r},{-(1/2048)+c,-(1/8)+r},{-(1/2048)+c,r},{-(1/2048)+c,(1/8)+r},{-(1/2048)+c,(1/128)+r},{-(1/2048)+c,(1/2048)+r},{-(1/128)+c,-(1/2048)+r},{-(1/128)+c,-(1/128)+r},{-(1/128)+c,-(1/8)+r},{-(1/128)+c,r},{-(1/128)+c,(1/8)+r},{-(1/128)+c,(1/128)+r},{-(1/128)+c,(1/2048)+r},{-(1/8)+c,-(1/2048)+r},{-(1/8)+c,-(1/128)+r},{-(1/8)+c,-(1/8)+r},{-(1/8)+c,r},{-(1/8)+c,(1/8)+r},{-(1/8)+c,(1/128)+r},{-(1/8)+c,(1/2048)+r},{c,-(1/2048)+r},{c,-(1/128)+r},{c,-(1/8)+r},{c,r},{c,(1/8)+r},{c,(1/128)+r},{c,(1/2048)+r},{(1/8)+c,-(1/2048)+r},{(1/8)+c,-(1/128)+r},{(1/8)+c,-(1/8)+r},{(1/8)+c,r},{(1/8)+c,(1/8)+r},{(1/8)+c,(1/128)+r},{(1/8)+c,(1/2048)+r},{(1/128)+c,-(1/2048)+r},{(1/128)+c,-(1/128)+r},{(1/128)+c,-(1/8)+r},{(1/128)+c,r},{(1/128)+c,(1/8)+r},{(1/128)+c,(1/128)+r},{(1/128)+c,(1/2048)+r},{(1/2048)+c,-(1/2048)+r},{(1/2048)+c,-(1/128)+r},{(1/2048)+c,-(1/8)+r},{(1/2048)+c,r},{(1/2048)+c,(1/8)+r},{(1/2048)+c,(1/128)+r},{(1/2048)+c,(1/2048)+r}},First[#]>1&&Last[#]>(1+Sqrt[2])(First[#]-1/2)&];
bests=MinimalBy[newpairs,NTchiUpperBound[a,q,T,First[#],Last[#],Method->"NumericalSimpleSplit"]&];
If[Length[bests]==1,{newc,newr}=First[bests],Print["weirdness ",{c,r,newpairs,bests}];{newc,newr}=First[bests]];
If[{newc,newr}=={c,r},done=True,{c,r,val}={newc,newr,NTchiUpperBound[a,q,T,newc,newr,Method->"NumericalSimpleSplit"]}]];

{q,c,r,val}];

First, a=0, T=5/7.

Boundq[0,3,5/7]
Boundq[0,4,5/7]
Boundq[0,5,5/7]
Boundq[0,6,5/7]
Boundq[0,7,5/7]
Boundq[0,8,5/7]
Boundq[0,9,5/7]

Boundq[1,3,5/7]
Boundq[1,4,5/7]
Boundq[1,5,5/7]
Boundq[1,6,5/7]
Boundq[1,7,5/7]
Boundq[1,8,5/7]
Boundq[1,9,5/7]

Boundq[0,3,1]
Boundq[0,4,1]
Boundq[0,5,1]
Boundq[0,6,1]
Boundq[0,7,1]
Boundq[0,8,1]
Boundq[0,9,1]

Boundq[1,3,1]
Boundq[1,4,1]
Boundq[1,5,1]
Boundq[1,6,1]
Boundq[1,7,1]
Boundq[1,8,1]
Boundq[1,9,1]

Boundq[0,3,2]
Boundq[0,4,2]
Boundq[0,5,2]
Boundq[0,6,2]
Boundq[0,7,2]
Boundq[0,8,2]
Boundq[0,9,2]

Boundq[1,3,2]
Boundq[1,4,2]
Boundq[1,5,2]
Boundq[1,6,2]
Boundq[1,7,2]
Boundq[1,8,2]
Boundq[1,9,2]

Validating the bottom of the table

AbsoluteTiming[Block[{a=0,T=5/7,q,c,r,int,k},
Table[
{q,c,r,int}=Boundq[a,k,T];
int<NTchiUpperBound[a,q,T,c,r,Method->"Rigorous"]<k+1,{k,3,9}]]]

AbsoluteTiming[Block[{a=1,T=5/7,q,c,r,int,k},
Table[
{q,c,r,int}=Boundq[a,k,T];
int<NTchiUpperBound[a,q,T,c,r,Method->"Rigorous"]<k+1,{k,3,9}]]]

AbsoluteTiming[Block[{a=0,T=1,q,c,r,int,k},
Table[
{q,c,r,int}=Boundq[a,k,T];
int<NTchiUpperBound[a,q,T,c,r,Method->"Rigorous"]<k+1,{k,3,9}]]]

AbsoluteTiming[Block[{a=1,T=1,q,c,r,int,k},
Table[
{q,c,r,int}=Boundq[a,k,T];
int<NTchiUpperBound[a,q,T,c,r,Method->"Rigorous"]<k+1,{k,3,9}]]]

AbsoluteTiming[Block[{a=0,T=2,q,c,r,int,k},
Table[
{q,c,r,int}=Boundq[a,k,T];
int<NTchiUpperBound[a,q,T,c,r,Method->"Rigorous"]<k+1,{k,3,9}]]]

AbsoluteTiming[Block[{a=1,T=2,q,c,r,int,k},
Table[
{q,c,r,int}=Boundq[a,k,T];
int<NTchiUpperBound[a,q,T,c,r,Method->"Rigorous"]<k+1,{k,3,9}]]]

Writing the Tables

Kevin’s Tables

Kevin[T_,a_,k_/;3≤k≤9]:=Boundq[a,k,T][[1]];
Kevin[T_,a_,k_]:=1;

TableForm[Table[{k,Kevin[5/7,0,k],Kevin[5/7,1,k],Kevin[1,0,k],Kevin[1,1,k],Kevin[2,0,k],Kevin[2,1,k]},{k,0,9}]]

TableForm[{Block[{a=0,T=5/7},Table[{Boundq[a,k,T][[2]],Boundq[a,k,T][[3]]} (2^11),{k,5,9}]],Block[{a=1,T=5/7},Table[{Boundq[a,k,T][[2]],Boundq[a,k,T][[3]]} (2^11),{k,5,9}]],Block[{a=0,T=1},Table[{Boundq[a,k,T][[2]],Boundq[a,k,T][[3]]} (2^11),{k,5,9}]],Block[{a=1,T=1},Table[{Boundq[a,k,T][[2]],Boundq[a,k,T][[3]]} (2^11),{k,5,9}]],Block[{a=0,T=2},Table[{Boundq[a,k,T][[2]],Boundq[a,k,T][[3]]} (2^11),{k,5,9}]],Block[{a=1,T=2},Table[{Boundq[a,k,T][[2]],Boundq[a,k,T][[3]]} (2^11),{k,5,9}]]}]

Andrew’s Table

TableForm[Table[{k,Andrew[5/7,0,k],Andrew[5/7,1,k],Andrew[1,0,k],Andrew[1,1,k],Andrew[2,0,k],Andrew[2,1,k]},{k,0,9}]]

Combined Table

TableForm[Table[{k,Max[Kevin[5/7,0,k],Andrew[5/7,0,k]],Max[Kevin[5/7,1,k],Andrew[5/7,1,k]],Max[Kevin[1,0,k],Andrew[1,0,k]],Max[Kevin[1,1,k],Andrew[1,1,k]],Max[Kevin[2,0,k],Andrew[2,0,k]],Max[Kevin[2,1,k],Andrew[2,1,k]]},{k,0,9}]]

TeXForm[%]