Encoding​

• Basis encoding: binary srings -> computational basis states
• Amplitude encoding: data values -> amplitudes of a quantum state
• Angle encoding: data values -> rotation angles on individual qubits

Basis Encoding​

$x = b_1 b_2 ... b_n \rightarrow \ket{x} = \ket{b_1 b_2 ... b_n}$

• applying $X$ gates to flip qubits from $\ket{0}$ to $\ket{1}$ based on the binary representation of the data.
• $\ket{00} \rightarrow \ket{01}$ (X gate on the second qubit)
• $\ket{00} \rightarrow \ket{10}$ (X gate on the first qubit)
• Dataset superposition: to encode set $\{01, 11\}$
  • $\ket{S} = \frac{1}{\sqrt{2}}(\ket{01} + \ket{11})$
  • it requires Hadamard and/or controlled gates
• Hadamard transform
  • $\ket{H^{\otimes n}}\ket{0}^{\otimes n} = \frac{1}{\sqrt{2^n}} \sum_{x=0}^{2^n-1} \ket{x}$

import pennylane as qml

x = [int(b) for b in '1011']

def circuit(x):
  qml.BasisEmbedding(features=x, wires=range(len(x)))

dev = qml.device('default.qubit', wires=4)
qnode = qml.QNode(circuit, dev)

print(qml.draw(qml.transforms.decompose(qnode), show_all_wires=True)(x))

Amplitude Encoding​

$x = [x_0, x_1, ..., x_{N-1}] \rightarrow |\psi\rangle = \sum_{i=0}^{2^N-1} x_k |k\rangle$

• The most qubit-efficient encoding method, since $n$ qubits can encode $2^n$ amplitudes.

• The state can be rewritten more explicitly (for 3 qubits)

$\ket{\psi} = x_0 \ket{000} + x_1 \ket{001} + x_2 \ket{010} + x_3 \ket{011} + x_4 \ket{100} + x_5 \ket{101} + x_6 \ket{110} + x_7 \ket{111}$

• For $N$ data points, we need $n = \log_2(N)$ qubits.
• Converting to binary
  • with $n$ qubits, the computational basis states range from
    • $\ket{0}$ to $\ket{2^n - 1}$
  • $[x_0, x_1, ..., x_{N-1}]$ can be mapped to $x_0\ket{000} + x_1\ket{001} + \cdots + x_{N-1}\ket{(N-1)}$.
  • $b_i = \left\lfloor \frac{k}{2^i} \right\rfloor \bmod 2$.
• if $k = 5$
  • $b_0 = \left\lfloor \frac{5}{2^0} \right\rfloor \bmod 2 = 1$
  • $b_1 = \left\lfloor \frac{5}{2^1} \right\rfloor \bmod 2 = 0$
  • $b_2 = \left\lfloor \frac{5}{2^2} \right\rfloor \bmod 2 = 1$
  • gives $b_2 b_1 b_0 = 101$ (binary representation of 5)
  • $\ket{\bf 5} = \ket{101}$

Angle Encoding​

• Each classical value controls the roation angle of a qubit gate.
• $x = [x_1, x_2, ..., x_n]$
• $RY(x_0) \ket{0} \otimes RY(x_1) \ket{0} \otimes ... \otimes RY(x_{n-1}) \ket{0}$
• where $RY(\theta) = \begin{bmatrix} \cos(\theta/2) & -\sin(\theta/2) \\ \sin(\theta/2) & \cos(\theta/2) \end{bmatrix}$ is the $Y$ rotation gate.

Summary of Encoding Methods​

• Pennylane: BasisEmbedding, AmplitudeEmbedding, AngleEmbedding
• Qiskit: initialize
• PyTKET: StatePreparationBox

Amplitude Encoding Circuit​

• The algorithm to prepare an arbitrary vector of length $2^n$ takes roughly that many gates. (e.g. $2^3 \approx 10$)

wires = [0, 1, 2]

def circuit(x):
  qml.AmplitudeEmbedding(x, wires)

dev = qml.device("default.qubit", wires=wires)
qnode = qml.QNode(circuit, dev)

# Random vector of length 8 (for 3 qubits)
x = np.random.rand(8)
# Normalize the vector to have unit length (required for quantum states)
x = x/np.sqrt(np.sum(x**2))

qml.draw_mpl(qnode)(x);
qml.draw_mpl(qml.transforms.decompose(qnode), decimals=3)(x);

from pytket.circuit import StatePreparationBox
from pytket.circuit.display import render_circuit_jupyter as draw

state_circ = pytket.circuit.Circuit(3)

