-
Notifications
You must be signed in to change notification settings - Fork 5
Update Docs towards New Version Deploy #155
New issue
Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.
By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.
Already on GitHub? Sign in to your account
Merged
Merged
Changes from all commits
Commits
Show all changes
19 commits
Select commit
Hold shift + click to select a range
9c6e0bb
created folder and mds. TODO - put cyper-path-functions under cypher …
1dcdd22
put dedicated path_algorithm.md under cypher/functions.md. clean redu…
2a65ded
added more untracked files related to previous commit
3d6de6c
(1) add algos (2) add memory usage
1ab1ca9
small changes to algos and memory usage
08dca15
add DEDUPLICATE_STRINGS to configuration md
c2f7a07
Merge branch 'main' into add-algo-section
barakb ce0ab50
fix spell checker
49b6044
Merge remote-tracking branch 'origin/add-algo-section' into add-algo-…
b6d0b05
add the updated wordlist file
f02471d
add verbosity
9f68b8b
minor typo fix
ae7003e
add array indices
fce15bd
add to wordlist
388795e
added (1) between centrality algo (2) remove dedupliacte string (3) u…
e3752a8
add wordllist
8a6b005
added cdlp
swilly22 dea9e92
spellcheck
swilly22 c846eed
Merge branch 'main' into add-algo-section
swilly22 File filter
Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
There are no files selected for viewing
This file contains hidden or bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
This file contains hidden or bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
Original file line number | Diff line number | Diff line change |
---|---|---|
@@ -0,0 +1,91 @@ | ||
--- | ||
title: "Betweenness Centrality" | ||
description: "Measures the importance of nodes based on the number of shortest paths that pass through them." | ||
parent: "Algorithms" | ||
--- | ||
|
||
# Betweenness Centrality | ||
|
||
## Introduction | ||
|
||
Betweenness Centrality is a graph algorithm that quantifies the importance of a node based on the number of shortest paths that pass through it. Nodes that frequently occur on shortest paths between other nodes have higher betweenness centrality scores. This makes the algorithm useful for identifying **key connectors** or **brokers** within a network. | ||
|
||
## Algorithm Overview | ||
|
||
The core idea of Betweenness Centrality is that a node is more important if it lies on many of the shortest paths connecting other nodes. It’s particularly useful in understanding information flow or communication efficiency in a graph. | ||
|
||
For example, in a social network, a person who frequently connects otherwise unconnected groups would have high betweenness centrality. | ||
|
||
## Syntax | ||
|
||
The procedure has the following call signature: | ||
```cypher | ||
CALL algo.betweenness({ | ||
nodeLabels: [<node_label>], | ||
relationshipTypes: [<relationship_type>] | ||
}) | ||
YIELD node, score | ||
``` | ||
|
||
### Parameters | ||
|
||
| Name | Type | Description | Default | | ||
|-----------------------|---------|-------------------------------------------------|---------| | ||
| `nodeLabels` | Array | *(Optional)* List of Strings representing node labels | [] | | ||
| `relationshipTypes` | Array | *(Optional)* List of Strings representing relationship types | [] | | ||
|
||
### Yield | ||
|
||
| Name | Type | Description | | ||
|---------|-------|-----------------------------------------------| | ||
| `node` | Node | The node being evaluated | | ||
| `score` | Float | The betweenness centrality score for the node | | ||
|
||
## Example: | ||
|
||
Lets take this Social Graph as an example: | ||
 | ||
