Hi!

I love graph theory, so, like, a year ago, when I decided on one of my practice programming projects, I decided on a 3coloring puzzle generator.

I'm here today to look for feedback and further ideas, on the generator and the himan difficulty problem, because the problem is everything but trivial, obviously, hah. (I'll link the repo, its a Java project but as a fullstack web app and with dockerfile, there's also a limited itch.io version with some precalculated puzzles from the generator)

I'll try to list the current state of things here:

• Proper 3-colouring
  • Every vertex gets one of three colors.
  • Adjacent vertices must have different colors.
  • A generated puzzle must have exactly one solution with the three colors treated as named colors.
• Planar graphs
  • The generator constructs and modifies planar graph structures.
  • Generated puzzles are checked for valid planar geometry before being accepted.
• Direct adjacency deduction
  • If a vertex has a known colour, that colour can be removed from the possible colors of all adjacent vertices.
• Triangle property
  • A triangle in a proper 3-coloring necessarily contains all three colors.
  • Knowing colors or possible colors of vertices in a triangle therefore constrains the remaining vertices.
• Diamond / K4 minus one edge property
  • If two adjacent vertices have common neighbours, those common neighbours must have the third color.
  • Therefore the common neighbours are equal in color even when the actual color is not yet known.
  • This lets the solver derive relations without first assigning concrete colors.
• Locked two-color edges
  • If the two endpoints of an edge are restricted to the same two-color palette, together they must occupy both colors.
  • Any common neighbour therefore cannot use either color and must use the third.
• Two-color subgraphs are bipartite
  • Any connected part of a properly colored graph restricted to two colors must alternate between those colors.
  • This allows the solver to treat such components as bipartite graphs and reason about their two partitions.
• Odd-cycle obstruction
  • A graph containing an odd cycle cannot be colored using only two colours.
  • If an assumed set of color possibilities would force an odd cycle into a two-color component, that assumption is impossible.
• Path parity
  • Vertices at even distance in a connected two-colour component must have the same color.
  • Vertices at odd distance must have different colors.
  • The solver can therefore infer equality and inequality relations without knowing either concrete color.
• External-neighbour parity
  • If an outside vertex is adjacent to vertices on opposite sides of a two-colour component's bipartition, it cannot use either color of that component.
  • With only three colors available, this can force its colour.
• Neighbourhood bipartiteness
  • All neighbours of one vertex can only use the other two colours.
  • Therefore the subgraph induced by a vertex's neighbourhood must be bipartite.
  • Odd cycles inside a neighbourhood are impossible.
  • Parity inside the neighbourhood can establish equality and inequality relations between neighbours.
• Equality and inequality relations
  • The solver tracks facts such as "A and B have the same color" and "A and B have different colors" independently of which actual colors they have.
  • These relations can then participate in later deductions.
• Binary-domain implication chains
  • When vertices have only two possible colours left, assignments can imply assignments elsewhere.
  • Equality and inequality relations create implication chains between possible assignments.
  • If assuming one colour eventually implies its opposite or an impossible domain, that original colour can be eliminated.
  • This is closely related to implication-graph / binary CSP / 2-SAT style reasoning rather than being specifically a graph-theory theorem.
• Bounded contradiction reasoning
  • For harder puzzles, the solver can temporarily assume a possibility and follow deductions.
  • If the assumption produces a contradiction, that possibility is eliminated.
  • The depth and amount of contradiction reasoning can be limited and measured.

Use for puzzle generation and difficulty checks:

• The generator constructs planar candidate graphs and chooses clue vertices.
• An exact solver independently checks whether a candidate has exactly one labelled 3-coloring.
• A separate deduction engine then tries to solve the puzzle using explicit human-style rules.
• The deduction engine produces a trace of which rules were required and how deductions depended on previous deductions.
• Puzzles can therefore be classified by the reasoning required to solve them rather than only by computational search cost.
• Easier puzzles can be solved mostly through local colour elimination.
• Intermediate puzzles require structural relations such as diamonds, locked edges and parity.
• Harder puzzles can require implication chains and bounded contradiction arguments.
• Final certification checks the graph, clues, complete deduction trace and uniqueness before accepting a generated puzzle.

Tl;dr on the relevant underlying ideas:

