1. R.G.L.M Samarawickrama , D. N. Ranasinghe , T. Sritharan
Vemaque: An Approximate Verifiable Remote Computation Mechanism for K-Clique and Maximum Clique Problem
R.G.L.M Samarawickrama , D. N. Ranasinghe , T. Sritharan

2. This Study….
is about a system(Vemaque) in which client can verify the correctness of remote executions

3. Untrusted Third-Parties – one of big problem

4. A Theory Offers a Solution
Interactive proofs, Probabilistically checkable proofs and etc.
Server can create a short certificate and then client can check it to know if the server executed correctly
Very efficient in principal but not practical.

5. Recent Projects Refine and Implement the Theory
Highly reduces the client’s cost of verification (than verifying computation by re-executing)
Muggles [10]
Verified computation with streaming interactive proofs [11, 12, 13]
Pepper [17] and Ginger [18]
Zaatar [8] and Pinocchio [7]

6. Remaining Roadblocks to Bring the Theory to Practice
Works only for straight-line computations.
The client incurs a large set up cost (verification cost).
The server’s overheads are large.

7. Straight-Line Computations
Usual computation procedures with branching and cycling instructions .
Depends only on the size of initial data .
Loop bounds are known at compile time .
Ex :- multiplications of polynomials, matrices and etc.

8. Why Only Straight-Line Computations ?
Recent works handle computations by, representing the computation as equivalent set of constraints.
Straight line computations can be directly represented as set of multiplications and additions.
So, they can be compiled to a set of mathematical constraints
Thus, prior works can handle them.

9. What about NP-Complete Problems
NP-Complete(NPC) problems doesn't fall into straight line computations.
Therefore, prior works can't handle them.

10. Our Study over Prior Works
Remaining Roadblocks to Bring the Theory to Practice
Vemaque
Works only for straight-line computations.
The client incurs a large set up cost (verification cost).
The server’s overheads are large.
Reduces the gap by verifying two NP-Complete computations
Retain

11. Rest of this Talk : Vemaque’s base : Zaatar [8] and Pinocchio [7]
The mechanism and verification protocol of Vemaque
Experiment and Evaluation.

12. Vemaque’s base : Zaatar [8] and Pinocchio [7]
The underlying framework for Vemaque

13. Vemaque’s base : Zaatar [8] and Pinocchio [7]
What Vemaque borrows from Zaatar and Pinocchio
Computational model
Verification protocol

14. Computational Model
Representing the computation as set of arithmetic constraints
Computation that compare two given variables Z1 and Z2 with IF and ELSE statement
  IF (Z1 != Z2) then Z3 = 1, ELSE Z3 = 0;
Representing the above computation as set of arithmetic constraints is as follows.
M . (Z1 - Z2) - Z3 = 0 for some value M
(1 - Z3) .(Z1 - Z2) = 0
  M equals to the multiplicative inverse of Z1 - Z2 if Z1! = Z2.

15. Verification Protocol
Probabilistically checkable proofs - Check the validity of π approximately by inspecting a small number of randomly-chosen locations to accept or reject output.

16. Vemaque over Zaatar Pinocchio
Zaatar and Pinocchio
Handle only straight line computations
Handle a restricted class of computations
Vemaque
Handle two NP-Complete computations (K-clique and Maximum clique Computation)
Fine tuned for only two computations

17. The Mechanism

18. K-Clique and Maximum Clique Problem
Vemaque handles verification for k-clique problem and maximum clique problem, happen outside the client machine approximately.
For an undirected graph G = (V, E)
K-clique problem (KCLQ) is to find k number of vertices VC⊆ V, any two of which are adjacent.
Maximum clique problem (MCLQ) is to find the largest number of vertices VC⊆ V, any two of which are adjacent.

19. Mechanism
The mechanism of Vemaque can be described by 7 steps.

20. Mechanism – Step 1
1. Client represents the computation F as arithmetic constraint C. C' for k-clique and C“ maximum clique problem.

21. Mechanism – Step 1 : Arithmetic Constraint C’
Suppose VC⊆ V is a clique of size k, found for a given undirected graph G = (V, E) and GC= (VC, EC) is a complete sub graph in G where VC is the set of vertices. Vemaque introduces the arithmetic constraint C' for k-clique problem as follows.
ECSum + (E-EC)Sum= ESum (C’)
C' is a sufficient condition to be satisfied if the output VC is a clique of size k. Satisfying C' doesn't mean that VC is a clique. But, if C' is not satisfied, then VC is not definitely a clique.

