https://github.com/argmaster/bachelors_thesis

Finished with grade 5 (2-5 range), unfortunately only Polish version is available.
https://github.com/argmaster/bachelors_thesis

cssfinder quantum-entanglement separable-states

Last synced: 26 days ago
JSON representation

Finished with grade 5 (2-5 range), unfortunately only Polish version is available.

• Host: GitHub
• URL: https://github.com/argmaster/bachelors_thesis
• Owner: Argmaster
• Created: 2023-05-10T23:32:36.000Z (over 1 year ago)
• Default Branch: main
• Last Pushed: 2024-07-06T00:50:59.000Z (4 months ago)
• Last Synced: 2024-09-05T02:06:47.928Z (2 months ago)
• Topics: cssfinder, quantum-entanglement, separable-states
• Language: Jupyter Notebook
• Homepage:
• Size: 42.9 MB
• Stars: 0
• Watchers: 2
• Forks: 0
• Open Issues: 4
• Metadata Files:
  • Readme: README.md

Awesome Lists containing this project

README

        
## Bachelor's thesis: *Optimization of quantum entanglement detection software*

> ## Introduction

>

> Closest Separable State Finder (CSSFinder) is a program which can be used for 

> detection of entanglement in quantum system and determining how strong this

> entanglement is. It is based on an adapted algorithm by Elmer G. Gilbert, which allows

> for calculating the approximate value of the Hilbert-Schmidt distance between a

> quantum state and a set of separated states. The operation of this algorithm is

> described in a paper titled `Hilbert-Schmidt distance and entanglement witnessing'

> whose authors are Palash Pandya, Omer Sakarya and Marcin Wieśniak.

> 

> Dr. Marcin Wieśniak, prof. of UG, created an implementation of the CSSF algorithm in the

> Python language, using the NumPy library to perform the necessary matrix calculations.

> This choice was dictated by the possibilities offered by this toolkit. It allows you to

> quickly create simple code, capable of performing calculations relatively efficiently on

> all the most popular systems for desktop computers.

> 

> The advantages of the Python language are widely noted by both the academia as well as

> the commercial community, as is clearly evident in compilations such as those published

> by GitHub, Inc. `The top programming languages' (2022). The Python language ranks second

> in it.

> 

> Alternatives in the form of the C, C++ or Fortran languages would require more and more

> complex code, while forcing you to manually compile a build system, external libraries,

> and using dedicated solutions for each operating system operating system. In addition,

> performing calculations would be difficult, due to the the complicated process of

> integrating specialized libraries for linear algebra, the need for manual memory

> handling and static typing.

Finished with grade 5 (2-5 range), unfortunately full version is available only in Polish.

## Table of contents

```

1 Introduction.........................................................................3

    1.1 Operation of the Program.......................................................3

    1.2 Purpose of the work............................................................4

    1.3 Reasons to proceed with optimization...........................................5

2 Tools................................................................................5

    2.1 AOT compilation................................................................5

    2.2 JIT compilation................................................................6

    2.3 Tool selection.................................................................7

        2.3.1 Python and NumPy.........................................................7

        2.3.2 Python and NumPy with AOT................................................7

        2.3.3 Python and NumPy with JIT................................................8

        2.3.4 Rust and Ndarray.........................................................8

        2.3.5 Rust and Ndarray with OpenBLAS...........................................9

3 Methods..............................................................................9

    3.1 Modularization.................................................................9

    3.2 Test data.....................................................................10

    3.3 Test environment..............................................................11

    3.4 Profiling.....................................................................11

    3.5 Calculation precision.........................................................12

    3.6 Graphs........................................................................13

4 Results.............................................................................13

    4.1 Preliminary profiling.........................................................13

    4.2 Preliminary performance measurements..........................................15

    4.3 Double precision measurements.................................................16

        4.3.1 Python and NumPy........................................................17

        4.3.2 Python and NumPy with AOT...............................................17

        4.3.3 Python and NumPy with JIT...............................................19

        4.3.4 Rust and Ndarray........................................................20

        4.3.5 Rust and Ndarray with OpenBLAS..........................................20

4.4 Single precision measurements.....................................................21

        4.4.1 Python and NumPy........................................................21

        4.4.2 Python and NumPy with AOT...............................................22

        4.4.3 Python and NumPy with JIT...............................................22

        4.4.4 Rust and Ndarray........................................................24

        4.4.5 Rust and Ndarray with OpenBLAS..........................................24

    4.5 Matrix statements.............................................................25

        4.5.1 Matrix ρ1 (32 × 32).....................................................25

        4.5.2 Matrix ρ2 (4 × 4).......................................................26

        4.5.3 Matrix ρ3 (8 × 8).......................................................27

        4.5.4 Matrix ρ4 (16 × 16).....................................................27

        4.5.5 Matrix ρ5 (32 × 32).....................................................27

        4.5.6 Matrix ρ6 (64 × 64).....................................................28

    4.6 Rust profiling with OpenBLAS..................................................29

5 Discussion..........................................................................30

    5.1 Summary.......................................................................30

    5.2 Follow-up.....................................................................31

    5.3 Overlooked tools..............................................................32

        5.3.1 PyTorch and TensorFlow..................................................32

        5.3.2 PyPy....................................................................32

        5.3.3 C/C++...................................................................32

6 Conclusions.........................................................................33

    6.1 Conclusion....................................................................33

    6.2 Code..........................................................................33

References............................................................................35

```