GDS Fundamentals SME Review (#459)

* update as per comments

* go live

---------

Co-authored-by: Adam Cowley <adam.cowley@neo4j.com>

Author: henrardo

asciidoc/courses/aura-fundamentals/modules/1-introduction/lessons/2-tiers/images/fact-check-sequence.mmd

@@ -0,0 +1,60 @@
+sequenceDiagram
+    participant U as User
+    participant A as Agent
+    participant R as Read Tool
+    participant D as Neo4j Docs MCP
+
+    U->>A: Fact-check @2-tiers lesson
+
+    Note over A: Step 1: Read lesson content
+    par Parallel reads
+        A->>R: Read lesson.adoc
+        A->>R: Read questions/1-choosing.adoc
+    end
+    R-->>A: Lesson content (4 tiers, limits, features)
+
+    Note over A: Step 2: Discover Aura docs
+    A->>D: list_manual_pages("aura")
+    D-->>A: 100+ Aura doc URLs
+
+    Note over A: Step 3: Read core tier docs
+    par Batch 1
+        A->>D: read_page(main aura page)
+        A->>D: read_page(create-instance)
+        A->>D: read_page(backup-restore)
+    end
+    D-->>A: Tier names, backup frequencies
+
+    Note over A: Step 4: Verify security claims
+    par Batch 2
+        A->>D: read_page(encryption)
+        A->>D: read_page(single-sign-on)
+        A->>D: read_page(cloud-providers)
+    end
+    D-->>A: CMEK for VDC, SSO for BC+VDC
+
+    Note over A: Step 5: Check RBAC & limits
+    par Batch 3
+        A->>D: read_page(migration-free)
+        A->>D: read_page(user-management)
+    end
+    D-->>A: RBAC exists for all tiers
+
+    Note over A: Step 6: Additional verification
+    par Batch 4
+        A->>D: read_page(instance-resources)
+        A->>D: read_page(ip-filtering)
+    end
+
+    par Batch 5
+        A->>D: read_page(billing-dimensions)
+        A->>D: read_page(new-console)
+    end
+
+    Note over A: Step 7: Analyze & compare
+    A->>A: Cross-reference claims vs docs
+    A->>A: Identify verified/unverified/incorrect
+
+    A->>U: Fact-check report with corrections
+
+

asciidoc/courses/aura-fundamentals/modules/1-introduction/lessons/2-tiers/images/fact-check-sequence.png

@@ -1,9 +1,9 @@
-= Get started with the Graph Data Science library
+= Get started with Graph Data Science
 :usecase: recommendations
 :categories: data-scientist:1, data-analysis:10, intermediate:3
 :duration: 3-4 hours
 :caption: Learn the fundamentals of Neo4j Graph Data Science
-:status: draft
+:status: active
 :key-points: Graph projections, Algorithm execution, Algorithm configuration, Relationship aggregation, Projection modeling
 :graph-analytics-plugin: true
 

asciidoc/courses/gds-fundamentals/course.adoc

@@ -16,6 +16,12 @@ By the end of this lesson, you will understand:
 * What graph structures you're creating when you project
 * Why different projection types matter for algorithms
 
+[NOTE]
+.Algorithm requirements drive projection choices
+====
+Different algorithms have different requirements for graph structure. Some algorithms work optimally on monopartite graphs (single node type), while others are designed for bipartite graphs (two distinct node types). As you learn projection techniques throughout this module, keep in mind that your projection choices should be guided by which algorithms you plan to use. You'll learn more about algorithm-specific requirements in Module 3.
+====
+
 
 == Cypher Projection Anatomy
 

asciidoc/courses/gds-fundamentals/modules/2-gds-basic-concepts/lessons/2-graph-projection-basics/lesson.adoc

@@ -159,6 +159,12 @@ Let's say you're a producer, and you want a star who will bridge multiple fan co
 
 You could use these results.
 
+[NOTE]
+.Computational complexity and large graphs
+====
+Betweenness centrality is computationally expensive, especially on large graphs. It has O(n³) time complexity, which means it can take hours or even days to run on graphs with millions of nodes.
+====
+
 
 == Community Detection: Finding Groups
 
@@ -362,6 +368,28 @@ Different questions require different algorithm categories:
 
 The same projection can answer multiple questions. One projection cannot answer all questions equally. 
 
+[NOTE]
+.Graph size and algorithm performance
+====
+When working with large graphs, algorithm performance becomes critical. Some algorithms that work well on small datasets become impractical on graphs with millions of nodes:
+
+**Performance considerations by graph size:**
+
+* **Small graphs (<1M nodes):** Most algorithms run quickly; choose based on your analytical question
+* **Medium graphs (1-10M nodes):** Avoid exact betweenness centrality
+* **Large graphs (>10M nodes):** Prioritize scalable algorithms and consider approximate versions
+
+**Approximate algorithms:**
+
+Many computationally expensive algorithms have approximate versions that trade some accuracy for significant speed improvements. These use sampling or heuristics to provide results faster. Look for parameters like:
+
+* `samplingSize` - Controls how much of the graph to sample
+* `maxIterations` - Limits computation time for iterative algorithms
+* `tolerance` - Sets convergence thresholds for early stopping
+
+Check the link:https://neo4j.com/docs/graph-data-science/current/[GDS documentation] for algorithm-specific parameters and their approximate variants.
+====
+
 == What's next
 
 You now understand the five main categories of algorithms in GDS and the types of questions each can answer. You've seen how the same data can be modeled differently depending on your analytical question.

asciidoc/courses/gds-fundamentals/modules/3-working-with-algorithms/lessons/1-algorithms-overview/lesson.adoc

@@ -397,6 +397,16 @@ The output shows how many nodes and relationships will be processed, and how muc
 
 GDS operates entirely in heap memory. For large graphs or complex algorithms, you may need to increase your heap size.
 
+[NOTE]
+.Estimate for time planning, not just memory
+====
+While estimate mode primarily shows memory requirements, it's also valuable for understanding computational scale. The `nodeCount` and `relationshipCount` in the estimate output, combined with knowledge of an algorithm's complexity, help you predict execution time. 
+
+For example, if estimate shows your graph has 250 million nodes and you're planning to run betweenness centrality (O(n³) complexity), you can anticipate an extremely long runtime—potentially days. This is when you should consider approximate algorithms or alternative approaches before starting a job that might run indefinitely.
+
+Use estimate mode as your first check for both memory feasibility and computational practicality.
+====
+
 To check or modify heap settings, open your `neo4j.conf` file:
 
 image::images/neo4j_conf.png[the main instance page of Neo4j Desktop 2. Click the three dots, hover on Open and choose neo4j.conf]

asciidoc/courses/gds-fundamentals/modules/3-working-with-algorithms/lessons/2-five-execution-modes/lesson.adoc

@@ -79,7 +79,6 @@ Or, if you absolutely had to use Leiden, you could add relationship weights to s
 
 Most algorithms support multiple configurations, but checking these attributes first saves time and helps you understand the algorithm's capabilities.
 
-
 == Reading Algorithm Syntax
 
 The syntax section shows you exactly how to call an algorithm. Here's an example for PageRank:

asciidoc/courses/gds-fundamentals/modules/3-working-with-algorithms/lessons/4-understanding-gds-docs/lesson.adoc

@@ -1,5 +1,5 @@
 [.question]
-= Question-Driven Projection Design
+= Using questions to drive projection design
 
 You're asked: "Which actors are most influential in Hollywood based on their collaboration network?"
 

asciidoc/courses/gds-fundamentals/modules/4-essential-projection-techniques/lessons/4-projection-modeling/questions/1-question-driven-design.adoc

@@ -4,7 +4,8 @@
 :duration: 30 minutes
 :next: graph-data-science-fundamentals
 :caption: Gain a high-level technical understanding of the Neo4j Graph Data Science (GDS) library
-:status: active
+:status: redirect
+:redirect: /courses/gds-fundamentals/
 :key-points: Graph Data Science, Graph projections, Installation options, GDS licensing
 
 == Course Description

asciidoc/courses/gds-product-introduction/course.adoc

@@ -4,8 +4,9 @@
 :duration: 1 hour
 :next: gds-shortest-paths
 :caption: Learn all you need to know about Graph Algorithms and Machine Learning Pipelines
-:status: active
 :key-points: Graph Data Science, Graph algorithms, Machine learning pipelines, GDS machine learning operations
+:status: redirect
+:redirect: /courses/gds-fundamentals/
 
 == Course Description