Never fail when no localMoves are ever done

Co-authored-by: Veselin Nikolov <veselin.nikolov@neotechnology.com>

Author: IoannisPanagiotas

algo/src/main/java/org/neo4j/gds/leiden/Leiden.java

@@ -133,9 +133,10 @@ public LeidenResult compute() {
                 gamma,
                 concurrency
             );
-            var communitiesCount = localMovePhase.run();
-            boolean localPhaseConverged = communitiesCount == workingGraph.nodeCount() || localMovePhase.swaps == 0;
 
+            localMovePhase.run();
+            //if you do swaps,  no convergence
+            boolean localPhaseConverged = localMovePhase.swaps == 0;
             progressTracker.endSubTask("Local Move");
 
             progressTracker.beginSubTask("Modularity Computation");
@@ -244,11 +245,11 @@ public LeidenResult compute() {
 
     @NotNull
     private LeidenResult getLeidenResult(boolean didConverge, int iteration) {
-        boolean seedIsOptimal = didConverge && seedValues.isPresent() && iteration == 0;
-        if (seedIsOptimal) {
+        boolean stoppedAtFirstIteration = didConverge && iteration == 0;
+        if (stoppedAtFirstIteration) {
             var modularity = modularities[0];
             return LeidenResult.of(
-                LeidenUtils.createSeedCommunities(rootGraph.nodeCount(), seedValues.orElse(null)),
+                LeidenUtils.createStartingCommunities(rootGraph.nodeCount(), seedValues.orElse(null)),
                 1,
                 didConverge,
                 null,
@@ -266,8 +267,8 @@ private LeidenResult getLeidenResult(boolean didConverge, int iteration) {
             );
         }
     }
-    
-    private boolean updateModularity(
+
+    private void updateModularity(
         Graph workingGraph,
         HugeLongArray localMoveCommunities,
         HugeDoubleArray localMoveCommunityVolumes,
@@ -276,8 +277,10 @@ private boolean updateModularity(
         boolean localPhaseConverged,
         int iteration
     ) {
-        boolean seedIsOptimal = localPhaseConverged && seedValues.isPresent() && iteration == 0;
-        boolean shouldCalculateModularity = !localPhaseConverged || seedIsOptimal;
+        //will calculate modularity only if:
+        // -    the local phase has not converged (i.e., no swaps done)
+        //- or we terminate in the first iteration (i.e., given seeding is optimal, graph is empty etc)
+        boolean shouldCalculateModularity = !localPhaseConverged || iteration == 0;
 
         if (shouldCalculateModularity) {
             modularities[iteration] = ModularityComputer.compute(
@@ -291,7 +294,6 @@ private boolean updateModularity(
                 progressTracker
             );
         }
-        return seedIsOptimal;
     }
 
     private double initVolumes(

algo/src/test/java/org/neo4j/gds/leiden/LeidenTest.java

@@ -41,6 +41,7 @@
 import org.neo4j.gds.extension.IdFunction;
 import org.neo4j.gds.extension.Inject;
 import org.neo4j.gds.extension.TestGraph;
+import org.neo4j.gds.gdl.GdlFactory;
 
 import java.util.stream.Collectors;
 import java.util.stream.LongStream;
@@ -154,6 +155,8 @@ void shouldWorkWithBestSeed() {
                 community -> assertThat(community).containsExactlyInAnyOrder("a1", "a5", "a6", "a7")
             );
         assertThat(communitiesMap.keySet()).containsExactly(4000L, 5000L);
+
+        assertThat(leidenResult.modularity()).isGreaterThan(0);
     }
 
     @Test
@@ -364,4 +367,29 @@ void shouldLogProgress() {
                 "Leiden :: Finished"
             );
     }
+
+    @Test
+    void shouldWorkIfStopAtFirstIteration() {
+
+        var query = " CREATE\n" +
+                    "          (c:C {id: 0}) \n" +
+                    "        , (d:D {id: 1}) ";
+        var empty = GdlFactory.of(query).build().getUnion();
+        var result = new Leiden(
+            empty,
+            5,
+            1,
+            0.01,
+            false,
+            42,
+            null,
+            0.1,
+            1,
+            ProgressTracker.NULL_TRACKER
+        ).compute();
+        var communities = result.communities();
+        assertThat(communities.toArray()).isEqualTo(new long[]{0, 1});
+
+
+    }
 }