{
"cells": [
{
"cell_type": "markdown",
"id": "9f566aff",
"metadata": {},
"source": [
"# Buying Round Lots\n",
"\n",
"The *standard mean-variance (Markowitz) portfolio selection model* determines the optimal investments by balancing risk and expected return. In this notebook, we minimize the variance (risk) of the portfolio given that the prescribed level of expected return is attained. Please refer to the [annotated list of references](../literature.rst#portfolio-optimization) for more background information on portfolio optimization.\n",
"\n",
"Securities on the stock market are often traded in *round lots*. A round lot is a fixed number of units (that typically depends on the financial instrument that is traded). For example, stocks are often traded in multiples of 100 shares. Any smaller quantity of traded securities is called an *odd lot*, which typically induces higher transaction costs, or slower order execution. Also, to avoid small positions, one might want to ensure that a *minimum number of units* is traded if a position is opened.\n",
"\n",
"In this notebook, we add the following constraints to the basic model:\n",
"\n",
"* If a position is opened, it must comprise a minimum number of shares and,\n",
"* stocks can only be bought in round lots.\n",
"\n",
"For our example, we will be using a lower bound of 1000 shares per asset and a uniform lot size of 100 shares.\n",
"\n",
"We also include a risk-free asset in the model."
]
},
{
"cell_type": "code",
"execution_count": 1,
"id": "58e955d9",
"metadata": {
"execution": {
"iopub.execute_input": "2026-07-03T11:05:42.503898Z",
"iopub.status.busy": "2026-07-03T11:05:42.503710Z",
"iopub.status.idle": "2026-07-03T11:05:43.118363Z",
"shell.execute_reply": "2026-07-03T11:05:43.117236Z"
},
"nbsphinx": "hidden"
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Requirement already satisfied: numpy in /opt/hostedtoolcache/Python/3.11.15/x64/lib/python3.11/site-packages (2.4.6)\r\n",
"Requirement already satisfied: scipy in /opt/hostedtoolcache/Python/3.11.15/x64/lib/python3.11/site-packages (1.17.1)\r\n",
"Requirement already satisfied: gurobipy in /opt/hostedtoolcache/Python/3.11.15/x64/lib/python3.11/site-packages (13.0.2)\r\n",
"Requirement already satisfied: pandas in /opt/hostedtoolcache/Python/3.11.15/x64/lib/python3.11/site-packages (3.0.3)\r\n",
"Requirement already satisfied: matplotlib in /opt/hostedtoolcache/Python/3.11.15/x64/lib/python3.11/site-packages (3.11.0)\r\n",
"Requirement already satisfied: python-dateutil>=2.8.2 in /opt/hostedtoolcache/Python/3.11.15/x64/lib/python3.11/site-packages (from pandas) (2.9.0.post0)\r\n",
"Requirement already satisfied: contourpy>=1.0.1 in /opt/hostedtoolcache/Python/3.11.15/x64/lib/python3.11/site-packages (from matplotlib) (1.3.3)\r\n",
"Requirement already satisfied: cycler>=0.10 in /opt/hostedtoolcache/Python/3.11.15/x64/lib/python3.11/site-packages (from matplotlib) (0.12.1)\r\n",
"Requirement already satisfied: fonttools>=4.22.0 in /opt/hostedtoolcache/Python/3.11.15/x64/lib/python3.11/site-packages (from matplotlib) (4.63.0)\r\n",
"Requirement already satisfied: kiwisolver>=1.3.1 in /opt/hostedtoolcache/Python/3.11.15/x64/lib/python3.11/site-packages (from matplotlib) (1.5.0)\r\n",
"Requirement already satisfied: packaging>=20.0 in /opt/hostedtoolcache/Python/3.11.15/x64/lib/python3.11/site-packages (from matplotlib) (26.2)\r\n",
"Requirement already satisfied: pillow>=9 in /opt/hostedtoolcache/Python/3.11.15/x64/lib/python3.11/site-packages (from matplotlib) (12.3.0)\r\n",
"Requirement already satisfied: pyparsing>=3 in /opt/hostedtoolcache/Python/3.11.15/x64/lib/python3.11/site-packages (from matplotlib) (3.3.2)\r\n",
"Requirement already satisfied: six>=1.5 in /opt/hostedtoolcache/Python/3.11.15/x64/lib/python3.11/site-packages (from python-dateutil>=2.8.2->pandas) (1.17.0)\r\n"
]
},
{
"name": "stdout",
"output_type": "stream",
"text": [
"Note: you may need to restart the kernel to use updated packages.\n"
]
}
],
"source": [
"# Install dependencies\n",
"%pip install numpy scipy gurobipy pandas matplotlib"
]
},
{
"cell_type": "code",
"execution_count": 2,
"id": "57c5cc4e",
"metadata": {
"execution": {
"iopub.execute_input": "2026-07-03T11:05:43.120307Z",
"iopub.status.busy": "2026-07-03T11:05:43.120096Z",
"iopub.status.idle": "2026-07-03T11:05:43.783079Z",
"shell.execute_reply": "2026-07-03T11:05:43.782217Z"
}
},
"outputs": [],
"source": [
"import gurobipy as gp\n",
"import gurobipy_pandas as gppd\n",
"import pandas as pd\n",
"import numpy as np\n",
"import matplotlib.pyplot as plt"
]
},
{
"cell_type": "code",
"execution_count": 3,
"id": "1c18972f",
"metadata": {
"execution": {
"iopub.execute_input": "2026-07-03T11:05:43.785115Z",
"iopub.status.busy": "2026-07-03T11:05:43.784819Z",
"iopub.status.idle": "2026-07-03T11:05:43.794896Z",
"shell.execute_reply": "2026-07-03T11:05:43.793951Z"
},
"nbsphinx": "hidden"
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Set parameter WLSAccessID\n"
]
},
{
"name": "stdout",
"output_type": "stream",
"text": [
"Set parameter WLSSecret\n"
]
},
{
"name": "stdout",
"output_type": "stream",
"text": [
"Set parameter LicenseID to value 2443533\n"
]
},
{
"name": "stdout",
"output_type": "stream",
"text": [
"WLS license 2443533 - registered to Gurobi GmbH\n"
]
}
],
"source": [
"# Hidden cell to avoid licensing messages\n",
"# when docs are generated.\n",
"with gp.Model():\n",
" pass"
]
},
{
"cell_type": "markdown",
"id": "07383aa2",
"metadata": {},
"source": [
"## Input Data\n",
"\n",
"The following input data is used within the model:\n",
"\n",
"- $S$: set of stocks\n",
"- $p_i$: last price of stock $i$ in USD\n",
"- $\\mu$: vector of expected returns\n",
"- $\\Sigma$: PSD variance-covariance matrix\n",
" - $\\sigma_{ij}$ covariance between returns of assets $i$ and $j$\n",
" - $\\sigma_{ii}$ variance of return of asset $i$"
]
},
{
"cell_type": "code",
"execution_count": 4,
"id": "4acc1190",
"metadata": {
"execution": {
"iopub.execute_input": "2026-07-03T11:05:43.796676Z",
"iopub.status.busy": "2026-07-03T11:05:43.796518Z",
"iopub.status.idle": "2026-07-03T11:05:43.802110Z",
"shell.execute_reply": "2026-07-03T11:05:43.800938Z"
}
},
"outputs": [],
"source": [
"# Import some example data set\n",
"Sigma = pd.read_pickle(\"sigma.pkl\")\n",
"mu = pd.read_pickle(\"mu.pkl\")"
]
},
{
"cell_type": "markdown",
"id": "33a932a0",
"metadata": {},
"source": [
"We also import the prices of the assets:"
]
},
{
"cell_type": "code",
"execution_count": 5,
"id": "beeebc24",
"metadata": {
"execution": {
"iopub.execute_input": "2026-07-03T11:05:43.803857Z",
"iopub.status.busy": "2026-07-03T11:05:43.803674Z",
"iopub.status.idle": "2026-07-03T11:05:43.813221Z",
"shell.execute_reply": "2026-07-03T11:05:43.812492Z"
}
},
"outputs": [],
"source": [
"# Import price data\n",
"prices = pd.read_pickle(\"subset_weekly_closings_10yrs.pkl\").tail(1).squeeze()\n",
"data = pd.DataFrame(data={\"Price\": prices})"
]
},
{
"cell_type": "markdown",
"id": "0fa6695a",
"metadata": {},
"source": [
"## Formulation\n",
"The model minimizes the variance of the portfolio given that the minimum level of expected return is attained. Also\n",
"* shares can only be bought in multiples of a lot size $l$, and\n",
"* if a position in an asset is bought, it must comprise at least $L$ lots (and hence at least $L\\cdot l$ shares).\n",
"\n",
"Mathematically, this results in a convex quadratic mixed-integer optimization problem.\n",
"\n",
"### Model Parameters\n",
"\n",
"We use the following parameters:\n",
"\n",
"- $\\bar\\mu$: required expected portfolio return\n",
"- $\\mu_\\text{rf}$: risk-free return\n",
"- $T$: total investment amount in USD (AUM)\n",
"- $L$: minimal number of lots per asset\n",
"- $l$: lot size"
]
},
{
"cell_type": "code",
"execution_count": 6,
"id": "b486263b",
"metadata": {
"execution": {
"iopub.execute_input": "2026-07-03T11:05:43.815346Z",
"iopub.status.busy": "2026-07-03T11:05:43.815157Z",
"iopub.status.idle": "2026-07-03T11:05:43.818957Z",
"shell.execute_reply": "2026-07-03T11:05:43.817793Z"
}
},
"outputs": [],
"source": [
"# Values for the model parameters:\n",
"r = 0.25 # Required return\n",
"mu_rf = 0.5 / 52 # Risk-free return rate\n",
"T = 1e7 # total investment amount\n",
"L = 10 # minimal number of lots\n",
"l = 100 # lot size"
]
},
{
"cell_type": "markdown",
"id": "a12a4b0f",
"metadata": {},
"source": [
"### Decision Variables\n",
"We need three types of decision variables:\n",
"\n",
"1. The *proportions* of capital invested among the considered stocks. The corresponding vector of positions is denoted by $x$ with its component $x_i$ denoting the proportion of capital invested in stock $i$.\n",
"\n",
"2. The proportion of capital invested into the risk-free asset is denoted by $x_\\text{rf}$.\n",
"\n",
"3. The *number of lots* of shares bought of the considered stocks. The corresponding vector is denoted by $z$ with its component $z_i$ denoting the number of lots in stock $i$. Note that the number of shares in asset $i$ is then $lz_i$.\n",
"\n",
"### Variable Bounds\n",
"\n",
"Each position must be between 0 and 1; this prevents leverage and short-selling:\n",
"\n",
"$$0\\leq x_i, x_\\text{rf}\\leq 1 \\; , \\; i \\in S$$\n",
"\n",
"The $z_i$ must be integers. To enforce the minimal number $L$ of lots if an asset is bought, we will declare those variables *semi-integer*. That is,\n",
"\n",
"$$z_i \\in \\mathbb Z\\ \\text{and}\\ z_i=0\\ \\text{or}\\ 0< L \\leq z_i \\;, \\; i \\in S$$\n",
"\n",
"\n",
"We will model this using the [gurobipy-pandas](https://github.com/Gurobi/gurobipy-pandas) package. Using this, we first create an extended DataFrame containing the decision variables."
]
},
{
"cell_type": "code",
"execution_count": 7,
"id": "3abfe970",
"metadata": {
"execution": {
"iopub.execute_input": "2026-07-03T11:05:43.820631Z",
"iopub.status.busy": "2026-07-03T11:05:43.820454Z",
"iopub.status.idle": "2026-07-03T11:05:43.840663Z",
"shell.execute_reply": "2026-07-03T11:05:43.839724Z"
}
},
"outputs": [
{
"data": {
"text/html": [
"\n",
"\n",
"
\n",
" \n",
" \n",
" Price \n",
" x \n",
" z \n",
" \n",
" \n",
" \n",
" \n",
" APTV \n",
" 79.150002 \n",
" <gurobi.Var x[APTV]> \n",
" <gurobi.Var z[APTV]> \n",
" \n",
" \n",
" DVN \n",
" 44.290001 \n",
" <gurobi.Var x[DVN]> \n",
" <gurobi.Var z[DVN]> \n",
" \n",
" \n",
" HSY \n",
" 194.528000 \n",
" <gurobi.Var x[HSY]> \n",
" <gurobi.Var z[HSY]> \n",
" \n",
" \n",
" CAG \n",
" 28.020000 \n",
" <gurobi.Var x[CAG]> \n",
" <gurobi.Var z[CAG]> \n",
" \n",
" \n",
" HST \n",
" 16.980000 \n",
" <gurobi.Var x[HST]> \n",
" <gurobi.Var z[HST]> \n",
" \n",
" \n",
" ... \n",
" ... \n",
" ... \n",
" ... \n",
" \n",
" \n",
" AEE \n",
" 76.779999 \n",
" <gurobi.Var x[AEE]> \n",
" <gurobi.Var z[AEE]> \n",
" \n",
" \n",
" AAPL \n",
" 187.440002 \n",
" <gurobi.Var x[AAPL]> \n",
" <gurobi.Var z[AAPL]> \n",
" \n",
" \n",
" AIZ \n",
" 159.820007 \n",
" <gurobi.Var x[AIZ]> \n",
" <gurobi.Var z[AIZ]> \n",
" \n",
" \n",
" UNP \n",
" 215.690002 \n",
" <gurobi.Var x[UNP]> \n",
" <gurobi.Var z[UNP]> \n",
" \n",
" \n",
" K \n",
" 52.200001 \n",
" <gurobi.Var x[K]> \n",
" <gurobi.Var z[K]> \n",
" \n",
" \n",
"
\n",
"
462 rows × 3 columns
\n",
"
\n",
"DVN 44.290001 \n",
"HSY 194.528000 \n",
"CAG 28.020000 \n",
"HST 16.980000 \n",
"... ... ... ...\n",
"AEE 76.779999 \n",
"AAPL 187.440002 \n",
"AIZ 159.820007 \n",
"UNP 215.690002 \n",
"K 52.200001 \n",
"\n",
"[462 rows x 3 columns]"
]
},
"execution_count": 7,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"# Create an empty optimization model\n",
"m = gp.Model()\n",
"\n",
"# Add variable: xrf denotes the proportion of risk-free asset\n",
"xrf = m.addVar(lb=0, ub=1, name=\"x_rf\")\n",
"\n",
"# Add variables\n",
"df_model = (\n",
" # x[i] denotes the proportion invested in stock i\n",
" data.gppd.add_vars(m, name=\"x\", ub=1)\n",
" # z[i] denotes the number of lots of stock i. Must be integer and greater or equal to L or zero.\n",
" # Defining the variable as semi-integer is enough to enforce the buy-in threshold requirement.\n",
" .gppd.add_vars(m, name=\"z\", vtype=gp.GRB.SEMIINT, lb=L)\n",
")\n",
"\n",
"# Inspect the created DataFrame:\n",
"m.update()\n",
"df_model"
]
},
{
"cell_type": "markdown",
"id": "f27c4b3e",
"metadata": {},
"source": [
"### Constraints\n",
"The budget constraint ensures that the entire capital is invested:\n",
"\n",
"$$\\sum_{i \\in S} x_i + x_\\text{rf} =1 $$\n",
"\n",
"The expected return of the portfolio must be at least $\\bar\\mu$:\n",
"\n",
"$$\\underbrace{\\mu_\\text{rf} x_\\text{rf}}_\\text{risk-free return} + \\underbrace{\\mu^\\top x}_\\text{risky return}\\geq \\bar\\mu$$"
]
},
{
"cell_type": "code",
"execution_count": 8,
"id": "e5186526",
"metadata": {
"execution": {
"iopub.execute_input": "2026-07-03T11:05:43.842647Z",
"iopub.status.busy": "2026-07-03T11:05:43.842443Z",
"iopub.status.idle": "2026-07-03T11:05:43.850494Z",
"shell.execute_reply": "2026-07-03T11:05:43.849503Z"
}
},
"outputs": [],
"source": [
"%%capture\n",
"# Budget constraint: all investments sum up to 1\n",
"m.addConstr(df_model[\"x\"].sum() + xrf == 1, name=\"Budget_Constraint\")\n",
"\n",
"# Lower bound on expected return\n",
"m.addConstr(mu.to_numpy() @ df_model[\"x\"] + mu_rf * xrf >= r, \"Minimal_Return\")"
]
},
{
"cell_type": "markdown",
"id": "db766b08",
"metadata": {},
"source": [
"#### Round lots\n",
"\n",
"The relative position $x_i$ in stock $i$ and the number of round lots $z_i$ are related via the price $p_i$ as follows:\n",
"\n",
"$$\n",
"x_i = \\frac{l z_i p_i}{T} \\; , \\; i \\in S\n",
"$$"
]
},
{
"cell_type": "code",
"execution_count": 9,
"id": "9cb3a315",
"metadata": {
"execution": {
"iopub.execute_input": "2026-07-03T11:05:43.852575Z",
"iopub.status.busy": "2026-07-03T11:05:43.852383Z",
"iopub.status.idle": "2026-07-03T11:05:43.864350Z",
"shell.execute_reply": "2026-07-03T11:05:43.863303Z"
}
},
"outputs": [],
"source": [
"%%capture\n",
"gppd.add_constrs(\n",
" m,\n",
" df_model[\"x\"] - l / T * df_model[\"Price\"] * df_model[\"z\"],\n",
" \"=\",\n",
" 0,\n",
" name=\"match_round_lots\",\n",
")"
]
},
{
"cell_type": "markdown",
"id": "63bda8ba",
"metadata": {},
"source": [
"### Objective Function\n",
"The objective is to minimize the risk of the portfolio, which is measured by its variance:\n",
"\n",
"$$\\min_x x^\\top \\Sigma x$$"
]
},
{
"cell_type": "code",
"execution_count": 10,
"id": "8e3e3ba8",
"metadata": {
"execution": {
"iopub.execute_input": "2026-07-03T11:05:43.866432Z",
"iopub.status.busy": "2026-07-03T11:05:43.866238Z",
"iopub.status.idle": "2026-07-03T11:05:44.466748Z",
"shell.execute_reply": "2026-07-03T11:05:44.465792Z"
}
},
"outputs": [],
"source": [
"# Define objective function: Minimize risk\n",
"m.setObjective(df_model[\"x\"] @ Sigma.to_numpy() @ df_model[\"x\"], gp.GRB.MINIMIZE)"
]
},
{
"cell_type": "markdown",
"id": "2fcd15d8",
"metadata": {},
"source": [
"We now solve the optimization problem:"
]
},
{
"cell_type": "code",
"execution_count": 11,
"id": "3120fd63",
"metadata": {
"execution": {
"iopub.execute_input": "2026-07-03T11:05:44.469232Z",
"iopub.status.busy": "2026-07-03T11:05:44.469048Z",
"iopub.status.idle": "2026-07-03T11:05:45.059594Z",
"shell.execute_reply": "2026-07-03T11:05:45.058653Z"
}
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Gurobi Optimizer version 13.0.2 build v13.0.2rc1 (linux64 - \"Ubuntu 24.04.4 LTS\")\n"
]
},
{
"name": "stdout",
"output_type": "stream",
"text": [
"\n"
]
},
{
"name": "stdout",
"output_type": "stream",
"text": [
"CPU model: AMD EPYC 7763 64-Core Processor, instruction set [SSE2|AVX|AVX2]\n"
]
},
{
"name": "stdout",
"output_type": "stream",
"text": [
"Thread count: 1 physical cores, 2 logical processors, using up to 2 threads\n"
]
},
{
"name": "stdout",
"output_type": "stream",
"text": [
"\n"
]
},
{
"name": "stdout",
"output_type": "stream",
"text": [
"WLS license 2443533 - registered to Gurobi GmbH\n"
]
},
{
"name": "stdout",
"output_type": "stream",
"text": [
"Optimize a model with 464 rows, 925 columns and 1850 nonzeros (Min)\n"
]
},
{
"name": "stdout",
"output_type": "stream",
"text": [
"Model fingerprint: 0x5dd8105c\n"
]
},
{
"name": "stdout",
"output_type": "stream",
"text": [
"Model has 0 linear objective coefficients\n"
]
},
{
"name": "stdout",
"output_type": "stream",
"text": [
"Model has 106953 quadratic objective terms\n"
]
},
{
"name": "stdout",
"output_type": "stream",
"text": [
"Variable types: 463 continuous, 0 integer (0 binary)\n"
]
},
{
"name": "stdout",
"output_type": "stream",
"text": [
"Semi-Variable types: 0 continuous, 462 integer\n"
]
},
{
"name": "stdout",
"output_type": "stream",
"text": [
"Coefficient statistics:\n"
]
},
{
"name": "stdout",
"output_type": "stream",
"text": [
" Matrix range [9e-05, 1e+00]\n"
]
},
{
"name": "stdout",
"output_type": "stream",
"text": [
" Objective range [0e+00, 0e+00]\n"
]
},
{
"name": "stdout",
"output_type": "stream",
"text": [
" QObjective range [6e-03, 2e+02]\n"
]
},
{
"name": "stdout",
"output_type": "stream",
"text": [
" Bounds range [1e+00, 1e+01]\n"
]
},
{
"name": "stdout",
"output_type": "stream",
"text": [
" RHS range [2e-01, 1e+00]\n"
]
},
{
"name": "stdout",
"output_type": "stream",
"text": [
"\n"
]
},
{
"name": "stdout",
"output_type": "stream",
"text": [
"Presolve time: 0.02s\n"
]
},
{
"name": "stdout",
"output_type": "stream",
"text": [
"Presolved: 1388 rows, 1387 columns, 3697 nonzeros\n"
]
},
{
"name": "stdout",
"output_type": "stream",
"text": [
"Presolved model has 106953 quadratic objective terms\n"
]
},
{
"name": "stdout",
"output_type": "stream",
"text": [
"Variable types: 463 continuous, 924 integer (462 binary)\n"
]
},
{
"name": "stdout",
"output_type": "stream",
"text": [
"Found heuristic solution: objective 11.4196528\n"
]
},
{
"name": "stdout",
"output_type": "stream",
"text": [
"\n"
]
},
{
"name": "stdout",
"output_type": "stream",
"text": [
"Root relaxation: objective 1.803654e+00, 161 iterations, 0.01 seconds (0.01 work units)\n"
]
},
{
"name": "stdout",
"output_type": "stream",
"text": [
"\n"
]
},
{
"name": "stdout",
"output_type": "stream",
"text": [
" Nodes | Current Node | Objective Bounds | Work\n"
]
},
{
"name": "stdout",
"output_type": "stream",
"text": [
" Expl Unexpl | Obj Depth IntInf | Incumbent BestBd Gap | It/Node Time\n"
]
},
{
"name": "stdout",
"output_type": "stream",
"text": [
"\n"
]
},
{
"name": "stdout",
"output_type": "stream",
"text": [
" 0 0 1.80365 0 62 11.41965 1.80365 84.2% - 0s\n"
]
},
{
"name": "stdout",
"output_type": "stream",
"text": [
"H 0 0 2.6779857 1.80365 32.6% - 0s\n"
]
},
{
"name": "stdout",
"output_type": "stream",
"text": [
"H 0 0 2.6491462 1.80365 31.9% - 0s\n"
]
},
{
"name": "stdout",
"output_type": "stream",
"text": [
"H 0 0 2.6455642 1.80365 31.8% - 0s\n"
]
},
{
"name": "stdout",
"output_type": "stream",
"text": [
"H 0 0 2.6443389 1.80365 31.8% - 0s\n"
]
},
{
"name": "stdout",
"output_type": "stream",
"text": [
"H 0 0 2.0051518 1.80365 10.0% - 0s\n"
]
},
{
"name": "stdout",
"output_type": "stream",
"text": [
"H 0 0 1.8416417 1.80365 2.06% - 0s\n"
]
},
{
"name": "stdout",
"output_type": "stream",
"text": [
"H 0 0 1.8235582 1.80365 1.09% - 0s\n"
]
},
{
"name": "stdout",
"output_type": "stream",
"text": [
" 0 0 1.80365 0 59 1.82356 1.80365 1.09% - 0s\n"
]
},
{
"name": "stdout",
"output_type": "stream",
"text": [
" 0 0 1.80365 0 59 1.82356 1.80365 1.09% - 0s\n"
]
},
{
"name": "stdout",
"output_type": "stream",
"text": [
" 0 0 1.80365 0 59 1.82356 1.80365 1.09% - 0s\n"
]
},
{
"name": "stdout",
"output_type": "stream",
"text": [
" 0 0 1.80449 0 57 1.82356 1.80449 1.05% - 0s\n"
]
},
{
"name": "stdout",
"output_type": "stream",
"text": [
" 0 0 1.80449 0 57 1.82356 1.80449 1.05% - 0s\n"
]
},
{
"name": "stdout",
"output_type": "stream",
"text": [
" 0 0 1.80449 0 57 1.82356 1.80449 1.05% - 0s\n"
]
},
{
"name": "stdout",
"output_type": "stream",
"text": [
" 0 0 1.80449 0 57 1.82356 1.80449 1.05% - 0s\n"
]
},
{
"name": "stdout",
"output_type": "stream",
"text": [
" 0 0 1.80449 0 57 1.82356 1.80449 1.05% - 0s\n"
]
},
{
"name": "stdout",
"output_type": "stream",
"text": [
" 0 2 1.80449 0 57 1.82356 1.80449 1.05% - 0s\n"
]
},
{
"name": "stdout",
"output_type": "stream",
"text": [
"\n"
]
},
{
"name": "stdout",
"output_type": "stream",
"text": [
"Cutting planes:\n"
]
},
{
"name": "stdout",
"output_type": "stream",
"text": [
" MIR: 3\n"
]
},
{
"name": "stdout",
"output_type": "stream",
"text": [
"\n"
]
},
{
"name": "stdout",
"output_type": "stream",
"text": [
"Explored 147 nodes (891 simplex iterations) in 0.58 seconds (0.40 work units)\n"
]
},
{
"name": "stdout",
"output_type": "stream",
"text": [
"Thread count was 2 (of 2 available processors)\n"
]
},
{
"name": "stdout",
"output_type": "stream",
"text": [
"\n"
]
},
{
"name": "stdout",
"output_type": "stream",
"text": [
"Solution count 8: 1.82356 1.84164 2.00515 ... 11.4197\n"
]
},
{
"name": "stdout",
"output_type": "stream",
"text": [
"\n"
]
},
{
"name": "stdout",
"output_type": "stream",
"text": [
"Optimal solution found (tolerance 1.00e-04)\n"
]
},
{
"name": "stdout",
"output_type": "stream",
"text": [
"Best objective 1.823558188851e+00, best bound 1.823393521111e+00, gap 0.0090%\n"
]
}
],
"source": [
"m.optimize()"
]
},
{
"cell_type": "markdown",
"id": "4e5489d5",
"metadata": {},
"source": [
"Display basic solution data:"
]
},
{
"cell_type": "code",
"execution_count": 12,
"id": "4ed77c24",
"metadata": {
"execution": {
"iopub.execute_input": "2026-07-03T11:05:45.061492Z",
"iopub.status.busy": "2026-07-03T11:05:45.061299Z",
"iopub.status.idle": "2026-07-03T11:05:45.080055Z",
"shell.execute_reply": "2026-07-03T11:05:45.079101Z"
}
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Minimum Risk: 1.823558\n",
"Expected return: 0.248349\n",
"Solution time: 0.58 seconds\n",
"\n",
"Number of trades: 20\n",
"\n",
"Risk-free alloc: 0.171827\n",
"\n"
]
},
{
"data": {
"text/html": [
"\n",
"\n",
"
\n",
" \n",
" \n",
" Position \n",
" Shares \n",
" Price \n",
" \n",
" \n",
" \n",
" \n",
" LLY \n",
" 0.158906 \n",
" 2700.0 \n",
" 588.539978 \n",
" \n",
" \n",
" KDP \n",
" 0.080403 \n",
" 25300.0 \n",
" 31.780001 \n",
" \n",
" \n",
" PGR \n",
" 0.078835 \n",
" 5000.0 \n",
" 157.669998 \n",
" \n",
" \n",
" NVDA \n",
" 0.048888 \n",
" 1000.0 \n",
" 488.880005 \n",
" \n",
" \n",
" DPZ \n",
" 0.048716 \n",
" 1300.0 \n",
" 374.739990 \n",
" \n",
" \n",
" NOC \n",
" 0.046388 \n",
" 1000.0 \n",
" 463.880005 \n",
" \n",
" \n",
" TMUS \n",
" 0.041163 \n",
" 2800.0 \n",
" 147.009995 \n",
" \n",
" \n",
" WM \n",
" 0.041081 \n",
" 2400.0 \n",
" 171.169998 \n",
" \n",
" \n",
" ODFL \n",
" 0.039779 \n",
" 1000.0 \n",
" 397.790009 \n",
" \n",
" \n",
" TTWO \n",
" 0.036816 \n",
" 2400.0 \n",
" 153.399994 \n",
" \n",
" \n",
" WST \n",
" 0.034423 \n",
" 1000.0 \n",
" 344.230011 \n",
" \n",
" \n",
" KR \n",
" 0.033701 \n",
" 7900.0 \n",
" 42.660000 \n",
" \n",
" \n",
" WMT \n",
" 0.024966 \n",
" 1600.0 \n",
" 156.039993 \n",
" \n",
" \n",
" ED \n",
" 0.023530 \n",
" 2600.0 \n",
" 90.500000 \n",
" \n",
" \n",
" MKTX \n",
" 0.022670 \n",
" 1000.0 \n",
" 226.699997 \n",
" \n",
" \n",
" CLX \n",
" 0.020479 \n",
" 1500.0 \n",
" 136.529999 \n",
" \n",
" \n",
" HRL \n",
" 0.017963 \n",
" 5500.0 \n",
" 32.660000 \n",
" \n",
" \n",
" MNST \n",
" 0.013775 \n",
" 2500.0 \n",
" 55.099998 \n",
" \n",
" \n",
" XEL \n",
" 0.009614 \n",
" 1600.0 \n",
" 60.090000 \n",
" \n",
" \n",
" CPB \n",
" 0.006075 \n",
" 1500.0 \n",
" 40.500000 \n",
" \n",
" \n",
"
\n",
"
"
]
},
"metadata": {},
"output_type": "display_data"
}
],
"source": [
"x_lots = pd.concat([data[\"Position\"], pd.Series([xrf.X], index=[\"risk-free\"])])\n",
"\n",
"# change type of z from semi-integer to continuous and lower bound to 0\n",
"df_model[\"z\"].gppd.set_attr(\"vtype\", gp.GRB.CONTINUOUS)\n",
"df_model[\"z\"].gppd.set_attr(\"lb\", 0)\n",
"\n",
"m.params.OutputFlag = 0\n",
"m.optimize()\n",
"\n",
"x_unconstr = pd.concat([df_model[\"x\"].gppd.X, pd.Series([xrf.X], index=[\"risk-free\"])])\n",
"\n",
"# retrieve and display solution data\n",
"mask = (x_lots > 1e-5) | (x_unconstr > 1e-5)\n",
"df_data = pd.DataFrame(\n",
" index=x_lots[mask].index,\n",
" data={\n",
" \"round lots\": x_lots[mask],\n",
" \"unconstrained\": x_unconstr[mask],\n",
" },\n",
").sort_values(by=[\"round lots\", \"unconstrained\"], ascending=True)\n",
"\n",
"axs = df_data.plot.barh(color=[\"#0b1a3c\", \"#dd2113\"])\n",
"axs.set_xlabel(\"Fraction of investment sum\")\n",
"plt.title(\"Minimum Variance portfolios with and without enforcing round lots\")\n",
"plt.show()"
]
},
{
"cell_type": "markdown",
"id": "aea2f285",
"metadata": {},
"source": [
"## Takeaways\n",
"\n",
"* Data from pandas DataFrames can easily be used to build an optimization model via the `gurobipy-pandas` package.\n",
"* To enforce buying round lots of shares, one needs to incorporate the asset price and the total investment amount into the model.\n",
"* Minimum buy-in and round lot constraints can be modeled using semi-integer variables. Semi-integer variables are integer decision variables that may either take the value 0 or a value between specified bounds. They are a convenient tool to guarantee a minimum position size if an asset is bought."
]
}
],
"metadata": {
"kernelspec": {
"display_name": "Python 3 (ipykernel)",
"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.11.15"
}
},
"nbformat": 4,
"nbformat_minor": 5
}