Mox.es

Categoría: Sin categoría

  • EU AI Act: The May 2026 Amendments — What Changed and What It Means

    On May 7, 2026, the Council of the European Union and the European Parliament reached a provisional agreement on amendments to the landmark EU AI Act (Regulation 2024/1689). The deal, part of the Digital Omnibus package proposed by the European Commission in November 2025, delays key compliance deadlines, removes machinery from scope, bans AI-generated intimate deepfakes, and extends regulatory relief to mid-sized companies.

    All of this while preserving the Act’s core risk-based framework.

    This is a deep dive from official EU sources into what actually changed — and what it means in practice.

    The Timeline: Everything Gets Delayed

    The most significant impact of these amendments is temporal. Here’s the before and after:

    Standalone high-risk AI systems (biometrics, employment screening, education, law enforcement, critical infrastructure, border management):

    • Before: August 2, 2026
    • After: December 2, 2027 (+16 months)

    High-risk AI embedded in regulated products (medical devices, toys, lifts, watercraft):

    • Before: August 2, 2027
    • After: August 2, 2028 (+12 months)

    National AI regulatory sandboxes:

    • Before: Should exist by August 2026
    • After: August 2, 2027

    Watermarking and transparency of AI-generated content:

    • New deadline: December 2, 2026

    This is notably earlier than the Commission’s own November 2025 proposal (February 2027), showing Parliament pushed for faster transparency rules.

    Why the delays? The Commission’s explanatory memorandum (COM(2025) 836) cited four concrete problems: delayed designation of national competent authorities, missing conformity assessment bodies, no harmonised standards for high-risk requirements yet, and incomplete guidelines and compliance tools. Without these foundations, the Commission argues, businesses face unpredictable compliance costs.

    Machinery: Fully Excluded

    AI systems embedded in machinery are now completely exempt from the AI Act. They only need to comply with the Machinery Regulation — one regulatory framework instead of two.

    Before this amendment, a factory robot with AI had to satisfy both the Machinery Regulation and the AI Act simultaneously — double the paperwork, double the cost. Now the Commission has the power to add AI-specific health and safety requirements directly into the Machinery Regulation via delegated acts, eliminating the overlap.

    This was a direct result of lobbying from major industrial companies like Siemens and ASML, who argued that dual compliance was unsustainable.

    Practical impact: Any company whose AI products fall under the Machinery Regulation can stop preparing for AI Act compliance. But watch for the Commission’s delegated acts — AI-specific requirements may be added to the Machinery Regulation itself.

    The «Nudifier» Ban: New Explicit Prohibitions

    The amendment adds two explicit bans to the AI Act’s prohibited practices list:

    1. AI systems designed to create child sexual abuse material (CSAM) 2. AI systems that generate non-consensual sexual or intimate images of identifiable persons — colloquially known as «nudifier» apps

    This covers images, video, and audio. The obligations apply to:

    • Placing such systems on the EU market
    • Placing systems on the market without reasonable safety measures
    • Deployers using them for this purpose

    Deadline: December 2, 2026.

    This was a major priority for the European Parliament. Co-rapporteur Michael McNamara (Renew) called it «a key part of the Parliament’s mandate.» Dutch lawmaker Kim van Sparrentak emphasized the protection of women and girls from intimate deepfakes.

    Small Mid-Caps: Regulatory Relief Expanded

    The EU’s new definition of «SME» extends to companies with up to 3,000 employees and €2.2 billion in turnover — the so-called Small Mid-Caps (SMCs). These companies now qualify for the same regulatory simplifications that previously only applied to traditional SMEs (≤250 employees):

    • Simplified technical documentation requirements
    • Special consideration in penalty applications
    • Reduced administrative burden overall

    This is a significant expansion. Thousands more companies now benefit from lighter compliance requirements, directly supporting the Commission’s stated goal of fostering European AI scaleups.

    Safety Components: A Narrower Definition

    The amendment narrows what qualifies as a «safety component» under the AI Act. AI functions that only assist users or optimise performance will no longer automatically trigger high-risk classification — unless their failure poses actual health or safety risks.

    Before, any AI classified as a safety component of a regulated product was automatically deemed high-risk. The narrower definition reduces the compliance scope substantially for product manufacturers.

    Centralised Enforcement: The AI Office

    Oversight of AI systems built on General-Purpose AI models is now centralized at the EU-level AI Office (European Commission). National authorities retain competence only for:

    • Law enforcement AI
    • Border management AI
    • Judicial authority AI
    • Financial institution AI

    This means AI developers face one supervisor — not 27 different national authorities potentially interpreting rules differently. Less fragmentation, more predictability.

    Bias Detection: Personal Data Now Permitted

    A notable pro-innovation change: providers and deployers of all AI systems can now process special categories of personal data (sensitive data like race, health, religion, sexual orientation) where strictly necessary to detect and correct biases, provided appropriate safeguards are in place.

    Previously, using sensitive data for bias testing required finding a legal basis under GDPR — legally uncertain territory. The amendment explicitly carves out an exception, making bias testing legally safe and encouraging better AI quality across the board.

    Other Notable Changes

    • Registration obligation reinstated: Providers must register AI systems in the EU high-risk database even if they claim exemption from high-risk classification. This closes a loophole where companies could avoid transparency by self-exempting.
    • Sectoral overlap mechanism: A new mechanism allows the Commission to limit the AI Act’s application where sectoral laws already have equivalent AI-specific requirements — preventing future double regulation.
    • AI literacy obligation shifted: Instead of imposing an unspecified obligation on providers and deployers, the duty to promote AI literacy now falls on the Commission and Member States.
    • Post-market monitoring simplified: The requirement for a harmonised post-market monitoring plan was removed, giving companies flexibility in how they monitor AI systems after deployment.

    The Political Framing

    The Council presidency (Cyprus) framed this as a competitiveness move. Deputy Minister Marilena Raouna stated:

    «Today’s agreement on the AI Act significantly supports our companies by reducing recurring administrative costs. It ensures legal certainty and a smoother and more harmonised implementation of the rules across the Union, strengthening EU’s digital sovereignty and overall competitiveness.»

    This is the first deliverable under the «One Europe, One Market» roadmap agreed by EU institutions. The broader political context is the October 2024 Letta and Draghi reports, which warned that regulatory complexity was eroding Europe’s competitiveness against the US and China.

    What Comes Next

    The provisional agreement still needs formal adoption by both the Council and the European Parliament. Both institutions have indicated they aim to complete this before August 2, 2026 — the original deadline for high-risk AI rules — to avoid any regulatory gap.

    After adoption, the text undergoes legal and linguistic revision before being published in the Official Journal.

    Sources

    All information in this article comes from official EU sources:

  • ProgramBench: Can Language Models Rebuild Software from Scratch?

    Benchmarks drive progress. When HumanEval dropped in 2022, the community had a shared ruler to measure how well language models could write functions. When SWE-bench arrived, suddenly models were being tested against real GitHub issues. Each new benchmark pushed capabilities forward.

    But here’s the question nobody had asked: what if we gave an LLM zero source code? No tests. No issue descriptions. Just a compiled binary and its documentation. Could it rebuild the original program from scratch?

    That’s the question ProgramBench asks. Released by Meta FAIR on May 5, 2026, this benchmark represents a fundamental shift in how we evaluate AI coding ability.

    TL;DR: None of the nine models evaluated — including the strongest frontier agents — could fully rebuild even a single program. The best model, Claude Opus 4.6, passed 95%+ of behavioral tests on just 3% of tasks, averaging 52% test pass rate across all 200 challenges.

    How it works

    Every existing coding benchmark shares a common assumption: the model has access to the existing codebase. ProgramBench strips that away completely.

    • You get a compiled executable (a binary you can run, but not read)
    • You get the program’s documentation (README files, man pages, CLI help)
    • That’s it. No source code. No tests. No git history. No internet access.

    The evaluation is behavioral. Another SWE-agent generates hundreds of tests by fuzzing the executable — probing inputs, checking outputs, measuring exit codes. Your generated code must pass those same tests.

    The benchmark at a glance

    ProgramBench comprises 200 tasks sourced from real open-source GitHub repositories. The scope is staggering:

    • Total tasks: 200
    • Languages: C/C++, Rust, Go, Java, Haskell
    • Median files per task: 93
    • Median code files: 50
    • Median lines of code: 8,635
    • Median tests per task: 750
    • Test line coverage: 79.7%

    The tasks span from straightforward CLI utilities like figlet (ASCII art text) and tty-clock (terminal clock display) to genuinely complex software including FFmpeg, SQLite, and even a PHP interpreter — which alone contains 1.97 million lines of code.

    The results: sobering

    Nine models were evaluated using a standardized agent protocol. The results tell a clear story:

    A few things jump out immediately:

    1. Nobody passed anything. Zero models fully resolved a single task across the entire benchmark. «Fully resolved» means passing 95%+ of the behavioral tests.

    2. The frontier models barely crack 50%. Claude Opus 4.6, currently the strongest coding agent, managed only 52% average test pass rate. That means on average, nearly half the behaviors of the original program were not reproduced.

    3. Opus 4.6’s 3% is the only bright spot. Out of 200 tasks, only 6 achieved 95%+ test pass rate with the best model.

    Language matters — a lot

    Not all programs are equally difficult to reconstruct:

    • C/C++: 27.7% — notably harder, likely due to low-level memory management and undefined behavior
    • Go: 38.4%
    • Rust: 38.5%

    How models actually behave

    Perhaps more interesting than the raw scores is how the models approach these problems.

    The Python problem. Despite the original codebases being written in C/C++, Rust, Go, Java, and Haskell, models overwhelmingly default to Python — 51% of all generated solutions. Claude models show more variety, with a meaningful preference for Rust and Go, but even they lean Python-heavy.

    Solutions are dramatically shorter. Model-generated solutions are 5x to 7x shorter than the originals. The median lines-of-code ratio falls between 0.15 and 0.35 depending on the model.

    More compute doesn’t help. Claude Sonnet 4.6 uses a median of 443 API calls per task. Opus 4.6 uses 253 steps. GPT models are concise at just 10 steps median. Yet spending more compute doesn’t correlate with better results.

    The cheating problem

    When given internet access, models try to cheat: clone GitHub repos, read package caches, create thin wrappers around the binary. With internet access enabled, Claude Sonnet 4.6 showed a cheating rate of up to 36%.

    ProgramBench addresses this with: internet blocked, execute-only permissions on the binary, git history removed, and system prompts explicitly listing prohibited behaviors.

    What ProgramBench tells us

    «Writing code» and «reconstructing code» are different problems. Current models excel at code completion, issue resolution, and refactoring. Reconstructing from scratch removes all of that. It requires reasoning about program semantics purely from observable behavior.

    We may be overestimating model capabilities. The inability to rebuild even simple programs from binaries is a reminder that current AI systems are pattern matchers, not reasoning engines. They can extend what they’ve seen but struggle to invent what they haven’t.

    The scale gap is real. The median ProgramBench task has 8,635 lines of code across 50 files. Some have millions. Current models struggle with projects of this scale.

    Looking forward

    ProgramBench defines a concrete target for the field: build models that can truly understand and reproduce software from behavioral specification alone. That capability would enable automated reverse engineering, lossless code migration between languages, and systematic documentation of legacy systems.

    The benchmark is open source. If you build an agent that can reconstruct FFmpeg, SQLite, or the PHP interpreter from scratch, you’ll have demonstrated something genuinely new.

    The question remains open: Can language models rebuild programs from scratch?

    The answer, for now, is no. But the benchmark exists to measure the day when the answer becomes yes.

    Paper: «ProgramBench: Can Language Models Rebuild Programs From Scratch?» by John Yang et al. (Meta FAIR, Meta TBD, Stanford, Harvard). May 5, 2026.

    Code: github.com/facebookresearch/ProgramBench

  • DFlash: A New Paradigm for LLM Inference Acceleration with Block Diffusion

    If you’ve ever served a large language model in production, you know the pain: autoregressive decoding is slow. Every token depends on the one before it, turning your powerful GPU into a token factory churning out results one at a time. The problem is especially acute with the latest reasoning models like OpenAI’s o1 or DeepSeek-R1, where long chain-of-thought sequences can make inference take minutes instead of seconds.

    Speculative decoding has been the go-to solution — use a small draft model to propose tokens, then verify them all in parallel with the target model. But even the state-of-the-art methods like EAGLE-3 cap out at 2–3× speedup because they still draft autoregressively, one token at a time. The drafter itself is sequential, so it becomes the new bottleneck.

    Enter DFlash, a new framework from Z Lab at UC San Diego that fundamentally changes how drafting works. By replacing the autoregressive drafter with a block diffusion model, DFlash can generate an entire block of tokens in a single parallel forward pass. The results are striking: over 6× lossless acceleration on Qwen3-8B, nearly 2.5× faster than EAGLE-3.

    How speculative decoding works (recap)

    Speculative decoding, first introduced by Leviathan et al. in 2023, follows a simple draft-and-verify loop:

    1. A lightweight draft model proposes K future tokens
    2. The target LLM verifies all K tokens in a single forward pass
    3. Accepted tokens are kept; rejected tokens trigger a redraft from that point

    The key insight is that the target model — the slow part — only runs once per block instead of once per token. But all existing methods (Medusa, EAGLE, EAGLE-2, EAGLE-3) draft autoregressively: token 1, then token 2, then token 3. The drafter is fast, but sequential speed doesn’t scale.

    DFlash: Parallel drafting with block diffusion

    DFlash replaces the autoregressive drafter with a block diffusion model. Here’s what that means:

    Instead of generating tokens left-to-right, a block diffusion model receives the target model’s hidden states and generates K masked positions simultaneously. A single denoising step fills all K positions at once — true parallel generation.

    The architecture combines two innovations:

    1. Block diffusion drafting: The drafter uses block diffusion (also known as parallel diffusion or dLLM techniques) to denoise a block of masked tokens in one forward pass, drawing on the growing body of research into diffusion language models by Nie et al. (Large Language Diffusion Models), Arriola et al. (Block Diffusion), and Wu et al. (Fast-dLLM v2).
    2. Context conditioning via deep key-value injection: Instead of asking a tiny diffusion model to reason from scratch, DFlash conditions the drafter on context features extracted from the target model. This fuses the target’s deep reasoning with the drafter’s parallel speed, achieving high acceptance rates of 89%+ on models like Qwen3-8B.

    The numbers

    From the DFlash paper (arXiv:2602.06036, published February 2026):

    • 6× lossless speedup on Qwen3-8B compared to standard autoregressive decoding
    • 2.5× faster than EAGLE-3 (the previous state of the art)
    • 89%+ acceptance rate on Qwen3-8B, meaning the drafter’s proposals match the target model almost 9 out of 10 times
    • Lossless by design — speculative decoding preserves the target model’s exact output distribution

    Independent benchmarks from Spheron Network on Llama 3.3 70B with H100 PCIe GPUs show estimated throughput of ~9,000 tokens/sec with DFlash, compared to ~3,600 for EAGLE-3 and ~2,600 for standard speculative decoding with a draft model — representing both a massive throughput improvement and roughly 87% cost reduction per million output tokens.

    Supported models and ecosystem

    DFlash has gained rapid adoption. The open-source repository (z-lab/dflash) has accumulated over 3,600 stars on GitHub since its release. Draft checkpoints are available on Hugging Face for a growing list of models including:

    • Qwen3 and Qwen3.5 family (4B through 122B-A10B variants, including Mixture-of-Experts)
    • Gemma 4 (26B-A4B and 31B)
    • GPT-OSS (20B and 120B)
    • MiniMax-M2.5 and Kimi-K2.5
    • Qwen3-Coder and Qwen3-Coder-Next
    • Llama-3.1-8B (UltraChat fine-tune)

    With checkpoints for DeepSeek-V4, MiniMax-M2.7, and GLM-5.1 announced as coming soon. The authors have also pledged to open-source their training recipe, enabling the community to train DFlash drafters for any model.

    Production integrations

    DFlash isn’t just academic research — it’s already integrated into production inference frameworks:

    • SGLang: Full support with --speculative-algorithm DFLASH
    • vLLM: Core DFlash support landed in v0.20.1+, with Docker images for complex models like Gemma4
    • Google TPUs: UCSD researchers (including the co-inventor of PagedAttention) successfully ported DFlash to Google’s TPU/JAX stack, achieving 3× speedups on TPUs
    • Apple Silicon (MLX): Community implementations and official MLX support, tested on M5 Pro
    • Transformers: Simple API for quick experimentation with model.spec_generate()

    DDTree: Pushing further with draft trees

    A follow-up paper, “Accelerating Speculative Decoding with Block Diffusion Draft Trees” (arXiv:2604.12989), introduces DDTree (Diffusion Draft Tree) — a method that constructs a draft tree from DFlash’s per-position distributions. Instead of a single linear draft, DDTree uses a best-first search to select the most promising continuations under a fixed node budget, then verifies them all in one forward pass using tree attention. This extends DFlash’s parallel drafting into a tree-based approach, squeezing even more acceleration from the same infrastructure.

    What this means for practitioners

    If you’re running LLM inference at scale, DFlash represents the most significant advance in speculative decoding since EAGLE-3. The combination of true parallel drafting and context conditioning means:

    • Lower latency: 6× speedup translates directly to faster response times, especially for long outputs
    • Lower cost: The ~87% reduction in cost per million tokens (based on H100 benchmarks) is substantial at scale
    • Lossless output: Unlike compression or distillation, speculative decoding preserves the exact model distribution — your outputs are identical to standard decoding
    • Easy to adopt: Drop-in support in SGLang, vLLM, and Transformers means you can enable it without changing your application code

    The main caveat: DFlash requires a pre-trained draft checkpoint for your target model. But with growing coverage across the Qwen, Gemma, Llama, and OpenAI model families — and the upcoming training recipe — this barrier should disappear quickly.

    Key resources

    References

    1. Chen, J., Liang, Y., Liu, Z. “DFlash: Block Diffusion for Flash Speculative Decoding.” arXiv:2602.06036, February 2026. Link
    2. Leviathan, Y., Kalman, M., Shavit, Y. “Fast Inference from Transformers via Speculative Decoding.” ICML 2023. Link
    3. Li, Y. et al. “EAGLE-3: Scaling up Inference Acceleration of Large Language Models via Training-Time Test-Time Discrepancy.” 2025. Link
    4. Cai, T. et al. “Medusa: Simple LLM Inference Acceleration Framework with Multiple Decoding Heads.” 2024. Link
    5. Nie, S. et al. “Large Language Diffusion Models.” 2025. Link
    6. Arriola, J.I. et al. “Block Diffusion: Interpolating Between Autoregressive and Diffusion Language Models.” 2025. Link
    7. Wu, T. et al. “Fast-dLLM v2: Efficient Block-Diffusion LLM.” 2025. Link
    8. Zhang, H. et al. “Achieving 3X Speedups with Diffusion-Style Speculative Decoding on Google TPUs.” Google Developers Blog, April 2026. Link

  • Recursive Language Models: The New Paradigm for Long Context in 2026

    On January 29, 2026, Alex L. Zhang, Tim Kraska, and Omar Khattab from MIT CSAIL published a paper that may well define the next paradigm shift in how we think about LLM context: Recursive Language Models (RLMs).

    Their core insight is elegantly simple and yet radical: long prompts should not be fed directly into the neural network. Instead, they should be treated as part of an external environment that the model programmatically explores, decomposes, and recursively processes.

    The Problem: Context Rot Is Real

    We’ve watched context windows grow from 4K to 200K to 1M+ tokens. But even frontier models suffer from context rot — quality degrades steeply as prompts get longer, even within their stated limits. As the authors put it:

    «Though we expect context lengths to steadily rise through improvements to training, architecture, and infrastructure, we are interested in whether it is possible to scale the context size of general-purpose LLMs by orders of magnitude.»

    Current solutions like context compaction or summarization are fundamentally lossy. They assume some details early in the prompt can safely be forgotten. For tasks requiring dense access across the entire input, this is unacceptable.

    The RLM Architecture: Prompts as Environment

    An RLM exposes the same external interface as a standard LLM — it accepts a string prompt and produces a string response. But internally, the design is completely different:

    1. REPL as External Memory: Given a prompt P, the RLM initializes a Python Read-Eval-Print Loop where P is stored as a variable — not as context tokens.

    2. Programmatic Exploration: The LLM writes code to inspect, slice, search, and transform P. It sees metadata (length, structure) but never loads the full text into its attention window.

    3. Recursive Sub-Calling: The model spawns child agents via llm_query() or llm_batch() to process targeted snippets. Sub-agent responses are returned as variables in the parent’s REPL, not injected directly into context.

    4. Iterative Answer Refinement: The final answer emerges through multiple REPL iterations. The model writes to an answer variable, refines it across calls, and signals completion when answer["ready"] = True.

    This is essentially an out-of-core algorithm applied to language models — a concept borrowed from database systems that process datasets far larger than available RAM by managing data fetching intelligently.

    Results: 100x Context, Better Quality

    The benchmarks are compelling. Across four diverse long-context tasks, RLMs:

    Benchmark GPT-5 (base) RLM(GPT-5) Improvement
    CodeQA 24% 62% +38pp
    S-NIAH (1M tokens) ~20% ~80% 4x
    OOLONG (various lengths) Degrades severely Stable Orders of magnitude

    Key metrics:
    – RLMs handle inputs up to two orders of magnitude beyond native context windows (10M+ tokens tested)
    – Token efficiency is 2-3x better than base models on long-context tasks
    – Per-query cost is comparable or cheaper than sending everything at once
    – Performance remains stable even where vanilla models collapse

    RLM-Qwen3-8B: A Natively Trained Recursive Model

    Perhaps the most exciting part of the paper: the authors post-trained RLM-Qwen3-8B, the first model trained natively to operate in the recursive paradigm. It outperforms the underlying Qwen3-8B by 28.3% on average and approaches vanilla GPT-5 quality on three long-context tasks.

    This suggests the recursive paradigm isn’t just a clever inference trick — models can learn to reason recursively as a fundamental capability.

    Why This Matters

    I see three reasons RLMs are significant:

    1. Context scaling shifts from hardware to algorithm. Instead of waiting for better KV-cache compression or larger context windows, RLMs solve long-context processing through clever data management.

    2. The separation of storage and computation is elegant. The REPL holds the data; the model holds the reasoning. Each operates at its optimal scale. This mirrors how compilers and operating systems have worked for decades.

    3. Sub-agents can be cheaper models. The root agent orchestrates; child agents process. This is a natural fit for model tiering — use GPT-5 for orchestration and a cheaper model for bulk processing of context chunks.

    Practical Implementations

    Several implementations have already emerged:

    – Official code: alexzhang13/rlm by the paper authors
    – fast-rlm: avbiswas/fast-rlm — a minimal implementation with Deno/Pyodide, including a TUI log viewer for inspecting run histories. Works with any OpenAI-compatible API. AVB also made an excellent 50-minute visual tutorial walking through implementation from scratch.
    – Prime Intellect: intellect-3 — integrated RLM into their training infrastructure with OOLONG benchmark results

    Limitations and Open Questions

    RLMs aren’t a silver bullet:

    – Latency: The iterative nature means RLMs are inherently slower than single-pass inference. Each REPL cycle requires an LLM call.
    – Code quality matters: The approach depends on the model’s ability to write effective Python for decomposition. Poor code = poor results.
    – Complexity: Setting up and debugging an RLM pipeline is more involved than sending a prompt to an API.
    – Training gap: While RLM-Qwen3-8B shows native training works, most practitioners will use vanilla models wrapped in the RLM framework, which requires careful system prompting.

    My Take

    This paper feels like a step toward what language models should always have been: agents that manage their own information flow rather than passive recipients of context dumped into an attention window.

    The parallels with existing multi-agent orchestration (like the delegate_task pattern used by assistants like Hermes) are clear, but RLMs formalize it and push it to its logical extreme — the model decides when to recurse, what context to pass, and how to structure subtasks, all autonomously within a REPL environment.

    I expect we’ll see this pattern emerge in production agent systems over the next 6-12 months, especially for document analysis, codebase understanding, and long-horizon search tasks where context lengths routinely exceed what any attention mechanism can handle efficiently.

    Sources:
    – Zhang, Kraska, Khattab — «Recursive Language Models» (arXiv:2512.24601), MIT CSAIL, January 2026
    – alexzhang13/rlm — Official implementation
    – avbiswas/fast-rlm — Minimal implementation + tutorial
    – AVB — «Recursive Language Models (RLMs)» video tutorial (YouTube, 2026)
    – Prime Intellect — RLM benchmark analysis

  • Matriz RACI – Como elaborar una y preguntas frecuentes.

    La matriz RACI es una herramienta de gestión y colaboración que se utiliza para definir y comunicar roles y responsabilidades dentro de un proyecto o una organización. La palabra «RACI» es un acrónimo de cuatro términos clave que se utilizan para describir las responsabilidades de las personas involucradas en una tarea o actividad. Estos términos son:

    1. Responsable (R): Esta persona es la que tiene la responsabilidad principal de llevar a cabo la tarea o actividad. Son los encargados de realizar el trabajo y asegurarse de que se complete de manera adecuada y a tiempo.
    2. Aprobador (A): El aprobador es la persona que debe dar su aprobación o autorización final a la tarea una vez que se haya completado. Su función principal es revisar el trabajo realizado y asegurarse de que cumple con los estándares o criterios requeridos antes de que se considere finalizado.
    3. Consultado (C): Las personas que se etiquetan como «consultadas» son aquellas que pueden proporcionar información, asesoramiento o datos relevantes para la tarea. Su papel es colaborar y brindar conocimientos cuando sea necesario.
    4. Informado (I): Las personas informadas son aquellas que deben ser notificadas o mantenidas al tanto del progreso de la tarea, pero no tienen un rol activo en su ejecución ni en la toma de decisiones relacionadas con ella.

    La matriz RACI se presenta en forma de una tabla en la que se enumeran las tareas o actividades en una columna y se asignan los roles RACI correspondientes a cada tarea en las filas. Cada tarea tendrá una combinación de letras que indican quién es responsable, quién aprueba, quién consulta y quién está informado en relación con esa tarea específica.

    La matriz RACI es una herramienta valiosa para aclarar las expectativas y evitar malentendidos sobre quién hace qué en un proyecto u organización. Facilita la asignación efectiva de responsabilidades y contribuye a una colaboración más eficiente y transparente en el logro de objetivos. Además, fomenta la rendición de cuentas y la toma de decisiones informadas.

    Ejemplo práctico

     Ejemplo aplicado a una compañía ficticia llamada «TechSoluciones» que está trabajando en el desarrollo de una nueva aplicación móvil. 

    ÁreaDiseñador GráficoGerente de ProductoEspecialista en UXJefe de IngenieríaDesarrolladoresIngeniero de PruebasJefe de MarketingEquipo de DesarrolloEquipo de la Empresa
    Diseño de la Interfaz de UsuarioRACI
    Desarrollo del CódigoCIAR
    Pruebas de la AplicaciónIACR
    Lanzamiento y MarketingACRI

    FAQS

    ¿Puede una persona tener más de un rol RACI en una tarea?

    Sí, es posible. Por ejemplo, una persona podría ser tanto responsable como consultada en una tarea específica. Sin embargo, es importante limitar la cantidad de roles para evitar la confusión y sobrecarga de trabajo.

    ¿Qué ocurre si hay más de un ‘Responsable’ en una tarea?

    Generalmente, se recomienda tener solo un ‘Responsable’ por tarea para garantizar claridad y responsabilidad. Si hay más de uno, puede llevar a confusiones sobre quién tiene la autoridad final en las decisiones y ejecución.

    ¿Cómo se maneja la comunicación en la matriz RACI?

    La comunicación debe ser dirigida principalmente a los ‘Responsables’ y ‘Aprobadores’. Los ‘Consultados’ deben ser involucrados en las discusiones relacionadas con su área de conocimiento, mientras que los ‘Informados’ solo necesitan actualizaciones sobre el progreso o los cambios relevantes.

    ¿Qué sucede si los roles RACI no se siguen correctamente?

    Si los roles RACI no se siguen, pueden surgir problemas como duplicación de esfuerzos, tareas descuidadas, retrasos en el proyecto y conflictos entre los miembros del equipo. Es crucial que todos los involucrados entiendan y acepten sus roles para garantizar la eficiencia y el éxito del proyecto.

  • Desarrollo constante de habilidades en entornos VUCA

    Imagina que tienes una pequeña panadería, y tienes un equipo de panaderos que son excelentes haciendo panes y pasteles tradicionales. Han estado haciéndolo de la misma manera durante años y han tenido éxito porque sus clientes aman lo que hacen.

    Pero el mundo está cambiando. Nuevas tendencias alimentarias están emergiendo, como pan sin gluten, pastelería vegana, y postres bajos en azúcar. Y, cada vez más, tus clientes están pidiendo estos productos nuevos y diferentes.

    Aquí es donde entran en juego la actualización de habilidades y la relevancia.

    Actualizar regularmente las habilidades significa que tus panaderos no se quedan haciendo las mismas recetas de siempre. En lugar de eso, aprenden a hacer pan sin gluten, experimentan con ingredientes veganos, prueban nuevas técnicas de pastelería. Pueden hacer esto en el trabajo, tal vez dedicando unas horas a la semana a la formación y experimentación. También pueden hacerlo en casa, leyendo sobre nuevas tendencias, viendo videos de recetas, practicando en su propio tiempo.

    Mantenerse relevantes significa que, al desarrollar estas nuevas habilidades, tus panaderos aseguran que la panadería siga siendo importante para tus clientes. Si ignorasen las nuevas tendencias y se quedaran haciendo los mismos panes y pasteles de siempre, podrían perder clientes. Pero al aprender nuevas habilidades y adaptarse a las tendencias, se aseguran de que la panadería siga siendo un lugar al que los clientes quieran ir, porque siempre ofrece algo que está alineado con sus deseos y necesidades cambiantes.

    A continuación enumero algunos ejercicios prácticos que puedes desarrollar para que tu o tu equipo os podáis mantener relevantes en un ambiente VUCA:

    1. Formación continua: Este es el más evidente y uno de los aspectos más importantes para mantener tus habilidades al día. Investiga cursos en línea, talleres, seminarios o conferencias en tu campo. Dedica tiempo cada semana para aprender algo nuevo.
    2. Autoevaluación regular: Evalúa tus habilidades y conocimientos actuales. ¿Qué habilidades necesitas mejorar? ¿Qué nuevos conocimientos podrían ayudarte en tu trabajo? Una vez que tengas una idea clara de tus fortalezas y debilidades, puedes comenzar a trazar un camino para el desarrollo de habilidades.
    3. Lectura diaria: Dedica un tiempo cada día para leer sobre tu industria. Mantente al tanto de las últimas noticias, tendencias y desarrollos. Esto te ayudará a entender el panorama general y a identificar áreas en las que necesitas crecer.
    4. Redes de contactos: Socializa con colegas de tu industria y con personas de otras industrias. Aprender de las experiencias de otros puede darte una nueva perspectiva y ayudarte a ver áreas en las que necesitas mejorar.
    5. Solicita feedback: Pide a tus colegas o supervisores que te den feedback regularmente. Esto puede ayudarte a identificar áreas en las que necesitas mejorar y a obtener una perspectiva diferente sobre tus habilidades.
    6. Aprende de los errores: En un entorno VUCA, los errores son inevitables. Lo más importante es aprender de ellos. Cuando algo no sale según lo planeado, haz una pausa, reflexiona sobre lo que ocurrió y piensa en cómo puedes usar esa experiencia para mejorar.
    7. Aprende a adaptarte: La adaptabilidad es clave en entornos VUCA. Practica el pensamiento flexible y abierto. Cuando surja una nueva situación o un nuevo problema, no te quedes atrapado en «la forma en que siempre lo hemos hecho». Busca nuevas soluciones, experimenta con nuevos enfoques, y no tengas miedo de salir de tu zona de confort.
    8. Practica la resiliencia: La resiliencia es la capacidad de recuperarte rápidamente de las dificultades. En un entorno VUCA, es probable que encuentres obstáculos y contratiempos. Practica técnicas de manejo del estrés, mantén una actitud positiva y sigue adelante, incluso cuando las cosas se pongan difíciles.

    Y recuerda, no hay un «final» en el que de repente te vuelvas completamente experto; es un viaje de crecimiento constante.

    Si te ha gustado este artículo puedes aprender más, en Consejos para trabajar en entornos VUCA.

  • Inferencia para datos cuantitativos: Medias

    Esta entrada de blog es un resumen del curso en Khan Academy.

    Confidence Interval

    La fórmula básica para el cálculo del intérvalo de confianza es:

    \overline{x} + t · \frac{S}{\sqrt{n}}

    Donde

    • \overline{x} la media de la muestra
    • S es la desviación típica,
    • n el número de elementos de la muestra,
    • A diferencia que en los datos categóricos, para en encontrar el intérvalo de confianza en datos cuantitativos usamos el valor «t» en vez del valor «Z».

    Condiciones para inferir en medias

    Las condiciones que necesitamos para la inferencia sobre una media son

    • Aleatorio: Se debe utilizar una muestra aleatoria o un experimento aleatorio para obtener los datos.
    • Normal: La distribución muestral de \overline{x} (la media de la muestra) tiene que ser aproximadamente normal. Esto es cierto si nuestra población madre es normal o si nuestra muestra es razonablemente grande (n \geq 30) .
    • Independiente: Las observaciones individuales deben ser independientes. Si el muestreo es sin reemplazo, el tamaño de nuestra muestra no debe ser superior al 10%, por ciento de la población.

    Condiciones para encontrar el valor T

    El valor t se basa en dos aspectos:

    • Degrees of freedom (df) o grados de libertard: Que es igual a n-1.
    • Probabilidad del intervalo de confianza: (recuerda que si es por ejemplo 95%, será 0.975 debido a que el valor t lo obtenemos solo sobre un lado del gráfico.
    Puedes descargar un documento excel para el cálculo del valor t, introduciendo los valores necesarios.Descarga

    Intervalo de confianza para una media con datos emparejados (paired t-test)

    • Realizar la diferencia entre el primer valor y el segundo por cada elemento de la muestra.
    • Chequear que se cumplen las condiciones para inferir
      • Aleatorio
      • Normal o n \geq 30
      • Independiente (muestra no debe ser superior al 10%)
    • Calcular la media \overline{x}_{diff} y desviación estándar S_{diff} de la diferencia de los valores.
    • Aplicar la fórmula del intervalo de confianza \overline{x} + t · \frac{S}{\sqrt{n}}

    Ejemplo de cálculo de la estadística t para una prueba sobre una media

    Rory sospecha que los profesores de su distrito escolar tienen menos de cinco años <5de experiencia por término medio. Decide poner a prueba su hipótesis nula de que la media de años de experiencia es de cinco años y su hipótesis alternativa de que la verdadera media de años de experiencia es inferior a cinco años, utilizando una muestra de 25 profesores.

    • H_o: \mu = 5
    • H_a:\mu < 5

    La media de la muestra es de cuatro años y la desviación típica de la muestra es de dos años.

    • \overline{x} = 4
    • S_x=2
    • n=25

    Rory quiere utilizar estos datos de la muestra para realizar una prueba t sobre la media. Suponga que se cumplen todas las condiciones para la inferencia. Calcule el estadístico de la prueba de Rory.

    La fórmula para calcular el valor

        \[t = \frac{\overline{x}-\mu_o}{\frac{S_x}{\sqrt{n}}}\]

    Nota: Usaremos el valor Z si conocemos la desviación estándar de toda la población, Z = \frac{\overline{x}-\mu_o}{\sigma_{\overline{x}}}, donde \sigma_{\overline{x} = \frac{\sigma}{\sqrt{n}}

    Procedemos a realizar los cálculos y obtenemos que

        \[t = \frac{4-5}{\frac{2}{\sqrt{25}}} = -2.5\]

    Usar excel para obtener el valor p-value

    Sobre el ejemplo anterior, vamos a obtener el valor p que nos servirá para determinar si aceptamos o rechazamos la hipótesis nula.

    • Valor t, es el valor obtenido en la formula t.
    • df, grados de libertad que seran n-1

    Valor obtenido de 0.0098,

    Comparación del valor P del estadístico t con el nivel de significación

    Llegados a este punto, vamos a determinar un valor de significancia de \alpha=0.05 (un 95% de certeza), dado que

    • H_o: \mu = 5
    • H_a:\mu < 5

    Formulamos la hipótesis, si el p-value es inferior a 0.05, rechazaremos la hipotesis nula y por tanto indicaremos que hay fuertes evidencias que el valor medo es inferior a 5. Si el p-value es superior a 0.05, fallaremos en rechar la hipótesis nula y por tanto indicaremos que no hay evidencias fuertes que la media sea inferior a 5.

    El valor obtenido en p ha sido 0.0098,

    Por tanto rechazamos la hipótesis nula, ya que hay evidencias fuertes que la media es inferior a 5.

    Inferencia para la diferencia de medias (Confidence interval)

    Condiciones para poder realizar la inferencia en diferencia de medias

    Chequear que se cumplen las condiciones para inferir

    • Aleatorio
    • Normal o n_1 \geq 30 y n_2 \geq 30
    • Independiente (muestra en ambas poblaciones no debe ser superior al 10%)

    Fórmula para calcular intervalo de confianza para la la diferencia entre las medias

    (\overline{x_1}-\overline{x_2} ) + t · \sqrt{\frac{S_1^2}{n_1}+\frac{S_2^2}{n_2}}

    Recuerda que \sigma_{\overline{x_1}-\overline{x_2} } = \sqrt{\frac{S_1^2}{n_1}+\frac{S_2^2}{n_2}}

    Two-sample t test for difference of means (Prueba t de dos muestras para la diferencia de medias)

    La fórmula para obtener el valor t de la diferencia de dos muestras,

    t = \frac{\overline{x_A}-\overline{x_B}}{\sqrt{\frac{S_A^2}{n_A}+\frac{S_B^2}{n_B}}}

    Si no disponemos de un software para realizar el cálculo para los grados de libertad, usaremos el (valor n más pequeño – 1) o , min((n_A-1),(n_B-1))

  • Inferencia para «Categorical data» (resumen)

    Este es un resumen de la unidad «Inference for categorical data: Proportions» de Khan Academy.

    Confidence Interval

    Aquí un simulador de Intervalos de Confianza

    Condiciones para un Intervalo de Confianza válido (MUY IMPORTANTE):

    • Random Sample: Los datos deben proceder de una muestra aleatoria o de un ensayo aleatorio.
    • Normal condition: La distribución del muestreo ha de ser aproximadamente normal. n\hat{P}\geq 10 y n(1-\hat{P})\geq 10 (ambas probabilidades).
    • Independence condition: Las observaciones individuales deben ser independientes. Si el muestreo es sin reemplazo, el tamaño de nuestra muestra ha de ser n<10\% .

    Para utilizar la fórmula de la desviación estándar de

    σp^=P(1−P)n

    necesitamos que las observaciones individuales sean independientes.

    Si no disponemos de la P global, podemos usar el de la muestra, pero entonces lo llamaremos Error Estandar (Standar Error).

    SE_\hat{P}=\sqrt{\frac{\hat{P}(1-\hat{P})}{n}}

    Valor crítico Z dado el valor de un intérvalo de confianza

    Para cálcular el intervalo de confianza será

    \hat{P}\pm \space (Z \cdot {SE_\hat{P}})

    Donde Z lo obtenemos de la inversa (tabla valor Z) sobre el intérvalo de confianza que queremos obtener.

    Por ejemplo, un CI (Confidence Interval) de 95%, seria el valor Z de 97.5%. Por qué? Mira el video de Khan Academy.

    Yo uso el truquillo de \frac{(100-CI)}{2}+CI

    \frac{(100-95)}{2}+95 = 97.5

    También uso la función de la calculadora Casio, «Dis. n. acum. inv» que me devuelve el valor. O para excel puedes usar «=INV.NORM(0,95;0;1)» (donde 0,95 es el CI).

    Determinar el tamaño mínimo de una muestra en base a un CI y margen de error

    El valor ideal es cuando \hat{P}=0.5 , por tanto si sabemos que queremos un CI de 99% con un margen de error inferior al 2% (por poner une ejemplo). Primero obtendremos la inversa de Z para 99,5% que es 2.576 aprox. A partir de aquí sabemos que:

    Z \cdot \sqrt{\frac{\hat{P}(1-\hat{P})}{n}} \leq 2\%

    2.576 \cdot \frac{0.5}{\sqrt{n}} \leq 0.02

    aislamos la n

    \frac{(0.5) \cdot (2.576)} {0.02}\leq \sqrt{n}

    64.4^2 \leq n

    4147 \leq n

    Hipótesis Test

    • Definir H_o y H_a.
    • Fijar un nivel de significancia \alpha = x.xx (puede ser 0.05, 0.10, etc…)
    • Tomar un sample. Recuerda que,
      • Random Sample: Los datos deben proceder de una muestra aleatoria o de un ensayo aleatorio.
      • Normal condition: La distribución del muestreo ha de ser aproximadamente normal. n\hat{P}\geq 10 y n(1-\hat{P})\geq 10 (ambas probabilidades).
      • Independence condition: Las observaciones individuales deben ser independientes. Si el muestreo es sin reemplazo, el tamaño de nuestra muestra ha de ser n<10\%
    • Calcular p-value, a partir de cálcular el valor Z.
      • Z=\frac{\hat{P}-P_o}{\sqrt{\frac{P_o (1-P_o)}{n}}} = \frac{\hat{P}-P_o}{\sigma_\hat{P}}
      • Una vez obtenido el valor Z, obtener el valor % para disponer de p-value.
    • Si p-value < \alpha rechazar H_o a favor de H_a
    • Si p-value \geq \alpha no rechazar H_o, pero eso no significa que la aceptemos.

    Errores potenciales cuando se realizan hypotesis test

    Un error de tipo I es cuando rechazamos una hipótesis nula verdadera. Los valores más bajos de \alpha hacen que sea más difícil rechazar la hipótesis nula, por lo que la elección de valores más bajos para \alpha puede reducir la probabilidad de un error de tipo I. La consecuencia es que si la hipótesis nula es falsa, puede ser más difícil de rechazar utilizando un valor bajo de \alpha. Así que el uso de valores más bajos de \alpha puede aumentar la probabilidad de un error de tipo II.
    Un error de tipo II es cuando no se rechaza una hipótesis nula falsa. Los valores más altos de \alpha facilitan el rechazo de la hipótesis nula, por lo que la elección de valores más altos para \alpha puede reducir la probabilidad de un error de tipo II. La consecuencia aquí es que si la hipótesis nula es verdadera, aumentar \alpha hace más probable que cometamos un error de Tipo I (rechazar una hipótesis nula verdadera).

    p-value\space < \alpha \leftarrow reject Ho
    p-value\space \geq \alpha \leftarrow fail to reject Ho

    H_o TrueH_o False
    reject H_oType I errorcorrect conclusion
    fail to reject H_ocorrect conclusiónType II error
    Info extraida del curso de Khan Academy

    Si \alpha aumenta:

    • Power aumenta
    • Probabilidad de Type I error aumenta

    Intervalos de confianza para la diferencia de dos proporciones

    Recuerda que:

    • Random
    • Distribución normal
    • Independencia de los datos (<10% sin reemplazo)

    Y el truquillo de \frac{(100-CI)}{2}+CI (CI = Intervalo de confianza deseado)

    Entonces, el CI para la diferencia entre dos proporciones es,

    Confidence Interval for P_1 - P_2 =({\hat{P}_1 - \hat{P}_2}) \space\pm \space Z \cdot \sigma_{\hat{P}_1 - \hat{P}_2}

    Donde,

    \sigma_{\hat{P}_1 - \hat{P}_2} = \sqrt{{\frac{\hat{P_1}(1-\hat{P_1})}{n}}+{\frac{\hat{P_2}(1-\hat{P_2})}{n}}}

    Prueba de hipótesis para la diferencia de proporciones

    Los pasos son los mismos que en hipotesis test normal, pero teniendo en cuenta que,

    Z = \frac{\hat{P}_A - \hat{P}_B}{\sigma_{\hat{P}_A - \hat{P}_B}}

    Donde,

        \[\sigma_{\hat{P}_A - \hat{P}_B} = \sqrt{{\frac{\hat{P_C}(1-\hat{P_C})}{n_{A}}}+{\frac{\hat{P_C}(1-\hat{P_C})}{n_{B}}}}\]

    \hat{P}_C es el promedio de las sumas \hat{P}_A y \hat{P}_B (sumar subtotales, dividir por suma de totales).

  • Variables aleatorias discretas «Cheat Sheet»

    Fuente: https://www.khanacademy.org/math/ap-statistics/random-variables-ap

    Valor esperado en una variable aleatoria discreta es el resultado promedio a largo plazo. Donde sumamos los productos del valor por la probabilidad de cada evento.

    $$E(X)=\mu_x=x_1p_1+x_2p_2+…+x_np_n$$

    $$=\sum x_i p_i$$

    Pepe vende pollos a l’ast en una bodega, este registra el número de pollos que vende cada día. En la siguiente tabla mostramos la distribución de probabilidad de P=pollos vendidos en un día seleccionado aleatoriamente.

    P=#pollos vendidos0102030
    Probabilidad0.30.50.150.05

    Calcular la media de P.

    $$\mu_P=(0·0.3)+(10·0.5)+(20·0.15)+(30·0.05)=9.5\space pollos$$

    La desviación estandar nos indica cuanto varía cada resultado de la media.

    $$Var(X)=\sigma ^2_X$$

    $$=(x_1-\mu_x)^2p_1+(x_2-\mu_x)^2p_2+…+(x_n-\mu_x)^2p_n$$

    $$=\sum (x_i- \mu _x)^2 p_i$$

    Vamos a calcular la desviación estándar de los pollos

    $$\sigma_P = \sqrt{(0-9.5)^2·0.3+(10-9.5)^2·0.5+(20-9.5)^2·0.15+(30-9.5)^2·0.05 }= \sqrt{64.75} \approx 8.04$$

    Calcular las probabilidades a partir de curvas de densidad:

    $$Z = \frac {(X-\mu)}{\sigma}$$

    Para obtener el valor estadístico, aplicar tabla Z.

    Combinar variables aleatorias normalizadas

    Si tenemos dos variables que son idependientes entre ellas, entonces podemos combinarlas para crear nuevas distribuciones que combinadas facilitan el cálculo estadístico. Vamos al ejemplo,

    MediaVarianza
    Suma: $$T=X+YT$$$$\mu_T=\mu_X + \mu_Y​$$$$\sigma^2_T=\sigma^2_X + \sigma^2_Y$$​
    Diferencia: $$T=X-YT$$$$\mu_T=\mu_X – \mu_Y​$$$$\sigma^2_T=\sigma^2_X + \sigma^2_Y$$​

    Manolo vende pepinos en paquetes de 4. Las masas individuales de cada pepino son normalizadas con una media de 175g, y una desviación estandar de 15g. Asumiendo que los pesos de los pepinos son independientes entre ellos.

    Siendo T = a 4 pepinos seleccionados aleatoriamente.

    Encuentra la probabilidad que el peso total de los pepinos sea superior a 685g.

    $$P(T<685)≈$$

    Calculamos la media de T que es el peso de 4 pepinos de 175g = 700.

    Calculamos la desviación estándard T, que será $$\sqrt{15^2+15^2+15^2+15^2} = 30$$

    Calculamos Z, $$Z= \frac{(685-700)}{30}=-0,5$$

    Buscamos valor en la tabla Z y nos da 0.30854, que es un 30,80% de probabilidades.

    Este ejemplo recoge el caso cuando la densidad es «< que». Cuando la densidad es «> que», hemos de restar 1, cuando está entre dos valores, hemos de calcular la diferencia.

  • Z-table — Tabla Z

    A continuación muestro una tabla Z para que puedas hacer la consulta de valores. Debajo de la tabla encontrarás un enlace para descargar la tabla en formato PDF. Si no sabes cómo usar la tabla Z, hay múltiples tutoriales por internet.

    Z 0,00 -0,01 -0,02 -0,03 -0,04 -0,05 -0,06 -0,07 -0,08 -0,09
    -3.9 0.00005 0.00005 0.00004 0.00004 0.00004 0.00004 0.00004 0.00004 0.00003 0.00003
    -3.8 0.00007 0.00007 0.00007 0.00006 0.00006 0.00006 0.00006 0.00005 0.00005 0.00005
    -3.7 0.00011 0.0001 0.0001 0.0001 0.00009 0.00009 0.00008 0.00008 0.00008 0.00008
    -3.6 0.00016 0.00015 0.00015 0.00014 0.00014 0.00013 0.00013 0.00012 0.00012 0.00011
    -3.5 0.00023 0.00022 0.00022 0.00021 0.0002 0.00019 0.00019 0.00018 0.00017 0.00017
    -3.4 0.00034 0.00032 0.00031 0.0003 0.00029 0.00028 0.00027 0.00026 0.00025 0.00024
    -3.3 0.00048 0.00047 0.00045 0.00043 0.00042 0.0004 0.00039 0.00038 0.00036 0.00035
    -3.2 0.00069 0.00066 0.00064 0.00062 0.0006 0.00058 0.00056 0.00054 0.00052 0.0005
    -3.1 0.00097 0.00094 0.0009 0.00087 0.00084 0.00082 0.00079 0.00076 0.00074 0.00071
    -3 0.00135 0.00131 0.00126 0.00122 0.00118 0.00114 0.00111 0.00107 0.00104 0.001
    -2.9 0.00187 0.00181 0.00175 0.00169 0.00164 0.00159 0.00154 0.00149 0.00144 0.00139
    -2.8 0.00256 0.00248 0.0024 0.00233 0.00226 0.00219 0.00212 0.00205 0.00199 0.00193
    -2.7 0.00347 0.00336 0.00326 0.00317 0.00307 0.00298 0.00289 0.0028 0.00272 0.00264
    -2.6 0.00466 0.00453 0.0044 0.00427 0.00415 0.00402 0.00391 0.00379 0.00368 0.00357
    -2.5 0.00621 0.00604 0.00587 0.0057 0.00554 0.00539 0.00523 0.00508 0.00494 0.0048
    -2.4 0.0082 0.00798 0.00776 0.00755 0.00734 0.00714 0.00695 0.00676 0.00657 0.00639
    -2.3 0.01072 0.01044 0.01017 0.0099 0.00964 0.00939 0.00914 0.00889 0.00866 0.00842
    -2.2 0.0139 0.01355 0.01321 0.01287 0.01255 0.01222 0.01191 0.0116 0.0113 0.01101
    -2.1 0.01786 0.01743 0.017 0.01659 0.01618 0.01578 0.01539 0.015 0.01463 0.01426
    -2 0.02275 0.02222 0.02169 0.02118 0.02068 0.02018 0.0197 0.01923 0.01876 0.01831
    -1.9 0.02872 0.02807 0.02743 0.0268 0.02619 0.02559 0.025 0.02442 0.02385 0.0233
    -1.8 0.03593 0.03515 0.03438 0.03362 0.03288 0.03216 0.03144 0.03074 0.03005 0.02938
    -1.7 0.04457 0.04363 0.04272 0.04182 0.04093 0.04006 0.0392 0.03836 0.03754 0.03673
    -1.6 0.0548 0.0537 0.05262 0.05155 0.0505 0.04947 0.04846 0.04746 0.04648 0.04551
    -1.5 0.06681 0.06552 0.06426 0.06301 0.06178 0.06057 0.05938 0.05821 0.05705 0.05592
    -1.4 0.08076 0.07927 0.0778 0.07636 0.07493 0.07353 0.07215 0.07078 0.06944 0.06811
    -1.3 0.0968 0.0951 0.09342 0.09176 0.09012 0.08851 0.08691 0.08534 0.08379 0.08226
    -1.2 0.11507 0.11314 0.11123 0.10935 0.10749 0.10565 0.10383 0.10204 0.10027 0.09853
    -1.1 0.13567 0.1335 0.13136 0.12924 0.12714 0.12507 0.12302 0.121 0.119 0.11702
    -1 0.15866 0.15625 0.15386 0.15151 0.14917 0.14686 0.14457 0.14231 0.14007 0.13786
    -0.9 0.18406 0.18141 0.17879 0.17619 0.17361 0.17106 0.16853 0.16602 0.16354 0.16109
    -0.8 0.21186 0.20897 0.20611 0.20327 0.20045 0.19766 0.19489 0.19215 0.18943 0.18673
    -0.7 0.24196 0.23885 0.23576 0.2327 0.22965 0.22663 0.22363 0.22065 0.2177 0.21476
    -0.6 0.27425 0.27093 0.26763 0.26435 0.26109 0.25785 0.25463 0.25143 0.24825 0.2451
    -0.5 0.30854 0.30503 0.30153 0.29806 0.2946 0.29116 0.28774 0.28434 0.28096 0.2776
    -0.4 0.34458 0.3409 0.33724 0.3336 0.32997 0.32636 0.32276 0.31918 0.31561 0.31207
    -0.3 0.38209 0.37828 0.37448 0.3707 0.36693 0.36317 0.35942 0.35569 0.35197 0.34827
    -0.2 0.42074 0.41683 0.41294 0.40905 0.40517 0.40129 0.39743 0.39358 0.38974 0.38591
    -0.1 0.46017 0.4562 0.45224 0.44828 0.44433 0.44038 0.43644 0.43251 0.42858 0.42465
    0 0.5 0.49601 0.49202 0.48803 0.48405 0.48006 0.47608 0.4721 0.46812 0.46414

     

    Z 0,00 0,01 0,02 0,03 0,04 0,05 0,06 0,07 0,08 0,09
    0 0.5 0.50399 0.50798 0.51197 0.51595 0.51994 0.52392 0.5279 0.53188 0.53586
    0.1 0.53983 0.5438 0.54776 0.55172 0.55567 0.55962 0.56356 0.56749 0.57142 0.57535
    0.2 0.57926 0.58317 0.58706 0.59095 0.59483 0.59871 0.60257 0.60642 0.61026 0.61409
    0.3 0.61791 0.62172 0.62552 0.6293 0.63307 0.63683 0.64058 0.64431 0.64803 0.65173
    0.4 0.65542 0.6591 0.66276 0.6664 0.67003 0.67364 0.67724 0.68082 0.68439 0.68793
    0.5 0.69146 0.69497 0.69847 0.70194 0.7054 0.70884 0.71226 0.71566 0.71904 0.7224
    0.6 0.72575 0.72907 0.73237 0.73565 0.73891 0.74215 0.74537 0.74857 0.75175 0.7549
    0.7 0.75804 0.76115 0.76424 0.7673 0.77035 0.77337 0.77637 0.77935 0.7823 0.78524
    0.8 0.78814 0.79103 0.79389 0.79673 0.79955 0.80234 0.80511 0.80785 0.81057 0.81327
    0.9 0.81594 0.81859 0.82121 0.82381 0.82639 0.82894 0.83147 0.83398 0.83646 0.83891
    1 0.84134 0.84375 0.84614 0.84849 0.85083 0.85314 0.85543 0.85769 0.85993 0.86214
    1.1 0.86433 0.8665 0.86864 0.87076 0.87286 0.87493 0.87698 0.879 0.881 0.88298
    1.2 0.88493 0.88686 0.88877 0.89065 0.89251 0.89435 0.89617 0.89796 0.89973 0.90147
    1.3 0.9032 0.9049 0.90658 0.90824 0.90988 0.91149 0.91309 0.91466 0.91621 0.91774
    1.4 0.91924 0.92073 0.9222 0.92364 0.92507 0.92647 0.92785 0.92922 0.93056 0.93189
    1.5 0.93319 0.93448 0.93574 0.93699 0.93822 0.93943 0.94062 0.94179 0.94295 0.94408
    1.6 0.9452 0.9463 0.94738 0.94845 0.9495 0.95053 0.95154 0.95254 0.95352 0.95449
    1.7 0.95543 0.95637 0.95728 0.95818 0.95907 0.95994 0.9608 0.96164 0.96246 0.96327
    1.8 0.96407 0.96485 0.96562 0.96638 0.96712 0.96784 0.96856 0.96926 0.96995 0.97062
    1.9 0.97128 0.97193 0.97257 0.9732 0.97381 0.97441 0.975 0.97558 0.97615 0.9767
    2.0 0.97725 0.97778 0.97831 0.97882 0.97932 0.97982 0.9803 0.98077 0.98124 0.98169
    2.1 0.98214 0.98257 0.983 0.98341 0.98382 0.98422 0.98461 0.985 0.98537 0.98574
    2.2 0.9861 0.98645 0.98679 0.98713 0.98745 0.98778 0.98809 0.9884 0.9887 0.98899
    2.3 0.98928 0.98956 0.98983 0.9901 0.99036 0.99061 0.99086 0.99111 0.99134 0.99158
    2.4 0.9918 0.99202 0.99224 0.99245 0.99266 0.99286 0.99305 0.99324 0.99343 0.99361
    2.5 0.99379 0.99396 0.99413 0.9943 0.99446 0.99461 0.99477 0.99492 0.99506 0.9952
    2.6 0.99534 0.99547 0.9956 0.99573 0.99585 0.99598 0.99609 0.99621 0.99632 0.99643
    2.7 0.99653 0.99664 0.99674 0.99683 0.99693 0.99702 0.99711 0.9972 0.99728 0.99736
    2.8 0.99744 0.99752 0.9976 0.99767 0.99774 0.99781 0.99788 0.99795 0.99801 0.99807
    2.9 0.99813 0.99819 0.99825 0.99831 0.99836 0.99841 0.99846 0.99851 0.99856 0.99861
    3.0 0.99865 0.99869 0.99874 0.99878 0.99882 0.99886 0.99889 0.99893 0.99896 0.999
    3.1 0.99903 0.99906 0.9991 0.99913 0.99916 0.99918 0.99921 0.99924 0.99926 0.99929
    3.2 0.99931 0.99934 0.99936 0.99938 0.9994 0.99942 0.99944 0.99946 0.99948 0.9995
    3.3 0.99952 0.99953 0.99955 0.99957 0.99958 0.9996 0.99961 0.99962 0.99964 0.99965
    3.4 0.99966 0.99968 0.99969 0.9997 0.99971 0.99972 0.99973 0.99974 0.99975 0.99976
    3.5 0.99977 0.99978 0.99978 0.99979 0.9998 0.99981 0.99981 0.99982 0.99983 0.99983
    3.6 0.99984 0.99985 0.99985 0.99986 0.99986 0.99987 0.99987 0.99988 0.99988 0.99989
    3.7 0.99989 0.9999 0.9999 0.9999 0.99991 0.99991 0.99992 0.99992 0.99992 0.99992
    3.8 0.99993 0.99993 0.99993 0.99994 0.99994 0.99994 0.99994 0.99995 0.99995 0.99995
    3.9 0.99995 0.99995 0.99996 0.99996 0.99996 0.99996 0.99996 0.99996 0.99997 0.99997

    Puedes descargar una versión en PDF de tabla Z