BranchesTags

Latest commit

History

145 Commits

Folders and files

NameName
Last commit message
Last commit date
algorithms
algorithms
challenges
challenges
papers
papers
.gitignore
.gitignore
LICENSE
LICENSE
README.md
README.md
Resources.ipynb
Resources.ipynb

Repository files navigation

Quantum Library

By Emilio Peláez

This repository contains work I have done in quantum computing using the Qiskit library in Python. Most of it consists of notebooks going through an specific algorithm or protocol in quantum computation while trying to give the best description possible and linking to useful resources to get a more in-depth view of the topic discussed. I am relatively new to the field of quantum information and quantum computation (I started in summer of 2020), so the topics covered in this repo may not be very advanced as they mostly reflect my learning process and progress.

The main goal of this repo is to have a reliable library which I or anyone can access to learn or verify something about the topics covered. Therefore, anyone is welcomed to contribute to the project if they find a mistake, would like to add to an explanation, or simply thinks that something should be different.

Some instructions to run this project locally and collaborate to it are included in the rest of this document in case someone wants to do so.

Set up

Once you clone the repository, you will need to create a new file called config.py (or change the name of the provided config_ex.py file) inside the algorithms folder, this is where you will store your IBM Quantum Experience API token. If you don't have an account yet, go to IBM Quantum Experience to create one. Inside this file, just replace the following code YOUR_KEY with your actual key.

IBM_KEY="YOUR_KEY"

Run on hardware

To run the circuits on real hardware, you will need to set up your IBM account as specified above. To run the circuit you desire in a real quantum computer, just uncomment the few lines of code that are above the code that runs the simulator. You will also need to load your IBM account, which relies on your config.py file being correctly written, to gain access to the hardware.

Note that not all circuits may be run in real hardware and some require modifications to run correctly. Those that require modifications to run correctly will make the necessary modifications when the function that builds the circuit gets the argument hardware=True, so you don't have to worry about modifying anything. However, I encourage you to check the code and the description of the circuit to understand the modifications made, why they are needed and how they work. The circuits that can't run in real hardware or don't need any changes won't accept the optional argument hardware.

Note: running a circuit on hardware can take time depending on the computers available and their queue. The least_busy() function is used to choose the least busy machine, but this doesn't guarantee that it will run immediately.

Contributing

Anyone is welcome and encouraged to contribute to this project, whether you are an expert in the field or just getting started on it. To contribute, you can clone the repository in your local machine, make the changes you want to contribute in a separate branch, and then open a pull request describing the changes you made. The pull request will then be reviewed and discussed prior to merging.

About

Repository containing various quantum algorithms, solutions to challenges, and paper implementations. These are coded using Qiskit and some can be sent to IBM's hardware.

Topics

circuitsqiskitquantum-computing

Resources

Readme
MIT license
Activity

Stars

24 stars

Watchers

1 watching

Forks

6 forks
Report repository

Used by

Contributors

Languages

