new port

Author: vchernoy

404.html

@@ -570,6 +570,8 @@ <h2>Latest</h2>
 
       <li><a href="/post/">Posts</a></li>
 
+      <li><a href="/post/perfect-distribution/">Perfect Distribution Based on GCD</a></li>
+    
       <li><a href="/post/binomial-modulo-prime/">Binomial Coefficients Modulo a Prime: Fermat&#39;s Theorem and the Non-Adjacent Selection Problem</a></li>
 
       <li><a href="/post/efficient-implementation-non-adjacent-selection/">Efficient Implementation of the Non-Adjacent Selection Formula</a></li>

content/post/perfect-distribution.md

@@ -4,7 +4,7 @@ math = true
 highlight = true
 tags = ["math","python", "recursion", "recursive functions", "gcd", "uniform distribution"]
 title = "Perfect Distribution Based on GCD"
-draft = true
+draft = false
 
 # Optional featured image (relative to `static/img/` folder).
 [header]
@@ -13,47 +13,51 @@ caption = ""
 
 +++
 
-## Perfect Distribution Based On GCD
+## Perfect Distribution Based on GCD
 
-We discuss an algorithm that has property of uniform distribution.
-The examples below are Software Engineering used cases of this algorithm.
+We discuss an algorithm that distributes $a$ ones among $n$ positions so that the gaps between consecutive ones differ by at most one—a **perfect distribution**. The examples below are software engineering use cases for this algorithm.
 
-### Software Engineering Used Case 0
+### Use Case 0: Text spacing
 
-Given a string of characters $s$, and the given number $n$ that is greater then the length of $s$.
-Extend the string $s$ to the length $n$ by inserting spaces between the words of $s$.
-They key requirement is that the distances between two consecutive words will be uniform.
+Given a string of characters $s$ and a number $n$ greater than the length of $s$,
+extend the string $s$ to length $n$ by inserting spaces between the words.
+The key requirement is that the distances between two consecutive words be uniform.
 
-### Software Engineering Used Case 1
+### Use Case 1: Stress testing
 
-Assume we want to test a server for stress.
+Assume we want to stress-test a server.
 Our test contains positive and negative requests.
-Assume we want to sends $1000$ request that $300$ of them are negative.
+Suppose we want to send $1000$ requests, $300$ of which are negative.
 Our test tool might send requests simultaneously or sequentially,
-but what we required is that the negative requests will arrive the server with uniform distribution.
-I.e., we want to prevent the following: sending 300 negative following by $700$ positive requests.
-Using the algorithm, we simple distribute $300$ request by calling ${\cal PD}(300, 1000)$,
-containing $1$ in cell $i$ corresponds to the request $i$ to be negative.
-Then the test tool will use the array to sends request that now might be sent even sequentially.
-
-### Software Engineering Used Case 2
-
-Assume the test tool can also run performance tests, that is, creates stress on the server and measure performance -- the number of requests per second processed by the server.
-We want to extend the test tool by profiling feature: to specify the number of requests being sent per second.
-E.g. a performance test shows that the server performance is $1000$ requests per second.
-We want test tool will send requests according to specified speed, say $500$, or $200$, or $20$, or even $0.2$ requests per second (i.e., one request per $5$ second).
-Such profiling tool allows to explore the state of the server under various stress conditions: utility of CPU, Memory, Threads in depending on various number of requests received.
-The test tool may divide $1$ seconds, say, on $100$ parts, i.e. every part is $20$ milliseconds.
-Assume $230$ is specified, then during every part, $2.3$ request must be send.
-In other words, the test tool must send 2 requests in most of parts and $3$ request in some parts.
-Calling ${\cal PD}(30, 100)$ yields an array defining the parts in which 3 requests will be sent.
-
-We present the general solution ${\cal PD}$ to the problem -- for any specified input in above examples, ${\cal PD}$ produces the exact solution.
-Any probabilistic or approximation solutions do not achieve the required exactness and usually are much more complicated.
-The algorithm ${\cal PD}$ is very simple, clear to prove correctness and to find time complexity.
-Moreover, it has a nice relation to well-known Euclid's algorithm of computing Greatest Common Divisor, which is denoted here by ${\cal GCD}$.
-
-Euqlid’s Algorithm $\cal GCD$
+but we require that the negative requests arrive at the server with uniform distribution.
+I.e., we want to avoid sending 300 negative followed by 700 positive requests.
+Using the algorithm, we simply distribute the 300 negative requests by calling ${\cal PD}(300, 1000)$:
+cell $i$ is $1$ if and only if request $i$ is negative.
+The test tool then uses the array to send requests (possibly sequentially).
+
+### Use Case 2: Rate limiting / profiling
+
+Assume the test tool can run performance tests—creating stress and measuring throughput (requests per second).
+We want to extend the test tool with a profiling feature: specify the number of requests sent per second.
+E.g., a performance test shows the server handles $1000$ requests per second.
+We want the test tool to send requests at a specified rate, say $500$, $200$, $20$, or even $0.2$ requests per second (one request every 5 seconds).
+Such a profiling tool allows exploring the server state under various load conditions: CPU, memory, threads depending on the number of requests received.
+
+The test tool may divide 1 second into $100$ parts, each $20$ milliseconds.
+Suppose we specify $230$ requests per second: then during every part, $2.3$ requests must be sent on average.
+In other words, the tool must send 2 requests in most parts and 3 in some parts.
+We need to choose which $30$ parts get the extra request; ${\cal PD}(30, 100)$ yields that array (a $1$ in cell $i$ means part $i$ gets 3 requests).
+
+We present the general solution ${\cal PD}$ to the problem—for any specified input in the above examples, ${\cal PD}$ produces the exact solution.
+Any probabilistic or approximation solutions do not achieve the required exactness and are usually more complicated.
+The algorithm ${\cal PD}$ is simple, has a clear correctness proof, and admits $O(n)$ time and space complexity.
+Moreover, it has a direct relation to Euclid's algorithm for computing the Greatest Common Divisor, denoted here by ${\cal GCD}$.
+
+### Notation
+
+*POST* denotes a condition that the procedure guarantees will hold after the call.
+
+### Euclid's Algorithm ${\cal GCD}$
 
 * POST: $res = {\cal GCD}(a, n)$.
 