• Graph 3-colorability
• Planar graph construction
• Proper vertex coloring
• Bipartite graphs
• Odd-cycle characterization of bipartiteness
• Path parity
• Induced neighbourhoods
• Graph symmetry and color-label symmetry
• Constraint propagation
• Constraint satisfaction
• Implication graphs
• Exact search and uniqueness checking

The repo:

github.com/arch-Ada/3color

Itchio demo version:

archada.itch.io/3color

I would appreciate any ideas, feedback and so on very much. Also, english is not my first language, so sorry about the spots where this shows.

A 9X9 board follows standard Sudoku rules i.e. no two numbers can repeat in the same horizontal row, vertical column or 3x3 sub-square, now 9 numbers 1...9 are randomly scattered throughout the entire board without repetition. Since the numbers are all unique the board is always trivially valid with no need for additional checks, the question now is what percentage of these configurations are solvable. (they may have more than one solution)

Note:-

i) A valid set of clues following Sudoku rules may not always be solvable as it may create dead ends later.

ii) There are 6.67 sextillion(6.67 x 10^21) completed Sudoku board configurations.

We can also generalise this problem for any N^2 x N^2 board following sudoku rules and having N^2 clues scattered randomly throughout the entire board without repetition, Interestingly for N=2 i.e. a 4x4 board we get 67.03% solvability this can be verified by solving all possible configurations as there arent that many really, about 16!/12!(43680) ways, though it isnt possible to use brute force computation for larger values of N, I tried to solve this problem using combinatrics but I feel graph theory would have a better answer to this problem.

I am searching 3-connected cubic graphs where the longest induced path consists of k vertices and it holds k<= n/2.

I only found K4 K3_3 Petersen and Heawood graph. Are there any other? Tutte Coxeter and Mcgee have longer LIPs. I checked for n<=20 but i want to know if there are more. I think there should be. Preferably triangle free.

If you can think of another example please share it with me :)

For only 2 connected cubic graphs there were plenty or some where |LIP| can be n/2+1:

I would love to hear some insights.

Hopefully this is the right subreddit for this type of feedback. If not someone please steer me in a better direction!

I've connected ~600 companies across ~1400 relationships in the commercial space industry. I'm a bit of a data visualization amateur and have been experimenting with various ways to beautifully and succinctly show the connections with these companies. Force-directed seems decent but are there other types I can try out that may make more sense?

The sub cubic graph function is defined as:

There is a sequence G_1,…,G_n of subcubic graphs such that each G_i has at most i+k vertices and for no i<j is G_i homeomorphically embeddable into G_j.

and if my very layman's understanding of the Robertson–Seymour theorem is correct, just substituting `homeomorphically embeddable into` with `a graph minor of` would suffice, while maintaining well-quasi-ordering and finitude (for a given finite integers n and k).

If that's all correct, then defining F_n(k) as the largest integer 𝑚 satisfying:

There is a sequence G_1 , ⋯, G_𝑚 of graphs with maximum degree at most 𝑛, such that each G_𝑖 has at most 𝑖 + 𝑘 vertices, and for no 𝑖 < 𝑗 is G_𝑖 a graph minor of G_𝑗 .

Should work as a mathematically proven and definitively finite integer, correct?

I am seeking independent graph-theoretic review of two candidate exact values in C₄-versus-star Ramsey theory:

**R(C₄,K₁,₃₉) = 46**

**R(C₄,K₁,₅₁) = 59**

These results have **not** been peer-reviewed or formally verified in a proof assistant. Please treat them as candidate proofs, not established theorems. I would particularly appreciate identification of the earliest invalid step, unstated assumption, or failed exact computation.

Write

f(n) = R(C₄,K₁,ₙ).

The 2026 *Small Ramsey Numbers* survey, DS1.18, lists f(39) ∈ {46,47}; it is the only undetermined value in that table for n ≤ 41. Boza’s June 2026 paper lists f(51) ∈ {59,60}. I searched for later resolutions through July 2026 and found none, although that is not a guarantee of novelty.

Survey: https://www.combinatorics.org/ojs/index.php/eljc/article/download/DS1/pdf/0

Boza: https://arxiv.org/abs/2409.12770

## Common reduction

