# Chapter 19. Cliques and independent vertex sets

These functions calculate various graph properties related to cliques and independent vertex sets.

## 1. Cliques

### 1.1. `igraph_is_complete` — Decides whether the graph is complete.

    igraph_error_t igraph_is_complete(const igraph_t *graph, igraph_bool_t *res);

A graph is considered complete if all pairs of different vertices are adjacent.

The null graph and the singleton graph are considered complete.

Arguments:

`graph`: | The graph object to analyze.
`res`: | Pointer to a Boolean variable, the result will be stored here.

Returns:

`` | Error code.

Time complexity: O(|V| + |E|) at worst.

### 1.2. `igraph_is_clique` — Does a set of vertices form a clique?

    igraph_error_t igraph_is_clique(const igraph_t *graph, igraph_vs_t candidate,
                                    igraph_bool_t directed, igraph_bool_t *res);

Tests if all pairs within a set of vertices are adjacent, i.e. whether they form a clique. An empty set and singleton set are considered to be a clique.

Arguments:

`graph`: | The input graph.
`candidate`: | The vertex set to test for being a clique.
`directed`: | Whether to take edge directions into account in directed graphs.
`res`: | The result will be stored here.

Returns:

`` | Error code.

See also:

`` | `igraph_is_complete()` to test if a graph is complete; `igraph_is_independent_vertex_set()` to test for independent vertex sets; `igraph_cliques()`, `igraph_maximal_cliques()` and `igraph_largest_cliques()` to find cliques.

Time complexity: O(n^2 log(d)) where n is the number of vertices in the candidate set and d is the typical vertex degree.

### 1.3. `igraph_cliques` — Finds all or some cliques in a graph.

    igraph_error_t igraph_cliques(
            const igraph_t *graph, igraph_vector_int_list_t *res,
            igraph_int_t min_size, igraph_int_t max_size,
            igraph_int_t max_results);

Cliques are fully connected subgraphs of a graph.

If you are only interested in the size of the largest clique in the graph, use `igraph_clique_number()` instead.

The current implementation of this function uses version 1.21 of the Cliquer library by Sampo Niskanen and Patric R. J. Östergård, http://users.aalto.fi/~pat/cliquer.html

Arguments:

`graph`: | The input graph.
`res`: | Pointer to an initialized list of integer vectors. The cliques will be stored here as vectors of vertex IDs.
`min_size`: | Integer specifying the minimum size of the cliques to be returned. If negative or zero, no lower bound will be used.
`max_size`: | Integer specifying the maximum size of the cliques to be returned. If negative or zero, no upper bound will be used.
`max_results`: | At most this many cliques will be recorded. If negative, or `IGRAPH_UNLIMITED`, no limit is applied.

Returns:

`` | Error code.

See also:

`` | `igraph_largest_cliques()` and `igraph_clique_number()`.

Time complexity: Exponential