# Example 3-qubit state to prepare
w_state = 1 / np.sqrt(3) * np.array([0, 1, 1, 0, 1, 0, 0, 0])

w_state_box = StatePreparationBox(w_state)
state_circ.add_gate(w_state_box, [0, 1, 2])

draw(state_circ)

pytket.transform.Transform.DecomposeBoxes().apply(state_circ)
draw(state_circ)

Different algorithms for Rotation gate​

• Pennylane: Transformation of quantum states using uniformly controlled rotations $Ry(\theta) = e^{-\theta Y / 2} = \begin{bmatrix} \cos(\theta/2) & -\sin(\theta/2) \\ \sin(\theta/2) & \cos(\theta/2) \end{bmatrix}$

• PyTKET: Synthesis of Quantum Logic Circuits $R_y(\theta) = e^{-\theta \pi Y / 2} = \begin{bmatrix} \cos(\theta \pi / 2) & -\sin(\theta \pi / 2) \\ \sin(\theta \pi / 2) & \cos(\theta \pi / 2) \end{bmatrix}$

• Qiskit: Quantum Circuits for Isometries

• There are concreate algorithms for encoding classical data into quantum states, but this process is generally computationally expensive.

• It usually requires classical preprocessing, and the resulting circuit can be quite deep.

• In general, amplitude encoding an arbitary large vector is expensive.

• "a quantum computer can store an exponential amount of data" should be always considered together with the cost of state preparation.

• The real advantage of quantum computers does not appear for every problem, but only for specific problems that are well-suited to them.

  • Problems where state preparation is natural or efficient.
  • Problems that involve simulating quantum systems themselves.
  • Structured linear algebra, optimization, or sampling problems.
  • Problems where the input is already given as a quantum state.

Binary Logic Gates​

• Sum $s = a \oplus b$ (XOR)
• Carry $c = a \cdot b$ (AND)

1. Declare registers
2. Apply opertions
3. Read the result

Full-Adder in Binary Logic​

• Handles three inpus ($a$, $b$, and carry-in $c_{in}$) and produces two outputs (sum $s$ and carry-out $c_{out}$).

• $s = a \oplus b \oplus c_{in}$
• $c_{out} = (a \cdot b) \oplus (a \cdot c_{in}) \oplus (b \cdot c_{in})$
• A full-adder = two half-adders + an OR gate
• Chaning full-adders producs a ripple-carry adder for multi-bit numbers.

Quantum Arithmetic​

• All quantum gates must be Unitary (Invertable)
• A classical half-adder discards input information after computing the sum and carry.
  • This irreversibility is forbidden in quantum circuits.
• The computation must be done in a way that preserves all input information.
  • XOR and AND operations must be implemented using reversible gates (e.g. Toffoli gate).
  • XOR $\rightarrow$ CNOT gate
  • AND $\rightarrow$ Toffoli gate

• With a third qubit initialized to $\ket{0}$, we can compute the AND of $a$ and $b$ without losing information about $a$ and $b$.

Half-Adder​

Full-Adder​

$C_{out} = (a \cdot b) \oplus (a \cdot c_{in}) \oplus (b \cdot c_{in})$ $s = a \oplus b \oplus c_{in}$

$CCX(a, b, c_{out}) \rightarrow CNOT(a, b) \rightarrow CCX(b, c_{in}, c_{out}) \rightarrow CNOT(b, c_{in})$

Ripple Carry Adder​

• Two full-adder circuits in sequence, overlapping on the carry qubit ("rippling" the carry through the circuit).
• CDKM adder
  • Carry-out is the majority vote of the three inputs

• MAJ: Majority, computes carry in-place using only 2 CNOTs + 1 Toffoli

  • $(c, b, a) \rightarrow (c \oplus a, b \oplus a, a \cdot b \oplus a \cdot c \oplus b \cdot c)$

• UMA: UnMajority-and-Add, reverses MAJ but overwrites $b$ with the sum.

  • $c \oplus a, b \oplus a, c_{out} \rightarrow c, a\oplus b\oplus c, s$

• CDKM Ripple-Carry Adder: For two n-bit numbers, chain MAJ/UMA pairs, sharing the carry qubit.
  • CDKMRippleCarryAdder

Quantum Multiplication​

• Binary multiplication is "shift and add"
  • for each 1-bit in the multiplier, add a shifted version of the multiplicand to the result.
  • for each 0-bit, add nothing (or add a zero vector).
• In quantum, each partial addition is a conditional adder , every internal gate is controlled by a bit of the multiplier.

