Q:

JavaScript prototypes equivalance for functions

I am reading JavaScript: Good parts by Douglas Crockford. I came across this following useful trick.
Function.prototype.method = function (name, func) {
    if (!this.prototype[name]) {
        this.prototype[name] = func;
    }
};

Based on the above code snippet, what I understood is, as all functions are objects of Function and as the above function adds the 'method' method to prototype of Function, there will be a method method available on all functions.
var pfun = function(name){
    this.name = name;
};

Consider the following log statements
console.log(Function.prototype.isPrototypeOf(pfun));//true - Thats fine
console.log(pfun.prototype == Function.prototype);//false - why?

I couldn't understand why the above logs contradict each other.
Here pfun is a functions which has the method method available from its prototype. So I can call the following.
pfun.method("greet",function(){
      console.log(this.name);
});

Now as method method runs, it adds the greet method to pfun's prototype. If the above logs doesn't contradict each other, then greet method should be available to all functions. 
My question is, why the above logs are contradicting each other?

A:

isPrototypeOf checks to see if an object is referenced by the internal [[Prototype]] property of another object.
All ECMAScript native functions inherit from Function.prototype therefore:
Function.prototype.isPrototypeOf(pfun))

returns true.
Every native function created by the Function constructor has a default public prototype property that is a plain object (see ECMAScript §13.2 #16). So when you do:
pfun.prototype == Function.prototype

you are comparing this plain object to Function.prototype1, which are different objects.
This confusion is brought about in discussion because the public and private prototype properties are often only distinguished by the context in which the term is used. All native Functions have both, and only for the Function constructor are they the same object by default, i.e.
Object.getPrototypeOf(Function) === Function.prototype

returns true. This relationship can be established for other Objects, but it doesn't happen by default (and I can't think of an example or sensible reason to do it).
1 The Function.prototype object is a bit of an oddity. It has an internal [[Class]] value of "function" and is callable, so in that regard it's a function. However, its internal [[Prototype]] is Object.prototype, so it can probably be called an instance of Object. When called, it ignores all arguments and returns undefined.