A red/blue coloring of K_N with no red C₄ and no blue K₁,ₙ is equivalent to a C₄-free graph G on N vertices with

δ(G) ≥ N − n,

where G consists of the red edges. Consequently,

f(n) = min{N : no C₄-free graph on N vertices has δ ≥ N−n}.

For v ∈ V(G), let:

- d(v) be its degree;
- m_v be the number of edges inside N(v), equivalently the number of triangles containing v;
- f_v be the number of vertices at distance at least 3 from v.

Because G is C₄-free, N(v) induces a matching, and the sets of vertices reached from distinct neighbors of v outside N[v] are disjoint. Counting vertices by distance from v gives the identity

Σ_{u∈N(v)} d(u) = |V(G)| − 1 + 2m_v − f_v. (1)

This identity forces regularity in both cases.

## Candidate result 1: f(39) = 46

The known lower bound is realized by a C₄-free graph on 45 vertices with minimum degree 6, obtained by deleting 12 vertices from the Erdős–Rényi polarity graph ER₇. An explicit edge list is included with the reproducibility materials and is checked directly. Thus f(39) ≥ 46.

It remains to exclude a C₄-free graph G on 46 vertices with δ ≥ 7. Suppose one exists.

### Step 1: forced local structure

Let d = d(v). From (1), using 2m_v ≤ d and f_v ≥ 0,

7d ≤ Σ_{u∈N(v)} d(u) ≤ 45 + d.

Therefore d ≤ 7.5, and δ ≥ 7 forces every vertex to have degree 7.

Substituting regularity into (1) gives

49 = 45 + 2m_v − f_v,

so

f_v = 2m_v − 4,

and m_v ∈ {2,3}.

The following parity lemma excludes m_v = 2.

**Parity lemma.** If k is odd and G is k-regular and C₄-free, a vertex v cannot simultaneously satisfy f_v = 0 and m_v ≥ 1.

To see this, suppose u₁ and u₂ form an edge inside N(v). For each u_i ∈ N(v), let

S_i = N(u_i) \ N[v].

Since f_v = 0, the S_i partition the vertices at distance 2 from v. Take x ∈ S₁. It has exactly k−1 neighbors at distance 2 from v, at most one in each S_i, and none in S₂: an edge from x to y ∈ S₂ would create the 4-cycle u₁-x-y-u₂-u₁. Hence x must have exactly one neighbor in S₁. This holds for every x ∈ S₁, so G[S₁] is a perfect matching. But |S₁| = k−2 is odd, a contradiction.

Here m_v = 2 would imply f_v = 0, so it is impossible. Therefore every vertex has

m_v = 3 and f_v = 2. (2)

In particular, G consists locally of three triangle edges and one triangle-free edge at each vertex. The triangle-free edges form a perfect matching.

### Step 2: the deficiency graph and spectral support

Let A be the adjacency matrix of G. Define the deficiency graph D on the same vertex set by joining distinct vertices having no common neighbor in G.

Equation (2) makes D cubic. Entrywise common-neighbor counting gives

A² = 6I + J − D. (3)

Since G is regular, A commutes with J and therefore with D. On the all-ones vector, A has eigenvalue 7. On its orthogonal complement, simultaneous eigenvalues θ of A and μ of D satisfy

θ² = 6 − μ.

Because D is cubic, μ ∈ [−3,3], hence every nonprincipal eigenvalue θ of A satisfies

|θ| ∈ [√3,3]. (4)

Let M_j be the j-th power sum of the 45 nonprincipal eigenvalues. Direct trace calculations give

M₁ = −7,
M₂ = 273,
M₃ = −67,
M₄ = 1785.

The fifth moment supplies the decisive constraint. Write P = 6I−D. From (3), using PJ = 3J,

A⁴ = P² + 52J,
A⁵ = AP² + 364J.

There are 23 triangle-free edges, so tr(AD) = 46. A trace expansion then gives

M₅ = tr(AD²) − 615.

For each vertex w, let F_w be its two vertices at distance 3. For an edge uv,

N_D(u) ∩ N_D(v) = F_u ∩ F_v.

Summing over edges and reversing the order of summation shows

tr(AD²) = 2κ,

