Analyze Code with Advanced Mathematical Rigor

Prof. Euler is an ultra-advanced mathematician persona, inspired by Terence Tao, Euler, Grothendieck, Von Neumann, and Gödel, that applies deep mathematical theory to rigorous code and architecture analysis. Where Tao's approach is described as decomposing problems into orthogonal subproblems and hunting for hidden structure, Prof. Euler extends this with applied category theory (treating cross-domain transformations as functors), code topology (shape invariants, not just value invariants), stochastic system analysis, applied information theory, differential geometry of parameter spaces, and extended Hoare logic (pre/post-conditions as formally proven contracts).

Its analytical toolkit spans five areas, each with concrete formal methods: mathematical code analysis - time/space/amortized (Banach potential) complexity with explicit constants, dependency graphs (detecting cycles, excessive coupling via cliques, single points of failure via betweenness centrality, strongly connected components), state machines as transition matrices (eigenvalues as steady states), and Shannon entropy/mutual information for API interfaces; concurrency and reactive systems - CSP process models for coroutines/StateFlow/Kotlin channels (detecting deadlock, livelock, race conditions via Lamport happens-before non-commutativity), and temporal logic (LTL/CTL) for safety/liveness/fairness properties; performance and optimization - queuing theory (Jackson networks, M/M/1 or M/M/k models with utilization ρ=λ/μ, expected wait time) for data pipelines like voice-to-STT-to-LLM-to-TTS, and convex optimization with KKT conditions for scheduling/resource allocation; formal correctness analysis and category theory for architecture.

CSP Process P = (S, s0, Σ, δ, F):
Deadlock: state s where no event e has δ(s,e) defined
Race condition iff exists a,b: not(a→b) and not(b→a) and both access the same data

The skill includes a specific worked application to an Android voice-assistant project ("Auri/Earllm"), covering coroutine scopes as lifecycle automata, formal semantics of repeatOnLifecycle and buffering, a documented anti-pattern (using StateFlow for one-shot events), a Recomposition Complexity Index (RCI) with optimization techniques, an Intent-safety taxonomy, a formal correctness proof sketch for a sendWhatsApp() function, and a random-walk cost model for context growth toward a breaking point.

Use this skill when a code or architecture review calls for rigorous, formally-grounded mathematical analysis - complexity proofs, concurrency correctness (deadlock/race detection), performance modeling via queuing theory, or category-theoretic reasoning about architecture - rather than informal code review. Per its own guidance, it should be combined with other complementary skills for comprehensive analysis, its suggestions should be reviewed before applying to production code, and it should not substitute for environment-specific validation, testing, or expert review; when it lacks sufficient project context, the expected behavior is to say so and ask, not guess.

Input is code, architecture, or a specific technical question (e.g. a concurrency bug, a performance bottleneck, an API design) needing mathematically rigorous analysis. Output is a structured mathematical analysis - complexity bounds, dependency graph properties, formal correctness proofs or counterexamples, queuing-theory performance models, or category-theoretic architecture insights - explained rigorously but accessibly, with concrete recommendations.

Applies general mathematical frameworks (complexity theory, graph theory, CSP, temporal logic, queuing theory, convex optimization, category theory) to whatever codebase or architecture is under review; its worked example targets an Android Kotlin coroutines/StateFlow voice-assistant pipeline.

Senior engineers and architects who want formally rigorous, mathematically-grounded analysis of complex systems - concurrency correctness, performance modeling, or architectural structure - beyond informal code review heuristics.