Deeper than primes

[doronshadmi]

When it is all they've got, and they can cut and paste, then it appears so.

It is correct, cut and paste, but all what you get from it is only the cut n' paste.


I completed jsfisher's DS, taken from F (1,1,1,0,0,0,0,0) of 8x8 tree:

<A,A,A> < = = > (ABC,ABC,ABC)
<A,A,B> < = = > (ABC,ABC,AB)
<A,A,C> < = = > (ABC,ABC,AC)
<A,A,D> < = = > (ABC,ABC,BC)
<A,A,E> < = = > (ABC,ABC,A)
<A,A,F> < = = > (ABC,ABC,B)
<A,A,G> < = = > (ABC,ABC,C)
<A,A,H> < = = > (ABC,ABC)  
<B,B,A> < = = > (ABC,AB,AB)
<B,B,B> < = = > (ABC,AB,AC)
<B,B,C> < = = > (ABC,AB,BC)
<B,B,D> < = = > (ABC,AC,AC)
<B,B,E> < = = > (ABC,AC,BC)
<B,B,F> < = = > (ABC,BC,BC)
<B,B,G> < = = > (ABC,AB,A) 
<B,B,H> < = = > (ABC,AB,B) 
<C,C,A> < = = > (ABC,AB,C) 
<C,C,B> < = = > (ABC,AC,A) 
<C,C,C> < = = > (ABC,AC,B) 
<C,C,D> < = = > (ABC,AC,C) 
<C,C,E> < = = > (ABC,BC,A) 
<C,C,F> < = = > (ABC,BC,B) 
<C,C,G> < = = > (ABC,BC,C) 
<C,C,H> < = = > (ABC,AB)   
<D,D,A> < = = > (ABC,AC)   
<D,D,B> < = = > (ABC,BC)   
<D,D,C> < = = > (AB,AB,AB) 
<D,D,D> < = = > (AB,AB,AC) 
<D,D,E> < = = > (AB,AC,AC) 
<D,D,F> < = = > (AC,AC,AC) 
<D,D,G> < = = > (AB,AB,BC) 
<D,D,H> < = = > (AB,AC,BC) 
<E,E,A> < = = > (AB,BC,BC) 
<E,E,B> < = = > (AC,AC,BC) 
<E,E,C> < = = > (AC,BC,BC) 
<E,E,D> < = = > (BC,BC,BC) 
<E,E,E> < = = > (AB,AB,A)  
<E,E,F> < = = > (AB,AC,A)  
<E,E,G> < = = > (AB,BC,A)  
<E,E,H> < = = > (AC,AC,A)  
<F,F,A> < = = > (AC,BC,A)  
<F,F,B> < = = > (BC,BC,A)  
<F,F,C> < = = > (AB,AB,B)  
<F,F,D> < = = > (AB,AC,B)  
<F,F,E> < = = > (AB,BC,B)  
<F,F,F> < = = > (AC,AC,B)  
<F,F,G> < = = > (AC,BC,B)  
<F,F,H> < = = > (BC,BC,B)  
<G,G,A> < = = > (AB,AB,C)  
<G,G,B> < = = > (AB,AC,C)  
<G,G,C> < = = > (AB,BC,C)  
<G,G,D> < = = > (AC,AC,C)  
<G,G,E> < = = > (AC,BC,C)  
<G,G,F> < = = > (BC,BC,C)  
<G,G,G> < = = > (AB,AB)    
<G,G,H> < = = > (AB,AC)    
<H,H,A> < = = > (AB,BC)    
<H,H,B> < = = > (AC,AC)    
<H,H,C> < = = > (AC,BC)    
<H,H,D> < = = > (BC,BC)    
<H,H,E> < = = > (A,A,ABC)  
<H,H,F> < = = > (B,B,ABC)  
<H,H,G> < = = > (A,B,ABC)  
<H,H,H> < = = > (A,C,ABC)  
<A,B,C> < = = > (B,C,ABC)  
<A,B,D> < = = > (ABC,A)    
<A,B,E> < = = > (ABC,B)    
<A,B,F> < = = > (ABC,C)    
<A,B,G> < = = > (ABC)      
<A,B,H> < = = > (A,A,AB)   
<A,C,D> < = = > (A,A,AC)   
<A,C,E> < = = > (A,A,BC)   
<A,C,F> < = = > (B,B,AB)   
<A,C,G> < = = > (B,B,AC)   
<A,C,H> < = = > (B,B,BC)   
<A,D,E> < = = > (C,C,AB)   
<A,D,F> < = = > (C,C,AC)   
<A,D,G> < = = > (C,C,BC)   
<A,D,H> < = = > (A,B,AB)   
<A,E,F> < = = > (A,B,AC)   
<A,E,G> < = = > (A,B,BC)   
<A,E,H> < = = > (A,C,AB)   
<A,F,G> < = = > (A,C,AC)   
<A,F,H> < = = > (A,C,BC)   
<B,C,D> < = = > (B,C,AB)   
<B,C,E> < = = > (B,C,AC)   
<B,C,F> < = = > (B,C,BC)   
<B,C,G> < = = > (AB,A)     
<B,C,H> < = = > (AB,B)     
<B,D,E> < = = > (AB,C)     
<B,D,F> < = = > (AC,A)     
<B,D,G> < = = > (AC,B)     
<B,D,H> < = = > (AC,C)     
<B,E,F> < = = > (BC,A)     
<B,E,G> < = = > (BC,B)     
<B,E,H> < = = > (BC,C)     
<B,F,G> < = = > (AB)       
<B,F,H> < = = > (AC)       
<C,D,E> < = = > (BC)       
<C,D,F> < = = > (A,A,A)    
<C,D,G> < = = > (B,B,B)    
<C,D,H> < = = > (C,C,C)    
<C,E,F> < = = > (A,A,B)    
<C,E,G> < = = > (A,A,C)    
<C,E,H> < = = > (B,B,A)    
<C,F,G> < = = > (B,B,C)    
<C,F,H> < = = > (C,C,A)    
<D,F,H> < = = > (C,C,B)    
<A,G,H> < = = > (A,B,C)    
<B,G,H> < = = > (A,A)      
<C,G,H> < = = > (B,B)      
<D,G,H> < = = > (C,C)      
<E,G,H> < = = > (A,B)      
<F,G,H> < = = > (A,C)      
<E,F,G> < = = > (C,B)      
<D,E,F> < = = > (A)        
<E,G,B> < = = > (B)        
<E,G,C> < = = > (C)        
<E,G,D> < = = > ()

 

