for many years i was under the misapprehension that i didn't have enough time to write unit tests for my code. when i did write tests, they were bloated, heavy things which only encouraged me to think that i should only ever write unit tests when i knew they were needed. then i started to use test driven development and i found it to be a complete revelation. i'm now firmly convinced that i don't have the time not to write unit - tests. in my experience, by developing with testing in mind you end up with cleaner interfaces, more focussed classes & modules and generally more solid, testable code. every time i work with legacy code which doesn't have unit tests and have to manually test something, i keep thinking " this would be so much quicker if this code already had unit tests ". every time i have to try and add unit test functionality to code with high coupling, i keep thinking " this would be so much easier if it had been written in a de - coupled way ". comparing and contrasting the two experimental stations that i support. one has been around for a while and has a great deal of legacy code, while the other is relatively new. when adding functionality to the old lab, it is often a case of getting down to the lab and spending many hours working through the implications of the functionality they need and how i can add that functionality without affecting any of the other functionality. the code is simply not set up to allow off - line testing, so pretty much everything has to be developed on - line. if i did try to develop off - line then i would end up with more mock objects than would be reasonable. in the newer lab, i can usually add functionality by developing it off - line at my desk, mocking out only those things which are immediately required, and then only spending a short time in the lab, ironing out any remaining problems not picked up off - line. for clarity, and since @ naught101 asked... i tend to work on experimental control and data acquisition software, with some ad hoc data analysis, so the combination of tdd with revision control helps to document both changes in the underlying experiment hardware and as well as changes in data collection requirements over time. even in the situation of developing exploratory code however, i could see a significant benefit from having assumptions codified, along with the ability to see how those assumptions evolve over time.


a great question, and since a textbook could probably be written to answer it, there's probably not going to be any single answer. i want to provide a general answer tailored to hobbyists, and hope that people more knowledgeable can come in and tie up specifics. summary solder is basically metal wire with a " low " melting point, where low for our purposes means low enough to be melted with a soldering iron. for electronics, it is traditionally a mix of tin and lead. tin has a lower melting point than lead, so more tin means a lower melting point. most common lead - based solder you'll find at the gadget store will be 60sn / 40pb ( for 60 % tin, 40 % lead ). there's some other minor variations you're likely to see, such as 63sn / 37pb, but for general hobbyist purposes i have used 60 / 40 for years with no issue. science content now, molten metal is a tricky beast, because it behaves a bit like water : of particular interest is its surface tension. molten metal will ball up if it doesn't find something to " stick " to. that's why solder masks work to keep jumpers from forming, and why you see surface - mount soldering tricks. in general, metal likes to stick to metal, but doesn't like to stick to oils or oxidized metals. by simply being exposed to air, our parts and boards start to oxidize, and through handling they get exposed to grime ( such as oils from our skin ). the solution to this is to clean the parts and boards first. that's where flux cores come in to solder. flux cores melt at a lower temperature than the solder, and coat the area to be soldered. the flux cleans the surfaces, and if they're not too dirty the flux is sufficient to make a good strong solder joint ( makes it " sticky " enough ). flux cores there are two common types of flux cores : acid and rosin. acid is for plumbing, and should not be used in electronics ( it is likely to eat your components or boards ). you do need to keep an eye out for that, but in general if it's in the electronics section of a gadget store it's good, if it's in the plumbing section of a home supply / home improvement store, it's bad. in general, for hobbyist use,


as long as you keep your parts clean and don't let them sit around too long, a flux core isn't necessary. however, if you are looking for solder then you probably should pick up something with a rosin core. the only reason you wouldn't use a flux core solder as a hobbyist is if you knew exactly why you didn't need the flux in the first place, but again, if you have some solder without flux you can probably use it for hobbyist purposes without issue. lead free that's pretty much all a hobbyist needs to know, but it doesn't hurt to know about lead - free solder since things are going that way. the eu now requires pretty much all commercially - available electronics ( with exceptions for the health and aerospace industries, as i recall ) to use lead - free components, including solder. this is catching on, and while you can still find lead - based solder it can lead to confusion. the purpose of lead - free solder is exactly the same : it's an evolution in the product meant to be more environmentally friendly. the issue is that lead ( which is used to reduce melting point of the solder ) is very toxic, so now different metals are used instead which aren't as effective at controlling melting point. in general, you can use lead - free and lead - based solder interchangeably for hobbyist uses, but lead - free solder is a bit harder to work with because it doesn't flow as nicely or at as low a temperature as its lead - based equivalent. it's nothing that will stop you from successfully soldering something, and in general lead - free and lead - based solders are pretty interchangeable to the hobbyist. tutorials there are plenty of soldering videos on youtube, just plugging in " soldering " to the search should turn up plenty. nasa has some old instructional videos that are great, because they deal with a lot of through - hole components. some of these are relevant because they discuss the techniques and how the solder types relate. in general, if you got it at the electronics hobby shop, it's good to use for hobbyist purposes.


a common error i think is to use greedy algorithms, which is not always the correct approach, but might work in most test cases. example : coin denominations, $ d _ 1, \ dots, d _ k $ and a number $ n $, express $ n $ as a sum of $ d _ i $ : s with as few coins as possible. a naive approach is to use the largest possible coin first, and greedily produce such a sum. for instance, the coins with value $ 6 $, $ 5 $ and $ 1 $ will give correct answers with greedy for all numbers between $ 1 $ and $ 14 $ except for the number $ 10 = 6 + 1 + 1 + 1 + 1 = 5 + 5 $.


you're attempting to take a limit. $ $ x _ { n + 1 } = 1 - \ frac { 1 } { x _ n } $ $ this recurrence actually never converges, from any real starting point. indeed, $ $ x _ 2 = 1 - \ frac { 1 } { x _ 1 } ; \ \ x _ 3 = 1 - \ frac { 1 } { 1 - 1 / x _ 1 } = 1 - \ frac { x _ 1 } { x _ 1 - 1 } = \ frac { 1 } { 1 - x _ 1 } ; \ \ x _ 4 = x _ 1 $ $ so the sequence is periodic with period 3. therefore it converges if and only if it is constant ; but the only way it could be constant is, as you say, if $ x _ 1 $ is one of the two complex numbers you found. therefore, what you have is actually basically a proof by contradiction that the sequence doesn't converge when you consider it over the reals. however, you have found exactly the two values for which the iteration does converge ; that is their significance. alternatively viewed, the map $ $ z \ mapsto 1 - \ frac { 1 } { z } $ $ is a certain transformation of the complex plane, which has precisely two fixed points. you might find it an interesting exercise to work out what that map does to the complex plane, and examine in particular what it does to points on the real line.


the reason is simple : chocolate contains cocoa which contains theobromine. the darker the chocolate is ( meaning the more cocoa it contains ) the more theobromine it contains. this is a bitter alkaloid which is toxic to dogs ( and also cats ), but can be tolerated by humans. the reason for this is the much slower metabolization of theobromine in the animals ( there are reports for poisonings of dogs, cats, birds, rabbits and even bear cubs ) so that the toxic effect can happen. depending on the size of the dog, something between 50 and 400g of milk chocolate can be fatal. as mentioned by @ anongoodnurse the cocoa content in milk chocolate is the lowest and much higher the darker the chocolate gets. the poisoning comes from the theobromine itself, which has different mechanisms of action : first it is an unselective antagonist of the adenosine receptor, which is a subclass of g - protein coupled receptors on the cell surface which usually bind adenosine as a ligand. this influences cellular signalling. then it is a competitive nonselective phosphodiesterase inhibitor, which prevents the breakdown of cyclic amp in the cell. camp is an important second messenger in the cell playing an important role in the mediation of signals from the outside of the cells via receptors to a reaction of a cell to changing conditions. the levels of camp are tightly controlled and the half - life of the molecule is generally short. elevated levels lead to an activation of the protein kinase a, an inhibition tnf - alpha and leukotriene synthesis and reduces inflammation and innate immunity. for references see here. the ld50 for theobromine is very different among species ( table from here ), with ld50 as the lethal dose killing 50 % of the individuals and tdlo the lowest published toxic dose : the ld50 also differs between different breeds of dogs, so there are online calculators available to make an estimation, if there is a problem or not. you can find them for example here and here. the selective toxicity makes it even an interesting poison for pest control of coyotes, see reference 4 for some details. references : chocolate - veterinary manual chocolate intoxication the poisonous chemistry of chocolate evaluation of cocoa - and coffee - derived methylxanthines as toxicants for the control of pest coyotes.


can i predict the products of any chemical reaction? in theory, yes! every substance has characteristic reactivity behavior. likewise pairs and sets of substances have characteristic behavior. for example, the following combinations of substances only have one likely outcome each : $ $ \ ce { hcl + naoh - > nacl + h2o } \ \ [ 2ex ] \ ce { ch3ch2ch2oh - > [ $ 1. $ ( cocl ) 2, ( ch3 ) 2so ] [ $ 2. $ et3n ] ch3ch2cho } $ $ however, it is not a problem suited to brute force or exhaustive approaches there are millions or perhaps billions of known or possible substances. let's take the lower estimate of 1 million substances. there are $ 999 \, 999 \, 000 \, 000 $ possible pairwise combinations. any brute force method ( in other words a database that has an answer for all possible combinations ) would be large and potentially resource prohibitive. likewise you would not want to memorize the nearly 1 trillion combinations. if more substances are given, the combination space gets bigger. in the second example reaction above, there are four substances combined : $ \ ce { ch3ch2ch2oh } $, $ \ ce { ( cocl ) 2 } $, $ \ ce { ( ch3 ) 2so } $, and $ \ ce { et3n } $. pulling four substances at random from the substance space generates a reaction space on the order of $ 1 \ times 10 ^ { 24 } $ possible combinations. and that does not factor in order of addition. in the second reaction above, there is an implied order of addition : $ \ ce { ch3ch2ch2oh } $ $ \ ce { ( cocl ) 2 } $, $ \ ce { ( ch3 ) 2so } $ $ \ ce { et3n } $ however, there are $ 4! = 24 $ different orders of addition for four substances, some of which might not generate the same result. our reaction space is up to $ 24 \ times 10 ^ { 24 } $, a bewildering number of combinations. and this space does not include other variables, like time, temperature, irradiation, agitation, concentration, pressure, control of environment, etc. if each reaction in the space could somehow be stored for as little as 100 kb of memory, then the whole space of combinations up to 4 substances would require $ 2


