@article{29236,
  abstract     = {{The numerical solution of an ordinary differential equation can be interpreted as the exact solution of a nearby modified equation. Investigating the behaviour of numerical solutions by analysing the modified equation is known as backward error analysis. If the original and modified equation share structural properties, then the exact and approximate solution share geometric features such as the existence of conserved quantities. Conjugate symplectic methods preserve a modified symplectic form and a modified Hamiltonian when applied to a Hamiltonian system. We show how a blended version of variational and symplectic techniques can be used to compute modified symplectic and Hamiltonian structures. In contrast to other approaches, our backward error analysis method does not rely on an ansatz but computes the structures systematically, provided that a variational formulation of the method is known. The technique is illustrated on the example of symmetric linear multistep methods with matrix coefficients.}},
  author       = {{McLachlan, Robert and Offen, Christian}},
  journal      = {{Journal of Geometric Mechanics}},
  keywords     = {{variational integrators, backward error analysis, Euler--Lagrange equations, multistep methods, conjugate symplectic methods}},
  number       = {{1}},
  pages        = {{98--115}},
  publisher    = {{AIMS Press}},
  title        = {{{Backward error analysis for conjugate symplectic methods}}},
  doi          = {{10.3934/jgm.2023005}},
  volume       = {{15}},
  year         = {{2023}},
}

