Lattigo

https://pkg.go.dev/github.com/tuneinsight/lattigo/v4
Admin
Lattigo is a Go library that implements Ring-Learning-With-Errors-based homomorphic encryption...
Tokens:180,383
Snippets:1,021
Trust Score:9.6
Update:6 months ago
Show doc for...
Tokens:
Raw
### Define Bootstrapping Parameters

Source: https://pkg.go.dev/github.com/tuneinsight/lattigo/v4/ckks/bootstrapping

Examples of defining default bootstrapping parameter literals for various security and precision configurations.

```go
N15QP768H192H32 = defaultParametersLiteral{
		ckks.ParametersLiteral{
			LogN:  15,
			Sigma: rlwe.DefaultSigma,
			H:     192,
			Q: []uint64{
				0x1fff90001,
				0x4000000420001,
				0x1fc0001,
				0xffffffffffc0001,
				0x4000000120001,
				0x40000001b0001,
				0x3ffffffdf0001,
				0x4000000270001,
				0x3ffffffd20001,
				0x3ffffffcd0001,
				0x4000000350001,
				0x3ffffffc70001,
				0x1fffffff50001,
				0x1ffffffea0001,
			},
			P: []uint64{
				0x7fffffffe0001,
				0x8000000110001,
			},
			LogSlots:     14,
			DefaultScale: 1 << 25,
		},

		Parameters{
			EphemeralSecretWeight: 32,
			SlotsToCoeffsParameters: advanced.EncodingMatrixLiteral{
				LinearTransformType: advanced.SlotsToCoeffs,
				RepackImag2Real:     true,
				LevelStart:          3,
				BSGSRatio:           2.0,
				BitReversed:         false,
				ScalingFactor: [][]float64{
					{1073741823.9998779, 1073741823.9998779},
				},
			},
			EvalModParameters: advanced.EvalModLiteral{
				Q:             0x1fff90001,
				LevelStart:    11,
				SineType:      advanced.Cos1,
				MessageRatio:  256.0,
				K:             16,
				SineDeg:       30,
				DoubleAngle:   3,
				ArcSineDeg:    0,
				ScalingFactor: 1 << 50,
			},
			CoeffsToSlotsParameters: advanced.EncodingMatrixLiteral{
				LinearTransformType: advanced.CoeffsToSlots,
				RepackImag2Real:     true,
				LevelStart:          13,
				BSGSRatio:           2.0,
				BitReversed:         false,
				ScalingFactor: [][]float64{
					{0x1fffffff50001},
					{0x1ffffffea0001},
				},
			},
		},
	}
```

```go
N16QP1767H32768H32 = defaultParametersLiteral{
		ckks.ParametersLiteral{
			LogN:  16,
			Sigma: rlwe.DefaultSigma,
			H:     32768,
			Q: []uint64{
				0x10000000006e0001,
				0x10000140001,
				0xffffe80001,
				0xffffc40001,
				0x100003e0001,
				0xffffb20001,
				0x10000500001,
				0xffff940001,
				0xffff8a0001,
				0xffff820001,
				0xffff780001,
				0x10000960001,
				0x10000a40001,
				0xffff580001,
				0x7fffe60001,
				0x7fffe40001,
				0x7fffe00001,
				0xfffffffff840001,
				0x1000000000860001,
				0xfffffffff6a0001,
				0x1000000000980001,
				0xfffffffff5a0001,
				0x1000000000b00001,
				0x1000000000ce0001,
				0xfffffffff2a0001,
				0x100000000060001,
				0xfffffffff00001,
				0xffffffffd80001,
				0x1000000002a0001,
			},
			P: []uint64{
				0x1fffffffffe00001,
				0x1fffffffffc80001,
				0x1fffffffffb40001,
				0x1fffffffff500001,
				0x1fffffffff420001,
				0x1fffffffff380001,
			},
			LogSlots:     15,
			DefaultScale: 1 << 40,
		},

		Parameters{
			EphemeralSecretWeight: 32,
			SlotsToCoeffsParameters: advanced.EncodingMatrixLiteral{
				LinearTransformType: advanced.SlotsToCoeffs,
				RepackImag2Real:     true,
				LevelStart:          16,
				BSGSRatio:           2.0,
				BitReversed:         false,
				ScalingFactor: [][]float64{
					{0x7fffe60001},
					{0x7fffe40001},
					{0x7fffe00001},
				},
			},
			EvalModParameters: advanced.EvalModLiteral{
				Q:             0x10000000006e0001,
```

--------------------------------

### Trace Evaluator Method

Source: https://pkg.go.dev/github.com/tuneinsight/lattigo/v4/rlwe

