= S-Metric Helper Data Method A metric based @hda generates helper data at PUF enrollment to provide more reliable results at the reconstruction stage. Each of these metrics correspond to a quantizer with different bounds to lower the risk of bit or symbol errors during reconstruction. == Background === Distribution Independency The publications for the Two-Metric approach @tmhd1 and @tmhd2, as well as the generalized S-Metric approach @smhd make the assumption, that the PUF readout is "zero-mean Gaussian distributed" @smhd. We propose, that a Gaussian distributed input für S-Metric quantization is not required for the operation of this quantizing algorithm. Instead, any distribution can be used for input values given, that a CDF exists for that distribution and its parameters are known. As already mentioned in @tilde-domain, this transformation will result in uniformly distributed values, where equi-probable areas in the real domain correspond to equi-distant areas in the Tilde-Domain. Contrary to @tmhd1, @tmhd2 and @smhd, which display relevant areas as equi-probable in a normal distribution, we will use equi-distant areas in a uniform distribution for better understandability. It has to be mentioned, that instead of transforming all values of the PUF readout into the Tilde-Domain, we could also use an inverse CDF to transform the bounds of our evenly spaced areas into the real domain with (normal) distributed values, which can be assessed as remarkably less computationally complex. === Two-Metric Helper Data Method The most simple form of a metric-based @hda is the Two-Metric Helper Data Method, since the quantization only yields symbols of 1-bit width and uses the lead amount of metrics possible. Publications @tmhd1 and @tmhd2 find all the relevant bounds for the enrollment and reconstruction phases under the assumption that the PUF readout is Gaussian distributed. Because this approach is static, meaning the parameters for symbol width and number of metrics always stays the same, it is easier to calculate the bounds for 8 equi-probable areas with a standard deviation of $sigma = 1$ first and then multiplying them with the estimated standard deviation of the PUF readout. This is done by fining two bounds $a$ and $b$, that $ integral_a^b f_X(x) \dx = 1/8 $ This operation yields 9 bounds defining these areas $-\T1$, $-a$, $-\T2$, $0$, $\T2$, $a$, $\T1$ and $plus.minus infinity$ During the enrollment phase, we will $plus.minus a$ as our quantizing bounds, retuning $0$ if the absolute values is smaller than $a$ and $1$ otherwise. The corresponding metric is chosen based on the following conditions: $ M = cases( \M1\, x < -a or 0 < x < a, \M2\, -a < x or 1 < a < x ) $ @fig:tmhd_enroll shows the curve of a quantizer $cal(Q)$, that would be used during the Two-Metric enrollment phase. At this point, we will still assume, that our input value $x$ is zero-mean Gaussian distributed. #grid( columns: (1fr, 1fr), [#figure( include("../graphics/quantizers/two-metric/enrollment.typ"), caption: [Two-Metric enrollment]) ], [#figure( include("../graphics/quantizers/two-metric/reconstruction.typ"), caption: [Two-Metric reconstruction]) ] ) The metric will be stored publicly for every quantized bit as helper data. As previously described, each of these metrics correspond to a different quantizer. Now, we can use the generated helper data in the reconstruction phase and define a reconstructed bit based on the chosen metric as follows: $ #grid( columns: (1fr, 1fr), align: (center, center), math.equation($\M1: k = cases(0\, x < \T1 or \T2 < x, 1\, -\T1 < x < \T2)$, block: true, numbering: none), math.equation($\M2: k = cases(0\, x < -\T2 or \T1 < x, 1\, -\T2 < x < \T1)$, block: true, numbering: none) ) $ @fig:tmhd_reconstruct illustrates the basic idea behind the Two-Metric method. Using the helper data, we will move the bounds of the original quantizer one octile to each side, yielding two new quantizers. The advantage of this method comes from moving the point of uncertainty away from our readout position. @fig:tmhd_example_enroll and @fig:tmhd_example_reconstruct illustrate an example enrollment and reconstruction process. We would consider the marked point the value of the initial measurement and the marked range our margin of error due to inaccuracies in the measurement process. If we now were to use the quantizer shown in @fig:tmhd_example_enroll during both the enrollment and the reconstruction phases, we would risk a bit error, because the margin of error overlaps with the lower quantization bound $-a$. But since we generated helper data during enrollment as depicted in @fig:tmhd_enroll, we can make use of a different quantizer $cal(R)(1, 2, x)$ whose boundaries do not overlap with the error margin of the measurement. #grid( columns: (1fr, 1fr), [#figure( include("../graphics/quantizers/two-metric/example_enroll.typ"), caption: [Example enrollment]) ], [#figure( include("../graphics/quantizers/two-metric/example_reconstruct.typ"), caption: [Example reconstruction]) ] ) #pagebreak() === S-Metric Helper Data Method Going on, the Two-Metric Helper Data Method can be generalized as shown in @smhd. This generalization allows for higher order bit quantization and the use of more than two metrics. A key difference to the Two-Metric approach is the alignment of quantization areas. Methods described in @tmhd1 and @tmhd2 use two bounds for 1-bit quantization, namely $plus.minus a$. Contrary, the method introduced by @smhd would look more like a sign based quantizer if the configuration $cal(Q)(2, 1)$ is used, using only one quantization bound at $x=0$. @fig:smhd_compar1 and @fig:smhd_compar2 illustrate this difference. #grid( columns: (1fr, 1fr), [#figure( include("../graphics/quantizers/s-metric/s-metric-compar1.typ"), caption: [Two-Metric enrollment] )], [#figure( include("../graphics/quantizers/s-metric/s-metric-compar2.typ"), caption: [S-Metric enrollment with 1-bit configuration] )] ) The generalization consists of two components: - *Higher order bit quantization* \ We can introduce more steps to our quantizer and use them to extract more than one bit out of our PUF readout. - *Using more than two metrics* \ Instead of splitting each quantizer steam into only two equi-probable parts, we can increase the number of metrics at the cost of generating more helper data. == Implementation We will now propose a specific implementation of the S-Metric Helper Data Method. \ As shown in @sect:dist_independency, we can use a CDF to transform our random distributed variable $X$ into the Tilde-Domain: $tilde(X)$. This allows us to use equi-distant bounds for the quantizer instead of equi-probable ones. From now on we will use the following syntax for quantizers that use the S-Metric Helper Data Method: $ cal(Q)(s, m, tilde(x)) $ where s defines the number of metrics, m the number of bits and $tilde(x)$ a Tilde-Domain transformed PUF measurement. #pagebreak() === Enrollment To enroll our PUF key, we will first need to define the quantizer for higher order bit quantization and helper data generation. Because our PUF readout $tilde(x)$ can be interpreted as a realization of a uniformly distributed variable $tilde(X)$, we can define the width $Delta$ of our quantizer bins as follows: $ Delta = frac(1, 2^m) $ For example, if we were to extract a symbol with the width of 2 bits from our PUF readout, we would need to evenly space $2^2 = 4$ bins. Using equation @eq:delta, the step size for a 2-bit quantizer would result to: $ Delta' = lr(frac(1, 2^m) mid(|))_(m=2)= frac(1, 4) $ @fig:smhd_two_bit shows a plot of the resulting quantizer function that would yield symbols with two bits for one measurement $tilde(x)$. #figure( include("../graphics/quantizers/two-bit-enroll.typ"), caption: [2-bit quantizer] ) Right now, this quantizer wouldn't help us generating any helper data. To achieve that, we will need to divide a symbol step - one, that returns the corresponding quantized symbol - into multiple sub-steps. More specifically, we will define the amount of metrics we want to use with the parameter $s$. Using $s$, we can define the step size $Delta_s$ as the division of $Delta$ by $s$: $ Delta_s = frac(Delta, s) = frac(frac(1, 2^m), s) = frac(1, 2^m * s) $ After this definition, we need to make an adjustment to our previously defined quantizer function, because we cannot simply return the quantized value based on a quantizer with step size $Delta_s$. That would just increase the amounts of bits we will extract out of one measurement. Instead, we will need to return a tuple, consisting of the quantized symbol and the metric ascertained that we will save as helper data for later. Going on in our example, we could choose the amount of our metrics to be 2. According to @eq:delta_s, we would then half out step size: $ Delta'_s = lr(frac(Delta', s)mid(|))_(s=2) = frac(1, 4 * 2) = frac(1, 8) $ This means, we can update out quantizer function with the new step size $Delta'_s = frac(1, 8)$ and redefining its output as a tuple consisting of bit value and helper data. We can visualize the quantizer that we will use during the enrollment phase of a 2-bit 2-metric configuration as depicted in @fig:smhd_2_2_en. #grid( columns: (1fr, 1fr), [#scale(x: 80%, y: 80%)[ #figure( include("../graphics/quantizers/s-metric/2_2_en.typ"), caption: [2-bit 2-metric enrollment] ) ]], [#scale(x: 80%, y: 80%)[ #figure( include("../graphics/quantizers/s-metric/3_2_en.typ"), caption: [2-bit 3-metric enrollment] ) ]]) To better demonstrate the generalization to $s$-metrics, @fig:smhd_3_2_en shows a 2-bit quantizer that generates helper data based on three metrics instead of two. In that sense, increasing the number of metrics will increase the number of sub-steps for each symbol. We can now perform the enrollment of a full PUF readout. Each measurement will be quantized with out quantizer $cal(E)$, returning a tuple consisting of the quantized symbol and helper data, as shown in @eq:smhd_quant $ K_i = cal(E)(s, m tilde(x_i)) = (k, h)_i $ Performing the operation of @eq:smhd_quant for our whole set of measurements will yield a vector of tuples $bold(K)$.