Boost Graph Library graph generation function issues

Ive been attempting to learn some graph theory for a personal project. I'm also trying to use the Boost Graph Library to perform these tasks.
The function below is an attempt to generate spanning tree graphs using the provided random_spanning_tree function and then connect parts of them randomly, but I cannot get the provided function to return the predecessor map in a working way.

Currently I declare the predecessor map and pass it into the random_spanning_tree function. the output is not what I am expecting. Using gdb, I can determine that the data structure is just that of the simply connected line graph the make_connected function builds, as well as large number which is what im assuming all of my data is being saved into in the 0th cell. I have included an image of the debug output for clarity. Clearly I am either not initializing or passing in the predecessor map correctly as all of my data is being saved into the first cell. Does anyone have any idea where I am going wrong?
Any help is greatly appreciated as Ive been trying to figure this out for the better part of a day.

image of predecessor map data after running the random_spanning_tree function:
gdb watched variable

Source:

struct VertexData
{
    int num;
    int pred;
    int dist;
};

struct EdgeData
{
    double dist;
};

typedef adjacency_matrix<undirectedS, VertexData, EdgeData > Graph;
typedef graph_traits<Graph>::vertex_descriptor Vertex;

Graph generateConnectedGraph2(int numVertices, double connectionProbability) {
    Graph graph(numVertices);
    std::random_device rand;
    random::minstd_rand gen(rand()); //Seeded Random number generator

    make_connected(graph);

    //build a minimally connected graph for the random spanning tree

    std::vector<double> xPos(num_vertices(graph));
    std::vector<double> yPos(num_vertices(graph));

    bool isPlanar = false;

    std::vector<Vertex> predecessor(numVertices);  // Predecessor map
    predecessor[0] = 0;  // Set the root vertex to 0
    // Generate random edges to create a connected graph
    random_spanning_tree(graph, gen, predecessor_map(make_iterator_property_map(predecessor.begin(), get(vertex_index, graph) )));
    
    printAdjMatrix(graph, numVertices);
    
    applyPredecessorMap(graph, predecessor);
    printAdjMatrix(graph, numVertices);
    
    // Iterate over each pair of vertices and potentially add an edge
    for (Vertex u = 0; u < numVertices; ++u) {
        for (Vertex v = u + 1; v < numVertices; ++v) {
            if (u != v && u != numVertices && !edge(u, v, graph).second && random::bernoulli_distribution<>(connectionProbability)(gen)) {
                add_edge(u, v, graph);
            }
        }
    }
    
    return graph;
}

void applyPredecessorMap(Graph& graph, const std::vector<Vertex>& predecessor) {
    int numVertices = num_vertices(graph);

    for (Vertex v = 1; v < numVertices; ++v) {
        Vertex u = predecessor[v];
        add_edge(u, v, graph);
    }
}

Your code is working entirely as expected. The "large number" isn't random. It is the special value indicating that the first vertex has no predecessor:

assert(predecessor.at(vertex(0, graph)) == graph.null_vertex());

Meanwhile, you find a spanning tree, but it can, by definition, only consist of edges already in the graph, so applyPredecessor should not have an effect, unless you choose another graph model that allows duplicate edges.

Here's the code extended with a bit of output showing exactly how and that it all works:

Live On Coliru

#include <boost/graph/adjacency_matrix.hpp>
#include <boost/graph/make_connected.hpp>
#include <boost/graph/random_spanning_tree.hpp>
#include <boost/graph/graph_utility.hpp>
#include <random>
#include <fmt/ranges.h>
struct VertexData {
int num;
int pred;
int dist;
};
struct EdgeData {
double dist;
};
using Graph  = boost::adjacency_matrix<boost::undirectedS, VertexData, EdgeData>;
using Vertex = Graph::vertex_descriptor;
void applyPredecessorMap(Graph& graph, std::vector<Vertex> const& predecessor) {
size_t numVertices = num_vertices(graph);
for (Vertex v = 1; v < numVertices; ++v) {
Vertex u = predecessor[v];
add_edge(u, v, graph);
}
}
Graph generateConnectedGraph2(size_t numVertices, double connectionProbability) {
Graph graph(numVertices);
std::random_device rand;
std::minstd_rand gen(rand()); //Seeded Random number generator
make_connected(graph);
auto const original = graph;
//build a minimally connected graph for the random spanning tree
std::vector<double> xPos(num_vertices(graph));
std::vector<double> yPos(num_vertices(graph));
// bool isPlanar = false;
std::vector<Vertex> predecessor(numVertices); // Predecessor map
fmt::print("predecessor constructed: {}\n", predecessor);
predecessor[0] = 0;                           // Set the root vertex to 0
fmt::print("predecessor initialized: {}\n", predecessor);
// Generate random edges to create a connected graph
random_spanning_tree(
std::as_const(graph), gen,
predecessor_map(make_iterator_property_map(predecessor.begin(), get(boost::vertex_index, graph))));
fmt::print("predecessor spanning: {}\n", predecessor);
// v 0 doesn't have a predecessor
assert(predecessor.at(vertex(0, graph)) == graph.null_vertex());
print_graph(graph, std::cout << "Graph:\n");
applyPredecessorMap(graph, predecessor);
print_graph(graph, std::cout << "Graph with predecessors applied:\n");
// Iterate over each pair of vertices and potentially add an edge
std::bernoulli_distribution dist(connectionProbability);
for (Vertex u = 0; u < numVertices; ++u) {
for (Vertex v = u + 1; v < numVertices; ++v) {
if (u != v && u != numVertices && !edge(u, v, graph).second && dist(gen)) {
add_edge(u, v, graph);
}
}
}
print_graph(graph, std::cout << "Graph with random edges added:\n");
return graph;
}
int main() {
generateConnectedGraph2(10, 0.2);
}

Printing e.g.

predecessor constructed: [0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
predecessor initialized: [0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
predecessor spanning: [18446744073709551615, 0, 1, 2, 3, 4, 5, 6, 7, 8]
Graph:
0 <--> 1 
1 <--> 0 2 
2 <--> 1 3 
3 <--> 2 4 
4 <--> 3 5 
5 <--> 4 6 
6 <--> 5 7 
7 <--> 6 8 
8 <--> 7 9 
9 <--> 8 
Graph with predecessors applied:
0 <--> 1 
1 <--> 0 2 
2 <--> 1 3 
3 <--> 2 4 
4 <--> 3 5 
5 <--> 4 6 
6 <--> 5 7 
7 <--> 6 8 
8 <--> 7 9 
9 <--> 8 
Graph with random edges added:
0 <--> 1 6 9 
1 <--> 0 2 
2 <--> 1 3 6 
3 <--> 2 4 6 7 
4 <--> 3 5 8 
5 <--> 4 6 9 
6 <--> 0 2 3 5 7 
7 <--> 3 6 8 
8 <--> 4 7 9 
9 <--> 0 5 8 

Or repeated runs: