1. package main
2.  
3. import (
4.  "fmt"
5.  "github.com/tuneinsight/lattigo/v3/ckks"
6.  "github.com/tuneinsight/lattigo/v3/dckks"
7. )
8.  
9. func main() {
10.  // Parameters
11.  params := ckks.DefaultParams[ckks.PN12QP109]
12.  // Number of parties
13.  nbParties := 2
14.  // Number of values to encrypt
15.  nbSlots := 16
16.  
17.  // Create the CKKS scheme
18.  scheme := ckks.NewScheme()
19.  scheme.SetParams(params)
20.  
21.  // Create the distributed CKKS scheme
22.  dckksScheme := dckks.NewDCKKS(scheme)
23.  
24.  // Create the collective public key generator
25.  collectivePublicKeyGen := dckksScheme.NewCKKSCollectivePublicKeyGenerator()
26.  
27.  // Generate the collective public key
28.  collectivePublicKey := collectivePublicKeyGen.GenCollectiveKey()
29.  
30.  // Create the encryptors for each party
31.  encryptors := make([]*dckks.CKKSLocalEncryptor, nbParties)
32.  for i := range encryptors {
33.   encryptors[i] = dckksScheme.NewCKKSLocalEncryptor(collectivePublicKeyGen.LocalSecretKeys()[i])
34.  }
35.  
36.  // Create the evaluator
37.  evaluator := dckksScheme.NewCKKSEvaluator()
38.  
39.  // Create the plaintexts for each party
40.  values1 := make([]complex128, nbSlots)
41.  values2 := make([]complex128, nbSlots)
42.  for i := range values1 {
43.   values1[i] = complex(float64(i), 0)
44.   values2[i] = complex(float64(i+1), 0)
45.  }
46.  fmt.Println("Values 1:", values1)
47.  fmt.Println("Values 2:", values2)
48.  
49.  pt1 := scheme.NewPlaintext(params.MaxLevel(), params.Scale())
50.  pt2 := scheme.NewPlaintext(params.MaxLevel(), params.Scale())
51.  scheme.EncodeNTT(pt1, values1, nbSlots)
52.  scheme.EncodeNTT(pt2, values2, nbSlots)
53.  
54.  // Encrypt the plaintexts for each party
55.  ct1 := encryptors[0].EncryptNew(pt1)
56.  ct2 := encryptors[1].EncryptNew(pt2)
57.  
58.  // Add the ciphertexts
59.  ctSum := evaluator.AddNew(ct1, ct2)
60.  
61.  // Create the decryptor for each party
62.  decryptors := make([]*dckks.CKKSLocalDecryptor, nbParties)
63.  for i := range decryptors {
64.   decryptors[i] = dckksScheme.NewCKKSLocalDecryptor(collectivePublicKeyGen.LocalSecretKeys()[i])
65.  }
66.  
67.  // Decrypt the ciphertexts for each party
68.  ptShares := make([]*ckks.Plaintext, nbParties)
69.  for i := range ptShares {
70.   ptShares[i] = decryptors[i].DecryptNew(ctSum)
71.  }
72.  
73.  // Recombine the plaintext shares
74.  ptResult := scheme.NewPlaintext(params.MaxLevel(), params.Scale())
75.  evaluator.Recombine(ptShares, ptResult)
76.  
77.  // Decode the result
78.  valuesResult := make([]complex128, nbSlots)
79.  scheme.DecodeNTT(ptResult, valuesResult, nbSlots)
80.  fmt.Println("Result:", valuesResult)
81. }
82.