ML Interview Q Series: No Free Lunch Theorem: Why Assumptions Matter in Machine Learning Model Selection.

📚 Browse the full ML Interview series here.

No Free Lunch Theorem: State the “No Free Lunch” theorem in the context of machine learning. What are the practical implications of this theorem for selecting or designing a model for a given problem? *Explain why one algorithm cannot be universally best for all problems, and how assumptions about the problem domain guide model selection.*

Understanding the No Free Lunch (NFL) theorem in machine learning can illuminate many core principles of model selection and algorithmic design. At its heart, the theorem asserts that when performance is averaged over all possible problems, all algorithms have the same overall efficacy. The crucial insight is that no single algorithm can outperform all others across every possible data-generating scenario. This means that building assumptions (or biases) into the learning model becomes necessary in order to achieve good performance on specific types of problems. Below is a detailed exploration of the concept, including how it is formally stated, why it holds, how it impacts our algorithm choices, and how domain assumptions come into play.

Why the No Free Lunch Theorem Matters

In machine learning, we often look for the “best” model or algorithm to handle a variety of tasks. While certain general-purpose methods often work well in practice (like neural networks or gradient-boosted trees on a wide range of structured tasks), the NFL theorem tells us that no model can be guaranteed to excel at every conceivable problem distribution. It implies that any performance advantage a model gains on one family of tasks (due to certain assumptions it makes) will be offset by inferior performance on other families of tasks where those assumptions do not hold.

Core Statement of the No Free Lunch Theorem

In very broad strokes, the theorem is often described like this: If one averages the performance of a learning algorithm over all possible ways the data (or labels) could be generated, then every algorithm ends up with the same average performance. More concretely, let us imagine that there is a vast space of all possible data-generating distributions. Summing or averaging an algorithm’s expected error (or expected accuracy) over all these distributions yields the same value for every possible algorithm.

One typical (informal) way to think about it is:

Expected Performance Over All Problems=constant

where “constant” is the same for any algorithm, meaning there is no single winner that beats others over that entire space of distributions.

In simpler terms, there is no universally optimal solution—if you assume nothing specific about the problem, then no single algorithm is guaranteed to be better than the rest in all scenarios. However, once you start to bring in some prior knowledge about the structure or nature of the data, certain algorithms can gain an advantage because they incorporate inductive biases aligned with that problem domain.

Implications for Model Selection

The theorem implies that a learning algorithm’s success hinges on how well its intrinsic assumptions align with the actual data distribution:

• If you have reason to believe your data is linear or near-linear, linear models can be very powerful and sample-efficient compared to more complex models that do not assume linearity. • If your data is known to have a hierarchical or compositional structure (for example, images, text, or other forms of high-dimensional signals), deep neural networks—particularly convolutional or transformer-based architectures—can significantly outperform other approaches. • If your features have complex interactions, tree-based methods might do well. • If you suspect chaotic behavior or no stable structure at all, it becomes much more difficult to choose a particular model, because the NFL theorem essentially says that without assumptions, you cannot guarantee performance improvements over simpler or random baselines.

Why There Cannot Be a Single Best Algorithm for All Problems

The intuitive reason is that learning algorithms rely on certain biases or assumptions—often called inductive biases—that help them generalize from limited data. A neural network with convolutional layers, for instance, assumes local spatial correlations in images, which helps it learn effectively when that assumption is correct. However, if you fed it data where this assumption is not just unhelpful but outright misleading, then a simpler or entirely different method might outperform the network.

Any algorithm that tries to do well across many tasks is effectively embedding certain assumptions about what those tasks look like. If those assumptions match the tasks you care about, then that algorithm can do well. But if your domain deviates drastically from those assumptions, there is little reason to expect that same algorithm to work well.

Role of Domain Assumptions

In practice, selecting or designing an algorithm always involves domain knowledge. For example:

• When dealing with text data (like language modeling), you might suspect that attention mechanisms and token embeddings are beneficial—hence Transformer-based models. • When dealing with streams of sensor data, you might choose specialized methods that handle time-series forecasting well. • When dealing with images, you might choose convolutional neural networks (ConvNets) because they incorporate the prior that “spatially close pixels tend to be more correlated.”

Your assumptions about how the real-world data is structured and which patterns are most significant guide you to choose the right hypothesis space. This is precisely why the NFL theorem guides us to incorporate domain knowledge. There is no universal free lunch, so we rely on the lunch that is specialized to the domain in which we work.