Example 19.1. File `examples/simple/igraph_cliques.c`

    #include <igraph.h>
    #include <stdlib.h>

    int compare_vectors(const igraph_vector_int_t *v1, const igraph_vector_int_t *v2) {
        igraph_int_t s1, s2, i;

        s1 = igraph_vector_int_size(v1);
        s2 = igraph_vector_int_size(v2);
        if (s1 < s2) {
            return -1;
        }
        if (s1 > s2) {
            return 1;
        }
        for (i = 0; i < s1; ++i) {
            if (VECTOR(*v1)[i] < VECTOR(*v2)[i]) {
                return -1;
            }
            if (VECTOR(*v1)[i] > VECTOR(*v2)[i]) {
                return 1;
            }
        }
        return 0;
    }

    /* Takes a pointer vector of vectors. Sorts each vector, then sorts the pointer vector */
    void canonicalize_list(igraph_vector_int_list_t *list) {
        igraph_int_t len = igraph_vector_int_list_size(list);
        for (igraph_int_t i = 0; i < len; ++i) {
            igraph_vector_int_sort(igraph_vector_int_list_get_ptr(list, i));
        }
        igraph_vector_int_list_sort(list, &compare_vectors);
    }

    struct userdata {
        igraph_int_t i;
        igraph_vector_int_list_t *list;
    };

    igraph_error_t handler(const igraph_vector_int_t *clique, void *arg) {
        struct userdata *ud;
        igraph_bool_t cont;

        ud = (struct userdata *) arg;
        cont = 1; /* true */

        if (compare_vectors(clique, igraph_vector_int_list_get_ptr(ud->list, ud->i)) != 0) {
            printf("igraph_cliques() and igraph_cliques_callback() give different results.\n");
            cont = 0; /* false */
        }

        ud->i += 1;

        return cont ? IGRAPH_SUCCESS : IGRAPH_STOP;
    }

    void test_callback(const igraph_t *graph) {
        igraph_vector_int_list_t list;
        struct userdata ud;

        igraph_vector_int_list_init(&list, 0);
        igraph_cliques(graph, &list, 0, 0, IGRAPH_UNLIMITED);

        ud.i = 0;
        ud.list = &list;

        igraph_cliques_callback(graph, 0, 0, &handler, (void *) &ud);

        igraph_vector_int_list_destroy(&list);
    }

    int main(void) {

        igraph_t g;
        igraph_vector_int_list_t result;
        igraph_es_t es;
        igraph_int_t omega;
        igraph_int_t i, j, n;
        const int params[] = {4, -1, 2, 2, 0, 0, -1, -1};

        /* Initialize the library. */
        igraph_setup();

        igraph_set_warning_handler(igraph_warning_handler_ignore);

        igraph_vector_int_list_init(&result, 0);
        igraph_full(&g, 6, 0, 0);
        igraph_es_pairs_small(&es, 0, 0, 1, 0, 2, 3, 5, -1);
        igraph_delete_edges(&g, es);
        igraph_es_destroy(&es);

        for (j = 0; j < sizeof(params) / (2 * sizeof(params[0])); j++) {
            if (params[2 * j + 1] != 0) {
                igraph_cliques(&g, &result, params[2 * j], params[2 * j + 1], IGRAPH_UNLIMITED);
            } else {
                igraph_largest_cliques(&g, &result);
            }
            n = igraph_vector_int_list_size(&result);
            printf("%" IGRAPH_PRId " cliques found\n", n);
            canonicalize_list(&result);
            for (i = 0; i < n; i++) {
                igraph_vector_int_t* v = igraph_vector_int_list_get_ptr(&result, i);
                igraph_vector_int_print(v);
            }
        }

        igraph_clique_number(&g, &omega);
        printf("omega=%" IGRAPH_PRId "\n", omega);

        test_callback(&g);

        igraph_destroy(&g);

        igraph_kary_tree(&g, 5, 2, IGRAPH_TREE_OUT);
        igraph_cliques(&g, &result, 5, 5, IGRAPH_UNLIMITED);
        if (igraph_vector_int_list_size(&result) != 0) {
            return 1;
        }

        igraph_destroy(&g);
        igraph_vector_int_list_destroy(&result);

        return 0;
    }

### 1.4. `igraph_clique_size_hist` — Counts cliques of each size in the graph.

    igraph_error_t igraph_clique_size_hist(const igraph_t *graph, igraph_vector_t *hist,
                                igraph_int_t min_size, igraph_int_t max_size);

Cliques are fully connected subgraphs of a graph.

The current implementation of this function uses version 1.21 of the Cliquer library by Sampo Niskanen and Patric R. J. Östergård, http://users.aalto.fi/~pat/cliquer.html

Arguments:

`graph`: | The input graph.
`hist`: | Pointer to an initialized vector. The result will be stored here. The first element will store the number of size-1 cliques, the second element the number of size-2 cliques, etc. For cliques smaller than `min_size`, zero counts will be returned.
`min_size`: | Integer specifying the minimum size of the cliques to be returned. If negative or zero, no lower bound will be used.
`max_size`: | Integer specifying the maximum size of the cliques to be returned. If negative or zero, no upper bound will be used.

Returns:

`` | Error code.

See also:

`` | `igraph_cliques()` and `igraph_cliques_callback()`

Time complexity: Exponential

### 1.5. `igraph_cliques_callback` — Calls a function for each clique in the graph.

    igraph_error_t igraph_cliques_callback(const igraph_t *graph,
                                igraph_int_t min_size, igraph_int_t max_size,
                                igraph_clique_handler_t *cliquehandler_fn, void *arg);

Cliques are fully connected subgraphs of a graph. This function enumerates all cliques within the given size range and calls `cliquehandler_fn` for each of them. The cliques are passed to the callback function as a pointer to an `igraph_vector_int_t`. Destroying and freeing this vector is left up to the user. Use `igraph_vector_int_destroy()` to destroy it first, then free it using `igraph_free()`.