$CU = \ket{0}\bra{0} \otimes I + \ket{1}\bra{1} \otimes U$

Superposition​

• Same adder circuit works on superposition of inputs

$\text{ADDER} \ket{2} (\ket{1} + \ket{3}) \ket{0} = \ket{2} (\ket{1} \ket{3})(\ket{3} \ket{5})$

• With one adder, both $2 + 1$ and $2 + 3$ are computed simultaneously.
• measurement collapses the superposition, we can only ever see one result per run. Either $2 + 1 = 3$ or $2 + 3 = 5$.
• Amplifying the probability of amplitudes corresponding to correct answers is a key part of quantum algorithms.

Summary​

• Basis encoding maps each classical bit to a qubit, with 0 mapped to $|0\rangle$ and 1 mapped to $|1\rangle$.
• To encode 1011, we need X gates on qubits 0, 2, and 3 (assuming qubit 0 is the most significant bit).
• Applying an H gate (Hadamard gate) to each qubit puts the system in a uniform superposition over all basis states.
• Amplitude encoding of an arbitrary vector of size $2^n$ generally requires $O(2^n)$ gates.
• In angle encoding, each classical value $x_i$ becomes the rotation angle of an RY gate on the $i$-th qubit.
• Using the binary conversion formula, the decimal number 5 maps to $|101\rangle$ for 3 qubits.
• In short, in quantum addition, the sum is an XOR operation, and the carry is an AND operation.
• A quantum half-adder must keep the original inputs to remain reversible and maintain its unitary nature.
• The Toffoli gate is defined as: $|a\rangle|b\rangle|c\rangle \mapsto |a\rangle|b\rangle|c \oplus a \cdot b\rangle$.
• A full-adder should produce a carry-out as follows: $c_{\text{out}} = a \cdot b \oplus a \cdot c_{\text{in}} \oplus b \cdot c_{\text{in}}$.
• The following operation is reversible: $|a\rangle|b\rangle|c\rangle \mapsto |a\rangle|a \oplus b\rangle|c \oplus a \cdot b\rangle$.
• For addition "in superposition," measuring the output register yields exactly one of the partial sums, chosen probabilistically.
• The MAJ circuit computes the majority function as: $a \cdot b \oplus a \cdot c \oplus b \cdot c$.
• The QASM snippet for a half-adder uses ccx q[0], q[1], q[2] to compute the carry ($a \cdot b$) and a cx q[0], q[1] (or cx q[1], q[0]) gate to compute the sum ($a \oplus b$).
• Quantum multiplication can be implemented via conditional addition, one per multiplier bit.

Superdense Coding​

• counterintuitive protocol that allows us to send 2 bits of classical information by sending only 1 qubit, using pre-shared entanglement
• it's often contextualized as a game with Alice and Bob.
• Alice and Bob share and entangled pair of qubits
• Pre-shared Entanglement (Shared Bell pair)
  • $|\Phi^+\rangle = \frac{1}{\sqrt{2}}(|00\rangle + |11\rangle)$
• Alice wants to send 2 bits of classical information (00, 01, 10, or 11) to Bob
  • For 00: Apply Identity $I$ (do nothing)
  • For 01: Apply Pauli-X $X$ (bit flip)
  • For 10: Apply Pauli-Z $Z$ (phase flip)
  • For 11: Apply $XZ$ (bit and phase flip)
• Alice sends her one qubit to Bob (Bob possesses both qubits of the entangled pair)
• Bob decodes the information
  • Inverts the entanglement operation on the two qubits (CNOT followed by Hadamard)
  • Measures each of the qubits
  • The outcome of this measurement reveals the two bits Alice encoded.
• $|\Phi^+\rangle$: is the most common and convenient form (Bell State) of entanglement and is also maximally entangled state despite single-qubit unitary gates.
  • Easy to build circuits for it
  • Symmetric and has nice properties that make it ideal for protocols like superdense coding and teleportation
  • Other Bell states can be generated from $|\Phi^+\rangle$ by applying single-qubit gates.

Superdense Coding Circuit​

