Struct BicliqueCover 

pub struct BicliqueCover { /* private fields */ }

The Biclique Cover problem.

Given a bipartite graph with vertex sets L and R, find k bicliques that together cover all edges. Each vertex can be in any subset of the k bicliques.

Example

use problemreductions::models::specialized::BicliqueCover;
use problemreductions::{Problem, Solver, BruteForce};

// Bipartite graph: L = {0, 1}, R = {2, 3}
// Edges: (0,2), (0,3), (1,2)
let problem = BicliqueCover::new(2, 2, vec![(0, 2), (0, 3), (1, 2)], 2);

let solver = BruteForce::new();
let solutions = solver.find_best(&problem);

// Check coverage
for sol in &solutions {
    assert!(problem.is_valid_cover(sol));
}

Implementations

impl BicliqueCover

pub fn new( left_size: usize, right_size: usize, edges: Vec<(usize, usize)>, k: usize, ) -> Self

Create a new Biclique Cover problem.

Arguments

• left_size - Number of vertices in left partition (0 to left_size-1)
• right_size - Number of vertices in right partition (left_size to left_size+right_size-1)
• edges - Edges as (left, right) pairs
• k - Number of bicliques

pub fn from_matrix(matrix: &[Vec<u8>], k: usize) -> Self

Create from a bipartite adjacency matrix.

Matrix[i][j] = 1 means edge between left vertex i and right vertex j.

pub fn num_vertices(&self) -> usize

Get the number of vertices.

pub fn num_edges(&self) -> usize

Get the number of edges.

pub fn k(&self) -> usize

Get k (number of bicliques).

pub fn is_valid_cover(&self, config: &[usize]) -> bool

Check if all edges are covered.

pub fn count_covered_edges(&self, config: &[usize]) -> usize

Count covered edges.

pub fn total_biclique_size(&self, config: &[usize]) -> usize

Count total biclique size (sum of vertices in all bicliques).

Trait Implementations

impl Clone for BicliqueCover

fn clone(&self) -> BicliqueCover

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for BicliqueCover

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for BicliqueCover

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Problem for BicliqueCover

const NAME: &'static str = "BicliqueCover"

Base name of this problem type (e.g., “IndependentSet”).

type GraphType = SimpleGraph

The graph type this problem operates on.

type Weight = i32

The weight type for this problem.

type Size = i32

The type used for objective/size values.

fn num_variables(&self) -> usize

Returns the number of variables in the problem.

fn num_flavors(&self) -> usize

Returns the number of possible values (flavors) for each variable. For binary problems, this is 2.

fn problem_size(&self) -> ProblemSize

Returns metadata about the problem size.

fn energy_mode(&self) -> EnergyMode

Returns whether larger or smaller objective values are better.

fn solution_size(&self, config: &[usize]) -> SolutionSize<Self::Size>

Evaluate the solution size for a given configuration.

fn variables(&self) -> Range<usize>

Returns the range of variable indices.

fn flavors(&self) -> Vec<usize>

Returns the possible flavors as a vector.

fn is_valid_config(&self, config: &[usize]) -> bool

Check if a configuration is valid for this problem.

fn solution_size_multiple( &self, configs: &[Vec<usize>], ) -> Vec<SolutionSize<Self::Size>>

Evaluate multiple configurations at once (batch evaluation).

impl Serialize for BicliqueCover

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.