14:46 there is no limit to numbers(except the top most number is 255)

3:34 it's not entirely correct, you either had to exclude the numbers less or equal 1 from the possible values of x, or you had to say that m can be any integer (e.g. for x=1 if you said m=0, it would satisfy the inequality - it is the only m integer that does - but you said m has to be greater than 0, or if you take 0.15, the only m integer satisfying the statement, would be -1). It doesn't affect the proof btw, just it bugged me a bit.

Three comments (two short, one long): 1)I think you should've mentioned that the proof you are presenting is (a version of) a proof due to Pafnuty L'vovich Chebyshev, when he famously proved the Bertrand's postulate. (I see that in the description you quote Idris D. Mercer, who unfortunately doesn't quote Chebyshev either). 2)It was perhaps worth mentioning that the estimate you obtained is up to a constant coincides with the prime number theorem, so in a sense with this elementary argument we are already only a constant away from the truth. But, if you only want to show that the density goes to zero there is a much simpler proof that I will outline in the third part. 3)We begin with a lemma: product of ((p-1)/p) over all the primes is zero. Assume for now that the lemma is true and let's estimate pi(n). Since by the lemma the product is zero, we can find finitely many primes such that the product is less than eps/2, that is (p_1-1)/p_1 *(p_2-1)/p_2*...*(p_k-1)/p_k < \eps/2. What are the primes up to n? Well, first of all we might have all the p_m for 1<=m <= k, there are k of them. Let us denote the product p_1*p_2*...*p_k by S_k and write n = aS_k + b, 0 <= b < S_k. The last b numbers for all we know might all be primes, so we will add b < S_k to our count. What about the remaining numbers? We can split them into a groups of consecutive S_k numbers. I claim that there are at most aS_k*eps/2 <= n*eps/2 primes bigger than p_k among them. Indeed, if the number is prime and is bigger than p_k then it definitely can not be divisible by neither of p_1, p_2, ..., p_k. So, it must be coprime to S_k! Here we can either quote directly the Euler's totient function or do a simple argument with a Chinese remainder theorem, either way we will get that in each group there are at most (p_1-1)*(p_2-1)*...*(p_k-1) primes, so in total it is at most a*(p_1-1)*...*(p_k-1), which is equal to aS_k*(p_1-1)/p_1 *(p_2-1)/p_2...*(p_k-1)/p_k < aS_k*eps/2. So, the number of primes up to n is less than k + S + n*eps/2. If we take n bigger than 2(k+S)/eps, this will be less than n*eps. Since eps>0 is arbitrary we get that the desired limit is zero. It remains to prove the lemma. For this we will (again) call our good friend Euler. To show that some product is zero, it is the same as to show that the product of one over this is infinity. So, we consider the product p_k/(p_k-1) (astute readers might already notice the presence of the Riemann zeta function lurking in the background, although we don't need to directly quote it). we have x/(x-1) = 1 + x + x^2 + .... So, we have the product of such sums over all primes. And now by the unique factorization we will get that this is exactly equal to the sum of 1/n over all natural numbers n, which is a Harmonic series, that is famously divergent. The lemma is proved, and so is the result. I like this proof more mostly for two reasons: first, it somehow proves that there are not too many primes from the fact that there are not too few primes! If the primes were very rare then the product in the lemma would've been strictly positive. Second, it uses only number-theoretic tools, with links to more mainstream things like Euler's totient function and Riemann zeta function, which leads (admittedly very far down the line) to the full proof of the prime number theorem, unlike the proof you presented with the binomial coefficient, which is, while a nice trick, still a trick. So, I prefer the above proof for the pedagogical reasons. But, as I said in 2), your proof indeed gives a better quantitative bounds, only a constant away from the truth.

There is a better way, simply use ternary with digi {-1,0,1} instead of {0,1,2}. To write 2 in that system you write 1(-1).

Me looking real smart walking in an exam room knowing I can draw the chessboard on the test paper while my pockets are jingling with coins

This problem has existed ever since maths tests became Englsh comprehension tests.

23 Factors is right if you consider first is 365/365 or 1

This is the equivalent of a Mage book of arcane arts studies

i was looking for this exatly

would would we write positive numbers in ‘negative decimal’?

It’s easy just like for loop under for loop in cpp instead of checking 1st person with every other person only here we just repeat it with every other remaining person present in the room 🧐🫡

1:00 Somewhere between 7.021% and 44.5%, depending on interpretation. The first value is if the problems are independent and the given values are the probabilities of answering correctly; the second is if I assume that knowing a hard question means I know the easier ones and that if I don’t know the answer I guess. Other combinations of assumptions can give other values in between.

When you wrote for the first time 2i-1 i freaked out how you get imaginary here

judging by the sound bite of "neg-a-de-ci-mal" I believe you did not enjoy pronouncing it

Easyer formula ⬇️ !n=(n-1)^n-2 This works btw try it if you are wrong tell me 😎

I prefere negative value as digit. I met it only in balanced ternary with digits "+", "-" and "0" i would like to see some more complex balanced system for example balanced quinary with five digits where two would be positive and two negative.

"doom runs on everything" mf's learning chessboards are actually calculators

Just pick a finite number of digits for all time and use 9s complement

Just the other day i was wondering if Decimal had some weird equivalent to Binary's two's complement addition where you can add technically two positive numbers to do subtraction. I guess this is in no way an equivalent but interesting nonetheless

You stopped too early, should've taken this to it's logical conclusion with base 10i.

Phinary is still cooler

Pfft. I had a substitute that didn't know about this. They let me pull out my checkers board during a test. Yeah, I think it's safe to say I flunked that Calculus Exam B)

