1. Parallel computing on internet: interactive
fault-tolerance based on homomorphic coding
Jean-Louis R OCH
INRIA MOAIS team, LIG lab.
´
Grenoble Universite, France
Joint work with
C. Pernet [?], T. Roche [?, ?], S. Varrette [?, ?], S. Jafar [?],
A. Krings [?], M. Cunche [?], M. Khonji[?], T. Stalinski[?]
Computer Science Dept, University of Oujda
Tuesday November 13, 2012
Plan
Introduction
High performance computing and cloud
Related works on trusting the clouds
ABFT
Fault tolerant computation in the Sky
Interactive sky computation

2. Context: High Performance Interactive Computation
INRIA - LIG Moais team
Performance: multi-criteria trade-off
→ computation latency and computation bandwidth
Application domains: interactive simulations (latency),
computer algebra (bandwidth), ...
HPC platforms
From low computation latency to high computation
bandwidth
Parallel chips multi/many-core architectures:
multicore cpu, GP-GPU, FPGA, MPSoCs
Servers: Multi-processor with ”sharedi” memory (CPUs +
GPUs+...)
Clusters: 72% of top 500 machines, Heterogeneous
(CPUs + GPUs + ...)
E.g. Tianhe-1A, ranked 1 in TOP500 nov 2010: 4.7 PFlops
Global computing platforms: grids, P2P, clouds
E.g. BOINC : in April 2010= 5.1 PFlops

3. Cloud / Global computing platforms
Applications
Data sharing (1980’s), Data storage, Computation (1990’s)
”Unbound” computation bandwidth
Volunteer Computing: steal idle cycles through the Internet
Folding@Home – 5 PFLOPS, as of March 17, 2009
MilkyWay@Home - 1.6 PFLOPS, as of April 2010
Thanks to GPUs !
Grid or cloud ?
Beyond computation bandwidth, two important criteria:
granularity: how small is the smallest bit of computational
resource that you can buy;
speed of scaling: how long it takes to increase the size of
available resources.

4. Global computing architecture and trust
Open platforms are subject to attacks:
machine badly configured, over clocking,
malicious programs,
client patched and redistributed: possibly large scale
Parallel Application
f1
f3
f2
f1 f4
f4 f5
s1 s2
s1
f3 f2
user
INTERNET
s2
f5
Global computing architecture and trust
Open platforms are subject to attacks:
machine badly configured, over clocking,
malicious programs,
client patched and redistributed: possibly large scale
Parallel Application
f1
f3
f2
f1 f4
f4 f5
s1 s2
s1
f3 f2
user
modified result INTERNET
s2
hacker
f5

5. Global computing platforms: drawbacks
Peers volatility
Peers can join/leave at any time.
Faults, crashes
As the number of nodes increases, the number of faults,
process crashes increases as well.
Trust in Peers
Malicious Peers (intentionally or infected by malwares).
Random Crashes
Random Forgeries
Byzantine behaviour (e.g., Peers collusion)
Related work: trusting the Cloud
Volatility, anonymity
- Replication, (partial) Re-execution, Checkpoint/restart
- Anonymity from homomorphic encryption
Trust
Challenges / blacklisting [Sramentaak 01]
Replication of tasks:
BOINC: credit evaluation
Byzantine agreement: n processes for n/3 faulty (one-third
faulty replicas [Lamport82s] )
Check / Verification using postconditions (on the output)
[Blum97]

6. Related work: trusting the Cloud
Volatility, anonymity
- Replication, (partial) Re-execution, Checkpoint/restart
- Anonymity from homomorphic encryption
Trust
Challenges / blacklisting [Sramentaak 01]
⇒expensive
Replication of tasks:
BOINC: credit evaluation
⇒Attacks can be adjusted
Byzantine agreement: n processes for n/3 faulty (one-third
faulty replicas [Lamport82s] )
⇒often expensive
Check / Verification using postconditions (on the output)
[Blum97]
⇒not always possible
Related work: trusting the Cloud
Without trust assumptions, basic properties (eg integrity,
atomicity, weak consistency, ...) cannot be guaranteed
But, by maintaining a small amount of trusted memory and
trusted computation units,
well-known cryptographic methods reduce the need for
trust in the storage [Cachinal. ACM SIGACT 2009]
integrity by storing small hash (hash tree for huge data)
authentication of data
proofs of retrievability (POR) and of data possession (PDP)

7. Plan
Introduction
High performance computing and cloud
Related works on trusting the clouds
ABFT
Fault tolerant computation in the Sky
Interactive sky computation
ABFT: Algorithmic Based Fault Tolerance
Idea: incorporate redundancy in the algorithm
[HuangAbraham 98] [Saha 2006] [Dongarra al. 2006]
⇒use properties specific to the problem

