Reference: Gidney Arithmetic Qubricks

Contents

• AddBase Class
• GidneyAdd Class
• NaiveAdd Class
• ConditionallyCleanAdd Class
• CuccaroAdd Class
• CuccaroDepthOptimisedAdd Class
• Square Class
• GidneySquare Class
• NaiveSquare Class
• MultiplyAdd Class
• GidneyMultiplyAdd Class
• NaiveMultiplyAdd Class
• CuccaroMultiplyAdd Class
• OptimizedGidneyMultiplyAdd Class
• OptimizedNaiveMultiplyAdd Class
• RSqrt Class
• GidneyLadder Class

---

AddBase Class

psiqworkbench.qubricks.qbk_gidney_arithmetic.AddBase

AddBase(
    add_engine=gidney_add_engine,
    expand_dest_qreg: bool = False,
    release_ancillae: bool = True,
    **kwargs,
)

Bases: Qubrick

Basic boilerplate for adder.

compute

compute(
    lhs: QType,
    rhs: QType,
    ctrl: Qubits | None = None,
    *,
    carry_in: bool = None,
    subtract_condition: bool = False,
    alloc_result: bool = False,
    release_ancillae: bool = None,
    condition: bool = None,
)

This computes (lhs += rhs).

Parameters:

Name	Type	Description	Default
lhs	Qubits	Left-hand operand and destination	required
rhs	Qubits or int	Right-hand operand	required
ctrl	Qubits	Quantum condition	None
subtract_condition	Qubits or bool	If True (classically or quantumly), subtract instead of adding	False
alloc_result	bool	If True, compute into a new register	False
release_ancillae	bool	If True, uncompute and release auxiliary qubits. If False, hold auxiliary qubits till uncompute.	None
carry_in	Qubits or int or None	Additional value to add, if any	None

Notes

release_ancillae allows us to trade off Toffoli cost vs. qubit cost:

• If True, then the ONLY effect remaining after compute() is the desired sum.
• If False, it uses fewer gates but rhs and the auxiliary qubits will be scrambled until uncompute.

---

GidneyAdd Class

psiqworkbench.qubricks.qbk_gidney_arithmetic.GidneyAdd

GidneyAdd(**kwargs)

Bases: AddBase

Wrapper for Gidney Add.

compute

compute(
    lhs: QType,
    rhs: QType,
    ctrl: Qubits | None = None,
    *,
    carry_in: bool = None,
    subtract_condition: bool = False,
    alloc_result: bool = False,
    release_ancillae: bool = None,
    condition: bool = None,
)

This computes (lhs += rhs).

Parameters:

Name	Type	Description	Default
lhs	Qubits	Left-hand operand and destination	required
rhs	Qubits or int	Right-hand operand	required
ctrl	Qubits	Quantum condition	None
subtract_condition	Qubits or bool	If True (classically or quantumly), subtract instead of adding	False
alloc_result	bool	If True, compute into a new register	False
release_ancillae	bool	If True, uncompute and release auxiliary qubits. If False, hold auxiliary qubits till uncompute.	None
carry_in	Qubits or int or None	Additional value to add, if any	None

Notes

release_ancillae allows us to trade off Toffoli cost vs. qubit cost:

• If True, then the ONLY effect remaining after compute() is the desired sum.
• If False, it uses fewer gates but rhs and the auxiliary qubits will be scrambled until uncompute.

---

NaiveAdd Class

psiqworkbench.qubricks.qbk_gidney_arithmetic.NaiveAdd

NaiveAdd(**kwargs)

Bases: AddBase

Wrapper for Naive Add.

compute

compute(
    lhs: QType,
    rhs: QType,
    ctrl: Qubits | None = None,
    *,
    carry_in: bool = None,
    subtract_condition: bool = False,
    alloc_result: bool = False,
    release_ancillae: bool = None,
    condition: bool = None,
)

This computes (lhs += rhs).

Parameters:

Name	Type	Description	Default
lhs	Qubits	Left-hand operand and destination	required
rhs	Qubits or int	Right-hand operand	required
ctrl	Qubits	Quantum condition	None
subtract_condition	Qubits or bool	If True (classically or quantumly), subtract instead of adding	False
alloc_result	bool	If True, compute into a new register	False
release_ancillae	bool	If True, uncompute and release auxiliary qubits. If False, hold auxiliary qubits till uncompute.	None
carry_in	Qubits or int or None	Additional value to add, if any	None

Notes

release_ancillae allows us to trade off Toffoli cost vs. qubit cost:

• If True, then the ONLY effect remaining after compute() is the desired sum.
• If False, it uses fewer gates but rhs and the auxiliary qubits will be scrambled until uncompute.

---

CuccaroAdd Class

psiqworkbench.qubricks.qbk_gidney_arithmetic.CuccaroAdd

CuccaroAdd(**kwargs)

Bases: AddBase

Wrapper for Cuccaro Add.

compute

compute(
    lhs: QType,
    rhs: QType,
    ctrl: Qubits | None = None,
    *,
    carry_in: bool = None,
    subtract_condition: bool = False,
    alloc_result: bool = False,
    release_ancillae: bool = None,
    condition: bool = None,
)

This computes (lhs += rhs).

Parameters:

Name	Type	Description	Default
lhs	Qubits	Left-hand operand and destination	required
rhs	Qubits or int	Right-hand operand	required
ctrl	Qubits	Quantum condition	None
subtract_condition	Qubits or bool	If True (classically or quantumly), subtract instead of adding	False
alloc_result	bool	If True, compute into a new register	False
release_ancillae	bool	If True, uncompute and release auxiliary qubits. If False, hold auxiliary qubits till uncompute.	None
carry_in	Qubits or int or None	Additional value to add, if any	None

Notes

release_ancillae allows us to trade off Toffoli cost vs. qubit cost:

• If True, then the ONLY effect remaining after compute() is the desired sum.
• If False, it uses fewer gates but rhs and the auxiliary qubits will be scrambled until uncompute.

---

ConditionallyCleanAdd Class

psiqworkbench.qubricks.qbk_gidney_arithmetic.ConditionallyCleanAdd

ConditionallyCleanAdd(**kwargs)

Bases: AddBase

Wrapper for Conditionally Clean Add.

compute

compute(
    lhs: QType,
    rhs: QType,
    ctrl: Qubits | None = None,
    *,
    carry_in: bool = None,
    subtract_condition: bool = False,
    alloc_result: bool = False,
    release_ancillae: bool = None,
    condition: bool = None,
)

This computes (lhs += rhs).

Parameters:

Name	Type	Description	Default
lhs	Qubits	Left-hand operand and destination	required
rhs	Qubits or int	Right-hand operand	required
ctrl	Qubits	Quantum condition	None
subtract_condition	Qubits or bool	If True (classically or quantumly), subtract instead of adding	False
alloc_result	bool	If True, compute into a new register	False
release_ancillae	bool	If True, uncompute and release auxiliary qubits. If False, hold auxiliary qubits till uncompute.	None
carry_in	Qubits or int or None	Additional value to add, if any	None

Notes

release_ancillae allows us to trade off Toffoli cost vs. qubit cost:

• If True, then the ONLY effect remaining after compute() is the desired sum.
• If False, it uses fewer gates but rhs and the auxiliary qubits will be scrambled until uncompute.

---

CuccaroDepthOptimisedAdd Class

psiqworkbench.qubricks.qbk_gidney_arithmetic.CuccaroDepthOptimisedAdd

CuccaroDepthOptimisedAdd(**kwargs)

Bases: AddBase

Wrapper for Cuccaro Depth Optimised Add.

compute

compute(
    lhs: QType,
    rhs: QType,
    ctrl: Qubits | None = None,
    *,
    carry_in: bool = None,
    subtract_condition: bool = False,
    alloc_result: bool = False,
    release_ancillae: bool = None,
    condition: bool = None,
)

This computes (lhs += rhs).

Parameters:

Name	Type	Description	Default
lhs	Qubits	Left-hand operand and destination	required
rhs	Qubits or int	Right-hand operand	required
ctrl	Qubits	Quantum condition	None
subtract_condition	Qubits or bool	If True (classically or quantumly), subtract instead of adding	False
alloc_result	bool	If True, compute into a new register	False
release_ancillae	bool	If True, uncompute and release auxiliary qubits. If False, hold auxiliary qubits till uncompute.	None
carry_in	Qubits or int or None	Additional value to add, if any	None

Notes

release_ancillae allows us to trade off Toffoli cost vs. qubit cost:

• If True, then the ONLY effect remaining after compute() is the desired sum.
• If False, it uses fewer gates but rhs and the auxiliary qubits will be scrambled until uncompute.

---

Square Class

psiqworkbench.qubricks.qbk_gidney_arithmetic.Square

Square(
    add_engine=gidney_add_engine,
    square_engine=square_engine,
    allow_negative_input=None,
    **kwargs,
)

Bases: Qubrick

Basic Gidney square.

Parameters:

Name	Type	Description	Default
allow_negative_input	bool or None	Set to allow negative input values. If None, decide based on input params.	None

compute

compute(
    lhs,
    ctrl=None,
    dst=None,
    alloc_result=None,
    add_to_dest=None,
    release_ancillae: bool = True,
    condition=None,
) -> None

This computes (lhs * lhs) into a new register.

Parameters:

Name	Type	Description	Default
lhs	Qubits	Left-hand operand and destination	required
ctrl	Qubits	Quantum ctrl	None
dst	Qubits or None	If provided, ADD result into this reg	None
alloc_result	None	Deprecated and will be removed in WB 5.0.0. To allocate a new result, pass None as dst.	None
add_to_dest	None	If False or dst=None, just compute square assuming dst is zero. Otherwise, add to dst	None
release_ancillae	bool	If True, uncompute and release auxiliary qubits. If False, hold auxiliary qubits till uncompute.	True

Notes

release_ancillae allows us to trade off Toffoli cost vs. qubit cost:

• If True, then the ONLY effect remaining after compute() is the desired sum.
• If False, it uses fewer gates but rhs and the auxiliary qubits will be scrambled until uncompute.

---

GidneySquare Class

psiqworkbench.qubricks.qbk_gidney_arithmetic.GidneySquare

GidneySquare(params=None, routines=None, **kwargs)

Bases: Square

Wrapper for Gidney Square.

compute

compute(
    lhs,
    ctrl=None,
    dst=None,
    alloc_result=None,
    add_to_dest=None,
    release_ancillae: bool = True,
    condition=None,
) -> None

This computes (lhs * lhs) into a new register.

Parameters:

Name	Type	Description	Default
lhs	Qubits	Left-hand operand and destination	required
ctrl	Qubits	Quantum ctrl	None
dst	Qubits or None	If provided, ADD result into this reg	None
alloc_result	None	Deprecated and will be removed in WB 5.0.0. To allocate a new result, pass None as dst.	None
add_to_dest	None	If False or dst=None, just compute square assuming dst is zero. Otherwise, add to dst	None
release_ancillae	bool	If True, uncompute and release auxiliary qubits. If False, hold auxiliary qubits till uncompute.	True

Notes

release_ancillae allows us to trade off Toffoli cost vs. qubit cost:

• If True, then the ONLY effect remaining after compute() is the desired sum.
• If False, it uses fewer gates but rhs and the auxiliary qubits will be scrambled until uncompute.

---

NaiveSquare Class

psiqworkbench.qubricks.qbk_gidney_arithmetic.NaiveSquare

NaiveSquare(params=None, routines=None, **kwargs)

Bases: Square

Wrapper for Naive Square.

compute

compute(
    lhs,
    ctrl=None,
    dst=None,
    alloc_result=None,
    add_to_dest=None,
    release_ancillae: bool = True,
    condition=None,
) -> None

This computes (lhs * lhs) into a new register.

Parameters:

Name	Type	Description	Default
lhs	Qubits	Left-hand operand and destination	required
ctrl	Qubits	Quantum ctrl	None
dst	Qubits or None	If provided, ADD result into this reg	None
alloc_result	None	Deprecated and will be removed in WB 5.0.0. To allocate a new result, pass None as dst.	None
add_to_dest	None	If False or dst=None, just compute square assuming dst is zero. Otherwise, add to dst	None
release_ancillae	bool	If True, uncompute and release auxiliary qubits. If False, hold auxiliary qubits till uncompute.	True

Notes

release_ancillae allows us to trade off Toffoli cost vs. qubit cost:

• If True, then the ONLY effect remaining after compute() is the desired sum.
• If False, it uses fewer gates but rhs and the auxiliary qubits will be scrambled until uncompute.

---

MultiplyAdd Class

psiqworkbench.qubricks.qbk_gidney_arithmetic.MultiplyAdd

MultiplyAdd(
    add_engine=gidney_add_engine,
    mul_engine=naive_mul_engine,
    allow_negative_input=None,
    **kwargs,
)

Bases: Qubrick

Basic Gidney Multiply-Add.

Parameters:

Name	Type	Description	Default
allow_negative_input	bool or None	Set to allow negative input values. If None, decide based on input params.	None

compute

compute(
    dst,
    lhs,
    rhs,
    ctrl=None,
    release_ancillae: bool = True,
    condition=None,
    subtract_condition: bool = False,
)

This computes dst + (lhs * rhs).

Parameters:

Name	Type	Description	Default
dst	Qubits or None	Destination to add into. If None, allocate a new register	required
lhs	Qubits	Left-hand multiply operand	required
rhs	Qubits	Right-hand multiply operand	required
ctrl	Qubits	Quantum control	None
subtract_condition	Qubits or bool	If True (classically or quantumly), subtract instead of adding	False
release_ancillae	bool	If True, uncompute and release auxiliary qubits. If False, hold auxiliary qubits till uncompute.	True

Notes

release_ancillae allows us to trade off Toffoli cost vs. qubit cost:

• If True, then the ONLY effect remaining after compute() is the desired sum.
• If False, it uses fewer gates but rhs and the auxiliary qubits will be scrambled until uncompute.

---

GidneyMultiplyAdd Class

psiqworkbench.qubricks.qbk_gidney_arithmetic.GidneyMultiplyAdd

GidneyMultiplyAdd(**kwargs)

Bases: MultiplyAdd

Wrapper for Gidney Multiply-Add.

compute

compute(
    dst,
    lhs,
    rhs,
    ctrl=None,
    release_ancillae: bool = True,
    condition=None,
    subtract_condition: bool = False,
)

This computes dst + (lhs * rhs).

Parameters:

Name	Type	Description	Default
dst	Qubits or None	Destination to add into. If None, allocate a new register	required
lhs	Qubits	Left-hand multiply operand	required
rhs	Qubits	Right-hand multiply operand	required
ctrl	Qubits	Quantum control	None
subtract_condition	Qubits or bool	If True (classically or quantumly), subtract instead of adding	False
release_ancillae	bool	If True, uncompute and release auxiliary qubits. If False, hold auxiliary qubits till uncompute.	True

Notes

release_ancillae allows us to trade off Toffoli cost vs. qubit cost:

• If True, then the ONLY effect remaining after compute() is the desired sum.
• If False, it uses fewer gates but rhs and the auxiliary qubits will be scrambled until uncompute.

---

NaiveMultiplyAdd Class

psiqworkbench.qubricks.qbk_gidney_arithmetic.NaiveMultiplyAdd

NaiveMultiplyAdd(params=None, routines=None, **kwargs)

Bases: MultiplyAdd

Wrapper for Naive Multiply-Add.

compute

compute(
    dst,
    lhs,
    rhs,
    ctrl=None,
    release_ancillae: bool = True,
    condition=None,
    subtract_condition: bool = False,
)

This computes dst + (lhs * rhs).

Parameters:

Name	Type	Description	Default
dst	Qubits or None	Destination to add into. If None, allocate a new register	required
lhs	Qubits	Left-hand multiply operand	required
rhs	Qubits	Right-hand multiply operand	required
ctrl	Qubits	Quantum control	None
subtract_condition	Qubits or bool	If True (classically or quantumly), subtract instead of adding	False
release_ancillae	bool	If True, uncompute and release auxiliary qubits. If False, hold auxiliary qubits till uncompute.	True

Notes

release_ancillae allows us to trade off Toffoli cost vs. qubit cost:

• If True, then the ONLY effect remaining after compute() is the desired sum.
• If False, it uses fewer gates but rhs and the auxiliary qubits will be scrambled until uncompute.

---

CuccaroMultiplyAdd Class

psiqworkbench.qubricks.qbk_gidney_arithmetic.CuccaroMultiplyAdd

CuccaroMultiplyAdd(params=None, routines=None, **kwargs)

Bases: MultiplyAdd

Wrapper for Cuccaro Multiply-Add.

compute

compute(
    dst,
    lhs,
    rhs,
    ctrl=None,
    release_ancillae: bool = True,
    condition=None,
    subtract_condition: bool = False,
)

This computes dst + (lhs * rhs).

Parameters:

Name	Type	Description	Default
dst	Qubits or None	Destination to add into. If None, allocate a new register	required
lhs	Qubits	Left-hand multiply operand	required
rhs	Qubits	Right-hand multiply operand	required
ctrl	Qubits	Quantum control	None
subtract_condition	Qubits or bool	If True (classically or quantumly), subtract instead of adding	False
release_ancillae	bool	If True, uncompute and release auxiliary qubits. If False, hold auxiliary qubits till uncompute.	True

Notes

release_ancillae allows us to trade off Toffoli cost vs. qubit cost:

• If True, then the ONLY effect remaining after compute() is the desired sum.
• If False, it uses fewer gates but rhs and the auxiliary qubits will be scrambled until uncompute.

---

OptimizedGidneyMultiplyAdd Class

psiqworkbench.qubricks.qbk_gidney_arithmetic.OptimizedGidneyMultiplyAdd

OptimizedGidneyMultiplyAdd(**kwargs)

Bases: MultiplyAdd

Wrapper for Gidney Multiply-Add.

compute

compute(
    dst,
    lhs,
    rhs,
    ctrl=None,
    release_ancillae: bool = True,
    condition=None,
    subtract_condition: bool = False,
)

This computes dst + (lhs * rhs).

Parameters:

Name	Type	Description	Default
dst	Qubits or None	Destination to add into. If None, allocate a new register	required
lhs	Qubits	Left-hand multiply operand	required
rhs	Qubits	Right-hand multiply operand	required
ctrl	Qubits	Quantum control	None
subtract_condition	Qubits or bool	If True (classically or quantumly), subtract instead of adding	False
release_ancillae	bool	If True, uncompute and release auxiliary qubits. If False, hold auxiliary qubits till uncompute.	True

Notes

release_ancillae allows us to trade off Toffoli cost vs. qubit cost:

• If True, then the ONLY effect remaining after compute() is the desired sum.
• If False, it uses fewer gates but rhs and the auxiliary qubits will be scrambled until uncompute.

---

OptimizedNaiveMultiplyAdd Class

psiqworkbench.qubricks.qbk_gidney_arithmetic.OptimizedNaiveMultiplyAdd

OptimizedNaiveMultiplyAdd(
    params=None, routines=None, **kwargs
)

Bases: MultiplyAdd

Wrapper for Naive Multiply-Add.

compute

compute(
    dst,
    lhs,
    rhs,
    ctrl=None,
    release_ancillae: bool = True,
    condition=None,
    subtract_condition: bool = False,
)

This computes dst + (lhs * rhs).

Parameters:

Name	Type	Description	Default
dst	Qubits or None	Destination to add into. If None, allocate a new register	required
lhs	Qubits	Left-hand multiply operand	required
rhs	Qubits	Right-hand multiply operand	required
ctrl	Qubits	Quantum control	None
subtract_condition	Qubits or bool	If True (classically or quantumly), subtract instead of adding	False
release_ancillae	bool	If True, uncompute and release auxiliary qubits. If False, hold auxiliary qubits till uncompute.	True

Notes

release_ancillae allows us to trade off Toffoli cost vs. qubit cost:

• If True, then the ONLY effect remaining after compute() is the desired sum.
• If False, it uses fewer gates but rhs and the auxiliary qubits will be scrambled until uncompute.

---

RSqrt Class

psiqworkbench.qubricks.qbk_gidney_arithmetic.RSqrt

RSqrt(**kwargs)

Bases: Qubrick

Fast reciprocal square root.

compute

compute(
    lhs,
    ctrl=None,
    release_ancillae: bool = True,
    condition=None,
) -> None

This computes reg = rsqrt(reg) in-place, where the input is a positive integer and the output is a fixed-point fraction with all bits below the decimal.

Parameters:

Name	Type	Description	Default
lhs	Qubits	Left-hand operand and destination	required
ctrl	Qubits	Quantum control	None
release_ancillae	bool	If True, uncompute and release auxiliary qubits. If False, hold auxiliary qubits till uncompute.	True

Note

For more details, see Built-in Qubricks tutorial

---

GidneyLadder Class

psiqworkbench.qubricks.qbk_gidney_arithmetic.GidneyLadder

GidneyLadder(**kwargs)

Bases: Qubrick

Basic tall-Toffoli-to-Gidney-elbow reduction.

compute

compute(
    ctrl=None, reduce_to: int = 2, condition=None
) -> None

This reduces tall condition stacks using Gidney elbows.

Parameters:

Name	Type	Description	Default
ctrl	Qubits	Condition qubits to reduce	None
reduce_to	int	Max number of conditions to output	2