Maps X to the sum of its trace components. Includes examples of the trace operation steps.

```go
func (eval *Evaluator) Trace(ctIn *Ciphertext, logN int, ctOut *Ciphertext)
```

```text
  [1 + 2X + 3X^2 + 4X^3 + 5X^4 + 6X^5 + 7X^6 + 8X^7]
+ [1 - 6X - 3X^2 + 8X^3 + 5X^4 + 2X^5 - 7X^6 - 4X^7]  {X-> X^(i * 5^1)}
= [2 - 4X + 0X^2 +12X^3 +10X^4 + 8X^5 - 0X^6 + 4X^7]
```

```text
  [2 - 4X + 0X^2 +12X^3 +10X^4 + 8X^5 - 0X^6 + 4X^7]
+ [2 + 4X + 0X^2 -12X^3 +10X^4 - 8X^5 + 0X^6 - 4X^7]  {X-> X^(i * 5^2)}
= [4 + 0X + 0X^2 - 0X^3 +20X^4 + 0X^5 + 0X^6 - 0X^7]
```

```text
  [4 + 0X + 0X^2 - 0X^3 +20X^4 + 0X^5 + 0X^6 - 0X^7]
+ [4 + 0X + 0X^2 - 0X^3 -20X^4 + 0X^5 + 0X^6 - 0X^7]  {X-> X^(i * -1)}
= [8 + 0X + 0X^2 - 0X^3 + 0X^4 + 0X^5 + 0X^6 - 0X^7]
```

--------------------------------

### Get Ring Type

Source: https://pkg.go.dev/github.com/tuneinsight/lattigo/v4/ring

Returns the ring type, which can be Standard or ConjugateInvariant.

```go
func (r *Ring) Type() Type
```

--------------------------------

### Create Parameters

Source: https://pkg.go.dev/github.com/tuneinsight/lattigo/v4/rlwe

Initializes parameters from ring degree, moduli, and distribution parameters.

```go
func NewParameters(logn int, q, p []uint64, pow2Base, h int, sigma float64, ringType ring.Type, defaultScale Scale, defaultNTTFlag bool) (Parameters, error)
```

--------------------------------

### Get Default Scale

Source: https://pkg.go.dev/github.com/tuneinsight/lattigo/v4/rlwe

Returns the default scale configured for the parameters.

```go
func (p Parameters) DefaultScale() Scale
```

--------------------------------

### Instantiate DomainSwitcher

Source: https://pkg.go.dev/github.com/tuneinsight/lattigo/v4/ckks

Creates a new DomainSwitcher instance. Returns an error if parameters do not support switching.

```go
func NewDomainSwitcher(params Parameters, comlexToRealSwk, RealToComplexSwk *rlwe.SwitchingKey) (DomainSwitcher, error)
```

--------------------------------

### Get Default NTT Flag

Source: https://pkg.go.dev/github.com/tuneinsight/lattigo/v4/rlwe

Returns the default NTT flag for the parameters.

```go
func (p Parameters) DefaultNTTFlag() bool
```

--------------------------------

### Get Scaling Factor

Source: https://pkg.go.dev/github.com/tuneinsight/lattigo/v4/ckks/advanced

Retrieves the scaling factor used during EvalMod operations.

```go
func (evp *EvalModPoly) ScalingFactor() rlwe.Scale
```

--------------------------------

### Initialize S2EProtocol

Source: https://pkg.go.dev/github.com/tuneinsight/lattigo/v4/dbfv

Creates a new S2EProtocol instance.

```go
func NewS2EProtocol(params bfv.Parameters, sigmaSmudging float64) *S2EProtocol
```

--------------------------------

### Get Polynomial Level

Source: https://pkg.go.dev/github.com/tuneinsight/lattigo/v4/ring

Returns the current number of moduli minus 1 for the polynomial.

```go
func (pol *Poly) Level() int
```

--------------------------------

### Create PRNGEncryptor

Source: https://pkg.go.dev/github.com/tuneinsight/lattigo/v4/rlwe

Instantiates a new PRNGEncryptor.

```go
func NewPRNGEncryptor(params Parameters, key *SecretKey) PRNGEncryptor
```

--------------------------------

### Bootstrapper.CheckKeys Method

Source: https://pkg.go.dev/github.com/tuneinsight/lattigo/v4/ckks/bootstrapping

Verifies that all required keys are present in the Bootstrapper instance.

```go
func (bb Bootstrapper) CheckKeys(btpKeys EvaluationKeys) (err error)
```

--------------------------------

### Get Galois Elements for Merge

