np.zeros(shape=(n_rows, n_cols))
np.ones(shape=(n_rows, n_cols))

While this works for some cases, in many others we want the elements of the array to be diverse rather than repeating. At this point hardly anyone thinks about creating a magic square! They do satisfy the diversity criteria, but numpy natively does not have methods to create magic squares. So we will skip them! The popular choice is random numbers. Numpy has a whole bunch of methods to create random numbers. https://docs.scipy.org/doc/numpy-1.13.0/reference/routines.random.html lists all the methods numpy.random has and they are sufficient for almost all our needs. Numpy has a good collection of simple methods for generating random numbers - rand, random, ranf, randnetc. The problem with these is the non intuitive names and the overlap of features provided by these functions.

Here are the confusions introduced be these functions:

• When you have a tuple/list for size everywhere in numpy, why not for rand?

rand(d0, d1, ..., dn) #Random values in a given shape.

• Can’t randn be named as rand_normal?

randn(d0, d1, ..., dn) 
#Return a sample (or samples) from the “standard normal” distribution 

• random, randf and sample provide the same functionality as random_sample

random_sample([size]) #Return random floats in the half-open interval [0.0, 1.0)
random([size]) #Return random floats in the half-open interval [0.0, 1.0)
ranf([size]) #Return random floats in the half-open interval [0.0, 1.0)
sample([size]) #Return random floats in the half-open interval [0.0, 1.0)

The functions for distributions do not suffer from this problem. But they are less frequently used. Almost every code you see, that needs a random number, has np.random.rand() or np.random.random(). They do the same thing - pick numbers in [0.0,1.0) uniformly. So does np.random.ranf().

np.random.seed(100); np.random.rand(7)
# array([ 0.54340494,  0.27836939,  0.42451759,  0.84477613,  0.00471886, 0.12156912,  0.67074908])
np.random.seed(100); np.random.random(7)
# array([ 0.54340494,  0.27836939,  0.42451759,  0.84477613,  0.00471886, 0.12156912,  0.67074908])
np.random.seed(100); np.random.ranf(7)
# array([ 0.54340494,  0.27836939,  0.42451759,  0.84477613,  0.00471886, 0.12156912,  0.67074908])

Would it not be easier to use np.random.uniform(size=(7)) instead? Though it has little more typing to do, it is easier to understand and explicitly tells how the random number is generated. To generate numbers in a range other than [0.0, 1.0)- say [2,5)- using rand or random methods you would have to resort to (5-2)*np.random.random()+2. Using uniform you can achieve it as np.random.uniform(2,5,7). It is better to forgo the convenient, obscure simple random number functions and use the actual distribution functions themselves.

The 80/20 rule (Pareto Principle) in action

Remember the 80/20 rule? It says that approximately 80% of the results come from just 20% of the total effort, i.e. a few actions provide disproportionate gains. It does apply here. Three easy distribution functions in numpy will cover the majority of your random number needs.

The Pareto principle (also known as the 80/20 rule, the law of the vital few, or the principle of factor sparsity) states that, for many events, roughly 80% of the effects come from 20% of the causes

The most common distributions we encounter are uniform or normal distributions.

1. Uniform distribution

Uniform distribution captures the idea that all are equal — every number in a given range have the same chance (probability) of appearing in the result.

np.random(low=0.0, high=1.0, size=None)
# range in which the random number need to fall is [low, high)

Some examples:

• 5 uniformly distributed numbers in range [0.0,1.0) (i.e. emulating functionality of rand or random or ranf methods)

np.random.uniform(size=5)

• 2x3 uniformly distributed numbers in the range [a, b)

np.random.uniform(a, b, (2,3))
#np.random.uniform(low=a, high=b, size=(2,3))

• 2x3 uniformly distributed integers numbers in the range [a, b)

np.random.uniform(a, b, (2,3)).astype(np.int32)
#np.random.uniform(low=a, high=b, size=(2,3)).astype(np.int32)

2 . Normal distribution (Bell Curve/Gaussian Distribution)

