<jupyter_start><jupyter_text>Importing Libraries<jupyter_code>import numpy as np
import matplotlib.pyplot as plt
import matplotlib as mpl
from scipy.integrate import quad
from math import sqrt,pow,log
import pandas as pd
from matplotlib.pyplot import figure
from matplotlib.patches import Ellipse
import matplotlib.transforms as transforms
from scipy.optimize import curve_fit
#plt.style.use('/root/Github_Repos/HubbleConstant-ConstraintsForVCG/standard.mplstyle')<jupyter_output><empty_output><jupyter_text>Importing data<jupyter_code>!wget http://supernova.lbl.gov/Union/figures/SCPUnion2.1_mu_vs_z.txt
d = np.genfromtxt('SCPUnion2.1_mu_vs_z.txt')
z = d.T[1]
dm = d.T[2]
errdm= d.T[3]
dldataSN=np.zeros(len(z))
error= np.zeros(len(z))
dlerror= np.zeros(len(z))
c=f=e=0

for (i,j) in zip(dm,errdm):   
  error[f]+= 10**((i+j)/5+1)/10**6
  f+=1

dlabel = 'SCP_2.1'
label = {"Z_SN":z,"DMdata_SN":dm,"Error_DM_SN":errdm}
data_SN=pd.DataFrame(label)
for i in data_SN.DMdata_SN:
  dldataSN[c]+=10**((i/5)+1)/1000000
  c=c+1
for (i,j) in zip(dldataSN,error):
    dlerror[e]+=j-i
    e+=1
data_SN["dLdata_SN"]=dldataSN
data_SN["Error_DL_SN"]=dlerror
print(data_SN)
len(z)<jupyter_output>URL transformed to HTTPS due to an HSTS policy
--2022-01-28 11:47:00--  https://supernova.lbl.gov/Union/figures/SCPUnion2.1_mu_vs_z.txt
Resolving supernova.lbl.gov (supernova.lbl.gov)... 192.168.3.11
Connecting to supernova.lbl.gov (supernova.lbl.gov)|192.168.3.11|:443... connected.
HTTP request sent, awaiting response... 200 OK
Length: 33899 (33K) [text/plain]
Saving to: ‘SCPUnion2.1_mu_vs_z.txt.10’

SCPUnion2.1_mu_vs_z 100%[===================>]  33.10K   104KB/s    in 0.3s    

2022-01-28 11:47:02 (104 KB/s) - ‘SCPUnion2.1_mu_vs_z.txt.10’ saved [33899/33899]

         Z_SN  DMdata_SN  Error_DM_SN     dLdata_SN  Error_DL_SN
0    0.028488  35.346583     0.223906    117.305042    12.741218
1    0.050043  36.682368     0.166829    217.006920    17.329264
2    0.052926  36.817691     0.155756    230.960787    17.175017
3    0.070086  37.446737     0.158467    308.565458    23.360101
4    0.062668  37.483409     0.156099    313.820905    23.390114
..        ...        ...          ...      [...]<jupyter_text>PARAMETER Definition (Hubble Parameter, Energy density of Radiation (r0) and Baryonic Matter (b0), in the current epoch)<jupyter_code>def defineparam():
  global omega_r0
  omega_r0 = float(input("Omega R0: "))
  global omega_b0
  omega_b0 = float(input("Omega B0: "))
defineparam()<jupyter_output>Omega R0: .0000245
Omega B0: .02<jupyter_text>Defining the function to find luminosity distance and followed by calculating the luminosity distance through integration by quad function of the scipy module for different combination of Omega M and n and from that the distance modulus.<jupyter_code>def int_func(redshift):
      return 1/((pow((1+redshift),2)*(omega_r0+(omega_b0/(1+redshift))+((1-omega_b0-omega_r0)*((omega_m*(1+redshift)**6)+(1-omega_m)*(1+redshift)**n)**(0.5)/(1+redshift)**(4)))**(0.5)))

H0 = np.zeros(len(z))

H0error= np.zeros(len(z))
omega_m=0.09
n=1.4545
a=b=c=d=e=0
# Distance luminosity from data in Mpc

# DL theoretical from VCG model
for redshift in data_SN.Z_SN:
  g = quad(int_func,0,redshift)
  H0[a]+=(1+redshift)*g[0]*(300000/data_SN.dLdata_SN[a]) 
  a=a+1