8. ABFT: Algorithmic Based Fault Tolerance
Idea: incorporate redundancy in the algorithm
[HuangAbraham 98] [Saha 2006] [Dongarra al. 2006]
⇒use properties specific to the problem
Example: Matrix-vector product
A
u uA
ABFT: Algorithmic Based Fault Tolerance
Idea: incorporate redundancy in the algorithm
[HuangAbraham 98] [Saha 2006] [Dongarra al. 2006]
⇒use properties specific to the problem
Example: Matrix-vector product
A Id R
u uA x

9. ABFT: Algorithmic Based Fault Tolerance
Idea: incorporate redundancy in the algorithm
[HuangAbraham 98] [Saha 2006] [Dongarra al. 2006]
⇒use properties specific to the problem
Example: Matrix-vector product
A Id R
u uA x
pre-compute the product B = A × I R
compute x = uB in parallel
decode/correct x
ABFT: Block LU Factorization for linear system solving

10. ABFT: Block LU Factorization for linear system solving
incorporate redundancy : Let A = A.G =
ABFT: Block LU Factorization for linear system solving
incorporate redundancy : Let A = A.G =
General work flow to tolerate one soft error in [Peng Dual. 2011 -1
error-, 2012 -3 errors-]
1. Generate checksum for the input matrix as additional
columns
2. Perform LU factorization WITH the additional checksum
columns
3. Solve Ax=b using LU from the factorization (even if soft
error occurs during LU factorization)
4. Check for soft error
5. Correct solution x
Pros: works with floating point
Cons: few errors, cost=O(nt ) to tolerate t errors

11. Plan
Introduction
High performance computing and cloud
Related works on trusting the clouds
ABFT
Fault tolerant computation in the Sky
Interactive sky computation
Considered sky computing platform
=⇒ Two disjoint set of resources:
U: The sky, unreliable
R: Resources blindly trusted by the user (reliable),
but with limited computation bandwidth
interconnected through a stable memory
Safe Resources
Controler Unsafe Resources
Verifier
Grid
Checkpoint Server
INTERNET
user

12. How to take benefit of the Cloud for HPiC?
Performance and correction
Performance: massive parallelism (work depth)
→ workstealing, adaptive scheduling [Leisersonal. 2007]
Correction of the results: proof
→ verifications on R (e.g. randomized checking)
Fault tolerance: to support resilience and/or errors
→ ABFT: Algorithm Based Fault Tolerance
Execution time model on the cloud
Resource average computation Total computation Usage
type bandwidth per proc bandwidth
Cloud U ΠU Πtot
U computation
Client R ΠR Πtot
R certification
bandwidth: number of unit operations per second
Bound on the time required for computation+certification
Based on work-stealing, with high probability [Bender-Rabin02] :
Wc Dc Wr Dr
Execution time ≤ tot + O + tot + O .
ΠU ΠU ΠR ΠR
Notations and target context:
Wc (resp. Dc ) = total work (resp. depth) executed on the cloud U;
Wr (resp. Dr ) = total work (resp. depth) executed on the client R;
1+
Target context: Wc = O(W1 ); Dc Wc ; Wr , Dr Dc .
Correction: may be computed either on R, or on U, or on both.

13. !#$%
• $'()*+,-)$%./01%23(4)(5#$,3%,)52+-$0%#$*%
,)+*%
• 63#'3*%7)(89%)$%'(+9-$0%'13%,)+*9%
• :;=%/$%.!%
• !#$%%'$()*%+',-#%.'*/*%0(123
– $'3(#,-?3%'(+9'3*%,)52+'#-)$%
– @+A5/B$0%,)52+'#-)$9%%'1()+01%C#263*+,3%
$'3(#,-?3%'(+9'3*%,)52+'#-)$%
)9'%A#$*7/*'1D%
%%E63/#A3%(39)+(,39D%F%D%%!6%%%%%%%%%A/$*G%(3/#A3%H)(#,3I%%A+'%3J23$9/?3K9)7%
%EL$(3/#A3%(39)+(,39FD%!LM%%%%%%N)'%A/$*G%(3/#A3%A+'%,13#2K4#9'%

14. C#263*+,3%')%9+A5/'%O)A9%/$%'13%@8G%
• C#263*+,3%:!%HP))03Q%1#*))2I%
!#$%
• $'()*+,-)$%./01%23(4)(5#$,3%,)52+-$0%#$*%
,)+*%
• 63#'3*%7)(89%)$%'(+9-$0%'13%,)+*9%
• :;=%/$%.!%
• !#$%%'$()*%+',-#%.'*/*%0(123
– $'3(#,-?3%'(+9'3*%,)52+'#-)$%
– @+A5/B$0%,)52+'#-)$9%%'1()+01%C#263*+,3%
– RJ#523D%=(+9'3*%5#'(/J%5+-2/,#-)$%#$*%SL%