Normal distribution enables a way of picking numbers (mostly) from a bell shaped region. The shape of the bell is determined by the standard deviation (which directly controls the width of the bell shape and inversely controls the height of the bell). The position of the center of the base of the bell is determined by the mean. This is a simplistic definition to aid visualization of the curve.

Normal distribution with mean=0 and standard deviation=1 is called Standard Normal distribution.

p.random.normal(loc=mean, scale=standard_deviation, size=None)
#loc and scale specify the mean and standard deviation values used to describe a normal distribution

Some examples:

• 5 standard normal distributed numbers

np.random.normal(size=5)

2x3 numbers from the normal distribution with mean=70, and standard deviation=4

np.random.normal(70,4,(2,3))
#np.random.normal(loc=70, scale=4, size=(2,3))

2x3 integers from the normal distribution with mean=70, and standard deviation=4

np.random.normal(70,4,(2,3))astype(np.int32)
#np.random.normal(loc=70, scale=4, size=(2,3))astype(np.int32)

3 . Binomial Distribution

If we toss a fair coin many many times, we get equal number of heads and tails. What if the coin is not fair and tends to land on one side more than other, the final outcome is biased to the side that has a higher chance. The results in these two situations follow the binomial distribution.

In probability theory and statistics, the binomial distribution with parameters n and p is the discrete probability distribution of the number of successes in a sequence of n independent experiments, each asking a yes–no question, and each with its own boolean-valued outcome: a random variable containing single bit of information: success/yes/true/one (with probability p) or failure/no/false/zero (with probability q = 1 − p). A single success/failure experiment is also called a Bernoulli trial or Bernoulli experiment and a sequence of outcomes is called a Bernoulli process; for a single trial, i.e., n = 1, the binomial distribution is a Bernoulli distribution.

np.random.binomial(n=number_of_tosses, p=probability_of_landing_on_head, size=None)

Some examples:

• Toss a fair coin 20 times and repeat this experiment 5 times

np.random.binomial(20, 0.5, size=5)
  #np.random.binomial(n=20, p=0.5, size=5)

2x3 numbers from a binomial distribution after 1000 trails(tosses) and probability of success is 0.8

np.random.binomial(1000, 0.8, size=(2,3))
#np.random.binomial(n=1000, p=0.8, size=(2,3))

As the Pareto principle goes, these three distributions should take care of the majority of your random number needs.

It is easy to remember these three functions. I call these the BUN functions — Binomial, Unifrom and Normal. All the three have size as the common, optional, third argument which if not mentioned returns a single value. The first two arguments to each of these functions are the parameters for generating the distribution.

BUN(?, ?, size)

These functions have sensible defaults for the first and second arguments if nothing is specified:

• low=0.0 and high=1.0 for the uniform distribution (which explains np.random.uniform())
• loc(mean)=0.0 and scale(std)=1.0 for normal distributions which is a standard normal distribution (which also explains the result of np.random.normal())
• binomal needs the first two arguments to be specified as they no defaults though one could argue that n=100 and p=0.5 (100 tosses of a fair coin) could make decent defaults.

The idea is to arrange both the matrices in two of the XY-grid quadrants, and use a visual property in the other two quadrants to validate, and determine the shape of the output matrix.

First some conventions: Of the four quadrants in XY-grid, Q1 is top-right, Q2 is top-left, Q3 is bottom-left and Q4 is bottom-right, as shown below.

Now lets say we have to multiply matrices A and B. A has shape 2x3 and B is a 3x4 matrix. Below are the steps to setup the matrices in the grid and interpret the result.

1. Fit the first matrix, A in the corner of Q3 (at the origin).
2. Similarly, fit the second matrix B in the corner of Q1 (at the origin).

3. Now some visuals:
Imagine shafts of light originating from each of the four edges of these two matrices.
It will be like below for Matrix A and B:

4. Light shafts from these two matrices overlap at two places, in Q2 and Q4.
The overlapping sections are the rectangles in green (blue+yellow=green).

5. Our setup is done. Examining Q2 and Q4 we can determine if these two matrices can be multiplied, and if so, the shape of the output matrix.
Look at Q2. If the overlap region (shown in green below) is a square then these matrices can be multiplied. Else not.