Trade-Offs and Practical Decisions

Because no single algorithm can be the best under all circumstances, practitioners often rely on:

• Cross-validation and hyperparameter tuning (to empirically test how well different algorithms perform on actual data). • Domain-specific heuristics and knowledge (to prune the vast space of methods down to those that incorporate relevant biases for the task). • Ensemble methods (to combine the strengths of multiple algorithms and average out their weaknesses).

The NFL theorem is not saying that performance is always the same on your real-world dataset; rather, it says that across all possible (theoretical) data distributions, the average performance evens out. In real applications, we do not sample from the entire space of distributions. Instead, we focus on a specific distribution or a family of distributions. Hence, in practice, certain algorithms can—and do—excel because their biases are better aligned with the domain at hand.

Code Example Demonstrating Different Algorithms on Different Synthetic Tasks

Below is a minimal Python snippet illustrating how different algorithms might excel on different synthetic datasets. Note that no single algorithm will be the best across all tasks.

py import numpy as np from sklearn.datasets import make_classification, make_circles from sklearn.model_selection import train_test_split from sklearn.svm import SVC from sklearn.neighbors import KNeighborsClassifier from sklearn.ensemble import RandomForestClassifier from sklearn.metrics import accuracy_score

Generate two synthetic datasets

X1, y1 = make_classification(n_samples=1000, n_features=5, n_informative=3, n_redundant=0, random_state=42) X2, y2 = make_circles(n_samples=1000, factor=0.5, noise=0.1, random_state=42)

Split into train/test

X1_train, X1_test, y1_train, y1_test = train_test_split(X1, y1, test_size=0.3, random_state=42) X2_train, X2_test, y2_train, y2_test = train_test_split(X2, y2, test_size=0.3, random_state=42)

Define multiple models

models = { "SVM": SVC(), "KNN": KNeighborsClassifier(), "RandomForest": RandomForestClassifier(random_state=42) }

for name, model in models.items(): # Train on dataset 1 model.fit(X1_train, y1_train) pred1 = model.predict(X1_test) acc1 = accuracy_score(y1_test, pred1)

# Train on dataset 2
model.fit(X2_train, y2_train)
pred2 = model.predict(X2_test)
acc2 = accuracy_score(y2_test, pred2)

print(f"{name} - Dataset1 Accuracy: {acc1:.3f}, Dataset2 Accuracy: {acc2:.3f}")

In this example:

• An SVM might work very well on the linearly separable (or near-linearly separable) dataset but might struggle if the data geometry is more complex without a suitable kernel. • KNN can perform well in local neighborhoods if the data manifold is distributed in certain ways, but it might struggle when the dimensionality grows or if the data distribution is unusual. • A Random Forest might handle certain patterns better but might not always excel if the dataset size is small or if hyperparameters are not tuned.

The results will likely show that none of these three is strictly superior for both datasets. Each has its strengths and weaknesses, reflecting the NFL theorem’s notion that no single algorithm is universally best.

How the Theorem Affects Real-World Practice

In real-world scenarios, you never deal with all possible data distributions; you care about specific tasks:

• Image recognition with natural images. • Speech recognition with human voice recordings. • Predicting click-through rates on a certain website’s user data.

Once you narrow the scope, you can exploit domain knowledge. That is why carefully incorporating relevant assumptions and collecting meaningful features are so critical. Practically, the NFL theorem encourages experimentation and domain-driven model design rather than blind reliance on a single method.

Interpretation and Edge Cases

It is important to note that the NFL theorem is sometimes misunderstood. It does not claim that all algorithms behave identically on real-world tasks. Instead, it specifically focuses on average performance across the entire space of all possible data distributions (including pathological or adversarial ones). In practice, we usually focus on a relatively small subset of possible distributions—those relevant to real problems—so certain algorithms indeed tend to perform better than others within those distributions.

Another edge case to consider is how “algorithm” is defined. If you define a particular learning algorithm to be a large ensemble that effectively includes many possible forms of bias, you might approach a more universal method. Yet even then, the ensemble is not truly universal because it can fail if you face entirely different data properties or constraints (e.g., massive domain shift, data-limited scenarios, extremely high noise).

How might the NFL theorem tie in with overfitting and generalization?