Source: https://pkg.go.dev/github.com/tuneinsight/lattigo/v4/rlwe

Returns the Galois elements required for the Merge operation.

```go
func (p Parameters) GaloisElementsForMerge() (galEls []uint64)
```

--------------------------------

### Get Galois Elements for Expand

Source: https://pkg.go.dev/github.com/tuneinsight/lattigo/v4/rlwe

Returns the Galois elements required for the Expand operation.

```go
func (p Parameters) GaloisElementForExpand(logN int) (galEls []uint64)
```

--------------------------------

### Initialize RefreshProtocol

Source: https://pkg.go.dev/github.com/tuneinsight/lattigo/v4/dbfv

Creates a new instance of the Refresh protocol.

```go
func NewRefreshProtocol(params bfv.Parameters, sigmaSmudging float64) (rfp *RefreshProtocol)
```

--------------------------------

### NewBootstrapper

Source: https://pkg.go.dev/github.com/tuneinsight/lattigo/v4/ckks/bootstrapping

Initializes a new Bootstrapper instance for the CKKS scheme.

```APIDOC
## func NewBootstrapper

### Description
Creates a new instance of the Bootstrapper using the provided CKKS parameters, bootstrapping parameters, and evaluation keys.

### Parameters
- **params** (ckks.Parameters) - Required - The CKKS scheme parameters.
- **btpParams** (Parameters) - Required - The bootstrapping specific parameters.
- **btpKeys** (EvaluationKeys) - Required - The evaluation keys required for bootstrapping.

### Returns
- **btp** (*Bootstrapper) - The initialized bootstrapper instance.
- **err** (error) - Error object if initialization fails.
```

--------------------------------

### Get Rotations for LinearTransform

Source: https://pkg.go.dev/github.com/tuneinsight/lattigo/v4/bgv

Returns the list of rotations required for evaluating the linear transform.

```go
func (LT *LinearTransform) Rotations() (rotations []int)
```

--------------------------------

### Create Parameters from Literal

Source: https://pkg.go.dev/github.com/tuneinsight/lattigo/v4/rlwe

Instantiates parameters from a ParametersLiteral specification.

```go
func NewParametersFromLiteral(paramDef ParametersLiteral) (Parameters, error)
```

--------------------------------

### Get Galois Elements for Inner Sum

Source: https://pkg.go.dev/github.com/tuneinsight/lattigo/v4/rlwe

Returns all Galois elements required for an InnerSum operation.

```go
func (p Parameters) GaloisElementsForRowInnerSum() (galEls []uint64)
```

--------------------------------

### Create new Thresholdizer instance

Source: https://pkg.go.dev/github.com/tuneinsight/lattigo/v4/drlwe

Initializes and returns a new Thresholdizer instance using the provided rlwe.Parameters.

```go
func NewThresholdizer(params rlwe.Parameters) *Thresholdizer
```

--------------------------------

### Get Galois Element for Column Rotation

Source: https://pkg.go.dev/github.com/tuneinsight/lattigo/v4/rlwe

Calculates the Galois element for rotating plaintext columns.

```go
func (p Parameters) GaloisElementForColumnRotationBy(k int) uint64
```

--------------------------------

### Parameters Struct

Source: https://pkg.go.dev/github.com/tuneinsight/lattigo/v4/ckks/bootstrapping

Defines the configuration structure for default bootstrapping parameters.

```APIDOC
## Parameters Struct

### Description
Represents the default bootstrapping parameters for the CKKS scheme.

### Fields
- **SlotsToCoeffsParameters** (advanced.EncodingMatrixLiteral) - Parameters for slots to coefficients encoding.
- **EvalModParameters** (advanced.EvalModLiteral) - Parameters for evaluation modular reduction.
- **CoeffsToSlotsParameters** (advanced.EncodingMatrixLiteral) - Parameters for coefficients to slots encoding.
- **EphemeralSecretWeight** (int) - Hamming weight of the ephemeral secret. If 0, no ephemeral secret is used.
```

--------------------------------

### Get Linear Transform Rotations

Source: https://pkg.go.dev/github.com/tuneinsight/lattigo/v4/ckks

Retrieves the list of rotations required for evaluating a linear transform.

```APIDOC
## func (*LinearTransform) Rotations

### Description
Rotations returns the list of rotations needed for the evaluation of the linear transform.

### Method
func (LT *LinearTransform)

### Endpoint
N/A

### Parameters
#### Path Parameters
N/A

#### Query Parameters
N/A

#### Request Body
N/A

### Request Example
N/A

### Response
#### Success Response (200)
- **rotations** ([]int) - The list of rotations needed for evaluation.

#### Response Example
N/A
```

