Why is char** argv same as char* argv[]

Also an array most of the times decays to a pointer for example arr[0] is the same as (arr + 0)

arr[0] is evaluated like *( arr + 0 ) that is the same as *arr.

Function parameters having array types are adjusted by the compiler to pointers to the array element types.

On the other hand, an array used as an argument expression is implicitly converted to pointer to its first element.

So for example these function declarations

void f( char * s[100] );
void f( char * s[10] );
void f( char * s[] );

are equivalent and declare the same one function as

void f( char **s );

To make it clear just introduce a typedef name. For example

typedef char *T;

then you have

void f( T s[] );

So the function parameter is adjusted by the compiler to

void f( T *s );

Now change the typedef alias to its original type and you will get

void f( char * *s );

Pay attention to that the pointer s knows nothing how many elements the array has used as a function argument.

Thus for example the function main is declared like

int main( int argc, char *argv[] );

That is it has one more parameter argc that allows to determine the number of elements in the array of strings passed to the function. Though if to tell about main then in general the parameter argc is redundant because the array of strings always contains the sentinel value NULL. That is argv[argc] is equal to NULL.

But in general you have to pass also the number of elements in the array used as a function argument.

But how is **argv the same as *argv[] since **argv is a pointer to a pointer

Because, quoting n1570 6.7.6.3p7 (emphasis mine):

A declaration of a parameter as "array of type" shall be adjusted to "qualified pointer to type", where the type qualifiers (if any) are those specified within the [ and ] of the array type derivation. If the keyword static also appears within the [ and ] of the array type derivation, then for each call to the function, the value of the corresponding actual argument shall provide access to the first element of an array with at least as many elements as specified by the size expression.

Each element of char *argv[] has type char *, which is a pointer to a char.

So according to 6.7.6.3p7, an array of char * will be adjusted to a pointer to a char *; i.e. char *argv[] (an array of pointer to chars) will be adjusted to char **argv (pointer to a pointer to a char).

how can **argv contain 10 different values since it is a pointer to a pointer?

Because it doesn't. Just because it is a pointer to a pointer, doesn't make it different from any other pointer (Well, except that their size, representation, and alignment requirements may differ).

The diagram below will probably help you understand what is actually going on:

argv (points to the beginning of the array of pointer to chars.)
------------------+---------+---------+
    \             |         |         |
     \ argv[0]    |argv[1]  |argv[2]  | argv[3]
      \           |         |         |
       \          |         |         |
        V  char * V  char * V char *  V char *
        +---------+---------+---------+---------+
        |  0xf00  |  0xf0C  |  0xf13  |   NULL  |   (0xf0C and 0xf13 are the addresses of the first element of the strings passed as parameters to your program.)
        +---------+---------+---------+---------+
             |           |        |
             |           |        |
             |           |        |
             V           V        V
            "my_        "hello"  "world"            ("hello" and "world" are the parameters passed to your program.)
            program"

"**" simply refers to a pointer to a pointer. Array itself works as an pointer. Therefore we can say that int **argv == *argv[] = argv[][0].

char *argv[] translates to an array of strings

If you consider this snippet

char const *arr[] = {"one", "two", "three"};

arr is declared as an array of pointers to char and inititialized with an initializer list.

The C Standard (see e.g. the C11 draft at 6.7.6.2 Array declarators¹) says (emphasis mine):

₁ In addition to optional type qualifiers and the keyword static, the [ and ] may delimit an expression or *. If they delimit an expression (which specifies the size of an array), the expression shall have an integer type. If the expression is a constant expression, it shall have a value greater than zero. The element type shall not be an incomplete or function type.
[...]
₄ If the size is not present, the array type is an incomplete type.

Later, at 6.7.9 Initialization²:

₈ An initializer specifies the initial value stored in an object.
[...]
₂₂ If an array of unknown size is initialized, its size is determined by the largest indexed element with an explicit initializer. The array type is completed at the end of its initializer list.

The question is about argv, though, the second function parameter of the main function.

As noted in JASLP's answer, we need to look at 6.7.6.3 Function declarators³

₆ A parameter type list specifies the types of, and may declare identifiers for, the parameters of the function.
₇ A declaration of a parameter as "array of type" shall be adjusted to "qualified pointer to type", where the type qualifiers (if any) are those specified within the [ and ] of the array type derivation. If the keyword static also appears within the [ and ] of the array type derivation, then for each call to the function, the value of the corresponding actual argument shall provide access to the first element of an array with at least as many elements as specified by the size expression.

^{1) http://port70.net/%7Ensz/c/c11/n1570.html#6.7.6.2}

^{2) http://port70.net/%7Ensz/c/c11/n1570.html#6.7.9}

^{3)http://port70.net/%7Ensz/c/c11/n1570.html#6.7.6.3}

Array and Pointers in C Language hold a very strong relationship. Generally, pointers are the variables which contain the addresses of some other variables and with arrays a pointer stores the starting address of the array. Array name itself acts as a pointer to the first element of the array and also if a pointer variable stores the base address of an array then we can manipulate all the array elements using the pointer variable only.

Difference between pointer and array in C: https://www.geeksforgeeks.org/difference-pointer-array-c/