[jsfisher]

Here is the last fixed version of 3x3 tree ( I missed DS under F (2,2,2) , F (2,2,1) and F (2,2,0) ). But now there are less elements according to your method. Can you find them?

So, what you are saying is you can't tell if your presentation is right or wrong. That doesn't speak well for the importance of your kXk obsession.

Be that as it may, yes, I can find them.

 

[jsfisher]

[jsfisher,] But now there are less elements according to your method. Can you find them?

sympathic...But now there are less elements according to jsfisher's method. Can you find them?

Ladies and gentlemen, I give you the Pakleds.

 

[doronshadmi]

So, what you are saying is you can't tell if your presentation is right or wrong.

Not at all.

It says that we need a general formula, which helps us to know how many DS there are under a given k x k tree.

The results of this formula are used by an algorithm that actually draws each DS, by not ignore the Uncertainty/Redundancy that each DS represents.

--------------------

I think that you have found a beautiful method to calculate the amount of DS of smaller k x k tree by using a partial case of DS of a greater k x k tree.

Your general formula is based on the following:

1) It allows combinations with repetition (what I call Redundancy).

2) It calculates the number of (1) according to the number of <…> finite places and the number of finite distinct symbols, which their amount is greater than the number of <…> finite places.

For example: the parameters of your formula that are relevant to k x k tree of Uncertainty/Redundancy DS are:

P= The number of places in <…> (from 1 to n, where n is a natural number).

D= The number of distinct symbols (for example: (A,B,C,…)) that are used to represent the different degrees of Uncertainty/Redundancy of a given k x k tree, for example:

0x0 tree

F (0) = ()


1X1 tree

F (1) = (A)
F (0) = ()

Now your method is used like this:

You take some DS of 1x1 tree (where 1x1 tree is greater than 0x0 tree), called (A), that is the maxima of F (1) under 1x1 tree, and use it in order to define the amount of DS of 0x0 tree:

A < = = > ()

So D=1 if P=0

-------------------------------

Here is 2X2 tree:

(2,2) = (AB,AB)
(2,1) = (AB,A),(AB,B)
(2,0) = (AB)
(1,1) = (A,A),(B,B),(A,B)
(1,0) = (A),(B)
(0,0) = ()

