1. The Cell Wall and the “Large or Charged” Rule

• Uncharged gases like oxygen ($\text{O}_2$) and carbon dioxide ($\text{CO}_2$) slip right through the wall without effort.
• Charged minerals (ions) like sodium ($\text{Na}^+$), potassium ($\text{K}^+$), and calcium ($\text{Ca}^{2+}$) are strictly blocked.

2. Going Downhill vs. Climbing Uphill

• Going Downhill (Passive Transport / Diffusion): When an ion channel opens, ions naturally flow from high concentration to low concentration. This costs zero energy—just like sitting at the top of a slide and letting gravity pull you down.
• Climbing Uphill (Active Transport): When a cell needs to push ions against their natural flow—from low concentration to high concentration—it has to fight nature. This is like climbing a steep ladder while carrying a heavy load. It requires physical effort and fuel in the form of ATP (adenosine triphosphate), the energy currency harvested from the food you eat and the oxygen you breathe.

  HIGH CONCENTRATION 

          \

           \  (Diffusion: Free Energy)

            \  "Going Down the Slide"

             v

  LOW CONCENTRATION

  ---------------------------------

  LOW CONCENTRATION

             ^

            /  (Active Transport: Costs ATP)

           /   "Climbing the Ladder"

          /

  HIGH CONCENTRATION

3. How the Pump Works: The 5-Step Mechanical Cycle

1. Locking onto Sodium: Pumping from inside the cell, the pump opens inward and grabs 3 sodium ions ($\text{Na}^+$).
2. Fueling the Spring: A packet of chemical fuel (ATP) attaches to the pump and breaks down, transferring a phosphate group to the protein.
3. Flipping Outward: This added energy acts like a spring latch releasing. The pump changes shape, flipping open to the outside of the cell and ejecting the 3 sodium ions into the surrounding fluid.
4. Grabbing Potassium: Now facing outward, the pump’s shape changes so it no longer fits sodium, but perfectly matches 2 potassium ions ($\text{K}^+$) from the outside.
5. Snapping Back Home: When 2 potassium ions land in their slots, the phosphate group falls off. Deprived of that extra energy, the pump snaps back to its original inward-facing shape, dropping the 2 potassium ions inside the cell.

       OUTSIDE THE CELL (Salty Sea)

            Na+   Na+   Na+  (3 Ejected Out)

        =================================== [Membrane]

            K+    K+         (2 Pulled In)

        INSIDE THE CELL (Potassium-Rich)

4. The Result: A Loaded Biological Battery

5. Why Does the Body Spend Energy Doing This?

A. Preventing the Cell from Swelling and Bursting

B. Powering Brain Signals and Thoughts

C. Regulating Heartbeats and Muscle Contraction

D. Giving Nutrients a “Piggyback” Ride

6. Why Dietary Potassium Matters

• The pump slows down, causing sodium to build up inside cells.
• Cells retain water and swell.
• Kidneys struggle to flush out excess salt, causing fluid volume in your blood vessels to rise—leading to high blood pressure (hypertension) and chronic fatigue.

Summary

1. Gut Bacteria Suitable for Fat Digestion

• Lactobacillaceae & Clostridiaceae: These families expand rapidly in the upper gastrointestinal tract in response to high-fat diets. They secrete lipid-modifying enzymes and interact with bile acids, influencing host lipid emulsification and transport (Small Intestinal Microbiota Regulate Digestive and Absorptive Adaptive Responses to Dietary Lipids).
• Bifidobacterium & Lactobacillus species: Convert dietary polyunsaturated fatty acids (PUFAs) into bioactive isomers such as conjugated linoleic acid (CLA), while aiding microbial lipases in dietary lipid processing (Microbial Interactions with Intestinal Lipid Digestion and Absorption).
• Bacteroides species (B. thetaiotaomicron): Process complex dietary phospholipids and host cell membrane lipids, modulating systemic sphingolipid pools.

2. Gut Bacteria Useful for Acid Reflux (GERD)

• Lactobacillus reuteri: Significantly accelerates gastric emptying time and improves stomach clearance (Role of Lactobacillus reuteri in Human Health and Diseases). Accelerating stomach clearance reduces intragastric pressure, minimizing transient relaxations of the lower esophageal sphincter (LES) that cause acid reflux.
• Lactobacillus gasseri (e.g., strain LG21): Helps reduce postprandial distress, heartburn frequency, and stomach discomfort by strengthening the protective gastric mucus barrier.
• Bifidobacterium lactis (e.g., strain HN019): Reduces colonic transit time and small intestinal gas formation. Reducing intra-abdominal bloating prevents physical pressure from forcing gastric contents upward into the esophagus.

3. What Happens When the Gallbladder Is Removed?

We’ve all been taught a simple rule about nutrition: white rice, pasta, and flatbreads are “fast carbs.” They hit your system, digest in a flash, spike your blood sugar, and leave you feeling hungry a few hours later.

But what if you could change the molecular structure of those exact same carbs, lowering their glycemic impact and reducing their absorbable calories—all without changing the ingredients?

It sounds like internet clickbait, but it is actually a beautifully elegant reality of food chemistry. By shifting your kitchen habits to a simple Cook, Cool, and Reheat method, you can transform rapidly digesting starches into something far friendlier to your metabolism: Resistant Starch.

