quantum_ruby 0.1.1 → 0.9.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 68be46a736a6bdd4f752c9232f65cddf546ca4dbf8b9b72f41fb6237860871e2
-  data.tar.gz: b0a51c8d0e885817db849e60f87a187e20a90dce5113d0e2c4a9b8962c6a2f85
+  metadata.gz: 6a4adb23b5e25ad751274853dad70416389645bab876ab7aacfa239ce329f8e6
+  data.tar.gz: 5dd0190e206fd8dd80c93af2ab6ffec1044566bd5ab1083e3c6801699fb5b39a
 SHA512:
-  metadata.gz: edbe804cdc48d763966e8b0f343aa8ab4d9dd00595f84b5951289311ca5f81623465b5ade7c5462b263b6402a4d81f4c86370a6360fd1e75db6b906462be1415
-  data.tar.gz: 72c0d4713f3025e9702c45aa05a9c56746e59f715322c769db7df1fe4a95c8b60bff536149e460500ad470e43a4e0fc0be27230dfabfe903a40996a1bf9f0658
+  metadata.gz: 5b8cb10f0ae00388c456624a8df9aa8943e70e0644b799dc6335fc2fc98329dbac576716d23f9427618ae3e950354fff4835a01edd84f53a850a6032b254de3b
+  data.tar.gz: dd3d0d8cb7497b26cb22cae572377f7e452bff84d15b52ab5c18b6bef5888da1ac3f336a227fe824ca7490229df20f75742504a0ae027be40fb63ae373896f82

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    quantum_ruby (0.1.1)
+    quantum_ruby (0.9.0)
 
 GEM
   remote: https://rubygems.org/

data/README.md

@@ -1,4 +1,3 @@
-
 # QuantumRuby
 
 This is a quantum computer simulator in under 300 lines of ruby. Meaning you can build arbitrarily large quantum circuits programmatically and simulate their behaviours.

data/examples/auto_scaling_gates_examples.rb

@@ -0,0 +1,36 @@
+require_relative '../lib/quantum_ruby'
+
+# Auto scale gates
+# Sometimes we want to apply a gate to N-qubits that takes only takes less than N inputs
+# To accomodate this we can scale the gatewith the identity matrix.
+# This has the effect of taking in a larger input size but still only affecting less than N inputs
+# More details here:
+#   https://en.wikipedia.org/wiki/Quantum_logic_gate#Application_on_entangled_states
+
+# Circuit:
+#   Before scaling
+#   x --- | H Gate | -- | C_NOT  | -- | H Gate | -
+#   y ----------------- |  GATE  | ---------------
+#
+#   After scaling
+#   x --- | H Gate | -- | C_NOT  | -- | H Gate  | -
+#   y ----------------- |  GATE  | -- | I2 Gate | -
+x = Qubit.new(1, 0)
+y = Qubit.new(1, 0)
+step_1 = H_GATE * x # single input
+step_2 = C_NOT_GATE.*(step_1, y) # double input, so future gates must accept 2 qubits
+raise unless H_GATE.*(step_2, scale: :down) == State.new(0.5 * Matrix[[1], [1], [1], [-1]])
+
+# Circuit:
+#   Before scaling
+#   x --- | H Gate | -- | C_NOT  | ---------------
+#   y ----------------- |  GATE  | -- | H Gate | -
+#
+#   After scaling
+#   x --- | H Gate | -- | C_NOT  | -- | I2 Gate | -
+#   y ----------------- |  GATE  | -- | H Gate  | -
+x = Qubit.new(1, 0)
+y = Qubit.new(1, 0)
+step_1 = H_GATE * x # single input
+step_2 = C_NOT_GATE.*(step_1, y) # double input, so future gates must accept 2 qubits
+raise unless H_GATE.*(step_2, scale: :up) == State.new(0.5 * Matrix[[1], [1], [1], [-1]])

data/examples/backward_control_gate_examples.rb

@@ -0,0 +1,29 @@
+require_relative '../lib/quantum_ruby'
+
+# In classical computing a control bit only affects the target bit
+# These can also be done with a quantum circuit
+# Circuit:
+#   x ----- | C_NOT  | ----- x
+#   y ----- |  GATE  | ----- y flipped
+x = Qubit.new(0, 1) # the control bit, 1
+y = Qubit.new(1, 0) # the target bit, 0
+C_NOT_GATE.*(x, y).measure
+# Since the control bit is set, we expect the target to flip
+raise unless y == Qubit.new(0, 1)
+
+# What is strange is that depending on how the qubits are entangled we can have
+# the target bit toggling the control bit!
+# Details can be read here:
+#   https://en.wikipedia.org/wiki/Controlled_NOT_gate#Constructing_the_Bell_State_%7F'"`UNIQ--postMath-00000039-QINU`"'%7F
+#   https://quantum.country/qcvc#the-controlled-not-gate
+
+# Backwards control gate
+# Circuit:
+#   x ---| H    | -- | C_NOT  | -- | H    |---- x flipped
+#   y ---| Gate | -- |  GATE  | -- | Gate |---- y
+x = Qubit.new(1, 0) # the control bit, 1
+y = Qubit.new(0, 1) # the target bit, 0
+h_big = H_GATE.kronecker(H_GATE)
+raise unless (h_big * (C_NOT_GATE * h_big)).*(x, y).measure
+# control bit is flipped but target is the same!
+raise unless x == Qubit.new(0, 1) && y == Qubit.new(0, 1)

data/examples/bell_state_examples.rb

@@ -0,0 +1,22 @@
+require_relative '../lib/quantum_ruby'
+
+# Bell state
+# Maximally entangle qubits. This is one of the coolest results of quantum computing.
+# Allows for things such as reverse control gates and quantum teleportation.
+# More details here:
+#   https://en.wikipedia.org/wiki/Bell_state#Applications
+#   https://en.wikipedia.org/wiki/Controlled_NOT_gate#Constructing_the_Bell_State_%7F'"`UNIQ--postMath-00000039-QINU`"'%7F
+
+# Circuit:
+#   x ---| H    | -- | C_NOT  | -
+#   y ---| Gate | -- |  GATE  | -
+
+# My lay man understanding of maximal entanglement comes from the state that is produced here.
+# Either the result can be 00 or 11 based on the probabilities. In this sense the qubits
+# are completely dependent on one another for the outcome ie. if one is 0 the other is 0, and likewise
+# if one is 1 the other must also be 1. This property holds over great distances so even after separating
+# if either is measure the partner instantly knows the result. This should sound weird because cause and
+# effect would normally be though as being limited by the speed of light.
+x = Qubit.new(1, 0)
+y = Qubit.new(1, 0)
+raise unless C_NOT_GATE.*(H_GATE * x, y) == State.new(Matrix[[0.7071067811865475], [0.0], [0.0], [0.7071067811865475]])

