By looking at this formula, we can see that $\fc{Gf}x$ is exactly the expectation value of $\fc f{x+Y}$, where $Y$ is a random vector distributed according to the multivariate normal distribution with mean $0$ and covariance matrix $A$. Let’s say, however, that instead of a multivariate normal distribution, we have a discrete distribution on a finite set of points $\B{a_i}$, each with probability $w_i$, satisfying $$\sum_i w_i=1,\quad\sum_i w_ia_i=0.$$ Then, for $Y$ distributed according to this discrete distribution, the expectation value of $\fc f{x+Y}$ is $$\bopc E{\fc f{x+Y}}=\sum_i w_i\fc f{x+a_i}.$$ This distribution has the covariance matrix $A_{jk}=\sum_i w_ia_{ij}a_{ik}$, but this expectation value is not the same as the result $\fc{Gf}x$ of the Gaussian blur filter. In order to approach the Gaussian distribution, we need to sum $N$ independent samples $\B{Y_\alpha}$, each distributed according the same discrete distribution with covariance matrix $A/N$. Without changing the relation between $A$ and $\B{a_i}$, we can achieve this by taking the distribution to be among the points $\B{a_i/\sqrt N}$, with the same probabilities $w_i$. Then, according to the central limit theorem, we have $$\fc{Gf}x=\lim_{N\to\infty}\bopc E{\fc f{x+\sum_\alpha Y_\alpha}} =\lim_{N\to\infty}\sum_{\B{i_\alpha}}\p{\prod_\alpha w_{i_\alpha}}\fc f{x+\fr{1}{\sqrt N}\sum_\alpha a_{i_\alpha}}.$$ By staring at this formula, one may notice that it is actually the result of the same linear transformation $P_N$ applied $N$ times to the function $f$, where $$\fc{P_Nf}x\ceq\sum_iw_i\fc f{x+\fr{a_i}{\sqrt N}}.$$ Thus, we can write $$G=\lim_{N\to\infty}P_N^N.$$

We can now see why we can implement a Gaussian blur filter as a multi-pass filter: each pass of the filter is equivalent to applying the linear transformation $P_N$ once, and the Gaussian blur filter is the limit of applying this transformation infinitely many times. After choosing the points $\B{a_i}$ and the weights $w_i$, we can easily implement the filter in a fragment shader. After implementing $P_N$, one can implement the multi-pass filter by flip-flopping between two textures $N$ times. Here is an example implementation of $P_N$ for a 2D ($d=2$) texture, with $$a_0=\begin{pmatrix}\sgm\\0\end{pmatrix},\quad a_1=\begin{pmatrix}-\sgm\\0\end{pmatrix},\quad w_0=w_1=\fr12,$$ where $\sgm$ would be the standard deviation of the resulting Gaussian blur filter:

          
            varying vec2 vTextureCoord;

            

            uniform sampler2D uTexture;

            uniform float uStrength; // sigma / sqrt(N)

            

            void main() {

            	gl_FragColor  = texture2D(uTexture, vTextureCoord + vec2( uStrength, 0.0)) * 0.5;

            	gl_FragColor += texture2D(uTexture, vTextureCoord + vec2(-uStrength, 0.0)) * 0.5;

            }

          
        

When using the shader, the texture is input as the uniform uTexture, and $\sgm/\sqrt N$ is input as the uniform uStrength. This example is then called the 2-tap horizontal Gaussian blur filter (because to find $\fc fx$ for some $x$ one needs to evaluate $f$ twice).

To get a good Gaussian blur effect, $N$ should be large enough, which can quickly become computationally expensive. We can reduce the number of passes by rewriting $P_N^N=\p{P_N^n}^{N/n}$ so that the number of passes is now reduced from $N$ to $N/n$ without changing the result, but the cost is to implement $P_N^n$ instead of $P_N$ in the shader. With the $P_N$ example above, the $P_N^n$ filter is then a $\p{n+1}$-tap horizontal Gaussian blur filter. The total number of times to fetch the texture is $\p{n+1}N/n$ to render the whole blurred texture, which decreases as $n$ increases.

By utilizing the linear sampling feature of the GPU, this number can be further reduced (by half) if $\sgm/\sqrt N=1$. One can read further about this in this article.