Here is the breakdown of the hidden science lurking in your leftovers and how you can harness it to upgrade your health.

The Problem: The Standard Starch Spike

To understand the solution, we have to look at how regular starches behave in our bodies.

Foods like white rice, wheat flour (used in rotis and paranthas), and potatoes are packed with two types of starch molecules: amylose (long, straight chains) and amylopectin (highly branched chains).

When you cook these foods in boiling water or on a hot griddle (tawa), these starch chains absorb water and swell. This process is called gelatinization. It makes the food soft, fluffy, and delicious.

The downside? It also makes them incredibly easy for your body’s digestive enzymes (like amylase in your saliva and gut) to shred apart. The enzymes break the soft starch down into pure glucose almost instantly. This triggers:

• A sharp spike in blood sugar.

• A corresponding surge of insulin to clear that glucose.

• An inevitable energy crash that leaves you reaching for more food.

The Chemistry: Re-engineering the Molecules

So, how do we fix it? We use chemistry to build an enzyme-resistant fortress around those starch molecules. This relies on two distinct scientific steps.

Phase 1: Amylose-Lipid Complexation (The Fat Lock)

When you add a healthy fat—like coconut oil, ghee, or olive oil—directly into your cooking water or dough, you trigger amylose-lipid complexation.

As the straight-chained amylose molecules heat up and expand, the fatty acid chains from the oil slide perfectly inside them. This creates a tight bond that essentially “waterproofs” the starch, making it physically difficult for your digestive enzymes to attach to and break open later.

Phase 2: Retrogradation (The Crystal Freeze)

The real magic, however, happens when the temperature drops. When you take that cooked starch and place it in the refrigerator (ideally at around 4°C / 39°F) for 12 to 24 hours, a process called retrogradation takes place.

As the starch cools, the unwound amylose and amylopectin chains begin to move closer together. They form incredibly tight, orderly, and rigid hydrogen bonds, recrystallizing into a dense matrix known as Resistant Starch (RS).

The Biological Repercussions: What Changes Inside You?

Once your starch has been cooked, cooled, and transformed, it behaves entirely differently inside your digestive system.

It Bypasses the Small Intestine: Instead of dissolving into glucose in your small intestine, resistant starch travels completely untouched all the way to your large intestine (colon).

This shift triggers a cascade of incredible biological benefits:

• Fewer Calories Absorbed: Because you cannot digest resistant starch, it carries roughly half the calories of regular starch. Depending on the food and the fat used, this method can reduce the absorbable calories of a meal by 10% to 50%.

• A Flattened Glucose Curve: Because the remaining starches digest at a fraction of the speed, glucose enters your bloodstream as a slow, steady trickle rather than a sudden wave. No spike, no crash.

• A Feast for Your Microbiome: In your colon, resistant starch acts as a powerful prebiotic. Your beneficial gut bacteria ferment it, turning it into short-chain fatty acids like butyrate. Butyrate is the primary fuel source for your colon cells, heavily linked to reduced inflammation, improved gut barrier integrity, and better metabolic health.

How to Deal With It: The Blueprint for Your Kitchen

You do not need a laboratory to pull this off. You just need patience and a little bit of meal prep. Best of all, reheating the food does not destroy the resistant starch once it has formed.

Here is how to apply the hack across different staple foods:

The Golden Rule: Avoid the “Soggy Filling” Trap

While this trick works phenomenally well for pure starches (like rice, pasta, or plain layered paranthas), be mindful of stuffed foods like Aloo Paranthas. While the potato starch will become healthily resistant, the texture of a cooled and reheated potato stuffing can turn dense and gummy.

For stuffed flatbreads, you are better off stuffing them with high-protein, low-starch alternatives like paneer, gobi (cauliflower), or lentils (daal), which naturally keep your blood sugar low right from the start!

Change the Timeline, Change Your Health

The global spike in metabolic issues isn’t just about what we are eating; it’s about how rapidly our modern, highly processed food digests. By introducing fat, cooling our food overnight, and allowing chemistry to do the heavy lifting, we can reclaim our favorite comfort foods.

The next time you cook, don’t think about what you are eating tonight—think about what you are preparing for tomorrow. Your gut, your energy levels, and your blood sugar will thank you.

The future of autonomous aerial systems is not arriving suddenly—it is being carefully engineered, tested, and refined in simulation environments that mirror the complexity of the real world.

Our latest IEEE research explores this future through the development of a distributed reinforcement learning testbed for UAV target tracking, where multiple autonomous drones learn to coordinate in real time to follow a dynamic airborne target.

At its core, this work investigates a simple but powerful question:

How can UAV swarms learn to track moving targets more efficiently in unpredictable environments?

The answer lies in combining realistic flight simulation, distributed networking, and modern reinforcement learning algorithms.

Why UAV Swarm Target Tracking Matters

Target tracking is one of the most important capabilities in autonomous drone systems.

Whether the mission involves:

• search and rescue
• disaster monitoring
• perimeter surveillance
• defense simulation
• intelligent logistics
• environmental observation

…the ability for multiple UAVs to collaboratively maintain awareness of a moving target is essential.