Overfitting occurs when a model memorizes training data instead of learning generalizable patterns. The NFL theorem does not directly say “overfitting will or won’t happen,” but it does suggest that if you try to create a very flexible algorithm that can model any form of data, you might do poorly on certain structured domains if you have not constrained the model or used appropriate regularization.

In other words, the NFL theorem underscores that you cannot avoid making assumptions. If you do not build in suitable biases or constraints, your method could overfit easily—or it might not find the right structure at all.

How does the theorem relate to Occam’s Razor or simplicity in models?

Inductive biases often reflect a preference for simpler explanations or a preference for explanations that fit a certain pattern. Occam’s Razor is a common heuristic used in science and machine learning: prefer simpler models if they explain the data well. Under the NFL theorem, if your data truly arises from a simple relationship, simpler models aligned with that simplicity might perform better. However, if your data arises from something complex that doesn’t match your prior assumptions, simpler models might fail. Thus, the “simplicity bias” is just one example of domain assumption that might or might not pay off depending on the problem.

How do ensemble methods or neural network architectures circumvent the NFL theorem?

They do not truly “circumvent” it. Instead, ensembles and large neural architectures integrate multiple forms of bias, making them more adaptable to a variety of tasks. But the fundamental statement remains: there is still no guaranteed universal best performance across all possible distributions. In practice, these methods often do well because real-world tasks are not arbitrary; they exhibit structure that deep networks or ensemble methods can capture. However, in a domain that is misaligned with those structural assumptions, these methods might fail or at least underperform simpler alternatives.

What are some subtle pitfalls when citing the NFL theorem in an interview?

One pitfall is to assume that the theorem implies that “all algorithms are equally good for everything.” That is not the correct reading. Another pitfall is to ignore the fact that we rarely care about performance on “all possible distributions.” Instead, we focus on the distribution(s) relevant to the problem at hand. Yet another subtlety is that “No Free Lunch” does not say we should not do model selection; rather, it says that model selection relies on domain knowledge to yield a performance advantage.

Follow-up Question 1

How does the No Free Lunch theorem address the role of hyperparameter tuning for a given model? Doesn’t tuning or searching over hyperparameters allow a single model class to adapt well to multiple domains?

Hyperparameter tuning does help your model adapt to certain domains, and it can significantly improve performance in practice. However, this adaptation is still predicated on the assumption that there is a subset of hyperparameters that best fit a particular distribution of data. While you might have a flexible model class (e.g., a deep neural network) with many hyperparameters, you are still embedding specific biases in the architecture: convolution filters for images, or attention mechanisms for language tasks, etc. Hyperparameter tuning does not fully negate the effect of assumptions. Instead, it fine-tunes them, but you still cannot escape the fundamental principle that, on average over all possible data distributions, there is no single guaranteed best approach.

It is also worth noting that hyperparameter tuning is guided by performance on validation data drawn from the same (or similar) distribution as your training set. If the underlying problem changes significantly or the data distribution shifts, the previously tuned hyperparameters might not be optimal anymore. This again connects back to the NFL theorem: if you switch to a completely different domain, your carefully tuned model might be outperformed by something else that aligns better with the new domain’s structure.

Follow-up Question 2

Is there any relationship between the No Free Lunch theorem and computational complexity? Could we say that more computationally powerful models can “escape” the constraints of the theorem?

Even if you have a vastly more powerful computational model, the NFL theorem still applies theoretically. A more computationally powerful model or algorithm can explore a larger hypothesis space, but this also broadens its potential for mismatches with certain data distributions. If your data distribution aligns well with certain complex patterns, a powerful model might excel. But across the entire space of possible distributions, any advantage it has in one subset will be offset by disadvantages in another subset.

Moreover, computational complexity is about how quickly or feasibly you can find a good solution. The NFL theorem is about the average accuracy or error on unseen data across all possible distributions. They address somewhat different questions. You can have an extremely fast or extremely large model, but the theorem tells us that, overall, it does not universally outperform simpler or smaller models unless the distribution of tasks is restricted in some way.

Follow-up Question 3

If the No Free Lunch theorem states that no algorithm is universally best, how can we justify the popularity of certain methods, like deep learning, which are used for so many different tasks?