Now you are taking some DS of 4x4 tree called (A,B,C,D), that is under F (1,1,1,1), and use it in order to define the amount of DS of 2x2 tree:

A < = = > (AB)
B < = = > (A)
C < = = > (B)
D < = = > ()

So, D=4

Then you are using 2 places (P=2) to define the combinations with repetition of 4 symbols, and by doing that you are using F (1,1,0,0) (which is a partial case under 4x4 tree) and show that this partial case has the same amount of 2x2 tree, as follows:

<A,A> < = = > (AB,AB)
<A,B> < = = > (AB,A)
<B,B> < = = > (AB,B)
<A,C> < = = > (AB)
<B,C> < = = > (A,A)
<C,C> < = = > (B,B)
<A,D> < = = > (A,B)
<B,D> < = = > (A)
<C,D> < = = > (B)
<D,D> < = = > ()

So, D=4 if P=2

-------------------------------

In a 3x3 tree you are using (A,B,C,D,E,F,G,H) that is a particular DS of F (1,1,1,1,1,1,1,1) under 8x8 tree.

A < = = > (ABC)
B < = = > (AB)
C < = = > (AC)
D < = = > (BC)
E < = = > (A)
F < = = > (B)
G < = = > (C)
H < = = > ()

So, D=8

Then you are using 3 places (P=3) to define the combinations with repetition of 8 symbols, and by doing that you are using F (1,1,1,0,0,0,0,0) that is a partial case under 8x8 tree, and show that this partial case has the same amount of the DS under 3x3 tree.


So, D=8 if P=3:

-------------------------------

In a 4x4 tree you are using (A,B,C,D,E,F,G,H,I,J,K,L,M,N,O,P) that is a particular DS of F (1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1) under 16x16 tree, where the DS that are used by you are under F (1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0) of 16x16 tree:

A < = = > (ABCD)
B < = = > (ABC)
C < = = > (ABD)
D < = = > (ACD)
E < = = > (BCD)
F < = = > (AB)
G < = = > (AC)
H < = = > (AD)
I < = = > (BC)
J < = = > (BD)
K < = = > (CD)
L < = = > (A)
M < = = > (B)
N < = = > (C)
O < = = > (D)
P < = = > ()

So, D=16 if P=4

-------------------------------

So, by using your method D=P^2 and in this case all we need is P value in order to define the amount of DS under a given kxk tree.

-------------------------------

But let us not forget these facts:

1) The results of your formula (that you did not write, yet) are used as a part of an algorithm that actually draws each DS, by not ignore the Uncertainty/Redundancy that each DS represents (and there is no Uncertainty under combinations with repetition, which is the core of your method).

2)

Your AB symbol behaves exactly as does my C symbol, but you can't see that, can you?

Your C symbol does not behave exactly as does my AB symbol, because AB is a symbol for Uncertainty and C is a symbol fo Certainty.

Certainty and Uncertainty are two different qualities that are not the same exactly as a point and a line are two qualities that are not the same, for example:

Uncertainty ≠ Certainty

Line ≠ Point

What you are doing is this:

Uncertainty < = = > Certainty

Line < = = > Point

But:

(Uncertainty < = = > Certainty) ≠ (Uncertainty ≠ Certainty)

(Line < = = > Point) ≠ (Line ≠ Point)

and you still do not get it.

3) Your beautiful method is technically right (as a part of an algorithm that defines the DS of k-Uncertainty x k-Redundancy tree), but it is conceptually wrong (it can't be used to undertand the complexity of a given k x k tree) because it uses F and DS of greater k x k tree in order to define the amount of DS of smaller k x k tree by ignoring uncertainty, which appears also in the greater k x k tree and so on ... ad infinitum.

It is conceptually wrong because your method is a partial case of k-Uncertainty x k-Redundancy mathematical universe, which ignores (there is no Uncertainty under combinations with repetition, which is the core of your method) the Uncertainty of that mathematical universe.


4) This lack of conceptual understanding of Uncertainty of k-Uncertainty x k-Redundancy tree prevents from you to understand k-Uncertainty x k-Redundancy tree (please also look at http://www.internationalskeptics.com/forums/showpost.php?p=5949657&postcount=9889).


5) Furthermore, even the algorithm (where your method is a part of it) that is used to draw the DS of a given of k-Uncertainty x k-Redundancy tree, is nothing but a serial-only tool that draws the DS, but it can't be used in order to understand the Complexity of a given k-Uncertainty x k-Redundancy tree, because this complexity is not less than both parallel/serial form (where each part of it is both local AND global case of it) which can't be understood by parallel-only or serial-only reasoning.


