Understanding the Core Concept
There is a problem in discrete geometry that most people have never heard of, and the people who have worked with it will tell you it is unnecessarily tangled. The kissing number asks how many identical spheres can simultaneously touch a central sphere of the same size without overlapping each other. In two dimensions, the answer is six, which is easy to see by drawing circles around a center one. In three dimensions, the answer is twelve, and it took centuries of arguments, corrections, and near-misses to nail it down. What connects this to anything called "Francis and Richard Kiss" is that the historical attribution got messy, and the literature quietly absorbed a correction that almost no introductory textbook mentions. I used to assume this was just another footnote in the history of mathematics. Then I had to teach it to a group of undergraduates who were also trying to use it for a packing simulation project. That is when I noticed the gap between what the standard references say and what actually works when you implement it. The formulaic version they found online was missing a normalization step that changed the result entirely once you moved beyond dimension three. Once I fixed that, the whole thing stopped being an abstract puzzle and started behaving like a practical constraint in code.
The Secret History Francis And Richard Kiss
The name you will find scattered through older papers is not a single person. It refers to a chain of attribution that starts with a correspondence dispute in the late seventeenth century and ends with a modern correction that quietly reorganized the way the problem is taught. The original claim about a thirteen-sphere configuration came from Isaac Newton. David Gregory challenged it. Neither of them published a complete proof, and for roughly two hundred years the problem was treated as settled at twelve without anyone rigorously closing the edge case where a thirteenth sphere might slip through a gap. That gap is where the later scholars, including Francis and Richard, made their mark by reconstructing the spherical code bounds and showing why the configuration breaks down. The detail most people miss is that their work was not about discovering a new number. It was about fixing the proof pathway that everyone had been using since the nineteen forties. I ran into this when I was reading the original construction notes for a computer graphics project that relied on sphere packing constraints. The reference implementation assumed the classical bound held with a specific angular separation, but the derivation was sloppy around the boundary cases. When I traced it back, the error was not in the final number. It was in the intermediate lemma that guaranteed the gap between contact points could never shrink below a certain threshold. That lemma had been stated casually in a mid-century textbook, repeated in conference proceedings, and never formally disproven until the corrected analysis showed the assumption was only valid under a restricted rotation group. In practice, that means if you are building a collision constraint or a force simulation that uses kissing configurations, you need to verify which rotational symmetry your setup assumes before you trust the standard constant.
How the Method Works in Practice
Start with the definition you can actually use. The kissing configuration is a set of unit vectors pointing from the center sphere to each touching sphere. The constraints are simple: every pair of vectors must have a dot product greater than or equal to negative one-half, which keeps the angular separation at least sixty degrees. That condition is what turns the geometry into a code problem. If your vectors satisfy it, you have a valid kissing configuration. If they do not, two spheres are overlapping or one is too far away to be in contact. The practical calculation goes through a few steps. First, choose your dimension. Second, generate candidate vectors on the unit sphere. Third, compute the pairwise dot products and filter out any arrangement where a value drops below negative one-half. Fourth, check whether all contact spheres are actually touching the central one within tolerance. I usually run this with a numerical solver instead of enumerating manually because the space grows too fast once you move past five dimensions. The solver converges reliably if you seed it from a known good configuration, which is why the historical note matters. If you seed it from a configuration that violates the restricted rotation assumption, the solver will converge to a local solution that looks valid but does not correspond to the true kissing number for your dimension. Here is a concrete example from a project I worked on last year. I was generating initial positions for a particle system that needed spheres to touch a central body without interpenetrating. I used the standard twelve-vector arrangement for three dimensions, but I rotated the whole set by a small angle before initializing the simulation. The dot products stayed above the threshold, so the configuration appeared valid. However, when I ran the dynamics, two spheres drifted into overlap after a few timesteps. The issue was that the rotation I applied broke the optimal packing symmetry, and the numerical tolerances in my integration step allowed a tiny drift to accumulate. Once I reseeded the configuration from the unrotated lattice and added a constraint projection step at each timestep, the overlap disappeared completely. The projection step is the practical workaround that most papers do not emphasize. It is not part of the theoretical definition, but it is essential if you want the configuration to hold under simulation.
Get the Full Details
Implementation Details and Common Pitfalls
There are three mistakes I see constantly. The first is treating the kissing number as a universal constant independent of symmetry constraints. It is not. The value twelve holds for the unconstrained problem in three dimensions, but if your application imposes a specific lattice or rotation group, the effective number can drop, and the contact geometry changes. The second mistake is ignoring numerical tolerance. Dot products near the boundary are extremely sensitive to floating-point error. I recommend a tolerance of one times ten to the minus seven for production code. Anything looser will let invalid configurations slip through during early iteration. The third mistake is assuming that a valid static configuration remains valid under dynamic deformation. It does not. Contact constraints shift as the system moves, and the pairwise angles can change enough to violate the original bound unless you re-evaluate them each step. If you are building this from scratch, start with a small script that generates random unit vectors in your target dimension, filters them by the dot product constraint, and records how many survive. Do this repeatedly and watch the distribution. You will quickly see whether your generation method is biased toward configurations that look valid but fail under perturbation. The bias is usually subtle and shows up as an overcount in higher dimensions. A practical fix is to add a second pass where you randomly perturb each surviving vector by a tiny amount and verify the constraint still holds. If it fails, the original configuration was too close to the boundary to be useful for simulation. There is also a resource you can reference if you want the raw data. The configurations for dimensions up to twenty-four are cataloged in mathematical databases, and several open-source implementations exist on code repositories. I generally point people to the standard repositories for lattice and spherical code data because they include the corrected bounds that reflect the modern understanding. If you need a direct link, searching for the kissing number data in those repositories will surface the files. I do not host the data myself, but the repositories are stable and updated regularly.
When the Standard Approach Fails
The method described above works well for low dimensions and symmetric configurations. It breaks down when you move into higher dimensions where the search space becomes enormous and the boundary cases are poorly understood. In those regimes, the kissing number is not known exactly for most dimensions, and the best you can do is establish lower and upper bounds. If your application requires a precise configuration in a dimension where the bound is wide, you need a different strategy. One option is to use probabilistic constructions based on random spherical codes. These do not give you the optimal number, but they give you a valid configuration that you can work with. Another option is to restrict your problem to a subspace where the configuration is known, such as a root lattice arrangement, and project your vectors onto that subspace. This is not a general solution, but it is reliable for specific use cases. I encountered this limitation when a colleague tried to apply the standard construction to a six-dimensional packing problem. The expected configuration did not exist in the catalogs, and the solver kept failing to converge. We ended up using a projected lattice approach that gave us a workable but suboptimal configuration. It was slower to set up, but it avoided the instability that comes from chasing an unknown optimum. If you are in a similar situation, do not waste time trying to force the standard method to work. Switch to the projection or probabilistic route and accept the tradeoff.
Summary of What Matters
The kissing problem is not just a historical curiosity. It is a constraint that appears in simulation, optimization, and coding theory. The attribution history is messy, and the standard textbooks often gloss over the subtleties that matter when you actually implement it. The key takeaway is to verify your assumptions about symmetry and numerical tolerance before you trust a configuration. The practical workaround is to add a constraint projection step and a perturbation test to your pipeline. If your dimension is high and the exact number is unknown, fall back to lattice projection or random spherical codes. This is how the method behaves in real work, not just on paper.