--------------------------------

### Instantiate CKKS Parameters

Source: https://pkg.go.dev/github.com/tuneinsight/lattigo/v4/ckks

Creates a new set of CKKS parameters from generic RLWE parameters and CKKS-specific settings.

```go
func NewParameters(rlweParams rlwe.Parameters, logSlots int) (p Parameters, err error)
```

--------------------------------

### Get Galois Element for Row Rotation

Source: https://pkg.go.dev/github.com/tuneinsight/lattigo/v4/rlwe

Returns the Galois element for generating row rotation automorphisms.

```go
func (p Parameters) GaloisElementForRowRotation() uint64
```

--------------------------------

### Generate and Get S2E Encryption

Source: https://pkg.go.dev/github.com/tuneinsight/lattigo/v4/dbfv

Methods to generate shares and compute the final encryption for the S2E protocol.

```go
func (s2e *S2EProtocol) GenShare(sk *rlwe.SecretKey, crp drlwe.CKSCRP, secretShare *rlwe.AdditiveShare, c0ShareOut *drlwe.CKSShare)
```

```go
func (s2e *S2EProtocol) GetEncryption(c0Agg *drlwe.CKSShare, crp drlwe.CKSCRP, ctOut *rlwe.Ciphertext)
```

--------------------------------

### New KeyedPRNG

Source: https://pkg.go.dev/github.com/tuneinsight/lattigo/v4/utils

Creates a new KeyedPRNG instance. Accepts an optional key. WARNING: Initializing with key=nil is insecure.

```go
func NewKeyedPRNG(key []byte) (*KeyedPRNG, error)
```

--------------------------------

### Create new BGV Parameters

Source: https://pkg.go.dev/github.com/tuneinsight/lattigo/v4/bgv

Instantiates BGV parameters from generic RLWE parameters and BGV-specific ones. Returns an error for invalid parameters.

```go
func NewParameters(rlweParams rlwe.Parameters, t uint64) (p Parameters, err error)
```

--------------------------------

### Create a new SwitchingKey

Source: https://pkg.go.dev/github.com/tuneinsight/lattigo/v4/rlwe

Initializes a new public switching key with pre-allocated zero-values based on the provided parameters and levels.

```go
func NewSwitchingKey(params Parameters, levelQ, levelP int) *SwitchingKey
```

--------------------------------

### Create New PolynomialBasis

Source: https://pkg.go.dev/github.com/tuneinsight/lattigo/v4/ckks

Initializes a new PolynomialBasis to generate powers of a monomial.

```go
func NewPolynomialBasis(ct *rlwe.Ciphertext, basistype BasisType) (p *PolynomialBasis)
```

--------------------------------

### Get Polynomial Coefficient Count (Poly)

Source: https://pkg.go.dev/github.com/tuneinsight/lattigo/v4/ring

N returns the number of coefficients of the polynomial, which equals the degree of the Ring cyclotomic polynomial.

```go
func (pol *Poly) N() int
```

--------------------------------

### Get Binary Size for 64-bit Encoding

Source: https://pkg.go.dev/github.com/tuneinsight/lattigo/v4/ring

Returns the number of bytes the polynomial will occupy when encoded using 8 bytes per coefficient.

```go
func (pol *Poly) MarshalBinarySize64() (cnt int)
```

--------------------------------

### Bootstrapper.ShallowCopy Method

Source: https://pkg.go.dev/github.com/tuneinsight/lattigo/v4/ckks/bootstrapping

Creates a shallow copy of the Bootstrapper, sharing read-only data structures and reallocating temporary buffers. Allows concurrent use.

```go
func (btp *Bootstrapper) ShallowCopy() *Bootstrapper
```

--------------------------------

### SwitchingKey Methods

Source: https://pkg.go.dev/github.com/tuneinsight/lattigo/v4/rlwe

Methods for creating and managing SwitchingKey objects.

```APIDOC
## SwitchingKey Methods

### Description
Methods for creating, copying, comparing, and serializing SwitchingKey objects.

### Methods

- `NewSwitchingKey(params Parameters, levelQ, levelP int) *SwitchingKey`: Creates a new SwitchingKey.
- `CopyNew() *SwitchingKey`: Creates a new SwitchingKey by copying the current one.
- `Equals(other *SwitchingKey) bool`: Checks if two SwitchingKeys are equal.
- `MarshalBinary() (data []byte, err error)`: Marshals the SwitchingKey into binary format.
- `UnmarshalBinary(data []byte) (err error)`: Unmarshals a SwitchingKey from binary format.
```

--------------------------------