@article{47065,
  abstract     = {{The reform of the European academic landscape with the introduction of bachelor's and master's degree programs has brought about several profound changes for teaching and assessment in higher education. With regard to the examination system, the shift towards output-oriented teaching is still one of the most significant challenges. Assessments have to be integrated into the teaching and learning arrangements and consistently aligned towards the intended learning outcomes. In particular, assessments should provide valid evidence that learners have acquired competences that are relevant for a specific domain. However, it seems that this didactic goal has not yet been fully achieved in modeling education in computer science. The aim of this study is to investigate whether typical task material used in exercises and exams in modeling education at selected German universities covers relevant competences required for graphical modeling. For this purpose, typical tasks in the field of modeling are first identified by means of a content-analytical procedure. Subsequently, it is determined which competence facets relevant for graphical modeling are addressed by the task types. By contrasting a competence model for modeling with the competences addressed by the tasks, a gap was identified between the required competences and the task material analyzed. In particular, the gap analysis shows the neglect of transversal competence facets as well as those related to the analysis and evaluation of models. The result of this paper is a classification of task types for modeling education and a specification of the competence facets addressed by these tasks. Recommendations for developing and assessing student's competences comprehensively are given.}},
  author       = {{Soyka, Chantal and Ullrich, Meike and Striewe, Michael and Schaper, Niclas}},
  journal      = {{Enterprise Modelling and Information Systems Architectures}},
  keywords     = {{conceptual modeling, higher education, competence-oriented assessment, task analysis, graphical modeling}},
  title        = {{{Comparison of Required Competences and Task Material in Modeling Education}}},
  doi          = {{10.18417/EMISA.18.7}},
  volume       = {{18}},
  year         = {{2023}},
}

@article{47155,
  abstract     = {{»Über Geld spricht man nicht.« Diese Benimmregel erweist sich beim Blick in die Ver-
gangenheit als Illusion. Keineswegs war Geld grundsätzlich ein Tabuthema zwischen-
menschlicher Kommunikation. Ganz im Gegenteil: Mit dem Reden über Geld wird dieses
mit Bedeutung aufgeladen. Die Autor*innen dieses Themenheftes untersuch en Gelddis-
kurse und die Zuschreibungen von Bedeutung an Geld in der internationalen Geschichte.}},
  author       = {{Schönhärl, Korinna and Schotters, Frederike  and Thiemeyer, Guido}},
  journal      = {{Werkstatt Geschichte}},
  keywords     = {{Financial History, Discourse Analysis, History of Money}},
  title        = {{{Editorial}}},
  volume       = {{88}},
  year         = {{2023}},
}

@misc{47154,
  abstract     = {{»Über Geld spricht man nicht.« Diese Benimmregel erweist sich beim Blick in die Vergangenheit als Illusion. Keineswegs war Geld grundsätzlich ein Tabuthema zwischenmenschlicher Kommunikation. Ganz im Gegenteil: Mit dem Reden über Geld wird dieses mit Bedeutung aufgeladen. Die Autor*innen dieses Themenheftes untersuchen Gelddiskurse und die Zuschreibungen von Bedeutung an Geld in der internationalen Geschichte.}},
  booktitle    = {{Werkstatt Geschichte}},
  editor       = {{Schönhärl, Korinna and Schotters, Frederike and Thiemeyer, Guido}},
  keywords     = {{Financial History, Discourse Analysis, History of Money}},
  title        = {{{Reden über Geld}}},
  volume       = {{88}},
  year         = {{2023}},
}

@inproceedings{44146,
  abstract     = {{Many Android applications collect data from users. When they do, they must
protect this collected data according to the current legal frameworks. Such
data protection has become even more important since the European Union rolled
out the General Data Protection Regulation (GDPR). App developers have limited
tool support to reason about data protection throughout their app development
process. Although many Android applications state a privacy policy, privacy
policy compliance checks are currently manual, expensive, and prone to error.
One of the major challenges in privacy audits is the significant gap between
legal privacy statements (in English text) and technical measures that Android
apps use to protect their user's privacy. In this thesis, we will explore to
what extent we can use static analysis to answer important questions regarding
data protection. Our main goal is to design a tool based approach that aids app
developers and auditors in ensuring data protection in Android applications,
based on automated static program analysis.}},
  author       = {{Khedkar, Mugdha}},
  booktitle    = {{2023 IEEE/ACM 45th International Conference on Software Engineering: Companion Proceedings (ICSE-Companion), Melbourne, Australia, 2023, pp. 197-199}},
  keywords     = {{static analysis, data protection and privacy, GDPR compliance}},
  title        = {{{Static Analysis for Android GDPR Compliance Assurance}}},
  doi          = {{10.1109/ICSE-Companion58688.2023.00054}},
  year         = {{2023}},
}

@inproceedings{44326,
  abstract     = {{Low-quality models that miss relevant dynamics lead to major challenges in modelbased
state estimation. We address this issue by simultaneously estimating the system’s states
and its model inaccuracies by a square root unscented Kalman filter (SRUKF). Concretely,
we augment the state with the parameter vector of a linear combination containing suitable
functions that approximate the lacking dynamics. Presuming that only a few dynamical terms
are relevant, the parameter vector is claimed to be sparse. In Bayesian setting, properties like
sparsity are expressed by a prior distribution. One common choice for sparsity is a Laplace
distribution. However, due to disadvantages of a Laplacian prior in regards to the SRUKF,
the regularized horseshoe distribution, a Gaussian that approximately features sparsity, is
applied instead. Results exhibit small estimation errors with model improvements detected by
an automated model reduction technique.}},
  author       = {{Götte, Ricarda-Samantha and Timmermann, Julia}},
  booktitle    = {{IFAC-PapersOnLine}},
  keywords     = {{joint estimation, unscented Kalman filter, sparsity, Laplacian prior, regularized horseshoe, principal component analysis}},
  location     = {{Yokohama, Japan}},
  number       = {{2}},
  pages        = {{869--874}},
  title        = {{{Approximating a Laplacian Prior for Joint State and Model Estimation within an UKF}}},
  volume       = {{56}},
  year         = {{2023}},
}

@inproceedings{36522,
  abstract     = {{Jupyter notebooks enable developers to interleave code snippets with rich-text and in-line visualizations. Data scientists use Jupyter notebook as the de-facto standard for creating and sharing machine-learning based solutions, primarily written in Python. Recent studies have demonstrated, however, that a large portion of Jupyter notebooks available on public platforms are undocumented and lacks a narrative structure. This reduces the readability of these notebooks. To address this shortcoming, this paper presents HeaderGen, a novel tool-based approach that automatically annotates code cells with categorical markdown headers based on a taxonomy of machine-learning operations, and classifies and displays function calls according to this taxonomy. For this functionality to be realized, HeaderGen enhances an existing call graph analysis in PyCG. To improve precision, HeaderGen extends PyCG's analysis with support for handling external library code and flow-sensitivity. The former is realized by facilitating the resolution of function return-types. Furthermore, HeaderGen uses type information to perform pattern matching on code syntax to annotate code cells.
The evaluation on 15 real-world Jupyter notebooks from Kaggle shows that HeaderGen's underlying call graph analysis yields high accuracy (96.4% precision and 95.9% recall). This is because HeaderGen can resolve return-types of external libraries where existing type inference tools such as pytype (by Google), pyright (by Microsoft), and Jedi fall short. The header generation has a precision of 82.2% and a recall rate of 96.8% with regard to headers created manually by experts. In a user study, HeaderGen helps participants finish comprehension and navigation tasks faster. All participants clearly perceive HeaderGen as useful to their task.}},
  author       = {{Shivarpatna Venkatesh, Ashwin Prasad and Wang, Jiawei and Li, Li and Bodden, Eric}},
  keywords     = {{static analysis, python, code comprehension, annotation, literate programming, jupyter notebook}},
  publisher    = {{IEEE SANER 2023 (International Conference on Software Analysis, Evolution and Reengineering)}},
  title        = {{{Enhancing Comprehension and Navigation in Jupyter Notebooks with Static Analysis}}},
  doi          = {{10.48550/ARXIV.2301.04419}},
  year         = {{2023}},
}

@article{46100,
  author       = {{Hinrichs, Benjamin and Janssen, Daan W. and Ziebell, Jobst}},
  issn         = {{0022-247X}},
  journal      = {{Journal of Mathematical Analysis and Applications}},
  keywords     = {{Applied Mathematics, Analysis}},
  number       = {{1}},
  publisher    = {{Elsevier BV}},
  title        = {{{Super-Gaussian decay of exponentials: A sufficient condition}}},
  doi          = {{10.1016/j.jmaa.2023.127558}},
  volume       = {{528}},
  year         = {{2023}},
}

@inproceedings{60304,
  abstract     = {{The focus towards multi-material and lightweight assemblies, driven by legal requirements on reducing emissions and energy consumptions, reveals important drawbacks and disadvantages of established joining processes, such as welding. In this context, mechanical joining technologies, such as clinching, are becoming more and more relevant especially in the automotive industry. However, the availability of only few standards and almost none systematic design methods causes a still very time- and cost-intensive assembly development process considering mainly expert knowledge and a considerable amount of experimental studies. Motivated by this, the presented work introduces a novel approach for the methodical design and dimensioning of mechanically clinched assemblies. Therefore, the utilization of regression models, such as machine learning algorithms, combined with manufacturing knowledge ensures a reliable estimation of individual clinched joint characteristics. In addition, the implementation of an engineering workbench enables the following data-driven and knowledge-based generation of high-quality initial assembly designs already in early product development phases. In a subsequent analysis and adjustment, these designs are being improved while guaranteeing joining safety and loading conformity. The presented results indicate that the methodological approach can pave the way to a more systematic design process of mechanical joining assemblies, which can significantly shorten the required number of iteration loops and therefore the product development time.}},
  author       = {{Zirngibl, Christoph and Martin, Sven and Steinfelder, Christian and Schleich, Benjamin and Tröster, Thomas and Brosius, Alexander and Wartzack, Sandro}},
  booktitle    = {{Materials Research Proceedings}},
  issn         = {{2474-395X}},
  keywords     = {{Joining, Structural Analysis, Machine Learning}},
  location     = {{Erlangen-Nürnberg}},
  publisher    = {{Materials Research Forum LLC}},
  title        = {{{Methodical approach for the design and dimensioning of mechanical clinched assemblies}}},
  doi          = {{10.21741/9781644902417-23}},
  volume       = {{25}},
  year         = {{2023}},
}

@misc{32409,
  abstract     = {{Context: Cryptographic APIs are often misused in real-world applications. Therefore, many cryptographic API misuse detection tools have been introduced. However, there exists no established reference benchmark for a fair and comprehensive comparison and evaluation of these tools. While there are benchmarks, they often only address a subset of the domain or were only used to evaluate a subset of existing misuse detection tools. Objective: To fairly compare cryptographic API misuse detection tools and to drive future development in this domain, we will devise such a benchmark. Openness and transparency in the generation process are key factors to fairly generate and establish the needed benchmark. Method: We propose an approach where we derive the benchmark generation methodology from the literature which consists of general best practices in benchmarking and domain-specific benchmark generation. A part of this methodology is transparency and openness of the generation process, which is achieved by pre-registering this work. Based on our methodology we design CamBench, a fair "Cryptographic API Misuse Detection Tool Benchmark Suite". We will implement the first version of CamBench limiting the domain to Java, the JCA, and static analyses. Finally, we will use CamBench to compare current misuse detection tools and compare CamBench to related benchmarks of its domain.}},
  author       = {{Schlichtig, Michael and Wickert, Anna-Katharina and Krüger, Stefan and Bodden, Eric and Mezini, Mira}},
  keywords     = {{cryptography, benchmark, API misuse, static analysis}},
  title        = {{{CamBench -- Cryptographic API Misuse Detection Tool Benchmark Suite}}},
  doi          = {{10.48550/ARXIV.2204.06447}},
  year         = {{2022}},
}

@inproceedings{32410,
  abstract     = {{Static analysis tools support developers in detecting potential coding issues, such as bugs or vulnerabilities. Research on static analysis emphasizes its technical challenges but also mentions severe usability shortcomings. These shortcomings hinder the adoption of static analysis tools, and in some cases, user dissatisfaction even leads to tool abandonment.
To comprehensively assess the current state of the art, this paper presents the first systematic usability evaluation in a wide range of static analysis tools. We derived a set of 36 relevant criteria from the scientific literature and gathered a collection of 46 static analysis tools complying with our inclusion and exclusion criteria - a representative set of mainly non-proprietary tools. Then, we evaluated how well these tools fulfill the aforementioned criteria.
The evaluation shows that more than half of the considered tools offer poor warning messages, while about three-quarters of the tools provide hardly any fix support. Furthermore, the integration of user knowledge is strongly neglected, which could be used for improved handling of false positives and tuning the results for the corresponding developer. Finally, issues regarding workflow integration and specialized user interfaces are proved further.
These findings should prove useful in guiding and focusing further research and development in the area of user experience for static code analyses.}},
  author       = {{Nachtigall, Marcus and Schlichtig, Michael and Bodden, Eric}},
  booktitle    = {{Proceedings of the 31st ACM SIGSOFT International Symposium on Software Testing and Analysis}},
  isbn         = {{9781450393799}},
  keywords     = {{Automated static analysis, Software usability}},
  pages        = {{532 -- 543}},
  publisher    = {{ACM}},
  title        = {{{A Large-Scale Study of Usability Criteria Addressed by Static Analysis Tools}}},
  doi          = {{10.1145/3533767}},
  year         = {{2022}},
}

@inproceedings{31133,
  abstract     = {{Application Programming Interfaces (APIs) are the primary mechanism that developers use to obtain access to third-party algorithms and services. Unfortunately, APIs can be misused, which can have catastrophic consequences, especially if the APIs provide security-critical functionalities like cryptography. Understanding what API misuses are, and for what reasons they are caused, is important to prevent them, e.g., with API misuse detectors. However, definitions and nominations for API misuses and related terms in literature vary and are diverse. This paper addresses the problem of scattered knowledge and definitions of API misuses by presenting a systematic literature review on the subject and introducing FUM, a novel Framework for API Usage constraint and Misuse classification. The literature review revealed that API misuses are violations of API usage constraints. To capture this, we provide unified definitions and use them to derive FUM. To assess the extent to which FUM aids in determining and guiding the improvement of an API misuses detectors' capabilities, we performed a case study on CogniCrypt, a state-of-the-art misuse detector for cryptographic APIs. The study showed that FUM can be used to properly assess CogniCrypt's capabilities, identify weaknesses and assist in deriving mitigations and improvements. And it appears that also more generally FUM can aid the development and improvement of misuse detection tools.}},
  author       = {{Schlichtig, Michael and Sassalla, Steffen and Narasimhan, Krishna and Bodden, Eric}},
  booktitle    = {{2022 IEEE International Conference on Software Analysis, Evolution and Reengineering (SANER)}},
  keywords     = {{API misuses, API usage constraints, classification framework, API misuse detection, static analysis}},
  pages        = {{673 -- 684}},
  title        = {{{FUM - A Framework for API Usage constraint and Misuse Classification}}},
  doi          = {{https://doi.org/10.1109/SANER53432.2022.00085}},
  year         = {{2022}},
}

@inproceedings{31054,
  abstract     = {{This paper aims at discussing past limitations set in sentiment analysis research regarding explicit and implicit mentions of opinions. Previous studies have regularly neglected this question in favor of methodical research on standard-datasets. Furthermore, they were limited to linguistically less-diverse domains, such as commercial product reviews. We face this issue by annotating a German-language physician review dataset that contains numerous implicit, long, and complex statements that indicate aspect ratings, such as the physician’s friendliness. We discuss the nature of implicit statements and present various samples to illustrate the challenge described.}},
  author       = {{Kersting, Joschka and Bäumer, Frederik Simon}},
  booktitle    = {{Proceedings of the Fourteenth International Conference on Pervasive Patterns and Applications (PATTERNS 2022): Special Track AI-DRSWA: Maturing Artificial Intelligence - Data Science for Real-World Applications}},
  editor       = {{Kersting, Joschka}},
  keywords     = {{Sentiment analysis, Natural language processing, Aspect phrase extraction}},
  location     = {{Barcelona, Spain}},
  pages        = {{5--9}},
  publisher    = {{IARIA}},
  title        = {{{Implicit Statements in Healthcare Reviews: A Challenge for Sentiment Analysis}}},
  year         = {{2022}},
}

@article{32865,
  abstract     = {{For the first time, poly(N-isopropylacrylamide) (PNIPAAm) star polymers with a β-cyclodextrin core are characterized in detail by size-exclusion chromatography (SEC) with triple detection to experimentally verify the number of arms. A combination of a refractive index detector, multi-angle laser light scattering detector, and an online-viscosimeter was used for branching analysis. At first, the SEC system was calibrated and the detector setup was validated using linear polystyrene reference polymers. The applicability of the established triple detection SEC for branching analysis was shown by the analysis of two commercially available polystyrene star polymers. Due to the high molar masses of the star polymers, both the contraction ratio g and g′ could be determined independently, thus allowing the calculation of the viscosity shielding ratio ε. Finally, the branching analysis of the PNIPAAm star polymers could experimentally confirm the assumed arm number of up to 21 arms. Moreover, an increasingly compact molecular structure and the influence of the arm number on the viscosity shielding ratio could be shown.}},
  author       = {{Herberg, Artjom and Kuckling, Dirk}},
  issn         = {{1023-666X}},
  journal      = {{International Journal of Polymer Analysis and Characterization}},
  keywords     = {{Size-exclusion chromatography, triple detection, branching analysis, star polymers, poly(N-isopropylacrylamide), β-cyclodextrin}},
  pages        = {{1--19}},
  publisher    = {{Informa UK Limited}},
  title        = {{{Branching analysis of β-cyclodextrin-based poly(<i>N</i>-isopropylacrylamide) star polymers using triple detection SEC}}},
  doi          = {{10.1080/1023666x.2022.2110133}},
  year         = {{2022}},
}

@article{48878,
  abstract     = {{Due to the rise of continuous data-generating applications, analyzing data streams has gained increasing attention over the past decades. A core research area in stream data is stream classification, which categorizes or detects data points within an evolving stream of observations. Areas of stream classification are diverse\textemdash ranging, e.g., from monitoring sensor data to analyzing a wide range of (social) media applications. Research in stream classification is related to developing methods that adapt to the changing and potentially volatile data stream. It focuses on individual aspects of the stream classification pipeline, e.g., designing suitable algorithm architectures, an efficient train and test procedure, or detecting so-called concept drifts. As a result of the many different research questions and strands, the field is challenging to grasp, especially for beginners. This survey explores, summarizes, and categorizes work within the domain of stream classification and identifies core research threads over the past few years. It is structured based on the stream classification process to facilitate coordination within this complex topic, including common application scenarios and benchmarking data sets. Thus, both newcomers to the field and experts who want to widen their scope can gain (additional) insight into this research area and find starting points and pointers to more in-depth literature on specific issues and research directions in the field.}},
  author       = {{Clever, Lena and Pohl, Janina Susanne and Bossek, Jakob and Kerschke, Pascal and Trautmann, Heike}},
  issn         = {{2076-3417}},
  journal      = {{Applied Sciences}},
  keywords     = {{big data, data mining, data stream analysis, machine learning, stream classification, supervised learning}},
  number       = {{18}},
  pages        = {{9094}},
  publisher    = {{{Multidisciplinary Digital Publishing Institute}}},
  title        = {{{Process-Oriented Stream Classification Pipeline: A Literature Review}}},
  doi          = {{10.3390/app12189094}},
  volume       = {{12}},
  year         = {{2022}},
}

@article{45956,
  abstract     = {{<jats:title>Abstract</jats:title>
               <jats:p>The full Maxwell equations in the unbounded three-dimensional space coupled to the Landau–Lifshitz–Gilbert equation serve as a well-tested model for ferromagnetic materials.
We propose a weak formulation of the coupled system based on the boundary integral formulation of the exterior Maxwell equations.
We show existence and partial uniqueness of a weak solution and propose a new numerical algorithm based on finite elements and boundary elements as spatial discretization with backward Euler and convolution quadrature for the time domain.
This is the first numerical algorithm which is able to deal with the coupled system of Landau–Lifshitz–Gilbert equation and full Maxwell’s equations without any simplifications like quasi-static approximations (e.g. eddy current model) and without restrictions on the shape of the domain (e.g. convexity).
We show well-posedness and convergence of the numerical algorithm under minimal assumptions on the regularity of the solution.
This is particularly important as there are few regularity results available and one generally expects the solution to be non-smooth.
Numerical experiments illustrate and expand on the theoretical results.</jats:p>}},
  author       = {{Bohn, Jan and Feischl, Michael and Kovács, Balázs}},
  issn         = {{1609-4840}},
  journal      = {{Computational Methods in Applied Mathematics}},
  keywords     = {{Applied Mathematics, Computational Mathematics, Numerical Analysis}},
  number       = {{1}},
  pages        = {{19--48}},
  publisher    = {{Walter de Gruyter GmbH}},
  title        = {{{FEM-BEM Coupling for the Maxwell–Landau–Lifshitz–Gilbert Equations via Convolution Quadrature: Weak Form and Numerical Approximation}}},
  doi          = {{10.1515/cmam-2022-0145}},
  volume       = {{23}},
  year         = {{2022}},
}

@article{53323,
  abstract     = {{<jats:title>Abstract</jats:title><jats:p>In a ball <jats:inline-formula><jats:alternatives><jats:tex-math>$$\Omega =B_R(0)\subset \mathbb {R}^n$$</jats:tex-math><mml:math xmlns:mml="http://www.w3.org/1998/Math/MathML">
                <mml:mrow>
                  <mml:mi>Ω</mml:mi>
                  <mml:mo>=</mml:mo>
                  <mml:msub>
                    <mml:mi>B</mml:mi>
                    <mml:mi>R</mml:mi>
                  </mml:msub>
                  <mml:mrow>
                    <mml:mo>(</mml:mo>
                    <mml:mn>0</mml:mn>
                    <mml:mo>)</mml:mo>
                  </mml:mrow>
                  <mml:mo>⊂</mml:mo>
                  <mml:msup>
                    <mml:mrow>
                      <mml:mi>R</mml:mi>
                    </mml:mrow>
                    <mml:mi>n</mml:mi>
                  </mml:msup>
                </mml:mrow>
              </mml:math></jats:alternatives></jats:inline-formula>, <jats:inline-formula><jats:alternatives><jats:tex-math>$$n\ge 2$$</jats:tex-math><mml:math xmlns:mml="http://www.w3.org/1998/Math/MathML">
                <mml:mrow>
                  <mml:mi>n</mml:mi>
                  <mml:mo>≥</mml:mo>
                  <mml:mn>2</mml:mn>
                </mml:mrow>
              </mml:math></jats:alternatives></jats:inline-formula>, the chemotaxis system <jats:disp-formula><jats:alternatives><jats:tex-math>$$\begin{aligned} \left\{ \begin{array}{l}u_t = \nabla \cdot \big ( D(u) \nabla u \big ) - \nabla \cdot \big ( uS(u)\nabla v\big ), \\ 0 = \Delta v - \mu + u, \qquad \mu =\frac{1}{|\Omega |} \int _\Omega u, \end{array} \right. \qquad \qquad (\star ) \end{aligned}$$</jats:tex-math><mml:math xmlns:mml="http://www.w3.org/1998/Math/MathML">
                <mml:mrow>
                  <mml:mtable>
                    <mml:mtr>
                      <mml:mtd>
                        <mml:mrow>
                          <mml:mfenced>
                            <mml:mrow>
                              <mml:mtable>
                                <mml:mtr>
                                  <mml:mtd>
                                    <mml:mrow>
                                      <mml:msub>
                                        <mml:mi>u</mml:mi>
                                        <mml:mi>t</mml:mi>
                                      </mml:msub>
                                      <mml:mo>=</mml:mo>
                                      <mml:mi>∇</mml:mi>
                                      <mml:mo>·</mml:mo>
                                      <mml:mrow>
                                        <mml:mo>(</mml:mo>
                                      </mml:mrow>
                                      <mml:mi>D</mml:mi>
                                      <mml:mrow>
                                        <mml:mo>(</mml:mo>
                                        <mml:mi>u</mml:mi>
                                        <mml:mo>)</mml:mo>
                                      </mml:mrow>
                                      <mml:mi>∇</mml:mi>
                                      <mml:mi>u</mml:mi>
                                      <mml:mrow>
                                        <mml:mo>)</mml:mo>
                                      </mml:mrow>
                                      <mml:mo>-</mml:mo>
                                      <mml:mi>∇</mml:mi>
                                      <mml:mo>·</mml:mo>
                                      <mml:mrow>
                                        <mml:mo>(</mml:mo>
                                      </mml:mrow>
                                      <mml:mi>u</mml:mi>
                                      <mml:mi>S</mml:mi>
                                      <mml:mrow>
                                        <mml:mo>(</mml:mo>
                                        <mml:mi>u</mml:mi>
                                        <mml:mo>)</mml:mo>
                                      </mml:mrow>
                                      <mml:mi>∇</mml:mi>
                                      <mml:mi>v</mml:mi>
                                      <mml:mrow>
                                        <mml:mo>)</mml:mo>
                                      </mml:mrow>
                                      <mml:mo>,</mml:mo>
                                    </mml:mrow>
                                  </mml:mtd>
                                </mml:mtr>
                                <mml:mtr>
                                  <mml:mtd>
                                    <mml:mrow>
                                      <mml:mrow />
                                      <mml:mn>0</mml:mn>
                                      <mml:mo>=</mml:mo>
                                      <mml:mi>Δ</mml:mi>
                                      <mml:mi>v</mml:mi>
                                      <mml:mo>-</mml:mo>
                                      <mml:mi>μ</mml:mi>
                                      <mml:mo>+</mml:mo>
                                      <mml:mi>u</mml:mi>
                                      <mml:mo>,</mml:mo>
                                      <mml:mspace />
                                      <mml:mi>μ</mml:mi>
                                      <mml:mo>=</mml:mo>
                                      <mml:mfrac>
                                        <mml:mn>1</mml:mn>
                                        <mml:mrow>
                                          <mml:mo>|</mml:mo>
                                          <mml:mi>Ω</mml:mi>
                                          <mml:mo>|</mml:mo>
                                        </mml:mrow>
                                      </mml:mfrac>
                                      <mml:msub>
                                        <mml:mo>∫</mml:mo>
                                        <mml:mi>Ω</mml:mi>
                                      </mml:msub>
                                      <mml:mi>u</mml:mi>
                                      <mml:mo>,</mml:mo>
                                    </mml:mrow>
                                  </mml:mtd>
                                </mml:mtr>
                              </mml:mtable>
                            </mml:mrow>
                          </mml:mfenced>
                          <mml:mspace />
                          <mml:mspace />
                          <mml:mrow>
                            <mml:mo>(</mml:mo>
                            <mml:mo>⋆</mml:mo>
                            <mml:mo>)</mml:mo>
                          </mml:mrow>
                        </mml:mrow>
                      </mml:mtd>
                    </mml:mtr>
                  </mml:mtable>
                </mml:mrow>
              </mml:math></jats:alternatives></jats:disp-formula>is considered under no-flux boundary conditions, with a focus on nonlinearities <jats:inline-formula><jats:alternatives><jats:tex-math>$$S\in C^2([0,\infty ))$$</jats:tex-math><mml:math xmlns:mml="http://www.w3.org/1998/Math/MathML">
                <mml:mrow>
                  <mml:mi>S</mml:mi>
                  <mml:mo>∈</mml:mo>
                  <mml:msup>
                    <mml:mi>C</mml:mi>
                    <mml:mn>2</mml:mn>
                  </mml:msup>
                  <mml:mrow>
                    <mml:mo>(</mml:mo>
                    <mml:mrow>
                      <mml:mo>[</mml:mo>
                      <mml:mn>0</mml:mn>
                      <mml:mo>,</mml:mo>
                      <mml:mi>∞</mml:mi>
                      <mml:mo>)</mml:mo>
                    </mml:mrow>
                    <mml:mo>)</mml:mo>
                  </mml:mrow>
                </mml:mrow>
              </mml:math></jats:alternatives></jats:inline-formula> which exhibit super-algebraically fast decay in the sense that with some <jats:inline-formula><jats:alternatives><jats:tex-math>$$K_S&gt;0, \beta \in [0,1)$$</jats:tex-math><mml:math xmlns:mml="http://www.w3.org/1998/Math/MathML">
                <mml:mrow>
                  <mml:msub>
                    <mml:mi>K</mml:mi>
                    <mml:mi>S</mml:mi>
                  </mml:msub>
                  <mml:mo>&gt;</mml:mo>
                  <mml:mn>0</mml:mn>
                  <mml:mo>,</mml:mo>
                  <mml:mi>β</mml:mi>
                  <mml:mo>∈</mml:mo>
                  <mml:mrow>
                    <mml:mo>[</mml:mo>
                    <mml:mn>0</mml:mn>
                    <mml:mo>,</mml:mo>
                    <mml:mn>1</mml:mn>
                    <mml:mo>)</mml:mo>
                  </mml:mrow>
                </mml:mrow>
              </mml:math></jats:alternatives></jats:inline-formula> and <jats:inline-formula><jats:alternatives><jats:tex-math>$$\xi _0&gt;0$$</jats:tex-math><mml:math xmlns:mml="http://www.w3.org/1998/Math/MathML">
                <mml:mrow>
                  <mml:msub>
                    <mml:mi>ξ</mml:mi>
                    <mml:mn>0</mml:mn>
                  </mml:msub>
                  <mml:mo>&gt;</mml:mo>
                  <mml:mn>0</mml:mn>
                </mml:mrow>
              </mml:math></jats:alternatives></jats:inline-formula>, <jats:disp-formula><jats:alternatives><jats:tex-math>$$\begin{aligned} S(\xi )&gt;0 \quad \text{ and } \quad S'(\xi ) \le -K_S\xi ^{-\beta } S(\xi ) \qquad \text{ for } \text{ all } \xi \ge \xi _0. \end{aligned}$$</jats:tex-math><mml:math xmlns:mml="http://www.w3.org/1998/Math/MathML">
                <mml:mrow>
                  <mml:mtable>
                    <mml:mtr>
                      <mml:mtd>
                        <mml:mrow>
                          <mml:mi>S</mml:mi>
                          <mml:mrow>
                            <mml:mo>(</mml:mo>
                            <mml:mi>ξ</mml:mi>
                            <mml:mo>)</mml:mo>
                          </mml:mrow>
                          <mml:mo>&gt;</mml:mo>
                          <mml:mn>0</mml:mn>
                          <mml:mspace />
                          <mml:mspace />
                          <mml:mtext>and</mml:mtext>
                          <mml:mspace />
                          <mml:mspace />
                          <mml:msup>
                            <mml:mi>S</mml:mi>
                            <mml:mo>′</mml:mo>
                          </mml:msup>
                          <mml:mrow>
                            <mml:mo>(</mml:mo>
                            <mml:mi>ξ</mml:mi>
                            <mml:mo>)</mml:mo>
                          </mml:mrow>
                          <mml:mo>≤</mml:mo>
                          <mml:mo>-</mml:mo>
                          <mml:msub>
                            <mml:mi>K</mml:mi>
                            <mml:mi>S</mml:mi>
                          </mml:msub>
                          <mml:msup>
                            <mml:mi>ξ</mml:mi>
                            <mml:mrow>
                              <mml:mo>-</mml:mo>
                              <mml:mi>β</mml:mi>
                            </mml:mrow>
                          </mml:msup>
                          <mml:mi>S</mml:mi>
                          <mml:mrow>
                            <mml:mo>(</mml:mo>
                            <mml:mi>ξ</mml:mi>
                            <mml:mo>)</mml:mo>
                          </mml:mrow>
                          <mml:mspace />
                          <mml:mspace />
                          <mml:mtext>for</mml:mtext>
                          <mml:mspace />
                          <mml:mspace />
                          <mml:mtext>all</mml:mtext>
                          <mml:mspace />
                          <mml:mi>ξ</mml:mi>
                          <mml:mo>≥</mml:mo>
                          <mml:msub>
                            <mml:mi>ξ</mml:mi>
                            <mml:mn>0</mml:mn>
                          </mml:msub>
                          <mml:mo>.</mml:mo>
                        </mml:mrow>
                      </mml:mtd>
                    </mml:mtr>
                  </mml:mtable>
                </mml:mrow>
              </mml:math></jats:alternatives></jats:disp-formula>It is, inter alia, shown that if furthermore <jats:inline-formula><jats:alternatives><jats:tex-math>$$D\in C^2((0,\infty ))$$</jats:tex-math><mml:math xmlns:mml="http://www.w3.org/1998/Math/MathML">
                <mml:mrow>
                  <mml:mi>D</mml:mi>
                  <mml:mo>∈</mml:mo>
                  <mml:msup>
                    <mml:mi>C</mml:mi>
                    <mml:mn>2</mml:mn>
                  </mml:msup>
                  <mml:mrow>
                    <mml:mo>(</mml:mo>
                    <mml:mrow>
                      <mml:mo>(</mml:mo>
                      <mml:mn>0</mml:mn>
                      <mml:mo>,</mml:mo>
                      <mml:mi>∞</mml:mi>
                      <mml:mo>)</mml:mo>
                    </mml:mrow>
                    <mml:mo>)</mml:mo>
                  </mml:mrow>
                </mml:mrow>
              </mml:math></jats:alternatives></jats:inline-formula> is positive and suitably small in relation to <jats:italic>S</jats:italic> by satisfying <jats:disp-formula><jats:alternatives><jats:tex-math>$$\begin{aligned} \frac{\xi S(\xi )}{D(\xi )} \ge K_{SD}\xi ^\lambda \qquad \text{ for } \text{ all } \xi \ge \xi _0 \end{aligned}$$</jats:tex-math><mml:math xmlns:mml="http://www.w3.org/1998/Math/MathML">
                <mml:mrow>
                  <mml:mtable>
                    <mml:mtr>
                      <mml:mtd>
                        <mml:mrow>
                          <mml:mfrac>
                            <mml:mrow>
                              <mml:mi>ξ</mml:mi>
                              <mml:mi>S</mml:mi>
                              <mml:mo>(</mml:mo>
                              <mml:mi>ξ</mml:mi>
                              <mml:mo>)</mml:mo>
                            </mml:mrow>
                            <mml:mrow>
                              <mml:mi>D</mml:mi>
                              <mml:mo>(</mml:mo>
                              <mml:mi>ξ</mml:mi>
                              <mml:mo>)</mml:mo>
                            </mml:mrow>
                          </mml:mfrac>
                          <mml:mo>≥</mml:mo>
                          <mml:msub>
                            <mml:mi>K</mml:mi>
                            <mml:mrow>
                              <mml:mi>SD</mml:mi>
                            </mml:mrow>
                          </mml:msub>
                          <mml:msup>
                            <mml:mi>ξ</mml:mi>
                            <mml:mi>λ</mml:mi>
                          </mml:msup>
                          <mml:mspace />
                          <mml:mspace />
                          <mml:mtext>for</mml:mtext>
                          <mml:mspace />
                          <mml:mspace />
                          <mml:mtext>all</mml:mtext>
                          <mml:mspace />
                          <mml:mi>ξ</mml:mi>
                          <mml:mo>≥</mml:mo>
                          <mml:msub>
                            <mml:mi>ξ</mml:mi>
                            <mml:mn>0</mml:mn>
                          </mml:msub>
                        </mml:mrow>
                      </mml:mtd>
                    </mml:mtr>
                  </mml:mtable>
                </mml:mrow>
              </mml:math></jats:alternatives></jats:disp-formula>with some <jats:inline-formula><jats:alternatives><jats:tex-math>$$K_{SD}&gt;0$$</jats:tex-math><mml:math xmlns:mml="http://www.w3.org/1998/Math/MathML">
                <mml:mrow>
                  <mml:msub>
                    <mml:mi>K</mml:mi>
                    <mml:mrow>
                      <mml:mi>SD</mml:mi>
                    </mml:mrow>
                  </mml:msub>
                  <mml:mo>&gt;</mml:mo>
                  <mml:mn>0</mml:mn>
                </mml:mrow>
              </mml:math></jats:alternatives></jats:inline-formula> and <jats:inline-formula><jats:alternatives><jats:tex-math>$$\lambda &gt;\frac{2}{n}$$</jats:tex-math><mml:math xmlns:mml="http://www.w3.org/1998/Math/MathML">
                <mml:mrow>
                  <mml:mi>λ</mml:mi>
                  <mml:mo>&gt;</mml:mo>
                  <mml:mfrac>
                    <mml:mn>2</mml:mn>
                    <mml:mi>n</mml:mi>
                  </mml:mfrac>
                </mml:mrow>
              </mml:math></jats:alternatives></jats:inline-formula>, then throughout a considerably large set of initial data, (<jats:inline-formula><jats:alternatives><jats:tex-math>$$\star $$</jats:tex-math><mml:math xmlns:mml="http://www.w3.org/1998/Math/MathML">
                <mml:mo>⋆</mml:mo>
              </mml:math></jats:alternatives></jats:inline-formula>) admits global classical solutions (<jats:italic>u</jats:italic>, <jats:italic>v</jats:italic>) fulfilling <jats:disp-formula><jats:alternatives><jats:tex-math>$$\begin{aligned} \frac{z(t)}{C} \le \Vert u(\cdot ,t)\Vert _{L^\infty (\Omega )} \le Cz(t) \qquad \text{ for } \text{ all } t&gt;0, \end{aligned}$$</jats:tex-math><mml:math xmlns:mml="http://www.w3.org/1998/Math/MathML">
                <mml:mrow>
                  <mml:mtable>
                    <mml:mtr>
                      <mml:mtd>
                        <mml:mrow>
                          <mml:mfrac>
                            <mml:mrow>
                              <mml:mi>z</mml:mi>
                              <mml:mo>(</mml:mo>
                              <mml:mi>t</mml:mi>
                              <mml:mo>)</mml:mo>
                            </mml:mrow>
                            <mml:mi>C</mml:mi>
                          </mml:mfrac>
                          <mml:mo>≤</mml:mo>
                          <mml:msub>
                            <mml:mrow>
                              <mml:mo>‖</mml:mo>
                              <mml:mi>u</mml:mi>
                              <mml:mrow>
                                <mml:mo>(</mml:mo>
                                <mml:mo>·</mml:mo>
                                <mml:mo>,</mml:mo>
                                <mml:mi>t</mml:mi>
                                <mml:mo>)</mml:mo>
                              </mml:mrow>
                              <mml:mo>‖</mml:mo>
                            </mml:mrow>
                            <mml:mrow>
                              <mml:msup>
                                <mml:mi>L</mml:mi>
                                <mml:mi>∞</mml:mi>
                              </mml:msup>
                              <mml:mrow>
                                <mml:mo>(</mml:mo>
                                <mml:mi>Ω</mml:mi>
                                <mml:mo>)</mml:mo>
                              </mml:mrow>
                            </mml:mrow>
                          </mml:msub>
                          <mml:mo>≤</mml:mo>
                          <mml:mi>C</mml:mi>
                          <mml:mi>z</mml:mi>
                          <mml:mrow>
                            <mml:mo>(</mml:mo>
                            <mml:mi>t</mml:mi>
                            <mml:mo>)</mml:mo>
                          </mml:mrow>
                          <mml:mspace />
                          <mml:mspace />
                          <mml:mtext>for</mml:mtext>
                          <mml:mspace />
                          <mml:mspace />
                          <mml:mtext>all</mml:mtext>
                          <mml:mspace />
                          <mml:mi>t</mml:mi>
                          <mml:mo>&gt;</mml:mo>
                          <mml:mn>0</mml:mn>
                          <mml:mo>,</mml:mo>
                        </mml:mrow>
                      </mml:mtd>
                    </mml:mtr>
                  </mml:mtable>
                </mml:mrow>
              </mml:math></jats:alternatives></jats:disp-formula>with some <jats:inline-formula><jats:alternatives><jats:tex-math>$$C=C^{(u,v)}\ge 1$$</jats:tex-math><mml:math xmlns:mml="http://www.w3.org/1998/Math/MathML">
                <mml:mrow>
                  <mml:mi>C</mml:mi>
                  <mml:mo>=</mml:mo>
                  <mml:msup>
                    <mml:mi>C</mml:mi>
                    <mml:mrow>
                      <mml:mo>(</mml:mo>
                      <mml:mi>u</mml:mi>
                      <mml:mo>,</mml:mo>
                      <mml:mi>v</mml:mi>
                      <mml:mo>)</mml:mo>
                    </mml:mrow>
                  </mml:msup>
                  <mml:mo>≥</mml:mo>
                  <mml:mn>1</mml:mn>
                </mml:mrow>
              </mml:math></jats:alternatives></jats:inline-formula>, where <jats:italic>z</jats:italic> denotes the solution of <jats:disp-formula><jats:alternatives><jats:tex-math>$$\begin{aligned} \left\{ \begin{array}{l}z'(t) = z^2(t) \cdot S\big ( z(t)\big ), \qquad t&gt;0, \\ z(0)=\xi _0, \end{array} \right. \end{aligned}$$</jats:tex-math><mml:math xmlns:mml="http://www.w3.org/1998/Math/MathML">
                <mml:mrow>
                  <mml:mtable>
                    <mml:mtr>
                      <mml:mtd>
                        <mml:mfenced>
                          <mml:mrow>
                            <mml:mtable>
                              <mml:mtr>
                                <mml:mtd>
                                  <mml:mrow>
                                    <mml:msup>
                                      <mml:mi>z</mml:mi>
                                      <mml:mo>′</mml:mo>
                                    </mml:msup>
                                    <mml:mrow>
                                      <mml:mo>(</mml:mo>
                                      <mml:mi>t</mml:mi>
                                      <mml:mo>)</mml:mo>
                                    </mml:mrow>
                                    <mml:mo>=</mml:mo>
                                    <mml:msup>
                                      <mml:mi>z</mml:mi>
                                      <mml:mn>2</mml:mn>
                                    </mml:msup>
                                    <mml:mrow>
                                      <mml:mo>(</mml:mo>
                                      <mml:mi>t</mml:mi>
                                      <mml:mo>)</mml:mo>
                                    </mml:mrow>
                                    <mml:mo>·</mml:mo>
                                    <mml:mi>S</mml:mi>
                                    <mml:mrow>
                                      <mml:mo>(</mml:mo>
                                    </mml:mrow>
                                    <mml:mi>z</mml:mi>
                                    <mml:mrow>
                                      <mml:mo>(</mml:mo>
                                      <mml:mi>t</mml:mi>
                                      <mml:mo>)</mml:mo>
                                    </mml:mrow>
                                    <mml:mrow>
                                      <mml:mo>)</mml:mo>
                                    </mml:mrow>
                                    <mml:mo>,</mml:mo>
                                    <mml:mspace />
                                    <mml:mi>t</mml:mi>
                                    <mml:mo>&gt;</mml:mo>
                                    <mml:mn>0</mml:mn>
                                    <mml:mo>,</mml:mo>
                                  </mml:mrow>
                                </mml:mtd>
                              </mml:mtr>
                              <mml:mtr>
                                <mml:mtd>
                                  <mml:mrow>
                                    <mml:mrow />
                                    <mml:mi>z</mml:mi>
                                    <mml:mrow>
                                      <mml:mo>(</mml:mo>
                                      <mml:mn>0</mml:mn>
                                      <mml:mo>)</mml:mo>
                                    </mml:mrow>
                                    <mml:mo>=</mml:mo>
                                    <mml:msub>
                                      <mml:mi>ξ</mml:mi>
                                      <mml:mn>0</mml:mn>
                                    </mml:msub>
                                    <mml:mo>,</mml:mo>
                                  </mml:mrow>
                                </mml:mtd>
                              </mml:mtr>
                            </mml:mtable>
                          </mml:mrow>
                        </mml:mfenced>
                      </mml:mtd>
                    </mml:mtr>
                  </mml:mtable>
                </mml:mrow>
              </mml:math></jats:alternatives></jats:disp-formula>which is seen to exist globally, and to satisfy <jats:inline-formula><jats:alternatives><jats:tex-math>$$z(t)\rightarrow +\infty $$</jats:tex-math><mml:math xmlns:mml="http://www.w3.org/1998/Math/MathML">
                <mml:mrow>
                  <mml:mi>z</mml:mi>
                  <mml:mo>(</mml:mo>
                  <mml:mi>t</mml:mi>
                  <mml:mo>)</mml:mo>
                  <mml:mo>→</mml:mo>
                  <mml:mo>+</mml:mo>
                  <mml:mi>∞</mml:mi>
                </mml:mrow>
              </mml:math></jats:alternatives></jats:inline-formula> as <jats:inline-formula><jats:alternatives><jats:tex-math>$$t\rightarrow \infty $$</jats:tex-math><mml:math xmlns:mml="http://www.w3.org/1998/Math/MathML">
                <mml:mrow>
                  <mml:mi>t</mml:mi>
                  <mml:mo>→</mml:mo>
                  <mml:mi>∞</mml:mi>
                </mml:mrow>
              </mml:math></jats:alternatives></jats:inline-formula>. As particular examples, exponentially and doubly exponentially decaying <jats:italic>S</jats:italic> are found to imply corresponding infinite-time blow-up properties in (<jats:inline-formula><jats:alternatives><jats:tex-math>$$\star $$</jats:tex-math><mml:math xmlns:mml="http://www.w3.org/1998/Math/MathML">
                <mml:mo>⋆</mml:mo>
              </mml:math></jats:alternatives></jats:inline-formula>) at logarithmic and doubly logarithmic rates, respectively.</jats:p>}},
  author       = {{Winkler, Michael}},
  issn         = {{1040-7294}},
  journal      = {{Journal of Dynamics and Differential Equations}},
  keywords     = {{Analysis}},
  publisher    = {{Springer Science and Business Media LLC}},
  title        = {{{Slow Grow-up in a Quasilinear Keller–Segel System}}},
  doi          = {{10.1007/s10884-022-10167-w}},
  year         = {{2022}},
}

@article{53327,
  author       = {{Tao, Youshan and Winkler, Michael}},
  issn         = {{0022-0396}},
  journal      = {{Journal of Differential Equations}},
  keywords     = {{Analysis, Applied Mathematics}},
  pages        = {{390--418}},
  publisher    = {{Elsevier BV}},
  title        = {{{Global solutions to a Keller-Segel-consumption system involving singularly signal-dependent motilities in domains of arbitrary dimension}}},
  doi          = {{10.1016/j.jde.2022.10.022}},
  volume       = {{343}},
  year         = {{2022}},
}

@article{53325,
  author       = {{Desvillettes, Laurent and Laurençot, Philippe and Trescases, Ariane and Winkler, Michael}},
  issn         = {{0362-546X}},
  journal      = {{Nonlinear Analysis}},
  keywords     = {{Applied Mathematics, Analysis}},
  publisher    = {{Elsevier BV}},
  title        = {{{Weak solutions to triangular cross diffusion systems modeling chemotaxis with local sensing}}},
  doi          = {{10.1016/j.na.2022.113153}},
  volume       = {{226}},
  year         = {{2022}},
}

@article{50024,
  author       = {{Feng, Yuanhua and Gries, Thomas and Letmathe, Sebastian and Schulz, Dominik}},
  issn         = {{2073-4859}},
  journal      = {{The R Journal}},
  keywords     = {{Statistics, Probability and Uncertainty, Numerical Analysis, Statistics and Probability}},
  number       = {{1}},
  pages        = {{182--195}},
  publisher    = {{The R Foundation}},
  title        = {{{The smoots Package in R for Semiparametric Modeling of Trend Stationary Time Series}}},
  doi          = {{10.32614/rj-2022-017}},
  volume       = {{14}},
  year         = {{2022}},
}