. 4 \ times 10 ^ { 27 } $ bytes of data, or $ 2. 4 \ times 10 ^ 7 $ zb ( zettabytes ) or $ 2. 4 \ times 10 ^ 4 $ trillion terabytes. the total digital data generated by the human species was estimated recently ( nov. 2015 ) to be 4. 4 zb. we need $ 5. 5 \ times 10 ^ 5 $ times more data in the world to hold such a database. and that does not even count the program written to search it or the humans needed to populate it, the bandwidth required to access it, or the time investment of any of these steps. in practice, it can be manageable! even though the reaction space is bewilderingly huge, chemistry is an orderly predictable business. folks in the natural product total synthesis world do not resort to random combinations and alchemical mumbo jumbo. they can predict with some certainty what type of reactions do what to which substances and then act on that prediction. when we learn chemistry, we are taught to recognize if a molecule belongs to a certain class with characteristic behavior. in the first example above, we can identify $ \ ce { hcl } $ as an acid and $ \ ce { naoh } $ as a base, and then predict an outcome that is common to all acid - base reactions. in the second example above, we are taught to recognize $ \ ce { ch3ch2ch2oh } $ as a primary alcohol and the reagents given as an oxidant. the outcome is an aldehyde. these examples are simple ones in which the molecules easily fit into one class predominantly. more complex molecules may belong to many categories. organic chemistry calls these categories “ functional groups ”. the ability to predict synthetic outcomes then begins and ends with identifying functional groups within a compound's structure. for example, even though the following compound has a more complex structure, it contains a primary alcohol, which will be oxidized to an aldehyde using the same reagents presented above. we can also be reasonably confident that no unpleasant side reactions will occur. if the reagents in the previous reaction had been $ \ ce { lialh4 } $ followed by $ \ ce { h3o + } $, then more than one outcome is possible since more than one functional group in the starting compound will react. controlling the reaction to give one of the possible outcomes is possible, but requires further careful thought. there are rules


, but they are not few in number. there are too many classes of compounds to list here. likewise even one class, like primary alcohols ( an hydroxyl group at the end of a hydrocarbon chain ) has too many characteristic reactions to list here. if there are 30 classes of compounds ( an underestimate ) and 30 types of reactions ( an underestimate ), then there are 900 reaction types ( an underestimate ). the number of viable reaction types is more manageable than the total reaction space, but would still be difficult to commit to memory quickly. and new reaction types are being discovered all the time. folks who learn how to analyze combinations of compounds spend years taking courses and reading books and research articles to accumulate the knowledge and wisdom necessary. it can be done. computer programs can be ( and have been ) designed to do the same analysis, but they were designed by people who learned all of the characteristic combinations. there is no shortcut.


the correct answer is because the ethernet specification requires it. although you didn't ask, others may wonder why this method of connection was chosen for that type of ethernet. keep in mind that this applies only to the point - to - point ethernet varieties, like 10base - t and 100base - t, not to the original ethernet or to thinlan ethernet. the problem is that ethernet can support fairly long runs such that equipment on different ends can be powered from distant branches of the power distribution network within a building or even different buildings. this means there can be significant ground offset between ethernet nodes. this is a problem with ground - referenced communication schemes, like rs - 232. there are several ways of dealing with ground offsets in communications lines, with the two most common being opto - isolation and transformer coupling. transformer coupling was the right choice for ethernet given the tradeoffs between the methods and what ethernet was trying to accomplish. even the earliest version of ethernet that used transformer coupling runs at 10 mbit / s. this means, at the very least, the overall channel has to support 10 mhz digital signals, although in practice with the encoding scheme used it actually needs twice that. even a 10 mhz square wave has levels lasting only 50 ns. that is very fast for opto - couplers. there are light transmission means that go much much faster than that, but they are not cheap or simple at each end like the ethernet pulse transformers are. one disadvantage of transformer coupling is that dc is lost. that's actually not that hard to deal with. you make sure all information is carried by modulation fast enough to make it thru the transformers. if you look at the ethernet signalling, you will see how this was considered. there are nice advantages to transformers too, like very good common mode rejection. a transformer only " sees " the voltage across its windings, not the common voltage both ends of the winding are driven to simultaneously. you get a differential front end without a deliberate circuit, just basic physics. once transformer coupling was decided on, it was easy to specify a high isolation voltage without creating much of a burden. making a transformer that insulates the primary and secondary by a few 100 v pretty much happens unless you try not to. making it good to 1000 v isn't much harder or much more expensive. given that, ethernet can be used to communicate between two nodes actively driven to significantly different voltages, not just to deal with a few volts of ground offset. for example, it


is perfectly fine and within the standard to have one node riding on a power line phase with the other referenced to the neutral.


adapted from an answer to a different question ( as mentioned in a comment ) in the hope that this question will not get thrown up repeatedly by community wiki as one of the top questions.... there is no " flipping " of the impulse response by a linear ( time - invariant ) system. the output of a linear time - invariant system is the sum of scaled and time - delayed versions of the impulse response, not the " flipped " impulse response. we break down the input signal $ x $ into a sum of scaled unit pulse signals. the system response to the unit pulse signal $ \ cdots, ~ 0, ~ 0, ~ 1, ~ 0, ~ 0, \ cdots $ is the impulse response or pulse response $ $ h [ 0 ], ~ h [ 1 ], \ cdots, ~ h [ n ], \ cdots $ $ and so by the scaling property the single input value $ x [ 0 ] $, or, if you prefer $ $ x [ 0 ] ( \ cdots, ~ 0, ~ 0, ~ 1, ~ 0, ~ 0, \ cdots ) = \ cdots ~ 0, ~ 0, ~ x [ 0 ], ~ 0, ~ 0, \ cdots $ $ creates a response $ $ x [ 0 ] h [ 0 ], ~ ~ x [ 0 ] h [ 1 ], \ cdots, ~ ~ x [ 0 ] h [ n ], \ cdots $ $ similarly, the single input value $ x [ 1 ] $ or $ $ x [ 1 ] ( \ cdots, ~ 0, ~ 0, ~ 0, ~ 1, ~ 0, \ cdots ) = \ cdots ~ 0, ~ 0, ~ 0, ~ x [ 1 ], ~ 0, \ cdots $ $ creates a response $ $ 0, x [ 1 ] h [ 0 ], ~ ~ x [ 1 ] h [ 1 ], \ cdots, ~ ~ x [ 1 ] h [ n - 1 ], x [ 1 ] h [ n ] \ cdots $ $ notice the delay in the response to $ x [ 1 ] $. we can continue further in this vein, but it is best to switch to a more tabular form and show the various outputs aligned properly in time. we have $ $ \ begin { array } { l | l | l | l | l | l | l | l } \ text { time } \ to & 0 & 1 & 2


& \ cdots & n & n + 1 & \ cdots \ \ \ hline x [ 0 ] & x [ 0 ] h [ 0 ] & x [ 0 ] h [ 1 ] & x [ 0 ] h [ 2 ] & \ cdots & x [ 0 ] h [ n ] & x [ 0 ] h [ n + 1 ] & \ cdots \ \ \ hline x [ 1 ] & 0 & x [ 1 ] h [ 0 ] & x [ 1 ] h [ 1 ] & \ cdots & x [ 1 ] h [ n - 1 ] & x [ 1 ] h [ n ] & \ cdots \ \ \ hline x [ 2 ] & 0 & 0 & x [ 2 ] h [ 0 ] & \ cdots & x [ 2 ] h [ n - 2 ] & x [ 2 ] h [ n - 1 ] & \ cdots \ \ \ hline \ vdots & \ vdots & \ vdots & \ vdots & \ ddots & \ \ \ hline x [ m ] & 0 & 0 & 0 & \ cdots & x [ m ] h [ n - m ] & x [ m ] h [ n - m + 1 ] & \ cdots \ \ \ hline \ vdots & \ vdots & \ vdots & \ vdots & \ ddots \ end { array } $ $ the rows in the above array are precisely the scaled and delayed versions of the impulse response that add up to the response $ y $ to input signal $ x $. but if you ask a more specific question such as what is the output at time $ n $? then you can get the answer by summing the $ n $ - th column to get $ $ \ begin { align * } y [ n ] & = x [ 0 ] h [ n ] + x [ 1 ] h [ n - 1 ] + x [ 2 ] h [ n - 2 ] + \ cdots + x [ m ] h [ n - m ] + \ cdots \ \ & = \ sum _ { m = 0 } ^ { \ infty } x [ m ] h [ n - m ], \ end { align * } $ $ the beloved convolution formula that befuddles generations of students because the impulse response seems to be " flipped over " or running backwards in time. but, what people seem to forget is that instead


we could have written $ $ \ begin { align * } y [ n ] & = x [ n ] h [ 0 ] + x [ n - 1 ] h [ 1 ] + x [ n - 2 ] h [ 2 ] + \ cdots + x [ 0 ] h [ n ] + \ cdots \ \ & = \ sum _ { m = 0 } ^ { \ infty } x [ n - m ] h [ m ], \ end { align * } $ $ so that it is the input that seems " flipped over " or running backwards in time! in other words, it is human beings who flip the impulse response ( or the input ) over when computing the response at time $ n $ using the convolution formula, but the system itself does nothing of the sort.


historical perspective it is really impossible to say what the new paradigms will be like in the future, for example a good historical perspective i suggest reading ken kennedy's rise and fall of hpf. kennedy gives an account of two emerging patterns, mpi versus a smart compiler, and details how mpi had the right amount of early adopters and flexibility to dominate. hpf eventually fixed its problems but it was too late. in many ways, several paradigms, such as pgas and openmp, are following that same hpf trend. the early codes have not been flexible enough to use well and left a lot of performance on the table. but the promise of not having to write every iota of the parallel algorithm is a attractive goal. so the pursuit of new models are always being pursued. clear trends in hardware now the success of mpi has often been cited as to being closely tied to how it models the hardware it runs on. roughly each node has a few number of processes and passing the messages to local point - to - point or through coordinated collective operations is easily done in the cluster space. because of this, i don't trust anyone who gives a paradigm that doesn't follow closely to new hardware trends, i actually was convinced of this opinion by the work from vivak sarakar. in keeping with that here are three trends that are clearly making headway in new architectures. and let me be clear, there are now twelve different architectures being marketed in hpc. this up from less than 5 years ago only featuring x86, so the coming days will see lots of opportunities for using hardware in different and interesting ways special purpose chips : think large vector units like accelerators ( view espoused by bill dally of nvidia ) low power chips : arm based clusters ( to accomodate power budgets ) tiling of chips : think tiling of chips with different specifications ( work of avant argwal ) current models the current model is actually 3 levels deep. while there are many codes using two of these levels well, not many have emerged using all three. i believe that to first get to exascale one needs to invest in determining if you code can run at all three levels. this is probably the safest path for iterating well with the current trends. let me iterate on the models and how they will need to change based on the predicted new hardware views. distributed the players at the distributed level largely fall into mpi and pgas languages. mpi is a


clear winner right now, but pgas languages such as upc and chapel are making headways into the space. one good indication is the hpc benchmark challenge. pgas languages are giving very elegant implementations of the benchmarks. the most interesting point here is that while this model currently only works at the node level, it will be an important model inside a node for tiled architectures. one indication is the intel scc chip, which fundamentally acted like a distributed system. the scc team created their own mpi implementation and many teams were successful at porting community libraries to this architecture. but to be honest pgas really has a good story for stepping in to this space. do you really want to program mpi internode and then have to do the same trick intranode? one big deal with these tiled architectures is that they will have different clock speeds on the chips and major differences in bandwidth to memory so performant codes must take this into account. on - node shared memory here we see mpi often being " good enough ", but pthreads ( and libraries deriving from pthreads such as intel parallel building blocks ) and openmp are still used often. the common view is that there will be a time when there are enough shared memory threads that mpi's socket model will break down for rpc or you need a lighter weight process running on the core. already you can see the indications of ibm bluegene systems having problems with shared memory mpi. as matt comments, the largest performance boost for compute intensive codes is the vectorization of the serial code. while many people assume this is true in accelerators, it is also critical for on - node machines as well. i believe westmere has a 4 wide fpu, thus one can only get a quarter of the flops without vectorization. while i don't see the current openmp stepping into this space well, there is a place for low - powered or tiles chips to use more light threads. openmp has difficulty describing how the data flow works and as more threads are used i only see this trend becoming more exaggerated, just look at examples of what one has to do to get proper prefetching with openmp. both openmp and pthreads at a course enough level can take advantage of the vectorization necessary to get a good percentage of peak, but doing so requires breaking down your algorithms in a way that vectorization is natural. co - processor finally the emergence of the co - processor ( gpu,


mic, cell acclerators ) has taken hold. it is becoming clear that no path to exascale will be complete without them. at sc11, every bell prize contestent used them very effectively to get to the low petaflops. while cuda and opencl have dominated the current market, i have hopes for openacc and pgas compilers entering the space. now to get to exascale, one proposal is to couple the low powered chips to lots of co - processors. this will pretty well kill off the middle layer of the current stack and use codes that manage decision problems on the main chip and shuffle off work to the co - processors. this means that for code to work quite effectively a person must rethink the algorithms in terms of kernels ( or codelets ), that is branchless instruction level parallel snippets. as far as i know, a solution to this evolution is pretty wide open. how this affects the app developer now to get to your question. if you want to protect yourself from the oncoming complexities of exascale machines, you should do a few things : develop your algorithms to fit at least three levels of parallel hierarchy. design your algorithms in terms of kernels that can be moved between the heirarchy. relax your need for any sequential processes, all of these effects will happen asynchronously because synchronous execution is just not possible. if you want to be performant today, mpi + cuda / opencl is good enough but upc is getting there so its not a bad idea to take a few days and learn it. openmp gets you started but leads to problems once the code needs to be refactored. pthreads requires completely rewriting your code to its style. which makes mpi + cuda / opencl the current best model. what is not discussed here while all this talk of exascale is nice, something not really discussed here is getting data onto and off of the machines. while there have been many advances in memory systems, we don't see them in commodity cluster ( just too darned expensive ). now that data intensive computing is becoming a large focus of all the super computing conferences, there is bound to be a bigger movement into the high memory bandwidth space. this brings to the other trend that might happen ( if the right funding agencies get involved ). machines are going to become more and more specialized for the type of computing required. we already see


" data - intensive " machines being funded by the nsf, but these machines are on a different track than the 2019 exascale grand challenge. this became longer than expected ask for references where you need them in the comments


this is really a footnote to the accepted answer. light cannot escape from an event horizon. but how can you check that light can never escape? you can watch the surface for some time $ t $, but all you have proved is that light can't escape in the time $ t $. this is what we mean by an apparent horizon, i. e. it is a surface from which light can't escape within a time $ t $. to prove the surface really was an event horizon you would have to watch it for an infinite time. the problem is that hawking radiation means that no event horizon can exist for an infinite time. the conclusion is that only apparent horizons can exist, though the time $ t $ associated with them can be exceedingly long, e. g. many times longer than the current age of the universe. a point worth mentioning because it's easy to overlook : when you start learning about black holes you'll start with a solution to einstein's equations called the schwarzschild metric, and this has a true horizon. however the schwarzschild metric is time independent so it would only describe a real black hole if that black hole had existed for an infinite time and would continue to exist for an infinite time. both of these are not possible in the real universe. so the schwarzschild metric is only an approximate description of a real black hole, though we expect it to be a very good approximation.


$ \ text { error = bias + variance } $ boosting is based on weak learners ( high bias, low variance ). in terms of decision trees, weak learners are shallow trees, sometimes even as small as decision stumps ( trees with two leaves ). boosting reduces error mainly by reducing bias ( and also to some extent variance, by aggregating the output from many models ). on the other hand, random forest uses as you said fully grown decision trees ( low bias, high variance ). it tackles the error reduction task in the opposite way : by reducing variance. the trees are made uncorrelated to maximize the decrease in variance, but the algorithm cannot reduce bias ( which is slightly higher than the bias of an individual tree in the forest ). hence the need for large, unpruned trees, so that the bias is initially as low as possible. please note that unlike boosting ( which is sequential ), rf grows trees in parallel. the term iterative that you used is thus inappropriate.


