autre correc english

[prng_gpu.git] / prng_gpu.tex

diff --git a/prng_gpu.tex b/prng_gpu.tex
index 678217540467750ffd9322330118fe8e6593fa47..7d94e0c7e3fa6fbffc4698764646a59f6849838b 100644 (file)
--- a/prng_gpu.tex
+++ b/prng_gpu.tex
@@ -7,7 +7,7 @@
 \usepackage{amscd}
 \usepackage{moreverb}
 \usepackage{commath}
 \usepackage{amscd}
 \usepackage{moreverb}
 \usepackage{commath}

-\usepackage{algorithm2e}
+\usepackage[ruled,vlined]{algorithm2e}

 \usepackage{listings}
 \usepackage[standard]{ntheorem}
 
 \usepackage{listings}
 \usepackage[standard]{ntheorem}
 


@@ -48,17 +48,18 @@ graphics processing units  (GPU). This PRNG is based  on the so-called chaotic i
 is firstly proven  to be chaotic according to the Devaney's  formulation. We thus propose  an efficient
 implementation  for  GPU that successfully passes the   {\it BigCrush} tests, deemed to be the  hardest
 battery of tests in TestU01.  Experiments show that this PRNG can generate
 is firstly proven  to be chaotic according to the Devaney's  formulation. We thus propose  an efficient
 implementation  for  GPU that successfully passes the   {\it BigCrush} tests, deemed to be the  hardest
 battery of tests in TestU01.  Experiments show that this PRNG can generate

-about 20 billions of random numbers  per second on Tesla C1060 and NVidia GTX280
+about 20 billion of random numbers  per second on Tesla C1060 and NVidia GTX280

 cards.
 cards.

-It is finally established that, under reasonable assumptions, the proposed PRNG can be cryptographically 
+It is then established that, under reasonable assumptions, the proposed PRNG can be cryptographically 

 secure.
 secure.

+A chaotic version of the Blum-Goldwasser asymmetric key encryption scheme is finally proposed.

 
 
 \end{abstract}
 
 \section{Introduction}
 
 
 
 \end{abstract}
 
 \section{Introduction}
 

-Randomness is of importance in many fields as scientific simulations or cryptography. 
+Randomness is of importance in many fields such as scientific simulations or cryptography. 

 ``Random numbers'' can mainly be generated either by a deterministic and reproducible algorithm
 called a pseudorandom number generator (PRNG), or by a physical non-deterministic 
 process having all the characteristics of a random noise, called a truly random number
 ``Random numbers'' can mainly be generated either by a deterministic and reproducible algorithm
 called a pseudorandom number generator (PRNG), or by a physical non-deterministic 
 process having all the characteristics of a random noise, called a truly random number


@@ -66,21 +67,21 @@ generator (TRNG).
 In this paper, we focus on reproducible generators, useful for instance in
 Monte-Carlo based simulators or in several cryptographic schemes.
 These domains need PRNGs that are statistically irreproachable. 
 In this paper, we focus on reproducible generators, useful for instance in
 Monte-Carlo based simulators or in several cryptographic schemes.
 These domains need PRNGs that are statistically irreproachable. 

-On some fields as in numerical simulations, speed is a strong requirement
+In some fields such as in numerical simulations, speed is a strong requirement

 that is usually attained by using parallel architectures. In that case,
 that is usually attained by using parallel architectures. In that case,

-a recurrent problem is that a deflate of the statistical qualities is often
+a recurrent problem is that a deflation of the statistical qualities is often

 reported, when the parallelization of a good PRNG is realized.
 This is why ad-hoc PRNGs for each possible architecture must be found to
 achieve both speed and randomness.
 On the other side, speed is not the main requirement in cryptography: the great
 reported, when the parallelization of a good PRNG is realized.
 This is why ad-hoc PRNGs for each possible architecture must be found to
 achieve both speed and randomness.
 On the other side, speed is not the main requirement in cryptography: the great

-need is to define \emph{secure} generators being able to withstand malicious
+need is to define \emph{secure} generators able to withstand malicious

 attacks. Roughly speaking, an attacker should not be able in practice to make 
 the distinction between numbers obtained with the secure generator and a true random
 sequence. 
 attacks. Roughly speaking, an attacker should not be able in practice to make 
 the distinction between numbers obtained with the secure generator and a true random
 sequence. 

-Finally, a small part of the community working in this domain focus on a
+Finally, a small part of the community working in this domain focuses on a

 third requirement, that is to define chaotic generators.
 The main idea is to take benefits from a chaotic dynamical system to obtain a
 third requirement, that is to define chaotic generators.
 The main idea is to take benefits from a chaotic dynamical system to obtain a

-generator that is unpredictable, disordered, sensible to its seed, or in other words chaotic.
+generator that is unpredictable, disordered, sensible to its seed, or in other word chaotic.

 Their desire is to map a given chaotic dynamics into a sequence that seems random 
 and unassailable due to chaos.
 However, the chaotic maps used as a pattern are defined in the real line 
 Their desire is to map a given chaotic dynamics into a sequence that seems random 
 and unassailable due to chaos.
 However, the chaotic maps used as a pattern are defined in the real line 


@@ -94,7 +95,7 @@ This is why the use of chaos for PRNG still remains marginal and disputable.
 The authors' opinion is that topological properties of disorder, as they are
 properly defined in the mathematical theory of chaos, can reinforce the quality
 of a PRNG. But they are not substitutable for security or statistical perfection.
 The authors' opinion is that topological properties of disorder, as they are
 properly defined in the mathematical theory of chaos, can reinforce the quality
 of a PRNG. But they are not substitutable for security or statistical perfection.

-Indeed, to the authors' point of view, such properties can be useful in the two following situations. On the
+Indeed, to the authors' mind, such properties can be useful in the two following situations. On the

 one hand, a post-treatment based on a chaotic dynamical system can be applied
 to a PRNG statistically deflective, in order to improve its statistical 
 properties. Such an improvement can be found, for instance, in~\cite{bgw09:ip,bcgr11:ip}.
 one hand, a post-treatment based on a chaotic dynamical system can be applied
 to a PRNG statistically deflective, in order to improve its statistical 
 properties. Such an improvement can be found, for instance, in~\cite{bgw09:ip,bcgr11:ip}.


@@ -109,7 +110,7 @@ Let us finish this paragraph by noticing that, in this paper,
 statistical perfection refers to the ability to pass the whole 
 {\it BigCrush} battery of tests, which is widely considered as the most
 stringent statistical evaluation of a sequence claimed as random.
 statistical perfection refers to the ability to pass the whole 
 {\it BigCrush} battery of tests, which is widely considered as the most
 stringent statistical evaluation of a sequence claimed as random.

-This battery can be found into the well-known TestU01 package~\cite{LEcuyerS07}.
+This battery can be found in the well-known TestU01 package~\cite{LEcuyerS07}.

 Chaos, for its part, refers to the well-established definition of a
 chaotic dynamical system proposed by Devaney~\cite{Devaney}.
 
 Chaos, for its part, refers to the well-established definition of a
 chaotic dynamical system proposed by Devaney~\cite{Devaney}.
 


@@ -130,20 +131,22 @@ applications. Therefore,  it is important  to be able to  generate pseudorandom
 numbers inside a GPU when a scientific application runs in it. This remark
 motivates our proposal of a chaotic and statistically perfect PRNG for GPU.  
 Such device
 numbers inside a GPU when a scientific application runs in it. This remark
 motivates our proposal of a chaotic and statistically perfect PRNG for GPU.  
 Such device

-allows us to generated almost 20 billions of pseudorandom numbers per second.
-Last, but not least, we show that the proposed post-treatment preserves the
+allows us to generate almost 20 billion of pseudorandom numbers per second.
+Furthermore, we show that the proposed post-treatment preserves the

 cryptographical security of the inputted PRNG, when this last has such a 
 property.
 cryptographical security of the inputted PRNG, when this last has such a 
 property.

+Last, but not least, we propose a rewritting of the Blum-Goldwasser asymmetric
+key encryption protocol by using the proposed method.

 
 The remainder of this paper  is organized as follows. In Section~\ref{section:related
   works} we  review some GPU implementations  of PRNGs.  Section~\ref{section:BASIC
   RECALLS} gives some basic recalls  on the well-known Devaney's formulation of chaos, 
   and on an iteration process called ``chaotic
 iterations'' on which the post-treatment is based. 
 
 The remainder of this paper  is organized as follows. In Section~\ref{section:related
   works} we  review some GPU implementations  of PRNGs.  Section~\ref{section:BASIC
   RECALLS} gives some basic recalls  on the well-known Devaney's formulation of chaos, 
   and on an iteration process called ``chaotic
 iterations'' on which the post-treatment is based. 