data/examples/building_complex_gate_examples.rb

@@ -0,0 +1,29 @@
+require_relative '../lib/quantum_ruby'
+
+# The Toffoli gate is a 3-qubit control gate (2 control, 1 target)
+# We can build it from more basic quantum gates.
+# We will use 3 gates to build this larger gate
+#  1. Hadamard Gates (H_GATE)
+#  2. Phase Shift Gates (T_GATE)
+#  3. Control Gates (C_NOT_GATE)
+
+# Helper function to perform adjoint of matrix
+# More details here:
+#   https://en.wikipedia.org/wiki/Conjugate_transpose   
+class Matrix; def adjoint; conjugate.transpose; end; end 
+
+# Special variations on our base gates
+# T_GATEa is just the adjoint of a T_GATE
+T_3GATE_ADJOINT = I2.kronecker(I2).kronecker(T_GATE).adjoint
+# C_NOT gate that takes 3 inputs, uses the top as control, ignores the middle, and uses the bottom as target
+# More details here:
+#   https://quantumcomputing.stackexchange.com/questions/9614/how-to-interpret-a-4-qubit-quantum-circuit-as-a-matrix/9615#9615
+#   https://quantumcomputing.stackexchange.com/questions/4252/how-to-derive-the-cnot-matrix-for-a-3-qbit-system-where-the-control-target-qbi
+C_3NOT_GATE = Gate[*Matrix[[1, 0], [0, 0]].kronecker(I2.kronecker(I2)) + Matrix[[0, 0], [0, 1]].kronecker(I2.kronecker(X_GATE))]
+
+# Assembly
+# Circuit:
+# -- | Toffoli | --    ----------------------------|C_3NOT|---------------------------|C_3NOT|----------|C_NOT|--|T_GATE|--|C_NOT|-
+# -- | Gate    | -- == ----------|C_NOT|-----------|      |----------|C_NOT|----------|      |-|T_GATE|-|Gate |--|T_GATEa|-|Gate |-
+# -- |         | --    -|H_GATE|-|Gate |-|T_GATEa|-|Gate  |-|T_GATE|-|Gate |-|T_GATE|-|Gate  |-|T_GATE|-|H_GATE|-------------------
+raise unless TOFFOLI_GATE == C_NOT_GATE.*(T_GATE.kronecker(T_GATE.adjoint).*(C_NOT_GATE.kronecker(H_GATE).*(I2.kronecker(T_GATE).kronecker(T_GATE).*(C_3NOT_GATE.*(T_3GATE_ADJOINT.*(C_NOT_GATE.*(T_GATE.*(C_3NOT_GATE.*(T_3GATE_ADJOINT.*(C_NOT_GATE.*(I2.kronecker(I2).kronecker(H_GATE), scale: :up))), scale: :up), scale: :up))))), scale: :down), scale: :down).round

data/examples/ket_examples.rb

@@ -0,0 +1,13 @@
+require_relative '../lib/quantum_ruby'
+# 'Ket' visualization
+# Supports Bra-ket notation
+x = Qubit.new(1, 0)
+raise unless x.to_s == '1|0>'
+
+x = Qubit.new(0, 1)
+raise unless x.to_s == '1|1>'
+
+# Complex number visualization
+x = Qubit.new((1 + 1i) / 2, 1i / Math.sqrt(2))
+raise unless x.to_s == '1/2+1/2i|0> + 0.707i|1>'
+raise unless x.state == "[1/2+1/2i\n 0.707i]"

data/examples/kronecker_examples.rb

@@ -0,0 +1,11 @@
+require_relative '../lib/quantum_ruby'
+# Kronecker product test
+# More details here:
+#   https://en.wikipedia.org/wiki/Kronecker_product
+x = Matrix[[1, 2], [3, 4]]
+y = Matrix[[0, 5], [6, 7]]
+raise unless x.kronecker(y) == Matrix[[0, 5, 0, 10], [6, 7, 12, 14], [0, 15, 0, 20], [18, 21, 24, 28]]
+
+x = Matrix[[1], [2]]
+y = Matrix[[3], [4]]
+raise unless x.kronecker(y) == Matrix[[3], [4], [6], [8]]

data/examples/measuring_examples.rb