# Calculating error bars of DL


for redshift in data_SN.Z_SN:
  g = quad(int_func,0,redshift)
  H0error[b]+=(data_SN.Error_DL_SN[b]/(data_SN.dLdata_SN[b] + data_SN.Error_DL_SN[b]))*(1+redshift)*g[0]*(300000/data_SN.dLdata_SN[b])
  b=b+1
data_SN["H0"]=H0
data_SN["H0error"] = H0error
%time<jupyter_output>CPU times: user 4 µs, sys: 1 µs, total: 5 µs
Wall time: 7.87 µs<jupyter_text>The Table has the Distance Modulus observed (DM) and the Distance Modulus calculated by Chaplygin Model<jupyter_code>print(data_SN)
sort_data_SN=data_SN.sort_values(by=['Z_SN'])
sort_data_SN
a=0
e = np.repeat(100, len(z))
INT=np.zeros(len(z))
def func(x,m):
    return x/m
for redshift in data_SN.Z_SN:
  g = quad(int_func,0,redshift)
  INT[a]+=(1+redshift)*g[0]*(300000) 
  a=a+1
popt, pcov=curve_fit(func,INT,data_SN.dLdata_SN,sigma=sort_data_SN.Error_DL_SN)
p=format(popt[0],'.2f')
err=pcov[0]**.5
err1=format(err[0],'.2f')
f=popt*data_SN.dLdata_SN
#plt.figure(figsize = (10,10))
plt.ylabel(r'$D_L$')
plt.xlabel("INT")
plt.rcParams["figure.figsize"] = (5,2.5)
#plt.title("Supernova - Hubble Constant")
plt.scatter(INT,data_SN.dLdata_SN,color='green')
plt.errorbar(INT,data_SN.dLdata_SN,yerr=sort_data_SN.Error_DL_SN,fmt=' ',ecolor='black', label='error')
plt.plot(f,data_SN.dLdata_SN,color='red')
plt.text(0,10000," \small Slope: "+str(p)+"+/-"+str(err1))
plt.legend(['\small fit','\small SN data'])
#plt.title(" H0 by SN")

