Radiative Neutralino Production in Low Energy Supersymmetric Models

We study the production of the lightest neutralinos in the radiative process $e^+e^- \to \tilde\chi^0_1 \tilde\chi^0_1\gamma$ in low energy supersymmetric models for the International Linear Collider energies. This includes the minimal supersymmetric standard model as well as its extension with an additional chiral Higgs singlet superfield, the nonminimal supersymmetric standard model. We compare and contrast the dependence of the signal cross section on the parameters of the neutralino sector of the minimal and nonminimal supersymmetric standard model. We also consider the background to this process coming from the Standard Model process $e^+e^- \to \nu \bar\nu \gamma$, as well as from the radiative production of the scalar partners of the neutrinos (sneutrinos) $e^+e^- \to \tilde\nu \tilde\nu^\ast \gamma$, which can be a background to the radiative neutralino production when the sneutrinos decay invisibly. In low energy supersymmetric models radiative production of the lightest neutralinos may be the only channel to study supersymmetric partners of the Standard Model particles at the first stage of a linear collider, since heavier neutralinos, charginos and sleptons may be too heavy to be pair-produced at a $e^+ e^-$ machine with \sqrt{s} =500\GeV.Comment: LaTeX, 21 pages, 19 figures, figures and text added, version to appear in Phys. Rev.

Instructions for Task 2A

Screenshot of what participants saw as instructions for Task 2

Discovering Likely Mappings between APIs using Text Mining

Abstract-Developers often release different versions of their applications to support various platform/programming-language application programming interfaces (APIs). To migrate an application written using one API (source) to another API (target), a developer must know how the methods in the source API map to the methods in the target API. Given a typical platform or language exposes a large number of API methods, manually writing API mappings is prohibitively resource-intensive and may be error prone. Recently, researchers proposed to automate the mapping process by mining API mappings from existing codebases. However, these approaches require as input a manually ported (or at least functionally similar) code across source and target APIs. To address the shortcoming, this paper proposes TMAP: Text Mining based approach to discover likely API mappings using the similarity in the textual description of the source and target API documents. To evaluate our approach, we used TMAP to discover API mappings for 15 classes across: 1) Java and C# API, and 2) Java ME and Android API. We compared the discovered mappings with state-of-the-art source code analysis based approaches: Rosetta and StaMiner. Our results indicate that TMAP on average found relevant mappings for 57% more methods compared to previous approaches. Furthermore, our results also indicate that TMAP on average found exact mappings for 6.5 more methods per class with a maximum of 21 additional exact mappings for a single class as compared to previous approaches

inferring method specifications from natural language api descriptions

Application Programming Interface (API) documents are a typical way of describing legal usage of reusable software libraries, thus facilitating software reuse. However, even with such documents, developers often overlook some documents and build software systems that are inconsistent with the legal usage of those libraries. Existing software verification tools require formal specifications (such as code contracts), and therefore cannot directly verify the legal usage described in natural language text in API documents against code using that library. However, in practice, most libraries do not come with formal specifications, thus hindering tool-based verification. To address this issue, we propose a novel approach to infer formal specifications from natural language text of API documents. Our evaluation results show that our approach achieves an average of 92% precision and 93% recall in identifying sentences that describe code contracts from more than 2500 sentences of API documents. Furthermore, our results show that our approach has an average 83% accuracy in inferring specifications from over 1600 sentences describing code contracts. © 2012 IEEE.IEEE Computer Society; ACM; University of Zurich (UZH), Department of Informatics; Technical Council on Software Engineering (TCSE); Special Interest Group on Software Engineering (SIGSOFT); SI-SEApplication Programming Interface (API) documents are a typical way of describing legal usage of reusable software libraries, thus facilitating software reuse. However, even with such documents, developers often overlook some documents and build software systems that are inconsistent with the legal usage of those libraries. Existing software verification tools require formal specifications (such as code contracts), and therefore cannot directly verify the legal usage described in natural language text in API documents against code using that library. However, in practice, most libraries do not come with formal specifications, thus hindering tool-based verification. To address this issue, we propose a novel approach to infer formal specifications from natural language text of API documents. Our evaluation results show that our approach achieves an average of 92% precision and 93% recall in identifying sentences that describe code contracts from more than 2500 sentences of API documents. Furthermore, our results show that our approach has an average 83% accuracy in inferring specifications from over 1600 sentences describing code contracts. © 2012 IEEE