15. =(+9'3*%5#'(/J%5+-2/,#-)$%
• $2+'%D%%:Q%;%%)(*3(%$%%%%%T+'2+'%D%U:%;%
• V)(8W)7%D%%
– T$%6%D%3$,)*3%;XU%;MP%%%%H%PU%$%J%H$Y(I%,)*/$0%5#'(/JI%
– T$%'13%,)+*%D%,)52+'3%X/QO%U%8%%;),8C+H%:/8Q;X8O%I%
!
• C#263*+,3%,)52+'#-)$%
– T$%6D%(3,)?3(%%4()5%X%%H+9/$0%P%')%,)((3,'%3(()(9I%
• )9'%H4)(%3J#,'%5#'(/J%5+-2/,#-)$%/$%Z$/'3%Z3*ID%%
– T$%6D%)*/$0%K%)((3,-)$%D%TH%H$Y(I[%)0THI%$Y(I%U%]H$[I%^^%
– T$%LD%5#'(/J%5+-2/,#-)$%D%TH%$%H$Y(I[%I%%%%%%%%%%%%%U%TH$_I%
:%
RJ#523D%=(+9'3*%A),8`SL%% ,)*/$0H:I%
%%%%%%%%%%%%;U%
• 63/#A3%(39)+(,39% • L$(3/#A3%(39)+(,39%
H*/#0)$#%A),89I% H3/5/$#-)$D%#%A),89I%
$/'D%)*/$0%D%;%U%,)*/$0H:I%a%%
4)(%8UMMb%!!#$%'(()*+,!-./-(0+1(
E%
M #,')(/c3%:8Q8%`d%S8Q8Q%L8Q8a%
[M )(%/U8Y%MM%b%E%
%%S/Q8U:/QbML8Q8`a%S/Q8eU,)*/$0HS/Q8Ia%
%%L8Q/US8Q8`M:/Qba%%L8Q/eU,)*/$0HL8Q/Ia%F%
_M !#()(%/U%8Y%MM%b%Q j = k+1..(1+r/n).K%
_M @2#7$%L2*#'3% %%%%%%%%;X/QOU;/QO%h%S/Q8eM%L8QOe%a%
% %%
fM g3,)*/$0Y(3,)*/$0D%
%:%U%*3,)*/$0H;XIa%;%U%,)*/$0H:I%a%%F%
)9'%6D%UbMbMH$KbI#%Y%i*3,)*/$0%UbMH$Y(I[)0H$Y(Ij% )9'%LD%,#,+%U%bMb[MHY(K$IH$KbI#%
%%%%%%%%%%%%%%U%$ _Kb%Y%bM$[%%%
% %%%%%%%%U%$_%
RJ#523%)4%A##$,3%7/'1%#U_a%Ud%%%bUk$%
=)'#%,)9'U%%$[k$%)$%'13%63/#A3%(39)+(,39Q%%%%%%%%%%%%%%%%%%%%%%%#$*%TH$_I%)$%'13%+$(3/#A3%@8G%

16. !#$%
• $'()*+,-)$%./01%23(4)(5#$,3%,)52+-$0%#$*%
,)+*%
• 63#'3*%7)(89%)$%'(+9-$0%'13%,)+*9%
• :;=%/$%.!%
• #+'%')3(#$'%,)52+'#-)$%/$%'13%@8G%
– $'3(#,-?3%'(+9'3*%,)52+'#-)$%
– @+A5/B$0%,)52+'#-)$9%%'1()+01%C#263*+,3%
– RJ#523D%=(+9'3*%5#'(/J%5+-2/,#-)$%#$*%SL%
• 4'*+$#5/'*
– :$$3J%D%R?#+#-)$%K%$'3(2)#-)$%,)*/$0%
)$,+9/)$%
• :0)(/'15%A#93*%4#+'%')3(#$,3%3$#A39%')%*3'3,'K
,)((3,'%3(()(9%H'1()+01%,)*/$0I%
– .!%H4)(%W)#-$0%2)/$'I%
• :;=%4)(%0)A#%,)52+-$0%2#l)(59%
– @3?3(#%3(()(9%1#?3%')%A3%9+22)('3*%H#m#,89I%
• $'3(#,-)$%A3'733$%'13%(3/#A3%,/3$'%#$*%'13%98G%
– =(#*3)n%4)(%23(4)(5#$,3%
– RJ#523D%5#'(/J%,)52+'#-)$%

17. Codes par interpolation / Reed-Solomon
V : un corps (fini) = un mot de Vk est vu comme un polynome
de degré k-1 à coefficients dans V.
1. Rappel : interpolation/évaluation – Vandermonde et FFT.
2. Code par interpolation : codage et décodage sans erreur.
Exemple simple
3. Décodage avec erreurs (Berlekamp-Welch)
4. Extensions: décodage par Euclide étendu.
Extension au cas entier
101
Evaluation / interpolation
matrice de Vandermonde
• [a0, …, an-1] n abscisses d’évaluation distinctes, fixées.
• Soit PS (X) = !i=0..n-1 si.Xi un polynôme : coefficients [s0, …, sn-1]
et soit ses évaluations yj=PS(aj) : évaluation [y0, …, yn-1]
a00 a10 a20 … an-10
a01 a11 a21 … an-11
… aji …
• Soit Gn,n = (matrice de Vandermonde,
a0 k-1 a1k-1 a2k-1 … an-1 k-1
inversible)
a0n-1 a1n-1 a2n-1 … an-1n-1
• Alors : [y0, …, yn-1] = [s0, …, sn-1] . Gn,n
et [s0, …, sn-1] = [y0, …, yn-1] . Gn,n-1
102

18. Interpolation aux racines de l’unité et FFT
• Soit une racine primitive n-ième de l’unité
– ie n=1 et 0, 1, 2, … n-1 sont n valeurs distinctes.
• Soit Gn,n = #n la matrice de Vandermonde : #i,j = i.j . Alors
– [y0, …, yn-1] = [s0, …, sn-1] . #n : calcul en O(n log n) ops [FFT]
– [s0, …, sn-1] = [y0, …, yn-1] . #n-1 : calcul en O(n log n) ops [FFT-inverse]
–
• En choisissant comme abscisses d’évaluation les n racines de l’unité,
évaluation et interpolation se calculent en O(n log n) opérations sur
le corps de base.
• Dans la suite, on prend ai distincts quelconques
(et on peut choisir ai = i pour accélérer codage et décodage)
103
Quelques mots sur la FFT
DEBUT
104

19. «!The Top 10 Algorithms!of the 20th»
[J. Dongarra, F. Sullivan editors, Computing in Science and
Engineering, Jan./Feb. 2000]
[Science page 799, February 4, 2000]
• 1946: The Metropolis Algorithm for Monte Carlo.
• 1947: Simplex Method for Linear Programming.
• 1950: Krylov Subspace Iteration Method.
• 1951: The Decompositional Approach to Matrix Computations.
• 1957: The Fortran Optimizing Compiler.
• 1959: QR Algorithm for Computing Eigenvalues.
• 1962: Quicksort Algorithms for Sorting.
• 1965: Fast Fourier Transform.
« An algorithm the whole family can use »
• « (…) themost ubiquitous algorithm in use today to analyze and manipulate digital or
discrete data. The FFT takes the operation count for discrete Fourier transform from
O(N2) to O(N log N). »
• Life as we know it would be very different without the FFT. » Charles Van Loan
• 1977: Integer Relation Detection.
• 1987: Fast Multipole Method.
Transformée de Fourier discrète (DFT)
Soit (A, +, $, 0, 1) un anneau commutatif tel que
• n = 1+ … + 1 (n fois) est inversible, d’inverse n-1,
• il existe dans A un élément qui est une racine n-ième primitive de l’unité:
0 = n = 1 et pour 0 j n : j ! 1.
Définition : Soit u = [u0, …, un-1] un vecteur de An.
La transformée de Fourier discrète û de u par rapport à est
DFT( u ) = û = [û0, …, ûn-1] avec ûj = !0%kn uk.k.j .
Remarques:
– La valeur de chaque ûk dépend des n entrées u0, …, un-1
– « Transformée » car DFT est inversible :
DFT( u ) = û ! u = n-1 . DFT-1 ( û )
« transformée de Fourier inverse »

20. Algorithme FFT «!Radix 2!» [Cooley-Tuckey 1965]
• On pose n = 2.m : m = -1 ;
– û2k = !0%jm-1 (uj+ uj+m). 2.k..j
– û2k+1 = !0%jm-1 (uj- uj+m) . j . 2.k..j
• D’où, en posant : FFT de taille m=n/2
– = 2 est une racine mième de l’unité
– vj= (uj+ uj+m) ' û2k = !0%jm-1 vj . k..j
– wj= (uj- uj+m) . j ' û2k+1 = !0%jm-1 wj . k..j
FFT de taille m=n/2
« Twiddle factor »
uj vj
uj+m wj
Algorithme FFT «!Radix 2!» [Cooley-Tuckey 1965]
• CoûtFFT(n) = 2. CoûtFFT(n/2) + ((n) = (( n.log2 n ) opérations.
• Remarque: généraliation: FFT de taille n=k.m se ramène à
[ k FFT de taille m ] + [ transposition m$k ) k$m ] + [m FFT de taille k ]

21. M. T. Heideman, D. H. Johnson, C. S. Burrus, Gauss and the history of the fast Fourier transform,
IEEE ASSP Magazine 1 (4), 14–21 (1984).
Quelques mots sur la FFT
FIN
110

22. Codes par interpolation / Reed-Solomon
V : un corps (fini) = un mot de Vk est vu comme un polynome
de degré k-1 à coefficients dans V.
1. Rappel : interpolation/évaluation – Vandermonde et FFT.
2. Code par interpolation : codage et décodage sans erreur.
Exemple simple
3. Décodage avec erreurs (Berlekamp-Welch)
4. Extensions: décodage par Euclide étendu.
Extension au cas entier
111
Codage par évaluation / Interpolation
• Soit S=[ s0, …, sk-1] mot source
• PS (X) = !i=0..k-1 si.Xi de degré k-1 sur V
– caractérisé de manière unique par sa valeur en k points ai distincts
• Pour n !k (et n #V), et pour n points aj distincts fixés
Alors [s0, …, sk-1]![y0, …, yn-1] avec yj=PS(aj)
• Dém:
– (sj)=(yj) : évaluation Pour j=0, … n-1: yj=!i=0..k-1si.aji
– (yj)=(sj): interpolation: !i=0..k-1si.Xi = !i=0..n-1 yi Li.(X)
avec Li.(X) = *j!i (ai - aj)-1.(X- aj) : polynôme de Lagrange
112

23. Ex. Code d’interpolation (6, 2) dans V=GF(11)
• Code (6, 2) sur GF(11) par évaluation aux abscisses (0, 1, 2, 3, 4, 5)
(code de distance 5 donc 2 correcteur !)
Codage Mot source: [7,2]
Polynôme associé au mot source: P = 7 + 2 X
Mot de code transmis : [7, 9, 0, 2, 4, 6] i.e. évaluation de P aux abscisses (ai)= (0, 1, 2, 3, 4, 5)
Décodage: (si il n’y a pas d’erreurs) Mot de code reçu : [7, 9, 0, 2, 4, 6]
Calcul du polynôme d’interpolation aux valeurs reçues:
(calcul par Lagrange, ou par résolution du système Vandermonde
ou mieux par remontée récursive)
• Interpolation en (a0=0, y0=7) et (a1=1, y1=9) : P01 = 9.X - 7.(X-1) = 2.X + 7 mod 11
• Interpolation en (a2=2, y2=0) et (a3=3, y3=2) : P23 = 2.(X-2) + 0.(X-3) = 2X – 4 = 2X + 7 mod 11
• Interpolation en (a4=4, y4=4) et (a5=5, y5=6) : P23 = 6.(X-4) - 4.(X-5) = 2X – 4 = 2X + 7 mod 11
Etc: on fusionne les polynômes récursivement: direct ici.
Polynôme interpolé mod 11 = 7 + 2.X = Mot décodé: [7, 2]
113
Matrice génératrice du code
= matrice de Vandermonde
• k premières lignes de la matrice (n,n) :
Gk,n
a00 a10 a20 … an-10
a01 a11 a21 … an-11
… aij …
Gn,n =
a0k-1 a1k-1 a2k-1 … an-1k-1
a0n-1 a1n-1 a2n-1 … an-1n-1
114

24. Codage / décodage sans erreur par Vandermonde
• Code (6, 2) sur GF(11) par évaluation aux abscisses (0, 1, 2, 3, 4, 5)
1 1 1 1 1 1
0 1 2 3 4 5
• G2,6= Matrice génératrice 0 1 4 9 5 3
= 2 premières lignes de la matrice de Vandermonde G6,6 = 0 1 8 5 9 4
0 1 5 4 5 9
0 1 10 1 9 1
• Codage : multplication par G2,6
codage ( [7, 2 ] ) = [7 2]. G2,6 = [ 7 9 0 2 4 6 ]
• Décodage sans erreur : multiplication par G6,6-1
decodage ([ 7 9 0 2 4 6 ] ) = [ 7 9 0 2 4 6 ] . G6,6-1 = [7 2 0 0 0 0] = [7 2 ]
On reçoit [ y1 y2 y3 y4 y5 y6 ]
– 1/ Calcul de [ s1 s2 s3 s4 s5 s6 ] = [ y1 y2 y3 y4 y5 y6 ] . G6,6-1
– 2/ Si s3=s4=s5=s6=0 : on a reçu un mot de code ! = le mot décodé est [ s1 s2 ]
sinon: détection d’erreurs ([ s1 s2 s3 s4 s5 s6 ] )
115
Codes par interpolation / Reed-Solomon
V : un corps (fini) = un mot de Vk est vu comme un polynome
de degré k-1 à coefficients dans V.
1. Rappel : interpolation/évaluation – Vandermonde et FFT.
2. Code par interpolation : codage et décodage sans erreur.
Exemple simple
3. Décodage avec erreurs (Berlekamp-Welch)
4. Extensions: décodage par Euclide étendu.
Extension au cas entier
116

25. Interpolation et correction
• Théorème fondamental:
Le code (n,k) par évaluation/interpolation est de distance d=n-k+1.
(NB donc d=r+1 : distance maximale – MDS - ).
• Preuve:
– Soient n évaluations (yj) d’un polynôme P de degré ! k-1.
Parmi ces n évauations, e sont erronées.
– Si 2e ! n-k, alors P est l’unique polynôme de degré k qui corresponde à
au moins n-e évaluations correctes, i.e.
#{ j=0..n-1 : yj P(aj) } ! e
– Corrige donc e(n-k)/2 erreurs: donc est de distance d = n - k + 1
• Intérêt: construction de codes correcteurs de distance d arbitraire :
• Distance maximale, mais il faut suffisament de points d’interpolation
117
Décodage du code d’interpolation avec correction
[par Berlekamp-Welch]
on reçoit un mot [ y0 …yn-1 ] avec des erreurs
• Problème décodage avec e!(n-k)/2=r/2 erreurs et t=n-ek+r/2 valeurs correctes.
– Entrée: on reçoit y0, …, yn-1 ∈ Fn vérifiant ∃P∈ F[X] de degré k tel que #{i / yi= P(ai) } ! t.
– Sortie : le polynôme P unique tel que #{i / yi= P(ai) } ! t.
• Principe :
– Soit T={ i / yi= P(ai) = L(ai) }les indices des valeurs correctes;
– { i T }les indices des valeurs erronées et E(X)= *i T (X-ai) le polynôme localisateur d’erreur :
on a Degré( E ) e [NB yi# P(ai) ssi E(ai) = 0 ].
– Posons N(X)=P(X).E(X) qui est de degré k+e-1: on a donc pour i=0..n-1 : N(ai) = P(ai).E(ai) ;
– P et E sont inconnus mais pour i ∈ T : N(ai) = E(ai).P(ai) = E(ai).yi
et pour i T : N(ai) = 0 = E(ai).yi
– donc, pour i=0..n-1 : N(ai) = yi.E(ai) ie un système de n équations à k+2.e n inconnues
(les inconnues sont les e coefs de E et k+e coefs de N);
– Ce système admet une solution unique (car P est unique) !
118

26. Décodage unique de Reed-Solomon par Berlekamp-Welch
• Algorithme: on reçoit un mot [ y0 …yn-1 ] avec des erreurs
1. // Calculer le polynôme d’interpolation L(X) = !i=0..n-1 ui.Xi
Calculer [u0, …, un-1] := [y0, …, yn-1] . Gn,n-1
Si [uk, …, un-1] sont tous nuls, retourner [u0, …, uk-1]
2. Sinon correction : // Résoudre pour i=0..n-1 : N(ai) = yi.E(ai)
// Soient E(X) = u0 +u1X + … +ue-1 Xe-1 + 1. Xe
// et N(X) = v0 +v1X + … … … … … … … … …+vk+e-1 Xk+e-1
Résoudre [ v0 v1 … … vk+e-1 0 … 0 ] . Gn,n = [ u0 u1 … ue-1 1 0 … … 0 ] . Gn,n . Diag(y0, …, yn-1) .
3. Si E(X) divise N(X) : calculer P(X) := N(X) div E(X) et retourner les coefficients [s0, …, sk-1] de P.
Sinon retourner « Erreur détectée non corrigeable (plus de (n-k)/2 erreurs ) »
• Coût : O(n log n) si pas d’erreurs; O(n3) si erreurs.
Remarque: il existe des algorithmes plus rapides en O(n.log2 n).
[Berlekamp-Massey, ou calcul de pgcd tronqué en utilisant un algorithme de pgcd rapide].
119
Résolution système linéaire
• Soit D = Diag(y0, …, yn-1)
• [ v0 v1 … … vk+e-1 0 … 0 ].Gn,n=[ u0 u1 … ue-1 1 0 … … 0 ]. Gn,n.D.
• Soit M = Gn,n.D.Gn,n-1 et soient
– Me,n = sous-matrice formée des e premières lignes de M
– me+1= ligne e+1 de M
– Alors: [ v0 v1 … … vk+e-1 0 … 0 ]=[ u0 u1 … ue-1]. Me,n + me+1.
• Soit Q = matrice formée des e premières lignes et e dernières colonnes de M
[ u0 u1 … ue-1] . Q = - [mn-e, … , mn-1], d’où [ u0 u1 … ue-1].
• Puis [ v0 v1 … … vk+e-1] = [ u0 u1 … ue-1 1]. Me+1,n.
ou bien: isoler les ai incorrects grâce aux ui (en testant si E(ai)=0) puis
interpoler (ou approximer aux moindres carrés) P aux valeurs correctes restantes
• NB On peut trouver aussi un vecteur u qui minimise la norme 2 en
ponderant avec un gros poids les composantes qui doivent être nulles.
120

27. Extension: Power decoding
• Généralisation du schéma précédent en élevant yi à la puissance q
– Posons N(q)(X)=Pq(X).E(X) qui est de degré q.(k-1)+e: donc pour i=0..n-1: N(q)(ai)=Pq(ai).E(ai)
– P et E sont inconnus mais pour i ∈ T : N(q) (ai) = E(ai).Pq (ai) = E(ai).yiq
et pour i T : N(q) (ai) = 0 = E(ai).yiq
ie un système de n équations dont les inconnues sont les e coefs de E et les q.(k-1)+e+1 de N(q).
– En prenant successivement q=1 (cas de base précédent), q=2, q=3, … q= b : on obtient un
système d’équations:
N(q)(ai) = yiq.E(ai) pour i=0..n-1, q=1, …, b
– soit en tout n.b équations (linéairement indépendantes en caractéristique nulle) dont les inconnues
sont les coefs de E et ceux de N(1), N(2), …, N(b):
• à savoir, en tout: e + !q=1..b q.(k-1)+e+1 = e(b+1) + 1 + (k-1).b(b+1)/2 inconnues
– Pour que le nombre d’inconnues soit plus petit que le nombre d’équations (nb), il faut:
e(b+1) + 1 + (k-1).b(b+1)/2 n.b
121
Codes par interpolation / Reed-Solomon
V : un corps (fini) = un mot de Vk est vu comme un polynome
de degré k-1 à coefficients dans V.
1. Rappel : interpolation/évaluation – Vandermonde et FFT.
2. Code par interpolation : codage et décodage sans erreur.
Exemple simple
3. Décodage avec erreurs (Berlekamp-Welch)
4. Extensions: décodage par Euclide étendu.
Extension au cas entier
122

28. Autre algorithme de correction
• Euclide étendu tronqué / Berlekamp-Massey
123
Correction
• Soit Q(X) le polynôme qui interpole les (yj) en les n points:
Q(X) = P(X) + E(X) avec E = polynôme d’erreur
• Soit * (X)=*j=0..n-1 (X - xj)
• Soit I le sous ensemble des n-t points xj tels que P(xj) =yj [corrects]
• Pour tout xj de I : E(xj)=0
• Donc E(X) est un multiple de *V(X)= *j dans I(X - xj) :
E(X) = Z(X). *V(X)
et PGCD ( E(X) , *(X) ) = *V(X) donc de degré n-t # k+t
• Astuce: les premières étapes du calcul PGCD(Q(X)=P+E, * (X))
donnent les mêmes quotients que PGCD(E(X), * (X)) !!! 124

29. Exemple
• Q = E + P : degré(P) k-1 ; degre(Q) =degré(E) # n-k
• Séquence des restes Ri dans l’algorithme d’Euclide (eténdu) : Ri = Ai.* + Bi.Q
Initialement R0 = * ; R1 = Q; R2 = * rem Q (reste Euclidien)
Ri = Ai.* + Bi.Q
Bi
125
Algorithme de correction par Euclide tronqué
• Entrée: * , Q = polynôme d’interpolation aux n points y
• Sortie: P de degré k-1 qui correspond à n-t évaluations
• A0=1.X0; B0 = 0; R0=*;
A1=0; B1=1.X0; R1=Q;
• For ( i=1 ; deg(Ri) # n - t ; i+=1 )
– Soit qi le quotient euclidien de Ri-1 par Ri.
– Ri+1 = Ri-1 - qi.Ri ;
– Ai+1 = Ai-1 - qi.Ai ;
– Bi+1 = Bi-1 - qi.Bi ;
• Return P = Ri / Bi ; // Bi est un multiple de Ri
126

30. Codage et Décodage en Maple
##### Fonction de CODAGE d'un mot a
##### (i.e. evaluation du polynome Pa(X) aux abscisses x[i] i=1..n
CodageInterpol := proc( a::list)::list ;
local Pa, y, i ; # Pa est le polynome associé à a; y le vecteur des évaluations
description Codage par interpolation aux n points x[i] du mot source a de longueur k »;
Pa := sum( op(i+1,a)*'X'^i, i=0.. k-1) mod q :
y := [seq( eval(Pa, X=x[i]) mod q, i=1..n )] : ##### Fonction de DECODAGE ET CORRECTION par algorithme d'Euclide tronqué
print(Polynome associé au mot source:, Pa) : DecodageInterpol := proc( yrecu::list)::list ;
print(Mot de code transmis :, y) : local
y
end proc; Precu, # Le polynome d'interpolation de degré n associé au mot recu
Pcorr, motcorrige, # Le polynome corrigé et le mot associé
A0, B0, A1, B1, # Les coefficients de Bezout dans Euclide
i, aux ;# Variables internes pour les boucles et pour les permutations
description Decodage par interpolation aux n points x[i] du mot recu de longueur n;
Precu:= expand( sum( op(i,yrecu)*op(i,LL), i=1..n )) mod q;
Polynôme d’interpolation print(Mot reçu : yrecu = , yrecu ) :
(formule de Lagrange) print(Interpolation de yrecu :, Precu ) :
A0:=1: B0:=0: R0 := PI: print(Reste Euclide tronqué:, R0) :
A1:=0: B1:=1: R1 := Precu: print(Reste Euclide tronqué:, R1):
while (degree(R1) = n-t) do
Algorithme d’Euclide tronqué quotient := Quo(R0, R1, X) mod q:
(reconstruction rationnelle) aux := Expand(R0 - quotient*R1) mod q: R0:=R1: R1:=aux : print(Reste Euclide tronqué:, R1):
aux := Expand(A0 - quotient*A1) mod q: A0:=A1: A1:=aux :
aux := Expand(B0 - quotient*B1) mod q: B0:=B1: B1:=aux :
end do :
if ( Rem(R1,B1,X) mod q 0) then
print (*** ERREUR: CORRECTION IMPOSSIBLE *** Reste non nul=, Rem(R1, B1, X) mod q ) :
motcorrige :=[ ECHEC DECODAGE car trop d'erreurs! ]
else
Pcorr := Quo(R1, B1, X) mod q:
Polynôme source motcorrige := [seq(coeff(Pcorr,'X',i), i=0..max(degree(Pcorr),k-1) ) ] :
après correction print( Polynome interpolé corrigé=, Pcorr, qui correspond au mot source:, motcorrige)
end if :
motcorrige 127
end proc;
Un exemple dans GF(11)
• Evaluation aux abscisses (0, 1, 2, 3, 4, 5) donc Code (6, 2, 5) qui est t=2 correcteur
Codage Mot source: [7,2]
Polynôme associé au mot source: P = 7 + 2 X
Mot de code transmis : [7, 9, 0, 2, 4, 6] (i.e. évaluation de P aux absisses X= 0, 1, 2, 3, 4, 5)
Décodage: Mot reçu avec 2 erreurs: [7, 4, 0, 2, 6, 6]
1/ Polynôme d’interpolation aux valeurs reçues: Q:= 2 X5 +2 X4 + 7 X3 + 6 X2 + 2 X + 7
2/ Séquence des restes dans l’algorithme d’Euclide étendu (et coefficient de Bezout B associé):
Étape 0: R0 = L(X) = X (X – 1) (X – 2) (X – 3) (X – 4) (X – 5) [ B0 = 0 ]
Étape 1: R1 = Q(X) = 2 X5 + 2 X4 + 7 X3 + 6 X2 + 2 X + 7 [ B1 = 1 ]
Étape 2: R2 = R0 mod R1 = 4X 4 + 4 X3 + 2 X2 + 8 X + 1 [ B2 = 5 X + 8 ]
Étape 3: R3 = R1 mod R2 = 6 X3 + 2 X2 + 7 X + 7 [ B3 = 3 X2 + 7 X + 1 ]
Arrêt de l’algorithme d’Euclide car degré inférieur ou égal à n-t = 4.
3/ Correction: Calcul de R3/B3 = (6 X3 + 2 X2 + 7 X + 7) / (3 X2 + 7 X + 1 ) mod 11 = 7 X + 2
= Mot décodé: [7, 2]
128