Setup MPC. Must be called to send the session to all other parties involved in the computation. Args: session (S

Reconstruct the secret. Request and get the shares from all the parties and reconstruct the secret. Depending on the value of "decode

Perform the backward pass for the transpose operation. Args: ctx (Dict[str, Any]): Context used to retrieve the information for t

Forward the call to the tensor specific class. Args: *args (List[Any]): list of args to be forwarded **kwargs(Dict[st

Wrap a function such that it can be run in parallel at multiple parties. Args: fn (Callable): The function to run. parties (Union

Wrapper to make sure that we call __getattribute__ before anything else. Args: func (Callable[Any, Any]): The function to wrap Retur

Get a generator that is initialized with seed. Args: seed (int): Seed. Returns: torch.Generator: Generator.

Returns method attribute based on ring_size and op_str. Args: ring_size (int): Ring size op_str (str): Operation stri

Generate shares from secret. Given a secret, split it into a number of shares such that each party would get one. Args:

Generates a random share using the generators held by a party. Args: shape (Union[tuple, torch.Size]): Shape for the share.

Returns sum of tensors based on ring_size. Args: shares (List[torch.Tensor]) : List of tensors. ring_size (int): Ring

Generate "op_str" primitives. Args: op_str (str): Operator. session (Session): Session. g_kwargs: Generat

Gets the current session for a party as defined in the global space. Args: uuid (Union[UUID, str]): used to retrieve the session Ret

Type of a tensor given a ring size/field. Args: ring_size (int): Ring size. Returns: torch.dtype: Type of tensor. Raise

Encode a value using the FixedPoint Encoder. Args: value (Union[torch.Tensor, float, int]): value to encode Returns:

Generates a random zero share using the two generators held by a party. Args: shape (Union[tuple, torch.Size]): Shape for the sha

Apply an operation on "self" which is a MPCTensor "y". This function checks if "y" is private or public value. Args: y:

Generate a new "random" tensor. Args: tensor_type (torch.dtype): Type of the tensor. generator (torch.Generator): Torch Generator

Decode via FixedPrecisionEncoder. Returns: torch.Tensor: Decoded value

Decode a value using the FixedPoint Encoder. Args: value (Union[int, torch.Tensor]): Value to decode. Returns:

Get number of bits. Args: ring_size (int): Ring Size. Returns: int: Bit length.

Get primitives from store. Args: op_str (str): Operator to get. nr_instances (int): Number of instances.

Check if a given obj is a pointer (is a remote object). Args: obj (Any): Object. Returns: bool: True (if pointer) or False (

Check the type of "y" and covert it to share if necessary. Args: x (ShareTensor): Typically "self". y (Union[int, flo

r"""Approximates the exponential function using a limit approximation. exp(x) = \lim_{n -> infty} (1 + x / n) ^ n Here we compute exp by choo

Ring size of tensor. Returns: ring_size (str): Returns ring_size of tensor in string. It is typecasted to string as we c

Reverse the broadcast operation. Credits goes to the CrypTen team. Args: x (MPCTensor): The value to be "reverse broadcasted"

Apply a given operation. Args: y (Union["ShareTensor", torch.Tensor, int, float]): tensor to apply the operator. op_s

Perform ABY3 bit injection for conversion of binary share to arithmetic share. Args: x (MPCTensor) : MPCTensor with shares of bit

r"""Calculate the reciprocal using the algorithm specified in the method args. Ref: https://github.com/facebookresearch/CrypTen Args:

XOR operator. Args: y (Union["MPCTensor", torch.Tensor, int]): MPCTensor to find xor. Returns: MPCTensor: Re

Copy specific fields from the session. Returns: A copy of the current Session.

Get protocol. Returns: Protocol

Apply the "mul" operation between "self" and "y". Args: y (Union["MPCTensor", torch.Tensor, float, int]): self * y Retur

Calculate sign of given tensor. Args: data: tensor whose sign has to be determined Returns: MPCTensor: tensor with the deter

Return the string representation of MPCTensor. Returns: str: String representation.

Get triples. The Trusted Third Party (TTP) or Crypto Provider should provide this triples Currently, the one that orchestrates the communicat

Apply the "conv2d" operation between "self" and "y". Args: weight: the convolution kernel bias: optional bias

Get the shares. Returns: List[MPCTensor]: List of shares.

Check the type of "y" and convert it to share if necessary. Args: x (ReplicatedSharedTensor): Typically "self". y (Un

Sets the variable to True to start primitive logging.

Sets the variable to False to stop primitive logging. Args: generate_file: when set to True generates a seperate primitive_log.js

Calculates tanh of given tensor. Args: tensor (MPCTensor): whose sigmoid has to be calculated method (str): method to use while c

Perfoms the ABY3 truncation algorithm. Args: x (MPCTensor): input tensor session (Session) : session of the input ten

Apply a given operation ". This function checks if "y" is private or public value. Args: y (Union[ReplicatedSharedTenso

Representation. Returns: str: Return the string representation of ShareTensor.

Generate FSS primitives. Args: op (str): type of operation (eq or comp) n_values (int): number of primitives to generate Ret

Count overflows and underflows if we reconstruct the original value. This function is taken from the CrypTen project. CrypTen repository: htt

Perform the forward pass and construct the computational graph. Args: _self (MPCTensor): Perform grad_fn (GradFunc): The gradient

Generates primitives from the log provided. Args: primitive_log (dict): the dict log created with primitive logging.

Generate Pseudo-Random-Zero Shares. PRZS at the parties involved in the computation. Args: shape (Union[torch.Size, List

Lower or equal operator. Args: other (MPCTensor): MPCTensor to compare. Returns: MPCTensor: Result of the co

Approximates the natural logarithm using 8th order modified Householder iterations. Recall that Householder method is an algorithm to solve a

Falcon semihonest multiplication. Performs Falcon's mul implementation, add masks and performs resharing. Args: x (MPCTe

Implementation of Falcon's multiplication with semi-honest security guarantee. Args: x (ReplicatedSharedTensor): Secret

Populate items. Args: op_str (str): Operator to store. primitives (Iterables[Any]): Primitives to store.

Falcon Private Compare functionality which computes(x>r). Args: x (List[MPCTensor]) : shares of bits of x in Zp. r (t

Rectified linear unit function. Args: x (MPCTensor): The tensor on which we apply the function Returns: An MPCTensor which r

Returns either x or y based on bit b. Args: x (MPCTensor): input tensor y (MPCTensor): input tensor b (MP

Approximates the sigmoid function using a given method. Args: tensor (Any): tensor to calculate sigmoid method (str): (default =

Apply the "div" operation between "self" and "y". Args: y (Union["MPCTensor", torch.Tensor, float, int]): Denominator. R

Performs the ABY3 truncation algorithm1. Args: ptr_list (List[torch.Tensor]): Tensors to truncate shape (torch.Size)

Add FSS primitives to the crypto store. Args: op (str): type of operation (eq or comp) store (Dict[Any,Any]): the crypto store

Create an empty store for FSS if it doesn't exist already. Args: store: the main crypto store

Generate random tensor share for the given shape and ring_size. Args: shape (Union[tuple, torch.Size]): Shape for the share.

Sanity check the parameters required for max_pool2d (backward and forward pass). Args: kernel_size (Union[int, Tuple[int, int]]): the ker

Perform ABY3 bit decomposition using orchestrator as ttp. Args: x (MPCTensor): Arithmetic shares of secret. session (

Extracts the bit at the specified position. Args: pos (int): position to extract bit. Returns: ReplicatedSha

Decode via FixedPointEncoder. Returns: List[torch.Tensor]: Decoded values

Define the workflow for a binary operation using Function Secret Sharing. Currently supported operand are = & <=, respectively corresponding to

Perform bit addition on MPCTensors using a full adder. Args: a (List[MPCTensor]): MPCTensor with shares of bit. b (Li

Config of tensor. Returns: config (Dict): returns config of the tensor as dict.

Compute argmax using pairwise comparisons. Makes the number of rounds fixed, here it is 2. This is inspired from CrypTen. Args: x (M

Check if a given obj is on the local machine (in Duet or VM). Args: obj (Any): Object. Returns: bool: True (if pointer) or F

Applies a softmax followed by a logarithm. While mathematically equivalent to log(softmax(x)), doing these two operations separately is slowe

Calculation of modulus for a given tensor. Args: data(MPCTensor): tensor whose modulus has to be calculated Returns: MPCTens

Master method for multiplication. Args: x (MPCTensor): Secret y (MPCTensor): Another secret session (Sess

Compute integer power of a number by recursion using mul. - Divide power by 2 and multiply base to itself (if the power is even) - De

Sets attributes of conv apart from weights. Args: attributes (Dict): Attributes with their values. Raises: V

Calculates tanh of given tensor's elements along the given dimension. Args: tensor (MPCTensor): whose softmax has to be calculated

Takes a list of MPCTensors and sorts them in ascending/desending order using bubble sort. Args: input_list (List[MPCTensor]): Takes a lis

Concatenates a sequence of tensors along a new dimension. Args: tensors (List): sequence of tensors to stacks dim (int): dimensio

Apply an operation on 2 RSTensors (secret shared values). Args: y (RelicatedSharedTensor): Tensor to apply the operation

Apply an operation on 2 MPCTensor (secret shared values). Args: y (MPCTensor): Tensor to apply the operation op_str (

Apply an operation on "self" which is a RSTensor and a public value. Args: y (Union[torch.Tensor, float, int]): Tensor to apply t

Apply an operation on "self" which is a MPCTensor and a public value. Args: y (Union[torch.Tensor, float, int]): Tensor to apply

Reconstruct value from shares. Args: share_ptrs (List[ReplicatedSharedTensor]): List of RSTensor pointers. get_shares

Reconstruct value from shares. Args: share_ptrs (List[ReplicatedSharedTensor]): List of RSTensor pointers. get_shares

Representation. Returns: String representation.

r"""Evaluates odd degree Chebyshev polynomials at x. Chebyshev Polynomials of the first kind are defined as P_0(x) = 1, P_1(x) = x, P_n(x

Decodes shares list of RSTensor via FixedPointEncoder. Returns: List[torch.Tensor]: Decoded values