Deep learning methods often include strong and useful inductive biases for many real-world data types (images, speech, text). For instance, convolutional neural networks exploit local correlations in images; recurrent or transformer models exploit sequential and contextual patterns in text. In essence, our real-world data is far from random—most tasks exhibit regularities, compositional structure, or hierarchical patterns. Neural networks have proven adept at capturing these patterns when given sufficient data and computational resources.

Thus, deep learning methods might appear to circumvent the NFL theorem because their biases match large classes of real-world tasks. But if you consider truly exotic distributions where these biases do not hold (e.g., deliberately scrambled or random data), deep networks might perform no better than simpler approaches or might even perform worse. Popular methods succeed in practice because the real-world domain of interest is usually not adversarial or randomly generated, but structured in ways that deep learning models can leverage.

Follow-up Question 4

What strategies do data scientists use in practice to cope with the reality of the No Free Lunch theorem?

They rely on a combination of experimentation, domain expertise, and established best practices:

They gather domain knowledge about the structure and nature of the data. For instance, a data scientist working with satellite imagery might know that certain types of features in the data correlate with atmospheric conditions, and they incorporate that knowledge when designing or choosing a model. They systematically run experiments comparing different algorithms (cross-validation, hold-out sets, etc.) to see which approaches work best in the real-world distribution of interest. They frequently use ensemble methods (e.g., random forests, gradient-boosted trees, or ensembles of neural networks) to combine multiple inductive biases into one system. This helps reduce the risk that a single set of assumptions fails catastrophically. They continuously monitor model performance in production to detect distribution shifts or concept drift. This aligns with the NFL principle because if the underlying distribution changes, the existing method might no longer perform as well as it did initially. They refine models over time and update their assumptions. Machine learning, especially in production, tends to be a continuous cycle of improvement, data augmentation, new features, and iterative tuning.

---

Below are additional follow-up questions

If the data distribution changes over time (concept drift), what does the No Free Lunch theorem imply about continuously maintaining and retraining models?

Concept drift occurs when the statistical properties of the target variable or features change over time. This means your model, which was trained on historical data, might no longer match the new data distribution that emerges later. The No Free Lunch (NFL) theorem reinforces the notion that no single algorithm can remain optimal across all possible distributions—especially if those distributions shift over time.

In practice, one must set up processes to continually monitor the environment and periodically update or retrain models. The main issue is that there is no universal “best” or “immune” algorithm for all distributions; when concept drift arises, the mismatch between training assumptions and new data can degrade performance. This leads to:

• Incremental or online learning approaches: Some algorithms (e.g., certain forms of gradient-based models or online updates for Naive Bayes) allow you to update the model as new data arrives. This partial re-training helps align the model’s assumptions with the shifting distribution.

• Model refresh cycles: Larger-scale production systems might periodically retrain from scratch on the most recent data. However, the NFL theorem implies that if the new distribution drastically deviates from previous assumptions, even a retrain might not help unless you incorporate updated assumptions that match the new data.

• Domain-specific knowledge for drift detection: Domain knowledge can reveal typical drift patterns (for instance, seasonal fluctuations in e-commerce). Early detection of drift is crucial, because the NFL theorem tells us that, without continued alignment between assumptions and actual data patterns, even advanced models can fail.

Pitfalls and edge cases:

• If you rely on a single, rigid model architecture without verifying whether the domain has changed, performance may suddenly collapse.

• Even ensembling multiple models might not help if none of them has an inductive bias aligned with the new domain distribution.

• Over-fitting to newly drifted data can cause the model to lose generality if the distribution oscillates or reverts to an older state.

In reinforcement learning (RL) contexts, does the No Free Lunch theorem still hold, and how does it affect strategy selection?

Reinforcement learning deals with agents acting in an environment to maximize a reward signal. The environment’s dynamics, reward function, and possible states and actions form the “data distribution” from which the agent learns. The NFL theorem continues to apply conceptually: across all conceivable RL problems (environments), no single RL algorithm or policy search method is universally best.

• Strategy selection: Different RL algorithms (like Q-learning, policy gradients, actor-critic, or model-based RL) embed different assumptions about how the environment behaves and how best to explore it. One strategy might excel in environments with sparse rewards if it includes sophisticated exploration, but it could struggle in environments with dense or deceptive reward structures.