So by conceptually understanding Organic Numbers (and more generally, Organic Mathematics), our reasoning is expanded beyond parallel-only or serial-only reasoning.

 

[jsfisher]

Not at all.

It says that we need a general formula, which helps us to know how many DS there are under a given k x k tree.

The results of this formula are used by an algorithm that actually draws each DS, by not ignore the Uncertainty/Redundancy that each DS represents.

Nonsense. I have a perfectly serviceable algorithm that generates all the possibilities, and a no point does "the results of the formula" play a role.

I think that you have found a beautiful method to calculate the amount of DS of smaller k x k tree by using a partial case of DS of a greater k x k tree.

I see you are now trying your hand at flattery instead of insult. Let me know how that works for you. Be that as it may, you are still wrong and confused what it is and why it works.

...
Now your method is used like this:

You take some DS of 1x1 tree (where 1x1 tree is greater than 0x0 tree), called (A), that is the maxima of F (1) under 1x1 tree, and use it in order to define the amount of DS of 0x0 tree

So, you believe my algorithm/method/formula solves for the mXm by first solving for an nXn case, where n>m. I must have been very clever to have pulled that off.

 

[The Man]

The fact is that F (2,1) , (2,0) , (1,1) , (1,0) and (0,0) are frames under F (2,2) such that F (2,2) is the maxima which has the "room" for all the DS of the rest frames.

Again your F(2,2) only refers to the number of letters in each of your “elements”, just like any and all of your “frame” notations. That is the only “room” you are referring to, “room” for a maximum of two letters per “element”. As you clearly demonstrate below.

Let us look at 2x2 tree from its minimal frame to its maximal frame:

F (0,0) = () has only no-uncertainty x no-redundancy.

F (1,0) = (A),(B) have 0-uncertainty x 0-redundancy, and also a "room" for the DS of F (0,0).

F (1,1) = (A,A),(B,B) have 0-uncertainty x 1-redundancy, (A,B) has 0-uncertainty x 0-redundancy, and also a "room" for the DS of F (0,0) and F (1,0).

F (2,0) = (AB) has 1-uncertainty x 0-redundancy, and also a "room" for the DS of F (0,0) and F (1,0).

F (2,1) = (AB,A),(AB,B) have 1-uncertainty x 1-redundancy, and also a "room" for the DS of F (0,0) , F (1,0) and F (1,1).

F (2,2) = (AB,AB) has 2-uncertainty x 2-redundancy, and also a "room" for the DS of F (0,0) , F (1,0) , F (1,1) and F (2,1).

In this representation

I simply wrote only the DS that have the maximum Uncertainty/Redundancy under a given frame of 2x2 tree.

The example of 2x2 tree can be expanded to any k x k tree.

Once again you are simply and deliberately ignoring the (AB,AB) “redundancy”, the “redundancy” of your AB “uncertainty” to claim a maximum “Redundancy under a given frame of 2x2 tree” as 2 when again your “2x2” simply expresses ‘2 element’ maximum “x” ‘2 letters per element’ maximum.


Remember Doron

Definition 5: Redundancy is a duplication of certain or uncertain identities, with respect to a given tree.

For example (A,A) , (B,B) , (AB,AB)

The (AB,AB) “redundancy” was in fact given by you as an example of your “uncertain identities” “redundancy”.

 

[The Man]

Are cranks always so wordy with their nonsense?

Yes, because they get things right from the level of silence.

Demonstrably a level they simply can not remain in (silence or getting things right).

 

[doronshadmi]

So, you believe my algorithm/method/formula solves for the mXm by first solving for an nXn case, where n>m. I must have been very clever to have pulled that off.

You did not provide yet any formula.

This formula returns the amount of combinations with repetitions forms of P places, which includes P^2 distinct symbols.

If you provide that formula, it is a part of an algorithm that draws the DS of a given k-Uncertainty x k-Redundancy tree.