The current implementation of this function uses version 1.21 of the Cliquer library by Sampo Niskanen and Patric R. J. Östergård, http://users.aalto.fi/~pat/cliquer.html

Arguments:

`graph`: | The input graph.
`min_size`: | Integer specifying the minimum size of the cliques to be returned. If negative or zero, no lower bound will be used.
`max_size`: | Integer specifying the maximum size of the cliques to be returned. If negative or zero, no upper bound will be used.
`cliquehandler_fn`: | Callback function to be called for each clique. See also `igraph_clique_handler_t`.
`arg`: | Extra argument to supply to `cliquehandler_fn`.

Returns:

`` | Error code.

See also:

`` | `igraph_cliques()`

Time complexity: Exponential

### 1.6. `igraph_clique_handler_t` — Type of clique handler functions.

    typedef igraph_error_t igraph_clique_handler_t(const igraph_vector_int_t *clique, void *arg);

Callback type, called when a clique was found. See the details at the documentation of `igraph_cliques_callback()`.

Arguments:

`clique`: | The current clique. The clique is owned by the clique search routine. You do not need to destroy or free it if you do not want to store it; however, if you want to hold on to it for a longer period of time, you need to make a copy of it on your own and store the copy itself.
`arg`: | This extra argument was passed to `igraph_cliques_callback()` when it was called.

Returns:

`` | Error code; `IGRAPH_SUCCESS` to continue the search or `IGRAPH_STOP` to stop the search without signaling an error.

### 1.7. `igraph_largest_cliques` — Finds the largest clique(s) in a graph.

    igraph_error_t igraph_largest_cliques(const igraph_t *graph, igraph_vector_int_list_t *res);

A clique is largest (quite intuitively) if there is no other clique in the graph which contains more vertices.

Note that this is not necessarily the same as a maximal clique, i.e. the largest cliques are always maximal but a maximal clique is not always largest.

The current implementation of this function searches for maximal cliques using `igraph_maximal_cliques_callback()` and drops those that are not the largest.

The implementation of this function changed between igraph 0.5 and 0.6, so the order of the cliques and the order of vertices within the cliques will almost surely be different between these two versions.

Arguments:

`graph`: | The input graph.
`res`: | Pointer to an initialized list of integer vectors. The cliques will be stored here as vectors of vertex IDs.

Returns:

`` | Error code.

See also:

`` | `igraph_cliques()`, `igraph_maximal_cliques()`

Time complexity: O(3^(|V|/3)) worst case.

### 1.8. `igraph_maximal_cliques` — Finds all maximal cliques in a graph.

    igraph_error_t igraph_maximal_cliques(
            const igraph_t *graph,
            igraph_vector_int_list_t *res,
            igraph_int_t min_size, igraph_int_t max_size,
            igraph_int_t max_results);

This function lists maximal cliques within a size range, ignoring edge directions. A clique is a subset of vertices in which all vertex pairs are connected. A maximal clique is a clique which is not a strict subset of any larger clique.

No guarantees are given about the order in which cliques are returned.

The current implementation uses a modified Bron-Kerbosch algorithm due to Eppstein, Löffler and Strash.

Reference:

David Eppstein, Maarten Löffler, Darren Strash: Listing All Maximal Cliques in Sparse Graphs in Near-Optimal Time. Algorithms and Computation, Lecture Notes in Computer Science, volume 6506, pp 403-414 (2010). https://doi.org/10.1007/978-3-642-17517-6_36 https://arxiv.org/abs/1006.5440

Arguments:

`graph`: | The input graph. Edge directions are ignored.
`res`: | Pointer to list of integer vectors. The maximal cliques will be returned here as vectors of vertex IDs. Note that vertices of a clique may be returned in arbitrary order.
`min_size`: | Integer giving the minimum size of the cliques to be returned. If negative or zero, no lower bound will be used.
`max_size`: | Integer giving the maximum size of the cliques to be returned. If negative or zero, no upper bound will be used.
`max_results`: | At most this many cliques will be recorded. If negative, or `IGRAPH_UNLIMITED`, no limit is applied.

Returns:

`` | Error code.

See also:

`` | `igraph_maximal_independent_vertex_sets()` to find maximal independent sets, which are cliques of the complement graph; `igraph_clique_number()` to find the size of the largest clique; `igraph_cliques()` to find all cliques.

