Metadata-Version: 1.0
Name: matSHEEP
Version: 1.2.0
Summary: Programmatic interface to SHEEP
Home-page: UNKNOWN
Author: Amartya Sanyal
Author-email: amartya18x@gmail.com
License: LICENSE.txt
Description: ========
        matSHEEP
        ========
        
        This library is a programmatic interface in python to generate a circuit for the bigger and more useful SHEEP library.
        
        The library has a few data types :
        
        * variables - A single bit (Could also be used as a normal scalar)
          
        * enc_vec - One dimensional bit vector (Could be used a one dimensional vector of any data type)
        
        * enc_mat - Two dimensional bit matrix (Could be used a one dimensional vector of any data type)
        
        * enc_tensor3 - Three dimensional bit tensor.
        
        
        To create a circuit, the basic class to inherit is ``mini_mod`` in ``mathsheep.interactions``. To add more components, you can use ``self.add(component)`` inside the ``create`` function as shown below.::
        
          class oneb_adder(mini_mod):
               def __init__(self, name, inputs, outputs, nb=None,
                               randomize_temps=1, carry=True):
        	    mini_mod.__init__(self, name, inputs, outputs)
                    self.create(...)
        
               def create(self, ...):
            	     self.add(..)
        
           
        Two types of components can be added.
        1. Assignments (``from matSHEEP.interactions``):
        
           * mono_assign
             * alias
             * negate
        
           * bi_assign
             * xor
             * and
             * or
             * constand
        
           * tri_assign
             * mux
        
        2. Other mini_mods
           
        There are a few predefined mini_mods. They can be found in
        
        1. ``matSHEEP.reusable_modules``
           * oneb_adder - Add two bits
           * nb_adder  - Adders x and y with incoming carrt where input is ``[cin x y]``
           * nb_adder_xy - Adds x and y with  ``input = (x, y)``
           * compare_cp - Compares ciphertext with plaintext with ``input = (c,p)``
        
        2. ``matSHEEP.functions``
           * reduce_add - Counts the number of ones in a bit vector.
        
        3. ``matSHEEP.nn_layer``
           * sign_fn
           * linear_layer_1d - Inner Product of a weight vector with encrypted bit vector  followed by a sign function.
           * linear_layer - Inner Product of a weight matrix with an encrypted bit vector followed by a sign function.
           * conv_layer - A convolution Layer. (Look at examples)
        
        4. ``matSHEEP.vector_ops``
           * vec_mono_op_cond - Takes a plaintext ``cond`` vector, a plaintext tuple ``ass_types`` containing only ``alias`` and ``negate`` as values and an encrypted bit vector ``input``. It outputs an encrypted bit vector where the ith position has the ``ass_types[cond[idx]]`` operation applied on  ``input[idx]``.
           * Similar operation for matrix and tensor.
        
Platform: UNKNOWN
