LazyGroupElement (math 1.0.0 API)

java.lang.Object
- org.cryptimeleon.math.structures.groups.lazy.LazyGroupElement

All Implemented Interfaces:

UniqueByteRepresentable, Representable, Element, GroupElement

Direct Known Subclasses:

ConstLazyGroupElement, ExpLazyGroupElement, HashResultLazyGroupElement, HomomorphismResultLazyGroupElement, InvLazyGroupElement, NeutralLazyGroupElement, OpLazyGroupElement, PairingResultLazyGroupElement, RandomGroupElement, RandomNonNeutralGroupElement
```
public abstract class LazyGroupElement
extends java.lang.Object
implements GroupElement
```
Abstract class providing the base for different lazy group operation results.

Nested Class Summary

Nested Classes
Modifier and Type Class and Description

protected static class LazyGroupElement.ComputationState

Nested Classes
Modifier and Type	Class and Description
`protected static class`	`LazyGroupElement.ComputationState`

Field Summary

Fields
Modifier and Type Field and Description

protected LazyGroup group

Fields
Modifier and Type	Field and Description
`protected LazyGroup`	`group`

Constructor Summary

Constructors
Constructor and Description

LazyGroupElement(LazyGroup group)

LazyGroupElement(LazyGroup group, GroupElementImpl concreteValue)

Constructors
Constructor and Description
`LazyGroupElement(LazyGroup group)`
`LazyGroupElement(LazyGroup group, GroupElementImpl concreteValue)`

Method Summary

All Methods Instance Methods Abstract Methods Concrete Methods
Modifier and Type	Method and Description
`protected GroupElementImpl`	`accumulateMultiexp(Multiexponentiation multiexp)` Writes down the value of this group element as a multiexponentiation.
`GroupElement`	`compute()` Hint that the concrete value of this GroupElement will be accessed soon (e.g., via `getRepresentation()` or `equals()`).
`protected abstract void`	`computeConcreteValue()` Computes the concrete value of the expression.
`GroupElement`	`computeSync()` Will compute stuff synchronously (this call blocks) so that the next call requiring the concrete value of this group element can immediately retrieve it.
`boolean`	`equals(java.lang.Object o)`
`protected GroupElementImpl`	`getConcreteValue()` Returns the concrete group element behind this LazyGroupElement.
`SmallExponentPrecomputation`	`getPrecomputedSmallExponents()`
`Representation`	`getRepresentation()` The representation of this object.
`Group`	`getStructure()` Returns the `Structure` that this `Element` belongs to.
`int`	`hashCode()`
`GroupElement`	`inv()` Calculates the inverse of this group element.
`boolean`	`isComputed()` Returns true if a concrete value has already been computed.
`protected boolean`	`isDefinitelySupposedToGetConcreteValue()` Generally, when computing the value of some LazyGroupElement, there is no need to compute the values of all LazyGroupElements related to it on the way.
`boolean`	`isNeutralElement()` Returns true iff this is the neutral element of the group.
`GroupElement`	`op(Element e)` Calculates the result of `this.op(e)`.
`GroupElement`	`pow(java.math.BigInteger exponent)` Calculates the result of applying the group operation k times.
`GroupElement`	`precomputePow()` Advises the `GroupElement` to prepare it for later `pow()` calls.
`GroupElement`	`precomputePow(int windowSize)` Advises the `GroupElement` to prepare it for later `pow()` calls.
`protected void`	`setConcreteValue(GroupElementImpl impl)`
`GroupElement`	`square()` Computes `this.op(this)`.
`java.lang.String`	`toString()`
`ByteAccumulator`	`updateAccumulator(ByteAccumulator accumulator)` Updates the ByteAccumulator with the unique byte representation of this object.

Methods inherited from class java.lang.Object
clone, finalize, getClass, notify, notifyAll, wait, wait, wait

Methods inherited from interface org.cryptimeleon.math.structures.groups.GroupElement
expr, op, op, pow, pow, pow, pow, pow, pow

Methods inherited from interface org.cryptimeleon.math.hash.UniqueByteRepresentable
getUniqueByteRepresentation

- Field Detail
  - group
```
protected LazyGroup group
```
- Constructor Detail
  - LazyGroupElement
```
public LazyGroupElement(LazyGroup group)
```
  - LazyGroupElement
