Saravanan666/pypi-org huggingface dataset:
Package: quantum-lab
quantum_labRequirementsPython Packagesetuptools: Python 라이브러리 및 확장을 배포하는데 일반적으로 사용되는 익스텐션 라이브러리입니다.wheel: wheel은 파이썬의 build package로 일반적인 source distribution보다 더 빠른 설치가 가능하여서 공식적으로 권장되는 포맷이다.twine: pypi에 업로드하기 위한 패키지입니다.How To UseFile and config info :https://sdt.atlassian.net/wiki/spaces/SVC/pages/2322661469/python+QCC+python+PackageUpload package패키지 빌드$ cd notebook-job-py-package
$ python3 setup.py sdist bdist_wheel패키지 업로드 - 업로드 시 pypi 계정 정보를 입력해야 합니다.$ python3 -m twine upload dist/*
Uploading distributions to https://upload.pypi.org/legacy/
Enter your username: sujunelee                                                  
Enter your password: ************RunDownload package.$ pip3 install quantum_labRun codefrom quantum_lab import resources
from quantum_lab import jobs
import json

## Resource 조회
result = resources.getResource()

## Job 객체 생성
q_job = jobs.quantum_lab("minkyu.kim@sdt.inc", 1, "june-w", "hardware qcc")

## Job 생성
q_job.create("pythoncode", 2, "/home/jovyan/june/june-w/test.py")

## Job 전체 조회
result = q_job.getList()

## Job 조회
result = q_job.getJob(279)

## Job 삭제
result = q_job.delete(278)
Package: quantumlib
Quantum functions for PythonExperimental library for quantum calculations.ExamplesInteger factorizationfromquantumlibimportshorshor.factorize(1234567890123456789)# returns prime factors of given integerFind collisions for a custom functionEasily breaks AES256, RSA2048, SHA256 or whateverfromhashlibimportsha256fromquantumlibimportgroverdata=sha256('Piece of cake!'.encode())result=grover.find_collisions(sha256,data,max_collisions=1)print(result[0].decode())# outputs "Piece of cake!"Installpip3 install quantumlibRequirements8192-qubits QPUsense of humorEnjoy! :)
Package: quantum-linear-solvers
# Quantum linear solvers
Contains classical and quantum algorithms to solve systems of linear equations such as the HHL algorithm.## Installation`python git clonehttps://github.com/anedumla/quantum_linear_solvers.gitcd quantum_linear_solvers pip install . `## Documentation
Tutorial:https://learn.qiskit.org/course/ch-applications/solving-linear-systems-of-equations-using-hhl-and-its-qiskit-implementation
Package: quantum-linear-systems
quantum-linear-systemsQuantum algorithms to solve linear systems of equations.InstallationDependencies are managed withpoetry.
If poetry is not already installed on your system/evironment, follow theinstallation instructions.Then clone the projectgit clone https://github.com/SURFQuantum/qc-quantum-linear-systems.gitSwitch to the project directory withcd qc-quantum-linear-systemsand then simply:poetry installto install all dependencies.Additional RequirementsClassiq SDKThis project makes use of theclassiqSDK.
To use theclassiqSKD the user must perform authentication.
For more info check out theclassiq docspage.Authentication is as simple as:import classiq

classiq.authenticate()This will open a confirmation window in your default browser.
After confirming the user code the classiq login screen appears.
Completing the login completes the authentication process.
Package: quantumnetworks
quantumnetworksPlease checkout thispresentationfor a quick overview ofquantumnetworks!InstallationConda users, please make sure toconda install pipbefore running any pip installation if you want to installquantumnetworksinto your conda environment.quantumnetworkswill soon be published on PyPI. So, to install, simply run:pipinstallquantumnetworksIf you also want to download the dependencies needed to run optional tutorials, please usepip install quantumnetworks[dev]orpip install 'quantumnetworks[dev]'(forzshusers).To check if the installation was successful, run:python3>>>importquantumnetworksasqnBuilding from sourceTo buildquantumnetworksfrom source, pip install using:git clone git@github.com:Phionx/quantumnetworks.git
cd quantumnetworks
pip install --upgrade .If you also want to download the dependencies needed to run optional tutorials, please usepip install --upgrade .[dev]orpip install --upgrade '.[dev]'(forzshusers).Installation for DevsIf you intend to contribute to this project, please installquantumnetworksin develop mode as follows:gitclonegit@github.com:Phionx/quantumnetworks.gitcdquantumnetworks
pipinstall-e.[dev]Please usepip install -e '.[dev]'if you are azshuser.MotivationWe presentquantumnetworksas a numerical simulation tool with which to explore the time-dynamics of a driven, lossness, and nonlinear multi-mode quantum network using the Heisenberg-Langevin Equations. The applications of this tooling span quantum transduction, bosonic quantum error correction systems, quantum communication, and more.CodebaseThe codebase is split acrossquantumnetworks/systemsandquantumnetworks/analysis, which respectively provide solvers and analysis tools for several quantum network systems of interest.Future DirectionsCheckoutissuesto see what we are working on these days!AcknowledgementsCore Devs:Shantanu Jha,Shoumik Chowdhury,Lamia AteshianThanks toProfessor Luca Danieland our TA, Taqiyyah Safi, for invaluable feedback during the development of this package in the Fall 2021 iteration ofIntroduction to Numerical Simulation(6.336) at MIT.
Package: quantum-pecos
PECOS (Performance Estimator of Codes On Surfaces) is a Python framework for studying, developing, and evaluating
quantum error-correction protocols.Author: CiarÃ¡n Ryan-AndersonLanguage: Python 3.5.2+ (with optional C and C++ extensions)ContactFor questions or suggestions, please feel free to contact the author:CiarÃ¡n Ryan-Anderson,ciaran.ryan-anderson@quantinuum.comGetting StartedTo get started, check out the documentation in the "docs" folder or find it online at:https://quantum-pecos.readthedocs.ioLatest DevelopmentSee the following branch for the latest version of PECOS under development:https://github.com/PECOS-packages/PECOS/tree/developmentBEAWARE: There are some changes planned in 0.2.dev that may break some backwards compatibility with 0.1. Although, we try to minimize breaks to backwards compatibility.RequirementsPython 3.5.2+NumPy 1.15+SciPy 1.1+Matplotlib 2.2+NetworkX 2.1+Optional DependenciesCython (to compile optional C/C++ extensions)pytest 3.0+ (to run tests)Sphinx 2.7.6+ (to compile documentation)LicensePECOS is licensed under theApache 2.0 licenseInstallationTo install using pip run the command:pip install quantum-pecosTo install from GitHub go to:https://github.com/PECOS-packages/PECOSThen, download/unzip or clone the version of PECOS you would like to use. Next, navigate to the root of the package
(where setup.py is located) and run:pip install .To install and continue to develop the version of PECOS located in the install folder, run the
following instead:pip install -e .UninstallTo uninstall run:pip uninstall quantum-pecos
Package: quantum-query-optimizer
QuantumQueryOptimizerA toolkit to find the optimal quantum query complexity and query optimal quantum algorithm of arbitrary Boolean functions.We present this toolkit in our paper titled
"Robust and Space-Efficient Dual Adversary Quantum Query Algorithms".
The code, data, and figures for the experiments in the paper can
be found in thepaper/folder.Consider a function f that maps from D to E where D is a subset of bitstrings
of length n and E is the corresponding set of single bit outputs.
In the query model, an algorithm looks at the bits of the input string x in D
as few times as possible before correctly determing f(x).
Given f, our program finds the optimal query complexity of a quantum algorithm
that evaluates f and a span program (i.e. quantum algorithm) that meets
this query complexity by solving a semidefinite program (SDP).There are two ways to run our program.
First, explicitly specify the sets D and E.
Second, create one function that generates the set D for arbitrary bitstring length n
and another function that generates the set E from D according to f.
(Note: We provide example functions inboolean_functions.py.)InstallationInstall via pip withpip install quantum-query-optimizer.Example 1 - Explicit ConstructionWe consider the Boolean functionORon input bitstrings of length 2.
The output is'1'if any bit is 1 and'0'otherwise.
In this example, we explicitly define bothDandE.
Then we call our functionqqo.runSDPafter loading the
our packagequantum_query_optimizerasqqo.importquantum_query_optimizerasqqoD=['00','01','10','11']E=['0','1','1','1']qqo.runSDP(D=D,E=E)The corresponding output should look similar to:n: 2
D: ['00', '01', '10', '11']
E: ['0', '1', '1', '1']
Optimal Query Complexity: 1.414
Number of Iterations: 73
Run Time: 0.067 secondsExample 2 - Function ConstructionWe again considerORon bitstrings of length 2.
In this example, though, we define functions to generate
all bitstrings of length n and evaluate the functionORon D.
Then we pass our functions intoqqo.runSDPForNand specify
for which sizes of bitstringnwe want to solve the SDP.importquantum_query_optimizerasqqoqqo.runSDPForN(getD=qqo.getDAll,getE=qqo.getEOR,n_end=2,n_start=2))The corresponding output should look similar to:n: 2
D: ['00', '01', '10', '11']
E: ['0', '1', '1', '1']
Optimal Query Complexity: 1.414
Number of Iterations: 73
Run Time: 0.058 seconds(You can find more examples indemo.ipynb.)Semidefinite Program FormulationWe use Ben Reichardt's formulation of the SDP for
optimal quantum query complexity (described inTheorem 6.2)
and query optimal span program (Lemma 6.5) inSpan programs and quantum query complexity:
The general adversary bound is nearly tight for every boolean function.Alternating Direction MethodTo solve the SDP,
we use Zaiwen Wen, Donald Goldfarb, and Wotao Yin'sAlgorithm 1described inAlternating direction augmented Lagrangian methods for semidefinite programming.
Package: quantum-random
Quantum random numbers in PythonUse thePython random modulewith real quantum random numbers fromANU. The default pseudo-random generator is replaced by calls to
the ANU API.UsageImportqrandomand use it like the standardrandommodule. For example:>>>importqrandom>>>qrandom.random()0.15357449726583722>>>qrandom.sample(range(10),2)[6,4]>>>qrandom.gauss(0.0,1.0)-0.8370871276247828Alternatively, you can use the classqrandom.QuantumRandom. It has the same
interface asrandom.Random.There is also aNumPyinterface, although it is not fully tested:>>>fromqrandom.numpyimportquantum_rng>>>qrng=quantum_rng()>>>qrng.random((3,3))# use like numpy.random.default_rng()array([[0.37220278,0.24337193,0.67534826],[0.209068,0.25108681,0.49201691],[0.35894084,0.72219929,0.55388594]])NumPy is supported usingRandomGen.InstallationThe minimum supported Python version is 3.9. Install withpip:pipinstall-Uquantum-randomIf you want NumPy support:pipinstall-U'quantum-random[numpy]'First-time setup: setting your API keyANU requires you to use an API key. You can get a free trial or pay for a keyhere.You can pass your key toqrandomin three ways:By setting the environment variableQRANDOM_API_KEY.By running the included command line utilityqrandom-initto save your
key inqrandom.iniin a subdirectory of your home config directory
as specified by XDG, e.g.,/home/<your-username>/.config/qrandom/.By runningqrandom-initto save your key inqrandom.iniin a directory
of your choice, and then specifying this directory by settingQRANDOM_CONFIG_DIR.IfQRANDOM_API_KEYis set, its value is used as the API key and the
config file is not read. Otherwise,qrandomwill look for the key
in the config directory. The config directory defaults to the XDG home config
and can be changed by settingQRANDOM_CONFIG_DIR.Pre-fetching batchesBatches of quantum numbers are fetched from the API as needed.
Each batch contains 1024 numbers. Useqrandom.fill(n)to fetchnbatches
if you need to pre-fetch at the start of your computation.TestsThe tests run for Python 3.9 - 3.12 on the latest Windows,
macOS and Ubuntu runner images. Usetoxto run the tests locally.Seeherefor a visualisation and a Kolmogorov–Smirnov
test.Notes on implementationTheqrandommodule exposes a class derived fromrandom.Randomwith arandom()method that outputs quantum floats in the range [0, 1)
(converted from 64-bit integers). Overridingrandom.Random.randomis sufficient to make theqrandommodule behave mostly like therandommodule as described in thePython docs. The exceptions
aregetrandbits()andrandbytes(): these are not available inqrandom. Becausegetrandbits()is not available,randrange()cannot
produce arbitrarily long sequences. Finally, the user is warned whenseed()is called because the quantum generator has no state. For the same reason,getstate()andsetstate()are not implemented.LicenseSeeLICENCE.
Package: quantum-robot
quantum-robotis a Python package for quantum-like perception modeling
for robotics. The package exploitsQiksitframework, implementing the models on quantum circuits which can be
simulated on a classical computer or sent to a quantum backend (service
provided byIBM Quantum
Experience).The project was started in 2019 by Davide Lanza as a Master thesis
research, with the help ofFulvio
MastrogiovanniandPaolo
Solinas.It is currently maintained by Davide Lanza.Website:http://quantum-robot.orgRepository:https://github.com/Davidelanz/quantum-robot/Documentation:http://quantum-robot.org/docsContentsInstallNotebooksContributingCitingLicenseInstallDependenciesSee the required packageshere.User installationThe easiest way to installquantum-robotis usingpip:pip install -U quantum-robotThe package can beinstalled from
sourceas well. You can check the latest sources with the command:git clone https://github.com/Davidelanz/quantum-robot.gitTestingAfter installation, you can launch the test suite from outside the
source directory (you will need to havepytestinstalled):pytest qrobotSee also theGetting
Startedguide.ContributingIf you are interested in the project, we welcome new contributors of all
experience levels. For any question,contact the
maintainer.An example module with the docstring standard we adopted is availablehere.LicenseGNU-GPLv3
Package: quantumsculpt
QuantumSculptQuantumSculpt is a bundle of Python scripts to analyze the electronic
structure of systems calculated usingVASP. QuantumSculpt
is designed to operate onVASP WAVECARfiles
and on the output files ofLobster, specifically DOS and COHP
type of files.InstallationAnacondacondainstall-cifilotquantumsculptPyPipipinstallquantumsculptManualSee:https://quantumsculpt-inorganic-materials-chemistry-5002ad1bf06a7fa61a5.pages.tue.nl/
Package: quantumsecurity
QuantumSecurityA Python package for supporting security applications with the power of quantum computing and cryptography.DescriptionQuantumSecurity is a Python package designed to assist developers in implementing security applications using quantum computing and cryptography. The package currently provides a function namedqrandthat generates quantum random numbers. The generated quantum random numbers are in hexadecimal format.InstallationYou can install QuantumSecurity using pip:pipinstallquantumsecurity## Usagefromquantumsecurityimportqrand# Generate a quantum random number with 16 bitsrandom_number=qrand(16)print("Quantum Random Number:",random_number)## DependenciesThecurrentversionofQuantumSecurityreliesontheQiskitpackageandits'qasm_simulator'forquantumrandomnumbergeneration.Infutureiterations,supportforothersimulatorsfromAmazonBraketandQuantumHardwarefacilitieswillbeaddedtothe'qrand'function.## Future FeaturesInfuturereleases,QuantumSecurityaimstoprovideadditionaldynamicfunctionsrelatedtoquantumcryptographyandpost-quantumcryptography.Thesefunctionswillempowerdeveloperstostreamlinetheirsecurityimplementationswithoutwritingextensivecode.
Package: quantumseeding
QuantumSeedingGenerate really random seeds with Quantum ComputersInstallationpipinstallquantumseedingUsagefromquantumseedingimportQuantumSeedingseed=QuantumSeeding(ibm_token="YOUR_IBM_TOKEN"# https://quantum-computing.ibm.com/accountmax_qubits=7,# Max qubits to useverbose=True,# Print progresssimulation=True,# Use quantum computer simulator).get_seed()print(seed)
Package: quantum-serverless
Quantum Serverless clientInstallationpipinstallquantum_serverlessDocumentationFull docs can be found athttps://qiskit-extensions.github.io/quantum-serverless/UsageStep 1: write patternfromquantum_serverlessimportdistribute_task,get,get_arguments,save_resultfromqiskitimportQuantumCircuitfromqiskit.circuit.randomimportrandom_circuitfromqiskit.primitivesimportSamplerfromqiskit.quantum_infoimportSparsePauliOp# 1. let's annotate out function to convert it# to distributed async function# using `distribute_task` decorator@distribute_task()defdistributed_sample(circuit:QuantumCircuit):"""Calculates quasi dists as a distributed function."""returnSampler().run(circuit).result().quasi_dists[0]# 2. our program will have one arguments# `circuits` which will store list of circuits# we want to sample in parallel.# Let's use `get_arguments` funciton# to access all program argumentsarguments=get_arguments()circuits=arguments.get("circuits",[])# 3. run our functions in a loop# and get execution references backfunction_references=[distributed_sample(circuit)forcircuitincircuits]# 4. `get` function will collect all# results from distributed functionscollected_results=get(function_references)# 5. `save_result` will save results of program execution# so we can access it latersave_result({"quasi_dists":collected_results})Step 2: run patternfromquantum_serverlessimportServerlessProvider,QiskitPatternfromqiskit.circuit.randomimportrandom_circuitserverless=ServerlessProvider(username="<USERNAME>",password="<PASSWORD>",host="<GATEWAY_ADDRESS>",)# create programprogram=QiskitPattern(title="Quickstart",entrypoint="pattern.py",working_dir="./src")# create inputs to our programcircuits=[]for_inrange(3):circuit=random_circuit(3,2)circuit.measure_all()circuits.append(circuit)# run programjob=serverless.run(program=program,arguments={"circuits":circuits})Step 3: monitor job statusjob.status()# 'DONE'# or get logsjob.logs()Step 4: get resultsjob.result()# {"quasi_dists": [#  {"0": 0.25, "1": 0.25, "2": 0.2499999999999999, "3": 0.2499999999999999},#  {"0": 0.1512273969460124, "1": 0.0400459556274728, "6": 0.1693190975212014, "7": 0.6394075499053132},#  {"0": 0.25, "1": 0.25, "4": 0.2499999999999999, "5": 0.2499999999999999}# ]}
Package: quantum-sg
quantum-sgA command line tool that generates a cryptographically secure quantum-level secrets using ANU QRNG.UsageThis function generates a random set of secrets using the quantumrandom library. The parameters population, number and length are optional.fromstringimportdigitsfromquantum_sgimportrandrand(length=24,number=2,population=digits)Usage as CLI$pipinstallquantum-sg
$quantum-sg-l24-n2>4HOpcSlzrP1JA5pFROUJLi7V
>FkEKjlgm08Ey17HrAeeKKRl4OptionsThis command line utility can be used to generate secure secrets of specified length and complexity.The-hor--helpflag will display a help message to the user with instructions on how to use the utility.The-nor--numberflag will allow the user to specify the number of secrets to generate. By default, the utility will generate one secret.The-lor--lengthflag will allow the user to specify the length of each generated secret. By default, this length is 24 characters.The-wd,--digits,-wl,--lowercase,-wu,--uppercase,-wpand--punctuationflags will allow the user to specify which types of characters should be included in the generated secrets. By default, digits, lowercase characters, and uppercase characters are included.LicenseThe MIT License (MIT)Copyright (c) 2023 Alexander ShelepenokPermission 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.
Package: quantum-simba
SImBA - Systematic Inference of Bosonic quAntum systems>>Documentation<<Compute graphical quantum system representations from transfer functionsfromsimbaimporttransfer_function_to_graph,tf2rss,adiabatically_eliminatefromsympyimportsymbolss=symbols('s')gamma_f,lmbda=symbols('gamma_f lambda',real=True,positive=True)tf=(s**2+s*gamma_f-lmbda)/(s**2-s*gamma_f-lmbda)transfer_function_to_graph(tf,'active_coupled_cavity.png',layout='dot')Calculate system transfer functions from the inferred systemsplit_network=tf2rss(tf).to_slh().split()h_int=split_network.interaction_hamiltonianh_int.expr.simplify()Compute transfer functions between any degrees of freedom of the systemprint(split_network.state_vector)tfm=split_network.tfmtf=tfm.open_loop('a_1','aout_1').simplify()gamma_1,_=split_network.aux_coupling_constantsadiabatically_eliminate(tf,gamma_1)InstallationInstall viapip install quantum-simbaSeenotebooksfor examples.To clone the dev environment run,$ conda env create -f=environment.yml
$ conda activate simbaTo install simba for development purposes,$ pwd
... (simba code directory containing setup.py)
$ pip install -e .
(then to run test suite)
$ py.testTo build documentation locally,$ pwd
... (simba code directory containing setup.py)
$ ./make_docs.shMotivationOften when designing detectors for high-precision measurements, we are most interested in the frequency domain behaviour of such systems. For example, when computing the measurement shot noise of a gravitational wave detector, the noise spectrum is determined solely by the transfer function from the internal degree of freedom perturbed by the passing gravitational wave to the measurement output of the detector.Until recently there has been no way to infer the layout of a quantum system directly from its transfer function, but now due to recent research in the quantum control community this is possible.This software makes the process of finding a given physical realisation from the input-output transfer function completely automatic. Once this has been computed, it can then be used, for example, to deduce physical realisations, or more interestingly, to compute the most sensitive possible detector for a given numbers of internal degrees of freedom by minimizing the quantum Cramer-Rao bound.TODOExample notebooksWrite paperImplement scattering matrixInclude examples on this page
Package: quantum-solver
QuantumSolverQuantumSolverA little quantum toolset developed usingQiskitExplore the docs »Table of ContentsQuantumSolverGetting startedWarningDownload and installCommand Line InterfaceQuantumSolverBB84Web InterfaceBackendFrontendScreenshotsDocumentationGetting startedWarningThe toolset uses your personal IBM Quantum Experience token to access to the IBM hardware. You can access to your API token or generate another onehere.You can also use the Guest Mode which only allows you to run quantum circuits in a local simulator ("aer_simulator").Download and installgitclonehttps://github.com/alu0101238944/quantum-solver.gitcdquantum-solver
pip3install-e.Command Line InterfaceQuantumSolverpython3 src/main_quantum_solver.py [optional IBMQ_TOKEN]BB84python3 src/main_bb84.py [optional IBMQ_TOKEN]Web InterfaceBackendcd quantum_solver_web
python3 src/flask-server/server.pyFrontendcd quantum_solver_web
npm i
npm startScreenshotsHome PageToken PageMain Menu PageRun PageRun Experimental Mode PageDocumentationQuantumSolver documentation is available athttps://alu0101238944.github.io/quantum-solver/.