Angebotene Arbeiten
Bei Interesse an einer Bachelor oder Master Arbeit, einer Ingenieurs oder Forschungspraxis oder einer Werkstudententätigkeit, können Sie sich auch direkt an unsere Doktoranden wenden. Es sind oftmals Themen in Vorbereitung, die hier noch nicht aufgelistet sind und es besteht die Möglichkeit ein Thema entsprechend Ihrer Interessenlage zu finden.
Bitte legen Sie jeder Bewerbung einen Lebenslauf sowie eine Liste der besuchten Lehrveranstaltungen bei.
Wenn Ihre Ingenieurspraxis vom Studiendekanat an einen unserer Professoren zugeteilt wurde, wenden Sie sich damit bitte an Frau Dorn (Raum N2401).
Bachelorarbeiten
Generalized Deterministic Identification For The DMC With Power Constraint
Generalized Deterministic Identification For The DMC With Power Constraint
Stichworte:
Identification via channel, Kidentification, deterministic codes
Kurzbeschreibung:
Kidentification capacity of a DMC is derived.
Beschreibung
The student attempt to study the deterministic identification capacity
of a DMC subject to power constraint and generalize it for the Kidentification.
Voraussetzungen
Basics of Information Theory and Channel Coding.
Familiarity with the fundamentals of Identification Theory
Betreuer:
A Jupyter Notebook for Line Coding in Access Networks (LB)
A Jupyter Notebook for Line Coding in Access Networks (LB)
Beschreibung
For the access network case, the spectrum of the transmit signal has to be adapted to the channel properties. This can either be achieved by choosing suitable transmit pulse shapes or by encoding the (redundancy free) source symbols [1].
The students task is to implement a demonstration of two line coding schemes in Python [2] (Jupyter Notebook) and visualize the results. Additionally, the student also has to arrange code and surrounding text, such that the content becomes selfexplanatory.
[1] Skript "Physical Layer Methods“
[2] "Python in 30 minutes" (https://www.programiz.com/pythonprogramming/tutorial)
Voraussetzungen
Since the Jupyter Notebook is to be written in german language, the student should be able to write in german at least on a basic level.
While some basics in any programming language are beneficial, this is also a great opportunity for programming beginners, wishing to expand their programming skills.
This topic is only available for students of the "Lehramtsstudiengänge".
Betreuer:
A Jupyter Notebook for Equalization Methods (LB)
A Jupyter Notebook for Equalization Methods (LB)
Beschreibung
Depending on the channel properties, the receive signal in a communication system can be severely distorted, causing intersymbol interference. To mitigate these interferences, several approaches for equalization can be taken [1].
The students task is to implement a demonstration of several equalization schemes in Python [2] (Jupyter Notebook) and visualize the results. Additionally, the student also has to arrange code and surrounding text, such that the content becomes selfexplanatory.
[1] Skript "Physical Layer Methods“
[2] "Python in 30 minutes" (https://www.programiz.com/pythonprogramming/tutorial)
Voraussetzungen
Since the Jupyter Notebook is to be written in german language, the student should be able to write in german at least on a basic level.
While some basics in any programming language are beneficial, this is also a great opportunity for programming beginners, wishing to expand their programming skills.
This topic is only available for students of the "Lehramtsstudiengänge".
Betreuer:
Computation of Identification Function Over Faulty Channels
Computation of Identification Function Over Faulty Channels
Stichworte:
Identification via channels, identification function, complexity of distributive computing, one/twoway probabilistic communications
Beschreibung
Identification problem (Ahlswede and Dueck, 1989) over the Binary Symmetric Channel (BSC) is linked to the communication complexity problem (one/two way communications) and interpreted in that context.
Voraussetzungen
Interested student is encouraged to contact me and send me a CV as well as all the academic transcripts and relevant courses that they have attended.
As well familiarity with the following is required:
 Basics of information/identification theory
 Basic of communication complexity
Betreuer:
Masterarbeiten
QuasiLinear Multiplexing in NFDM Systems with Purely Discrete Nonlinear Spectrum
QuasiLinear Multiplexing in NFDM Systems with Purely Discrete Nonlinear Spectrum
Beschreibung
As the achievable rates of modern transmission systems seem to saturate, while the bandwidth demand is steadily growing, it is necessary to consider alternative approaches for fiber optic data transmission. In recent years, many publications have explored possibilities to overcome the phenomenon, commonly known as 'capacity crunch', by using the nonlinear Fourier transform (NFT).
In a special case of nonlinear frequency division multiplexing (NFDM) only discrete eigenvalues of the ZakharovShabatsystem are used for multiplexing data streams in the nonlinear Fourier domain. While, at first, this seems appealing, because the resulting signal pulses are Nsoliton breathers and thus are not affected by chromatic dispersion in the same way as e.g. wave division multiplexing (WDM) signals, the timebandwidth product of such pulses is rather high when compared to pulses used in WDM systems. This results in a low modulation efficiency for such discrete nonlinear spectrum NFDM systems.
One possible option to increase the spectral efficiency of the previously mentioned NFDM systems is to extend the modulated linear frequency range by linearly multiplexing such NFDM signals in a WDM fashion. Since the transformations used in NFDM systems are quite involved, it is not clear what the analog of this in nonlinear domain would be.
The task of the student would be to first get familiar with the necessary preliminaries regarding NFDM systems. Subsequently, the simulation of the system described above has to be implemented (certain parts of the system will be made available to the student by the supervisor) and evaluated in terms of some performance metrics.
While specific literature will be recommended to the student over the course of the thesis, some basic literature discussing the 'capacity peak' of WDM modulated optical fiber systems [1] and the basics of the nonlinear Fourier transform (NFT) [24], which is a central concept in NFDM systems, are given below. Note that, since NFDM is a very broad topic it is not necessary to fully understand every notion in [14]. Nonetheless, these publications give the reader a solid foundation for the further study of this topic.
[1] Essiambre, RenéJean, et al. "Capacity limits of optical fiber networks."
[2] Yousefi, Mansoor I., and Frank R. Kschischang. "Information transmission using the nonlinear Fourier transform, Part I: Mathematical tools."
[3] Yousefi, Mansoor I., and Frank R. Kschischang. "Information transmission using the nonlinear Fourier transform, Part II: Numerical methods."
[4] Yousefi, Mansoor I., and Frank R. Kschischang. "Information transmission using the nonlinear Fourier transform, Part III: Spectrum modulation."
Voraussetzungen
Having listened to the lecture 'Optical Communication Systems' by professor Hanik (or any comparable lecture on fiber optic systems) is highly beneficial.
Basic Matlab skills (and programming skills in general) are also beneficial.
Regarding the NFDM part of the thesis no prior knowledge is assumed.
Betreuer:
[identification] Implementation of identification with algebraicgeometry (Goppa) codes
[identification] Implementation of identification with algebraicgeometry (Goppa) codes
Stichworte:
goppa algebraic geometry codes identification
Beschreibung
Identification is a communication scheme that allows rate doubly exponential in the blocklemght, with the tradeoff that identities cannot be decoded (as messages do) but can only be verified.
The double exponential growth presents various challenges in the finite regime: there are heavy computational costs introduced at the encoder and decoder and heavy tradeoffs between the error and the codes sizes.
The ultimate goal is to find a fast, reliable implementation while still achieving large code sizes.
Identification codes can be achieved by first removing the errors from the channel with regular transmission channel coding, and then sending a challenge though the corrected channel. For every identity i, The channenge is generated by picking a random input m and computing the corresponding output T_i(m) using a function T_i that depends on the identity. The challenge is then the pair m,T_i(m) and the receiver wanting to verify an identity j will verify whether j=i by testing the challenge. This is done by recomputing the output with T_j and verifying whether T_j(m)= T_i(m). The errors are reduced by ensuring that the various functions collide on a small fraction of the possible inputs.
It turns out that choosing good sets of funtions {T_i} is the same as choosing errorcorrection codes {c_i} with large distance, where now each codeword c_i defines a function by mapping positions m (sometimes called code locators) to symbols c_im of the codeword.
We can thus construct identification codes by choosing errorcorrection codes where we are only interested in the performance of the error correction encoders (we are not interested in the errorcorrection decoder or errorcorrection codes).
Your task will be implementing identification with Goppa codes, aiming at the fastest implementation, and testing their performance in comparison to other current implementations. The reference articles for this implementation are:
For reference, our previous work on identification based on ReedSolomon and ReedMuller code can be found at
The coding will be in Python/Sagemath.
The working language will be in English.
Environment: we collaborate with LTI. At LNT and LTI there is currently a lot of funding for research in identification. Therefore you will find a large group of people that might be available for discussion and collaboration.
Betreuer:
[identification] Implementation of identification with universal hash functions
[identification] Implementation of identification with universal hash functions
Stichworte:
universal hash identification
Beschreibung
Identification is a communication scheme that allows rate doubly exponential in the blocklemght, with the tradeoff that identities cannot be decoded (as messages do) but can only be verified.
The double exponential growth presents various challenges in the finite regime: there are heavy computational costs introduced at the encoder and decoder and heavy tradeoffs between the error and the codes sizes.
The ultimate goal is to find a fast, reliable implementation while still achieving large code sizes.
Identification codes can be achieved by first removing the errors from the channel with regular transmission channel coding, and then sending a challenge though the corrected channel. For every identity i, The channenge is generated by picking a random input m and computing the corresponding output T_i(m) using a function T_i that depends on the identity. The challenge is then the pair m,T_i(m) and the receiver wanting to verify an identity j will verify whether j=i by testing the challenge. This is done by recomputing the output with T_j and verifying whether T_j(m)= T_i(m). The errors are reduced by ensuring that the various functions collide on a small fraction of the possible inputs.
It turns out that choosing good sets of funtions {T_i} is the same as choosing errorcorrection codes {c_i} with large distance, where now each codeword c_i defines a function by mapping positions m (sometimes called code locators) to symbols c_im of the codeword.
We can thus construct identification codes by choosing errorcorrection codes where we are only interested in the performance of the error correction encoders (we are not interested in the errorcorrection decoder or errorcorrection codes).
Your task will be implementing the identification codes described in
aiming at the fastest implementation, and testing their performance in comparison to other current implementations.
For reference, our previous work on identification based on ReedSolomon and ReedMuller code can be found at
The coding will be in Python/Sagemath.
The working language will be in English.
Environment: we collaborate with LTI. At LNT and LTI there is currently a lot of funding for research in identification. Therefore you will find a large group of people that might be available for discussion and collaboration.
Betreuer:
[identification] Implementation of identification with Polar codes
[identification] Implementation of identification with Polar codes
Stichworte:
polar codes identification
Beschreibung
Identification is a communication scheme that allows rate doubly exponential in the blocklemght, with the tradeoff that identities cannot be decoded (as messages do) but can only be verified.
The double exponential growth presents various challenges in the finite regime: there are heavy computational costs introduced at the encoder and decoder and heavy tradeoffs between the error and the codes sizes.
The ultimate goal is to find a fast, reliable implementation while still achieving large code sizes.
Identification codes can be achieved by first removing the errors from the channel with regular transmission channel coding, and then sending a challenge though the corrected channel. For every identity i, The channenge is generated by picking a random input m and computing the corresponding output T_i(m) using a function T_i that depends on the identity. The challenge is then the pair m,T_i(m) and the receiver wanting to verify an identity j will verify whether j=i by testing the challenge. This is done by recomputing the output with T_j and verifying whether T_j(m)= T_i(m). The errors are reduced by ensuring that the various functions collide on a small fraction of the possible inputs.
It turns out that choosing good sets of funtions {T_i} is the same as choosing errorcorrection codes {c_i} with large distance, where now each codeword c_i defines a function by mapping positions m (sometimes called code locators) to symbols c_im of the codeword.
We can thus construct identification codes by choosing errorcorrection codes where we are only interested in the performance of the error correction encoders (we are not interested in the errorcorrection decoder or errorcorrection codes).
Your task will be implementing identification with polar codes, aiming at the fastest implementation, and testing their performance in comperison to other current implementations.
For reference, our previous work on identification based on ReedSolomon and ReedMuller code can be found at
The coding will be in Python/Sagemath.
The working language will be in English.
Environment: we collaborate with LTI. At LNT and LTI there is currently a lot of funding for research in identification. Therefore you will find a large group of people that might be available for discussion and collaboration.
Betreuer:
[identification] Applications of Identification Codes in V2X Communications
[identification] Applications of Identification Codes in V2X Communications
Beschreibung
As part of the NewCom Project, new communication paradigms are investigated from an experimental perspective in order to construct proofofconcept implementations that demonstrate the theoretical results obtained for PostShannon Communication schemes. In particular, this MSc thesis focuses on Identification Codes and their integration into a simulation environment where vehicular networks are modelled.
For this, the master student will first conduct a review of the stateoftheart use cases for identification in the scientific literature and in form of patents, with an emphasis on V2X communications. By using an opensource V2X implementation based on LDR’s Simulation of Urban Mobility (SUMO) framework integrated with ns3’s implementation of the ITSG5 and LTE standards and conducting simulation in specific scenarios, the student will gain a first impression of the performance of the system using traditional transmission schemes. The integration of existing implementation of identification codes culminates this thesis, where KPIs will be defined in order to compare the advantages of using identification instead of transmission in the context of V2X communications.
Voraussetzungen

Knowledge of communications engineering, mobile communications, wireless channel models, signal processing, and channel coding techniques (experience in LTE/5G cellular networks is a plus)

Interest in novel communication concepts as well in their practical implementation

Software experience: MATLAB, C++ and Python (experience with ns3 or SUMO is a plus)

Comfortable working with Linux operative systems and distributed version control tools (e.g., gitlab)

Goaloriented and structured work style
Kontakt
To apply, Please send your application by email to Roberto Ferrara (roberto.ferrara@tum.de) and Luis TorresFigueroa (luis.torres.figueroa@tum.de) with the following documents:

Curriculum vitae

Academic transcript

Short motivation (0.5 – 1 page)
Betreuer:
[identification] Simulation and performance improvement of identification codes
[identification] Simulation and performance improvement of identification codes
Beschreibung
Identification is a communication scheme that allows rate doubly exponential in the blocklemght, with the tradeoff that identities cannot be decoded (as messages do) but can only be verified.
The double exponential growth presents various challenges in the finite regime: there are heavy computational costs introduced at the encoder and decoder and heavy tradeoffs between the error and the codes sizes.
The ultimate goal is to find a fast, reliable implementation while still achieving large code sizes.
Identification codes can be achieved by first removing the errors from the channel with regular transmission channel coding, and then sending a challenge though the corrected channel. For every identity i, The channenge is generated by picking a random input m and computing the corresponding output T_i(m) using a function T_i that depends on the identity. The challenge is then the pair m,T_i(m) and the receiver wanting to verify an identity j will verify whether j=i by testing the challenge. This is done by recomputing the output with T_j and verifying whether T_j(m)= T_i(m). The errors are reduced by ensuring that the various functions collide on a small fraction of the possible inputs.
It turns out that choosing good sets of funtions {T_i} is the same as choosing errorcorrection codes {c_i} with large distance, where now each codeword c_i defines a function by mapping positions m (sometimes called code locators) to symbols c_im of the codeword.
We can thus construct identification codes by choosing errorcorrection codes where we are only interested in the performance of the error correction encoders (we are not interested in the errorcorrection decoder or errorcorrection codes).
Your task will be speeding up the current implementations based on ReedSolomon and ReedMuller codes:
The coding will be in Python/Sagemath.
This work can accomodate multiple students.
The working language will be in English.
Environment: we collaborate with LTI. At LNT and LTI there is currently a lot of funding for research in identification. Therefore you will find a large group of people that might be available for discussion and collaboration.
Voraussetzungen
Nachrichtentechnik 2
Betreuer:
[security] Practical implementation of physicallayer semantic security
[security] Practical implementation of physicallayer semantic security
Stichworte:
semantic, security, secrecy, programming, implementation
Beschreibung
The goal of this project is to implement in Python/Sagemath the security functions (at least one of four) described in https://arxiv.org/abs/2102.00983
Sagemath contains libraries for mosaics, BIBDs, etc, that can be used for the project.
Motivation:
There are various types of security definitions.
The mutual information based types, in increasing order of security requirement are
 Weak secresy asks that the average mutual information of the eavesdropper I(M:E)/n goes to 0 for a uniform message M (average here means averaged over the blocklength n, an additional average over M is implicit in the mutual information)
 Strong secrecy asks that the total mutual information I(M:E) goes to 0,
 Semantic security asks that the total mutual informaiton I(M:E) goes to 0 for any distribution of the message M (and thus in particular for all distributions that pick any of two chosen messages with 1/2 probabilty)
Then there are the almostequivalent respective indistiguishablity types of security requirements (below PQ_1 is the statistical distance and Exp_M is expectation value over M)
 average indistinguishability 1/n Exp_M  P_{EM}  P_E _1 for a uniform message M goes to 0 (again average refers over the blocklegth n, clearly there is also the average over M)
 total indistiguishability Exp_M  P_{EM}  P_E _1 for a uniform message M goes to 0
 indistinguishability P_{Em}  P_{Em'}_1 for any two messages m and m' goes to 0.
Each of the indistiguishabilities can also be written using KL digvergence instead of statistical distance, in which case the conditions are exactly equivalent to their mutual information versions.
Strong secrecy is the standard security requirement considered in informationtheoretic security, while semantic security is the minimum requirement considered in computational security.
Informationtheoretic (physicallayer) security differs from computational security in that the secrecy is guaranteed irrespective of the power of the adversary, while in computational security E is computationally bounded. Computational security also assumes that the message is at least of a certain length for the schemes to work, and thus if the message to be secured is too small it needs to be padded to a larger message.
In practice, information theoretic security is expensive, because the messages that can be secured can be only as long as the keys that can be generated. However, in identification only a very small part of the message needs to be secured, which in computational security triggers padding and thus waste, but on the other side makes informationtheoretic security accessible and not so expensive.
At the same time, the security of identification implicitly requires semantic security. It has been known for a while that hash functions provide informationtheoretic strong secrecy. However, because the standard for informationtheoretic security has been strong secrecy, before https://arxiv.org/abs/2102.00983 no efficient functions where known to provide informationtheoretic semantic security.
We need an implementation of these type of functions so that we can integrate informationtheoretic security into our identification project.
Betreuer:
[quantum] Realignment criterion and upper bounds in deviceindependent QKD
[quantum] Realignment criterion and upper bounds in deviceindependent QKD
Beschreibung
This paper uses the partial transpose as a tool to derive upper bounds on deviceindependent QKD
https://arxiv.org/abs/2005.13511
In this project the goal is to try to generalize the above to the other tools like the reallignment criterion:
https://arxiv.org/abs/quantph/0205017
https://arxiv.org/abs/0802.2019
Voraussetzungen
basics of quantum information/quantum formalism
Betreuer:
[quantum] Semantic security of infinitedimensional classicalquantum channels
[quantum] Semantic security of infinitedimensional classicalquantum channels
Beschreibung
Generalize semantic security of classicalquantum channels to infinite dimensional channel (not necessarily gaussian)
 [1] finite dimensional classicalquantum case
https://arxiv.org/abs/2001.05719  finite and infinite dimensional classical case
https://arxiv.org/abs/1811.07798  [this subpoint can be a project by itself] the finite dimesional case needs to be recast into smoothmax information (instead than Lemma 5.7 of [1]) as the classical case does, this paper proves properties of the smoothmaxinf in finite dimension that we would need for that
https://arxiv.org/abs/2001.05719  papers regarding the capacity for infinite dimensional channels
http://arxiv.org/abs/quantph/9912067v1
http://arxiv.org/abs/quantph/0408009v3
http://arxiv.org/abs/quantph/0408176v1
Voraussetzungen
quantum information theory
Betreuer:
[quantum] Asymptotic continuity of restricted quantum relative entropies under general channels
[quantum] Asymptotic continuity of restricted quantum relative entropies under general channels
Stichworte:
quantum, relative entropy, Pinsker, reverse, inequality, information thoery, asymptotic, continuity
Beschreibung
Asypmtotic continuity is a property in the form of inequalities (classically known also as inequalities of the reversePinker type) that is necessary to prove upper bounds on operational capacities.
The (quantum) relative entropy (also known as quantum divergence and classically also known as KullbacktLeibler divergence), can be used to define various entanglment measures many of which have a proven asymptotic continuity.
Of particular interest are the restricted quantum relative entropies defined by Marco Piani (https://arxiv.org/abs/0904.2705), many of which satisfy asymptotic continuity (A.S.)
 https://arxiv.org/abs/quantph/9910002
 https://arxiv.org/abs/quantph/0203107
 https://arxiv.org/abs/quantph/0507126
 https://arxiv.org/abs/1210.3181
 https://arxiv.org/abs/1507.07775
 https://arxiv.org/abs/1512.09047
In the above there are maybe 23 different proof styles.
We can group the results in the above as follows:
 A.S. for entropy, conditional entropies, mutual information, conditional mutual information
 A.S. for relative entropies with infimum over states on the second argument
 A.S. relative entropies with infimum over state *and maximization over measurement channels*
The goal of the project is to generalize the last case to asymptotic continuity for relative entropies with infimum over state and maximization over *general* channels.
 Partial results toward this goal can be found in the appendix of my PhD thesis: http://web.math.ku.dk/noter/filer/phd18rf.pdf
 Such a result would have immediate applications to this paper: https://arxiv.org/abs/1801.02861
Possible new proof directions are
 using Renyi αrealtive entropies with the limit α>1
 using Kim's operator inequality from
https://arxiv.org/abs/1210.5190
to get an operator inequality looking like a reverse strong subadditivity (see https://www.youtube.com/watch?v=P3xI1u1Y2s for a good overview and in particular at minute 31:20 for the reverse SSA)
Voraussetzungen
Knowledge of quantum information is highly recommended/required.
Knowledge of matrix analysis will be a strong advantage.
Kontakt
roberto.ferrara@tum.de
Betreuer:
[quantum] Practical protocols for quantum synchronization in classical network
[quantum] Practical protocols for quantum synchronization in classical network
Stichworte:
quantum, network, synchronization
Beschreibung
relevant papers
https://arxiv.org/abs/1310.6043
https://arxiv.org/abs/1304.5944
https://arxiv.org/abs/1310.6045
https://arxiv.org/abs/1703.05876
https://arxiv.org/abs/1303.6357
background papers
https://ieeexplore.ieee.org/document/7509657
Voraussetzungen
Knowledge of quantum theory as provided by the course Algorithms in Quantum Theory or similar
Betreuer:
[quantum] Entanglementmeasures upper bounds on deviceindependent distillable key
[quantum] Entanglementmeasures upper bounds on deviceindependent distillable key
Stichworte:
quantum, qkd, entanglement
Beschreibung
The goal of this work is to try to upper bound the deviceindependent distillable key in terms of locally restricted relative entropy of entanglement (an entanglement measure).
The following are relevant works/articles
 works toward even *a definition* of device independent distillable key
https://arxiv.org/abs/2005.13511
https://arxiv.org/abs/2005.12325
https://arxiv.org/abs/1810.05627  works relating distillable entanglement and distillable key to locally restricted relative entropy measures
https://arxiv.org/abs/1609.04696
https://arxiv.org/abs/1402.5927  the first definition of restricted relative entropies
https://arxiv.org/abs/0904.2705  important properties of restricted relative entropies, and some overview of entanglement measures
https://arxiv.org/abs/1210.3181  my PhD thesis
http://web.math.ku.dk/noter/filer/phd18rf.pdf
Voraussetzungen
Strong background in quantum theory is required, preferably in quantum information theory, which is not covered by the course Algorithms in Quantum Theory
Betreuer:
Explicit Construction of Deterministic Identification Codes
Explicit Construction of Deterministic Identification Codes
Stichworte:
Identification via channels, identification codes,
Beschreibung
In this thesis, the student after studying deterministic identification will construct the explicit codes for certain channels.
Voraussetzungen
Interested student are encouraged to contact me and send me a CV as well as all the academic transcripts and relevant courses that they have attended.
As well familiarity with the following is required:
Background in Information Theory and Channel Coding
Familiarity in fundamentals of Identification Theory
Betreuer:
Group testing techniques based on sparse graphs for largescale population screening
Group testing techniques based on sparse graphs for largescale population screening
Beschreibung
Group testing is a combinatorial technique (developed by R. Dorfman in 1943) which allows to detect infected individuals by running “pooled” tests on (blood) samples. More specifically, by merging the samples of a subset of individuals into a pool, a test is carried out to verify the positivity (or negativity) of the pool. By repeating the test on different subsets, it is eventually possible to detect the individuals carrying the infection, possibly with very few tests compared with the test population. The approach is currently scouted to speedup the testing in the context of the COVID19 pandemic (see https://www.nature.com/articles/d41586020020536 and [12]). The technique admits a description which shares several similarities with the syndromebased error correction problem via linear block codes. It is not a surprise that major contributions in the area of group testing have been given by coding and information theorists.
The scope of the thesis is to investigate the adoption of capacityapproaching codes based on sparse graphs (e.g., lowdensity paritycheck codes) to attack the group testing problem. The use of sparsegraph codes for this purpose has been already envisaged in [34]. In this work, we will address the design of adaptive/nonadaptive and quantitative/nonquantitative group testing techniques based on sparse graphs, under various detection algorithms (belief propagation, as well as combinatorial orthogonal matching pursuit).
[1] Mutesa, Leon, et al. "A strategy for finding people infected with SARSCoV2: optimizing pooled testing at low prevalence." arXiv preprint arXiv:2004.14934 (2020). [2] Narayanan, Krishna R., Anoosheh Heidarzadeh, and Ramanan Laxminarayan. "On Accelerated Testing for COVID19 Using Group Testing." arXiv preprint arXiv:2004.04785(2020). [3] K. Lee, R. Pedarsani and K. Ramchandran, "SAFFRON: A fast, efficient, and robust framework for group testing based on sparsegraph codes," 2016 IEEE International Symposium on Information Theory (ISIT), Barcelona, 2016  available at https://arxiv.org/abs/1508.04485 [4] Aldridge, Matthew, Oliver Johnson, and Jonathan Scarlett. "Group testing: an information theory perspective,: NOW Published, 2020  available at https://arxiv.org/pdf/1902.06002.pdf
Voraussetzungen
The student should have successfully passed the Channel Coding course and should exhibit a good understanding of probability theory. The Channel Codes for Iterative Decoding and Information Theory courses are plus.
Kontakt
mustafa.coskun@tum.de
Betreuer:
Forschungspraxis oder MSCE Forschungspraxis
[identification] Implementation of identification with algebraicgeometry (Goppa) codes
[identification] Implementation of identification with algebraicgeometry (Goppa) codes
Stichworte:
goppa algebraic geometry codes identification
Beschreibung
Identification is a communication scheme that allows rate doubly exponential in the blocklemght, with the tradeoff that identities cannot be decoded (as messages do) but can only be verified.
The double exponential growth presents various challenges in the finite regime: there are heavy computational costs introduced at the encoder and decoder and heavy tradeoffs between the error and the codes sizes.
The ultimate goal is to find a fast, reliable implementation while still achieving large code sizes.
Identification codes can be achieved by first removing the errors from the channel with regular transmission channel coding, and then sending a challenge though the corrected channel. For every identity i, The channenge is generated by picking a random input m and computing the corresponding output T_i(m) using a function T_i that depends on the identity. The challenge is then the pair m,T_i(m) and the receiver wanting to verify an identity j will verify whether j=i by testing the challenge. This is done by recomputing the output with T_j and verifying whether T_j(m)= T_i(m). The errors are reduced by ensuring that the various functions collide on a small fraction of the possible inputs.
It turns out that choosing good sets of funtions {T_i} is the same as choosing errorcorrection codes {c_i} with large distance, where now each codeword c_i defines a function by mapping positions m (sometimes called code locators) to symbols c_im of the codeword.
We can thus construct identification codes by choosing errorcorrection codes where we are only interested in the performance of the error correction encoders (we are not interested in the errorcorrection decoder or errorcorrection codes).
Your task will be implementing identification with Goppa codes, aiming at the fastest implementation, and testing their performance in comparison to other current implementations. The reference articles for this implementation are:
For reference, our previous work on identification based on ReedSolomon and ReedMuller code can be found at
The coding will be in Python/Sagemath.
The working language will be in English.
Environment: we collaborate with LTI. At LNT and LTI there is currently a lot of funding for research in identification. Therefore you will find a large group of people that might be available for discussion and collaboration.
Betreuer:
[identification] Implementation of identification with universal hash functions
[identification] Implementation of identification with universal hash functions
Stichworte:
universal hash identification
Beschreibung
Identification is a communication scheme that allows rate doubly exponential in the blocklemght, with the tradeoff that identities cannot be decoded (as messages do) but can only be verified.
The double exponential growth presents various challenges in the finite regime: there are heavy computational costs introduced at the encoder and decoder and heavy tradeoffs between the error and the codes sizes.
The ultimate goal is to find a fast, reliable implementation while still achieving large code sizes.
Identification codes can be achieved by first removing the errors from the channel with regular transmission channel coding, and then sending a challenge though the corrected channel. For every identity i, The channenge is generated by picking a random input m and computing the corresponding output T_i(m) using a function T_i that depends on the identity. The challenge is then the pair m,T_i(m) and the receiver wanting to verify an identity j will verify whether j=i by testing the challenge. This is done by recomputing the output with T_j and verifying whether T_j(m)= T_i(m). The errors are reduced by ensuring that the various functions collide on a small fraction of the possible inputs.
It turns out that choosing good sets of funtions {T_i} is the same as choosing errorcorrection codes {c_i} with large distance, where now each codeword c_i defines a function by mapping positions m (sometimes called code locators) to symbols c_im of the codeword.
We can thus construct identification codes by choosing errorcorrection codes where we are only interested in the performance of the error correction encoders (we are not interested in the errorcorrection decoder or errorcorrection codes).
Your task will be implementing the identification codes described in
aiming at the fastest implementation, and testing their performance in comparison to other current implementations.
For reference, our previous work on identification based on ReedSolomon and ReedMuller code can be found at
The coding will be in Python/Sagemath.
The working language will be in English.
Environment: we collaborate with LTI. At LNT and LTI there is currently a lot of funding for research in identification. Therefore you will find a large group of people that might be available for discussion and collaboration.
Betreuer:
[identification] Implementation of identification with Polar codes
[identification] Implementation of identification with Polar codes
Stichworte:
polar codes identification
Beschreibung
Identification is a communication scheme that allows rate doubly exponential in the blocklemght, with the tradeoff that identities cannot be decoded (as messages do) but can only be verified.
The double exponential growth presents various challenges in the finite regime: there are heavy computational costs introduced at the encoder and decoder and heavy tradeoffs between the error and the codes sizes.
The ultimate goal is to find a fast, reliable implementation while still achieving large code sizes.
Identification codes can be achieved by first removing the errors from the channel with regular transmission channel coding, and then sending a challenge though the corrected channel. For every identity i, The channenge is generated by picking a random input m and computing the corresponding output T_i(m) using a function T_i that depends on the identity. The challenge is then the pair m,T_i(m) and the receiver wanting to verify an identity j will verify whether j=i by testing the challenge. This is done by recomputing the output with T_j and verifying whether T_j(m)= T_i(m). The errors are reduced by ensuring that the various functions collide on a small fraction of the possible inputs.
It turns out that choosing good sets of funtions {T_i} is the same as choosing errorcorrection codes {c_i} with large distance, where now each codeword c_i defines a function by mapping positions m (sometimes called code locators) to symbols c_im of the codeword.
We can thus construct identification codes by choosing errorcorrection codes where we are only interested in the performance of the error correction encoders (we are not interested in the errorcorrection decoder or errorcorrection codes).
Your task will be implementing identification with polar codes, aiming at the fastest implementation, and testing their performance in comperison to other current implementations.
For reference, our previous work on identification based on ReedSolomon and ReedMuller code can be found at
The coding will be in Python/Sagemath.
The working language will be in English.
Environment: we collaborate with LTI. At LNT and LTI there is currently a lot of funding for research in identification. Therefore you will find a large group of people that might be available for discussion and collaboration.
Betreuer:
[identification] Simulation and performance improvement of identification codes
[identification] Simulation and performance improvement of identification codes
Beschreibung
Identification is a communication scheme that allows rate doubly exponential in the blocklemght, with the tradeoff that identities cannot be decoded (as messages do) but can only be verified.
The double exponential growth presents various challenges in the finite regime: there are heavy computational costs introduced at the encoder and decoder and heavy tradeoffs between the error and the codes sizes.
The ultimate goal is to find a fast, reliable implementation while still achieving large code sizes.
Identification codes can be achieved by first removing the errors from the channel with regular transmission channel coding, and then sending a challenge though the corrected channel. For every identity i, The channenge is generated by picking a random input m and computing the corresponding output T_i(m) using a function T_i that depends on the identity. The challenge is then the pair m,T_i(m) and the receiver wanting to verify an identity j will verify whether j=i by testing the challenge. This is done by recomputing the output with T_j and verifying whether T_j(m)= T_i(m). The errors are reduced by ensuring that the various functions collide on a small fraction of the possible inputs.
It turns out that choosing good sets of funtions {T_i} is the same as choosing errorcorrection codes {c_i} with large distance, where now each codeword c_i defines a function by mapping positions m (sometimes called code locators) to symbols c_im of the codeword.
We can thus construct identification codes by choosing errorcorrection codes where we are only interested in the performance of the error correction encoders (we are not interested in the errorcorrection decoder or errorcorrection codes).
Your task will be speeding up the current implementations based on ReedSolomon and ReedMuller codes:
The coding will be in Python/Sagemath.
This work can accomodate multiple students.
The working language will be in English.
Environment: we collaborate with LTI. At LNT and LTI there is currently a lot of funding for research in identification. Therefore you will find a large group of people that might be available for discussion and collaboration.
Voraussetzungen
Nachrichtentechnik 2
Betreuer:
[quantum] Realignment criterion and upper bounds in deviceindependent QKD
[quantum] Realignment criterion and upper bounds in deviceindependent QKD
Beschreibung
This paper uses the partial transpose as a tool to derive upper bounds on deviceindependent QKD
https://arxiv.org/abs/2005.13511
In this project the goal is to try to generalize the above to the other tools like the reallignment criterion:
https://arxiv.org/abs/quantph/0205017
https://arxiv.org/abs/0802.2019
Voraussetzungen
basics of quantum information/quantum formalism
Betreuer:
Decoding of product codes
BCJR Algorithm
Identification Codes via Prime Numbers
Identification Codes via Prime Numbers
Stichworte:
Identification via channels, Prime Number Encryption
Kurzbeschreibung:
An approach for construction of identification codes for noiseless channel by means of the prime number encryption would be studied.
Beschreibung
In original scheme of identificaion via channels (Ahlswede and Dueck, 1989), a nonconstructive method for coding for noiseless channel was studied. To address the explicit construction of identificaion codes, foremost Ahlswede and Verboven, 1991 provide a number theoretic approach based on the two successive prime number encryption. This method require the knowledge of first 2^n prime numbers for a blocklength of n codeword. In this research internship, this method along with related prime number encryption tools and theorems would be investigated. Further, the extension of this scheme to a general DMC will be analyzed.
Voraussetzungen
Interested student are encouraged to contact me and send me a CV as well as all the academic transcripts and relevant courses that they have attended.
As well familiarity with the Basics of following is required:
 information/identification theory
 channel coding
 prime number theorem (Chebyshev)
Betreuer:
On the Equivalence of Identification and Authentication
On the Equivalence of Identification and Authentication
Stichworte:
Identification via channel, identification codes, authentication, authentication codes
Kurzbeschreibung:
A Certain equivalence of identification and authentication would be shown.
Beschreibung
It would be shown that under suitable formulations (preserving all salient features) the two problem of Identification (Ahlswede and Dueck, 1989) and Authentication (Simmons, G. J. 1984) are in essence very close to each other. This equivalency was conjectured first by M. S. Pinsker. In this research internship the student is expected to address this conjecture. Both problems must be studied separately and then the similar essence of them should be drawn out. In particular the identification codes and authentication codes along with theire relation will be investigated.
Voraussetzungen
 Background in Information Theory and Channel Coding
 Familiarity with fundamentals of Identification Theory
References:
 Simmons, G. J. 1984, “Message authentication: a game on hypergraphs,” Congressus Numer. 45:161192.
 Simmons, G. J. 1982, “A game theory model of digital message authentication,” Congressus Numer., 34, 413424
 Simmons, G. J. 1985, “Authentication theory/coding theory,” in: Advances in Cryptology: Proceedings of CRYPTO 84, Lecture Notes in Computer Science, vol. 196, SpringerVerlag, Berlin, pp. 411432.
 E. Gilbert, F. J. MacWilliams and N.J. A. Sloane, 1974, “Codes which detect deception,” Bell System Tech. J., 53, 405424.
 R. Ahlswede and G. Dueck, “Identification via channels,” in IEEE Trans. on Inf. Theory, vol. 35, no. 1, pp. 1529, Jan. 1989, doi: 10.1109/18.42172.
 L. A. Bassalygo, M. V. Burnashev, “Authentication, Identification, and Pairwise Separated Measures”, Problems Inform. Transmission, 32:1 (1996), 33–39
Betreuer:
Analysis of CrissCross Deletion in Arrays
Analysis of CrissCross Deletion in Arrays
Beschreibung
yle="fontweight: normal;" lang="deDE" align="left">In this project we study two dimensional deletion/insertion problem introduced in https://arxiv.org/pdf/2004.14740.pdf. An array of n rows and n columns is transmitted through a specific deletion channel which for example occurs in DNA storage systems and racetrack memories. After transmission the receiver observes an array of dimension (n1)*(n1). The goal is to allow the receiver to know exactly which n*n array was transmitted by using errorcorrection techniques.
The goal of the project is to derive bounds on the deletion ball of any twodimensional array. A deletion ball of an array X is the set of unique arrays resulting from the deletion of any possible combination of a column and a row in X. Deriving such bounds is not trivial since it depends heavily on the structure of the array. Thus, it is important to investigate useful characteristics representing the structure of an array for this particular setting. Furthermore, having this bound will be helpful to characterize the optimal redundancy of a deletioncorrecting code for this setting.
Betreuer:
Investigation of polar and ReedMuller codes under inactivation decoding for distributed computing
Investigation of polar and ReedMuller codes under inactivation decoding for distributed computing
Beschreibung
Recently, channel codes are proposed to speed up computation in distributed systems by introducing redundant calculations to avoid the latency due to, e.g., straggling nodes (see, e.g., [1]). Since this problem can be casted as coding for erasure channels (where the erasure probability itself might be a random variable), there are works using inactivation decoding, an efficient way of implementing Gaussian elimination, for this problem [2]. In this internship, the task of the student is to understand the advantages of polar codes under successive cancellation (SC) decoding [3] and investigate polar codes and their variants, e.g., ReedMuller codes, under an inactivation decoder [4] to understand their performance compared to the existing works, e.g., [2].
[1] https://arxiv.org/pdf/1512.02673.pdf
[2] https://arxiv.org/pdf/1712.08230.pdf
[3] https://arxiv.org/pdf/1901.06811.pdf
[4] https://arxiv.org/abs/2004.05969
Betreuer:
Ingenieurpraxis
A Jupyter Notebook for Line Coding in Access Networks (LB)
A Jupyter Notebook for Line Coding in Access Networks (LB)
Beschreibung
For the access network case, the spectrum of the transmit signal has to be adapted to the channel properties. This can either be achieved by choosing suitable transmit pulse shapes or by encoding the (redundancy free) source symbols [1].
The students task is to implement a demonstration of two line coding schemes in Python [2] (Jupyter Notebook) and visualize the results. Additionally, the student also has to arrange code and surrounding text, such that the content becomes selfexplanatory.
[1] Skript "Physical Layer Methods“
[2] "Python in 30 minutes" (https://www.programiz.com/pythonprogramming/tutorial)
Voraussetzungen
Since the Jupyter Notebook is to be written in german language, the student should be able to write in german at least on a basic level.
While some basics in any programming language are beneficial, this is also a great opportunity for programming beginners, wishing to expand their programming skills.
This topic is only available for students of the "Lehramtsstudiengänge".
Betreuer:
A Jupyter Notebook for Equalization Methods (LB)
A Jupyter Notebook for Equalization Methods (LB)
Beschreibung
Depending on the channel properties, the receive signal in a communication system can be severely distorted, causing intersymbol interference. To mitigate these interferences, several approaches for equalization can be taken [1].
The students task is to implement a demonstration of several equalization schemes in Python [2] (Jupyter Notebook) and visualize the results. Additionally, the student also has to arrange code and surrounding text, such that the content becomes selfexplanatory.
[1] Skript "Physical Layer Methods“
[2] "Python in 30 minutes" (https://www.programiz.com/pythonprogramming/tutorial)
Voraussetzungen
Since the Jupyter Notebook is to be written in german language, the student should be able to write in german at least on a basic level.
While some basics in any programming language are beneficial, this is also a great opportunity for programming beginners, wishing to expand their programming skills.
This topic is only available for students of the "Lehramtsstudiengänge".
Betreuer:
Seminar Themen
Die drei Seminare "Seminar on Coding and Cryptography", "Seminar on Digital Communications" und "Seminar on Optical Communications" werden zusammen organisiert und abgehalten.
Mehr Informationen finden Sie unter Seminar Themen.