In this part, we build on Part II and III to develop a protocol for verifiable blind evaluation of polynomials, which we will define shortly. In Part V we’ll start to see how such a protocol can be used for constructing SNARKs, so bear with me a little bit longer for the connection to SNARKs :).

Suppose, as in Part II, that Alice has a polynomial :math:`P` of degree :math:`d` and Bob has a point :math:`s\in\mathbb{F}_p` that he chose randomly. We want to construct a protocol that allows Bob to learn :math:`E(P(s))`, i.e. the hiding of :math:`P` evaluated at :math:`s`, with two additional properties:

**Blindness**: Alice will*not*learn :math:`s` (and Bob will not learn :math:`P`).**Verifiability**: The probability that Alice sends a value not of the form :math:`E(P(s))` for :math:`P` of degree :math:`d` that is known to her, but Bob still accepts – is negligible.

This is what we call *verifiable* blind evaluation of a polynomial. The protocol in Part II gave us the first item but not the second. To get verifiability we need an extended version of the Knowledge of Coefficient Assumption (KCA) that was presented in Part III.

The verifiability and blindness properties are useful together because they make Alice decide what polynomial :math:`P` she will use *without seeing* :math:`s`. [1] This, in a sense, commits Alice to an “answer polynomial” without seeing the “challenge point” :math:`s`. This intuition will become more clear in the next parts of the series.

## An Extended KCA

The KCA as we defined it in Part III essentially said something like this: If Bob gives Alice some :math:`\alpha`-pair :math:`(a,b = \alpha\cdot a)` and then Alice generates another :math:`\alpha`-pair :math:`(a’,b’)`, then she knows :math:`c` such that :math:`a’=c\cdot a`. In other words, Alice knows the relation between :math:`a’` and :math:`a`.

Now, suppose that instead of one, Bob sends Alice several :math:`\alpha`-pairs :math:`(a_1,b_1),\ldots,(a_d,b_d)` (for the same :math:`\alpha`); and that again, after receiving these pairs, Alice is challenged to generate some other :math:`\alpha`-pair :math:`(a’,b’)`. Recall that the main point is that Alice must do so although *she does not know* :math:`\alpha`.

As we saw in Part III, a natural way for Alice to generate such an :math:`\alpha`-pair, would be to take one of the pairs :math:`(a_i,b_i)` she received from Bob, and multiply both elements by some :math:`c\in\mathbb{F}^*_p`; if :math:`(a_i,b_i)` was an :math:`\alpha`-pair, then :math:`(c\cdot a_i,c\cdot b_i)` will be one too. But can Alice generate :math:`\alpha`-pairs in more ways now that she’s received *multiple* :math:`\alpha`-pairs? Perhaps using several of the received :math:`\alpha`-pairs *simultaneously* to get a new one?

The answer is yes: For example, Alice can choose *two* values :math:`c_1,c_2\in \mathbb{F}_p` and compute the pair :math:`(a’,b’)=(c_1\cdot a_1 + c_2\cdot a_2, c_1\cdot b_1 + c_2\cdot b_2)`. An easy computation shows that, as long as :math:`a’` is non-zero, this is also an :math:`\alpha`-pair:

:math:`b’ = c_1\cdot b_1 + c_2 \cdot b_2 = c_1 \alpha \cdot a_1 + c_2\alpha\cdot a_2 = \alpha (c_1\cdot a_1 + c_2\cdot a_2) = \alpha\cdot a’.`

More generally, Alice can take any *linear combination* of the given :math:`d` pairs – that is choose any :math:`c_1,\ldots,c_d\in\mathbb{F}_p` and define :math:`(a’,b’)=(\sum_{i=1}^d c_i a_i,\sum_{i=1}^d c_ib_i)`.