6. If above check fails we know these matrices cannot be multiplied. If check succeeds, (i.e. multiplication is feasible) then look at the green overlap region in Q4. The shape of the overlap region is the shape of the output matrix. That’s it!

Examples

Lets walk through a few examples to make it concrete. For the following three examples we calculate A * B.

1. Let A be a 3x1 matrix (a column vector) and B be a 1x3 matrix (a row vector). Putting A in Q3, and B in Q1 we examine Q2. The overlap in Q2 is a square (1x1). So we can multiply A and B. And the output is a 3x3 matrix (green overlap region in Q4). This is called outer product.

2. Now, let A be a 1x4 matrix (row vector) and B a 4x1 matrix (column vector). The overlap in Q2 is a 4x4 square region. So multiplication is possible. The output (overlap size in Q4), is a 1x1 matrix. In other words, the output is a scalar. This matrix multiplication is the popular vector dot product/dot product.

3. Now lets try multiplying incompatible matrices. Let A be a 4x2 matrix and B a 4x5 matrix. In this case, the overlap region in Q2 is not a square (but a 4x2 rectangle). So, these matrices cannot be multiplied.

Note

If we need to do B * A instead of A * B, we normally would shift A to Q1 and B to Q3 and repeat the process. But, we can do that without changing the position of A and B - validate in Q4 and get output shape in Q2. Look for a square in Q4. If so, then overlap in Q2 has the output shape of B * A.
So, keeping A and B fixed in Q1 and Q3 respectively, we can visualize both A * B and B * A.

If the placement of A and B in Q1 and Q3 is uncomfortable for you, you can change it. In general, we place A and B in any diagonal quadrants (i.e. in the odd or even quadrants). We need to examine the other diagonal quadrant for validation and output shape. The quadrant horizontal to the second matrix should have a square overlap and the quadrant horizontal to the first matrix has the output shape. For A * B, A is the first and B is the second matrix. For B * A, B is the first and A is the second matrix.
For instance, if we place A in Q2 and B in Q4 and want to compute B * A, validation (square overlap) happens in Q1 (horizontal to Q2 where we have the second matrix, A) and output shape is visible in Q3 (horizontal to Q4 where we have the first matrix, B).

Back to the basics

All this time it was assumed you knew how to multiply two matrices. Well if you don’t know, here is how.

The figure above is the multiplication of A and B. We know that the output shape is 2x4. Lets call each of the 8 (2*4=8) small green (1x1) squares in Q4 a cell. Each cell in Q4 is the result of a vector dot product of a row vector and column vector (similar to Example 2). The value of cell at 1st row, 2nd column of Q4 is the vector dot product of 1st row of A (which is a row vector) and 2nd columnof B (which is a column vector). The value of cell at 2nd row, 4th column of Q4 is the vector dot product of 2nd row of A (a row vector) and 4th column of B (a column vector), as shown in figure below. In general, value of every cell in the output is the dot product of the corresponding row in A and corresponding column in B.

If we do this systematically, the first row of the output matrix is computed by the dot product of first row of A with each of the columns of B. Do the same for the second row of output matrix same as above, but using the second row of A instead of the first row. Repeat this till the the last row of A. Now you have multiplied matrices A and B.

Matrix multiplication can be interpreted as the (vector) dot product of every row in the first matrix with every column in in the second matrix.

As a fun exercise you can infer some properties of matrix multiplication using this representation.

This is a useful rule. But, a general rule of thumb that estimates the time required to convert an amount P into X*P would be better. In this article we will learn to do that.

PROBLEM

Say, we need to convert 50,000 $ to 1,000,000 $ at 8 % p.a. How many years will that take? Our goal here is to be able to solve this problem in our head (easily).

SOLUTION

First we will use our knowledge of Rule of 72, to get a rough estimate. Then we will use a clever trick to solve the problem in an elegant manner. Finally, we will use the concept of approximation to make the elegant solution feasible to be computed in our heads without the need for a calculator.

1. Use Rule of 72 to get a rough estimate

1,000,000 is 20 times 50,000.

