{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Investigación de Operaciones · Clase 6\n",
    "## Una pregunta que Excel no puede responder bien\n",
    "\n",
    "**Universidad Jorge Tadeo Lozano** · Elkin Rodríguez E.\n",
    "\n",
    "---\n",
    "\n",
    "Hoy **no vamos a rehacer el modelo en Python**. Ya lo armaron en Excel y funciona.\n",
    "\n",
    "Vamos a hacer **una sola pregunta** que en Excel costaría quince corridas manuales del Solver:\n",
    "\n",
    "> El modelo recomienda mandar al experto lejos **porque una segunda visita cuesta $120.000**.\n",
    ">\n",
    "> ¿Y si costara $40.000? ¿Y si costara $300.000?\n",
    ">\n",
    "> **¿En qué punto exacto cambia la recomendación?**\n",
    "\n",
    "Nadie sabe con certeza cuánto cuesta una segunda visita. Pero sí se puede decir **a partir de qué valor la respuesta cambia** — y eso convierte una discusión de opiniones en una pregunta con respuesta.\n",
    "\n",
    "**Las celdas ya están escritas. Solo córranlas.**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "## Paso 0 · Preparar el ambiente"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "!pip install pulp -q"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pulp\n",
    "print(\"Listo. PuLP\", pulp.__version__)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "## Paso 1 · Los datos de ServiTech\n",
    "\n",
    "Son exactamente los mismos que tienen en su Excel."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "TEC   = [\"Andrea\",\"Bryan\",\"Camilo\",\"Diana\",\"Esteban\",\"Fabian\"]\n",
    "ORD   = [\"Nevera Bosa\",\"Lavadora Kennedy\",\"Aire Usaquén\",\n",
    "         \"Estufa Suba\",\"Nevera Chapinero\",\"Aire Fontibón\"]\n",
    "\n",
    "# minutos de viaje: técnico i -> orden j\n",
    "TIEMPO = [[75,65,10,30,25,50],\n",
    "          [75,65,10,30,25,50],\n",
    "          [60,50,25,45,10,40],\n",
    "          [20,10,65,55,50,25],\n",
    "          [20,10,65,55,50,25],\n",
    "          [30,25,50,40,40,10]]\n",
    "\n",
    "# nivel de dominio: 1 experto · 2 medio · 3 basico\n",
    "NIVEL  = [[1,3,3,3,1,3],\n",
    "          [3,1,3,3,3,3],\n",
    "          [3,3,1,3,3,1],\n",
    "          [3,3,3,1,3,3],\n",
    "          [2,2,2,2,2,2],\n",
    "          [3,3,1,3,3,1]]\n",
    "\n",
    "# 1 si puede hacerla (certificación en aires), 0 si no\n",
    "PERMISO = [[1,1,0,1,1,0],\n",
    "           [1,1,0,1,1,0],\n",
    "           [1,1,1,1,1,1],\n",
    "           [1,1,0,1,1,0],\n",
    "           [1,1,1,1,1,1],\n",
    "           [1,1,1,1,1,1]]\n",
    "\n",
    "COSTO_MINUTO = 800\n",
    "RIESGO = {1:0.05, 2:0.20, 3:0.40}\n",
    "\n",
    "print(\"6 técnicos x 6 órdenes =\", 6*6, \"decisiones\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "## Paso 2 · El modelo, en una función\n",
    "\n",
    "Es el mismo que armaron en Excel. La única diferencia: aquí lo podemos correr **muchas veces seguidas** cambiando un parámetro.\n",
    "\n",
    "`objetivo=\"viaje\"` es el Plan A · `objetivo=\"total\"` es el Plan B."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def resolver(costo_revisita, objetivo=\"total\"):\n",
    "    \"\"\"objetivo:\n",
    "       \"total\"   -> Plan B: minimiza viaje + reproceso\n",
    "       \"viaje\"   -> Plan A: minimiza SOLO el viaje, desempatando por reproceso.\n",
    "                    El desempate es importante: hay varios planes que viajan lo\n",
    "                    mismo, y le damos al despachador el MEJOR de ellos.\n",
    "    \"\"\"\n",
    "    n = 6\n",
    "    prob = pulp.LpProblem(\"servitech\", pulp.LpMinimize)\n",
    "    x = pulp.LpVariable.dicts(\"x\", (range(n), range(n)), cat=\"Binary\")\n",
    "\n",
    "    def costo(i, j):\n",
    "        viaje = TIEMPO[i][j] * COSTO_MINUTO\n",
    "        repro = RIESGO[NIVEL[i][j]] * costo_revisita\n",
    "        if objetivo == \"total\":\n",
    "            return viaje + repro\n",
    "        return viaje * 1000 + repro        # viaje manda; reproceso desempata\n",
    "\n",
    "    prob += pulp.lpSum(costo(i,j) * x[i][j] for i in range(n) for j in range(n))\n",
    "    for i in range(n): prob += pulp.lpSum(x[i][j] for j in range(n)) == 1\n",
    "    for j in range(n): prob += pulp.lpSum(x[i][j] for i in range(n)) == 1\n",
    "    for i in range(n):\n",
    "        for j in range(n):\n",
    "            if PERMISO[i][j] == 0:\n",
    "                prob += x[i][j] == 0\n",
    "\n",
    "    prob.solve(pulp.PULP_CBC_CMD(msg=0))\n",
    "    sel = [(i,j) for i in range(n) for j in range(n) if x[i][j].value() > 0.5]\n",
    "    minutos = sum(TIEMPO[i][j] for i,j in sel)\n",
    "    viaje   = minutos * COSTO_MINUTO\n",
    "    repro   = sum(RIESGO[NIVEL[i][j]] * costo_revisita for i,j in sel)\n",
    "    expertos= sum(1 for i,j in sel if NIVEL[i][j] == 1)\n",
    "    return minutos, viaje, repro, viaje + repro, expertos\n",
    "\n",
    "a = resolver(120000, \"viaje\")\n",
    "b = resolver(120000, \"total\")\n",
    "print(\"Con la revisita en $120.000\")\n",
    "print(f\"   Plan A: {a[0]:>3} min · total ${a[3]:>9,.0f} · expertos {a[4]}/6\")\n",
    "print(f\"   Plan B: {b[0]:>3} min · total ${b[3]:>9,.0f} · expertos {b[4]}/6\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "## Paso 3 · El barrido\n",
    "\n",
    "Ahora la pregunta de verdad. Corremos el modelo **quince veces**, con la revisita costando desde $0 hasta $400.000.\n",
    "\n",
    "En Excel esto serían quince configuraciones manuales del Solver, anotando a mano cada resultado."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(f\"{'revisita':>10} | {'Plan A':>12} {'Plan B':>12} | {'ahorro':>10} | expertos B\")\n",
    "print(\"-\"*68)\n",
    "\n",
    "quiebre = None\n",
    "for cr in range(0, 400001, 25000):\n",
    "    _, _, _, total_a, _  = resolver(cr, \"viaje\")\n",
    "    _, _, _, total_b, eb = resolver(cr, \"total\")\n",
    "    ahorro = total_a - total_b\n",
    "    if quiebre is None and ahorro > 0:\n",
    "        quiebre = cr\n",
    "    print(f\"{cr:>10,} | {total_a:>12,.0f} {total_b:>12,.0f} | {ahorro:>10,.0f} | {eb}/6\")\n",
    "\n",
    "print()\n",
    "print(f\"Hasta ${quiebre-25000:,} los dos planes cuestan lo mismo.\")\n",
    "print(f\"El Plan B empieza a convenir cuando la revisita pasa de ${quiebre:,}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Cómo se lee eso\n",
    "\n",
    "- Mientras la revisita sea **barata**, los dos planes cuestan casi lo mismo: no vale la pena viajar por un experto.\n",
    "- A partir del punto de quiebre, el Plan B se despega y **el ahorro crece**.\n",
    "- Y a medida que la revisita encarece, el modelo manda **cada vez más expertos**, aunque queden lejos.\n",
    "\n",
    "**El argumento para el comité:** *\"mandar al experto conviene siempre que una segunda visita nos cueste más de X. ¿Nos cuesta más o menos que eso?\"*"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "## Paso 4 · Lo mismo, con la otra palanca\n",
    "\n",
    "El punto de quiebre depende de **dos** cosas: lo que cuesta la revisita y lo que cuesta el minuto de viaje.\n",
    "\n",
    "Si la gasolina sube, viajar se encarece y conviene menos ir por el experto. Miren."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "original = COSTO_MINUTO\n",
    "\n",
    "print(f\"{'$/minuto':>10} | revisita a partir de la cual conviene el Plan B\")\n",
    "print(\"-\"*58)\n",
    "for cm in [400, 800, 1200, 1600, 2000]:\n",
    "    COSTO_MINUTO = cm\n",
    "    q = None\n",
    "    for cr in range(0, 800001, 5000):\n",
    "        _, _, _, ta, _ = resolver(cr, \"viaje\")\n",
    "        _, _, _, tb, _ = resolver(cr, \"total\")\n",
    "        if ta - tb > 0:\n",
    "            q = cr; break\n",
    "    print(f\"{cm:>10,} | \" + (f\"${q:,}\" if q else \"nunca conviene\"))\n",
    "\n",
    "COSTO_MINUTO = original\n",
    "print()\n",
    "print(\"Entre mas caro el minuto de viaje, mas cara tiene que ser la revisita\")\n",
    "print(\"para que valga la pena mandar al experto lejos.\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "## Cierre\n",
    "\n",
    "**Lo que acaban de hacer no es programar. Es hacerle preguntas al modelo.**\n",
    "\n",
    "| | En Excel | Aquí |\n",
    "|---|---|---|\n",
    "| Correr el modelo una vez | ✅ perfecto | igual |\n",
    "| Correrlo 15 veces cambiando un dato | 15 configuraciones a mano | **un ciclo** |\n",
    "| Cruzar dos parámetros a la vez | inviable | **cinco líneas** |\n",
    "\n",
    "El modelo es **el mismo que armaron en Excel**. Lo único que cambió es que aquí se le puede preguntar *\"¿y si…?\"* muchas veces seguidas.\n",
    "\n",
    "**Y esa pregunta —a partir de qué valor cambia la recomendación— es la que se lleva a un comité.**"
   ]
  }
 ],
 "metadata": {
  "colab": {
   "provenance": [],
   "toc_visible": true
  },
  "kernelspec": {
   "display_name": "Python 3",
   "name": "python3"
  },
  "language_info": {
   "name": "python"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 0
}