Traditional rule-based control methods often struggle when the target behaves unpredictably or when the environment becomes dynamic.

This is where reinforcement learning (RL) becomes transformative.

Instead of following hard-coded instructions, UAVs learn through interaction with the environment, continuously improving their decision-making policies based on experience.

A Realistic Testbed Built on FlightGear and JSBSim

To study this problem, we developed a distributed UAV simulation testbed using:

• FlightGear for high-fidelity 3D flight simulation
• JSBSim for realistic flight dynamics modeling
• UDP-based distributed communication
• real-time reinforcement learning control loops

The architecture allows multiple UAVs to operate as independent learning agents while exchanging state information such as:

• positional coordinates
• orientation
• velocity
• control signals

This creates a highly scalable framework for testing swarm intelligence strategies under near-realistic conditions.

In our experimental setup:

• one UAV acts as the autonomous target
• multiple UAVs act as tracking agents
• distributed reinforcement learning coordinates the swarm in real time

Comparing Modern Reinforcement Learning Models

The study compares three influential RL methods:

• A2C (Advantage Actor-Critic)
• A3C (Asynchronous Advantage Actor-Critic)
• PPO (Proximal Policy Optimization)

Each algorithm contributes different strengths.

A2C for the Target UAV

A2C was used to control the target UAV, generating complex motion patterns that make the tracking task challenging and realistic.

A3C for Distributed Swarm Coordination

A3C enables multiple worker agents to learn asynchronously, making it highly suitable for swarm UAV coordination where multiple trackers operate in parallel.

PPO for Stable Policy Learning

PPO was used to provide robust and stable policy optimization, particularly useful in dynamic environments where abrupt policy updates can destabilize learning.

The Role of Intelligent Exploration

One of the biggest challenges in reinforcement learning is the sparse reward problem.

In target tracking, useful feedback may not arrive frequently enough for agents to learn efficiently.

This means UAVs may spend too much time exploring ineffective strategies before discovering successful behaviours.

To address this, our work integrates an Intrinsic Curiosity Module (ICM), which generates internal rewards whenever the agent encounters novel or difficult-to-predict states.

This mechanism encourages:

• better exploration
• faster discovery of useful strategies
• improved adaptation to unfamiliar target behaviour
• more efficient learning in dynamic environments

Rather than waiting for explicit environmental rewards, the swarm develops an internal motivation to learn.

This significantly improves learning speed and robustness.

What the Results Showed

The results were highly encouraging.

Across multiple simulation runs, the UAV swarm agents enhanced with curiosity-driven exploration demonstrated:

• faster convergence
• higher cumulative rewards
• smoother actor-critic losses
• stronger policy stability
• improved entropy-driven exploration
• better generalisation to dynamic target motion

Among all tested models, A3C integrated with curiosity mechanisms showed the strongest overall performance, delivering the most stable and effective swarm target tracking.

This is particularly significant because asynchronous distributed learning closely mirrors how real swarm systems may operate across multiple compute nodes or edge devices.

Why This Matters Beyond Simulation

The importance of this research extends far beyond virtual flight environments.

The same principles can directly influence real-world systems in:

• disaster response drones
• persistent surveillance
• maritime monitoring
• intelligent border systems
• military training simulation
• autonomous delivery fleets
• environmental hazard assessment

The ability of UAVs to learn collaboratively, adapt to novelty, and coordinate under uncertainty is central to the next generation of autonomous aerospace systems.

Simulation-first research provides a safe, cost-effective pathway to develop these capabilities before real deployment.

Looking Ahead

This work represents an important step toward truly intelligent UAV swarms.

As reinforcement learning continues to mature, the combination of:

• distributed simulation
• curiosity-driven exploration
• asynchronous swarm learning
• realistic flight dynamics
• scalable communication architectures

…will become increasingly important for building resilient autonomous systems.

The sky is no longer the limit.

It is the next intelligent frontier.

The post Building Smarter UAV Swarms: How Reinforcement Learning is Transforming Autonomous Target Tracking first appeared on Psyops Prime.]]> https://psyopsprime.com/ideas/building-smarter-uav-swarms-how-reinforcement-learning-is-transforming-autonomous-target-tracking/feed/ 0 https://creativecommons.org/licenses/by-nc-nd/4.0/ 2730 https://psyopsprime.com/ideas/teaching-machines-to-be-curious-a-step-toward-intelligent-uav-swarms/?utm_source=rss&utm_medium=rss&utm_campaign=teaching-machines-to-be-curious-a-step-toward-intelligent-uav-swarms https://psyopsprime.com/ideas/teaching-machines-to-be-curious-a-step-toward-intelligent-uav-swarms/#respond Wed, 25 Mar 2026 17:29:08 +0000 https://psyopsprime.com/?p=2723 Autonomous systems are often described as the future—but in many ways, they are still struggling with a very human problem: learning from delayed consequences. In

Autonomous systems are often described as the future—but in many ways, they are still struggling with a very human problem: learning from delayed consequences.

In reinforcement learning, this challenge is known as the delayed reward problem. An agent performs a sequence of actions, but the reward—or feedback—arrives much later. By then, it becomes difficult to determine which action actually led to success or failure. For systems operating in complex, dynamic environments—like unmanned aerial vehicles (UAVs)—this problem becomes even more pronounced.