```
public LazyGroupElement(LazyGroup group,
                        GroupElementImpl concreteValue)
```
- Method Detail
  - getStructure
```
public Group getStructure()
```
    Description copied from interface: Element
    
    Returns the Structure that this Element belongs to.
    
    Specified by:
    
    getStructure in interface Element
    
    Specified by:
    
    getStructure in interface GroupElement
  - inv
```
public GroupElement inv()
```
    Description copied from interface: GroupElement
    
    Calculates the inverse of this group element.
    
    Specified by:
    
    inv in interface GroupElement
    
    Returns:
    
    an element x such that x.op(this).equals(getStructure().getNeutralElement())
  - op
```
public GroupElement op(Element e)
                throws java.lang.IllegalArgumentException
```
    Description copied from interface: GroupElement
    
    Calculates the result of this.op(e).
    
    Specified by:
    
    op in interface GroupElement
    
    Parameters:
    
    e - right hand side of the operation
    
    Returns:
    
    the element resulting from the group operation
    
    Throws:
    
    java.lang.IllegalArgumentException - if e is of the wrong type
  - square
```
public GroupElement square()
```
    Description copied from interface: GroupElement
    
    Computes this.op(this).
    Useful if this group allows squaring to be more efficiently implemented than general exponentiation as is the case for elliptic curves.
    
    Specified by:
    
    square in interface GroupElement
  - pow
```
public GroupElement pow(java.math.BigInteger exponent)
```
    Description copied from interface: GroupElement
    
    Calculates the result of applying the group operation k times. i.e. it computes k*this (additive group) or this^k (multiplicative group). For negative exponents k, computes this.inv().pow(-k).
    
    Specified by:
    
    pow in interface GroupElement
  - precomputePow
```
public GroupElement precomputePow()
```
    Description copied from interface: GroupElement
    Advises the GroupElement to prepare it for later pow() calls. This will take some time and should only be done ahead of time. That is, the usual usage pattern should be:
```
 //Setting up your encryption scheme (or whatever)
 GroupElement g = group.getUniformlyRandomElement().precomputePow();
 //Then (maybe even multiple) future calls of
 GroupElement encrypt(GroupElement m) {
     return m.op(g.pow(sk)).compute();
 }
 
```
    Don't use g.precomputePow().pow(x).compute(); unless you're planning to do more exponentiations of g in the future. Uses a reasonable default for the memory consumed by this. Use GroupElement.precomputePow(int) to customize.
    Specified by:
    
    precomputePow in interface GroupElement
    
    Returns:
    
    the same object (for chaining calls)
  - precomputePow
```
public GroupElement precomputePow(int windowSize)
```
    Description copied from interface: GroupElement
    Advises the GroupElement to prepare it for later pow() calls. This will take some time and should only be done ahead of time. That is, the usual usage pattern should be:
```
 //Setting up your encryption scheme (or whatever)
 GroupElement g = group.getUniformlyRandomElement().precomputePow();
 //Then (maybe even multiple) future calls of
 GroupElement encrypt(GroupElement m) {
     return m.op(g.pow(sk)).compute();
 }
 
```
    Don't use g.precomputePow().pow(x).compute(); unless you're planning to do more exponentiations of g in the future.
    Specified by:
    
    precomputePow in interface GroupElement
    
    Parameters:
    
    windowSize - an indicator for how much memory you're willing to invest. Precomputation will take up space of roughly 2^(windowSize) group elements.
    
    Returns:
    
    the same object (for chaining calls)
  - compute
```
public GroupElement compute()
```
    Description copied from interface: GroupElement
    
    Hint that the concrete value of this GroupElement will be accessed soon (e.g., via getRepresentation() or equals()). Will start computing stuff in the background.
    
    Specified by:
    
    compute in interface GroupElement
    
    Returns:
    
    the same object (for chaining calls)
  - computeSync
```
public GroupElement computeSync()
```
    Description copied from interface: GroupElement
    
    Will compute stuff synchronously (this call blocks) so that the next call requiring the concrete value of this group element can immediately retrieve it. For designers of cryptographic schemes, were should be no reason to call this. Instead, use compute() which does the same, but asynchronously (i.e. concurrently).
    
    Specified by:
    
    computeSync in interface GroupElement
    
    Returns:
    
    the same object (for chaining calls)
  - setConcreteValue
```
protected void setConcreteValue(GroupElementImpl impl)
```
  - getConcreteValue