Time complexity: O(d(n-d)3^(d/3)) worst case, d is the degeneracy of the graph, this is typically small for sparse graphs.

Example 19.2. File `examples/simple/igraph_maximal_cliques.c`

    #include <igraph.h>

    int main(void) {
        igraph_t g;
        igraph_vector_int_list_t cliques;
        igraph_int_t no;

        /* Initialize the library. */
        igraph_setup();

        igraph_small(&g, 9, IGRAPH_UNDIRECTED,
                     0,1, 0,2, 1,2, 2,3, 3,4, 3, 5, 4,5, 5,6, 6,7, -1);
        igraph_vector_int_list_init(&cliques, 0);
        igraph_maximal_cliques(&g, &cliques, /*min_size=*/ IGRAPH_UNLIMITED,
                               /*max_size=*/ IGRAPH_UNLIMITED,
                               /*max_results=*/ IGRAPH_UNLIMITED);
        igraph_maximal_cliques_count(&g, &no, /*min_size=*/ IGRAPH_UNLIMITED,
                                     /*max_size=*/ IGRAPH_UNLIMITED);

        if (no != igraph_vector_int_list_size(&cliques)) {
            return 1;
        }

        for (igraph_int_t i = 0; i < igraph_vector_int_list_size(&cliques); i++) {
            igraph_vector_int_t *v = igraph_vector_int_list_get_ptr(&cliques, i);
            igraph_vector_int_print(v);
        }

        igraph_vector_int_list_destroy(&cliques);
        igraph_destroy(&g);

        return 0;
    }

### 1.9. `igraph_maximal_cliques_count` — Count the number of maximal cliques in a graph.

    igraph_error_t igraph_maximal_cliques_count(
            const igraph_t *graph,
            igraph_int_t *res,
            igraph_int_t min_size, igraph_int_t max_size);

See `igraph_maximal_cliques()` for details.

Arguments:

`graph`: | The input graph. Edge directions are ignored.
`res`: | Pointer to an `igraph_int_t`; the number of maximal cliques will be stored here.
`min_size`: | Integer giving the minimum size of the cliques to be returned. If negative or zero, no lower bound will be used.
`max_size`: | Integer giving the maximum size of the cliques to be returned. If negative or zero, no upper bound will be used.

Returns:

`` | Error code.

See also:

`` | `igraph_maximal_cliques()`.

Time complexity: O(d(n-d)3^(d/3)) worst case, d is the degeneracy of the graph, this is typically small for sparse graphs.

Example 19.3. File `examples/simple/igraph_maximal_cliques.c`

    #include <igraph.h>

    int main(void) {
        igraph_t g;
        igraph_vector_int_list_t cliques;
        igraph_int_t no;

        /* Initialize the library. */
        igraph_setup();

        igraph_small(&g, 9, IGRAPH_UNDIRECTED,
                     0,1, 0,2, 1,2, 2,3, 3,4, 3, 5, 4,5, 5,6, 6,7, -1);
        igraph_vector_int_list_init(&cliques, 0);
        igraph_maximal_cliques(&g, &cliques, /*min_size=*/ IGRAPH_UNLIMITED,
                               /*max_size=*/ IGRAPH_UNLIMITED,
                               /*max_results=*/ IGRAPH_UNLIMITED);
        igraph_maximal_cliques_count(&g, &no, /*min_size=*/ IGRAPH_UNLIMITED,
                                     /*max_size=*/ IGRAPH_UNLIMITED);

        if (no != igraph_vector_int_list_size(&cliques)) {
            return 1;
        }

        for (igraph_int_t i = 0; i < igraph_vector_int_list_size(&cliques); i++) {
            igraph_vector_int_t *v = igraph_vector_int_list_get_ptr(&cliques, i);
            igraph_vector_int_print(v);
        }

        igraph_vector_int_list_destroy(&cliques);
        igraph_destroy(&g);

        return 0;
    }

### 1.10. `igraph_maximal_cliques_file` — Find maximal cliques and write them to a file.

    igraph_error_t igraph_maximal_cliques_file(
            const igraph_t *graph,
            FILE *outfile,
            igraph_int_t min_size, igraph_int_t max_size,
            igraph_int_t max_results);

This function enumerates all maximal cliques within a size range and writes them to file. See `igraph_maximal_cliques()` for details

Arguments:

`graph`: | The input graph. Edge directions are ignored.
`outfile`: | Pointer to the output file, it should be writable.
`min_size`: | Integer giving the minimum size of the cliques to be returned. If negative or zero, no lower bound will be used.
`max_size`: | Integer giving the maximum size of the cliques to be returned. If negative or zero, no upper bound will be used.
`max_results`: | At most this many cliques will be output. If negative, or `IGRAPH_UNLIMITED`, no limit is applied.

Returns:

`` | Error code.

See also:

`` | `igraph_maximal_cliques()`.

Time complexity: O(d(n-d)3^(d/3)) worst case, d is the degeneracy of the graph, this is typically small for sparse graphs.*

### 1.11. `igraph_maximal_cliques_subset` — Maximal cliques for a subset of initial vertices.

    igraph_error_t igraph_maximal_cliques_subset(
            const igraph_t *graph, const igraph_vector_int_t *subset,
            igraph_vector_int_list_t *res, igraph_int_t *no, FILE *outfile,
            igraph_int_t min_size, igraph_int_t max_size,
            igraph_int_t max_results);

This function enumerates all maximal cliques for a subset of initial vertices and writes them to file. See `igraph_maximal_cliques()` for details.

Arguments:

`graph`: | The input graph. Edge directions are ignored.
`subset`: | Pointer to an `igraph_vector_int_t` containing the subset of initial vertices.
`res`: | Pointer to a list of integer vectors; the cliques will be stored here.
`no`: | Pointer to an `igraph_int_t`; the number of maximal cliques will be stored here.
`outfile`: | Pointer to an output file or `NULL`. When not `NULL`, the file should be writable.
`min_size`: | Integer giving the minimum size of the cliques to be returned. If negative or zero, no lower bound will be used.
`max_size`: | Integer giving the maximum size of the cliques to be returned. If negative or zero, no upper bound will be used.
`max_results`: | At most this many cliques will be recorded. If negative, or `IGRAPH_UNLIMITED`, no limit is applied.

Returns:

`` | Error code.

See also:

`` | `igraph_maximal_cliques()`.

Time complexity: O(d(n-d)3^(d/3)) worst case, d is the degeneracy of the graph, this is typically small for sparse graphs.

### 1.12. `igraph_maximal_cliques_hist` — Counts the number of maximal cliques of each size in a graph.

    igraph_error_t igraph_maximal_cliques_hist(
            const igraph_t *graph,
            igraph_vector_t *hist,
            igraph_int_t min_size, igraph_int_t max_size);

This function counts how many maximal cliques of each size are present in the graph. Maximal cliques of size one are simply isolated vertices.

Arguments:

`graph`: | The input graph. Edge directions are ignored.
`hist`: | Pointer to an initialized vector. The result will be stored here. The first element will store the number of size-1 maximal cliques, the second element the number of size-2 maximal cliques, etc. For cliques smaller than `min_size`, zero counts will be returned.
`min_size`: | Integer giving the minimum size of the cliques to be returned. If negative or zero, no lower bound will be used.
`max_size`: | Integer giving the maximum size of the cliques to be returned. If negative or zero, no upper bound will be used.

Returns:

`` | Error code.

See also:

`` | `igraph_maximal_cliques()`, `igraph_clique_size_hist()`.

Time complexity: O(d(n-d)3^(d/3)) worst case, d is the degeneracy of the graph, this is typically small for sparse graphs.

### 1.13. `igraph_maximal_cliques_callback` — Finds maximal cliques in a graph and calls a function for each one.

    igraph_error_t igraph_maximal_cliques_callback(
            const igraph_t *graph,
            igraph_int_t min_size, igraph_int_t max_size,
            igraph_clique_handler_t *cliquehandler_fn, void *arg);

This function enumerates all maximal cliques within the given size range and calls `cliquehandler_fn` for each of them. The cliques are passed to the callback function as a pointer to an `igraph_vector_int_t`. The vector is owned by the maximal clique search routine so users are expected to make a copy of the vector using `igraph_vector_int_init_copy()` if they want to hold on to it.

Arguments:

`graph`: | The input graph. Edge directions are ignored.
`cliquehandler_fn`: | Callback function to be called for each clique. See also `igraph_clique_handler_t`.
`arg`: | Extra argument to supply to `cliquehandler_fn`.
`min_size`: | Integer giving the minimum size of the cliques to be returned. If negative or zero, no lower bound will be used.
`max_size`: | Integer giving the maximum size of the cliques to be returned. If negative or zero, no upper bound will be used.