• Domain-driven inductive biases: For instance, if you have a robotics control problem with continuous state spaces, you might prefer actor-critic methods that handle continuous actions gracefully. If you have a discrete grid-world with well-defined transition probabilities, tabular Q-learning or a value-iteration approach might be more direct.

• Pitfalls:

  • Adversarial or rapidly changing environments can invalidate an algorithm’s assumptions.

  • Overemphasizing exploration or exploitation without domain insights can lead to suboptimal or unstable policies.

  • Sim2Real transfer (training in simulation, then deploying in real-world robots) can fail if the real environment deviates heavily from the simulation; the NFL theorem implies that an algorithm tuned for a simulation might be suboptimal for the real environment unless the simulation is a close match.

How do meta-learning or automated machine learning (AutoML) approaches relate to the NFL theorem?

Meta-learning and AutoML systems attempt to learn how to learn, often by automatically searching over model families, hyperparameters, or data transformations for a given task. While these methods can appear powerful because they “adapt” to many different tasks, the NFL theorem is still in effect:

• Why it applies: Even if you search over a large space of models and strategies, you still implicitly encode assumptions—for example, the set of model architectures you allow, the types of hyperparameters you consider, or the meta-learning updates you define. If the true data distribution resides far outside the regions covered by those assumptions, performance can degrade.

• Adaptive advantage: By searching across multiple algorithms or parameter settings, meta-learning can find (locally) best fits for a given distribution. It effectively helps you pick the right inductive bias from a curated library of biases. This can give an advantage in many practical tasks (e.g., image recognition or structured data classification), but it does not guarantee universal optimality.

• Pitfalls and edge cases:

  • If the search space is too large and not guided by relevant domain knowledge, the process can be computationally expensive or converge to suboptimal solutions.

  • Distribution shift can break the meta-learned strategy if the new distribution differs significantly from the ones used to train the meta-learner.

  • Automated pipelines might inadvertently overfit to the tasks in the meta-training set, failing when a new problem is structurally dissimilar to any of those tasks.

Could a Bayesian approach “beat” the NFL theorem by incorporating prior knowledge about distributions?

Bayesian methods explicitly incorporate a prior distribution over model parameters or structures, then update those priors in light of observed data. While this can lead to robust inference and potentially better generalization, it does not circumvent the NFL theorem in the broad sense:

• Why not: The Bayesian prior encodes assumptions about the problem. If the real-world distribution aligns with those assumptions, Bayesian updating can yield excellent results. But if your prior is mismatched, you might converge to poor posteriors, or require enormous amounts of data to overcome the misleading prior.

• Benefits of Bayesian frameworks:

  • They can elegantly quantify uncertainty, which is helpful when data is limited or noisy.

  • They allow you to incorporate domain expertise in the form of structured priors (e.g., expecting smoothness or certain parameter constraints).

  • They can handle model comparisons in a principled way.

• Pitfalls and edge cases:

  • If the prior is overly restrictive or too complicated, you might end up with a model that is computationally intractable or poorly aligned.

  • In high-dimensional spaces (as common in deep learning), specifying a good prior is non-trivial. A generic or uninformative prior might not yield significant improvements unless you have vast data.

  • The NFL theorem still implies that across all hypothetical data distributions, a Bayesian method that is tailored to some distributions can fail in others.

Does the No Free Lunch theorem have any implications for interpretability methods like feature importance, SHAP values, or LIME?

Interpretability techniques aim to shed light on how a model makes its predictions. While the NFL theorem primarily focuses on performance rather than interpretability, there are some indirect implications:

• Model interpretability is also domain- and context-specific: If your model’s inductive biases align well with real-world data, you might produce explanations that are more stable and consistent. Conversely, if your model’s assumptions are weakly matched to the data, you might see erratic or non-intuitive explanations.

• Choice of interpretability method depends on assumptions: LIME, SHAP, and other techniques each make assumptions about linear approximations or additive feature contributions. In distributions that starkly violate these assumptions, the explanations might be misleading.

• Pitfalls:

  • Over-reliance on interpretability methods for complex models can lead you to incorrectly trust a model that is misaligned with the data distribution.

  • If the underlying model’s performance is poor (due to mismatch with the domain), interpretability might simply confirm that the model is not capturing the correct relationships.

How do specialized architectures (e.g., graph neural networks for graph-structured data) illustrate the NFL theorem’s main point about inductive biases?