@@ -0,0 +1,72 @@
+require_relative '../lib/quantum_ruby'
+
+# Measuring
+1_000.times do
+  x = Qubit.new(1, 0).measure
+  raise unless x.zero?
+
+  x = Qubit.new(0, 1).measure
+  raise unless x == 1
+
+  # H_GATE puts qubits into a uniform superposition
+  s = (H_GATE * Qubit.new(0, 1))
+  case s.measure[0]
+  when 0
+    raise unless s == State.new(Matrix[[1], [0]])
+  when 1
+    raise unless s == State.new(Matrix[[0], [1]])
+  else
+    raise
+  end
+
+  # Multi qubit systems update individual qubits to their new state after a measurement occurs
+  x = Qubit.new(1, 0)
+  y = Qubit.new(0, 1)
+  a = Array.new(4, 0)
+  a[rand(4)] = 1
+  r = State.new(Matrix.column_vector(a), [x, y]).measure.join.to_i(2)
+  case r
+  when 0
+    raise unless x == Qubit.new(1, 0) && y == Qubit.new(1, 0)
+  when 1
+    raise unless x == Qubit.new(1, 0) && y == Qubit.new(0, 1)
+  when 2
+    raise unless x == Qubit.new(0, 1) && y == Qubit.new(1, 0)
+  when 3
+    raise unless x == Qubit.new(0, 1) && y == Qubit.new(0, 1)
+  end
+
+  x = Qubit.new(1, 0)
+  y = Qubit.new(0, 1)
+  z = Qubit.new(0, 1)
+  a = Array.new(8, 0)
+  a[rand(8)] = 1
+  r = State.new(Matrix.column_vector(a), [x, y, z]).measure.join.to_i(2)
+  case r
+  when 0
+    raise unless x == Qubit.new(1, 0) && y == Qubit.new(1, 0) && z == Qubit.new(1, 0)
+  when 1
+    raise unless x == Qubit.new(1, 0) && y == Qubit.new(1, 0) && z == Qubit.new(0, 1)
+  when 2
+    raise unless x == Qubit.new(1, 0) && y == Qubit.new(0, 1) && z == Qubit.new(1, 0)
+  when 3
+    raise unless x == Qubit.new(1, 0) && y == Qubit.new(0, 1) && z == Qubit.new(0, 1)
+  when 4
+    raise unless x == Qubit.new(0, 1) && y == Qubit.new(1, 0) && z == Qubit.new(1, 0)
+  when 5
+    raise unless x == Qubit.new(0, 1) && y == Qubit.new(1, 0) && z == Qubit.new(0, 1)
+  when 6
+    raise unless x == Qubit.new(0, 1) && y == Qubit.new(0, 1) && z == Qubit.new(1, 0)
+  when 7
+    raise unless x == Qubit.new(0, 1) && y == Qubit.new(0, 1) && z == Qubit.new(0, 1)
+  end
+end
+
+# The following two show an example of reversing a previously applied Hadamard gate
+# Circuit: 1/sqrt(2)|0> + 1/sqrt(2)|1> ----- H ------ 1|0>
+x = Qubit.new(1 / Math.sqrt(2), 1 / Math.sqrt(2))
+raise unless (H_GATE * x).measure[0].zero?
+
+# Circuit: 1/sqrt(2)|0> + 1/sqrt(2)|1> ----- H ------ 1|1>
+x = Qubit.new(1 / Math.sqrt(2), -1 / Math.sqrt(2))
+raise unless (H_GATE * x).measure[0] == 1

data/examples/measuring_partial_examples.rb

@@ -0,0 +1,90 @@
+require_relative '../lib/quantum_ruby'
+# Partial Measure
+# After a partial measure qubits are no longer equal
+# One outcome is chosen for the desired qubit and all other qubits collapse to a 
+# normalized version of the new state
+
+# y is measured in a system of 2 qubits
+x = Qubit.new(0, 1)
+y = Qubit.new(0, 1)
+raise unless x == y
+State.new(Matrix.column_vector([0, Math.sqrt(0.8), Math.sqrt(0.2), 0]), [x, y]).measure_partial(y)
+raise if x == y
+
+# y is measure in a system of 3 qubits
+x = Qubit.new(0, 1)
+y = Qubit.new(0, 1)
+z = Qubit.new(0, 1)
+State.new(Matrix.column_vector([0, 0.5, 0.5, 0, 0, 0.5, 0.5, 0]), [x, y, z]).measure_partial(y)
+raise if (y == x) || (z == y)
+
+# The following shows all possibles outcomes, randomized and verified
+# Can be a good way to understand partial measuring by considering the logics tables
+# More information can be found at these resources:
+#   https://cs.stackexchange.com/questions/71462/how-are-partial-measurements-performed-on-a-n-qubit-quantum-circuit
+#   https://quantum.country/teleportation#background_partial_measurement
+1_000.times do
+  x = Qubit.new(0, 1)
+  y = Qubit.new(0, 1)
+  z = Qubit.new(0, 1)
+  a = Array.new(8, 0)
+  a[rand(8)] = 1
+  r = State.new(Matrix.column_vector(a), [x, y, z]).measure_partial(y, z).join.to_i(2)
+  case r
+  when 0
+    raise unless y == Qubit.new(1, 0) && z == Qubit.new(1, 0)
+  when 1
+    raise unless y == Qubit.new(1, 0) && z == Qubit.new(0, 1)
+  when 2
+    raise unless y == Qubit.new(0, 1) && z == Qubit.new(1, 0)
+  when 3
+    raise unless y == Qubit.new(0, 1) && z == Qubit.new(0, 1)
+  else
+    raise
+  end
+
+  i = Qubit.new(0, 1)
+  y = Qubit.new(0, 1)
+  z = Qubit.new(0, 1)
+  a = Array.new(8, 0)
+  a[rand(8)] = 1
+  r = State.new(Matrix.column_vector(a), [y, z, i]).measure_partial(i, y).join.to_i(2)
+  case r
+  when 0
+    raise unless y == Qubit.new(1, 0) && i == Qubit.new(1, 0)
+  when 1
+    raise unless y == Qubit.new(1, 0) && i == Qubit.new(0, 1)
+  when 2
+    raise unless y == Qubit.new(0, 1) && i == Qubit.new(1, 0)
+  when 3
+    raise unless y == Qubit.new(0, 1) && i == Qubit.new(0, 1)
+  else
+    raise
+  end
+
+  x = Qubit.new(0, 1)
+  y = Qubit.new(0, 1)
+  z = Qubit.new(0, 1)
+  i = Qubit.new(0, 1)
+  a = Array.new(16, 0)
+  a[rand(16)] = 1
+  r = State.new(Matrix.column_vector(a), [x, i, y, z]).measure_partial(x, y, z).join.to_i(2)
+  case r
+  when 0
+    raise unless x == Qubit.new(1, 0) && y == Qubit.new(1, 0) && z == Qubit.new(1, 0)
+  when 1
+    raise unless x == Qubit.new(1, 0) && y == Qubit.new(1, 0) && z == Qubit.new(0, 1)
+  when 2
+    raise unless x == Qubit.new(1, 0) && y == Qubit.new(0, 1) && z == Qubit.new(1, 0)
+  when 3
+    raise unless x == Qubit.new(1, 0) && y == Qubit.new(0, 1) && z == Qubit.new(0, 1)
+  when 4
+    raise unless x == Qubit.new(0, 1) && y == Qubit.new(1, 0) && z == Qubit.new(1, 0)
+  when 5
+    raise unless x == Qubit.new(0, 1) && y == Qubit.new(1, 0) && z == Qubit.new(0, 1)
+  when 6
+    raise unless x == Qubit.new(0, 1) && y == Qubit.new(0, 1) && z == Qubit.new(1, 0)
+  when 7
+    raise unless x == Qubit.new(0, 1) && y == Qubit.new(0, 1) && z == Qubit.new(0, 1)
+  end
+end

data/examples/quantum_teleporation_examples.rb