plt.show()
plt.xlabel("Redshifts")
plt.ylabel("HUbble constant")
plt.title("Supernova - Hubble constant vs Redshift")
plt.scatter(sort_data_SN.Z_SN,sort_data_SN.H0,color='green',label='H0')
plt.errorbar(sort_data_SN.Z_SN,sort_data_SN.H0,yerr=sort_data_SN.H0error,fmt=' ',ecolor='black', label='error')
plt.legend(loc='best')
plt.show()
name=np.array(['GW190521','GW190706_222641','GW190413_134308','GW190514_065416','GW190719_215514','GW190521',"GW190909_114149","GW190413_052954",'GW190803_022701','GW190731_140936','GW190727_060333','GW190620_030421','GW190421_213856','GW170729','GW190602_175927','GW190527_092055','GW190519_153544','GW190424_180648','GW190929_012149','GW190828_063405','GW190701_203306','GW190513_205428','GW170823','GW190517_055101','GW190915_235702','GW190828_065509','GW190408_181802','GW190910_112807','GW190512_180714','GW190503_185404','GW190521_074359','GW170818','GW151012','GW170809','GW170104','GW190728_064510','GW190708_232457','GW190630_185205','GW190720_000836','GW190707_093326','GW190930_133541','GW190412','GW190924_021846','GW170814','GW151226','GW150914','GW190426_152155','GW200115_042309','GW170608','GW200105_162426','GW190814','GW190425','GW170817'])
full_DL_GW=np.array([[5300.0,2400,-2600],[4420.0,2590,-1930],[4450,2480,-2120],[4130.0,2650,-2170],[3940.0,2590,-2000],[3920.0,2190,-1950],[3770.0,3270,-2220],[3550.0,2270,-1660],[3270.0,1950,-1580],[3300.0,2390,-1720],[3300.0,1540,-1500],[2810.0,1680,-1310],[2880.0,1370,-1380],[2840.0,1400,-1360],[2690.0,1790,-1120],[2490.0,2480,-1240],[2530.0,1830,-920],[2200.0,1580,-1160],[2130.0,3650,-1050],[2130.0,660,-930],[2060.0,760,-730],[2060.0,880,-800],[1940.0,970,-900],[1860.0,1620,-840],[1620.0,710,-610],[1600.0,620,-600],[1550.0,400,-600],[1460.0,1030,-580],[1430.0,550,-550],[1450.0,690,-630],[1240.0,400,-570],[1060.0,420,-380],[1080.0,550,-490],[1030.0,320,-390],[990.0,440,-430],[870.0,260,-370],[880.0,330,-390],[890.0,560,-370],[790.0,690,-320],[770.0,380,-370],[760.0,360,-320],[740.0,140,-170],[570.0,220,-220],[600.0,150,-220],[450.0,180,-190],[440.0,150,-170],[370.0,180,-160],[300.0,150,-100],[320.0,120,-110],[280.0,110,-110],[241.0,41,-45],[159.0,69,-72],[40.0,7,-15]])
full_Z_GW=np.array([[0.82,0.28,-0.34],[0.71,0.32,-0.27],[0.71,0.31,-0.30],[0.67,0.33,-0.31],[0.64,0.33,-0.29],[0.64,0.28,-0.28],[0.62,0.41,-0.33],[0.59,0.29,-0.24],[0.55,0.26,-0.24],[0.55,0.31,-0.26],[0.55,0.21,-0.22],[0.49,0.23,-0.20],[0.49,0.19,-0.21],[0.49,0.19,-0.21],[0.47,0.25,-0.17],[0.44,0.34,-0.20],[0.44,0.25,-0.14],[0.39,0.23,-0.19],[0.38,0.49,-0.17],[0.38,0.10,-0.15],[0.37,0.11,-0.12],[0.37,0.13,-0.13],[0.35,0.15,-0.15],[0.34,0.24,-0.14],[0.3,0.11,-0.10],[0.3,0.10,-0.10],[0.29,0.06,-0.10],[0.28,0.16,-0.10],[0.27,0.09,-0.10],[0.27,0.11,-0.11],[0.24,0.07,-0.10],[0.21,0.07,-0.07],[0.21,0.09,-0.09],[0.2,0.05,-0.07],[0.2,0.08,-0.08],[0.18,0.05,-0.07],[0.18,0.06,-0.07],[0.18,0.10,-0.07],[0.16,0.12,-0.06],[0.16,0.07,-0.07],[0.15,0.06,-0.06],[0.15,0.03,-0.03],[0.12,0.04,-0.04],[0.12,0.03,-0.04],[0.09,0.04,-0.04],[0.09,0.03,-0.03],[0.08,0.04,-0.03],[0.07,0.03,-0.02],[0.07,0.02,-0.02],[0.06,0.02,-0.02],[0.053,0.009,-0.010],[0.04,0.01,-0.02],[0.01,0.00,-0.00]])
# Number of events
a=name.size

#Defining arrays
dldata_GW=np.zeros(a)
dlUP=np.zeros(a)
dlLOW=np.zeros(a)
dlTOP=np.zeros(a)
dlBOTTOM=np.zeros(a)
dmtop=np.zeros(a)
dmbottom=np.zeros(a)
Z_GW=np.zeros(a)
dmth_GW=np.zeros(a)
dmdata_GW=np.zeros(a)
dlth_GW = np.zeros(a)
dmtoperr=np.zeros(a)
dmbottomerr=np.zeros(a)
#defining variables for index of the above arrays
b=c=d=e=f=h=k=l=m=x=y=p=q=r=s=0
#extracting redshifts and DL from the full data
for i in full_Z_GW:
  Z_GW[e]+=i[0]
  e+=1
for i in full_DL_GW:
  dldata_GW[b]+=i[0]
  b+=1
#Upper and Lower limit of DL from data
for i in full_DL_GW:
  dlUP[c]+=i[0]+i[1]
  c+=1
for i in full_DL_GW:
  dlLOW[d]+=i[0]+i[2]
  d+=1
# Calculating upper and lower limit of Distance modulus from DL limits calculated above

#Calculating differences in DL from its limits
for (i,j) in zip(dldata_GW,dlUP):
  dlTOP[x]+=j-i
  x+=1
for (i,j) in zip(dldata_GW,dlLOW):
  dlBOTTOM[y]=i-j
  y+=1


# DL-h1 < DL < DL+h2,if h1<h2, take error to be h1 or vice versa
#new_error=np.zeros(a)
#for (i,j) in zip(dlTOP,dlBOTTOM):
 # if i<j:
