{"id":12719,"date":"2025-07-28T08:04:16","date_gmt":"2025-07-28T12:04:16","guid":{"rendered":"https:\/\/blogs.mathworks.com\/student-lounge\/?p=12719"},"modified":"2025-07-28T08:04:16","modified_gmt":"2025-07-28T12:04:16","slug":"how-satellites-use-game-theory-to-fly-in-perfect-formation-simulated-in-matlab","status":"publish","type":"post","link":"https:\/\/blogs.mathworks.com\/student-lounge\/2025\/07\/28\/how-satellites-use-game-theory-to-fly-in-perfect-formation-simulated-in-matlab\/","title":{"rendered":"How Satellites Use Game Theory to Fly in Perfect Formation \u2014 Simulated in MATLAB"},"content":{"rendered":"
\n
<\/div>\n
Today\u2019s guest blogger is Maria Luisa, who\u2019s doing her PhD in Control Systems at Imperial College London and is also one of our MATLAB Student Ambassadors. Over to you, Maria..<\/span><\/div>\n

Introduction & Motivation<\/span><\/h2>\n
What do poker players, self-driving cars, and satellites have in common? They all make strategic decisions under uncertainty. And believe it or not, they all rely on game theory<\/span>.<\/div>\n
In this blog, I\u2019ll walk you through how I used MATLAB to simulate a team of satellites flying in formation\u2014coordinating their actions like players in a cosmic chess game.<\/div>\n
I am Maria Luisa, a MATLAB Student Ambassador<\/a>, and I am currently doing a PhD in control systems at Imperial College London. I work in the field of differential game theory. More specifically, in this blog I will tackle the formation control problem of satellites using differential game theory.<\/div>\n
<\/div>\n

Why Do Satellites Need to Play Games in Space?<\/span><\/h2>\n
Formation flying is a growing concept in modern aerospace engineering. Whether it’s satellites working together to capture synchronized Earth imagery, measure climate variables, or deliver GPS signals, tight coordination is critical. But there\u2019s a challenge: space is unforgiving. Small errors in velocity or position can accumulate quickly, leading to significant drift over time.<\/div>\n
If one satellite corrects its trajectory, the others must respond appropriately to preserve the formation. And here\u2019s the interesting part\u2014each satellite is autonomous, acting based on its own goals and fuel constraints.<\/div>\n
This scenario is a textbook example of a strategic decision-making problem under uncertainty<\/span>\u2014the domain of game theory<\/span><\/a>.<\/div>\n
Instead of central coordination, we model the satellites as players in a differential game<\/span>, each trying to optimize its own outcome (i.e., maintain formation while minimizing fuel usage), while accounting for the actions of the others. It’s not unlike poker: your best move depends on what the others are doing. The solution concept? A Nash equilibrium<\/span><\/a>\u2014a state where no satellite has an incentive to unilaterally change its strategy.<\/div>\n
In this project, we use MATLAB<\/span> to simulate this multi-agent coordination using tools from optimal control<\/span><\/a> and game theory<\/span>.<\/div>\n
<\/div>\n

Modelling the Satellites<\/span><\/h2>\n
Let\u2019s break down how we mathematically model this coordination problem.<\/div>\n
We consider a team of three satellites<\/span> in low Earth orbit. Each satellite has a thruster system it can use to slightly adjust its position and velocity. We model the dynamics using a linearized version of Newton\u2019s equations<\/span> around a reference orbit.<\/div>\n
The system is described using a state-space model<\/span>:<\/div>\n
<\/div>\n
\"systemmatrix.png\"<\/div>\n
\n

In MATLAB, we construct this using blkdiag<\/span><\/a> for the overall A<\/span> matrix and control input matrices B1\u2009,B2\u2009,B3.<\/p>\n<\/div>\n

<\/div>\n

What are they optimizing?<\/span><\/h2>\n
Each satellite tries to:<\/div>\n
    \n
  1. Stay close to the desired trajectory<\/span>,<\/li>\n
  2. Use as little thrust as possible<\/span> (to save fuel).<\/li>\n<\/ol>\n
    This leads us to define a cost functional<\/span> for each satellite. It penalizes both formation error and control effort:<\/div>\n
    \"cost_functional.png\"<\/div>\n
    These matrices can be tuned in MATLAB to reflect different behaviors\u2014e.g., a satellite that prioritizes accuracy over fuel, or vice versa.<\/div>\n
    Now that we\u2019ve modeled how each satellite moves and what it wants (stay in formation, save fuel), we need to remember that each satellite acts independently<\/span>.<\/div>\n
    That means Satellite 1 doesn’t know exactly what Satellite 2 or 3 will do\u2014it just assumes they\u2019ll act optimally. This situation is called a non-cooperative differential game<\/span>. That is, each player (satellite) is trying to minimize its own cost, while taking into account how the others will move.<\/div>\n
    This is where game theory<\/span> comes in. We\u2019re looking for a balance point where no satellite can improve its outcome by changing its strategy\u2014assuming the others keep theirs unchanged. That\u2019s called a Nash equilibrium<\/span>.<\/div>\n
    <\/div>\n

    Solving the differential game in MATLAB<\/span><\/h2>\n
    To find the Nash equilibrium for our satellites, we need to solve a set of coupled Riccati-like matrix equations<\/span>. These arise from the Linear Quadratic Differential Game<\/span><\/a> formulation and they are a more complex version of the algebraic Riccati equation seen in standard LQR control. The equations for the three satellites are given by:<\/div>\n
    <\/div>\n
    $ P_1A + A^\\top P_1 + Q_1 – P_1S_1P_1 – P_1S_2P_2 – P_1S_3P_3 – P_2S_2P_1 – P_3S_3P_1 = 0 $<\/span><\/div>\n
    $ P_2A + A^\\top P_2 + Q_2 – P_2S_2P_2 – P_2S_1P_1 – P_2S_3P_3 – P_1S_1P_2 – P_3S_3P_2 = 0 $<\/span><\/div>\n
    $ P_3A + A^\\top P_3 + Q_3 – P-3S_3P_3 – P_3S_2P_2 – P_3S_1P_1 – P_2S_2P_3 – P_1S_1P_3 = 0 $<\/span><\/div>\n
    <\/div>\n
    \n

    Where P1,P2,P3are the matrices we are solving for and$ S_i = B_iR_i^{-1}B_i^\\top $<\/span>. These equations are coupled<\/span> and nonlinear<\/span>, so we can\u2019t solve them directly in one step. Instead, we\u2019ll use MATLAB to solve them numerically. Here I will explain two methods we can use but other options can be available.<\/p>\n<\/div>\n

    <\/div>\n

    Method 1) Iterative Best-Response Dynamics<\/span><\/h2>\n
    The first approach is based on best-response iteration<\/span>, a fixed-point method where each player optimizes assuming the others are fixed. At each iteration, player i<\/span> solves a standard iCARE<\/span><\/a> assuming current values of $ P_j, j \\neq i $<\/span>.<\/div>\n
    \n
    \n

    The idea of the algorithm can be summarized as:<\/strong><\/p>\n

      \n
    1. Initialize \\(P_1\\), \\(P_2\\), and \\(P_3\\).<\/li>\n
    2. For each \\(i \\in \\{1, 2, 3\\}\\), solve:\\(P_i = \\mathrm{icare}\\bigl(A – \\sum_{j \\neq i} S_j P_j, B_i, Q_i, R_i\\bigr)\\)<\/em><\/li>\n
    3. Repeat until convergence:\\(\\|P_i^{(i)} – P_i^{(i-1)}\\| \\leq \\epsilon\\)<\/em><\/li>\n<\/ol>\n<\/div>\n<\/div>\n<\/div>\n
      <\/div>\n
      This method is intuitive and efficient for problems where the interdependencies are smooth and well-behaved. Let\u2019s see some relevant parts of the code:<\/div>\n
      \n
      \n
      %<\/span> Defining the initial guesses <\/span><\/span><\/div>\n<\/div>\n
      \n
      P1_0 = P;<\/span><\/div>\n<\/div>\n
      \n
      P2_0 = P;<\/span><\/div>\n<\/div>\n
      \n
      P3_0 = P;<\/span><\/div>\n<\/div>\n<\/div>\n
      \n

      We initialize each Pi with a common matrix P, often obtained from a centralized LQR solution or using icare. This gives us a feasible and symmetric starting point.<\/p>\n<\/div>\n

      \n
      \n
      while<\/span> norm(P1 – P1_0) > tol && …<\/span><\/span><\/div>\n<\/div>\n
      \n
      norm(P2 – P2_0) > tol && …<\/span><\/span><\/div>\n<\/div>\n
      \n
      norm(P3 – P3_0) > tol<\/span><\/div>\n<\/div>\n
      \n
      <\/div>\n<\/div>\n
      \n
      <\/div>\n<\/div>\n
      \n
      % Update K matrices using the iterative CARE solver<\/span><\/span><\/div>\n<\/div>\n
      \n
      P1 = icare(A – S2 * P2_0 – S3 * P3_0, B1, Q1, R1);<\/span><\/div>\n<\/div>\n
      \n
      P2 = icare(A – S1 * P1_0 – S3 * P3_0, B2, Q2, R2);<\/span><\/div>\n<\/div>\n
      \n
      P3 = icare(A – S1 * P1_0 – S2 * P2_0, B3, Q3, R3);<\/span><\/div>\n<\/div>\n
      \n
      <\/div>\n<\/div>\n
      \n
      % Store current values as old for the next iteration<\/span><\/span><\/div>\n<\/div>\n
      \n
      P1_0 = P1;<\/span><\/div>\n<\/div>\n
      \n
      P2_0 = P2;<\/span><\/div>\n<\/div>\n
      \n
      P3_0 = P3;<\/span><\/div>\n<\/div>\n
      \n
      end<\/span><\/span><\/div>\n<\/div>\n<\/div>\n