diff --git a/README.md b/README.md deleted file mode 100644 index 306d65180..000000000 --- a/README.md +++ /dev/null @@ -1,217 +0,0 @@ - - -![](docs/images/apps-catalog-promo-web-banner-laptop-300@2x.jpg) - -# NVIDIA Generative AI Examples - -This repository is a starting point for developers looking to integrate with the NVIDIA software ecosystem to speed up their generative AI systems. Whether you are building RAG pipelines, agentic workflows, or fine-tuning models, this repository will help you integrate NVIDIA, seamlessly and natively, with your development stack. - -## Table of Contents - - -* [What's New?](#whats-new) - * [Data Flywheel](#data-flywheel) - * [Safer Agentic AI](#safer-agentic-ai) - * [Knowledge Graph RAG](#knowledge-graph-rag) - * [Agentic Workflows with Llama 3.1](#agentic-workflows-with-llama-31) - * [RAG with Local NIM Deployment and LangChain](#rag-with-local-nim-deployment-and-langchain) - * [Vision NIM Workflows](#vision-nim-workflows) -* [Try it Now!](#try-it-now) -* [Data Flywheel](#data-flywheel) - * [Tool-Calling Notebooks](#tool-calling-notebooks) -* [RAG](#rag) - * [RAG Notebooks](#rag-notebooks) - * [RAG Examples](#rag-examples) - * [RAG Tools](#rag-tools) - * [RAG Projects](#rag-projects) -* [Documentation](#documentation) - * [Getting Started](#getting-started) - * [How To's](#how-tos) - * [Reference](#reference) -* [Community](#community) - - - -## What's New? - -### Data Flywheel - -These tutorials demonstrate Data Flywheel workflows that use NVIDIA NeMo Microservices. They include components such as NVIDIA NeMo Datastore, NeMo Entity Store, NeMo Customizer, NeMo Evaluator, NeMo Guardrails microservices, and NVIDIA NIMs. - -- [Tool Calling Fine-tuning, Inference, Evaluation, and Guardrailing with NVIDIA NeMo Microservices and NIMs](./nemo/data-flywheel/tool-calling) -- [Embedding Fine-tuning, Inference, and Evaluation with NVIDIA NeMo Microservices and NIMs](./nemo/data-flywheel/embedding-finetuning/) - -### Safer Agentic AI - -The following tutorials illustrate how to audit your large language models with NeMo Auditor to identify vulnerabilities to unsafe prompts, and how to run inference with multiple rails in parallel to reduce latency and improve throughput. - -- [Audit your LLMs](./nemo/NeMo-Auditor/Getting_Started_With_NeMo_Auditor.ipynb) -- [Inference with Parallel Rails](./nemo/NeMo-Guardrails/Parallel_Rails_Tutorial.ipynb) - -### Knowledge Graph RAG - -This example implements a GPU-accelerated pipeline for creating and querying knowledge graphs using RAG by leveraging NIM microservices and the RAPIDS ecosystem to process large-scale datasets efficiently. - -- [Knowledge Graphs for RAG with NVIDIA AI Foundation Models and Endpoints](community/knowledge_graph_rag) - -### Agentic Workflows with Llama 3.1 - -- Build an Agentic RAG Pipeline with Llama 3.1 and NVIDIA NeMo Retriever NIM microservices [[Blog](https://developer.nvidia.com/blog/build-an-agentic-rag-pipeline-with-llama-3-1-and-nvidia-nemo-retriever-nims/), [Notebook](RAG/notebooks/langchain/agentic_rag_with_nemo_retriever_nim.ipynb)] -- [NVIDIA Morpheus, NIM microservices, and RAG pipelines integrated to create LLM-based agent pipelines](https://github.com/NVIDIA/GenerativeAIExamples/blob/v0.7.0/experimental/event-driven-rag-cve-analysis) - - -### RAG with Local NIM Deployment and LangChain - -- Tips for Building a RAG Pipeline with NVIDIA AI LangChain AI Endpoints by Amit Bleiweiss. [[Blog](https://developer.nvidia.com/blog/tips-for-building-a-rag-pipeline-with-nvidia-ai-langchain-ai-endpoints/), [Notebook](https://github.com/NVIDIA/GenerativeAIExamples/blob/v0.7.0/notebooks/08_RAG_Langchain_with_Local_NIM.ipynb)] - -For more information, refer to the [Generative AI Example releases](https://github.com/NVIDIA/GenerativeAIExamples/releases/). - -### Vision NIM Workflows -A collection of Jupyter notebooks, sample code and reference applications built with Vision NIMs. - -To pull the vision NIM workflows, clone this repository recursively: -``` -git clone https://github.com/nvidia/GenerativeAIExamples --recurse-submodules -``` - -The workflows will then be located at [GenerativeAIExamples/vision_workflows](vision_workflows/README.md) - -Follow the links below to learn more: -- [Learn how to use VLMs to automatically monitor a video stream for custom events.](nim_workflows/vlm_alerts/README.md) -- [Learn how to search images with natural language using NV-CLIP.](nim_workflows/nvclip_multimodal_search/README.md) -- [Learn how to combine VLMs, LLMs and CV models to build a robust text extraction pipeline.](nim_workflows/vision_text_extraction/README.md) -- [Learn how to use embeddings with NVDINOv2 and a Milvus VectorDB to build a few shot classification model.](nim_workflows/nvdinov2_few_shot/README.md) - - -## Try it Now! - -Experience NVIDIA RAG Pipelines with just a few steps! - -1. Get your NVIDIA API key. - 1. Go to the [NVIDIA API Catalog](https://build.ngc.nvidia.com/explore/). - 1. Select any model. - 1. Click **Get API Key**. - 1. Run: - ```console - export NVIDIA_API_KEY=nvapi-... - ``` - -1. Clone the repository. - - ```console - git clone https://github.com/nvidia/GenerativeAIExamples.git - ``` - -1. Build and run the basic RAG pipeline. - - ```console - cd GenerativeAIExamples/RAG/examples/basic_rag/langchain/ - docker compose up -d --build - ``` - -1. Go to and submit queries to the sample RAG Playground. - -1. Stop containers when done. - - ```console - docker compose down - ``` - - - -## Data Flywheel - -A [Data Flywheel](https://www.nvidia.com/en-us/glossary/data-flywheel/) is a self-reinforcing cycle where user interactions generate data that improves AI models or products, leading to better outcomes that attract more users and further enhance data quality. This feedback loop relies on continuous data processing, model refinement, and guardrails to ensure accuracy and compliance while compounding value over time. Real-world applications range from personalized customer experiences to operational systems like inventory management, where improved predictions drive efficiency and growth. - -### Tool-Calling Notebooks - -Tool calling empowers Large Language Models (LLMs) to integrate with external APIs, execute dynamic workflows, and retrieve real-time data beyond their training scope. The NVIDIA NeMo microservices platform offers a modular infrastructure for deploying AI pipelines that includes fine-tuning, evaluation, inference, and guardrail enforcement—across Kubernetes clusters in cloud or on-premises environments. - -This end-to-end [tutorial](./nemo/data-flywheel/tool-calling) demonstrates how to leverage NeMo Microservices to customize [Llama-3.2-1B-Instruct](https://huggingface.co/meta-llama/Llama-3.2-1B-Instruct) by using the [xLAM](https://huggingface.co/datasets/Salesforce/xlam-function-calling-60k) function-calling dataset, assess its accuracy, and implement safety constraints to govern its behavior. - -## RAG - -### RAG Notebooks - -NVIDIA has first-class support for popular generative AI developer frameworks like [LangChain](https://python.langchain.com/v0.2/docs/integrations/chat/nvidia_ai_endpoints/), [LlamaIndex](https://docs.llamaindex.ai/en/stable/examples/llm/nvidia/), and [Haystack](https://haystack.deepset.ai/integrations/nvidia). These end-to-end notebooks show how to integrate NIM microservices using your preferred generative AI development framework. - -Use these [notebooks](./RAG/notebooks/README.md) to learn about the LangChain and LlamaIndex connectors. - -#### LangChain Notebooks - -- RAG - - [Basic RAG with CHATNVIDIA LangChain Integration](./RAG/notebooks/langchain/langchain_basic_RAG.ipynb) - - [RAG using local NIM microservices for LLMs and Retrieval](./RAG/notebooks/langchain/RAG_Langchain_with_Local_NIM.ipynb) - - [RAG for HTML Documents](./RAG/notebooks/langchain/RAG_for_HTML_docs_with_Langchain_NVIDIA_AI_Endpoints.ipynb) - - [Chat with NVIDIA Financial Reports](./RAG/notebooks/langchain/Chat_with_nvidia_financial_reports.ipynb) -- Agents - - [NIM Tool Calling 101](https://github.com/langchain-ai/langchain-nvidia/blob/main/cookbook/nvidia_nim_agents_llama3.1.ipynb) - - [Agentic RAG with NeMo Retriever](./RAG/notebooks/langchain/agentic_rag_with_nemo_retriever_nim.ipynb) - - [Agents with Human in the Loop](./RAG/notebooks/langchain/LangGraph_HandlingAgent_IntermediateSteps.ipynb) - - -#### LlamaIndex Notebooks - -- [Basic RAG with LlamaIndex Integration](./RAG/notebooks/llamaindex/llamaindex_basic_RAG.ipynb) - -### RAG Examples - -By default, these end-to-end [examples](RAG/examples/README.md) use preview NIM endpoints on [NVIDIA API Catalog](https://catalog.ngc.nvidia.com). Alternatively, you can run any of the examples [on premises](./RAG/examples/local_deploy/). - -#### Basic RAG Examples - - - [LangChain example](./RAG/examples/basic_rag/langchain/README.md) - - [LlamaIndex example](./RAG/examples/basic_rag/llamaindex/README.md) - -#### Advanced RAG Examples - - - [Multi-Turn](./RAG/examples/advanced_rag/multi_turn_rag/README.md) - - [Multimodal Data](./RAG/examples/advanced_rag/multimodal_rag/README.md) - - [Structured Data](./RAG/examples/advanced_rag/structured_data_rag/README.md) (CSV) - - [Query Decomposition](./RAG/examples/advanced_rag/query_decomposition_rag/README.md) - -### RAG Tools - -Example tools and tutorials to enhance LLM development and productivity when using NVIDIA RAG pipelines. - -- [Evaluation](./RAG/tools/evaluation/README.md) -- [Observability](./RAG/tools/observability/README.md) - -### RAG Projects - -- [NVIDIA Tokkio LLM-RAG](https://docs.nvidia.com/ace/latest/workflows/tokkio/text/Tokkio_LLM_RAG_Bot.html): Use Tokkio to add avatar animation for RAG responses. -- [Hybrid RAG Project on AI Workbench](https://github.com/NVIDIA/workbench-example-hybrid-rag): Run an NVIDIA AI Workbench example project for RAG. - -## Documentation - -### Getting Started - -- [Prerequisites](./docs/common-prerequisites.md) - -### How To's - -- [Changing the Inference or Embedded Model](./docs/change-model.md) -- [Customizing the Vector Database](./docs/vector-database.md) -- [Customizing the Chain Server](./docs/chain-server.md): - - [Chunking Strategy](./docs/text-splitter.md) - - [Prompting Template Engineering](./docs/prompt-customization.md) -- [Configuring LLM Parameters at Runtime](./docs/llm-params.md) -- [Supporting Multi-Turn Conversations](./docs/multiturn.md) -- [Speaking Queries and Listening to Responses with NVIDIA Riva](./docs/riva-asr-tts.md) - -### Reference - -- [Support Matrix](./docs/support-matrix.md) -- [Architecture](./docs/architecture.md) -- [Using the Sample Chat Web Application](./docs/using-sample-web-application.md) -- [RAG Playground Web Application](./docs/frontend.md) -- [Software Component Configuration](./docs/configuration.md) - - -## Community -We're posting these examples on GitHub to support the NVIDIA LLM community and facilitate feedback. -We invite contributions! Open a GitHub issue or pull request! See [contributing](docs/contributing.md) Check out the [community](./community/README.md) examples and notebooks. - diff --git a/oss_tutorials/Building_a_Simple_AI_Agent_with_Qwen3_Next_powered_by_NVIDIA_NIM.ipynb b/oss_tutorials/Building_a_Simple_AI_Agent_with_Qwen3_Next_powered_by_NVIDIA_NIM.ipynb new file mode 100644 index 000000000..47ca9911d --- /dev/null +++ b/oss_tutorials/Building_a_Simple_AI_Agent_with_Qwen3_Next_powered_by_NVIDIA_NIM.ipynb @@ -0,0 +1,931 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": { + "colab_type": "text", + "id": "view-in-github" + }, + "source": [ + "[![ Click here to deploy.](https://brev-assets.s3.us-west-1.amazonaws.com/nv-lb-dark.svg)](https://brev.nvidia.com/launchable/deploy?launchableID=env-32plqISpN9NtCg5hdlFtrdZzoEs) \"Open" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "0jFwCpFmwgjK" + }, + "source": [ + "![image](https://imgur.com/FfbspFL.png)\n", + "# Building an AI Agent with Qwen3 Next Powered by NVIDIA NIM\n", + "\n", + "In the following notebook, we'll take a look at a few things:\n", + "\n", + "1. How to use the NVIDIA-hosted NIM API to run inference on the model through the [ChatCompletions API](https://platform.openai.com/docs/api-reference/chat)\n", + "2. How to build a Simple Notes Taking Agent powered by the `qwen3-next` NIM using the [OpenAI Agents SDK](https://github.com/openai/openai-agents-python/tree/main).\n", + "\n", + "Let's get right into it!" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "LjSo-Kx3xzQY" + }, + "source": [ + "## Getting an API Key from build.nvidia.com\n", + "\n", + "In order to use the NVIDIA-hosted NIM API - we'll need to have an API key from build.nvidia.com, luckily this is very straightforward.\n", + "\n", + "First, let's navigate to the model on [build.nvidia.com](https://build.nvidia.com/qwen/qwen3-next-80b-a3b-thinking)!\n", + "\n", + "> NOTE: You'll need to ensure you're logged in before moving to the next steps!\n", + "\n", + "Once there, you can click on the green button that says: `View Code`.\n", + "\n", + "![image](https://i.imgur.com/mSGQPfC.png)\n", + "\n", + "A new modal should appear on your screen, where you can click the `Generate API Key` text to obtain your API key!\n", + "\n", + "![image](https://imgur.com/sDlK4eO.png)\n", + "\n", + "Once you have that API key, you're good to move on to the next step which will capture it as an environment variable." + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "fiwQ8aZUUJpv", + "outputId": "8b7770b8-61d7-4f8b-a28c-b8f2e906a206" + }, + "outputs": [], + "source": [ + "import os\n", + "import getpass\n", + "\n", + "os.environ[\"NVIDIA_API_KEY\"] = getpass.getpass(\"Enter your NVIDIA API key (found at build.nvidia.com)\")" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "C7anNSsM0ZNU" + }, + "source": [ + "## Using the OpenAI Library with the NVIDIA-hosted NIM API\n", + "\n", + "We will be using the Python [OpenAI SDK](https://github.com/openai/openai-python) to access the `qwen3-next` model on build.nvidia.com.\n", + "\n", + "Let's start with a classic `pip install`." + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "ZI2c_q34Uqke", + "outputId": "852aa8ec-e250-437b-c8a5-257a12d41d3a" + }, + "outputs": [], + "source": [ + "! pip install -qU openai" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "N8oxujI-07oe" + }, + "source": [ + "Once we've installed the `openai` library - we can use it to create an OpenAI client, which we'll point at the NVIDIA-hosted NIM API endpoint.\n", + "\n", + "We'll also be sure to provide the API key we entered above by referencing the environment variable." + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": { + "id": "lrzOTsg2UZPL" + }, + "outputs": [], + "source": [ + "from openai import OpenAI\n", + "\n", + "client = OpenAI(\n", + " base_url = \"https://integrate.api.nvidia.com/v1\",\n", + " api_key = os.environ[\"NVIDIA_API_KEY\"]\n", + ")" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "8nV95Jaq1Qa5" + }, + "source": [ + "This latest model from Qwen is best suitable for agentic tasks, where multi-step reasoning over long contexts is crucial.\n", + "\n", + "Let's get acquainted with how you can interact with this model at API level.\n", + "\n", + "We will use a math question from AIME25, a dataset designed to test reasoning model's Mathemaric capabilities.\n", + "\n", + "The example is as follows." + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "collapsed": true, + "id": "C3FoTglNQQHT", + "outputId": "532749d0-2918-4045-e615-4e770d1d5ac2" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "This is a complex or challenging question, and it is difficult to provide a direct and correct answer. I need to think about it.\n", + "Well, so we have 9 baseball players, each getting a single-scoop ice cream: chocolate (C), vanilla (V), or strawberry (S). Conditions: at least one of each flavor, so no flavor is zero. Also, number of chocolate > vanilla > strawberry. Let's denote the counts as c, v, s for chocolate, vanilla, strawberry respectively. So we have c + v + s = 9, with c > v > s ≥ 1 (since at least one each, so s ≥ 1, then v > s implies v ≥ 2, c > v implies c ≥ 3, but maybe better to just write inequalities strictly).\n", + "\n", + "First step: find all possible triples (c, v, s) of positive integers satisfying c > v > s and c + v + s = 9. Then for each such triple, compute the number of assignments, which is the multinomial coefficient: 9! / (c! v! s!), since we're assigning flavors to distinct players (wait, yes, the problem says \"different assignments of flavors to players\", so each player is distinct, so yes, multinomial coefficient for the counts).\n", + "\n", + "So first, let's list all possible (c, v, s) with c > v > s ≥ 1, integers, sum to 9.\n", + "\n", + "Start with smallest possible s, which is 1 (since at least 1). Then v must be at least s + 1 = 2, c at least v + 1 = 3, so minimum sum for s=1 is 1+2+3=6, which is less than 9, so possible.\n", + "\n", + "s=1: then v + c = 8, with c > v > 1, so v ≥ 2, c = 8 - v > v ⇒ 8 - v > v ⇒ 8 > 2v ⇒ v < 4. So v < 4, and v > s=1, so v=2 or 3.\n", + "\n", + "Check v=2: c=8-2=6, check c > v: 6>2 yes, v > s: 2>1 yes. So (6,2,1)\n", + "\n", + "v=3: c=8-3=5, 5>3>1 yes, so (5,3,1)\n", + "\n", + "v=4: c=4, but c must be > v, so no, equal, not allowed.\n", + "\n", + "s=2: then v > 2, so v ≥ 3, c > v ≥ 3, so c ≥ 4, minimum sum 2+3+4=9, which is exactly 9! Let's check: s=2, v=3, c=4, sum=9, and 4>3>2 yes, perfect.\n", + "\n", + "s=2, v=4: then c=9-2-4=3, but c=3 < v=4, which violates c > v, so no. v must be less than c, so c=9 - s - v > v ⇒ 9 - 2 - v > v ⇒ 7 > 2v ⇒ v < 3.5, but v > s=2, so v ≥ 3, so v=3 is only possibility, which we have: (4,3,2)\n", + "\n", + "s=3: then v > 3, so v ≥4, c > v ≥4, so c ≥5, minimum sum 3+4+5=12 >9, too big. So no solutions for s≥3.\n", + "\n", + "Wait, let's check if we missed any for s=1: s=1, v=2, c=6; v=3, c=5; v=4, c=4 invalid; v=5, c=3 < v, invalid. Yes, only two for s=1.\n", + "\n", + "s=2: v must be >2, so v=3, c=4; v=4, c=3 < v invalid; v=5, c=2 < v, etc., so only (4,3,2)\n", + "\n", + "s=3: as above, too big. So total possible triples: (6,2,1), (5,3,1), (4,3,2). Let's confirm sums: 6+2+1=9, 5+3+1=9, 4+3+2=9, all good, and each satisfies c > v > s.\n", + "\n", + "Is there another one? Let's see, maybe (5,2,2)? But no, v must be > s, so can't have equal, and also c > v, so all strict inequalities, so no repeats in counts. So yes, only three triples.\n", + "\n", + "Now, for each triple, compute the number of assignments. Since players are distinct, for a given count of each flavor, the number of ways is the number of ways to choose which players get chocolate, then which get vanilla from the rest, then strawberry is fixed. So that's C(9,c) * C(9-c,v) * C(s,s) = 9!/(c!v!s!), which is the multinomial coefficient, correct.\n", + "\n", + "So let's compute each one by one.\n", + "\n", + "First triple: (c,v,s)=(6,2,1). So number of assignments: 9! / (6! 2! 1!) = (362880)/(720 * 2 * 1) = 362880 / 1440 = let's compute step by step: 9! = 362880, 6! = 720, so 9! / 6! = 9×8×7 = 504, then divide by 2! = 2, so 504 / 2 = 252, then divide by 1! = 1, so 252. Wait, yes, that's simpler: 9 choose 6 for chocolate, then 3 choose 2 for vanilla, then 1 for strawberry: C(9,6)=C(9,3)=84, C(3,2)=3, so 84×3=252, same result. Good.\n", + "\n", + "Second triple: (5,3,1). So 9! / (5! 3! 1!) = let's compute: 9! / 5! = 9×8×7×6 = 3024, then divide by 3! = 6, so 3024 / 6 = 504, then divide by 1! = 504. Alternatively, C(9,5)=126, C(4,3)=4, so 126×4=504, correct.\n", + "\n", + "Third triple: (4,3,2). 9! / (4! 3! 2!) = let's compute: 9! = 362880, 4!=24, 3!=6, 2!=2, so denominator=24×6×2=288, 362880 / 288. Let's divide step by step: 362880 / 24 = 15120, 15120 / 6 = 2520, 2520 / 2 = 1260. Alternatively, C(9,4)=126, C(5,3)=10, C(2,2)=1, so 126×10=1260, yes, that's easier. Good.\n", + "\n", + "Now, are there any other triples? Wait, let's double-check if we have all possible ordered triples where c > v > s ≥1, sum 9. Sometimes when listing, it's easy to miss, but let's list all possible partitions of 9 into 3 distinct positive integers where order matters for the counts but we have the strict inequality for the flavors, so we need to make sure we don't have permutations, but since the flavors are distinct (chocolate, vanilla, strawberry are different), the counts are assigned to specific flavors, so we don't have to worry about permuting the counts among flavors; the condition is specifically chocolate > vanilla > strawberry, so the counts must be in that order for those specific flavors. So yes, we just need the triples where first component is chocolate count, second vanilla, third strawberry, with c > v > s ≥1, sum 9. So we did that correctly by fixing s, then v, then c, with inequalities.\n", + "\n", + "Wait, let's list all possible triples of positive integers summing to 9 with all distinct, then see which have c > v > s. Total partitions of 9 into 3 distinct positive integers (unordered):\n", + "\n", + "Start with smallest number 1: then partition 8 into two distinct numbers >1, so possible pairs: (2,6), (3,5), (4,4) but 4,4 not distinct, so (1,2,6), (1,3,5)\n", + "\n", + "Smallest number 2: partition 7 into two distinct numbers >2, so (3,4), since 2+3+4=9, next would be (2,5,2) no, distinct, so only (2,3,4)\n", + "\n", + "Smallest number 3: 3+4+5=12>9, so no. So unordered partitions: {1,2,6}, {1,3,5}, {2,3,4}. Now, for each unordered partition, how many ordered assignments to flavors? But in our problem, the flavors have a specific order condition: chocolate > vanilla > strawberry, so for each unordered partition, there's exactly one way to assign the counts to the flavors to satisfy c > v > s: the largest count to chocolate, middle to vanilla, smallest to strawberry. So yes, exactly the three triples we found: for {1,2,6}, largest=6 (chocolate), middle=2 (vanilla), smallest=1 (strawberry); for {1,3,5}, largest=5 (chocolate), middle=3 (vanilla), smallest=1 (strawberry); for {2,3,4}, largest=4 (chocolate), middle=3 (vanilla), smallest=2 (strawberry). Perfect, that confirms we have all three possible count triples.\n", + "\n", + "So no other triples, since any other assignment would either have equal counts (which violates strict inequality) or not satisfy the order for the flavors. For example, if we had counts (5,2,2), but vanilla and strawberry equal, which isn't allowed (since vanilla > strawberry must hold, so they must be strictly greater, so counts must all be distinct, which we already considered in the partitions).\n", + "\n", + "So now, total number of assignments N is sum of the multinomial coefficients for each triple.\n", + "\n", + "So first triple: 252, second: 504, third: 1260. Let's add them up.\n", + "\n", + "252 + 504 = 756; 756 + 1260 = 2016. Wait, is that right? 252+504 is 756, 756+1260: 700+1200=1900, 56+60=116, so 1900+116=2016. Hmm, 2016.\n", + "\n", + "But wait, hold on a second, let's make sure we didn't misinterpret the problem. The problem says \"the number of players who chose chocolate was greater than the number of players who chose vanilla, which was greater than the number of players who chose strawberry\". So yes, c > v > s, which is exactly what we used. At least one of each, which we have (s ≥1, and since v > s, v ≥2, c > v ≥2, so c ≥3, all counts at least 1, good).\n", + "\n", + "But wait, is 2016 the total? Let's check the multinomial coefficients again to be sure, maybe miscalculated.\n", + "\n", + "First triple: 6,2,1. 9!/(6!2!1!) = (9×8×7×6!)/(6!×2×1) = (9×8×7)/2 = (504)/2 = 252. Correct.\n", + "\n", + "Second: 5,3,1. 9!/(5!3!1!) = (9×8×7×6×5!)/(5!×6×1) = (9×8×7×6)/6 = 9×8×7 = 504. Yes, that's simpler, the 6 cancels, so 504. Correct.\n", + "\n", + "Third: 4,3,2. 9!/(4!3!2!) = (9×8×7×6×5×4!)/(4!×6×2) = (9×8×7×6×5)/(6×2) = (9×8×7×5)/2 = (9×4×7×5) = 9×140 = 1260. Yes, that's right, 8/2=4, so 9×4=36, 36×7=252, 252×5=1260. Correct.\n", + "\n", + "Sum: 252 + 504 = 756; 756 + 1260 = 2016. So N=2016? Then 2016 mod 1000 is 16? But wait, that seems low, maybe I missed some triples?\n", + "\n", + "Wait, hold on! Wait a second, is it possible that when they say \"the number of players who chose chocolate was greater than the number who chose vanilla, which was greater than strawberry\", does that mean strictly greater, which we did, but maybe we need to check if there are other triples where maybe s=1, v=4, c=4? No, c must be greater than v, so c=4, v=4 is equal, not greater. s=1, v=5, c=3, but c=3 < v=5, which violates c > v. s=2, v=5, c=2, but c=2 < v=5 and s=2, so v > s but c < v, not satisfying c > v > s.\n", + "\n", + "Wait, another thought: maybe the problem allows for the counts to be in any order as long as chocolate > vanilla > strawberry, but we considered the counts assigned to specific flavors, which is correct because chocolate, vanilla, strawberry are distinct flavors, so the count for chocolate must be the largest, vanilla middle, strawberry smallest. So yes, only the three triples we have.\n", + "\n", + "But let's think differently: total number of ways with at least one of each flavor, without the inequality condition, is 3^9 - 3*2^9 + 3*1^9 by inclusion-exclusion, but that's not necessary, but just to check if our count is reasonable. But maybe not helpful.\n", + "\n", + "Wait, but let's list all possible ordered triples (c,v,s) with c + v + s =9, c,v,s ≥1 integers, c > v > s.\n", + "\n", + "Start with s=1:\n", + "\n", + "v must be at least 2, c=9-1-v=8-v > v ⇒ 8-v > v ⇒ v <4, so v=2,3 as before.\n", + "\n", + "v=2: c=6, so (6,2,1)\n", + "\n", + "v=3: c=5, (5,3,1)\n", + "\n", + "v=4: c=4, not >, v=5: c=3 < v, etc.\n", + "\n", + "s=2:\n", + "\n", + "v >2, so v≥3, c=9-2-v=7-v > v ⇒7-v >v ⇒v <3.5, so v=3 (since v≥3), c=4, so (4,3,2)\n", + "\n", + "v=4: c=3 < v, invalid\n", + "\n", + "s=3:\n", + "\n", + "v >3, v≥4, c=9-3-v=6-v >v ⇒6>2v ⇒v<3, but v≥4, impossible\n", + "\n", + "s=4: even bigger, sum too big.\n", + "\n", + "So yes, only three triples. So why do I feel like 2016 is maybe too small? Wait, but let's compute total assignments with all counts distinct and at least one each, then see how many satisfy c > v > s.\n", + "\n", + "Total number of assignments with all counts distinct: for each unordered partition into three distinct positive integers, multiply by the number of permutations for the flavors. But in our problem, we only want the specific permutation where chocolate is largest, vanilla middle, strawberry smallest, so for each unordered partition of three distinct numbers, there's exactly one assignment to flavors satisfying c > v > s, which is what we did.\n", + "\n", + "How many unordered partitions into three distinct positive integers summing to 9? As we listed: {1,2,6}, {1,3,5}, {2,3,4}, so three partitions, each with 3! =6 permutations for assigning to flavors, but we only want one permutation per partition (the one where largest→chocolate, middle→vanilla, smallest→strawberry), so total assignments for our problem is sum over each partition of (9!/(a!b!c!)) where a,b,c are the partition numbers in order for the specific flavor assignment.\n", + "\n", + "Which is exactly what we computed: for {1,2,6}, the assignment to flavors with c=6,v=2,s=1 is 9!/(6!2!1!)=252; if we had assigned differently, say c=2,v=6,s=1, that would not satisfy c > v, so we don't count that, which is correct.\n", + "\n", + "So yes, only the three specific assignments per partition where the counts are in the correct order for the flavors.\n", + "\n", + "Wait, but let's check if for the partition {2,3,4}, the multinomial coefficient is 1260, which is correct, and that's the only way to assign those counts to flavors with c > v > s (i.e., 4,3,2 for C,V,S).\n", + "\n", + "Is there a case where two counts are equal? But the problem says \"greater than\", so strict inequalities, so no equal counts allowed, which we accounted for.\n", + "\n", + "Wait, but let's check the problem statement again: \"the number of players who chose chocolate was greater than the number of players who chose vanilla, which was greater than the number of players who chose strawberry\". So yes, chocolate > vanilla and vanilla > strawberry, so by transitivity, chocolate > strawberry, all strict, so all counts distinct, and ordered as C > V > S.\n", + "\n", + "So our triples are correct.\n", + "\n", + "But then total N=252+504+1260=2016. 2016 divided by 1000 is 2 with remainder 16. But wait, is that possible? Maybe, but let me check once more the arithmetic for the multinomial coefficients, because sometimes when doing quick calculations, mistakes happen.\n", + "\n", + "First triple: 6 chocolate, 2 vanilla, 1 strawberry. Number of ways: choose 6 players for chocolate: C(9,6)=84. Then from remaining 3, choose 2 for vanilla: C(3,2)=3. Last 1 is strawberry: 1. So 84*3=252. Correct.\n", + "\n", + "Second triple: 5C, 3V, 1S. C(9,5)=126, C(4,3)=4, 126*4=504. Correct.\n", + "\n", + "Third triple: 4C, 3V, 2S. C(9,4)=126, C(5,3)=10, 126*10=1260. Correct. 126*10 is 1260, yes.\n", + "\n", + "252+504: 200+500=700, 52+4=56, total 756. 756+1260: 700+1200=1900, 56+60=116, 1900+116=2016. Yes, 2016.\n", + "\n", + "Wait, but maybe the problem is that \"assignments of flavors to players\" – are the players distinguishable? Yes, of course, each player is a distinct person, so assigning chocolate to player 1 vs player 2 is different, so multinomial coefficient is correct for distinct players.\n", + "\n", + "Is there a possibility that we missed a triple where, say, s=1, v=4, c=4? But c must be greater than v, so 4 is not greater than 4, so no. s=1, v=1, c=7? But v must be greater than s, so v=1 not greater than s=1, equal, invalid. s=2, v=2, c=5? v not greater than s, equal, invalid. s=3, v=3, c=3? All equal, invalid, and also sum=9, but no strict inequalities.\n", + "\n", + "Another check: total number of ways with c > v > s ≥1, sum 9. Let's list all possible c first, since c is the largest, so c must be at least ceiling(9/3)+1? Wait, for three distinct positive integers, the largest must be at least 4 (since 2+3+4=9), and maximum c is 9-1-2=6 (since s≥1, v≥2, so c≤6). So c can be 4,5,6.\n", + "\n", + "c=6: then v + s=3, with v > s ≥1, so possible (v,s)=(2,1), since 2+1=3, and 2>1. That's the first triple.\n", + "\n", + "c=5: v + s=4, v > s ≥1, so possible (v,s)=(3,1) because 3+1=4, 3>1; (2,2) invalid, so only (3,1). That's second triple.\n", + "\n", + "c=4: v + s=5, v > s ≥1, and v < c=4, so v ≤3, s=5-v < v ⇒5-v < v ⇒5 < 2v ⇒v >2.5, so v≥3, and v <4, so v=3, then s=2. Which is (4,3,2), third triple.\n", + "\n", + "c=3: then v <3, s vanilla count > strawberry count, so the counts for each flavor must satisfy that inequality, so chocolate is highest, vanilla middle, strawberry lowest, so our assignment is correct.\n", + "\n", + "Wait, but let's think of a smaller case to test. Suppose 3 players, each flavor at least one, so only one way per flavor, but c > v > s, but with 3 players, each at least 1, so counts must be 1,1,1, but can't have strict inequalities, so N=0, which makes sense. For 4 players: c > v > s ≥1, sum=4. Possible? s=1, v=2, c=1? No, c must be >v=2, so c≥3, sum=3+2+1=6>4, impossible, so N=0. For 5 players: s=1, v=2, c=2 invalid; s=1, v=2, c=2 no; s=1, v=3, c=1 invalid; minimum sum 1+2+3=6>5, so N=0. For 6 players: 1+2+3=6, so counts (3,2,1), so multinomial 6!/(3!2!1!)=60, and that's the only triple, so N=60. Let's check: chocolate=3, vanilla=2, strawberry=1, yes, 3>2>1, sum=6, at least one each. Correct, and that's the only one, so N=60 for 6 players, which seems right.\n", + "\n", + "So for 9 players, our calculation seems consistent with smaller cases. So maybe 2016 is correct, so remainder 16. But wait, 2016 is less than 1000? No, 2016 is more than 1000, 2016-2*1000=16, yes, remainder 16.\n", + "\n", + "But wait, hold on! Wait a second, I just realized: when we say \"assignments of flavors to players\", is there a possibility that the problem considers the ice cream flavors as indistinct except for the counts, but no, players are distinct, so each player's choice matters, so yes, multinomial is correct. For example, for two players, one chocolate one vanilla, there are 2 assignments, which is 2!/(1!1!)=2, correct.\n", + "\n", + "Another check: total number of assignments with at least one of each flavor is 3^9 - 3*2^9 + 3*1^9 = 19683 - 3*512 + 3 = 19683 - 1536 + 3 = 18150. Then the number of assignments where c > v > s should be less than that, which 2016 is, and also, for three distinct counts, the number of assignments where counts are all distinct and satisfy c > v > s should be equal to (total distinct count assignments)/6, since for each set of three distinct counts, there are 6 permutations of the flavors, and only one permutation satisfies c > v > s. Wait, is that true?\n", + "\n", + "Let's see: total assignments with all counts distinct (i.e., c, v, s all different, each at least 1). For each such assignment, the counts are three distinct numbers, so there are 3! =6 ways to assign those counts to the three flavors. Only one of those 6 assignments will have chocolate > vanilla > strawberry (the one where largest count→chocolate, middle→vanilla, smallest→strawberry). So yes, if we let T be total assignments with all counts distinct and at least one each, then N = T / 6.\n", + "\n", + "Let's compute T for our problem and see if T/6=2016, so T=12096.\n", + "\n", + "Compute T: total assignments with at least one each minus assignments with at least two counts equal.\n", + "\n", + "Total with at least one each: 18150 as above.\n", + "\n", + "Assignments with at least two counts equal: use inclusion-exclusion for equal counts.\n", + "\n", + "Case 1: c = v ≠ s\n", + "\n", + "Case 2: c = s ≠ v\n", + "\n", + "Case 3: v = s ≠ c\n", + "\n", + "Case 4: c = v = s\n", + "\n", + "First, Case 4: c = v = s = 3, since 9/3=3, so only one count triple: (3,3,3). Number of assignments: 9!/(3!3!3!)=1680.\n", + "\n", + "Case 1: c = v ≠ s, c + v + s =9 ⇒2c + s=9, s≠c, s≥1, c≥1.\n", + "\n", + "s=9-2c ≥1 ⇒9-2c≥1 ⇒2c≤8 ⇒c≤4.\n", + "\n", + "c=1: s=7, s≠c yes, counts (1,1,7)\n", + "\n", + "c=2: s=5, (2,2,5)\n", + "\n", + "c=3: s=3, but s=c, which is Case 4, so exclude\n", + "\n", + "c=4: s=1, (4,4,1)\n", + "\n", + "c=5: s=9-10=-1 invalid\n", + "\n", + "So for Case 1: c=v, s≠c, so triples (1,1,7),(2,2,5),(4,4,1). For each, number of assignments: 9!/(c!c!s!) for each triple.\n", + "\n", + "(1,1,7): 9!/(1!1!7!)=36\n", + "\n", + "(2,2,5): 9!/(2!2!5!)= 362880/(2*2*120)=362880/480=756\n", + "\n", + "(4,4,1): same as (1,1,7) by symmetry, 9!/(4!4!1!)=36\n", + "\n", + "So total for Case 1: 36+756+36=828\n", + "\n", + "Case 2: c = s ≠ v, similar to Case 1 by symmetry (since c and s are symmetric in the problem for this case, but actually, for the counts, it's the same as Case 1 because we're just relabeling flavors, but wait no, for the count triples, c=s≠v, so 2c + v=9, v≠c, same equations as Case 1, so same number of triples: (1,7,1),(2,5,2),(4,1,4), but when counting assignments, for each triple, it's 9!/(c!v!s!) which is same as Case 1 for the counts, so yes, same numbers: 36+756+36=828\n", + "\n", + "Case 3: v = s ≠ c, same thing: 2v + c=9, c≠v, so triples (7,1,1),(5,2,2),(1,4,4), assignments same as above: 36+756+36=828\n", + "\n", + "Now, Case 4: c=v=s=3, assignments=1680, as above.\n", + "\n", + "Now, by inclusion-exclusion, total assignments with at least two counts equal = (Case1 + Case2 + Case3) - 2*Case4? Wait no, inclusion-exclusion for \"at least two equal\" is sum of pairwise equal minus twice the all three equal? Wait, no: when we count Case1, Case2, Case3, each includes the all three equal case, so for example, Case1 (c=v) includes c=v=s, same for Case2 and Case3. So total number of assignments where at least two counts are equal is (Case1 + Case2 + Case3) - 2*Case4, because the all three equal case was counted three times in Case1+Case2+Case3, but we only want to count it once for \"at least two equal\", so subtract 2*Case4.\n", + "\n", + "Wait, actually, standard inclusion-exclusion for union of three sets: |A∪B∪C|=|A|+|B|+|C|-|A∩B|-|A∩C|-|B∩C|+|A∩B∩C|, where A=c=v, B=c=s, C=v=s.\n", + "\n", + "Then |A∩B|=c=v and c=s ⇒c=v=s, same for all intersections, so |A∩B|=|A∩C|=|B∩C|=Case4=1680, and |A∩B∩C|=Case4=1680.\n", + "\n", + "Thus |A∪B∪C|= (828+828+828) - (1680+1680+1680) + 1680 = 2484 - 5040 + 1680 = (2484 + 1680) - 5040 = 4164 - 5040 = -876? That can't be, negative number, which means I messed up the counts for Case1, Case2, Case3.\n", + "\n", + "Ah, right! When we count Case1: c=v, regardless of s, so including s=c, so |A|=number of assignments with c=v, which includes c=v=s. So for Case1 (c=v), we need to compute all assignments where c=v, so 2c + s=9, s≥1, c≥1, no restriction s≠c yet.\n", + "\n", + "So for c=v, 2c + s=9, s=9-2c≥1 ⇒c≤4 as before, c=1 to 4:\n", + "\n", + "c=1: s=7, assignments=9!/(1!1!7!)=36\n", + "\n", + "c=2: s=5, 9!/(2!2!5!)=756\n", + "\n", + "c=3: s=3, 9!/(3!3!3!)=1680\n", + "\n", + "c=4: s=1, 9!/(4!4!1!)=36\n", + "\n", + "So total |A|=36+756+1680+36=2508\n", + "\n", + "Similarly, |B|=c=s, so 2c + v=9, same counts: c=1,v=7; c=2,v=5; c=3,v=3; c=4,v=1, so same numbers: 36+756+1680+36=2508\n", + "\n", + "|C|=v=s, 2v + c=9, same: v=1,c=7; v=2,c=5; v=3,c=3; v=4,c=1, so |C|=2508\n", + "\n", + "Now, |A∩B|=c=v and c=s ⇒c=v=s, so only c=v=s=3, assignments=1680, same for |A∩C| and |B∩C|, all equal to 1680\n", + "\n", + "|A∩B∩C|=same as above, 1680\n", + "\n", + "Thus |A∪B∪C|=2508*3 - 1680*3 + 1680 = 7524 - 5040 + 1680 = (7524 + 1680) - 5040 = 9204 - 5040 = 4164\n", + "\n", + "Yes, that makes sense, positive number.\n", + "\n", + "Total assignments with at least one of each flavor: 3^9 - 3*2^9 + 3*1^9 = 19683 - 3*512 + 3 = 19683 - 1536 + 3 = 18150, correct.\n", + "\n", + "Total assignments with all counts distinct (and at least one each) = total with at least one each - |A∪B∪C| = 18150 - 4164 = 13986\n", + "\n", + "Now, if all counts are distinct, then for each such assignment, the three counts are distinct numbers, so there are 3! =6 ways to assign those counts to the three flavors (chocolate, vanilla, strawberry). Only one of those 6 assignments will satisfy chocolate > vanilla > strawberry (the one where largest count→chocolate, middle→vanilla, smallest→strawberry).\n", + "\n", + "Therefore, N should be total distinct count assignments / 6 = 13986 / 6 = 2331.\n", + "\n", + "Wait a second! Now this is different from our previous 2016. So which one is correct? There's a contradiction here, so we must have made a mistake in one of the methods.\n", + "\n", + "Ah! Here's the key: when we say \"all counts distinct\", does that include cases where one of the counts is zero? No, because total with at least one each is already subtracted the cases with any flavor missing, so total distinct count assignments (with all counts ≥1 and distinct) is 13986, as above.\n", + "\n", + "But let's check with the small case where n=6 players, at least one each, so total assignments with at least one each: 3^6 - 3*2^6 + 3*1^6 = 729 - 3*64 + 3 = 729 - 192 + 3 = 540.\n", + "\n", + "Total assignments with all counts distinct: for n=6, possible counts must be distinct positive integers summing to 6, which is only 1,2,3. So number of assignments with all counts distinct: for each permutation of (1,2,3) to flavors, 6!/(1!2!3!)=60, and there are 6 permutations, so 6*60=360. Then total distinct count assignments=360, which should equal total with at least one each minus assignments with at least two equal.\n", + "\n", + "Assignments with at least two equal for n=6: |A∪B∪C|, where A=c=v, etc.\n", + "\n", + "|A|=c=v, 2c + s=6, s≥1, c≥1:\n", + "\n", + "c=1,s=4; c=2,s=2; c=3,s=0 invalid (since s≥1 for total with at least one each? Wait no, when we compute |A| for the union, we need to consider all assignments where c=v, regardless of s, but in the total with at least one each, s≥1, so for |A| in the context of total with at least one each, s≥1, so c=1,s=4; c=2,s=2; c=3,s=0 invalid, so |A|=6!/(1!1!4!)+6!/(2!2!2!)=15 + 90=105\n", + "\n", + "Similarly |B|=|C|=105\n", + "\n", + "|A∩B|=c=v=s=2, since 6/3=2, so 6!/(2!2!2!)=90\n", + "\n", + "Thus |A∪B∪C|=105*3 - 90*3 + 90=315 - 270 + 90=135\n", + "\n", + "Total with at least one each=540, so distinct count assignments=540-135=405? But wait, we know for n=6, only possible distinct counts are 1,2,3, so number of assignments with distinct counts should be 6*60=360, but 540-135=405≠360. Contradiction, so where's the mistake?\n", + "\n", + "Ah! When we compute |A| for c=v, we need to include assignments where s=0? No, because in the total with at least one each, we already excluded assignments with any flavor missing, so when computing |A| (c=v) within the total with at least one each, s must be ≥1, c≥1, v≥1, so for n=6, c=v, s=6-2c ≥1 ⇒c≤2.5, so c=1,s=4; c=2,s=2; c=3,s=0 invalid, so yes, |A|=C(6,1,1,4)+C(6,2,2,2)=15+90=105, correct.\n", + "\n", + "But total assignments with at least one each: 540, which is correct (3^6 - 3*2^6 + 3=729-192+3=540).\n", + "\n", + "Now, assignments with all counts distinct: for counts to be distinct and each ≥1, sum=6, only 1,2,3. Number of assignments: for each permutation of flavors to counts, 6!/(1!2!3!)=60, and there are 6 permutations (3! ways to assign 1,2,3 to C,V,S), so 6*60=360. Correct.\n", + "\n", + "Now, assignments with at least two equal counts (and all counts ≥1): total with at least one each - distinct count assignments=540-360=180.\n", + "\n", + "But using inclusion-exclusion: |A∪B∪C|=105+105+105 - 90-90-90 + 90=315-270+90=135, which is not 180. So where's the error in inclusion-exclusion?\n", + "\n", + "Ah! Because when we define A as c=v, but in the context of all assignments (including those with s=0), but we are only considering assignments with at least one each, so actually, when computing |A| for the subset of assignments with at least one each, we need to ensure s≥1, which we did, but let's compute |A| (c=v, all counts ≥1) for n=6:\n", + "\n", + "c=v, s=6-2c ≥1, so c=1,s=4; c=2,s=2; c=3,s=0 invalid. So assignments where c=v and s≥1: for c=1,v=1,s=4: number of assignments is 6!/(1!1!4!)=30? Wait no! Wait, multinomial coefficient: for counts c,v,s, it's 6!/(c!v!s!), yes, so for c=1,v=1,s=4: 6!/(1!1!4!)=720/(1*1*24)=30, not 15. Oh! Here's the mistake! C(6,1,1,4) is 6!/(1!1!4!)=30, yes, because choosing 1 for C, 1 for V, 4 for S: C(6,1)*C(5,1)=6*5=30, correct. Earlier I said 15, which is wrong; C(6,1,1,4) is not C(6,4), it's C(6,1) for C, then C(5,1) for V, so 6*5=30, yes.\n", + "\n", + "Similarly, c=2,v=2,s=2: 6!/(2!2!2!)=720/8=90, correct.\n", + "\n", + "So |A|=30+90=120 for n=6, c=v, all counts ≥1.\n", + "\n", + "Similarly |B|=|C|=120.\n", + "\n", + "|A∩B|=c=v=s=2, which is 90, correct.\n", + "\n", + "Thus |A∪B∪C|=120*3 - 90*3 + 90=360 - 270 + 90=180, which matches total with at least one each (540) minus distinct count assignments (360)=180. Perfect, so earlier mistake was in the multinomial coefficient for the equal counts case: for c=v=1, s=4, it's 6!/(1!1!4!)=30, not 15. I confused it with combinations where order doesn't matter, but for distinct players, it's multinomial.\n", + "\n", + "Okay, so going back to n=9, let's correctly compute |A| for c=v (all counts ≥1), so 2c + s=9, s≥1, c≥1, so s=9-2c≥1 ⇒c≤4, c=1,2,3,4:\n", + "\n", + "c=1: s=7, assignments=9!/(1!1!7!)=362880/(1*1*5040)=72? Wait no: 9!/(1!1!7!)= (9×8×7!)/(1×1×7!)=72, yes! 9×8=72, correct. Earlier for n=6, c=1,v=1,s=4: 6×5=30, which is 6!/(1!1!4!)=30, yes.\n", + "\n", + "c=2: s=5, 9!/(2!2!5!)= (362880)/(2×2×120)=362880/480=756, correct as before.\n", + "\n", + "c=3: s=3, 9!/(3!3!3!)=1680, correct.\n", + "\n", + "c=4: s=1, 9!/(4!4!1!)= same as c=1,s=7, which is 72, yes, because 9!/(4!4!1!)= (9×8×7×6×5×4!)/(4!×24×1)= (9×8×7×6×5)/24= (9×7×6×5)/3=9×7×10=630? Wait no, wait 4! is 24, so 9×8×7×6×5=15120, 15120/24=630? Wait no, 9!/(4!4!1!)= (9×8×7×6×5×4!)/(4!×4!×1)= (9×8×7×6×5)/(24)= (9×7×6×5)/3=9×7×10=630? Wait 8/24=1/3, yes, so 9×7×6×5 /3=9×7×2×5=630. But earlier for c=1,s=7: 9!/(1!1!7!)=9×8=72, which is correct, because choosing 1 for C, 1 for V, rest for S: C(9,1)*C(8,1)=9*8=72.\n", + "\n", + "For c=4,v=4,s=1: choosing 4 for C, 4 for V, 1 for S: C(9,4)*C(5,4)=126*5=630, yes! That's right, I forgot earlier when I calculated for the first triple (6,2,1), C(9,6)*C(3,2)=84*3=252, which is correct, so for c=4,v=4,s=1: C(9,4)*C(5,4)=126*5=630, yes, not 36. My mistake earlier was in the n=6 case for c=1,v=1,s=4: C(6,1)*C(5,1)=30, correct, so for n=9, c=1,v=1,s=7: C(9,1)*C(8,1)=72, correct; c=4,v=4,s=1: C(9,4)*C(5,4)=126*5=630, yes, that's right, I incorrectly calculated 9!/(4!4!1!) as 36 before, which was wrong. 9!/(4!4!1!)= (362880)/(24*24*1)=362880/576=630, yes, 576*600=345600, 576*30=17280, so 345600+17280=362880, so 630, correct.\n", + "\n", + "Okay, let's redo the inclusion-exclusion for n=9 correctly, now that we know multinomial coefficients.\n", + "\n", + "First, total assignments with at least one of each flavor: 3^9 - 3*2^9 + 3*1^9 = 19683 - 3*512 + 3 = 19683 - 1536 + 3 = 18150, correct.\n", + "\n", + "Now, define:\n", + "\n", + "A: assignments where chocolate = vanilla (c=v), all counts ≥1\n", + "\n", + "B: assignments where chocolate = strawberry (c=s), all counts ≥1\n", + "\n", + "C: assignments where vanilla = strawberry (v=s), all counts ≥1\n", + "\n", + "Compute |A|: c=v, so 2c + s=9, s=9-2c ≥1 ⇒c≤4, c=1,2,3,4\n", + "\n", + "c=1: s=7, assignments=9!/(1!1!7!)=72 (as C(9,1)*C(8,1)=72)\n", + "\n", + "c=2: s=5, 9!/(2!2!5!)= (9×8×7×6×5!)/(2×2×120)= (3024)/240=12.6? No, better: C(9,2)*C(7,2)=36*21=756, yes, correct.\n", + "\n", + "c=3: s=3, 9!/(3!3!3!)=1680, correct (C(9,3)*C(6,3)=84*20=1680)\n", + "\n", + "c=4: s=1, 9!/(4!4!1!)=C(9,4)*C(5,4)=126*5=630, correct\n", + "\n", + "c=5: s=9-10=-1 invalid, so stop.\n", + "\n", + "Thus |A|=72 + 756 + 1680 + 630 = let's add: 72+756=828; 828+1680=2508; 2508+630=3138\n", + "\n", + "Similarly, |B|=c=s, so 2c + v=9, v≥1, c≥1, same counts: c=1,v=7; c=2,v=5; c=3,v=3; c=4,v=1, so assignments same as |A|: 3138\n", + "\n", + "|C|=v=s, so 2v + c=9, c≥1, v≥1, same counts: v=1,c=7; v=2,c=5; v=3,c=3; v=4,c=1, so |C|=3138\n", + "\n", + "Now, intersections:\n", + "\n", + "|A∩B|=c=v and c=s ⇒c=v=s, so 3c=9 ⇒c=3, assignments=1680, correct\n", + "\n", + "Similarly, |A∩C|=c=v and v=s ⇒c=v=s=3, 1680\n", + "\n", + "|B∩C|=c=s and v=s ⇒c=v=s=3, 1680\n", + "\n", + "|A∩B∩C|=same, 1680\n", + "\n", + "Now, |A∪B∪C|=|A|+|B|+|C| - |A∩B| - |A∩C| - |B∩C| + |A∩B∩C| = 3138*3 - 1680*3 + 1680 = 9414 - 5040 + 1680 = (9414 + 1680) - 5040 = 11094 - 5040 = 6054\n", + "\n", + "Now, total assignments with at least one of each flavor: 18150\n", + "\n", + "Thus, total assignments with all counts distinct (and each ≥1) = total with at least one each - |A∪B∪C| = 18150 - 6054 = 12096\n", + "\n", + "Ah! Now this matches the earlier wrong calculation where I thought T=12096, but then I miscalculated |A| before, but now with correct |A|=3138, we get distinct count assignments=12096.\n", + "\n", + "Now, for assignments with all counts distinct, the three counts are distinct positive integers summing to 9, so for each such assignment, the counts can be permuted among the three flavors in 3! =6 ways. Only one of those 6 permutations will satisfy chocolate > vanilla > strawberry (i.e., largest count→chocolate, middle→vanilla, smallest→strawberry).\n", + "\n", + "Therefore, N = total distinct count assignments / 6 = 12096 / 6 = 2016\n", + "\n", + "Yes! That's exactly what we calculated initially by listing the triples and summing the multinomial coefficients. So the inclusion-exclusion method confirms that N=2016.\n", + "\n", + "Earlier, when I thought there was a contradiction, it was because I miscalculated the multinomial coefficients for the equal count cases, but now with correct calculations, both methods agree: direct count of valid triples gives 2016, and total distinct count assignments divided by 6 also gives 2016.\n", + "\n", + "Let's verify with the n=6 case to be sure:\n", + "\n", + "n=6, total with at least one each=540\n", + "\n", + "|A|=c=v, 2c+s=6, s≥1:\n", + "\n", + "c=1,s=4: C(6,1)*C(5,1)=30\n", + "\n", + "c=2,s=2: C(6,2)*C(4,2)=15*6=90\n", + "\n", + "c=3,s=0 invalid, so |A|=30+90=120\n", + "\n", + "Similarly |B|=|C|=120\n", + "\n", + "|A∩B|=c=v=s=2: 90\n", + "\n", + "|A∪B∪C|=120*3 - 90*3 + 90=360-270+90=180\n", + "\n", + "Distinct count assignments=540-180=360\n", + "\n", + "N=360/6=60, which is correct (only triple (3,2,1) for c>v>s, multinomial 60, which matches).\n", + "\n", + "Perfect, so for n=6, it works, and for n=9, our direct count was correct, and inclusion-exclusion confirms it.\n", + "\n", + "So why did I doubt it earlier? Because I miscalculated the multinomial coefficients in the inclusion-exclusion step, but now it's consistent.\n", + "\n", + "So going back, N=2016, so 2016 mod 1000=16.\n", + "\n", + "But wait, the problem says \"the number of different assignments of flavors to players that meet these conditions\". We have confirmed through two methods that N=2016, so remainder when divided by 1000 is 16.\n", + "\n", + "But just to make 100% sure, let's list all possible triples again with their correct multinomial coefficients:\n", + "\n", + "1. (6,2,1): 9!/(6!2!1!)= (9×8×7)/2=252 ✔️\n", + "\n", + "2. (5,3,1): 9!/(5!3!1!)= (9×8×7×6)/6=504 ✔️\n", + "\n", + "3. (4,3,2): 9!/(4!3!2!)= (9×8×7×6×5)/(24×2)= (15120)/48=315? No, wait no: 9!/(4!3!2!)= (362880)/(24×6×2)=362880/288=1260 ✔️, yes, 288×1200=345600, 288×60=17280, 345600+17280=362880, so 1260.\n", + "\n", + "252+504=756, 756+1260=2016. Yes.\n", + "\n", + "Another way: for (4,3,2), number of ways is 9 choose 4 for chocolate, then 5 choose 3 for vanilla, then 2 choose 2 for strawberry: C(9,4)=126, C(5,3)=10, 126×10=1260, correct.\n", + "\n", + "Yes, all correct.\n", + "\n", + "So the total number is indeed 2016, so 2016 divided by 1000 is 2*1000=2000, remainder 16.\n", + "\n", + "I think the key was realizing that the direct count was correct, and the inclusion-exclusion later confirmed it, after fixing calculation errors. Initially, I was worried because 2016 seemed small, but for distinct counts with strict inequalities, it's reasonable, and the small case checks out.\n", + "\n", + "So the remainder when N is divided by 1000 is 16.\n", + "\n", + "\n", + "To solve the problem, we are given that 9 baseball players each choose one of three flavors: chocolate (C), vanilla (V), or strawberry (S). The constraints are:\n", + "\n", + "- At least one player chooses each flavor.\n", + "- The number of players who chose **chocolate** is **greater than** the number who chose **vanilla**, which in turn is **greater than** the number who chose **strawberry**.\n", + "\n", + "Let $ c, v, s $ represent the counts of players choosing chocolate, vanilla, and strawberry respectively. Then:\n", + "\n", + "$$\n", + "c + v + s = 9 \\quad \\text{with} \\quad c > v > s \\geq 1\n", + "$$\n", + "\n", + "---\n", + "\n", + "### Step 1: Find all valid integer triples $(c, v, s)$\n", + "\n", + "We need to find all ordered triples of positive integers such that $ c > v > s $ and $ c + v + s = 9 $. Since all values must be distinct and strictly decreasing, we can systematically list them:\n", + "\n", + "- Start with the smallest possible value for $ s $, then determine possible $ v $ and $ c $ accordingly.\n", + "\n", + "#### Case $ s = 1 $:\n", + "- $ v + c = 8 $\n", + "- $ v > 1 $, so $ v \\geq 2 $\n", + "- $ c > v \\Rightarrow c = 8 - v > v \\Rightarrow v < 4 $\n", + "\n", + "So possible values for $ v $: 2, 3 \n", + "- $ v = 2 \\Rightarrow c = 6 $ → (6, 2, 1) \n", + "- $ v = 3 \\Rightarrow c = 5 $ → (5, 3, 1)\n", + "\n", + "#### Case $ s = 2 $:\n", + "- $ v + c = 7 $\n", + "- $ v > 2 \\Rightarrow v \\geq 3 $\n", + "- $ c > v \\Rightarrow c = 7 - v > v \\Rightarrow v < 3.5 $\n", + "\n", + "So only $ v = 3 \\Rightarrow c = 4 $ → (4, 3, 2)\n", + "\n", + "#### Case $ s = 3 $:\n", + "- Minimum sum would be $ 3 + 4 + 5 = 12 > 9 $, so no solutions.\n", + "\n", + "Thus, the only valid triples are:\n", + "- (6, 2, 1)\n", + "- (5, 3, 1)\n", + "- (4, 3, 2)\n", + "\n", + "---\n", + "\n", + "### Step 2: Compute the number of assignments for each triple\n", + "\n", + "Each assignment corresponds to assigning specific players to each flavor. Since the players are **distinct**, the number of ways to assign the counts is given by the multinomial coefficient:\n", + "\n", + "$$\n", + "\\frac{9!}{c! \\cdot v! \\cdot s!}\n", + "$$\n", + "\n", + "#### For (6, 2, 1):\n", + "$$\n", + "\\frac{9!}{6! \\cdot 2! \\cdot 1!} = \\frac{362880}{720 \\cdot 2 \\cdot 1} = \\frac{362880}{1440} = 252\n", + "$$\n", + "\n", + "#### For (5, 3, 1):\n", + "$$\n", + "\\frac{9!}{5! \\cdot 3! \\cdot 1!} = \\frac{362880}{120 \\cdot 6 \\cdot 1} = \\frac{362880}{720} = 504\n", + "$$\n", + "\n", + "#### For (4, 3, 2):\n", + "$$\n", + "\\frac{9!}{4! \\cdot 3! \\cdot 2!} = \\frac{362880}{24 \\cdot 6 \\cdot 2} = \\frac{362880}{288} = 1260\n", + "$$\n", + "\n", + "---\n", + "\n", + "### Step 3: Total number of valid assignments\n", + "\n", + "$$\n", + "N = 252 + 504 + 1260 = 2016\n", + "$$\n", + "\n", + "Now compute the remainder when $ N $ is divided by 1000:\n", + "\n", + "$$\n", + "2016 \\mod 1000 = 16\n", + "$$\n", + "\n", + "---\n", + "\n", + "### Final Answer\n", + "\n", + "$$\n", + "\\boxed{16}\n", + "$$" + ] + } + ], + "source": [ + "math_prompt = \"\"\"\n", + "The 9 members of a baseball team went to an ice cream parlor after their game. Each player had a singlescoop cone of chocolate, vanilla, or strawberry ice cream. At least one player chose each flavor, and the number of players who chose chocolate was greater than the number of players who chose vanilla, which was greater than the number of players who chose strawberry. Let $N$ be the number of different assignments of flavors to players that meet these conditions. Find the remainder when $N$ is divided by 1000.\n", + "\n", + "Please provide your answer in boxed format.\n", + "\"\"\"\n", + "\n", + "response = client.chat.completions.create(\n", + " model=\"qwen/qwen3-next-80b-a3b-thinking\",\n", + " messages=[{\"role\":\"user\",\"content\":math_prompt}],\n", + " top_p=0.7,\n", + " temperature=0.6,\n", + " stream=True\n", + ")\n", + "\n", + "for chunk in response:\n", + " reasoning = getattr(chunk.choices[0].delta, \"reasoning_content\", None)\n", + " if reasoning:\n", + " print(reasoning, end=\"\")\n", + " if chunk.choices[0].delta.content is not None:\n", + " print(chunk.choices[0].delta.content, end=\"\")" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "7kk-fkLQ40Nd" + }, + "source": [ + "## Building a Simple Note Taking Agent Powered by the `Qwen3 Next` NIM.\n", + "\n", + "Next, we'll look at a very simple example of how we can build Agents leveraging the NVIDIA-hosted NIM API powered by NVIDIA NIM.\n", + "\n", + "In order to get started, we need to grab `openai-agents` SDK\n", + "\n", + "> NOTE: Instructions on how you can download and run the NIM are available [here](https://build.nvidia.com/qwen/qwen3-next-80b-a3b-thinking/deploy)!" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "6dynEYLiU3gb", + "outputId": "134b8461-b028-4e71-e2bc-759e1014d5a2" + }, + "outputs": [], + "source": [ + "!pip install -qU \"openai-agents[litellm]\"" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "m4MrPd4W5nGr" + }, + "source": [ + "Next, we can create our `AsyncOpenAI` client through the same process we used for our `OpenAI` client." + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": { + "id": "1d24oWmGVQuG" + }, + "outputs": [], + "source": [ + "from openai import AsyncOpenAI\n", + "\n", + "client = AsyncOpenAI(\n", + " base_url = \"https://integrate.api.nvidia.com/v1\",\n", + " api_key = os.environ[\"NVIDIA_API_KEY\"]\n", + ")" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "5DWGSWkN5u_o" + }, + "source": [ + "To streamline note-taking, we will create two function tools:\n", + "- Write Notes: Takes filename and text input, and writes it into a .txt file in plain text format.\n", + "- Display Notes: This function displays the stored content, making it easy to review notes at any time." + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": { + "id": "mPWHDzD4kQB1" + }, + "outputs": [], + "source": [ + "from agents import function_tool\n", + "import os\n", + "\n", + "@function_tool\n", + "async def display_file(filename: str) -> str:\n", + " \"\"\"Read and return the contents of a file.\"\"\"\n", + " if not os.path.exists(filename):\n", + " return f\"File '{filename}' not found.\"\n", + " print(f\"[INFO] Reading file: {filename}\")\n", + " with open(filename, \"r\", encoding=\"utf-8\") as f:\n", + " return f.read()\n", + "\n", + "@function_tool\n", + "def write_file(filename: str, content: str) -> str:\n", + " \"\"\"Write content to a file (append).\"\"\"\n", + " print(f\"[INFO] Writing to file: {filename}\")\n", + " with open(filename, \"a\", encoding=\"utf-8\") as f:\n", + " f.write(content + '\\n')\n", + " return f\"Content written to '{filename}'.\"\n" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "3frz3WRq8TcT" + }, + "source": [ + "Next up, we'll create the Agent itself. For more details, you can explore the OpenAI Agents SDK [here](https://github.com/openai/openai-agents-python/tree/main). In this notebook, we'll focus on integrating with the NVIDIA-hosted NIM API.\n", + "\n", + "The key component for smooth integration is\n", + "```\n", + "OpenAIChatCompletionsModel(model=\"\", ...)\n", + "```\n", + "\n", + "Since NVIDIA NIM exposes the ChatCompletions API for the model - you can seamlessly integrate these models whether locally or through the NVIDIA-hosted NIM API." + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": { + "id": "gAXUJiS3VZ_4" + }, + "outputs": [], + "source": [ + "from agents import Agent, OpenAIChatCompletionsModel, ModelSettings\n", + "\n", + "agent = Agent(\n", + " name=\"Notes Assistant\",\n", + " instructions=\"You're a helpful assistant. You take notes and save them to notes.txt. You can also read from notes.txt.\",\n", + " model=OpenAIChatCompletionsModel(model=\"qwen/qwen3-next-80b-a3b-thinking\", openai_client=client),\n", + " model_settings=ModelSettings(temperature=0.6),\n", + " tools=[display_file, write_file],\n", + ")" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "LmTuo6PP-fJT" + }, + "source": [ + "Now that we have our Agent, let's go ahead and *disable* automated tracing - since we're not providing our OpenAI key, and are only communicating with the NVIDIA-hosted NIM API powered by NIM on build.nvidia.com.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": { + "id": "Q9vVAYcarp5G" + }, + "outputs": [], + "source": [ + "from agents import set_tracing_disabled\n", + "set_tracing_disabled(disabled=True)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "Oi5gC5VD-rA_" + }, + "source": [ + "Finally, we can run our agent. Let's ask it to jot down something, and then ask it to display." + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "Kc7faUhxSXWS", + "outputId": "9b7b2991-3aa1-436a-a266-b1d6fce9ce3d" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[INFO] Writing to file: notes.txt\n" + ] + } + ], + "source": [ + "from agents import Runner\n", + "\n", + "result = await Runner.run(agent, \"I am excited to use Qwen3 Next with NVIDIA NIM, can you take note of this?\")" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "gTZHZAt-fVUv", + "outputId": "52407ccd-13cd-4baa-e009-5ac1e6f8a021" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[INFO] Reading file: notes.txt\n", + "Your notes currently contain: \n", + "\"I am excited to use Qwen3 Next with NVIDIA NIM\"\n" + ] + } + ], + "source": [ + "result = await Runner.run(agent, \"Can you read me what i have in my notes?\")\n", + "print(result.final_output)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "AFlXkbqa-yuZ" + }, + "source": [ + "Now that you've built a simple Agent using NVIDIA NIM - head over the [model page](https://build.nvidia.com/openai/gpt-oss-20b) and try it out, or follow the [deployment instructions](https://build.nvidia.com/openai/gpt-oss-20b/deploy) to start building locally!" + ] + } + ], + "metadata": { + "colab": { + "include_colab_link": true, + "machine_shape": "hm", + "provenance": [] + }, + "kernelspec": { + "display_name": "librarian", + "language": "python", + "name": "python3" + }, + "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.12.10" + } + }, + "nbformat": 4, + "nbformat_minor": 0 +} diff --git a/oss_tutorials/notes.txt b/oss_tutorials/notes.txt new file mode 100644 index 000000000..f6488c644 --- /dev/null +++ b/oss_tutorials/notes.txt @@ -0,0 +1 @@ +I am excited to use Qwen3 Next with NVIDIA NIM