@@ -0,0 +1,52 @@
+require_relative '../lib/quantum_ruby'
+
+# Quantum Teleportation
+# More details here:
+#   https://quantum.country/teleportation
+#   https://en.wikipedia.org/wiki/Quantum_teleportation#Non-technical_summary
+#   https://cs.uwaterloo.ca/~watrous/LectureNotes/CPSC519.Winter2006/04.pdf
+
+1_000.times do
+  # alice will teleport 'a' to bob
+  a = Qubit.new(0, 1)
+  b = Qubit.new(1, 0)
+  c = Qubit.new(1, 0)
+  # dup so we have copy of the original state to verify transportation.
+  # In practice neither Alice nor Bob knows these values and our final check
+  # cannot be preformed. Through the maths we can understand that this holds
+  # regardless of not knowing initial values.
+  a_dup = a.dup
+
+  # first entangle 'b' and 'c'
+  s = C_NOT_GATE.*(H_GATE * b, c)
+  # bob takes 'c' far away
+
+  # Alice continues
+  g = H_GATE.kronecker(I2).kronecker(I2) * C_NOT_GATE.kronecker(I2)
+  s = g.*(a, s)
+
+  # Alice measure her two qubits and sends classical bits to bob
+  z, x = s.measure_partial(a, b)
+  case [z, x].join.to_i(2)
+  when 0
+    raise unless a == Qubit.new(1, 0) && b == Qubit.new(1, 0)
+  when 1
+    raise unless a == Qubit.new(1, 0) && b == Qubit.new(0, 1)
+  when 2
+    raise unless a == Qubit.new(0, 1) && b == Qubit.new(1, 0)
+  when 3
+    raise unless a == Qubit.new(0, 1) && b == Qubit.new(0, 1)
+  else
+    raise
+  end
+
+  # depending on what bobs gets, he applies gates to his qubit
+  # and is able to regain Alice’s 'a' qubit's original state instantly!
+  c = X_GATE * c if x == 1
+  c = Z_GATE * c if z == 1
+
+  # Bob now knows Alice's original state. This is surprising, because Alice nor Bob
+  # needed to EVER know the state prior and this information is "instantly" transferred
+  # across any distance upon Alice's measurements
+  raise unless a_dup == c
+end

data/examples/readme_examples.rb

@@ -1,4 +1,4 @@
-require 'quantum_ruby'
+require_relative '../lib/quantum_ruby'
 # All the readme examples tested
 
 # qubit_1 = Qubit.new(1, 0)

data/examples/simple_gate_examples.rb

@@ -0,0 +1,24 @@
+require_relative '../lib/quantum_ruby'
+
+# NOT gate
+# Circuit: 1|0> ----- X ------- 1|1> 
+z = Qubit.new(1, 0)
+raise unless X_GATE * z == State.new(Matrix[[0], [1]])
+
+# Hadamard Gate ie. Uniform superposition gate
+# Circuit: 1|0> ----- H ------- 1/sqrt(2)|0> + 1/sqrt(2)|1> 
+z = Qubit.new(1, 0)
+raise unless H_GATE * z == State.new(Matrix[[1 / Math.sqrt(2)], [1 / Math.sqrt(2)]])
+
+# Demonstrate gate reversibility
+# Since gates are unitary, applying them twice has the effect of reversing computation
+# Circuit: 0.6|0> + 0.8|1> ---- H --- H --- 0.6|0> + 0.8|1>
+z = Qubit.new(0.6, 0.8)
+raise unless H_GATE * H_GATE * z == State.new(Matrix[[0.6], [0.8]])
+
+# A mathematical demonstration of gate reversibility ie. Unitary inversion of gates
+# More details here:
+#   https://en.wikipedia.org/wiki/Unitary_matrix
+#   https://quantum.country/qcvc#what-does-it-mean-to-be-unitary
+class Matrix; def adjoint; conjugate.transpose; end; end # helper function
+raise unless (C_NOT_GATE * H_GATE.kronecker(Matrix.identity(2))).adjoint == H_GATE.kronecker(Matrix.identity(2)) * C_NOT_GATE

data/lib/quantum_ruby.rb

@@ -1,8 +1,13 @@
-require "quantum_ruby/version"
+require 'quantum_ruby/version'
 require 'matrix'
 
-# Overrides for base Ruby classes
+#
+# Overrides for base ruby base classes
 class Matrix
+  #
+  # Takes two arbitrary sized resulting in a block matrix
+  # according to the Kronecker Product
+  # Details: https://en.wikipedia.org/wiki/Kronecker_product
   def kronecker(m)
     raise ErrOperationNotDefined, [__method__, self.class, m.class] unless m.is_a?(Matrix)
 
@@ -30,23 +35,23 @@ class Complex
     Complex(real.round(digits), imag.round(digits))
   end
 end
-# End of Overrides for base Ruby classes
+# End of Overrides for base ruby base classes
 
-ZERO_KET       = '|0>'
-ONE_KET        = '|1>'
-ADD_SYM        = ' + '
-ADD_SYM_SQUISH = '+'
-I_SYM          = 'i'
+ZERO_KET       = '|0>'.freeze
+ONE_KET        = '|1>'.freeze
+ADD_SYM        = ' + '.freeze
+ADD_SYM_SQUISH = '+'.freeze
+I_SYM          = 'i'.freeze
 
 module ExceptionForQuantum
   class NormalizationConstraint < StandardError
     def initialize
-      super('Normalization constraint failed. Amplitudes must equal 1')
+      super('Normalization constraint failed. Sum of squared amplitudes must equal 1')
     end
   end
 
   class ColumnMatrxiConstraint < StandardError
-    def initalize
+    def initialize
       super('Vector supplied must be a Matrix with a single column.')
     end
   end
@@ -63,13 +68,18 @@ module QuantumComplexPrinter
   end
 end
 
+#
+# Contains helper functions for Qubit and State objects
 module QuantumVector
   include ExceptionForQuantum
   using QuantumComplexPrinter
 
-
   PRECISION = 14
 
+  def ==(other)
+    @vector.map { |i| i.round(PRECISION) } == other.vector.map { |i| i.round(PRECISION) }
+  end
+
   def state
     out = '['
     out << @vector[0, 0].to_s
@@ -79,35 +89,74 @@ module QuantumVector
     out << ']'
   end
 
-  def ==(other)
-    @vector.map { |i| i.round(PRECISION) } == other.vector.map { |i| i.round(PRECISION) }
-  end
-
   private
 