-Proofs of chaos are given in  Section~\ref{sec:pseudorandom}.
+The proposed PRNG and its proof of chaos are given in  Section~\ref{sec:pseudorandom}.

 Section~\ref{sec:efficient    PRNG}   presents   an   efficient
 implementation of  this chaotic PRNG  on a CPU, whereas   Section~\ref{sec:efficient PRNG
 Section~\ref{sec:efficient    PRNG}   presents   an   efficient
 implementation of  this chaotic PRNG  on a CPU, whereas   Section~\ref{sec:efficient PRNG

-  gpu}   describes   the  GPU   implementation. 
+  gpu}   describes and evaluates theoretically  the  GPU   implementation. 

 Such generators are experimented in 
 Section~\ref{sec:experiments}.
 We show in Section~\ref{sec:security analysis} that, if the inputted
 Such generators are experimented in 
 Section~\ref{sec:experiments}.
 We show in Section~\ref{sec:security analysis} that, if the inputted


@@ -151,7 +154,8 @@ generator is cryptographically secure, then it is the case too for the
 generator provided by the post-treatment.
 Such a proof leads to the proposition of a cryptographically secure and
 chaotic generator on GPU based on the famous Blum Blum Shum
 generator provided by the post-treatment.
 Such a proof leads to the proposition of a cryptographically secure and
 chaotic generator on GPU based on the famous Blum Blum Shum

-in Section~\ref{sec:CSGPU}.
+in Section~\ref{sec:CSGPU}, and to an improvement of the
+Blum-Goldwasser protocol in Sect.~\ref{Blum-Goldwasser}.

 This research work ends by a conclusion section, in which the contribution is
 summarized and intended future work is presented.
 
 This research work ends by a conclusion section, in which the contribution is
 summarized and intended future work is presented.
 


@@ -161,8 +165,8 @@ summarized and intended future work is presented.
 \section{Related works on GPU based PRNGs}
 \label{section:related works}
 
 \section{Related works on GPU based PRNGs}
 \label{section:related works}
 

-Numerous research works on defining GPU based PRNGs have yet been proposed  in the
-literature, so that completeness is impossible.
+Numerous research works on defining GPU based PRNGs have already been proposed  in the
+literature, so that exhaustivity is impossible.

 This is why authors of this document only give reference to the most significant attempts 
 in this domain, from their subjective point of view. 
 The  quantity of pseudorandom numbers generated per second is mentioned here 
 This is why authors of this document only give reference to the most significant attempts 
 in this domain, from their subjective point of view. 
 The  quantity of pseudorandom numbers generated per second is mentioned here 


@@ -180,7 +184,7 @@ chaos or cryptography in this document.
 In \cite{ZRKB10}, the authors propose  different versions of efficient GPU PRNGs
 based on  Lagged Fibonacci or Hybrid  Taus.  They have  used these
 PRNGs   for  Langevin   simulations   of  biomolecules   fully  implemented   on
 In \cite{ZRKB10}, the authors propose  different versions of efficient GPU PRNGs
 based on  Lagged Fibonacci or Hybrid  Taus.  They have  used these
 PRNGs   for  Langevin   simulations   of  biomolecules   fully  implemented   on

-GPU. Performance of  the GPU versions are far better than  those obtained with a
+GPU. Performances of  the GPU versions are far better than  those obtained with a

 CPU, and these PRNGs succeed to pass the {\it BigCrush} battery of TestU01. 
 However the evaluations of the proposed PRNGs are only statistical ones.
 
 CPU, and these PRNGs succeed to pass the {\it BigCrush} battery of TestU01. 
 However the evaluations of the proposed PRNGs are only statistical ones.
 


@@ -192,11 +196,11 @@ the  performance  of the  same  PRNGs on  different architectures are compared.
 FPGA appears as  the  fastest  and the most
 efficient architecture, providing the fastest number of generated pseudorandom numbers
 per joule. 
 FPGA appears as  the  fastest  and the most
 efficient architecture, providing the fastest number of generated pseudorandom numbers
 per joule. 

-However, we can notice that authors can ``only'' generate between 11 and 16GSamples/s
+However, we notice that authors can ``only'' generate between 11 and 16GSamples/s

 with a GTX 280  GPU, which should be compared with
 the results presented in this document.
 We can remark too that the PRNGs proposed in~\cite{conf/fpga/ThomasHL09} are only
 with a GTX 280  GPU, which should be compared with
 the results presented in this document.
 We can remark too that the PRNGs proposed in~\cite{conf/fpga/ThomasHL09} are only

-able to pass the {\it Crush} battery, which is very easy compared to the {\it Big Crush} one.
+able to pass the {\it Crush} battery, which is far easier than the {\it Big Crush} one.

 
 Lastly, Cuda  has developed  a  library for  the  generation of  pseudorandom numbers  called
 Curand~\cite{curand11}.        Several       PRNGs        are       implemented, among
 
 Lastly, Cuda  has developed  a  library for  the  generation of  pseudorandom numbers  called
 Curand~\cite{curand11}.        Several       PRNGs        are       implemented, among


@@ -206,7 +210,7 @@ their  fastest version provides  15GSamples/s on  the new  Fermi C2050  card.
 But their PRNGs cannot pass the whole TestU01 battery (only one test is failed).
 \newline
 \newline
 But their PRNGs cannot pass the whole TestU01 battery (only one test is failed).
 \newline
 \newline

-We can finally remark that, to the best of our knowledge, no GPU implementation have been proven to be chaotic, and the cryptographically secure property is surprisingly never regarded.
+We can finally remark that, to the best of our knowledge, no GPU implementation has been proven to be chaotic, and the cryptographically secure property has surprisingly never been considered.

 
 \section{Basic Recalls}
 \label{section:BASIC RECALLS}
 
 \section{Basic Recalls}
 \label{section:BASIC RECALLS}


@@ -380,9 +384,9 @@ their distance should increase too.
 \item In addition, if two systems present the same cells and their respective
 strategies start with the same terms, then the distance between these two points
 must be small because the evolution of the two systems will be the same for a
 \item In addition, if two systems present the same cells and their respective
 strategies start with the same terms, then the distance between these two points
 must be small because the evolution of the two systems will be the same for a

-while. Indeed, the two dynamical systems start with the same initial condition,
-use the same update function, and as strategies are the same for a while, then
-components that are updated are the same too.
+while. Indeed, both dynamical systems start with the same initial condition,
+use the same update function, and as strategies are the same for a while, furthermore
+updated components are the same as well.

 \end{itemize}
 The distance presented above follows these recommendations. Indeed, if the floor
 value $\lfloor d(X,Y)\rfloor $ is equal to $n$, then the systems $E, \check{E}$
 \end{itemize}
 The distance presented above follows these recommendations. Indeed, if the floor
 value $\lfloor d(X,Y)\rfloor $ is equal to $n$, then the systems $E, \check{E}$


@@ -391,7 +395,7 @@ measure of the differences between strategies $S$ and $\check{S}$. More
 precisely, this floating part is less than $10^{-k}$ if and only if the first
 $k$ terms of the two strategies are equal. Moreover, if the $k^{th}$ digit is
 nonzero, then the $k^{th}$ terms of the two strategies are different.
 precisely, this floating part is less than $10^{-k}$ if and only if the first
 $k$ terms of the two strategies are equal. Moreover, if the $k^{th}$ digit is
 nonzero, then the $k^{th}$ terms of the two strategies are different.

-The impact of this choice for a distance will be investigate at the end of the document.
+The impact of this choice for a distance will be investigated at the end of the document.

 
 Finally, it has been established in \cite{guyeux10} that,
 
 
 Finally, it has been established in \cite{guyeux10} that,
 


@@ -414,8 +418,7 @@ The relation between $\Gamma(f)$ and $G_f$ is clear: there exists a
 path from $x$ to $x'$ in $\Gamma(f)$ if and only if there exists a
 strategy $s$ such that the parallel iteration of $G_f$ from the
 initial point $(s,x)$ reaches the point $x'$.
 path from $x$ to $x'$ in $\Gamma(f)$ if and only if there exists a
 strategy $s$ such that the parallel iteration of $G_f$ from the
 initial point $(s,x)$ reaches the point $x'$.

-
-We have finally proven in \cite{bcgr11:ip} that,
+We have then proven in \cite{bcgr11:ip} that,

 
 
 \begin{theorem}
 
 
 \begin{theorem}


@@ -424,14 +427,33 @@ Let $f:\mathds{B}^\mathsf{N}\to\mathds{B}^\mathsf{N}$. $G_f$ is chaotic  (accord
 if and only if $\Gamma(f)$ is strongly connected.
 \end{theorem}
 
 if and only if $\Gamma(f)$ is strongly connected.
 \end{theorem}
 

-This result of chaos has lead us to study the possibility to build a
+Finally, we have established in \cite{bcgr11:ip} that,
+\begin{theorem}
+  Let $f: \mathds{B}^{n} \rightarrow \mathds{B}^{n}$, $\Gamma(f)$ its
+  iteration graph, $\check{M}$ its adjacency
+  matrix and $M$
+  a $n\times n$ matrix defined by 
+  $
+  M_{ij} = \frac{1}{n}\check{M}_{ij}$ %\textrm{ 
+  if $i \neq j$ and  
+  $M_{ii} = 1 - \frac{1}{n} \sum\limits_{j=1, j\neq i}^n \check{M}_{ij}$ otherwise.
+  
+  If $\Gamma(f)$ is strongly connected, then 
+  the output of the PRNG detailed in Algorithm~\ref{CI Algorithm} follows 
+  a law that tends to the uniform distribution 
+  if and only if $M$ is a double stochastic matrix.
+\end{theorem} 
+
+
+These results of chaos and uniform distribution have led us to study the possibility of building a

 pseudorandom number generator (PRNG) based on the chaotic iterations. 
 As $G_f$, defined on the domain   $\llbracket 1 ;  \mathsf{N} \rrbracket^{\mathds{N}} 
 pseudorandom number generator (PRNG) based on the chaotic iterations. 
 As $G_f$, defined on the domain   $\llbracket 1 ;  \mathsf{N} \rrbracket^{\mathds{N}} 

-\times \mathds{B}^\mathsf{N}$, is build from Boolean networks $f : \mathds{B}^\mathsf{N}
+\times \mathds{B}^\mathsf{N}$, is built from Boolean networks $f : \mathds{B}^\mathsf{N}

 \rightarrow \mathds{B}^\mathsf{N}$, we can preserve the theoretical properties on $G_f$
 \rightarrow \mathds{B}^\mathsf{N}$, we can preserve the theoretical properties on $G_f$

-during implementations (due to the discrete nature of $f$). It is as if
+during implementations (due to the discrete nature of $f$). Indeed, it is as if

 $\mathds{B}^\mathsf{N}$ represents the memory of the computer whereas $\llbracket 1 ;  \mathsf{N}
 \rrbracket^{\mathds{N}}$ is its input stream (the seeds, for instance, in PRNG, or a physical noise in TRNG).
 $\mathds{B}^\mathsf{N}$ represents the memory of the computer whereas $\llbracket 1 ;  \mathsf{N}
 \rrbracket^{\mathds{N}}$ is its input stream (the seeds, for instance, in PRNG, or a physical noise in TRNG).

+Let us finally remark that the vectorial negation satisfies the hypotheses of both theorems above.

 
 \section{Application to Pseudorandomness}
 \label{sec:pseudorandom}
 
 \section{Application to Pseudorandomness}
 \label{sec:pseudorandom}


@@ -485,7 +507,7 @@ It takes as input: a Boolean function $f$ satisfying Theorem~\ref{Th:Caractéris
 an integer $b$, ensuring that the number of executed iterations is at least $b$
 and at most $2b+1$; and an initial configuration $x^0$.
 It returns the new generated configuration $x$.  Internally, it embeds two
 an integer $b$, ensuring that the number of executed iterations is at least $b$
 and at most $2b+1$; and an initial configuration $x^0$.
 It returns the new generated configuration $x$.  Internally, it embeds two

-\textit{XORshift}$(k)$ PRNGs~\cite{Marsaglia2003} that returns integers
+\textit{XORshift}$(k)$ PRNGs~\cite{Marsaglia2003} that return integers

 uniformly distributed
 into $\llbracket 1 ; k \rrbracket$.
 \textit{XORshift} is a category of very fast PRNGs designed by George Marsaglia,
 uniformly distributed
 into $\llbracket 1 ; k \rrbracket$.
 \textit{XORshift} is a category of very fast PRNGs designed by George Marsaglia,


@@ -494,19 +516,7 @@ with a bit shifted version of it. This PRNG, which has a period of
 $2^{32}-1=4.29\times10^9$, is summed up in Algorithm~\ref{XORshift}. It is used
 in our PRNG to compute the strategy length and the strategy elements.
 
 $2^{32}-1=4.29\times10^9$, is summed up in Algorithm~\ref{XORshift}. It is used
 in our PRNG to compute the strategy length and the strategy elements.
 

-
-We have proven in \cite{bcgr11:ip} that,
-\begin{theorem}
-  Let $f: \mathds{B}^{n} \rightarrow \mathds{B}^{n}$, $\Gamma(f)$ its
-  iteration graph, $\check{M}$ its adjacency
-  matrix and $M$ a $n\times n$ matrix defined as in the previous lemma.
-  If $\Gamma(f)$ is strongly connected, then 
-  the output of the PRNG detailed in Algorithm~\ref{CI Algorithm} follows 
-  a law that tends to the uniform distribution 
-  if and only if $M$ is a double stochastic matrix.
-\end{theorem} 
-
-This former generator as successively passed various batteries of statistical tests, as the NIST~\cite{bcgr11:ip}, DieHARD~\cite{Marsaglia1996}, and TestU01~\cite{LEcuyerS07}.
+This former generator has successively passed various batteries of statistical tests, as the NIST~\cite{bcgr11:ip}, DieHARD~\cite{Marsaglia1996}, and TestU01~\cite{LEcuyerS07} ones.

 
 \subsection{Improving the Speed of the Former Generator}
 
 
 \subsection{Improving the Speed of the Former Generator}
 


@@ -526,7 +536,7 @@ x^0 \in \llbracket 0, 2^\mathsf{N}-1 \rrbracket, S \in \llbracket 0, 2^\mathsf{N
 \label{equation Oplus}
 \end{equation}
 where $\oplus$ is for the bitwise exclusive or between two integers. 
 \label{equation Oplus}
 \end{equation}
 where $\oplus$ is for the bitwise exclusive or between two integers. 

-This rewritten can be understood as follows. The $n-$th term $S^n$ of the
+This rewritting can be understood as follows. The $n-$th term $S^n$ of the

 sequence $S$, which is an integer of $\mathsf{N}$ binary digits, presents
 the list of cells to update in the state $x^n$ of the system (represented
 as an integer having $\mathsf{N}$ bits too). More precisely, the $k-$th 
 sequence $S$, which is an integer of $\mathsf{N}$ binary digits, presents
 the list of cells to update in the state $x^n$ of the system (represented
 as an integer having $\mathsf{N}$ bits too). More precisely, the $k-$th 


@@ -550,13 +560,12 @@ where $f$ is the vectorial negation and $\forall n \in \mathds{N}$,
 $\mathcal{S}^n \subset \llbracket 1, \mathsf{N} \rrbracket$ is such that
 $k \in \mathcal{S}^n$ if and only if the $k-$th digit in the binary
 decomposition of $S^n$ is 1. Such chaotic iterations are more general
 $\mathcal{S}^n \subset \llbracket 1, \mathsf{N} \rrbracket$ is such that
 $k \in \mathcal{S}^n$ if and only if the $k-$th digit in the binary
 decomposition of $S^n$ is 1. Such chaotic iterations are more general

-than the ones presented in Definition \ref{Def:chaotic iterations} for 
-the fact that, instead of updating only one term at each iteration,
+than the ones presented in Definition \ref{Def:chaotic iterations} because, instead of updating only one term at each iteration,

 we select a subset of components to change.
 
 
 Obviously, replacing Algorithm~\ref{CI Algorithm} by 
 we select a subset of components to change.
 
 
 Obviously, replacing Algorithm~\ref{CI Algorithm} by 

-Equation~\ref{equation Oplus}, possible when the iteration function is
+Equation~\ref{equation Oplus}, which is possible when the iteration function is

 the vectorial negation, leads to a speed improvement. However, proofs
 of chaos obtained in~\cite{bg10:ij} have been established
 only for chaotic iterations of the form presented in Definition 
 the vectorial negation, leads to a speed improvement. However, proofs
 of chaos obtained in~\cite{bg10:ij} have been established
 only for chaotic iterations of the form presented in Definition 


@@ -630,7 +639,7 @@ X^{k+1}=G_{f}(X^k).%
 \right.
 \end{equation}%
 
 \right.
 \end{equation}%
 

-Another time, a shift function appears as a component of these general chaotic 
+Once more, a shift function appears as a component of these general chaotic 

 iterations. 
 
 To study the Devaney's chaos property, a distance between two points 
 iterations. 
 
 To study the Devaney's chaos property, a distance between two points 


@@ -645,7 +654,7 @@ d(X,Y)=d_{e}(E,\check{E})+d_{s}(S,\check{S}),
 \left\{
 \begin{array}{lll}
 \displaystyle{d_{e}(E,\check{E})} & = & \displaystyle{\sum_{k=1}^{\mathsf{N}%
 \left\{
 \begin{array}{lll}
 \displaystyle{d_{e}(E,\check{E})} & = & \displaystyle{\sum_{k=1}^{\mathsf{N}%

-}\delta (E_{k},\check{E}_{k})}\textrm{ is another time the Hamming distance}, \\
+}\delta (E_{k},\check{E}_{k})}\textrm{ is once more the Hamming distance}, \\

 \displaystyle{d_{s}(S,\check{S})} & = & \displaystyle{\dfrac{9}{\mathsf{N}}%
 \sum_{k=1}^{\infty }\dfrac{|S^k\Delta {S}^k|}{10^{k}}}.%
 \end{array}%
 \displaystyle{d_{s}(S,\check{S})} & = & \displaystyle{\dfrac{9}{\mathsf{N}}%
 \sum_{k=1}^{\infty }\dfrac{|S^k\Delta {S}^k|}{10^{k}}}.%
 \end{array}%


@@ -661,7 +670,7 @@ The function $d$ defined in Eq.~\ref{nouveau d} is a metric on $\mathcal{X}$.
 
 \begin{proof}
  $d_e$ is the Hamming distance. We will prove that $d_s$ is a distance
 
 \begin{proof}
  $d_e$ is the Hamming distance. We will prove that $d_s$ is a distance

-too, thus $d$ will be a distance as sum of two distances.
+too, thus $d$, as being the sum of two distances, will also be a distance.

  \begin{itemize}
 \item Obviously, $d_s(S,\check{S})\geqslant 0$, and if $S=\check{S}$, then 
 $d_s(S,\check{S})=0$. Conversely, if $d_s(S,\check{S})=0$, then 
  \begin{itemize}
 \item Obviously, $d_s(S,\check{S})\geqslant 0$, and if $S=\check{S}$, then 
 $d_s(S,\check{S})=0$. Conversely, if $d_s(S,\check{S})=0$, then 


@@ -678,7 +687,7 @@ inequality is obtained.
 
 
 Before being able to study the topological behavior of the general 
 
 
 Before being able to study the topological behavior of the general 

-chaotic iterations, we must firstly establish that:
+chaotic iterations, we must first establish that:

 
 \begin{proposition}
  For all $f:\mathds{B}^\mathsf{N} \longrightarrow \mathds{B}^\mathsf{N} $, the function $G_f$ is continuous on 
 
 \begin{proposition}
  For all $f:\mathds{B}^\mathsf{N} \longrightarrow \mathds{B}^\mathsf{N} $, the function $G_f$ is continuous on 


@@ -714,7 +723,7 @@ so, after the $max(n_0, n_1)^{th}$ term, the distance $d$ between these two poin
 G_{f}(S^n,E^n)\right) $ and $\left( G_{f}(S,E)\right) $ is convergent to
 0. Let $\varepsilon >0$. \medskip
 \begin{itemize}
 G_{f}(S^n,E^n)\right) $ and $\left( G_{f}(S,E)\right) $ is convergent to
 0. Let $\varepsilon >0$. \medskip
 \begin{itemize}

-\item If $\varepsilon \geqslant 1$, we see that distance
+\item If $\varepsilon \geqslant 1$, we see that the distance

 between $\left( G_{f}(S^n,E^n)\right) $ and $\left( G_{f}(S,E)\right) $ is
 strictly less than 1 after the $max(n_{0},n_{1})^{th}$ term (same state).
 \medskip
 between $\left( G_{f}(S^n,E^n)\right) $ and $\left( G_{f}(S,E)\right) $ is
 strictly less than 1 after the $max(n_{0},n_{1})^{th}$ term (same state).
 \medskip


@@ -776,7 +785,7 @@ where $(s^0,s^1, \hdots)$ is the strategy of $Y$, satisfies the properties
 claimed in the lemma.
 \end{proof}
 
 claimed in the lemma.
 \end{proof}
 

-We can now prove the Theorem~\ref{t:chaos des general}...
+We can now prove Theorem~\ref{t:chaos des general}...

 
 \begin{proof}[Theorem~\ref{t:chaos des general}]
 Firstly, strong transitivity implies transitivity.
 
 \begin{proof}[Theorem~\ref{t:chaos des general}]
 Firstly, strong transitivity implies transitivity.


@@ -815,7 +824,7 @@ given PRNG.
 An iteration of the system is simply the bitwise exclusive or between
 the last computed state and the current strategy.
 Topological properties of disorder exhibited by chaotic 
 An iteration of the system is simply the bitwise exclusive or between
 the last computed state and the current strategy.
 Topological properties of disorder exhibited by chaotic 

-iterations can be inherited by the inputted generator, hoping by doing so to 
+iterations can be inherited by the inputted generator, we hope by doing so to 

 obtain some statistical improvements while preserving speed.
 
 
 obtain some statistical improvements while preserving speed.
 
 


@@ -846,7 +855,9 @@ $$
 
 
 
 
 
 

-\lstset{language=C,caption={C code of the sequential PRNG based on chaotic iterations},label=algo:seqCIPRNG}
+
+\lstset{language=C,caption={C code of the sequential PRNG based on chaotic iteration\
+s},label=algo:seqCIPRNG}

 \begin{lstlisting}
 unsigned int CIPRNG() {
   static unsigned int x = 123123123;
 \begin{lstlisting}
 unsigned int CIPRNG() {
   static unsigned int x = 123123123;


@@ -866,19 +877,18 @@ unsigned int CIPRNG() {
 
 
 
 
 
 

+In Listing~\ref{algo:seqCIPRNG} a sequential  version of the proposed PRNG based
+on  chaotic  iterations  is  presented.   The xor  operator  is  represented  by
+\textasciicircum.  This function uses  three classical 64-bits PRNGs, namely the
+\texttt{xorshift},         the          \texttt{xor128},         and         the
+\texttt{xorwow}~\cite{Marsaglia2003}.  In the following, we call them ``xor-like
+PRNGs''.   As each  xor-like PRNG  uses 64-bits  whereas our  proposed generator
+works with 32-bits, we use the command \texttt{(unsigned int)}, that selects the
+32 least  significant bits  of a given  integer, and the  code \texttt{(unsigned
+  int)(t$>>$32)} in order to obtain the 32 most significant bits of \texttt{t}.

 
 

-In Listing~\ref{algo:seqCIPRNG}  a sequential version of  the proposed PRNG based on chaotic iterations
- is  presented.  The xor operator is  represented by \textasciicircum.
-This  function uses  three classical  64-bits PRNGs, namely the  \texttt{xorshift}, the
-\texttt{xor128},  and  the  \texttt{xorwow}~\cite{Marsaglia2003}.   In  the following,  we  call  them
-``xor-like PRNGs''. 
-As
-each xor-like PRNG  uses 64-bits whereas our proposed generator works with 32-bits,
-we use the command \texttt{(unsigned int)}, that selects the 32 least significant bits of a given integer, and the code
-\texttt{(unsigned int)(t3$>>$32)}  in order to obtain the 32 most significant  bits of \texttt{t}.   
-
-So producing a  pseudorandom number needs  6 xor operations
-with 6 32-bits  numbers that are provided by 3 64-bits PRNGs.   This version successfully passes the
+Thus producing a pseudorandom number needs 6 xor operations with 6 32-bits numbers
+that  are provided by  3 64-bits  PRNGs.  This  version successfully  passes the

 stringent BigCrush battery of tests~\cite{LEcuyerS07}.
 
 \section{Efficient PRNGs based on Chaotic Iterations on GPU}
 stringent BigCrush battery of tests~\cite{LEcuyerS07}.
 
 \section{Efficient PRNGs based on Chaotic Iterations on GPU}


@@ -890,12 +900,12 @@ simultaneously. In general,  the larger the number of  threads is, the
 more local  memory is  used, and the  less branching  instructions are
 used  (if,  while,  ...),  the  better the  performances  on  GPU  is.
 Obviously, having these requirements in  mind, it is possible to build
 more local  memory is  used, and the  less branching  instructions are
 used  (if,  while,  ...),  the  better the  performances  on  GPU  is.
 Obviously, having these requirements in  mind, it is possible to build

-a   program    similar   to    the   one   presented    in   Algorithm
+a   program    similar   to    the   one   presented    in  Listing 

 \ref{algo:seqCIPRNG}, which computes  pseudorandom numbers on GPU.  To
 do  so,  we  must   firstly  recall  that  in  the  CUDA~\cite{Nvid10}
 environment,    threads    have     a    local    identifier    called
 \texttt{ThreadIdx},  which   is  relative  to   the  block  containing
 \ref{algo:seqCIPRNG}, which computes  pseudorandom numbers on GPU.  To
 do  so,  we  must   firstly  recall  that  in  the  CUDA~\cite{Nvid10}
 environment,    threads    have     a    local    identifier    called
 \texttt{ThreadIdx},  which   is  relative  to   the  block  containing

-them. With  CUDA parts of  the code which  are executed by the  GPU are
+them. Furthermore, in  CUDA, parts of  the code that are executed by the  GPU, are

 called {\it kernels}.
 
 
 called {\it kernels}.
 
 


@@ -903,10 +913,10 @@ called {\it kernels}.
 
  
 It is possible to deduce from the CPU version a quite similar version adapted to GPU.
 
  
 It is possible to deduce from the CPU version a quite similar version adapted to GPU.

-The simple principle consists to make each thread of the GPU computing the CPU version of our PRNG.  
+The simple principle consists in making each thread of the GPU computing the CPU version of our PRNG.  

 Of course,  the  three xor-like
 PRNGs  used in these computations must have different  parameters. 
 Of course,  the  three xor-like
 PRNGs  used in these computations must have different  parameters. 

-In a given thread, these lasts are
+In a given thread, these parameters are

 randomly picked from another PRNGs. 
 The  initialization stage is performed by  the CPU.
 To do it, the  ISAAC  PRNG~\cite{Jenkins96} is used to  set  all  the
 randomly picked from another PRNGs. 
 The  initialization stage is performed by  the CPU.
 To do it, the  ISAAC  PRNG~\cite{Jenkins96} is used to  set  all  the


@@ -951,14 +961,14 @@ and  the pseudorandom  numbers generated by  our  PRNG,  is  equal to  $100,000\
 
 This generator is able to pass the whole BigCrush battery of tests, for all
 the versions that have been tested depending on their number of threads 
 
 This generator is able to pass the whole BigCrush battery of tests, for all
 the versions that have been tested depending on their number of threads 

-(called \texttt{NumThreads} in our algorithm, tested until $10$ millions).
+(called \texttt{NumThreads} in our algorithm, tested up to $5$ million).

 
 \begin{remark}
 
 \begin{remark}

-The proposed algorithm has  the  advantage to  manipulate  independent
+The proposed algorithm has  the  advantage of  manipulating  independent

 PRNGs, so this version is easily adaptable on a cluster of computers too. The only thing
 to ensure is to use a single ISAAC PRNG. To achieve this requirement, a simple solution consists in
 using a master node for the initialization. This master node computes the initial parameters
 PRNGs, so this version is easily adaptable on a cluster of computers too. The only thing
 to ensure is to use a single ISAAC PRNG. To achieve this requirement, a simple solution consists in
 using a master node for the initialization. This master node computes the initial parameters

-for all the differents nodes involves in the computation.
+for all the different nodes involved in the computation.

 \end{remark}
 
 \subsection{Improved Version for GPU}
 \end{remark}
 
 \subsection{Improved Version for GPU}


@@ -972,42 +982,44 @@ thread uses the result of which other  one, we can use a combination array that
 contains  the indexes  of  all threads  and  for which  a combination has  been
 performed. 
 
 contains  the indexes  of  all threads  and  for which  a combination has  been
 performed. 
 

-In Algorithm~\ref{algo:gpu_kernel2}, two combination arrays are used.
-The    variable   \texttt{offset}    is    computed   using    the   value    of
+In  Algorithm~\ref{algo:gpu_kernel2},  two  combination  arrays are  used.   The
+variable     \texttt{offset}    is     computed    using     the     value    of

 \texttt{combination\_size}.   Then we  can compute  \texttt{o1}  and \texttt{o2}
 \texttt{combination\_size}.   Then we  can compute  \texttt{o1}  and \texttt{o2}

-representing the indexes of the  other threads whose results are used
-by the  current one. In  this algorithm, we  consider that a  64-bits xor-like
-PRNG has been chosen, and so its two 32-bits parts are used.
+representing the  indexes of  the other  threads whose results  are used  by the
+current one.   In this algorithm, we  consider that a 32-bits  xor-like PRNG has
+been chosen. In practice, we  use the xor128 proposed in~\cite{Marsaglia2003} in
+which  unsigned longs  (64 bits)  have been  replaced by  unsigned  integers (32
+bits).

 
 

-This version also can pass the whole {\it BigCrush} battery of tests.
+This version  can also pass the whole {\it BigCrush} battery of tests.

 
 \begin{algorithm}
 
 \KwIn{InternalVarXorLikeArray: array with internal variables of 1 xor-like PRNGs
 in global memory\;
 NumThreads: Number of threads\;
 
 \begin{algorithm}
 
 \KwIn{InternalVarXorLikeArray: array with internal variables of 1 xor-like PRNGs
 in global memory\;
 NumThreads: Number of threads\;

-tab1, tab2: Arrays containing combinations of size combination\_size\;}
+array\_comb1, array\_comb2: Arrays containing combinations of size combination\_size\;}

 
 \KwOut{NewNb: array containing random numbers in global memory}
 \If{threadId is concerned} {
   retrieve data from InternalVarXorLikeArray[threadId] in local variables including shared memory and x\;
   offset = threadIdx\%combination\_size\;
 
 \KwOut{NewNb: array containing random numbers in global memory}
 \If{threadId is concerned} {
   retrieve data from InternalVarXorLikeArray[threadId] in local variables including shared memory and x\;
   offset = threadIdx\%combination\_size\;

-  o1 = threadIdx-offset+tab1[offset]\;
-  o2 = threadIdx-offset+tab2[offset]\;
+  o1 = threadIdx-offset+array\_comb1[offset]\;
+  o2 = threadIdx-offset+array\_comb2[offset]\;

   \For{i=1 to n} {
     t=xor-like()\;
   \For{i=1 to n} {
     t=xor-like()\;

-    t=t $\hat{ }$ shmem[o1] $\hat{ }$ shmem[o2]\;
+    t=t\textasciicircum shmem[o1]\textasciicircum shmem[o2]\;

     shared\_mem[threadId]=t\;
     shared\_mem[threadId]=t\;

-    x = x $\hat{ }$ t\;
+    x = x\textasciicircum t\;

 
     store the new PRNG in NewNb[NumThreads*threadId+i]\;
   }
   store internal variables in InternalVarXorLikeArray[threadId]\;
 }
 
 
     store the new PRNG in NewNb[NumThreads*threadId+i]\;
   }
   store internal variables in InternalVarXorLikeArray[threadId]\;
 }
 

-\caption{main kernel for the chaotic iterations based PRNG GPU efficient
-version}
-\label{algo:gpu_kernel2}
+\caption{Main kernel for the chaotic iterations based PRNG GPU efficient
+version\label{IR}}
+\label{algo:gpu_kernel2} 

 \end{algorithm}
 
 \subsection{Theoretical Evaluation of the Improved Version}
 \end{algorithm}
 
 \subsection{Theoretical Evaluation of the Improved Version}


@@ -1021,7 +1033,7 @@ and two values previously obtained by two other threads).
 To be certain that we are in the framework of Theorem~\ref{t:chaos des general},
 we must guarantee that this dynamical system iterates on the space 
 $\mathcal{X} = \mathcal{P}\left(\llbracket 1, \mathsf{N} \rrbracket\right)^\mathds{N}\times\mathds{B}^\mathsf{N}$.
 To be certain that we are in the framework of Theorem~\ref{t:chaos des general},
 we must guarantee that this dynamical system iterates on the space 
 $\mathcal{X} = \mathcal{P}\left(\llbracket 1, \mathsf{N} \rrbracket\right)^\mathds{N}\times\mathds{B}^\mathsf{N}$.

-The left term $x$ obviously belongs into $\mathds{B}^ \mathsf{N}$.
+The left term $x$ obviously belongs to $\mathds{B}^ \mathsf{N}$.

 To prevent from any flaws of chaotic properties, we must check that the right 
 term (the last $t$), corresponding to the strategies,  can possibly be equal to any
 integer of $\llbracket 1, \mathsf{N} \rrbracket$. 
 To prevent from any flaws of chaotic properties, we must check that the right 
 term (the last $t$), corresponding to the strategies,  can possibly be equal to any
 integer of $\llbracket 1, \mathsf{N} \rrbracket$. 


@@ -1032,8 +1044,7 @@ last $t$ respects the requirement. Furthermore, it is possible to
 prove by an immediate mathematical induction that, as the initial $x$
 is uniformly distributed (it is provided by a cryptographically secure PRNG),
 the two other stored values shmem[o1] and shmem[o2] are uniformly distributed too,
 prove by an immediate mathematical induction that, as the initial $x$
 is uniformly distributed (it is provided by a cryptographically secure PRNG),
 the two other stored values shmem[o1] and shmem[o2] are uniformly distributed too,

-(this can be stated by an immediate mathematical
-induction), and thus the next $x$ is finally uniformly distributed.
+(this is the induction hypothesis), and thus the next $x$ is finally uniformly distributed.

 
 Thus Algorithm~\ref{algo:gpu_kernel2} is a concrete realization of the general
 chaotic iterations presented previously, and for this reason, it satisfies the 
 
 Thus Algorithm~\ref{algo:gpu_kernel2} is a concrete realization of the general
 chaotic iterations presented previously, and for this reason, it satisfies the 


@@ -1051,7 +1062,7 @@ All the
 cards have 240 cores.
 
 In  Figure~\ref{fig:time_xorlike_gpu} we  compare the  quantity of  pseudorandom numbers
 cards have 240 cores.
 
 In  Figure~\ref{fig:time_xorlike_gpu} we  compare the  quantity of  pseudorandom numbers

-generated per second with various xor-like based PRNG. In this figure, the optimized
+generated per second with various xor-like based PRNGs. In this figure, the optimized

 versions use the {\it xor64} described in~\cite{Marsaglia2003}, whereas the naive versions
 embed  the three  xor-like  PRNGs described  in Listing~\ref{algo:seqCIPRNG}.   In
 order to obtain the optimal performances, the storage of pseudorandom numbers
 versions use the {\it xor64} described in~\cite{Marsaglia2003}, whereas the naive versions
 embed  the three  xor-like  PRNGs described  in Listing~\ref{algo:seqCIPRNG}.   In
 order to obtain the optimal performances, the storage of pseudorandom numbers


@@ -1059,7 +1070,7 @@ into the GPU memory has been removed. This step is time consuming and slows down
 generation.  Moreover this   storage  is  completely
 useless, in case of applications that consume the pseudorandom
 numbers  directly   after generation. We can see  that when the number of  threads is greater
 generation.  Moreover this   storage  is  completely
 useless, in case of applications that consume the pseudorandom
 numbers  directly   after generation. We can see  that when the number of  threads is greater

-than approximately 30,000 and lower than 5 millions, the number of pseudorandom numbers generated
+than approximately 30,000 and lower than 5 million, the number of pseudorandom numbers generated

 per second  is almost constant.  With the  naive version, this value ranges from 2.5 to
 3GSamples/s.   With  the  optimized   version,  it  is  approximately  equal to
 20GSamples/s. Finally  we can remark  that both GPU  cards are quite  similar, but in
 per second  is almost constant.  With the  naive version, this value ranges from 2.5 to
 3GSamples/s.   With  the  optimized   version,  it  is  approximately  equal to
 20GSamples/s. Finally  we can remark  that both GPU  cards are quite  similar, but in


@@ -1080,13 +1091,12 @@ As a  comparison,   Listing~\ref{algo:seqCIPRNG}  leads   to the  generation of
 
 
 
 
 
 

-In Figure~\ref{fig:time_bbs_gpu}  we highlight the performances  of the optimized
-BBS-based  PRNG on GPU. On the  Tesla C1060 we
-obtain approximately 700MSample/s and on the GTX 280 about 670MSample/s, which is
-obviously slower than the xorlike-based PRNG on GPU. However, we will show in the 
-next sections that 
-this new PRNG has a strong level of security, which is necessary paid by a speed
-reduction. 
+In Figure~\ref{fig:time_bbs_gpu} we highlight  the performances of the optimized
+BBS-based PRNG on GPU.  On  the Tesla C1060 we obtain approximately 700MSample/s
+and  on the  GTX 280  about  670MSample/s, which  is obviously  slower than  the
+xorlike-based PRNG on GPU. However, we  will show in the next sections that this
+new PRNG  has a strong  level of  security, which is  necessarily paid by  a speed
+reduction.

 
 \begin{figure}[htbp]
 \begin{center}
 
 \begin{figure}[htbp]
 \begin{center}


@@ -1098,7 +1108,7 @@ reduction.
 
 All  these  experiments allow  us  to conclude  that  it  is possible  to
 generate a very large quantity of pseudorandom  numbers statistically perfect with the  xor-like version.
 
 All  these  experiments allow  us  to conclude  that  it  is possible  to
 generate a very large quantity of pseudorandom  numbers statistically perfect with the  xor-like version.

-In a certain extend, it is the case too with the secure BBS-based version, the speed deflation being
+To a certain extend, it is also the case with the secure BBS-based version, the speed deflation being

 explained by the fact that the former  version has ``only''
 chaotic properties and statistical perfection, whereas the latter is also cryptographically secure,
 as it is shown in the next sections.
 explained by the fact that the former  version has ``only''
 chaotic properties and statistical perfection, whereas the latter is also cryptographically secure,
 as it is shown in the next sections.


@@ -1148,7 +1158,7 @@ strings of length $N$ such that $H(S_0)=S_1 \ldots S_k$ ($H(S_0)$ is the concate
 the $S_i$'s). The cryptographic PRNG $X$ defined in (\ref{equation Oplus})
 is the algorithm mapping any string of length $2N$ $x_0S_0$ into the string
 $(x_0\oplus S_0 \oplus S_1)(x_0\oplus S_0 \oplus S_1\oplus S_2)\ldots
 the $S_i$'s). The cryptographic PRNG $X$ defined in (\ref{equation Oplus})
 is the algorithm mapping any string of length $2N$ $x_0S_0$ into the string
 $(x_0\oplus S_0 \oplus S_1)(x_0\oplus S_0 \oplus S_1\oplus S_2)\ldots

-(x_o\bigoplus_{i=0}^{i=k}S_i)$. Particularly one has $\ell_{X}(2N)=kN=\ell_H(N)$. 
+(x_o\bigoplus_{i=0}^{i=k}S_i)$. One in particular has $\ell_{X}(2N)=kN=\ell_H(N)$. 

 We claim now that if this PRNG is secure,
 then the new one is secure too.
 
 We claim now that if this PRNG is secure,
 then the new one is secure too.
 


@@ -1212,11 +1222,11 @@ It follows that
 \mathrm{Pr}[D^\prime(H(U_{N}))=1]=\mathrm{Pr}[D(U_{2N})=1].
 \end{equation}
  From (\ref{PCH-2}) and (\ref{PCH-4}), one can deduce that
 \mathrm{Pr}[D^\prime(H(U_{N}))=1]=\mathrm{Pr}[D(U_{2N})=1].
 \end{equation}
  From (\ref{PCH-2}) and (\ref{PCH-4}), one can deduce that

-there exist a polynomial time probabilistic
+there exists a polynomial time probabilistic

 algorithm $D^\prime$, a positive polynomial $p$, such that for all $k_0$ there exists
 $N\geq \frac{k_0}{2}$ satisfying 
 $$| \mathrm{Pr}[D(H(U_{N}))=1]-\mathrm{Pr}[D(U_{kN}=1]|\geq \frac{1}{p(2N)},$$
 algorithm $D^\prime$, a positive polynomial $p$, such that for all $k_0$ there exists
 $N\geq \frac{k_0}{2}$ satisfying 
 $$| \mathrm{Pr}[D(H(U_{N}))=1]-\mathrm{Pr}[D(U_{kN}=1]|\geq \frac{1}{p(2N)},$$

-proving that $H$ is not secure, a contradiction. 
+proving that $H$ is not secure, which is a contradiction. 

 \end{proof}
 
 
 \end{proof}
 
 


@@ -1230,84 +1240,87 @@ algorithm (Algorithm~\ref{algo:gpu_kernel2}).   Due to Proposition~\ref{cryptopr
 it simply consists  in replacing
 the  {\it  xor-like} PRNG  by  a  cryptographically  secure one.  
 We have chosen the Blum Blum Shum generator~\cite{BBS} (usually denoted by BBS) having the form:
 it simply consists  in replacing
 the  {\it  xor-like} PRNG  by  a  cryptographically  secure one.  
 We have chosen the Blum Blum Shum generator~\cite{BBS} (usually denoted by BBS) having the form:

-$$x_{n+1}=x_n^2~ mod~ M$$  where $M$ is the product of  two prime numbers. These
-prime numbers  need to be congruent  to 3 modulus  4. BBS is
+$$x_{n+1}=x_n^2~ mod~ M$$  where $M$ is the product of  two prime numbers (these
+prime numbers  need to be congruent  to 3 modulus  4). BBS is known to be

 very slow and only usable for cryptographic applications. 
 
   
 The modulus operation is the most time consuming operation for current
 GPU cards.  So in order to obtain quite reasonable performances, it is
 very slow and only usable for cryptographic applications. 
 
   
 The modulus operation is the most time consuming operation for current
 GPU cards.  So in order to obtain quite reasonable performances, it is

-required to use only modulus  on 32 bits integer numbers. Consequently
-$x_n^2$ need  to be less than $2^{32}$  and the number $M$  need to be
-less than $2^{16}$.  So in practice we can choose prime numbers around
-256 that are congruent to 3 modulus 4.  With 32 bits numbers, only the
+required to use only modulus  on 32-bits integer numbers. Consequently
+$x_n^2$ need  to be lesser than $2^{32}$,  and thus the number $M$ must be
+lesser than $2^{16}$.  So in practice we can choose prime numbers around
+256 that are congruent to 3 modulus 4.  With 32-bits numbers, only the

 4 least significant bits of $x_n$ can be chosen (the maximum number of
 indistinguishable    bits    is    lesser    than   or    equals    to
 4 least significant bits of $x_n$ can be chosen (the maximum number of
 indistinguishable    bits    is    lesser    than   or    equals    to

-$log_2(log_2(x_n))$). So to generate a  32 bits number, we need to use
-8 times  the BBS  algorithm with different  combinations of  $M$. This
-approach is  not sufficient to pass  all the tests  of TestU01 because
-the fact  of having chosen  small values of  $M$ for the BBS  leads to
-have a  small period. So, in  order to add randomness  we proceed with
+$log_2(log_2(M))$). In other words, to generate a  32-bits number, we need to use
+8 times  the BBS  algorithm with possibly different  combinations of  $M$. This
+approach is  not sufficient to be able to pass  all the TestU01,
+as small values of  $M$ for the BBS  lead to
+  small periods. So, in  order to add randomness  we have proceeded with

 the followings  modifications. 
 \begin{itemize}
 \item
 the followings  modifications. 
 \begin{itemize}
 \item

-First we  define 16 arrangement arrays  instead of 2  (as described in
-algorithm \ref{algo:gpu_kernel2}) but only 2  are used at each call of
-the  PRNG kernels. In  practice, the  selection of  which combinations
-arrays will be used is different for all the threads and is determined
+Firstly, we  define 16 arrangement arrays  instead of 2  (as described in
+Algorithm \ref{algo:gpu_kernel2}), but only 2 of them are used at each call of
+the  PRNG kernels. In  practice, the  selection of   combination
+arrays to be used is different for all the threads. It is determined

 by using  the three last bits  of two internal variables  used by BBS.
 by using  the three last bits  of two internal variables  used by BBS.

-This approach  adds more randomness.   In algorithm~\ref{algo:bbs_gpu},
-character  \& performs the  AND bitwise.  So using  \&7 with  a number
-gives the last 3 bits, so it provides a number between 0 and 7.
+%This approach  adds more randomness.   
+In Algorithm~\ref{algo:bbs_gpu},
+character  \& is for the  bitwise AND. Thus using  \&7 with  a number
+gives the last 3 bits, thus providing a number between 0 and 7.

 \item
 \item

-Second, after the  generation of the 8 BBS numbers  for each thread we
-have a 32 bits number for which the period is possibly quite small. So
-to add randomness,  we generate 4 more BBS numbers  which allows us to
-shift  the 32 bits  numbers and  add upto  6 new  bits.  This  part is
-described  in algorithm~\ref{algo:bbs_gpu}.  In  practice, if  we call
-{\it strategy}, the number representing  the strategy, the last 2 bits
-of the first new BBS number are  used to make a left shift of at least
-3 bits. The  last 3 bits of the  second new BBS number are  add to the
+Secondly, after the  generation of the 8 BBS numbers  for each thread, we
+have a 32-bits number whose period is possibly quite small. So
+to add randomness,  we generate 4 more BBS numbers   to
+shift  the 32-bits  numbers, and  add up to  6 new  bits.  This  improvement is
+described  in Algorithm~\ref{algo:bbs_gpu}.  In  practice, the last 2 bits
+of the first new BBS number are  used to make a left shift of at most
+3 bits. The  last 3 bits of the  second new BBS number are  added to the

 strategy whatever the value of the first left shift. The third and the
 fourth new BBS  numbers are used similarly to apply  a new left shift
 and add 3 new bits.
 \item
 strategy whatever the value of the first left shift. The third and the
 fourth new BBS  numbers are used similarly to apply  a new left shift
 and add 3 new bits.
 \item

-Finally, as  we use 8 BBS numbers  for each thread, the  store of these
+Finally, as  we use 8 BBS numbers  for each thread, the  storage of these

 numbers at the end of the  kernel is performed using a rotation. So,
 internal  variable for  BBS number  1 is  stored in  place  2, internal
 numbers at the end of the  kernel is performed using a rotation. So,
 internal  variable for  BBS number  1 is  stored in  place  2, internal

-variable  for BBS  number 2  is  store ind  place 3,  ... and  internal
+variable  for BBS  number 2  is  stored in  place 3,  ..., and finally, internal

 variable for BBS number 8 is stored in place 1.
 \end{itemize}
 
 variable for BBS number 8 is stored in place 1.
 \end{itemize}
 

-

 \begin{algorithm}
 
 \KwIn{InternalVarBBSArray: array with internal variables of the 8 BBS
 in global memory\;
 NumThreads: Number of threads\;
 \begin{algorithm}
 
 \KwIn{InternalVarBBSArray: array with internal variables of the 8 BBS
 in global memory\;
 NumThreads: Number of threads\;

-tab: 2D Arrays containing 16 combinations (in first dimension)  of size combination\_size (in second dimension)\;}
+array\_comb: 2D Arrays containing 16 combinations (in first dimension)  of size combination\_size (in second dimension)\;
+array\_shift[4]=\{0,1,3,7\}\;
+}

 
 \KwOut{NewNb: array containing random numbers in global memory}
 \If{threadId is concerned} {
   retrieve data from InternalVarBBSArray[threadId] in local variables including shared memory and x\;
   we consider that bbs1 ... bbs8 represent the internal states of the 8 BBS numbers\;
   offset = threadIdx\%combination\_size\;
 
 \KwOut{NewNb: array containing random numbers in global memory}
 \If{threadId is concerned} {
   retrieve data from InternalVarBBSArray[threadId] in local variables including shared memory and x\;
   we consider that bbs1 ... bbs8 represent the internal states of the 8 BBS numbers\;
   offset = threadIdx\%combination\_size\;

-  o1 = threadIdx-offset+tab[bbs1\&7][offset]\;
-  o2 = threadIdx-offset+tab[8+bbs2\&7][offset]\;
+  o1 = threadIdx-offset+array\_comb[bbs1\&7][offset]\;
+  o2 = threadIdx-offset+array\_comb[8+bbs2\&7][offset]\;

   \For{i=1 to n} {
   \For{i=1 to n} {

-    t<<=4\;
+    t$<<$=4\;

     t|=BBS1(bbs1)\&15\;
     ...\;
     t|=BBS1(bbs1)\&15\;
     ...\;

-    t<<=4\;
+    t$<<$=4\;

     t|=BBS8(bbs8)\&15\;
     t|=BBS8(bbs8)\&15\;

-    //two new shifts\;
-    t<<=BBS3(bbs3)\&3\;
-    t|=BBS1(bbs1)\&7\;
-     t<<=BBS7(bbs7)\&3\;
-    t|=BBS2(bbs2)\&7\;
-    t=t $\hat{ }$ shmem[o1] $\hat{ }$ shmem[o2]\;
+    \tcp{two new shifts}
+    shift=BBS3(bbs3)\&3\;
+    t$<<$=shift\;
+    t|=BBS1(bbs1)\&array\_shift[shift]\;
+    shift=BBS7(bbs7)\&3\;
+    t$<<$=shift\;
+    t|=BBS2(bbs2)\&array\_shift[shift]\;
+    t=t\textasciicircum  shmem[o1]\textasciicircum     shmem[o2]\;

     shared\_mem[threadId]=t\;
     shared\_mem[threadId]=t\;

-    x = x $\hat{ }$ t\;
+    x = x\textasciicircum   t\;

 
     store the new PRNG in NewNb[NumThreads*threadId+i]\;
   }
 
     store the new PRNG in NewNb[NumThreads*threadId+i]\;
   }


@@ -1318,16 +1331,35 @@ tab: 2D Arrays containing 16 combinations (in first dimension)  of size combinat
 \label{algo:bbs_gpu}
 \end{algorithm}
 
 \label{algo:bbs_gpu}
 \end{algorithm}
 

-In algorithm~\ref{algo:bbs_gpu}, t<<=4 performs a left shift of 4 bits
-on the variable  t and stores the result  in t. BBS1(bbs1)\&15 selects
-the last  four bits of the result  of BBS1. It should  be noticed that
-for the two new shifts, we use arbitrarily 4 BBSs that have previously
-been used.
+In Algorithm~\ref{algo:bbs_gpu}, $n$ is for  the quantity of random numbers that
+a thread has to  generate.  The operation t<<=4 performs a left  shift of 4 bits
+on the variable  $t$ and stores the result in  $t$, and $BBS1(bbs1)\&15$ selects
+the last  four bits  of the  result of $BBS1$.   Thus an  operation of  the form
+$t<<=4; t|=BBS1(bbs1)\&15\;$  realizes in $t$ a  left shift of 4  bits, and then
+puts the 4 last bits of $BBS1(bbs1)$  in the four last positions of $t$.  Let us
+remark that the initialization $t$ is not a  necessity as we fill it 4 bits by 4
+bits, until  having obtained 32-bits.  The  two last new shifts  are realized in
+order to enlarge the small periods of  the BBS used here, to introduce a kind of
+variability.  In these operations, we make twice a left shift of $t$ of \emph{at
+  most}  3 bits,  represented by  \texttt{shift} in  the algorithm,  and  we put
+\emph{exactly} the \texttt{shift}  last bits from a BBS  into the \texttt{shift}
+last bits of $t$. For this, an array named \texttt{array\_shift}, containing the
+correspondance between the  shift and the number obtained  with \texttt{shift} 1
+to make the \texttt{and} operation is used. For example, with a left shift of 0,
+we  make an  and operation  with 0,  with  a left  shift of  3, we  make an  and
+operation with 7 (represented by 111 in binary mode).
+
+It should  be noticed that this generator has once more the form $x^{n+1} = x^n \oplus S^n$,
+where $S^n$ is referred in this algorithm as $t$: each iteration of this
+PRNG ends with $x = x \wedge t$. This $S^n$ is only constituted
+by secure bits produced by the BBS generator, and thus, due to
+Proposition~\ref{cryptopreuve}, the resulted PRNG is cryptographically
+secure.

 
 
 
 \subsection{Toward a Cryptographically Secure and Chaotic Asymmetric Cryptosystem}
 
 
 
 \subsection{Toward a Cryptographically Secure and Chaotic Asymmetric Cryptosystem}

-
+\label{Blum-Goldwasser}

 We finish this research work by giving some thoughts about the use of
 the proposed PRNG in an asymmetric cryptosystem.
 This first approach will be further investigated in a future work.
 We finish this research work by giving some thoughts about the use of
 the proposed PRNG in an asymmetric cryptosystem.
 This first approach will be further investigated in a future work.


@@ -1355,7 +1387,7 @@ Suppose Bob wishes to send a string $m=(m_0, \dots, m_{L-1})$ of $L$ bits to Ali
 \item $i=0$.
 \item While $i \leqslant L-1$:
 \begin{itemize}
 \item $i=0$.
 \item While $i \leqslant L-1$:
 \begin{itemize}

-\item Set $b_i$ equal to the least-significant\footnote{BBS can securely output up to $\mathsf{N} = \lfloor log(log(N)) \rfloor$ of the least-significant bits of $x_i$ during each round.} bit of $x_i$,
+\item Set $b_i$ equal to the least-significant\footnote{As signaled previously, BBS can securely output up to $\mathsf{N} = \lfloor log(log(N)) \rfloor$ of the least-significant bits of $x_i$ during each round.} bit of $x_i$,

 \item $i=i+1$,
 \item $x_i = (x_{i-1})^2~mod~N.$
 \end{itemize}
 \item $i=i+1$,
 \item $x_i = (x_{i-1})^2~mod~N.$
 \end{itemize}


@@ -1369,7 +1401,7 @@ When Alice receives $\left[(c_0, \dots, c_{L-1}), y\right]$, she can recover $m$
 \item Using the secret key $(p,q)$, she computes $r_p = y^{((p+1)/4)^{L}}~mod~p$ and $r_q = y^{((q+1)/4)^{L}}~mod~q$.
 \item The initial seed can be obtained using the following procedure: $x_0=q(q^{-1}~{mod}~p)r_p + p(p^{-1}~{mod}~q)r_q~{mod}~N$.
 \item She recomputes the bit-vector $b$ by using BBS and $x_0$.
 \item Using the secret key $(p,q)$, she computes $r_p = y^{((p+1)/4)^{L}}~mod~p$ and $r_q = y^{((q+1)/4)^{L}}~mod~q$.
 \item The initial seed can be obtained using the following procedure: $x_0=q(q^{-1}~{mod}~p)r_p + p(p^{-1}~{mod}~q)r_q~{mod}~N$.
 \item She recomputes the bit-vector $b$ by using BBS and $x_0$.

-\item Alice computes finally the plaintext by XORing the keystream with the ciphertext: $ m = c \oplus  b$.
+\item Alice finally computes the plaintext by XORing the keystream with the ciphertext: $ m = c \oplus  b$.

 \end{enumerate}
 
 
 \end{enumerate}
 
 


@@ -1389,23 +1421,32 @@ instead of $\left(m_0 \oplus b_0, m_1 \oplus b_1, \hdots, m_{L-1} \oplus b_{L-1}
 
 The same decryption stage as in Blum-Goldwasser leads to the sequence 
 $\left(m_0 \oplus S^0, m_1 \oplus S^0, \hdots, m_{L-1} \oplus S^0 \right)$.
 
 The same decryption stage as in Blum-Goldwasser leads to the sequence 
 $\left(m_0 \oplus S^0, m_1 \oplus S^0, \hdots, m_{L-1} \oplus S^0 \right)$.

-Thus, with a simple use of $S^0$, Alice can obtained the plaintext.
+Thus, with a simple use of $S^0$, Alice can obtain the plaintext.

 By doing so, the proposed generator is used in place of BBS, leading to
 the inheritance of all the properties presented in this paper.
 
 \section{Conclusion}
 
 
 By doing so, the proposed generator is used in place of BBS, leading to
 the inheritance of all the properties presented in this paper.
 
 \section{Conclusion}
 
 

-In  this  paper  we have  presented  a  new  class  of  PRNGs based  on  chaotic
-iterations. We have proven that these PRNGs are chaotic in the sense of Devaney.
-We also propose a PRNG cryptographically secure and its implementation on GPU.
-
-An  efficient implementation  on  GPU based  on  a xor-like  PRNG  allows us  to
-generate   a  huge   number   of  pseudorandom   numbers   per  second   (about
-20Gsamples/s). This PRNG succeeds to pass the hardest batteries of TestU01.
-
-In future  work we plan to  extend this work  for parallel PRNG for  clusters or
-grid computing.
+In  this  paper, a formerly proposed PRNG based on chaotic iterations
+has been generalized to improve its speed. It has been proven to be
+chaotic according to Devaney.
+Efficient implementations on  GPU using xor-like  PRNGs as input generators
+have shown that a very large quantity of pseudorandom numbers can be generated per second (about
+20Gsamples/s), and that these proposed PRNGs succeed to pass the hardest battery in TestU01,
+namely the BigCrush.
+Furthermore, we have shown that when the inputted generator is cryptographically
+secure, then it is the case too for the PRNG we propose, thus leading to
+the possibility to develop fast and secure PRNGs using the GPU architecture.
+Thoughts about an improvement of the Blum-Goldwasser cryptosystem, using the 
+proposed method, has been finally proposed.
+
+In future  work we plan to extend these researches, building a parallel PRNG for  clusters or
+grid computing. Topological properties of the various proposed generators will be investigated,
+and the use of other categories of PRNGs as input will be studied too. The improvement
+of Blum-Goldwasser will be deepened. Finally, we
+will try to enlarge the quantity of pseudorandom numbers generated per second either
+in a simulation context or in a cryptographic one.