Let us now move on to an interesting relation to the heat equation. The heat equation is a partial differential equation that reads $$\partial_t\fc{f_t}x=\sum_j\partial_j\partial_j\fc{f_t}x.$$ The physical meaning of $\fc{f_t}x$ is the temperature at position $x$ at time $t$, and the solution to this equation gives the time evolution of the temperature distribution in a medium with unit thermal diffusivity. More generally, we can have some other thermal diffusivities, which may even be anisotropic, in which case the equation reads $$\partial_t\fc{f_t}x=\fr12\sum_{jk}A_{jk}\partial_j\partial_k\fc{f_t}x,$$ where $A$ is a symmetric positive definite matrix. Such an equation can always be reduced to the form with unit thermal diffusivity by a linear transformation of the coordinates $x\mapsto Lx$, where $L$ satisfies $A/2=L^\mrm TL$ (the Cholesky decomposition of $A/2$). By using operator exponentiation, we can write the solution to the heat equation as $\fc{f_t}x=G^t\fc{f_0}x$, where $$G^t\ceq\fc\exp{\fr t2\sum_{jk}A_{jk}\partial_j\partial_k}$$ is called the time evolution operator (which is not generally defined for $t<0$, which means that $\B{G^t}$ cannot form a group but only a monoid).

The reason that I denote it as $G^t$ is that $G^1$ gives exactly the Gaussian blur filter $G$ (when acting on real analytic functions). This is not immediately obvious, and I will justify its correctness by starting from the multi-pass expression of the Gaussian blur filter. For analytic functions, we can get the translation operator by exponentiating the derivative operator, so $$\fc f{x+\fr{a_i}{\sqrt N}}=\fc\exp{\sum_j\fr{a_{ij}}{\sqrt N}\partial_j}\fc fx.$$ Therefore, we can write $$\begin{align*} P_N&=\sum_iw_i\fc\exp{\sum_j\fr{a_{ij}}{\sqrt N}\partial_j}\\ &=\underbrace{\sum_iw_i}_1 +\fr1{\sqrt N}\sum_j\underbrace{\sum_iw_ia_{ij}}_0\partial_j +\fr1{2N}\sum_{jk}\underbrace{\sum_iw_ia_{ij}a_{ik}}_{A_{jk}}\partial_j\partial_k +\order{N^{-3/2}}. \end{align*}$$ Now, in the limit of infinite $N$, we have $$G=\lim_{N\to\infty}P_N^N =\lim_{N\to\infty}\p{1+\fr1{2N}\sum_{jk}A_{jk}\partial_j\partial_k}^N =\fc\exp{\fr12\sum_{jk}A_{jk}\partial_j\partial_k}=G^1.$$ This means that applying the Gaussian blur filter is equivalent to evolving one unit of time according to the heat equation. Therefore, the equation in the beginning of this article, the definition of the Gaussian blur filter, can then be used to express the unit time evolution under the heat equation in the form of a integral transformation. To get the general $G^t$, we can just replace $A$ with $tA$.