-  def column_vector?
-    raise ColumnMatrxiConstraint unless @vector.is_a?(Matrix) && (@vector.column_count == 1)
-  end
-
+  #
+  # Qubit and State vectors must be normalized so that the sum
+  # of squared amplitudes is equal to 1. This is a probability constraints saying that probabilities
+  # must sum to 1
+  #   Qubit.new(1, 1) # fail
+  #   Qubit.new(1, 0) # pass
+  #   Qubit.new(1/Math.sqrt(2), 1/Math.sqrt(2)) # pass
   def normalized?
     raise NormalizationConstraint unless @vector.reduce(0) { |i, v| i + v.abs2 }.round(PRECISION) == 1
   end
 end
 
+#
+# The +Qubit+ class represents quantum bit. They are stored a 2-dimensional column vector.
+# Qubits can be operated on via matrix multiplication or measurement.
 class Qubit
-  attr_reader :vector
+  attr_reader   :vector
   attr_accessor :entangled
   include QuantumVector
   using QuantumComplexPrinter
 
-  ENTANGLED_WARNING = "Alert:  This qubit is entangled.\n\tPlease locate and measure the State\n\tthat contains this qubit's superposition."
+  ENTANGLED_WARNING = "Alert:  This qubit is entangled.\n\tPlease locate and measure the State\n\tthat contains this qubit's superposition.".freeze
 
+  #
+  # Takes two values for the superposition of |0> and |1> respectively and store it in a Qubit
+  # Values must obey the normalization constraint
   def initialize(zero, one)
     @vector = Matrix[[zero], [one]]
-    column_vector?
     normalized?
   end
 
+  #
+  # Measurement can only happen at the expense of information elsewhere in the system.
+  # If two qubits are combined then their combined state becomes dependent so doing something to one
+  # can affect the other. This applies both to further operations or measurement.
+  # After measurement all related qubits' superpositions collapse to a classical interpretation, either 0 or 1
+  #   Qubit.news(1, 0).to_s # 0, qubit remains the same
+  #   Qubit.news(0, 1).to_s # 1, qubit remains the same
+  #   Qubit.new(1/Math.sqrt(2), 1/Math.sqrt(2)) # either 0 or 1 and qubit superposition collapses
+  #                                               to look like one the above qubits depending on the outcome
+  def measure
+    if rand < @vector[0, 0].abs2
+      @vector = [1, 0]
+      0
+    else
+      @vector = [0, 1]
+      1
+    end
+  end
+
+  #
+  # Return the qubit's superposition as a pretty printed array
+  #   Qubit.news(1, 0).state
+  #   #   [1
+  #   #    0]
+  def state
+    return if entangled?
+
+    super
+  end
+
+  #
+  # Returns the qubit's superposition in Bra-Ket notation
+  #   Qubit.news(1, 0).to_s # 1|0>
+  #   Qubit.news(0, 1).to_s # 1|1>
+  #   Qubit.new(1/Math.sqrt(2), 1/Math.sqrt(2)) # 0.707|0> + 0.707|1>
   def to_s
     return if entangled?
 
@@ -121,22 +170,6 @@ class Qubit
     out
   end
 
-  def state
-    return(puts(ENTANGLED_WARNING)) if entangled?
-
-    super
-  end
-
-  def measure
-    if rand < @vector[0, 0].abs2
-      @vector = [1, 0]
-      0
-    else
-      @vector = [0, 1]
-      1
-    end
-  end
-
   private
 
   def el(row)
@@ -144,26 +177,32 @@ class Qubit
     out.is_a?(Float) || out.is_a?(Complex) ? out.round(PRECISION) : out
   end
 
+  def entangled?
+    puts ENTANGLED_WARNING if entangled
+    entangled
+  end
+
   def vector=(array)
     @vector = Matrix.column_vector(array)
     normalized?
   end
-
-  def entangled?
-    if entangled
-      puts ENTANGLED_WARNING
-      true
-    else
-      false
-    end
-  end
 end
 
+#
+# The +State+ class represents a combination of qubits' superpositions. They are stored a 2**n-dimensional column vector where
+# N is the numbers of qubits entangled.
+# State is usually produce after the applications of gates to a number of qubits and is continually passed forward through
+# the quantum circuit until a measurement is made.
+# State can be operated on via matrix multiplication or measurement(partial or otherwise).
 class State
   attr_reader  :vector
   attr_reader  :qubits
   include QuantumVector
 
+  #
+  # Takes a column matrix representing N qubits and the corresponding superposition
+  # Values of the matrix must obey the normalization constraint
+  # Additional takes references to the actual qubits so that they can be updated in the future
   def initialize(vector, *qubits)
     @vector = vector
     column_vector?
@@ -172,36 +211,17 @@ class State
     @qubits = qubits.flatten.tap { |i| i.each { |j| j.entangled = true } }
   end
 
+  #
+  # Returns an array of bits representing the final state of all entangled qubits
+  # All qubits are written with their new state and all superposition information is lost
   def measure
-    # "determine' 'winner'
-    acc = 0
-    out = nil
-    secret = rand
-
-    @vector.to_a.each_with_index do |probability, index|
-      acc += probability[0].abs2
-      if acc > secret
-        out = index
-        break
-      end
-    end
-
-    # Reset state
-    @vector = Matrix.column_vector Array.new(@vector.row_count, 0)
-    # Update state
-    @vector.send(:[]=, out, 0, 1)
-
-    # Update each qubit
-    out = out.to_s(2).rjust(size, '0')
-    @qubits.each_with_index do |qubit, index|
-      qubit.entangled = false
-      qubit.send(:vector=, Array.new(2, 0).tap { |vector| vector[out[index].to_i] = 1 })
-    end
-
-    freeze
-    out.split('').map(&:to_i)
+    measure_partial(@qubits)
   end
 
+  #
+  # Takes an array of qubits for which a measurement should be made
+  # Returns an array of bits representing the final state of the requested qubits
+  # All others qubits are written with a normalized state and all superposition information is lost
   def measure_partial(*qubit)
     # find location of our desired qubit(s)
     qubit_ids = qubit.map { |i| @qubits.find_index { |j| j.hash == i .hash } }.sort
@@ -215,11 +235,11 @@ class State
 
     # calculate final probabilities for qubit(s) state
     probabilities = sub_result.sort.to_h.transform_values { |v| v.reduce(0) { |i, p| i + p[0].abs2 } }.values