In this post, I want to share insights from a research project focused on addressing this challenge in the context of multi-UAV systems, and how introducing a concept as simple—and as powerful—as curiosity can significantly improve learning.

---

The Problem with Learning Too Late

Imagine trying to learn how to fly a drone, but you only receive feedback minutes after making a mistake. You wouldn’t know what exactly went wrong. Reinforcement learning agents face a similar issue.

In UAV tracking tasks, for example:

• A drone may take dozens of actions before receiving a reward
• The learning signal becomes weak and noisy
• Training becomes unstable and slow

This is particularly problematic in real-time systems, where decisions must be made continuously and reliably.

---

Building a Realistic UAV Testbed

To study this problem, we developed a multi-UAV testbed that combines:

• A high-fidelity flight simulator (FlightGear)
• A Flight Dynamics Model (JSBSim)
• A real-time communication layer using UDP
• Reinforcement learning models integrated directly into the control loop

This setup allows UAVs to:

• Interact with a realistic environment
• Learn from continuous feedback
• Be evaluated under dynamic flight conditions

The goal was not just to simulate intelligence—but to create a platform where intelligent behavior can emerge.

---

A Hybrid Learning Approach

One of the key design decisions was to use different reinforcement learning strategies for different roles:

• The target UAV is controlled using Advantage Actor-Critic (A2C)
  → This ensures stable and predictable flight behavior
• The tracking UAV is controlled using Asynchronous Advantage Actor-Critic (A3C)
  → This enables parallel exploration and faster learning

This separation is important. In multi-agent systems, if all agents behave unpredictably, the environment becomes chaotic. By keeping one agent stable and allowing the other to explore, we create a balanced learning ecosystem.

---

Introducing Curiosity into Machines

The real breakthrough comes from integrating an Intrinsic Curiosity Module (ICM) into the learning process.

Instead of relying only on external rewards (e.g., “you successfully tracked the target”), the UAV also receives intrinsic rewards based on how surprised it is by new experiences.

In simple terms:

• If the UAV encounters something unexpected → it gets rewarded
• If it explores new states → it gets encouraged
• If it keeps doing the same thing → rewards diminish

This transforms learning in a fundamental way.

---

From Sparse Rewards to Continuous Learning

By combining external and intrinsic rewards, we effectively turn:

Sparse, delayed feedback
into
Continuous, meaningful learning signals

This allows the UAV to:

• Keep learning even when external rewards are absent
• Explore more effectively
• Adapt to changing environments in real time

Curiosity acts as a bridge over the gap created by delayed rewards.

---

What We Observed

The results were both encouraging and insightful:

• Traditional methods showed initial learning followed by instability
• The curiosity-driven approach demonstrated:
  • Smoother learning curves
  • Better exploration
  • More reliable tracking behavior

In practical terms, the tracking UAV was able to:

• Maintain pursuit more effectively
• Adapt to variations in the target’s movement
• Continue learning even in uncertain conditions

---

Why This Matters

Most UAV research focuses on:

• Flight control
• Navigation
• Multi-agent coordination

But relatively little attention is given to how these systems actually learn over time, especially under imperfect conditions.

This work highlights an important shift:

Instead of designing systems that rely solely on external feedback, we can build systems that motivate themselves to learn.

This idea has implications far beyond UAVs:

• Autonomous vehicles
• Robotics
• Smart surveillance systems
• Distributed AI systems

---

Looking Ahead

There is still much to explore.

Future directions include:

• Expanding to multi-UAV swarm coordination
• Incorporating vision-based perception
• Exploring advanced algorithms like Proximal Policy Optimization (PPO)
• Moving toward real-world deployment and digital twins

Each of these steps brings us closer to systems that are not just automated—but truly autonomous.

---

Final Thoughts

Curiosity is often seen as a uniquely human trait—the drive to explore, to learn, to understand the unknown.

But what happens when machines begin to exhibit the same behavior?

This research suggests that by embedding curiosity into artificial systems, we can overcome some of the most persistent challenges in learning—transforming hesitation into exploration, and delay into discovery.

And perhaps, in doing so, we move one step closer to building machines that don’t just follow instructions—but learn how to think for themselves.

The post Teaching Machines to Be Curious: A Step Toward Intelligent UAV Swarms first appeared on Psyops Prime.]]>

If you’ve ever dipped your toes into Digital Signal Processing (DSP), you’ve probably encountered the mythical beast known as the “complex plane” and its equally enigmatic resident, the imaginary number $j$ (or $i$ in math circles). For many, these concepts are where DSP goes from “a bit tricky” to “utterly bewildering.”

But what if I told you that, for engineers, j isn’t really “imaginary” at all? What if it’s actually one of the most practical, intuitive tools we have?

Richard Lyons, in his seminal “Understanding Digital Signal Processing,” has a gift for making these intimidating topics not just understandable, but obvious. Let’s unpack his wisdom and reveal the real-world power of j and the complex plane.

Step 1: Beyond the Number Line – The Complex Plane

