pytket.circuit.logic_exp

For more discussion of classical logic in pytket see the manual section.

Classes and functions for constructing logical expressions over Bit and BitRegister.

class pytket.circuit.logic_exp.And

eval_vals()

Attempt to evaluate all sub-expressions; simple constant folding.

Return type:

Union[LogicExp, Bit, BitRegister, int]

class pytket.circuit.logic_exp.BinaryOp

Expresion for operation on two arguments.

class pytket.circuit.logic_exp.BitAnd(arg1, arg2)

class pytket.circuit.logic_exp.BitEq(arg1, arg2)

class pytket.circuit.logic_exp.BitLogicExp

Expression acting only on Bit or Constant types.

class pytket.circuit.logic_exp.BitNeq(arg1, arg2)

class pytket.circuit.logic_exp.BitNot(arg1)

class pytket.circuit.logic_exp.BitOne

class pytket.circuit.logic_exp.BitOr(arg1, arg2)

eval_vals()

Attempt to evaluate all sub-expressions; simple constant folding.

Return type:

Union[LogicExp, Bit, BitRegister, int]

enum pytket.circuit.logic_exp.BitWiseOp(value)

Enum for operations on Bit.

Valid values are as follows:

AND = <BitWiseOp.AND: '&'>

OR = <BitWiseOp.OR: '|'>

XOR = <BitWiseOp.XOR: '^'>

EQ = <BitWiseOp.EQ: '=='>

NEQ = <BitWiseOp.NEQ: '!='>

NOT = <BitWiseOp.NOT: '~'>

ZERO = <BitWiseOp.ZERO: '0'>

ONE = <BitWiseOp.ONE: '1'>

class pytket.circuit.logic_exp.BitXor(arg1, arg2)

class pytket.circuit.logic_exp.BitZero

class pytket.circuit.logic_exp.Eq

class pytket.circuit.logic_exp.LogicExp

Logical expressions over Bit or BitRegister. Encoded as a tree of expressions

all_inputs()

Returns:

All variables involved in expression.

Return type:

Set[Variable]

all_inputs_ordered()

Returns:

All variables involved in expression, in order of first appearance.

Return type:

list[Variable]

eval_vals()

Attempt to evaluate all sub-expressions; simple constant folding.

Return type:

Union[LogicExp, Bit, BitRegister, int]

classmethod factory(op)

Return matching operation class for enum.

Return type:

type[LogicExp]

classmethod from_dict(dic)

Load from JSON serializable nested dictionary.

Return type:

LogicExp

rename_args(cmap)

Rename the Bits according to a Bit map. Raise ValueError if a bit is being used in a register-wise expression.

Return type:

bool

set_value(var, val)

Set value of var to val recursively.

Return type:

None

to_dict()

Output JSON serializable nested dictionary.

Return type:

dict[str, Any]

class pytket.circuit.logic_exp.Neq

class pytket.circuit.logic_exp.NullaryOp

Expression for operation on no arguments (i.e. constant).

class pytket.circuit.logic_exp.Or

class pytket.circuit.logic_exp.PredicateExp

A binary predicate where the arguments are either Bits, BitRegisters, or Constants.

class pytket.circuit.logic_exp.RegAdd(arg1, arg2)

class pytket.circuit.logic_exp.RegAnd(arg1, arg2)

class pytket.circuit.logic_exp.RegDiv(arg1, arg2)

class pytket.circuit.logic_exp.RegEq(arg1, arg2)

class pytket.circuit.logic_exp.RegGeq(arg1, arg2)

class pytket.circuit.logic_exp.RegGt(arg1, arg2)

class pytket.circuit.logic_exp.RegLeq(arg1, arg2)

class pytket.circuit.logic_exp.RegLogicExp

Expression acting only on BitRegister or Constant types.

class pytket.circuit.logic_exp.RegLsh(arg1, arg2)

class pytket.circuit.logic_exp.RegLt(arg1, arg2)

class pytket.circuit.logic_exp.RegMul(arg1, arg2)

class pytket.circuit.logic_exp.RegNeg(arg1)

class pytket.circuit.logic_exp.RegNeq(arg1, arg2)

class pytket.circuit.logic_exp.RegNot(arg1)

class pytket.circuit.logic_exp.RegOr(arg1, arg2)

class pytket.circuit.logic_exp.RegPow(arg1, arg2)

class pytket.circuit.logic_exp.RegRsh(arg1, arg2)

class pytket.circuit.logic_exp.RegSub(arg1, arg2)

enum pytket.circuit.logic_exp.RegWiseOp(value)

Enum for operations on BitRegister.

Valid values are as follows:

AND = <RegWiseOp.AND: '&'>

OR = <RegWiseOp.OR: '|'>

XOR = <RegWiseOp.XOR: '^'>

EQ = <RegWiseOp.EQ: '=='>

NEQ = <RegWiseOp.NEQ: '!='>

LT = <RegWiseOp.LT: '<'>

GT = <RegWiseOp.GT: '>'>

LEQ = <RegWiseOp.LEQ: '<='>

GEQ = <RegWiseOp.GEQ: '>='>

ADD = <RegWiseOp.ADD: '+'>

SUB = <RegWiseOp.SUB: '-'>

MUL = <RegWiseOp.MUL: '*'>

DIV = <RegWiseOp.DIV: '/'>