As a byproduct, we can then show that the heat kernel is a Gaussian kernel. The heat kernel $\fc{K_t}{x,x'}$ is defined as the solution to the heat equation with initial condition $\fc{K_0}{x,x'}=\fc\dlt{x-x'}$. Directly applying $G^t$ to $\fc\dlt{x-x'}$ gives $$\begin{align*} \fc{K_t}{x,x'}&=G^t\fc\dlt{x-x'}\\ &=\int\fr{\d^dy}{\sqrt{\p{2\pi t}^d\det A}}\fc\exp{-\fr1{2t}\p{A^{-1}}_{jk}y_jy_k}\fc\dlt{x+y-x'}\\ &=\fr{1}{\sqrt{\p{2\pi t}^d\det A}}\fc\exp{-\fr1{2t}\p{A^{-1}}_{jk}\p{x_j-x'_j}\p{x_k-x'_k}}, \end{align*}$$ which is the form that you would find in textbooks.

The reason that I decided to study the Gaussian blur filter is that I spotted a flaw in the implementation of the blur filter in PixiJS, where the uniform uStrength in the example shader above is scaled by $1/N$ instead of $1/\sqrt N$. I was very happy to find the bug because this is the first time that I found a bug without actually producing an unexpected phenomenon first but by just staring at the source codes and deducing the mathematical formulas by hand. I opened an issue for my findings.

As a rhythm game player, I often wonder what my max combo will be in my next play. This is a rather unpredictable outcome, and what I can do is to try to conclude a probability distribution of my max combo.

For those who are not familiar with rhythm games and also to make the question clearer, I state the problem in a more mathematical setting.

Consider a random bit string of length $n\in\mathbb N$, where each bit is independent and has probability $Y\in[0,1]$ of being $1$. Let $P_{n,k}(Y)$ be the probability that the length of the longest all-$1$ substring of the bit string is $k\in\mathbb N$ (where obviously $P_{n,k}(Y)$ is nonzero only when $k\le n$). What is the expression of $P_{n,k}(Y)$?

A more interesting problem to consider is what the probability distribution tends to be when $n\to\infty$. Define the random variable $\kappa\coloneqq k/n$ where $k$ is the length of the longest all-$1$ substring. Define a parameter $y\coloneqq Y^n$ (this parameter is held constant while $n\to\infty$). Define the probability distribution function of $\kappa$ as $$f(y,\kappa)\coloneqq\lim_{n\to\infty}\left(n+1\right)P_{n,\kappa n}\!\left(y^{\frac1n}\right).$$ $$(1)$$ What is the expression of $f(y,\kappa)$?

Notation

Notation for integer range: $a\ldots b$ denotes the integer range defined by the ends $a$ (inclusive) and $b$ (exclusive), or in other words $\left\{a,a+1,\ldots,b-1\right\}$. It is defined to be empty if $a\ge b$. The operator $\ldots$ has a lower precedence than $+$ and $-$ but a higher precedence than $\in$.

The notation $a\,..b$ denotes the inclusive integer range $\left\{a,a+1,\ldots,b\right\}$. It is defined to be empty if $a>b$.

The case for finite $n$

A natural approach to find $P_{n,k}$ is to try to find a recurrence relation of $P_{n,k}$ for different $n$ and $k$, and then use a dynamic programming (DP) algorithm to compute $P_{n,k}$ for any given $n$ and $k$.

The first DP approach

For a rhythm game player, the most straightforward way of finding $k$ for a given bit string is to track the current combo, and update the max combo when the current combo is greater than the previous max combo.

To give the current combo a formal definition, denote each bit in the bit string as $b_i$, where $i\in0\ldots n$. Define the current combo $r_i$ as the length of the longest all-$1$ substring of the bit string ending before (exclusive) $i$ (so $r_i=0$ if $b_{i-1}=0$, which is callled a combo break): $$r_i\coloneqq\max\left\{r\in0\,..i\,\middle|\,\forall j\in i-r\ldots i:b_j=1\right\},$$ where $i\in0\,..n$.

Now, use three numbers $(n,k,r)$ to define a DP state. Denote $P_{n,k,r}$ to be the probability that the max combo is $k$ and the final combo ($r_n$) is $r$. Then, consider a transition from state $(n,k,r)$ to state $(n+1,k',r')$ by adding a new bit $b_n$ to the bit string. There are two cases:

• If $b_n=0$ (has $1-Y$ probability), then this means a combo break, so we have $r'=0$ and $k'=k$.
• If $b_n=1$ (has $Y$ probability), then the combo continues, so we have $r'=r+1$. The max combo needs to be updated if needed, so we have $k'=\max(k,r')$.

However, in actual implementation of the DP algorithm, we need to reverse this transition by considering what state can lead to the current state $(n,k,r)$ (to use the bottom-up approach).

First, obviously in any possible case $r\in0\,..k$ (currently we only consider the cases where $n>k>0$). Divide all those cases into three groups:

1. If $r=0$, this is means a combo break, so the last bit is $0$, and the previous state can have any possible final combo $r'$. Therefore, it can be transitioned from any $(n-1,k,r')$ where $r'\in0\,..k$. For each possible previous state, the probability of the transition to this new state is $1-Y$.
2. If $r\in1\,..k-1$, this means the last bit is $1$, the previous final combo is $r-1$, and the previous max combo is already $k$. Therefore, the previous state is $(n-1,k,r-1)$, and the probability of the transition is $Y$.
3. If $r=k$, this means the max combo may (or may not) have been updated. In either case, the previous final combo is $r-1=k-1$.

• If the max combo is updated, the previous max combo must be $k-1$ because it must not be less than the previous final combo $k-1$ and must be less than the new max combo $k$. Therefore, the previous state is $(n-1,k-1,k-1)$, and the probability of the transition is $Y$.
• If the max combo is not updated, the previous max combo is the same as the new one, which is $k$. Therefore, the previous state is $(n-1,k,k-1)$, and the probability of the transition is $Y$.

Therefore, we can write a recurrence relation that is valid when $n>k>0$: $$P_{n,k,r}=\begin{cases} \left(1-Y\right)\sum_{r'=0}^kP_{n-1,k,r'},&r=0\\ YP_{n-1,k,r-1},&r\in1\,..k-1\\ Y\left(P_{n-1,k-1,k-1}+P_{n-1,k,k-1}\right),&r=k. \end{cases}$$

However, there are also other cases (mostly edge cases) because we assumed $n>k>0$. Actually, in the meaningfulness condition $n\ge k\ge r\ge0$ (necessary condition for $P_{n,k,r}$ to be nonzero), there are three inequality that can be altered between a less-than sign or an equal sign, so there are totally $2^3=8$ cases. Considering all those cases (omitted in this article because of the triviality), we can write a recurrence relation that is valid for all $n,k,r$, covering all the edge cases: $$P_{n,k,r}=\begin{cases} 1,& n=k=r=0,\\ YP_{n-1,n-1,n-1},& n=k=r>0,\\ 0,& n=k>r>0,\\ 0,& n=k>r=0,\\ Y\left(P_{n-1,k-1,k-1}+P_{n-1,k,k-1}\right),& n>k=r>0,\\ YP_{n-1,k,r-1},& n>k>r>0,\\ \left(1-Y\right)\sum_{r'=0}^kP_{n-1,k,r'},& n>k>r=0,\\ \left(1-Y\right)P_{n-1,0,0},& n>k=r=0. \end{cases}$$ $$(2)$$

Note that the probabilities related to note count $n$ only depend on those related to note count $n-1$ and that the probabilities related to max combo $k$ and final combo $r$ only depend on those related to either less max combo than $k$ or less final combo than $r$ (except for the case $n>k>r=0$, which can be specially treated before the current iteration of $k$ actually starts), so for the bottom-up DP we can reduce the spatial complexity from $O\!\left(n^3\right)$ to $O\!\left(n^2\right)$ by reducing the 3-dimensional DP to a 2-dimensional one. What needs to be taken care of is that the DP table needs to be updated from larger $k$ and $r$ to smaller $k$ and $r$ instead of the other way so that the numbers in the last iteration in $n$ are left untouched while we need to use them in the current iteration.

After the final iteration in $n$ finishes, we need to sum over the index $r$ to get the final answer: $$P_{n,k}=\sum_{r=0}^kP_{n,k,r}.$$

Writing the code for the DP algorithm is then straightforward. Here is an implementation in Ruby. In the code, dp[k][r] means $P_{n,k,r}$ in the $n$th iteration.

          
            ## Returns an array of size m+1,

            ## with the k-th element being the probability P_{m,k}.

            def combo m

            	(1..m).each_with_object [[1]] do |n, dp|

            		dp[n] = [0]*n + [Y * dp[n-1][n-1]] # n = k > 0

            		(n-1).downto 1 do |k| # n > k > 0

            			dpk0 = (1-Y) * dp[k].sum

            			dp[k][k] = Y * (dp[k-1][k-1] + dp[k][k-1])        # n > k = r > 0

            			(k-1).downto(1) { |r| dp[k][r] = Y * dp[k][r-1] } # n > k > r > 0

            			dp[k][0] = dpk0                                   # n > k > r = 0

            		end

            		dp[0][0] *= 1-Y # n > k = r = 0

            	end.map &:sum

            end

          
        

Because of the three nested loops, the time complexity of the DP algorithm is $O\!\left(n^3\right)$.

The second DP approach

Here is an alternative way to use DP to solve the problem. Instead of building a DP table with the $k,r$ indices, we can build a DP table with the $n,k$ indices.

First, we need to rewrite the recurrence relation of $P_{n,k}$ instead of that of $P_{n,k,r}$. We then need to try to express $P_{n,k,r}$ in terms of $P_{n,k}$ terms. The easiest part is the case where $n\ge k=r=0$. By recursively applying Equation 2 to $P_{n,0,0}$, we have $$\begin{align*} P_{n,0,0}&=\left(1-Y\right)P_{n-1,0,0}\\ &=\left(1-Y\right)^2P_{n-2,0,0}\\ &=\cdots\\ &=\left(1-Y\right)^nP_{0,0,0}. \end{align*}$$ Because $P_{0,0,0}=1$, we have $$P_{n,0,0}=\left(1-Y\right)^n.$$ $$(3)$$

For $n>k>r>0$, we can recursively apply Equation 2 to get $$\begin{align*} P_{n,k,r}&=YP_{n-1,k,r-1}\\ &=Y^2P_{n-2,k,r-2}\\ &=\cdots \end{align*}$$ This will finally either decend the note count to $k$ or decend the final combo to $0$, determined by which comes first.

• If $n-r\le k$, we will decend to the term $P_{k,k,r-(n-k)}$, which must be zero according to the case $n=k>r=0$ and the case $n=k>r>0$ in Equation 2, so $P_{n,k,r}=0$.
• If $n-r>k$, then we will decend to the term $P_{n-r,k,0}$, which is equal to $\left(1-Y\right)P_{n-r-1,k}$ according to the case $n>k>r=0$ in Equation 2.

Therefore, for $n>k>r>0$, we have $$P_{n,k,r}=\begin{cases} 0,&n-r\le k,\\ Y^r\left(1-Y\right)P_{n-r-1,k},&n-r>k. \end{cases}$$ $$(4)$$

For the case $n>k=r>0$, we can also recursively apply Equation 2 to get $$\begin{align*} P_{n,k,k}&=Y\left(P_{n-1,k-1,k-1}+P_{n-1,k,k-1}\right)\\ &=Y\left(Y\left(P_{n-2,k-2,k-2}+P_{n-2,k-1,k-2}\right)+P_{n-1,k,k-1}\right)\\ &=\cdots\\ &=Y\left(Y\left(\cdots Y\left(P_{n-k,0,0}+P_{n-k,1,0}\right)+\cdots\right)+P_{n-1,k,k-1}\right)\\ &=Y^kP_{n-k,0,0}+\sum_{j=1}^kY^jP_{n-j,k-j+1,k-j}. \end{align*}$$ We can then substitute Equation 3 and 4 into the above equation. The substitution of Equation 3 can be done without a problem, but the substitution of Equation 4 requires some care because of the different cases.

• If $n-k>k$, then only the case $n-r>k$ in Equation 4 will be involved in the summation.
• If $n-k\le k$, then both cases in Equation 4 will be involved in the summation. To be specific, for $j\in1\,..\,2k-n+1$, we need the case $n-r\le k$ in Equation 4 (where the summed terms are just zero and can be omitted); for other terms in the summation, we need the other case.

Considering both cases, we may realize that we can just modify the range of the summation to $j\in\max(1,2k-n+1)\,..k$ and adopt the case $n-r>k$ in Equation 4 for all terms in the summation. Therefore, we have $$\begin{align*} P_{n,k,k}&=Y^k\left(1-Y\right)^{n-k}+\sum_{j=\max(1,2k-n+1)}^{k}Y^jY^{k-j}\left(1-Y\right)P_{n-j-(k-j)-1,k-j+1}\\ &=Y^k\left(1-Y\right)^{n-k}+Y^k\left(1-Y\right)\sum_{k'=1}^{\min(k,n-k-1)}P_{n-k-1,k'}, \end{align*}$$ where in the last line we changed the summation index to $k'\coloneqq k-j+1$ to simplify it. Because $P_{n-k-1,0}=P_{n-k-1,0,0}=\left(1-Y\right)^{n-k-1}$ according to Equation 3, we can combine the two terms into one summation to get the final result for $n>k=r>0$: $$P_{n,k,k}=Y^k\left(1-Y\right)\sum_{k'=0}^{\min(k,n-k-1)}P_{n-k-1,k'}.$$ $$(5)$$ Noticing the obvious fact that $\sum_{k=0}^nP_{n,k}=1$, the above equation can be simplified, when $k\ge n-k-1$, to $$P_{n,k,k}=Y^k\left(1-Y\right).$$ $$(6)$$ This simplification is not specially useful, but it can be used to simplify the calculation in the program.

Then, for $n>k>0$, express $P_{n,k}$ in terms of $P_{n,k,r}$ by summing over $r$, and substitute previous results: $$\begin{align*} P_{n,k}&=\sum_{r=0}^kP_{n,k,r}\\ &=P_{n,k,0}+P_{n,k,k}+\sum_{r=1}^{k-1}P_{n,k,r}\\ &=\left(1-Y\right)P_{n-1,k}+Y^k\left(1-Y\right)\sum_{k'=0}^{\min(k,n-k-1)}P_{n-k-1,k'}\\ &\phantom{=~}{}+\sum_{r=1}^{\min(k-1,n-k-1)}Y^r\left(1-Y\right)P_{n-r-1,k}\\ &=\left(1-Y\right)\left( Y^k\sum_{k'=0}^{\min(k,n-k-1)}P_{n-k-1,k'} +\sum_{r=0}^{\min(k-1,n-k-1)}Y^rP_{n-r-1,k} \right) \end{align*}$$ where in the last term $r$ is summed to $\min(k-1,n-k-1)$ instead of $k-1$ because of the different cases in Equation 4.

Finally, consider the edge cases where $n=k\ge0$ and $n\ge k=0$ (trivial), we have the complete resursive relation for $P_{n,k}$: $$P_{n,k}=\begin{cases} Y^n,&n=k\ge0,\\ \left(1-Y\right)^n,&n\ge k=0,\\ \displaystyle{\begin{split} \left(1-Y\right)&\,\left( Y^k\sum_{k'=0}^{\min(k,n-k-1)}P_{n-k-1,k'} \right.\\&\left. +\sum_{r=0}^{\min(k-1,n-k-1)}Y^rP_{n-r-1,k} \right), \end{split}}&n>k>0. \end{cases}$$ $$(7)$$

Then, we can write the program to calculate $P_{n,k}$:

          
            ## Returns an array of size m+1,

            ## with the k-th element being the probability P_{m,k}.

            def combo m

            	(1..m).each_with_object [[1]] do |n, dp|

            		dp[n] = (1..n-1).each_with_object [(1-Y)**n] do |k, dpn|

            			dpn[k] = (1-Y) * (Y**k * (0..[k, n-k-1].min).sum { dp[n-k-1][_1] } + (0..[k-1, n-k-1].min).sum { Y**_1 * dp[n-_1-1][k] })

            		end

            		dp[n][n] = Y**n

            	end.last

            end

          
        

This algorithm has the same (asymptotic) space and time complexity as the previous one.

Polynomial coefficients

We have wrote programmes to calculate probabilities $P_{n,k}(Y)$ based on given $Y$, which we assumed to be a float number. However, float numbers have limited precision, and the calculation may be inaccurate. Actually, the calculation can be done symbolically.

The probability $P_{n,k}$ is a polynomial of degree (at most) $n$ in $Y$, and the coefficients of the polynomial are integers. This can be easily proven by using mathematical induction and utilizing Equation 7. Therefore, we can calculate the coefficients of the polynomial $P_{n,k}(Y)$ instead of calculate the value directly so that we get a symbolic but accurate result.

Both the two DP algorithms above can be modified to calculate the coefficients of the polynomial. Actually, we can define Y to be a polynomial object that can do arithmetic operations with other polynomials or numbers, and then the programmes can run without any modification. Here, I will modify the second DP algorithm to calculate the coefficients of the polynomial.

We can also utilize Equation 6 to simplify the calculation. Considering the edge cases involved in $\min(k,n-k-1)$ and $\min(k-1,n-k-1)$, there are three cases we need to consider:

1. Case $k>n-k-1$: Equation 6 can be applied, and $r$ is summed to $n-k-1$.
2. Case $k=n-k-1$ (can only happen when $n$ is odd): Equation 6 can be applied, and $r$ is summed to $k-1$.
3. Case $k<n-k-1$: Equation 6 cannot be applied, and $r$ is summed to $k-1$.

Then, use arrays to store the coefficients of the polynomial $P_{n,k}(Y)$, and we can write the program to calculate the coefficients:

          
            ## Returns a nested array of size m+1 times m+1,

            ## with the j-th element of the k-th element being the coefficient of Y^j in P_{m,k}(Y).

            def combo_pc m

            	(1..m).each_with_object [[[1]]] do |n, dp|

            		dp[n] = Array.new(n+1) { Array.new n+1, 0 }

            

            		# dp[n][0] = (1-Y)**n

            		0.upto(n-1) { dp[n][0][_1] = dp[n-1][0][_1] } # will be multiplied by 1-Y later

            

            		1.upto n/2-1 do |k|

            			# dp[n][k] = (1-Y) * (Y**k * (0..k).sum { |j| dp[n-k-1][j] } + (0..k-1).sum { |r| Y**r * dp[n-r-1][k] })

            			0.upto(k) { |j| 0.upto(n-k-1) { dp[n][k][_1+k] += dp[n-k-1][j][_1] } }

            			0.upto(k-1) { |r| 0.upto(n-r-1) { dp[n][k][_1+r] += dp[n-r-1][k][_1] } }

            		end

            

            		if n % 2 == 1

            			k = n/2

            			# dp[n][k] = (1-Y) * (Y**k + (0..k-1).sum { |r| Y**r * dp[n-r-1][k] })

            			dp[n][k][k] = 1

            			0.upto(k-1) { |r| 0.upto(n-r-1) { dp[n][k][_1+r] += dp[n-r-1][k][_1] } }

            		end

            

            		((n+1)/2).upto n-1 do |k|

            			# dp[n][k] = (1-Y) * (Y**k + (0..n-k-1).sum { |r| Y**r * dp[n-r-1][k] })

            			dp[n][k][k] = 1

            			0.upto(n-k-1) { |r| 0.upto(n-r-1) { dp[n][k][_1+r] += dp[n-r-1][k][_1] } }

            		end

            

            		0.upto(n-1) { |k| n.downto(1) { dp[n][k][_1] -= dp[n][k][_1-1] } } # multiply by 1-Y

            

            		# dp[n][n] = Y**n

            		dp[n][n][n] = 1

            	end.last

            end

          
        

Here I list first few polynomials $P_{n,k}(Y)$ calculated by the above program: $$\begin{array}{r|llllc} & k=0 & 1 & 2 & 3 & \cdots\\ \hline n=0 & 1\\ 1 & 1-Y & Y\\ 2 & 1-2Y+Y^2 & 2Y-2Y^2 & Y^2\\ 3 & 1-3Y+3Y^2-Y^3 & 3Y-5Y^2+2Y^3 & 2Y^2-2Y^3 & Y^3\\ \vdots \end{array}$$

When evaluating the polynomials for large $n$, the result is inaccurate for $Y$ that is not close to $0$ because of the limited precision of floating numbers. If $Y$ is closer to $1$, we can first find the coefficients of $P_{n,k}(1-X)$ and then substitute $X\coloneqq1-Y$.

Plots of the probability distributions

Here are some plots of the probability distribution of max combo $k$ when $n=50$:

The plots are intuitive as they show that one has higher probability to get a higher max combo when they have a higher success rate.

There is a suspicious jump in $P_{n,k}(Y)$ near $k=n/2$ when $Y$ is close to $1$. We can look at it closer:

In the zoomed-in plot, we can also see a jump in first derivative (w.r.t. $k$) of $P_{n,k}(Y)$ near $k=n/3$. Actually, the jumps can be modeled in later sections when we talk about the case when $n\to\infty$.

The case when $n\to\infty$

A natural approach is to try substituting Equation 7 into Equation 1 to get a function w.r.t. the unknown function $f(y,\kappa)$. First, we can easily write the case when $y=0$ because it means zero success rate, and the only possible max combo is zero: $$f(y=0,\kappa)=\delta(\kappa).$$ $$(8)$$ Similarly, we can easily write the case when $y=1$: $$f(y=1,\kappa)=\delta(\kappa-1).$$ $$(9)$$

From now on, we only consider the case when $0<y<1$. First, for the case $\kappa=0$, according to Equation 7, $$\begin{align*} f(y,\kappa=0)&=\lim_{n\to\infty}\left(n+1\right)\left(1-y^{\frac1n}\right)^n\\ &=\begin{cases}0,&0<y\le1,\\\infty,&y=0.\end{cases} \end{align*}$$ The $\infty$ means that there is a Dirac $\delta$ function (shown in Equation 8).

Then, for the case $\kappa=1$, according to Equation 7, $$f(y,\kappa=1)=\lim_{n\to\infty}\left(n+1\right)y=\infty.$$ The $\infty$ means that there is a Dirac $\delta$ function. Actually, it is easy to see that there must be a $y\delta(\kappa-1)$ term in the expression of $f(y,\kappa)$ because the probability of getting a max combo ($\kappa=1$) is $y$.

Define $$h(y,\kappa)\coloneqq f(y,\kappa)-y\delta(\kappa-1),$$ $$(10)$$ and then we can get rid of the infinity here.

From now on, we only consider the case when $0<y<1$ and $0<\kappa<1$. According to Equation 7, $$\begin{align*} &\phantom{=~}f\!\left(y\in\left(0,1\right),\kappa\in\left(0,1\right)\right)\\ &=\lim_{n\to\infty}\left(n+1\right)\left(1-y^{\frac1n}\right)\left( y^\kappa\sum_{k'=0}^{\min(\kappa n,n-\kappa n-1)}P_{n-\kappa n-1,k'}\!\left(y^{\frac1n}\right) \right.\\&\phantom{=\lim_{n\to\infty}\left(n+1\right)\left(1-y^{\frac1n}\right)}\left. +\sum_{r=0}^{\min(\kappa n-1,n-\kappa n-1)}y^{\frac rn}P_{n-r-1,\kappa n}\!\left(y^{\frac1n}\right) \right)\\ &=\lim_{n\to\infty}n\left(1-y^{\frac1n}\right)\cdot\lim_{n\to\infty}\left( y^\kappa\sum_{t=0,\Delta t=\frac1n}^{\min(\kappa,1-\kappa)}P_{(1-\kappa)n,tn}\!\left(y^{\frac1n}\right) +\sum_{t=0,\Delta t=\frac1n}^{\min(\kappa,1-\kappa)}y^tP_{(1-t)n,\kappa n}\!\left(y^{\frac1n}\right) \right)\\ &=-\ln y\lim_{n\to\infty}\left( y^\kappa\sum_{t=0,\Delta t=\frac1n}^{\min(\kappa,1-\kappa)} \frac1{\left(1-\kappa\right)n}f\!\left(y^{1-\kappa},\frac t{1-\kappa}\right) \right.\\&\phantom{=-\ln y\lim_{n\to\infty}}\left. +\sum_{t=0,\Delta t=\frac1n}^{\min(\kappa,1-\kappa)}y^t \frac1{\left(1-t\right)n}f\!\left(y^{1-t},\frac{\kappa}{1-t}\right) \right)\\ &=-\ln y\lim_{n\to\infty}\sum_{t=0,\Delta t=\frac 1n}^{\min(\kappa,1-\kappa)}\left( \frac{y^\kappa}{1-\kappa}f\!\left(y^{1-\kappa},\frac t{1-\kappa}\right) +\frac{y^t}{1-t}f\!\left(y^{1-t},\frac\kappa{1-t}\right) \right)\Delta t\\ &=-\ln y\int_{t=0}^{\min(\kappa,1-\kappa)}\left( \frac{y^\kappa}{1-\kappa}f\!\left(y^{1-\kappa},\frac t{1-\kappa}\right) +\frac{y^t}{1-t}f\!\left(y^{1-t},\frac\kappa{1-t}\right) \right)\mathrm dt. \end{align*}$$ Add back the delta function at $\kappa=1$, and we have the integral equation $$\begin{split} f\!\left(y\in\left(0,1\right),\kappa\right)=-\ln y\int_{t=0}^{\min(\kappa,1-\kappa)}&\,\left( \frac{y^\kappa}{1-\kappa}f\!\left(y^{1-\kappa},\frac t{1-\kappa}\right) \right.\\&\left. +\frac{y^t}{1-t}f\!\left(y^{1-t},\frac\kappa{1-t}\right) \right)\mathrm dt+y\delta(\kappa-1). \end{split}$$