IOP defines as interactive oracle proofs are denoted by a system $S=(P,V)$ of interactive randomised algorithms where interaction happens between entities involved in the system: $P=Prover,V=Verifier$. Verifier is given oracle access to the message sent by prover to the verifier in any round.

Properties of an IOP system:

- Round complexity, $r(N)$: number of rounds of interaction between $P$ and $V$
- Proof length, $l(N)$: sum of length of all messages sent by $P→V$
- Proof complexity, $q(N)$: number of entries read by $V$ from the various prover messages

## PIOP

Polynomial interactive oracle proofs are interactive protocols between prover and verifier where with each message, prover creates an oracle and verifier can query any oracle supplied by the prover.

Method to convince verifier that the proof generated by prover is correct.

$S(C):S_{p},S_{v}$ :- setup procedure of circuit

$S_{v}=[f_{0}],[f_{−1}],[f_{−2}]⋯[f_{−s}]$ :- $S_{v}$ consists of commitments to $s+1$ polys.

- Why does $S_{v}$ contains commitments to different polynomial?::maybe due to having different sets of polynomial for each part of circuit.
- What if prover commits to a zero polynomial? i.e. what if $f(x)=0∀x∈F_{p}$ :: then we can do zero test on polynomial. i.e. take a random point $r$ in $F_{p}$ and test whether it’s zero or not. and prob. of being zero is negligible with value $d/p$ where d is the degree of polynomial. example: $p=2_{256},d=2_{40}$
- what if prover commits to same polynomial? :: do equality test, take $r∈F_{p}$ if $f(r)=g(r)$, then $f=g$ with very high prob.
Not straightaway understandable to me tho.

- Prover sends t commitments to verifier
- verifier sends t random values to prover
- verifier runs a verify algorithm taking all the commitments and the random values, and previously generated setup summary $S_{v}$, i.e. $s+1$ commitments to polynomials.
- It can ask prover to open any of the commitment at any point.
- Verifier accepts/reject the proof.

$(t,q)$ Poly-IOP:

- $t$: no. of commitments to polynomials
- $q$: no. of eval queries in verify

- Prover sends $t$ commitments
- Verifier verifies at $q$ evaluations by running PCS eval.

Info

Length of SNARK: $t$ commitments + $q$ eval proofs

Verifier time: $q∗O(eval)+O(IOP−verify)$

Prover time: $t∗O(commit)+q∗O(prove)+O(IOP−prove)$