protocol

# `weighted_graph_protocol`

Protocol for weighted graph predicates, extending the common graph protocol with weighted edge operations.

Availability:
`logtalk_load(graphs(loader))`
Author: Paulo Moura
Version: 1:0:0
Date: 2026-02-25
Compilation flags:
`static`
Extends:
`public` graph_protocol
Remarks:
(none)
Inherited public predicates:
add_edges/3 add_vertex/3 add_vertices/3 all_pairs_min_paths/2 all_pairs_min_predecessors/2 breadth_first_order/3 delete_edges/3 delete_vertex/3 delete_vertices/3 depth_first_order/3 edges/2 empty/1 has_path/3 is_bipartite/1 is_complete/1 is_sparse/1 max_path/5 min_distances/3 min_path/5 min_predecessors/3 neighbors/3 new/1 new/2 new/3 number_of_edges/2 number_of_vertices/2 path/3 reachable/3 vertices/2

## Public predicates

### `edge/4`

True iff there is an edge between `Vertex1` and `Vertex2` with weight `Weight` in `Graph`.

Compilation flags:
`static`
Template:
`edge(Vertex1,Vertex2,Weight,Graph)`
Mode and number of proofs:
`edge(+vertex,+vertex,?number,+graph)` - `zero_or_one`

### `add_edge/5`

Adds a weighted edge between `Vertex1` and `Vertex2` with weight `Weight`.

Compilation flags:
`static`
Template:
`add_edge(Graph,Vertex1,Vertex2,Weight,NewGraph)`
Mode and number of proofs:
`add_edge(+graph,+vertex,+vertex,+number,-graph)` - `one`

### `delete_edge/5`

Deletes the weighted edge between `Vertex1` and `Vertex2`. Unifies `Weight` with the weight of the deleted edge. The graph is unchanged if the edge does not exist.

Compilation flags:
`static`
Template:
`delete_edge(Graph,Vertex1,Vertex2,Weight,NewGraph)`
Mode and number of proofs:
`delete_edge(+graph,+vertex,+vertex,?number,-graph)` - `one`

### `wneighbors/3`

Unifies `WNeighbors` with a list of `NeighborVertex-Weight` pairs for the neighbors of `Vertex`. Fails if `Vertex` is not in the graph.

Compilation flags:
`static`
Template:
`wneighbors(Vertex,Graph,WNeighbors)`
Mode and number of proofs:
`wneighbors(+vertex,+graph,-list(pair))` - `zero_or_one`

### `min_path_bellman_ford/5`

Finds the minimum cost path from `Vertex1` to `Vertex2` using the Bellman-Ford algorithm. Supports negative edge weights and fails if no path exists or if a reachable negative cycle makes the optimum undefined.

Compilation flags:
`static`
Template:
`min_path_bellman_ford(Vertex1,Vertex2,Graph,Path,Cost)`
Mode and number of proofs:
`min_path_bellman_ford(+vertex,+vertex,+graph,-list(vertex),-number)` - `zero_or_one`

### `has_negative_cycle/1`

True iff `Graph` contains a negative-weight cycle.

Compilation flags:
`static`
Template:
`has_negative_cycle(Graph)`
Mode and number of proofs:
`has_negative_cycle(+graph)` - `zero_or_one`

## Protected predicates

(no local declarations; see entity ancestors if any)

## Private predicates

(no local declarations; see entity ancestors if any)

## Operators

(none)