• Alice's message $mn$, where each of $m$ and $n$ is a bit (0 or 1)
• Alice's operation can be represented as $Z^m X^n \otimes \mathbb{I} | \Phi^+\rangle$
  • $m=0 \Rightarrow Z^0 = I$ (no phase flip)
  • $m=1 \Rightarrow Z^1 = Z$ (phase flip)
  • $n=0 \Rightarrow X^0 = I$ (no bit flip
  • $n=1 \Rightarrow X^1 = X$ (bit flip)
  • $00 \rightarrow I$
  • $01 \rightarrow X$
  • $10 \rightarrow Z$
  • $11 \rightarrow ZX$
• $Z^m|b\rangle = (-1)^{mb}|b\rangle$ (phase flip)
• $X^n|a\rangle = |a \oplus n\rangle$ (xor operation)

$X^n \left(\frac{1}{\sqrt{2}} (|00\rangle + |11\rangle)\right) = \frac{1}{\sqrt{2}} \left( |n0\rangle + |(1\oplus n)1\rangle \right)$

• $n=0$: $\frac{1}{\sqrt{2}} (|00\rangle + |11\rangle) = |\Phi^+\rangle$
• $n=1$: $\frac{1}{\sqrt{2}} (|10\rangle + |01\rangle)$

$Z^m X^n \left(\frac{1}{\sqrt{2}} (|00\rangle + |11\rangle)\right) = \frac{1}{\sqrt{2}} \left( (-1)^{mn}|n0\rangle + (-1)^{m(1\oplus n)}|(1\oplus n)1\rangle \right)$

• $|n0\rangle$: first qubit is $n$, $(-1)^{mn}$ is the phase factor
• $|(1\oplus n)1\rangle$: first qubit is $1\oplus n$, $(-1)^{m(1\oplus n)}$ is the phase factor
• Bob's decoding operation is the inverse of the entanglement operation
  • $CNOT |a\rangle |b\rangle = |a\rangle |a \oplus b\rangle$

• which is seperable state.
• First qubit is $|n\rangle + (-1)^m|1 \oplus n\rangle$ and second qubit is $|n\rangle$.
• $n, m \in \{0, 1\}$, then apply Hadamard to the first qubit:

• second qubit is $|n\rangle$, so the final state is:

$(-1)^{mn}(-1)^{nm}|m\rangle|n\rangle = |mn\rangle$

Superdense QASM​

OPENQASM 2.0;
qreg q[2];
creg c[2];

// Prepare Bell pair
h q[0];
cx q[0],q[1];

// Alice's encoding
// For message 11: apply X and Z
x q[0];
z q[0];

// Alice sends q[0] to Bob (in simulation, we just proceed)

// Bob's decoding
cx q[0],q[1];
h q[0];

// Measure both qubits
measure q[0] -> c[0];
measure q[1] -> c[1];

QASM Programming​

Custom Gates​

// params: parameters for the gate (e.g., rotation angles)
// q_args: quantum arguments (qubits the gate acts on)
gate NAME(parameters) q_args {
  // Define gate operations
}

gate bell a,b {
  h a;
  cx a,b;
}

qreg q[2];
creg c[2];

// Use the custom bell gate
bell q[0], q[1];

// Measure the qubits
measure q[0] -> c[0];
measure q[1] -> c[1];

Toffoli Gate​

// Toffoli gate (CCX)
gate ccx a, b, c {
  h c;
  cx b, c;
  tdg c;
  cx a, c;
  t c;
  cx b, c;
  tdg c;
  cx a, c;
  t b;
  t c;
  cx a, b;
  h c;
  t a;
  tdg b;
  cx a, b;
}

Rotation Gates​

// Rotation around Y-axis
gate ry_deg(theta) q {
  ry(theta/180 * pi) q;
}

// Rotation around X-axis
gate rx_deg(theta) q {
  rx(theta/180 * pi) q;
}

Qiskit​

IBM

import qiskit

superdense = qiskit.QuantumCircuit(2, 2)
superdense.draw()

superdense.h(0)
superdense.cx(0, 1)
superdense.draw()

# Alice's encoding for message '11'
superdense.x(0)
superdense.z(0)
superdense.draw()

# Bob unentangles the two qubits (reverses the entangling gate)
superdense.cx(0,1)
superdense.h(0)

# The measurement pattern is `measure(qubit to measure, classical bit to store result)`
superdense.measure(0,0)
superdense.measure(1,1)
superdense.draw()

from qiskit.providers.basic_provider import BasicSimulator

sim = BasicSimulator()
# run the circuit on the simulator with 1 shot (execute the circuit once)
result = sim.run(superdense, shots=1).result().get_counts()

print(result)
# {'11': 1}

Custom Gates in Qiskit​

bell = qiskit.QuantumCircuit(2, name='bell')
bell.h(0)
bell.cx(0, 1)
bell_gate = bell.to_gate()

c = qiskit.QuantumCircuit(2)
c.append(bell_gate, [0, 1])
c.draw()

Decompose a custom gate​

ccxgate = qiskit.circuit.library.CCXGate()
ccx = qiskit.QuantumCircuit(3)
ccx.append(ccxgate, [0, 1, 2])

print(ccx)
print(ccx.decompose())

Cirq​

Google

import cirq

alice = cirq.NamedQubit('Alice')
bob = cirq.NamedQubit('Bob')

superdense = cirq.Circuit()
superdense.append([
  cirq.H(alice),
  cirq.CNOT(alice, bob),
])

superdense.append([
  cirq.X(alice),
  cirq.Z(alice),
])

superdense.append([
  cirq.CNOT(alice, bob),
  cirq.H(alice),
])

superdense.append(cirq.measure(alice, bob, key='received'))

print(superdense)

simulator = cirq.Simulator()
result = simulator.run(superdense, repetitions=1)
print(result)
# received=1, 1

Pennylane​

Xanadu

import pennylane as qml

def entangle():
    qml.Hadamard(wires=0)
    qml.CNOT(wires=[0, 1])

print(qml.draw(entangle)())

device = qml.device("default.qubit", wires=[0, 1])

# Wrap the quantum function as a QNode
entangle_qnode = qml.QNode(my_circuit, device)

# Set the number of shots to 10
entangle_qnode = qml.set_shots(entangle_qnode, shots=10)

import numpy as np

state = np.array([1, 1j], dtype=complex)

state = state / np.linalg.norm(state)

def teleport(state):
    # Ensure "state" is loaded into the first qubit
    # (otherwise qubits would start in |0>)
    qml.StatePrep(state, wires=0)

    # Shared entanglement between qubits 1 and 2
    qml.Hadamard(wires=1)
    qml.CNOT(wires=[1, 2])

    # Alice's operation:
    # CNOT from Alice's input qubit to her half of the Bell pair,
    # then Hadamard on the input qubit
    qml.CNOT(wires=[0, 1])
    qml.Hadamard(wires=0)

    # Measurement (store the classical outcomes)
    m0 = qml.measure(0)
    m1 = qml.measure(1)

    # Bob's conditional correction operations
    qml.cond(m1, qml.PauliX)(wires=2)
    qml.cond(m0, qml.PauliZ)(wires=2)

    # Return Bob's qubit as a density matrix
    return qml.density_matrix(wires=2)

print(qml.draw(teleport)(state))

Quantum Teleportation​

• if there is entanglement:
  • we can use it to send 2 bits of classical information by sending 1 qubit (superdense coding)
  • we can use it to send 1 qubit of quantum information by sending 2 bits of classical information (teleportation)
• Alice wants to send a qubit $|\psi\rangle = \alpha|0\rangle + \beta|1\rangle$ to Bob, but only has a classical channel.

Protocol​

1. Alice and Bob share $|\Phi^+\rangle$ (pre-shared entanglement)
2. Alice applies $CNOT$ (her qubit -> her Bell half), then $H$, then measures both, obtaining 2 classical bits (00, 01, 10, or 11)
3. Alice sends $mn$ classically to Bob
4. Bob applies $X^n Z^m$ to his qubit, recovering $|\psi\rangle$

• For 00: Apply Identity $I$ (do nothing)
• For 01: Apply Pauli-X $X$ (bit flip)
• For 10: Apply Pauli-Z $Z$ (phase flip)
• For 11: Apply $XZ$ (bit and phase flip)
• Bob now has a qubit in the state Alice wanted to send $|\psi\rangle$ without Alice ever sending a qubit directly to Bob.

Teleportation Circuit​

$|\psi\rangle \otimes |\Phi^+\rangle = \left(\alpha |0\rangle + \beta |1\rangle\right) \otimes \frac{1}{\sqrt{2}} \left(|00\rangle + |11\rangle\right)$

$|\psi\rangle \otimes |\Phi^+\rangle = \frac{1}{\sqrt{2}} \left(\alpha |0\rangle |00\rangle + \alpha |0\rangle |11\rangle + \beta |1\rangle |00\rangle + \beta |1\rangle |11\rangle\right)$

• Alice applies a $CNOT$ gate with her qubit $|\psi\rangle$ as control and her half of the Bell pair $|\Phi^+\rangle$ as target.
  • $\beta |1\rangle |00\rangle$ becomes $\beta |1\rangle |10\rangle$ (target flips when control is 1)
  • $\beta |1\rangle |11\rangle$ becomes $\beta |1\rangle |01\rangle$ (target flips when control is 1)

$\frac{1}{\sqrt{2}} \Big(\alpha |0\rangle |00\rangle + \alpha |0\rangle |11\rangle + \beta |1\rangle |10\rangle + \beta |1\rangle |01\rangle\Big)$

• Alice then applies a Hadamard gate to her qubit ($|\psi\rangle$).
  • $H|0\rangle = \frac{|0\rangle + |1\rangle}{\sqrt{2}}$
  • $H|1\rangle = \frac{|0\rangle - |1\rangle}{\sqrt{2}}$
• To prepare for measurement, Bell measurement is performed on Alice's two qubits, which can be expressed as:

• Alice measures her two qubits, resulting in one of four possible outcomes corresponding to the classical bits $|mn\rangle$ where $m, n \in \{0, 1\}$
  • Alice's two qubits: $|00\rangle, |0 1\rangle, |1 0\rangle, |1 1\rangle$
  • Bob's qubit is in a state that depends on Alice's measurement outcome

$X^n Z^m |\psi\rangle$

Channels​

• Classical Channel: carries bits (fibre, radio, paper, ...)
• Quantum Channel: carries qubits (can also carry bits)
  • Quantum channels can emulate classical ones, but not vice versa
• Teleportation: classical channel + pre-shared entanglement -> effective quantum channel

Summary​

• In superdense coding, by sending only one qubit and using pre-shared entanglement, Alice can transmit two classical bits of information.
• The operation $X^n \lvert a \rangle = \lvert a \oplus (n \bmod 2) \rangle$ correctly defines the effect of applying the $X$ gate $n$ times.
• The tensor product of two identity operators is the identity operator on the composite space. In symbols, where the subscript is the dimension: $I_2 \otimes I_2 = I_4$.
• The state $\lvert \phi \rangle = \frac{1}{\sqrt{2}}(\lvert 0 \rangle + \lvert 1 \rangle)$ is an eigenstate of the Pauli-$X$ gate with eigenvalue $+1$.
• In the teleportation protocol, the classical communication channel is used to transmit two classical bits from Alice to Bob.
• Three qubits are required for quantum teleportation.
• After the teleportation protocol completes, Bob has a qubit in the state $\lvert \psi \rangle$.
• Of QASM, Qiskit, Cirq, and PennyLane, PennyLane is the only quantum language that spells out the full name of the Hadamard gate for its built-in gates.

Innovation Ecosystem​

• A network of organizations, people and resources that interact with each other to develop and support new ideas, technologies and businesses.
• Innovation Ecosystem
  • Start-up companies
  • Medical Centers
  • Mature Companies
  • City, Regional and State Organizations
  • Providers of Support Services (Legal, Accounting, etc)
  • Venture Capital Funds
  • Colleges & universities

Type of Innovation Ecosystem​

• Corporate innovation ecosystem
• Digital innovation ecosystem
• City-based innovation ecosystem
• High-tech SMEs centered ecosystem (Small and Medium-sized Enterprises)
• University-based ecosystem
• Incubators and Accelerators ecosystems
• Regional and National innovation ecosystems
• Social innovation ecosystems

The core -> New Innovation Initiatives -> Startup Ecosystem -> Customers

Roles and Activites across Innovation Ecosystem​

• Leadership:
  • Ecosystem leader
    • ecosystem governance: decipher roles, coordinate interactions, orchestrate resource flows
    • forging partnerships: attract & link partners, create collaboration, stimulate complementary
    • platform management: build platform, open platform, orchestrate compleentors
    • value management: decipher bases of value, create & capture value
  • Dominator: integrate actors
• Direct Value Creation:
  • Supplier: supply components
  • Assembler: assemble components
  • Complementor: provide complementarities
  • User: define need, provide ideas, purchase & use
• Value Support:
  • Expert: generte knowledge, provide expertise, transfer technology
  • Champion: build connections, provide access to markets
• Entrepreneur Ecosystem:
  • Entrepreneur: co-locate, set-up network
  • Sponsor: give resources, co-develop offering, link to other actors
  • Regulator: provide favorable conditions

Systems Thinking​

• a holistic and non-linear approach to problem solving that focuses on the interactions and patterns within an entire system
• emphasizes relationships and feedback loops instead of analysing individual parts in isolation

Fishbone Diagram​

• common categories to help think broadly about the possible causes include:
• People: skils, training, communication, motivation
• Process / Methods: procedures, or workflows
• Machines / Techonology: tools, equipment, software
• Materials: resources or inputs used
• Environment: workplace or external conditions
• Mangement / Policies: decisions, rules, or leadership

Innovation Networks​

• connected systems of people working together toward shared objectives, often through internal teams and external partners such as suppliers, universities, accelerators, customers, and startups.
• is also part of innovation ecosystem

Types of Innovation Networks​

• Enterpreneur-based
• Internal project teams
• Internal enterpreneur networks
• Communities of practice: can involve players inside and across different organizations
• Spatial clusters: like Silicon Valley, Boston, etc
• Sectoral networks: bring different players together because they share a common sector
• New product or process develoment consortium
• New technology development consortium
• Emerging standards: Exploring and estabilishing standards around innovative technologies
• Supply chain learning
• Learning networks
• Recombinant innovation networks: Cross-sectoral groupings that alloow for networking across boundaries and the transfer of ieads.
• Managed open innovation networks
• User networks
• Innovation markets
• Crowdfunding and new resource approaches

Stakeholder Analysis​

• High power, highly interested people (Engage Closely)
• High power, less interested people (Keep Satisfied)
• Low power, Highly interested people (Keep Informed)
• Low power, less interested people (Monitor)

Tensor Products​

Kronecker product

• a way to multiply vectors and matrices to generate bigger vectors and matrices

$|\psi\rangle \otimes |\phi\rangle = \begin{pmatrix} \psi_0 \\ \psi_1 \end{pmatrix} \otimes \begin{pmatrix} \phi_0 \\ \phi_1 \end{pmatrix} = \begin{pmatrix} \psi_0 \begin{pmatrix} \phi_0 \\ \phi_1 \end{pmatrix} \\ \\ \psi_1 \begin{pmatrix} \phi_0 \\ \phi_1 \end{pmatrix} \end{pmatrix} = \begin{pmatrix} \psi_0 \phi_0 \\ \psi_0 \phi_1 \\ \psi_1 \phi_0 \\ \psi_1 \phi_1 \end{pmatrix}$

$|\psi\rangle \otimes |\phi\rangle \equiv |\psi\rangle |\phi\rangle \equiv|\psi\phi\rangle$

Tensor product of Matrices​

$A \otimes B = \begin{pmatrix} a_{00}B & a_{01}B \\ a_{10}B & a_{11}B \end{pmatrix}$

• The tensor product $|0\rangle \langle1| \otimes |1\rangle \langle0|$ is:

$|0\rangle \langle 1| \otimes |1\rangle \langle 0| = \begin{pmatrix} 0 & 1 \\ 0 & 0 \end{pmatrix} \otimes \begin{pmatrix} 0 & 0 \\ 1 & 0 \end{pmatrix}$

$|0\rangle \langle 1| \otimes |1\rangle \langle 0| = \begin{pmatrix} 0 \cdot \begin{pmatrix} 0 & 0 \\ 1 & 0 \end{pmatrix} & 1 \cdot \begin{pmatrix} 0 & 0 \\ 1 & 0 \end{pmatrix} \\ 0 \cdot \begin{pmatrix} 0 & 0 \\ 1 & 0 \end{pmatrix} & 0 \cdot \begin{pmatrix} 0 & 0 \\ 1 & 0 \end{pmatrix} \end{pmatrix} = \begin{pmatrix} 0 & 0 & 0 & 0 \\ 0 & 0 & 1 & 0 \\ 0 & 0 & 0 & 0 \\ 0 & 0 & 0 & 0 \end{pmatrix}$

• To short hand this, we can write:

$|0\rangle \langle 1| \otimes |1\rangle \langle 0| \equiv |0\rangle|1\rangle \langle 1| \langle 0| \equiv |01\rangle \langle 10|$

• $(|a\rangle \langle b|) \otimes (|c\rangle \langle d|) = (|a\rangle |c\rangle)(\langle b| \langle d|) = |ac\rangle \langle bd|$

Bases​

• The basis for a single qubit is $\{|0\rangle, |1\rangle\}$
• It is given by taking the tensor product of the basis for each qubit:
  • $\{|0\rangle \otimes |0\rangle, |0\rangle \otimes |1\rangle, |1\rangle \otimes |0\rangle, |1\rangle \otimes |1\rangle\}$
  • For short hand, we write $\{|00\rangle, |01\rangle, |10\rangle, |11\rangle\}$
• The computational basis for two qubits is $\{|00\rangle, |01\rangle, |10\rangle, |11\rangle\}$
• For three qubits $\{|000\rangle, |001\rangle, |010\rangle, |011\rangle, |100\rangle, |101\rangle, |110\rangle, |111\rangle\}$

Matrices​

$\{|0\rangle\langle0|,\; |0\rangle\langle1|,\; |1\rangle\langle0|,\; |1\rangle\langle1|\}$

• forms a basis for the space of $2 \times 2$ matrices
• operator basis: a set of matrices that can be used to express any matrix as a linear combination of the basis matrices

$\begin{pmatrix} a & b \\ c & d \end{pmatrix} = a |0\rangle\langle0| + b |0\rangle\langle1| + c |1\rangle\langle0| + d |1\rangle\langle1|$

• One of the basis elements is: $|0\rangle\langle0| \otimes |0\rangle\langle0| = |00\rangle\langle00|$
• Similarly $|0\rangle\langle0| \otimes |0\rangle\langle1| = |00\rangle\langle01|$
• In total, the tensor products yields $4 \times 4 = 16$ basis elements for the space of $4 \times 4$ matrices: $\{|00\rangle\langle00|,\; |00\rangle\langle01|,\; |00\rangle\langle10|,\; |00\rangle\langle11|,\; |01\rangle\langle00|,\; |01\rangle\langle01|,\; \ldots,\; |11\rangle\langle11|\}.$

The Golden Rule of Tensor Products​

What starts on the left of the tensor product says on the left

$(A \otimes B)(|\psi\rangle \otimes |\phi\rangle) = (A|\psi\rangle) \otimes (B|\phi\rangle)$

$(|0\rangle\langle0| \otimes |1\rangle\langle1|)(|00\rangle) \\ = (|0\rangle\langle 0| \otimes |1\rangle\langle1|)(|0\rangle \otimes |0\rangle) \\ \\ = (|0\rangle\langle0||0\rangle) \otimes (|1\rangle\langle1||0\rangle) \\ = |0\rangle \otimes 0 \\ = 0$

• $|\psi\rangle \otimes |\phi\rangle \equiv |\psi\rangle|\phi\rangle \equiv |\psi\phi\rangle$
• $(|\psi\rangle \otimes |\phi\rangle)^\dagger = \langle\psi| \otimes \langle\phi|$
• $(\alpha|\psi\rangle + \beta|\phi\rangle) \otimes |\omega\rangle = \alpha|\psi\rangle \otimes |\omega\rangle + \beta|\phi\rangle \otimes |\omega\rangle$
• $((\langle\psi| \otimes \langle\phi|)(|\omega\rangle \otimes |\eta\rangle)) = \langle\psi|\omega\rangle \langle\phi|\eta\rangle$
• $(A + B) \otimes C = A \otimes C + B \otimes C$
• $A \otimes (B + C) = A \otimes B + A \otimes C$
• $(A \otimes B)(C \otimes D) = AC \otimes BD$
• $(A \otimes B)^\dagger = A^\dagger \otimes B^\dagger$

Entanglement​

• Single-qubit state is a two dimensional vector: $|\psi\rangle = \alpha|0\rangle + \beta|1\rangle$
• where $\alpha$ and $\beta$ are complex numbers such that $\||\psi\rangle\|^2 = |\alpha|^2 + |\beta|^2 = 1$
• Two qubits $\psi_1\rangle$ and $\psi_2\rangle$ can be combined to form a four-dimensional vector: $|\psi_{12}\rangle = |\psi_1\rangle \otimes |\psi_2\rangle \equiv |\psi_1\rangle|\psi_2\rangle \equiv |\psi_1\psi_2\rangle$
• Separable States: can be written as a tensor product of single-qubit states
  • $|\Psi\rangle = \alpha_{00} |00\rangle + \alpha_{01} |01\rangle + \alpha_{10} |10\rangle + \alpha_{11} |11\rangle \\ = |\psi_1\rangle| \otimes \psi_2\rangle$
• if the state is not separable, it is called entangled.
  • entangled: $\frac{1}{\sqrt{2}}(|00\rangle + |11\rangle)$
• if $ad = 0$ and $bc = 0$, then $ac$ or $bd$ must also vanish.
  • separable: $\frac{1}{2}(|00\rangle + |01\rangle) = |0\rangle \otimes \frac{1}{\sqrt{2}}(|0\rangle + |1\rangle)$

Two-Qubit Gates​

• Two-qubit gates are $4 \times 4$ unitary matrices that act on two-qubit states.

CNOT Gate​

Controlled NOT gate

• flips target if control is $|1\rangle$

$\text{CNOT} = \begin{pmatrix} 1 & 0 & 0 & 0 \\ 0 & 1 & 0 & 0 \\ 0 & 0 & 0 & 1 \\ 0 & 0 & 1 & 0 \end{pmatrix} = |0\rangle\langle0| \otimes \mathbb I + |1\rangle\langle1| \otimes X$