Forget the simple, one-dimensional number line we learned in grad school. That line is great for showing “how much,” but in DSP, we often need to know “how much” and “where it’s at” in a cycle. Think of a spinning wheel: you need to know its speed and its current position.

Enter the Complex Plane.

Instead of a line, imagine a two-dimensional grid:

• The Horizontal Axis (Real Axis): This is your familiar number line. We use it to represent the “in-phase” part of a signal.

• The Vertical Axis (Imaginary Axis): This is the new kid on the block. It represents the “quadrature” (or 90-degree shifted) part of a signal.

Now, instead of just a single number, any point on this plane is a complex number, made up of a real part and an imaginary part. We write it as

, where

is the real part and

is the imaginary part.

Step 2: j – Not Imaginary, But a Rotational Operator!

Here’s where Lyons flips the script. Stop thinking of j as “the square root of -1” in a purely abstract sense. In DSP, j has a concrete, visual job: it’s a 90-degree counter-clockwise rotation operator ¹.

Let’s see it in action:

1. Start with a real number, say

   1

   , on the positive Real Axis.

2. Multiply

   1

   by j:

   1 * j = j

   . You’ve rotated

   1

   by 90 degrees counter-clockwise, and now you’re at

   j

   on the positive Imaginary Axis.

3. Multiply

   j

   by j again:

   j * j = j^2

   . You’ve rotated another 90 degrees. You’re now at

   -1

   on the negative Real Axis.

4. Multiply

   -1

   by j:

   -1 * j = -j

   . Another 90-degree rotation. You’re now at

   -j

   on the negative Imaginary Axis.

5. Multiply

   -j

   by $j$:

   -j * j = -j^2 = -(-1) = 1

   . One more 90-degree rotation brings you back to

   1

   on the positive Real Axis.

See? j isn’t making things disappear into some alternate reality. It’s simply turning things on a two-dimensional surface. This is the core insight that unlocks so much of DSP. This is the power of j. And j has brought us a long way.

Step 3: Spinning Signals – The Power of Phasors

Now, let’s bring it back to signals. Many real-world signals, like sound waves or radio waves, are sinusoidal—they oscillate up and down. Instead of describing them with messy sines and cosines, DSP engineers represent them as phasors: points that spin around the origin of the complex plane. Basically such waves do not oscillate up and down. They propagate from source to the sink in a helical manner.

The magic comes with Euler’s Equation:

This deceptively simple equation is the bedrock of modern DSP. It tells us that a complex exponential (the left side, which describes something spinning) is made up of a cosine wave (its projection onto the Real axis) and a sine wave (its projection onto the Imaginary axis).

Why is this a big deal?

• Simplification: Multiplying complex exponentials (which involves just adding their angles) is far easier than wrestling with trigonometric identities. Want to shift a signal’s phase? Just add an angle to its complex representation.

• Complete Picture: A single complex number can encapsulate both the amplitude (how big the signal is, represented by the length of the phasor) and the phase (where it is in its cycle, represented by its angle on the complex plane).

Step 4: The “Mystery” of Negative Frequency Solved

With the complex plane and spinning phasors in hand, “negative frequency” also becomes intuitive.

Imagine our phasor spinning.

• Positive Frequency: The phasor spins counter-clockwise.

• Negative Frequency: The phasor spins clockwise.

A real-world sine wave, the kind you measure with an oscilloscope, is actually the sum of two complex phasors: one spinning counter-clockwise (positive frequency) and one spinning clockwise (negative frequency). Their imaginary components cancel out, leaving only the real oscillation we observe.

On a spectrum analyzer, when you see a spike at 100 Hz, you’ll also see a mirrored spike at -100 Hz for a real signal. They are two sides of the same coin, both necessary to describe that single real cosine wave.

The Practical Benefit: By converting real signals into purely complex (or “analytic”) signals through techniques like Hilbert transforms, we can eliminate one of these mirrored frequencies. This effectively doubles our usable bandwidth and simplifies many advanced DSP operations, especially in communications systems (like radio and cellular data).

The Takeaway

Richard Lyons strips away the fear surrounding “imaginary” numbers by showing their practical utility. The complex plane isn’t an abstract mathematical playground; it’s a two-dimensional whiteboard where we can draw and manipulate signals more effectively.

Understanding j as a rotation, and grasping how phasors spin on this plane, unlocks the intuition behind powerful concepts like Euler’s Equation and negative frequency. These aren’t just theoretical constructs—they are the foundational tools that allow us to build everything from your smartphone to high-fidelity audio systems.

So, next time you see j, don’t be intimidated. Just remember: it’s simply turning things around, making the complex world of signals a whole lot clearer!

Artificial Intelligence systems are no longer confined to research labs. They influence decisions about loans, employment, healthcare, and criminal justice—domains where fairness is not optional. Yet, much of modern machine learning still treats fairness as a secondary concern: something to be fixed after a model has already learned its patterns.

One of the most persistent assumptions in this space is that fairness and accuracy are inherently at odds. Improve one, and the other must suffer. But is this trade-off inevitable—or is it simply a limitation of how we frame the problem?