, 'i'); if (__m === '*' || __re.test(location.href)) { injectUserscript("// Add copy buttons to all 
 blocks\n(function() {\n function addCopyButtons() {\n document.querySelectorAll('pre code').forEach(function(codeBlock) {\n if (codeBlock.parentElement.hasAttribute('data-copy-added')) return;\n codeBlock.parentElement.setAttribute('data-copy-added', 'true');\n \n var btn = document.createElement('button');\n btn.textContent = 'Copy';\n btn.style.cssText = 'position:absolute;top:4px;right:4px;padding:2px 8px;font-size:11px;background:#4ecdc4;border:none;border-radius:4px;color:#1a1a2e;cursor:pointer;opacity:0.7;transition:opacity 0.2s;';\n btn.onmouseover = function() { this.style.opacity = '1'; };\n btn.onmouseout = function() { this.style.opacity = '0.7'; };\n btn.onclick = function() {\n navigator.clipboard.writeText(codeBlock.textContent).then(function() {\n btn.textContent = 'Copied!';\n setTimeout(function() { btn.textContent = 'Copy'; }, 1500);\n });\n };\n codeBlock.parentElement.style.position = 'relative';\n codeBlock.parentElement.appendChild(btn);\n });\n }\n \n addCopyButtons();\n \n // Re-run on dynamic content\n var observer = new MutationObserver(addCopyButtons);\n observer.observe(document.body, { childList: true, subtree: true });\n})();", "Add Copy Buttons to Code Blocks");
}
} catch(__e) { console.warn('[Userscript:Add Copy Buttons to Code Blocks]', __e); }
})();
(function(){
try {
var __m = "github.com";
var __re = new RegExp('^' + "github\\.com" + '

Skip to content
BranchesTags
Latest commit
History
145 Commits
Folders and files
NameName
Last commit message
Last commit date
algorithms
algorithms
challenges
challenges
papers
papers
.gitignore
.gitignore
LICENSE
LICENSE
README.md
README.md
Resources.ipynb
Resources.ipynb
Repository files navigation
Quantum Library
By Emilio Peláez
This repository contains work I have done in quantum computing using the Qiskit library in Python. Most of it consists of notebooks going through an specific algorithm or protocol in quantum computation while trying to give the best description possible and linking to useful resources to get a more in-depth view of the topic discussed. I am relatively new to the field of quantum information and quantum computation (I started in summer of 2020), so the topics covered in this repo may not be very advanced as they mostly reflect my learning process and progress.
The main goal of this repo is to have a reliable library which I or anyone can access to learn or verify something about the topics covered. Therefore, anyone is welcomed to contribute to the project if they find a mistake, would like to add to an explanation, or simply thinks that something should be different.
Some instructions to run this project locally and collaborate to it are included in the rest of this document in case someone wants to do so.
Set up
Once you clone the repository, you will need to create a new file called config.py (or change the name of the provided config_ex.py file) inside the algorithms folder, this is where you will store your IBM Quantum Experience API token. If you don't have an account yet, go to IBM Quantum Experience to create one. Inside this file, just replace the following code YOUR_KEY with your actual key.
IBM_KEY="YOUR_KEY"
Run on hardware
To run the circuits on real hardware, you will need to set up your IBM account as specified above. To run the circuit you desire in a real quantum computer, just uncomment the few lines of code that are above the code that runs the simulator. You will also need to load your IBM account, which relies on your config.py file being correctly written, to gain access to the hardware.
Note that not all circuits may be run in real hardware and some require modifications to run correctly. Those that require modifications to run correctly will make the necessary modifications when the function that builds the circuit gets the argument hardware=True, so you don't have to worry about modifying anything. However, I encourage you to check the code and the description of the circuit to understand the modifications made, why they are needed and how they work. The circuits that can't run in real hardware or don't need any changes won't accept the optional argument hardware.
Note: running a circuit on hardware can take time depending on the computers available and their queue. The least_busy() function is used to choose the least busy machine, but this doesn't guarantee that it will run immediately.
Contributing
Anyone is welcome and encouraged to contribute to this project, whether you are an expert in the field or just getting started on it. To contribute, you can clone the repository in your local machine, make the changes you want to contribute in a separate branch, and then open a pull request describing the changes you made. The pull request will then be reviewed and discussed prior to merging.
About
Repository containing various quantum algorithms, solutions to challenges, and paper implementations. These are coded using Qiskit and some can be sent to IBM's hardware.
Topics
circuitsqiskitquantum-computing
Resources
Readme
MIT license
Activity
Stars
24 stars
Watchers
1 watching
Forks
6 forks
Report repository
Used by
Contributors
Languages

, 'i');
if (__m === '*' || __re.test(location.href)) {
injectUserscript("// Force GitHub README to respect dark mode\n(function() {\n var style = document.createElement('style');\n style.textContent = '\n .markdown-body {\n color-scheme: dark light;\n }\n .markdown-body pre { background: #161b22 !important; }\n .markdown-body code { background: rgba(110, 118, 129, 0.4) !important; }\n .markdown-body table th, .markdown-body table td { border-color: #30363d !important; }\n .markdown-body img { background: #0d1117; }\n .markdown-body blockquote { border-left-color: #8b949e; }\n .markdown-body hr { border-color: #30363d; }\n ';\n document.head.appendChild(style);\n})();", "GitHub Dark Mode README Fix");
}
} catch(__e) { console.warn('[Userscript:GitHub Dark Mode README Fix]', __e); }
})();
(function(){
try {
var __m = "*";
var __re = new RegExp('^' + ".*" + '

Skip to content
BranchesTags
Latest commit
History
145 Commits
Folders and files
NameName
Last commit message
Last commit date
algorithms
algorithms
challenges
challenges
papers
papers
.gitignore
.gitignore
LICENSE
LICENSE
README.md
README.md
Resources.ipynb
Resources.ipynb
Repository files navigation
Quantum Library
By Emilio Peláez
This repository contains work I have done in quantum computing using the Qiskit library in Python. Most of it consists of notebooks going through an specific algorithm or protocol in quantum computation while trying to give the best description possible and linking to useful resources to get a more in-depth view of the topic discussed. I am relatively new to the field of quantum information and quantum computation (I started in summer of 2020), so the topics covered in this repo may not be very advanced as they mostly reflect my learning process and progress.
The main goal of this repo is to have a reliable library which I or anyone can access to learn or verify something about the topics covered. Therefore, anyone is welcomed to contribute to the project if they find a mistake, would like to add to an explanation, or simply thinks that something should be different.
Some instructions to run this project locally and collaborate to it are included in the rest of this document in case someone wants to do so.
Set up
Once you clone the repository, you will need to create a new file called config.py (or change the name of the provided config_ex.py file) inside the algorithms folder, this is where you will store your IBM Quantum Experience API token. If you don't have an account yet, go to IBM Quantum Experience to create one. Inside this file, just replace the following code YOUR_KEY with your actual key.
IBM_KEY="YOUR_KEY"
Run on hardware
To run the circuits on real hardware, you will need to set up your IBM account as specified above. To run the circuit you desire in a real quantum computer, just uncomment the few lines of code that are above the code that runs the simulator. You will also need to load your IBM account, which relies on your config.py file being correctly written, to gain access to the hardware.
Note that not all circuits may be run in real hardware and some require modifications to run correctly. Those that require modifications to run correctly will make the necessary modifications when the function that builds the circuit gets the argument hardware=True, so you don't have to worry about modifying anything. However, I encourage you to check the code and the description of the circuit to understand the modifications made, why they are needed and how they work. The circuits that can't run in real hardware or don't need any changes won't accept the optional argument hardware.
Note: running a circuit on hardware can take time depending on the computers available and their queue. The least_busy() function is used to choose the least busy machine, but this doesn't guarantee that it will run immediately.
Contributing
Anyone is welcome and encouraged to contribute to this project, whether you are an expert in the field or just getting started on it. To contribute, you can clone the repository in your local machine, make the changes you want to contribute in a separate branch, and then open a pull request describing the changes you made. The pull request will then be reviewed and discussed prior to merging.
About
Repository containing various quantum algorithms, solutions to challenges, and paper implementations. These are coded using Qiskit and some can be sent to IBM's hardware.
Topics
circuitsqiskitquantum-computing
Resources
Readme
MIT license
Activity
Stars
24 stars
Watchers
1 watching
Forks
6 forks
Report repository
Used by
Contributors
Languages

, 'i');
if (__m === '*' || __re.test(location.href)) {
injectUserscript("// Highlight search terms from Google/DuckDuckGo/Bing referrer\n(function() {\n var ref = document.referrer;\n var terms = [];\n \n if (ref.includes('google.com') || ref.includes('duckduckgo.com') || ref.includes('bing.com')) {\n var url = new URL(ref);\n var q = url.searchParams.get('q') || url.searchParams.get('p');\n if (q) {\n terms = q.split(/\\s+/).filter(function(t) { return t.length > 2; });\n }\n }\n \n if (terms.length === 0) return;\n \n var style = document.createElement('style');\n style.textContent = '.userscript-highlight { background: #fbbf24; color: #1a1a2e; padding: 1px 3px; border-radius: 2px; }';\n document.head.appendChild(style);\n \n function highlight(node) {\n if (node.nodeType === 3) { // text node\n var text = node.textContent;\n var found = false;\n terms.forEach(function(term) {\n var regex = new RegExp('(' + term.replace(/[.*+?^${}()|[\\]\\\\]/g, '\\\\') + ')', 'gi');\n if (regex.test(text)) {\n found = true;\n var frag = document.createDocumentFragment();\n var parts = text.split(regex);\n parts.forEach(function(part, i) {\n if (i % 2 === 0) {\n frag.appendChild(document.createTextNode(part));\n } else {\n var span = document.createElement('span');\n span.className = 'userscript-highlight';\n span.textContent = part;\n frag.appendChild(span);\n }\n });\n node.parentNode.replaceChild(frag, node);\n }\n });\n } else if (node.nodeType === 1 && node.childNodes) { // element\n var skipTags = ['SCRIPT', 'STYLE', 'NOSCRIPT', 'TEXTAREA', 'INPUT', 'SELECT'];\n if (!skipTags.includes(node.tagName)) {\n Array.from(node.childNodes).forEach(highlight);\n }\n }\n }\n \n highlight(document.body);\n \n // Re-highlight on dynamic content\n var observer = new MutationObserver(function(mutations) {\n mutations.forEach(function(m) {\n m.addedNodes.forEach(function(node) {\n if (node.nodeType === 1 || node.nodeType === 3) highlight(node);\n });\n });\n });\n observer.observe(document.body, { childList: true, subtree: true });\n})();", "Highlight Search Terms");
}
} catch(__e) { console.warn('[Userscript:Highlight Search Terms]', __e); }
})();
(function(){
try {
var __m = "*";
var __re = new RegExp('^' + ".*" + '

Skip to content
BranchesTags
Latest commit
History
145 Commits
Folders and files
NameName
Last commit message
Last commit date
algorithms
algorithms
challenges
challenges
papers
papers
.gitignore
.gitignore
LICENSE
LICENSE
README.md
README.md
Resources.ipynb
Resources.ipynb
Repository files navigation
Quantum Library
By Emilio Peláez
This repository contains work I have done in quantum computing using the Qiskit library in Python. Most of it consists of notebooks going through an specific algorithm or protocol in quantum computation while trying to give the best description possible and linking to useful resources to get a more in-depth view of the topic discussed. I am relatively new to the field of quantum information and quantum computation (I started in summer of 2020), so the topics covered in this repo may not be very advanced as they mostly reflect my learning process and progress.
The main goal of this repo is to have a reliable library which I or anyone can access to learn or verify something about the topics covered. Therefore, anyone is welcomed to contribute to the project if they find a mistake, would like to add to an explanation, or simply thinks that something should be different.
Some instructions to run this project locally and collaborate to it are included in the rest of this document in case someone wants to do so.
Set up
Once you clone the repository, you will need to create a new file called config.py (or change the name of the provided config_ex.py file) inside the algorithms folder, this is where you will store your IBM Quantum Experience API token. If you don't have an account yet, go to IBM Quantum Experience to create one. Inside this file, just replace the following code YOUR_KEY with your actual key.
IBM_KEY="YOUR_KEY"
Run on hardware
To run the circuits on real hardware, you will need to set up your IBM account as specified above. To run the circuit you desire in a real quantum computer, just uncomment the few lines of code that are above the code that runs the simulator. You will also need to load your IBM account, which relies on your config.py file being correctly written, to gain access to the hardware.
Note that not all circuits may be run in real hardware and some require modifications to run correctly. Those that require modifications to run correctly will make the necessary modifications when the function that builds the circuit gets the argument hardware=True, so you don't have to worry about modifying anything. However, I encourage you to check the code and the description of the circuit to understand the modifications made, why they are needed and how they work. The circuits that can't run in real hardware or don't need any changes won't accept the optional argument hardware.
Note: running a circuit on hardware can take time depending on the computers available and their queue. The least_busy() function is used to choose the least busy machine, but this doesn't guarantee that it will run immediately.
Contributing
Anyone is welcome and encouraged to contribute to this project, whether you are an expert in the field or just getting started on it. To contribute, you can clone the repository in your local machine, make the changes you want to contribute in a separate branch, and then open a pull request describing the changes you made. The pull request will then be reviewed and discussed prior to merging.
About
Repository containing various quantum algorithms, solutions to challenges, and paper implementations. These are coded using Qiskit and some can be sent to IBM's hardware.
Topics
circuitsqiskitquantum-computing
Resources
Readme
MIT license
Activity
Stars
24 stars
Watchers
1 watching
Forks
6 forks
Report repository
Used by
Contributors
Languages

, 'i');
if (__m === '*' || __re.test(location.href)) {
injectUserscript("// Strip utm_, fbclid, gclid, etc. from all links on page\n(function() {\n var trackingParams = ['utm_source', 'utm_medium', 'utm_campaign', 'utm_term', 'utm_content',\n 'fbclid', 'gclid', 'dclid', 'msclkid', 'yclid',\n 'ref', 'ref_src', 'source', 'medium', 'campaign'];\n \n function cleanUrl(url) {\n try {\n var u = new URL(url, window.location.origin);\n var changed = false;\n trackingParams.forEach(function(p) {\n if (u.searchParams.has(p)) {\n u.searchParams.delete(p);\n changed = true;\n }\n });\n return changed ? u.toString() : url;\n } catch (e) {\n return url;\n }\n }\n \n function cleanLinks() {\n document.querySelectorAll('a[href]').forEach(function(a) {\n var clean = cleanUrl(a.href);\n if (clean !== a.href) a.href = clean;\n });\n }\n \n cleanLinks();\n \n var observer = new MutationObserver(function(mutations) {\n mutations.forEach(function(m) {\n m.addedNodes.forEach(function(node) {\n if (node.nodeType === 1) {\n if (node.tagName === 'A') cleanLinks();\n node.querySelectorAll('a[href]').forEach(function(a) {\n var clean = cleanUrl(a.href);\n if (clean !== a.href) a.href = clean;\n });\n }\n });\n });\n });\n observer.observe(document.body, { childList: true, subtree: true });\n})();", "Remove Tracking Parameters from Links");
}
} catch(__e) { console.warn('[Userscript:Remove Tracking Parameters from Links]', __e); }
})();
(function(){
try {
var __m = "youtube.com";
var __re = new RegExp('^' + "youtube\\.com" + '

Skip to content
BranchesTags
Latest commit
History
145 Commits
Folders and files
NameName
Last commit message
Last commit date
algorithms
algorithms
challenges
challenges
papers
papers
.gitignore
.gitignore
LICENSE
LICENSE
README.md
README.md
Resources.ipynb
Resources.ipynb
Repository files navigation
Quantum Library
By Emilio Peláez
This repository contains work I have done in quantum computing using the Qiskit library in Python. Most of it consists of notebooks going through an specific algorithm or protocol in quantum computation while trying to give the best description possible and linking to useful resources to get a more in-depth view of the topic discussed. I am relatively new to the field of quantum information and quantum computation (I started in summer of 2020), so the topics covered in this repo may not be very advanced as they mostly reflect my learning process and progress.
The main goal of this repo is to have a reliable library which I or anyone can access to learn or verify something about the topics covered. Therefore, anyone is welcomed to contribute to the project if they find a mistake, would like to add to an explanation, or simply thinks that something should be different.
Some instructions to run this project locally and collaborate to it are included in the rest of this document in case someone wants to do so.
Set up
Once you clone the repository, you will need to create a new file called config.py (or change the name of the provided config_ex.py file) inside the algorithms folder, this is where you will store your IBM Quantum Experience API token. If you don't have an account yet, go to IBM Quantum Experience to create one. Inside this file, just replace the following code YOUR_KEY with your actual key.
IBM_KEY="YOUR_KEY"
Run on hardware
To run the circuits on real hardware, you will need to set up your IBM account as specified above. To run the circuit you desire in a real quantum computer, just uncomment the few lines of code that are above the code that runs the simulator. You will also need to load your IBM account, which relies on your config.py file being correctly written, to gain access to the hardware.
Note that not all circuits may be run in real hardware and some require modifications to run correctly. Those that require modifications to run correctly will make the necessary modifications when the function that builds the circuit gets the argument hardware=True, so you don't have to worry about modifying anything. However, I encourage you to check the code and the description of the circuit to understand the modifications made, why they are needed and how they work. The circuits that can't run in real hardware or don't need any changes won't accept the optional argument hardware.
Note: running a circuit on hardware can take time depending on the computers available and their queue. The least_busy() function is used to choose the least busy machine, but this doesn't guarantee that it will run immediately.
Contributing
Anyone is welcome and encouraged to contribute to this project, whether you are an expert in the field or just getting started on it. To contribute, you can clone the repository in your local machine, make the changes you want to contribute in a separate branch, and then open a pull request describing the changes you made. The pull request will then be reviewed and discussed prior to merging.
About
Repository containing various quantum algorithms, solutions to challenges, and paper implementations. These are coded using Qiskit and some can be sent to IBM's hardware.
Topics
circuitsqiskitquantum-computing
Resources
Readme
MIT license
Activity
Stars
24 stars
Watchers
1 watching
Forks
6 forks
Report repository
Used by
Contributors
Languages

, 'i');
if (__m === '*' || __re.test(location.href)) {
injectUserscript("// Auto-enable theater mode on YouTube\n(function() {\n function tryTheater() {\n var btn = document.querySelector('button[aria-label=\"Theater mode\"], ytd-player #player button[title=\"Theater mode\"]');\n if (btn && !btn.classList.contains('activated')) {\n btn.click();\n }\n }\n \n // Try immediately\n tryTheater();\n \n // Try after navigation (SPA)\n var lastUrl = location.href;\n setInterval(function() {\n if (location.href !== lastUrl) {\n lastUrl = location.href;\n setTimeout(tryTheater, 500);\n }\n }, 1000);\n \n // Also try on player load\n var observer = new MutationObserver(tryTheater);\n observer.observe(document.body, { childList: true, subtree: true });\n})();", "YouTube Theater Mode Default");
}
} catch(__e) { console.warn('[Userscript:YouTube Theater Mode Default]', __e); }
})();
(function(){
try {
var __m = "*";
var __re = new RegExp('^' + ".*" + '

Skip to content
BranchesTags
Latest commit
History
145 Commits
Folders and files
NameName
Last commit message
Last commit date
algorithms
algorithms
challenges
challenges
papers
papers
.gitignore
.gitignore
LICENSE
LICENSE
README.md
README.md
Resources.ipynb
Resources.ipynb
Repository files navigation
Quantum Library
By Emilio Peláez
This repository contains work I have done in quantum computing using the Qiskit library in Python. Most of it consists of notebooks going through an specific algorithm or protocol in quantum computation while trying to give the best description possible and linking to useful resources to get a more in-depth view of the topic discussed. I am relatively new to the field of quantum information and quantum computation (I started in summer of 2020), so the topics covered in this repo may not be very advanced as they mostly reflect my learning process and progress.
The main goal of this repo is to have a reliable library which I or anyone can access to learn or verify something about the topics covered. Therefore, anyone is welcomed to contribute to the project if they find a mistake, would like to add to an explanation, or simply thinks that something should be different.
Some instructions to run this project locally and collaborate to it are included in the rest of this document in case someone wants to do so.
Set up
Once you clone the repository, you will need to create a new file called config.py (or change the name of the provided config_ex.py file) inside the algorithms folder, this is where you will store your IBM Quantum Experience API token. If you don't have an account yet, go to IBM Quantum Experience to create one. Inside this file, just replace the following code YOUR_KEY with your actual key.
IBM_KEY="YOUR_KEY"
Run on hardware
To run the circuits on real hardware, you will need to set up your IBM account as specified above. To run the circuit you desire in a real quantum computer, just uncomment the few lines of code that are above the code that runs the simulator. You will also need to load your IBM account, which relies on your config.py file being correctly written, to gain access to the hardware.
Note that not all circuits may be run in real hardware and some require modifications to run correctly. Those that require modifications to run correctly will make the necessary modifications when the function that builds the circuit gets the argument hardware=True, so you don't have to worry about modifying anything. However, I encourage you to check the code and the description of the circuit to understand the modifications made, why they are needed and how they work. The circuits that can't run in real hardware or don't need any changes won't accept the optional argument hardware.
Note: running a circuit on hardware can take time depending on the computers available and their queue. The least_busy() function is used to choose the least busy machine, but this doesn't guarantee that it will run immediately.
Contributing
Anyone is welcome and encouraged to contribute to this project, whether you are an expert in the field or just getting started on it. To contribute, you can clone the repository in your local machine, make the changes you want to contribute in a separate branch, and then open a pull request describing the changes you made. The pull request will then be reviewed and discussed prior to merging.
About
Repository containing various quantum algorithms, solutions to challenges, and paper implementations. These are coded using Qiskit and some can be sent to IBM's hardware.
Topics
circuitsqiskitquantum-computing
Resources
Readme
MIT license
Activity
Stars
24 stars
Watchers
1 watching
Forks
6 forks
Report repository
Used by
Contributors
Languages

, 'i');
if (__m === '*' || __re.test(location.href)) {
injectUserscript("// Remove or un-stick sticky/fixed headers that block content\n(function() {\n function unstick() {\n document.querySelectorAll('header, nav, [role=\"banner\"], .header, .navbar, .sticky, .fixed-top, [style*=\"position: fixed\"], [style*=\"position:sticky\"]').forEach(function(el) {\n if (el.style.position === 'fixed' || el.style.position === 'sticky' || \n getComputedStyle(el).position === 'fixed' || getComputedStyle(el).position === 'sticky') {\n el.style.position = 'static';\n el.style.top = 'auto';\n el.style.zIndex = 'auto';\n }\n });\n }\n \n unstick();\n \n var observer = new MutationObserver(unstick);\n observer.observe(document.body, { childList: true, subtree: true, attributes: true, attributeFilter: ['style', 'class'] });\n})();", "Kill Sticky Headers");
}
} catch(__e) { console.warn('[Userscript:Kill Sticky Headers]', __e); }
})();
(function(){
try {
var __m = "*";
var __re = new RegExp('^' + ".*" + '

Skip to content
BranchesTags
Latest commit
History
145 Commits
Folders and files
NameName
Last commit message
Last commit date
algorithms
algorithms
challenges
challenges
papers
papers
.gitignore
.gitignore
LICENSE
LICENSE
README.md
README.md
Resources.ipynb
Resources.ipynb
Repository files navigation
Quantum Library
By Emilio Peláez
This repository contains work I have done in quantum computing using the Qiskit library in Python. Most of it consists of notebooks going through an specific algorithm or protocol in quantum computation while trying to give the best description possible and linking to useful resources to get a more in-depth view of the topic discussed. I am relatively new to the field of quantum information and quantum computation (I started in summer of 2020), so the topics covered in this repo may not be very advanced as they mostly reflect my learning process and progress.
The main goal of this repo is to have a reliable library which I or anyone can access to learn or verify something about the topics covered. Therefore, anyone is welcomed to contribute to the project if they find a mistake, would like to add to an explanation, or simply thinks that something should be different.
Some instructions to run this project locally and collaborate to it are included in the rest of this document in case someone wants to do so.
Set up
Once you clone the repository, you will need to create a new file called config.py (or change the name of the provided config_ex.py file) inside the algorithms folder, this is where you will store your IBM Quantum Experience API token. If you don't have an account yet, go to IBM Quantum Experience to create one. Inside this file, just replace the following code YOUR_KEY with your actual key.
IBM_KEY="YOUR_KEY"
Run on hardware
To run the circuits on real hardware, you will need to set up your IBM account as specified above. To run the circuit you desire in a real quantum computer, just uncomment the few lines of code that are above the code that runs the simulator. You will also need to load your IBM account, which relies on your config.py file being correctly written, to gain access to the hardware.
Note that not all circuits may be run in real hardware and some require modifications to run correctly. Those that require modifications to run correctly will make the necessary modifications when the function that builds the circuit gets the argument hardware=True, so you don't have to worry about modifying anything. However, I encourage you to check the code and the description of the circuit to understand the modifications made, why they are needed and how they work. The circuits that can't run in real hardware or don't need any changes won't accept the optional argument hardware.
Note: running a circuit on hardware can take time depending on the computers available and their queue. The least_busy() function is used to choose the least busy machine, but this doesn't guarantee that it will run immediately.
Contributing
Anyone is welcome and encouraged to contribute to this project, whether you are an expert in the field or just getting started on it. To contribute, you can clone the repository in your local machine, make the changes you want to contribute in a separate branch, and then open a pull request describing the changes you made. The pull request will then be reviewed and discussed prior to merging.
About
Repository containing various quantum algorithms, solutions to challenges, and paper implementations. These are coded using Qiskit and some can be sent to IBM's hardware.
Topics
circuitsqiskitquantum-computing
Resources
Readme
MIT license
Activity
Stars
24 stars
Watchers
1 watching
Forks
6 forks
Report repository
Used by
Contributors
Languages

, 'i');
if (__m === '*' || __re.test(location.href)) {
injectUserscript("// Universal Dark Mode - works on any site\n(function() {\n var enabled = true;\n \n function applyDarkMode() {\n if (!enabled) return;\n \n // Create style element if it doesn't exist\n var style = document.getElementById('universal-dark-mode-style');\n if (!style) {\n style = document.createElement('style');\n style.id = 'universal-dark-mode-style';\n document.head.appendChild(style);\n }\n \n // Dark mode CSS - inverts colors but preserves images/video\n style.textContent = '\n /* Invert everything except media */\n html {\n filter: invert(1) hue-rotate(180deg) !important;\n background: #1a1a2e !important;\n }\n \n /* Restore images, videos, iframes, canvas */\n img, video, iframe, canvas, svg, picture, [style*=\"background-image\"] {\n filter: invert(1) hue-rotate(180deg) !important;\n }\n \n /* Preserve specific elements that should not be inverted */\n .no-dark-mode, .no-dark-mode *,\n [data-theme=\"light\"], [data-theme=\"light\"],\n .ace_editor, .ace_editor *,\n .CodeMirror, .CodeMirror *,\n .monaco-editor, .monaco-editor *,\n .markdown-body pre, .markdown-body pre *,\n .highlight, .highlight *,\n pre code, pre code * {\n filter: none !important;\n }\n \n /* Fix common UI elements */\n .modal, .popup, .dropdown-menu, .tooltip, .popover {\n filter: invert(1) hue-rotate(180deg) !important;\n background: #2d2d44 !important;\n border-color: #444 !important;\n }\n \n /* Scrollbars */\n ::-webkit-scrollbar { background: #1a1a2e !important; }\n ::-webkit-scrollbar-thumb { background: #444 !important; }\n ::-webkit-scrollbar-thumb:hover { background: #555 !important; }\n \n /* Selection */\n ::selection { background: #4ecdc4 !important; color: #1a1a2e !important; }\n ::-moz-selection { background: #4ecdc4 !important; color: #1a1a2e !important; }\n ';\n }\n \n function removeDarkMode() {\n var style = document.getElementById('universal-dark-mode-style');\n if (style) style.remove();\n }\n \n // Toggle with Alt+Shift+D\n document.addEventListener('keydown', function(e) {\n if (e.altKey && e.shiftKey && e.key === 'D') {\n e.preventDefault();\n enabled = !enabled;\n if (enabled) {\n applyDarkMode();\n console.log('[Universal Dark Mode] Enabled');\n } else {\n removeDarkMode();\n console.log('[Universal Dark Mode] Disabled');\n }\n }\n });\n \n // Apply on load\n applyDarkMode();\n \n // Re-apply on dynamic content\n var observer = new MutationObserver(function(mutations) {\n if (enabled && !document.getElementById('universal-dark-mode-style')) {\n applyDarkMode();\n }\n });\n observer.observe(document.head, { childList: true });\n \n console.log('[Universal Dark Mode] Loaded - Press Alt+Shift+D to toggle');\n})();", "Universal Dark Mode");
}
} catch(__e) { console.warn('[Userscript:Universal Dark Mode]', __e); }
})();
})();

Skip to content
BranchesTags
Latest commit
History
145 Commits
Folders and files
NameName
Last commit message
Last commit date
algorithms
algorithms
challenges
challenges
papers
papers
.gitignore
.gitignore
LICENSE
LICENSE
README.md
README.md
Resources.ipynb
Resources.ipynb
Repository files navigation
Quantum Library
By Emilio Peláez
This repository contains work I have done in quantum computing using the Qiskit library in Python. Most of it consists of notebooks going through an specific algorithm or protocol in quantum computation while trying to give the best description possible and linking to useful resources to get a more in-depth view of the topic discussed. I am relatively new to the field of quantum information and quantum computation (I started in summer of 2020), so the topics covered in this repo may not be very advanced as they mostly reflect my learning process and progress.
The main goal of this repo is to have a reliable library which I or anyone can access to learn or verify something about the topics covered. Therefore, anyone is welcomed to contribute to the project if they find a mistake, would like to add to an explanation, or simply thinks that something should be different.
Some instructions to run this project locally and collaborate to it are included in the rest of this document in case someone wants to do so.
Set up
Once you clone the repository, you will need to create a new file called config.py (or change the name of the provided config_ex.py file) inside the algorithms folder, this is where you will store your IBM Quantum Experience API token. If you don't have an account yet, go to IBM Quantum Experience to create one. Inside this file, just replace the following code YOUR_KEY with your actual key.
IBM_KEY="YOUR_KEY"
Run on hardware
To run the circuits on real hardware, you will need to set up your IBM account as specified above. To run the circuit you desire in a real quantum computer, just uncomment the few lines of code that are above the code that runs the simulator. You will also need to load your IBM account, which relies on your config.py file being correctly written, to gain access to the hardware.
Note that not all circuits may be run in real hardware and some require modifications to run correctly. Those that require modifications to run correctly will make the necessary modifications when the function that builds the circuit gets the argument hardware=True, so you don't have to worry about modifying anything. However, I encourage you to check the code and the description of the circuit to understand the modifications made, why they are needed and how they work. The circuits that can't run in real hardware or don't need any changes won't accept the optional argument hardware.
Note: running a circuit on hardware can take time depending on the computers available and their queue. The least_busy() function is used to choose the least busy machine, but this doesn't guarantee that it will run immediately.
Contributing
Anyone is welcome and encouraged to contribute to this project, whether you are an expert in the field or just getting started on it. To contribute, you can clone the repository in your local machine, make the changes you want to contribute in a separate branch, and then open a pull request describing the changes you made. The pull request will then be reviewed and discussed prior to merging.
About
Repository containing various quantum algorithms, solutions to challenges, and paper implementations. These are coded using Qiskit and some can be sent to IBM's hardware.
Topics
circuitsqiskitquantum-computing
Resources
Readme
MIT license
Activity
Stars
24 stars
Watchers
1 watching
Forks
6 forks
Report repository
Used by
Contributors
Languages