We know that the amount will double in 72/8=9 years. At the end of 9 years, the amount is 100,000. Crossing 18 (2*9) years it becomes 200,000 = 22 * (50,000). After 27 (3*9) years, it becomes 400,000 = 23 * (50,000).

Notice the pattern that after n*9 years the total amount is 2n * (50,000). We know that 20 lies between 24 (16) and 25 (32). In 9*4 years our amount grows to 800,000 (24*50,000=16*50,000) and in 9*5 years our amount grows to 1,600,000 (25*50,000=32*50,000). 1,00,000 falls in between 800,000 and 1,600,000. So the time it takes to get a million dollars will be anywhere between 36 (9*4) and 45 (9*5) years.

To get a more accurate estimate we can use simple interest calculation. The Simple Interest for 800,000 is 64,000 (0.08 * 800,000) . Thrice the Simple Interest is approximately 200,000(196,000 exactly). Compound interest for this three years will be more than Simple Interest as the interest earns interest while compounding. So we get a million in 36+3 years approximately.

The exact value after 39 years is 1,005,764.88 (which can be calculated here ). We need to be careful of this small difference of 5764.88 $(1,005,764.88-1,00,000). It will grow to a large amount when compounding for more years due to exponential nature of compounding. That aside, the problem with this approach is that the estimated 36-45 years has a range/gap of 11 years. This gap widens as the rate of interest gets smaller. And calculating Simple Interest leads to larger errors when this range grows. We need a better solution that can reduce this range/gap and one which does not resort to calculation of Simple Interest.

2. An elegant solution

Just as we have a rule to double our money, we also have a rule to triple our money. It takes 110/ryears to triple. To make our money 4 times initial, it takes 139/r years. To make it 5 times it takes 161/r years and so on ... to make it 20 times it takes 300/r years. We need to remember 20 rules to be able to estimate the number of years for multiplying our principal for up to 20 times. To calculate for a multiple of up to 100 times, we should remember 100 such rules. Remembering so many numbers is a challenge for many. Luckily, there is a neat mathematical trick that eases the load on our memory.

We all have learnt in school that any positive number can be written as a product of just prime numbers. Yes. It is called the Fundamental theorem of Arithmetic. Take out a paper and work it out. For example 20=22*5, 53=53 (it is a prime number), 45=33*5.

Here are rules for the first 15 prime numbers, which we will be referencing shortly. Just these 15 prime numbers can be used to represent any integer from 1 to 50.

We use the above knowledge to solve our problem as below:

1. Represent the multiplier X (20 in our problem) as a product of its primes.
   20=22*5=22*51.
2. The prime factors of X will be of the form primen. Using the table above apply the corresponding rule and find the number of years, y. Multiply y with n.
3. Repeat Step 2. for all the prime factors.
4. Sum up all the years from above. This is the result we need.

Now, lets apply the steps to our problem.

1. The desired/final amount (1,000,000) is 20 times the initial/principal amount (50,000).20=22*51.
2. For factor 22, we apply Rule of 72, and multiply the result by 2. 72/8=9 and 9*2=18 years.
3. We repeat it for 51.For factor 51, we apply Rule of 161, and multiply the result by 1.161/8=20(approx) and 20*1=20 years.
4. So our answer is 18+20=38 years.The accurate answer is a touch below 39 years.

I prefer to look at the above procedure this way:
Multiplier, X=(prime1)a * (prime2)b * (prime3)c * ...
becomes
Required years, Y=(Rule for prime1) * a + (Rule for prime2) * b +(Rule for prime3) * c + ...

3. The faster solution

The above solution is quite accurate. But then there is the problem of remembering 15 rules for multipliers till 50 (as we need 15 prime numbers to represent any integer from 1 to 50). We can forego a bit of accuracy by using an approximation trick. The trick is to approximate the multiplier (X) using a small set of prime factors, rather than all. We will try to approximate any X as a product of prime factors 2,3,5, and 7; 53 as approximately 56 (23*7=56), 29 as 30 (21*31*51=30) and so on. Now we need to remember only 4 rules ( Rule of 72, Rule of 110, Rule of 161 and Rule of 195) to get a good approximation.