In our recent work, A Multi-Objective Approach to Balance Fairness and Accuracy, we argue for a different perspective: fairness should be treated not as a constraint or post-processing correction, but as a first-class optimisation objective, explored alongside accuracy rather than subordinated to it. I would like to congratulate my co-authors about this who are: 1. the doctoral candidate Zahid Irfan, Dr. Roisin Loughran, and Professor Fergal Mc Caffery. Basically this is the work was done by Zahid, who is a colleague as well as a very close friend of mine.

Why Bias Persists in Machine Learning

Bias in AI systems often reflects deeper structural issues: biased data collection, historical inequalities, and spurious correlations that models eagerly exploit. When these correlations involve protected attributes—such as sex, age, or race—the resulting systems may achieve impressive accuracy while still producing unfair outcomes.

Traditional bias-mitigation approaches typically fall into three categories:

• Pre-processing, where the data is modified before training
• In-processing, where fairness is incorporated into the learning algorithm
• Post-processing, where predictions are adjusted after training

While all three have their place, many approaches operate largely as black-box fixes. They may improve a fairness metric, but often at the cost of interpretability and deeper understanding.

This is where causal modelling becomes essential.

Bringing Causality into the Picture

Correlation alone cannot tell us why a model behaves unfairly. Causal models, on the other hand, explicitly represent cause–effect relationships between variables.

We use Causal Bayesian Networks (CBNs)—directed acyclic graphs where nodes represent variables and edges encode causal influence. These structures allow us to reason about dependencies, confounders, and interventions, rather than relying solely on statistical association.

However, learning causal structures from data is a notoriously difficult problem. The search space of possible graphs grows exponentially, making exhaustive search infeasible.

To address this, we turned to Evolutionary Computation.

Evolving Causal Graphs with Grammatical Evolution

Our approach uses Grammatical Evolution (GE) to automatically generate and evolve causal graph structures. A context-free grammar constrains the search space to valid causal graphs, while still allowing a rich variety of structures to emerge.

Each individual in the evolutionary population represents a candidate causal graph. From this graph, we build a CBN, train it on data, and evaluate its performance.

Crucially, we do not evaluate performance using a single objective.

Fairness and Accuracy as Joint Objectives

Instead of collapsing everything into one score, we adopt a multi-objective optimisation framework using NSGA-II, a well-established evolutionary algorithm.

We optimise two objectives simultaneously:

1. Accuracy, measuring predictive performance
2. Fairness, measured using Equal Opportunity Difference (EOD), which captures disparities in true positive rates between protected groups

This produces not a single “best” model, but a Pareto front—a set of non-dominated solutions representing different fairness–accuracy trade-offs.

This is a powerful shift in mindset. Rather than asking “What is the best model?”, we ask:
“Which trade-off best fits the ethical and operational requirements of this domain?”

What We Observed

Using the German Credit dataset as a case study, our experiments showed that:

• It is possible to achieve very low fairness disparity while maintaining competitive accuracy
• Multiple causal graphs can yield similar performance, offering flexibility and interpretability
• The evolved graphs are non-trivial, capturing meaningful dependencies among features
• Practitioners can choose models that slightly sacrifice accuracy for substantial gains in fairness—or vice versa

Importantly, the causal graphs themselves provide insight. They allow us to inspect how features influence outcomes, opening the door to causal reasoning, domain validation, and future intervention analysis.

Why This Matters

Fair AI is not just about metrics—it’s about understanding.

By combining causality with multi-objective evolutionary optimisation, this work demonstrates that:

• Fairness does not have to be an afterthought
• Accuracy does not have to be blindly maximised
• Interpretability and performance can coexist

Most importantly, it reframes fairness as an optimisation problem, not a moral constraint imposed from outside the model.

Looking Ahead

Future directions include:

• Exploring additional fairness metrics to capture different notions of equity
• Extending experiments to larger and more diverse datasets
• Incorporating causal interventions and counterfactual analysis
• Further strengthening the link between ethical requirements and model design

As AI systems continue to shape society, approaches that integrate ethics, causality, and optimisation will be essential—not optional.

Fairness is not something we bolt onto AI.
It is something we design for

In mobile development,

(Android) and

(iOS) are the “go-to” tools for saving simple settings like a user’s theme preference or a “Remember Me” toggle. However, using these for session tokens or authentication secrets in a banking application is a critical security flaw.

Even on a non-rooted device, this practice exposes users to significant risks and fails to meet modern financial security standards.

The Risk: The “Backup” Backdoor

The primary risk of storing a session token in

on a non-rooted device is Unauthorized Data Extraction via Backups.

How the Attack Works

By default, Android’s backup system (via

or cloud sync) includes the application’s private data folder, where

files are stored as plain-text XML.