+
+    # determine 'winner'
     acc = 0
     out = nil
     secret = rand
-
-    # "determine' 'winner'
     probabilities.each_with_index do |probability, index|
       acc += probability
       if acc > secret
@@ -236,25 +256,53 @@ class State
     # Update each qubit
     @qubits.each_with_index do |q, i|
       q.entangled = false
-      if index = qubit_ids.find_index(i)
+      if (index = qubit_ids.find_index(i))
         q.send(:vector=, Array.new(2, 0).tap { |vector| vector[out[index].to_i] = 1 })
       else
         q.send(:vector=, new_state)
       end
     end
-    freeze
+
+    # State should no longer be used
     out.split('').map(&:to_i)
   end
 
   private
 
+  def column_vector?
+    raise ColumnMatrxiConstraint unless @vector.is_a?(Matrix) && (@vector.column_count == 1)
+  end
+
   def size
     Math.log(@vector.row_count, 2)
   end
 end
 
+#
+# The +Gate+ class represents quantum logic gates as matrices.
+# These matrices should be square and unitary. It is up to the user to perform these checks if they want a custom gate.
+# There are a number of gates provided in this gem:
+  # X_GATE
+  # Y_GATE
+  # Z_GATE
+  # H_GATE
+  # T_GATE
+  # C_NOT_GATE
+  # SWAP_GATE
+  # TOFFOLI_GATE
 class Gate < Matrix
-  # can take gate, qubit, or state
+  #
+  # Applies the 'effect' of the gate on the arguments.
+  # The matrix operation on a gate can take multiple arguments but the dimensions must match according to the general
+  # rules of matrix multiplication.
+  #
+  # Gates can be scaled if you want to only affect less than N qubits of a system. Scaling occurs either up or down. If both is desired
+  # choose one direction and manually scale the other direction.
+  # NOTE scaling is done brute force and may no be applicable to the needs of your circuit.
+  # Refer to scaling examples for more details: https://github.com/AlessandroMinali/exanples/auto_scaling_gates_examples.rb
+  #
+  # Can take Gate, Qubit, or State
+  # Results in a new Gate if supplied a Gate, otherwise returns a new State
   def *(*args, scale: nil)
     if scale
       arg = begin
@@ -288,11 +336,45 @@ class Gate < Matrix
 end
 
 I2 = Gate.identity(2)
-X_GATE = Gate[[0, 1], [1, 0]]
-Y_GATE = Gate[[0, -1i], [1i, 0]]
-Z_GATE = Gate[[1, 0], [0, -1]]
-H_GATE = 1 / Math.sqrt(2) * Gate[[1, 1], [1, -1]]
-T_GATE = Gate[[1, 0], [0, Math::E**((1i * Math::PI) / 4)]]
-C_NOT_GATE = Gate[[1, 0, 0, 0], [0, 1, 0, 0], [0, 0, 0, 1], [0, 0, 1, 0]]
-SWAP_GATE = Gate[[1, 0, 0, 0], [0, 0, 1, 0], [0, 1, 0, 0], [0, 0, 0, 1]]
-TOFFOLI_GATE = Gate[[1, 0, 0, 0, 0, 0, 0, 0], [0, 1, 0, 0, 0, 0, 0, 0], [0, 0, 1, 0, 0, 0, 0, 0], [0, 0, 0, 1, 0, 0, 0, 0], [0, 0, 0, 0, 1, 0, 0, 0], [0, 0, 0, 0, 0, 1, 0, 0], [0, 0, 0, 0, 0, 0, 0, 1], [0, 0, 0, 0, 0, 0, 1, 0]]
+
+X_GATE = Gate[
+[0, 1],
+[1, 0]]
+
+Y_GATE = Gate[
+[0, -1i],
+[1i, 0]]
+
+Z_GATE = Gate[
+[1,  0],
+[0, -1]]
+
+H_GATE = 1 / Math.sqrt(2) * Gate[
+[1,  1],
+[1, -1]]
+
+T_GATE = Gate[
+[1,                              0],
+[0, Math::E**((1i * Math::PI) / 4)]]
+
+C_NOT_GATE = Gate[
+[1, 0, 0, 0],
+[0, 1, 0, 0],
+[0, 0, 0, 1],
+[0, 0, 1, 0]]
+
+SWAP_GATE = Gate[
+[1, 0, 0, 0],
+[0, 0, 1, 0],
+[0, 1, 0, 0],
+[0, 0, 0, 1]]
+
+TOFFOLI_GATE = Gate[
+[1, 0, 0, 0, 0, 0, 0, 0],
+[0, 1, 0, 0, 0, 0, 0, 0],
+[0, 0, 1, 0, 0, 0, 0, 0],
+[0, 0, 0, 1, 0, 0, 0, 0],
+[0, 0, 0, 0, 1, 0, 0, 0],
+[0, 0, 0, 0, 0, 1, 0, 0],
+[0, 0, 0, 0, 0, 0, 0, 1],
+[0, 0, 0, 0, 0, 0, 1, 0]]

data/lib/quantum_ruby/version.rb

@@ -1,3 +1,3 @@
 module QuantumRuby
-  VERSION = "0.1.1"
+  VERSION = "0.9.0"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: quantum_ruby
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: 0.9.0
 platform: ruby
 authors:
 - Alessandro
@@ -53,8 +53,17 @@ files:
 - Rakefile
 - bin/console
 - bin/setup
-- examples/general.rb
+- examples/auto_scaling_gates_examples.rb
+- examples/backward_control_gate_examples.rb
+- examples/bell_state_examples.rb
+- examples/building_complex_gate_examples.rb
+- examples/ket_examples.rb
+- examples/kronecker_examples.rb
+- examples/measuring_examples.rb
+- examples/measuring_partial_examples.rb
+- examples/quantum_teleporation_examples.rb
 - examples/readme_examples.rb
+- examples/simple_gate_examples.rb
 - lib/quantum_ruby.rb
 - lib/quantum_ruby/version.rb
 - quantum_ruby.gemspec

data/examples/general.rb

