matematico-tao — Skillopedia

Prof. Euler — Matemático Ultra-Avançado Overview Matemático ultra-avançado inspirado em Terence Tao. Análise rigorosa de código e arquitetura com teoria matemática profunda: teoria da informação, teoria dos grafos, complexidade computacional, álgebra linear, análise estocástica, teoria das categorias, probabilidade bayesiana e lógica formal. When to Use This Skill - When the user mentions "matematico" or related topics - When the user mentions "terence tao" or related topics - When the user mentions "prof euler" or related topics - When the user mentions "analise matematica codigo" or related…

, content, re.MULTILINE)\n\n # Analisar funções\n metrics.functions = self._extract_functions(content, str(file_path))\n\n return metrics\n\n def _extract_functions(self, content: str, filepath: str) -> List[FunctionMetrics]:\n \"\"\"Extrai e analisa todas as funções do arquivo.\"\"\"\n functions = []\n lines = content.split('\\n')\n\n # Pattern para declarações de função Kotlin\n fun_pattern = re.compile(\n r'^(\\s*)((?:suspend\\s+)?(?:private\\s+|protected\\s+|internal\\s+|public\\s+)?'\n r'(?:override\\s+)?(?:suspend\\s+)?fun\\s+(\\w+)\\s*\$([^)]*)\$)',\n re.MULTILINE\n )\n\n for match in fun_pattern.finditer(content):\n fun_name = match.group(3)\n params_str = match.group(4)\n is_suspend = 'suspend' in match.group(2)\n line_num = content[:match.start()].count('\\n') + 1\n\n # Extrair corpo da função\n body = self._extract_function_body(content, match.end())\n if not body:\n continue\n\n # Calcular métricas\n cc = self._cyclomatic_complexity(body)\n cog = self._cognitive_complexity(body)\n params = self._count_parameters(params_str)\n nullable = self._count_nullable_params(params_str)\n has_try = bool(re.search(r'\\btry\\b', body))\n\n functions.append(FunctionMetrics(\n name=fun_name,\n file=filepath,\n line=line_num,\n cyclomatic=cc,\n cognitive=cog,\n lines=body.count('\\n'),\n parameters=params,\n nullable_params=nullable,\n has_try_catch=has_try,\n coroutine=is_suspend\n ))\n\n return functions\n\n def _extract_function_body(self, content: str, start: int) -> str:\n \"\"\"Extrai o corpo de uma função por contagem de chaves.\"\"\"\n i = start\n depth = 0\n started = False\n\n while i \u003c len(content):\n c = content[i]\n if c == '{':\n depth += 1\n started = True\n elif c == '}':\n depth -= 1\n if started and depth == 0:\n return content[start:i+1]\n i += 1\n\n return content[start:min(start + 500, len(content))]\n\n def _cyclomatic_complexity(self, code: str) -> int:\n \"\"\"Calcula CC de McCabe.\"\"\"\n cc = 1 # Base\n for pattern in self.CYCLOMATIC_TOKENS:\n matches = re.findall(pattern, code)\n cc += len(matches)\n return cc\n\n def _cognitive_complexity(self, code: str) -> int:\n \"\"\"Calcula complexidade cognitiva (aproximação).\"\"\"\n cog = 0\n nesting = 0\n lines = code.split('\\n')\n\n for line in lines:\n stripped = line.strip()\n\n # Aumenta nesting\n if re.search(r'\\b(if|when|for|while|try)\\b', stripped):\n cog += (1 + nesting)\n nesting += 1\n\n # Fecha nesting\n elif stripped == '}':\n nesting = max(0, nesting - 1)\n\n # Breaks de fluxo\n for pattern in self.COGNITIVE_BREAK_TOKENS:\n if re.search(pattern, stripped):\n cog += 1\n\n return cog\n\n def _count_parameters(self, params_str: str) -> int:\n \"\"\"Conta parâmetros de uma função.\"\"\"\n if not params_str.strip():\n return 0\n return len([p for p in params_str.split(',') if p.strip()])\n\n def _count_nullable_params(self, params_str: str) -> int:\n \"\"\"Conta parâmetros nullable (tipo?).\"\"\"\n return len(re.findall(r'\\w+\\?', params_str))\n\n def analyze_coupling(self) -> Dict[str, ModuleCoupling]:\n \"\"\"Analisa acoplamento entre módulos.\"\"\"\n module_imports: Dict[str, set] = defaultdict(set)\n\n for file_metrics in self.metrics:\n for imp in file_metrics.imports:\n # Detecta qual módulo está sendo importado\n for mod in ['bluetooth', 'audio', 'voice', 'llm', 'integrations', 'core.logging']:\n if mod in imp:\n module_imports[file_metrics.module].add(mod.replace('.', '-'))\n\n coupling = {}\n all_modules = set(m.module for m in self.metrics)\n\n for mod in all_modules:\n c = ModuleCoupling(module=mod)\n c.efferent = list(module_imports.get(mod, set()))\n for other_mod, deps in module_imports.items():\n if mod.replace('-', '.') in deps or mod in deps:\n c.afferent.append(other_mod)\n coupling[mod] = c\n\n return coupling\n\n def generate_report(self) -> Dict:\n \"\"\"Gera relatório completo com análise matemática.\"\"\"\n # Funções problemáticas\n high_cc = []\n high_cognitive = []\n too_long = []\n too_many_params = []\n unsafe_nullable = []\n coroutine_issues = []\n\n for file_m in self.metrics:\n for func in file_m.functions:\n if func.cyclomatic > self.threshold:\n high_cc.append({\n 'function': func.name,\n 'file': file_m.path,\n 'line': func.line,\n 'cc': func.cyclomatic,\n 'risk': self._cc_risk_label(func.cyclomatic)\n })\n\n if func.cognitive > self.threshold * 1.5:\n high_cognitive.append({\n 'function': func.name,\n 'file': file_m.path,\n 'line': func.line,\n 'cognitive': func.cognitive\n })\n\n if func.lines > 50:\n too_long.append({\n 'function': func.name,\n 'file': file_m.path,\n 'line': func.line,\n 'lines': func.lines\n })\n\n if func.parameters > 5:\n too_many_params.append({\n 'function': func.name,\n 'file': file_m.path,\n 'params': func.parameters\n })\n\n if func.nullable_params > 2:\n unsafe_nullable.append({\n 'function': func.name,\n 'file': file_m.path,\n 'nullable_params': func.nullable_params\n })\n\n if func.coroutine and func.has_try_catch:\n coroutine_issues.append({\n 'function': func.name,\n 'file': file_m.path,\n 'note': 'suspend fun with try-catch: verify structured concurrency'\n })\n\n # Ordenar por severidade\n high_cc.sort(key=lambda x: x['cc'], reverse=True)\n\n # Módulos com maior complexidade\n module_stats = defaultdict(lambda: {'total_cc': 0, 'max_cc': 0, 'functions': 0, 'files': 0})\n for file_m in self.metrics:\n mod = file_m.module\n module_stats[mod]['files'] += 1\n module_stats[mod]['functions'] += len(file_m.functions)\n for f in file_m.functions:\n module_stats[mod]['total_cc'] += f.cyclomatic\n module_stats[mod]['max_cc'] = max(module_stats[mod]['max_cc'], f.cyclomatic)\n\n # Calcular média CC por módulo\n for mod, stats in module_stats.items():\n if stats['functions'] > 0:\n stats['avg_cc'] = round(stats['total_cc'] / stats['functions'], 2)\n else:\n stats['avg_cc'] = 0\n\n coupling = self.analyze_coupling()\n coupling_data = {}\n for mod, c in coupling.items():\n coupling_data[mod] = {\n 'Ca': len(c.afferent),\n 'Ce': len(c.efferent),\n 'instability': round(c.instability, 3),\n 'depends_on': c.efferent,\n 'depended_by': c.afferent\n }\n\n return {\n 'summary': {\n 'total_files': len(self.metrics),\n 'total_functions': sum(len(f.functions) for f in self.metrics),\n 'total_code_lines': sum(f.code_lines for f in self.metrics),\n 'high_cc_functions': len(high_cc),\n 'high_cognitive_functions': len(high_cognitive),\n },\n 'high_cyclomatic_complexity': high_cc[:20], # top 20\n 'high_cognitive_complexity': high_cognitive[:10],\n 'overly_long_functions': too_long[:10],\n 'too_many_parameters': too_many_params[:10],\n 'nullable_risks': unsafe_nullable[:10],\n 'coroutine_issues': coroutine_issues[:10],\n 'module_statistics': dict(module_stats),\n 'module_coupling': coupling_data,\n }\n\n def _cc_risk_label(self, cc: int) -> str:\n if cc \u003c= 5:\n return \"LOW\"\n elif cc \u003c= 10:\n return \"MODERATE\"\n elif cc \u003c= 20:\n return \"HIGH — refactor recommended\"\n else:\n return \"CRITICAL — must refactor\"\n\n def print_report(self, report: Dict) -> None:\n \"\"\"Imprime relatório formatado.\"\"\"\n print(\"\\n\" + \"=\"*70)\n print(\" PROF. EULER — ANÁLISE DE COMPLEXIDADE MATEMÁTICA\")\n print(\"=\"*70)\n\n s = report['summary']\n print(f\"\\n📊 RESUMO:\")\n print(f\" Arquivos analisados: {s['total_files']}\")\n print(f\" Funções analisadas: {s['total_functions']}\")\n print(f\" Linhas de código: {s['total_code_lines']}\")\n print(f\" Funções alta CC: {s['high_cc_functions']} (threshold={self.threshold})\")\n print(f\" Funções alta cognitiva: {s['high_cognitive_functions']}\")\n\n if report['high_cyclomatic_complexity']:\n print(f\"\\n⚠️ TOP FUNÇÕES POR COMPLEXIDADE CICLOMÁTICA:\")\n print(f\" {'Função':\u003c35} {'CC':>5} {'Arquivo':\u003c40} Risco\")\n print(f\" {'-'*35} {'-'*5} {'-'*40} {'-'*25}\")\n for item in report['high_cyclomatic_complexity'][:10]:\n fname = item['function'][:34]\n ffile = item['file'][:39]\n print(f\" {fname:\u003c35} {item['cc']:>5} {ffile:\u003c40} {item['risk']}\")\n\n if report['module_statistics']:\n print(f\"\\n📦 ESTATÍSTICAS POR MÓDULO:\")\n print(f\" {'Módulo':\u003c20} {'Arquivos':>8} {'Funções':>8} {'CC Médio':>10} {'CC Máximo':>10} {'Instabilidade':>14}\")\n print(f\" {'-'*20} {'-'*8} {'-'*8} {'-'*10} {'-'*10} {'-'*14}\")\n coupling = report['module_coupling']\n for mod, stats in sorted(report['module_statistics'].items()):\n inst = coupling.get(mod, {}).get('instability', 'N/A')\n inst_str = f\"{inst:.3f}\" if isinstance(inst, float) else inst\n print(f\" {mod:\u003c20} {stats['files']:>8} {stats['functions']:>8} \"\n f\"{stats['avg_cc']:>10.2f} {stats['max_cc']:>10} {inst_str:>14}\")\n\n if report['coroutine_issues']:\n print(f\"\\n🔄 PROBLEMAS POTENCIAIS EM COROUTINES:\")\n for item in report['coroutine_issues'][:5]:\n print(f\" ⚠️ {item['function']} ({item['file']})\")\n print(f\" → {item['note']}\")\n\n if report['nullable_risks']:\n print(f\"\\n❓ NULLABLE RISKS (muitos parâmetros nullable):\")\n for item in report['nullable_risks'][:5]:\n print(f\" {item['function']}: {item['nullable_params']} nullable params ({item['file']})\")\n\n print(\"\\n\" + \"=\"*70)\n print(\" Análise matemática completa. Consulte Prof. Euler para interpretação.\")\n print(\"=\"*70 + \"\\n\")\n\n\ndef main():\n parser = argparse.ArgumentParser(\n description='Prof. Euler — Análise de Complexidade Matemática para Kotlin/Android'\n )\n parser.add_argument('path', nargs='?',\n default=r'C:\\Users\\renat\\earbudllm',\n help='Caminho raiz do projeto')\n parser.add_argument('--module', '-m', help='Analisar apenas este módulo')\n parser.add_argument('--threshold', '-t', type=int, default=10,\n help='Threshold de complexidade ciclomática (default: 10)')\n parser.add_argument('--json', '-j', action='store_true',\n help='Saída em formato JSON')\n parser.add_argument('--output', '-o', help='Salvar relatório em arquivo')\n\n args = parser.parse_args()\n\n print(f\"🔬 Prof. Euler analisando: {args.path}\")\n if args.module:\n print(f\" Módulo: {args.module}\")\n\n analyzer = KotlinComplexityAnalyzer(args.path, threshold=args.threshold)\n analyzer.analyze(module_filter=args.module)\n\n report = analyzer.generate_report()\n\n if args.json:\n output = json.dumps(report, indent=2, ensure_ascii=False)\n print(output)\n else:\n analyzer.print_report(report)\n\n if args.output:\n output_path = Path(args.output)\n if args.json:\n output_path.write_text(json.dumps(report, indent=2, ensure_ascii=False))\n else:\n # Salvar como markdown\n save_as_markdown(report, output_path, args.threshold)\n print(f\"✅ Relatório salvo em: {args.output}\")\n\n return report\n\n\ndef save_as_markdown(report: Dict, path: Path, threshold: int) -> None:\n \"\"\"Salva relatório em formato Markdown.\"\"\"\n lines = [\n \"# Prof. Euler — Relatório de Complexidade Matemática\\n\",\n f\"Threshold CC: {threshold}\\n\\n\",\n \"## Resumo\\n\",\n f\"- **Arquivos**: {report['summary']['total_files']}\\n\",\n f\"- **Funções**: {report['summary']['total_functions']}\\n\",\n f\"- **Linhas de código**: {report['summary']['total_code_lines']}\\n\",\n f\"- **Alta CC**: {report['summary']['high_cc_functions']}\\n\\n\",\n \"## Funções de Alta Complexidade Ciclomática\\n\",\n \"| Função | CC | Arquivo | Risco |\\n\",\n \"|--------|-----|---------|-------|\\n\",\n ]\n for item in report['high_cyclomatic_complexity'][:15]:\n lines.append(\n f\"| `{item['function']}` | {item['cc']} | `{item['file']}` | {item['risk']} |\\n\"\n )\n\n lines.append(\"\\n## Acoplamento de Módulos\\n\")\n lines.append(\"| Módulo | Ca | Ce | Instabilidade | Depende de |\\n\")\n lines.append(\"|--------|----|----|--------------|------------|\\n\")\n for mod, data in sorted(report['module_coupling'].items()):\n deps = ', '.join(data['depends_on']) or 'nenhum'\n lines.append(\n f\"| {mod} | {data['Ca']} | {data['Ce']} | {data['instability']:.3f} | {deps} |\\n\"\n )\n\n path.write_text(''.join(lines), encoding='utf-8')\n\n\nif __name__ == '__main__':\n main()\n","content_type":"text/x-python; charset=utf-8","language":"python","size":20006,"content_sha256":"d38103b5ead3fb6f07adb1a1fbe8ea007cbf65a631d5108b47aef2cf4a9e9f3e"},{"filename":"scripts/dependency_graph.py","content":"#!/usr/bin/env python3\n\"\"\"\nProf. Euler — Dependency Graph Analyzer\nGera grafo de dependências de projetos Kotlin/Android com análise matemática\nde grafos: componentes, ciclos, centralidade, instabilidade.\n\nUso:\n python dependency_graph.py [path] [--format dot|json|text] [--output FILE]\n python dependency_graph.py C:/Users/renat/earbudllm\n python dependency_graph.py C:/Users/renat/earbudllm --format dot --output deps.dot\n\"\"\"\n\nimport os\nimport re\nimport sys\nimport json\nimport argparse\nfrom pathlib import Path\nfrom dataclasses import dataclass, field\nfrom typing import Dict, List, Set, Optional, Tuple\n\n# Fix Windows terminal encoding (cp1252 doesn't support emojis/unicode)\nif sys.platform == 'win32':\n try:\n sys.stdout.reconfigure(encoding='utf-8', errors='replace')\n sys.stderr.reconfigure(encoding='utf-8', errors='replace')\n except AttributeError:\n pass # Python \u003c 3.7 fallback\nfrom collections import defaultdict, deque\n\n\n@dataclass\nclass Node:\n id: str\n module: str\n package: str\n kind: str # 'class', 'interface', 'object', 'enum', 'data class'\n is_abstract: bool = False\n is_open: bool = False\n\n\n@dataclass\nclass Edge:\n src: str # node id\n dst: str # node id\n kind: str # 'implements', 'extends', 'uses', 'imports', 'delegates_to'\n weight: float = 1.0\n\n\nclass DependencyGraph:\n \"\"\"Grafo de dependências com análise matemática completa.\"\"\"\n\n def __init__(self):\n self.nodes: Dict[str, Node] = {}\n self.edges: List[Edge] = []\n self._adj: Dict[str, Set[str]] = defaultdict(set) # adjacência direta\n self._radj: Dict[str, Set[str]] = defaultdict(set) # adjacência reversa\n\n def add_node(self, node: Node) -> None:\n self.nodes[node.id] = node\n\n def add_edge(self, edge: Edge) -> None:\n if edge.src != edge.dst: # sem self-loops\n self.edges.append(edge)\n self._adj[edge.src].add(edge.dst)\n self._radj[edge.dst].add(edge.src)\n\n def successors(self, node_id: str) -> Set[str]:\n return self._adj.get(node_id, set())\n\n def predecessors(self, node_id: str) -> Set[str]:\n return self._radj.get(node_id, set())\n\n # ─── Algoritmos de Grafos ────────────────────────────────────────────────\n\n def find_cycles(self) -> List[List[str]]:\n \"\"\"Detecta ciclos usando DFS com coloração (branco/cinza/preto).\"\"\"\n WHITE, GRAY, BLACK = 0, 1, 2\n color = {n: WHITE for n in self.nodes}\n cycles = []\n path = []\n\n def dfs(node: str) -> None:\n color[node] = GRAY\n path.append(node)\n\n for neighbor in self._adj.get(node, set()):\n if neighbor not in self.nodes:\n continue\n if color[neighbor] == GRAY:\n # Ciclo encontrado! Extrair o ciclo do path\n cycle_start = path.index(neighbor)\n cycle = path[cycle_start:] + [neighbor]\n cycles.append(cycle)\n elif color[neighbor] == WHITE:\n dfs(neighbor)\n\n path.pop()\n color[node] = BLACK\n\n for node in list(self.nodes.keys()):\n if color[node] == WHITE:\n dfs(node)\n\n # Deduplicar ciclos\n unique = []\n seen = set()\n for cycle in cycles:\n key = frozenset(cycle)\n if key not in seen:\n seen.add(key)\n unique.append(cycle)\n\n return unique\n\n def strongly_connected_components(self) -> List[List[str]]:\n \"\"\"Algoritmo de Kosaraju para SCCs.\"\"\"\n visited = set()\n finish_order = []\n\n def dfs1(node: str) -> None:\n visited.add(node)\n for neighbor in self._adj.get(node, set()):\n if neighbor in self.nodes and neighbor not in visited:\n dfs1(neighbor)\n finish_order.append(node)\n\n def dfs2(node: str, component: List[str]) -> None:\n visited.add(node)\n component.append(node)\n for neighbor in self._radj.get(node, set()):\n if neighbor in self.nodes and neighbor not in visited:\n dfs2(neighbor, component)\n\n # Fase 1: DFS no grafo original\n for node in self.nodes:\n if node not in visited:\n dfs1(node)\n\n # Fase 2: DFS no grafo transposto na ordem inversa de finalização\n visited.clear()\n sccs = []\n for node in reversed(finish_order):\n if node not in visited:\n component = []\n dfs2(node, component)\n sccs.append(component)\n\n return sccs\n\n def topological_sort(self) -> Optional[List[str]]:\n \"\"\"Ordenação topológica (só válida se DAG).\"\"\"\n in_degree = defaultdict(int)\n for edge in self.edges:\n if edge.src in self.nodes and edge.dst in self.nodes:\n in_degree[edge.dst] += 1\n\n queue = deque([n for n in self.nodes if in_degree[n] == 0])\n result = []\n\n while queue:\n node = queue.popleft()\n result.append(node)\n for neighbor in self._adj.get(node, set()):\n if neighbor in self.nodes:\n in_degree[neighbor] -= 1\n if in_degree[neighbor] == 0:\n queue.append(neighbor)\n\n if len(result) == len(self.nodes):\n return result\n return None # Há ciclos → não é DAG\n\n def betweenness_centrality(self) -> Dict[str, float]:\n \"\"\"\n Centralidade de betweenness: nós que fazem \"ponte\" entre outros.\n Alto betweenness = single point of failure.\n\n Algoritmo de Brandes: O(V·E)\n \"\"\"\n betweenness = defaultdict(float)\n nodes = list(self.nodes.keys())\n\n for s in nodes:\n # BFS para encontrar caminhos mais curtos de s para todos\n stack = []\n pred = defaultdict(list)\n sigma = defaultdict(int)\n sigma[s] = 1\n dist = defaultdict(lambda: -1)\n dist[s] = 0\n queue = deque([s])\n\n while queue:\n v = queue.popleft()\n stack.append(v)\n for w in self._adj.get(v, set()):\n if w not in self.nodes:\n continue\n if dist[w] \u003c 0:\n queue.append(w)\n dist[w] = dist[v] + 1\n if dist[w] == dist[v] + 1:\n sigma[w] += sigma[v]\n pred[w].append(v)\n\n # Acumulação\n delta = defaultdict(float)\n while stack:\n w = stack.pop()\n for v in pred[w]:\n if sigma[w] > 0:\n delta[v] += (sigma[v] / sigma[w]) * (1 + delta[w])\n if w != s:\n betweenness[w] += delta[w]\n\n # Normalizar\n n = len(nodes)\n if n > 2:\n factor = 2 / ((n - 1) * (n - 2))\n for node in betweenness:\n betweenness[node] *= factor\n\n return dict(betweenness)\n\n def page_rank(self, damping: float = 0.85, iterations: int = 100) -> Dict[str, float]:\n \"\"\"\n PageRank para identificar classes/módulos mais \"importantes\".\n Nodes com alto PageRank são frequentemente usados por outros.\n \"\"\"\n n = len(self.nodes)\n if n == 0:\n return {}\n\n rank = {node: 1.0 / n for node in self.nodes}\n\n for _ in range(iterations):\n new_rank = {}\n for node in self.nodes:\n incoming_sum = sum(\n rank.get(pred, 0) / max(len(self._adj.get(pred, set())), 1)\n for pred in self._radj.get(node, set())\n if pred in self.nodes\n )\n new_rank[node] = (1 - damping) / n + damping * incoming_sum\n rank = new_rank\n\n return rank\n\n def coupling_metrics(self) -> Dict[str, Dict]:\n \"\"\"Calcula Ca, Ce, instabilidade e abstração por módulo.\"\"\"\n module_nodes: Dict[str, Set[str]] = defaultdict(set)\n for node_id, node in self.nodes.items():\n module_nodes[node.module].add(node_id)\n\n metrics = {}\n for module, nodes in module_nodes.items():\n # Ce: dependências efetivas (de fora do módulo)\n efferent = set()\n for n in nodes:\n for dep in self._adj.get(n, set()):\n if dep in self.nodes and self.nodes[dep].module != module:\n efferent.add(self.nodes[dep].module)\n\n # Ca: acoplamentos aferentes\n afferent = set()\n for n in nodes:\n for dep in self._radj.get(n, set()):\n if dep in self.nodes and self.nodes[dep].module != module:\n afferent.add(self.nodes[dep].module)\n\n ca = len(afferent)\n ce = len(efferent)\n instability = ce / (ca + ce) if (ca + ce) > 0 else 0.0\n\n # Abstração: razão de interfaces/abstratas para total\n abstracts = sum(1 for n in nodes if\n n in self.nodes and\n (self.nodes[n].is_abstract or self.nodes[n].kind == 'interface'))\n abstraction = abstracts / max(len(nodes), 1)\n\n # Distância da sequência principal: D = |A + I - 1|\n # Sequência principal: A + I = 1 (ideal)\n distance = abs(abstraction + instability - 1)\n\n metrics[module] = {\n 'Ca': ca,\n 'Ce': ce,\n 'instability': round(instability, 3),\n 'abstraction': round(abstraction, 3),\n 'distance_from_main_sequence': round(distance, 3),\n 'total_classes': len(nodes),\n 'abstract_classes': abstracts,\n 'depends_on_modules': list(efferent),\n 'used_by_modules': list(afferent),\n }\n\n return metrics\n\n\nclass ProjectAnalyzer:\n \"\"\"Analisa um projeto Kotlin/Android completo.\"\"\"\n\n def __init__(self, project_root: str):\n self.project_root = Path(project_root)\n self.graph = DependencyGraph()\n self.module_files: Dict[str, List[Path]] = defaultdict(list)\n\n def analyze(self) -> None:\n \"\"\"Analisa todos os arquivos Kotlin.\"\"\"\n kt_files = list(self.project_root.glob(\"**/*.kt\"))\n\n for kt_file in kt_files:\n module = self._detect_module(kt_file)\n self.module_files[module].append(kt_file)\n self._analyze_file(kt_file, module)\n\n def _detect_module(self, file_path: Path) -> str:\n known = ['app', 'bluetooth', 'audio', 'voice', 'llm', 'integrations', 'core-logging']\n for part in file_path.parts:\n if part in known:\n return part\n return 'unknown'\n\n def _analyze_file(self, file_path: Path, module: str) -> None:\n try:\n content = file_path.read_text(encoding='utf-8', errors='ignore')\n except Exception:\n return\n\n # Extrair package\n pkg_match = re.search(r'^package\\s+(.+)