Again, even this algorithm (where your method is a part of it), which is used to draw the DS of a given of k-Uncertainty x k-Redundancy tree, is nothing but a serial-only tool that draws the DS, but it can't be used in order to understand the Complexity of a given k-Uncertainty x k-Redundancy tree, because this complexity is not less than both parallel/serial form (where each part of it is both local AND global case of it) which can't be understood by parallel-only or serial-only reasoning.

Again, by understanding Organic Numbers (and more generally, Organic Mathematics), our reasoning is expended beyond parallel-only or serial-only reasoning.

 

[jsfisher]

If you provide that formula, it is a part of an algorithm

Whether I provide the formula or not, it is not part of the construction algorithm.

 

[The Man]

You did not provide yet any formula.

This formula returns the amount of combinations with repetitions forms of P places, which includes P^2 distinct symbols.

If you provide that formula, it is a part of an algorithm that draws the DS of a given k-Uncertainty x k-Redundancy tree.

Again, even this algorithm (where your method is a part of it), which is used to draw the DS of a given of k-Uncertainty x k-Redundancy tree, is nothing but a serial-only tool that draws the DS, but it can't be used in order to understand the Complexity of a given k-Uncertainty x k-Redundancy tree, because this complexity is not less than both parallel/serial form (where each part of it is both local AND global case of it) which can't be understood by parallel-only or serial-only reasoning.

Again, by understanding Organic Numbers (and more generally, Organic Mathematics), our reasoning is expended beyond parallel-only or serial-only reasoning.

Actually Doron your reasoning has been for quite some time entirely confined to trying to rationalize your “Organic Numbers (and more generally, Organic Mathematics)” by any means possible. Again as demonstrated in your previous posts where you simply insist that more than one letter must be used to represent your “uncertainty”.

 

[doronshadmi]

Again your F(2,2) only refers to the number of letters in each of your “elements”, just like any and all of your “frame” notations. That is the only “room” you are referring to, “room” for a maximum of two letters per “element”. As you clearly demonstrate below.

Once again you are simply and deliberately ignoring the (AB,AB) “redundancy”, the “redundancy” of your AB “uncertainty” to claim a maximum “Redundancy under a given frame of 2x2 tree” as 2 when again your “2x2” simply expresses ‘2 element’ maximum “x” ‘2 letters per element’ maximum.

No, F(2,2) has a room for all the DS of a given 2-Uncertainty x 2-Redundancy tree, where the DS (AB,AB) has a room only under F(2,2).

You simply ignore the maxima/minima of a given k-Uncertainty x k-Redundancy tree.

Remember Doron

The (AB,AB) “redundancy” was in fact given by you as an example of your “uncertain identities” “redundancy”.

Again (AB,AB) has 0-Unceertantiy x 1-Redundancy, if it is taken only as a redundancy case, and 0-Unceertantiy x 1-Redundancy is defiantly under the maxima, which is 2-Unceertantiy x 2-Redundancy.

In other words, you still do not understand k-Uncertainty x k-Redundancy forms.

 

[doronshadmi]

Whether I provide the formula or not, it is not part of the construction algorithm.

Yes it is.

It provides the number of DS that are defined under a given k-Uncertainty x k-Redundancy tree, but it does not provide any information about the structures of the DS, which have also uncertain information that does not appear in your method (which uses only Redundant information).

 

[doronshadmi]

Again as demonstrated in your previous posts where you simply insist that more than one letter must be used to represent your “uncertainty”.

You can't use a single symbol to represent uncertainty, because the all idea of Uncertainty is based on the inability to know the distinct value of a given form.

You may define a 1-to-1 correspondence between distinct symbol and non-distinct form, for example:

Z < = = > AB

But Z ≠ AB because Z represents certainty and AB represents uncertainty.

In other words, (Z < = = > AB) ≠ (Z ≠ AB).

As long as you don't get it, you don't get ON or OM.

 

[The Man]

No, F(2,2) has a room for all the DS of a given 2-Uncertainty x 2-Redundancy tree, where the DS (AB,AB) has a room only under F(2,2).

You simply ignore the maxima/minima of a given k-Uncertainty x k-Redundancy tree.

No Doran you are simply ignoring one of your own specifically stated “redundancies” for
(AB,AB) in order to profess your imaginary “maxima/minima of a given k-Uncertainty x k-Redundancy tree.”

Again (AB,AB) has 0-Unceertantiy x 1-Redundancy, if it is taken only as a redundancy case, and 0-Unceertantiy x 1-Redundancy is defiantly under the maxima, which is 2-Unceertantiy x 2-Redundancy.