```
protected GroupElementImpl getConcreteValue()
```
    Returns the concrete group element behind this LazyGroupElement. If it has already been computed, the cached value is returned. If it is in the process of being computed, this blocks until the value is ready.
  - isDefinitelySupposedToGetConcreteValue
```
protected boolean isDefinitelySupposedToGetConcreteValue()
```
    Generally, when computing the value of some LazyGroupElement, there is no need to compute the values of all LazyGroupElements related to it on the way. One example of this is multiexponentiation, where the element g^a * h^b generally should be computed without explicitly computing g^a and h^b. However, if this returns true, then we have indication that at some point, we'll want to have the concrete value of this LazyGroupElement, i.e. if g^a.isDefinitelySupposedToGetConcreteValue(), then it's more advantageous to actually compute g^a instead of "just" including it in the multiexponentiation.
  - computeConcreteValue
```
protected abstract void computeConcreteValue()
```
    Computes the concrete value of the expression. Goal is to call setConcreteValue(). Implementations should call getConcreteValue() on dependent LazyGroupElements if needed. May be called multiple times (in several threads), but generally, best effort is applied to only call once. So if the value this computes is not constant (e.g., is random), you should apply synchronization here and make sure you're always returning a consistent value here.
  - accumulateMultiexp
```
protected GroupElementImpl accumulateMultiexp(Multiexponentiation multiexp)
```
    Writes down the value of this group element as a multiexponentiation. Implementors shall return a value h and put values g_i^x_i into multiexp such that h * product(g_i^x_i) is the value of this LazyGroupElement. For h = 1, return null. Yes, this is slightly weird from an API design perspective, but it's for the sake of (probably premature) optimization.
  - getPrecomputedSmallExponents
```
public SmallExponentPrecomputation getPrecomputedSmallExponents()
```
  - isComputed
```
public boolean isComputed()
```
    Description copied from interface: GroupElement
    
    Returns true if a concrete value has already been computed. No need to call this outside of upb.crypto.math, it's meant to allow for optimizations.
    
    Specified by:
    
    isComputed in interface GroupElement
  - equals
```
public boolean equals(java.lang.Object o)
```
    Specified by:
    
    equals in interface Element
    
    Overrides:
    
    equals in class java.lang.Object
  - isNeutralElement
```
public boolean isNeutralElement()
```
    Description copied from interface: GroupElement
    
    Returns true iff this is the neutral element of the group.
    
    Specified by:
    
    isNeutralElement in interface GroupElement
  - hashCode
```
public int hashCode()
```
    Specified by:
    
    hashCode in interface Element
    
    Overrides:
    
    hashCode in class java.lang.Object
  - updateAccumulator
```
public ByteAccumulator updateAccumulator(ByteAccumulator accumulator)
```
    Description copied from interface: UniqueByteRepresentable
    
    Updates the ByteAccumulator with the unique byte representation of this object.
    The input to the accumulators update function is an injective (with respect to a given domain) byte encoding of this object.
    For many use-cases, the AnnotatedUbrUtil can be used to quickly implement this method.
    
    Specified by:
    
    updateAccumulator in interface UniqueByteRepresentable
    
    Returns:
    
    the same accumulator as was input
  - getRepresentation
```
public Representation getRepresentation()
```
    Description copied from interface: Representable
    
    The representation of this object. Used for serialization. A convenient way to implement this is using @link ReprUtil
    
    Specified by:
    
    getRepresentation in interface Representable
    
    Returns:
    
    a Representation or null if an equal object can be recreated without any information.
    
    See Also:
    
    Representation
  - toString
```
public java.lang.String toString()
```
    Overrides:
    
    toString in class java.lang.Object

Class LazyGroupElement

Nested Class Summary

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Methods inherited from interface org.cryptimeleon.math.structures.groups.GroupElement

Methods inherited from interface org.cryptimeleon.math.hash.UniqueByteRepresentable

Field Detail

group

Constructor Detail

LazyGroupElement

LazyGroupElement

Method Detail

getStructure

inv

op

square

pow

precomputePow

precomputePow

compute

computeSync

setConcreteValue

getConcreteValue

isDefinitelySupposedToGetConcreteValue

computeConcreteValue

accumulateMultiexp

getPrecomputedSmallExponents

isComputed

equals

isNeutralElement

hashCode

updateAccumulator

getRepresentation

toString