Important: agents should read /llm.txt, /llms.txt, or /.well-known/skills.json to discover the public Skillopedia API.

, content, re.MULTILINE)\n package = pkg_match.group(1).strip() if pkg_match else 'unknown'\n\n # Extrair declarações de classe/interface/object\n class_patterns = [\n (r'(?:abstract\\s+)?(?:open\\s+)?(?:data\\s+)?class\\s+(\\w+)', 'class'),\n (r'interface\\s+(\\w+)', 'interface'),\n (r'object\\s+(\\w+)', 'object'),\n (r'enum\\s+class\\s+(\\w+)', 'enum'),\n ]\n\n for pattern, kind in class_patterns:\n for match in re.finditer(pattern, content):\n class_name = match.group(1)\n node_id = f\"{package}.{class_name}\"\n is_abstract = 'abstract' in content[max(0, match.start()-20):match.start()]\n is_open = 'open' in content[max(0, match.start()-10):match.start()]\n\n node = Node(\n id=node_id,\n module=module,\n package=package,\n kind=kind,\n is_abstract=is_abstract,\n is_open=is_open\n )\n self.graph.add_node(node)\n\n # Extrair dependências via imports\n imports = re.findall(r'^import\\s+(.+)

Important: agents should read /llm.txt, /llms.txt, or /.well-known/skills.json to discover the public Skillopedia API.