Returns:

`` | Error code.

See also:

`` | `igraph_maximal_cliques()`, `igraph_cliques_callback()`.

Time complexity: O(d(n-d)3^(d/3)) worst case, d is the degeneracy of the graph, this is typically small for sparse graphs.

### 1.14. `igraph_clique_number` — Finds the clique number of the graph.

    igraph_error_t igraph_clique_number(const igraph_t *graph, igraph_int_t *no);

The clique number of a graph is the size of the largest clique.

The current implementation of this function searches for maximal cliques using `igraph_maximal_cliques_callback()` and keeps track of the size of the largest clique that was found.

Arguments:

`graph`: | The input graph.
`no`: | The clique number will be returned to the `igraph_int_t` pointed by this variable.

Returns:

`` | Error code.

See also:

`` | `igraph_cliques()`, `igraph_largest_cliques()`.

Time complexity: O(3^(|V|/3)) worst case.

## 2. Weighted cliques

### 2.1. `igraph_weighted_cliques` — Finds all cliques in a given weight range in a vertex weighted graph.

    igraph_error_t igraph_weighted_cliques(
            const igraph_t *graph, const igraph_vector_t *vertex_weights,
            igraph_vector_int_list_t *res,
            igraph_bool_t maximal,
            igraph_real_t min_weight, igraph_real_t max_weight,
            igraph_int_t max_results);

Cliques are fully connected subgraphs of a graph. The weight of a clique is the sum of the weights of individual vertices within the clique.

Only positive integer vertex weights are supported.

The current implementation of this function uses version 1.21 of the Cliquer library by Sampo Niskanen and Patric R. J. Östergård, http://users.aalto.fi/~pat/cliquer.html

Arguments:

`graph`: | The input graph.
`vertex_weights`: | A vector of vertex weights. The current implementation will truncate all weights to their integer parts. You may pass `NULL` here to make each vertex have a weight of 1.
`res`: | Pointer to an initialized list of integer vectors. The cliques will be stored here as vectors of vertex IDs.
`maximal`: | If true, only maximal cliques will be returned
`min_weight`: | Integer specifying the minimum weight of the cliques to be returned. If negative or zero, no lower bound will be used.
`max_weight`: | Integer specifying the maximum weight of the cliques to be returned. If negative or zero, no upper bound will be used.
`max_results`: | At most this many cliques will be recorded. If negative, or `IGRAPH_UNLIMITED`, no limit is applied.

Returns:

`` | Error code.

See also:

`` | `igraph_cliques()`, `igraph_maximal_cliques()`

Time complexity: Exponential

### 2.2. `igraph_largest_weighted_cliques` — Finds the largest weight clique(s) in a graph.

    igraph_error_t igraph_largest_weighted_cliques(const igraph_t *graph,
                                        const igraph_vector_t *vertex_weights, igraph_vector_int_list_t *res);

The weight of a clique is the sum of the weights of its vertices. This function finds the clique(s) having the largest weight in the graph.

Only positive integer vertex weights are supported.

The current implementation of this function uses version 1.21 of the Cliquer library by Sampo Niskanen and Patric R. J. Östergård, http://users.aalto.fi/~pat/cliquer.html

Arguments:

`graph`: | The input graph.
`vertex_weights`: | A vector of vertex weights. The current implementation will truncate all weights to their integer parts. You may pass `NULL` here to make each vertex have a weight of 1.
`res`: | Pointer to an initialized list of integer vectors. The cliques will be stored here as vectors of vertex IDs.

Returns:

`` | Error code.

See also:

`` | `igraph_weighted_cliques()`, `igraph_weighted_clique_number()`, `igraph_largest_cliques()`

Time complexity: TODO

### 2.3. `igraph_weighted_clique_number` — Finds the weight of the largest weight clique in the graph.

    igraph_error_t igraph_weighted_clique_number(const igraph_t *graph,
                                      const igraph_vector_t *vertex_weights, igraph_real_t *res);

The weight of a clique is the sum of the weights of its vertices. This function finds the weight of the largest weight clique.

Only positive integer vertex weights are supported.

