- Författare

# Examensarbeten för masterexamen // Master Theses

## Länka till denna samling:

## Browse

### Browsar Examensarbeten för masterexamen // Master Theses efter Författare "Abel, Andreas"

Visar 1 - 13 av 13

###### Sökresultat per sida

###### Sortera efter

- PostA Formal Semantics for Javalette in the K framework(2022) Burak Bilge, Yalcinkaya; Chalmers tekniska högskola / Institutionen för data och informationsteknik; Abel, Andreas; Myreen, Magnus
Visa mer This thesis is about developing an executable formal semantics for Javalette in the K framework. Javalette is an imperative programming language. Its syntax is formally specified using BNF (Backus-Naur form) notation, but it does not have a formal semantics. The semantics of the language is informally documented in English. Javalette has several extensions that enrich the language’s syntax and semantics with new types, statements, and expressions. K is a toolset for programming language design and implementation. It provides a specification language for formally defining syntax and semantics. From these definitions, K automatically generates various tools such as parsers, interpreters, model checkers, and deductive verifiers. The purpose of this project is to develop a complete formal semantics for the Javalette language, design an architecture for extending the language modularly and implement language extensions, find and resolve undefined behaviors in the language, and use the formal semantics to develop an input fuzzer for testing Javalette programs and implementations.Visa mer - PostA Parametric Fitch-Style Modal Lambda Calculus(2023) Forsman, Axel; Chalmers tekniska högskola / Institutionen för data och informationsteknik; Chalmers University of Technology / Department of Computer Science and Engineering; Abel, Andreas; Valliappan, Nachiappan
Visa mer The necessity modality, denoted by , where the focus lies, has been applied to model staged computations, compartmental purity in functional languages, and more. So called Fitch-style modal deduction, where modalities are eliminated by opening a subproof, and introduced by shutting one, has been adapted for lambda calculi. Different modal logics may be encoded via different open and shut rules. Prior work [1] has given normalization proofs for four Fitch-style formulations of lambda calculi with different modalities, which required repeating the proofs for each individual calculus. A parametric Fitch-style modal lambda calculus generalizing the variants is presented, in order to avoid the repetition and ease further extensions.Visa mer - PostA Reflexive Graph Model of Sized Types(2020) Limperg, Jannis; Chalmers tekniska högskola / Institutionen för data och informationsteknik; Hughes, John; Abel, Andreas
Visa mer Sized types are a type-based termination checking mechanism for dependently typed languages. Compared to syntactic termination checkers, sized types make termination checking more modular and allow for an elegant treatment of coinductive and nested data types. This thesis investigates λST, a simply-typed lambda calculus with sized types similar to those of Agda. Its primary contribution is a relationally parametric denotational semantics for λST in the form of a reflexive graph model. In this model, sizes are irrelevant: they do not affect the result of any computations. The calculus and model are fully formalised in Agda (without sized types).Visa mer - PostA Syntax for Composable Data Types in Haskell, A User-friendly Syntax for Solving the Expression Problem(2023) Romeborn, Anna; Albers, Fredrik; Chalmers tekniska högskola / Institutionen för data och informationsteknik; Chalmers University of Technology / Department of Computer Science and Engineering; Abel, Andreas; Broberg, Niklas
Visa mer The expression problem is the problem of designing a programming language such that it has both extensible data types and extensible sets of functions over those data types. This means that it should be possible to add new functions, new variants to a data type, and function cases for these new variants, without modification or recompilation of existing code. There exist a number of different approaches to solving the expression problem, which have different qualities in expressiveness or simplicity. In this thesis, we have designed a syntax, with an accompanying transformation into compilable code, that acts as a solution to the expression problem in Haskell. By designing this syntax, we can make simplifications that would not be possible for solutions written directly in Haskell. In particular, we can, behind our syntax, abstract away some syntactic overhead that can be generated by the transformation. To demonstrate that our designed syntax is feasible and works as an extension to Haskell, we have implemented the transformation, which transforms code written using our syntax into code that uses the Haskell library compdata. That library is an existing solution to the expression problem, and is based on another solution:Data Types à la Carte. Both of these solutions share many similarities in semantics with our syntax. Similarly to compdata and Data Types à la Carte, data types in our syntax are composable; that is, variants of a data type are manually combined to form a type with a fixed set of possible variants. We introduce a new concept, called categories, with the purpose of grouping variants and compositions of data types and simplifying the syntax into one closer to that of regular data types. This means that compositions of variants can only be formed of variants belonging to the same category, as opposed to freely being able to combine any variants. Again, similar to compdata and Data Types à la Carte, functions over composable data types are extended automatically in our syntax. This means that a function can be used for a variant of the data type as long as the function has a case defined for the variant. Through the introduction of categories and the abstractions possible through the transformation, we are able to conclude that our syntax provides several improvements compared to existing solutions to the expression problem in Haskell.Visa mer - PostAn Agda Formalisation of Modalities and Erasure in a Dependently Typed Language(2021) Eriksson, Oskar; Chalmers tekniska högskola / Institutionen för data och informationsteknik; Jansson, Patrik; Abel, Andreas
Visa mer Modal types extend the expressivity of types by giving them different interpretations depending on the used modality. In this thesis, we develop a general modality structure in the setting of a dependently typed language, notably containing dependent products and sums as well as natural numbers, based on the work of Abel and Bernardy [1]. The modality structure is based on a semiring, the elements of which are used as annotations on terms and whose algebraic properties form the basis for the modal type system. In addition, we instantiate the general modality structure to a modality for erasure in which annotations are interpreted as either computationally relevant, indicating that the annotated term is used during evaluation, or computationally irrelevant, indicating that the marked term is not useful during evaluation. Based on this interpretation, we define an extraction function that translates terms to an untyped lambda calculus, removing terms that have been marked for erasure. Using a logical relation between terms of the two languages we then prove the extraction function to be sound with respect to the semantics of the languages in the special case of natural numbers.Visa mer - PostAn Agda scope checker implemented in Agda(2023) Gazzetta, Francesco; Chalmers tekniska högskola / Institutionen för data och informationsteknik; Chalmers University of Technology / Department of Computer Science and Engineering; Jansson, Patrik; Abel, Andreas
Visa mer Agda [1] is a Haskell-style, purely functional, dependently typed programming language and theorem prover. Scope checking is the process of analyzing the Abstract Syntax Tree (AST) of a program and resolving all references to symbols by connecting them to the corresponding declarations of said symbols. The Agda scope checker – as well as the rest of the compiler – is written in Haskell, and does not include any proof about the reachability of declarations. In this thesis, we present a scope checker for the Agda language, written in Agda itself, and prove the correctness of its name resolution algorithm with reference to the reachability properties of the Agda language. The result of this scope checking pass is a correct by construction AST that contains a proof that the syntax is well-scoped represented as paths from references of names (eg. x) to declarations (eg. x = ...).Visa mer - PostComparison of Machine Learning Approaches Applied to Predicting Football Players Performance(2020) Lindberg, Adrian; Söderberg, David; Chalmers tekniska högskola / Institutionen för data och informationsteknik; Abel, Andreas; Seger, Carl-Johan; Yu, Yinan
Visa mer This thesis investigates three machine learning approaches: Support Vector Machine (SVM), Multi-Layer Perceptron (MLP) and Long Short-Term Memory (LSTM) on predicting the performance of an upcoming match for a football player in the English Premier League. Each approach is applied to two problems: regression and classification. The last four seasons of English Premier League is collected and analyzed. Each approach and problem is tested several times with different hyperparameters in order to find the best performance. We evaluate on five game weeks by picking a lineup for each model that is then measured by its collective score. The results indicate that regression outperforms classification, with LSTM being the best performing model. The score ends up outperforming the average of all managers during the evaluated period in the online football game, Fantasy Premier League. The findings could be used to assist in providing insight from historical data that might be too complex to find for humans.Visa mer - PostDecision provenance in a real-time system with microservice architecture(2022) Willim, Daniel; Ljungdahl, Erik; Chalmers tekniska högskola / Institutionen för data och informationsteknik; Abel, Andreas; Russo, Alejandro
Visa mer This thesis investigates the feasibility of decision provenance, by implementing it in Carmenta TrafficWatch, a real-time system with a microservice architecture. We add provenance by creating a separate service that listens to the message-bus and stores all events and potential changes to those events. This provenance information can later be queried by other services. To have provenance of how events interact with each other, we also implement a system for event aggregation. Our findings indicate that adding provenance to real-time systems with microservice architecture will not impact the overall performance of the system significantly, and is a viable solution to add accountability and increase the understanding of complex systems.Visa mer - PostLayout Syntax Support in the BNF Converter(2023) Burreau, Beata; Chalmers tekniska högskola / Institutionen för data och informationsteknik; Chalmers University of Technology / Department of Computer Science and Engineering; Ranta, Aarne; Abel, Andreas
Visa mer Many programming languages, such as Haskell and Python, use layout as part of their syntax. We can expect future programming languages to also be layoutsensitive. Therefore, the toolchains for implementing programming languages must support layout-sensitive languages. This thesis presents a declarative approach to describing layout-sensitive languages and parsing programs written in them. We reserve the terminals newline, indent, and dedent for describing layout syntax in BNF grammar and provide an algorithm for representing the layout of a program with these terminals, before parsing it. By verbalising layout syntax this way, mainstream parser generators, and their parsing algorithms, can be used. This approach is successfully implemented in BNF Converter (BNFC), a tool that generates a compiler front-end from a context-free grammar in Labelled BNF (LBNF) form. With a special kind of LBNF rule, called pragma, it is possible to declare global layout syntax rules, such as the offside rule, which affects the insertion of layout terminals by the aforementioned algorithm. The reserved terminals and the pragmas can together describe popular layout syntax. Furthermore, both purely layout-sensitive languages and those mixing layoutsensitive and insensitive syntax are describable in LBNF.Visa mer - PostOn Definability and Normalization by Evaluation in the Logical Framework(2019) Ramcke, Frederik; Chalmers tekniska högskola / Institutionen för data och informationsteknik; Danielsson, Nils Anders; Abel, Andreas
Visa mer The question of definability asks to characterise what objects of the meta-theory are definable by a given calculus; for example, the untyped -calculus characterises exactly the Turing-computable functions. This thesis gives a characterisation of LF-definability—definability in a variant of the Edinburgh Logical Framework—in terms of a notion of Kripke predicates. The constructions in this thesis are heavily inspired by, and generalise, those by Jung and Tiuryn, who gave a definability result for the simply-typed -calculus in ‘A New Characterization of Lambda Definability’.Visa mer - PostPolynomial Functors in Agda: Theory and Practice(2023) Jörgensson, Marcus; Muricy Santos, André; Chalmers tekniska högskola / Institutionen för data och informationsteknik; Chalmers University of Technology / Department of Computer Science and Engineering; Abel, Andreas; Cherubini, Felix
Visa mer The category of polynomial functors - Poly - has been studied for over two decades and is well known for its relevance to computer science [1] and deep mathematical structure [2]. In recent years, new interpretations of Poly have been found in dynamical systems theory [3]. This thesis formalizes Poly in Cubical Agda and showcases its use in dynamical systems, contributing to the Poly code ecosystem. The first part, theory, formalizes the category Poly itself and many of its categorical constructs, including the initial and terminal objects, product, coproduct, equalizer, composition and parallel product. Then Chart is formalized, together with its own categorical constructs. Finally, Poly and Chart morphisms are combined via commuting squares. The second part, practice, builds upon the theory by using these categories to implement dynamical systems. It covers how morphisms in Poly represent dynamical systems, how polynomials act as interfaces, how systems are wired together, how behavior is installed into wiring diagrams, and how to run systems arriving at concrete programs. Many dynamical system examples are given, such as a Fibonacci sequence generator, the Lorenz system, the Hodkgin-Huxley model, and an Echo-State Network that learns the Lorenz dynamics. Commuting squares are used as a way of showing that one dynamical system can be made to simulate another.Visa mer - PostSecuring Electronic Exam Environments(2023) Cronqvist, Daniel; Kortesaari, Saga; Chalmers tekniska högskola / Institutionen för data och informationsteknik; Chalmers University of Technology / Department of Computer Science and Engineering; Abel, Andreas; Ahmadpanah, Mohammad M.
Visa mer Electronic exams have gained widespread popularity due to their convenience and advantages, particularly in courses involving writing or programming assessments. However, along with their benefits, electronic exams also pose the risk of facilitating cheating, especially when examinees are allowed to use their own devices. To ensure that in-hall bring-your-own-device (BYOD) electronic exams are as secure as their traditional paper-based counterparts, significant measures must be taken to secure the exam environment. This study focuses on two types of e-exam environments: software-based and OS-based. The thesis presents a comprehensive threat modeling process using the Quantitative Threat Modeling Method (QTMM) to identify various cheating-related threats. Based on these findings, the research proposes eight new design principles to guide developers in creating robust and secure e-exam environments as part of their design strategy. These principles are then evaluated through a case study conducted on a popular e-exam environment, Safe Exam Browser (SEB). The case study reveals several vulnerabilities and successful attacks, highlighting that six out of the eight proposed design principles were not adhered to. To address this problem, the thesis presents a novel design proposal for Safe Exam Browser that aligns with the suggested design principles. Implementation of this proposal would effectively address many of the preventable threats, including a significant design flaw. Lastly, the thesis explores how well both software-based and OS-based e-exam environments can mitigate threats by following these design principles. By emphasizing the importance of robust security measures in e-exam environments and providing practical recommendations, this research contributes to the ongoing efforts to enhance the integrity of electronic examinations.Visa mer - PostTowards Normalization by Evaluation for Erlang(2023) Agrell, Carl; Yang, Haohan; Chalmers tekniska högskola / Institutionen för data och informationsteknik; Chalmers University of Technology / Department of Computer Science and Engineering; Abel, Andreas; Valliappan, Nachiappan
Visa mer Normalization by Evaluation (NbE) is a technique to extract the normal form of a 𝜆-calculus term. Originally targeting pure 𝜆-calculus, the algorithm can be extended and adjusted to work on more practical call-by-value programming languages. We implement NbE for a fragment of Erlang, starting at the Moggi’s semantics framework of computational lambda calculus, and largely inspired by Filinski’s research. The result shows that our normalizer can be applied on programs with rich semantics, and can potentially be extended to perform partial evaluation.Visa mer