1. Physical Access: If an attacker gets physical access to an unlocked device for just a few minutes, they can trigger a backup to an external machine.
2. The Extraction: Because
   SharedPreferences

   is not encrypted by the OS, the attacker can extract the

   shared_prefs/*.xml

   file.

3. Session Hijacking: The attacker now has a valid, active session token. They can “replay” this token from their own device or a browser to bypass the login screen and gain full access to the victim’s bank account without ever needing the password or MFA.

The “Malware” Pivot

While Android isolates apps through “sandboxing,” vulnerabilities in the OS or other high-privilege apps can sometimes allow a malicious app to bypass these boundaries. If a token is stored in plain text, any process that manages to escalate privileges can scrape the token instantly.

The Modern Standard: Hardware-Backed Security

To meet modern security standards (like OWASP MASVS), sensitive data must be stored in a location that provides encryption at rest and hardware-level isolation.

The Secure Alternative: Android Keystore & EncryptedSharedPreferences

The correct approach for a banking application is to use the Android Keystore System in conjunction with EncryptedSharedPreferences.

1. Android Keystore (The Vault)

The Keystore does not store the token itself; it stores the cryptographic keys used to encrypt the token. These keys are stored in a Trusted Execution Environment (TEE) or a Secure Element (SE)—dedicated hardware on the phone that is physically isolated from the main Android OS. Even if the OS is compromised, the keys cannot be extracted.

2. EncryptedSharedPreferences (The Wrapper)

This is a part of the Jetpack Security library. It acts as a wrapper around the standard SharedPreferences but adds two critical layers:

• Value Encryption: Every value (like your session token) is encrypted using keys managed by the Keystore.
• Key Encryption: The keys themselves are protected, ensuring that even if an attacker steals the XML file, they see only encrypted gibberish.

Why This Works

If an attacker triggers a backup of an app using

, they will successfully steal the XML file, but they cannot steal the keys from the hardware-backed Keystore. Without the keys, the stolen session token is mathematically impossible to decrypt, rendering the backup attack useless.

Conclusion

For a banking application, “it works” is not enough. You must assume the device might be physically accessible to an attacker or that the software environment might be compromised.

By moving session tokens from standard

to hardware-backed EncryptedSharedPreferences, you ensure that the “keys to the kingdom” never leave the device’s physical security module.

In financial software, if the hardware isn’t protecting the secret, the secret isn’t protected.

In the world of medical IoT, the stakes aren’t just about data—they are about human life. Imagine a smart Continuous Glucose Monitor (CGM) that reports blood sugar levels to an insulin pump. If that device is compromised, the risk isn’t just a privacy leak; it’s a lethal dose of medication based on tampered data.

For manufacturers operating under extreme cost and hardware constraints (minimal RAM and processing power), every CPU cycle counts. In these scenarios, security architects must make a difficult choice: where do we spend our limited “security budget”?

The answer is clear: Secure Boot is mandatory, and it is significantly more critical for these devices than Full-Disk Encryption (FDE).

The Core Solution: Secure Boot

Secure Boot is a security standard that ensures a device boots using only software that is trusted by the Original Equipment Manufacturer (OEM).

How it Works

1. The Root of Trust: The device hardware contains a “Read-Only” public key burned into the chip during manufacturing.
2. Signature Verification: Every time the device powers on, the bootloader checks the digital signature of the firmware (the operating code).
3. The “Kill Switch”: If the signature doesn’t match—meaning the code has been altered by an attacker—the device refuses to boot. It effectively “bricks” itself rather than running untrusted code.

Why Secure Boot Trumps Encryption in Resource-Constrained IoT

While Full-Disk Encryption (FDE) is standard on laptops, it is often the wrong priority for a low-power medical sensor. Here is why Secure Boot is the superior control for a CGM:

1. Integrity is More Critical than Confidentiality

For a glucose monitor, the primary threat is unauthorized modification. An attacker who modifies the firmware can force the device to report “normal” sugar levels while the user is actually in a state of hypoglycemic shock.

• FDE protects data at rest (if the device is stolen).
• Secure Boot protects the logic of the system. In medical devices, ensuring the device does exactly what it was designed to do (Integrity) is a higher safety priority than ensuring the data on the device can’t be read (Confidentiality).

2. The Computational “Tax”

Encryption is “expensive.” FDE requires the CPU to constantly encrypt and decrypt data every time the system reads or writes to storage. On a device with minimal RAM and a tiny processor, this overhead can drain the battery in days rather than months and cause latency in life-critical readings.

Secure Boot, by contrast, is a one-time check. The “tax” is paid only at startup. Once the firmware is verified as authentic, the device runs at full speed without the ongoing burden of real-time decryption.

3. Preventing Persistence

Without Secure Boot, an attacker who finds a way to remotely access the device can install a “rootkit”—malicious code that stays on the device even after a reboot. Because the CGM is connected to the internet, it could become part of a botnet or a persistent gateway into the user’s home network. Secure Boot ensures that any such malicious changes are detected and blocked the moment the device restarts.

The Verdict

For a smart glucose monitor, the greatest risk is a “silent failure”—a device that looks like it’s working but is actually lying to the user. Secure Boot is the only way to guarantee that the firmware running on the device is the same code that was tested, validated, and signed by the manufacturer.

In resource-constrained medical design, we must prioritize Trust over Privacy. Secure Boot provides that trust without sacrificing the battery life and performance required to keep a patient safe.

In the world of industrial infrastructure, there is a common saying: “If it ain’t broke, don’t fix it.” This philosophy often leads to a dangerous reality: proprietary Industrial Control Systems (ICS) running mission-critical tasks on software that hasn’t seen a security patch in half a decade.

While these systems might be stable, they are “cryptographically brittle” and full of known vulnerabilities. The danger escalates exponentially when organizations attempt to integrate these legacy environments into a modern, internet-connected corporate network.

The Two Distinct Risks of “Merging” Worlds

When you connect a five-year-old, unpatched ICS to a modern IT network, you aren’t just adding a device; you are adding a permanent “beachhead” for attackers. There are two primary risks associated with this integration:

1. Targeted Exploitation (The Weakest Link)

Modern operating systems have advanced protections like ASLR, DEP, and automated patching. Legacy ICS software usually does not. An attacker doesn’t need to find a sophisticated zero-day exploit for your modern Windows 11 machines; they only need to find a five-year-old, public exploit for the ICS. Because the software is proprietary and unpatched, it represents a “static target.” Once an attacker identifies the software version, the exploit is often as simple as a single script found on a public repository.

2. Lateral Movement (The Pivot Point)

The most severe risk isn’t just the compromise of the ICS itself, but what happens next. In a typical corporate network, devices often “trust” one another. If an attacker gains a foothold on the vulnerable ICS, they can use it as a launching pad to move laterally across the network. From the ICS, they can sniff traffic, scan for vulnerabilities in the modern corporate servers, or attempt to steal administrative credentials. The legacy system becomes a “cloak” that allows the attacker to operate from inside your perimeter.

The Problem: You Can’t Patch It

In a perfect world, we would simply update the software. However, with proprietary ICS, the original vendor may no longer exist, or the update might require a complete hardware overhaul costing millions. When “fixing” the vulnerability is impossible, we must change the environment around the vulnerability.

The Mandatory Solution: Network Segmentation

Since we cannot eliminate the vulnerability, we must implement a Mandatory Compensating Control. The gold standard for legacy ICS is Network Segmentation via a “Demilitarized Zone” (DMZ) or VLAN.

How it Works:

Instead of allowing the ICS to sit on the same flat network as the accounting department and the mail server, it is placed in its own isolated “sandbox” (a separate VLAN).

The Implementation Details:

• Zero-Trust Connectivity: A firewall sits between the ICS segment and the rest of the corporate network. By default, all traffic is blocked. * The “Jumpbox” Pattern: If an engineer needs to access the ICS, they must first log into a highly secured, multi-factor authenticated “Jumpbox.” Only the Jumpbox is permitted to talk to the ICS, and only over a specific, monitored port.
• Protocol Filtering: The firewall should use Deep Packet Inspection (DPI) to ensure that only legitimate industrial protocols (like Modbus or OPC) are flowing, blocking any attempt at standard web traffic or file transfers that could indicate a breach.

Conclusion

Legacy ICS is a reality for many industries, from manufacturing to energy. You cannot always patch the software, but you can control the network. By treating your legacy systems as “untrusted” and isolating them through strict network segmentation, you ensure that a vulnerability in a five-year-old piece of software doesn’t lead to a total compromise of your modern enterprise.

In the age of interconnected systems, isolation is often the best form of protection.

Exploit Mitigations: ASLR and DEP

Address Space Layout Randomization (ASLR) and Data Execution Prevention (DEP) are “exploit mitigation” technologies. They do not fix underlying code vulnerabilities (like buffer overflows), but they make it significantly harder for an attacker to successfully turn a bug into a working exploit.

1. ASLR (Address Space Layout Randomization)

The Concept: Imagine a thief trying to rob a house who knows exactly where the safe is located in every home in the neighborhood. ASLR is the equivalent of randomly rearranging the floor plan of every house so the thief doesn’t know where the safe is.

How it Works:

• Randomization: Every time an application or the operating system boots, ASLR randomly arranges the address space positions of key data areas. This includes the base of the executable, as well as the positions of libraries (DLLs), the heap, and the stack.
• The Defense: In a classic “buffer overflow” attack, an attacker needs to point the CPU to a specific memory address where their malicious code is hidden. If the memory addresses change every time the program runs, the attacker’s hard-coded address will point to empty space or invalid memory, causing the application to crash rather than execute the payload.

2. DEP (Data Execution Prevention)

The Concept: DEP marks specific areas of memory as “non-executable.” It enforces a strict rule: a memory page can either hold data (like a document or a user’s input) or it can hold instructions (code), but it should rarely do both.

How it Works:

• The “NX” Bit: DEP leverages hardware support (the “No-Execute” bit in modern CPUs). The operating system marks memory regions used for data (the stack and heap) as non-executable.
• The Defense: In many attacks, a hacker tries to “inject” code into a data field (like a username box) and then trick the computer into running that code. With DEP enabled, even if the attacker successfully places code in the memory, the CPU will refuse to execute it because that section of memory is flagged for “Data Only.”

How They Work Together

ASLR and DEP are most effective when used in tandem:

1. DEP stops the attacker from running code they’ve placed in data regions.
2. ASLR stops the attacker from reliably finding existing, “safe” code snippets within the system (like system libraries) that they might try to stitch together to bypass DEP (an attack known as Return-Oriented Programming or ROP).

In the context of your Legacy ICS software, these systems often lack these protections. This means an attacker doesn’t have to “guess” where memory is located, and they can execute code directly from the stack, making the system a “sitting duck” compared to a modern Windows or Linux machine.