1. Precision Control and GRACE
J. Fujimoto(KEK), N. Hamaguchi(Hitachi Co. Ltd.),T. Ishikawa(KEK),
T. Kaneko(KEK), H. Morita(Hitachi Co. Ltd.),
D. Perret-Gallix(LAPP), A. Tokura(Hitachi Co. Ltd.)
and Y. Shimizu(The Graduate University for Advanced Studies)
ACAT05
2005.５.２５, Zeuthen presented by　J. Fujmoto(KEK)

2. Introduction
　High-precision experiments like LC  Requires high prevision theoretical
　　　prediction
　　　　=> higher order calculation
　 Automatic System like GRACE is needed to perform 1-loop correction to
e+e- 3, 4-bodies
Great progress since Sept. 2002

3. Full 1-loop calculations available
GRACE, PLB559(2003)252 Denner et al., NPB660(2003)289
GRACE, PLB571(2003)163 You et al., PLB571(2003)85 Denner et al., PLB575(2003)290
GRACE, PLB576(2003)152 Zhang et al., PLB578(2004)349
GRACE, PLB600(2004)65
GRACE, NIM A534(2004)334
GRACE, Talk by K. Kato at LCWS05(Mar.2005)
Denner etal., hep-ph/

4. How to check the results?
One solution is
check gauge invariance Independence on gauge parameters
Non-linear gauge fixing terms
in GRACE

5. Linear Gauge vs Non-Linear Gauge check of
NLG
Cuv=0
Cuv=100 LG
Cuv=0

6. Alternative solution Use higher computation precision.
Is Quadruple precision good enough?
 see ‘Simple Example’
Hitachi has developed a new FORTRAN
library of High-speed Multiprecision operations in collaboration with the GRACE group.
This library provides information on ‘lost-bits’ during the calculation.

7. Simple Example f = 333.75*(b**6)
+ (a**2)*{11*(a**2)*(b**2) - (b**6)- 121*(b**4) - 2}
+ 5.5*(b**8) + a/(2*b),
where a= 、b=
by C. Hu, S. Xu and X. Yang
f =
w/ Quadruple precision
Analytical result = /66192 =
Using the new Octuple precision library in HMLib:
f =
with lost bits = 121

8. HMLIb: New FORTRAN Library for High-speed Multiprecision operations
Library in FORTRAN  available for any architectures
Based on Integer operations
 fast & “lost bits” information for subtraction.
For the octuple floating point operations:
based on IEEE754,
1 bit for sign,15bits for exponent,
240 bits for mantissa.
For example
call Q4ADDSUB(A,B,C,I,IBIT) : for add/sub in Quad.
call Q8ADDSUB(A,B,C,I.IBIT) : for add/sub in Octuple
MULT/DIV,SQRT,LOG,ATAN2 … are also available
Please contact to Mr. Hashimoto from Hitachi;
lost bits information

9. Number of “lost-bits” Suppose A=2**T1*(1.F), B=2**T2*(1.G),
where A≧B>0.
Construct two positive integers,
IA=1.F*2**242､ IB=1.G*2**(242 – (T1 – T2)). 　
In the case of subtraction, we can get
IA – IB=2**T3+N (0≦N≦2**T3 – 1).
Then, the number of lost bits is given by 242 – T3.

10. Performance Comparison
Ratio of the execution time (Double precision:1)
Pen4 Intel Fortran V O0
only 4 times
slower
FPU
ALU
HMLIb
w/ lost bits
HMLib
w/ lost bits

11. Actual application
QED corrections to t
Quadruple precision is required in some phase space points due to the Gram determinant
mass of
happens in the reduction
algorithm.
mass of photon

12. Loop integrals for box diagrams
where
and
Using

13. Reduction Algorithm LHS is given by 2-dim integrals since
RHS is presented by So
are given by
and 2-dim integrals.
Similarly,
are given by
, 2-dim/1-dim integrals.
Reduction Algorithm
Determinant to solve the system is nothing but the
‘Gram Determinant’

14. in Quadruple precision
in Double precision
ReJ[1] =
ReJ[x] = E-0002
ReJ[y] = E-0002
ReJ[w] =
ReJ[w**2] =
ReJ[w*x] = E-0002
ReJ[x*y] = E-0002 …
ReJ[w**3] =
Blow up !!
in Quadruple precision
ReJ[1] =
ReJ[x] = E-0002
ReJ[y] = E-0002
ReJ[w] =
ReJ[w**2] =
ReJ[w*x] = E-0002
ReJ[x*y] = E-0002 …
ReJ[w**3] =

15. How does HMLib work? Call HMLib in the codes.
At the point of J[w**3], HMLib reported
70-bit lost in total, which means
12 decimal digits of the result is guaranteed.
More precisely, Gram determ. for J[w**3] is
E-5.
Before J[W**3], already 43bits were lost,

16. Summary Precision control is mandatory for large scale calculations.
GRACE relies on gauge independent checks for 1-loop calculations.
High precision computation provides an alternative approach.
HMLib (Hitachi in collaboration with GRACE group) is a FORTRAN library for Multiprecision operations.
HMLib is fast due to the integer operations and gives the number of “lost-bits” in the computations.
HMLib has been applied to1-loop corrections;
We have shown that higher precision computations and HMLib guarantees the precision of the results.