### Get Binary Size for 32-bit Encoding

Source: https://pkg.go.dev/github.com/tuneinsight/lattigo/v4/ring

Returns the number of bytes the polynomial will occupy when encoded using 4 bytes per coefficient.

```go
func (pol *Poly) MarshalBinarySize32() (cnt int)
```

--------------------------------

### NewBootstrapper Function

Source: https://pkg.go.dev/github.com/tuneinsight/lattigo/v4/ckks/bootstrapping

Creates a new Bootstrapper instance. Requires CKKS parameters, bootstrapping parameters, and evaluation keys.

```go
func NewBootstrapper(params ckks.Parameters, btpParams Parameters, btpKeys EvaluationKeys) (btp *Bootstrapper, err error)
```

--------------------------------

### Buffer Get Bytes

Source: https://pkg.go.dev/github.com/tuneinsight/lattigo/v4/utils

Returns the underlying byte slice of the Buffer. Note: This method creates a new byte buffer, implying a copy.

```go
func (b *Buffer) Bytes() []byte
```

--------------------------------

### Default Parameter Collections

Source: https://pkg.go.dev/github.com/tuneinsight/lattigo/v4/bfv

Slices containing default parameter sets for classic and post-quantum security settings.

```go
var DefaultParams = []ParametersLiteral{PN11QP54, PN12QP109, PN13QP218, PN14QP438, PN15QP880}
```

```go
var DefaultPostQuantumParams = []ParametersLiteral{PN12QP101pq, PN13QP202pq, PN14QP411pq, PN15QP827pq}
```

--------------------------------

### Define LinearTransformType in Go

Source: https://pkg.go.dev/github.com/tuneinsight/lattigo/v4/ckks/advanced

Defines LinearTransformType as an integer type to distinguish different linear transformations. No specific setup is required beyond this definition.

```go
type LinearTransformType int
```

--------------------------------

### Copy a SwitchingKey

Source: https://pkg.go.dev/github.com/tuneinsight/lattigo/v4/rlwe

Creates and returns a deep copy of an existing SwitchingKey instance.

```go
func (swk *SwitchingKey) CopyNew() *SwitchingKey
```

--------------------------------

### Get Share for E2S Protocol

Source: https://pkg.go.dev/github.com/tuneinsight/lattigo/v4/dbgv

Performs masked decryption and removes the caller's secret share. Used to obtain an additive sharing of the message.

```go
func (e2s *E2SProtocol) GetShare(secretShare *rlwe.AdditiveShare, aggregatePublicShare *drlwe.CKSShare, ct *rlwe.Ciphertext, secretShareOut *rlwe.AdditiveShare)
```

--------------------------------

### Define SineType in Go

Source: https://pkg.go.dev/github.com/tuneinsight/lattigo/v4/ckks/advanced

Defines SineType as a uint64 type for functions used in homomorphic modular reduction during bootstrapping. No specific setup is required beyond this definition.

```go
type SineType uint64
```

--------------------------------

### Serialize Parameters

Source: https://pkg.go.dev/github.com/tuneinsight/lattigo/v4/ckks/bootstrapping

Methods for encoding and decoding bootstrapping parameters to and from byte slices.

```go
func (p *Parameters) MarshalBinary() (data []byte, err error)
```

```go
func (p *Parameters) UnmarshalBinary(data []byte) (err error)
```

--------------------------------

### Generate NTT Friendly Primes (Power of 2)

Source: https://pkg.go.dev/github.com/tuneinsight/lattigo/v4/ring

Generates NTT-friendly primes starting from 2**LogP downwards. Seeks primes with bit-sizes smaller than LogP.

```go
func GenerateNTTPrimesP(logP, NthRoot, n int) (primes []uint64)
```

--------------------------------

### SwitchingKey Creation and Manipulation

Source: https://pkg.go.dev/github.com/tuneinsight/lattigo/v4/rlwe

Functions for creating, copying, and comparing SwitchingKeys.

```APIDOC
## func NewSwitchingKey

### Description
NewSwitchingKey returns a new public switching key with pre-allocated zero-value.

### Method
func

### Endpoint
N/A

### Parameters
#### Path Parameters
N/A

#### Query Parameters
N/A

#### Request Body
N/A

### Request Example
N/A

### Response
#### Success Response (200)
N/A

#### Response Example
N/A

## func (*SwitchingKey) CopyNew

### Description
CopyNew creates a deep copy of the target SwitchingKey and returns it.

### Method
func (*SwitchingKey)

### Endpoint
N/A

### Parameters
#### Path Parameters
N/A

#### Query Parameters
N/A

#### Request Body
N/A

### Request Example
N/A

### Response
#### Success Response (200)
N/A

#### Response Example
N/A

## func (*SwitchingKey) Equals

### Description
Equals checks two SwitchingKeys for equality.

### Method
func (*SwitchingKey)

### Endpoint
N/A

### Parameters
#### Path Parameters
N/A

#### Query Parameters
N/A

#### Request Body
N/A

### Request Example
N/A

### Response
#### Success Response (200)
N/A

#### Response Example
N/A
```