i can tell you why i don't believe in it. i think my reasons are different from most physicists'reasons, however. regular quantum mechanics implies the existence of quantum computation. if you believe in the difficulty of factoring ( and a number of other classical problems ), then a deterministic underpinning for quantum mechanics would seem to imply one of the following. there is a classical polynomial - time algorithm for factoring and other problems which can be solved on a quantum computer. the deterministic underpinnings of quantum mechanics require $ 2 ^ n $ resources for a system of size $ o ( n ) $. quantum computation doesn't actually work in practice. none of these seem at all likely to me. for the first, it is quite conceivable that there is a polynomial - time algorithm for factoring, but quantum computation can solve lots of similar periodicity problems, and you can argue that there can't be a single algorithm that solves all of them on a classical computer, so you would have to have different classical algorithms for each classical problem that a quantum computer can solve by period finding. for the second, deterministic underpinnings of quantum mechanics that require $ 2 ^ n $ resources for a system of size $ o ( n ) $ are really unsatisfactory ( but maybe quite possible... after all, the theory that the universe is a simulation on a classical computer falls in this class of theories, and while truly unsatisfactory, can't be ruled out by this argument ). for the third, i haven't seen any reasonable way to how you could make quantum computation impossible while still maintaining consistency with current experimental results.


i believe this can also be solved using double integrals. it is possible ( if i remember correctly ) to justify switching the order of integration to give the equality : $ $ \ int _ { 0 } ^ { \ infty } \ bigg ( \ int _ { 0 } ^ { \ infty } e ^ { - xy } \ sin x \, dy \ bigg ) \, dx = \ int _ { 0 } ^ { \ infty } \ bigg ( \ int _ { 0 } ^ { \ infty } e ^ { - xy } \ sin x \, dx \ bigg ) \, dy $ $ notice that $ $ \ int _ { 0 } ^ { \ infty } e ^ { - xy } \ sin x \, dy = \ frac { \ sin x } { x } $ $ this leads us to $ $ \ int _ { 0 } ^ { \ infty } \ big ( \ frac { \ sin x } { x } \ big ) \, dx = \ int _ { 0 } ^ { \ infty } \ bigg ( \ int _ { 0 } ^ { \ infty } e ^ { - xy } \ sin x \, dx \ bigg ) \, dy $ $ now the right hand side can be found easily, using integration by parts. $ $ \ begin { align * } i & = \ int e ^ { - xy } \ sin x \, dx = - e ^ { - xy } { \ cos x } - y \ int e ^ { - xy } \ cos x \, dx \ \ & = - e ^ { - xy } { \ cos x } - y \ big ( e ^ { - xy } \ sin x + y \ int e ^ { - xy } \ sin x \, dx \ big ) \ \ & = \ frac { - ye ^ { - xy } \ sin x - e ^ { - xy } \ cos x } { 1 + y ^ 2 }. \ end { align * } $ $ thus $ $ \ int _ { 0 } ^ { \ infty } e ^ { - xy } \ sin x \, dx = \ frac { 1 } { 1 + y ^ 2 } $ $ thus $ $ \ int _


{ 0 } ^ { \ infty } \ big ( \ frac { \ sin x } { x } \ big ) \, dx = \ int _ { 0 } ^ { \ infty } \ frac { 1 } { 1 + y ^ 2 } \, dy = \ frac { \ pi } { 2 }. $ $


all three are so - called " meta - algorithms " : approaches to combine several machine learning techniques into one predictive model in order to decrease the variance ( bagging ), bias ( boosting ) or improving the predictive force ( stacking alias ensemble ). every algorithm consists of two steps : producing a distribution of simple ml models on subsets of the original data. combining the distribution into one " aggregated " model. here is a short description of all three methods : bagging ( stands for bootstrap aggregating ) is a way to decrease the variance of your prediction by generating additional data for training from your original dataset using combinations with repetitions to produce multisets of the same cardinality / size as your original data. by increasing the size of your training set you can't improve the model predictive force, but just decrease the variance, narrowly tuning the prediction to expected outcome. boosting is a two - step approach, where one first uses subsets of the original data to produce a series of averagely performing models and then " boosts " their performance by combining them together using a particular cost function ( = majority vote ). unlike bagging, in the classical boosting the subset creation is not random and depends upon the performance of the previous models : every new subsets contains the elements that were ( likely to be ) misclassified by previous models. stacking is a similar to boosting : you also apply several models to your original data. the difference here is, however, that you don't have just an empirical formula for your weight function, rather you introduce a meta - level and use another model / approach to estimate the input together with outputs of every model to estimate the weights or, in other words, to determine what models perform well and what badly given these input data. here is a comparison table : as you see, these all are different approaches to combine several models into a better one, and there is no single winner here : everything depends upon your domain and what you're going to do. you can still treat stacking as a sort of more advances boosting, however, the difficulty of finding a good approach for your meta - level makes it difficult to apply this approach in practice. short examples of each : bagging : ozone data. boosting : is used to improve optical character recognition ( ocr ) accuracy. stacking : is used in classification of cancer microarrays in medicine.


essentially, os is slightly more efficient since it does not require the addition of the overlapping transients. however, you may want to use oa if you need to reuse the ffts with zero - padding rather than repeated samples. here is a quick overview from an article i wrote a while ago fast convolution refers to the blockwise use of circular convolution to accomplish linear convolution. fast convolution can be accomplished by oa or os methods. os is also known as “ overlap - scrap ”. in oa filtering, each signal data block contains only as many samples as allows circular convolution to be equivalent to linear convolution. the signal data block is zero - padded prior to the fft to prevent the filter impulse response from “ wrapping around ” the end of the sequence. oa filtering adds the input - on transient from one block with the input - off transient from the previous block. in os filtering, shown in figure 1, no zero - padding is performed on the input data, thus the circular convolution is not equivalent to linear convolution. the portions that “ wrap around ” are useless and discarded. to compensate for this, the last part of the previous input block is used as the beginning of the next block. os requires no addition of transients, making it faster than oa.


i think possibly the problem here is the way you're approaching the issue. you're considering improvement as anything that increases the abilities or complexity of the organism — that isn't necessarily what an improvement is though. the outcome of natural selection is that the organism best equipped to survive / reproduce in a certain environment is the most successful. so, for example, thermophillic archaea do much better in 60°c - plus pools of water than humans do. our capacity to process information, use tools, etc. doesn't actually confer much advantage in that situation. and there can be downsides to that kind of complexity as well, requiring more energy and longer developmental periods. so, natural selection in 60°c - plus pools of water gives you archaea, and in ( presumably ) the plains of east africa, it gives you humans. the comment you quote mentions sickle - cell anaemia, which is a different example. while there is little benefit to having the sickle - cell anaemia allele in a temperate region, in those regions where malaria is endemic, heterozygosity can provide a survival advantage, and so the allele is maintained in the population. if you're someone living in a malaria - endemic region, and you don't have access to antimalarials, heterozygosity for the sickle - cell anaemia allele is arguably an improvement. it depends entirely on how you define the word. the fundamental principal of natural selection is that it favours the organism most suited to a particular environment. but, that isn't always the most complex organism. it's important not to confuse human - like with better. it isn't the universal endpoint of evolution to produce an organism similar to us, just the organism most suited to the environment in question. also, to briefly address the previous question you asked — you asserted that we must be missing something from the process of evolution because we were unable to simulate it. you also pointed out that ( in your opinion ) we have sufficient computing power to simulate the kinds of organisms you're referring to. but natural selection is intrinsically linked to the environment it occurs in, so the simulation wouldn't just have to accurately simulate the biological processes of the organism, but also all of the external pressures the organism faces. i'd imagine that, in simulating evolution, that would be the real obstacle.


gravitational waves are qualitatively different from other detections. as much as we have tested gr before, it's still reassuring to find a completely different test that works just as well. the most notable tests so far have been the shifting of mercury's orbit, the correct deflection of light by massive objects, and the redshifting of light moving against gravity. in these cases, spacetime is taken to be static ( unchanging in time, with no time - space cross terms in the metric ). gravitational waves, on the other hand, involve a time - varying spacetime. gravitational waves provide a probe of strong - field gravity. the tests so far have all been done in weak situations, where you have to measure things pretty closely to see the difference between gr and newtonian gravity. while gravitational waves themselves are a prediction of linearized gravity and are the very essence of small perturbations, their sources are going to be very extreme environments - - merging black holes, exploding stars, etc. now a lot of things can go wrong between our models of these extreme phenomena and our recording of a gravitational wave signal, but if the signal agrees with our predictions, that's a sign that not only are we right about the waves themselves, but also about the sources. gravitational waves are a new frontier in astrophysics. this point is often forgotten when we get so distracted with just finding any signal. finding the first gravitational waves is only the beginning for astronomical observations. with just two detectors, ligo for instance cannot pinpoint sources on the sky any better than " somewhere out there, roughly. " eventually, as more detectors come online, the hope is to be able to localize signals better, so we can simultaneously observe electromagnetic counterparts. that is, if the event causing the waves is the merger of two neutron stars, one might expect there to be plenty of light released as well. by combining both types of information, we can gain quite a bit more knowledge about the system. gravitational waves are also good at probing the physics at the innermost, most - obscured regions in cataclysmic events. for most explosions in space, all we see now is the afterglow - - the hot, radioactive shell of material left behind - - and we can only infer indirectly what processes were happening at the core. gravitational waves provide a new way to gain insight in this respect.


sometimes, especially in introductory courses the instructor will try to keep things " focused " in order to promote learning. still, it's unfortunate that the instructor couldn't respond in a more positive and stimulating way to your question. these reactions do occur at $ \ ce { sp ^ 2 } $ hybridized carbon atoms, they are often just energetically more costly, and therefore somewhat less common. consider when a nucleophile reacts with a carbonyl compound, the nucleophile attacks the carbonyl carbon atom in an $ \ ce { s _ { n } 2 } $ manner. the electrons in the c - o $ \ pi $ – bond can be considered as the leaving group and a tetrahedral intermediate is formed with a negative charge on oxygen. it is harder to do this with a carbon - carbon double bond ( energetically more costly ) because you would wind up with a negative charge on carbon ( instead of oxygen ), which is energetically less desirable ( because of the relative electronegativities of carbon and oxygen ). if you look at the michael addition reaction, the 1, 4 - addition of a nucleophile to the carbon - carbon double bond in an $ \ ce { \ alpha - \ beta } $ unsaturated carbonyl system, this could be viewed as an $ \ ce { s _ { n } 2 } $ attack on a carbon - carbon double bond, but again, it is favored ( lower in energy ) because you create an intermediate with a negative charge on oxygen. $ \ ce { s _ { n } 1 } $ reactions at $ \ ce { sp ^ 2 } $ carbon are well documented. solvolysis of vinyl halides in very acidic media is an example. the resultant vinylic carbocations are actually stable enough to be observed using nmr spectroscopy. the picture below helps explain why this reaction is so much more difficult ( energetically more costly ) than the more common solvolysis of an alkyl halide. in the solvolysis of the alkyl halide we produce a traditional carbocation with an empty p orbital. in the solvolysis of the vinyl halide we produce a carbocation with the positive charge residing in an $ \ ce { sp ^ 2 } $ orbital. placing positive charge in an $ \ ce { sp ^ 2 } $ orbital is a higher energy situation compared to placing it in a p orbital ( electrons prefer to be in orbitals with higher s density,


it stabilizes them because the more s character in an orbital the lower its energy ; conversely, in the absence of electrons, an orbital prefers to have high p character and mix the remaining s character into other bonding orbitals that do contain electrons in order to lower their energy ).


a schematic is a visual representation of a circuit. as such, its purpose is to communicate a circuit to someone else. a schematic in a special computer program for that purpose is also a machine - readable description of the circuit. this use is easy to judge in absolute terms. either the proper formal rules for describing the circuit are followed and the circuit is correctly defined or it isn't. since there are hard rules for that and the result can be judged by machine, this isn't the point of the discussion here. this discussion is about rules, guidelines, and suggestions for good schematics for the first purpose, which is to communicate a circuit to a human. good and bad will be judged here in that context. since a schematic is to communicate information, a good schematic does this quickly, clearly, and with a low chance of misunderstanding. it is necessary but far from sufficient for a schematic to be correct. if a schematic is likely to mislead a human observer, it is a bad schematic whether you can eventually show that after due deciphering it was in fact correct. the point is clarity. a technically correct but obfuscated schematic is still a bad schematic. some people have their own silly - ass opinions, but here are the rules ( actually, you'll probably notice broad agreement between experienced people on most of the important points ) : use component designators this is pretty much automatic with any schematic capture program, but we still often see schematics here without them. if you draw your schematic on a napkin and then scan it, make sure to add component designators. these make the circuit much easier to talk about. i have skipped over questions when schematics didn't have component designators because i didn't feel like bothering with the second 10 kω resistor from the left by the top pushbutton. it's a lot easier to say r1, r5, q7, etc. clean up text placement schematic programs generally plunk down part names and values based on a generic part definition. this means they often end up in inconvenient places in the schematic when other parts are placed nearby. fix it. that's part of the job of drawing a schematic. some schematic capture programs make this easier than others. in eagle for example, unfortunately, there can only be one symbol for a part. some parts


are commonly placed in different orientations, horizontal and vertical in the case of resistors for example. diodes can be placed in at least 4 orientations since they have direction too. the placement of text around a part, like the component designator and value, probably won't work in other orientations than it was originally drawn in. if you rotate a stock part, move the text around afterward so that it is easily readable, clearly belongs to that part, and doesn't collide with other parts of the drawing. vertical text looks stupid and makes the schematic hard to read. i make separate redundant parts in eagle that differ only in the symbol orientation and therefore the text placement. that's more work upfront but makes it easier when drawing a schematic. however, it doesn't matter how you achieve a neat and clear end result, only that you do. there is no excuse. sometimes we hear whines like " but circuitbarf 0. 1 doesn't let me do that ". so get something that does. besides, circuitbarf 0. 1 probably does let you do it, just that you were too lazy to read the manual to learn how and too sloppy to care. draw it ( neatly! ) on paper and scan it if you have to. again, there is no excuse. for example, here are some parts at different orientations. note how the text is in different places relative to parts to make things neat and clear. don't let this happen to you : yes, this is actually a small snippet of what someone dumped on us here. basic layout and flow in general, it is good to put higher voltages towards the top, lower voltages towards the bottom and logical flow left to right. that's clearly not possible all the time, but at least a generally higher level effort to do this will greatly illuminate the circuit to those reading your schematic. one notable exception to this is feedback signals. by their very nature, they feed " back " from downstream to upstream, so they should be shown sending information opposite of the main flow. power connections should go up to positive voltages and down to negative voltages. don't do this : there wasn't room to show the line going down to ground because other stuff was already there. move it. you made the mess, you can unmake it. there is always a way. following these rules causes common subcircuits to be drawn


similarly most of the time. once you get more experience looking at schematics, these will pop out at you and you will appreciate this. if stuff is drawn every which way, then these common circuits will look visually different every time and it will take others longer to understand your schematic. what's this mess, for example? after some deciphering, you realize " oh, it's a common emitter amplifier. why didn't that # % & ^ $ @ # $ % just draw it like one in the first place!? " : draw pins according to function show pins of ics in a position relevant to their function, not how they happen to stick out of the chip. try to put positive power pins at the top, negative power pins ( usually grounds ) at the bottom, inputs at left, and outputs at right. note that this fits with the general schematic layout as described above. of course, this isn't always reasonable and possible. general - purpose parts like microcontrollers and fpgas have pins that can be input and output depending on use and can even vary at run time. at least you can put the dedicated power and ground pins at top and bottom, and possibly group together any closely related pins with dedicated functions, like crystal driver connections. ics with pins in physical pin order are difficult to understand. some people use the excuse that this aids in debugging, but with a little thought you can see that's not true. when you want to look at something with a scope, which question is more common " i want to look at the clock, what pin is that? " or " i want to look at pin 5, what function is that? ". in some rare cases, you might want to go around a ic and look at all the pins, but the first question is by far more common. physical pin order layouts obfuscate the circuit and make debugging more difficult. don't do it. direct connections, within reason spend some time with placement reducing wire crossings and the like. the recurring theme here is clarity. of course, drawing a direct connection line isn't always possible or reasonable. obviously, it can't be done with multiple sheets, and a messy rats nest of wires is worse than a few carefully chosen " air wires ". it is impossible to come up with a universal rule here, but if you constantly think of the mythical person looking over your shoulder trying to understand the circuit from


the schematic you are drawing, you'll probably do alright. you should be trying to help people understand the circuit easily, not make them figure it out despite the schematic. design for regular size paper the days of electrical engineers having drafting tables and being set up to work with d size drawings are long gone. most people only have access to regular page - size printers, like for 8 1 / 2 x 11 - inch paper here in the us. the exact size is a little different all around the world, but they are all roughly what you can easily hold in front of you or place on your desk. there is a reason this size evolved as a standard. handling larger paper is a hassle. there isn't room on the desk, it ends up overlapping the keyboard, pushes things off your desk when you move it, etc. the point is to design your schematic so that individual sheets are nicely readable on a single normal page, and on the screen at about the same size. currently, the largest common screen size is 1920 x 1080. having to scroll a page at that resolution to see necessary detail is annoying. if that means using more pages, go ahead. you can flip pages back and forth with a single button press in acrobat reader. flipping pages is preferable to panning a large drawing or dealing with outsized paper. i also find that one normal page at reasonable detail is a good size to show a subcircuit. think of pages in schematics like paragraphs in a narrative. breaking a schematic into individually labeled sections by pages can actually help readability if done right. for example, you might have a page for the power input section, the immediate microcontroller connections, the analog inputs, the h bridge drive power outputs, the ethernet interface, etc. it's actually useful to break up the schematic this way even if it had nothing to do with drawing size. here is a small section of a schematic i received. this is from a screenshot displaying a single page of the schematic maximized in acrobat reader on a 1920 x 1200 screen. in this case, i was being paid in part to look at this schematic so i put up with it, although i probably used more time and therefore charged the customer more money than if the schematic had been easier to work with. if this was from someone looking for free help like on this web the site, i would have thought


to myself screw this and gone on to answer someone else's question. label key nets schematic capture programs generally let you give nets nicely readable names. all nets probably have names inside the software, just that they default to some gobbledygook unless you explicitly set them. if a net is broken up into visually unconnected segments, then you absolutely have to let people know the two seemingly disconnected nets are really the same. different packages have different built - in ways to show that. use whatever works with the software you have, but in any case, give the net a name and show that name at each separately drawn segment. think of that as the lowest common denominator or using " air wires " in a schematic. if your software supports it and you think it helps with clarity, by all means, use little " jump point " markers or whatever. sometimes these even give you the sheet and coordinates of one or more corresponding jump points. that's all great but label any such net anyway. the important point is that the little name strings for these nets are derived automatically from the internal net name by the software. never draw them manually as arbitrary text that the software doesn't understand as the net name. if separate sections of the net ever get disconnected or separately renamed by accident, the software will automatically show this since the name shown comes from the actual net name, not something you type in separately. this is a lot like a variable in a computer language. you know that multiple uses of the variable symbol refer to the same variable. another good reason for net names is short comments. i sometimes name and then show the names of nets only to give a quick idea what the purpose of that net is. for example, seeing that a net is called " 5v " or " miso " could help a lot in understanding the circuit. many short nets don't need a name or clarification, and adding names would hurt more due to clutter than they would illuminate. again, the whole point is clarity. show a meaningful net name when it helps in understanding the circuit, and don't when it would be more distracting than useful. keep names reasonably short just because your software lets you enter 32 or 64 character net names, doesn't mean you should. again, the point is about clarity. no names is no information, but lots of long names are clutter, which then decreases clarity. somewhere in between is a good tradeoff. don't get silly and write


" 8 mhz clock to my pic ", when simply " clock ", " clk ", or " 8mhz " would convey the same information. see this ansi / ieee standard for recommended pin name abbreviations. upper case symbol names use all caps for net names and pin names. pin names are almost always shown upper case in datasheets and schematics. various schematic programs, eagle included, don't even allow for lower case names. one advantage of this, which is also helped when the names aren't too long, is that they stick out in the regular text. if you do write real comments in the schematic, always write them in mixed case but make sure to upper case symbol names to make it clear they are symbol names and not part of your narrative. for example, " the input signal test1 goes high to turn on q1, which resets the processor by driving mclr low. ". in this case, it is obvious that test1, q1, and mclr refer to names in the schematic and aren't part of the words you are using in the description. show decoupling caps by the part decoupling caps must be physically close to the part they are decoupling due to their purpose and basic physics. show them that way. sometimes i've seen schematics with a bunch of decoupling caps off in a corner. of course, these can be placed anywhere in the layout, but by placing them by their ic you at least show the intent of each cap. this makes it much easier to see that proper decoupling was at least thought about, more likely a mistake is caught in a design review, and more likely the cap actually ends up where intended when the layout is done. dots connect, crosses don't draw a dot at every junction. that's the convention. don't be lazy. any competent software will enforce this any way, but surprisingly we still see schematics without junction dots here occasionally. it's a rule. we don't care whether you think it's silly or not. that's how it's done. sort of related, try to keep junctions to ts, not 4 - way crosses. this isn't as hard a rule, but stuff happens. with two lines crossing, one vertical the other horizontal, the only way to know whether they are connected is whether the little junction dot is present. in past days when sc


##hematics were routinely photocopied or otherwise optically reproduced, junction dots could disappear after a few generations, or could sometimes even appear at crosses when they weren't there originally. this is less important now that schematics are generally in a computer, but it's not a bad idea to be extra careful. the way to do that is to never have a 4 - way junction. if two lines cross, then they are never connected, even if after some reproduction or compression artifacts it looks like there maybe is a dot there. ideally connections or crossovers would be unambiguous without junction dots, but in reality, you want as little chance of misunderstanding as possible. make all junctions ts with dots, and all crossing lines are therefore different nets without dots. look back and you can see the point of all these rules is to make it as easy as possible for someone else to understand the circuit from the schematic, and to maximize the chance that understanding is correct. good schematics show you the circuit. bad schematics make you decipher them. there is another human point to this too. a sloppy schematic shows lack of attention to detail and is irritating and insulting to anyone you ask to look at it. think about it. it says to others " your aggravation with this schematic isn't worth my time to clean it up " which is basically saying " i'm more important than you are ". that's not a smart thing to say in many cases, like when you are asking for free help here, showing your schematic to a customer, teacher, etc. neatness and presentation count. a lot. you are judged by your presentation quality every time you present something, whether you think that's how it should be or not. in most cases, people won't bother to tell you either. they'll just go on to answer a different question, not look for some good points that might make the grade one notch higher, or hire someone else, etc. when you give someone a sloppy schematic ( or any other sloppy work from you ), the first thing they're going to think is " what a jerk ". everything else they think of you and your work will be colored by that initial impression. don't be that loser.


this method has worked well for me ( but what works well for one person won't necessarily work well for everyone ). i take it in several passes : read 0 : don't read the book, read the wikipedia article or ask a friend what the subject is about. learn about the big questions asked in the subject, and the basics of the theorems that answer them. often the most important ideas are those that can be stated concisely, so you should be able to remember them once you are engaging the book. read 1 : let your eyes jump from definition to lemma to theorem without reading the proofs in between unless something grabs your attention or bothers you. if the book has exercises, see if you can do the first one of each chapter or section as you go. read 2 : read the book but this time read the proofs. but don't worry if you don't get all the details. if some logical jump doesn't make complete sense, feel free to ignore it at your discretion as long as you understand the overall flow of reasoning. read 3 : read through the lens of a skeptic. work through all of the proofs with a fine toothed comb, and ask yourself every question you think of. you should never have to ask yourself " why " you are proving what you are proving at this point, but you have a chance to get the details down. this approach is well suited to many math textbooks, which seem to be written to read well to people who already understand the subject. most of the " classic " textbooks are labeled as such because they are comprehensive or well organized, not because they present challenging abstract ideas well to the uninitiated. ( steps 1 - 3 are based on a three step heuristic method for writing proofs : convince yourself, convince a friend, convince a skeptic )


if you can assign the total electron geometry ( geometry of all electron domains, not just bonding domains ) on the central atom using vsepr, then you can always automatically assign hybridization. hybridization was invented to make quantum mechanical bonding theories work better with known empirical geometries. if you know one, then you always know the other. linear - $ \ ce { sp } $ - the hybridization of one $ \ ce { s } $ and one $ \ ce { p } $ orbital produce two hybrid orbitals oriented $ 180 ^ \ circ $ apart. trigonal planar - $ \ ce { sp ^ 2 } $ - the hybridization of one $ \ ce { s } $ and two $ \ ce { p } $ orbitals produce three hybrid orbitals oriented $ 120 ^ \ circ $ from each other all in the same plane. tetrahedral - $ \ ce { sp ^ 3 } $ - the hybridization of one $ \ ce { s } $ and three $ \ ce { p } $ orbitals produce four hybrid orbitals oriented toward the points of a regular tetrahedron, $ 109. 5 ^ \ circ $ apart. trigonal bipyramidal - $ \ ce { dsp ^ 3 } $ or $ \ ce { sp ^ 3d } $ - the hybridization of one $ \ ce { s } $, three $ \ ce { p } $, and one $ \ ce { d } $ orbitals produce five hybrid orbitals oriented in this weird shape : three equatorial hybrid orbitals oriented $ 120 ^ \ circ $ from each other all in the same plane and two axial orbitals oriented $ 180 ^ \ circ $ apart, orthogonal to the equatorial orbitals. octahedral - $ \ ce { d ^ 2sp ^ 3 } $ or $ \ ce { sp ^ 3d ^ 2 } $ - the hybridization of one $ \ ce { s } $, three $ \ ce { p } $, and two $ \ ce { d } $ orbitals produce six hybrid orbitals oriented toward the points of a regular octahedron $ 90 ^ \ circ $ apart. i assume you haven't learned any of the geometries above steric number 6 ( since they are rare ), but they each correspond to a specific hybridization also. $ \ ce { nh3 } $ for $ \ ce { nh3 } $, which category does it fit in above? remember to count the lone pair as


an electron domain for determining total electron geometry. since the sample question says $ \ ce { nh3 } $ is $ \ ce { sp ^ 3 } $, then $ \ ce { nh3 } $ must be tetrahedral. make sure you can figure out how $ \ ce { nh3 } $ has tetrahedral electron geometry. for $ \ ce { h2co } $ start by drawing the lewis structure. the least electronegative atom that is not a hydrogen goes in the center ( unless you have been given structural arrangement ). determine the number of electron domains on the central atom. determine the electron geometry using vsepr. correlate the geometry with the hybridization. practice until you can do this quickly.


the fundamental difference between discriminative models and generative models is : discriminative models learn the ( hard or soft ) boundary between classes generative models model the distribution of individual classes to answer your direct questions : svms ( support vector machines ) and dts ( decision trees ) are discriminative because they learn explicit boundaries between classes. svm is a maximal margin classifier, meaning that it learns a decision boundary that maximizes the distance between samples of the two classes, given a kernel. the distance between a sample and the learned decision boundary can be used to make the svm a " soft " classifier. dts learn the decision boundary by recursively partitioning the space in a manner that maximizes the information gain ( or another criterion ). it is possible to make a generative form of logistic regression in this manner. note that you are not using the full generative model to make classification decisions, though. there are a number of advantages generative models may offer, depending on the application. say you are dealing with non - stationary distributions, where the online test data may be generated by different underlying distributions than the training data. it is typically more straightforward to detect distribution changes and update a generative model accordingly than do this for a decision boundary in an svm, especially if the online updates need to be unsupervised. discriminative models also do not generally function for outlier detection, though generative models generally do. what's best for a specific application should, of course, be evaluated based on the application. ( this quote is convoluted, but this is what i think it's trying to say ) generative models are typically specified as probabilistic graphical models, which offer rich representations of the independence relations in the dataset. discriminative models do not offer such clear representations of relations between features and classes in the dataset. instead of using resources to fully model each class, they focus on richly modeling the boundary between classes. given the same amount of capacity ( say, bits in a computer program executing the model ), a discriminative model thus may yield more complex representations of this boundary than a generative model.


what we're seeing is arithmetic progressions ( not prime - producing polynomials ) of primes, combined with a classical phenomenon about rational approximations. when the integers ( or any subset of them ) are represented by the polar points $ ( n, n ) $, of course integers that are close to a multiple of $ 2 \ pi $ apart from each other will lie close to the same central ray. figuring out when integers are close to a multiple of $ 2 \ pi $ apart is a perfect job for continued fractions. the continued fraction of $ 2 \ pi $ is $ \ langle 6 ; 3, 1, 1, 7, 2, 146, \ dots \ rangle $, giving the convergents $ $ \ left \ { 6, \ frac { 19 } { 3 }, \ frac { 25 } { 4 }, \ frac { 44 } { 7 }, \ frac { 333 } { 53 }, \ frac { 710 } { 113 }, \ frac { 103993 } { 16551 }, \ dots \ right \ }, $ $ which are the rational approximations of $ 2 \ pi $ that will dominate the picture on different scales. for example, if you plot the polar points $ ( n, n ) $ for $ 1 \ le n \ le 25000 $, you will notice the points aligning themselves into $ 44 $ spirals : jumping ahead from $ n $ to $ n + 44 $ is almost the same as going around the circle $ 7 $ times ( note the convergent $ \ frac { 44 } 7 $ showing up ) ; moving from $ n $ to $ n + 1 $ jumps ahead $ 7 $ spirals. each spiral corresponds to an arithmetic progression $ a \ pmod { 44 } $ ; going from one spiral to the next one counterclockwise corresponding to changing the arithmetic progression from $ a \ pmod { 44 } $ to $ a + 19 \ pmod { 44 } $ ( note that $ 19 \ equiv7 ^ { - 1 } \ pmod { 44 } $ ). if instead you plot only the primes $ ( p, p ) $, you will get reasonable representation in the $ \ phi ( 44 ) = 20 $ spirals corresponding to arithmetic progressions $ a \ pmod { 44 } $ where $ \ gcd ( a, 44 ) = 1 $, and no primes in the other $ 24 $ spirals. that's


what we're seeing in the top two pictures. as the scale moves farther out, these particular spirals become more tightly wound and harder to see ( go from the 1st picture to the 5th, then the 3rd, then the 4th ), and the next convergent takes over. in this case, the convergent $ \ frac { 710 } { 113 } $ is an extremely good rational approximation to $ 2 \ pi $ ( as we know from the large partial quotient $ 146 $ ). therefore the integer points $ ( n, n ) $ will group themselves into $ 710 $ spirals, but these spirals are so close to straight lines at the beginning that they almost don't look like spirals, and persist for a large interval of possible scales. each ray thus corresponds to an arithmetic progression $ a \ pmod { 710 } $. when we plot only prime points $ ( p, p ) $ ( the 4th picture is best here ), we will only see the $ \ phi ( 710 ) = 280 $ arithmetic progressions $ a \ pmod { 710 } $ where $ \ gcd ( a, 710 ) = 1 $. the fact that the visible rays are mostly grouped in fours is a consequence of the fact that $ 5 \ mid710 $ and so every fifth ray doesn't contain primes. really, though, we are seeing four out of every ten rays rather than four out of every five ; the arithmetic progressions $ a \ pmod { 710 } $ with $ a $ even have no primes at all and are thus invisible. there are four exceptional groups containing only three rays instead of four ; these correspond to the four arithmetic progressions $ a \ pmod { 710 } $ where $ a $ is a multiple of $ 71 $ but not a multiple of $ 2 $ or $ 5 $.


i think the key will be whether or not libraries start being developed for julia. it's all well and good to see toy examples ( even if they are complicated toys ) showing that julia blows r out of the water at tasks r is bad at. but poorly done loops and hand coded algorithms are not why many of the people i know who use r use r. they use it because for nearly any statistical task under the sun, someone has written r code for it. r is both a programming language and a statistics package - at present julia is only the former. i think its possible to get there, but there are much more established languages ( python ) that still struggle with being usable statistical toolkits.


good question. if you look at the spectral energy distribution in the accepted answer here, we see that photons with wavelengths less than ~ 300 nm are absorbed by species such as ozone. much beyond 750 infrared radiation is largely absorbed by species such as water and carbon dioxide. therefore the vast majority of solar photons reaching the surface have wavelengths that lie between these two extremes. therefore, i would suggest that surface organisms will have adapted to use these wavelengths of light whether it be used in photoreceptors or in photosynthesis since these are the wavelengths available ; i. e., organisms have adapted to use these wavelengths of light, rather than these wavelengths being special per se ( although in the specific case of photosynthesis there is a photon energy sweet spot ). for example this study suggests that some fungi might actually be able to utilize ionizing radiation in metabolism. this suggests that hypothetical organisms on a world bathed in ionizing radiation may evolve mechanisms to utilize this energy.


no, it is not meaningful. 25 % is correct iff 50 % is correct, and 50 % is correct iff 25 % is correct, so it can be neither of those two ( because if both are correct, the only correct answer could be 75 % which is not even an option ). but it cannot be 0 % either, because then the correct answer would be 25 %. so none of the answers are correct, so the answer must be 0 %. but then it is 25 %. and so forth. it's a multiple - choice variant ( with bells and whistles ) of the classical liar paradox, which asks whether the statement this statement is false. is true or false. there are various more or less contrived " philosophical " attempts to resolve it, but by far the most common resolution is to deny that the statement means anything in the first place ; therefore it is also meaningless to ask for its truth value. edited much later to add : there's a variant of this puzzle that's very popular on the internet at the moment, in which answer option ( c ) is 60 % rather than 0 %. in this variant it is at least internally consistent to claim that all of the answers are wrong, and so the possibility of getting a right one by choosing randomly is 0 %. whether this actually resolves the variant puzzle is more a matter of taste and temperament than an objective mathematical question. it is not in general true for self - referencing questions that simply being internally consistent is enough for an answer to be unambiguously right ; otherwise the question is the correct answer to this question " yes "? would have two different " right " answers, because " yes " and " no " are both internally consistent. in the 60 % variant of the puzzle it is happens that the only internally consistent answer is " 0 % ", but even so one might, as a matter of caution, still deny that such reasoning by elimination is valid for self - referential statements at all. if one adopts this stance, one would still consider the 60 % variant meaningless. one rationale for taking this strict position would be that we don't want to accept reasoning by elimination on true or false? the great pumpkin exists. both of these statements are false. where the only internally consistent resolution is that the first statement is true and the second one is false. however, it appears to be unsound to conclude that the great pumpkin exists on the basis simply that the puzzle was posed. on the other hand


, it is difficult to argue that there is no possible principle that will cordon off the great pumpkin example as meaningless while still allowing the 60 % variant to be meaningful. in the end, though, these things are more matters of taste and philosophy than they are mathematics. in mathematics we generally prefer to play it safe and completely refuse to work with explicitly self - referential statements. this avoids the risk of paradox, and does not seem to hinder mathematical arguments about the things mathematicians are ordinarily interested in. so whatever one decides to do with the question - about - itself, what one does is not really mathematics.


i've written my own integrator, quadcc, which copes substantially better than the matlab integrators with singularities, and provides a more reliable error estimate. to use it for your problem, i did the following : > > lambda = 0. 00313 ; kappa = 0. 00825 ; nu = 0. 33 ; > > x = 10 ; > > e = @ ( r ) r. ^ 4. * ( lambda * sqrt ( kappa ^ 2 + r. ^ 2 ) ). ^ ( - nu - 5 / 2 ). * besselk ( - nu - 5 / 2, lambda * sqrt ( kappa ^ 2 + r. ^ 2 ) ) ; > > sincp = @ ( x ) cos ( x ). / x - sin ( x ). / x. ^ 2 ; > > f = @ ( r ) sincp ( x * r ). * r. * sqrt ( e ( r ) ) ; the function f is now your integrand. note that i've just assigned any old value to x. in order to integrate on an infinite domain, i apply a substitution of variables : > > g = @ ( x ) f ( tan ( pi / 2 * x ) ). * ( 1 + tan ( pi * x / 2 ). ^ 2 ) * pi / 2 ; i. e. integrating g from 0 to 1 should be the same as integrating f from 0 to $ \ infty $. different transforms may produce different quality results : mathematically all transforms should give the same result, but different transforms may produce smoother, or more easily integrable gs. i then call my own integrator, quadcc, which can deal with the nans on both ends : > > [ int, err, npoints ] = quadcc ( g, 0, 1, 1e - 6 ) int = - 1. 9552e + 06 err = 1. 6933e + 07 npoints = 20761 note that the error estimate is huge, i. e. quadcc doesn't have much confidence in the results. looking at the function, though, this is not surprising as it oscillates at values three orders of magnitude above the actual integral. again, using a different interval transform may produce better results. you may also want to look at more specific methods such as this. it's a bit more involved, but


definitely the right method for this type of problem.


2017 - 10 - 27 update [ note : my earlier notation - focused answer, unchanged, is below this update. ] yes. while having an octet of valence electrons creates an exceptionally deep energy minimum for most atoms, it is only a minimum, not a fundamental requirement. if there are sufficiently strong compensating energy factors, even atoms that strongly prefer octets can form stable compounds with more ( or less ) than the 8 valence shell electrons. however, the same bonding mechanisms that enable the formation of greater - than - 8 valence shells also enable alternative structural interpretations of such shells, depending mostly on whether such bonds are interpreted as ionic or covalent. manishearth's excellent answer explores this issue in much greater detail than i do here. sulfur hexafluoride, $ \ ce { sf6 } $, provides a delightful example of this ambiguity. as i described diagrammatically in my original answer, the central sulfur atom in $ \ ce { sf6 } $ can be interpreted as either : ( a ) a sulfur atom in which all 6 of its valence electrons have been fully ionized away by six fluorine atoms, or ( b ) a sulfur atom with a stable, highly symmetric 12 - electron valence shell that is both created and stabilized by six octahedrally located fluorine atoms, each of which covalently shares an electron pair with the central sulfur atom. while both of these interpretations are plausible from a purely structural perspective, the ionization interpretation has serious problems. the first and greatest problem is that fully ionizing all 6 of sulfur's valence electrons would require energy levels that are unrealistic ( " astronomical ” might be a more apt word ). a second issue is that the stability and clean octahedral symmetry of $ \ ce { sf6 } $ strongly suggest that the 12 electrons around the sulfur atom have reached a stable, well - defined energy minimum that is different from its usual octet structure. both points imply that the simpler and more energetically accurate interpretation of the sulfur valence shell in $ \ ce { sf6 } $ is that it has 12 electrons in a stable, non - octet configuration. notice also that for sulfur this 12 - electron stable energy minimum is unrelated to the larger numbers of valence - related electrons seen in transition element shells, since sulfur simply does not have enough electrons to access those more complex orbitals. the 12 electron valence shell of $ \ ce { sf6 } $ is instead a


true bending of the rules for an atom that in nearly all other circumstances prefers to have an octet of valence electrons. that is why my overall answer to this question is simply " yes ". question : why are octets special? the flip side of whether stable non - octet valence shells exist is this : why do octet shells provide an energy minimum that is so deep and universal that the entire periodic table is structured into rows that end ( except for helium ) with noble gases with octet valence shells? in a nutshell, the reason is that for any energy level above the special case of the $ n = 1 $ shell ( helium ), the " closed shell " orbital set $ \ { s, p _ x, p _ y, p _ z \ } $ is the only combination of orbitals whose angular momenta are ( a ) all mutually orthogonal, and ( b ) cover all such orthogonal possibilities for three - dimensional space. it is this unique orthogonal partitioning of angular momentum options in 3d space that makes the $ \ { s, p _ x, p _ y, p _ z \ } $ orbital octet both especially deep and relevant even in the highest energy shells. we see the physical evidence of this in the striking stability of the noble gases. the reason orthogonality of angular momentum states is so important at atomic scales is the pauli exclusion principle, which requires that every electron have its own unique state. having orthogonal angular momentum states provides a particularly clean and easy way to provide strong state separation between electron orbitals, and thus avoid the larger energy penalties imposed by pauli exclusion. pauli exclusion conversely makes incompletely orthogonal sets of orbitals substantially less attractive energetically. because they force more orbitals to share the same spherical space as the fully orthogonal $ p _ x $, $ p _ y $, and $ p _ d $ orbitals of the octet, the $ d $, $ f $, and higher orbitals are increasingly less orthogonal, and thus subject to increasing pauli exclusion energy penalties. a final note i may later add another addendum to explain angular momentum orthogonality in terms of classical, satellite - type circular orbits. if i do, i'll also add a bit of explanation as to why the $ p $ orbitals have such bizarrely different dumbell shapes. ( a hint : if you have ever watched people create two loops in a single skip rope, the equations behind such double loops have unexpected similarities to the equations behind $ p $ orbital


##s. ) original 2014 - ish answer ( unchanged ) this answer is intended to supplement manishearth's earlier answer, rather than compete with it. my objective is to show how octet rules can be helpful even for molecules that contain more than the usual complement of eight electrons in their valence shell. i call it donation notation, and it dates back to my high school days when none of the chemistry texts in my small - town library bothered to explain how those oxygen bonds worked in anions such as carbonate, chlorate, sulfate, nitrate, and phosphate. the idea behind this notation is simple. you begin with the electron dot notation, then add arrows that show whether and how other atoms are " borrowing " each electron. a dot with an arrow means that the electron " belongs " mainly to the atom at the base of the arrow, but is being used by another atom to help complete that atom's octet. a simple arrow without any dot indicates that the electron has effectively left the original atom. in that case, the electron is no longer attached to the arrow at all but is instead shown as an increase in the number of valence electrons in the atoms at the end of the arrow. here are examples using table salt ( ionic ) and oxygen ( covalent ) : notice that the ionic bond of $ \ ce { nacl } $ shows up simply as an arrow, indicating that it has " donated " its outermost electron and fallen back to its inner octet of electrons to satisfy its own completion priorities. ( such inner octets are never shown. ) covalent bonds happen when each atom contributes one electron to a bond. donation notation shows both electrons, so doubly bonded oxygen winds up with four arrows between the atoms. donation notation is not really needed for simple covalent bonds, however. it's intended more for showing how bonding works in anions. two closely related examples are calcium sulfate ( $ \ ce { caso4 } $, better known as gypsum ) and calcium sulfite ( $ \ ce { caso3 } $, a common food preservative ) : in these examples the calcium donates via a mostly ionic bond, so its contribution becomes a pair of arrows that donate two electrons to the core of the anion, completing the octet of the sulfur atom. the oxygen atoms then attach to the sulfur and " borrow " entire electrons pairs, without really contributing anything in return. this borrowing model is a major factor in why there can be more


than one anion for elements such as sulfur ( sulfates and sulfites ) and nitrogen ( nitrates and nitrites ). since the oxygen atoms are not needed for the central atom to establish a full octet, some of the pairs in the central octet can remain unattached. this results in less oxidized anions such as sulfites and nitrites. finally, a more ambiguous example is sulfur hexafluoride : the figure shows two options. should $ \ ce { sf6 } $ be modeled as if the sulfur is a metal that gives up all of its electrons to the hyper - aggressive fluorine atoms ( option a ), or as a case where the octet rule gives way to a weaker but still workable 12 - electron rule ( option b )? there is some controversy even today about how such cases should be handled. the donation notation shows how an octet perspective can still be applied to such cases, though it is never a good idea to rely on first - order approximation models for such extreme cases. 2014 - 04 - 04 update finally, if you are tired of dots and arrows and yearn for something closer to standard valence bond notation, these two equivalences come in handy : the upper straight - line equivalence is trivial since the resulting line is identical in appearance and meaning to the standard covalent bond of organic chemistry. the second u - bond notation is the novel one. i invented it out of frustration in high school back in the 1970s ( yes i'm that old ), but never did anything with it at the time. the main advantage of u - bond notation is that it lets you prototype and assess non - standard bonding relationships while using only standard atomic valences. as with the straight - line covalent bond, the line that forms the u - bond represents a single pair of electrons. however, in a u - bond, it is the atom at the bottom of the u that donates both electrons in the pair. that atom gets nothing out of the deal, so none of its bonding needs are changed or satisfied. this lack of bond completion is represented by the absence of any line ends on that side of the u - bond. the beggar atom at the top of the u gets to use both of the electrons for free, which in turn means that two of its valence - bond needs are met. notationally, this is reflected by the fact that both of the line ends of the u are next to that atom. taken as


a whole, the atom at the bottom of a u - bond is saying " i don't like it, but if you are that desperate for a pair of electrons, and if you promise to stay very close by, i'll let you latch onto a pair of electrons from my already - completed octet. " carbon monoxide with its baffling " why does carbon suddenly have a valence of two? " structure nicely demonstrates how u - bonds interpret such compounds in terms of more traditional bonding numbers : notice that two of carbon's four bonds are resolved by standard covalent bonds with oxygen, while the remaining two carbon bonds are resolved by the formation of a u - bond that lets the beggar carbon " share " one of the electron pairs from oxygen's already - full octet. carbon ends up with four - line ends, representing its four bonds, and oxygen ends up with two. both atoms thus have their standard bonding numbers satisfied. another more subtle insight from this figure is that since a u - bond represents a single pair of electrons, the combination of one u - bond and two traditional covalent bonds between the carbon and oxygen atoms involves a total of six electrons, and so should have similarities to the six - electron triple bond between two nitrogen atoms. this small prediction turns out to be correct : nitrogen and carbon monoxide molecules are in fact electron configuration homologs, one of the consequences of which is that they have nearly identical physical chemistry properties. below are a few more examples of how u - bond notation can make anions, noble gas compounds, and odd organic compounds seem a bit less mysterious :


both thawing and evaporation involve heat exchange between the stone tile, the water sitting atop the stone tile, any water that's been absorbed by the stone tile, and the air around. the basic reason that the center and the edges of the tile evaporate differently is that the gaps between the tiles change the way that heat is exchanged there. however the details of how that works are a little more involved than i can get into at the moment, and would be lost on a three - year - old anyway. a good way to explain this phenomenon to a three - year - old would be to bake a batch of brownies in a square pan, and watch how the brownies get done from the outside of the pan inwards. even after you have finished them you can still tell the difference between the super - crispy corner brownies, the medium - crispy edge brownies, and the gooey middle - of - the - pan brownies. the three - year - old would probably ask you to repeat this explanation many times. i think the shapes are not exactly circles, superellipses, or any other simple mathematical object - - - there's too much real life in the way - - - but they do become more circular as the remaining puddle gets further from the edges. a related explanation.


paper, especially when freshly cut, might appear to have smooth edges, but in reality, its edges are serrated ( i. e. having a jagged edge ), making it more like a saw than a smooth blade. this enables the paper to tear through the skin fairly easily. the jagged edges greatly reduce contact area, and causes the pressure applied to be rather high. thus, the skin can be easily punctured, and as the paper moves in a transverse direction, the jagged edge will tear the skin open. paper may bend easily, but it's very resistant to lateral compression ( along its surface ). try squeezing a few sheets of paper in a direction parallel to its surface ( preferably by placing them flat on a table and attempting to " compress " it laterally ), and you will see what i mean. this is analogous to cutting skin with a metal saw versus a rubber one. the paper is more like a metal one in this case. paper is rather stiff in short lengths, such as a single piece of paper jutting out from a stack ( which is what causes cuts a lot of the time ). most of the time, holding a single large piece of paper and pressing it against your skin won't do much more than bend the paper, but holding it such that only a small length is exposed will make it much harder to bend. the normal force from your skin and the downward force form what is known as a torque couple. there is a certain threshold torque before the paper gives way and bends instead. a shorter length of paper will have a shorter lever arm, which greatly increases the tolerance of the misalignment of the two forces. holding the paper at a longer length away decreases this threshold ( i. e. you have to press down much more precisely over the contact point for the paper to not bend ). this is also an important factor in determining whether the paper presses into your skin or simply bends. paper is made of cellulose short fibers / pulp, which are attached to each other through hydrogen bonding and possibly a finishing layer. when paper is bent or folded, fibers at the folding line separate and detach, making the paper much weaker. even if we unfold the folded paper, those detached fibers do not re - attach to each other as before, so the folding line remains as a mechanically weak region and decreasing its stiffness. this is why freshly made, unfolded paper is also more likely to cause cuts. lastly, whether a piece of paper cuts skin easily, of


course depends on its stiffness. this is why office paper is much more likely to cut you than toilet paper. the paper's density ( mass per unit area ), also known as grammage, has a direct influence on its stiffness.


there are two points relevant for the discussion : air itself carries a very small amount of thermal energy and it is a very poor thermal conductor. for the first point, i think it is interesting to consider the product $ \ text { density } \ times \ text { specific heat } $, that is the amount of energy per unit volume that can be transferred for every $ \ text { k } $ of temperature difference. as of order of magnitudes, the specific heat is roughly comparable, but the density of air is $ 10 ^ 3 $ times smaller than the density of a common metal ; this means that for a given volume there are much less " molecules " of air that can store thermal energy than in a solid metal, and hence air has much less thermal energy and it is not enough to cause you a dangerous rise of the temperature. the rate at which energy is transferred to your hand, that is the flow of heat from the other objects ( air included ) to your hand. in the same amount of time and exposed surface, touching air or a solid object causes you get a very different amount of energy transferred to you. the relevant quantity to consider is thermal conductivity, that is the energy transferred per unit time, surface and temperature difference. i added this to give more visibility to his comment ; my original answer follows. air is a very poor conductor of heat, the reason being the fact that the molecules are less concentrated and less interacting with each other, as you conjectured ( this is not very precise, but in general situations this way of thinking works ). on the opposite, solids are in general better conductors : this is the reason why you should not touch anything inside the oven. considering order of magnitudes, according to wikipedia, air has a thermal conductivity $ \ lesssim 10 ^ { - 1 } \ \ text { w / ( m k ) } $, whereas for metals is higher at least of two orders of magnitude. i really thank zephyr and chemical engineer for the insight that they brought to my original answer, that was much poorer but got an unexpected fame.


ok, here's my favorite. i thought of this after reading a proof from the book " proofs from the book " by aigner & ziegler, but later i found more or less the same proof as mine in a paper published a few years earlier by josef hofbauer. on robin's list, the proof most similar to this is number 9 ( edit :... which is actually the proof that i read in aigner & ziegler ). when $ 0 < x < \ pi / 2 $ we have $ 0 < \ sin x < x < \ tan x $ and thus $ $ \ frac { 1 } { \ tan ^ 2 x } < \ frac { 1 } { x ^ 2 } < \ frac { 1 } { \ sin ^ 2 x }. $ $ note that $ 1 / \ tan ^ 2 x = 1 / \ sin ^ 2 x - 1 $. split the interval $ ( 0, \ pi / 2 ) $ into $ 2 ^ n $ equal parts, and sum the inequality over the ( inner ) " gridpoints " $ x _ k = ( \ pi / 2 ) \ cdot ( k / 2 ^ n ) $ : $ $ \ sum _ { k = 1 } ^ { 2 ^ n - 1 } \ frac { 1 } { \ sin ^ 2 x _ k } - \ sum _ { k = 1 } ^ { 2 ^ n - 1 } 1 < \ sum _ { k = 1 } ^ { 2 ^ n - 1 } \ frac { 1 } { x _ k ^ 2 } < \ sum _ { k = 1 } ^ { 2 ^ n - 1 } \ frac { 1 } { \ sin ^ 2 x _ k }. $ $ denoting the sum on the right - hand side by $ s _ n $, we can write this as $ $ s _ n - ( 2 ^ n - 1 ) < \ sum _ { k = 1 } ^ { 2 ^ n - 1 } \ left ( \ frac { 2 \ cdot 2 ^ n } { \ pi } \ right ) ^ 2 \ frac { 1 } { k ^ 2 } < s _ n. $ $ although $ s _ n $ looks like a complicated sum, it can actually be computed fairly easily. to begin with, $ $ \ frac { 1 } { \ sin ^ 2 x } + \ frac { 1 } { \ sin ^


2 ( \ frac { \ pi } { 2 } - x ) } = \ frac { \ cos ^ 2 x + \ sin ^ 2 x } { \ cos ^ 2 x \ cdot \ sin ^ 2 x } = \ frac { 4 } { \ sin ^ 2 2x }. $ $ therefore, if we pair up the terms in the sum $ s _ n $ except the midpoint $ \ pi / 4 $ ( take the point $ x _ k $ in the left half of the interval $ ( 0, \ pi / 2 ) $ together with the point $ \ pi / 2 - x _ k $ in the right half ) we get 4 times a sum of the same form, but taking twice as big steps so that we only sum over every other gridpoint ; that is, over those gridpoints that correspond to splitting the interval into $ 2 ^ { n - 1 } $ parts. and the midpoint $ \ pi / 4 $ contributes with $ 1 / \ sin ^ 2 ( \ pi / 4 ) = 2 $ to the sum. in short, $ $ s _ n = 4 s _ { n - 1 } + 2. $ $ since $ s _ 1 = 2 $, the solution of this recurrence is $ $ s _ n = \ frac { 2 ( 4 ^ n - 1 ) } { 3 }. $ $ ( for example like this : the particular ( constant ) solution $ ( s _ p ) _ n = - 2 / 3 $ plus the general solution to the homogeneous equation $ ( s _ h ) _ n = a \ cdot 4 ^ n $, with the constant $ a $ determined by the initial condition $ s _ 1 = ( s _ p ) _ 1 + ( s _ h ) _ 1 = 2 $. ) we now have $ $ \ frac { 2 ( 4 ^ n - 1 ) } { 3 } - ( 2 ^ n - 1 ) \ leq \ frac { 4 ^ { n + 1 } } { \ pi ^ 2 } \ sum _ { k = 1 } ^ { 2 ^ n - 1 } \ frac { 1 } { k ^ 2 } \ leq \ frac { 2 ( 4 ^ n - 1 ) } { 3 }. $ $ multiply by $ \ pi ^ 2 / 4 ^ { n + 1 } $ and let $ n \ to \ infty $. this squeezes the partial sums between two


sequences both tending to $ \ pi ^ 2 / 6 $. voila!