Deeper than primes

Status
Not open for further replies.
Complexity said:
When it is all they've got, and they can cut and paste, then it appears so.
Click to expand...
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:

Code: 
<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> < = = > ()
 
Last edited:
doronshadmi said:
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?
Click to expand...


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 said:
So, what you are saying is you can't tell if your presentation is right or wrong.
Click to expand...
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)
doronshadmi said:
jsfisher said:
Your AB symbol behaves exactly as does my C symbol, but you can't see that, can you?
Click to expand...
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.
Click to expand...


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.
 
Last edited:
doronshadmi said:
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.
Click to expand...

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.
Click to expand...

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
Click to expand...

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.
 
doronshadmi said:
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.
Click to expand...

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.

doronshadmi said:
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.
Click to expand...

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

doronshadmi said:
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)
Click to expand...

The (AB,AB) “redundancy” was in fact given by you as an example of your “uncertain identities” “redundancy”.
 
jsfisher said:
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.
Click to expand...

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.
 
doronshadmi said:
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.
Click to expand...

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”.
 
The Man said:
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.
Click to expand...
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.

The Man said:
Remember Doron

The (AB,AB) “redundancy” was in fact given by you as an example of your “uncertain identities” “redundancy”.
Click to expand...
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.
 
jsfisher said:
Whether I provide the formula or not, it is not part of the construction algorithm.
Click to expand...

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).
 
Last edited:
The Man said:
Again as demonstrated in your previous posts where you simply insist that more than one letter must be used to represent your “uncertainty”.
Click to expand...
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.
 
doronshadmi said:
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.
Click to expand...

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.”


doronshadmi said:
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.
Click to expand...

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.


doronshadmi said:
In other words, you still do not understand k-Uncertainty x k-Redundancy forms.
Click to expand...

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.
 
doronshadmi said:
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).
Click to expand...


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 said:
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.
Click to expand...

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.


doronshadmi said:
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).
Click to expand...

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.



doronshadmi said:
As long as you don't get it, you don't get ON or OM.
Click to expand...

Again Doron you just “don't get ON or OM” or basic math for that matter.
 
The Man said:
Again that is the whole basis of a variable.
Click to expand...

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.

The Man said:
So you’re just not certain that your “AB” represents your “uncertainty”?
Click to expand...
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.
 
Last edited:
jsfisher said:
I missed no important detail in that post.
Click to expand...

You missed the understanding of it.

jsfisher said:
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.
Click to expand...
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.
 
Last edited:
doronshadmi - It is quite apparent that jsfisher understands this better than you do.

You're having fun playing with a curiosity.

What is its value? Why should it be regarded as important?

Why the hell have you wasted nearly 10,000 posts on this fluff?
 
doronshadmi said:
Read the end of http://www.internationalskeptics.com/forums/showpost.php?p=5958767&postcount=9924 .
Click to expand...


No. Write a short explanation, no more than 100 words, no pictures.

Answer those questions to my satisfaction and I'll work to understand what you're up to. Otherwise, this is all an utter waste of time.

If you do attempt to answer those questions, please do so using fairly conventional English without any grandiose claims, without links, and without fog of any kind.

Clarity, brevity, and responsiveness will get your reply read.
 
Complexity said:
I never follow any of your links, doron.

See post #9941 for the reason.
Click to expand...

If you never follow any of my link (or in other words, ignore my posts) you can't conclude that:
Complexity said:
doronshadmi - It is quite apparent that jsfisher understands this better than you do.
Click to expand...

Maybe you mean that you understand jsfisher's posts better than my posts.
 
Last edited:
You may wonder where I get off making demands.

You have been obtuse and demanding for nearly 10,000 posts.

You obviously want to be understood and to have your work appreciated.

Join the club.

If you want intelligent readers who are prepared to work through the verbal thicket that you have erected around your work, you are going to have to meet us more than half-way.

I've given you my demands, and I'll add one more. Do not use any private jargon in your response to me. Only use words whose meanings can be looked up and found in dictionary.com.
 