--------------------------------

### Bootstrapper.Bootstrap Method

Source: https://pkg.go.dev/github.com/tuneinsight/lattigo/v4/ckks/bootstrapping

Re-encrypts a ciphertext to a lower level. Input scale constraints apply based on the ciphertext's level.

```go
func (btp *Bootstrapper) Bootstrap(ctIn *rlwe.Ciphertext) (ctOut *rlwe.Ciphertext)
```

--------------------------------

### BRedParams (Binary Reduction Parameters)

Source: https://pkg.go.dev/github.com/tuneinsight/lattigo/v4/ring

Generates parameters for the BRed algorithm. Returns ((2^128)/q)/(2^64) and (2^128)/q mod 2^64.

```go
func BRedParams(q uint64) (params []uint64)
```

--------------------------------

### GaussianSampler structure and initialization

Source: https://pkg.go.dev/github.com/tuneinsight/lattigo/v4/ring

Sampler for generating truncated Gaussian polynomials.

```go
type GaussianSampler struct {
	// contains filtered or unexported fields
}
```

```go
func NewGaussianSampler(prng utils.PRNG, baseRing *Ring, sigma float64, bound int) *GaussianSampler
```

--------------------------------

### Initialize LUT Polynomial

Source: https://pkg.go.dev/github.com/tuneinsight/lattigo/v4/rgsw/lut

Creates a LUT polynomial for a function g within the interval [a, b].

```go
func InitLUT(g func(x float64) (y float64), scale rlwe.Scale, ringQ *ring.Ring, a, b float64) (F *ring.Poly)
```

--------------------------------

### New Buffer Creation

Source: https://pkg.go.dev/github.com/tuneinsight/lattigo/v4/utils

Creates a new Buffer instance from a provided backing byte slice. Use this to initialize a buffer for data operations.

```go
func NewBuffer(s []byte) *Buffer
```

--------------------------------

### Thresholdizer API

Source: https://pkg.go.dev/github.com/tuneinsight/lattigo/v4/drlwe

Methods for initializing the Thresholdizer, generating Shamir polynomials, and creating secret shares.

```APIDOC
## NewThresholdizer

### Description
Creates a new Thresholdizer instance from provided RLWE parameters.

### Parameters
- **params** (rlwe.Parameters) - Required - The parameters for the RLWE scheme.

## GenShamirPolynomial

### Description
Generates a new secret ShamirPolynomial by sampling a random polynomial of degree threshold - 1 with the constant term equal to the secret.

### Parameters
- **threshold** (int) - Required - The threshold value for the access structure.
- **secret** (*rlwe.SecretKey) - Required - The secret key to be shared.

## GenShamirSecretShare

### Description
Generates a secret share for a specific recipient identified by a ShamirPublicPoint.

### Parameters
- **recipient** (ShamirPublicPoint) - Required - The identity of the share recipient.
- **secretPoly** (*ShamirPolynomial) - Required - The polynomial used for sharing.
- **shareOut** (*ShamirSecretShare) - Required - The output container for the generated share.

## AggregateShares

### Description
Aggregates two ShamirSecretShare instances and stores the result in the output share.

### Parameters
- **share1** (*ShamirSecretShare) - Required - First share to aggregate.
- **share2** (*ShamirSecretShare) - Required - Second share to aggregate.
- **outShare** (*ShamirSecretShare) - Required - The destination for the aggregated result.
```

--------------------------------

### Prime and Modular Arithmetic

Source: https://pkg.go.dev/github.com/tuneinsight/lattigo/v4/ring

Utilities for primality testing, modular reduction, and modular exponentiation.

```go
func IsPrime(x uint64) bool
```

```go
func MRed(x, y, q, qInv uint64) (r uint64)
```

```go
func MRedConstant(x, y, q, qInv uint64) (r uint64)
```

```go
func MRedParams(q uint64) (qInv uint64)
```

```go
func ModExp(x, e, p uint64) (result uint64)
```

```go
func ModExpPow2(x, e, p uint64) (result uint64)
```

--------------------------------

### Default RLWE Parameters

Source: https://pkg.go.dev/github.com/tuneinsight/lattigo/v4/rlwe