Graph neural networks (GNNs) incorporate layer designs tailored to graph-structured data (nodes, edges, adjacency relationships). This is a strong inductive bias: the model assumes that node features depend on neighbor features in ways that can be propagated through the graph.

• Alignment with the domain: When data is naturally expressed as graphs (social networks, molecular structures, knowledge graphs), GNNs often excel precisely because they use the assumption that edges and neighbors matter. This can yield dramatic performance advantages over general-purpose methods.

• Mismatch scenario: If you apply a GNN to data that does not have meaningful graph structure (or if the relationships are better captured by other forms), then the GNN’s assumptions become liabilities, and another method might outperform it.

• NFL theorem takeaway: GNNs can be optimal for a class of tasks where the graph assumption holds, but they are not a universal solution for all machine learning tasks.

• Potential pitfalls:

  • If you incorrectly define the graph structure (e.g., the edges do not reflect true relationships), GNN performance might degrade.

  • GNNs often require careful handling of large or dynamic graphs, raising computational and memory complexity issues.

Could quantum computing or other emerging paradigms circumvent the No Free Lunch theorem?

Quantum computing and other novel paradigms (e.g., neuromorphic hardware) may offer substantial computational speedups or different ways of encoding information, but they do not fundamentally bypass the NFL theorem:

• Theory remains: The NFL theorem is about algorithmic performance averaged over all possible data distributions. Having faster or more efficient computation does not change the fact that you must embed domain-specific assumptions to achieve strong performance on a given subset of problems.

• Possible advantages:

  • Quantum algorithms might sample from certain probability distributions more efficiently or factorize large numbers more quickly (for cryptography), but that is highly domain-specific.

  • Some aspects of neuromorphic or biologically inspired hardware could better match certain tasks that rely on spiking neural networks or event-driven architectures.

• Pitfalls:

  • Even if a quantum model can evaluate certain transformations quickly, if the real-world data distribution lacks the structures exploited by those transformations, it will not confer a universal advantage.

  • Overestimating the generality of next-generation computing can lead to misallocations of resources and effort if the underlying domain does not require those specialized capabilities.

In situations of extreme data scarcity, can the No Free Lunch theorem guide how we should incorporate expert rules or symbolic knowledge?

When data is sparse, purely data-driven learning can falter because there are not enough examples to accurately estimate parameters or discover patterns. The NFL theorem implies that if you rely solely on an algorithm with little domain-specific structure, it might fail catastrophically. Incorporating expert knowledge (sometimes in the form of symbolic rules, constraints, or specialized features) is often the key:

• Why domain knowledge helps: It effectively narrows the hypothesis space to those consistent with expert insights. This can drastically improve performance if the domain knowledge is correct and relevant.

• Hybrid systems: For instance, combining machine learning with rule-based expert systems can create strong biases that help generalize from limited data. You are effectively injecting powerful assumptions that direct the learning process.

• Pitfalls:

  • Incorrect or outdated expert rules can degrade the model; it might overfit to erroneous assumptions.

  • If the domain is novel and experts are not truly sure about the underlying mechanisms, heavily relying on guesswork can lead to systematically biased predictions.

  • Balancing symbolic rules with data-driven learning (e.g., deciding which to prioritize when they conflict) can be non-trivial.

How does the No Free Lunch theorem connect with fairness and bias issues in machine learning?

Fairness and bias involve ensuring that models do not systematically disadvantage certain groups or produce inequitable outcomes. While the NFL theorem does not directly address ethical or social concerns, there are conceptual overlaps:

• Need for assumptions to ensure fairness: To achieve equitable results, you must embed fairness constraints or ethical assumptions into model training. If you do not, the model’s inductive biases might inadvertently learn or exacerbate existing societal biases. The NFL theorem says no single unconstrained algorithm is universally best, which means adding fairness constraints is another form of domain or ethical bias.

• Pitfalls:

  • If fairness constraints do not match real-world requirements or if they are too generic, they could degrade performance for certain subsets of the population.

  • If you assume a certain definition of fairness (e.g., demographic parity vs. equalized odds), you might do well under that metric but fail under other fairness definitions. This parallels the idea that no universal performance measure is optimal for all tasks.

• Practical takeaway: The NFL theorem highlights that your success depends on the alignment between the model’s assumptions and the problem’s realities. In fairness contexts, “realities” includes ethical and social expectations as well as technical constraints.