QNLP.encoding.utils Namespace Reference

Functions
def	pow2bits (bin_val)
def	get_type_offsets (encoding_dict)
def	get_type_masks (encoding_dict, type_offsets=None)
def	bin_to_sentence (bin_val, encoding_dict, decoding_dict, type_offsets=None)
def	gen_state_string (l)
def	HammingInt (int i1, int i2)
def	num_qubits (dict enc_dict)
def	encode_binary_pattern ((str, str, str) pattern, dict enc_dict)
def	encode_binary_pattern_direct ([int, int, int] pattern, dict enc_dict)
def	decode_binary_pattern (int pattern, dict dec_dict)

Function Documentation

bin_to_sentence()

def QNLP.encoding.utils.bin_to_sentence	(		bin_val,
			encoding_dict,
			decoding_dict,
			type_offsets = None
	)

Map the integer binary value to the result from the encoded basis mappings.

Definition at line 38 of file utils.py.

def bin_to_sentence(bin_val, encoding_dict, decoding_dict, type_offsets=None):
    """
    Map the integer binary value to the result from the encoded basis mappings.
    """
    if type_offsets == None:
        l_ns, l_v, l_no = get_type_offsets(encoding_dict)
    else:
        l_ns, l_v, l_no = type_offsets
    
    bitmask_ns, bitmask_v, bitmask_no = get_type_masks(encoding_dict, type_offsets=(l_ns, l_v, l_no) )

    ns_val = (bin_val & bitmask_ns) >> (l_v[1] + l_no[1])
    v_val  = (bin_val & bitmask_v) >> l_no[1]
    no_val = (bin_val & bitmask_no)

    return decoding_dict["ns"][ns_val], decoding_dict["v"][v_val], decoding_dict["no"][no_val]

References QNLP.encoding.utils.get_type_masks(), and QNLP.encoding.utils.get_type_offsets().

Here is the call graph for this function:

decode_binary_pattern()

def QNLP.encoding.utils.decode_binary_pattern	(	int	pattern,
		dict	dec_dict
	)

Pass in the pattern given as the encoded integer.
The pattern will be deconstructed into the appropriate token tuple
and output for plotting/printing. Inverse of encode_binary_pattern.

Definition at line 105 of file utils.py.

def decode_binary_pattern(pattern : int, dec_dict : dict):
    """
    Pass in the pattern given as the encoded integer.
    The pattern will be deconstructed into the appropriate token tuple
    and output for plotting/printing. Inverse of encode_binary_pattern.
    """
    num_ns, num_v, num_no = num_qubits(dec_dict)

    t_ns =   pattern & (2**num_ns -1)
    t_v  = ( pattern >> num_ns ) & (2**num_v -1)
    t_no = ( pattern >> (num_ns + num_v) ) & (2**num_no -1)
    
    return (dec_dict["ns"][t_ns], dec_dict["v"][t_v], dec_dict["no"][t_no])

References QNLP.encoding.utils.num_qubits().

Here is the call graph for this function:

encode_binary_pattern()

def QNLP.encoding.utils.encode_binary_pattern	(	(str,str,str)	pattern,
		dict	enc_dict
	)

Pass in the pattern given by the basis token values as (ns,v,no)
The pattern will be constructed into the appropriate binary string
and output for encoding.

Definition at line 80 of file utils.py.

def encode_binary_pattern(pattern : (str,str,str), enc_dict : dict):
    """
    Pass in the pattern given by the basis token values as (ns,v,no)
    The pattern will be constructed into the appropriate binary string
    and output for encoding.
    """
    num_ns, num_v, num_no = num_qubits(enc_dict)
    result = enc_dict["ns"][pattern[0]] | \
                enc_dict["v"][pattern[1]] << num_ns | \
                enc_dict["no"][pattern[2]] << (num_ns + num_v)

    return result

References QNLP.encoding.utils.num_qubits().

Here is the call graph for this function:

encode_binary_pattern_direct()

def QNLP.encoding.utils.encode_binary_pattern_direct	(	[int,int,int]	pattern,
		dict	enc_dict
	)

Pass in the pattern given by the basis token values as (ns,v,no)
The pattern will be constructed into the appropriate binary string
and output for encoding.

Definition at line 93 of file utils.py.