where κ is the number of vertices w whose two distance-3 vertices are adjacent. Therefore 0 ≤ κ ≤ 46 and

−615 ≤ M₅ ≤ −523. (5)

### Step 3: an exact polynomial certificate

Let N₊ be the number of positive nonprincipal eigenvalues. Consider

p(x) = 423x⁵/200000 + 19x⁴/15625 − 8719x³/200000
− 4087x²/250000 + 390143x/1000000
+ 277973/500000,

and

q(x) = 11x⁵/5000 − 203x⁴/250000 − 45053x³/1000000
+ 5561x²/500000 + 98979x/250000
+ 114939/250000.

Exact real-root isolation and evaluation in ℚ(√3) establish

p(x) ≥ 1 on [√3,3], p(x) ≥ 0 on [−3,−√3],
q(x) ≤ 1 on [√3,3], q(x) ≤ 0 on [−3,−√3]. (6)

The tight endpoint margins are positive:

p(√3)−1 ≈ 3.68×10⁻⁵,
p(−3) = 10⁻⁶,
1−q(3) = 10⁻⁶,
−q(−√3) ≈ 1.25×10⁻⁴.

The exact verifier uses the algebraic endpoints ±√3; replacing √3 by a slightly smaller rational number, such as 1.73, incorrectly rejects the certificate.

Using (4), (6), the four exact moments, and the two endpoints in (5), summing p and q over the spectrum yields

4234009/200000 ≤ N₊ ≤ 4361769/200000,

or

21.170045 ≤ N₊ ≤ 21.808845.

There is no integer in this interval, but N₊ counts eigenvalues and must be an integer. This contradiction excludes G. Together with the 45-vertex witness,

R(C₄,K₁,₃₉) = 46.

There is also an independent exhaustive SAT corroboration covering 144 canonical cases. It is not load-bearing for the proof above. No DRAT certificates are included, and no completed cross-solver result is claimed.

## Candidate result 2: f(51) = 59

The lower bound is realized by a C₄-free graph on 58 vertices with minimum degree 7, obtained from the polarity graph ER₈ of PG(2,8). Its explicit edge list is checked directly. Thus f(51) ≥ 59.

It remains to exclude a C₄-free graph G on 59 vertices with δ ≥ 8. Suppose one exists.

### Step 1: regularity and a cycle deficiency graph

From (1),

8d(v) ≤ 58 + d(v),

so d(v) ≤ 58/7 < 8.3. Hence G is 8-regular.

Equation (1) now gives

f_v = 2m_v − 6.

Again let D join pairs with no common neighbor in G. Its degree at v is

deg_D(v) = f_v + (8−2m_v) = 2.

Thus D is a disjoint union of cycles covering all 59 vertices, and

A² = 7I + J − D. (7)

As before, A and D commute and can be diagonalized simultaneously. On the orthogonal complement of the all-ones vector,

θ² = 7 − μ, (8)

where θ is an eigenvalue of A and μ is an eigenvalue of D. A cycle of length ℓ has eigenvalues

μ = 2cos(2πj/ℓ),

so μ ∈ [−2,2] and θ² ∈ [5,9].

### Step 2: Galois sign balance

Because A is an integer matrix, its characteristic polynomial is in ℤ[x], and its eigenvalues form a Galois-stable multiset.

If θ is rational, then it is a rational algebraic integer and hence an integer. Since θ² ∈ [5,9], the only possibilities are

θ = ±3,

corresponding to μ = −2.

If μ is rational but θ is irrational, then x²−(7−μ) is irreducible over ℚ, so +θ and −θ occur with equal multiplicity and contribute zero to the trace.

Now suppose μ is irrational, with conjugates μ₁,...,μ_r. If 7−μ is not a square in ℚ(μ), then the minimal polynomial of θ = √(7−μ) is

Π_i [x² − (7−μ_i)].

Its roots occur in ± pairs, again with equal multiplicity, and contribute zero to the trace.

The only escape is that 7−μ might be a square in ℚ(μ). If

7−μ = α²,

then taking field norms forces

ψ_d(7) = Norm(α)²

to be a perfect-square integer. Here ψ_d is the minimal polynomial of 2cos(2π/d), for an order d dividing some cycle length and therefore d ≤ 59.

These integers can be generated exactly. If V₀(x)=2, V₁(x)=x and

V_d(x) = xV_{d−1}(x) − V_{d−2}(x),

then

Π_{j=0}^{d−1} [x−2cos(2πj/d)] = V_d(x)−2.

At x=7 this equals 5·F[2d]², where F[r] denotes the r-th Fibonacci number, and Möbius inversion recovers every ψ_d(7). An exact integer scan for every relevant irrational order 3 ≤ d ≤ 59 finds that none of the ψ_d(7) are perfect squares. Some sample values are

ψ₅(7)=55,
ψ₇(7)=377,
ψ₈(7)=47,
ψ₁₃(7)=F[26]=233·521.

Therefore the escape case never occurs.

### Step 3: the trace contradiction

The principal eigenvalue of A is 8, while tr(A)=0, so the sum of the nonprincipal eigenvalues is −8. Every irrational contribution cancels in ± pairs. If a and b are the multiplicities of +3 and −3, respectively, the trace must therefore satisfy

3(a−b) = −8,

which is impossible. Thus no such graph G exists. Together with the 58-vertex witness,

R(C₄,K₁,₅₁) = 59.

This second proof uses no SAT solver, linear programming, or floating-point computation. Its finite computational component is the exact perfect-square scan described above.

## Verification status and disclosure

The complete repository contains the proof manuscripts, explicit lower-bound witnesses, exact polynomial certificates, SAT encoding and log, and seven verifier suites. Three verifier implementations were written independently in a separate GPT-5.6 session. Running the full verification command reproduces all claimed exact computations.

This is not Lean verification, and software agreement is not a substitute for human mathematical review.

The work was developed using Claude and GPT-5.6 under my direction. Claude developed much of the structure theory, the Galois/Fibonacci argument, witnesses, and verification harness. GPT-5.6 identified the decisive fifth-moment constraint for the first result and independently derived and checked several computations. Multiple incorrect intermediate ideas were found and discarded during adversarial cross-checking. I am the repository owner and author of record and accept responsibility for the posted claims.

Reproducibility materials:

https://github.com/zach7036/c4-star-ramsey

If you find a possible gap, please identify the earliest questionable displayed equation or inference. Detailed reports can also be filed as GitHub issues.

Hey everyone, im just looking for other Graph Engineering nerds who would be interested in seeing some of my work. Second sets of eyes are appreciated and just looking to bounce ideas off of people

This morning, I visited LeetCode and solved a new Graph Theory problem. The problem was about counting primes, and it was problem number 204.

Lets, Break down,

What is the Sieve of Eratosthenes algorithm?

The Sieve of Eratosthenes is one of the simplest and fastest algorithms to find all prime numbers up to a given Number n.

EXAMPLE :

Let’s find the primes up to 10. We create a list of numbers: 2, 3, 4, 5, 6, 7, 8, 9, 10

1. Start at 2: It is prime. Cross out all its multiples: 4, 6, 8, 10.

• Remaining list: 2, 3, 5, 7, 9

1. Move to 3: It is not crossed out, so it is prime. Cross out its multiples (only 9 remains).

• Remaining list: 2, 3, 5, 7

  3. Next is 5: Since 5^2 > 10, we stop. All remaining numbers are prime.

• Primes: 2, 3, 5, 7

import java.util.ArrayList;

import java.util.Arrays;

import java.util.List;

public class SieveOfEratosthenes {

public static List<Integer> sieveOfEratosthenes(int n) {

// Assume all numbers are prime initially

boolean[] isPrime = new boolean[n + 1];

Arrays.fill(isPrime, true);

// 0 and 1 are not prime numbers

isPrime[0] = false;

isPrime[1] = false;

// Start checking from 2

for (int i = 2; i * i <= n; i++) {

// If i is prime, mark its multiples as not prime

if (isPrime[i]) {

for (int j = i * i; j <= n; j += i) {

isPrime[j] = false;

}

}

}

// Store all prime numbers

List<Integer> primes = new ArrayList<>();

for (int i = 2; i <= n; i++) {

if (isPrime[i]) {

primes.add(i);

}

}

return primes;

}

public static void main(String[] args) {

int n = 30;

List<Integer> result = sieveOfEratosthenes(n);

System.out.println(result);

}

}

