Base class for compiler exceptions.

Single value in memory. This is useful to transfer information between threads. Operations are automatically read from memory if required, th

Clear integer in same domain as secure computation (depends on protocol). A number operators are supported (``+, -, *, /, //, **, %, ^, &

Clear 64-bit integer. Unlike :py:class:`cint` this is always a 64-bit integer. The type supports the following operations with :py:class:

r""" Secret integer in the protocol-specific domain. It supports operations with :py:class:`sint`, :py:class:`cint`, :py:class:`regint`, a

Array accessible by public index. That is, ``a[i]`` works for an array ``a`` and ``i`` being a :py:class:`regint`, :py:class:`cint`, or a

* Type for arbitrarily large integers. * This is a sub-class of ``mpz_class`` from GMP. As such, it implements * all integers operations and input/o

Multidimensional array. The access operator (``a[i]``) allows to a multi-dimensional array of dimension one less or a simple array for a

An (O)RAM entry with empty bit, index, and value.

Works like a vector.

Copy secret register (vector). :param: destination (cint) :param: source (cint)

Matrix. :param rows: compile-time (int) :param columns: compile-time (int) :param value_type: basic type of entries Matrices aren't

Clear fixed-point number represented as clear integer. It supports basic arithmetic (``+, -, *, /``), returning either :py:class:`cfix` i

Output time since start of computation.

Secret fixed-point number represented as secret integer, by multiplying with ``2^f`` and then rounding. See :py:class:`sint` for security con

Fixed-point addition layer. :param inputs: two input layers with same shape (tuple/list)

r""" Clear :math:`\mathrm{GF}(2^n)` value. n is chosen at runtime. A number operators are supported (``+, -, *, /, **, ^, &, |, ~, ==, !=

Secret addition. :param: result (sint) :param: summand (sint) :param: summand (sint)

Vector of registers of secret bits, effectively a matrix of secret bits. This facilitates parallel arithmetic operations in binary circuits.

Reveal secret registers (vectors) to clear registers (vectors). :param: number of argument to follow (odd number) :param: check after openin

Value known to one player. Supports operations with public values and personal values known to the same player. Can be used with :py:func:`~C

Fixed-point dense (matrix multiplication) layer. Supports inputs of size [N, d, d_in] to map to [N, d, d_out]. If d > 1, the layer behaves li

r""" Secret floating-point number. Represents :math:`(1 - 2s) \cdot (1 - z)\cdot v \cdot 2^p`. v: significand p: exp

Exception raised for errors in instruction argument parsing.

Bucket for tree ORAM. Contains an ORAM of some type and possibly two children.

Debugging output of clear register (vector). :param: source (cint) :param: comment (4 bytes / 1 unit)

Single secret bit.

Local share conversion. This instruction use the vector length in the instruction code field. :param: number of arguments to follow (number

List of entries in memory.

(Element-wise) multiplication of secret registers (vectors). :param: number of arguments to follow (multiple of four) :param: vector size (i

Store insecure random value of specified length in clear integer register (vector). :param: destination (regint) :param: length (regint)

r""" Secret :math:`\mathrm{GF}(2^n)` value. n is chosen at runtime. A number operators are supported (``+, -, *, /, **, ^, ~, ==, !=, <<`

:py:class:`sint` holding a bit, supporting binary operations (``&, |, ^``).

Multiply secret and clear value. :param: result (sint) :param: factor (sint) :param: factor (cint)

Bitwise right shift of secret register (vector) by (constant) immediate value. This only makes sense in connection with protocols allowing lo

Start timer. :param: timer number (int)

Store maximal number of corrupt players in clear integer register. :param: destination (regint)

Adam/AMSgrad optimizer. :param layers: layers of linear graph :param approx: use approximation for inverse square root (bool) :param ams

* BGV secret key. * The class allows addition. */

Mixed addition. :param: result (sint) :param: summand (sint) :param: summand (cint)

This gives access IEEE754 floating-point operations using Bristol Fashion circuits. The following example computes the standard deviation

Create incremental clear integer vector. For example, vector size 10, base 1, increment 2, repeat 3, and wrap 2 produces the following::

Assign (constant) immediate value to clear register (vector). :param: destination (cint) :param: value (int)

Extract part of vector. :param: result (sint) :param: input (sint) :param: start offset (int) :param: step

Start tape/bytecode file in another thread. :param: number of arguments to follow (multiple of three) :param: virtual machine thread number

Randomly shuffles clear integer vector with public randomness. :param: destination (regint) :param: source (regint)

Dropout layer. :param N: number of examples :param shape: list [N, ...] where N is the number of examples and an arbitrary amount of further

Fixed-point 2D AvgPool layer. :param input_shape: input shape (tuple/list of four int) :param output_shape: output shape (tuple/list of four