Explaining Discrete Mathematics with Lara Croft's Evolution
Why is this Graphics meme funny?
Level 1: Blocks vs Clay
Imagine you want to make a model of an apple. You have two options: build it out of little blocks or sculpt it out of clay. If you use blocks (like LEGO bricks), you might only have a few big square pieces to shape it. The result will look kind of rough and blocky – you’ll see the square corners sticking out. This is like the 1996 picture: the apple (or Lara Croft) is made from only a few pieces, so it looks chunky. Now, if you sculpt an apple out of clay, you can smooth it into a perfectly round shape. That’s like the 2018 picture: so many tiny pieces (or practically a continuous material like clay) that it looks nice and smooth. Discrete math is like working with the blocks – it’s all about those individual pieces you use to build something. When you have only a few pieces, the result is obviously made of separate parts. But if you have a lot of very small pieces (or something continuous like clay), the result can look smooth and realistic. The meme is showing a blocky old video game character next to a smooth modern version and saying: explaining discrete math is like showing the difference between building with chunky blocks versus sculpting with fine material. One clearly shows its pieces, and the other looks seamless – but deep down, it’s all made of pieces!
Level 2: Blocky vs Smooth
So, what exactly are we looking at here? On the left, we have a 1996 video game character model – that’s Lara Croft from the original Tomb Raider. She looks blocky because her model is made of only a small number of polygons. Polygons (in games) are typically triangles that form the surface of a 3D object. Imagine a sculpture made out of flat triangular panels – if you only use a few big panels, the result has sharp corners and clearly flat surfaces. That’s what “low-poly” means: a low number of polygons. Back in the 90s, hardware couldn’t draw too many triangles quickly, so game developers were forced to use just enough triangles to suggest a shape. You can count the straight edges on her arms and the angular shape of her face. It’s like a rough sketch of a person, with only a dozen or so flat facets making up each body part.
On the right, we have 2018 Lara Croft from a much newer Tomb Raider game. She looks smooth and realistic – a high-fidelity, high-detail model. But underneath, she’s also made of polygons! The difference is she’s “high-poly,” meaning there are thousands of tiny polygons forming her shape. Each polygon is so small that you don’t see flat faces or sharp edges anymore; instead, they blend into what looks like naturally smooth curves. For example, 1996 Lara’s shoulder might have been a single flat trapezoid, whereas 2018 Lara’s shoulder is composed of many dozens of small triangles, each at a slightly different angle, approximating a rounded shape. The more triangles you have, the rounder and more continuous things can appear. This is similar to how a circle on a computer screen looks jagged if it’s drawn with only a few points but looks smooth if it’s drawn with many tiny points.
Now, the text at the top of the meme says, “My best example when explaining what discrete mathematics is to people who don't know it.” Discrete mathematics is a core part of ComputerScienceFundamentals. It deals with things that are separate or “countable.” Think of counting with whole numbers, working with individual objects, or stepping through a process one stage at a time – that’s discrete. It’s different from continuous mathematics (like calculus), which deals with smooth changes and infinitely fine gradations (like smoothly varying time or fluid motion). In discrete math, you study topics like logic (true/false values), sets (collections of distinct objects), graphs (networks of nodes and edges), and combinatorics (counting ways to arrange things). In computers, everything is ultimately discrete: your screen is made of individual pixels, your memory stores distinct bytes, and 3D models are made of polygons. So the meme’s author is using the two Lara Croft images as a visual aid. 1996 Lara = discrete representation (very obviously made of separate pieces), 2018 Lara = result of more pieces (so many that it starts to feel continuous). This helps people unfamiliar with the term “discrete math” get an intuitive sense: it’s like the difference between an old blocky game character and a modern smooth one. Both are digital, but one clearly shows the “building blocks” while the other has so many building blocks you hardly notice them.
For someone early in their tech journey, think of it this way: if you’ve ever zoomed in on a digital picture and seen the pixels (small colored squares), you know that the image is made of discrete units. If the pixels are large (low resolution), the picture looks blocky. If the pixels are tiny (high resolution), the picture looks smooth. In 3D, polygons are like the “pixels” of a model. Early games had a low polygon count (like low resolution – you could see the jagged parts). Modern games have a high polygon count (like ultra HD resolution – everything looks detailed). So this meme is a tech humor way to say “Discrete math is about those little pieces that make up the whole.” The categories it touches – Graphics and Games – are really familiar to many of us, which makes the math idea click. Even if you don’t know the formal definition of discrete math, you can look at Lara Croft’s evolution and intuitively grasp: one side is clearly made of distinct pieces, and the other side has so many pieces it fools you into seeing a continuous surface. That’s the essence of the analogy. It’s a fun, geeky way to bridge a gap between an abstract concept and a visual reality.
Level 3: Discrete Polygons, Smooth Curves
For seasoned developers and gamers, this meme sparks a knowing smile. It’s referencing the almost comical difference between 1990s low-poly graphics and today’s near-photorealistic game visuals – and using that as an analogy to explain discrete mathematics. Why is this funny? Because anyone who’s taken a CS fundamentals course (or struggled through a discrete math class) knows how hard it is to describe what “discrete math” means in plain English. It’s not about keeping secrets (that’s discreet with two e’s), but about math with separate, countable pieces – things like integers, graphs, or logical statements. So how do you explain that concept to someone without diving into binary or set theory? Enter our heroine from gaming history: Lara Croft. The meme’s creator brilliantly picked Lara’s 1996 polygonal model versus her 2018 incarnation to illustrate the idea.
Think of 1996 Lara: she’s all sharp angles and straight lines – you can literally count the polygons on her model with the naked eye (her triangular chest became a running joke in 90s GeekHumor). Each triangle is a separate piece – that’s the “discrete” side of things. Nothing is smoothly curved; everything is a flat facet or a hard edge. Now look at 2018 Lara: she has smooth curves, realistic facial features, and natural body contours. But here’s the kicker that experienced devs appreciate – she’s still made of polygons! You just can’t see them easily because there are so many, and they’re so small, that her surface appears continuous. In other words, 2018 Lara is what happens when you pump an enormous amount of discrete pieces into the model. GraphicsProgramming veterans know that GPUs in 2018 can push huge polygon counts, use clever shaders, and apply smoothing techniques so that each tiny triangle is virtually imperceptible. The result is a character model that looks “analog” or continuous, even though underneath it’s as digital and discrete as the 1996 version.
This juxtaposition is humorous to those of us in tech because it’s a perfect tech analogy slotted into a gaming reference. It’s as if a CS professor finally found the ultimate relatable example: “See this blocky character from an old game? That’s discrete math in action – lots of chunky separate bits. See the modern version? Same math, just way more bits, giving the illusion of a smooth reality!” It also pokes a bit of fun at how far we’ve come. Older developers remember when those blocky graphics were the cutting edge, and we marveled at them on our 16MB graphics cards. Now, our standards are so high that a face made of a mere thousand triangles would look archaic. The meme resonates because it connects CS_Fundamentals to something tangible: early games vs modern games. It’s tech humor that educates. Seasoned folks recall struggling to explain to a friend, “Discrete math is like... well, think of old video game graphics versus new ones.” We appreciate this meme because it’s both nerdy and insightful – it takes an abstract concept we all know and love (or love to hate) from computer science and renders it (pun intended) in a way anyone who’s seen a PlayStation 1 game can understand. It’s a celebration of how adding more detail (or more data points, more polygons) turns a choppy approximation into something richly detailed – much like how a high-resolution approach to any problem yields clarity. And let’s be honest, it’s also a little bit of nerd flex: using a Tomb Raider reference to explain math is the kind of quirky teaching trick only a geeky educator (or an enthusiast on a developer forum) would pull out. We’ve all heard “it’s like pixels in an image, more pixels equal higher resolution” – this meme just applies that same principle to 3D and ties it back to the abstract idea of discreteness. It’s the kind of explanation a senior dev might give a junior when helping them appreciate why understanding discrete structures (like polygons, pixels, or graph nodes) actually matters in the real world of software and games.
Level 4: Triangles to Infinity
In computer graphics, every seemingly smooth character or object is actually made up of tiny flat pieces. These pieces are usually triangles in a 3D mesh. From a theoretical standpoint, this is a perfect illustration of the discrete vs continuous divide. A continuous curved surface (like a real human face or a mathematically perfect sphere) has infinitely many points and no sharp edges. But a computer can’t handle infinity directly – it works with discrete elements (bits, pixels, polygons). So instead, graphics engines approximate the continuous surface by using a finite (but sometimes huge) number of flat triangular facets. The 1996 Lara Croft model is an extreme case: only a few hundred triangular facets made up her entire shape, producing visible sharp edges and flat planes. By 2018, Lara’s model uses orders of magnitude more triangles – tens of thousands, even hundreds of thousands – to approximate curves so finely that her silhouette and features look almost continuous to our eyes. The math insight here is that as the number of discrete pieces increases, the approximation converges toward the real thing. It’s reminiscent of a limit in calculus: increase polygon count → the model’s shape approaches a smooth continuous surface. To infinity, and beyond! each added triangle takes you one step closer to seamless realism.
Under the hood, this process touches on deep CS fundamentals. Representing Lara’s figure with polygons invokes graph theory (a branch of discrete math) because the mesh is essentially a graph: vertices (points in 3D) connected by edges forming triangular faces. The topology of a 3D model – how these vertices connect – is a discrete structure that computer algorithms can handle. The lighting and shading of those triangles involve linear algebra and discrete sampling of continuous physics equations. Even the textures (the skin, fabric, dirt on 2018 Lara’s outfit) are just high-resolution grids of pixels mapped onto those polygons – again discrete units creating an illusion of continuity. In essence, all digital images and models live in a discrete world: finite pixels, finite polygons, finite precision. Discrete mathematics provides the language and tools (like combinatorics, finite geometry, and algorithms) to work in this digital realm. The meme cleverly highlights that if you take a coarse discrete model (1996’s low-poly count) and refine it with many more discrete elements (2018’s high-poly count), you approach the continuous ideal. It’s the same principle that links a Riemann sum of rectangles to a smooth curve’s area – as you use more, thinner rectangles (or smaller triangles on Lara’s shoulder), the jagged error shrinks. In high-fidelity graphics, we’re practically doing calculus with polygons: enough tiny pieces can mimic a smooth curve to the point that your eye can’t tell the difference. ComputerScienceFundamentals classes rarely feel this glamorous, but here in a gaming context we see a beautiful convergence of theory and practice – literally graphic evidence of discrete math at work!
Description
A two-panel meme used to explain the concept of discrete mathematics. The top text reads, 'My best example when explaining what discrete mathematics is to people who don't know it:'. Below, two images of the video game character Lara Croft are shown side-by-side. The left image, labeled '1996', shows the original, highly angular and low-polygon version of the character, famous for its blocky, geometric construction. The right image, labeled '2018', displays a modern, photorealistic, and smoothly rendered version of the same character. The humor and educational value come from the visual analogy: the 1996 Lara is a clear representation of a 3D model built from a small number of discrete geometric shapes (polygons), the fundamental building blocks of computer graphics. The 2018 version, while appearing smooth and continuous, is still composed of a vastly larger number of discrete polygons. It cleverly illustrates how complex, continuous-looking surfaces in the digital world are approximations made from a finite number of distinct, countable units - the core idea of discrete mathematics
Comments
57Comment deleted
Modern frameworks are like the 2018 Lara Croft - smooth, high-level abstractions. But every senior engineer knows that when you're debugging a performance issue, you're just staring at the pointy, low-poly 1996 version written in raw SQL
1996 Lara: 540 ints in an index buffer; 2018 Lara: 60 000 ints in an index buffer with better normal maps - proof that under all the photoreal hype, it’s still just the same adjacency matrix your discrete math prof made you hand-draw
The real discrete mathematics lesson here is calculating how many triangles you can render before your PM discretely asks why the frame rate dropped to single digits in production
This is actually a brilliant pedagogical example: discrete math is like 1996 Lara - you can literally count the vertices and see the distinct states. Continuous functions are 2018 Lara - smooth interpolation everywhere, but under the hood it's still discrete vertices with enough tessellation to fool the eye. The real irony? Both are discrete at the hardware level; we just got better at lying about it with more triangles and fragment shaders
As the triangle count approaches ‘photorealistic,’ marketing calls it reality, SRE calls it a thermal incident, and the math still calls it discrete
Discrete math: curves are just marketing’s word for “more triangles” - 1996 shipped at eight, 2018 ships at two million, and your render loop still only gets 16 ms to pretend calculus
Low-poly Lara to photoreal: discrete math proving finite triangles approximate any curve - if your GPU budget converges
I didnt get it Comment deleted
I'm sure that joke is somehow about her four-polygon breasts Comment deleted
That's exactly wrong, by the way. Vertices in polygons stored in float, which is not discrete mathematics. Also mesh is not a graph, it's just oner array of vertices, and another array of of indexes. 3 index = polygon. Meaning it's doesn't explained by discrete mathematics. Comment deleted
floats, as defined by IEEE754, are discrete values, and therefore fall under the umbrella of discrete math ALSO, the ps1, which is where this game ran iirc, used whole numbers for vertexes (that's where the awful vertex jittering comes from) Comment deleted
where is in IEE754 float defined as discrete number? It may be stored as discrete number, but that is far abstraction level from mesh storage Comment deleted
→ it's stored as a discrete number there is the definition. If you abstract that away, that's on you. 2^16 might be a lot of values, but they're still finite. Comment deleted
well that's stupid. First of all ps1 supported fixed-point data type, which is not integer. Second - polygons where cut cause of rendering limitations, not because non-decimal data types where not supported (which were supported, anyhow). I'm pretty sure rendering process doesn't include graph search. Comment deleted
integers and fixed point numbers are one and the same in how you handle them. The only difference is if you have a little dot somewhere imagined in the number. in other words, 1.2/3.4 is the same as 12/34. both are equally discrete, anyway. you're right about the second point, but nobody claimed something else, so you really just made an obvious statement. graph search is part of discrete math, but not required if you want to make a joke referencing it. keep in mind that I do agree that the joke is kinda bad Comment deleted
The only difference is if you have a little dot somewhere imagined in the number. Yes, that's the point. Comment deleted
doesn't matter for the argument Comment deleted
What's the main difference between float and integer as data interfaces? Not the floating point? Comment deleted
integers and fixed-point numbers just count from the lowest to the highest value in equal sized steps (ignoring two's complement) and if you hit the highest or lowest number, you're out of luck. floating point numbers have variable sized steps, which makes them good for general application, no matter how small or large numbers get (to an extent) - also, there's infinity, negative infinity, NaN and all sorts of black magic included. actual non-discrete fractions can store any number, not just a finite amount of them. That's often represented by higher-level objects instead. While technically still limited by the amount of RAM and the address size of the cpu architecture, in theory those objects are meant to be infinite. Comment deleted
Otherwise, if we agreed on your defenition, then everything is descrete mathematics, meaning term will lose any sense. Comment deleted
no, everything in digital computing is discrete mathematics, which is inherent, since digital means only being able to store a finite amount of information, unlike analogue systems. Comment deleted
That's what I meant. That you can post any computer related image and paste "My best example when explaining what discrete mathematics". More, applying your definition on planck units - everything is descrete mathematics, cause on planck scale everything is integral. Which is again, stupid, ad ruin purpose of any terminology - specific contexts is given specific meaning Comment deleted
planck units are a theory, and, if correct, would mean that physics is discrete math, yes. However, much like gravity not actually being 9.82m/s everywhere, or for everything, we can usually model physics much easier with non-discrete math. All math is just knowing where and how to approximate effectively. Comment deleted
>> ad ruin purpose of any terminology - specific contexts is given specific meaning It doesnt. Main context we have here is CS and jokes should be perceived (first of all) through this context Comment deleted
So the joke is that in both cases meshes stored in non integral data. But non integral data is stored in integral view in raw memory binary, hence it's discrete math? That's just great, isn't it? (no, it's obviously bad, and doesn't fit) Comment deleted
The joke here is that (in most cases) for purpose of computational science we would consider all FP operations as done over finite number and in wide range of tasks (on theoretical level) you can just remove dot and on those numbers as with integers This is answer if your main problem is about discrete math to work specifically over field of 𝐙 Comment deleted
@qwnick and another fun fact: many game engines of old time heavily relied on CPUs for grapphical tasks and not solely on GPUs (partially) because GPUs alghs were targeting approximate solution instead of exact solution possible with CPUs Comment deleted
So joke is not related to the picture, from your words. Cause you said nothing about breast low poly count. Comment deleted
I did some more research. The CPU had fixed-point data, but the GPU only had integers; one pixel on screen got exactly one number. That's it. The ps1 didn't even support subpixel verteces. Comment deleted
Wtf is not sub-pixel vertex? Comment deleted
subpixel vertex as in e.g. a triangle that has its points defined somewhere between pixel positions. Comment deleted
But polygons are not defined in pixel space Comment deleted
I assume they convert the numbers somewhere between cpu->gpu interaction and rasterization. Comment deleted
So they are not stored in pixel space? They just rasterized in pixel space, same as now without AA? Comment deleted
they're stored in multiple places, in multiple ways, as most things in computation. AA is something else entirely Comment deleted
but yes, I assume they don't have a dedicated cache for verteces between the 3d transformation step and the rasterization step Comment deleted
wdym stored in multiple places? Mesh is not stored in multiple places. Mesh is stored in 2 arrays, one is vertex, other is index. Index taken in a loop by 3 points. 3 index = 1 polygon. Rendering direction is defined by indexes order in polygon. Comment deleted
you need to store 3d models at least once in ROM, once in RAM, and once inside the GPU, unless the CPU and GPU share RAM, which might be possible inside the ps1, but idk tbh Comment deleted
it's just how data is transfered to vram, it doesn't change fact that meshes are not stored in pixel space. They are rasterized in pixel space, but after this they are not meshes, but frame (or draw call result). Comment deleted
now that I think of it, I think the ps1 didn't even have vertex transformations on the GPU, since programmers needed to pre-sort verteces anyway because of the lack of z-buffer, so they also had to apply camera angle transformations in CPU to know the correct order… or maybe the had a chip dedicated to 3D transforms that supplied the transformed positions to CPU RAM? Comment deleted
plus, the way they implement shading is also completely CPU-controlled - basically, you have to define light levels per vertex. no "oh, there's a light over there, let me compute the shading for each model", no, you had to find that out yourself and tell the GPU which vertex is how bright Comment deleted
I'm getting this info from here btw → https://www.copetti.org/writings/consoles/playstation/ check it out, it's interesting Comment deleted
If you don't have z-buffer, you need to make draw calls in correct order. Any mesh is stored subpixel space and rasterized into pixel space. It worked same way on ps1, and it working same way now. Wobble on ps1 was caused not by vertex logic, but that in order to rasterize mesh you need to check every pixel, and then take texture by UV and apply to this pixel. PS1 didn't did divides (cause they are pricey) and instead of deciding on each pixel color based on UV, squeezed whole texture in this polygon. Which is, again, doesn't include discrete mathematics. And also, does not related to small polygon count Comment deleted
yes, they did have to do that. ps1-era GPUs and modern GPUs are so far apart in terms of how they do things that they're basically incomparable. Again, they didn't even have vertex shaders on the ps1. no depth buffer. no perspective. no, that is the texture wobble, not the vertex wobble. And they had to do that because they lacked perspective (haha, but yes, very literally, no vertex transforms→no perspective info) nobody was talking about small polygon count, except for my initial guess about "haha boob pointy" being the go-to joke for tomb raider Comment deleted
basically, as I understand it, the ps1 GPU literally only rasterized. Comment deleted
yep, they had a coprocessor for that lol Comment deleted
they also didn't have z-buffer, as an aside. They really cut corners whereever possible. The N64, its competitor at the time, had not only floating point numbers, but a z-buffer and mipmapping. Comment deleted
they also hat better games, har har Comment deleted
What is not sub-pixel vertex? Comment deleted
hm I guess that's what the joke is about, isn't it? The ps1 integer verteces Comment deleted
All those memes about 0.1 + 0.2 are not wasted 🎉 Comment deleted
This is a good one too: let a = 9999999999999999; let b = 1; if (a - b == a) { alert(‘wtf?’); } else { alert(‘everything is fine’); } Comment deleted
🤓🤓 moment Comment deleted
Pun intended Comment deleted
Wow the debate on top 👍🏼 Comment deleted
BREAKING: Guy's humor is not tingled by meme, decides to make it a big deal Comment deleted
I didn't get it Comment deleted