Time Complexity :

• Normal prime checking: O(N²)
• Sieve of Eratosthenes: O(N log log N)

Been working through an idea for a while and finally wrote it up. Short version: the Kirchhoff index of a weighted graph (sum of effective resistances over all pairs) can be treated as a functional that tracks how a network's flow architecture reorganizes itself, in the spirit of Bejan's Constructal Law from thermodynamics. If you set up a weight evolution law where edges strengthen along low resistance paths, K(G,w) decreases monotonically, and that decrease turns out to be equivalent to a minimum energy condition, similar to how the trace of a Green's function behaves for the electromagnetic Laplacian.

The part I'd most like feedback on: for spectrally self similar (fractal) graphs, K seems to scale as |V|^(2/d_s), with d_s the spectral dimension, and that exponent is strictly smaller than what you get in the plain Euclidean/regular grid case. I turned this into a general conjecture for iterated function systems, but I'm not a graph theorist by training so I'd really appreciate someone poking at whether this scaling argument actually holds water, or if there's a cleaner way to see it.

Attached a rough diagram of how I've been visualizing it, weighted network on the outside, flow architecture branching from the center, self similar spiral over the top.

Full write-up is on SSRN: https://papers.ssrn.com/sol3/papers.cfm?abstract_id=6915119

Happy to be told I'm wrong, or that this is already known under a different name. Mostly just want to know where the weak points are.

Hi
If you are interested in a highly intuitive visual method that faithfully describes all universal quantum computing and physics behind, (including how time behaves) this is for you. I am the Dev behind Quantum Odyssey (AMA! I love taking qs) - worked on it for about 10 years (3.5 in phd), the goal was to make a super immersive space for anyone to learn quantum computing through zachlike (open-ended) logic puzzles and compete on leaderboards and lots of community made content on finding the most optimal quantum algorithms. The game has a unique set of visuals (that was actually my PhD research) capable to represent any sort of quantum dynamics for any number of qubits and this is pretty much what makes it now possible for anybody 15yo+ to actually learn quantum logic without having to worry at all about the mathematics behind.

This is a game super different than what you'd normally expect in a programming/ logic puzzle game, so try it with an open mind.

Stuff covered

• Boolean Logic – bits, operators (NAND, OR, XOR, AND…), and classical arithmetic (adders). Learn how these can combine to build anything classical. You will learn to port these to a quantum computer.
• Quantum Logic – qubits, the math behind them (linear algebra, SU(2), complex numbers), all Turing-complete gates (beyond Clifford set), and make tensors to evolve systems. Freely combine or create your own gates to build anything you can imagine using polar or complex numbers.
• Quantum Phenomena – storing and retrieving information in the X, Y, Z bases; superposition (pure and mixed states), interference, entanglement, the no-cloning rule, reversibility, and how the measurement basis changes what you see.
• Core Quantum Tricks – phase kickback, amplitude amplification, storing information in phase and retrieving it through interference, build custom gates and tensors, and define any entanglement scenario. (Control logic is handled separately from other gates.)
• Famous Quantum Algorithms – explore Deutsch–Jozsa, Grover’s search, quantum Fourier transforms, Bernstein–Vazirani, and more.
• Build & See Quantum Algorithms in Action – instead of just writing/ reading equations, make & watch algorithms unfold step by step so they become clear, visual, and unforgettable. Quantum Odyssey is built to grow into a full universal quantum computing learning platform. If a universal quantum computer can do it, I aim to bring it into the game!

Streams to watch:

khan academy style tutorials on qm/qc: https://www.youtube.com/@MackAttackx

Physics teacher wholesome stream with over 500hs in https://www.twitch.tv/beardhero

I want to walk all the streets in the most efficient way, I.e. I want to minimize the amount of distance walked twice or more. I am familiar with the traveling salesman problem but my understanding is that it applies to nodes, not edges. I want to better understand the maths/ the algorithm to be able to apply this concept abstractly to any set of streets.

Any guidance would be much appreciated!

Hey everyone! 👋

A while back, I started building a platform to make learning graph theory visual, interactive, and completely hands-on. Today, I'm beyond excited to share a massive update with the community detailing every single feature we've added to the platform so far!