Note that, if Alice uses this strategy to generate her :math:`\alpha`-pair she will know some linear relation between :math:`a’` and :math:`a_1,\ldots,a_d`; that is, she knows :math:`c_1,\ldots,c_d` such that :math:`a’=\sum_{i=1}^d c_i\cdot a_i`.

The extended KCA states, essentially, that this is the only way Alice can generate an :math:`\alpha`-pair; that is, whenever she succeeds, she will know such a linear relation between :math:`a’` and :math:`a_1,\ldots,a_d`. More formally, suppose that :math:`G` is a group of size :math:`p` with generator :math:`g` written additively as in Part III. The *d-power Knowledge of Coefficient Assumption* (d-KCA) [2] in :math:`G` is as follows:

**d-KCA**: *Suppose Bob chooses random* :math:`\alpha\in\mathbb{F}_p^*` *and* :math:`s\in\mathbb{F}_p`, *and sends to Alice the* :math:`\alpha`-pairs :math:`(g,\alpha\cdot g), (s\cdot g,\alpha s\cdot g),\ldots,(s^d\cdot g,\alpha s^d\cdot g)`. *Suppose that Alice then outputs another* :math:`\alpha`-pair :math:`(a’,b’)`. *Then, except with negligible probability, Alice knows* :math:`c_0,\ldots,c_d\in\mathbb{F}_p` *such that* :math:`\sum_{i=0}^d c_i s^i\cdot g = a’`.

Note that in the d-KCA Bob does not send an arbitrary set of :math:`\alpha`-pairs, but one with a certain “polynomial structure”. This will be useful in the protocol below.

## The Verifiable Blind Evaluation Protocol

Assume that our HH is the mapping :math:`E(x)=x\cdot g` for a generator :math:`g` of :math:`G` as above.

For simplicity, we present the protocol for this particular :math:`E`:

- Bob chooses a random :math:`\alpha\in\mathbb{F}_p^*`, and sends to Alice the hidings :math:`g,s\cdot g,\ldots,s^d\cdot g` (of :math:`1,s,\ldots,s^d`) and also the hidings :math:`\alpha\cdot g,\alpha s \cdot g,\ldots,\alpha s^d\cdot g` (of :math:`\alpha,\alpha s,\ldots,\alpha s^d`).
- Alice computes :math:`a=P(s)\cdot g` and :math:`b=\alpha P(s)\cdot g` using the elements sent in the first step, and sends both to Bob.
- Bob checks that :math:`b=\alpha \cdot a`, and accepts if and only if this equality holds.

First, note that given the coefficients of :math:`P`, :math:`P(s)\cdot g` is a linear combination of :math:`g,s\cdot g,\ldots,s^d\cdot g`; and :math:`\alpha P(s)\cdot g` is a linear combination of :math:`\alpha\cdot g,\alpha s \cdot g,\ldots,\alpha s^d\cdot g`. Thus, similarly to the protocol of Part II, Alice can indeed compute these values from Bob’s messages for a polynomial :math:`P` that she knows.

Second, by the d-KCA if Alice sends :math:`a`, :math:`b` such that :math:`b=\alpha \cdot a` then almost surely she knows :math:`c_0,\ldots,c_d\in\mathbb{F}_p` such that :math:`a=\sum_{i=0}^d c_is^i\cdot g`. In that case, :math:`a=P(s)\cdot g` for the polynomial :math:`P(X)=\sum_{i=0}^d c_i\cdot X^i` known to Alice. In other words, the probability that Bob accepts in Step 3 while at the same time Alice does not know such a :math:`P` is negligible.

To summarize, using the d-KCA we’ve developed a protocol for verifiable blind evaluation of polynomials. In the next posts, we will see how this building block comes to play in SNARK constructions.

[1] | In the fully formal proof, things are somewhat more subtle, as Alice does see some information about :math:`s` before deciding on her :math:`P` – for example, the hidings of :math:`s,\ldots,s^d`. |

[2] | The d-KCA was introduced in a paper of Jens Groth. |