So now you are deliberately ignoring your “uncertainty” just as you were ignoring your own specifically stated example of “redundancy” in “uncertain identities” before.

“if it is taken only as a redundancy case”? Well that just wouldn’t be a given k-Uncertainty x k-Redundancy tree. Deliberately ignoring your own “Uncertainty” won’t help you Doron just as you deliberately ignoring your own expressly stated “Redundancy” in your “Uncertainty” didn’t.

In other words, you still do not understand k-Uncertainty x k-Redundancy forms.

In the same words that have been expressed throughout this thread Doron, you clearly demonstrate that you simply do not understand your own notion or what you want to represent with your notations.

 

[jsfisher]

Yes it is.

It provides the number of DS that are defined under a given k-Uncertainty x k-Redundancy tree, but it does not provide any information about the structure of DS, that have also uncertain information, that does not appear in your method (which uses only Redundant information).

Wrong on so many counts. It is quite the feat on your part, too, to be making so many wrongful statements with having seen neither the count formula nor the generation algorithm.

Do carry on, though.

 

[doronshadmi]

Wrong on so many counts. It is quite the feat on your part, too, to be making so many wrongful statements with having seen neither the count formula nor the generation algorithm.

Do carry on, though.

You are still missing the details of http://www.internationalskeptics.com/forums/showpost.php?p=5958767&postcount=9924 .

 

[jsfisher]

You are still missing the details of http://www.internationalskeptics.com/forums/showpost.php?p=5958767&postcount=9924 .

I missed no important detail in that post.

 

[The Man]

You can't use a single symbol to represent uncertainty, because the all idea of Uncertainty is based on the inability to know the distinct value of a given form.

It is done all the time Doron. Again that is the whole basis of a variable. The simple fact that your claim “You can't use a single symbol to represent uncertainty” is so undeniably wrong simply demonstrate that you don’t have any idea what you are talking about.

You may define a 1-to-1 correspondence between distinct symbol and non-distinct form, for example:

Z < = = > AB


But Z ≠ AB because Z represents certainty and AB represents uncertainty.

In other words, (Z < = = > AB) ≠ (Z ≠ AB).

So you’re just not certain that your “AB” represents your “uncertainty”? Once again Doron you are entirely preoccupied with the specific symbols themselves (“Z” or “AB”) and seem completely unable to conceptualize the abstract meaning. Hence your simple insistence that your “Uncertainty” must be represented as more than one symbol.

As long as you don't get it, you don't get ON or OM.

Again Doron you just “don't get ON or OM” or basic math for that matter.

 

[doronshadmi]

Again that is the whole basis of a variable.

By using a notation to represent variable or constant you are unable to distinguish between the different types of information.

For example: 2 can be amount or order, but it is also used as a distinction tool for uncertainty or redundancy.

This is exactly what Organic Numbers are, they have amount and distinction (uncertainty and redundancy) in a one framework (where order is based on amount and distinction).

Things are not changed if you are using a variable, because a variable is nothing but a certain notation that helps you to point on some data, but it does not provide you any information about the amount, order or distinction of that data.

So you’re just not certain that your “AB” represents your “uncertainty”?

Exactly the opposite, by using Z I have no idea what it represents (amount, order distinction) except the fact that Z is a certain notation.

On the contrary, AB is exactly an uncertain notation.

 

[doronshadmi]

I missed no important detail in that post.

You missed the understanding of it.

You little 2X2 collection, when stripped of all the nonsense you insist on adding, is nothing more than a set of unordered 2-tuples where each element of the pair is one of four symbols.

jsfisher, I can strip of all the nonsense you insist on adding when using unordered 2-tuples, by using a 1-tuple (0-Uncertainty x 0-Redundancy) where each element is one of ten symbols (which is, by the way, the particular case of F (1,0,0,0,0,0,0,0,0,0) under 10x10 tree):

<A> < = = > (AB,AB)
<B> < = = > (AB,A)
<C> < = = > (AB,B)
<D> < = = > (AB)
<E> < = = > (A,A)
<F> < = = > (B,B)
<G> < = = > (A,B)
<H> < = = > (A)
<I> < = = > (B)
<J> < = = > ()

for 2x2 tree, so?

In other word, by ignoring Uncertainty or Redundancy you are not dealing with k-Uncertainty x k-Redundancy trees.