POW = <RegWiseOp.POW: '**'>

LSH = <RegWiseOp.LSH: '<<'>

RSH = <RegWiseOp.RSH: '>>'>

NOT = <RegWiseOp.NOT: '~'>

class pytket.circuit.logic_exp.RegXor(arg1, arg2)

class pytket.circuit.logic_exp.UnaryOp

Expression for operation on one argument.

class pytket.circuit.logic_exp.Xor

pytket.circuit.logic_exp.create_bit_logic_exp(op, args)

Builds the LogicExp corresponding to applying the given BitWiseOp to some sequence of bits.

Return type:

BitLogicExp

pytket.circuit.logic_exp.create_logic_exp(op, args)

Builds the LogicExp corresponding to applying the given BitWiseOp or RegWiseOp to some sequence of arguments.

Return type:

LogicExp

pytket.circuit.logic_exp.create_predicate_exp(op, args)

Builds the LogicExp corresponding to applying a given comparison predicate to some sequence of arguments.

Return type:

PredicateExp

pytket.circuit.logic_exp.create_reg_logic_exp(op, args)

Builds the LogicExp corresponding to applying the given RegWiseOp to some sequence of registers.

Return type:

RegLogicExp

pytket.circuit.logic_exp.filter_by_type(seq, var_type)

Return enumeration of seq, with only elements of type var_type.

Return type:

Iterator[tuple[int, TypeVar(T)]]

pytket.circuit.logic_exp.if_bit(bit)

Equivalent of if bit:.

Return type:

PredicateExp

pytket.circuit.logic_exp.if_not_bit(bit)

Equivalent of if not bit:.

Return type:

PredicateExp

pytket.circuit.logic_exp.reg_eq(register, value)

Function to express a BitRegister equality predicate, i.e. for a register r, (r == 5) is expressed as reg_eq(r, 5)

Return type:

RegLogicExp

pytket.circuit.logic_exp.reg_geq(register, value)

Function to express a BitRegister greater than or equal to predicate, i.e. for a register r, (r >= 5) is expressed as reg_geq(r, 5)

Return type:

RegLogicExp

pytket.circuit.logic_exp.reg_gt(register, value)

Function to express a BitRegister greater than predicate, i.e. for a register r, (r > 5) is expressed as reg_gt(r, 5)

Return type:

RegLogicExp

pytket.circuit.logic_exp.reg_leq(register, value)

Function to express a BitRegister less than or equal to predicate, i.e. for a register r, (r <= 5) is expressed as reg_leq(r, 5)

Return type:

RegLogicExp

pytket.circuit.logic_exp.reg_lt(register, value)

Function to express a BitRegister less than predicate, i.e. for a register r, (r < 5) is expressed as reg_lt(r, 5)

Return type:

RegLogicExp

pytket.circuit.logic_exp.reg_neq(register, value)

Function to express a BitRegister inequality predicate, i.e. for a register r, (r != 5) is expressed as reg_neq(r, 5)

Return type:

RegLogicExp

pytket.circuit.add_condition

Enable adding of gates with conditions on Bit or BitRegister expressions.

exception pytket.circuit.add_condition.NonConstError

A custom exception class for non constant predicate argument.

pytket.circuit.clexpr

pytket.circuit.clexpr.check_register_alignments(circ)

Check whether all ClExprOp operations in the circuit are register-aligned.

This means that all register variables and outputs occurring in ClExprOp comprise whole registers with the bits in the correct order.

Parameters:

circ (Circuit) – circuit to check

Return type:

bool

Returns:

True iff all ClExprOp operations are register-aligned

pytket.circuit.clexpr.wired_clexpr_from_logic_exp(exp, output_bits)

Convert a LogicExp to a WiredClExpr

Parameters:

• exp (LogicExp) – the LogicExp

• output_bits (list[Bit]) – list of output bits of the LogicExp

Return type:

tuple[WiredClExpr, list[Bit]]

Returns:

the WiredClExpr and its full list of arguments

pytket.circuit.decompose_classical

Functions for decomposing Circuits containing classical expressions in to primitive logical operations.

exception pytket.circuit.decompose_classical.DecomposeClassicalError

Error with decomposing classical operations.

class pytket.circuit.decompose_classical.BitHeap(_reg_name='tk_SCRATCH_BIT')

Heap of temporary Bits.

fresh_var()

Return Bit, from heap if available, otherwise create new.

Return type:

Bit

property next_index: int

Next available bit index, not used by any other heap bit.

class pytket.circuit.decompose_classical.RegHeap(_reg_name_base='tk_SCRATCH_BITREG')

Heap of temporary BitRegisters.

fresh_var(size=64)

Return BitRegister, from heap if available, otherwise create new. Optionally set size of created register.

Return type:

BitRegister

property next_index: int

Next available bit index, not used by any other heap register.

class pytket.circuit.decompose_classical.VarHeap

A generic heap implementation.

fresh_var()

Generate new variable.

Return type:

TypeVar(T)

is_heap_var(var)

Check if var was generated from heap.

Return type:

bool

pop()

Pop from top of heap.

Return type:

TypeVar(T)

push(var)

Push var to heap.

Return type:

None

pytket.circuit.decompose_classical.temp_reg_in_args(args)

If there are bits from a temporary register in the args, return it.

Return type:

BitRegister | None