22. Mechanism – Step 1 : Arithmetic Constraint C”
Derived from the results proven in theoretical computing : finding maximum clique for an undirected graph corresponds to find the minimum vertex cover for the complement of that graph .
Suppose VC⊆ V is the maximum clique for an undirected graph G = (V, E) and Graph G'= (V, E') is the complement of graph G and G" = (V, E") is the complete graph of G .Vemaque introduces the arithmetic constraint C" for maximum clique computation.
ESum + E'FacSum = E"sum (C")
C” is a sufficient condition to be satisfied if the output VC is the maximum clique. Satisfying C” doesn't mean that VC is the maximum clique. But, if C” is not satisfied, then VC is not definitely the maximum clique.

23. Mechanism – Step 2
2.Server (Prover) also represents F as arithmetic constraint C and performs the computation.(We used Bron and Kerbosch Algorithm to find the maximum clique since it guaranteed to find the maximum clique)

24. Mechanism – Step 3
3. If output is not empty, client starts the interactive session with server. For that, client generate a unique random prime number for each and every vertex in G (Vertex-Random prime set R1) and sends it to server.

25. Mechanism – Step 3: Vertex-Random Prime Set
Let V= {v1, v2, v3, v4, v5, v6} and E = {(v1, v2), (v1, v3), (v1, v4), (v2, v3), (v2, v4), (v3, v4), (v3, v5), (v4, v6), (v5, v6)} of a graph G=(V,E).
Let R = {3, 7, 11, 19, 23, 29} and a Vertex-Random prime set can be generated as follows.
v1 => 3, v2 => 7, v3 => 11, v4 => 19, v5 => 23, v6 => 29

26. Mechanism – Step 4
4. Server satisfies the constraint C for R1,input X and output Y and encodes satisfied C to a string π1 and sends it to client.

27. Mechanism – Step 4 : Satisfying C’ (Case 1)
Input G=(V,E) V= {v1, v2, v3, v4, v5, v6} and E = {(v1, v2), (v1, v3), (v1, v4), (v2, v3), (v2, v4), (v3, v4), (v3, v5), (v4, v6), (v5, v6)}
Let , Output = VC = {v1, v2, v3, v4}
And R = {3, 7, 11, 19, 23, 29}
ECSum + (E-EC)Sum = ESum
{(v3, v5), (v4, v6), (v5, v6) }Sum = 254
{(v3, v5)Val + (v4, v6)Val + (v5, v6)Val } = 254
{(11+23) + (19+29) + (23+29)} = 254

28. Mechanism – Step 4 : Satisfying C” (Case 2)
Input G=(V,E) V= {v1, v2, v3, v4, v5, v6} and E = {(v1, v2), (v1, v3), (v1, v4), (v2, v3), (v2, v4), (v3, v4), (v3, v5), (v4, v6), (v5, v6)}
Let , Output = VC = {v1, v2, v3, v4}
And R = {3, 7, 11, 19, 23, 29}
= (ESum + E'FacSum = E"sum)
= 206 (E'FacSum = (v5)facVal +(v6)facVal )
3*23 + (3+7+19) = 98 (v5)facVal
3*29 + (3+7+11) = (v6)facVal

29. Mechanism – Step 5
5. Client checks the validity of π1 using probabilistically checkable proofs – Verification protocol. If π1 passes all checks done by client, client generates another Vertex-Random prime set R2 and sends it server to start the second iteration. Otherwise, client rejects the output with probability 1

30. Mechanism – Step 6
6. Step 4 is repeated for R2

31. Mechanism – Step 6 : Why Two Iterations
Assume a scenario where server uses a wrong logic to do the computation and the result derived from that wrong logic accidently satisfies the constraint.
At that time, if Vemaque uses only one iteration, the result is verified as valid although the logic is incorrect.
But, if Vemaque can use more than one iteration, Vemaque can reduce the possibility of verifying incorrect results as valid.
Likewise, Vemaque can achieve a higher accuracy by using more iterations.
But when we increase the number of iterations, it directly effects on verification cost of the client.
So, we set the number of iteration to two to obtain a higher accuracy with a reasonable client performance.

32. Mechanism – Step 7
7. Verification process of π2(encoded satisfied constraint for R2) is same as in step 5. If π2 passes all checks done by client, client accepts output with probability 1-ɛ where ɛ can be made small. Otherwise, client rejects the output with probability 1. Our experimental results have shown that ɛ can be made so small.

33. Mechanism – Summary
Vemaque holds the soundness and completeness properties since it uses probabilistically checkable proofs to check the validity of π1 and π2.
Completeness: If output is correct, Vemaque allows server to convince the client with probability 1.
Soundness: Otherwise, server can convince verifier with very lower probability ɛ. In Vemaque, we have experimentally shown that ɛ< for both k-clique and maximum clique computations.

34. Experiment and Evaluation

35. Set up for the Experiment
Implemented server on one machine and the client on another.

36. Evaluation of K-clique Computation
34 graphs from the well-known DIMACS benchmark set [21] and 24 random graphs generated by a sequential Algorithm [22] for the test set.

37. Experimental result of k-clique computation for 58 instances
Instance(G) k
Solved
Nodes
Edges
Time(mills)
Verify
Random_1 4
yes 15 63 43
Random_2 6
123
Random_3 7 65
Random_4 30 31
473 84
Random_5 16 34
471
300
Random_6 9 38
501
344
Random_7 25 51
612
107
Random_8
140
Random_9 19 60
701
383
Random_10 23 67
754
388
Random_11 29 52
1228
615
Random_12 37 55
1301
518
Random_13 50 61
1402
423
Random_14
533
Random_15 33 68
1615
833
Random_16 47 73
1708
844
Random_17 77
1912
943
Random_18
116
1347
760
Random_19 71
688
Random_20
100
102
4970
664
Random_21
503
28360
1182
Random_22 57
600
30228
1097
Random_23
810
41195
1321
Random_24
101
1000
50623
1754
C125.9 32
125
6963
749
C250.9 41
250
27984
1558
1763
C500.9
500
112332
3874
C1000.9
450079
18365 C
crashed
2000
999836 -
DSJC500_5
115248
3459 no
1512
brock200_2 11
yes
200
9876
1165
brock200_4 8
13089
1596
brock400_2 28
400
59786
1703
brock400_4 17
59765
2317
brock800_2 21
800
208166
5312
brock800_4 19
207643
4329 33 no
1156 -
gen200_p0.9_44 41
17910
1234
gen200_p0.9_55 55
1621
gen400_p0.9_55
71820
2904
gen400_p0.9_65 63
2767 59
3367
gen400_p0.9_75 74
2532
hamming10-4 37
1024
434176
13911
hamming8-4
256
20864
1501
keller4
171
9435
885
keller5 23
776
225990
3190
p_hat300-1 5
300
10933
2245
p_hat300-2 6
21928
1567
p_hat300-3 29
33390
1730
p_hat700-1 10
700
60999
3308
p_hat700-2
121728
3065
p_hat700-3 62
183010
4000
p_hat1500-1
1500
284923
5615
p_hat1500-2 35
568960
7760
Experimental result of k-clique computation for 58 instances

38. Accuracy
Accuracy = Number of correctly verified instances / Number of verified instances
= 54 / 55 =
Vemaque allows client to accept the wrong answers with ( ) for k-clique computation.

39. Accuracy after the First Iteration
Accuracy = Number of correctly verified instances / Number of verified instances
= 54 / 55
= (= – Accuracy after the second iteration)

40. Set up cost of Client (Verification Cost)
Consists of three polynomial time computations for a given graph G=(V,E)
producing Vertex-Random prime set - O (|V|)
computing ESum - O (|E|)
probabilistic checking - O (|E-EC |)
Time complexity = (O (|V|) + O (|E|) + O (|E-EC|))
= O (|V|) + O (|E|) since O (|E|) dominates O (|E-EC|)
= O (|V+E|)

41. Verification Time Against the Number of Edges

42. Power of Vemaque
Verification takes less than 20s for graphs with more than 1000 vertices and 250,000 edges
Instance(G) k
Clique_found
Nodes
Edges
Time(mills)
p_hat1500-1 11
yes
1500
284923
5615 (5.65s)
p_hat1500-2 35
568960
7760 (7.76s)
hamming10-4 37
1024
434176
13911(13.91s)
C1000.9 68
1000
450079
18365 (18.36s)

43. Limitation of Vemaque
When the size of graph increases in terms of number of edges, Vemaque stops execution after some graph size.
In our set up, Vemaque worked for a graph with 2,134,530 edges and 5000 nodes without crashing
Instance(G) k
Clique_found
Nodes
Edges
Time(mills)
Random_big_1
100
yes
5000
850210
23112 (23.112s)
Random_big_2
37638 (37.76s)
Random_big_3
73911(73.91s)
Random_big_4
163507( s)

44. Evaluation of Maximum Clique Computation
28 graphs from the well-known DIMACS benchmark set [21] and 27 random graphs generated by a sequential Algorithm [22] for the test set.

45. Experimental result of maximum clique computation (55 instances)
Instance(G)
Max_Clique
Nodes
Edges
Time
(mills)
Verify
random_0 2 1 34
yes
random_1 6 15 63
170
random_2 31 49
196
random_3 10 40
112
215
random_4 13 25
160
223
random_5 21 33
273
227
random_6 36
372
254
random_7 30 50
435 81 no
random_8
455
261
random_9
567
409
random_10 53
612
345
random_11 37 64
762
355
random_12 51
1227
765
random_13 60
1325
357
random_14 52
1412
368
random_15 55
100
1315
501
random_16 73
1815
812
random_17 67 80
2318
763
random_18
116
1429
629
random_19 84
2803
811
random_20
102
4970
1287
random_21
150
5012
2936
random_22
121
400
26512
1798
random_23
110
503
28360
1823
random_24
600
30228
2244
random_25
101
810
41195
3793
random_26
1000
50623
6127
c125.9
125
6963
1168
c250.9 44
250
27984
1734
c500.9
500
112332
10201
c1000.9 68
450079
34400
dsjc500_5
115248
8120
brock200_2 12
200
9876
976
brock200_4 17
13089
1709
brock400_2 29
59786
4079
gen200_p0.9_44 44
200
17910
1213
yes
gen200_p0.9_55 55
1103
gen400_p0.9_55
400
71820
7650
gen400_p0.9_65 65
8653
gen400_p0.9_75 75
7612
hamming10-4 40
1024
434176
27823
hamming8-4 16
256
20864
1635
keller4 11
171
9435
1280
keller5 27
776
225990
15560
p_hat300-1 8
300
10933
1611
p_hat300-2 25
21928
1583
p_hat300-3 36
33390
2340
p_hat700-1
700
60999
4918
p_hat700-2
121728
10040
p_hat700-3 62
183010
11448
p_hat1500-3 -
1500
847244
p_hat1500-1 12
284923
16524
Experimental result of maximum clique computation (55 instances)

46. Accuracy
Accuracy = Number of correctly verified instances / Number of verified instances
= 53 / 54 =
Vemaque allows client to accept the wrong answers with ( ) for maximum clique computation.

47. Accuracy after the First Iteration
Accuracy = Number of correctly verified instances / Number of verified instances
= 52 / 54
= (< – Accuracy after the second iteration)

48. Set up cost of Verifier (Verification cost)
Consists of three polynomial time computations for a given graph G=(V,E)
producing Vertex-Random prime set - O (|V|)
computing ESum - O (|E|)
probabilistic checking - O (|E’ |)
Time complexity = O (|V| + |E| + |E'|)
= O (|V| + |E"|) since |E"| = |E'| + |E|
= O (|V| + |V|2 ) since |E"| = (|V|*|V|-1) /2
= O (|V|2)

49. Verification time against the Number of Vertices

50. Power of Vemaque
Verification takes less than 40s for graphs with more than 1000 vertices
Instance(G)
Max_Clique
Node
Edges
Time(mills)
Verification
random_26
101
1000
50623
6127(6.127s)
yes
c1000.9 68
450079
34400 (34.4s)
hamming10-4 40
1024
434176
27823 (27.823s)
p_hat1500-1 12
1500
284923
16524 (16.524)

51. Limitation of Vemaque
When the size of graph increases in terms of number of vertices, Vemaque stops execution after some graph size.
In our set up, Vemaque worked for a graph with 9112 nodes and 2,134,530 edges without crashing.
Instance(G)
Max_Clique
Nodes
Edges
Time(mills)
Random_big_1
100
5000
1,200,046
73245 (73.245s)
Random_big_2
6000
97386 (97.38s)
Random_big_3
8000
137,391(137.39s)
Random_big_4
9112
183705( s)

52. Summary and Conclusion
Vemaque extends the concept of verifiable remote computation towards verifying two NP- Complete (NPC) computations that are not handled in prior work
The experimental results show that Vemaque achieves more than 98% of accuracy for the verification of both k-clique and maximum clique problem and a reasonable set up cost for a range of graph sizes (around 10,000 nodes with 2,000,000 edges).
And also Vemaque has some limitations : When the size of graph increases, the performance degrades and Vemaque doesn't work after some point of the graph size depending on the configuration of client machine.
In conclusion, there is a great deal of work remaining to bring verifiable computation to practice in terms of reducing client's verification cost , expanding the class of computation that can be handled in the verification and etc. But Vemaque is a significant step towards that goal.

53. References

54. Thank You……
Vemaque