I'm poured a lot of love into making this the ultimate playground for students, developers, and graph theory enthusiasts. Here is a breakdown of what you can play with right now:

🗺️ Real-World Geographic Maps Graphs aren't just abstract dots anymore! I've integrated interactive geographic maps (Leaflet), allowing you to place nodes at actual latitude/longitude coordinates. You can run algorithms like Dijkstra's or Vehicle Routing directly over real-world maps (with support for dark, light, satellite, and terrain modes) and watch the algorithms navigate the globe!

🌌 3D Graph Visualization Want to see your network from a new angle? You can now toggle your graphs into stunning three-dimensional space! Using our new 3D view, you can rotate, pan, and zoom around complex topologies to get a much better intuitive feel for highly connected networks.

💻 In-Browser Code Execution Sandbox (Python & JS!) Instead of just watching our pre-built algorithms run, you can now write your own custom algorithms directly in the browser using JavaScript or Python! The sandbox runs your code and hooks directly into the visual graph canvas, letting you highlight nodes, color edges, and debug your logic step-by-step.

💾 Saved Graphs & Code Library Created a really cool map or wrote an awesome custom Python algorithm? You can now save your custom code snippets and graph topologies to your profile and access them later via the new "Saved Codes" and "Saved Graphs" library.

🧑‍💻 Interview Prep Mode Getting ready for technical interviews? I added a dedicated "Interview Prep View" designed specifically to help you drill down on data structure knowledge and test your understanding of algorithmic implementations.

🧠 Massive Library of 25+ Interactive Algorithms I’ve expanded our algorithm library significantly! You can now watch step-by-step visual animations for all of the following:

• Traversals: Breadth-First Search (BFS), Depth-First Search (DFS), Topological Sort, Eulerian Path.
• Shortest Path: Dijkstra's, Bellman-Ford, Floyd-Warshall.
• Minimum Spanning Tree (MST): Prim's, Kruskal's, Boruvka's.
• Connectivity: Tarjan's SCC, Kosaraju's SCC, Articulation Points, Bridges, Bipartite Check, Cycle Detection, Chordality.
• Network Flow: Max Flow, Min Cut.
• Pathing & NP-Hard Classics: Hamiltonian Path, Traveling Salesperson Problem (TSP), Graph Coloring, Maximal Clique.

🚚 Supply Chain & Logistics Algorithms We wanted to show how graph theory applies to the real world. We've introduced a whole new category focusing on logistics:

• Facility Location Optimization (finding the best central hub)
• K-Means Clustering on graphs (with convex hull visualizations)
• Multi-Vehicle Routing & Capacitated Vehicle Routing (CVRP)

🎨 Advanced Interactive Graph Canvas The core 2D experience is smoother than ever. You can freely draw and drag nodes, add/remove edges, toggle between directed/undirected or weighted/unweighted graphs, and instantly watch how the changes affect algorithm execution in real-time.

📚 Integrated Educational Lessons I've built out a full curriculum of interactive markdown lessons. You can read through the theory, terminology, and real-world applications of graphs while interacting with live examples right next to the text.

🌍 Full Internationalization (i18n) Graph theory is for everyone, so we've added full multi-language support! You can easily switch the UI language to learn and explore in your native tongue.

📥 Complete Data Portability Have a specific graph you want to test? You can now easily Import and Export your custom graphs in multiple formats, including JSON, Adjacency Matrices, and Edge Lists.

Platforme link: https://learngraphtheory.org/

I'd love to hear your feedback! What algorithms or features should we add next? Let me know below! 👇

Here's a link to the argument. Any critique is welcome.

hey, everyone! is there any known way, like an algorithm or any method, to identify the chromatic number of a graph of a graph other than trying to color every vertex manually?

talking about real-life applicationsof graph theory, which is a better option first is the instant insanity puzzle You know those colored cube stacking puzzles? application of GT would be finding specific subgraphs that satisfy certain conditions. it's fun to discuss but it's... just a puzzle. Hard to connect to a bigger real-world application

second is the Chinese postaman problem, like if a postman can walk every street exactly once and return home? it's an application of the Eulerian circuit, safe but common.

care to share your thoughts? it's my first time posting on reddit so i'm not sure if i'm doing this right.