#    new_error[p]+=i
#    p+=1
#  elif j<i:
#    new_error[q]+=j
 #   q+=1


#for (i,j) in zip(dmtoperr,dmbottomerr):
#  if i<j:
 #  new_error[p]+=i
  # p+=1
#  elif j<i:
 #  new_error[q]+=j
  # q+=1

label1 = {"Event_Name":name,"Z_GW":Z_GW,"dLdata_GW":dldata_GW,"DL_Uplimit": dlUP, "DL_Lowlimit": dlLOW,"DL_UP_Error":dlTOP,"DL_LOW_Error":dlBOTTOM}
data_GW=pd.DataFrame(label1)
#data_GW.to_excel(excel_writer = "/root/Github_Repos/VCG_GW/GWTColdGW.xlsx")
print(data_GW)
data_GWTC3 = pd.read_excel (r'/root/Github_Repos/VCG_GW/oldGW.xlsx')
data_GWTC3.index= np.arange(53,88)
print(data_GWTC3)
mucollect=[data_GW.Z_GW,data_GWTC3.redshift]
finalredshift = pd.concat(mucollect)

namecollect=[data_GW.Event_Name,data_GWTC3.Event_Name_GWTC3]
finalevents = pd.concat(namecollect)

dlcollect=[data_GW.dLdata_GW,data_GWTC3.luminosity_distance]
finaldl = pd.concat(dlcollect)

dlupcollect=[data_GW.DL_Uplimit,data_GWTC3.luminosity_distance_upper]
finaldlup = pd.concat(dlupcollect)

dllowcollect=[data_GW.DL_Lowlimit,data_GWTC3.luminosity_distance_lower]
finaldllow = pd.concat(dllowcollect)

label2 = {"Fin_Event_Name":finalevents,"Fin_Z_GW":finalredshift,"Fin_dLdata_GW":finaldl, "Fin_DL_UpError": finaldlup, "Fin_DL_LowError": finaldllow}
Fin_data_GW=pd.DataFrame(label2)

a=finalevents.size

#Defining arrays
H0GW=np.zeros(a)
H0uperror=np.zeros(a)
H0lowerror=np.zeros(a)

#defining variables for index of the above arrays
f=h=k=l=m=x=y=p=q=r=s=0


omega_m=.09
n=1.4545

# Calculating theoretical value of DL and DM from the model VCG
for i in finalredshift:
  g=quad(int_func,0,i)
  H0GW[l]+=(1+i)*g[0]*(300000/Fin_data_GW.Fin_dLdata_GW[l] )
  l+=1
for i in finalredshift:
  g=quad(int_func,0,i)
  H0uperror[f]+=((Fin_data_GW.Fin_DL_UpError[f]-Fin_data_GW.Fin_dLdata_GW[f])/Fin_data_GW.Fin_DL_UpError[f])*(1+i)*g[0]*(300000/Fin_data_GW.Fin_dLdata_GW[f] )
  f+=1
for i in finalredshift:
  g=quad(int_func,0,i)
  H0lowerror[k]+=((Fin_data_GW.Fin_dLdata_GW[k]-Fin_data_GW.Fin_DL_LowError[k])/(2*Fin_data_GW.Fin_dLdata_GW[k]-Fin_data_GW.Fin_DL_LowError[k]))*(1+i)*g[0]*(300000/Fin_data_GW.Fin_dLdata_GW[k] )
  k+=1
Fin_data_GW["H0_GW"]=H0GW
Fin_data_GW["H0_+error"]=H0uperror
Fin_data_GW["H0_-error"]=H0lowerror
#label3={"H0_GW":H0GW,"H0_+error":H0uperror , "H0_-error": H0lowerror }
#Fin_data_GW=pd.DataFrame(label3)
namecollect=[data_GW.Event_Name,data_GWTC3.Event_Name_GWTC3]
finalevents = pd.concat(namecollect)
finalevents
sort_data_GW=Fin_data_GW.sort_values(by=['Fin_Z_GW'])
sort_data_GW<jupyter_output><empty_output><jupyter_text>from soad import AsymmetricData as asyda=[10,11,12]b=[1,2,3]erra=[.1,.2,.3]errb=[.2,.3,.4]errbneg=[.1,.2,.3]erraneg=[.2,.3,.4]A = asyd(10, .1, .2, N=1, confidence=1.0)B = asyd(5, .3, .1, N=1, confidence=1.0)c=A+Bprint(c) from soad import AsymmetricData as asyda=np.array([10,11,12])b=np.array([1,2,3])erra=np.array([.1,.2,.3])errb=np.array([.2,.3,.4])errbneg=np.array([.1,.2,.3])erraneg=np.array([.2,.3,.4])A = asyd(a.any(), erra.any(), erraneg.any(), N=10, confidence=1.0)B = asyd(b.any(), errb.any(), errbneg.any(), N=10, confidence=1.0)c=A/Bprint(c)<jupyter_code>a=0
c=finalevents.size
INTGW=np.zeros(c)
def func(x,m):
    return x/m
for redshift in sort_data_GW.Fin_Z_GW:
  g = quad(int_func,0,redshift)
  INTGW[a]+=(1+redshift)*g[0]*(300000) 
  a=a+1
for redshiftup in sort_data_GW.Fin_Z_GW:
  g = quad(int_func,0,redshift)
  INTGW[a]+=(1+redshift)*g[0]*(300000) 
  a=a+1
for redshift in sort_data_GW.Fin_Z_GW:
  g = quad(int_func,0,redshift)
  INTGW[a]+=(1+redshift)*g[0]*(300000) 
  a=a+1
popt, pcov=curve_fit(func,INTGW,sort_data_GW.Fin_dLdata_GW,sigma=sort_data_GW.Fin_DL_UpError)
p=format(popt[0],'.4f')
err=pcov[0]**.5
err1=format(err[0],'.4f')
f=popt*sort_data_GW.Fin_dLdata_GW
plt.xlabel("Distance Luminosity")
plt.ylabel("INTEGERATION Value")
plt.title("GW - Hubble Constant")
plt.scatter(sort_data_GW.Fin_dLdata_GW,INTGW,color='green')
plt.errorbar(sort_data_GW.Fin_dLdata_GW,INTGW,xerr=sort_data_GW.Fin_DL_UpError,fmt=' ',ecolor='black', label='error')
plt.plot(sort_data_GW.Fin_dLdata_GW,f,color='red')
plt.text(7000,50000,"Slope: "+str(p)+"+/-"+str(err1))
plt.show()
plt.xlabel("Redshifts")
plt.ylabel("HUbble constant")
plt.title("Supernova - Hubble constant vs Redshift")
plt.scatter(sort_data_GW.Fin_Z_GW,sort_data_GW.H0_GW,color='green',label='H0')
plt.errorbar(sort_data_GW.Fin_Z_GW,sort_data_GW.H0_GW,yerr=(sort_data_GW.Fin_DL_LowError,sort_data_GW.Fin_DL_UpError),fmt=' ',ecolor='black', label='error')
plt.legend(loc='best')
plt.show()
# Chi_square test considering only GW data points
chi_sq = []
collection=[]
nconf=np.zeros(15876)
omegconf=np.zeros(15876)
col=[]
dlth_GW= np.zeros(88)
dmth_GW= np.zeros(88)
chi_sq=np.zeros(88)
a=0
b=0
c=0
d=0
new_error=Fin_data_GW.Fin_DL_LowError
for H in np.linspace(50,100,1000):
    for redshift in Fin_data_GW.Fin_Z_GW:
      g = quad(int_func,0,redshift)
      dl1=(1+redshift)*g[0]*(300000/H)
      dlth_GW[b]+=dl1
      dmth_GW[a]+=5.*log(dl1,10)+25
      a+=1
      b+=1
      Fin_data_GW["DLchi"]=dlth_GW
    a=0
    b=0
    C2=0
    C1=0
    for i in new_error:
      C2+=1/np.power(i,2)
    Fin_data_GW["dC1"]=(Fin_data_GW["DLchi"]-Fin_data_GW["Fin_dLdata_GW"])/(new_error**2)
    for i in Fin_data_GW["dC1"]:
      C1+=i
    del Fin_data_GW["dC1"]
    chi_sq_part1 = 0
    Fin_data_GW["Part1"]=((Fin_data_GW["DLchi"]-Fin_data_GW["Fin_dLdata_GW"])/new_error)**2
    for i in Fin_data_GW.Part1:
      chi_sq_part1+=i
    del Fin_data_GW["Part1"]
    chi_sq = chi_sq_part1+(C1/C2)*(C1+(2*log(10)/5))-(2*log(0.698))
    col.append(chi_sq)
    collection.append([chi_sq,H])
    dlth_GW = np.zeros(88)
    del Fin_data_GW["DLchi"]
print(len(collection))
for i in collection:
  if i[0]==min(col):
    print(i)  

%time
!pip install paida
import paida
from paida import *
#from paida import paida_core
#import paida
#from paida_core.PAbsorber import *

analysisFactory = IAnalysisFactory.create()
treeFactory = analysisFactory.createTreeFactory()
tree = treeFactory.create()

### DataPointSet
dataPointSetFactory = analysisFactory.createDataPointSetFactory(tree)
dataPointSet1 = dataPointSetFactory.create('dataPointSet1', 'Symmetric', 2)
dataPointSet2 = dataPointSetFactory.create('dataPointSet2', 'Asymmetric', 2)

### Fill
import random
r = random.Random()
for i in range(30):
	error1 = r.randrange(-10.0, 10.0)
	error2 = r.random() * 10.0
	### Symmetric
	dataPoint = dataPointSet1.addPoint()
	dataPoint.coordinate(0).setValue(i)
	dataPoint.coordinate(1).setValue(2.0 * i + error1)
	dataPoint.coordinate(1).setErrorPlus(error2)
	dataPoint.coordinate(1).setErrorMinus(error2)
	### Asymmetric
	dataPoint = dataPointSet2.addPoint()
	dataPoint.coordinate(0).setValue(i)
	dataPoint.coordinate(1).setValue(2.0 * i + error1)
	dataPoint.coordinate(1).setErrorPlus(error2)
	dataPoint.coordinate(1).setErrorMinus(error2 / 2.0)

### Fit
fitFactory = analysisFactory.createFitFactory()
fitter = fitFactory.createFitter()
fitResult1 = fitter.fit(dataPointSet1, 'P1')
print ('### Symmetric: p0 + p1 * x')
print ('Parameter:', fitResult1.fittedParameters())
print ('Error    :', fitResult1.errors())
fitResult2 = fitter.fit(dataPointSet2, 'P1')
print ('### Asymmetric:  p0 + p1 * x')
print ('Parameter:', fitResult2.fittedParameters())
print ('Error    :', fitResult2.errors())

### Plot
plotterFactory = analysisFactory.createPlotterFactory()
plotter = plotterFactory.create('PAIDA Plotter')
plotter.createRegions(1, 2)

plotter.region(0).setTitle('Symmetric')
plotter.region(0).style().setParameter('showTitle', 'true')
plotter.region(0).style().dataStyle().setParameter('showErrorBars', 'True')
plotter.region(0).plot(dataPointSet1)
plotter.region(0).plot(fitResult1.fittedFunction())

plotter.region(1).setTitle('Asymmetric')
plotter.region(1).style().setParameter('showTitle', 'true')
plotter.region(1).style().dataStyle().setParameter('showErrorBars', 'True')
plotter.region(1).plot(dataPointSet2)
plotter.region(1).plot(fitResult2.fittedFunction())

### Wait.
dummy = raw_input('Hit any key.')<jupyter_output><empty_output>
{'fraction_non_alphanumeric': 0.20192534845263407, 'fraction_numerical': 0.1433971178832979, 'mean_word_length': 6.317631806395851, 'pattern_counts': {'":': 18, '<': 29, '<?xml version=': 0, '>': 23, 'https://': 1, 'lorem ipsum': 0, 'www.': 0, 'xml': 0}, 'pii_count': 2, 'substrings_counts': 0, 'word_list_counts': {'cursed_substrings.json': 0, 'profanity_word_list.json': 0, 'sexual_word_list.json': 0, 'zh_pornsignals.json': 0}}
{'chain_length': '6', 'dir': 'jupyter-structured-clean-dedup', 'id': '23330', 'license': 'MIT', 'n_tokens_mistral': 9222, 'n_tokens_neox': 7699, 'n_words': 926, 'path': 'Python Codes/H0 using GWTC3.ipynb', 'repo_name': 'AshleyChraya/HubbleConstant-ConstraintsForVCG', 'size': '16930'}