quantum_ruby 0.1.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 68be46a736a6bdd4f752c9232f65cddf546ca4dbf8b9b72f41fb6237860871e2
+  data.tar.gz: b0a51c8d0e885817db849e60f87a187e20a90dce5113d0e2c4a9b8962c6a2f85
+SHA512:
+  metadata.gz: edbe804cdc48d763966e8b0f343aa8ab4d9dd00595f84b5951289311ca5f81623465b5ade7c5462b263b6402a4d81f4c86370a6360fd1e75db6b906462be1415
+  data.tar.gz: 72c0d4713f3025e9702c45aa05a9c56746e59f715322c769db7df1fe4a95c8b60bff536149e460500ad470e43a4e0fc0be27230dfabfe903a40996a1bf9f0658

data/.gitignore

@@ -0,0 +1,8 @@
+/.bundle/
+/.yardoc
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/

data/Gemfile

@@ -0,0 +1,6 @@
+source "https://rubygems.org"
+
+# Specify your gem's dependencies in quantum_ruby.gemspec
+gemspec
+
+gem "rake", "~> 12.0"

data/Gemfile.lock

@@ -0,0 +1,20 @@
+PATH
+  remote: .
+  specs:
+    quantum_ruby (0.1.1)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    rake (12.3.3)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  bundler
+  quantum_ruby!
+  rake (~> 12.0)
+
+BUNDLED WITH
+   2.1.4

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2020 Alessandro
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,151 @@
+
+# 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.
+
+<img src="https://upload.wikimedia.org/wikipedia/commons/thumb/6/65/Qcircuit_CNOTfromSQRTSWAP.svg/1024px-Qcircuit_CNOTfromSQRTSWAP.svg.png" />
+
+Learning about quantum computing isn't that difficult. Trust me! I learned and built this simulator within five days with no prior quantum computing knowledge. This gem can also be a great tool to facilitate learning about quantum computing.
+
+[Check out the many examples in this repo.](https://github.com/AlessandroMinali/quantum_ruby/examples)
+
+## How to learn about Quantum Computers
+1. Have an understanding of Linear Algebra. This [series of youtube lectures](https://www.youtube.com/playlist?list=PLZHQObOWTQDPD3MizzM2xVFitgF8hE_ab) can get you up to speed on everything you need to know
+2. Read this great intro to quantum computing. This is the single resource that I read before I began implementing this simulator: [Quantum computing for the very curious](https://quantum.country/qcvc)
+3. Experiment with this simulator as you learn about quantum computing
+4. Read the [other articles](https://quantum.country) about quantum computing. Read wiki pages about [qubits](https://en.wikipedia.org/wiki/Qubit) and [quantum gates](https://en.wikipedia.org/wiki/Quantum_logic_gate). Both should be understandable to you now!
+5. If you ever get stuck start back at the top of this list or reach out to me with questions: `alessandro.minali AT gmail DOT com`
+
+## Installation
+Add this line to your application's Gemfile:
+```ruby
+gem 'quantum_ruby'
+```
+
+And then execute:
+
+    $ bundle install
+
+Or install it yourself as:
+
+    $ gem install quantum_ruby
+In your code:
+```ruby
+require 'quantum_ruby`
+```
+
+## Usage
+
+**This gem adds `Matrix#kronecker` and `Complex#round` onto ruby base classes**
+
+There are three objects that this gem uses to simulate any quantum circuitry.
+
+---
+### Qubit
+Quantum computing is achieved by manipulating quantum bits(ie. qubits). For simulation purposes we can arbitrarily create qubits, manipulate them and read their results.
+
+```ruby
+qubit_1 = Qubit.new(1, 0)
+qubit_1.measure # returns 0 bit
+qubit_2 = Qubit.new(0, 1)
+qubit_2.measure # returns 1 bit
+```
+
+---
+
+### Gate
+Quantum gates perform operations on single or multi qubits to produce a variety of classical and non-classical behaviours(such as superpositions and entanglement). Gates are simulated as matrices and interact with qubits via multiplication.
+
+```ruby
+# single qubit gate example (X_GATE ie. quantum NOT gate)
+qubit_1 = Qubit.new(0, 1) # equivalent to classical 1 bit
+state = X_GATE * qubit_1
+state.measure # returns 0 bit
+
+# multi qubit gate example (C_NOT_GATE ie. controlled NOT gate)
+control_qubit = Qubit.new(1, 0) # 0 bit
+target_qubit  = Qubit.new(0, 1) # 1 bit
+# note multi params syntax: "GATE.*(param1, param2, etc.)"
+state = C_NOT_GATE.*(control_qubit, target_qubit) 
+state.measure_partial(target_qubit) # return 1 bit since control is 0
+
+# again with control bit ON
+control_qubit = Qubit.new(0, 1) # 1 bit
+target_qubit  = Qubit.new(0, 1) # 1 bit
+state = C_NOT_GATE.*(control_qubit, target_qubit) 
+state.measure_partial(target_qubit) # return 0 bit since control is 1
+```
+
+#### Provided Gates
+X_GATE  
+Y_GATE  
+Z_GATE  
+H_GATE  
+T_GATE  
+C_NOT_GATE  
+SWAP_GATE  
+TOFFOLI_GATE  
+Information about any of these gates behaviours can be found [here on wiki](https://en.wikipedia.org/wiki/Quantum_logic_gate).
+
+#### Advanced Gate Usage
+
+#### 1. Making your own gates
+This can be done simply like creating a ruby `Matrix`:
+```ruby
+x = Matrix[[0, 1], [1, 0]]
+y = Gate[[0, 1], [1, 0]]
+```
+Note: A true quantum gate must be [unitary](https://en.wikipedia.org/wiki/Unitary_matrix). You can verify if your creation is unitary with the built-in `Matrix#unitary?`
+###### [some versions of ruby have a broken implementation of this function](https://github.com/ruby/matrix/pull/14)
+#### 2. `Matrix#kronecker(matrix)`
+This method allows you to parallelize and scale gates. Examples follow:
+
+Parallel Gates:
+<img src="https://upload.wikimedia.org/wikipedia/commons/d/d5/Parallel_quantum_logic_gates.png" />
+```ruby
+Y_X_GATE = Y_GATE.kronecker(X_GATE)
+```
+
+Scaling Gate:
+<img src="https://upload.wikimedia.org/wikipedia/commons/d/d2/Shows_the_application_of_a_hadamard_gate_on_a_state_that_span_two_qubits.png" />
+```ruby
+state = State.new(Matrix.column_vector([0, 0, 0, 1]))
+# H_GATE normally only works on 1 qubit ie. 2x1 matrix
+# the following will auto scale H_GATE with kronecker
+new_state = H_GATE.*(state, scale: :down)
+```
+
+---
+
+### State
+
+Generally once a qubit enters a circuit we no longer care about it. We are instead interested in the combine state of the whole circuit where multiple qubits are being processed by gates. After sending the qubits through a circuit this object will hold their results in a probabilistic model. We can take a measurement to get classical information back out of the qubits.
+
+```ruby
+qubit_1 = Qubit.new(0, 1) # equivalent to classical 1 bit
+state = H_GATE * qubit_1
+state.measure # returns 0 bit or 1 bit with equal probability
+```
+
+#### `State#measure` vs `State#measure_partial(qubits)`
+In multi-qubit systems gates put the qubits into a combined state. We can either measure the entire state to determine an outcome or try to extract information about specific qubits at the expense of information of the total system. In most cases we are interested in `State#measure`. Make sure you understand which one you intend to do in any situation. [Resource](https://quantum.country/teleportation#background_partial_measurement)
+
+## Other Resources
+For some trickier aspects of quantum computing these online resources really helped me grasp deeper concepts:
+- 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
+- https://cs.stackexchange.com/questions/71462/how-are-partial-measurements-performed-on-a-n-qubit-quantum-circuit
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+
+To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/AlessandroMinali/quantum_ruby.
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).

data/Rakefile

@@ -0,0 +1,8 @@
+require "bundler/gem_tasks"
+
+task default: :test
+
+desc 'Run tests'
+task :test do
+  sh 'ruby examples/*'
+end

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "quantum_ruby"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require "irb"
+IRB.start(__FILE__)

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/examples/general.rb

@@ -0,0 +1,266 @@
+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

data/examples/readme_examples.rb

@@ -0,0 +1,62 @@
+require 'quantum_ruby'
+# All the readme examples tested
+
+# qubit_1 = Qubit.new(1, 0)
+# qubit_1.measure # returns 0 bit
+# qubit_2 = Qubit.new(0, 1)
+# qubit_2.measure # returns 1 bit
+qubit_1 = Qubit.new(1, 0)
+raise unless qubit_1.measure.zero?
+qubit_2 = Qubit.new(0, 1)
+raise unless qubit_2.measure == 1
+
+# # single qubit gate example (X_GATE ie. quantum NOT gate)
+# qubit_1 = Qubit.new(0, 1) # equivalent to classical 1 bit
+# state = X_GATE * qubit_1
+# state.measure # returns 0 bit
+# # multi qubit gate example (C_NOT_GATE ie. controlled NOT gate)
+# control_qubit = Qubit.new(1, 0) # 0 bit
+# target_qubit  = Qubit.new(0, 1) # 1 bit
+# # note multi params syntax: "GATE.*(param1, param2, etc.)"
+# state = C_NOT_GATE.*(control_qubit, target_qubit) 
+# state.measure_partial(target_qubit) # return 1 bit since control is 0
+# # again with control bit ON
+# control_qubit = Qubit.new(0, 1) # 1 bit
+# target_qubit  = Qubit.new(0, 1) # 1 bit
+# state = C_NOT_GATE.*(control_qubit, target_qubit) 
+# state.measure_partial(target_qubit) # return 0 bit since control is 1
+# single qubit gate example (X_GATE ie. quantum NOT gate)
+qubit_1 = Qubit.new(0, 1)
+state = X_GATE * qubit_1
+raise unless state.measure[0].zero?
+control_qubit = Qubit.new(1, 0)
+target_qubit  = Qubit.new(0, 1)
+state = C_NOT_GATE.*(control_qubit, target_qubit) 
+raise unless state.measure_partial(target_qubit)[0] == 1
+# again with control bit ON
+control_qubit = Qubit.new(0, 1) # 1 bit
+target_qubit  = Qubit.new(0, 1) # 1 bit
+state = C_NOT_GATE.*(control_qubit, target_qubit) 
+raise unless state.measure_partial(target_qubit)[0].zero?
+
+# x = Matrix[[0, 1], [1, 0]]
+# y = Gate[[0, 1], [1, 0]]
+x = Matrix[[0, 1], [1, 0]]
+y = Gate[[0, 1], [1, 0]]
+
+# Y_X_GATE = Y_GATE.kronecker(X_GATE)
+Y_X_GATE = Y_GATE.kronecker(X_GATE)
+
+# state = State.new(Matrix.column_vector([0, 0, 0, 1]))
+# # H_GATE normally only works on 1 qubit ie. 2x1 matrix
+# # the following will auto scale H_GATE with kronecker
+# new_state = H_GATE.*(state, scale: :down)
+state = State.new(Matrix.column_vector([0, 0, 0, 1]))
+new_state = H_GATE.*(state, scale: :down)
+
+# qubit_1 = Qubit.new(0, 1) # equivalent to classical 1 bit
+# state = H_GATE * qubit_1
+# state.measure # returns 0 bit or 1 bit with equal probability
+qubit_1 = Qubit.new(0, 1)
+state = H_GATE * qubit_1
+raise unless state == State.new(Matrix.column_vector([1/Math.sqrt(2), -1/Math.sqrt(2)]))

data/lib/quantum_ruby.rb

@@ -0,0 +1,298 @@
+require "quantum_ruby/version"
+require 'matrix'
+
+# Overrides for base Ruby classes
+class Matrix
+  def kronecker(m)
+    raise ErrOperationNotDefined, [__method__, self.class, m.class] unless m.is_a?(Matrix)
+
+    a = Array.new(row_count * m.row_count) { Array.new(column_count * m.column_count) }
+
+    count_ver = 0
+    row_count.times do |i|
+      count_hor = 0
+      column_count.times do |j|
+        m.row_count.times do |p|
+          m.column_count.times do |q|
+            a[i + p + count_ver][j + q + count_hor] = self[i, j] * m[p, q]
+          end
+        end
+        count_hor += m.column_count - 1
+      end
+      count_ver += m.row_count - 1
+    end
+    self.class[*a]
+  end
+end
+
+class Complex
+  def round(digits)
+    Complex(real.round(digits), imag.round(digits))
+  end
+end
+# End of Overrides for base Ruby classes
+
+ZERO_KET       = '|0>'
+ONE_KET        = '|1>'
+ADD_SYM        = ' + '
+ADD_SYM_SQUISH = '+'
+I_SYM          = 'i'
+
+module ExceptionForQuantum
+  class NormalizationConstraint < StandardError
+    def initialize
+      super('Normalization constraint failed. Amplitudes must equal 1')
+    end
+  end
+
+  class ColumnMatrxiConstraint < StandardError
+    def initalize
+      super('Vector supplied must be a Matrix with a single column.')
+    end
+  end
+end
+
+module QuantumComplexPrinter
+  refine Complex do
+    def to_s
+      out = ''
+      out << real.round(3).to_s          if real.positive?
+      out << ADD_SYM_SQUISH              if real.positive? && imag
+      out << imag.round(3).to_s << I_SYM if imag
+    end
+  end
+end
+
+module QuantumVector
+  include ExceptionForQuantum
+  using QuantumComplexPrinter
+
+
+  PRECISION = 14
+
+  def state
+    out = '['
+    out << @vector[0, 0].to_s
+    @vector.drop(1).each do |i|
+      out << "\n " << i.to_s
+    end
+    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
+
+  def normalized?
+    raise NormalizationConstraint unless @vector.reduce(0) { |i, v| i + v.abs2 }.round(PRECISION) == 1
+  end
+end
+
+class Qubit
+  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."
+
+  def initialize(zero, one)
+    @vector = Matrix[[zero], [one]]
+    column_vector?
+    normalized?
+  end
+
+  def to_s
+    return if entangled?
+
+    first = el(0)
+    last = el(1)
+
+    out = ''
+    out << first.to_s << ZERO_KET unless first.zero?
+    out << ADD_SYM                unless first.zero? || last.zero?
+    out << last.to_s << ONE_KET   unless last.zero?
+    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)
+    out = @vector[row, 0]
+    out.is_a?(Float) || out.is_a?(Complex) ? out.round(PRECISION) : out
+  end
+
+  def vector=(array)
+    @vector = Matrix.column_vector(array)
+    normalized?
+  end
+
+  def entangled?
+    if entangled
+      puts ENTANGLED_WARNING
+      true
+    else
+      false
+    end
+  end
+end
+
+class State
+  attr_reader  :vector
+  attr_reader  :qubits
+  include QuantumVector
+
+  def initialize(vector, *qubits)
+    @vector = vector
+    column_vector?
+    normalized?
+
+    @qubits = qubits.flatten.tap { |i| i.each { |j| j.entangled = true } }
+  end
+
+  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)
+  end
+
+  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
+
+    # collect probabilities for qubit(s) states
+    sub_result = @vector.to_a.flatten.each_with_index.group_by do |_probability, index|
+      qubit_ids.map do |id|
+        index.to_s(2).rjust(size, '0')[id]
+      end.join
+    end
+
+    # 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
+    acc = 0
+    out = nil
+    secret = rand
+
+    # "determine' 'winner'
+    probabilities.each_with_index do |probability, index|
+      acc += probability
+      if acc > secret
+        out = index
+        break
+      end
+    end
+
+    # Renormalize
+    squared_sum_mag = Math.sqrt(probabilities[out])
+    out = out.to_s(2).rjust(qubit.length, '0')
+    new_state = sub_result.fetch(out).map { |i| i[0] / squared_sum_mag }
+
+    # Update each qubit
+    @qubits.each_with_index do |q, i|
+      q.entangled = false
+      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
+    out.split('').map(&:to_i)
+  end
+
+  private
+
+  def size
+    Math.log(@vector.row_count, 2)
+  end
+end
+
+class Gate < Matrix
+  # can take gate, qubit, or state
+  def *(*args, scale: nil)
+    if scale
+      arg = begin
+              args[0].vector
+            rescue StandardError
+              args[0]
+            end
+      diff = (arg.row_count / row_count)
+      if diff > 1
+        return case scale
+               when :down
+                 Gate[*kronecker(Matrix.identity(diff))].*(*args)
+               when :up
+                 Gate[*Matrix.identity(diff).kronecker(self)].*(*args)
+               end
+      end
+    end
+
+    case args[0]
+    when State, Qubit
+      qubits = []
+      args = args.map do |i|
+        qubits << (i.is_a?(Qubit) ? i : i.qubits)
+        i.vector
+      end.reduce(:kronecker)
+      State.new(super(args), qubits)
+    else
+      super(*args)
+    end
+  end
+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]]

data/lib/quantum_ruby/version.rb

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

data/quantum_ruby.gemspec

@@ -0,0 +1,26 @@
+require_relative 'lib/quantum_ruby/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "quantum_ruby"
+  spec.version       = QuantumRuby::VERSION
+  spec.authors       = ["Alessandro"]
+  spec.email         = ["alessandro.minali@gmail.com"]
+
+  spec.summary       = %q{A Quantum Computer Simulator written in Ruby.}
+  spec.description   = %q{A Quantum Computer Simulator written in Ruby.}
+  spec.homepage      = "https://github.com/AlessandroMinali/quantum_ruby"
+  spec.license       = "MIT"
+  spec.required_ruby_version = Gem::Requirement.new(">= 2.3.0")
+
+  # Specify which files should be added to the gem when it is released.
+  # The `git ls-files -z` loads the files in the RubyGem that have been added into git.
+  spec.files         = Dir.chdir(File.expand_path('..', __FILE__)) do
+    `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  end
+  spec.bindir        = "exe"
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler"
+  spec.add_development_dependency "rake"
+end

metadata

@@ -0,0 +1,84 @@
+--- !ruby/object:Gem::Specification
+name: quantum_ruby
+version: !ruby/object:Gem::Version
+  version: 0.1.1
+platform: ruby
+authors:
+- Alessandro
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2020-05-03 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: A Quantum Computer Simulator written in Ruby.
+email:
+- alessandro.minali@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- Gemfile
+- Gemfile.lock
+- LICENSE.txt
+- README.md
+- Rakefile
+- bin/console
+- bin/setup
+- examples/general.rb
+- examples/readme_examples.rb
+- lib/quantum_ruby.rb
+- lib/quantum_ruby/version.rb
+- quantum_ruby.gemspec
+homepage: https://github.com/AlessandroMinali/quantum_ruby
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.3.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.1.2
+signing_key: 
+specification_version: 4
+summary: A Quantum Computer Simulator written in Ruby.
+test_files: []