A collection of predefined parameter sets for different security levels and polynomial degrees.

```go
var (

	// TestPN10QP27 is a set of default parameters with logN=10 and logQP=27
	TestPN10QP27 = ParametersLiteral{
		LogN:     10,
		Q:        []uint64{0x7fff801},
		Pow2Base: 2,
	}

	// TestPN11QP54 is a set of default parameters with logN=11 and logQP=54
	TestPN11QP54 = ParametersLiteral{
		LogN:     11,
		Q:        []uint64{0x15400000001},
		P:        []uint64{0x3001},
		Pow2Base: 14,
	}
	// TestPN12QP109 is a set of default parameters with logN=12 and logQP=109
	TestPN12QP109 = ParametersLiteral{
		LogN:     12,
		Q:        []uint64{0x7ffffffec001, 0x400000008001},
		P:        []uint64{0xa001},
		Pow2Base: 16,
	}
	// TestPN13QP218 is a set of default parameters with logN=13 and logQP=218
	TestPN13QP218 = ParametersLiteral{
		LogN: 13,
		Q:    []uint64{0x3fffffffef8001, 0x4000000011c001, 0x40000000120001},
		P:    []uint64{0x7ffffffffb4001},
	}

	// TestPN14QP438 is a set of default parameters with logN=14 and logQP=438
	TestPN14QP438 = ParametersLiteral{
		LogN: 14,
		Q: []uint64{0x100000000060001, 0x80000000068001, 0x80000000080001,
			0x3fffffffef8001, 0x40000000120001, 0x3fffffffeb8001},
		P: []uint64{0x80000000130001, 0x7fffffffe90001},
	}

	// TestPN15QP880 is a set of default parameters with logN=15 and logQP=880
	TestPN15QP880 = ParametersLiteral{
		LogN: 15,
		Q: []uint64{0x7ffffffffe70001, 0x7ffffffffe10001, 0x7ffffffffcc0001,
			0x400000000270001, 0x400000000350001, 0x400000000360001,
			0x3ffffffffc10001, 0x3ffffffffbe0001, 0x3ffffffffbd0001,
			0x4000000004d0001, 0x400000000570001, 0x400000000660001},
		P: []uint64{0xffffffffffc0001, 0x10000000001d0001, 0x10000000006e0001},
	}

	// TestPN16QP240 is a set of default parameters with logN=16 and logQP=240
	TestPN16QP240 = ParametersLiteral{
		LogN: 16,
		LogQ: []int{60, 60, 60},
		LogP: []int{60},
	}

	// TestPN17QP360 is a set of default parameters with logN=17 and logQP=360
	TestPN17QP360 = ParametersLiteral{
		LogN: 17,
		LogQ: []int{60, 60, 60, 60},
		LogP: []int{60, 60},
	}

	DefaultParams = []ParametersLiteral{TestPN10QP27, TestPN11QP54, TestPN12QP109, TestPN13QP218, TestPN14QP438, TestPN15QP880, TestPN16QP240, TestPN17QP360}
)
```

--------------------------------

### Define CKKS Bootstrapping Parameters

Source: https://pkg.go.dev/github.com/tuneinsight/lattigo/v4/ckks/bootstrapping

Configuration structures for bootstrapping parameters, including encoding matrices and evaluation modulus settings.

```go
				LevelStart:    24,
				SineType:      advanced.Cos1,
				MessageRatio:  256.0,
				K:             16,
				SineDeg:       30,
				DoubleAngle:   3,
				ArcSineDeg:    0,
				ScalingFactor: 1 << 60,
			},
			CoeffsToSlotsParameters: advanced.EncodingMatrixLiteral{
				LinearTransformType: advanced.CoeffsToSlots,
				RepackImag2Real:     true,
				LevelStart:          28,
				BSGSRatio:           2.0,
				BitReversed:         false,
				ScalingFactor: [][]float64{
					{0x100000000060001},
					{0xfffffffff00001},
					{0xffffffffd80001},
					{0x1000000002a0001},
				},
			},
		},
	}
```