Lets quickly work through another problem using this method.

Problem: Years to make 2,650,000 $ from 50,000 $ at 6 % p.a. compounded annually.

Solution: 2,650,000 $ is 53 (2,650,000/50,000=53) times 50,000 $. Taking 56 as an approximation for 53 results in 56=23*7. Required years, Y=(Rule of 72) * 3 + (Rule of 195) * 1.Y=(72/6) * 3 + (195/6) * 1=12*3 + 32.5*1 = 68.5.

At the end of 68.5 years the actual value is 2,628,868.38 $, which is close to our desired value.

With little practise you should be able to work out the answer in your head. You will need just the four rules above.

Hadron lets people mine AI in their web browsers on phones and computers to enable incredibly powerful AI computations on a global scale. Hadron creates a distributed artificial intelligence supercomputer with unprecedented speed and blockchain cost efficiency while letting new users start mining in just seconds.

In this post lets understand the payment for mining and what measures are taken to ensure a fair distribution of reward.

This is the equation for Payment to a miner for completing an AI computation. The formula is from page 7 of the white paper. The powers of 1/d makes it a little non-intuitive to understand the equation. In the rest of this post I will break it down to understand what the formula does.

In the equation t is the AI task given for miners to solve, m is the miner, Q is Quorum, which collectively stands for all the miners performing the task, t. The payment for the miner, m is dependent on the stake, Stake(m) he/she has. Bid(t) is the amount that is bid in the market place for completing the task. Hadron has some operational costs, OperatingCost(t) for managing the task, t and it is deducted from the bid amount.

The amount Bid(t)-OperatingCost(t), which lets call balance, is shared between the miners. The question now is how much share of the balance miner gets paid? To say in a nutshell, the miners with more stake gets slightly larger fraction of the balance. We don’t want the miners with large stake to get almost all the balance. This is enforced by the 1/d in the formula.

To get a sense of how the 1/d affects the distribution of balance, lets imagine that a task, t is assigned two miners m1 and m2. Stake of m1 is 9 (Hadron tokens) and stake of m2 is 100 tokens. Let the bid amount be 1005 tokens and the operation cost is 5 tokens. So the balance will be 1005–5=1000 tokens, which will be shared between m1 and m2.

Now let us consider two scenarios:

Scenario 1:

Without damping — d=1, i.e. 1/d=1/1=1

• In this above figure, there are two pi charts. The first chart shows the reward/share in the balance for miners m1 and m2 if they have stake 9 and 100 respectively. m1 gets 83 tokens and m2 gets 917 tokens. The second pi chart shows the rewards for m1 and m2 if they have stake 9 and 10000 respectively. Here m1 gets 1 token, but m2 gets 999 tokens! We see that in the absence of damping factor (i.e. d=1), if a miner has a very very large Stake (10000 of m2 vs 9 of m1) he/she ends up taking up almost all the balance. This kind of situation does not provide an incentive for miners with small stake to mine.

Scenario 2:

With damping — d=2, i.e. 1/d=1/2

• In the above figure, the first pi chart shows the reward/share in the balance for miners m1 and m2 if they have stake 9 and 100 respectively. m1 gets 231 tokens and m2 gets 769 tokens. Notice that this pi chart is for the same situation as the pi chart in the first figure; the only difference is the existence of a damping factor here. m1 here gets more tokens for the same stake (9) i.e. 231 tokens in contrast to the 83 before. The second pi chart shows the rewards for m1 and m2 if they have stake 9 and 10000 respectively. Here m1 gets 29 token and m2 gets 971 tokens. Again contrast it with the second pi chart of the previous figure. Miner m1 gets 29 tokens here compared to 1 token in the case without damping factor. Hence, the damping factor can provide better returns for miners with small stakes without favoring the high stake miners very much.
• Also note that as the value of d becomes very large, every miner gets almost the same share in the balance irrespective of their stake.

For Hadron, the damping factor, d is greater than 1. It is not yet known what the exact value will be.

Hopefully now it is clear how the payment is calculated for miners and the important role damping factor plays in ensuring fair distribution of the balance.