@@ -68,12 +72,14 @@ def gcd(a, n):
     return res
 ```
 
-Deterministic algorithm of perfect distribution $\cal PD$
+### Deterministic algorithm of perfect distribution ${\cal PD}$
+
+The recurrence mirrors Euclid's algorithm: ${\cal PD}(a, n)$ calls ${\cal PD}(n \bmod a, a)$, so the recursion depth is $O(\log \min(a, n))$ and total time is $O(n)$.
 
 * POST: size of $res$ is $n$.
-* POST: $\forall i, res[i] ∈ \{0, 1\}$.
-* POST: $\sum_{i=1}^n res[i] = a$
-* POST: $res$ is perfectly distributed.
+* POST: $\forall i,\, res[i] \in \{0, 1\}$.
+* POST: $\sum_{i=0}^{n-1} res[i] = a$ (exactly $a$ ones).
+* POST: $res$ is perfectly distributed (gaps between consecutive ones differ by at most 1).
 
 ```python
 def pd(a, n):
@@ -91,17 +97,13 @@ def pd(a, n):
     return res
 ```
 
-## Notation.
-
-* POST means a condition that the procedure guarantees will hold after the call.
-
-### Example. ${\cal PD}(2, 10): a = 2, b = 8$
-We want to mix $2$ ones and $8$ zeros up.
+### Example. ${\cal PD}(2, 10)$: $a = 2$, $n = 10$, so $n - a = 8$ zeros
+We want to mix $2$ ones and $8$ zeros.
 The recursive call ${\cal PD}(0, 2)$ returns $[0, 0] = 0^2$, which is assigned to $arr$.
 Then the array $res$ is filled as follows: $[(1, 0, 0, 0, 0), (1, 0, 0, 0, 0)] = (1, 0^4)^2$, which is returned by ${\cal PD}(2, 10)$.
 
-### Example. ${\cal PD}(8, 10): a = 8, b = 2$
-We want to mix $8$ ones and $2$ zeros up.
+### Example. ${\cal PD}(8, 10)$: $a = 8$, $n = 10$, so $n - a = 2$ zeros
+We want to mix $8$ ones and $2$ zeros.
 The recursive call ${\cal PD}(2, 8)$ returns $[1, 0, 0, 0, 1, 0, 0, 0] = (1, 0^3)^2$, which is assigned to $arr$.
 Then the array $res$ is filled as follows: $[(1, 0, 1, 1, 1), (1, 0, 1, 1, 1)] = (1, 0, 1^3)^2$, which is returned by ${\cal PD}(8, 10)$.
 
@@ -116,18 +118,22 @@ Then the array $res$ is filled as follows: $[(1, 0, 1, 1, 1), (1, 0, 1, 1, 1)] =
 
 * ${\cal PD}(0, 2) : [0, 0] = 0^2$
 * ${\cal PD}(2, 6) : [1, 0, 0, 1, 0, 0] = 1, 0^2 , 1, 0^2 = (1, 0^2)^2$
-* ${\cal PD}(6, 8) : [1, 0, 1, 1, 1, 0, 1, 1] = 1, 0, 13 , 0, 12 = (1, 0, 12)^2$
+* ${\cal PD}(6, 8) : [1, 0, 1, 1, 1, 0, 1, 1] = 1, 0, 1^3, 0, 1^2 = (1, 0, 1^2)^2$
 * ${\cal PD}(8, 14) : [1, 0, 1, 1, 0, 1, 0, 1, 0, 1, 1, 0, 1, 0] = (1, 0, 1, 1, 0, 1, 0)^2$ $ = ((1, 0, 1)^2 , 0)^2$
 
-### Slow version of $\cal GCD$.
+### Alternative formulation: subtraction-based (slow) versions
+
+The same recurrence can be expressed using subtraction instead of modulo, which makes the symmetry with Euclid's algorithm more explicit. These versions have the same recursion structure but do more work per step.
+
+**Slow GCD (subtraction-based):**
 
 ```python
 def gcd(a, n):
     assert 0 <= a <= n
 
     res = n
     if a > 0:
-        b = n − a
+        b = n - a
         if b > a:
             res = gcd(a, b)
         else:
@@ -136,7 +142,7 @@ def gcd(a, n):
     return res
 ```
 
-### Slow versions of $\cal PD$
+**Slow PD (subtraction-based):**
 
 ```python
 def pd(a, n):
@@ -145,7 +151,7 @@ def pd(a, n):
     res = [0] * n
     if a > 0:
         ofs = 0
-        b = n − a
+        b = n - a
         if b > a:
             arr = pd(a, b)
             for i in range(b):
@@ -155,8 +161,8 @@ def pd(a, n):
         else:
             arr = pd(b, a)
             for i in range(a):
-                res[ofs] = 1 − arr[i]
-                ofs += 2 − arr[i]
+                res[ofs] = 1 - arr[i]
+                ofs += 2 - arr[i]
 
     return res
 ```