# Struct elastic_elgamal::DiscreteLogTable

source · `pub struct DiscreteLogTable<G: Group> { /* private fields */ }`

## Expand description

Lookup table for discrete logarithms.

For `Ciphertext`

s to be partially homomorphic, the encrypted values must be
group scalars linearly mapped to group elements: `x -> [x]G`

, where `G`

is the group
generator. After decryption it is necessary to map the decrypted group element back to a scalar
(i.e., get its discrete logarithm with base `G`

). Because of discrete logarithm assumption,
this task is computationally infeasible in the general case; however, if the possible range
of encrypted values is small, it is possible to “cheat” by precomputing mapping `[x]G -> x`

for all allowed `x`

ahead of time. This is exactly what `DiscreteLogTable`

does.

## §Examples

```
let mut rng = thread_rng();
let receiver = Keypair::<Ristretto>::generate(&mut rng);
let ciphertexts = (0_u64..16)
.map(|i| receiver.public().encrypt(i, &mut rng));
// Assume that we know that the plaintext is in range 0..16,
// e.g., via a zero-knowledge proof.
let lookup_table = DiscreteLogTable::new(0..16);
// Then, we can use the lookup table to decrypt values.
// A single table may be shared for multiple decryption operations
// (i.e., it may be constructed ahead of time).
for (i, enc) in ciphertexts.enumerate() {
assert_eq!(
receiver.secret().decrypt(enc, &lookup_table),
Some(i as u64)
);
}
```

## Implementations§

source§### impl<G: Group> DiscreteLogTable<G>

### impl<G: Group> DiscreteLogTable<G>

## Trait Implementations§

## Auto Trait Implementations§

### impl<G> Freeze for DiscreteLogTable<G>

### impl<G> RefUnwindSafe for DiscreteLogTable<G>where
G: RefUnwindSafe,

### impl<G> Send for DiscreteLogTable<G>where
G: Send,

### impl<G> Sync for DiscreteLogTable<G>where
G: Sync,

### impl<G> Unpin for DiscreteLogTable<G>where
G: Unpin,

### impl<G> UnwindSafe for DiscreteLogTable<G>where
G: UnwindSafe,

## Blanket Implementations§

source§### impl<T> BorrowMut<T> for Twhere
T: ?Sized,

### impl<T> BorrowMut<T> for Twhere
T: ?Sized,

source§#### fn borrow_mut(&mut self) -> &mut T

#### fn borrow_mut(&mut self) -> &mut T

Mutably borrows from an owned value. Read more