The current implementation of this function uses version 1.21 of the Cliquer library by Sampo Niskanen and Patric R. J. Östergård, http://users.aalto.fi/~pat/cliquer.html

Arguments:

`graph`: | The input graph.
`vertex_weights`: | A vector of vertex weights. The current implementation will truncate all weights to their integer parts. You may pass `NULL` here to make each vertex have a weight of 1.
`res`: | The largest weight will be returned to the `igraph_real_t` pointed to by this variable.

Returns:

`` | Error code.

See also:

`` | `igraph_weighted_cliques()`, `igraph_largest_weighted_cliques()`, `igraph_clique_number()`

Time complexity: TODO

## 3. Independent vertex sets

### 3.1. `igraph_is_independent_vertex_set` — Does a set of vertices form an independent set?

    igraph_error_t igraph_is_independent_vertex_set(const igraph_t *graph, igraph_vs_t candidate,
                                             igraph_bool_t *res);

Tests if no pairs within a set of vertices are adjacenct, i.e. whether they form an independent set. An empty set and singleton set are both considered to be an independent set.

Arguments:

`graph`: | The input graph.
`candidate`: | The vertex set to test for being an independent set.
`res`: | The result will be stored here.

Returns:

`` | Error code.

See also:

`` | `igraph_is_clique()` to test for cliques; `igraph_independent_vertex_sets()`, `igraph_maximal_independent_vertex_sets()` and `igraph_largest_independent_vertex_sets()` to find independent vertex sets.

Time complexity: O(n^2 log(d)) where n is the number of vertices in the candidate set and d is the typical vertex degree.

### 3.2. `igraph_independent_vertex_sets` — Finds all independent vertex sets in a graph.

    igraph_error_t igraph_independent_vertex_sets(
            const igraph_t *graph,
            igraph_vector_int_list_t *res,
            igraph_int_t min_size, igraph_int_t max_size,
            igraph_int_t max_results);

A vertex set is considered independent if there are no edges between them.

If you are interested in the size of the largest independent vertex set, use `igraph_independence_number()` instead.

The current implementation was ported to igraph from the Very Nauty Graph Library by Keith Briggs and uses the algorithm from the paper S. Tsukiyama, M. Ide, H. Ariyoshi and I. Shirawaka. A new algorithm for generating all the maximal independent sets. SIAM J Computing, 6:505--517, 1977.

Arguments:

`graph`: | The input graph.
`res`: | Pointer to an initialized list of integer vectors. The cliques will be stored here as vectors of vertex IDs.
`min_size`: | Integer specifying the minimum size of the sets to be returned. If negative or zero, no lower bound will be used.
`max_size`: | Integer specifying the maximum size of the sets to be returned. If negative or zero, no upper bound will be used.
`max_results`: | At most this many independent vertex sets will be recorded. If negative, or `IGRAPH_UNLIMITED`, no limit is applied.

Returns:

`` | Error code.

See also:

`` | `igraph_largest_independent_vertex_sets()`, `igraph_independence_number()`.

Time complexity: TODO

Example 19.4. File `examples/simple/igraph_independent_sets.c`

    #include <igraph.h>
    #include <stdlib.h>

    int main(void) {

        igraph_t g;
        igraph_vector_int_list_t result;
        igraph_int_t n;
        igraph_int_t alpha;
        const int params[] = {4, -1, 2, 2, 0, 0, -1, -1};

        /* Initialize the library. */
        igraph_setup();

        igraph_vector_int_list_init(&result, 0);

        igraph_kary_tree(&g, 5, 2, IGRAPH_TREE_OUT);
        for (size_t j = 0; j < sizeof(params) / (2 * sizeof(params[0])); j++) {
            if (params[2 * j + 1] != 0) {
                igraph_independent_vertex_sets(&g, &result, params[2 * j], params[2 * j + 1], IGRAPH_UNLIMITED);
            } else {
                igraph_largest_independent_vertex_sets(&g, &result);
            }
            n = igraph_vector_int_list_size(&result);
            printf("%" IGRAPH_PRId " independent sets found\n", n);
            for (igraph_int_t i = 0; i < n; i++) {
                igraph_vector_int_print(igraph_vector_int_list_get_ptr(&result, i));
            }
        }
        igraph_destroy(&g);

        igraph_kary_tree(&g, 10, 2, IGRAPH_TREE_OUT);
        igraph_maximal_independent_vertex_sets(&g, &result, IGRAPH_UNLIMITED, IGRAPH_UNLIMITED, IGRAPH_UNLIMITED);
        n = igraph_vector_int_list_size(&result);
        printf("%" IGRAPH_PRId " maximal independent sets found\n", n);
        for (igraph_int_t i = 0; i < n; i++) {
            igraph_vector_int_print(igraph_vector_int_list_get_ptr(&result, i));
        }

        igraph_maximal_independent_vertex_sets(&g, &result, 4, 5, IGRAPH_UNLIMITED);
        n = igraph_vector_int_list_size(&result);
        printf("%" IGRAPH_PRId " maximal independent sets between sizes 4 and 5 found\n", n);
        for (igraph_int_t i = 0; i < n; i++) {
            igraph_vector_int_print(igraph_vector_int_list_get_ptr(&result, i));
        }

        igraph_independence_number(&g, &alpha);
        printf("alpha=%" IGRAPH_PRId "\n", alpha);

        igraph_destroy(&g);

        igraph_vector_int_list_destroy(&result);

        return 0;
    }