```go
N16QP1788H32768H32 = defaultParametersLiteral{
		ckks.ParametersLiteral{
			LogN:  16,
			Sigma: rlwe.DefaultSigma,
			H:     32768,
			Q: []uint64{
				0x10000000006e0001,
				0x2000000a0001,
				0x2000000e0001,
				0x1fffffc20001,
				0x200000440001,
				0x200000500001,
				0x200000620001,
				0x1fffff980001,
				0x2000006a0001,
				0x1fffff7e0001,
				0x3ffffe80001,
				0x3ffffd20001,
				0x3ffffca0001,
				0xffffffffffc0001,
				0xfffffffff240001,
				0x1000000000f00001,
				0xfffffffff840001,
				0x1000000000860001,
				0xfffffffff6a0001,
				0x1000000000980001,
				0xfffffffff5a0001,
				0x1000000000b00001,
				0x1000000000ce0001,
				0xfffffffff2a0001,
				0x400000000360001,
				0x3ffffffffbe0001,
				0x400000000660001,
				0x4000000008a0001,
			},
			P: []uint64{
				0x1fffffffffe00001,
				0x1fffffffffc80001,
				0x1fffffffffb40001,
				0x1fffffffff500001,
				0x1fffffffff420001,
			},
			LogSlots:     15,
			DefaultScale: 1 << 45,
		},

		Parameters{
			EphemeralSecretWeight: 32,
			SlotsToCoeffsParameters: advanced.EncodingMatrixLiteral{
				LinearTransformType: advanced.SlotsToCoeffs,
				RepackImag2Real:     true,
				LevelStart:          12,
				BSGSRatio:           2.0,
				BitReversed:         false,
				ScalingFactor: [][]float64{
					{0x3ffffe80001},
					{0x3ffffd20001},
					{0x3ffffca0001},
				},
			},
			EvalModParameters: advanced.EvalModLiteral{
				Q:             0x10000000006e0001,
				LevelStart:    23,
				SineType:      advanced.Cos1,
				MessageRatio:  4.0,
				K:             16,
				SineDeg:       30,
				DoubleAngle:   3,
				ArcSineDeg:    7,
				ScalingFactor: 1 << 60,
			},
			CoeffsToSlotsParameters: advanced.EncodingMatrixLiteral{
				LinearTransformType: advanced.CoeffsToSlots,
				RepackImag2Real:     true,
				LevelStart:          27,
				BSGSRatio:           2.0,
				BitReversed:         false,
				ScalingFactor: [][]float64{
					{0x400000000360001},
					{0x3ffffffffbe0001},
					{0x400000000660001},
					{0x4000000008a0001},
				},
			},
		},
	}
```

```go
N16QP1793H32768H32 = defaultParametersLiteral{
		ckks.ParametersLiteral{
			LogN:  16,
			Sigma: rlwe.DefaultSigma,
			H:     32768,
			Q: []uint64{
				0x80000000080001,
				0xffffffffffc0001,
				0x10000000006e0001,
				0xfffffffff840001,
				0x1000000000860001,
				0xfffffffff6a0001,
				0x1000000000980001,
				0xfffffffff5a0001,
				0xfffffffff2a0001,
				0xfffffffff240001,
				0x1000000000f00001,
				0xffffffffefe0001,
				0x1000000000b00001,
				0x1000000000ce0001,
				0x80000000440001,
				0x7fffffffba0001,
				0x80000000500001,
				0x7fffffffaa0001,
				0x800000005e0001,
				0x7fffffff7e0001,
				0x7fffffff380001,
				0x80000000ca0001,
				0x200000000e0001,
				0x20000000140001,
				0x20000000280001,
				0x1fffffffd80001,
			},
			P: []uint64{
				0x1fffffffffe00001,
				0x1fffffffffc80001,
				0x1fffffffffb40001,
				0x1fffffffff500001,
				0x1fffffffff420001,
			},
			LogSlots:     15,
			DefaultScale: 1 << 30,
		},

		Parameters{
			EphemeralSecretWeight: 32,
			SlotsToCoeffsParameters: advanced.EncodingMatrixLiteral{
				LinearTransformType: advanced.SlotsToCoeffs,
				RepackImag2Real:     true,
				LevelStart:          13,
				BSGSRatio:           2.0,
				BitReversed:         false,
				ScalingFactor: [][]float64{
					{1073741824.0},
					{1073741824.0062866, 1073741824.0062866},
				},
			},
			EvalModParameters: advanced.EvalModLiteral{
				Q:             0x80000000080001,
				LevelStart:    21,
				SineType:      advanced.Cos1,
				MessageRatio:  256.0,
				K:             16,
				SineDeg:       30,
				DoubleAngle:   3,
				ArcSineDeg:    0,
				ScalingFactor: 1 << 55,
			},
			CoeffsToSlotsParameters: advanced.EncodingMatrixLiteral{
				LinearTransformType: advanced.CoeffsToSlots,
				RepackImag2Real:     true,
				LevelStart:          25,
				BSGSRatio:           2.0,
				BitReversed:         false,
				ScalingFactor: [][]float64{
```
Tokens:
Raw