bro invented the slide rule in 1617

So how do you convert addition and subtraction into addition and subtraction using this board

If you do this on an exam you deserve to pass.

i always knew somehow sqrt(-1) was canada's fault....

I immediately visualize base +b as taking progressively finer steps in the same direction, being careful not to walk too far as to overstep. While base -b overshoots what it represents and corrects that by bouncing back and forth around it. It's a little fun to think of this dance on a number line.

I love the fact that he used the same copy pasted audio clip to say “negadecimal” every single time; I’m just imagining him saying it repeatedly into the mic and then strenuously listening to each to find which one sounds the least like a slur 😂😂

I'd like to suggest using the squares on the left edge of the board to represent 256, 512, etc.

You are pronouncing "binary" incorrectly.

And -10²=-100

Actually -10⁰=-1

I thought log without a base by default is base 10, while ln is base e

37:20 I don't think it is all that difficult using properties of inverse functions. Because the original exponential function has domain R, the range of the logarithm is R by definition of inverse functions. Because it is an inverse function, it must be a bijection from its domain to its range. Therefore it either is strictly decreasing or strictly increasing. Because the base is >1, the logarithm is strictly increasing to positive infinity in the limit.

Ngl you could have converted it to binary and done it in paper faster, but at that point you might as well just do it in base10. One step of newton’s method takes less time than this for the roots too 💀

niggadecimal is my new favorite number system

Tell me you don't know what a calculator is. I usually don't have to do math myself on a calculator.

😎 With a Go board it goes up to 2^19 524,288

X/ln(X) not log

Next you need to figure out how to remove that pesky . Symbol used to represent the negative powers of your base. When considering the powers of negative 10, those exponents are also written in negadecimal. Since -1 = 19(nd), 0.1 = 1×(10^-1) = 1x(10^19(nd)) = 10000000000000000000(nd'). Almost no thought has been put in here, so I'm sure that there are holes left to fill in to make this system work.

Bro y’all want to say it so bad lmao 😂

Gonna make a prediction: 0 before a number negates it.

20:41 wait is that why they call it a square?

19:08 With a little bit of trickery you can push everything in the grid up and to the left as you go along to fake having a bigger board squaring your precision, this lets you approximate the sqrt of 2 as 1.4125 on an 8*8 Checkers board. Best to just use Excel though and make a 64*64 board. This method works better as a fun challenge than a real way to calculate sqrt due to the problems I previously mentioned, it sugar coats the problem but doesn't actually give you a way to solve it, leaving you to reason with your own logic and not that of the algorithm itself. As a result, it also can't be used as a computer algorithm. Of course, it is possible to brute force it to work on a computer by always assuming that placing an extra two tokens is best then retracing your step each and every time this winds up failing.

how do you even think of this

Only took me a day to calculate sqrt this way for a sixty four bit number! Noticeable problems occur with very large numbers in that it does not immediately punish for failure and so you may have to go back several steps once you realize an error has occurred if not having to redo the whole thing. If you spend an extra two counters when you're not meant to then you will run out of counters before paying your debt, if you fail to spend the extra two counters when you are meant to then you will have an inaccurate result.

Oh yeah I remember how 9 times 6 equals 288

I tried making a binary version of this "negabinary" since i think binary is the best number system i = 0 l = 1 | ( using different symbols for a more digestible look ) the patterns you have to really remember for positive numbers is li, ll, ii, il and for negative il, ii, ll, li the order of positive numbers from one ( spaced out in pairs so you can see the pattern ) l l li l ll l ii l il l li li l li ll l li ii l li il l ll li l ll ll ... the order of negative numbers ( the pattern skips first two numbers since they start with 0 ) ll li l l il l l ii l l ll l l li l i il l i ii l i ll l i li l l il il l l il ii ... addition works the same as in the video, it’s just easier to "subtract the one" from the next digit, because there can only be two outcomes when you do that for example, 13 ( lllil ) -14 ( llilli ) l ll il+ ll il li ii ii ll ll ( -1 )

No thanks

'negadecimal'