doronshadmi said:
If you never follow any of my link (or in other words, ignore my posts) you can't conclude that:

Maybe you mean that you understand jsfisher's posts better than my posts.
Click to expand...


I've read many of your posts since rejoining the JREF community a few months ago.

I didn't (and won't) follow links in your posts. If you have a point to make, make it, don't simply point to a post that obviously didn't achieve communications in the past and is very unlikely to do so this time around.

I have an idea what this entire mess is about. jsfisher seems to have a good handle on it, if I'm not mistaken. He is also able to communicate about it well if he wants to invest the time and effort to do so.

As far as I can tell, your undertanding of your own work is patchy and your communication skills really suck.

If you want an informed readership, you're going to have to work a lot harder for it.
 
doronshadmi said:
You missed the understanding of it.
Click to expand...

Odd that you'd say that, since the rest of your post demonstrates you don't understand it.

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):
...
for 2x2 tree, so?
Click to expand...

Yep, you could do that. It wouldn't address the original question, though, now would it?

You keep forgetting what the original question was, don't you? It was a simple question of "how many." I showed that your question could be converted to another, equivalent question, a question for which there was a simple answer.

Answering your question yourself is something you continue to be unable to do. Your little excursion into self-deception and confusion, above, does not end up with the answer to the question; it starts with it. What good is that?

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

Never said I was. I was just answering your question, correctly, by the way.

I annoys you that those uncertain and redundant properties aren't significant to the question you posed, doesn't it?
 
I'm still waiting.


There are six responses:
  1. Explain, clearly and coherently and merciful brevity why your work is of important, of value, and worth someone's time.
  2. Do any of the above but not all of it.
  3. Emit fog and incoherent nonsense (i.e. none of it)
  4. Admit that it is important, etc., but that you don't know how to explain why
  5. Admit that it isn't important, etc.
  6. Do nothing, which is equivalent to 4 and/or 5 depending upon my whim
My whim is tired of this stuff and very inclined towards: 6 => 5

Hop to it.
 
doronshadmi said:
By using a notation to represent variable or constant you are unable to distinguish between the different types of information.
Click to expand...

"By using a notation to represent variable or constant" you (and I mean just you) may be "unable to distinguish between the different types of information" and I seriously doubt your inability has anything to do with the "notation". Guess what, your "AB" is a notation for your "uncertainty".

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

No it isn't since your "uncertainty or redundancy" still remain distinctly undefined.

doronshadmi said:
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).
Click to expand...

Again no they are not as your "uncertainty or redundancy" still remain distinctly undefined.

For your information Doron “amounts” (or numbers) are already ‘distinct’ from other “amounts” (or numbers) so they have “amount and distinction” already.

doronshadmi said:
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.
Click to expand...

Sure they are changed, a variable is useful while your notions are not. Again Doron try using some math and you will find that a vast amount of information can be obtained by using a variable, while you can’t even use or define your terms “distinction (uncertainty and redundancy)” in a self consistent fashion.

doronshadmi said:
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.
Click to expand...

Again what it represents is variable that is what makes it a, well, variable.

doronshadmi said:
On the contrary, AB is exactly an uncertain notation.
Click to expand...

On the contrary, your "AB" is just a notation that you ascribe to your “uncertainty” that you referred to as a “superposition” while claiming you “do not use” superposition. Again your primary uncertainty is simply about your own notions and somehow you think that must be imbued in your notations.
 
The man said:
On the contrary, your "AB" is just a notation that you ascribe to your “uncertainty” that you referred to as a “superposition” while claiming you “do not use” superposition.
Click to expand...

The Man "superposition" can't be defined among a single thing.

For example by taking AB as a single thing like Z variable = AB superposition, you actually look at a superposition as a certain or distinct thing.

By doing that you are loosing the superposition among more than a single thing, that is notated at least as AB.

Another failure of you is that you do not understand that (AB,AB) represents 0-Uncertainty x 1-Redundancy exactly because you ignore AB superposition and uncertainty (you take AB as a one thing, and there is no superposition among a one thing).

Another misunderstanding of you is derived from you inability to grasp that 2-Uncertanty x 2-Redundancy tree is a parallel/Serial form where all its DS are in simultaneous relations under the "room" of this tree.

All you get is the serial aspect of the DS under a given tree, exactly because by your method everything is based on a serial step-by-step reasoning of the observed.
 
jsfisher said:
I annoys you that those uncertain and redundant properties aren't significant to the question you posed, doesn't it?
Click to expand...
That is the whole idea here, jsfisher, "how many?" is a too weak question that can't answer to questions where Uncertainty and Redundancy are involved, simply because an exact amount (or sum, if you wish) can't deal with real Complexity, where in real Complexity Uncertainty and Redundancy are significant and not some "white noise" that has to be eliminated, in order to discover your partial case of distinct things.


You simply can't get http://www.internationalskeptics.com/forums/showpost.php?p=5958767&postcount=9924 post, for example, this part:
doronshadmi said:
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.
Click to expand...
 
Last edited:
Still waiting for you to fix your 3X3 presentation...or will you just leave that blundered and broken?
 
Still waiting, doron.

Explain, clearly, coherently, and with merciful brevity why your work is important, of value, and worth someone's time.

No links, personal jargon, or uses or words that aren't in accord with www.Dictionary.com.

The universe is waiting.
 
doronshadmi said:
The Man "superposition" can't be defined among a single thing.
Click to expand...

I expect your "superposition" simply can’t or won’t be defined by you in any self-consistent fashion. If you’re talking about actual superposition then that it just a linear addition of something with itself or something else. Even for quantum superposition (again based on the superposition principle) a single photon does interfere (a superposition of phase differences) with itself (see single photon double slit experiments)

doronshadmi said:
For example by taking AB as a single thing like Z variable = AB superposition, you actually look at a superposition as a certain or distinct thing.
Click to expand...

Again superposition is a certain distinct thing, a linear addition. Your “superposition” however, apparently even you do not know what that is and it simply appears to be you being uncertain about some value.

doronshadmi said:
By doing that you are loosing the superposition among more than a single thing, that is notated at least as AB.
Click to expand...

Your “superposition” is already lost Doron as it is just some way for you to say you are uncertain about some value. Apparently you just like to call that a “superposition”, I guess because you think it sounds important, perhaps you think others do not actually understand superposition and that it somehow brings a quantum aspect to your notions. Regardless, you claim that you “do not use” superposition in your “superposition” so the loss remains simply yours.

doronshadmi said:
Another failure of you is that you do not understand that (AB,AB) represents 0-Uncertainty x 1-Redundancy exactly because you ignore AB superposition and uncertainty (you take AB as a one thing, and there is no superposition among a one thing).
Click to expand...

Again, by your own assertions, there is no superposition in your “superposition”.

Your “direct perception” fails you again as do your own assertions.


doronshadmi said:
(2,2) = (AB,AB) has 2-uncertainty x 2-redundancy

<snip>
Form now on let us take this as the right expression of k-uncertainty x k-redundancy tree.
Click to expand...


doronshadmi said:
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).
Click to expand...


The ignorance and contradictions again remain simply yours.

doronshadmi said:
Another misunderstanding of you is derived from you inability to grasp that 2-Uncertanty x 2-Redundancy tree is a parallel/Serial form where all its DS are in simultaneous relations under the "room" of this tree.
Click to expand...

Ah your old “parallel/Serial form” claim that you apparently think mitigates you claiming whatever self-contradictory nonsense that comes to your mind as being some great insight.

doronshadmi said:
All you get is the serial aspect of the DS under a given tree, exactly because by your method everything is based on a serial step-by-step reasoning of the observed.
Click to expand...

Ah back to the old standard label again I see with your “serial step-by-step reasoning” ascription. What happen, did you get tired of your new labels, don’t feel like inventing another (it’s about that time) or you just felt like reminiscing for old times sake?
 
Status
Not open for further replies.

Back
Top Bottom