def encode_binary_pattern_direct(pattern : [int,int,int], enc_dict : dict):
    """
    Pass in the pattern given by the basis token values as (ns,v,no)
    The pattern will be constructed into the appropriate binary string
    and output for encoding.
    """
    num_ns, num_v, num_no = num_qubits(enc_dict)
    result = pattern[0] | pattern[1] << num_ns | pattern[2] << (num_ns + num_v)

    return result

References QNLP.encoding.utils.num_qubits().

Here is the call graph for this function:

gen_state_string()

def QNLP.encoding.utils.gen_state_string

(

l

)

Given a list of strings, generate the latex '\\vert {} \\rangle' representation of this in superposition.

Definition at line 56 of file utils.py.

def gen_state_string(l):
    """Given a list of strings, generate the latex '\\vert {} \\rangle' representation of this in superposition."""
    result = ""
    str_template = r"\vert {} \rangle"
    for idx,i in enumerate(l):
        result += r"b_{{{}}}\vert \textrm{{{}}} \rangle ".format(idx, i[0])
        if i != l[-1]:
            result += " + "
    return result

get_type_masks()

def QNLP.encoding.utils.get_type_masks	(		encoding_dict,
			type_offsets = None
	)

Definition at line 24 of file utils.py.

def get_type_masks(encoding_dict, type_offsets=None):
    # Create the bit_masks of the required length to decode the value from bin_val
    if type_offsets == None:
        l_ns, l_v, l_no = get_type_offsets(encoding_dict)
    else:
        l_ns, l_v, l_no = type_offsets

    bitmask_ns = (l_ns[0]-1) << (l_v[1] + l_no[1])
    bitmask_v = (l_v[0]-1) << l_no[1]
    bitmask_no = (l_no[0]-1) 
    
    return bitmask_ns, bitmask_v, bitmask_no

References QNLP.encoding.utils.get_type_offsets().

Referenced by QNLP.encoding.utils.bin_to_sentence().

Here is the call graph for this function:

Here is the caller graph for this function:

get_type_offsets()

def QNLP.encoding.utils.get_type_offsets

(

encoding_dict

)

Definition at line 18 of file utils.py.

def get_type_offsets(encoding_dict):
    l_ns = pow2bits( int(np.max( list(encoding_dict['ns'].values()))) )
    l_v  = pow2bits( int(np.max( list(encoding_dict['v'].values()))) )
    l_no = pow2bits( int(np.max( list(encoding_dict['no'].values()))) )
    return l_ns, l_v, l_no

References QNLP.encoding.utils.pow2bits().

Referenced by QNLP.encoding.utils.bin_to_sentence(), and QNLP.encoding.utils.get_type_masks().

Here is the call graph for this function:

Here is the caller graph for this function:

HammingInt()

def QNLP.encoding.utils.HammingInt	(	int	i1,
		int	i2
	)

Simple integer based hamming distance for bits

Definition at line 66 of file utils.py.

def HammingInt(i1 : int, i2 : int):
    """Simple integer based hamming distance for bits"""
    return bin(i1 ^ i2).count("1")

References QNLP_Python_MPI.count.

num_qubits()

def QNLP.encoding.utils.num_qubits

(

dict

enc_dict

)

Assuming simple.py encoding and give qubits as num_tokens/2 per meaning space

Definition at line 70 of file utils.py.

def num_qubits(enc_dict : dict):
    """
    Assuming simple.py encoding and give qubits as num_tokens/2 per meaning space
    """
    
    num_ns = len(enc_dict['ns'])//2
    num_v = len(enc_dict['v'])//2
    num_no = len(enc_dict['no'])//2
    return num_ns, num_v, num_no

Referenced by QNLP.encoding.utils.decode_binary_pattern(), QNLP.encoding.utils.encode_binary_pattern(), and QNLP.encoding.utils.encode_binary_pattern_direct().

Here is the caller graph for this function:

pow2bits()

def QNLP.encoding.utils.pow2bits

(

bin_val

)

Convert the integer value to a tuple of the next power of two, 
and number of bits required to represent it.

Definition at line 4 of file utils.py.

def pow2bits(bin_val):
    """
    Convert the integer value to a tuple of the next power of two, 
    and number of bits required to represent it.
    """
    result = -1
    bits = (bin_val).bit_length()
    if bin_val > 1:
        result = 2**(bits)
    else:
        result = 1
        bits = 1
    return result, bits

Referenced by QNLP.encoding.utils.get_type_offsets().

Here is the caller graph for this function: