You have a dataset with multiple variables. Some are related, others aren't. How do you map out this web of relationships? The goal of structural learning is to take this raw, observational data and reverse-engineer the underlying Directed Acyclic Graph (DAG) that likely generated it. This isn't just about finding correlations; it's about defining a model of dependencies and, crucially, independencies.

Imagine trying to untangle a set of Christmas lights by only seeing which bulbs light up together. It's a tricky puzzle. In machine learning, two main strategies have emerged to solve this: score-based methods, which are like judging a bake-off by tasting every cake, and constraint-based methods, which use a process of elimination.

Before diving into methods, we hit a fundamental snag. Can we even find the one true graph from data? Often, the answer is no. Different DAG structures can sometimes describe the exact same set of conditional independencies. These graphs are said to be in the same Markov Equivalence Class and are statistically indistinguishable from one another based on observational data alone.

For example, a graph where $X \rightarrow Y \rightarrow Z$ implies the same independence ($X$ is independent of $Z$ given $Y$) as $X \leftarrow Y \leftarrow Z$ and $X \leftarrow Y \rightarrow Z$. All three belong to the same equivalence class. However, a structure like $X \rightarrow Y \leftarrow Z$, known as a v-structure or collider, is unique. Here, $X$ and $Z$ are independent, but become dependent when we condition on $Y$.

To make any progress, we must make the Faithfulness Assumption. This is a leap of faith where we assume that all the conditional independencies we find in our data are a direct consequence of the graph's structure, and not just random chance or a weird coincidence of parameters. It allows us to trust the data as a map to the underlying structure.

The first major approach to structural learning is to turn it into a search problem. Score-based methods work in two steps:

1. Define a scoring function that measures how well a given DAG explains the data.
2. Search through the vast space of possible DAGs to find the one with the best score.

Since testing every possible graph is computationally impossible for more than a handful of variables, we rely on heuristic search algorithms like greedy hill-climbing. These start with a simple graph (like one with no edges) and iteratively make small changes—adding, removing, or reversing an edge—that improve the score, until no more improvements can be found.

A popular scoring function is the Bayesian Information Criterion (BIC). It elegantly balances model fit with model complexity. A complex graph with many edges will always fit the training data better, but it's likely overfitting. The BIC penalizes complexity, favoring simpler graphs that generalize better.

Constraint-based algorithms take a different tack. Instead of searching for the best score, they use a series of statistical tests for conditional independence to rule out connections. The most famous example is the PC algorithm (named after its creators, Peter Spirtes and Clark Glymour).

The PC algorithm works in three main steps:

1. Build the Skeleton: Start with a fully connected undirected graph. Then, for every pair of nodes (A, B), test if they are independent. If they are, remove the edge. Next, test if they are independent given a third node C. If so, remove the edge. Continue this process, conditioning on larger and larger sets of nodes, until no more edges can be removed. What's left is the undirected 'skeleton' of the graph.

2. Identify V-Structures: Go through the skeleton and find all uncoupled triples A-C-B. If A and B were not found to be independent conditioned on the set that separated them earlier, but they are independent without conditioning on C, then you have a v-structure: $A \rightarrow C \leftarrow B$. This is the only orientation you can determine with certainty at this stage.

3. Orient Remaining Edges: Apply a set of logical rules to orient as many of the remaining edges as possible, ensuring no new cycles or v-structures are created. For example, if you have $A \rightarrow B - C$, you must orient the second edge as $B \rightarrow C$ to avoid creating a new v-structure at B.

Once you have a DAG structure, whether from a score-based or constraint-based method, the final step is to quantify the relationships. This means estimating the Conditional Probability Table (CPT) for each node. A CPT specifies the probability of a node being in a certain state, given the states of its parents.

Estimating these is typically done using Maximum Likelihood Estimation. In simple terms, you just count. To find the probability of node B being 'true' when its parent A is 'false', you look at all the rows in your data where A is 'false' and calculate the fraction of those rows where B is 'true'. These CPTs, combined with the graph structure, fully define your Bayesian Network.

Understanding these structural learning methods is key. They form the basis for discovering dependencies in complex systems and provide the 'weak learner' components that can be combined in more advanced ensemble frameworks.