|
||
### Create the Graph | ||
|
||
```cypher | ||
CREATE | ||
(a:Person {name: 'Alice'}), | ||
(b:Person {name: 'Bob'}), | ||
(c:Person {name: 'Charlie'}), | ||
(d:Person {name: 'David'}), | ||
(e:Person {name: 'Emma'}), | ||
(a)-[:FRIEND]->(b), | ||
(b)-[:FRIEND]->(c), | ||
(b)-[:FRIEND]->(d), | ||
(c)-[:FRIEND]->(e), | ||
(d)-[:FRIEND]->(e) | ||
``` | ||
|
||
### Run Betweenness Centrality - Sort Persons by importance based on FRIEND relationship | ||
|
||
```cypher | ||
CALL algo.betweenness({ | ||
'nodeLabels': ['Person'], | ||
'relationshipTypes': ['FRIEND'] | ||
}) | ||
YIELD node, score | ||
RETURN node.name AS person, score | ||
ORDER BY score DESC | ||
``` | ||
|
||
Expected result: | ||
|
||
| person | score | | ||
|-----------|--------| | ||
| `Bob` | 6 | | ||
| `Charlie` | 2 | | ||
| `David` | 2 | | ||
| `Alice` | 0 | | ||
| `Emma` | 0 | | ||
|
||
## Usage Notes | ||
|
||
- Scores are based on **all shortest paths** between node pairs. | ||
- Nodes that serve as bridges between clusters tend to score higher. | ||
- Can be computationally expensive on large, dense graphs. |
This file contains hidden or bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
Original file line number | Diff line number | Diff line change |
---|---|---|
@@ -0,0 +1,97 @@ | ||
--- | ||
title: "BFS" | ||
description: "Breadth-First Search (BFS) explores a graph level by level, visiting all neighbors of a node before moving to the next depth." | ||
parent: "Algorithms" | ||
--- | ||
|
||
# BFS | ||
|
||
## Overview | ||
|
||
The Breadth-First Search (BFS) procedure allows you to perform a breadth-first traversal of a graph starting from a specific node. | ||
BFS explores all the nodes at the present depth before moving on to nodes at the next depth level. | ||
This is particularly useful for finding the shortest path between two nodes or exploring a graph layer by layer. | ||
|
||
## Syntax | ||
|
||
``` | ||
CALL algo.bfs(start_node, max_depth, relationship) | ||
YIELD nodes, edges | ||
``` | ||
|
||
## Arguments | ||
|
||
| Name | Type | Description | Default | | ||
|--------------|----------------|-----------------------------------------------------------------------------|------------| | ||
| start_node | Node | Starting node for the BFS traversal | (Required) | | ||
| max_depth | Integer | Maximum depth to traverse | (Required) | | ||
| relationship | String or null | The relationship type to traverse. If null, all relationship types are used | null | | ||
|
||
## Returns | ||
|
||
| Name | Type | Description | | ||
|-------|------|----------------------------------------------| | ||
| nodes | List | List of visited nodes in breadth-first order | | ||
| edges | List | List of edges traversed during the BFS | | ||
|
||
## Examples | ||
|
||
### Social Network Friend Recommendations | ||
|
||
This example demonstrates how to use BFS to find potential friend recommendations in a social network. | ||
By exploring friends of friends, BFS uncovers second-degree connections—people you may know through mutual friends—which are often strong candidates for relevant and meaningful recommendations. | ||
|
||
#### Create the Graph | ||
|
||
```cypher | ||
CREATE | ||
(alice:Person {name: 'Alice', age: 28, city: 'New York'}), | ||
(bob:Person {name: 'Bob', age: 32, city: 'Boston'}), | ||
(charlie:Person {name: 'Charlie', age: 35, city: 'Chicago'}), | ||
(david:Person {name: 'David', age: 29, city: 'Denver'}), | ||
(eve:Person {name: 'Eve', age: 31, city: 'San Francisco'}), | ||
(frank:Person {name: 'Frank', age: 27, city: 'Miami'}), | ||
|
||
(alice)-[:FRIEND]->(bob), | ||
(alice)-[:FRIEND]->(charlie), | ||
(bob)-[:FRIEND]->(david), | ||
(charlie)-[:FRIEND]->(eve), | ||
(david)-[:FRIEND]->(frank), | ||
(eve)-[:FRIEND]->(frank) | ||
``` | ||
|
||
 | ||
|
||
#### Find Friends of Friends (Potential Recommendations) | ||
|
||
``` | ||
// Find Alice's friends-of-friends (potential recommendations) | ||
MATCH (alice:Person {name: 'Alice'}) | ||
CALL algo.bfs(alice, 2, 'FRIEND') | ||
YIELD nodes | ||
|
||
// Process results to get only depth 2 connections (friends of friends) | ||
WHERE size(nodes) >= 3 | ||
WITH alice, nodes[2] AS potential_friend | ||
WHERE NOT (alice)-[:FRIEND]->(potential_friend) | ||
RETURN potential_friend | ||
``` | ||
|
||
In this social network example, the BFS algorithm helps find potential friend recommendations by identifying people who are connected to Alice's existing friends but not directly connected to Alice yet. | ||
|
||
|
||
## Performance Considerations | ||
|
||
- **Indexing:** Ensure properties used for finding your starting node are indexed for optimal performance | ||
- **Maximum Depth:** Choose an appropriate max_depth value based on your graph's connectivity; large depths in highly connected graphs can result in exponential growth of traversed nodes | ||
- **Relationship Filtering:** When applicable, specify the relationship type to limit the traversal scope | ||
- **Memory Management:** Be aware that the procedure stores visited nodes in memory to avoid cycles, which may require significant resources in large, densely connected graphs | ||
|
||
## Error Handling | ||
|
||
Common errors that may occur: | ||
|
||
- **Null Starting Node:** If the start_node parameter is null, the procedure will raise an error; ensure your MATCH clause successfully finds the starting node | ||
- **Invalid Relationship Type:** If you specify a relationship type that doesn't exist in your graph, the traversal will only include the starting node | ||
- **Memory Limitations:** For large graphs with high connectivity, an out-of-memory error may occur if too many nodes are visited | ||
- **Result Size:** If the BFS traversal returns too many nodes, query execution may be slow or time out; in such cases, try reducing the max_depth or filtering by relationship types |
Oops, something went wrong.
Add this suggestion to a batch that can be applied as a single commit.
This suggestion is invalid because no changes were made to the code.
Suggestions cannot be applied while the pull request is closed.
Suggestions cannot be applied while viewing a subset of changes.
Only one suggestion per line can be applied in a batch.
Add this suggestion to a batch that can be applied as a single commit.
Applying suggestions on deleted lines is not supported.
You must change the existing code in this line in order to create a valid suggestion.
Outdated suggestions cannot be applied.
This suggestion has been applied or marked resolved.
Suggestions cannot be applied from pending reviews.
Suggestions cannot be applied on multi-line comments.
Suggestions cannot be applied while the pull request is queued to merge.
Suggestion cannot be applied right now. Please check back later.
Uh oh!
There was an error while loading. Please reload this page.