### 3.3. `igraph_largest_independent_vertex_sets` — Finds the largest independent vertex set(s) in a graph.

    igraph_error_t igraph_largest_independent_vertex_sets(const igraph_t *graph,
            igraph_vector_int_list_t *res);

An independent vertex set is largest if there is no other independent vertex set with more vertices in the graph.

The current implementation was ported to igraph from the Very Nauty Graph Library by Keith Briggs and uses the algorithm from the paper S. Tsukiyama, M. Ide, H. Ariyoshi and I. Shirawaka. A new algorithm for generating all the maximal independent sets. SIAM J Computing, 6:505--517, 1977.

Arguments:

`graph`: | The input graph.
`res`: | Pointer to an initialized list of integer vectors. The cliques will be stored here as vectors of vertex IDs.

Returns:

`` | Error code.

See also:

`` | `igraph_independent_vertex_sets()`, `igraph_maximal_independent_vertex_sets()`.

Time complexity: TODO

### 3.4. `igraph_maximal_independent_vertex_sets` — Finds all maximal independent vertex sets of a graph.

    igraph_error_t igraph_maximal_independent_vertex_sets(
            const igraph_t *graph,
            igraph_vector_int_list_t *res,
            igraph_int_t min_size, igraph_int_t max_size,
            igraph_int_t max_results);

A maximal independent vertex set is an independent vertex set which can't be extended any more by adding a new vertex to it.

The algorithm used here is based on the following paper: S. Tsukiyama, M. Ide, H. Ariyoshi and I. Shirawaka. A new algorithm for generating all the maximal independent sets. SIAM J Computing, 6:505--517, 1977.

The implementation was originally written by Kevin O'Neill and modified by K M Briggs in the Very Nauty Graph Library. I simply re-wrote it to use igraph's data structures.

If you are interested in the size of the largest independent vertex set, use `igraph_independence_number()` instead.

Arguments:

`graph`: | The input graph.
`res`: | Pointer to an initialized list of integer vectors. The cliques will be stored here as vectors of vertex IDs.
`min_size`: | Integer specifying the minimum size of the sets to be returned. If negative or zero, no lower bound will be used.
`max_size`: | Integer specifying the maximum size of the sets to be returned. If negative or zero, no upper bound will be used.
`max_results`: | At most this many independent vertex sets will be recorded. If negative, or `IGRAPH_UNLIMITED`, no limit is applied.

Returns:

`` | Error code.

See also:

`` | `igraph_maximal_cliques()`, `igraph_independence_number()`

Time complexity: TODO.

### 3.5. `igraph_independence_number` — Finds the independence number of the graph.

    igraph_error_t igraph_independence_number(const igraph_t *graph, igraph_int_t *no);

The independence number of a graph is the cardinality of the largest independent vertex set.

The current implementation was ported to igraph from the Very Nauty Graph Library by Keith Briggs and uses the algorithm from the paper S. Tsukiyama, M. Ide, H. Ariyoshi and I. Shirawaka. A new algorithm for generating all the maximal independent sets. SIAM J Computing, 6:505--517, 1977.

Arguments:

`graph`: | The input graph.
`no`: | The independence number will be returned to the `igraph_int_t` pointed by this variable.

Returns:

`` | Error code.

See also:

`` | `igraph_independent_vertex_sets()`.

Time complexity: TODO.