o1/Azure OpenAI o1 mini examples.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "de69cdc1-399e-47e6-ae0c-b2fb7b80c78c",
   "metadata": {},
   "source": [
    "# Azure OpenAI o1-mini examples\n",
    "\n",
    "Azure OpenAI o-series models are designed to tackle reasoning and problem-solving tasks with increased focus and capability. These models spend more time processing and understanding the user's request, making them exceptionally strong in areas like science, coding, and math compared to previous iterations.\n",
    "\n",
    "<img src=\"o1.jpg\" width=300>\n",
    "\n",
    "### Key capabilities of the o-series models:\n",
    "\n",
    "- **Complex Code Generation:** Capable of generating algorithms and handling advanced coding tasks to support developers.\n",
    "- **Advanced Problem Solving:** Ideal for comprehensive brainstorming sessions and addressing multifaceted challenges.\n",
    "- **Complex Document Comparison:** Perfect for analyzing contracts, case files, or legal documents to identify subtle differences.\n",
    "- **Instruction Following and Workflow Management:** Particularly effective for managing workflows requiring shorter contexts.\n",
    "\n",
    "### Links\n",
    "- Documentation: https://learn.microsoft.com/en-us/azure/ai-services/openai/how-to/reasoning?tabs=python<br>\n",
    "- API & feature support: https://learn.microsoft.com/en-us/azure/ai-services/openai/how-to/reasoning?tabs=python#api--feature-support\n",
    "- https://learn.microsoft.com/en-us/azure/ai-services/openai/concepts/models?tabs=global-standard%2Cstandard-chat-completions#o-series-models<br>\n",
    "- Prompt recommandation: https://techcommunity.microsoft.com/blog/Azure-AI-Services-blog/prompt-engineering-for-openai%E2%80%99s-o1-and-o3-mini-reasoning-models/4374010"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "57cd614d-8fcb-4bf9-887e-43faace8f6c5",
   "metadata": {},
   "outputs": [],
   "source": [
    "import datetime\n",
    "import openai\n",
    "import os\n",
    "import sys\n",
    "\n",
    "from dotenv import load_dotenv\n",
    "from openai import AzureOpenAI\n",
    "from IPython.display import display, Markdown"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "342ae966-b85f-454e-a666-ae8b107c3b8f",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Today is 12-Feb-2025 08:58:37\n"
     ]
    }
   ],
   "source": [
    "print(f\"Today is {datetime.datetime.today().strftime('%d-%b-%Y %H:%M:%S')}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "337ec4b6-9359-436f-b591-9d310ad61765",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Python version: 3.10.14 (main, May  6 2024, 19:42:50) [GCC 11.2.0]\n",
      "OpenAI version: 1.61.1\n"
     ]
    }
   ],
   "source": [
    "print(f\"Python version: {sys.version}\")\n",
    "print(f\"OpenAI version: {openai.__version__}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "023c321d-b6af-42eb-b17b-1155e8cc4a0f",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "OK\n"
     ]
    }
   ],
   "source": [
    "print('OK') if load_dotenv(\"azure.env\") else print('ERROR: Check file location or name.')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "24ab513d-fc74-4f1a-8d1e-63a701af2097",
   "metadata": {},
   "source": [
    "## Settings"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "ba0696b4-e372-4792-86b5-3b2e530c881c",
   "metadata": {},
   "outputs": [],
   "source": [
    "model = \"o1-mini\"  # As deployed in Azure AI Foundry\n",
    "\n",
    "api_version = \"2025-01-01-preview\"  # Subject to change"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "f4dc6641-7d2f-4dd2-ada2-0f31180e7dbf",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "We will use o1-mini from Azure AI Foundry\n"
     ]
    }
   ],
   "source": [
    "print(f\"We will use {model} from Azure AI Foundry\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "58a04462-45d9-48da-9fcf-1e9b4ce3aa07",
   "metadata": {},
   "outputs": [],
   "source": [
    "def cost(input_tokens: int, completion_tokens: int) -> float:\n",
    "    \"\"\"\n",
    "    Calculates the total cost in EUR for the given number of input and completion tokens for o1 mini in Sweden central.\n",
    "    Args:\n",
    "        input_tokens (int): The number of input tokens.\n",
    "        completion_tokens (int): The number of completion tokens.\n",
    "    Returns:\n",
    "        float: The total cost in EUR.\n",
    "    \"\"\"\n",
    "    inp_cost_eur = 2.8791 / 1_000_000\n",
    "    out_cost_eur = 11.516315 / 1_000_000\n",
    "    total_cost_eur = (input_tokens * inp_cost_eur) + (completion_tokens * out_cost_eur)\n",
    "    return total_cost_eur"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "2489ccc8-8bdb-42b2-b4a1-ae261c597f4a",
   "metadata": {},
   "outputs": [],
   "source": [
    "def o1mini(prompt:str):\n",
    "    \"\"\"\n",
    "    Sends a chat completion request to the Azure OpenAI API o1 mini model.\n",
    "    Args:\n",
    "        prompt (str): The input prompt to generate a response for.\n",
    "    Returns:\n",
    "        response (openai.Completion): The response object containing the generated completion.\n",
    "    \"\"\" \n",
    "    try:\n",
    "        # Azure OpenAI client\n",
    "        aoai_client = AzureOpenAI(\n",
    "            azure_endpoint=os.getenv(\"AZURE_OPENAI_ENDPOINT\"),\n",
    "            api_key=os.getenv(\"AZURE_OPENAI_API_KEY\"),\n",
    "            api_version=api_version,\n",
    "        )\n",
    "        # Calling the model\n",
    "        response = aoai_client.chat.completions.create(\n",
    "            model=model,\n",
    "            messages=[{\"role\": \"user\", \"content\": prompt}],\n",
    "            max_completion_tokens=16384,\n",
    "        )\n",
    "        return response\n",
    "\n",
    "    except Exception as e:\n",
    "        print(f\"[ERROR] {e}\")\n",
    "        return None"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c9fa3501-a7c5-4044-bcc4-069be4bc5313",
   "metadata": {},
   "source": [
    "## Quick test"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "398b5d87-04d9-4291-87f8-14149d2cb99a",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello! I’m ChatGPT, an artificial intelligence language model developed by OpenAI. I’m here to help answer your questions, provide information, and assist with a wide range of topics. How can I assist you today?\n"
     ]
    }
   ],
   "source": [
    "prompt = \"Who are you?\"\n",
    "\n",
    "resp = o1mini(prompt)\n",
    "print(resp.choices[0].message.content)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "ef169772-fd4b-415a-bb5b-35bea250b890",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "CompletionUsage(completion_tokens=440, prompt_tokens=11, total_tokens=451, completion_tokens_details=CompletionTokensDetails(accepted_prediction_tokens=None, audio_tokens=None, reasoning_tokens=384, rejected_prediction_tokens=None), prompt_tokens_details=PromptTokensDetails(audio_tokens=None, cached_tokens=0))"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "resp.usage"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "801003e4-56fc-44ba-b68e-e55e6bc875a1",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\u001b[1;34m\n",
      "{\n",
      "    \"id\": \"chatcmpl-B02rlKdBSzcdxwo67fZdcU7jfHp5e\",\n",
      "    \"choices\": [\n",
      "        {\n",
      "            \"finish_reason\": \"stop\",\n",
      "            \"index\": 0,\n",
      "            \"logprobs\": null,\n",
      "            \"message\": {\n",
      "                \"content\": \"Hello! I’m ChatGPT, an artificial intelligence language model developed by OpenAI. I’m here to help answer your questions, provide information, and assist with a wide range of topics. How can I assist you today?\",\n",
      "                \"refusal\": null,\n",
      "                \"role\": \"assistant\",\n",
      "                \"audio\": null,\n",
      "                \"function_call\": null,\n",
      "                \"tool_calls\": null\n",
      "            },\n",
      "            \"content_filter_results\": {\n",
      "                \"hate\": {\n",
      "                    \"filtered\": false,\n",
      "                    \"severity\": \"safe\"\n",
      "                },\n",
      "                \"self_harm\": {\n",
      "                    \"filtered\": false,\n",
      "                    \"severity\": \"safe\"\n",
      "                },\n",
      "                \"sexual\": {\n",
      "                    \"filtered\": false,\n",
      "                    \"severity\": \"safe\"\n",
      "                },\n",
      "                \"violence\": {\n",
      "                    \"filtered\": false,\n",
      "                    \"severity\": \"safe\"\n",
      "                }\n",
      "            }\n",
      "        }\n",
      "    ],\n",
      "    \"created\": 1739350717,\n",
      "    \"model\": \"o1-mini-2024-09-12\",\n",
      "    \"object\": \"chat.completion\",\n",
      "    \"service_tier\": null,\n",
      "    \"system_fingerprint\": \"fp_f6ff3bb326\",\n",
      "    \"usage\": {\n",
      "        \"completion_tokens\": 440,\n",
      "        \"prompt_tokens\": 11,\n",
      "        \"total_tokens\": 451,\n",
      "        \"completion_tokens_details\": {\n",
      "            \"accepted_prediction_tokens\": null,\n",
      "            \"audio_tokens\": null,\n",
      "            \"reasoning_tokens\": 384,\n",
      "            \"rejected_prediction_tokens\": null\n",
      "        },\n",
      "        \"prompt_tokens_details\": {\n",
      "            \"audio_tokens\": null,\n",
      "            \"cached_tokens\": 0\n",
      "        }\n",
      "    },\n",
      "    \"prompt_filter_results\": [\n",
      "        {\n",
      "            \"prompt_index\": 0,\n",
      "            \"content_filter_results\": {\n",
      "                \"hate\": {\n",
      "                    \"filtered\": false,\n",
      "                    \"severity\": \"safe\"\n",
      "                },\n",
      "                \"jailbreak\": {\n",
      "                    \"filtered\": false,\n",
      "                    \"detected\": false\n",
      "                },\n",
      "                \"self_harm\": {\n",
      "                    \"filtered\": false,\n",
      "                    \"severity\": \"safe\"\n",
      "                },\n",
      "                \"sexual\": {\n",
      "                    \"filtered\": false,\n",
      "                    \"severity\": \"safe\"\n",
      "                },\n",
      "                \"violence\": {\n",
      "                    \"filtered\": false,\n",
      "                    \"severity\": \"safe\"\n",
      "                }\n",
      "            }\n",
      "        }\n",
      "    ]\n",
      "}\n"
     ]
    }
   ],
   "source": [
    "print(\"\\033[1;34m\")\n",
    "print(resp.model_dump_json(indent=4))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "002465cf-f002-42f5-83e7-96c3e58e768f",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Hello! I’m ChatGPT, an artificial intelligence language model developed by OpenAI. I’m here to help answer your questions, provide information, and assist with a wide range of topics. How can I assist you today?'"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "resp.choices[0].message.content"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "022b0711-4443-4d25-9726-ac3ae628a67d",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'o1-mini-2024-09-12'"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "resp.model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "e293ce40-2d23-4869-b9ec-0c718c9ad97d",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2025-02-12 08:58:37\n"
     ]
    }
   ],
   "source": [
    "print(datetime.datetime.fromtimestamp(resp.created).strftime(\"%Y-%m-%d %H:%M:%S\"))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "ff747fb2-17e2-4985-bf89-ec6698c0beb9",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Prompt tokens = 11 | Completion tokens = 440 | Total tokens = 451\n"
     ]
    }
   ],
   "source": [
    "print(f\"Prompt tokens = {resp.usage.prompt_tokens} | Completion tokens = {resp.usage.completion_tokens} | Total tokens = {resp.usage.total_tokens}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "53bfaa70-0376-478f-8a49-d41729be1ce6",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Total cost = 0.005099 €\n"
     ]
    }
   ],
   "source": [
    "total_cost = cost(resp.usage.prompt_tokens, resp.usage.completion_tokens)\n",
    "print(f\"Total cost = {total_cost:.6f} €\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9aab26b7-217f-4b90-83c1-e30c20f1636f",
   "metadata": {},
   "source": [
    "## Basic example"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "502550bc-5e28-40ce-9176-92a1955bc12c",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/markdown": [
       "As of my knowledge cutoff in October 2023, the \"o1\" and \"o1-mini\" generative AI (genAI) models represent two variants within a model family, designed to cater to different needs based on resource availability, performance requirements, and specific use cases. Below is a comprehensive comparison between **o1** and **o1-mini** across various dimensions:\n",
       "\n",
       "### 1. **Size and Complexity**\n",
       "\n",
       "- **o1 Model:**\n",
       "  - **Parameters:** Typically larger, with a higher number of parameters (e.g., 1 billion parameters).\n",
       "  - **Layers:** More layers and complex architecture, allowing for deeper feature extraction and understanding.\n",
       "  - **Memory Footprint:** Requires more memory for training and inference, making it suitable for environments with ample computational resources.\n",
       "\n",
       "- **o1-mini Model:**\n",
       "  - **Parameters:** Significantly smaller, often in the range of hundreds of millions of parameters (e.g., 300 million parameters).\n",
       "  - **Layers:** Fewer layers, resulting in a simpler architecture.\n",
       "  - **Memory Footprint:** Optimized for lower memory usage, enabling deployment on devices with limited hardware capabilities.\n",
       "\n",
       "### 2. **Performance**\n",
       "\n",
       "- **o1 Model:**\n",
       "  - **Accuracy:** Higher accuracy and better performance on complex tasks due to its larger size and deeper architecture.\n",
       "  - **Understanding:** Superior at capturing nuanced language patterns, context, and generating more coherent and contextually relevant outputs.\n",
       "  - **Inference Speed:** Generally slower inference times due to the model's size, which might require specialized hardware for optimal performance.\n",
       "\n",
       "- **o1-mini Model:**\n",
       "  - **Accuracy:** Slightly lower accuracy compared to the o1 model but still robust for a wide range of applications.\n",
       "  - **Understanding:** Adequate for handling straightforward tasks and maintaining reasonable context, though it may struggle with highly complex queries.\n",
       "  - **Inference Speed:** Faster inference times, making it suitable for real-time applications and scenarios where quick responses are essential.\n",
       "\n",
       "### 3. **Use Cases**\n",
       "\n",
       "- **o1 Model:**\n",
       "  - **Complex Applications:** Suitable for tasks requiring deep understanding, such as advanced natural language understanding, detailed content generation, complex problem-solving, and nuanced conversational agents.\n",
       "  - **Research and Development:** Ideal for AI research where performance and depth are prioritized.\n",
       "  - **Enterprise Solutions:** Used in applications where accuracy and comprehensive analysis are critical, such as legal document analysis, medical diagnoses support, and detailed data analytics.\n",
       "\n",
       "- **o1-mini Model:**\n",
       "  - **Lightweight Applications:** Perfect for applications with limited computational resources, such as mobile apps, IoT devices, and browser-based tools.\n",
       "  - **Real-Time Systems:** Suitable for chatbots, virtual assistants, and customer support tools that require quick response times.\n",
       "  - **Cost-Sensitive Deployments:** Ideal for startups or projects with budget constraints where deploying larger models like o1 may not be feasible.\n",
       "\n",
       "### 4. **Architecture**\n",
       "\n",
       "- **o1 Model:**\n",
       "  - **Layer Depth:** Deeper neural network with more layers, allowing for complex feature hierarchies and better abstraction capabilities.\n",
       "  - **Attention Mechanisms:** Enhanced attention mechanisms to better capture long-range dependencies and contextual information.\n",
       "  - **Optimization Techniques:** Utilizes advanced optimization algorithms and regularization techniques to improve performance and prevent overfitting.\n",
       "\n",
       "- **o1-mini Model:**\n",
       "  - **Layer Depth:** Shallower neural network with fewer layers to reduce computational complexity.\n",
       "  - **Attention Mechanisms:** Simplified attention mechanisms to maintain efficiency while still capturing essential context.\n",
       "  - **Optimization Techniques:** Streamlined optimization processes to accelerate training and inference, possibly at the expense of some representational capacity.\n",
       "\n",
       "### 5. **Deployment and Scalability**\n",
       "\n",
       "- **o1 Model:**\n",
       "  - **Deployment:** Typically deployed on powerful servers, cloud infrastructures, or specialized hardware like GPUs and TPUs to handle the computational demands.\n",
       "  - **Scalability:** While highly scalable in terms of handling large-scale data and complex queries, scaling may require significant infrastructure investment.\n",
       "\n",
       "- **o1-mini Model:**\n",
       "  - **Deployment:** Easily deployable on edge devices, smartphones, and environments with limited infrastructure.\n",
       "  - **Scalability:** Offers better scalability in resource-constrained environments, allowing for broader distribution without the need for extensive hardware resources.\n",
       "\n",
       "### 6. **Cost Considerations**\n",
       "\n",
       "- **o1 Model:**\n",
       "  - **Training Costs:** Higher costs associated with training due to the need for extensive computational resources and longer training times.\n",
       "  - **Operational Costs:** Increased operational expenses for deployment, maintenance, and scaling.\n",
       "\n",
       "- **o1-mini Model:**\n",
       "  - **Training Costs:** Lower training costs owing to reduced model size and faster training times.\n",
       "  - **Operational Costs:** More economical to deploy and maintain, especially at scale or in distributed environments.\n",
       "\n",
       "### **Conclusion**\n",
       "\n",
       "The **o1** and **o1-mini** genAI models offer distinct advantages tailored to different needs:\n",
       "\n",
       "- **Choose the **o1** model** when high accuracy, deep understanding, and handling of complex tasks are paramount, and when you have the necessary computational resources to support its deployment and operation.\n",
       "\n",
       "- **Opt for the **o1-mini** model** when resource efficiency, faster inference, and cost-effectiveness are critical, making it ideal for real-time applications, deployment on edge devices, or scenarios with budget and infrastructure constraints.\n",
       "\n",
       "Selecting between these models depends on the specific requirements of your application, the available resources, and the desired balance between performance and efficiency."
      ],
      "text/plain": [
       "<IPython.core.display.Markdown object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "prompt = \"What are the differences between o1 and o1-mini genAI models in terms of size and complexity, performance, usecases and architecture?\"\n",
    "\n",
    "resp = o1mini(prompt)\n",
    "display(Markdown(resp.choices[0].message.content))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "19441ce2-15ca-421a-b8fa-a71d34630bfa",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Prompt tokens = 35 | Completion tokens = 1646 | Total tokens = 1681\n"
     ]
    }
   ],
   "source": [
    "print(f\"Prompt tokens = {resp.usage.prompt_tokens} | Completion tokens = {resp.usage.completion_tokens} | Total tokens = {resp.usage.total_tokens}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4e79e7cc-31b4-47c4-9b2e-7cd9da506a38",
   "metadata": {},
   "source": [
    "### Solving example"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "id": "e1133a30-038f-4279-a620-fb1cd466b0d8",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/markdown": [
       "To solve the quadratic equation:\n",
       "\n",
       "\\[ 3x^2 + 5x - 2 = 0 \\]\n",
       "\n",
       "we can use the **quadratic formula**, which is given by:\n",
       "\n",
       "\\[ x = \\frac{-b \\pm \\sqrt{b^2 - 4ac}}{2a} \\]\n",
       "\n",
       "Here, the coefficients are:\n",
       "- \\( a = 3 \\)\n",
       "- \\( b = 5 \\)\n",
       "- \\( c = -2 \\)\n",
       "\n",
       "**Step 1: Calculate the discriminant (\\( \\Delta \\))**\n",
       "\\[ \\Delta = b^2 - 4ac = (5)^2 - 4(3)(-2) = 25 + 24 = 49 \\]\n",
       "\n",
       "**Step 2: Compute the square root of the discriminant**\n",
       "\\[ \\sqrt{\\Delta} = \\sqrt{49} = 7 \\]\n",
       "\n",
       "**Step 3: Apply the quadratic formula**\n",
       "\\[ x = \\frac{-5 \\pm 7}{2 \\times 3} \\]\n",
       "\\[ x = \\frac{-5 \\pm 7}{6} \\]\n",
       "\n",
       "**Step 4: Find the two solutions**\n",
       "\n",
       "1. **First solution (\\( + \\))**:\n",
       "   \\[ x = \\frac{-5 + 7}{6} = \\frac{2}{6} = \\frac{1}{3} \\]\n",
       "\n",
       "2. **Second solution (\\( - \\))**:\n",
       "   \\[ x = \\frac{-5 - 7}{6} = \\frac{-12}{6} = -2 \\]\n",
       "\n",
       "**Final Answer:**\n",
       "\\[ x = \\frac{1}{3} \\quad \\text{and} \\quad x = -2 \\]"
      ],
      "text/plain": [
       "<IPython.core.display.Markdown object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "prompt = \"Solve for x in the equation 3x^2 + 5x - 2 = 0\"\n",
    "\n",
    "resp = o1mini(prompt)\n",
    "display(Markdown(resp.choices[0].message.content))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "id": "139a7e60-e759-4b4a-9989-069d0e0f829d",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Prompt tokens = 29 | Completion tokens = 551 | Total tokens = 580\n"
     ]
    }
   ],
   "source": [
    "print(f\"Prompt tokens = {resp.usage.prompt_tokens} | Completion tokens = {resp.usage.completion_tokens} | Total tokens = {resp.usage.total_tokens}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ff4eb947-d7c3-4944-88c1-5f69ab95429c",
   "metadata": {},
   "source": [
    "### Legal example"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "id": "7db16fdb-3bf2-47bc-ba6f-90fa659a02c9",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/markdown": [
       "Certainly! Below is a draft **Residential Purchase Agreement** tailored to the details you've provided. Please review and modify it as necessary to fit your specific needs and ensure compliance with California state laws. It's advisable to have all parties consult with their respective legal counsel before finalizing any legal document.\n",
       "\n",
       "---\n",
       "\n",
       "**RESIDENTIAL PURCHASE AGREEMENT**\n",
       "\n",
       "This Residential Purchase Agreement (\"Agreement\") is made and entered into as of [Date], by and between:\n",
       "\n",
       "**Buyer:**\n",
       "Sophie Martin  \n",
       "[Buyer's Address]  \n",
       "[City, State, ZIP]\n",
       "\n",
       "**Sellers:**\n",
       "John Smith and Jane Smith  \n",
       "[Seller's Address]  \n",
       "[City, State, ZIP]\n",
       "\n",
       "**PROPERTY:**\n",
       "1500 Diagonal Road, Contoso City, California (\"Property\").\n",
       "\n",
       "**1. PURCHASE PRICE**\n",
       "The Buyer agrees to purchase the Property for the total purchase price of Seven Hundred Ten Thousand Dollars ($710,000.00) (\"Purchase Price\"), payable as follows:\n",
       "\n",
       "- **Earnest Money Deposit:** Buyer shall deposit Five Thousand Dollars ($5,000.00) as earnest money (\"Earnest Money\") within [number] days of the effective date of this Agreement. The Earnest Money shall be held in escrow by [Escrow Agent/Title Company] and applied toward the Purchase Price at closing.\n",
       "\n",
       "- **Balance:** The balance of the Purchase Price shall be paid by Buyer to Seller at closing via wire transfer or other mutually agreed-upon method.\n",
       "\n",
       "**2. CLOSING**\n",
       "The closing of the purchase and sale contemplated by this Agreement (\"Closing\") shall take place on or before sixty (60) days from the effective date of this Agreement, unless otherwise mutually agreed upon in writing by both parties.\n",
       "\n",
       "**3. CONSIDERATIONS**\n",
       "\n",
       "- **No Financing Contingency:** This Agreement is not contingent upon the Buyer obtaining financing. Buyer acknowledges responsibility for securing the necessary funds to complete the purchase.\n",
       "\n",
       "- **Right to Inspection:** Buyer shall have the right to conduct inspections of the Property (\"Inspection Period\") within [number] days from the effective date of this Agreement. Buyer may terminate this Agreement based on inspection results in accordance with California Civil Code Section 1102.\n",
       "\n",
       "  - **Inspection Requests:** Buyer shall provide Seller with a written list of any inspection issues or repair requests by [specific date].\n",
       "\n",
       "  - **Access for Inspections:** Seller agrees to provide reasonable access to the Property for the purpose of conducting inspections.\n",
       "\n",
       "**4. POSSESSION**\n",
       "Possession of the Property shall be delivered to Buyer at Closing, free of any tenants or occupants, unless otherwise agreed in writing.\n",
       "\n",
       "**5. REPRESENTATIONS AND WARRANTIES**\n",
       "\n",
       "- **Seller's Representations:** Sellers represent and warrant that they are the lawful owners of the Property, have the right to sell the Property, and that the Property will be delivered free of all liens and encumbrances, except as expressly stated in this Agreement.\n",
       "\n",
       "- **Buyer's Representations:** Buyer represents that they have the financial capacity to complete the purchase as outlined in this Agreement.\n",
       "\n",
       "**6. CONTINGENCIES**\n",
       "This Agreement is contingent upon the following, to be satisfied or waived by Buyer within the specified time frames:\n",
       "\n",
       "- Satisfactory inspection results.\n",
       "- [Any additional contingencies, if applicable].\n",
       "\n",
       "**7. DEFAULT**\n",
       "\n",
       "- **Buyer Default:** If Buyer fails to perform any of their obligations under this Agreement, the Earnest Money shall be forfeited to the Sellers as liquidated damages.\n",
       "\n",
       "- **Seller Default:** If Sellers fail to perform any of their obligations under this Agreement, the Earnest Money shall be refunded to the Buyer, and Buyer may seek any other remedies available at law or in equity.\n",
       "\n",
       "**8. DISPUTE RESOLUTION**\n",
       "Any disputes arising out of or relating to this Agreement shall be resolved through [mediation/arbitration/litigation] in [County], California.\n",
       "\n",
       "**9. MISCELLANEOUS**\n",
       "\n",
       "- **Entire Agreement:** This Agreement constitutes the entire understanding between the parties and supersedes all prior agreements, representations, and understandings.\n",
       "\n",
       "- **Amendments:** Any amendments or modifications to this Agreement must be in writing and signed by both parties.\n",
       "\n",
       "- **Governing Law:** This Agreement shall be governed by and construed in accordance with the laws of the State of California.\n",
       "\n",
       "- **Notices:** All notices required or permitted under this Agreement shall be in writing and delivered to the respective parties at their addresses set forth above.\n",
       "\n",
       "**10. SIGNATURES**\n",
       "\n",
       "IN WITNESS WHEREOF, the parties hereto have executed this Residential Purchase Agreement as of the day and year first above written.\n",
       "\n",
       "---\n",
       "\n",
       "**Buyer:**\n",
       "\n",
       "_____________________________  \n",
       "Sophie Martin  \n",
       "Date: ______________________\n",
       "\n",
       "**Sellers:**\n",
       "\n",
       "_____________________________  \n",
       "John Smith  \n",
       "Date: ______________________\n",
       "\n",
       "_____________________________  \n",
       "Jane Smith  \n",
       "Date: ______________________\n",
       "\n",
       "---\n",
       "\n",
       "**EXHIBITS AND ADDENDUMS**\n",
       "\n",
       "- **Exhibit A:** Property Condition Disclosure Statement\n",
       "- **Exhibit B:** [Any other relevant documents]\n",
       "\n",
       "---\n",
       "\n",
       "**Escrow Instructions:**\n",
       "\n",
       "[Details regarding escrow instructions, if applicable]\n",
       "\n",
       "---\n",
       "\n",
       "**ATTORNEYS' ACKNOWLEDGMENT:**\n",
       "\n",
       "[Space for attorney signatures if required]\n",
       "\n",
       "---\n",
       "\n",
       "*Please ensure all placeholders (e.g., [Date], [Buyer’s Address], [Escrow Agent/Title Company], [number], [County]) are filled in with the appropriate information before finalizing the document.*"
      ],
      "text/plain": [
       "<IPython.core.display.Markdown object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "prompt = \"\"\"\n",
    "You are an expert lawyer. So am I.\n",
    "We are working on a document that will allow Sophie Martin to purchase a property for $710,000.\n",
    "The property is located at 1500 Diagonal Road, Contoso City, California.\n",
    "The sellers are John and Jane Smith. Sophie Martin will pay $5,000 in earnest money, and wants the right to conduct an inspection.\n",
    "The parties should close within 60 days. This sale is not contingent on financing.\n",
    "\n",
    "Could you help me draft the document?\n",
    "\"\"\"\n",
    "\n",
    "resp = o1mini(prompt)\n",
    "display(Markdown(resp.choices[0].message.content))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "id": "dc8e9c70-ae53-44b5-9092-c6ecc2a91ddc",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Prompt tokens = 117 | Completion tokens = 1411 | Total tokens = 1528\n"
     ]
    }
   ],
   "source": [
    "print(f\"Prompt tokens = {resp.usage.prompt_tokens} | Completion tokens = {resp.usage.completion_tokens} | Total tokens = {resp.usage.total_tokens}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5f0de25f-bbb1-41a9-8bde-a7cccaecdb4e",
   "metadata": {},
   "source": [
    "### Physic example"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "id": "d8cdf507-2033-41e1-b6a1-dfbda6046c8e",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/markdown": [
       "To determine the maximum initial speed \\( v_0 \\) at which the first ball can be thrown upward without colliding with the second ball before it returns to its starting position, let's analyze the motion of both balls.\n",
       "\n",
       "### Setup\n",
       "\n",
       "- **Ball A (Thrown Upwards):**\n",
       "  - Initial position: \\( y_A(0) = 0 \\) meters.\n",
       "  - Initial velocity: \\( v_A(0) = v_0 \\).\n",
       "  - Equation of motion: \n",
       "    \\[\n",
       "    y_A(t) = v_0 t - \\frac{1}{2} g t^2\n",
       "    \\]\n",
       "  \n",
       "- **Ball B (Dropped from Above):**\n",
       "  - Initial position: \\( y_B(0) = 12 \\) meters.\n",
       "  - Initial velocity: \\( v_B(0) = 0 \\) m/s.\n",
       "  - Equation of motion:\n",
       "    \\[\n",
       "    y_B(t) = 12 - \\frac{1}{2} g t^2\n",
       "    \\]\n",
       "\n",
       "### Collision Condition\n",
       "\n",
       "A collision occurs if at any time \\( t \\), \\( y_A(t) = y_B(t) \\). Setting the equations equal:\n",
       "\n",
       "\\[\n",
       "v_0 t - \\frac{1}{2} g t^2 = 12 - \\frac{1}{2} g t^2\n",
       "\\]\n",
       "\n",
       "Simplifying, we get:\n",
       "\n",
       "\\[\n",
       "v_0 t = 12\n",
       "\\]\n",
       "\\[\n",
       "t = \\frac{12}{v_0}\n",
       "\\]\n",
       "\n",
       "### Return Time for Ball A\n",
       "\n",
       "Ball A returns to the starting height \\( y = 0 \\) when:\n",
       "\n",
       "\\[\n",
       "v_0 t - \\frac{1}{2} g t^2 = 0\n",
       "\\]\n",
       "\\[\n",
       "t( v_0 - \\frac{1}{2} g t ) = 0\n",
       "\\]\n",
       "\n",
       "The non-zero solution is:\n",
       "\n",
       "\\[\n",
       "t_{\\text{return}} = \\frac{2 v_0}{g}\n",
       "\\]\n",
       "\n",
       "### Ensuring No Collision Before Return\n",
       "\n",
       "To avoid collision, the collision time \\( t = \\frac{12}{v_0} \\) must be greater than the return time \\( t_{\\text{return}} \\):\n",
       "\n",
       "\\[\n",
       "\\frac{12}{v_0} > \\frac{2 v_0}{g}\n",
       "\\]\n",
       "\n",
       "Multiplying both sides by \\( v_0 \\) (since \\( v_0 > 0 \\)):\n",
       "\n",
       "\\[\n",
       "12 > \\frac{2 v_0^2}{g}\n",
       "\\]\n",
       "\\[\n",
       "v_0^2 < 6g\n",
       "\\]\n",
       "\\[\n",
       "v_0 < \\sqrt{6g}\n",
       "\\]\n",
       "\n",
       "### Final Answer\n",
       "\n",
       "The maximum initial speed \\( v_0 \\) is:\n",
       "\n",
       "\\[\n",
       "v_0 = \\sqrt{6g}\n",
       "\\]\n",
       "\n",
       "Numerically, using \\( g = 9.8 \\, \\text{m/s}^2 \\):\n",
       "\n",
       "\\[\n",
       "v_0 \\approx \\sqrt{6 \\times 9.8} \\approx 7.67 \\, \\text{m/s}\n",
       "\\]\n",
       "\n",
       "**Thus, the maximum speed is the square root of six times gravity:**\n",
       "\n",
       "\\[\n",
       "v_0 = \\sqrt{6\\,g}\n",
       "\\]"
      ],
      "text/plain": [
       "<IPython.core.display.Markdown object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "prompt = \"\"\" \n",
    "A ball is thrown vertically upward at the same instant that a second ball is dropped from rest directly above it.\n",
    "The two balls are 12.0 meters apart when they start their motion.\n",
    "\n",
    "Find the maximum speed at which the first ball can be throw such that it doesn't collide with the second ball before it returns to its starting height. Treat the balls as being very small (i.e. ignore their diameters).\n",
    "\"\"\"\n",
    "\n",
    "resp = o1mini(prompt)\n",
    "display(Markdown(resp.choices[0].message.content))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "id": "693c75a2-3906-4f8e-8705-2df0433db4db",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Prompt tokens = 94 | Completion tokens = 1326 | Total tokens = 1420\n"
     ]
    }
   ],
   "source": [
    "print(f\"Prompt tokens = {resp.usage.prompt_tokens} | Completion tokens = {resp.usage.completion_tokens} | Total tokens = {resp.usage.total_tokens}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a846383d-d028-469b-96f5-c6cfcd88aa2e",
   "metadata": {},
   "source": [
    "### Logic example"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "id": "5c50db00-a27b-4686-b3af-3c5a4864fe89",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/markdown": [
       "Let's analyze the given statements based on the provided conditions:\n",
       "\n",
       "**Conditions:**\n",
       "1. **All apples are fruits.**  \n",
       "   *(Every apple is a type of fruit.)*\n",
       "\n",
       "2. **Some fruits are red.**  \n",
       "   *(There exists at least one fruit that is red.)*\n",
       "\n",
       "3. **All red fruits are sweet.**  \n",
       "   *(If a fruit is red, then it is sweet.)*\n",
       "\n",
       "**Statements to Evaluate:**\n",
       "1. **All apples are sweet.**  \n",
       "   - **Analysis:**  \n",
       "     - From Condition 1, we know all apples are fruits.  \n",
       "     - However, not all fruits are necessarily red or sweet. Only red fruits are guaranteed to be sweet (Condition 3).  \n",
       "     - Therefore, unless all apples are red (which isn't stated), we **cannot conclude that all apples are sweet**.\n",
       "     \n",
       "2. **Some fruits are sweet.**  \n",
       "   - **Analysis:**  \n",
       "     - From Condition 2, some fruits are red.  \n",
       "     - From Condition 3, all red fruits are sweet.  \n",
       "     - Therefore, **there exists at least one sweet fruit** (the red ones).\n",
       "   \n",
       "3. **No apples are red.**  \n",
       "   - **Analysis:**  \n",
       "     - While some fruits are red, the conditions do not specify whether apples can be red or not.  \n",
       "     - Apples could be among the red fruits, but this isn't confirmed or denied by the given conditions.  \n",
       "     - Thus, **we cannot assert that no apples are red** based solely on the provided information.\n",
       "\n",
       "**Conclusion:**\n",
       "Only the second statement, **\"Some fruits are sweet,\"** is conclusively true based on the given conditions.\n",
       "\n",
       "**Answer:**  \n",
       "Only “Some fruits are sweet” is necessarily true."
      ],
      "text/plain": [
       "<IPython.core.display.Markdown object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "prompt = \"\"\"\n",
    "Which of the following statements is true based on these conditions?\n",
    "All apples are fruits.\n",
    "Some fruits are red.\n",
    "All red fruits are sweet.\n",
    "\n",
    "Statements:\n",
    "- All apples are sweet.\n",
    "- Some fruits are sweet.\n",
    "- No apples are red.\n",
    "\n",
    "Which statement is true?\n",
    "\"\"\"\n",
    "\n",
    "resp = o1mini(prompt)\n",
    "display(Markdown(resp.choices[0].message.content))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "id": "1e163a3f-cf52-4140-acef-a218d675db3a",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Prompt tokens = 71 | Completion tokens = 761 | Total tokens = 832\n"
     ]
    }
   ],
   "source": [
    "print(f\"Prompt tokens = {resp.usage.prompt_tokens} | Completion tokens = {resp.usage.completion_tokens} | Total tokens = {resp.usage.total_tokens}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6b08b07d-7479-490f-860c-2f027152b1c2",
   "metadata": {},
   "source": [
    "### Optimization with constraints example"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "id": "ef156184-f1db-4cdb-b9ad-9073d3451ebf",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/markdown": [
       "To solve the optimization problem of maximizing the function \\( 3x + 2y \\) with the given constraints, we can follow these steps:\n",
       "\n",
       "### **Constraints:**\n",
       "1. \\( 2x + y \\leq 18 \\)\n",
       "2. \\( 2x + 3y \\leq 42 \\)\n",
       "3. \\( 3x + y \\leq 24 \\)\n",
       "4. \\( x \\geq 0 \\)\n",
       "5. \\( y \\geq 0 \\)\n",
       "\n",
       "### **Solution Steps:**\n",
       "\n",
       "1. **Identify Feasible Region:**\n",
       "   - Plot the constraints on a graph to determine the feasible region where all inequalities are satisfied.\n",
       "   \n",
       "2. **Find Intersection Points:**\n",
       "   - Compute the points where the lines intersect by solving the equations pairwise.\n",
       "   - The intersection points (vertices of the feasible region) are:\n",
       "     - \\( (0, 0) \\)\n",
       "     - \\( (0, 14) \\)\n",
       "     - \\( (3, 12) \\)\n",
       "     - \\( (6, 6) \\)\n",
       "     - \\( \\left(\\frac{30}{7}, \\frac{78}{7}\\right) \\) (approximately \\( (4.29, 11.14) \\))\n",
       "     - \\( (8, 0) \\)\n",
       "\n",
       "3. **Evaluate Objective Function at Each Vertex:**\n",
       "   - Calculate \\( 3x + 2y \\) for each vertex:\n",
       "     - \\( (0, 0) \\): \\( 3(0) + 2(0) = 0 \\)\n",
       "     - \\( (0, 14) \\): \\( 3(0) + 2(14) = 28 \\)\n",
       "     - \\( (3, 12) \\): \\( 3(3) + 2(12) = 33 \\)\n",
       "     - \\( (6, 6) \\): \\( 3(6) + 2(6) = 30 \\)\n",
       "     - \\( \\left(\\frac{30}{7}, \\frac{78}{7}\\right) \\): \\( 3\\left(\\frac{30}{7}\\right) + 2\\left(\\frac{78}{7}\\right) \\approx 35.14 \\) (Not integer)\n",
       "     - \\( (8, 0) \\): \\( 3(8) + 2(0) = 24 \\)\n",
       "\n",
       "4. **Check for Integer Solutions:**\n",
       "   - Since \\( x \\) and \\( y \\) must be integers, the point \\( \\left(\\frac{30}{7}, \\frac{78}{7}\\right) \\) is not feasible.\n",
       "   - Among the integer points, \\( (3, 12) \\) yields the highest value of \\( 33 \\).\n",
       "\n",
       "### **Optimal Solution:**\n",
       "\n",
       "- **Values:**\n",
       "  - \\( x = 3 \\)\n",
       "  - \\( y = 12 \\)\n",
       "\n",
       "- **Maximum Objective Function Value:**\n",
       "  - \\( 3x + 2y = 33 \\)\n",
       "\n",
       "### **Conclusion:**\n",
       "The optimal solution to maximize \\( 3x + 2y \\) under the given constraints is:\n",
       "- **\\( x = 3 \\)**\n",
       "- **\\( y = 12 \\)**\n",
       "- **Maximum Value = 33**"
      ],
      "text/plain": [
       "<IPython.core.display.Markdown object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "prompt = \"\"\"\n",
    "x and y are integers.\n",
    "You need to maximize this function: 3x + 2y\n",
    "\n",
    "with these five contraints:\n",
    "2x + y <= 18\n",
    "2x + 3y <= 42\n",
    "3x + y <= 24\n",
    "x >= 0\n",
    "y >= 0\n",
    "\n",
    "Print the results of this optimal problem.\n",
    "\"\"\"\n",
    "\n",
    "resp = o1mini(prompt)\n",
    "display(Markdown(resp.choices[0].message.content))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "id": "92627390-f2fb-4b95-a2c3-34be0aef01ef",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Prompt tokens = 90 | Completion tokens = 2808 | Total tokens = 2898\n"
     ]
    }
   ],
   "source": [
    "print(f\"Prompt tokens = {resp.usage.prompt_tokens} | Completion tokens = {resp.usage.completion_tokens} | Total tokens = {resp.usage.total_tokens}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "26fc074c-5e5e-49c3-bb4e-73704e89ccb2",
   "metadata": {},
   "source": [
    "### Code example"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "id": "c5003dd0-2135-41bd-9db0-5f42102b32c9",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/markdown": [
       "Python offers several robust libraries for resizing JPEG images, each with its own set of features, advantages, and limitations. Below is an overview of some of the most popular Python libraries used for image resizing, along with their pros and cons. Additionally, you'll find example code snippets to demonstrate how to use these libraries effectively.\n",
       "\n",
       "## 1. Pillow (PIL Fork)\n",
       "\n",
       "**Pillow** is the friendly PIL (Python Imaging Library) fork and is one of the most widely used libraries for image processing in Python.\n",
       "\n",
       "### Pros\n",
       "- **Ease of Use:** Simple and intuitive API that's easy for beginners.\n",
       "- **Wide Format Support:** Supports numerous image formats, including JPEG, PNG, GIF, and more.\n",
       "- **Active Development:** Regular updates and a large community.\n",
       "- **Integration:** Works well with other Python libraries and frameworks.\n",
       "\n",
       "### Cons\n",
       "- **Performance:** Slower compared to some alternatives like OpenCV, especially for large images or batch processing.\n",
       "- **Limited Advanced Features:** While great for basic to intermediate tasks, it may lack some advanced image processing capabilities.\n",
       "\n",
       "### Example Code\n",
       "\n",
       "```python\n",
       "from PIL import Image\n",
       "\n",
       "# Open an existing image\n",
       "with Image.open('input.jpg') as img:\n",
       "    # Define the new size\n",
       "    new_size = (800, 600)\n",
       "    # Resize the image\n",
       "    resized_img = img.resize(new_size, Image.ANTIALIAS)\n",
       "    # Save the resized image\n",
       "    resized_img.save('resized_output.jpg')\n",
       "```\n",
       "\n",
       "## 2. OpenCV\n",
       "\n",
       "**OpenCV** (Open Source Computer Vision Library) is a highly optimized library designed for real-time computer vision applications.\n",
       "\n",
       "### Pros\n",
       "- **Performance:** Highly optimized for speed, making it suitable for real-time applications and large-scale image processing.\n",
       "- **Advanced Features:** Extensive functionalities for computer vision and image processing beyond basic resizing.\n",
       "- **Language Support:** Although primarily C++, it has robust Python bindings.\n",
       "\n",
       "### Cons\n",
       "- **Complexity:** More complex API compared to Pillow, which might have a steeper learning curve for beginners.\n",
       "- **Color Format Handling:** Uses BGR by default instead of RGB, which can cause confusion.\n",
       "\n",
       "### Example Code\n",
       "\n",
       "```python\n",
       "import cv2\n",
       "\n",
       "# Read the image\n",
       "img = cv2.imread('input.jpg')\n",
       "\n",
       "# Define the scaling factors or desired size\n",
       "width = 800\n",
       "height = 600\n",
       "dim = (width, height)\n",
       "\n",
       "# Resize the image\n",
       "resized_img = cv2.resize(img, dim, interpolation=cv2.INTER_AREA)\n",
       "\n",
       "# Save the resized image\n",
       "cv2.imwrite('resized_output.jpg', resized_img)\n",
       "```\n",
       "\n",
       "## 3. scikit-image\n",
       "\n",
       "**scikit-image** is a part of the SciPy ecosystem and is designed for image processing in Python.\n",
       "\n",
       "### Pros\n",
       "- **Integration with SciPy:** Seamlessly integrates with other scientific libraries like NumPy and SciPy.\n",
       "- **Advanced Image Processing:** Offers specialized algorithms for image analysis and processing.\n",
       "- **Documentation:** Well-documented with numerous examples.\n",
       "\n",
       "### Cons\n",
       "- **Performance:** Not as fast as OpenCV for certain tasks.\n",
       "- **Learning Curve:** Might be more complex for simple tasks compared to Pillow.\n",
       "\n",
       "### Example Code\n",
       "\n",
       "```python\n",
       "from skimage import io, transform\n",
       "\n",
       "# Read the image\n",
       "img = io.imread('input.jpg')\n",
       "\n",
       "# Define the scaling factors or desired size\n",
       "new_size = (600, 800)  # (rows, cols)\n",
       "\n",
       "# Resize the image\n",
       "resized_img = transform.resize(img, new_size, anti_aliasing=True)\n",
       "\n",
       "# Save the resized image\n",
       "io.imsave('resized_output.jpg', (resized_img * 255).astype('uint8'))\n",
       "```\n",
       "\n",
       "## 4. Imageio\n",
       "\n",
       "**Imageio** is a Python library that provides an easy interface to read and write a wide range of image data, including animated images, volumetric data, and more.\n",
       "\n",
       "### Pros\n",
       "- **Simplicity:** Straightforward API for basic image operations.\n",
       "- **Format Support:** Supports a wide array of image formats.\n",
       "- **Extensibility:** Can be extended with plugins.\n",
       "\n",
       "### Cons\n",
       "- **Basic Features:** Primarily focused on reading and writing images; lacks advanced processing capabilities.\n",
       "- **Performance:** Not optimized for high-performance tasks compared to OpenCV.\n",
       "\n",
       "### Example Code\n",
       "\n",
       "```python\n",
       "import imageio\n",
       "from skimage.transform import resize\n",
       "\n",
       "# Read the image\n",
       "img = imageio.imread('input.jpg')\n",
       "\n",
       "# Define the new size\n",
       "new_size = (600, 800)  # (rows, cols)\n",
       "\n",
       "# Resize the image using scikit-image's resize\n",
       "resized_img = resize(img, new_size, anti_aliasing=True)\n",
       "\n",
       "# Save the resized image\n",
       "imageio.imwrite('resized_output.jpg', (resized_img * 255).astype('uint8'))\n",
       "```\n",
       "\n",
       "## 5. Matplotlib\n",
       "\n",
       "While primarily a plotting library, **Matplotlib** can also handle basic image processing tasks, including resizing.\n",
       "\n",
       "### Pros\n",
       "- **Visualization:** Excellent for displaying images alongside data visualizations.\n",
       "- **Ease of Use for Simple Tasks:** Simple API for basic image manipulation.\n",
       "- **Integration:** Combines well with other data processing and visualization workflows.\n",
       "\n",
       "### Cons\n",
       "- **Not Designed for Processing:** Limited image processing capabilities compared to dedicated libraries.\n",
       "- **Performance:** Not optimized for high-performance image processing.\n",
       "\n",
       "### Example Code\n",
       "\n",
       "```python\n",
       "import matplotlib.pyplot as plt\n",
       "import matplotlib.image as mpimg\n",
       "from PIL import Image\n",
       "\n",
       "# Read the image\n",
       "img = mpimg.imread('input.jpg')\n",
       "\n",
       "# Convert to PIL Image for resizing\n",
       "pil_img = Image.fromarray((img * 255).astype('uint8'))\n",
       "\n",
       "# Define the new size\n",
       "new_size = (800, 600)\n",
       "\n",
       "# Resize the image\n",
       "resized_img = pil_img.resize(new_size, Image.ANTIALIAS)\n",
       "\n",
       "# Save the resized image\n",
       "resized_img.save('resized_output.jpg')\n",
       "```\n",
       "\n",
       "## Choosing the Right Library\n",
       "\n",
       "The best library for resizing JPEG images in Python depends on your specific needs:\n",
       "\n",
       "- **For Simple Tasks and Beginners:** **Pillow** is often the go-to choice due to its simplicity and ease of use.\n",
       "- **For Performance and Advanced Processing:** **OpenCV** is ideal for high-performance applications and more complex image processing tasks.\n",
       "- **For Scientific Computing and Integration:** **scikit-image** integrates well with scientific workflows and offers advanced algorithms.\n",
       "- **For Basic Read/Write Operations:** **Imageio** provides a simple interface for reading and writing images.\n",
       "- **For Visualization with Basic Resizing:** **Matplotlib** can be useful when combined with plotting capabilities.\n",
       "\n",
       "## Additional Tips\n",
       "\n",
       "- **Preserving Aspect Ratio:** When resizing images, it's often important to maintain the original aspect ratio to avoid distortion. Most libraries offer ways to calculate the new size while preserving the aspect ratio.\n",
       "\n",
       "  ### Example with Pillow:\n",
       "  ```python\n",
       "  from PIL import Image\n",
       "\n",
       "  def resize_image_preserving_aspect(input_path, output_path, base_width):\n",
       "      with Image.open(input_path) as img:\n",
       "          w_percent = (base_width / float(img.size[0]))\n",
       "          h_size = int((float(img.size[1]) * float(w_percent)))\n",
       "          resized_img = img.resize((base_width, h_size), Image.ANTIALIAS)\n",
       "          resized_img.save(output_path)\n",
       "\n",
       "  resize_image_preserving_aspect('input.jpg', 'resized_output.jpg', 800)\n",
       "  ```\n",
       "\n",
       "- **Batch Processing:** If you need to resize multiple images, consider writing a loop or using parallel processing libraries like `multiprocessing` to speed up the task.\n",
       "\n",
       "- **Handling Different Image Modes:** Ensure that you handle different image modes (e.g., RGB, RGBA, grayscale) appropriately, especially when saving the resized images.\n",
       "\n",
       "## Conclusion\n",
       "\n",
       "Python provides a rich ecosystem of libraries for image resizing and processing. **Pillow** is excellent for straightforward tasks and ease of use, while **OpenCV** offers high performance and advanced capabilities suitable for more demanding applications. Depending on your project's requirements, you can choose the library that best fits your needs and integrate it seamlessly into your workflow."
      ],
      "text/plain": [
       "<IPython.core.display.Markdown object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "prompt = \"\"\"\n",
    "What are the python capabilities to resize a jpg image file?\n",
    "List the pros and cons.\n",
    "Display some python code examples.\n",
    "\"\"\"\n",
    "\n",
    "resp = o1mini(prompt)\n",
    "display(Markdown(resp.choices[0].message.content))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "id": "13247705-91d8-40be-844f-d878f1bc2ddb",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Prompt tokens = 34 | Completion tokens = 1911 | Total tokens = 1945\n"
     ]
    }
   ],
   "source": [
    "print(f\"Prompt tokens = {resp.usage.prompt_tokens} | Completion tokens = {resp.usage.completion_tokens} | Total tokens = {resp.usage.total_tokens}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d403c0bb-cfd1-492f-889c-7e7ec9a64d18",
   "metadata": {},
   "source": [
    "## Optimization with constraints example"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "id": "05454c22-30e2-46f4-a88d-8a251c7c0eda",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/markdown": [
       "To determine the most cost-effective way to transport 300 kids to the Bronx Zoo using 40-seat and 30-seat buses, we'll set up and solve an optimization problem. Here's a step-by-step breakdown:\n",
       "\n",
       "### **1. Define Variables**\n",
       "\n",
       "- **Let:**\n",
       "  - \\( x \\) = number of 40-seat buses\n",
       "  - \\( y \\) = number of 30-seat buses\n",
       "\n",
       "### **2. Set Up the Constraints**\n",
       "\n",
       "- **Seat Requirement:**\n",
       "  \n",
       "  The total number of seats must be at least 300.\n",
       "  \n",
       "  \\[\n",
       "  40x + 30y \\geq 300\n",
       "  \\]\n",
       "  \n",
       "- **Non-Negativity and Integer Constraints:**\n",
       "  \n",
       "  \\[\n",
       "  x \\geq 0, \\quad y \\geq 0\n",
       "  \\]\n",
       "  \n",
       "  \\( x \\) and \\( y \\) must be whole numbers since you can't rent a fraction of a bus.\n",
       "\n",
       "### **3. Define the Objective Function**\n",
       "\n",
       "- **Minimize Total Cost:**\n",
       "  \n",
       "  The cost for each 40-seat bus is \\$500, and for each 30-seat bus is \\$400.\n",
       "  \n",
       "  \\[\n",
       "  \\text{Total Cost} = 500x + 400y\n",
       "  \\]\n",
       "  \n",
       "### **4. Solve the Problem**\n",
       "\n",
       "To minimize the cost, it's generally best to use as many of the cheaper per-seat options as possible. However, since the 40-seat buses are slightly cheaper per seat, we'll prioritize them.\n",
       "\n",
       "Let's explore possible integer combinations of \\( x \\) and \\( y \\):\n",
       "\n",
       "| \\( x \\) (40-seat buses) | \\( y \\) (30-seat buses) | Total Seats (\\(40x + 30y\\)) | Total Cost (\\$)         |\n",
       "|-------------------------|-------------------------|------------------------------|-------------------------|\n",
       "| 6                       | 2                       | \\(6 \\times 40 + 2 \\times 30 = 240 + 60 = 300\\) | \\(6 \\times 500 + 2 \\times 400 = 3000 + 800 = 3800\\) |\n",
       "| 7                       | 1                       | \\(7 \\times 40 + 1 \\times 30 = 280 + 30 = 310\\) | \\(7 \\times 500 + 1 \\times 400 = 3500 + 400 = 3900\\) |\n",
       "| 8                       | 0                       | \\(8 \\times 40 + 0 \\times 30 = 320 + 0 = 320\\) | \\(8 \\times 500 + 0 \\times 400 = 4000 + 0 = 4000\\) |\n",
       "| 5                       | 4                       | \\(5 \\times 40 + 4 \\times 30 = 200 + 120 = 320\\) | \\(5 \\times 500 + 4 \\times 400 = 2500 + 1600 = 4100\\) |\n",
       "| 4                       | 6                       | \\(4 \\times 40 + 6 \\times 30 = 160 + 180 = 340\\) | \\(4 \\times 500 + 6 \\times 400 = 2000 + 2400 = 4400\\) |\n",
       "\n",
       "From the table:\n",
       "\n",
       "- **Minimum Cost:** \\$3,800\n",
       "- **Bus Allocation:** 6 buses of 40 seats and 2 buses of 30 seats\n",
       "\n",
       "### **5. Conclusion**\n",
       "\n",
       "To **minimize the total cost** while transporting **300 kids**, the school should rent:\n",
       "\n",
       "- **6 buses** with **40 seats each**\n",
       "- **2 buses** with **30 seats each**\n",
       "\n",
       "This combination provides exactly 300 seats and results in a **total cost of \\$3,800**."
      ],
      "text/plain": [
       "<IPython.core.display.Markdown object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "prompt = \"\"\"\n",
    "300 kids need to travel to the Bronx zoo.\n",
    "The school may rent 40 seats and 30 seats buses for $500 and $400.\n",
    "\n",
    "How many buses of each size do you use to minimize cost?\n",
    "Print the number of 40 seats buses and the number of 30 seats buses and the total cost.\n",
    "\"\"\"\n",
    "\n",
    "resp = o1mini(prompt)\n",
    "display(Markdown(resp.choices[0].message.content))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "id": "bc967377-dbd8-499c-be8f-15cf89b39a6c",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Prompt tokens = 76 | Completion tokens = 1820 | Total tokens = 1896\n"
     ]
    }
   ],
   "source": [
    "print(f\"Prompt tokens = {resp.usage.prompt_tokens} | Completion tokens = {resp.usage.completion_tokens} | Total tokens = {resp.usage.total_tokens}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "65ea36f5-630e-438a-b1e3-c17a37985cfb",
   "metadata": {},
   "source": [
    "### Math example"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "id": "f5e588f0-5bb6-43ed-896e-cb20ca13adb7",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/markdown": [
       "To determine when Train B catches up with Train A, let's break down the problem step by step.\n",
       "\n",
       "### **Step 1: Calculate the Head Start of Train A**\n",
       "- **Departure Times:**\n",
       "  - **Train A:** Leaves at **10:20 AM** with a speed of **150 km/h**.\n",
       "  - **Train B:** Leaves at **10:30 AM** with a speed of **180 km/h**.\n",
       "  \n",
       "- **Time Difference:** Train A departs **10 minutes** before Train B.\n",
       "\n",
       "- **Distance Covered by Train A in 10 Minutes:**\n",
       "  \\[\n",
       "  \\text{Distance} = \\text{Speed} \\times \\text{Time} = 150 \\, \\text{km/h} \\times \\frac{10}{60} \\, \\text{hours} = 25 \\, \\text{km}\n",
       "  \\]\n",
       "  \n",
       "  So, Train A has a **25 km head start** when Train B begins its journey.\n",
       "\n",
       "### **Step 2: Determine the Relative Speed**\n",
       "- **Train A's Speed:** 150 km/h\n",
       "- **Train B's Speed:** 180 km/h\n",
       "- **Relative Speed of Train B with Respect to Train A:**\n",
       "  \\[\n",
       "  180 \\, \\text{km/h} - 150 \\, \\text{km/h} = 30 \\, \\text{km/h}\n",
       "  \\]\n",
       "  \n",
       "  This means Train B is closing the gap at **30 km/h**.\n",
       "\n",
       "### **Step 3: Calculate the Time Needed to Catch Up**\n",
       "- **Distance to Cover:** 25 km\n",
       "- **Relative Speed:** 30 km/h\n",
       "\n",
       "\\[\n",
       "\\text{Time} = \\frac{\\text{Distance}}{\\text{Speed}} = \\frac{25 \\, \\text{km}}{30 \\, \\text{km/h}} = \\frac{5}{6} \\, \\text{hours} = 50 \\, \\text{minutes}\n",
       "\\]\n",
       "\n",
       "### **Step 4: Determine the Catch-Up Time**\n",
       "- **Train B's Departure Time:** 10:30 AM\n",
       "- **Time to Catch Up:** 50 minutes\n",
       "\n",
       "\\[\n",
       "10:30 \\, \\text{AM} + 50 \\, \\text{minutes} = 11:20 \\, \\text{AM}\n",
       "\\]\n",
       "\n",
       "### **Conclusion**\n",
       "Train B catches up with Train A at **11:20 AM**.\n",
       "\n",
       "**Answer:**  \n",
       "Train B catches up with Train A at 11:20 AM."
      ],
      "text/plain": [
       "<IPython.core.display.Markdown object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "prompt = \"\"\"\n",
    "A train A left at 10:20 AM and travels at a speed of 150 km/h.\n",
    "A train B left at 10:30 AM but travels at 180 km/h.\n",
    "\n",
    "At what time does train B catch up with train A?\n",
    "\"\"\"\n",
    "\n",
    "resp = o1mini(prompt)\n",
    "display(Markdown(resp.choices[0].message.content))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "id": "48cd5885-688b-4c9a-91d5-c74210b77605",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Prompt tokens = 62 | Completion tokens = 799 | Total tokens = 861\n"
     ]
    }
   ],
   "source": [
    "print(f\"Prompt tokens = {resp.usage.prompt_tokens} | Completion tokens = {resp.usage.completion_tokens} | Total tokens = {resp.usage.total_tokens}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "737292d7-94b1-4227-adb0-e4c08e24cc76",
   "metadata": {},
   "source": [
    "### Physic example"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "id": "9458339b-8b9e-401f-b47e-a67257b7eb0a",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/markdown": [
       "When analyzing the scenario step by step under the normal laws of physics on Earth, we can determine the final position of the strawberry as follows:\n",
       "\n",
       "1. **Placing the Strawberry in the Cup:**\n",
       "   - **Action:** A small strawberry is placed inside a normal (presumably open) cup.\n",
       "   - **Result:** The strawberry resides at the bottom of the cup, held there by gravity.\n",
       "\n",
       "2. **Inverting the Cup on the Table:**\n",
       "   - **Action:** The cup is turned upside down and placed on a flat surface like a table.\n",
       "   - **Result:** \n",
       "     - **Gravity's Role:** Gravity acts downward, pulling the strawberry toward the new \"top\" of the inverted cup (which is actually the open side now facing upward).\n",
       "     - **Outcome:** Since the cup is open and there’s no mechanism (like liquid creating surface tension or a lid preventing the strawberry from falling) to keep the strawberry inside, the strawberry will fall out of the cup due to gravity.\n",
       "     - **Position:** The strawberry lands on the table next to the inverted cup.\n",
       "\n",
       "3. **Moving the Cup to the Microwave:**\n",
       "   - **Action:** Someone picks up the inverted cup from the table and places it inside a microwave.\n",
       "   - **Result:** \n",
       "     - **Cup Movement:** The cup, now inside the microwave, remains empty because the strawberry had already fallen out.\n",
       "     - **Strawberry Location:** The strawberry stays on the table where it fell out earlier and is not inside the microwave.\n",
       "\n",
       "**Final Position of the Strawberry:**\n",
       "- **Location:** The strawberry is on the table, outside and separate from both the cup and the microwave.\n",
       "- **Reasoning:** Inverting a standard open cup causes its contents to fall out due to gravity, especially when there's nothing inside (like a liquid) to hold the strawberry in place. Therefore, moving the empty (inverted) cup to the microwave does not affect the strawberry, which remains on the table."
      ],
      "text/plain": [
       "<IPython.core.display.Markdown object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "prompt = \"\"\"\n",
    "Assume laws of physics on Earth.\n",
    "A small strawberry is put into a normal cup and the cup is placed upside down on a table.\n",
    "Someone then takes the cup and puts it inside the microwave.\n",
    "\n",
    "Where is the strawberry now? Explain your reasoning step by step.\n",
    "\"\"\"\n",
    "\n",
    "resp = o1mini(prompt)\n",
    "display(Markdown(resp.choices[0].message.content))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "id": "8ccebc6e-812d-4c53-b988-06d956c619db",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Prompt tokens = 64 | Completion tokens = 1244 | Total tokens = 1308\n"
     ]
    }
   ],
   "source": [
    "print(f\"Prompt tokens = {resp.usage.prompt_tokens} | Completion tokens = {resp.usage.completion_tokens} | Total tokens = {resp.usage.total_tokens}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "dfeda5f4-33c3-4f0e-899c-2d1385e095a1",
   "metadata": {},
   "source": [
    "### Python example"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "id": "dd3a4432-f36e-4f6e-8fd3-d46427c4a68d",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/markdown": [
       "Developing your first Python API is an exciting endeavor that can open up numerous possibilities for building applications, services, and integrations. To ensure a smooth development process and create a robust, maintainable API, consider the following key aspects:\n",
       "\n",
       "### 1. **Choose the Right Framework**\n",
       "\n",
       "Python offers several frameworks tailored for API development. Selecting the one that best fits your project’s needs is crucial.\n",
       "\n",
       "- **Flask**: A micro-framework that's lightweight and flexible, ideal for small to medium-sized APIs.\n",
       "- **Django REST Framework (DRF)**: Built on Django, it provides a comprehensive toolkit for building large-scale, feature-rich APIs.\n",
       "- **FastAPI**: Modern, fast (high-performance) framework that uses Python type hints, ideal for building performant APIs with automatic documentation.\n",
       "- **Tornado or Bottle**: Other alternatives depending on specific requirements.\n",
       "\n",
       "**Recommendation**: For beginners, **Flask** is often recommended due to its simplicity and extensive documentation. If you prioritize speed and automatic documentation, **FastAPI** is an excellent choice.\n",
       "\n",
       "### 2. **Design Your API Endpoints Thoughtfully**\n",
       "\n",
       "A well-designed API is intuitive, consistent, and easy to use.\n",
       "\n",
       "- **RESTful Principles**: Utilize standard HTTP methods (GET, POST, PUT, DELETE) and organize endpoints around resources.\n",
       "- **Naming Conventions**: Use clear and consistent naming for endpoints (e.g., `/users`, `/orders/{id}`).\n",
       "- **Versioning**: Implement versioning from the start (e.g., `/v1/users`) to accommodate future changes without breaking existing clients.\n",
       "\n",
       "### 3. **Handle Data Serialization and Validation**\n",
       "\n",
       "Ensure that the data exchanged between clients and your API is correctly structured and validated.\n",
       "\n",
       "- **Serialization**: Convert complex data types (like database objects) into JSON or other formats using libraries like Marshmallow or Pydantic (especially with FastAPI).\n",
       "- **Validation**: Validate incoming data to prevent errors and security issues. Frameworks often provide built-in validation tools.\n",
       "\n",
       "### 4. **Implement Authentication and Authorization**\n",
       "\n",
       "Securing your API is paramount to protect data and control access.\n",
       "\n",
       "- **Authentication**: Verify the identity of users. Common methods include:\n",
       "  - **API Keys**: Simple tokens assigned to clients.\n",
       "  - **OAuth2**: A robust standard for token-based authentication.\n",
       "  - **JWT (JSON Web Tokens)**: Compact and self-contained tokens.\n",
       "- **Authorization**: Define what authenticated users are allowed to do. Implement role-based access control (RBAC) or permission-based systems.\n",
       "\n",
       "### 5. **Ensure Proper Error Handling**\n",
       "\n",
       "Gracefully handle errors to provide meaningful feedback to API consumers.\n",
       "\n",
       "- **Consistent Error Responses**: Use a standardized format for error messages, including status codes and descriptive messages.\n",
       "- **HTTP Status Codes**: Utilize appropriate status codes (e.g., 400 for bad requests, 401 for unauthorized, 404 for not found, 500 for server errors).\n",
       "- **Logging**: Log errors internally for troubleshooting without exposing sensitive information to clients.\n",
       "\n",
       "### 6. **Provide Comprehensive Documentation**\n",
       "\n",
       "Good documentation enhances the usability and adoption of your API.\n",
       "\n",
       "- **Auto-generated Docs**: Use tools like Swagger/OpenAPI (integrated with FastAPI and DRF) to generate interactive documentation.\n",
       "- **Detailed Descriptions**: Explain endpoints, parameters, request/response formats, authentication methods, and examples.\n",
       "- **Getting Started Guides**: Help users begin quickly with tutorials or sample code.\n",
       "\n",
       "### 7. **Write Tests for Your API**\n",
       "\n",
       "Testing ensures reliability and helps catch issues early.\n",
       "\n",
       "- **Unit Tests**: Test individual components or functions.\n",
       "- **Integration Tests**: Test interactions between different parts of your API.\n",
       "- **Tools**: Use frameworks like `unittest`, `pytest`, or `nose`, and tools like `Postman` or `Swagger` for automated testing.\n",
       "\n",
       "### 8. **Consider Performance and Scalability**\n",
       "\n",
       "Ensure your API can handle the expected load and performance requirements.\n",
       "\n",
       "- **Asynchronous Programming**: Consider using asynchronous frameworks or features (e.g., `async`/`await` in FastAPI) for better performance.\n",
       "- **Caching**: Implement caching strategies (e.g., Redis, Memcached) to reduce load and improve response times.\n",
       "- **Database Optimization**: Optimize queries and use indexing to enhance database performance.\n",
       "- **Load Balancing**: Distribute traffic across multiple servers or instances if needed.\n",
       "\n",
       "### 9. **Plan for Deployment and Hosting**\n",
       "\n",
       "Decide where and how to deploy your API to make it accessible.\n",
       "\n",
       "- **Hosting Services**: Options include cloud providers like AWS, Google Cloud, Azure, or platforms like Heroku, DigitalOcean, and Vercel.\n",
       "- **Containerization**: Use Docker to containerize your application for consistent deployment environments.\n",
       "- **Continuous Integration/Continuous Deployment (CI/CD)**: Automate testing and deployment processes using tools like GitHub Actions, Travis CI, or Jenkins.\n",
       "\n",
       "### 10. **Implement Security Best Practices**\n",
       "\n",
       "Protect your API from common vulnerabilities and attacks.\n",
       "\n",
       "- **HTTPS**: Always use HTTPS to encrypt data in transit.\n",
       "- **Input Sanitization**: Prevent injection attacks by sanitizing user inputs.\n",
       "- **Rate Limiting**: Limit the number of requests a client can make to prevent abuse (using tools like `Flask-Limiter`).\n",
       "- **CORS Configuration**: Properly configure Cross-Origin Resource Sharing to control access from different domains.\n",
       "- **Regular Updates**: Keep dependencies and frameworks up to date to patch security vulnerabilities.\n",
       "\n",
       "### 11. **Handle Data Formats and Standards**\n",
       "\n",
       "Ensure your API communicates effectively using standard data formats.\n",
       "\n",
       "- **JSON**: The most common data interchange format for APIs. Ensure proper serialization and deserialization.\n",
       "- **Versioning Data Structures**: Plan for changes in data models by versioning or using backward-compatible changes.\n",
       "- **Consistent Formatting**: Maintain consistency in key naming (e.g., snake_case vs. camelCase) and data structures across the API.\n",
       "\n",
       "### 12. **Set Up Logging and Monitoring**\n",
       "\n",
       "Monitor your API’s health and performance to maintain reliability.\n",
       "\n",
       "- **Logging**: Implement logging for requests, responses, errors, and important events using libraries like `logging` in Python.\n",
       "- **Monitoring Tools**: Use services like Prometheus, Grafana, or third-party solutions like Datadog or New Relic to track performance metrics and uptime.\n",
       "- **Alerting**: Set up alerts for critical issues to respond promptly.\n",
       "\n",
       "### 13. **Plan for API Versioning and Deprecation**\n",
       "\n",
       "Manage changes over time without disrupting existing users.\n",
       "\n",
       "- **Versioning Strategies**:\n",
       "  - **URI Versioning**: Include the version number in the URL (e.g., `/v1/users`).\n",
       "  - **Header Versioning**: Specify the version in request headers.\n",
       "- **Deprecation Policy**: Clearly communicate deprecation timelines and provide support for migrating to newer versions.\n",
       "\n",
       "### 14. **Optimize for Developer Experience**\n",
       "\n",
       "Make your API easy and enjoyable for others to use.\n",
       "\n",
       "- **Clear and Concise Endpoints**: Ensure endpoints are logical and easy to remember.\n",
       "- **Consistent Responses**: Maintain consistency in response structures and naming conventions.\n",
       "- **SDKs and Libraries**: Provide client libraries or SDKs in popular languages to simplify integration.\n",
       "- **Example Requests**: Offer example requests and responses in your documentation.\n",
       "\n",
       "### 15. **Understand and Comply with Relevant Standards and Regulations**\n",
       "\n",
       "Ensure your API adheres to necessary legal and industry standards.\n",
       "\n",
       "- **Data Privacy**: Comply with regulations like GDPR or CCPA if handling personal data.\n",
       "- **Industry Standards**: Follow relevant standards (e.g., OAuth2 for authentication, OpenAPI for documentation).\n",
       "- **Licensing**: Choose appropriate licenses for your API and any associated code or data.\n",
       "\n",
       "---\n",
       "\n",
       "### **Getting Started Checklist**\n",
       "\n",
       "To summarize, here's a checklist to guide you through developing your first Python API:\n",
       "\n",
       "1. **Select a Framework**: Choose between Flask, FastAPI, DRF, etc.\n",
       "2. **Set Up the Development Environment**: Use virtual environments, install necessary packages.\n",
       "3. **Design API Endpoints**: Plan resource endpoints, methods, and data structures.\n",
       "4. **Implement Authentication**: Decide on and implement an authentication mechanism.\n",
       "5. **Develop and Test Endpoints**: Write code for each endpoint and test thoroughly.\n",
       "6. **Handle Errors Gracefully**: Implement consistent error handling and logging.\n",
       "7. **Document Your API**: Create comprehensive and accessible documentation.\n",
       "8. **Write Automated Tests**: Ensure your API is reliable with unit and integration tests.\n",
       "9. **Prepare for Deployment**: Choose hosting, set up CI/CD pipelines.\n",
       "10. **Implement Security Measures**: Protect your API against common threats.\n",
       "11. **Monitor and Maintain**: Set up monitoring tools and plan for ongoing maintenance.\n",
       "\n",
       "By thoughtfully addressing each of these considerations, you'll be well on your way to developing a successful and maintainable Python API. Remember to start simple, iterate based on feedback, and continuously learn and adapt best practices as you gain more experience."
      ],
      "text/plain": [
       "<IPython.core.display.Markdown object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "prompt = \"What considerations should I keep in mind when developing my first Python API?\"\n",
    "\n",
    "resp = o1mini(prompt)\n",
    "display(Markdown(resp.choices[0].message.content))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "id": "2b8123e5-f7bb-4904-9897-fb48d650b718",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Prompt tokens = 21 | Completion tokens = 1990 | Total tokens = 2011\n"
     ]
    }
   ],
   "source": [
    "print(f\"Prompt tokens = {resp.usage.prompt_tokens} | Completion tokens = {resp.usage.completion_tokens} | Total tokens = {resp.usage.total_tokens}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d0b90615-20f6-4464-8e2b-94303fceb6f5",
   "metadata": {},
   "source": [
    "### Optimization with constraints example"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "id": "c581c787-6fa0-4672-aeca-b5364e9c5e15",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/markdown": [
       "To determine the optimal production levels of yogurt and cream that maximize Jane's revenue, we'll set up and solve a linear programming problem based on the given constraints.\n",
       "\n",
       "### **Variables:**\n",
       "- **\\( y \\)**: Liters of yogurt produced per week.\n",
       "- **\\( c \\)**: Liters of cream produced per week.\n",
       "\n",
       "### **Constraints:**\n",
       "1. **Milk Availability:**\n",
       "   - **Total milk produced per week:** \\( 30 \\text{ goats} \\times 20 \\text{ liters/goat} = 600 \\text{ liters} \\).\n",
       "   - **Milk used for yogurt:** \\( 1.5 \\text{ liters/yogurt} \\times y = 1.5y \\).\n",
       "   - **Milk used for cream:** \\( 6 \\text{ liters/cream} \\times c = 6c \\).\n",
       "   - **Total milk used must not exceed 600 liters:**\n",
       "     \\[\n",
       "     1.5y + 6c \\leq 600\n",
       "     \\]\n",
       "     Simplifying:\n",
       "     \\[\n",
       "     y + 4c \\leq 400\n",
       "     \\]\n",
       "   \n",
       "2. **Demand Constraints:**\n",
       "   - **At least 200 liters of yogurt:**\n",
       "     \\[\n",
       "     y \\geq 200\n",
       "     \\]\n",
       "   - **Yogurt must be at least 3 times the cream:**\n",
       "     \\[\n",
       "     y \\geq 3c\n",
       "     \\]\n",
       "\n",
       "3. **Non-negativity:**\n",
       "   \\[\n",
       "   y \\geq 0 \\quad \\text{and} \\quad c \\geq 0\n",
       "   \\]\n",
       "\n",
       "### **Objective Function:**\n",
       "Maximize revenue \\( R \\):\n",
       "\\[\n",
       "R = 36y + 10c\n",
       "\\]\n",
       "Where:\n",
       "- **Yogurt sells for \\$36 per liter.**\n",
       "- **Cream sells for \\$10 per liter.**\n",
       "\n",
       "### **Solving the Problem:**\n",
       "\n",
       "1. **Graphical Representation:**\n",
       "   - **Equation \\( y + 4c = 400 \\):** This line represents the milk constraint.\n",
       "   - **Equation \\( y = 200 \\):** The minimum yogurt production.\n",
       "   - **Equation \\( y = 3c \\):** The ratio constraint between yogurt and cream.\n",
       "\n",
       "2. **Feasible Region:**\n",
       "   - The feasible region is bounded by the intersection of the above constraints.\n",
       "   - The vertices (corner points) of this region are potential candidates for the optimal solution.\n",
       "\n",
       "3. **Identifying Vertices:**\n",
       "   - **Intersection of \\( y = 200 \\) and \\( y + 4c = 400 \\):**\n",
       "     \\[\n",
       "     200 + 4c = 400 \\implies c = 50\n",
       "     \\]\n",
       "     Point: **\\( (200, 50) \\)**\n",
       "   \n",
       "   - **Intersection of \\( y + 4c = 400 \\) and \\( c = 0 \\):**\n",
       "     \\[\n",
       "     y = 400\n",
       "     \\]\n",
       "     Point: **\\( (400, 0) \\)**\n",
       "\n",
       "4. **Evaluating the Objective Function at Vertices:**\n",
       "   - **At \\( (200, 50) \\):**\n",
       "     \\[\n",
       "     R = 36(200) + 10(50) = 7200 + 500 = \\$7,700\n",
       "     \\]\n",
       "   \n",
       "   - **At \\( (400, 0) \\):**\n",
       "     \\[\n",
       "     R = 36(400) + 10(0) = 14,400 + 0 = \\$14,400\n",
       "     \\]\n",
       "\n",
       "5. **Optimal Solution:**\n",
       "   - The highest revenue of **\\$14,400** is achieved at **\\( (400, 0) \\)**.\n",
       "   - This means producing **400 liters of yogurt** and **0 liters of cream** maximizes Jane's revenue.\n",
       "\n",
       "### **Conclusion:**\n",
       "To maximize her weekly revenue, Jane should produce:\n",
       "\n",
       "- **400 liters of yogurt**\n",
       "- **0 liters of cream**\n",
       "\n",
       "---\n",
       "\n",
       "**Answer:**  \n",
       "To maximize revenue, Jane should produce 400 liters of yogurt each week and produce no cream."
      ],
      "text/plain": [
       "<IPython.core.display.Markdown object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "prompt = \"\"\"\n",
    "Jane makes a living from her herd of 30 goats, each producing up to 20 liters of milk per week.\n",
    "She uses this milk to create two products that she then sells at the market: yogurt and cream. It takes 1.5 liters of milk to make 1 liter of yogurt.\n",
    "It also takes 6 liters of milk to produce 1 liter of cream.\n",
    "Given the demand for her products, Mélanie must produce at least 3 times more yogurt than cream and she must produce at least 200 liters of yogurt per week.\n",
    "At the market, she sells her yogurt for $36 per liter and her cream for $10 per liter.\n",
    "\n",
    "How many liters of yogurt and liters of cream should Jane produce per week to maximize her revenue?\n",
    "\"\"\"\n",
    "\n",
    "resp = o1mini(prompt)\n",
    "display(Markdown(resp.choices[0].message.content))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "id": "93cce4c1-5f1f-46f9-8df0-12689c46ea21",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Prompt tokens = 166 | Completion tokens = 3121 | Total tokens = 3287\n"
     ]
    }
   ],
   "source": [
    "print(f\"Prompt tokens = {resp.usage.prompt_tokens} | Completion tokens = {resp.usage.completion_tokens} | Total tokens = {resp.usage.total_tokens}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "869e8307-5655-4eee-81bd-6197d39a24ce",
   "metadata": {},
   "source": [
    "### Custom retention example"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "id": "309dfd06-d074-42cd-940e-5679b3143ef2",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/markdown": [
       "## Executive Summary\n",
       "\n",
       "After a comprehensive analysis of Emily Thompson's interactions and behaviors as a **Contoso Plus** subscriber, it is evident that while **cost** is the primary reason cited for her subscription cancellation, several underlying factors contribute to her dissatisfaction. Key findings include:\n",
       "\n",
       "- **Delivery Performance Issues:** Emily experienced delays during June and July, a period where overall on-time delivery rates decreased.\n",
       "- **Underutilization of Subscription Benefits:** Limited engagement with personalized styling sessions and exclusive discounts.\n",
       "- **Competitive Pricing Concerns:** The pricing of Dresses at Contoso is higher compared to competitors, potentially affecting perceived value.\n",
       "- **Minimal Engagement with Promotional Content:** Low interaction with certain email campaigns, indicating a possible disconnect with marketing efforts.\n",
       "\n",
       "**Recommendations** to retain Emily as a premium subscriber include offering personalized discounts, enhancing the utilization of subscription benefits, addressing delivery performance, and tailoring marketing communications to better align with her preferences.\n",
       "\n",
       "---\n",
       "\n",
       "## Detailed Analysis\n",
       "\n",
       "### 1. Primary Reason for Cancellation\n",
       "\n",
       "**Suspected Reason:** Financial Reasons (Cost)\n",
       "\n",
       "While Emily explicitly mentioned that the cost of the **Contoso Plus** subscription is becoming too high, this reason accounts for only **3%** of all cancellation reasons (Dataset 12). This suggests that while cost is her stated reason, other factors may influence her decision.\n",
       "\n",
       "### 2. Contributing Factors to Dissatisfaction\n",
       "\n",
       "#### a. **Delivery Performance**\n",
       "\n",
       "**Data Insights:**\n",
       "\n",
       "- **Observed Issues:** \n",
       "  - **June:** Average delivery time increased to **6 days**, on-time delivery rate dropped to **88%**, and customer complaints surged to **50**.\n",
       "  - **July:** Further degradation with an average delivery time of **7 days**, on-time rate of **85%**, and **70** customer complaints.\n",
       "  \n",
       "- **Impact on Emily:**\n",
       "  - **Order O5890 (2023-07-22):** Emily expressed concern about the timely delivery for an event, indicating the importance of reliable delivery (Customer Service Interaction 2).\n",
       "\n",
       "**Conclusion:** Delays during these months likely affected Emily's satisfaction, contributing to her desire to cancel the subscription.\n",
       "\n",
       "#### b. **Underutilization of Subscription Benefits**\n",
       "\n",
       "**Data Insights:**\n",
       "\n",
       "- **Benefit Utilization (Dataset 9):**\n",
       "  - **Free Shipping:** Used **7** times.\n",
       "  - **Early Access to Collections:** Used only **2** times.\n",
       "  - **Exclusive Discounts:** Used **1** time.\n",
       "  - **Personalized Styling Sessions:** **0** usage.\n",
       "\n",
       "- **Feedback from Store Visits (Dataset 8):**\n",
       "  - **Uptown Mall Visit (2023-07-20):** Booked a personal styling session but did not attend.\n",
       "\n",
       "**Conclusion:** Emily is not fully leveraging the available benefits, particularly personalized styling, which may reduce the perceived value of the subscription.\n",
       "\n",
       "#### c. **Competitive Pricing Concerns**\n",
       "\n",
       "**Data Insights:**\n",
       "\n",
       "- **Competitor Pricing Analysis (Dataset 14):**\n",
       "  - **Dresses:** Contoso's average price is **$120**, whereas competitors offer them at **$100**.\n",
       "  \n",
       "- **Email Marketing Engagement (Dataset 11):**\n",
       "  - Emily did not engage with the **Exclusive Member Offers** or **Personal Styling Invite** campaigns.\n",
       "\n",
       "**Conclusion:** Higher pricing in key categories like Dresses may lead Emily to perceive better value elsewhere, especially if she is financially sensitive.\n",
       "\n",
       "#### d. **Delivery and Operational Issues**\n",
       "\n",
       "**Data Insights:**\n",
       "\n",
       "- **Warehouse Incident Reports (Dataset 13):**\n",
       "  - **June Incident (2023-06-15):** Inventory system outage affecting **100** orders.\n",
       "  - **July Incident (2023-07-18):** Logistics partner strike affecting **250** orders.\n",
       "\n",
       "- **Impact on Delivery Performance:** These incidents coincide with the deterioration in delivery metrics, directly affecting Emily's experience.\n",
       "\n",
       "**Conclusion:** Operational disruptions led to delivery delays, eroding Emily's trust in the reliability of Contoso's services.\n",
       "\n",
       "#### e. **Minimal Engagement with Promotional Content**\n",
       "\n",
       "**Data Insights:**\n",
       "\n",
       "- **Email Marketing Engagement (Dataset 11):**\n",
       "  - Emily has not engaged with **Exclusive Member Offers** and **Personal Styling Invite**, which are key to maximizing subscription value.\n",
       "\n",
       "**Conclusion:** Lack of engagement suggests that the current marketing strategies may not align with Emily's interests or communication preferences.\n",
       "\n",
       "### 3. Quantified Patterns and Trends\n",
       "\n",
       "- **Delivery Performance Impact:**\n",
       "  - **June-July:** On-time delivery rate dropped from **95%** (April) to **85%** (July), directly overlapping with Emily's key orders.\n",
       "  \n",
       "- **Benefit Utilization Trends:**\n",
       "  - Emily has not utilized personalized styling sessions despite booking a session, indicating potential barriers or lack of perceived value.\n",
       "  \n",
       "- **Competitive Pricing Impact:**\n",
       "  - Dresses, a preferred category for Emily, are **$20** more expensive than competitors, which may influence her spending decisions.\n",
       "\n",
       "---\n",
       "\n",
       "## Personalized Email Draft\n",
       "\n",
       "**Subject:** We’re Here to Support You, Emily – Let’s Enhance Your Contoso Plus Experience\n",
       "\n",
       "---\n",
       "\n",
       "**Dear Emily,**\n",
       "\n",
       "I hope this message finds you well. I recently received your request to cancel your Contoso Plus subscription, and I wanted to take a moment to address your concerns personally.\n",
       "\n",
       "Firstly, I understand that managing expenses is important, and I'm sorry to hear that the cost of your subscription has been a burden. Your satisfaction is our priority, and I’d like to ensure you’re getting the maximum value from your Contoso Plus membership.\n",
       "\n",
       "**We’ve Noticed a Few Areas Where We Can Enhance Your Experience:**\n",
       "\n",
       "1. **Personalized Styling Sessions:**\n",
       "   - I see you had a styling session booked on July 20th but were unable to attend. We’d love to reschedule at your convenience to provide you with tailored fashion advice that aligns with your preferences in Dresses, Shoes, and Accessories.\n",
       "\n",
       "2. **Exclusive Discounts and Early Access:**\n",
       "   - To make your subscription more valuable, I’d like to offer you an **additional 20% discount** on your next purchase. Additionally, we can ensure you have priority access to our upcoming collections, so you never miss out on the styles you love.\n",
       "\n",
       "3. **Improved Delivery Experience:**\n",
       "   - We acknowledge the delivery delays you experienced earlier this year and have since enhanced our logistics partnerships to ensure timely deliveries. Your upcoming orders will benefit from our improved delivery process.\n",
       "\n",
       "4. **Competitive Pricing on Dresses:**\n",
       "   - Understanding your preference for Dresses, we are introducing a **special promotion** exclusively for Contoso Plus members, reducing the average price closer to market competitors.\n",
       "\n",
       "**As a token of our appreciation for your loyalty, I’d like to offer you a **15% discount** on renewing your Contoso Plus subscription for the next six months. Additionally, we’ll ensure you receive personalized updates on new arrivals and exclusive offers that match your style preferences.\n",
       "\n",
       "If you have any other concerns or suggestions, please don't hesitate to reach out. We value your feedback and are committed to providing you with an exceptional shopping experience.\n",
       "\n",
       "Thank you for being a valued member of the Contoso family. We hope to continue serving you with the quality and dedication you expect from us.\n",
       "\n",
       "Warm regards,\n",
       "\n",
       "[Your Name]  \n",
       "Customer Support Analyst  \n",
       "Contoso"
      ],
      "text/plain": [
       "<IPython.core.display.Markdown object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "prompt = \"\"\"\n",
    "<title>\n",
    "Customer Retention Analysis at Contoso: Uncovering the Root Cause of Subscription Cancellation\n",
    "</title>\n",
    "\n",
    "<background>\n",
    "\n",
    "Contoso is a leading fashion and clothing retailer that offers a premium subscription service called **Contoso Plus**. The service includes benefits like free shipping, early access to new collections, and personalized styling recommendations. Recently, a long-term customer, **Emily Thompson**, emailed customer support expressing her desire to cancel her **Contoso Plus** subscription, citing the cost as the main issue.\n",
    "\n",
    "As a customer support analyst, you have access to various datasets to investigate the underlying reasons for Emily's cancellation request. Your goal is to identify the true cause of her dissatisfaction and propose solutions to retain her as a valued customer.\n",
    "\n",
    "Below are the datasets available for your analysis:\n",
    "\n",
    "---\n",
    "\n",
    "### Dataset 1: Customer Profile\n",
    "\n",
    "This dataset provides an overview of Emily's interaction with Contoso.\n",
    "\n",
    "| Customer ID | Name            | Age | Membership Duration (Months) | Total Spend ($) | Average Monthly Spend ($) | Preferred Categories    |\n",
    "|-------------|-----------------|-----|------------------------------|-----------------|---------------------------|-------------------------|\n",
    "| C1024       | Emily Thompson  | 35  | 24                           | 4,800           | 200                       | Dresses, Shoes, Accessories |\n",
    "\n",
    "---\n",
    "\n",
    "### Dataset 2: Purchase History\n",
    "\n",
    "A detailed list of Emily's purchases over the past 6 months.\n",
    "\n",
    "| Order ID   | Date       | Items Purchased                    | Total Amount ($) | Discount Applied (%) | Date Delivered | Return Flag |\n",
    "|------------|------------|------------------------------------|------------------|----------------------|-----------------------|-------------|\n",
    "| O5678      | 2023-03-15 | Summer Floral Dress, Sun Hat       | 150              | 10                   | 2023-03-19                     | No          |\n",
    "| O5721      | 2023-04-10 | Leather Ankle Boots                | 120              | 15                   | 2023-04-13                     | No          |\n",
    "| O5789      | 2023-05-05 | Silk Scarf                         | 80               | 0                    | 2023-05-25                     | Yes         |\n",
    "| O5832      | 2023-06-18 | Casual Sneakers                    | 90               | 5                    | 2023-06-21                     | No          |\n",
    "| O5890      | 2023-07-22 | Evening Gown, Clutch Bag           | 300              | 20                   | 2023-08-05                | No          |\n",
    "| O5935      | 2023-08-30 | Denim Jacket                       | 110              | 0                    | 2023-09-03                     | Yes         |\n",
    "| O5970      | 2023-09-12 | Fitness Leggings, Sports Bra       | 130              | 25                   | 2023-09-18                     | No          |\n",
    "\n",
    "---\n",
    "\n",
    "### Dataset 3: Customer Service Interactions\n",
    "\n",
    "Transcripts of Emily's past interactions with customer support.\n",
    "\n",
    "#### Interaction 1: Live Chat on 2023-06-20\n",
    "\n",
    "**Agent:** Hello Emily, how can I assist you today?\n",
    "\n",
    "**Emily:** Hi, I just received my order O5789, and wanted to swap it for another colour\n",
    "\n",
    "**Agent:** Sure, that's fine- feel free to send it back or change it in store.\n",
    "\n",
    "**Emily:** Ok, I'll just send it back then\n",
    "\n",
    "**Agent:** Certainly. I've initiated the return process. You'll receive an email with the return instructions.\n",
    "\n",
    "**Emily:** Thank you.\n",
    "\n",
    "---\n",
    "\n",
    "#### Interaction 2: Phone Call on 2023-07-25\n",
    "\n",
    "**Agent:** Good afternoon, this is Contoso customer service. How may I help you?\n",
    "\n",
    "**Emily:** I'm calling about my order O5890. I need the gown for an event this weekend, and just want to make sure it will be delivered on time as it's really important.\n",
    "\n",
    "**Agent:** Let me check... it seems like the delivery is on track. It should be there on time.\n",
    "\n",
    "**Emily:** Ok thanks.\n",
    "\n",
    "---\n",
    "\n",
    "#### Interaction 3: Email on 2023-09-15\n",
    "\n",
    "*Subject:* Membership Cancellation Request\n",
    "\n",
    "*Body:*\n",
    "\n",
    "Hello,\n",
    "\n",
    "I want to cancel my Contoso Plus subscription. The cost is becoming too high for me.\n",
    "\n",
    "- Emily Thompson\n",
    "\n",
    "---\n",
    "\n",
    "### Dataset 4: Website Activity Log *DS*\n",
    "\n",
    "Logs of Emily's activity on the Contoso website.\n",
    "\n",
    "| Date       | Pages Visited                                  | Time Spent (Minutes) |\n",
    "|------------|------------------------------------------------|----------------------|\n",
    "| 2023-09-10 | Homepage, New Arrivals, Dresses                | 15                   |\n",
    "| 2023-09-11 | Account Settings, Subscription Details         | 5                    |\n",
    "| 2023-09-12 | FAQ, Return Policy                             | 3                    |\n",
    "| 2023-09-13 | Careers Page, Company Mission                  | 2                    |\n",
    "| 2023-09-14 | Sale Items, Accessories                        | 10                   |\n",
    "\n",
    "---\n",
    "\n",
    "### Dataset 5: Delivery Performance Metrics\n",
    "\n",
    "Company-wide delivery statistics over the past 6 months.\n",
    "\n",
    "| Month      | Average Delivery Time (Days) | On-Time Delivery Rate (%) | Customer Complaints Received |\n",
    "|------------|------------------------------|---------------------------|------------------------------|\n",
    "| March      | 3                            | 98                        | 15                           |\n",
    "| April      | 4                            | 95                        | 20                           |\n",
    "| May        | 5                            | 92                        | 30                           |\n",
    "| June       | 6                            | 88                        | 50                           |\n",
    "| July       | 7                            | 85                        | 70                           |\n",
    "| August     | 4                            | 94                        | 25                           |\n",
    "| September  | 3                            | 97                        | 10                           |\n",
    "\n",
    "---\n",
    "\n",
    "### Dataset 6: Product Return Rates *DS*\n",
    "\n",
    "Return rates for different product categories.\n",
    "\n",
    "| Category      | Return Rate (%) |\n",
    "|---------------|-----------------|\n",
    "| Dresses       | 15              |\n",
    "| Shoes         | 10              |\n",
    "| Accessories   | 8               |\n",
    "| Outerwear     | 12              |\n",
    "| Sportswear    | 9               |\n",
    "\n",
    "---\n",
    "\n",
    "### Dataset 7: Social Media Sentiment Analysis *DS*\n",
    "\n",
    "Aggregated customer sentiment towards Contoso.\n",
    "\n",
    "| Month      | Positive Mentions | Negative Mentions | Neutral Mentions |\n",
    "|------------|-------------------|-------------------|------------------|\n",
    "| March      | 500               | 50                | 200              |\n",
    "| April      | 480               | 60                | 220              |\n",
    "| May        | 450               | 80                | 250              |\n",
    "| June       | 400               | 120               | 300              |\n",
    "| July       | 350               | 150               | 320              |\n",
    "| August     | 480               | 70                | 230              |\n",
    "| September  | 510               | 40                | 210              |\n",
    "\n",
    "---\n",
    "\n",
    "### Dataset 8: Store Visit History\n",
    "\n",
    "Records of Emily's visits to physical Contoso stores.\n",
    "\n",
    "| Date       | Store Location        | Purpose           | Outcome                                 |\n",
    "|------------|-----------------------|-------------------|-----------------------------------------|\n",
    "| 2023-05-12 | Downtown Outlet       | Browsing          | Purchased a Silk Scarf (O5789)          |\n",
    "| 2023-07-20 | Uptown Mall           | Personal Styling  | Booked a session but didn't attend |\n",
    "| 2023-08-05 | Midtown Boutique      | Browsing          | No purchase                             |\n",
    "\n",
    "---\n",
    "\n",
    "### Dataset 9: Subscription Benefits Utilization\n",
    "\n",
    "Emily's usage of Contoso Plus benefits.\n",
    "\n",
    "| Benefit                       | Usage Frequency (Last 6 Months) |\n",
    "|-------------------------------|---------------------------------|\n",
    "| Free Shipping                 | 7                               |\n",
    "| Early Access to Collections   | 2                               |\n",
    "| Exclusive Discounts           | 1                               |\n",
    "| Personalized Styling Sessions | 0                               |\n",
    "\n",
    "---\n",
    "\n",
    "### Dataset 10: Customer Feedback Surveys\n",
    "\n",
    "Emily's responses to post-purchase surveys.\n",
    "\n",
    "#### Survey After Order O5678 (2023-03-16)\n",
    "\n",
    "- **Satisfaction Rating (1-5):** 5\n",
    "- **Comments:** \"\"Loved the summer dress! Fast delivery.\"\"\n",
    "\n",
    "#### Survey After Order O5970 (2023-09-13)\n",
    "\n",
    "- **Satisfaction Rating (1-5):** 4\n",
    "- **Comments:** \"\"Happy with the sportswear. Quick delivery.\"\"\n",
    "\n",
    "---\n",
    "\n",
    "### Dataset 11: Email Marketing Engagement *DS*\n",
    "\n",
    "Emily's engagement with promotional emails.\n",
    "\n",
    "| Campaign                  | Opened | Clicked | Unsubscribed |\n",
    "|---------------------------|--------|---------|--------------|\n",
    "| Summer Sale               | Yes    | Yes     | No           |\n",
    "| New Arrivals              | Yes    | No      | No           |\n",
    "| Exclusive Member Offers   | No     | No      | No           |\n",
    "| Personal Styling Invite   | No     | No      | No           |\n",
    "| Autumn Collection Preview | Yes    | Yes     | No           |\n",
    "\n",
    "---\n",
    "\n",
    "### Dataset 12: Customer Churn Analysis *DS*\n",
    "\n",
    "Metrics related to subscription cancellations across all customers.\n",
    "\n",
    "| Reason for Cancellation          | Percentage (%) |\n",
    "|----------------------------------|----------------|\n",
    "| Service Dissatisfaction          | 40             |\n",
    "| Financial Reasons                | **3**          |\n",
    "| Competitor Offer                 | 15             |\n",
    "| Moving to a Non-Service Area     | 5              |\n",
    "| Other                            | 37             |\n",
    "\n",
    "---\n",
    "\n",
    "### Dataset 13: Warehouse Incident Reports\n",
    "\n",
    "Reports of operational issues affecting order fulfillment.\n",
    "\n",
    "| Date       | Incident Description                              | Affected Orders |\n",
    "|------------|---------------------------------------------------|-----------------|\n",
    "| 2023-06-15 | Inventory system outage                           | 100             |\n",
    "| 2023-07-18 | Logistics partner strike                          | 250             |\n",
    "| 2023-08-25 | Warehouse flooding due to heavy rain              | 150             |\n",
    "\n",
    "---\n",
    "\n",
    "### Dataset 14: Competitor Pricing Analysis *DS*\n",
    "\n",
    "Comparison of product pricing with major competitors.\n",
    "\n",
    "| Product Category | Contoso Average Price ($) | Competitor Average Price ($) |\n",
    "|------------------|------------------------------|------------------------------|\n",
    "| Dresses          | 120                          | **100**                      |\n",
    "| Shoes            | 100                          | 105                          |\n",
    "| Accessories      | 60                           | 55                           |\n",
    "| Sportswear       | 80                           | 85                           |\n",
    "\n",
    "---\n",
    "\n",
    "### Dataset 15: Loyalty Program Overview\n",
    "\n",
    "Details of Contoso's loyalty point accrual and redemption for Emily.\n",
    "\n",
    "| Total Points Earned | Points Redeemed | Current Point Balance | Points Expiring Next Month |\n",
    "|---------------------|-----------------|-----------------------|----------------------------|\n",
    "| 4,800               | 3,600           | 1,200                 | 1,200                      |\n",
    "\n",
    "---\n",
    "\n",
    "### Dataset 16: Unauthorized Access Attempts *DS*\n",
    "\n",
    "Security logs related to Emily's account.\n",
    "\n",
    "| Date       | IP Address     | Location       | Successful Login? |\n",
    "|------------|----------------|----------------|-------------------|\n",
    "| 2023-06-20 | 192.168.1.1    | Home Network   | Yes               |\n",
    "| 2023-07-22 | 203.0.113.45   | Unknown        | No                |\n",
    "| 2023-08-15 | 198.51.100.23  | Office Network | Yes               |\n",
    "\n",
    "---\n",
    "\n",
    "</background>\n",
    "\n",
    "<question>\n",
    "\n",
    "### Task\n",
    "\n",
    "As a customer support analyst at Contoso, you are tasked with:\n",
    "\n",
    "1. **Identifying the primary reason for Emily Thompson's cancellation request**.\n",
    "2. **Providing a detailed analysis** of the factors contributing to her dissatisfaction.\n",
    "3. **Drafting a personalized email** responding to Emily's concerns, acknowledging the specific issues that have been frustrating for her, and offering solutions to retain her as a premium subscriber.\n",
    "\n",
    "Your analysis should:\n",
    "- Synthesize information from multiple datasets provided.\n",
    "- Highlight key incidents that have impacted Emily's experience.\n",
    "- Quantify any patterns or trends relevant to her case.\n",
    "\n",
    "</question>\n",
    "\n",
    "<instruction>\n",
    "\n",
    "- Carefully review all the datasets to extract relevant information.\n",
    "- Include all intermediate analyses and reference specific data points from the datasets to support your conclusions.\n",
    "- Provide a brief **executive summary** at the beginning of your solution, summarizing your key findings and recommendations.\n",
    "- Draft a professional and empathetic email to Emily, addressing her concerns.\n",
    "- Present your findings in a clear and structured manner, suitable for presentation to senior management.\n",
    "- Use markdown formatting for headings, tables, and any figures.\n",
    "\n",
    "</instruction>\"\n",
    "\"\"\"\n",
    "\n",
    "resp = o1mini(prompt)\n",
    "display(Markdown(resp.choices[0].message.content))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "id": "bae782d8-74a6-4190-b3d9-c5b1de7fa8b6",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Prompt tokens = 2881 | Completion tokens = 2120 | Total tokens = 5001\n"
     ]
    }
   ],
   "source": [
    "print(f\"Prompt tokens = {resp.usage.prompt_tokens} | Completion tokens = {resp.usage.completion_tokens} | Total tokens = {resp.usage.total_tokens}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "id": "5d5e4e59-d5ab-4f69-9b62-ebd3732e1520",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Total cost = 0.032709 €\n"
     ]
    }
   ],
   "source": [
    "total_cost = cost(resp.usage.prompt_tokens, resp.usage.completion_tokens)\n",
    "print(f\"Total cost = {total_cost:.6f} €\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e84bcae4-48e8-487d-9fd2-b6ec0a37f8b0",
   "metadata": {},
   "source": [
    "### Text generation example"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "id": "16a94e02-0dff-423e-ae85-739851111201",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/markdown": [
       "Creating an **Emoji-to-French Dictionary** can greatly enhance communication in a community that relies solely on emojis. Below is a comprehensive guide covering **everyday conversations** and **technical discussions**. The emojis are categorized for ease of use.\n",
       "\n",
       "---\n",
       "\n",
       "## 📚 **Everyday Conversations**\n",
       "\n",
       "### **Greetings & Farewells**\n",
       "| Emoji | French Meaning          |\n",
       "|-------|-------------------------|\n",
       "| 👋     | Bonjour / Salut (Hello / Hi) |\n",
       "| 🙋‍♂️ | Je suis là (I am here)      |\n",
       "| 👋🏻   | Au revoir (Goodbye)        |\n",
       "| 🌞    | Bonne journée (Have a good day) |\n",
       "| 🌜    | Bonne nuit (Good night)     |\n",
       "\n",
       "### **Emotions & Reactions**\n",
       "| Emoji | French Meaning          |\n",
       "|-------|-------------------------|\n",
       "| 😀     | Content / Heureux          |\n",
       "| 😢     | Triste / Pleurer           |\n",
       "| 😡     | En colère                  |\n",
       "| 😂     | Rire / Mdr                 |\n",
       "| 😍     | Amoureux / Adorer          |\n",
       "| 😱     | Effrayé / Choqué           |\n",
       "| 🤔     | Réfléchir / Penser          |\n",
       "| 😴     | Fatigué / Dormir            |\n",
       "\n",
       "### **Basic Expressions**\n",
       "| Emoji | French Meaning          |\n",
       "|-------|-------------------------|\n",
       "| 👍     | D'accord / Bien           |\n",
       "| 👎     | Pas d'accord / Mal        |\n",
       "| 🙏     | Merci / S'il te plaît      |\n",
       "| 💯    | Parfait / Excellent        |\n",
       "| 🎉    | Félicitations / Célébration |\n",
       "| ❓     | Question / Pourquoi        |\n",
       "| ❗     | Attention / Important      |\n",
       "\n",
       "### **Common Objects**\n",
       "| Emoji | French Meaning          |\n",
       "|-------|-------------------------|\n",
       "| 📱     | Téléphone                |\n",
       "| 💻    | Ordinateur               |\n",
       "| 🕰️    | Horloge                   |\n",
       "| 🚌    | Bus                      |\n",
       "| 🚗    | Voiture                  |\n",
       "| 🍎    | Pomme                    |\n",
       "| 🍞    | Pain                     |\n",
       "| ☕    | Café / Thé               |\n",
       "\n",
       "---\n",
       "\n",
       "## 🛠️ **Technical Discussions**\n",
       "\n",
       "### **Technology & Computers**\n",
       "| Emoji | French Meaning          |\n",
       "|-------|-------------------------|\n",
       "| 💻    | Ordinateur Portable      |\n",
       "| 🖥️    | Écran d'ordinateur       |\n",
       "| 🖱️    | Souris                   |\n",
       "| ⌨️    | Clavier                  |\n",
       "| 📱    | Smartphone               |\n",
       "| 📡    | Antenne / Connexion       |\n",
       "| 🔌    | Prise / Énergie           |\n",
       "| 🛰️    | Satellite                 |\n",
       "\n",
       "### **Software & Internet**\n",
       "| Emoji | French Meaning          |\n",
       "|-------|-------------------------|\n",
       "| 🌐    | Internet / Web            |\n",
       "| 🖧    | Réseau                   |\n",
       "| 🔒    | Sécurité / Verrouillé     |\n",
       "| 🔓    | Déverrouillé              |\n",
       "| 🖇️    | Attacher / Liaison        |\n",
       "| 🗂️    | Dossier / Classement      |\n",
       "| 📝    | Note / Documentation      |\n",
       "\n",
       "### **Engineering & Tools**\n",
       "| Emoji | French Meaning          |\n",
       "|-------|-------------------------|\n",
       "| 🛠️    | Outils / Réparation       |\n",
       "| 🔧    | Clé / Ajustement          |\n",
       "| 🪛    | Tournevis                 |\n",
       "| 🧰    | Boîte à outils            |\n",
       "| ⚙️    | Engrenage / Paramètres    |\n",
       "| 🪜    | Échelle                    |\n",
       "| 📐    | Règle / Mesure             |\n",
       "\n",
       "### **Science & Mathematics**\n",
       "| Emoji | French Meaning          |\n",
       "|-------|-------------------------|\n",
       "| 🔬    | Microscope                |\n",
       "| 🔭    | Télescope                 |\n",
       "| 🧬    | ADN / Génétique           |\n",
       "| 📊    | Graphique / Statistiques |\n",
       "| 📈    | Croissance / Courbe ascendante |\n",
       "| 📉    | Déclin / Courbe descendante |\n",
       "| ∑     | Somme / Sigma              |\n",
       "| π     | Pi                        |\n",
       "\n",
       "### **Miscellaneous Technical**\n",
       "| Emoji | French Meaning          |\n",
       "|-------|-------------------------|\n",
       "| ⚛️    | Atomique / Physique         |\n",
       "| ☢️    | Radioactif                 |\n",
       "| 🧲    | Aimant                     |\n",
       "| 🪐    | Planète / Astronomie        |\n",
       "| 🕹️    | Joystick / Contrôle de jeu  |\n",
       "| 🖨️    | Imprimante                 |\n",
       "| 📡    | Antenne / Transmission      |\n",
       "\n",
       "---\n",
       "\n",
       "## 🧑‍🤝‍🧑 **People & Roles**\n",
       "\n",
       "### **Professions**\n",
       "| Emoji | French Meaning          |\n",
       "|-------|-------------------------|\n",
       "| 👨‍⚕️  | Médecin (Doctor)            |\n",
       "| 👩‍💻  | Développeuse (Developer)    |\n",
       "| 👮‍♂️  | Policier (Police Officer)   |\n",
       "| 👨‍🏫 | Professeur (Teacher)        |\n",
       "| 👷‍♀️  | Ouvrière / Ingénieure (Worker / Engineer) |\n",
       "\n",
       "### **Roles & Relationships**\n",
       "| Emoji | French Meaning          |\n",
       "|-------|-------------------------|\n",
       "| 🧑‍🤝‍🧑 | Communauté / Groupe       |\n",
       "| 👨‍👩‍👧‍👦 | Famille                |\n",
       "| 🤝     | Accord / Collaboration      |\n",
       "| 💑     | Couple                     |\n",
       "| 👫     | Relations amicales/appariement |\n",
       "\n",
       "---\n",
       "\n",
       "## 📅 **Time & Dates**\n",
       "\n",
       "| Emoji | French Meaning          |\n",
       "|-------|-------------------------|\n",
       "| ⏰    | Réveil / Heure              |\n",
       "| 🗓️    | Calendrier / Date           |\n",
       "| 📅    | Agenda / Programmation      |\n",
       "| 🕒    | Troisième heure / 3h        |\n",
       "| 🕰️    | Horloge                     |\n",
       "\n",
       "---\n",
       "\n",
       "## 🏠 **Places & Directions**\n",
       "\n",
       "| Emoji | French Meaning          |\n",
       "|-------|-------------------------|\n",
       "| 🏠    | Maison                     |\n",
       "| 🏢    | Bâtiment / Bureau           |\n",
       "| 🏥    | Hôpital                    |\n",
       "| 🏫    | École / Université          |\n",
       "| 🚦    | Feu de signalisation        |\n",
       "| 🛣️    | Autoroute                   |\n",
       "| 🗺️    | Carte / Navigation           |\n",
       "\n",
       "---\n",
       "\n",
       "## 🍔 **Food & Drink**\n",
       "\n",
       "| Emoji | French Meaning          |\n",
       "|-------|-------------------------|\n",
       "| 🍎    | Pomme                      |\n",
       "| 🍞    | Pain                       |\n",
       "| 🍔    | Hamburger                  |\n",
       "| 🍕    | Pizza                      |\n",
       "| ☕    | Café / Thé                 |\n",
       "| 🍷    | Vin                        |\n",
       "| 🥗    | Salade                     |\n",
       "\n",
       "---\n",
       "\n",
       "## 🗣️ **Communication & Symbols**\n",
       "\n",
       "| Emoji | French Meaning          |\n",
       "|-------|-------------------------|\n",
       "| 💬    | Conversation / Message        |\n",
       "| 📢    | Annoncer / Publicité          |\n",
       "| 📧    | E-mail                        |\n",
       "| 📞    | Appel téléphonique            |\n",
       "| 📨    | Recevoir un message           |\n",
       "| 📲    | Message instantané / SMS       |\n",
       "| 🔔    | Notification / Alerte          |\n",
       "\n",
       "---\n",
       "\n",
       "## ⚠️ **Safety & Alerts**\n",
       "\n",
       "| Emoji | French Meaning          |\n",
       "|-------|-------------------------|\n",
       "| 🚨    | Urgence / Alerte             |\n",
       "| ⚠️    | Attention / Danger            |\n",
       "| 🔥    | Incendie / Urgent             |\n",
       "| 💣    | Bombe / Danger extrême        |\n",
       "| 💉    | Injection / Médicament        |\n",
       "\n",
       "---\n",
       "\n",
       "## ℹ️ **Miscellaneous**\n",
       "\n",
       "| Emoji | French Meaning          |\n",
       "|-------|-------------------------|\n",
       "| ❇️    | Information supplémentaire      |\n",
       "| 🆗    | Tout va bien / OK               |\n",
       "| 🅰️    | Lettre A / Début                |\n",
       "| 🆘    | S.O.S. / Aide urgente            |\n",
       "| 📴    | Éteindre le téléphone            |\n",
       "\n",
       "---\n",
       "\n",
       "### **Notes for Effective Use**\n",
       "- **Context Matters**: The meaning of an emoji can change based on context. Always consider surrounding emojis to infer the correct interpretation.\n",
       "- **Combining Emojis**: For more precise meanings, combine multiple emojis. For example, 👨‍💻💡 could represent a \"software developer's idea.\"\n",
       "- **Cultural Variations**: Some emojis might have different interpretations based on cultural nuances. Adapt as needed for the specific community.\n",
       "\n",
       "---\n",
       "\n",
       "This dictionary provides a foundational framework for emoji-based communication in French, accommodating both daily interactions and specialized technical discussions. As emoji usage evolves, consider updating the dictionary to include new emojis and meanings."
      ],
      "text/plain": [
       "<IPython.core.display.Markdown object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "prompt = \"\"\"\n",
    "Imagine a community that communicates solely through emojis.\n",
    "Create an emoji-to-French dictionary that is detailed enough to cover both everyday conversations and technical discussions.\n",
    "\"\"\"\n",
    "\n",
    "resp = o1mini(prompt)\n",
    "display(Markdown(resp.choices[0].message.content))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "id": "acfb3acd-350d-4038-956d-b2ec920a316a",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Prompt tokens = 38 | Completion tokens = 2076 | Total tokens = 2114\n"
     ]
    }
   ],
   "source": [
    "print(f\"Prompt tokens = {resp.usage.prompt_tokens} | Completion tokens = {resp.usage.completion_tokens} | Total tokens = {resp.usage.total_tokens}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d8e90bbe-15ab-476a-945d-beaa0caa0d47",
   "metadata": {},
   "source": [
    "### Python example"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "id": "22946257-08bd-46a6-992c-5f1f81b5d12c",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/markdown": [
       "Certainly! Below is a Python command-line application for financial planning that incorporates user input. It includes features like budgeting tools and expense tracking. This application allows users to:\n",
       "\n",
       "1. **Set Monthly Income**: Input your total monthly income.\n",
       "2. **Set Budget Categories**: Define different categories for budgeting (e.g., Rent, Food, Entertainment).\n",
       "3. **Add Expenses**: Track expenses under the defined categories.\n",
       "4. **View Budget Summary**: See a summary of your budget, expenses, and remaining balance.\n",
       "\n",
       "### Features:\n",
       "- **User-Friendly Menu**: Navigate through different options easily.\n",
       "- **Data Persistence**: Saves your data to a JSON file (`finance_data.json`) so that your information is retained between sessions.\n",
       "- **Error Handling**: Ensures that user inputs are valid and handles errors gracefully.\n",
       "\n",
       "### Prerequisites:\n",
       "- **Python 3.x**: Ensure you have Python installed on your system.\n",
       "- **Standard Libraries Used**: `json`, `os`, and `datetime` (all come pre-installed with Python).\n",
       "\n",
       "### Application Code:\n",
       "\n",
       "```python\n",
       "import json\n",
       "import os\n",
       "from datetime import datetime\n",
       "\n",
       "DATA_FILE = 'finance_data.json'\n",
       "\n",
       "def load_data():\n",
       "    if not os.path.exists(DATA_FILE):\n",
       "        # Initialize data structure\n",
       "        data = {\n",
       "            'income': 0.0,\n",
       "            'budget_categories': {},\n",
       "            'expenses': []\n",
       "        }\n",
       "        save_data(data)\n",
       "    else:\n",
       "        with open(DATA_FILE, 'r') as f:\n",
       "            data = json.load(f)\n",
       "    return data\n",
       "\n",
       "def save_data(data):\n",
       "    with open(DATA_FILE, 'w') as f:\n",
       "        json.dump(data, f, indent=4)\n",
       "\n",
       "def set_income(data):\n",
       "    while True:\n",
       "        try:\n",
       "            income = float(input(\"Enter your total monthly income: $\"))\n",
       "            if income < 0:\n",
       "                print(\"Income cannot be negative. Please try again.\")\n",
       "                continue\n",
       "            data['income'] = income\n",
       "            save_data(data)\n",
       "            print(f\"Monthly income set to ${income:.2f}\\n\")\n",
       "            break\n",
       "        except ValueError:\n",
       "            print(\"Invalid input. Please enter a numeric value.\")\n",
       "\n",
       "def set_budget_categories(data):\n",
       "    print(\"\\nSet Budget Categories\")\n",
       "    print(\"---------------------\")\n",
       "    print(\"Enter your budget categories. Type 'done' when finished.\")\n",
       "    while True:\n",
       "        category = input(\"Enter category name (or 'done'): \").strip()\n",
       "        if category.lower() == 'done':\n",
       "            break\n",
       "        if category in data['budget_categories']:\n",
       "            print(\"Category already exists. Please enter a different category.\")\n",
       "            continue\n",
       "        while True:\n",
       "            try:\n",
       "                amount = float(input(f\"Enter budget amount for '{category}': $\"))\n",
       "                if amount < 0:\n",
       "                    print(\"Amount cannot be negative. Please try again.\")\n",
       "                    continue\n",
       "                data['budget_categories'][category] = amount\n",
       "                save_data(data)\n",
       "                print(f\"Category '{category}' set with budget ${amount:.2f}\\n\")\n",
       "                break\n",
       "            except ValueError:\n",
       "                print(\"Invalid input. Please enter a numeric value.\")\n",
       "    print(\"Finished setting budget categories.\\n\")\n",
       "\n",
       "def add_expense(data):\n",
       "    if not data['budget_categories']:\n",
       "        print(\"No budget categories found. Please set budget categories first.\\n\")\n",
       "        return\n",
       "    print(\"\\nAdd Expense\")\n",
       "    print(\"-----------\")\n",
       "    print(\"Available Categories:\")\n",
       "    for idx, category in enumerate(data['budget_categories'], 1):\n",
       "        print(f\"{idx}. {category}\")\n",
       "    while True:\n",
       "        try:\n",
       "            choice = int(input(\"Select a category by number: \"))\n",
       "            if choice < 1 or choice > len(data['budget_categories']):\n",
       "                print(\"Invalid choice. Please select a valid category number.\")\n",
       "                continue\n",
       "            category = list(data['budget_categories'].keys())[choice - 1]\n",
       "            break\n",
       "        except ValueError:\n",
       "            print(\"Invalid input. Please enter a number corresponding to the category.\")\n",
       "    while True:\n",
       "        try:\n",
       "            amount = float(input(f\"Enter expense amount for '{category}': $\"))\n",
       "            if amount < 0:\n",
       "                print(\"Amount cannot be negative. Please try again.\")\n",
       "                continue\n",
       "            description = input(\"Enter a description for the expense: \").strip()\n",
       "            expense = {\n",
       "                'category': category,\n",
       "                'amount': amount,\n",
       "                'description': description,\n",
       "                'date': datetime.now().strftime(\"%Y-%m-%d %H:%M:%S\")\n",
       "            }\n",
       "            data['expenses'].append(expense)\n",
       "            save_data(data)\n",
       "            print(f\"Added expense of ${amount:.2f} to category '{category}'.\\n\")\n",
       "            break\n",
       "        except ValueError:\n",
       "            print(\"Invalid input. Please enter a numeric value.\")\n",
       "\n",
       "def view_summary(data):\n",
       "    print(\"\\nBudget Summary\")\n",
       "    print(\"--------------\")\n",
       "    income = data['income']\n",
       "    print(f\"Total Monthly Income: ${income:.2f}\")\n",
       "    total_budget = sum(data['budget_categories'].values())\n",
       "    print(f\"Total Budgeted Amount: ${total_budget:.2f}\")\n",
       "    print(f\"Remaining Income (Income - Total Budget): ${income - total_budget:.2f}\\n\")\n",
       "    \n",
       "    print(\"Budget by Category:\")\n",
       "    for category, amount in data['budget_categories'].items():\n",
       "        print(f\"  {category}: ${amount:.2f}\")\n",
       "    print()\n",
       "    \n",
       "    print(\"Expenses:\")\n",
       "    if not data['expenses']:\n",
       "        print(\"  No expenses recorded.\\n\")\n",
       "    else:\n",
       "        for expense in data['expenses']:\n",
       "            print(f\"  [{expense['date']}] {expense['category']}: ${expense['amount']:.2f} - {expense['description']}\")\n",
       "        print()\n",
       "    \n",
       "    # Calculate total expenses per category\n",
       "    expenses_per_category = {}\n",
       "    for expense in data['expenses']:\n",
       "        expenses_per_category.setdefault(expense['category'], 0.0)\n",
       "        expenses_per_category[expense['category']] += expense['amount']\n",
       "    \n",
       "    print(\"Expense Summary by Category:\")\n",
       "    for category, budget in data['budget_categories'].items():\n",
       "        spent = expenses_per_category.get(category, 0.0)\n",
       "        remaining = budget - spent\n",
       "        status = \"Under Budget\" if remaining >= 0 else \"Over Budget\"\n",
       "        print(f\"  {category}: Spent ${spent:.2f} / Budget ${budget:.2f} - {status} ({remaining:.2f})\")\n",
       "    print()\n",
       "\n",
       "def monthly_report(data):\n",
       "    print(\"\\nMonthly Report\")\n",
       "    print(\"--------------\")\n",
       "    if not data['expenses']:\n",
       "        print(\"No expenses recorded.\\n\")\n",
       "        return\n",
       "    # Aggregate expenses by category\n",
       "    expenses_per_category = {}\n",
       "    for expense in data['expenses']:\n",
       "        month = expense['date'][:7]  # YYYY-MM\n",
       "        if month != datetime.now().strftime(\"%Y-%m\"):\n",
       "            continue  # Only current month\n",
       "        expenses_per_category.setdefault(expense['category'], 0.0)\n",
       "        expenses_per_category[expense['category']] += expense['amount']\n",
       "    \n",
       "    if not expenses_per_category:\n",
       "        print(\"No expenses recorded for this month.\\n\")\n",
       "        return\n",
       "    \n",
       "    print(f\"Expenses for {datetime.now().strftime('%B %Y')}:\")\n",
       "    for category, amount in expenses_per_category.items():\n",
       "        print(f\"  {category}: ${amount:.2f}\")\n",
       "    print()\n",
       "\n",
       "def reset_data():\n",
       "    confirmation = input(\"Are you sure you want to reset all data? This action cannot be undone. (yes/no): \").strip().lower()\n",
       "    if confirmation == 'yes':\n",
       "        if os.path.exists(DATA_FILE):\n",
       "            os.remove(DATA_FILE)\n",
       "        print(\"All data has been reset.\\n\")\n",
       "    else:\n",
       "        print(\"Reset action canceled.\\n\")\n",
       "\n",
       "def main_menu():\n",
       "    data = load_data()\n",
       "    while True:\n",
       "        print(\"Financial Planning Application\")\n",
       "        print(\"------------------------------\")\n",
       "        print(\"1. Set Monthly Income\")\n",
       "        print(\"2. Set Budget Categories\")\n",
       "        print(\"3. Add Expense\")\n",
       "        print(\"4. View Budget Summary\")\n",
       "        print(\"5. View Monthly Report\")\n",
       "        print(\"6. Reset All Data\")\n",
       "        print(\"7. Exit\")\n",
       "        choice = input(\"Select an option (1-7): \").strip()\n",
       "        \n",
       "        if choice == '1':\n",
       "            set_income(data)\n",
       "        elif choice == '2':\n",
       "            set_budget_categories(data)\n",
       "        elif choice == '3':\n",
       "            add_expense(data)\n",
       "        elif choice == '4':\n",
       "            view_summary(data)\n",
       "        elif choice == '5':\n",
       "            monthly_report(data)\n",
       "        elif choice == '6':\n",
       "            reset_data()\n",
       "            data = load_data()\n",
       "        elif choice == '7':\n",
       "            print(\"Exiting the application. Goodbye!\")\n",
       "            break\n",
       "        else:\n",
       "            print(\"Invalid choice. Please select a valid option.\\n\")\n",
       "\n",
       "if __name__ == \"__main__\":\n",
       "    main_menu()\n",
       "```\n",
       "\n",
       "### How to Use the Application:\n",
       "\n",
       "1. **Save the Code**:\n",
       "   - Copy the above code into a file named, for example, `financial_planner.py`.\n",
       "\n",
       "2. **Run the Application**:\n",
       "   - Open your terminal or command prompt.\n",
       "   - Navigate to the directory containing `financial_planner.py`.\n",
       "   - Execute the script by running:\n",
       "     ```\n",
       "     python financial_planner.py\n",
       "     ```\n",
       "     *(Use `python3` instead of `python` if necessary, depending on your Python installation.)*\n",
       "\n",
       "3. **Navigate the Menu**:\n",
       "   - **Set Monthly Income**: Start by setting your total monthly income.\n",
       "   - **Set Budget Categories**: Define various categories you want to budget for (e.g., Rent, Groceries, Utilities).\n",
       "   - **Add Expense**: Log your expenses by selecting a category and entering the amount.\n",
       "   - **View Budget Summary**: Get a summary of your income, budgeted amounts, expenses, and remaining balances.\n",
       "   - **View Monthly Report**: See a report of your expenses for the current month.\n",
       "   - **Reset All Data**: If you want to start fresh, you can reset all your data.\n",
       "   - **Exit**: Close the application.\n",
       "\n",
       "4. **Data Persistence**:\n",
       "   - All your data is saved in a JSON file named `finance_data.json` in the same directory as the script. This allows your financial data to persist between different sessions of using the application.\n",
       "\n",
       "### Sample Interaction:\n",
       "\n",
       "```\n",
       "Financial Planning Application\n",
       "------------------------------\n",
       "1. Set Monthly Income\n",
       "2. Set Budget Categories\n",
       "3. Add Expense\n",
       "4. View Budget Summary\n",
       "5. View Monthly Report\n",
       "6. Reset All Data\n",
       "7. Exit\n",
       "Select an option (1-7): 1\n",
       "Enter your total monthly income: $5000\n",
       "Monthly income set to $5000.00\n",
       "\n",
       "Financial Planning Application\n",
       "------------------------------\n",
       "1. Set Monthly Income\n",
       "2. Set Budget Categories\n",
       "3. Add Expense\n",
       "4. View Budget Summary\n",
       "5. View Monthly Report\n",
       "6. Reset All Data\n",
       "7. Exit\n",
       "Select an option (1-7): 2\n",
       "\n",
       "Set Budget Categories\n",
       "---------------------\n",
       "Enter your budget categories. Type 'done' when finished.\n",
       "Enter category name (or 'done'): Rent\n",
       "Enter budget amount for 'Rent': $1500\n",
       "Category 'Rent' set with budget $1500.00\n",
       "\n",
       "Enter category name (or 'done'): Groceries\n",
       "Enter budget amount for 'Groceries': $500\n",
       "Category 'Groceries' set with budget $500.00\n",
       "\n",
       "Enter category name (or 'done'): Entertainment\n",
       "Enter budget amount for 'Entertainment': $300\n",
       "Category 'Entertainment' set with budget $300.00\n",
       "\n",
       "Enter category name (or 'done'): done\n",
       "Finished setting budget categories.\n",
       "\n",
       "Financial Planning Application\n",
       "------------------------------\n",
       "1. Set Monthly Income\n",
       "2. Set Budget Categories\n",
       "3. Add Expense\n",
       "4. View Budget Summary\n",
       "5. View Monthly Report\n",
       "6. Reset All Data\n",
       "7. Exit\n",
       "Select an option (1-7): 3\n",
       "\n",
       "Add Expense\n",
       "-----------\n",
       "Available Categories:\n",
       "1. Rent\n",
       "2. Groceries\n",
       "3. Entertainment\n",
       "Select a category by number: 2\n",
       "Enter expense amount for 'Groceries': $150\n",
       "Enter a description for the expense: Weekly groceries\n",
       "Added expense of $150.00 to category 'Groceries'.\n",
       "\n",
       "Financial Planning Application\n",
       "------------------------------\n",
       "1. Set Monthly Income\n",
       "2. Set Budget Categories\n",
       "3. Add Expense\n",
       "4. View Budget Summary\n",
       "5. View Monthly Report\n",
       "6. Reset All Data\n",
       "7. Exit\n",
       "Select an option (1-7): 4\n",
       "\n",
       "Budget Summary\n",
       "--------------\n",
       "Total Monthly Income: $5000.00\n",
       "Total Budgeted Amount: $2300.00\n",
       "Remaining Income (Income - Total Budget): $2700.00\n",
       "\n",
       "Budget by Category:\n",
       "  Rent: $1500.00\n",
       "  Groceries: $500.00\n",
       "  Entertainment: $300.00\n",
       "\n",
       "Expenses:\n",
       "  [2023-10-01 12:34:56] Groceries: $150.00 - Weekly groceries\n",
       "\n",
       "Expense Summary by Category:\n",
       "  Rent: Spent $0.00 / Budget $1500.00 - Under Budget (1500.00)\n",
       "  Groceries: Spent $150.00 / Budget $500.00 - Under Budget (350.00)\n",
       "  Entertainment: Spent $0.00 / Budget $300.00 - Under Budget (300.00)\n",
       "```\n",
       "\n",
       "### Enhancements & Future Improvements:\n",
       "\n",
       "- **Data Encryption**: For security, especially if sensitive financial data is stored.\n",
       "- **GUI Interface**: Implement a graphical user interface using libraries like Tkinter or PyQt for better user experience.\n",
       "- **Recurring Expenses & Income**: Handle regular payments and income streams automatically.\n",
       "- **Reporting & Analytics**: Provide more detailed insights, charts, and trends over time.\n",
       "- **Multiple Months Support**: Track finances across multiple months instead of just the current month.\n",
       "- **Export Data**: Allow exporting reports to formats like CSV or PDF.\n",
       "\n",
       "### Conclusion\n",
       "\n",
       "This Python application serves as a foundational tool for personal financial planning. It leverages user input to manage income, budget allocations, and expenses, providing a clear overview of one's financial state. You can further expand its functionality based on your requirements and Python proficiency."
      ],
      "text/plain": [
       "<IPython.core.display.Markdown object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "prompt = \"\"\"\n",
    "Create a Python application for financial planning that incorporates user input.\n",
    "Ensure it includes features like budgeting tools, expense.\n",
    "\"\"\"\n",
    "\n",
    "resp = o1mini(prompt)\n",
    "display(Markdown(resp.choices[0].message.content))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "id": "ae385c34-8898-44e2-a701-c7f7fc61dd10",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Prompt tokens = 31 | Completion tokens = 3178 | Total tokens = 3209\n"
     ]
    }
   ],
   "source": [
    "print(f\"Prompt tokens = {resp.usage.prompt_tokens} | Completion tokens = {resp.usage.completion_tokens} | Total tokens = {resp.usage.total_tokens}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "beadc3c1-8a33-4dbd-8977-550e94f662de",
   "metadata": {},
   "source": [
    "### Code example"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "id": "524dbfd1-8c2b-4dd2-b179-5cc60845992e",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/markdown": [
       "Sure! Below is a complete, self-contained HTML file that implements an iPhone-style scientific calculator using Tailwind CSS and JavaScript. You can save this code as an `.html` file and open it in your browser to use the calculator.\n",
       "\n",
       "### Features:\n",
       "- **iPhone-Style Design**: Clean and modern UI inspired by the iPhone's calculator.\n",
       "- **Basic Operations**: Addition, subtraction, multiplication, division.\n",
       "- **Scientific Functions**: Sine, cosine, tangent, logarithm, exponentiation, square root, and more.\n",
       "- **Responsive Layout**: Adapts to different screen sizes.\n",
       "\n",
       "### Code Explanation:\n",
       "- **Tailwind CSS**: Integrated via CDN for rapid styling using utility classes.\n",
       "- **JavaScript**:\n",
       "  - Handles button clicks to build and evaluate mathematical expressions.\n",
       "  - Uses `math.js` library (included via CDN) for robust mathematical computations and error handling.\n",
       "\n",
       "### Complete HTML Code:\n",
       "\n",
       "```html\n",
       "<!DOCTYPE html>\n",
       "<html lang=\"en\">\n",
       "<head>\n",
       "    <meta charset=\"UTF-8\">\n",
       "    <title>iPhone-Style Scientific Calculator</title>\n",
       "    <meta name=\"viewport\" content=\"width=device-width, initial-scale=1.0\">\n",
       "    <!-- Tailwind CSS CDN -->\n",
       "    <script src=\"https://cdn.tailwindcss.com\"></script>\n",
       "    <!-- Optional: Use Tailwind Configuration for Customization -->\n",
       "    <style>\n",
       "        /* Custom styles for the calculator buttons */\n",
       "        .btn {\n",
       "            @apply w-16 h-16 m-1 bg-gray-800 text-white rounded-full flex items-center justify-center text-xl shadow-lg;\n",
       "        }\n",
       "        .btn-operator {\n",
       "            @apply bg-orange-500;\n",
       "        }\n",
       "        .btn-function {\n",
       "            @apply bg-gray-600;\n",
       "        }\n",
       "        .btn-equal {\n",
       "            @apply bg-green-500;\n",
       "        }\n",
       "        .btn-clear {\n",
       "            @apply bg-red-500;\n",
       "        }\n",
       "        .btn-zero {\n",
       "            @apply w-34; /* To make zero button wider */\n",
       "        }\n",
       "        /* Display styling */\n",
       "        .display {\n",
       "            @apply bg-black text-white text-right p-4 rounded mb-2 text-3xl min-h-[60px];\n",
       "            word-wrap: break-word;\n",
       "        }\n",
       "    </style>\n",
       "</head>\n",
       "<body class=\"flex items-center justify-center min-h-screen bg-gray-900\">\n",
       "    <div class=\"w-full max-w-md p-4 bg-gray-800 rounded-xl shadow-2xl\">\n",
       "        <div id=\"display\" class=\"display\">\n",
       "            0\n",
       "        </div>\n",
       "        <div class=\"grid grid-cols-5 gap-2\">\n",
       "            <!-- Scientific Functions -->\n",
       "            <button class=\"btn btn-function\" data-value=\"sin(\">sin</button>\n",
       "            <button class=\"btn btn-function\" data-value=\"cos(\">cos</button>\n",
       "            <button class=\"btn btn-function\" data-value=\"tan(\">tan</button>\n",
       "            <button class=\"btn btn-function\" data-value=\"log(\">log</button>\n",
       "            <button class=\"btn btn-function\" data-value=\"ln(\">ln</button>\n",
       "\n",
       "            <button class=\"btn btn-function\" data-value=\"√(\">√</button>\n",
       "            <button class=\"btn btn-function\" data-value=\"^\">^</button>\n",
       "            <button class=\"btn btn-function\" data-value=\"(\">(</button>\n",
       "            <button class=\"btn btn-function\" data-value=\")\">)</button>\n",
       "            <button class=\"btn btn-clear\" id=\"clear\">C</button>\n",
       "\n",
       "            <!-- Numbers and Operators -->\n",
       "            <button class=\"btn\" data-value=\"7\">7</button>\n",
       "            <button class=\"btn\" data-value=\"8\">8</button>\n",
       "            <button class=\"btn\" data-value=\"9\">9</button>\n",
       "            <button class=\"btn btn-operator\" data-value=\"/\">÷</button>\n",
       "            <button class=\"btn btn-function\" data-value=\"pi\">π</button>\n",
       "\n",
       "            <button class=\"btn\" data-value=\"4\">4</button>\n",
       "            <button class=\"btn\" data-value=\"5\">5</button>\n",
       "            <button class=\"btn\" data-value=\"6\">6</button>\n",
       "            <button class=\"btn btn-operator\" data-value=\"*\">×</button>\n",
       "            <button class=\"btn btn-function\" data-value=\"e\">e</button>\n",
       "\n",
       "            <button class=\"btn\" data-value=\"1\">1</button>\n",
       "            <button class=\"btn\" data-value=\"2\">2</button>\n",
       "            <button class=\"btn\" data-value=\"3\">3</button>\n",
       "            <button class=\"btn btn-operator\" data-value=\"-\">−</button>\n",
       "            <button class=\"btn btn-equal\" rowspan=\"2\" id=\"equals\">=</button>\n",
       "\n",
       "            <button class=\"btn btn-zero\" data-value=\"0\">0</button>\n",
       "            <button class=\"btn\" data-value=\".\">.</button>\n",
       "            <button class=\"btn btn-operator\" data-value=\"+\">+</button>\n",
       "        </div>\n",
       "    </div>\n",
       "\n",
       "    <!-- Math.js CDN for robust mathematical computations -->\n",
       "    <script src=\"https://cdnjs.cloudflare.com/ajax/libs/mathjs/11.8.0/math.min.js\" integrity=\"sha512-CyQEH98jxeEmEF58K07k8ki61/dwRev+tNjy+6FluYbSlBJVMrNRLgjazEGAaAaJpBfx39wtsH7JvyAfHok+PQ==\" crossorigin=\"anonymous\" referrerpolicy=\"no-referrer\"></script>\n",
       "\n",
       "    <script>\n",
       "        const display = document.getElementById('display');\n",
       "        const buttons = document.querySelectorAll('button');\n",
       "        const clearButton = document.getElementById('clear');\n",
       "        const equalsButton = document.getElementById('equals');\n",
       "\n",
       "        let expression = '';\n",
       "\n",
       "        buttons.forEach(button => {\n",
       "            button.addEventListener('click', () => {\n",
       "                const value = button.getAttribute('data-value');\n",
       "\n",
       "                if (button === clearButton) {\n",
       "                    expression = '';\n",
       "                    display.innerText = '0';\n",
       "                } else if (button === equalsButton) {\n",
       "                    try {\n",
       "                        // Replace symbols with math.js compatible syntax\n",
       "                        let expr = expression\n",
       "                            .replace(/÷/g, '/')\n",
       "                            .replace(/×/g, '*')\n",
       "                            .replace(/−/g, '-')\n",
       "                            .replace(/π/g, 'pi')\n",
       "                            .replace(/√/g, 'sqrt')\n",
       "                            .replace(/ln/g, 'log'); // math.js uses log for natural logarithm\n",
       "\n",
       "                        // Evaluate the expression using math.js\n",
       "                        const result = math.evaluate(expr);\n",
       "                        display.innerText = result;\n",
       "                        expression = result.toString();\n",
       "                    } catch (error) {\n",
       "                        display.innerText = 'Error';\n",
       "                        expression = '';\n",
       "                    }\n",
       "                } else {\n",
       "                    expression += value;\n",
       "                    display.innerText = expression;\n",
       "                }\n",
       "            });\n",
       "        });\n",
       "\n",
       "        // Optional: Handle keyboard input\n",
       "        document.addEventListener('keydown', (event) => {\n",
       "            const key = event.key;\n",
       "            const validKeys = '0123456789.+-*/()^';\n",
       "            const functions = {\n",
       "                'Enter': '=',\n",
       "                'Escape': 'C',\n",
       "                'Backspace': 'C'\n",
       "            };\n",
       "\n",
       "            if (validKeys.includes(key)) {\n",
       "                expression += key;\n",
       "                display.innerText = expression;\n",
       "            } else if (key in functions) {\n",
       "                if (functions[key] === '=') {\n",
       "                    equalsButton.click();\n",
       "                } else if (functions[key] === 'C') {\n",
       "                    clearButton.click();\n",
       "                }\n",
       "            }\n",
       "            // Add more keyboard handling as needed\n",
       "        });\n",
       "    </script>\n",
       "</body>\n",
       "</html>\n",
       "```\n",
       "\n",
       "### How It Works:\n",
       "\n",
       "1. **Layout**:\n",
       "    - The calculator is structured using a **grid layout** with 5 columns to accommodate scientific functions, numbers, and operators.\n",
       "    - Buttons are styled using Tailwind CSS utility classes for consistent sizing, coloring, and spacing.\n",
       "\n",
       "2. **Buttons**:\n",
       "    - **Scientific Functions**: Buttons like `sin`, `cos`, `tan`, `log`, `ln`, `√`, `^`, and constants like `π` and `e` are included.\n",
       "    - **Operators and Numbers**: Basic arithmetic operators and numerical digits are laid out similar to a standard calculator.\n",
       "    - **Special Buttons**:\n",
       "        - `C`: Clears the current expression.\n",
       "        - `=`: Evaluates the expression.\n",
       "\n",
       "3. **JavaScript Functionality**:\n",
       "    - **Expression Building**: Clicking on buttons appends their respective values to the `expression` string and updates the display.\n",
       "    - **Evaluation**: Upon clicking `=`, the expression is sanitized and passed to `math.js` for evaluation. Results or errors are displayed accordingly.\n",
       "    - **Keyboard Support**: The calculator also listens for keyboard inputs, allowing users to type expressions directly.\n",
       "\n",
       "4. **Math.js Integration**:\n",
       "    - **Robust Calculations**: Instead of using `eval()`, which can be dangerous and limited, `math.js` provides a secure and comprehensive way to parse and evaluate mathematical expressions.\n",
       "    - **Syntax Replacement**: Certain symbols (like `÷`, `×`, `−`, `π`, and `√`) are replaced with `math.js`-compatible syntax before evaluation.\n",
       "\n",
       "### Customization:\n",
       "\n",
       "- **Styling**: You can modify the Tailwind CSS classes or the custom `<style>` section to change the appearance of the calculator.\n",
       "- **Functions**: Additional scientific functions can be added by introducing new buttons and handling them in the JavaScript section.\n",
       "- **Responsive Design**: The current setup is responsive, but you can enhance it further by tweaking Tailwind’s responsive utility classes.\n",
       "\n",
       "### Usage:\n",
       "\n",
       "1. **Basic Operations**: Click on the numerical and operator buttons to build an expression, then press `=` to evaluate.\n",
       "2. **Scientific Calculations**: Use functions like `sin`, `cos`, `tan`, etc., to perform trigonometric and logarithmic calculations.\n",
       "3. **Clearing**: Press the `C` button to clear the current input.\n",
       "4. **Keyboard Support**: You can also use your keyboard to type expressions and press `Enter` to evaluate.\n",
       "\n",
       "---\n",
       "\n",
       "Feel free to enhance and expand this calculator based on your specific needs!"
      ],
      "text/plain": [
       "<IPython.core.display.Markdown object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "prompt = \"iPhone-style scientific calculator in a single HTML file, using Tailwind CSS and JavaScript.\"\n",
    "\n",
    "resp = o1mini(prompt)\n",
    "display(Markdown(resp.choices[0].message.content))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "id": "5c53510f-793a-4cd4-9bc2-25bc1417b157",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Prompt tokens = 26 | Completion tokens = 2395 | Total tokens = 2421\n"
     ]
    }
   ],
   "source": [
    "print(f\"Prompt tokens = {resp.usage.prompt_tokens} | Completion tokens = {resp.usage.completion_tokens} | Total tokens = {resp.usage.total_tokens}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5bb4f017-031f-44e5-b3b9-f9747ed12d4b",
   "metadata": {},
   "source": [
    "### Python example"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "id": "45634ed4-ec91-4b5e-9f7c-4b5607f49b76",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/markdown": [
       "Certainly! Below is a JavaScript function that reverses a given string. The code adheres to best practices, is well-commented, and easy to understand.\n",
       "\n",
       "```javascript\n",
       "/**\n",
       " * Reverses the input string.\n",
       " *\n",
       " * @param {string} str - The string to be reversed.\n",
       " * @returns {string} - The reversed string.\n",
       " */\n",
       "function reverseString(str) {\n",
       "    // Check if the input is a string\n",
       "    if (typeof str !== 'string') {\n",
       "        throw new TypeError('Input must be a string');\n",
       "    }\n",
       "\n",
       "    // Split the string into an array of characters,\n",
       "    // reverse the array, and join it back into a string\n",
       "    return str.split('').reverse().join('');\n",
       "}\n",
       "\n",
       "// Example usage:\n",
       "const originalString = \"Hello, World!\";\n",
       "const reversed = reverseString(originalString);\n",
       "console.log(reversed); // Output: \"!dlroW ,olleH\"\n",
       "```\n",
       "\n",
       "---\n",
       "\n",
       "### How the Code Works: Step-by-Step Explanation\n",
       "\n",
       "1. **Function Declaration**:\n",
       "    ```javascript\n",
       "    function reverseString(str) { ... }\n",
       "    ```\n",
       "    - Defines a function named `reverseString` that takes one parameter, `str`.\n",
       "\n",
       "2. **Input Validation**:\n",
       "    ```javascript\n",
       "    if (typeof str !== 'string') {\n",
       "        throw new TypeError('Input must be a string');\n",
       "    }\n",
       "    ```\n",
       "    - Checks if the provided `str` is of type string.\n",
       "    - If not, it throws a `TypeError` to inform the user that the input must be a string. This is a good practice to ensure the function behaves predictably.\n",
       "\n",
       "3. **Reversing the String**:\n",
       "    ```javascript\n",
       "    return str.split('').reverse().join('');\n",
       "    ```\n",
       "    - **`str.split('')`**:\n",
       "        - Splits the string into an array of individual characters.\n",
       "        - Example: `\"Hello\"` becomes `['H', 'e', 'l', 'l', 'o']`.\n",
       "    - **`.reverse()`**:\n",
       "        - Reverses the array in place.\n",
       "        - Example: `['H', 'e', 'l', 'l', 'o']` becomes `['o', 'l', 'l', 'e', 'H']`.\n",
       "    - **`.join('')`**:\n",
       "        - Joins the array of characters back into a single string.\n",
       "        - Example: `['o', 'l', 'l', 'e', 'H']` becomes `\"olleH\"`.\n",
       "    - The reversed string is then returned.\n",
       "\n",
       "4. **Example Usage**:\n",
       "    ```javascript\n",
       "    const originalString = \"Hello, World!\";\n",
       "    const reversed = reverseString(originalString);\n",
       "    console.log(reversed); // Output: \"!dlroW ,olleH\"\n",
       "    ```\n",
       "    - Demonstrates how to use the `reverseString` function with an example input.\n",
       "\n",
       "---\n",
       "\n",
       "### Complexity Analysis\n",
       "\n",
       "- **Time Complexity**: O(n)\n",
       "    - The operations `split`, `reverse`, and `join` each take linear time relative to the length of the string (`n`).\n",
       "    - Therefore, the overall time complexity is O(n).\n",
       "\n",
       "- **Space Complexity**: O(n)\n",
       "    - The `split` method creates an array of size `n`.\n",
       "    - The `reverse` method operates in place but the `join` method creates a new string, resulting in additional space proportional to `n`.\n",
       "\n",
       "---\n",
       "\n",
       "### Potential Edge Cases\n",
       "\n",
       "1. **Empty String**:\n",
       "    - Input: `\"\"`\n",
       "    - Output: `\"\"`\n",
       "    - The function correctly handles empty strings by returning an empty string.\n",
       "\n",
       "2. **Single Character**:\n",
       "    - Input: `\"a\"`\n",
       "    - Output: `\"a\"`\n",
       "    - A single character string remains unchanged upon reversal.\n",
       "\n",
       "3. **Unicode Characters**:\n",
       "    - Input: `\"😊🚀\"`\n",
       "    - Output: `\"🚀😊\"`\n",
       "    - The function works with Unicode characters, including emojis.\n",
       "\n",
       "4. **Strings with Spaces and Punctuation**:\n",
       "    - Input: `\"Hello, World!\"`\n",
       "    - Output: `\"!dlroW ,olleH\"`\n",
       "    - Preserves spaces and punctuation in their reversed positions.\n",
       "\n",
       "5. **Non-String Inputs**:\n",
       "    - Input: `12345` (Number)\n",
       "    - Behavior: Throws a `TypeError`\n",
       "    - The function enforces that only strings are processed.\n",
       "\n",
       "---\n",
       "\n",
       "### Alternative Approaches\n",
       "\n",
       "1. **Using a For Loop**:\n",
       "    ```javascript\n",
       "    function reverseString(str) {\n",
       "        if (typeof str !== 'string') {\n",
       "            throw new TypeError('Input must be a string');\n",
       "        }\n",
       "\n",
       "        let reversed = '';\n",
       "        for (let i = str.length - 1; i >= 0; i--) {\n",
       "            reversed += str[i];\n",
       "        }\n",
       "        return reversed;\n",
       "    }\n",
       "    ```\n",
       "    - **Pros**:\n",
       "        - More control over the reversal process.\n",
       "        - Can be optimized for specific use cases.\n",
       "    - **Cons**:\n",
       "        - Typically slower for very long strings due to string concatenation in a loop.\n",
       "\n",
       "2. **Using Recursion**:\n",
       "    ```javascript\n",
       "    function reverseString(str) {\n",
       "        if (typeof str !== 'string') {\n",
       "            throw new TypeError('Input must be a string');\n",
       "        }\n",
       "        if (str === \"\") {\n",
       "            return \"\";\n",
       "        } else {\n",
       "            return reverseString(str.substr(1)) + str.charAt(0);\n",
       "        }\n",
       "    }\n",
       "    ```\n",
       "    - **Pros**:\n",
       "        - Elegant and concise for educational purposes.\n",
       "    - **Cons**:\n",
       "        - Not efficient for long strings due to call stack limitations.\n",
       "        - Risk of stack overflow with very long strings.\n",
       "\n",
       "3. **Using Array's `reduce` Method**:\n",
       "    ```javascript\n",
       "    function reverseString(str) {\n",
       "        if (typeof str !== 'string') {\n",
       "            throw new TypeError('Input must be a string');\n",
       "        }\n",
       "\n",
       "        return str.split('').reduce((reversed, character) => character + reversed, '');\n",
       "    }\n",
       "    ```\n",
       "    - **Pros**:\n",
       "        - Functional programming approach.\n",
       "    - **Cons**:\n",
       "        - Less intuitive for those unfamiliar with `reduce`.\n",
       "        - May have similar performance to the loop method.\n",
       "\n",
       "---\n",
       "\n",
       "### Performance Improvements\n",
       "\n",
       "- **Avoiding Multiple Iterations**:\n",
       "    - The initial method (`split`, `reverse`, `join`) involves three iterations over the string. If performance is critical, especially for very long strings, a single-pass approach using a loop can be more efficient.\n",
       "\n",
       "- **Using In-Place Reversal for Mutable Data Structures**:\n",
       "    - Strings are immutable in JavaScript, so in-place reversal isn't possible. However, if dealing with mutable data structures like arrays, in-place reversal can save memory.\n",
       "\n",
       "- **Handling Surrogate Pairs and Combining Characters**:\n",
       "    - The basic reversal method may not correctly handle Unicode surrogate pairs or combining characters. For applications requiring accurate processing of such characters, more sophisticated handling is necessary.\n",
       "\n",
       "---\n",
       "\n",
       "### Adapting the Code for Similar Tasks\n",
       "\n",
       "1. **Reversing Array Elements**:\n",
       "    - The same approach can be used to reverse elements in an array by skipping the `split` and `join` steps.\n",
       "    ```javascript\n",
       "    function reverseArray(arr) {\n",
       "        if (!Array.isArray(arr)) {\n",
       "            throw new TypeError('Input must be an array');\n",
       "        }\n",
       "        return arr.reverse();\n",
       "    }\n",
       "    ```\n",
       "\n",
       "2. **Reversing Words in a Sentence**:\n",
       "    - To reverse the order of words instead of characters:\n",
       "    ```javascript\n",
       "    function reverseWords(sentence) {\n",
       "        if (typeof sentence !== 'string') {\n",
       "            throw new TypeError('Input must be a string');\n",
       "        }\n",
       "        return sentence.split(' ').reverse().join(' ');\n",
       "    }\n",
       "\n",
       "    // Example:\n",
       "    console.log(reverseWords(\"Hello World from JavaScript\"));\n",
       "    // Output: \"JavaScript from World Hello\"\n",
       "    ```\n",
       "\n",
       "3. **Palindrome Checker**:\n",
       "    - Using the `reverseString` function to check if a string is a palindrome:\n",
       "    ```javascript\n",
       "    function isPalindrome(str) {\n",
       "        if (typeof str !== 'string') {\n",
       "            throw new TypeError('Input must be a string');\n",
       "        }\n",
       "        const cleanedStr = str.replace(/[^A-Za-z0-9]/g, '').toLowerCase();\n",
       "        const reversed = reverseString(cleanedStr);\n",
       "        return cleanedStr === reversed;\n",
       "    }\n",
       "\n",
       "    // Example:\n",
       "    console.log(isPalindrome(\"A man, a plan, a canal: Panama\")); // Output: true\n",
       "    ```\n",
       "\n",
       "4. **Case Conversion During Reversal**:\n",
       "    - Reversing the string and converting it to uppercase:\n",
       "    ```javascript\n",
       "    function reverseStringUpperCase(str) {\n",
       "        return reverseString(str).toUpperCase();\n",
       "    }\n",
       "    ```\n",
       "\n",
       "---\n",
       "\n",
       "### Conclusion\n",
       "\n",
       "Reversing a string is a common task that can be accomplished efficiently in JavaScript using built-in methods. Understanding various approaches allows developers to choose the most suitable method based on the specific requirements and constraints of their applications. Always consider input validation and edge cases to make your functions robust and reliable."
      ],
      "text/plain": [
       "<IPython.core.display.Markdown object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "prompt = \"\"\"\n",
    "As an expert developer proficient in python, please generate a code snippet to solve the following problem: [insert problem description]. \n",
    "Ensure the code follows best practices, is well-commented, and easy to understand.\n",
    "\n",
    "Additionally, explain how the code works step-by-step and offer suggestions for optimizing or modifying the code to fit different scenarios.\n",
    "Language: JavaScript.\n",
    "Problem: Write a function to reverse a string.\n",
    "\n",
    "Additional Notes:\n",
    "- Provide a brief overview of the problem's complexity and any potential edge cases.\n",
    "- Suggest alternative approaches or performance improvements, if applicable.\n",
    "- Include guidance on how users can adapt the code for other similar tasks.\n",
    "\"\"\"\n",
    "\n",
    "resp = o1mini(prompt)\n",
    "display(Markdown(resp.choices[0].message.content))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "id": "eeda85aa-5bd7-4f07-b12f-8fc3a98be77b",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Prompt tokens = 144 | Completion tokens = 2053 | Total tokens = 2197\n"
     ]
    }
   ],
   "source": [
    "print(f\"Prompt tokens = {resp.usage.prompt_tokens} | Completion tokens = {resp.usage.completion_tokens} | Total tokens = {resp.usage.total_tokens}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "aa339444-703b-468d-905f-db2a037f3ffa",
   "metadata": {},
   "source": [
    "### Physic example"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "id": "9b99d9d6-0daf-4c9e-8129-871c3566bd40",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/markdown": [
       "Certainly! Deriving the equations of motion for a double pendulum using Lagrangian mechanics is a classic problem in classical mechanics. Below is a comprehensive step-by-step derivation.\n",
       "\n",
       "## **1. System Description**\n",
       "\n",
       "A **double pendulum** consists of two point masses \\( m_1 \\) and \\( m_2 \\) connected by two massless rods of lengths \\( \\ell_1 \\) and \\( \\ell_2 \\), respectively. The first mass \\( m_1 \\) is attached to a fixed pivot, and the second mass \\( m_2 \\) is attached to \\( m_1 \\). Both masses move in a plane under the influence of gravity.\n",
       "\n",
       "Let:\n",
       "- \\( \\theta_1 \\) be the angle the first rod makes with the vertical.\n",
       "- \\( \\theta_2 \\) be the angle the second rod makes with the vertical.\n",
       "\n",
       "Assumptions:\n",
       "- Rods are massless and rigid.\n",
       "- Motion is frictionless.\n",
       "- The system moves in a two-dimensional plane.\n",
       "\n",
       "## **2. Generalized Coordinates**\n",
       "\n",
       "The generalized coordinates for the system are \\( \\theta_1 \\) and \\( \\theta_2 \\). These angles uniquely define the configuration of the double pendulum at any instant.\n",
       "\n",
       "## **3. Kinetic and Potential Energies**\n",
       "\n",
       "### **a. Positions of the Masses**\n",
       "\n",
       "First, express the Cartesian coordinates of both masses in terms of \\( \\theta_1 \\) and \\( \\theta_2 \\).\n",
       "\n",
       "- **Mass \\( m_1 \\):**\n",
       "  \\[\n",
       "  \\begin{cases}\n",
       "  x_1 = \\ell_1 \\sin \\theta_1 \\\\\n",
       "  y_1 = -\\ell_1 \\cos \\theta_1\n",
       "  \\end{cases}\n",
       "  \\]\n",
       "\n",
       "- **Mass \\( m_2 \\):**\n",
       "  \\[\n",
       "  \\begin{cases}\n",
       "  x_2 = x_1 + \\ell_2 \\sin \\theta_2 = \\ell_1 \\sin \\theta_1 + \\ell_2 \\sin \\theta_2 \\\\\n",
       "  y_2 = y_1 - \\ell_2 \\cos \\theta_2 = -\\ell_1 \\cos \\theta_1 - \\ell_2 \\cos \\theta_2\n",
       "  \\end{cases}\n",
       "  \\]\n",
       "\n",
       "### **b. Velocities of the Masses**\n",
       "\n",
       "Differentiate the positions with respect to time to obtain velocities.\n",
       "\n",
       "- **Mass \\( m_1 \\):**\n",
       "  \\[\n",
       "  \\begin{cases}\n",
       "  \\dot{x}_1 = \\ell_1 \\cos \\theta_1 \\cdot \\dot{\\theta}_1 \\\\\n",
       "  \\dot{y}_1 = \\ell_1 \\sin \\theta_1 \\cdot \\dot{\\theta}_1\n",
       "  \\end{cases}\n",
       "  \\]\n",
       "\n",
       "- **Mass \\( m_2 \\):**\n",
       "  \\[\n",
       "  \\begin{cases}\n",
       "  \\dot{x}_2 = \\dot{x}_1 + \\ell_2 \\cos \\theta_2 \\cdot \\dot{\\theta}_2 \\\\\n",
       "  \\dot{y}_2 = \\dot{y}_1 + \\ell_2 \\sin \\theta_2 \\cdot \\dot{\\theta}_2\n",
       "  \\end{cases}\n",
       "  \\]\n",
       "  \n",
       "  Substituting \\( \\dot{x}_1 \\) and \\( \\dot{y}_1 \\):\n",
       "  \n",
       "  \\[\n",
       "  \\begin{cases}\n",
       "  \\dot{x}_2 = \\ell_1 \\cos \\theta_1 \\cdot \\dot{\\theta}_1 + \\ell_2 \\cos \\theta_2 \\cdot \\dot{\\theta}_2 \\\\\n",
       "  \\dot{y}_2 = \\ell_1 \\sin \\theta_1 \\cdot \\dot{\\theta}_1 + \\ell_2 \\sin \\theta_2 \\cdot \\dot{\\theta}_2\n",
       "  \\end{cases}\n",
       "  \\]\n",
       "\n",
       "### **c. Kinetic Energy \\( T \\)**\n",
       "\n",
       "The total kinetic energy is the sum of the kinetic energies of both masses.\n",
       "\n",
       "\\[\n",
       "T = \\frac{1}{2} m_1 (\\dot{x}_1^2 + \\dot{y}_1^2) + \\frac{1}{2} m_2 (\\dot{x}_2^2 + \\dot{y}_2^2)\n",
       "\\]\n",
       "\n",
       "Substituting the expressions for \\( \\dot{x}_1, \\dot{y}_1, \\dot{x}_2, \\dot{y}_2 \\):\n",
       "\n",
       "\\[\n",
       "\\begin{aligned}\n",
       "T &= \\frac{1}{2} m_1 (\\ell_1^2 \\dot{\\theta}_1^2) \\\\\n",
       "&\\quad + \\frac{1}{2} m_2 \\left[ (\\ell_1 \\cos \\theta_1 \\dot{\\theta}_1 + \\ell_2 \\cos \\theta_2 \\dot{\\theta}_2)^2 + (\\ell_1 \\sin \\theta_1 \\dot{\\theta}_1 + \\ell_2 \\sin \\theta_2 \\dot{\\theta}_2)^2 \\right]\n",
       "\\end{aligned}\n",
       "\\]\n",
       "\n",
       "Simplify the expression inside the brackets for \\( T_{m_2} \\):\n",
       "\n",
       "\\[\n",
       "\\begin{aligned}\n",
       "&(\\ell_1 \\cos \\theta_1 \\dot{\\theta}_1 + \\ell_2 \\cos \\theta_2 \\dot{\\theta}_2)^2 + (\\ell_1 \\sin \\theta_1 \\dot{\\theta}_1 + \\ell_2 \\sin \\theta_2 \\dot{\\theta}_2)^2 \\\\\n",
       "&= \\ell_1^2 \\dot{\\theta}_1^2 (\\cos^2 \\theta_1 + \\sin^2 \\theta_1) + \\ell_2^2 \\dot{\\theta}_2^2 (\\cos^2 \\theta_2 + \\sin^2 \\theta_2) \\\\\n",
       "&\\quad + 2 \\ell_1 \\ell_2 \\dot{\\theta}_1 \\dot{\\theta}_2 (\\cos \\theta_1 \\cos \\theta_2 + \\sin \\theta_1 \\sin \\theta_2) \\\\\n",
       "&= \\ell_1^2 \\dot{\\theta}_1^2 + \\ell_2^2 \\dot{\\theta}_2^2 + 2 \\ell_1 \\ell_2 \\dot{\\theta}_1 \\dot{\\theta}_2 \\cos(\\theta_1 - \\theta_2)\n",
       "\\end{aligned}\n",
       "\\]\n",
       "\n",
       "Thus, the total kinetic energy becomes:\n",
       "\n",
       "\\[\n",
       "T = \\frac{1}{2} m_1 \\ell_1^2 \\dot{\\theta}_1^2 + \\frac{1}{2} m_2 \\left[ \\ell_1^2 \\dot{\\theta}_1^2 + \\ell_2^2 \\dot{\\theta}_2^2 + 2 \\ell_1 \\ell_2 \\dot{\\theta}_1 \\dot{\\theta}_2 \\cos(\\theta_1 - \\theta_2) \\right]\n",
       "\\]\n",
       "\n",
       "### **d. Potential Energy \\( V \\)**\n",
       "\n",
       "The potential energy is due to gravity. Choose the zero potential energy level at the pivot point.\n",
       "\n",
       "\\[\n",
       "V = m_1 g y_1 + m_2 g y_2\n",
       "\\]\n",
       "\n",
       "Substitute \\( y_1 \\) and \\( y_2 \\):\n",
       "\n",
       "\\[\n",
       "V = -m_1 g \\ell_1 \\cos \\theta_1 - m_2 g (\\ell_1 \\cos \\theta_1 + \\ell_2 \\cos \\theta_2)\n",
       "\\]\n",
       "\n",
       "Simplify:\n",
       "\n",
       "\\[\n",
       "V = -(m_1 + m_2) g \\ell_1 \\cos \\theta_1 - m_2 g \\ell_2 \\cos \\theta_2\n",
       "\\]\n",
       "\n",
       "## **4. Lagrangian \\( L \\)**\n",
       "\n",
       "The Lagrangian is given by:\n",
       "\n",
       "\\[\n",
       "L = T - V\n",
       "\\]\n",
       "\n",
       "Substituting \\( T \\) and \\( V \\):\n",
       "\n",
       "\\[\n",
       "\\begin{aligned}\n",
       "L &= \\frac{1}{2} m_1 \\ell_1^2 \\dot{\\theta}_1^2 + \\frac{1}{2} m_2 \\left[ \\ell_1^2 \\dot{\\theta}_1^2 + \\ell_2^2 \\dot{\\theta}_2^2 + 2 \\ell_1 \\ell_2 \\dot{\\theta}_1 \\dot{\\theta}_2 \\cos(\\theta_1 - \\theta_2) \\right] \\\\\n",
       "&\\quad + (m_1 + m_2) g \\ell_1 \\cos \\theta_1 + m_2 g \\ell_2 \\cos \\theta_2\n",
       "\\end{aligned}\n",
       "\\]\n",
       "\n",
       "## **5. Equations of Motion via Lagrange's Equations**\n",
       "\n",
       "Lagrange's equations for each generalized coordinate \\( \\theta_i \\) are:\n",
       "\n",
       "\\[\n",
       "\\frac{d}{dt} \\left( \\frac{\\partial L}{\\partial \\dot{\\theta}_i} \\right) - \\frac{\\partial L}{\\partial \\theta_i} = 0 \\quad \\text{for } i = 1, 2\n",
       "\\]\n",
       "\n",
       "We'll derive separate equations for \\( \\theta_1 \\) and \\( \\theta_2 \\).\n",
       "\n",
       "### **a. Equation for \\( \\theta_1 \\)**\n",
       "\n",
       "**Compute \\( \\frac{\\partial L}{\\partial \\dot{\\theta}_1} \\):**\n",
       "\n",
       "\\[\n",
       "\\frac{\\partial L}{\\partial \\dot{\\theta}_1} = m_1 \\ell_1^2 \\dot{\\theta}_1 + m_2 \\ell_1^2 \\dot{\\theta}_1 + m_2 \\ell_1 \\ell_2 \\dot{\\theta}_2 \\cos(\\theta_1 - \\theta_2)\n",
       "\\]\n",
       "\n",
       "Factor \\( \\dot{\\theta}_1 \\):\n",
       "\n",
       "\\[\n",
       "\\frac{\\partial L}{\\partial \\dot{\\theta}_1} = (m_1 + m_2) \\ell_1^2 \\dot{\\theta}_1 + m_2 \\ell_1 \\ell_2 \\dot{\\theta}_2 \\cos(\\theta_1 - \\theta_2)\n",
       "\\]\n",
       "\n",
       "**Compute \\( \\frac{d}{dt} \\left( \\frac{\\partial L}{\\partial \\dot{\\theta}_1} \\right) \\):**\n",
       "\n",
       "Differentiate with respect to time:\n",
       "\n",
       "\\[\n",
       "\\frac{d}{dt} \\left( \\frac{\\partial L}{\\partial \\dot{\\theta}_1} \\right) = (m_1 + m_2) \\ell_1^2 \\ddot{\\theta}_1 + m_2 \\ell_1 \\ell_2 \\ddot{\\theta}_2 \\cos(\\theta_1 - \\theta_2) - m_2 \\ell_1 \\ell_2 \\dot{\\theta}_2 \\sin(\\theta_1 - \\theta_2) (\\dot{\\theta}_1 - \\dot{\\theta}_2)\n",
       "\\]\n",
       "\n",
       "**Compute \\( \\frac{\\partial L}{\\partial \\theta_1} \\):**\n",
       "\n",
       "\\[\n",
       "\\frac{\\partial L}{\\partial \\theta_1} = -m_2 \\ell_1 \\ell_2 \\dot{\\theta}_1 \\dot{\\theta}_2 \\sin(\\theta_1 - \\theta_2) - (m_1 + m_2) g \\ell_1 \\sin \\theta_1\n",
       "\\]\n",
       "\n",
       "**Apply Lagrange's Equation for \\( \\theta_1 \\):**\n",
       "\n",
       "\\[\n",
       "\\frac{d}{dt} \\left( \\frac{\\partial L}{\\partial \\dot{\\theta}_1} \\right) - \\frac{\\partial L}{\\partial \\theta_1} = 0\n",
       "\\]\n",
       "\n",
       "Substitute the expressions:\n",
       "\n",
       "\\[\n",
       "(m_1 + m_2) \\ell_1^2 \\ddot{\\theta}_1 + m_2 \\ell_1 \\ell_2 \\ddot{\\theta}_2 \\cos(\\theta_1 - \\theta_2) - m_2 \\ell_1 \\ell_2 \\dot{\\theta}_2 \\sin(\\theta_1 - \\theta_2) (\\dot{\\theta}_1 - \\dot{\\theta}_2) + m_2 \\ell_1 \\ell_2 \\dot{\\theta}_1 \\dot{\\theta}_2 \\sin(\\theta_1 - \\theta_2) + (m_1 + m_2) g \\ell_1 \\sin \\theta_1 = 0\n",
       "\\]\n",
       "\n",
       "Simplify the terms involving \\( \\sin(\\theta_1 - \\theta_2) \\):\n",
       "\n",
       "\\[\n",
       "- m_2 \\ell_1 \\ell_2 \\dot{\\theta}_2 \\sin(\\theta_1 - \\theta_2) (\\dot{\\theta}_1 - \\dot{\\theta}_2) + m_2 \\ell_1 \\ell_2 \\dot{\\theta}_1 \\dot{\\theta}_2 \\sin(\\theta_1 - \\theta_2) = m_2 \\ell_1 \\ell_2 \\dot{\\theta}_2^2 \\sin(\\theta_1 - \\theta_2)\n",
       "\\]\n",
       "\n",
       "Thus, the equation becomes:\n",
       "\n",
       "\\[\n",
       "(m_1 + m_2) \\ell_1^2 \\ddot{\\theta}_1 + m_2 \\ell_1 \\ell_2 \\ddot{\\theta}_2 \\cos(\\theta_1 - \\theta_2) + m_2 \\ell_1 \\ell_2 \\dot{\\theta}_2^2 \\sin(\\theta_1 - \\theta_2) + (m_1 + m_2) g \\ell_1 \\sin \\theta_1 = 0\n",
       "\\]\n",
       "\n",
       "**Rearrange:**\n",
       "\n",
       "\\[\n",
       "(m_1 + m_2) \\ell_1^2 \\ddot{\\theta}_1 + m_2 \\ell_1 \\ell_2 \\ddot{\\theta}_2 \\cos(\\theta_1 - \\theta_2) + m_2 \\ell_1 \\ell_2 \\dot{\\theta}_2^2 \\sin(\\theta_1 - \\theta_2) + (m_1 + m_2) g \\ell_1 \\sin \\theta_1 = 0\n",
       "\\]\n",
       "  \n",
       "This is **Equation (1)**.\n",
       "\n",
       "### **b. Equation for \\( \\theta_2 \\)**\n",
       "\n",
       "**Compute \\( \\frac{\\partial L}{\\partial \\dot{\\theta}_2} \\):**\n",
       "\n",
       "\\[\n",
       "\\frac{\\partial L}{\\partial \\dot{\\theta}_2} = m_2 \\ell_2^2 \\dot{\\theta}_2 + m_2 \\ell_1 \\ell_2 \\dot{\\theta}_1 \\cos(\\theta_1 - \\theta_2)\n",
       "\\]\n",
       "\n",
       "**Compute \\( \\frac{d}{dt} \\left( \\frac{\\partial L}{\\partial \\dot{\\theta}_2} \\right) \\):**\n",
       "\n",
       "Differentiate with respect to time:\n",
       "\n",
       "\\[\n",
       "\\frac{d}{dt} \\left( \\frac{\\partial L}{\\partial \\dot{\\theta}_2} \\right) = m_2 \\ell_2^2 \\ddot{\\theta}_2 + m_2 \\ell_1 \\ell_2 \\ddot{\\theta}_1 \\cos(\\theta_1 - \\theta_2) - m_2 \\ell_1 \\ell_2 \\dot{\\theta}_1 \\sin(\\theta_1 - \\theta_2) (\\dot{\\theta}_1 - \\dot{\\theta}_2)\n",
       "\\]\n",
       "\n",
       "**Compute \\( \\frac{\\partial L}{\\partial \\theta_2} \\):**\n",
       "\n",
       "\\[\n",
       "\\frac{\\partial L}{\\partial \\theta_2} = m_2 \\ell_1 \\ell_2 \\dot{\\theta}_1 \\dot{\\theta}_2 \\sin(\\theta_1 - \\theta_2) - m_2 g \\ell_2 \\sin \\theta_2\n",
       "\\]\n",
       "\n",
       "**Apply Lagrange's Equation for \\( \\theta_2 \\):**\n",
       "\n",
       "\\[\n",
       "\\frac{d}{dt} \\left( \\frac{\\partial L}{\\partial \\dot{\\theta}_2} \\right) - \\frac{\\partial L}{\\partial \\theta_2} = 0\n",
       "\\]\n",
       "\n",
       "Substitute the expressions:\n",
       "\n",
       "\\[\n",
       "m_2 \\ell_2^2 \\ddot{\\theta}_2 + m_2 \\ell_1 \\ell_2 \\ddot{\\theta}_1 \\cos(\\theta_1 - \\theta_2) - m_2 \\ell_1 \\ell_2 \\dot{\\theta}_1 \\sin(\\theta_1 - \\theta_2) (\\dot{\\theta}_1 - \\dot{\\theta}_2) - m_2 \\ell_1 \\ell_2 \\dot{\\theta}_1 \\dot{\\theta}_2 \\sin(\\theta_1 - \\theta_2) + m_2 g \\ell_2 \\sin \\theta_2 = 0\n",
       "\\]\n",
       "\n",
       "Simplify the terms involving \\( \\sin(\\theta_1 - \\theta_2) \\):\n",
       "\n",
       "\\[\n",
       "- m_2 \\ell_1 \\ell_2 \\dot{\\theta}_1 \\sin(\\theta_1 - \\theta_2) (\\dot{\\theta}_1 - \\dot{\\theta}_2) - m_2 \\ell_1 \\ell_2 \\dot{\\theta}_1 \\dot{\\theta}_2 \\sin(\\theta_1 - \\theta_2) = - m_2 \\ell_1 \\ell_2 \\dot{\\theta}_1^2 \\sin(\\theta_1 - \\theta_2)\n",
       "\\]\n",
       "\n",
       "Thus, the equation becomes:\n",
       "\n",
       "\\[\n",
       "m_2 \\ell_2^2 \\ddot{\\theta}_2 + m_2 \\ell_1 \\ell_2 \\ddot{\\theta}_1 \\cos(\\theta_1 - \\theta_2) - m_2 \\ell_1 \\ell_2 \\dot{\\theta}_1^2 \\sin(\\theta_1 - \\theta_2) + m_2 g \\ell_2 \\sin \\theta_2 = 0\n",
       "\\]\n",
       "\n",
       "**Rearrange:**\n",
       "\n",
       "\\[\n",
       "m_2 \\ell_2^2 \\ddot{\\theta}_2 + m_2 \\ell_1 \\ell_2 \\ddot{\\theta}_1 \\cos(\\theta_1 - \\theta_2) - m_2 \\ell_1 \\ell_2 \\dot{\\theta}_1^2 \\sin(\\theta_1 - \\theta_2) + m_2 g \\ell_2 \\sin \\theta_2 = 0\n",
       "\\]\n",
       "\n",
       "This is **Equation (2)**.\n",
       "\n",
       "## **6. Simplifying the Equations**\n",
       "\n",
       "To make the equations more manageable, divide both equations by \\( \\ell_1 \\) or \\( \\ell_2 \\) and eliminate common factors.\n",
       "\n",
       "Let's assume both rods and masses are the same for simplicity, i.e., \\( m_1 = m_2 = m \\) and \\( \\ell_1 = \\ell_2 = \\ell \\). This assumption is not necessary but simplifies the algebra.\n",
       "\n",
       "**Note:** The general solution involves solving these coupled, nonlinear differential equations, which typically requires numerical methods. However, under the assumption \\( m_1 = m_2 = m \\) and \\( \\ell_1 = \\ell_2 = \\ell \\), the equations can be further simplified.\n",
       "\n",
       "**Equation (1):**\n",
       "\n",
       "\\[\n",
       "(m + m) \\ell^2 \\ddot{\\theta}_1 + m \\ell^2 \\ddot{\\theta}_2 \\cos(\\theta_1 - \\theta_2) + m \\ell^2 \\dot{\\theta}_2^2 \\sin(\\theta_1 - \\theta_2) + (m + m) g \\ell \\sin \\theta_1 = 0\n",
       "\\]\n",
       "\n",
       "Simplify:\n",
       "\n",
       "\\[\n",
       "2 m \\ell^2 \\ddot{\\theta}_1 + m \\ell^2 \\ddot{\\theta}_2 \\cos(\\theta_1 - \\theta_2) + m \\ell^2 \\dot{\\theta}_2^2 \\sin(\\theta_1 - \\theta_2) + 2 m g \\ell \\sin \\theta_1 = 0\n",
       "\\]\n",
       "\n",
       "Divide by \\( m \\):\n",
       "\n",
       "\\[\n",
       "2 \\ell^2 \\ddot{\\theta}_1 + \\ell^2 \\ddot{\\theta}_2 \\cos(\\theta_1 - \\theta_2) + \\ell^2 \\dot{\\theta}_2^2 \\sin(\\theta_1 - \\theta_2) + 2 g \\ell \\sin \\theta_1 = 0\n",
       "\\]\n",
       "\n",
       "**Equation (2):**\n",
       "\n",
       "\\[\n",
       "m \\ell^2 \\ddot{\\theta}_2 + m \\ell^2 \\ddot{\\theta}_1 \\cos(\\theta_1 - \\theta_2) - m \\ell^2 \\dot{\\theta}_1^2 \\sin(\\theta_1 - \\theta_2) + m g \\ell \\sin \\theta_2 = 0\n",
       "\\]\n",
       "\n",
       "Divide by \\( m \\):\n",
       "\n",
       "\\[\n",
       "\\ell^2 \\ddot{\\theta}_2 + \\ell^2 \\ddot{\\theta}_1 \\cos(\\theta_1 - \\theta_2) - \\ell^2 \\dot{\\theta}_1^2 \\sin(\\theta_1 - \\theta_2) + g \\ell \\sin \\theta_2 = 0\n",
       "\\]\n",
       "\n",
       "Now, we have two coupled equations:\n",
       "\n",
       "\\[\n",
       "\\begin{cases}\n",
       "2 \\ell \\ddot{\\theta}_1 + \\ell \\ddot{\\theta}_2 \\cos(\\theta_1 - \\theta_2) + \\ell \\dot{\\theta}_2^2 \\sin(\\theta_1 - \\theta_2) + 2 g \\sin \\theta_1 = 0 \\quad \\text{(1)} \\\\\n",
       "\\ell \\ddot{\\theta}_2 + \\ell \\ddot{\\theta}_1 \\cos(\\theta_1 - \\theta_2) - \\ell \\dot{\\theta}_1^2 \\sin(\\theta_1 - \\theta_2) + g \\sin \\theta_2 = 0 \\quad \\text{(2)}\n",
       "\\end{cases}\n",
       "\\]\n",
       "\n",
       "For general masses and lengths, the equations remain as initially derived in **Equation (1)** and **Equation (2)}**. Solving these equations typically requires numerical integration techniques due to their nonlinear nature.\n",
       "\n",
       "## **7. Final Form of Equations of Motion**\n",
       "\n",
       "Returning to the general case without simplifying assumptions, the equations of motion for the double pendulum are:\n",
       "\n",
       "\\[\n",
       "\\begin{aligned}\n",
       "& (m_1 + m_2) \\ell_1^2 \\ddot{\\theta}_1 + m_2 \\ell_1 \\ell_2 \\ddot{\\theta}_2 \\cos(\\theta_1 - \\theta_2) + m_2 \\ell_1 \\ell_2 \\dot{\\theta}_2^2 \\sin(\\theta_1 - \\theta_2) + (m_1 + m_2) g \\ell_1 \\sin \\theta_1 = 0 \\quad \\text{(1)} \\\\\n",
       "& m_2 \\ell_2^2 \\ddot{\\theta}_2 + m_2 \\ell_1 \\ell_2 \\ddot{\\theta}_1 \\cos(\\theta_1 - \\theta_2) - m_2 \\ell_1 \\ell_2 \\dot{\\theta}_1^2 \\sin(\\theta_1 - \\theta_2) + m_2 g \\ell_2 \\sin \\theta_2 = 0 \\quad \\text{(2)}\n",
       "\\end{aligned}\n",
       "\\]\n",
       "\n",
       "These coupled, nonlinear second-order differential equations describe the dynamics of the double pendulum system.\n",
       "\n",
       "## **8. Expressing Equations in Matrix Form (Optional)**\n",
       "\n",
       "For further analysis or numerical simulation, it's often useful to express the equations in matrix form or solve for the accelerations \\( \\ddot{\\theta}_1 \\) and \\( \\ddot{\\theta}_2 \\). However, the algebra becomes quite involved and typically requires symbolic computation tools.\n",
       "\n",
       "In summary, using Lagrangian mechanics, we've derived the equations of motion for a double pendulum system, capturing the intricate interplay between the two masses as they swing under the influence of gravity."
      ],
      "text/plain": [
       "<IPython.core.display.Markdown object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "prompt = \"Using the principles of Lagrangian mechanics, derive the equations of motion for a double pendulum system.\"\n",
    "\n",
    "resp = o1mini(prompt)\n",
    "display(Markdown(resp.choices[0].message.content))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "id": "371d7db4-4cf5-4e55-8fa9-74160d3e5a66",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Prompt tokens = 28 | Completion tokens = 5398 | Total tokens = 5426\n"
     ]
    }
   ],
   "source": [
    "print(f\"Prompt tokens = {resp.usage.prompt_tokens} | Completion tokens = {resp.usage.completion_tokens} | Total tokens = {resp.usage.total_tokens}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fa6023f0-0d7c-498c-bd23-37fcd7a776d1",
   "metadata": {},
   "source": [
    "### Physic example"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "id": "16f08c59-9e47-4bc8-af58-aea6de6f0639",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/markdown": [
       "Achieving quantum supremacy in cryptography—the point at which quantum computers can solve cryptographic problems that are infeasible for classical computers—requires a deep understanding of the essential components of quantum computers, their current technological limitations, and the trajectory of ongoing advancements. Below is a detailed exploration addressing each of your queries:\n",
       "\n",
       "---\n",
       "\n",
       "### 1. **Essential Components of a Quantum Computer**\n",
       "\n",
       "A quantum computer comprises several critical components that work together to perform quantum computations. The essential components include:\n",
       "\n",
       "1. **Qubits (Quantum Bits):**\n",
       "   - **Description:** The fundamental units of quantum information, analogous to classical bits but capable of representing both 0 and 1 simultaneously due to superposition.\n",
       "   \n",
       "2. **Quantum Gates and Circuits:**\n",
       "   - **Description:** Operations that manipulate qubits through quantum gates, enabling quantum algorithms to be executed within quantum circuits.\n",
       "\n",
       "3. **Quantum Control Systems:**\n",
       "   - **Description:** Hardware and software that precisely control the initialization, manipulation, and measurement of qubits.\n",
       "\n",
       "4. **Quantum Interconnects:**\n",
       "   - **Description:** Mechanisms for coupling qubits together to enable multi-qubit operations and entanglement.\n",
       "\n",
       "5. **Quantum Error Correction (QEC) Systems:**\n",
       "   - **Description:** Techniques and hardware necessary to detect and correct errors due to decoherence and other quantum noise.\n",
       "\n",
       "6. **Cryogenic Systems:**\n",
       "   - **Description:** Cooling mechanisms that maintain qubits at near-absolute-zero temperatures to preserve quantum states.\n",
       "\n",
       "7. **Readout Mechanisms:**\n",
       "   - **Description:** Systems that measure the states of qubits at the end of computation to extract classical information.\n",
       "\n",
       "8. **Software and Classical Computing Integration:**\n",
       "   - **Description:** Interface software that integrates classical computing resources with quantum processors for tasks like error correction, algorithm implementation, and result interpretation.\n",
       "\n",
       "---\n",
       "\n",
       "### 2. **Function and Current Technological Limitations of Each Component**\n",
       "\n",
       "#### **1. Qubits**\n",
       "\n",
       "- **Function:** Serve as the core units of quantum information, enabling operations that exploit quantum phenomena like superposition and entanglement.\n",
       "  \n",
       "- **Technological Limitations:**\n",
       "  - **Coherence Time:** Qubits can maintain their quantum states only for short durations (typically microseconds to milliseconds), limiting the complexity of computations.\n",
       "  - **Scalability:** Building systems with a large number of qubits while maintaining control and coherence is challenging.\n",
       "  - **Types of Qubits:** Various implementations (e.g., superconducting, trapped ions, topological) have unique challenges; for example, superconducting qubits require extremely low temperatures.\n",
       "\n",
       "#### **2. Quantum Gates and Circuits**\n",
       "\n",
       "- **Function:** Perform logical operations on qubits, enabling the execution of quantum algorithms.\n",
       "\n",
       "- **Technological Limitations:**\n",
       "  - **Gate Fidelity:** Imperfections in gate operations introduce errors; achieving high fidelity (>99.9%) is essential for reliable computations.\n",
       "  - **Gate Speed:** Faster gates can mitigate decoherence but require precise control, which is technologically demanding.\n",
       "\n",
       "#### **3. Quantum Control Systems**\n",
       "\n",
       "- **Function:** Precisely manipulate qubits through laser pulses, microwave signals, or other means to perform gate operations.\n",
       "\n",
       "- **Technological Limitations:**\n",
       "  - **Precision and Stability:** Maintaining precise control over qubits over time is difficult due to environmental noise and signal degradation.\n",
       "  - **Scalability of Control Electronics:** Managing control for thousands or millions of qubits requires significant advances in control hardware and software.\n",
       "\n",
       "#### **4. Quantum Interconnects**\n",
       "\n",
       "- **Function:** Facilitate interactions between qubits to create entanglement, a resource for quantum computation.\n",
       "\n",
       "- **Technological Limitations:**\n",
       "  - **Cross-Talk and Noise:** Ensuring qubits interact correctly without unwanted interference is challenging.\n",
       "  - **Physical Connectivity:** Designing architectures that allow flexible interconnects without increasing error rates is an ongoing area of research.\n",
       "\n",
       "#### **5. Quantum Error Correction (QEC) Systems**\n",
       "\n",
       "- **Function:** Detect and correct errors arising from decoherence and operational faults, ensuring the integrity of quantum computations.\n",
       "\n",
       "- **Technological Limitations:**\n",
       "  - **Overhead:** Implementing QEC requires a large number of physical qubits to encode a single logical qubit, significantly increasing the qubit count needed.\n",
       "  - **Real-Time Processing:** Efficiently processing and correcting errors in real-time demands advanced classical-quantum integration and fast feedback systems.\n",
       "\n",
       "#### **6. Cryogenic Systems**\n",
       "\n",
       "- **Function:** Maintain qubits at extremely low temperatures to minimize thermal noise and decoherence.\n",
       "\n",
       "- **Technological Limitations:**\n",
       "  - **Cooling Power and Efficiency:** Scaling cryogenic systems to accommodate larger quantum processors without excessive energy consumption is challenging.\n",
       "  - **Integration with Other Components:** Ensuring that all quantum components function reliably within cryogenic environments requires specialized materials and engineering solutions.\n",
       "\n",
       "#### **7. Readout Mechanisms**\n",
       "\n",
       "- **Function:** Measure the final states of qubits to obtain the results of quantum computations.\n",
       "\n",
       "- **Technological Limitations:**\n",
       "  - **Measurement Speed and Accuracy:** Achieving fast, high-fidelity measurements without disturbing adjacent qubits is difficult.\n",
       "  - **Scalability:** Developing readout systems that can handle a large number of qubits simultaneously is an ongoing challenge.\n",
       "\n",
       "#### **8. Software and Classical Computing Integration**\n",
       "\n",
       "- **Function:** Facilitate the execution of quantum algorithms, manage qubit control, and interpret measurement results.\n",
       "\n",
       "- **Technological Limitations:**\n",
       "  - **Optimization Algorithms:** Developing efficient algorithms that can translate classical problems into quantum instructions remains complex.\n",
       "  - **Hybrid Computing Models:** Seamlessly integrating classical and quantum resources requires sophisticated software architectures and communication protocols.\n",
       "\n",
       "---\n",
       "\n",
       "### 3. **Estimating the Timeline for Achieving Quantum Supremacy in Cryptography**\n",
       "\n",
       "**Quantum Supremacy in Cryptography** refers to quantum computers performing cryptographically relevant tasks (like factoring large numbers or breaking elliptic curve cryptography) beyond the capabilities of classical computers. Estimating the timeline involves considering advancements in each component and the interplay between them.\n",
       "\n",
       "#### **Current State (As of 2023)**\n",
       "\n",
       "- **Qubit Numbers:** State-of-the-art quantum processors have achieved over 100 qubits, but error rates and coherence times limit practical applications.\n",
       "- **Error Correction:** Implementing effective QEC is still in early stages, requiring significant qubit overhead.\n",
       "- **Algorithm Development:** Quantum algorithms for cryptography exist (e.g., Shor’s algorithm) but are not yet practical on noisy intermediate-scale quantum (NISQ) devices.\n",
       "\n",
       "#### **Factors Influencing the Timeline**\n",
       "\n",
       "1. **Scalability of Qubits:**\n",
       "   - Achieving thousands to millions of qubits with low error rates is essential. Progress in this area is steady but faces significant engineering hurdles.\n",
       "\n",
       "2. **Advancements in QEC:**\n",
       "   - Developing efficient QEC protocols that reduce qubit overhead will accelerate progress. Recent research shows promise, but practical implementation is years away.\n",
       "\n",
       "3. **Improvement in Gate Fidelities and Coherence Times:**\n",
       "   - Continued enhancements in qubit control and materials science are needed to reduce error rates and extend coherence times.\n",
       "\n",
       "4. **Integration of Components:**\n",
       "   - Building scalable, integrated systems that combine all quantum components seamlessly is crucial. Progress is being made, particularly in superconducting and trapped ion technologies.\n",
       "\n",
       "5. **Software and Algorithm Optimization:**\n",
       "   - Optimizing quantum algorithms to be more resource-efficient will lower the barriers to achieving quantum supremacy.\n",
       "\n",
       "#### **Estimated Timeline**\n",
       "\n",
       "Considering the current pace of technological advancements and the challenges outlined:\n",
       "\n",
       "- **Near-Term (5-10 Years):**\n",
       "  - **Milestones:** \n",
       "    - Achieve quantum processors with several thousand qubits.\n",
       "    - Demonstrate fault-tolerant operations on logical qubits.\n",
       "    - Develop scalable QEC implementations.\n",
       "  - **Implications:** Initial demonstrations of quantum advantages in specific, limited cryptographic tasks, but not yet breaking widely used cryptographic schemes.\n",
       "\n",
       "- **Medium-Term (10-20 Years):**\n",
       "  - **Milestones:**\n",
       "    - Reach millions of physical qubits with effective QEC.\n",
       "    - Perform large-scale quantum computations relevant to cryptography, such as breaking RSA-2048 or ECC.\n",
       "  - **Implications:** Quantum supremacy in cryptography is likely achieved, rendering current public-key cryptographic systems vulnerable.\n",
       "\n",
       "- **Long-Term (20+ Years):**\n",
       "  - **Milestones:**\n",
       "    - Further scaling and optimization of quantum systems for broader applications beyond cryptography.\n",
       "    - Development and adoption of quantum-resistant cryptographic algorithms.\n",
       "  - **Implications:** Transition to quantum-secure cryptographic infrastructures becomes imperative.\n",
       "\n",
       "**Caveats:**\n",
       "\n",
       "- **Technological Breakthroughs:** Unexpected advances could accelerate the timeline, while unforeseen challenges may cause delays.\n",
       "- **Resource Allocation:** Significant investment in research and development by governments, academia, and industry will impact progress.\n",
       "- **Quantum-Classical Integration:** Progress in hybrid systems and efficient classical-quantum interfaces is essential for practical applications.\n",
       "\n",
       "---\n",
       "\n",
       "### **Conclusion**\n",
       "\n",
       "Achieving quantum supremacy in cryptography is contingent upon substantial progress across multiple quantum computer components. While advancements are ongoing and promising, the convergence of scalable qubit architectures, effective error correction, high-fidelity operations, and integrated systems suggests that quantum supremacy in cryptography could realistically be realized within the next 10 to 20 years. This projection underscores the urgency for transitioning to quantum-resistant cryptographic methods to safeguard against future quantum-enabled security threats."
      ],
      "text/plain": [
       "<IPython.core.display.Markdown object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "prompt = \"\"\"\n",
    "1. Identify the essential components of a quantum computer.\n",
    "2. Describe the function and current technological limitations of each component.\n",
    "3. Integrate this information to estimate the timeline for achieving quantum supremacy in cryptography.\n",
    "\"\"\"\n",
    "\n",
    "resp = o1mini(prompt)\n",
    "display(Markdown(resp.choices[0].message.content))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "id": "90d6f899-f7a3-4c2d-9b73-df7fad0e921e",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Prompt tokens = 55 | Completion tokens = 1998 | Total tokens = 2053\n"
     ]
    }
   ],
   "source": [
    "print(f\"Prompt tokens = {resp.usage.prompt_tokens} | Completion tokens = {resp.usage.completion_tokens} | Total tokens = {resp.usage.total_tokens}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8b5d1be4-6bc3-4237-8478-82c3e2ded844",
   "metadata": {},
   "source": [
    "### Optimization example"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "id": "1f9c59bb-9848-482b-96c8-f9c44dcdfe04",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/markdown": [
       "Designing a sustainable urban transportation system for a city of 5 million residents requires a comprehensive and strategic approach that addresses environmental, economic, and social objectives. Below is a detailed proposal that aligns with the specified constraints: reducing carbon emissions by 50% within 10 years, limiting budget increases to 20%, and enhancing accessibility for disabled residents by 30%.\n",
       "\n",
       "---\n",
       "\n",
       "## **1. Executive Summary**\n",
       "\n",
       "This proposal outlines a sustainable urban transportation system aimed at transforming a city of 5 million inhabitants into a low-carbon, efficient, and inclusive metropolis. By integrating advanced public transit, promoting active transportation, leveraging technology, and implementing supportive policies, the system seeks to halve carbon emissions over the next decade, stay within a 20% budget increase, and significantly improve accessibility for disabled citizens.\n",
       "\n",
       "---\n",
       "\n",
       "## **2. Goals and Objectives**\n",
       "\n",
       "- **Carbon Emissions Reduction:** Achieve a 50% reduction in transportation-related carbon emissions within 10 years.\n",
       "- **Budget Management:** Implement the system without exceeding the current transportation budget by more than 20%.\n",
       "- **Accessibility Enhancement:** Improve accessibility for disabled residents by 30%, ensuring equitable mobility for all.\n",
       "\n",
       "---\n",
       "\n",
       "## **3. Proposed Transportation System Components**\n",
       "\n",
       "### **3.1. Public Transit Enhancements**\n",
       "\n",
       "**a. Electrification of Bus Fleet**\n",
       "- **Action:** Transition 80% of the existing bus fleet to electric buses within 5 years.\n",
       "- **Benefits:** Significant reduction in emissions, lower operating costs due to electric power, quieter operation enhancing urban livability.\n",
       "- **Budget Consideration:** Initial investment offset by subsidies, grants, and long-term savings on fuel and maintenance.\n",
       "\n",
       "**b. Expansion of Light Rail and Metro Services**\n",
       "- **Action:** Develop new light rail lines and extend existing metro services to underserved areas.\n",
       "- **Benefits:** Increased capacity, faster and more reliable service, reduced reliance on personal vehicles.\n",
       "- **Accessibility:** Modern trains and stations equipped with elevators, ramps, tactile paving, and audio-visual information systems.\n",
       "\n",
       "**c. Integrated Transit Hubs**\n",
       "- **Action:** Create multimodal transit hubs that seamlessly connect buses, trains, cycling, and pedestrian pathways.\n",
       "- **Benefits:** Enhanced connectivity, reduced transfer times, improved user experience.\n",
       "\n",
       "### **3.2. Active Transportation Infrastructure**\n",
       "\n",
       "**a. Cycling Networks**\n",
       "- **Action:** Develop extensive, safe, and segregated cycling lanes throughout the city.\n",
       "- **Benefits:** Encourages cycling, reduces traffic congestion, lowers emissions.\n",
       "- **Accessibility:** Incorporate adaptive cycling solutions for disabled individuals, such as bike-sharing programs with adaptive bikes.\n",
       "\n",
       "**b. Pedestrian-Friendly Streets**\n",
       "- **Action:** Expand sidewalks, implement pedestrian-only zones, and improve crosswalk safety.\n",
       "- **Benefits:** Promotes walking, enhances public health, and increases social interactions.\n",
       "\n",
       "### **3.3. Electric and Shared Mobility**\n",
       "\n",
       "**a. Electric Vehicle (EV) Integration**\n",
       "- **Action:** Install widespread EV charging infrastructure and incentivize the adoption of electric cars.\n",
       "- **Benefits:** Reduces emissions from private vehicles, supports transition to clean energy.\n",
       "- **Budget Consideration:** Leverage public-private partnerships and government incentives to share infrastructure costs.\n",
       "\n",
       "**b. Shared Mobility Services**\n",
       "- **Action:** Promote car-sharing and ride-sharing services utilizing electric or hybrid vehicles.\n",
       "- **Benefits:** Decreases the number of vehicles on the road, optimizes vehicle usage, reduces emissions.\n",
       "\n",
       "### **3.4. Technology Integration**\n",
       "\n",
       "**a. Intelligent Transportation Systems (ITS)**\n",
       "- **Action:** Implement smart traffic management, real-time tracking, and mobile applications for transit users.\n",
       "- **Benefits:** Enhances efficiency, reduces congestion, improves user experience.\n",
       "\n",
       "**b. Mobility as a Service (MaaS)**\n",
       "- **Action:** Develop a unified platform offering integrated transportation options, ticketing, and payment systems.\n",
       "- **Benefits:** Simplifies travel planning, encourages multimodal transportation usage.\n",
       "\n",
       "---\n",
       "\n",
       "## **4. Carbon Emission Reduction Strategies**\n",
       "\n",
       "- **Electrification:** Shift to electric public transit and support electric personal and shared mobility.\n",
       "- **Renewable Energy:** Power transit systems with renewable energy sources, such as solar or wind.\n",
       "- **Mode Shift:** Encourage a shift from high-emission private vehicles to public transit, cycling, and walking.\n",
       "- **Efficiency Improvements:** Optimize routes, increase service frequency to reduce wait times and reliance on cars.\n",
       "\n",
       "---\n",
       "\n",
       "## **5. Budget Management**\n",
       "\n",
       "To ensure the transportation budget does not exceed current levels by more than 20%, the following strategies will be employed:\n",
       "\n",
       "- **Prioritization:** Focus on high-impact, cost-effective projects first, such as bus electrification and cycling infrastructure.\n",
       "- **Phased Implementation:** Spread out capital expenditures over the 10-year period to manage cash flow.\n",
       "- **Public-Private Partnerships (PPPs):** Collaborate with private entities to share costs of infrastructure projects like EV charging stations and transit hubs.\n",
       "- **Grants and Subsidies:** Utilize federal and state grants for sustainable transportation projects to supplement municipal funding.\n",
       "- **Cost Savings:** Offset increased spending through fuel savings from electric buses, reduced maintenance costs, and decreased congestion-related economic losses.\n",
       "\n",
       "---\n",
       "\n",
       "## **6. Accessibility Enhancements for Disabled Residents**\n",
       "\n",
       "### **6.1. Infrastructure Improvements**\n",
       "\n",
       "- **Accessible Stations:** Ensure all transit stations have elevators, ramps, tactile paving, and clear signage.\n",
       "- **Low-Floor Vehicles:** Deploy buses and trains with low floors and priority seating for easy boarding.\n",
       "- **Audio-Visual Aids:** Provide real-time announcements, visual displays, and accessible ticketing options.\n",
       "\n",
       "### **6.2. Service Enhancements**\n",
       "\n",
       "- **On-Demand Services:** Introduce specialized on-demand transit services for individuals with mobility impairments.\n",
       "- **Training Programs:** Train transit staff on assisting disabled passengers and ensuring respectful service.\n",
       "\n",
       "### **6.3. Technology Solutions**\n",
       "\n",
       "- **Accessible Apps:** Develop mobile applications with features catering to disabled users, such as route planning with accessibility filters.\n",
       "- **Real-Time Information:** Provide real-time updates on accessible services and any disruptions affecting accessibility.\n",
       "\n",
       "### **6.4. Policy and Incentives**\n",
       "\n",
       "- **Inclusive Planning:** Involve disabled communities in transportation planning to address specific needs.\n",
       "- **Incentives for Accessibility Upgrades:** Offer subsidies or incentives to transit operators to implement and maintain accessibility features.\n",
       "\n",
       "---\n",
       "\n",
       "## **7. Implementation Plan**\n",
       "\n",
       "### **7.1. Phase 1 (Year 1-3): Foundation Building**\n",
       "\n",
       "- **Electrify Bus Fleet:** Begin procurement of electric buses.\n",
       "- **Develop Cycling and Pedestrian Infrastructure:** Start building essential bike lanes and pedestrian paths.\n",
       "- **Install EV Charging Infrastructure:** Roll out charging stations in strategic locations.\n",
       "- **Enhance Accessibility Features:** Upgrade existing transit stations and vehicles with accessibility improvements.\n",
       "\n",
       "### **7.2. Phase 2 (Year 4-6): Expansion and Integration**\n",
       "\n",
       "- **Expand Light Rail and Metro Services:** Begin construction of new lines and extensions.\n",
       "- **Implement Intelligent Transportation Systems:** Deploy ITS technologies across the network.\n",
       "- **Launch Mobility as a Service Platform:** Introduce integrated mobility applications for users.\n",
       "\n",
       "### **7.3. Phase 3 (Year 7-10): Optimization and Sustainability**\n",
       "\n",
       "- **Optimize Public Transit Operations:** Use data from ITS to streamline services and improve efficiency.\n",
       "- **Promote Shared Mobility Services:** Encourage the adoption of car-sharing and ride-sharing platforms.\n",
       "- **Evaluate and Scale Successful Initiatives:** Assess the effectiveness of implemented projects and scale up successful ones to reach emission and accessibility targets.\n",
       "\n",
       "---\n",
       "\n",
       "## **8. Monitoring and Evaluation**\n",
       "\n",
       "- **Establish Key Performance Indicators (KPIs):** Track metrics related to carbon emissions, budget adherence, and accessibility improvements.\n",
       "- **Regular Reporting:** Provide annual reports to stakeholders on progress towards goals.\n",
       "- **Adaptive Management:** Adjust strategies based on performance data, feedback from users, and emerging technologies.\n",
       "- **Community Engagement:** Continuously involve residents, especially disabled communities, in feedback loops to ensure the system meets their needs.\n",
       "\n",
       "---\n",
       "\n",
       "## **9. Conclusion**\n",
       "\n",
       "The proposed sustainable urban transportation system offers a balanced approach to drastically reduce carbon emissions, manage fiscal responsibility, and enhance accessibility for all residents. Through strategic investments in electrification, public transit expansion, active transportation infrastructure, and inclusive practices, the city can achieve its environmental and social goals, fostering a resilient and equitable urban environment for the future."
      ],
      "text/plain": [
       "<IPython.core.display.Markdown object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "prompt = \"\"\"\n",
    "Design a sustainable urban transportation system for a city of 5 million people.\n",
    "Constraints are:\n",
    "- Must reduce carbon emissions by 50% within 10 years.\n",
    "- Cannot exceed current transportation budget by more than 20%.\n",
    "- Must improve accessibility for disabled residents by 30%.\n",
    "\"\"\"\n",
    "\n",
    "resp = o1mini(prompt)\n",
    "display(Markdown(resp.choices[0].message.content))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "id": "692ce951-7b54-4229-8629-a031b87b4c8b",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Prompt tokens = 67 | Completion tokens = 1944 | Total tokens = 2011\n"
     ]
    }
   ],
   "source": [
    "print(f\"Prompt tokens = {resp.usage.prompt_tokens} | Completion tokens = {resp.usage.completion_tokens} | Total tokens = {resp.usage.total_tokens}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a25e759d-47c3-46d2-9fa7-11b3b72116e8",
   "metadata": {},
   "source": [
    "### Physic example"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "id": "7b17f72c-0b37-467e-ba2a-f126670da015",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/markdown": [
       "### Relationship Between the Riemann Hypothesis and the Distribution of Prime Numbers\n",
       "\n",
       "The **Riemann Hypothesis (RH)** is one of the most profound and long-standing conjectures in mathematics, particularly within the field of number theory. Proposed by Bernhard Riemann in 1859, the hypothesis concerns the **non-trivial zeros** of the **Riemann zeta function**, defined for complex numbers \\( s = \\sigma + it \\) (where \\( \\sigma \\) and \\( t \\) are real numbers) by the analytic continuation of:\n",
       "\n",
       "\\[\n",
       "\\zeta(s) = \\sum_{n=1}^{\\infty} \\frac{1}{n^s}\n",
       "\\]\n",
       "\n",
       "**Riemann Hypothesis Statement:**\n",
       "All non-trivial zeros of the Riemann zeta function \\( \\zeta(s) \\) have a real part equal to \\( \\frac{1}{2} \\). In other words, if \\( \\zeta(s) = 0 \\) and \\( 0 < \\sigma < 1 \\), then \\( \\sigma = \\frac{1}{2} \\).\n",
       "\n",
       "**Connection to Prime Numbers:**\n",
       "\n",
       "The Riemann zeta function is intimately connected to the distribution of prime numbers through its Euler product representation:\n",
       "\n",
       "\\[\n",
       "\\zeta(s) = \\prod_{p \\text{ prime}} \\frac{1}{1 - p^{-s}} \\quad \\text{for } \\sigma > 1\n",
       "\\]\n",
       "\n",
       "This product formula establishes a direct link between \\( \\zeta(s) \\) and prime numbers \\( p \\). The distribution of the zeros of \\( \\zeta(s) \\) influences the distribution of primes via several key areas:\n",
       "\n",
       "1. **Prime Number Theorem (PNT):** The PNT states that the number of primes less than a given number \\( x \\) is asymptotically equivalent to \\( \\frac{x}{\\log x} \\). The proof of the PNT relies on properties of \\( \\zeta(s) \\), particularly the absence of zeros on the line \\( \\sigma = 1 \\).\n",
       "\n",
       "2. **Explicit Formulas:** These formulas connect the zeros of \\( \\zeta(s) \\) to the distribution of primes by expressing functions like the prime-counting function \\( \\pi(x) \\) in terms of the zeros of \\( \\zeta(s) \\). The error term in the approximation of \\( \\pi(x) \\) by \\( \\text{Li}(x) \\) (the logarithmic integral) is directly influenced by the location of these zeros.\n",
       "\n",
       "3. **Error Terms and Refinements:** If RH is true, it implies the best possible error estimates in the distribution of prime numbers. Specifically, RH would lead to bounds on the error term in the Prime Number Theorem of the form \\( O(x^{1/2} \\log x) \\), which is tighter than currently known bounds.\n",
       "\n",
       "In summary, the truth of the Riemann Hypothesis would provide deep insights into the fine-scale distribution of prime numbers, offering precise estimates and revealing underlying regularities in their seemingly random distribution.\n",
       "\n",
       "### An Innovative Method to Prove the Riemann Hypothesis Using Algebraic Geometry Techniques\n",
       "\n",
       "Proving the Riemann Hypothesis has eluded mathematicians for over a century, with approaches spanning various fields such as analytic number theory, random matrix theory, and mathematical physics. An **innovative approach leveraging algebraic geometry** could involve the following conceptual framework:\n",
       "\n",
       "#### 1. Geometric Interpretation of the Zeta Function\n",
       "\n",
       "**Objective:** Develop a geometric object (e.g., an algebraic variety or scheme) whose properties encapsulate the behavior of the Riemann zeta function, particularly its zeros.\n",
       "\n",
       "**Approach:**\n",
       "\n",
       "- **Arithmetic Schemes:** Inspired by the analogy between number fields and function fields, construct an arithmetic scheme over the integers \\( \\text{Spec}(\\mathbb{Z}) \\) that reflects the analytic properties of \\( \\zeta(s) \\). This could involve defining a suitable cohomological framework where the zeta function arises as a Lefschetz-type trace formula associated with this scheme.\n",
       "\n",
       "- **Motivic Zeta Functions:** Explore the possibility of interpreting \\( \\zeta(s) \\) as a motivic zeta function, linking it to the counting of points on algebraic varieties over finite fields. Although \\( \\zeta(s) \\) is defined over the complex numbers, establishing a bridge to motives could allow the application of powerful tools from algebraic geometry.\n",
       "\n",
       "#### 2. Cohomological Tools and the Weil Conjectures Analogy\n",
       "\n",
       "**Objective:** Utilize cohomological machinery analogous to that used in proving the Weil conjectures for varieties over finite fields, where the Riemann Hypothesis for those zeta functions has been established.\n",
       "\n",
       "**Approach:**\n",
       "\n",
       "- **Étale Cohomology:** Investigate whether an étale-type cohomology theory can be defined over \\( \\text{Spec}(\\mathbb{Z}) \\) or a related arithmetic space that captures the analytic properties of \\( \\zeta(s) \\). The success of étale cohomology in proving the Weil conjectures suggests that similar techniques might illuminate the nature of the zeros of \\( \\zeta(s) \\).\n",
       "\n",
       "- **Hodge Structures and L-functions:** Examine if the zeta function can be related to Hodge structures or more general motives, allowing the application of deep results concerning the weights and purity of cohomological groups, which are central to proving the Weil conjecture’s RH analog.\n",
       "\n",
       "#### 3. Noncommutative Geometry and Derived Categories\n",
       "\n",
       "**Objective:** Integrate concepts from noncommutative algebraic geometry to handle the transcendental nature of \\( \\zeta(s) \\).\n",
       "\n",
       "**Approach:**\n",
       "\n",
       "- **Spectral Interpretation:** Inspired by Alain Connes' work on noncommutative geometry, seek a spectral interpretation of \\( \\zeta(s) \\) where the non-trivial zeros correspond to spectral invariants of a geometric object, such as a noncommutative space or a derived category.\n",
       "\n",
       "- **Derived Categories and D-modules:** Utilize derived categories or D-module theory to encode the analytic continuation and functional equation of \\( \\zeta(s) \\) within a geometric framework, potentially enabling the application of geometric techniques to study the location of zeros.\n",
       "\n",
       "#### 4. Bridging to Physical Intuition: Topological Quantum Field Theories (TQFT)\n",
       "\n",
       "**Objective:** Leverage insights from TQFT and mirror symmetry, areas where algebraic geometry plays a pivotal role, to model \\( \\zeta(s) \\).\n",
       "\n",
       "**Approach:**\n",
       "\n",
       "- **String Theory Analogues:** Draw analogies between the zeta function and partition functions in string theory, where the zeros of \\( \\zeta(s) \\) might correspond to states or geometrical transitions in a hypothetical TQFT associated with \\( \\text{Spec}(\\mathbb{Z}) \\).\n",
       "\n",
       "- **Mirror Symmetry:** Investigate if mirror symmetry can provide dual geometric descriptions that constrain the location of zeros, analogous to how it predicts relationships between different geometric invariants.\n",
       "\n",
       "#### 5. Potential Roadmap to Prove RH\n",
       "\n",
       "- **Formulate a Geometric Object:** Define an algebraic variety or scheme whose associated zeta function aligns with the Riemann zeta function.\n",
       "\n",
       "- **Establish Cohomological Correspondence:** Develop a cohomological theory where the zeros of \\( \\zeta(s) \\) correspond to eigenvalues or spectral data of cohomological operators.\n",
       "\n",
       "- **Apply Geometric Techniques:** Utilize stability conditions, purity results, or symmetry arguments from algebraic geometry to constrain the possible locations of zeros.\n",
       "\n",
       "- **Leverage Analogies from Finite Fields:** Mimic strategies from the proof of the Weil conjectures, adapting them to the arithmetic setting intrinsic to \\( \\zeta(s) \\).\n",
       "\n",
       "### Challenges and Considerations\n",
       "\n",
       "While this proposed method draws on powerful and rich areas of algebraic geometry, several significant challenges must be addressed:\n",
       "\n",
       "1. **Transcendental Nature of \\( \\zeta(s) \\):** Unlike zeta functions of algebraic varieties over finite fields, the Riemann zeta function is inherently linked to the infinite prime (the archimedean place), necessitating novel geometric interpretations.\n",
       "\n",
       "2. **Lack of Direct Geometric Object:** There is no known algebraic variety whose zeta function is the Riemann zeta function, making it unclear how to construct such an object if it exists.\n",
       "\n",
       "3. **Cohomological Framework:** Developing an appropriate cohomological framework analogous to that used in the Weil conjectures remains an open and highly non-trivial task.\n",
       "\n",
       "4. **Analytic Continuation and Functional Equation:** Integrating these analytic aspects within an algebraic geometry context poses additional layers of complexity.\n",
       "\n",
       "### Conclusion\n",
       "\n",
       "Proposing an algebraic geometry-based proof of the Riemann Hypothesis involves pioneering new connections between number theory and geometry. By envisioning the Riemann zeta function through the lens of algebraic geometry—potentially via motivic interpretations, cohomological methods, or categorical frameworks—mathematicians might uncover novel pathways to tackle RH. While ambitious and speculative, such interdisciplinary approaches are essential for breakthroughs in understanding one of mathematics' most enigmatic problems."
      ],
      "text/plain": [
       "<IPython.core.display.Markdown object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "prompt = \"\"\"\n",
    "Describe the relationship between the Riemann Hypothesis and the distribution of prime numbers.\n",
    "\n",
    "Next, suggest an innovative method to prove the Riemann Hypothesis utilizing algebraic geometry techniques.\n",
    "\"\"\"\n",
    "\n",
    "resp = o1mini(prompt)\n",
    "display(Markdown(resp.choices[0].message.content))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "id": "ce28945f-7fc5-4bad-a84a-29a9a599c7c6",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Prompt tokens = 47 | Completion tokens = 2293 | Total tokens = 2340\n"
     ]
    }
   ],
   "source": [
    "print(f\"Prompt tokens = {resp.usage.prompt_tokens} | Completion tokens = {resp.usage.completion_tokens} | Total tokens = {resp.usage.total_tokens}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4f228e0a-1b54-4d17-8907-c9f48d1c24fa",
   "metadata": {},
   "source": [
    "### IT example"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "id": "41324f8f-d5ad-485f-8cf7-929169dd35c4",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/markdown": [
       "Designing a distributed system architecture for a real-time financial trading platform capable of processing **1 million transactions per second (TPS)** involves careful consideration of scalability, data consistency, fault tolerance, and regulatory compliance. Below is a comprehensive architecture outline addressing these requirements:\n",
       "\n",
       "---\n",
       "\n",
       "## **1. High-Level Architecture Overview**\n",
       "\n",
       "1. **Client Interface Layer**\n",
       "   - **Components**: Trader terminals, APIs for external systems, mobile applications.\n",
       "   - **Purpose**: Facilitates real-time interaction with the trading platform.\n",
       "\n",
       "2. **Load Balancing and API Gateway**\n",
       "   - **Components**: Global and local load balancers (e.g., NGINX, HAProxy), API gateways (e.g., Kong, AWS API Gateway).\n",
       "   - **Purpose**: Distributes incoming traffic efficiently, provides security features like rate limiting and authentication.\n",
       "\n",
       "3. **Message Brokering and Event Streaming**\n",
       "   - **Components**: Distributed message brokers (e.g., Apache Kafka, Apache Pulsar).\n",
       "   - **Purpose**: Decouples producers and consumers, ensures high-throughput and low-latency data ingestion.\n",
       "\n",
       "4. **Real-Time Processing Layer**\n",
       "   - **Components**: Stream processing frameworks (e.g., Apache Flink, Apache Storm, ksqlDB).\n",
       "   - **Purpose**: Processes transactions in real-time, handles order matching, risk assessments, and compliance checks.\n",
       "\n",
       "5. **Data Storage Layer**\n",
       "   - **Components**:\n",
       "     - **Transactional Data**: NoSQL databases (e.g., Cassandra, ScyllaDB) for high write throughput.\n",
       "     - **In-Memory Data Stores**: Redis, Memcached for low-latency data access.\n",
       "     - **Immutable Logs**: Write-optimized storage (e.g., Apache Hudi, AWS S3 with versioning) for audit trails.\n",
       "   - **Purpose**: Stores transactional data, maintains quick access to frequently used data, ensures data durability and immutability for compliance.\n",
       "\n",
       "6. **Consensus and Coordination**\n",
       "   - **Components**: Distributed consensus systems (e.g., Apache ZooKeeper, etcd, Consul).\n",
       "   - **Purpose**: Manages configuration, leader election, and ensures consistency across distributed components.\n",
       "\n",
       "7. **Microservices Layer**\n",
       "   - **Components**: Containerized services orchestrated with Kubernetes or similar platforms.\n",
       "   - **Purpose**: Implements business logic such as order management, user authentication, reporting, and compliance.\n",
       "\n",
       "8. **Monitoring, Logging, and Observability**\n",
       "   - **Components**: Prometheus, Grafana for monitoring; ELK Stack (Elasticsearch, Logstash, Kibana) for logging; Jaeger for tracing.\n",
       "   - **Purpose**: Provides visibility into system performance, facilitates troubleshooting, ensures adherence to SLAs.\n",
       "\n",
       "9. **Security Layer**\n",
       "   - **Components**: Firewalls, Intrusion Detection Systems (IDS), encryption services, IAM (Identity and Access Management).\n",
       "   - **Purpose**: Protects against unauthorized access, ensures data encryption in transit and at rest, manages user permissions.\n",
       "\n",
       "10. **Regulatory Compliance Module**\n",
       "    - **Components**: Automated compliance checking tools, audit log systems, data governance frameworks.\n",
       "    - **Purpose**: Ensures all transactions and data handling comply with relevant financial regulations (e.g., SEC, GDPR, MiFID II).\n",
       "\n",
       "---\n",
       "\n",
       "## **2. Addressing Key Requirements**\n",
       "\n",
       "### **a. Scalability to 1 Million TPS**\n",
       "\n",
       "- **Distributed Architecture**: Horizontally scalable across multiple data centers or cloud regions to handle high loads.\n",
       "- **Load Balancing**: Efficient distribution of incoming requests to prevent bottlenecks.\n",
       "- **Event-Driven Design**: Utilizing message brokers like Kafka allows decoupling and parallel processing of transactions.\n",
       "- **Stateless Services**: Microservices designed to be stateless facilitate easy scaling and load distribution.\n",
       "- **Data Sharding**: Partition databases by key (e.g., account ID) to distribute load and prevent single points of contention.\n",
       "- **Optimized Data Paths**: Minimize data movement and use in-memory processing where possible to reduce latency.\n",
       "\n",
       "### **b. Data Consistency**\n",
       "\n",
       "- **Consistency Model**: Utilize **strong consistency** where necessary (e.g., order execution) and **eventual consistency** for non-critical data to balance performance.\n",
       "- **Distributed Transactions**: Implement patterns like **Sagas** for managing complex transactions across microservices without relying on distributed locking.\n",
       "- **Consensus Algorithms**: Use protocols like **Raft** or **Paxos** within coordination services to maintain consistent states across nodes.\n",
       "- **Idempotency**: Ensure operations are idempotent to handle retries without data corruption.\n",
       "\n",
       "### **c. Fault Tolerance**\n",
       "\n",
       "- **Redundancy**: Deploy multiple instances of each service across different failure zones or data centers.\n",
       "- **Data Replication**: Replicate data across nodes and regions to prevent data loss.\n",
       "- **Automatic Failover**: Implement health checks and auto-restart mechanisms to handle node failures seamlessly.\n",
       "- **Circuit Breakers**: Prevent cascading failures by isolating failing components.\n",
       "- **Graceful Degradation**: Design the system to maintain core functionalities even when some components fail.\n",
       "\n",
       "### **d. Regulatory Compliance**\n",
       "\n",
       "- **Data Encryption**: Encrypt sensitive data both **in transit** (TLS/SSL) and **at rest** (AES-256 or similar).\n",
       "- **Audit Trails**: Maintain immutable audit logs for all transactions and system changes to facilitate audits.\n",
       "- **Access Controls**: Implement role-based access controls (RBAC) and multi-factor authentication (MFA) to secure access.\n",
       "- **Data Residency**: Ensure data is stored and processed in compliance with regional data residency laws.\n",
       "- **Compliance Automation**: Use automated tools to enforce compliance policies and generate necessary reports.\n",
       "- **Regular Audits and Assessments**: Conduct periodic security and compliance audits to identify and mitigate risks.\n",
       "\n",
       "---\n",
       "\n",
       "## **3. Technology Stack Recommendations**\n",
       "\n",
       "While specific technology choices may vary based on organizational preferences and existing infrastructure, the following stack is well-suited for the outlined requirements:\n",
       "\n",
       "- **Frontend & API Layer**: NGINX or HAProxy for load balancing; Kong or AWS API Gateway for API management.\n",
       "- **Message Brokering**: Apache Kafka for high-throughput, fault-tolerant event streaming.\n",
       "- **Stream Processing**: Apache Flink or Apache Storm for real-time transaction processing.\n",
       "- **Databases**:\n",
       "  - **Transactional**: ScyllaDB for high-performance NoSQL storage.\n",
       "  - **In-Memory**: Redis for caching and low-latency data access.\n",
       "  - **Immutable Logs**: Apache Hudi on Amazon S3 or similar storage solutions.\n",
       "- **Microservices Orchestration**: Kubernetes for container orchestration and management.\n",
       "- **Monitoring & Logging**: Prometheus & Grafana for monitoring; ELK Stack for centralized logging; Jaeger for distributed tracing.\n",
       "- **Security**: Vault by HashiCorp for secrets management; AWS IAM or equivalent for access management.\n",
       "- **Compliance Tools**: Tools like Immuta or BigID for data governance and compliance management.\n",
       "\n",
       "---\n",
       "\n",
       "## **4. Additional Considerations**\n",
       "\n",
       "### **a. Latency Optimization**\n",
       "\n",
       "- **Geographical Distribution**: Deploy services closer to major trading hubs to reduce network latency.\n",
       "- **Efficient Protocols**: Use binary protocols (e.g., gRPC) for inter-service communication to minimize overhead.\n",
       "- **Hardware Acceleration**: Consider using hardware optimizations (e.g., FPGAs) for latency-sensitive components like order matching engines.\n",
       "\n",
       "### **b. Data Backup and Disaster Recovery**\n",
       "\n",
       "- **Regular Backups**: Schedule automated backups of critical data with secure storage.\n",
       "- **Disaster Recovery Plans**: Establish and regularly test disaster recovery strategies to ensure business continuity.\n",
       "\n",
       "### **c. Testing and Continuous Integration/Continuous Deployment (CI/CD)**\n",
       "\n",
       "- **Automated Testing**: Implement comprehensive testing (unit, integration, stress) to ensure system reliability.\n",
       "- **CI/CD Pipelines**: Utilize pipelines for rapid, safe deployments with rollback capabilities.\n",
       "\n",
       "### **d. Documentation and Training**\n",
       "\n",
       "- **Comprehensive Documentation**: Maintain up-to-date documentation for all system components and processes.\n",
       "- **Training Programs**: Ensure development and operations teams are well-trained in managing and maintaining the distributed system.\n",
       "\n",
       "---\n",
       "\n",
       "## **5. Example Workflow**\n",
       "\n",
       "1. **Transaction Submission**: A trader submits a transaction via the client interface.\n",
       "2. **Load Balancing**: The API Gateway receives the request and routes it through the load balancer to an appropriate microservice instance.\n",
       "3. **Event Streaming**: The transaction is published to a Kafka topic for further processing.\n",
       "4. **Real-Time Processing**: Stream processors consume the transaction from Kafka, perform order matching, perform risk checks, and enforce compliance rules.\n",
       "5. **Data Persistence**: Processed transactions are written to ScyllaDB for durable storage, cached in Redis for quick access, and appended to immutable logs for audit purposes.\n",
       "6. **Feedback Loop**: Confirmation or rejection of the transaction is sent back through the API Gateway to the trader.\n",
       "7. **Monitoring and Logging**: All steps are monitored in real-time, with logs collected for audit and troubleshooting.\n",
       "\n",
       "---\n",
       "\n",
       "## **6. Conclusion**\n",
       "\n",
       "Building a distributed real-time financial trading platform capable of handling **1 million TPS** is a complex endeavor that requires a robust, scalable, and resilient architecture. By leveraging proven distributed technologies, implementing stringent data consistency and fault tolerance mechanisms, and ensuring comprehensive regulatory compliance, such a platform can achieve the desired performance and reliability standards essential for the high-stakes environment of financial trading.\n",
       "\n",
       "---\n",
       "\n",
       "**Note:** The specific implementation details may vary based on organizational needs, existing infrastructure, and technological preferences. It's crucial to conduct thorough testing, performance benchmarking, and security assessments to ensure the system meets all specified requirements."
      ],
      "text/plain": [
       "<IPython.core.display.Markdown object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "prompt = \"\"\"\n",
    "Develop a distributed system architecture for a real-time financial trading platform capable of processing 1 million transactions per second.\n",
    "\n",
    "Ensure the design addresses data consistency, fault tolerance, and regulatory compliance.\n",
    "\"\"\"\n",
    "\n",
    "resp = o1mini(prompt)\n",
    "display(Markdown(resp.choices[0].message.content))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "id": "2ce834d4-e824-4cac-bbb1-1c90627b9562",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Prompt tokens = 46 | Completion tokens = 2782 | Total tokens = 2828\n"
     ]
    }
   ],
   "source": [
    "print(f\"Prompt tokens = {resp.usage.prompt_tokens} | Completion tokens = {resp.usage.completion_tokens} | Total tokens = {resp.usage.total_tokens}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "adee1481-e4dd-450f-8b30-c0a2973a8a8a",
   "metadata": {},
   "source": [
    "### AI example"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "id": "976c9d82-29bc-4ec6-b94f-546c9b484e07",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/markdown": [
       "Creating a comprehensive ethical framework for the development and deployment of autonomous AI systems is crucial to ensure that these technologies benefit society while minimizing potential harms. This framework addresses key ethical principles—accountability, transparency, fairness, and long-term societal impacts—and proposes specific governance structures and regulatory approaches to oversee AI systems effectively.\n",
       "\n",
       "## 1. Ethical Principles\n",
       "\n",
       "### a. Accountability\n",
       "\n",
       "**Definition:** Ensuring that there are clear lines of responsibility for the actions and decisions made by autonomous AI systems.\n",
       "\n",
       "**Key Components:**\n",
       "- **Responsibility Assignment:** Define who is responsible at each stage of the AI lifecycle, including developers, deployers, and operators.\n",
       "- **Auditability:** Develop mechanisms for auditing AI decisions and actions to trace back to responsible parties.\n",
       "- **Liability Frameworks:** Establish legal structures that determine liability in cases of AI-induced harm or errors.\n",
       "- **Human Oversight:** Maintain human-in-the-loop systems where appropriate to ensure that humans can intervene in critical decisions.\n",
       "\n",
       "### b. Transparency\n",
       "\n",
       "**Definition:** Making AI systems and their decision-making processes understandable to stakeholders.\n",
       "\n",
       "**Key Components:**\n",
       "- **Explainability:** Ensure AI models can provide understandable explanations for their decisions to users and stakeholders.\n",
       "- **Documentation:** Maintain comprehensive documentation of AI system design, data sources, algorithms, and decision-making processes.\n",
       "- **Open Communication:** Foster open communication channels for stakeholders to inquire about and understand AI operations.\n",
       "- **Disclosure of Limitations:** Clearly communicate the limitations and potential biases inherent in AI systems.\n",
       "\n",
       "### c. Fairness\n",
       "\n",
       "**Definition:** Ensuring AI systems operate without bias and provide equitable treatment across different groups.\n",
       "\n",
       "**Key Components:**\n",
       "- **Bias Mitigation:** Implement techniques to identify and reduce biases in training data and algorithms.\n",
       "- **Inclusive Design:** Involve diverse teams in AI development to incorporate multiple perspectives and reduce unintended biases.\n",
       "- **Equitable Outcomes:** Monitor and evaluate AI impacts to ensure they do not disproportionately benefit or harm specific groups.\n",
       "- **Regular Audits:** Conduct periodic fairness audits to assess and address disparities in AI performance.\n",
       "\n",
       "### d. Long-Term Societal Impacts\n",
       "\n",
       "**Definition:** Assessing and managing the broader implications of AI systems on society over time.\n",
       "\n",
       "**Key Components:**\n",
       "- **Sustainability:** Evaluate the environmental impact of AI development and deployment, striving for energy-efficient solutions.\n",
       "- **Economic Impact:** Consider the effects of AI on employment, job displacement, and economic inequality.\n",
       "- **Social Cohesion:** Assess how AI influences social dynamics, privacy, and human interactions.\n",
       "- **Ethical Foresight:** Anticipate future challenges and ethical dilemmas arising from AI advancements and proactively address them.\n",
       "\n",
       "## 2. Governance Structures\n",
       "\n",
       "### a. Multi-Stakeholder Oversight Committees\n",
       "\n",
       "**Composition:**\n",
       "- Representatives from government, industry, academia, civil society, and marginalized communities.\n",
       "\n",
       "**Functions:**\n",
       "- Develop and update ethical guidelines and standards.\n",
       "- Monitor AI deployments and assess compliance with ethical standards.\n",
       "- Serve as advisory bodies for policymakers on AI-related issues.\n",
       "\n",
       "### b. Independent Ethics Boards\n",
       "\n",
       "**Composition:**\n",
       "- Ethicists, legal experts, technologists, and community representatives.\n",
       "\n",
       "**Functions:**\n",
       "- Review AI projects for ethical compliance before deployment.\n",
       "- Conduct independent audits of AI systems.\n",
       "- Provide recommendations for improving ethical practices in AI development.\n",
       "\n",
       "### c. Regulatory Agencies\n",
       "\n",
       "**Role:**\n",
       "- Enforce compliance with laws and regulations governing AI.\n",
       "- Issue certifications or licenses for AI systems based on ethical criteria.\n",
       "- Investigate and address violations related to AI ethics.\n",
       "\n",
       "## 3. Regulatory Approaches\n",
       "\n",
       "### a. Legislation and Standards\n",
       "\n",
       "**Actions:**\n",
       "- Enact laws that define ethical requirements for AI systems, including data privacy, security, and non-discrimination.\n",
       "- Develop industry-specific standards that outline best practices for ethical AI deployment.\n",
       "\n",
       "### b. Certification and Licensing\n",
       "\n",
       "**Actions:**\n",
       "- Implement certification processes for AI systems to ensure they meet ethical standards before market entry.\n",
       "- Require licenses for entities developing or deploying high-risk AI systems, contingent on ethical compliance.\n",
       "\n",
       "### c. Impact Assessments\n",
       "\n",
       "**Actions:**\n",
       "- Mandate comprehensive ethical and societal impact assessments for AI projects, particularly those with significant societal implications.\n",
       "- Require periodic re-evaluations of AI systems to account for evolving ethical standards and societal norms.\n",
       "\n",
       "### d. International Collaboration\n",
       "\n",
       "**Actions:**\n",
       "- Foster global cooperation to harmonize AI ethical standards and regulations.\n",
       "- Participate in international bodies and agreements to address cross-border AI challenges.\n",
       "\n",
       "### e. Incentives for Ethical AI\n",
       "\n",
       "**Actions:**\n",
       "- Provide grants, tax incentives, or other benefits for organizations that prioritize ethical AI development.\n",
       "- Recognize and reward companies and projects that demonstrate exemplary ethical practices in AI.\n",
       "\n",
       "## 4. Implementation Strategies\n",
       "\n",
       "### a. Education and Training\n",
       "\n",
       "**Actions:**\n",
       "- Incorporate ethics training into AI and data science curricula.\n",
       "- Provide ongoing professional development on ethical AI for practitioners and decision-makers.\n",
       "\n",
       "### b. Public Engagement\n",
       "\n",
       "**Actions:**\n",
       "- Engage with the public to understand societal concerns and expectations regarding AI.\n",
       "- Promote transparency initiatives to build trust between AI developers and the community.\n",
       "\n",
       "### c. Technological Tools for Ethics Compliance\n",
       "\n",
       "**Actions:**\n",
       "- Develop and utilize tools that assist in monitoring, auditing, and ensuring compliance with ethical standards.\n",
       "- Employ AI techniques, such as fairness-aware algorithms, to enhance ethical outcomes.\n",
       "\n",
       "## 5. Monitoring and Evaluation\n",
       "\n",
       "### a. Continuous Monitoring\n",
       "\n",
       "**Actions:**\n",
       "- Implement real-time monitoring systems to detect and address ethical breaches promptly.\n",
       "- Use performance metrics to evaluate the ethical performance of AI systems regularly.\n",
       "\n",
       "### b. Feedback Mechanisms\n",
       "\n",
       "**Actions:**\n",
       "- Establish channels for stakeholders to provide feedback on AI systems and report ethical concerns.\n",
       "- Incorporate feedback into iterative improvements of AI systems and ethical guidelines.\n",
       "\n",
       "### c. Periodic Reviews\n",
       "\n",
       "**Actions:**\n",
       "- Conduct regular reviews of the ethical framework to adapt to technological advancements and societal changes.\n",
       "- Update governance structures and regulations as necessary to maintain relevance and effectiveness.\n",
       "\n",
       "## 6. Case Studies and Best Practices\n",
       "\n",
       "### a. The European Union’s AI Act\n",
       "\n",
       "**Overview:**\n",
       "- Provides a comprehensive regulatory framework categorizing AI systems based on risk.\n",
       "- Imposes strict requirements on high-risk AI applications, including transparency and human oversight.\n",
       "\n",
       "**Lessons Learned:**\n",
       "- Risk-based approaches can effectively prioritize regulatory efforts.\n",
       "- Clear definitions and criteria are essential for enforceable regulations.\n",
       "\n",
       "### b. IEEE’s Ethically Aligned Design\n",
       "\n",
       "**Overview:**\n",
       "- A set of guidelines developed by IEEE to promote ethical considerations in AI and autonomous systems.\n",
       "\n",
       "**Lessons Learned:**\n",
       "- Industry-led initiatives can complement governmental regulations.\n",
       "- Collaboration across sectors is crucial for comprehensive ethical standards.\n",
       "\n",
       "## 7. Challenges and Mitigation Strategies\n",
       "\n",
       "### a. Rapid Technological Advancement\n",
       "\n",
       "**Challenges:**\n",
       "- AI technologies evolve quickly, potentially outpacing regulatory and ethical guidelines.\n",
       "\n",
       "**Mitigation:**\n",
       "- Implement flexible and adaptive regulatory frameworks that can respond to technological changes.\n",
       "- Foster continuous dialogue between technologists, ethicists, and policymakers.\n",
       "\n",
       "### b. Global Coordination\n",
       "\n",
       "**Challenges:**\n",
       "- Diverse ethical standards and regulations across different countries can lead to inconsistencies.\n",
       "\n",
       "**Mitigation:**\n",
       "- Promote international treaties and agreements to harmonize ethical and regulatory standards.\n",
       "- Encourage cross-border collaboration on AI ethics research and policy development.\n",
       "\n",
       "### c. Balancing Innovation and Regulation\n",
       "\n",
       "**Challenges:**\n",
       "- Over-regulation may stifle innovation, while under-regulation can lead to unethical practices.\n",
       "\n",
       "**Mitigation:**\n",
       "- Adopt a balanced approach that ensures ethical compliance without unduly hindering technological progress.\n",
       "- Encourage sandbox environments where AI innovations can be tested under regulatory supervision.\n",
       "\n",
       "## 8. Conclusion\n",
       "\n",
       "Establishing a thorough ethical framework for autonomous AI systems is imperative to harness their benefits while mitigating risks. By focusing on accountability, transparency, fairness, and long-term societal impacts, and by implementing robust governance structures and regulatory approaches, stakeholders can ensure that AI technologies develop responsibly and align with societal values. Continuous engagement, adaptive policies, and international cooperation are essential to navigate the evolving landscape of autonomous AI and to promote ethical innovation that benefits all of humanity."
      ],
      "text/plain": [
       "<IPython.core.display.Markdown object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "prompt = \"\"\"\n",
    "Create a thorough ethical framework for the development and deployment of autonomous AI systems.\n",
    "\n",
    "This framework should address accountability, transparency, fairness, and potential long-term societal impacts.\n",
    "Additionally, suggest specific governance structures and regulatory approaches.\n",
    "\"\"\"\n",
    "\n",
    "resp = o1mini(prompt)\n",
    "display(Markdown(resp.choices[0].message.content))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "id": "fc1ba270-d2ac-4e10-8781-0b5fda1147d4",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Prompt tokens = 53 | Completion tokens = 1778 | Total tokens = 1831\n"
     ]
    }
   ],
   "source": [
    "print(f\"Prompt tokens = {resp.usage.prompt_tokens} | Completion tokens = {resp.usage.completion_tokens} | Total tokens = {resp.usage.total_tokens}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fb672c5a-0544-4f6c-9925-f67d4603cbe4",
   "metadata": {},
   "source": [
    "## Physic calculations"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "id": "0ed808cf-ea50-4635-9883-dfb63b6c8b2d",
   "metadata": {},
   "outputs": [],
   "source": [
    "prompt = \"\"\"\n",
    "Magnesium (Mg, element 12) has three natural isotopes: Mg-24, Mg-25, and Mg-26.\n",
    "\n",
    "Mg-24 has a mass of 23.99 amu and accounts for 78.99% of all natural magnesium.\n",
    "Mg-25 has a mass of 24.99 amu and accounts for 10.00% of natural magnesium.\n",
    "Mg-26 has a mass of 25.98 amu and accounts for the final 11.01% of natural magnesium.\n",
    "\n",
    "What is the atomic mass of magnesium?\"\"\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "id": "67aaf0d6-28fc-45ee-b737-8bdf28b30aa9",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/markdown": [
       "To determine the atomic mass of magnesium, we need to calculate the weighted average of the masses of its natural isotopes based on their relative abundances. Here's how you can do it step-by-step:\n",
       "\n",
       "### Given Data:\n",
       "- **Mg-24**\n",
       "  - Mass: 23.99 amu\n",
       "  - Abundance: 78.99% (or 0.7899 in decimal)\n",
       "  \n",
       "- **Mg-25**\n",
       "  - Mass: 24.99 amu\n",
       "  - Abundance: 10.00% (or 0.1000 in decimal)\n",
       "  \n",
       "- **Mg-26**\n",
       "  - Mass: 25.98 amu\n",
       "  - Abundance: 11.01% (or 0.1101 in decimal)\n",
       "\n",
       "### Calculation:\n",
       "\n",
       "1. **Multiply the mass of each isotope by its fractional abundance:**\n",
       "\n",
       "   \\[\n",
       "   \\begin{align*}\n",
       "   \\text{Mg-24 contribution} &= 23.99 \\, \\text{amu} \\times 0.7899 = 18.9498 \\, \\text{amu} \\\\\n",
       "   \\text{Mg-25 contribution} &= 24.99 \\, \\text{amu} \\times 0.1000 = 2.499 \\, \\text{amu} \\\\\n",
       "   \\text{Mg-26 contribution} &= 25.98 \\, \\text{amu} \\times 0.1101 = 2.8598 \\, \\text{amu} \\\\\n",
       "   \\end{align*}\n",
       "   \\]\n",
       "\n",
       "2. **Sum the contributions to get the atomic mass:**\n",
       "\n",
       "   \\[\n",
       "   \\text{Atomic Mass of Mg} = 18.9498 \\, \\text{amu} + 2.499 \\, \\text{amu} + 2.8598 \\, \\text{amu} = 24.3086 \\, \\text{amu}\n",
       "   \\]\n",
       "\n",
       "3. **Rounding:**\n",
       "\n",
       "   It's standard to round the atomic mass to two decimal places based on the precision of the given data:\n",
       "\n",
       "   \\[\n",
       "   \\text{Atomic Mass of Mg} \\approx 24.31 \\, \\text{amu}\n",
       "   \\]\n",
       "\n",
       "### Conclusion:\n",
       "\n",
       "The **atomic mass of magnesium** is **approximately ** **24.31 amu**."
      ],
      "text/plain": [
       "<IPython.core.display.Markdown object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "resp = o1mini(prompt)\n",
    "display(Markdown(resp.choices[0].message.content))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "id": "bd30eff5-bece-42ee-96d9-d23fe397f7a8",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Prompt tokens = 127 | Completion tokens = 1132 | Total tokens = 1259\n"
     ]
    }
   ],
   "source": [
    "print(f\"Prompt tokens = {resp.usage.prompt_tokens} | Completion tokens = {resp.usage.completion_tokens} | Total tokens = {resp.usage.total_tokens}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fe4bc617-4274-4295-a6bb-b37d1b7b1473",
   "metadata": {},
   "source": [
    "## Chemistry example"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "id": "2562d1c2-234d-4911-801a-f32b5f430026",
   "metadata": {},
   "outputs": [],
   "source": [
    "prompt = \"\"\"\n",
    "Sodium hydroxide (NaOH) reacts with phosphoric acid (H₃PO₄) to form sodium phosphate (Na₃PO₄) and water (H₂O) by the reaction:\n",
    "3 NaOH(aq) + H₃PO₄(aq) → Na₃PO₄(aq) + 3 H₂O(l) If 35.60 grams of NaOH are reacted with 30.80 grams of H₃PO₄.\n",
    "How many grams of Na₃PO₄ are formed?\n",
    "\"\"\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "id": "200d41da-0268-40fc-9579-5da90eee41a9",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/markdown": [
       "To determine how many grams of sodium phosphate (Na₃PO₄) are formed when 35.60 grams of sodium hydroxide (NaOH) react with 30.80 grams of phosphoric acid (H₃PO₄), follow these steps:\n",
       "\n",
       "### 1. **Write the Balanced Chemical Equation:**\n",
       "\\[ 3 \\, \\text{NaOH}(aq) + \\text{H}_3\\text{PO}_4(aq) \\rightarrow \\text{Na}_3\\text{PO}_4(aq) + 3 \\, \\text{H}_2\\text{O}(l) \\]\n",
       "\n",
       "### 2. **Calculate Molar Masses:**\n",
       "- **NaOH:** \n",
       "  \\[\n",
       "  \\text{Na} = 22.99 \\, \\text{g/mol}, \\, \\text{O} = 16.00 \\, \\text{g/mol}, \\, \\text{H} = 1.008 \\, \\text{g/mol} \n",
       "  \\]\n",
       "  \\[\n",
       "  \\text{Molar mass of NaOH} = 22.99 + 16.00 + 1.008 \\approx 40.00 \\, \\text{g/mol}\n",
       "  \\]\n",
       "- **H₃PO₄:**\n",
       "  \\[\n",
       "  \\text{H}_3\\text{PO}_4 = 3(1.008) + 30.97 + 4(16.00) = 3.024 + 30.97 + 64.00 \\approx 98.00 \\, \\text{g/mol}\n",
       "  \\]\n",
       "- **Na₃PO₄:**\n",
       "  \\[\n",
       "  \\text{Na}_3\\text{PO}_4 = 3(22.99) + 30.97 + 4(16.00) = 68.97 + 30.97 + 64.00 = 163.94 \\, \\text{g/mol}\n",
       "  \\]\n",
       "\n",
       "### 3. **Determine Moles of Reactants:**\n",
       "- **Moles of NaOH:**\n",
       "  \\[\n",
       "  \\frac{35.60 \\, \\text{g}}{40.00 \\, \\text{g/mol}} = 0.89 \\, \\text{mol}\n",
       "  \\]\n",
       "- **Moles of H₃PO₄:**\n",
       "  \\[\n",
       "  \\frac{30.80 \\, \\text{g}}{98.00 \\, \\text{g/mol}} \\approx 0.314 \\, \\text{mol}\n",
       "  \\]\n",
       "\n",
       "### 4. **Identify the Limiting Reactant:**\n",
       "The balanced equation requires 3 moles of NaOH for every 1 mole of H₃PO₄.\n",
       "\n",
       "- **Required moles of NaOH for 0.314 mol of H₃PO₄:**\n",
       "  \\[\n",
       "  3 \\times 0.314 = 0.942 \\, \\text{mol}\n",
       "  \\]\n",
       "  \n",
       "Since you only have 0.89 mol of NaOH, **NaOH is the limiting reactant**.\n",
       "\n",
       "### 5. **Calculate Moles of Na₃PO₄ Formed:**\n",
       "From the balanced equation, 3 moles of NaOH produce 1 mole of Na₃PO₄.\n",
       "\n",
       "\\[\n",
       "\\text{Moles of Na}_3\\text{PO}_4 = \\frac{0.89 \\, \\text{mol NaOH}}{3} \\approx 0.297 \\, \\text{mol}\n",
       "\\]\n",
       "\n",
       "### 6. **Convert Moles of Na₃PO₄ to Grams:**\n",
       "\\[\n",
       "0.297 \\, \\text{mol} \\times 163.94 \\, \\text{g/mol} \\approx 48.62 \\, \\text{g}\n",
       "\\]\n",
       "\n",
       "### **Final Answer:**\n",
       "Approximately **48.6 g of sodium phosphate (Na₃PO₄)** are formed."
      ],
      "text/plain": [
       "<IPython.core.display.Markdown object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "resp = o1mini(prompt)\n",
    "display(Markdown(resp.choices[0].message.content))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "id": "8f3d9d77-ad91-4c39-b2d8-62e7194302e9",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Prompt tokens = 126 | Completion tokens = 1569 | Total tokens = 1695\n"
     ]
    }
   ],
   "source": [
    "print(f\"Prompt tokens = {resp.usage.prompt_tokens} | Completion tokens = {resp.usage.completion_tokens} | Total tokens = {resp.usage.total_tokens}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a590e143-62d3-4a50-88f5-d43cdbe7e40c",
   "metadata": {},
   "source": [
    "## Physic example"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "id": "c5a7b8dc-2a72-43ad-a34a-374bfba4e6bd",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/markdown": [
       "To calculate the volume of the pyramid \\( SABCD \\), we'll follow these steps:\n",
       "\n",
       "### 1. **Calculate the Base Area**\n",
       "The base of the pyramid is a rectangle with sides:\n",
       "- \\( AB = 4.2 \\, \\text{cm} \\)\n",
       "- \\( BC = 3.5 \\, \\text{cm} \\)\n",
       "\n",
       "\\[\n",
       "\\text{Base Area} = AB \\times BC = 4.2 \\, \\text{cm} \\times 3.5 \\, \\text{cm} = 14.7 \\, \\text{cm}^2\n",
       "\\]\n",
       "\n",
       "### 2. **Calculate the Volume of the Pyramid**\n",
       "The formula for the volume \\( V \\) of a pyramid is:\n",
       "\n",
       "\\[\n",
       "V = \\frac{1}{3} \\times \\text{Base Area} \\times \\text{Height}\n",
       "\\]\n",
       "\n",
       "Given the height \\( h = 6.3 \\, \\text{cm} \\):\n",
       "\n",
       "\\[\n",
       "V = \\frac{1}{3} \\times 14.7 \\, \\text{cm}^2 \\times 6.3 \\, \\text{cm} = \\frac{1}{3} \\times 92.61 \\, \\text{cm}^3 = 30.87 \\, \\text{cm}^3\n",
       "\\]\n",
       "\n",
       "### 3. **Convert Volume to Millimeters Cubed (mm³)**\n",
       "Since \\( 1 \\, \\text{cm}^3 = 1000 \\, \\text{mm}^3 \\):\n",
       "\n",
       "\\[\n",
       "30.87 \\, \\text{cm}^3 \\times 1000 = 30{,}870 \\, \\text{mm}^3\n",
       "\\]\n",
       "\n",
       "### **Final Answer**\n",
       "- **Volume in cm³:** 30.87 cm³\n",
       "- **Volume in mm³:** 30 870 mm³"
      ],
      "text/plain": [
       "<IPython.core.display.Markdown object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "prompt = \"\"\"\n",
    "Calculate the volume of a pyramid SABCD, with a height of 6.3 cm and a rectangular base ABCD such that AB = 4.2 cm and BC = 3.5 cm. \n",
    "Give the result in cm³ and then in mm³.\n",
    "\"\"\"\n",
    "\n",
    "resp = o1mini(prompt)\n",
    "display(Markdown(resp.choices[0].message.content))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "id": "9e6b325f-d3c9-4794-9412-487c4b2762a7",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Prompt tokens = 64 | Completion tokens = 690 | Total tokens = 754\n"
     ]
    }
   ],
   "source": [
    "print(f\"Prompt tokens = {resp.usage.prompt_tokens} | Completion tokens = {resp.usage.completion_tokens} | Total tokens = {resp.usage.total_tokens}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "id": "ed8ae14a-04e4-46f0-b321-b3766a4aca0d",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/markdown": [
       "The **volume of a pyramid** can be calculated using the following formula:\n",
       "\n",
       "\\[\n",
       "\\text{Volume} = \\frac{1}{3} \\times \\text{Base Area} \\times \\text{Height}\n",
       "\\]\n",
       "\n",
       "### Where:\n",
       "\n",
       "- **Base Area (\\(B\\))**: This is the area of the pyramid's base. The shape of the base can vary (e.g., square, rectangular, triangular, etc.), and you'll use the appropriate area formula based on the base shape.\n",
       "  \n",
       "- **Height (\\(h\\))**: This is the perpendicular distance from the base to the apex (the top point) of the pyramid.\n",
       "\n",
       "### Step-by-Step Calculation:\n",
       "\n",
       "1. **Determine the Base Area (\\(B\\))**:\n",
       "   - For a **square base** with side length \\(a\\):\n",
       "     \\[\n",
       "     B = a^2\n",
       "     \\]\n",
       "   - For a **rectangular base** with length \\(l\\) and width \\(w\\):\n",
       "     \\[\n",
       "     B = l \\times w\n",
       "     \\]\n",
       "   - For a **triangular base** with base \\(b\\) and height \\(h_b\\):\n",
       "     \\[\n",
       "     B = \\frac{1}{2} \\times b \\times h_b\n",
       "     \\]\n",
       "   - *(Use the appropriate formula based on your specific pyramid.)*\n",
       "\n",
       "2. **Measure the Height (\\(h\\))**:\n",
       "   - Ensure that the height is **perpendicular** to the base.\n",
       "\n",
       "3. **Apply the Volume Formula**:\n",
       "   \\[\n",
       "   \\text{Volume} = \\frac{1}{3} \\times B \\times h\n",
       "   \\]\n",
       "\n",
       "### **Example:**\n",
       "\n",
       "**Problem:**  \n",
       "Calculate the volume of a pyramid with a square base where each side of the base is 6 meters, and the height of the pyramid is 9 meters.\n",
       "\n",
       "**Solution:**\n",
       "\n",
       "1. **Calculate Base Area (\\(B\\))**:\n",
       "   \\[\n",
       "   B = 6\\ \\text{m} \\times 6\\ \\text{m} = 36\\ \\text{m}^2\n",
       "   \\]\n",
       "\n",
       "2. **Use the Volume Formula**:\n",
       "   \\[\n",
       "   \\text{Volume} = \\frac{1}{3} \\times 36\\ \\text{m}^2 \\times 9\\ \\text{m} = \\frac{1}{3} \\times 324\\ \\text{m}^3 = 108\\ \\text{m}^3\n",
       "   \\]\n",
       "\n",
       "**Answer:**  \n",
       "The volume of the pyramid is **108 cubic meters**.\n",
       "\n",
       "### **Key Points to Remember:**\n",
       "\n",
       "- The volume of any pyramid is always **one-third** the product of its base area and its height.\n",
       "- Ensure that the **height** is measured **perpendicularly** from the base to the apex for an accurate calculation.\n",
       "- This formula applies to **any pyramid**, regardless of the shape of the base.\n",
       "\n",
       "If you have a specific pyramid in mind or need help with a different base shape, feel free to provide more details!"
      ],
      "text/plain": [
       "<IPython.core.display.Markdown object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "prompt = \"\"\"\n",
    "What is the volume of a pyramid?\n",
    "\"\"\"\n",
    "\n",
    "resp = o1mini(prompt)\n",
    "display(Markdown(resp.choices[0].message.content))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 73,
   "id": "5545c9ed-d285-4542-ace7-6daa82c40066",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Prompt tokens = 16 | Completion tokens = 772 | Total tokens = 788\n"
     ]
    }
   ],
   "source": [
    "print(f\"Prompt tokens = {resp.usage.prompt_tokens} | Completion tokens = {resp.usage.completion_tokens} | Total tokens = {resp.usage.total_tokens}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "9e03f6a1-4758-4ba5-b801-da26dc823bea",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "99ff0419-dea6-462d-b5d7-19e6cf8a25ac",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "71206c76-cc69-40c3-aa06-7e75fc2f157b",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3.10 - SDK v2",
   "language": "python",
   "name": "python310-sdkv2"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.10.14"
  },
  "varInspector": {
   "cols": {
    "lenName": 16,
    "lenType": 16,
    "lenVar": 40
   },
   "kernels_config": {
    "python": {
     "delete_cmd_postfix": "",
     "delete_cmd_prefix": "del ",
     "library": "var_list.py",
     "varRefreshCmd": "print(var_dic_list())"
    },
    "r": {
     "delete_cmd_postfix": ") ",
     "delete_cmd_prefix": "rm(",
     "library": "var_list.r",
     "varRefreshCmd": "cat(var_dic_list()) "
    }
   },
   "types_to_exclude": [
    "module",
    "function",
    "builtin_function_or_method",
    "instance",
    "_Feature"
   ],
   "window_display": false
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}