, content, re.MULTILINE)\n for imp in imports:\n imp = imp.strip()\n if imp.startswith('com.earllm'):\n dep_id = imp\n if dep_id != node_id:\n edge = Edge(src=node_id, dst=dep_id, kind='imports')\n self.graph.add_edge(edge)\n\n def generate_full_report(self) -> Dict:\n \"\"\"Gera relatório matemático completo do grafo.\"\"\"\n cycles = self.graph.find_cycles()\n sccs = self.graph.strongly_connected_components()\n topo = self.graph.topological_sort()\n betweenness = self.graph.betweenness_centrality()\n pagerank = self.graph.page_rank()\n coupling = self.graph.coupling_metrics()\n\n # Top nodes por betweenness (single points of failure)\n top_betweenness = sorted(\n betweenness.items(), key=lambda x: x[1], reverse=True\n )[:10]\n\n # Top nodes por pagerank (mais influentes)\n top_pagerank = sorted(\n pagerank.items(), key=lambda x: x[1], reverse=True\n )[:10]\n\n # SCCs com mais de 1 nó (ciclos reais)\n real_sccs = [scc for scc in sccs if len(scc) > 1]\n\n return {\n 'graph_summary': {\n 'nodes': len(self.graph.nodes),\n 'edges': len(self.graph.edges),\n 'is_dag': topo is not None,\n 'cycles_found': len(cycles),\n 'strongly_connected_components': len(real_sccs),\n },\n 'cycles': cycles[:10], # primeiros 10 ciclos\n 'real_sccs': real_sccs[:5],\n 'topological_order': topo[:20] if topo else None,\n 'top_betweenness_centrality': [\n {'node': n, 'betweenness': round(b, 4)} for n, b in top_betweenness\n ],\n 'top_pagerank': [\n {'node': n, 'pagerank': round(pr, 4)} for n, pr in top_pagerank\n ],\n 'module_coupling': coupling,\n 'modules': {mod: len(files) for mod, files in self.module_files.items()},\n }\n\n def to_dot(self) -> str:\n \"\"\"Exporta grafo em formato DOT para visualização (Graphviz).\"\"\"\n lines = ['digraph AuriDependencies {']\n lines.append(' rankdir=LR;')\n lines.append(' node [shape=box, fontname=\"Arial\"];')\n\n # Cores por módulo\n module_colors = {\n 'app': '#4CAF50',\n 'bluetooth': '#2196F3',\n 'audio': '#FF9800',\n 'voice': '#9C27B0',\n 'llm': '#F44336',\n 'integrations': '#00BCD4',\n 'core-logging': '#607D8B',\n }\n\n # Adicionar nós por módulo\n modules_seen = defaultdict(list)\n for node_id, node in self.graph.nodes.items():\n modules_seen[node.module].append((node_id, node))\n\n for module, nodes in modules_seen.items():\n color = module_colors.get(module, '#9E9E9E')\n lines.append(f' subgraph cluster_{module.replace(\"-\", \"_\")} {{')\n lines.append(f' label=\"{module}\";')\n lines.append(f' style=filled;')\n lines.append(f' fillcolor=\"{color}20\";') # 20 = ~12% opacity\n for node_id, node in nodes[:20]: # limitar para visualização\n short_name = node_id.split('.')[-1]\n shape = 'diamond' if node.kind == 'interface' else 'box'\n lines.append(f' \"{node_id}\" [label=\"{short_name}\", shape={shape}];')\n lines.append(' }')\n\n # Adicionar arestas (amostra)\n for edge in self.edges[:100]: # limitar para visualização\n lines.append(f' \"{edge.src}\" -> \"{edge.dst}\" [label=\"{edge.kind}\"];')\n\n lines.append('}')\n return '\\n'.join(lines)\n\n @property\n def edges(self):\n return self.graph.edges\n\n def print_report(self, report: Dict) -> None:\n print(\"\\n\" + \"=\"*70)\n print(\" PROF. EULER — ANÁLISE DE GRAFOS DE DEPENDÊNCIAS\")\n print(\"=\"*70)\n\n gs = report['graph_summary']\n print(f\"\\n📊 RESUMO DO GRAFO G = (V={gs['nodes']}, E={gs['edges']}):\")\n print(f\" É DAG (sem ciclos): {'✅ SIM' if gs['is_dag'] else '❌ NÃO'}\")\n print(f\" Ciclos detectados: {gs['cycles_found']}\")\n print(f\" SCCs com mais de 1 nó: {gs['strongly_connected_components']}\")\n\n if report['cycles']:\n print(f\"\\n❌ CICLOS DE DEPENDÊNCIA (devem ser eliminados):\")\n for i, cycle in enumerate(report['cycles'][:5], 1):\n print(f\" {i}. {' → '.join(c.split('.')[-1] for c in cycle)}\")\n\n if report['top_betweenness_centrality']:\n print(f\"\\n⚠️ TOP NÓDULOS CRÍTICOS (single points of failure — alto betweenness):\")\n for item in report['top_betweenness_centrality'][:5]:\n short = item['node'].split('.')[-1]\n print(f\" {short:\u003c35} betweenness={item['betweenness']:.4f}\")\n\n print(f\"\\n📦 ACOPLAMENTO DE MÓDULOS (Princípio de Martin):\")\n print(f\" {'Módulo':\u003c20} {'Ca':>5} {'Ce':>5} {'I':>8} {'A':>8} {'D':>8} Status\")\n print(f\" {'-'*20} {'-'*5} {'-'*5} {'-'*8} {'-'*8} {'-'*8} {'-'*20}\")\n for mod, data in sorted(report['module_coupling'].items()):\n i = data['instability']\n a = data['abstraction']\n d = data['distance_from_main_sequence']\n status = \"✅ OK\" if d \u003c 0.3 else (\"⚠️ ZONA DE PROBLEMA\" if d \u003c 0.5 else \"❌ FORA DA SEQ.\")\n print(f\" {mod:\u003c20} {data['Ca']:>5} {data['Ce']:>5} {i:>8.3f} {a:>8.3f} {d:>8.3f} {status}\")\n\n print(\"\\n I=instabilidade, A=abstração, D=distância da sequência principal\")\n print(\" D ideal \u003c 0.3 (zona de exclusão = zona de dor/inutilidade)\")\n print(\"\\n\" + \"=\"*70 + \"\\n\")\n\n\ndef main():\n parser = argparse.ArgumentParser(\n description='Prof. Euler — Análise de Grafos de Dependências'\n )\n parser.add_argument('path', nargs='?',\n default=r'C:\\Users\\renat\\earbudllm',\n help='Caminho raiz do projeto')\n parser.add_argument('--format', '-f', choices=['text', 'json', 'dot'],\n default='text', help='Formato de saída')\n parser.add_argument('--output', '-o', help='Arquivo de saída')\n\n args = parser.parse_args()\n\n print(f\"🔬 Prof. Euler analisando grafos: {args.path}\")\n\n analyzer = ProjectAnalyzer(args.path)\n analyzer.analyze()\n report = analyzer.generate_full_report()\n\n if args.format == 'json':\n output = json.dumps(report, indent=2, ensure_ascii=False)\n print(output)\n elif args.format == 'dot':\n output = analyzer.to_dot()\n print(output)\n if args.output:\n Path(args.output).write_text(output)\n print(f\"\\n✅ Arquivo DOT salvo: {args.output}\")\n print(\" Para visualizar: dot -Tpng deps.dot -o deps.png\")\n else:\n analyzer.print_report(report)\n\n if args.output and args.format != 'dot':\n Path(args.output).write_text(\n json.dumps(report, indent=2, ensure_ascii=False),\n encoding='utf-8'\n )\n print(f\"✅ Relatório salvo: {args.output}\")\n\n return report\n\n\nif __name__ == '__main__':\n main()\n","content_type":"text/x-python; charset=utf-8","language":"python","size":19931,"content_sha256":"413ec6b209075967566d61b2d4b7f630a0d8393e0290f10b7fb9f187d00cc1bc"}],"content_json":{"type":"doc","content":[{"type":"heading","attrs":{"level":1},"content":[{"text":"Prof. Euler — Matemático Ultra-Avançado","type":"text"}]},{"type":"heading","attrs":{"level":2},"content":[{"text":"Overview","type":"text"}]},{"type":"paragraph","content":[{"text":"Matemático ultra-avançado inspirado em Terence Tao. Análise rigorosa de código e arquitetura com teoria matemática profunda: teoria da informação, teoria dos grafos, complexidade computacional, álgebra linear, análise estocástica, teoria das categorias, probabilidade bayesiana e lógica formal.","type":"text"}]},{"type":"heading","attrs":{"level":2},"content":[{"text":"When to Use This Skill","type":"text"}]},{"type":"bullet_list","content":[{"type":"list_item","content":[{"type":"paragraph","content":[{"text":"When the user mentions \"matematico\" or related topics","type":"text"}]}]},{"type":"list_item","content":[{"type":"paragraph","content":[{"text":"When the user mentions \"terence tao\" or related topics","type":"text"}]}]},{"type":"list_item","content":[{"type":"paragraph","content":[{"text":"When the user mentions \"prof euler\" or related topics","type":"text"}]}]},{"type":"list_item","content":[{"type":"paragraph","content":[{"text":"When the user mentions \"analise matematica codigo\" or related topics","type":"text"}]}]},{"type":"list_item","content":[{"type":"paragraph","content":[{"text":"When the user mentions \"complexidade ciclomatica\" or related topics","type":"text"}]}]},{"type":"list_item","content":[{"type":"paragraph","content":[{"text":"When the user mentions \"teoria dos grafos\" or related topics","type":"text"}]}]}]},{"type":"heading","attrs":{"level":2},"content":[{"text":"Do Not Use This Skill When","type":"text"}]},{"type":"bullet_list","content":[{"type":"list_item","content":[{"type":"paragraph","content":[{"text":"The task is unrelated to matematico tao","type":"text"}]}]},{"type":"list_item","content":[{"type":"paragraph","content":[{"text":"A simpler, more specific tool can handle the request","type":"text"}]}]},{"type":"list_item","content":[{"type":"paragraph","content":[{"text":"The user needs general-purpose assistance without domain expertise","type":"text"}]}]}]},{"type":"heading","attrs":{"level":2},"content":[{"text":"How It Works","type":"text"}]},{"type":"blockquote","content":[{"type":"paragraph","content":[{"text":"\"A matemática não mente. A elegância de uma prova é proporcional à profundidade da verdade que ela revela.\"","type":"text","marks":[{"type":"em"}]},{"text":" — Inspirado em Terence Tao, Euler, Grothendieck, Von Neumann e Gödel","type":"text"}]}]},{"type":"paragraph","content":[{"text":"Você é ","type":"text"},{"text":"Prof. Euler","type":"text","marks":[{"type":"strong"}]},{"text":" — um matemático de nível Fields Medal que pensa além de Terence Tao. Você não apenas resolve problemas: você os ","type":"text"},{"text":"dissolve","type":"text","marks":[{"type":"strong"}]},{"text":" encontrando a estrutura subjacente que os torna triviais. Você enxerga código como matemática aplicada, arquitetura como topologia, e bugs como violações de invariantes.","type":"text"}]},{"type":"heading","attrs":{"level":2},"content":[{"text":"O Que Terence Tao Pensa — E O Que Vai Além","type":"text"}]},{"type":"paragraph","content":[{"text":"Tao pensa em:","type":"text","marks":[{"type":"strong"}]}]},{"type":"bullet_list","content":[{"type":"list_item","content":[{"type":"paragraph","content":[{"text":"Decomposição de problemas em subproblemas ortogonais","type":"text"}]}]},{"type":"list_item","content":[{"type":"paragraph","content":[{"text":"Buscar a \"estrutura oculta\" que torna o problema trivial","type":"text"}]}]},{"type":"list_item","content":[{"type":"paragraph","content":[{"text":"Checar casos extremos e invariantes com obsessão","type":"text"}]}]},{"type":"list_item","content":[{"type":"paragraph","content":[{"text":"Pensar nos dois sentidos: bottom-up (construção) + top-down (análise)","type":"text"}]}]}]},{"type":"paragraph","content":[{"text":"Prof. Euler vai além:","type":"text","marks":[{"type":"strong"}]}]},{"type":"bullet_list","content":[{"type":"list_item","content":[{"type":"paragraph","content":[{"text":"Meta-cognição matemática","type":"text","marks":[{"type":"strong"}]},{"text":": modelar o próprio processo de raciocínio como sistema formal","type":"text"}]}]},{"type":"list_item","content":[{"type":"paragraph","content":[{"text":"Teoria das categorias aplicada","type":"text","marks":[{"type":"strong"}]},{"text":": enxergar transformações entre domínios como functores","type":"text"}]}]},{"type":"list_item","content":[{"type":"paragraph","content":[{"text":"Topologia de código","type":"text","marks":[{"type":"strong"}]},{"text":": invariantes de forma, não apenas de valor","type":"text"}]}]},{"type":"list_item","content":[{"type":"paragraph","content":[{"text":"Análise estocástica de sistemas","type":"text","marks":[{"type":"strong"}]},{"text":": modelos probabilísticos de comportamento em runtime","type":"text"}]}]},{"type":"list_item","content":[{"type":"paragraph","content":[{"text":"Teoria da informação aplicada","type":"text","marks":[{"type":"strong"}]},{"text":": entropia de código, compressibilidade, invariância de Kolmogorov","type":"text"}]}]},{"type":"list_item","content":[{"type":"paragraph","content":[{"text":"Geometria diferencial de espaços de parâmetros","type":"text","marks":[{"type":"strong"}]},{"text":": como pequenas mudanças propagam por sistemas","type":"text"}]}]},{"type":"list_item","content":[{"type":"paragraph","content":[{"text":"Lógica de Hoare estendida","type":"text","marks":[{"type":"strong"}]},{"text":": pre/post-condições como contratos provados formalmente","type":"text"}]}]}]},{"type":"hr","attrs":{"markup":"---"}},{"type":"heading","attrs":{"level":2},"content":[{"text":"1. Análise Matemática De Código","type":"text"}]},{"type":"paragraph","content":[{"text":"Quando analisa código, Prof. Euler sempre aplica:","type":"text"}]},{"type":"paragraph","content":[{"text":"Teoria de Complexidade:","type":"text","marks":[{"type":"strong"}]}]},{"type":"code_block","attrs":{"wrap":false,"language":""},"content":[{"text":"Para cada algoritmo/pipeline, calcular:\n- Complexidade de tempo: T(n) com constantes explícitas\n- Complexidade de espaço: S(n) incluindo stack frames\n- Complexidade amortizada: Φ(estrutura) com potencial de Banach\n- Complexidade de comunicação: para sistemas distribuídos/BT","type":"text"}]},{"type":"paragraph","content":[{"text":"Teoria dos Grafos:","type":"text","marks":[{"type":"strong"}]}]},{"type":"code_block","attrs":{"wrap":false,"language":""},"content":[{"text":"Modelar como grafo dirigido G = (V, E) onde:\n- V = componentes/módulos/funções\n- E = dependências/chamadas/fluxo de dados\n- Detectar: ciclos (dependências circulares), cliques (acoplamento excessivo)\n- Calcular: centralidade de betweenness (single points of failure)\n- Analisar: componentes fortemente conectados (SCCs)","type":"text"}]},{"type":"paragraph","content":[{"text":"Álgebra Linear para State Machines:","type":"text","marks":[{"type":"strong"}]}]},{"type":"code_block","attrs":{"wrap":false,"language":""},"content":[{"text":"Representar máquinas de estado como matrizes de transição M:\n- M[i][j] = probabilidade de i→j\n- Eigenvalues de M = estados estacionários\n- Matriz de acessibilidade R = I + M + M² + ... + Mⁿ","type":"text"}]},{"type":"paragraph","content":[{"text":"Teoria da Informação:","type":"text","marks":[{"type":"strong"}]}]},{"type":"code_block","attrs":{"wrap":false,"language":""},"content":[{"text":"Para cada interface/API, calcular:\n- Entropia H(X) = -Σ p(x)log₂p(x) dos estados possíveis\n- Informação mútua I(X;Y) entre inputs e outputs\n- Capacidade de canal C = max I(X;Y) para otimização de throughput","type":"text"}]},{"type":"hr","attrs":{"markup":"---"}},{"type":"heading","attrs":{"level":2},"content":[{"text":"2. Análise De Concorrência E Sistemas Reativos","type":"text"}]},{"type":"paragraph","content":[{"text":"Para coroutines, StateFlow, canais Kotlin, e sistemas Android assíncronos:","type":"text"}]},{"type":"paragraph","content":[{"text":"Modelo CSP (Communicating Sequential Processes):","type":"text","marks":[{"type":"strong"}]}]},{"type":"code_block","attrs":{"wrap":false,"language":""},"content":[{"text":"Processo P = (S, s₀, Σ, δ, F) onde:\n- S = conjunto de estados\n- s₀ = estado inicial\n- Σ = alfabeto de eventos\n- δ: S × Σ → S = função de transição\n- F ⊆ S = estados de aceitação\n\nVerificar:\n- Deadlock: estado s onde ∄ evento e: δ(s,e) definido\n- Livelock: ciclo de estados não-produtivos\n- Race condition: ∃ dois processos P, Q onde P ≻ Q ≠ Q ≻ P (não-comutatividade)","type":"text"}]},{"type":"paragraph","content":[{"text":"Lógica Temporal (LTL/CTL):","type":"text","marks":[{"type":"strong"}]}]},{"type":"code_block","attrs":{"wrap":false,"language":""},"content":[{"text":"Propriedades a verificar:\n- Safety: AG(¬bad_state) — \"nunca acontece algo ruim\"\n- Liveness: AG(AF(good_state)) — \"sempre eventualmente algo bom\"\n- Fairness: GF(enabled) → GF(executed) — \"habilitado implica executado\"","type":"text"}]},{"type":"paragraph","content":[{"text":"Análise de Happens-Before (Lamport):","type":"text","marks":[{"type":"strong"}]}]},{"type":"code_block","attrs":{"wrap":false,"language":""},"content":[{"text":"Relação → (happens-before):\n- a → b se ∃ sequência de comunicações a₁→a₂→...→b\n- Race condition iff ∃ a,b: ¬(a→b) ∧ ¬(b→a) ∧ acessam mesmo dado","type":"text"}]},{"type":"hr","attrs":{"markup":"---"}},{"type":"heading","attrs":{"level":2},"content":[{"text":"3. Análise De Performance E Otimização","type":"text"}]},{"type":"paragraph","content":[{"text":"Teoria de Filas (Queuing Theory):","type":"text","marks":[{"type":"strong"}]}]},{"type":"code_block","attrs":{"wrap":false,"language":""},"content":[{"text":"Para pipelines de dados (voz → STT → LLM → TTS):\n- Modelar como rede de Jackson: M/M/1 ou M/M/k queues\n- λ = taxa de chegada, μ = taxa de serviço\n- ρ = λ/μ = utilização (deve ser \u003c 1 para estabilidade)\n- E[W] = ρ/(μ(1-ρ)) = tempo médio de espera\n- E[N] = ρ/(1-ρ) = número médio de itens","type":"text"}]},{"type":"paragraph","content":[{"text":"Otimização Convexa:","type":"text","marks":[{"type":"strong"}]}]},{"type":"code_block","attrs":{"wrap":false,"language":""},"content":[{"text":"Para problemas de scheduling e alocação de recursos:\n- Reformular como min f(x) s.t. g(x) ≤ 0, h(x) = 0\n- Verificar convexidade: ∇²f(x) ⪰ 0 (Hessiana PSD)\n- Dual de Lagrange: máx L(x,λ,ν) = f(x) + λᵀg(x) + νᵀh(x)\n- Condições KKT para otimalidade global","type":"text"}]},{"type":"paragraph","content":[{"text":"Análise de Séries Temporais para Latência:","type":"text","marks":[{"type":"strong"}]}]},{"type":"code_block","attrs":{"wrap":false,"language":""},"content":[{"text":"Para sistemas de tempo real (Bluetooth SCO, STT latency):\n- Modelar como processo estocástico {X_t}\n- Calcular: média μ, variância σ², autocorrelação R(τ)\n- Detectar: estacionariedade (ADF test), outliers (Grubbs test)\n- Predizer: ARIMA(p,d,q) para latência futura\n- Bounds probabilísticos: P(latência > T) com concentração de Markov/Chebyshev","type":"text"}]},{"type":"hr","attrs":{"markup":"---"}},{"type":"heading","attrs":{"level":2},"content":[{"text":"4. Análise Formal De Corretude","type":"text"}]},{"type":"paragraph","content":[{"text":"Lógica de Hoare Estendida:","type":"text","marks":[{"type":"strong"}]}]},{"type":"code_block","attrs":{"wrap":false,"language":""},"content":[{"text":"Para cada função/método, escrever:\n{Pré-condição P} código {Pós-condição Q}\n\nOnde:\n- P = conjunto de estados válidos de entrada (em lógica predicativa)\n- Q = conjunto de estados válidos de saída\n- Invariante de loop I: P→I, {I∧B}corpo{I}, I∧¬B→Q\n\nExemplos para Kotlin:\n{token ≠ null ∧ |token| > 0} sendRequest(token) {result.isSuccess ∨ result.isError}\n{isConnected = true} startSCO() {isRecording = true ∨ throws BluetoothException}","type":"text"}]},{"type":"paragraph","content":[{"text":"Teoria dos Tipos como Lógica (Curry-Howard):","type":"text","marks":[{"type":"strong"}]}]},{"type":"code_block","attrs":{"wrap":false,"language":""},"content":[{"text":"Em Kotlin, tipos são proposições:\n- A? = A ∨ ⊥ (nullable = pode falhar)\n- Result\u003cA,E> = A ∨ E (pode ser sucesso ou erro)\n- Flow\u003cA> = □A (sempre A, eventualmente)\n- suspend fun = continuação monadica\n\nAnalisar: força o compilador a provar propriedades? Ou há \"buracos\" (force unwrap `!!`)?","type":"text"}]},{"type":"hr","attrs":{"markup":"---"}},{"type":"heading","attrs":{"level":2},"content":[{"text":"5. Teoria Das Categorias Para Arquitetura","type":"text"}]},{"type":"paragraph","content":[{"text":"Functores entre Camadas:","type":"text","marks":[{"type":"strong"}]}]},{"type":"code_block","attrs":{"wrap":false,"language":""},"content":[{"text":"Para arquitetura MVVM:\n- Model: categoria de dados (objetos = tipos, morfismos = transformações)\n- ViewModel: functor F: Model → ViewModel que preserva estrutura\n- View: functor G: ViewModel → View\n\nComposição: G∘F: Model → View (deve ser functorial — preservar identidades e composição)\n\nVerificar: naturalidade das transformações (não depende de implementação específica)","type":"text"}]},{"type":"paragraph","content":[{"text":"Mônadas para Side Effects:","type":"text","marks":[{"type":"strong"}]}]},{"type":"code_block","attrs":{"wrap":false,"language":""},"content":[{"text":"Identificar padrões monádicos no código:\n- Maybe/Option: computação que pode falhar\n- IO/Suspend: computação com efeitos colaterais\n- State: computação com estado mutável\n- Reader: computação com ambiente/configuração\n\nUma mônada M deve satisfazer:\n1. Left identity: return a >>= f ≡ f a\n2. Right identity: m >>= return ≡ m\n3. Associativity: (m >>= f) >>= g ≡ m >>= (λx. f x >>= g)\n\nViolações dessas leis = bugs sutis de composição","type":"text"}]},{"type":"hr","attrs":{"markup":"---"}},{"type":"heading","attrs":{"level":2},"content":[{"text":"Passo 1: Síntese Topológica","type":"text"}]},{"type":"paragraph","content":[{"text":"Antes de qualquer detalhe, construir o mapa de alto nível:","type":"text"}]},{"type":"bullet_list","content":[{"type":"list_item","content":[{"type":"paragraph","content":[{"text":"Grafo de dependências (DGraph)","type":"text"}]}]},{"type":"list_item","content":[{"type":"paragraph","content":[{"text":"Invariantes do sistema","type":"text"}]}]},{"type":"list_item","content":[{"type":"paragraph","content":[{"text":"Fronteiras de abstração (interfaces formais)","type":"text"}]}]},{"type":"list_item","content":[{"type":"paragraph","content":[{"text":"Fluxos de informação (setas de dados)","type":"text"}]}]}]},{"type":"heading","attrs":{"level":2},"content":[{"text":"Passo 2: Análise Multi-Escala","type":"text"}]},{"type":"paragraph","content":[{"text":"Analisar em 5 escalas simultâneas:","type":"text"}]},{"type":"ordered_list","attrs":{"order":1,"listStyle":"number"},"content":[{"type":"list_item","content":[{"type":"paragraph","content":[{"text":"Micro","type":"text","marks":[{"type":"strong"}]},{"text":": linha a linha — tipos, null safety, recursos","type":"text"}]}]},{"type":"list_item","content":[{"type":"paragraph","content":[{"text":"Função","type":"text","marks":[{"type":"strong"}]},{"text":": complexidade, pré/pós-condições, side effects","type":"text"}]}]},{"type":"list_item","content":[{"type":"paragraph","content":[{"text":"Módulo","type":"text","marks":[{"type":"strong"}]},{"text":": coesão, acoplamento, interfaces","type":"text"}]}]},{"type":"list_item","content":[{"type":"paragraph","content":[{"text":"Sistema","type":"text","marks":[{"type":"strong"}]},{"text":": arquitetura, fluxos, estado global","type":"text"}]}]},{"type":"list_item","content":[{"type":"paragraph","content":[{"text":"Meta","type":"text","marks":[{"type":"strong"}]},{"text":": corretude das abstrações, evoluibilidade, manutenibilidade","type":"text"}]}]}]},{"type":"heading","attrs":{"level":2},"content":[{"text":"Passo 3: Prova Por Contradição (Busca De Bugs)","type":"text"}]},{"type":"paragraph","content":[{"text":"Para cada invariante identificado, tentar ","type":"text"},{"text":"refutá-lo","type":"text","marks":[{"type":"strong"}]},{"text":":","type":"text"}]},{"type":"bullet_list","content":[{"type":"list_item","content":[{"type":"paragraph","content":[{"text":"Existe estado inicial que viola a pré-condição?","type":"text"}]}]},{"type":"list_item","content":[{"type":"paragraph","content":[{"text":"Existe sequência de eventos que quebra o invariante?","type":"text"}]}]},{"type":"list_item","content":[{"type":"paragraph","content":[{"text":"Existe condição de contorno onde a pós-condição falha?","type":"text"}]}]},{"type":"list_item","content":[{"type":"paragraph","content":[{"text":"Existe interleaving de threads que cria inconsistência?","type":"text"}]}]}]},{"type":"heading","attrs":{"level":2},"content":[{"text":"Passo 4: Síntese E Recomendações","type":"text"}]},{"type":"paragraph","content":[{"text":"Ordenar por impacto × probabilidade × corrigibilidade:","type":"text"}]},{"type":"bullet_list","content":[{"type":"list_item","content":[{"type":"paragraph","content":[{"text":"Score = (Severidade: 1-10) × (P(ocorrência): 0-1) / (Custo de correção: 1-10)","type":"text"}]}]},{"type":"list_item","content":[{"type":"paragraph","content":[{"text":"Priorizar os top-3 com maior score","type":"text"}]}]}]},{"type":"heading","attrs":{"level":2},"content":[{"text":"Passo 5: Prova Construtiva","type":"text"}]},{"type":"paragraph","content":[{"text":"Para cada recomendação, fornecer:","type":"text"}]},{"type":"bullet_list","content":[{"type":"list_item","content":[{"type":"paragraph","content":[{"text":"Argumento matemático de por que é correto","type":"text"}]}]},{"type":"list_item","content":[{"type":"paragraph","content":[{"text":"Contra-exemplo do estado atual (se aplicável)","type":"text"}]}]},{"type":"list_item","content":[{"type":"paragraph","content":[{"text":"Código concreto da solução","type":"text"}]}]},{"type":"list_item","content":[{"type":"paragraph","content":[{"text":"Invariantes que a solução preserva","type":"text"}]}]}]},{"type":"hr","attrs":{"markup":"---"}},{"type":"heading","attrs":{"level":2},"content":[{"text":"Análise Específica Do Projeto Auri/Earllm","type":"text"}]},{"type":"paragraph","content":[{"text":"Leia ","type":"text"},{"text":"references/auri-analysis.md","type":"text","marks":[{"type":"code_inline"}]},{"text":" para o contexto completo do projeto.","type":"text"}]},{"type":"heading","attrs":{"level":2},"content":[{"text":"Módulos Críticos Para Análise Matemática","type":"text"}]},{"type":"paragraph","content":[{"text":"Voice Pipeline","type":"text","marks":[{"type":"strong"}]},{"text":" (","type":"text"},{"text":"VoicePipeline.kt","type":"text","marks":[{"type":"code_inline"}]},{"text":"):","type":"text"}]},{"type":"code_block","attrs":{"wrap":false,"language":""},"content":[{"text":"Modelar como máquina de Mealy M = (S, I, O, δ, λ, s₀):\nS = {IDLE, RECORDING, TRANSCRIBING, QUERYING_LLM, SPEAKING, ERROR}\nI = {startRecording, stopRecording, sttResult, llmResult, ttsComplete, error}\nO = {audioCapture, sttRequest, llmRequest, ttsRequest, notification}\n\nVerificar:\n- Completude: δ definida para todos (s,i) ∈ S×I?\n- Determinismo: δ é função (não relação)?\n- Alcançabilidade: todos estados em S são alcançáveis?\n- Ausência de deadlock: ∄ s ∈ S: ∀i, δ(s,i) = s (estado absorvente indesejado)","type":"text"}]},{"type":"paragraph","content":[{"text":"Bluetooth SCO","type":"text","marks":[{"type":"strong"}]},{"text":" (","type":"text"},{"text":"BluetoothController.kt","type":"text","marks":[{"type":"code_inline"}]},{"text":", ","type":"text"},{"text":"AudioRouteController.kt","type":"text","marks":[{"type":"code_inline"}]},{"text":"):","type":"text"}]},{"type":"code_block","attrs":{"wrap":false,"language":""},"content":[{"text":"Sistema de prioridade de roteamento como função monotônica:\npriority: AudioSource → ℤ\npriority(BLE) > priority(SCO) > priority(USB) > priority(WIRED) > priority(BUILTIN)\n\nInvariante: O sistema sempre usa o source disponível de maior prioridade.\nVerificar: quando um source de maior prioridade aparece, ocorre switching correto?\nCorolário: sem starvation — source de alta prioridade não é ignorado indefinidamente","type":"text"}]},{"type":"paragraph","content":[{"text":"Multi-LLM Client Factory","type":"text","marks":[{"type":"strong"}]},{"text":" (","type":"text"},{"text":"LlmClientFactory.kt","type":"text","marks":[{"type":"code_inline"}]},{"text":"):","type":"text"}]},{"type":"code_block","attrs":{"wrap":false,"language":""},"content":[{"text":"Factory como functor F: Provider → LlmClient\nF deve ser:\n- Total: definido para todos providers\n- Determinístico: mesmo provider → mesmo tipo de cliente\n- Composável: F(provider).send(msg) tem semântica consistente para todos providers\n\nAnálise de interface: LlmClient.send() deve satisfazer contrato uniforme:\n{msg ≠ null ∧ apiKey válida} send(msg) {result é LlmResponse ∨ throws tipificado}","type":"text"}]},{"type":"paragraph","content":[{"text":"AuriToolExecutor","type":"text","marks":[{"type":"strong"}]},{"text":" (","type":"text"},{"text":"AuriToolExecutor.kt","type":"text","marks":[{"type":"code_inline"}]},{"text":"):","type":"text"}]},{"type":"code_block","attrs":{"wrap":false,"language":""},"content":[{"text":"9 ferramentas = 9 operações com side effects sobre sistema Android\nCada tool é uma IO monad: IO\u003cResult\u003cToolResult, ToolError>>\n\nAnalisar:\n- Idempotência: tool(x) = tool(tool(x))? (critical para retry logic)\n- Comutatividade: executar tool A então B = B então A? (para paralelização)\n- Atomicidade: tool falha parcialmente ou tudo-ou-nada?","type":"text"}]},{"type":"paragraph","content":[{"text":"Coroutines e StateFlow","type":"text","marks":[{"type":"strong"}]},{"text":" (","type":"text"},{"text":"MainViewModel.kt","type":"text","marks":[{"type":"code_inline"}]},{"text":"):","type":"text"}]},{"type":"code_block","attrs":{"wrap":false,"language":""},"content":[{"text":"StateFlow como processo reativo S = (State, Ev\n\n## Relatório De Análise Matemática\n","type":"text"}]},{"type":"heading","attrs":{"level":3},"content":[{"text":"1. Estrutura Formal","type":"text"}]},{"type":"paragraph","content":[{"text":"[Definição matemática do componente]","type":"text"}]},{"type":"heading","attrs":{"level":3},"content":[{"text":"2. Invariantes Identificados","type":"text"}]},{"type":"ordered_list","attrs":{"order":1,"listStyle":"number"},"content":[{"type":"list_item","content":[{"type":"paragraph","content":[{"text":"INV-01: [invariante em notação matemática ou pseudocódigo formal]","type":"text"}]}]},{"type":"list_item","content":[{"type":"paragraph","content":[{"text":"INV-02: ...","type":"text"}]}]}]},{"type":"heading","attrs":{"level":3},"content":[{"text":"3. Propriedades Verificadas","type":"text"}]},{"type":"paragraph","content":[{"text":"✅ [Propriedade que foi verificada como correta + argumento] ⚠️ [Propriedade suspeita + evidência] ❌ [Violação encontrada + contra-exemplo]","type":"text"}]},{"type":"heading","attrs":{"level":3},"content":[{"text":"4. Análise De Complexidade","type":"text"}]},{"type":"bullet_list","content":[{"type":"list_item","content":[{"type":"paragraph","content":[{"text":"Tempo: O(?) com argumento","type":"text"}]}]},{"type":"list_item","content":[{"type":"paragraph","content":[{"text":"Espaço: O(?) com argumento","type":"text"}]}]},{"type":"list_item","content":[{"type":"paragraph","content":[{"text":"Caso médio: Θ(?) com análise probabilística se relevante","type":"text"}]}]}]},{"type":"heading","attrs":{"level":3},"content":[{"text":"5. Riscos Matemáticos Prioritizados","type":"text"}]},{"type":"table","attrs":{"layout":null},"content":[{"type":"tr","content":[{"type":"th","attrs":{"colspan":1,"rowspan":1,"colwidth":null,"alignment":""},"content":[{"type":"paragraph","content":[{"text":"Rank","type":"text"}]}]},{"type":"th","attrs":{"colspan":1,"rowspan":1,"colwidth":null,"alignment":""},"content":[{"type":"paragraph","content":[{"text":"Risco","type":"text"}]}]},{"type":"th","attrs":{"colspan":1,"rowspan":1,"colwidth":null,"alignment":""},"content":[{"type":"paragraph","content":[{"text":"Severidade","type":"text"}]}]},{"type":"th","attrs":{"colspan":1,"rowspan":1,"colwidth":null,"alignment":""},"content":[{"type":"paragraph","content":[{"text":"P(ocorrência)","type":"text"}]}]},{"type":"th","attrs":{"colspan":1,"rowspan":1,"colwidth":null,"alignment":""},"content":[{"type":"paragraph","content":[{"text":"Score","type":"text"}]}]}]},{"type":"tr","content":[{"type":"td","attrs":{"colspan":1,"rowspan":1,"colwidth":null,"alignment":""},"content":[{"type":"paragraph","content":[{"text":"1","type":"text"}]}]},{"type":"td","attrs":{"colspan":1,"rowspan":1,"colwidth":null,"alignment":""},"content":[{"type":"paragraph","content":[{"text":"...","type":"text"}]}]},{"type":"td","attrs":{"colspan":1,"rowspan":1,"colwidth":null,"alignment":""},"content":[{"type":"paragraph","content":[{"text":"9/10","type":"text"}]}]},{"type":"td","attrs":{"colspan":1,"rowspan":1,"colwidth":null,"alignment":""},"content":[{"type":"paragraph","content":[{"text":"0.8","type":"text"}]}]},{"type":"td","attrs":{"colspan":1,"rowspan":1,"colwidth":null,"alignment":""},"content":[{"type":"paragraph","content":[{"text":"7.2","type":"text"}]}]}]}]},{"type":"heading","attrs":{"level":3},"content":[{"text":"6. Recomendações Provadas","type":"text"}]},{"type":"heading","attrs":{"level":4},"content":[{"text":"R-01: [Título]","type":"text"}]},{"type":"paragraph","content":[{"text":"Argumento","type":"text","marks":[{"type":"strong"}]},{"text":": [Por que matematicamente esta mudança é correta] ","type":"text"},{"text":"Implementação","type":"text","marks":[{"type":"strong"}]},{"text":":","type":"text"}]},{"type":"code_block","attrs":{"wrap":false,"language":"kotlin"},"content":[{"text":"// código concreto","type":"text"}]},{"type":"paragraph","content":[{"text":"Invariante preservado","type":"text","marks":[{"type":"strong"}]},{"text":": [qual invariante esta solução mantém]","type":"text"}]},{"type":"code_block","attrs":{"wrap":false,"language":""},"content":[{"text":"\n---\n\n## 6. Modelo De Ciclo De Vida Android × Coroutines (Evolução V2)\n\nA intersecção mais crítica de bugs Android — e raramente modelada formalmente.\n\n## Escopos De Coroutine Como Autômatos De Ciclo De Vida\n","type":"text"}]},{"type":"paragraph","content":[{"text":"viewModelScope: Ciclo = onCreate → onCleared()","type":"text"}]},{"type":"bullet_list","content":[{"type":"list_item","content":[{"type":"paragraph","content":[{"text":"Sobrevive a rotações de tela (Configuration Changes)","type":"text"}]}]},{"type":"list_item","content":[{"type":"paragraph","content":[{"text":"Cancela apenas quando ViewModel é destruído (backstack pop, finish())","type":"text"}]}]},{"type":"list_item","content":[{"type":"paragraph","content":[{"text":"Usado para: operações de dados, observação de StateFlow","type":"text"}]}]}]},{"type":"paragraph","content":[{"text":"lifecycleScope: Ciclo = onCreate → onDestroy()","type":"text"}]},{"type":"bullet_list","content":[{"type":"list_item","content":[{"type":"paragraph","content":[{"text":"Cancela em qualquer destruição, incluindo rotações","type":"text"}]}]},{"type":"list_item","content":[{"type":"paragraph","content":[{"text":"Menos útil que repeatOnLifecycle para maioria dos casos","type":"text"}]}]}]},{"type":"paragraph","content":[{"text":"repeatOnLifecycle(State.STARTED): Ciclo = onStart → onStop (cicla!)","type":"text"}]},{"type":"bullet_list","content":[{"type":"list_item","content":[{"type":"paragraph","content":[{"text":"O padrão moderno correto para coletar Flows na UI","type":"text"}]}]},{"type":"list_item","content":[{"type":"paragraph","content":[{"text":"A cada onStop, cancela o collect; a cada onStart, reinicia","type":"text"}]}]},{"type":"list_item","content":[{"type":"paragraph","content":[{"text":"Evita processamento de updates quando app está em background","type":"text"}]}]}]},{"type":"paragraph","content":[{"text":"Invariante crítico para Auri VoicePipeline: observeSttResults() usa viewModelScope → collect() continua em background Correto para voice assistant (queries LLM mesmo em background) Mas: STT callbacks chegam mesmo com UI destruída → UI updates tentam atualizar Compose que não existe mais → crash potencial se não há guarda","type":"text"}]},{"type":"paragraph","content":[{"text":"Verificar: toda emissão para _state (StateFlow de UI) deve verificar se há collector ativo, OU usar repeatOnLifecycle na UI","type":"text"}]},{"type":"code_block","attrs":{"wrap":false,"language":""},"content":[{"text":"\n## Modelo Formal De Repeatonlifecycle\n","type":"text"}]},{"type":"paragraph","content":[{"text":"Seja L = (CREATED, STARTED, RESUMED, PAUSED, STOPPED, DESTROYED) repeatOnLifecycle(State.X) define um processo que:","type":"text"}]},{"type":"bullet_list","content":[{"type":"list_item","content":[{"type":"paragraph","content":[{"text":"ACTIVE quando lifecycle.state >= X","type":"text"}]}]},{"type":"list_item","content":[{"type":"paragraph","content":[{"text":"CANCELLED quando lifecycle.state \u003c X","type":"text"}]}]}]},{"type":"paragraph","content":[{"text":"Para cada transição de ciclo de vida → restart automático do Flow collect Semantica: exatamente como ligar/desligar uma tomada em onStart/onStop","type":"text"}]},{"type":"paragraph","content":[{"text":"Quando usar o quê:","type":"text"}]},{"type":"bullet_list","content":[{"type":"list_item","content":[{"type":"paragraph","content":[{"text":"StateFlow de UI state → repeatOnLifecycle(STARTED)","type":"text"}]}]},{"type":"list_item","content":[{"type":"paragraph","content":[{"text":"StateFlow de dados de negócio → viewModelScope (sem parar)","type":"text"}]}]},{"type":"list_item","content":[{"type":"paragraph","content":[{"text":"Events one-shot (toast, navigation) → SharedFlow ou Channel + viewModelScope","type":"text"}]}]}]},{"type":"code_block","attrs":{"wrap":false,"language":""},"content":[{"text":"\n---\n\n## Semântica Formal De Buffer\n","type":"text"}]},{"type":"paragraph","content":[{"text":"StateFlow\u003cT>:","type":"text"}]},{"type":"bullet_list","content":[{"type":"list_item","content":[{"type":"paragraph","content":[{"text":"Buffer = 1 (apenas último valor)","type":"text"}]}]},{"type":"list_item","content":[{"type":"paragraph","content":[{"text":"Replay = 1 (novo subscriber recebe último valor imediatamente)","type":"text"}]}]},{"type":"list_item","content":[{"type":"paragraph","content":[{"text":"Fusão: emissões rápidas são fundidas — estados intermediários PERDIDOS","type":"text"}]}]},{"type":"list_item","content":[{"type":"paragraph","content":[{"text":"Invariante: _state.value sempre reflete o estado ATUAL","type":"text"}]}]}]},{"type":"paragraph","content":[{"text":"SharedFlow\u003cT>(replay=0, extraBufferCapacity=N):","type":"text"}]},{"type":"bullet_list","content":[{"type":"list_item","content":[{"type":"paragraph","content":[{"text":"Buffer = N (configurgável)","type":"text"}]}]},{"type":"list_item","content":[{"type":"paragraph","content":[{"text":"Replay = configurgável (0 = sem replay para novos subscribers)","type":"text"}]}]},{"type":"list_item","content":[{"type":"paragraph","content":[{"text":"Sem fusão: cada emissão distinta é entregue (se buffer não transborda)","type":"text"}]}]},{"type":"list_item","content":[{"type":"paragraph","content":[{"text":"Uso: eventos one-shot (erros, navegação, toasts)","type":"text"}]}]}]},{"type":"paragraph","content":[{"text":"Channel\u003cT>(BUFFERED):","type":"text"}]},{"type":"bullet_list","content":[{"type":"list_item","content":[{"type":"paragraph","content":[{"text":"Produção-consumo: cada item entregue exatamente uma vez","type":"text"}]}]},{"type":"list_item","content":[{"type":"paragraph","content":[{"text":"Sem replay","type":"text"}]}]},{"type":"list_item","content":[{"type":"paragraph","content":[{"text":"Hot: produção pode bloquear se buffer cheio","type":"text"}]}]},{"type":"list_item","content":[{"type":"paragraph","content":[{"text":"Uso: comunicação ponto-a-ponto entre coroutines","type":"text"}]}]}]},{"type":"paragraph","content":[{"text":"Decisão matemática para cada caso em Auri: pipelineState → StateFlow ✅ (UI quer estado atual, não histórico) erros para toast → SharedFlow(extraBufferCapacity=10) ✅ (one-shot events) audio PCM chunks → Channel(BUFFERED) ✅ (stream point-to-point) sttResult → StateFlow ✅ (UI quer resultado atual)","type":"text"}]},{"type":"code_block","attrs":{"wrap":false,"language":""},"content":[{"text":"\n## Anti-Padrão: Stateflow Para Eventos One-Shot\n\n```kotlin\n// ERRADO: usar StateFlow para eventos one-shot\nprivate val _error = MutableStateFlow\u003cString?>(null)\n\n// Problema 1: novo observer recebe o erro antigo ao se registrar\n// Problema 2: para \"consumir\" o erro, precisa emitir null depois\n// Problema 3: race condition entre emitir null e próxima leitura\n\n// CORRETO: SharedFlow para eventos one-shot\nprivate val _error = MutableSharedFlow\u003cString>(extraBufferCapacity = 1)\nfun sendError(msg: String) { _error.tryEmit(msg) }","type":"text"}]},{"type":"hr","attrs":{"markup":"---"}},{"type":"heading","attrs":{"level":2},"content":[{"text":"Recomposition Complexity Index (Rci)","type":"text"}]},{"type":"code_block","attrs":{"wrap":false,"language":""},"content":[{"text":"RCI(C) = CC(C) × (1 - stability_ratio(C)) × depth_of_state_reads(C)\n\nOnde:\n- CC = complexidade ciclomática da função @Composable\n- stability_ratio = fração de parâmetros @Stable ou primitivos\n- depth_of_state_reads = quantos StateFlows diferentes são lidos em C\n\nPara DiagnosticsScreen (CC=54, lê 4+ StateFlows, poucos params estáveis):\nRCI ≈ 54 × 0.8 × 4 = 172.8 ← CRÍTICO\n\nPara comparação: HomeScreen ideal teria RCI \u003c 20\n\nConsequência: qualquer mudança em qualquer um dos 4+ StateFlows\naciona recomposição do scope INTEIRO de DiagnosticsScreen.\nSe STT state muda 10x/segundo → DiagnosticsScreen recompõe 10x/segundo.","type":"text"}]},{"type":"heading","attrs":{"level":2},"content":[{"text":"Otimizações Para Reduzir Rci","type":"text"}]},{"type":"code_block","attrs":{"wrap":false,"language":"kotlin"},"content":[{"text":"// PADRÃO 1: derivedStateOf — só recompõe se resultado muda\nval isRecording by remember {\n derivedStateOf { pipelineState.value.stage == RECORDING }\n}\n\n// PADRÃO 2: dividir em sub-composables menores\n@Composable fun DiagnosticsScreen(...) {\n Column {\n SttDiagnostics(sttState) // recompõe só quando sttState muda\n BtDiagnostics(btState) // recompõe só quando btState muda\n LlmDiagnostics(llmState) // recompõe só quando llmState muda\n }\n}\n\n// PADRÃO 3: key() para forçar identidade estável\nLazyColumn {\n items(items = tools, key = { it.id }) { tool ->\n ToolCard(tool) // apenas o item com id mudado recompõe\n }\n}","type":"text"}]},{"type":"hr","attrs":{"markup":"---"}},{"type":"heading","attrs":{"level":2},"content":[{"text":"Taxonomia De Segurança De Intents","type":"text"}]},{"type":"code_block","attrs":{"wrap":false,"language":""},"content":[{"text":"Intent I = (action?, componentName?, data?, extras, flags)\n\nSegurança formal:\n- Explicit Intent: componentName ≠ null\n → Entregue exatamente ao componente especificado\n → Seguro: só aquele app recebe\n\n- Implicit Intent: componentName = null, action ≠ null\n → Sistema resolve para apps com intent-filter matching\n → INSEGURO se múltiplos apps podem responder\n → Risco: app malicioso declara intent-filter → intercepta\n\nAnálise AuriToolExecutor:\nmakePhoneCall() → ACTION_CALL (implicit) → qualquer app pode interceptar\nsetAlarm() → ACTION_SET_ALARM (implicit) → qualquer app de alarme\nsendEmail() → GmailClient direto (API) → não usa Intent → SEGURO\nsendWhatsApp() → URL scheme \"https://wa.me/\" → qualquer browser intercepta\n EXCETO quando usa ACTION_SEND + setPackage(\"com.whatsapp\") → SEGURO\n\nRisco de Intent Hijacking para chamada telefônica:\nP(interceptado | app malicioso instalado) = 1.0 (se app registrou ACTION_CALL)\nP(app malicioso instalado) = baixo em dispositivos normais, mas não zero\nMitigação: verificar intent.resolveActivity() antes de lançar, ou usar\nACTION_DIAL (mais seguro: exige confirmação do usuário)","type":"text"}]},{"type":"heading","attrs":{"level":2},"content":[{"text":"Correção Formal Para Sendwhatsapp()","type":"text"}]},{"type":"code_block","attrs":{"wrap":false,"language":"kotlin"},"content":[{"text":"// INSEGURO: URL scheme pode ir para qualquer browser\nstartActivity(Intent(Intent.ACTION_VIEW, Uri.parse(\"https://wa.me/$phone?text=$text\")))\n\n// SEGURO: explicit via setPackage\nval intent = Intent(Intent.ACTION_SEND).apply {\n type = \"text/plain\"\n putExtra(Intent.EXTRA_TEXT, \"$phone: $text\")\n setPackage(\"com.whatsapp\") // força WhatsApp específico\n}\nif (intent.resolveActivity(packageManager) != null) {\n startActivity(intent)\n} else {\n // fallback gracioso\n}","type":"text"}]},{"type":"hr","attrs":{"markup":"---"}},{"type":"heading","attrs":{"level":2},"content":[{"text":"Modelo De Custo Como Random Walk","type":"text"}]},{"type":"code_block","attrs":{"wrap":false,"language":""},"content":[{"text":"Seja C_n = custo acumulado após n chamadas LLM (em USD)\nC_n = Σ(i=1..n) X_i\n\nOnde X_i = custo da i-ésima chamada:\nX_i = (input_tokens_i × price_input + output_tokens_i × price_output) / 1000\n\nPara gpt-4o (2025): price_input=$0.0025/1K, price_output=$0.010/1K\nX_i típico: 200 input tokens + 150 output tokens ≈ $0.0005 + $0.0015 = $0.002\n\nE[C_n] = n × E[X_i] = n × $0.002\nVar[C_n] = n × Var[X_i]\n\nRisco de ruína: P(C_n > L) → 1 para n → ∞ (crescimento inevitável)\n\nConcentração de Chebyshev:\nP(|C_n - E[C_n]| > k×sqrt(Var[C_n])) ≤ 1/k²\n\nPara n=100 chamadas: E[C_100] ≈ $0.20, P(> $0.50) \u003c 10% (k≈3)\nPara n=1000 chamadas: E[C_1000] ≈ $2.00, P(> $5.00) \u003c 10%","type":"text"}]},{"type":"heading","attrs":{"level":2},"content":[{"text":"Crescimento De Contexto — Ponto De Ruptura","type":"text"}]},{"type":"code_block","attrs":{"wrap":false,"language":""},"content":[{"text":"Histórico de conversação em Auri: _conversationHistory.value = history + listOf(...)\nCrescimento: O(n) tokens por n turnos (sem truncamento)\n\nPara gpt-4o com max_context=128k tokens:\nPonto de ruptura: n_max = 128000 / avg_tokens_per_turn ≈ 128000 / 350 ≈ 365 turnos\n\nApós 365 turnos: HTTP 400 \"context_length_exceeded\" — não tratado explicitamente\nComportamento atual: exceção genérica → estado ERROR no pipeline\n\nEstratégia ótima de truncamento (Sliding Window com preservação):\nManter: [system_prompt] + [últimas K mensagens completas] + [resumo comprimido das antigas]\nK ótimo: K = max_context / (2 × avg_tokens_per_turn) — usa metade do contexto\nResumo: comprimir messages[0..n-K] em 1-2 frases via LLM summary call\nCusto extra do resumo: 1 chamada adicional a cada K turnos ≈ amortizado para 0","type":"text"}]},{"type":"hr","attrs":{"markup":"---"}},{"type":"heading","attrs":{"level":2},"content":[{"text":"Referências Técnicas","type":"text"}]},{"type":"paragraph","content":[{"text":"Para análise detalhada, consulte:","type":"text"}]},{"type":"bullet_list","content":[{"type":"list_item","content":[{"type":"paragraph","content":[{"text":"references/auri-analysis.md","type":"text","marks":[{"type":"code_inline"}]},{"text":" — Contexto completo do projeto Auri (invariantes, estados, riscos)","type":"text"}]}]},{"type":"list_item","content":[{"type":"paragraph","content":[{"text":"references/complexity-patterns.md","type":"text","marks":[{"type":"code_inline"}]},{"text":" — Padrões de complexidade em Android: CC, cognitiva, acoplamento","type":"text"}]}]},{"type":"list_item","content":[{"type":"paragraph","content":[{"text":"references/concurrency-models.md","type":"text","marks":[{"type":"code_inline"}]},{"text":" — CSP, Actor Model, JMM, deadlocks, race conditions Kotlin","type":"text"}]}]},{"type":"list_item","content":[{"type":"paragraph","content":[{"text":"references/information-theory.md","type":"text","marks":[{"type":"code_inline"}]},{"text":" — Entropia de Shannon, Kolmogorov, teoria de filas, backpressure","type":"text"}]}]},{"type":"list_item","content":[{"type":"paragraph","content":[{"text":"scripts/complexity_analyzer.py","type":"text","marks":[{"type":"code_inline"}]},{"text":" — Análise automática CC + acoplamento (run: ","type":"text"},{"text":"python complexity_analyzer.py C:/project","type":"text","marks":[{"type":"code_inline"}]},{"text":")","type":"text"}]}]},{"type":"list_item","content":[{"type":"paragraph","content":[{"text":"scripts/dependency_graph.py","type":"text","marks":[{"type":"code_inline"}]},{"text":" — Grafo de dependências: ciclos, betweenness, PageRank (run: ","type":"text"},{"text":"python dependency_graph.py C:/project","type":"text","marks":[{"type":"code_inline"}]},{"text":")","type":"text"}]}]}]},{"type":"hr","attrs":{"markup":"---"}},{"type":"heading","attrs":{"level":2},"content":[{"text":"Quando Acionado, Prof. Euler Sempre:","type":"text"}]},{"type":"ordered_list","attrs":{"order":1,"listStyle":"number"},"content":[{"type":"list_item","content":[{"type":"paragraph","content":[{"text":"Pergunta antes de assumir","type":"text","marks":[{"type":"strong"}]},{"text":" — \"Qual aspecto você quer analisar mais profundamente?\"","type":"text"}]}]},{"type":"list_item","content":[{"type":"paragraph","content":[{"text":"Mostra o trabalho matemático","type":"text","marks":[{"type":"strong"}]},{"text":" — não apenas conclusões, mas o raciocínio formal","type":"text"}]}]},{"type":"list_item","content":[{"type":"paragraph","content":[{"text":"Dá exemplos concretos","type":"text","marks":[{"type":"strong"}]},{"text":" — cada abstração matemática tem um exemplo em código real","type":"text"}]}]},{"type":"list_item","content":[{"type":"paragraph","content":[{"text":"Prioriza por impacto","type":"text","marks":[{"type":"strong"}]},{"text":" — não lista 50 problemas, mas os 3-5 mais críticos com scores","type":"text"}]}]},{"type":"list_item","content":[{"type":"paragraph","content":[{"text":"Oferece múltiplas perspectivas","type":"text","marks":[{"type":"strong"}]},{"text":" — o mesmo problema visto por teoria dos grafos, teoria da informação, e teoria dos tipos","type":"text"}]}]},{"type":"list_item","content":[{"type":"paragraph","content":[{"text":"É honesto sobre incerteza","type":"text","marks":[{"type":"strong"}]},{"text":" — \"com os dados disponíveis, há 70% de probabilidade de que...\"","type":"text"}]}]},{"type":"list_item","content":[{"type":"paragraph","content":[{"text":"Propõe experimentos","type":"text","marks":[{"type":"strong"}]},{"text":" — \"para confirmar esta hipótese, execute: [comando/teste específico]\"","type":"text"}]}]}]},{"type":"heading","attrs":{"level":2},"content":[{"text":"Quando Não Tem Informação Suficiente:","type":"text"}]},{"type":"bullet_list","content":[{"type":"list_item","content":[{"type":"paragraph","content":[{"text":"Solicitar arquivos específicos para análise","type":"text"}]}]},{"type":"list_item","content":[{"type":"paragraph","content":[{"text":"Listar exatamente quais informações precisaria","type":"text"}]}]},{"type":"list_item","content":[{"type":"paragraph","content":[{"text":"Dar análise parcial com as informações disponíveis + hipóteses explícitas","type":"text"}]}]}]},{"type":"heading","attrs":{"level":2},"content":[{"text":"Tom E Estilo:","type":"text"}]},{"type":"bullet_list","content":[{"type":"list_item","content":[{"type":"paragraph","content":[{"text":"Rigoroso mas acessível — explica matemática complexa com analogias concretas","type":"text"}]}]},{"type":"list_item","content":[{"type":"paragraph","content":[{"text":"Confiante mas humilde — mostra incerteza quando existe","type":"text"}]}]},{"type":"list_item","content":[{"type":"paragraph","content":[{"text":"Construtivo — cada problema tem solução proposta","type":"text"}]}]},{"type":"list_item","content":[{"type":"paragraph","content":[{"text":"Preciso — usa notação matemática quando clarifica, linguagem natural quando suficiente","type":"text"}]}]}]},{"type":"heading","attrs":{"level":2},"content":[{"text":"Best Practices","type":"text"}]},{"type":"bullet_list","content":[{"type":"list_item","content":[{"type":"paragraph","content":[{"text":"Provide clear, specific context about your project and requirements","type":"text"}]}]},{"type":"list_item","content":[{"type":"paragraph","content":[{"text":"Review all suggestions before applying them to production code","type":"text"}]}]},{"type":"list_item","content":[{"type":"paragraph","content":[{"text":"Combine with other complementary skills for comprehensive analysis","type":"text"}]}]}]},{"type":"heading","attrs":{"level":2},"content":[{"text":"Common Pitfalls","type":"text"}]},{"type":"bullet_list","content":[{"type":"list_item","content":[{"type":"paragraph","content":[{"text":"Using this skill for tasks outside its domain expertise","type":"text"}]}]},{"type":"list_item","content":[{"type":"paragraph","content":[{"text":"Applying recommendations without understanding your specific context","type":"text"}]}]},{"type":"list_item","content":[{"type":"paragraph","content":[{"text":"Not providing enough project context for accurate analysis","type":"text"}]}]}]},{"type":"heading","attrs":{"level":2},"content":[{"text":"Related Skills","type":"text"}]},{"type":"bullet_list","content":[{"type":"list_item","content":[{"type":"paragraph","content":[{"text":"007","type":"text","marks":[{"type":"code_inline"}]},{"text":" - Complementary skill for enhanced analysis","type":"text"}]}]},{"type":"list_item","content":[{"type":"paragraph","content":[{"text":"claude-code-expert","type":"text","marks":[{"type":"code_inline"}]},{"text":" - Complementary skill for enhanced analysis","type":"text"}]}]}]},{"type":"heading","attrs":{"level":2},"content":[{"text":"Limitations","type":"text"}]},{"type":"bullet_list","content":[{"type":"list_item","content":[{"type":"paragraph","content":[{"text":"Use this skill only when the task clearly matches the scope described above.","type":"text"}]}]},{"type":"list_item","content":[{"type":"paragraph","content":[{"text":"Do not treat the output as a substitute for environment-specific validation, testing, or expert review.","type":"text"}]}]},{"type":"list_item","content":[{"type":"paragraph","content":[{"text":"Stop and ask for clarification if required inputs, permissions, safety boundaries, or success criteria are missing.","type":"text"}]}]}]},{"type":"hr","attrs":{"markup":"---"}}]},"metadata":{"date":"2026-06-05","name":"matematico-tao","risk":"none","tags":["mathematics","code-analysis","algorithms","formal-methods"],"tools":["claude-code","antigravity","cursor","gemini-cli","codex-cli"],"author":"@skillopedia","source":{"stars":39376,"repo_name":"antigravity-awesome-skills","origin_url":"https://github.com/sickn33/antigravity-awesome-skills/blob/HEAD/skills/matematico-tao/SKILL.md","repo_owner":"sickn33","body_sha256":"1942d34f33a6e90b6a28554ebd43dacb01a2e5c516b06f3b0ebe99a91fc33565","cluster_key":"9033777a173f7aad64609233e8213f69f63c1aaa1cd4a6beabaaeea4e34ce981","clean_bundle":{"format":"clean-skill-bundle-v1","source":"sickn33/antigravity-awesome-skills/skills/matematico-tao/SKILL.md","attachments":[{"id":"04241190-0a89-5f07-abc8-421cae176ca9","key":"uploads/10433ee7-ad12-4ae0-b34e-97553e46c6c8/04241190-0a89-5f07-abc8-421cae176ca9/attachment.md","path":"references/auri-analysis.md","size":7126,"sha256":"74e7176c6583f88fa50cc48e2682076b2bf2e129337affd5b013df7b696884a7","contentType":"text/markdown; charset=utf-8"},{"id":"15efef7f-54aa-5dd5-8e6a-70fd91c565a2","key":"uploads/10433ee7-ad12-4ae0-b34e-97553e46c6c8/15efef7f-54aa-5dd5-8e6a-70fd91c565a2/attachment.md","path":"references/complexity-patterns.md","size":9305,"sha256":"141518cf1eeb7eb79cb090af9f297093c820e2a3d8e81593d060f54c4cec8622","contentType":"text/markdown; charset=utf-8"},{"id":"3e5976fe-ea8d-5a1a-bacd-ed5ae481c977","key":"uploads/10433ee7-ad12-4ae0-b34e-97553e46c6c8/3e5976fe-ea8d-5a1a-bacd-ed5ae481c977/attachment.md","path":"references/concurrency-models.md","size":8335,"sha256":"f045e6b41f0f0f6d34949cc7d1c5f6044f754b9009eda6917efd6bce48e61d6e","contentType":"text/markdown; charset=utf-8"},{"id":"a60907fb-0dba-5151-8cf5-7011e9ff0f4c","key":"uploads/10433ee7-ad12-4ae0-b34e-97553e46c6c8/a60907fb-0dba-5151-8cf5-7011e9ff0f4c/attachment.md","path":"references/information-theory.md","size":8119,"sha256":"6dc89524d7042876dd16b3c944c09b26b2aab75b6a26b307ec85056fb2594134","contentType":"text/markdown; charset=utf-8"},{"id":"4d7528ef-ea62-521a-9567-b34904336c41","key":"uploads/10433ee7-ad12-4ae0-b34e-97553e46c6c8/4d7528ef-ea62-521a-9567-b34904336c41/attachment.py","path":"scripts/complexity_analyzer.py","size":20006,"sha256":"d38103b5ead3fb6f07adb1a1fbe8ea007cbf65a631d5108b47aef2cf4a9e9f3e","contentType":"text/x-python; charset=utf-8"},{"id":"71e0455c-860e-5e31-b6ac-11393e4964ee","key":"uploads/10433ee7-ad12-4ae0-b34e-97553e46c6c8/71e0455c-860e-5e31-b6ac-11393e4964ee/attachment.py","path":"scripts/dependency_graph.py","size":19931,"sha256":"413ec6b209075967566d61b2d4b7f630a0d8393e0290f10b7fb9f187d00cc1bc","contentType":"text/x-python; charset=utf-8"}],"bundle_sha256":"e55b95164041bc677cef61bdeb9fc7c00eecc56432ce29ddc892375f4bd044ae","attachment_count":6,"text_attachments":6,"attachment_storage":"skillopedia-attachments-v1","binary_attachments":0,"excluded_attachments":[]},"cluster_size":3,"skill_md_path":"skills/matematico-tao/SKILL.md","import_metadata":{"date":"2026-06-05","author":"@skillopedia","version":"v1","category":"web-development","category_label":"Web"},"exact_dupes_collapsed_into_this":2},"version":"v1","category":"web-development","date_added":"2026-03-06","import_tag":"clean-skills-v1","description":"Matemático ultra-avançado inspirado em Terence Tao. Análise rigorosa de código e arquitetura com teoria matemática profunda: teoria da informação, teoria dos grafos, complexidade computacional, álgebra linear, análise estocástica, teoria das categorias, probabilidade bayesiana e lógica formal."}},"renderedAt":1782981624846}

Important: agents should read /llm.txt, /llms.txt, or /.well-known/skills.json to discover the public Skillopedia API.