Bold Blue Writing Graph Paper: Fill & Download for Free

The most fiendish false proofs are not proofs of incorrect assertions. They are faulty proofs of correct assertions.When someone offers a proof of an incorrect assertion, you know that at some point in their chain of reasoning they must say something that’s wrong. Find that something, and you’ll see immediately where the proof fails.But when someone “proves”, incorrectly, a correct statement, demonstrating the incorrectness of the proof can be anywhere from easy to extremely hard. The assertions made in the steps of the proof may, for all we know, all be correct: it’s the implications that are broken.When students learn the idea of proofs, this is a point well worth emphasizing, and one of the tools is the study of incorrect proofs. It’s not used often enough, and that’s a shame. There’s much to be learned.Here are some of the best examples I know.The first example is a faulty proof by none other than Srinivasa Ramanujan. Now, granted, rigor in proofs was never Ramanujan’s forte; his breakthroughs were almost universally discoveries and conjectures, not proofs, which were supplied by others (sometimes decades after his death). But it’s interesting to study this case because this proof, or variations of it, still show up all the time.In 1911, Ramanujan published the following problem in the Journal of the Indian Mathematical Society: Evaluate the nested radicals[math]\displaystyle \sqrt{1+2\sqrt{1+3\sqrt{1+4\sqrt{\cdots}}}}[/math][math]\displaystyle \sqrt{6+2\sqrt{7+3\sqrt{8+4\sqrt{\cdots}}}}[/math]The practice of publishing problems and asking for solutions by readers is still common, and when no solutions are offered the proposer is often expected to submit their own. Ramanujan published 58 such problems between 1911 and 1919, many of which are deep and fascinating. A wonderful survey of these problems is in this paper[1] by Berndt, Choi and Kang.Ramanujan’s own solution of these nested radicals runs as follows (we’ll do the first one; the other one is similar). Observe that[math]\displaystyle n+2 = \sqrt{1+(n+1)(n+3)}[/math]Consequently, if we define [math]f(n)=n(n+2)[/math] then[math]\displaystyle f(n) = n\sqrt{1+f(n+1)}[/math]but then the same formula can be applied to the inner [math]f(n+1)[/math], yielding[math]\displaystyle f(n) = n\sqrt{1+(n+1)\sqrt{1+f(n+2)}}[/math]and this can be repeated indefinitely, yielding an infinite nested radical. Finally, setting [math]n=1[/math] yields[math]\displaystyle f(1) = \sqrt{1+2\sqrt{1+3\sqrt{\cdots}}}[/math]which is the desired nested radical, and of course [math]f(1)=3[/math], so the answer is [math]3[/math].This seems both clever and convincing, but it’s incorrect – or at least, incomplete. Here’s the problem: we’ve managed to find one particular expression which, when repeatedly expanded, yields a sequence of nested radicals which approaches the desired one. But what if someone finds some other particular expression which also produces the same infinite nested radical, but with a different value?Indeed, this can actually be done. For example:[math]4 = \sqrt{1+2(15/2)} = \sqrt{1+2\sqrt{1+3(221/12)}}=\ldots[/math]this can also be pushed further indefinitely, and it seems to say that the value of the same nested radical is [math]4[/math]! (I stole this example from Herschfeld’s paper “On Infinite Radicals[2]”).Which is it then?The situation may remind you of similar traps which come up with other infinite expressions. For example, when evaluating[math]\displaystyle x = \sqrt{2}^{\sqrt{2}^{\sqrt{2}^\cdots}}[/math]people often say that clearly [math]x = \sqrt{2}^x[/math], and this is satisfied by [math]x=2[/math] so the answer is [math]2[/math]. But the problem is that [math]x=\sqrt{2}^x[/math] is also satisfied by [math]x=4[/math], so which is it?Part of the problem, of course, is that we need to carefully define what those infinite expressions even mean. This is typically done by declaring them to be limits of finite prefixes of themselves. Then, to evaluate them, we need to first prove that the limit exists, and then determine its value.Sometimes pinpointing the value can be done by studying fixed points of the iteration, as is the case with the infinite tower of [math]\sqrt{2}[/math]'s. Ramanujan’s radical is more subtle since the iteration keeps changing. A complete and correct proof that the value is indeed [math]3[/math] can be found in Herschfeld’s paper, and I think there’s also a question about this on Quora.The Cayley-Hamilton theorem (in its matrix formulation) states that if [math]A[/math] is a square matrix (over some field) and [math]p_A(t)=\det(A-It)[/math] is its characteristic polynomial then [math]p_A(A)=0[/math].This is not a terribly difficult theorem, but it’s not quite straightforward either. Most courses on linear algebra present one of the correct proofs, and the students move on.However, few teachers pause to show the following incorrect argument: we want to show that [math]p_A(A)=0[/math]. Well, what’s [math]p_A(t)[/math]? Why, it is [math]\det(A-It)[/math] where [math]I[/math] is the identity matrix of the appropriate size. Ok, so what’s [math]p_A(A)[/math]? Obviously, it is [math]\det(A-IA) = \det(A-A)=0[/math]. Done, QED.Here’s the thing: if any teacher actually walked their class through this “argument”, with a poker face and a confident attitude, I guarantee you nobody would raise their hand to protest. It seems clear, easy, obvious and straightforward. Doesn’t it? And furthermore, what it proves is actually true, so nobody can find a counterexample. This is most definitely a proof which “appears to be correct”.It’s a really good exercise to ponder this “argument” and see why it fails. There’s actually a relatively easy howler here, created by our poor notation.Ask yourself, what is “[math]0[/math]"?Wait, what do you mean “what is [math]0[/math]"? Seems like a silly question. Well, look again at the statement [math]p_A(A)=0[/math]. A careful teacher would write [math]p_A(A) = \mathbf{0}[/math], a bold zero denoting the zero matrix. Indeed, what the Cayley-Hamilton theorem says it that if you calculate [math]c_0I+c_1A+c_2A^2+\ldots+c_nA^n[/math] where [math]c_i[/math] are the coefficients of the characteristic polynomial, then you get the zero matrix. You get a matrix, not a number.On the other hand, our “proof” ended with [math]\det(A-A)=0[/math], the number zero. The number zero is not the matrix zero. Our “proof”, whatever it shows, only concludes that a certain number is zero. This isn’t what the theorem says.Whenever I teach the C-H theorem to anyone I make a point of showing this silly non-proof. It’s actually not silly. It stresses the meaning of the theorem and lets students see how misleading proofs can be if we don’t pay careful attention.Famously, in 1879, Alfred Kempe published a proof of the 4-color theorem using the (very clever) idea of flipping colors along what are now known as Kempe Chains. The proof stood and was accepted for 11 years before Heawood found a critical error, in 1890.Briefly, the proof runs as follows. Assume that the 4-color-theorem is false, and pick a minimal counterexample: a planar graph which is not 4-colorable. We may assume that the graph is that of a triangulation, and using Euler’s formula we show that the graph must contain a vertex [math]v[/math] of degree [math]\le[/math] 5. If we remove vertex [math]v[/math] (and its incident edges), the leftover graph can be colored with 4 colors, since we picked a minimal counterexample. Our goal is to show that we can still use just 4 colors even if we put that vertex back.If [math]v[/math] has degree 3 or less, that’s obvious: at worst, three colors are unavailable for our vertex, so we can use a fourth one.If [math]v[/math] has degree 4, we may assume that the coloring of the leftover graph uses all four colors for its neighbors, let’s say Blue, Red, Green and Yellow as you walk around the vertex. Put yourself at the Blue vertex and attempt to walk all the way to the Green one only using Blue/Green vertices. Either you can or you can’t.If you can’t, good news: flip all the colors along your walk from Blue to Green. Now our vertex sees only Red, Yellow and two Greens, so it can be colored Blue.If you can complete the walk, the flipping doesn’t help, of course, because the Green became Blue but the Blue became Green. But now repeat the argument with the Red-Yellow vertices. It’s impossible for two closed loops to form, one Blue-Green and the other Red-Yellow, because planar graphs can’t have two such non-intersecting loops. This proves the reduction for the degree-4 case.Everything up to this point is perfectly valid.Kempe then moved on to repeat the argument for degree 5, which is where he subtly tripped up. He considered a coloring around [math]v[/math] going R-B-R-G-Y, and worked with similar chains as before. If both the R vertices are surrounded by blocking chains, he attempted to created a R-G chain and a R-Y chain and simultaneously flip them; but this can’t work because the flips may clash with each other.The error is subtle, but the proof is unfixable. It took over 80 years to produce a correct proof of 4CT, relying on extensive computer calculations. The basic logical structure of the proof can be traced back to Kempe’s original idea: we work with minimal counterexamples and “unavoidable configurations”, which for Kempe were simply vertices of degree at most 5, and we show that they can be “reduced”, meaning they can always be recolored with fewer colors. But the details of the eventual proof were much more complicated than Kempe believed.Finally, let’s recall that “proofs which appear to be correct” can be extremely serious and difficult affairs.In 1993, Andrew Wiles had a proof of Fermat’s Last Theorem which he was completely confident in. He is a very, very careful mathematician, and quite shy; “coming out” with such a sensational proof was a difficult step, but he did it because he knew he had it. He presented the proof in a series of lectures, and submitted a full write-up for publication.Nick Katz[3] began the monumental task of reviewing Wiles’ paper. Few people were even capable of doing that, but Katz had both the immense knowledge and the meticulous nature required to comprehend and check everything very, very carefully. He wrote to Wiles whenever something was unclear, and Wiles always responded with clarifications. Until that one time when he couldn’t. They discussed the point back and forth over weeks, and it became clear that there was a problem, and it was not a trifle, and then it became deep, and then it became an irreversible flaw that demolished the entire proof.It wasn’t even directly something in Wiles’ proof, as far as my understanding goes: it was an issue with a construction by Flach[4], then a young researcher, now himself a renowned mathematician at Caltech (we should hold none of that against him – these things happen). Wiles had to go back to the proverbial drawing board, now under immense pressure knowing that his edifice is out and the whole world is chasing the elusive proof. It was a terrible time.Eventually, he made a dramatic breakthrough: the very thing that blocked Flach’s construction from working turned out to resurrect a completely different approach to the proof which Wiles abandoned years earlier. He rebuilt the whole thing, recruiting Richard Taylor for a difficult ring-theoretic argument, and successfully published a complete and correct proof in 1995.His 1993 proof certainly “appeared to be correct” to his audience and the first round of readers, and most of all, to himself. It was incorrect, but from its ashes emerged the correct proof, one of the greatest mathematical breakthroughs of the 20th century.Footnotes[1] The Problems Submitted by Ramanujan to the Journal of the Indian Mathematical Society[2] https://www.jstor.org/stable/2301294?seq=1#page_scan_tab_contents[3] Nick Katz - Wikipedia[4] Matthias Flach (mathematician) - Wikipedia

There are multiple levels of representation of text on a modern PC.When you type on a keyboard, each keypress closes a switch. A small processor in the keyboard converts all the switch presses into a ‘key code’, which is a unique binary pattern for each key. It is not yet text, it is merely the identity of a pressed key.The key code is sent to the computer via USB or Bluetooth. In the computer, the key code is wrapped up into a ‘key press event’, which is a way to package up external inputs like key presses and mouse movements, clicks, etc. The event is sent to the application that has the user’s focus. This is determined by which window is in front, and which element of that window is ‘focused’, according to the design rules for apps on that platform.Let’s assume that the focus is in a word processing app. When it receives the key press event, the app determines if the key press is just a letter key or something else, such as the ‘alt’ key for example. Keys have different effects - some do not directly add to text, but act as controls for how the receiver of the event behaves. Some modify other keys, such as shift implying upper case rather than lower case. A simple letter keycode is then mapped to a character (depending on the operating system, the key event wrapping may have already performed this look-up, and supplied the character equivalent in the key event). The character is a logical representation of a unit of text. It requires an encoding, which is to say an agreed meaning on what the binary bits in the character actually stand for. Classically, this was ASCII, with various extensions such as Windows ISO 8859. These days Unicode is the mapping used, since it covers all of the world’s writing systems in a single very large code space.At this point, the key press has become a logical unit of text. The character is stored in a buffer (chunk of memory) that represents the block of text being written.Now a whole different layer of code swings into action, actually displaying that text on a screen. These days, text is just a special case of general graphics. In the earliest PCs, running e.g. MS-DOS, text was treated very differently, being a ‘native’ data type that fed directly into the display hardware. These were the classic text-based ‘green screen’ displays you may remember if you’re old enough. But these work very differently from a modern computer.A modern computer has a GPU, which is responsible for turning bits in memory into the image on the screen. GPUs offload a lot of the work of rendering descriptions of a complete 3D scene into the actual pixels, but for display of text and GUI elements, they don’t play a huge role, other than capturing window content as textures, which are then converted to video driver signals.What we can say is that, in some manner, a representation of an image is built in memory, where bits set in the memory correspond to pixel values on the screen. Typically, these image buffers use a format with several channels of colour information, for example, one byte for each Red, Green, Blue and Alpha value for each pixel on the screen in a certain position. This format is called RGBA, and uses 32 bits per screen pixel. (The Alpha value is a measure of how transparent the pixel appears, when blended with any existing background). The image is laid out in rows and columns exactly like the rows and columns of pixels on the screen, and other elements in the image data structure indicate the row stride, colour format and many other things that determine how the image is to be interpreted. The point is that by changing the values in the image buffer, pixels can be made to appear in any colour in any position. So now we just need some code that can figure out which pixels are what colour.The code responsible for this is large and complex, and is called a graphics primitive library. The name should not be taken to imply the software is ‘primitive’ - it’s actually very very sophisticated. But it is only concerned with relatively simple graphical elements such as straight lines, curved paths, rectangles, colours, clipping, and copying other already defined image objects into a single screen image. Take a simple straight line. It is defined by two points, being the end points. The graphics library then needs other information, such as the desired thickness of the line, its colour, whether it’s drawn using a pattern, a dash or a solid colour. All of these settings are established in the graphics code, and then it is asked to render the line. Input are the two end points of the line, and output is the pixels set in the image memory buffer corresponding to that line. The graphics code will also figure out what colour to set pixels that are only partially impacted by the line to smooth out the appearance of any jagged edges. This is called ‘antialiasing’ and is done by all modern PCs. This overall process is called rasterisation (Rasterisation - Wikipedia). The logical description of a path (as in two end points make a line, or multiple control points define a curve) is converted to a raster scan of pixels. A raster is the rectangular array of picture elements (pixels) making up the final screen image.One of the graphics primitives that can be rendered is a series of bezier curves. A bezier curve is a curved path defined by its two end points, plus one or two additional control points. A curve can be drawn by interpreting these points mathematically, exactly like drawing a graph of a function on graph paper. Bezier curves can be joined end-to-end to make more complex paths and shapes. The graphics code can take the description of the curves as a list of control points, and rasterise them by drawing the resulting graph. It can draw the pixels along the path (stroking) or by filling in the space enclosed by the path (filling), or both.A particular form of bezier path is the shape of a letter of a text character, called a glyph.The graphics code is able to render glyphs by filling their bezier paths. This is the same process as filling any other graphics path.Glyphs are collected together into a list of all possible similar glyphs for a range of text encoding in a structure called a font. A font is essentially a table mapping encoded text values to the bezier paths for each corresponding glyph. Now we are in a position to begin to render (rasterise) the representation of text in our word processor’s text buffer to pixels on the screen. The text in the text buffer is part of the information - this tells us which glyphs we’ll need, but we also need to specify the font, the final size of the rendered glyphs, their colour, and numerous other stylistic variations we might want to apply, such as italic, bold or underlined. Yet more information specifies how the text is laid out, where paragraph breaks are, whether the text is flushed left, right or centred, or whether it is fully justified between margins, where the margins are, and so on and so forth.The word processor will track the various attributes of the text in additional data structures it maintains. These attributes are supplied to a text rendering engine, along with the text. This is another layer of code that bridges between the logical model of text (as in our word processor) and the rendering of text on the screen, which is carried out by our graphics primitives library.The text rendering engine takes all of the information about the text and lays it out in lines, translating from the text character to the glyph using font information. The glyph consists of not only the bezier path that defines the shape of the character, but also metrics, being how much space the character occupies on a line, how tall the line is, etc. The text rendering engine uses this information to position each glyph in the right place on the line, and when the text wraps to the next line, how much space there is between lines, etc. Once it has calculated the layout, it asks the graphics library to go ahead and turn the formatted text into actual pixels by rendering the glyphs.Finally, the image of the text has been fully generated, and can be sent to the GPU as a texture to be converted into the video signals that drive the monitor.The process is very complex, but has many significant advantages over a ‘green screen’ type of text display. One is that by introducing a translation between a text character and a glyph we can have an endless variation in the font used. Together with unicode, fonts can be almost endlessly extended, which is why we are able to have such a huge array of emojis and other elements able to be treated as text. Another advantage is that text and other graphics can be freely mixed and placed on screen anywhere. At the graphics level, text is graphics. This ability, along with the ability to directly see the layout and appearance of a page on screen, was a major reason for the ‘killer’ app of desktop publishing firmly establishing this approach in the 1980s.

Experiment, and when you find something that works great for you, simply keep doing it.EDIT: a brilliant answer that dives deeper into this aspect: Do grad school students remember everything they were taught in college all the time?-------I'm almost finished studying for my master's degree in engineering (Belgium, KU Leuven). Before I began, I wanted to retain as much information as possible. So I researched. The 3 most important concepts are:Knowledge works like a spider web. It's not a closet with several shoves of different topics you pull open when you need one. This is only an artificial system we developed to mimic storing information, which is used in computers. But in humans, all knowledge and experience is interlinked, and works together as one, massive structure. Memories, scents, sounds, textures, colors, feelings. The best way then to add new elements, is through association. E.g. a child figures out how to open a door with the door handle. Whenever it sees a door again, his or her mind instinctively goes 'hey, a door, where's the handle?' It immediatly hops to the strongest associated connection.But, and this is why you should get as much exposure as possible: if you understand something only one way, then you don't really understand the topic. It all depends on how well we've connected an idea to all other things we know. Well-connected representations let you turn ideas around in your mind, to envision things from many perspectives, which leads to a deeper understanding.(Image source)In practice:Use analogies and metaphors (if it has more emotion, like humor, the connection will be stronger), and structure your notes. Link complex idea's to simple concepts you already understand. Ways of doing this?- Visually through drawings , mind maps, memories, ...- Auditive through a link with sound, repeating out loud, ...It's all about strenghtening and maintaining those most important connections. Those associative links I talked about? They degrade over time. Dust falls over them, untill they dissapear and you forget what was there. Especially when they're boring. It's easier to maintain than to rebuild - the harder they shine, the longer it will take for them to gather dust again. Hi there, long-term memory!(Image source)These reminders must be rather active than passive, in spaced repetition. Only then, when actively juggling idea's in your head, you will notice where there are still gaps in your understanding, or where dust has gathered. This will keep you on your toes, and the material stays interesting.Do you find what you're learning boring? Then things will be harder to remember. Trick yourself into being curious by thinking differently, for example:Latin - "Jeez, this is how people thought, talked and wrote 2000 years ago?! How cool!"History - "Whoa, I'm just learning the history of the world! Hundreds or even thousands of years before my existence."Science - "So this is how the world works! From atoms 'till planets? And you can even make predictions based on known facts? That's crazy.."Law - "Alright, cool, so this is how our legal procedures fit together!"And so on, you get the idea.In practice, strengthening connections:Re-reading (passive), organising notes in your own way (active), paraphrasing (active), explaining things like you would to a child (active) , teaching others (active), ...The human concentration span is SHORT. As in, it's waning after 20 minutes, and completely gone in 45 minutes. Take breaks, they're good for you.The following graphs show the mean student attention during lectures, on the right including short breaks.(Image source)In practice, what-ever works for you:A 5-minute break every 25 minutes and a longer break every 2 hours(The Pomodoro Technique), a ±10-minute break every 45 minutes, ... andmost importantly: go to sleep when you feel tired.A break means: completely irrelevant to what you're doing! Hop around in yourroom, do some push-ups, go outside, play with your dog, ....That's it! Three simple concepts which had an immense impact on how I was learning. Integrating all of them though, is pretty daunting. Here's what worked for me to maximize long-term memory, so you don't have to re-invent the wheel.First time seeing the material:Slides available? Print them and bring 'm with you. On as little paper as possible, double-sided. With writing next to the slides, that's already one less source to consult on your desk. If possible, give them a quick read before the lecture starts. This way you will already have a basic understanding about the topics and their order, which leads to a primary index in your head. If you spot something interesting already, your attention will boost during the lecture itself.Go to your lectures, and take quality hand-written notes on what the professor explains. Don't just bring your laptop and type down everything you hear. Writing by hand will force you to process the information first, and then filter out (and write down) what's important remembering.Read the book or your notes when you find the time, and while doing this, color code what's important. This way, when you look at a page you immediatly know what's important and where it stands. The lay-out just sticks with you. This enables you to learn faster. As a highly visual learner, after enough repetition I can fairly well remember what concept is written on which page without even looking.E.g., I use the following:Blue (full / underlined / dotted line) - main titels, subtitels, ...Purple - most important definitions, equations, ...Orange - concept keywordsGreen - for every (short) summary listYellow - keywords all-round --> most used colorImportant note: don't make a colorbook. Try to create a tree-like structure.it's crucial to understand everything you color code, so you don't have to re-read it with the same depth and concentration all over again later. Time is valuable.Actively learning:Making a notes compression paper with all core concepts. After the above is done, it's time for stage 2. I absolutely hate having to study or review 100+ pages before an exam, so I do this instead. Not everything is equally important. With 'notes compression', I mean I recapitulate (in my own words!) every course on MAX ± 2-6 papers, double-sided. Crucial here is to understand everything you jot down: the formules you derivative, the keywords you capture, ... and write it as short as possible, using as many abbreviations as you can.The main benefit of this method is the possibilty to connect the dots. Often, on an exam, I can easily hop to different branches, which leads to very broad and defined answers.Takes me about 2-5 days per course depending on the load, and you can review it any time in your life if you need to look back on 'oh, how did it go again?' with everything popping back in place. By hand - works best for scientific courses (add drawings, graphs, ...)I use following color-coded pens:Black - main titels, index-likeBlue - keywordsGreen - for every (short) summary listRed - really important stuffPencil - explanations (principle: once read, you don't have to read it again)Example - LOOKS messy, but notes you write yourself always make more sense than somebody else's.Also possible: 15 papers (max) on a computer for more text-heavy courses. Since it takes more effort to color-code digitally, I simply leave everything black, size 11, and the stuff I'd normally write in pencil I shrink to size 7. Chapter titels are in red, bold, and keywords are also bold. Same principle applies: keep things short.When printed, I apply my text-book color code - not my most flattering example:2. Now the only problem that remains is memorizing those important bits. Fun part: the hard work is already done. You got everything together, you understand the concepts, and since you actively juggled everything to get these compressions together, most of the knowledge is already there. SO, in the 2-5 days before an exam for example, depending on the time available, the only thing I do is: repeat - repeat - repeat. Why? Because the mother of all skill is repetition. How? By talking out loud and explaining the concepts/story to myself, switching between walking around and sitting, which keeps the body active. This way, both the auditive and visual memory are prompted.Do this piece by piece. Only when the chapter chapter at hand is completely memorised, continue to the next one. And as you advance, always start from the beginning. Don't just hop to the middle, because then you'll lose the story. The trick is to remember it like a story, because that is what our minds are attracted to.To motivate myself, what I do is I write down the amount of repetitions I want to get done that day. A reasonable number, like 4 or 5. Then make sure to get it done - afterwards you can do what ever.Note: A repetition must also be re-reading the slides/textbook/... These compressions act as your core tree-structure, but I noticed that they can remain a bit too superficial. Combining them with some minor re-evaluating the 'standard' material solves this problem.Same with excercices: practice.------Make a schedule: I make sure I see everything in shifts (see: spaced repetitions). So in stage 1: course by course I make a compression paper, starting with the exam that comes first, ending with the last exam. In stage 2, I start learning back at the beginning: the compression paper of stage one. After the first exam, start learning the second paper, etc.------3. Day of the exam: sleep early, get up early, and do 1 or more repetition in the morning. Then go nail the exam.Hope this helps!