@@ -1,266 +0,0 @@
-require 'quantum_ruby'
-# should be added in upcoming ruby/matrix patch
-class Matrix
-  def adjoint
-    conjugate.transpose
-  end
-end
-
-# Matrix * test
-a = Matrix[[1, 2, 3], [4, 5, 6]]
-b = Matrix[[7, 8], [9, 10], [11, 12]]
-raise unless a * b == Matrix[[58, 64], [139, 154]]
-
-# Matrix * test
-a = Matrix[[1, 2], [3, 4]]
-b = Matrix[[2, 0], [1, 2]]
-raise unless a * b == Matrix[[4, 4], [10, 8]]
-
-# Kronecker product test
-x = Matrix[[1, 2], [3, 4]]
-y = Matrix[[0, 5], [6, 7]]
-raise unless x.kronecker(y) == Matrix[[0, 5, 0, 10], [6, 7, 12, 14], [0, 15, 0, 20], [18, 21, 24, 28]]
-
-x = Matrix[[1], [2]]
-y = Matrix[[3], [4]]
-raise unless x.kronecker(y) == Matrix[[3], [4], [6], [8]]
-
-# 'Ket' visualization
-x = Qubit.new(1, 0)
-raise unless x.to_s == '1|0>'
-
-# Complex number visualization
-x = Qubit.new((1 + 1i) / 2, 1i / Math.sqrt(2))
-raise unless x.to_s == '1/2+1/2i|0> + 0.707i|1>'
-raise unless x.state == "[1/2+1/2i\n 0.707i]"
-
-# NOT gate
-z = Qubit.new(1, 0)
-raise unless X_GATE * z == State.new(Matrix[[0], [1]])
-
-# Uniform superposition gate
-z = Qubit.new(1, 0)
-raise unless H_GATE * z == State.new(Matrix[[1 / Math.sqrt(2)], [1 / Math.sqrt(2)]])
-
-# Demonstrate gate reversibility
-z = Qubit.new(0.6, 0.8)
-raise unless H_GATE * H_GATE * z == State.new(Matrix[[0.6], [0.8]])
-
-# Measuring
-1_000.times do
-  x = Qubit.new(1, 0).measure
-  raise unless x.zero?
-
-  x = Qubit.new(0, 1).measure
-  raise unless x == 1
-
-  # equal chance of result
-  s = (H_GATE * Qubit.new(0, 1))
-  case s.measure[0]
-  when 0
-    raise unless s == State.new(Matrix[[1], [0]])
-  when 1
-    raise unless s == State.new(Matrix[[0], [1]])
-  else
-    raise
-  end
-
-  x = Qubit.new(1, 0)
-  y = Qubit.new(0, 1)
-  a = Array.new(4, 0)
-  a[rand(4)] = 1
-  r = State.new(Matrix.column_vector(a), [x, y]).measure.join.to_i(2)
-  case r
-  when 0
-    raise unless x == Qubit.new(1, 0) && y == Qubit.new(1, 0)
-  when 1
-    raise unless x == Qubit.new(1, 0) && y == Qubit.new(0, 1)
-  when 2
-    raise unless x == Qubit.new(0, 1) && y == Qubit.new(1, 0)
-  when 3
-    raise unless x == Qubit.new(0, 1) && y == Qubit.new(0, 1)
-  end
-
-  x = Qubit.new(1, 0)
-  y = Qubit.new(0, 1)
-  z = Qubit.new(0, 1)
-  a = Array.new(8, 0)
-  a[rand(8)] = 1
-  r = State.new(Matrix.column_vector(a), [x, y, z]).measure.join.to_i(2)
-  case r
-  when 0
-    raise unless x == Qubit.new(1, 0) && y == Qubit.new(1, 0) && z == Qubit.new(1, 0)
-  when 1
-    raise unless x == Qubit.new(1, 0) && y == Qubit.new(1, 0) && z == Qubit.new(0, 1)
-  when 2
-    raise unless x == Qubit.new(1, 0) && y == Qubit.new(0, 1) && z == Qubit.new(1, 0)
-  when 3
-    raise unless x == Qubit.new(1, 0) && y == Qubit.new(0, 1) && z == Qubit.new(0, 1)
-  when 4
-    raise unless x == Qubit.new(0, 1) && y == Qubit.new(1, 0) && z == Qubit.new(1, 0)
-  when 5
-    raise unless x == Qubit.new(0, 1) && y == Qubit.new(1, 0) && z == Qubit.new(0, 1)
-  when 6
-    raise unless x == Qubit.new(0, 1) && y == Qubit.new(0, 1) && z == Qubit.new(1, 0)
-  when 7
-    raise unless x == Qubit.new(0, 1) && y == Qubit.new(0, 1) && z == Qubit.new(0, 1)
-  end
-end
-
-x = Qubit.new(1 / Math.sqrt(2), 1 / Math.sqrt(2))
-raise unless (H_GATE * x).measure[0].zero?
-
-x = Qubit.new(1 / Math.sqrt(2), -1 / Math.sqrt(2))
-raise unless (H_GATE * x).measure[0] == 1
-
-# Backwards control gate!
-x = Qubit.new(1, 0)
-y = Qubit.new(0, 1)
-h_big = H_GATE.kronecker(H_GATE)
-z = h_big * (C_NOT_GATE * h_big)
-raise unless z.*(x, y) == State.new(Matrix[[0.0], [0.0], [0.0], [1.0]])
-
-# Bell state
-x = Qubit.new(1, 0)
-y = Qubit.new(1, 0)
-raise unless C_NOT_GATE.*(H_GATE * x, y) == State.new(Matrix[[0.7071067811865475], [0.0], [0.0], [0.7071067811865475]])
-
-# Unitary inversion of gates
-raise unless (C_NOT_GATE * H_GATE.kronecker(Matrix.identity(2))).adjoint == H_GATE.kronecker(Matrix.identity(2)) * C_NOT_GATE
-
-# Auto scale gates
-z = C_NOT_GATE.*(H_GATE * x, y)
-raise unless H_GATE.*(z, scale: :down) == State.new(0.5 * Matrix[[1], [1], [1], [-1]])
-
-# TOFFOLI_GATE test
-raise unless TOFFOLI_GATE.*(Qubit.new(0, 1), Qubit.new(0, 1), Qubit.new(0, 1)) == State.new(Matrix.column_vector([0, 0, 0, 0, 0, 0, 1, 0]))
-
-# Build a TOFFOLI_GATE from simple gates (C_NOT, H_GATE, and T_GATE's only)
-T_3GATE_ADJOINT = I2.kronecker(I2).kronecker(T_GATE).adjoint
-C_3NOT_GATE = Gate[*Matrix[[1, 0], [0, 0]].kronecker(I2.kronecker(I2)) + Matrix[[0, 0], [0, 1]].kronecker(I2.kronecker(X_GATE))]
-  raise unless TOFFOLI_GATE == C_NOT_GATE.*(T_GATE.kronecker(T_GATE.adjoint).*(C_NOT_GATE.kronecker(H_GATE).*(I2.kronecker(T_GATE).kronecker(T_GATE).*(C_3NOT_GATE.*(T_3GATE_ADJOINT.*(C_NOT_GATE.*(T_GATE.*(C_3NOT_GATE.*(T_3GATE_ADJOINT.*(C_NOT_GATE.*(I2.kronecker(I2).kronecker(H_GATE), scale: :up))), scale: :up), scale: :up))))), scale: :down), scale: :down).round
-
-# Partial Measure
-x = Qubit.new(0, 1)
-y = Qubit.new(0, 1)
-raise unless x == y
-
-State.new(Matrix.column_vector([0, Math.sqrt(0.8), Math.sqrt(0.2), 0]), [x, y]).measure_partial(y)
-raise if x == y
-
-x = Qubit.new(0, 1)
-y = Qubit.new(0, 1)
-z = Qubit.new(0, 1)
-State.new(Matrix.column_vector([0, 0.5, 0.5, 0, 0, 0.5, 0.5, 0]), [x, y, z]).measure_partial(y)
-raise if (y == x) || (z == y)
-
-1_000.times do
-  x = Qubit.new(0, 1)
-  y = Qubit.new(0, 1)
-  z = Qubit.new(0, 1)
-  a = Array.new(8, 0)
-  a[rand(8)] = 1
-  r = State.new(Matrix.column_vector(a), [x, y, z]).measure_partial(y, z).join.to_i(2)
-  case r
-  when 0
-    raise unless y == Qubit.new(1, 0) && z == Qubit.new(1, 0)
-  when 1
-    raise unless y == Qubit.new(1, 0) && z == Qubit.new(0, 1)
-  when 2
-    raise unless y == Qubit.new(0, 1) && z == Qubit.new(1, 0)
-  when 3
-    raise unless y == Qubit.new(0, 1) && z == Qubit.new(0, 1)
-  else
-    raise
-  end
-
-  i = Qubit.new(0, 1)
-  y = Qubit.new(0, 1)
-  z = Qubit.new(0, 1)
-  a = Array.new(8, 0)
-  a[rand(8)] = 1
-  r = State.new(Matrix.column_vector(a), [y, z, i]).measure_partial(i, y).join.to_i(2)
-  case r
-  when 0
-    raise unless y == Qubit.new(1, 0) && i == Qubit.new(1, 0)
-  when 1
-    raise unless y == Qubit.new(1, 0) && i == Qubit.new(0, 1)
-  when 2
-    raise unless y == Qubit.new(0, 1) && i == Qubit.new(1, 0)
-  when 3
-    raise unless y == Qubit.new(0, 1) && i == Qubit.new(0, 1)
-  else
-    raise
-  end
-
-  x = Qubit.new(0, 1)
-  y = Qubit.new(0, 1)
-  z = Qubit.new(0, 1)
-  i = Qubit.new(0, 1)
-  a = Array.new(16, 0)
-  a[rand(16)] = 1
-  r = State.new(Matrix.column_vector(a), [x, i, y, z]).measure_partial(x, y, z).join.to_i(2)
-  case r
-  when 0
-    raise unless x == Qubit.new(1, 0) && y == Qubit.new(1, 0) && z == Qubit.new(1, 0)
-  when 1
-    raise unless x == Qubit.new(1, 0) && y == Qubit.new(1, 0) && z == Qubit.new(0, 1)
-  when 2
-    raise unless x == Qubit.new(1, 0) && y == Qubit.new(0, 1) && z == Qubit.new(1, 0)
-  when 3
-    raise unless x == Qubit.new(1, 0) && y == Qubit.new(0, 1) && z == Qubit.new(0, 1)
-  when 4
-    raise unless x == Qubit.new(0, 1) && y == Qubit.new(1, 0) && z == Qubit.new(1, 0)
-  when 5
-    raise unless x == Qubit.new(0, 1) && y == Qubit.new(1, 0) && z == Qubit.new(0, 1)
-  when 6
-    raise unless x == Qubit.new(0, 1) && y == Qubit.new(0, 1) && z == Qubit.new(1, 0)
-  when 7
-    raise unless x == Qubit.new(0, 1) && y == Qubit.new(0, 1) && z == Qubit.new(0, 1)
-  end
-end
-
-# # Quantum Teleportation
-1_000.times do
-  # alice will teleport 'a' to bob
-  a = Qubit.new(0, 1)
-  b = Qubit.new(1, 0)
-  c = Qubit.new(1, 0)
-  # dup so we have copy of the original state to verify transportation.
-  # In practice neither Alice nor Bob knows these values and our final check
-  # cannot be preformed. Through the maths we can understand that this holds
-  # regardless of not knowing initial values.
-  a_dup = a.dup
-
-  # first entangle 'b' and 'c'
-  s = C_NOT_GATE.*(H_GATE * b, c)
-  # bob takes 'c' far away
-
-  # alice continues
-  g = H_GATE.kronecker(I2).kronecker(I2) * C_NOT_GATE.kronecker(I2)
-  s = g.*(a, s)
-
-  # alice measure her two qubits and sends classical bits to bob
-  z, x = s.measure_partial(a, b)
-  case [z, x].join.to_i(2)
-  when 0
-    raise unless a == Qubit.new(1, 0) && b == Qubit.new(1, 0)
-  when 1
-    raise unless a == Qubit.new(1, 0) && b == Qubit.new(0, 1)
-  when 2
-    raise unless a == Qubit.new(0, 1) && b == Qubit.new(1, 0)
-  when 3
-    raise unless a == Qubit.new(0, 1) && b == Qubit.new(0, 1)
-  else
-    raise
-  end
-
-  # depending on what bobs gets, he applies gates to his qubit
-  # and is able to regain alice's 'a' qubit's original state instantly!
-  c = X_GATE * c if x == 1
-  c = Z_GATE * c if z == 1
-
-  # p [z, x]
-  # p a_dup, c
-  raise unless a_dup == c
-end