The Cognitive Dyads

[scenefinale]

Here's the quick version.

In an effort to help improve CFT, I am introducing new terminology. I call them the Cognitive Dyads (dyad meaning "group of two"). I have defined them in a manner somewhat similar to the Quadras of Socionics. (Please note, I am using Set in the mathematical/programmer way, meaning there is no implied order of the Set's elements, no duplicates, etc.)

The four dyads are:

Lambda 	=	Set(Ti, Fe)	=	subjective logic, objective feeling
Kappa 	=	Set(Fi, Te)	=	subjective feeling, objective logic
Zeta	=	Set(Ni, Se)	=	subjective intuition, objective sensing
Mu	=	Set(Si, Ne)	=	subjective sensing, objective intuition

Lambda and Kappa can also be referred to as the Judgement Dyads.
Zeta and Mu can also be referred to as the Perception Dyads.


Here are a few implications.

The Quadras can now also be thought of as these respective sets, each containing one Judgement Dyad and one Perception Dyad:

Alpha	=	Set(L, M)
Beta	=	Set(L, Z)
Gamma	=	Set(K, Z)
Delta	=	Set(K, M)

One minor drawback is that the Cognitive Functions now get two names.

Ti = iL
Fe = eL

Fi = iK
Te = eK

Ni = iZ 
Se = eZ

Si = iM
Ne = eM

Some Benefits
--------
-More concise way of expressing, e.g. "A person who uses Te/Fi or Fi/Te"
-The Quadras were named in such a way that immediate subjective interpretation of the name was not as much of a problem. Which is why I have extended that.
-Help seperate CFT from MBTI, which, in my opinion has a horrible reputation among researchers. I believe there is much scientific validity to be had for CFT, but there has simply yet to be someone competent enough, with the resources and interest, to substantially investigate it "conclusively".
-I have chosen what I consider to be the lesser of ambiguous Greek letters available, but I did use an L (sorry Socionics!).

[bIMG]http://i1292.photobucket.com/albums/b567/scenefinale/Dyads_zps233fdb57.png[/bIMG]

This is meant to compliment existing terminology, not replace. I, personally, believe the majority of impact will be positive. Also in an effort to facilitate this, I am writing interactive software (I was able to get a tremendous amount of coding done at HackPrinceton last weekend, so it shouldn't be too much longer) as well as creating a database of examples. I have a domain parked for web access, but I'm very short on time as this is all being done solo, for non-profit/educational purposes at the moment. Hopefully I will have time to make the videos I have structured/laid out as well.

Also, before anyone asks... Yes. I am aware of this somewhat similar thread http://personalitycafe.com/cognitive-functions/295034-finally-official-tandem-group-names.html I came up with my idea, which is much different anyway, long before ever reading that post, however. But anyway, hopefully some will find this useful.

Thank you for your time.

 

[OrLevitate]

I don't mean to take away from the thread or whatever but what did you use to draw the picture? Do you have a tablet?

 

[EyeSeeCold]

This is meant to compliment existing terminology, not replace.

I don't understand, why not just advocate Socionics?

The dyads aren't fully compatible with MBTI. There's nothing against it in theory, but due to different methods of arranging types between MBTI and Socionics, you wind up with different interpretations of what the dyads mean or describe.


edit: I realize you're emphasizing CFT, though I would still hold that CFT is closer to MBTI than it is to Jung.

 

[scenefinale]

I don't mean to take away from the thread or whatever but what did you use to draw the picture? Do you have a tablet?

Lol Surface Pro 3 with Windows 10 preview. Worth it for students, IMO.

 

[scenefinale]

I don't understand, why not just advocate Socionics?

The dyads aren't fully compatible with MBTI. There's nothing against it in theory, but due to different methods of arranging types between MBTI and Socionics, you wind up with different interpretations of what the dyads mean or describe.
edit: I realize you're emphasizing CFT, though I would still hold that CFT is closer to MBTI than it is to Jung.

Yes, without Jung's brilliance in observing and describing these patterns or the hard work from both Myers and Briggs, I would likely not be able to stand on top of this knowledge as I do right now. But, a rose by any other name...

My priority at this point is describing what I see. The priority is not to line this up with existing theories (although it would of course be really nice if they happened to line up), it's to push forward our understanding of what these patterns actually are, and to get the scientific community back on board with that.
I very much consider science to be like the "Blind men [and women] feeling the elephant". All descriptions are important. But at some point you need someone with ample imagination to stand back and listen to put it all together into a coherent work.

 

[Cherry Cola]

I think that cognitive functions should always be considered in pairs as well because they work that way. For instance, accurately describing Ti is impossible without including Fe, so why have the formal layout of MBTI done in a way that encourages describing Ti and Fe separately? I think it halts progress because it forces people to realize that Ti and Fe are always in a symmetric relationship where they serve on another on their own, rather than tell it to them up straight.

Unfortunately I don't know any socionics so I didn't really get all of the latter part of the OP.

 

[scenefinale]

I think that cognitive functions should always be considered in pairs as well because they work that way. For instance, accurately describing Ti is impossible without including Fe, so why have the formal layout of MBTI done in a way that encourages describing Ti and Fe separately? I think it halts progress because it forces people to realize that Ti and Fe are always in a symmetric relationship where they serve on another on their own, rather than tell it to them up straight.

Unfortunately I don't know any socionics so I didn't really get all of the latter part of the OP.

The Quadras are a very easy concept. You can think of it as grouping the personality types with the same dyads.

 

[Cherry Cola]

Yeah that wasn't very complicated haha :P

 

[EyeSeeCold]

Yes, without Jung's brilliance in observing and describing these patterns or the hard work from both Myers and Briggs, I would likely not be able to stand on top of this knowledge as I do right now. But, a rose by any other name...

My priority at this point is describing what I see. The priority is not to line this up with existing theories (although it would of course be really nice if they happened to line up), it's to push forward our understanding of what these patterns actually are, and to get the scientific community back on board with that.
I very much consider science to be like the "Blind men [and women] feeling the elephant". All descriptions are important. But at some point you need someone with ample imagination to stand back and listen to put it all together into a coherent work.

Unification is a respectable goal, however it would only be re-inventing the wheel unless the new approach acknowledged, adopted and attempted to resolve the problems that current Jungian forks already face.

The deductive properties and dichotomies of the functions/types have already been identified in Socionics. The problem right now is the severe lack of empirical support for the imposition of such binary orientations on reality, and empirical research is difficult when there doesn't even exist a reliable method of typing or determining what is the correct interpretation of the functions and dichotomies.

I'm only saying this because I know it's easy to "start your own typology", and it seems most effort to further progress is wasted on the basics.

 

[scenefinale]

Unification is a respectable goal, however it would only be re-inventing the wheel unless the new approach acknowledged, adopted and attempted to resolve the problems that current Jungian forks already face.

The deductive properties and dichotomies of the functions/types have already been identified in Socionics. The problem right now is the severe lack of empirical support for the imposition of such binary orientations on reality, and empirical research is difficult when there doesn't even exist a reliable method of typing or determining what is the correct interpretation of the functions and dichotomies.

I'm only saying this because I know it's easy to "start your own typology", and it seems most effort to further progress is wasted on the basics.

I'm competent.

 

[8151147]

I think that cognitive functions should always be considered in pairs as well because they work that way. For instance, accurately describing Ti is impossible without including Fe, so why have the formal layout of MBTI done in a way that encourages describing Ti and Fe separately? I think it halts progress because it forces people to realize that Ti and Fe are always in a symmetric relationship where they serve on another on their own, rather than tell it to them up straight.

This. I struggled to express my mean about the symmetric relationship between pairs of cognitive functions, due to lack of proper english grammar.

Actually they are opposite but work in the same way, Ti - Fe, Ne- Si...etc And if an individual truly understand a cognitive function, that one must understand its counterpart as well. They are rather more familiar to each other than other functions under certain point of view.

Moreover, first two functions paired similarly last two functions. for example Ti-Ne vs Si-Fe, not Fe-Si

 

[Aetherius Rimor]

Scenefinale, I've also been interested in the CFTs after reading about socionics. To be honest I can't for the life of me find an MBTI model descriptions as in depth as the Socionics website I've found, when it comes to developing code to implement typing.

I'm not sure why you're partial to MBTI, but the model for socionics is far more suitable for translation into code. Looks like a damn business analyst has already done their part of the project for me.

I'm interested in working with you on this if you're open to collaboration. My primary language is C#, but I've done java (desktop and Android) , php, objective-c (ios), F# and can generally read any language as long as it's not too low level and isn't an esoteric language like brainfuck or malbolge lol.

My question is, why Scala? It's not a very common language in my experience, and so I'm wondering what benefits it offers over the others for you to choose it. Rarely do I encounter a project C# can't be used unless it's Mobile development, and with Mono its portable to non-microsoft OSes without issue if you avoid using Windows api based references.

 

[Aetherius Rimor]

And hell, your dyads model helped me understand something I've been trying to figure out. The relationship between the functions and J/P. Thanks for that

 

[scenefinale]

Hi everybody,

Thank you for your patience. Here is the preview of my first draft of my model.

There is still much I need to explore with my model but this is progress.


Also

As usual, feedback is more than welcomed.

Aetherius Rimor -- Thank you for your offer. I'll send you a PM. A lot of my code is written with emphasis on functional programming so translating it to a language designed around imperative programming might be a little tricky.

 

[Teffnology]

This is definitely something the typology community can use. Curious to see how you test for the cognitive functions as that seems to be the tricky part in typology in general.

This model definitely helps explain the cognitive functions to a lamen, I showed it to my mom and everything I have been rambling about for 3+ weeks finally clicked when I showed her the diagram.

Thank you again for your contribution to typology, I think you definitely are on to something. In regards to the haters you seem to have aquired, keep doing you, I am in your corner.

 

[Aetherius Rimor]

Not incredibly difficult.

I translated a Python functional script into F# and subsequently into C#.

It's not as fluid/elegant looking as the functional version; but still does the job. And it's easier to maintain.

Functional code reminds me to much of perl scripts. Makes me cringe.

 

[scenefinale]

Curious to see how you test for the cognitive functions as that seems to be the tricky part in typology in general.

This is where my presentation comes in. It is my favorite part of my work, so far. With the insight this model brings along with my presentation, typing becomes much more refined. I have so much I would like to clear up for the community but it's a big, time-consuming undertaking.

Thank you again for your contribution to typology, I think you definitely are on to something. In regards to the haters you seem to have aquired, keep doing you, I am in your corner.

Thanks, I don't mind having haters though. http://youtu.be/e7z_ztMxBgk

I translated a Python functional script into F# and subsequently into C#.

It's not as fluid/elegant looking as the functional version; but still does the job. And it's easier to maintain.

Functional code reminds me to much of perl scripts. Makes me cringe.

Python encourages side-effects all over the place (so does Java [for example: getter/setter, mutations]), actual functional code is concise, minimal, elegant, and nothing like perl! Programming with map/filter/etc. is one of the greatest things to ever happen to me!
Functional programming leads to better abstractions which leads to less code, and less code generally facilitates less bugs, easier maintenance, etc.

 

[Aetherius Rimor]

I'll have to strongly disagree with your generalizations. Functional languages are incredibly efficient for mathematical software development. And while I'm not a fan of python, it's development has placed a lot of emphasis on optimizing mathematically intensive functional applications. It's efficiency is good enough for most uses to be on par with native compiled code. It's used by an annoyingly high number of academics with no programming backgrounds though, which leads to some really ugly code.

Outside math, imperative and object oriented code is far more developer friendly.

Your complaints about getter setter mutations I'm going to guess comes from working with poorly written code/frameworks (there are things you can do, but shouldn't do with them), or a lack of understanding how they are meant to be used.

Runtime code injection, and decoupled dependencies made possible by java and .Net frameworks are a godsend for large scale application maintainability.

Perl zealots say the same things about perl scripts by the way. Luckily its incredibly rare to find one of those people nowadays.

 

[scenefinale]

Aetherius Rimor, I'd gladly debate it, just in another thread

 

[Aetherius Rimor]

Aye. I was already thinking this would end up as one of those off topic tangents lol.

 

[Architect]

I like it, but we're suffering from over nomenclature. We have the preferences, the four temperaments, the eight functions and their archetypical positions, and of course the type. Now there's yet another dimension on it; make it easy to remember.

Also it's not clear how these manifest. So, a mu user (subjective sensing, objective intuition - Si/Ne), how does this manifest in a prototypical INTP? If it ain't observable then it ain't worth jack.

 

[scenefinale]

I like it, but we're suffering from over nomenclature.

I agree 100%, the fact that I was barely able to come up with unambiguous letters is a prime example.

Also it's not clear how these manifest. So, a mu user (subjective sensing, objective intuition - Si/Ne), how does this manifest in a prototypical INTP? If it ain't observable then it ain't worth jack.

I also agree. I do plan to thoroughly address this though!

Almost ready, here is a graph of my commit activity.

 

[Aetherius Rimor]

Eh, naming isn't hard. Did this in 30 minutes (figuring out how to implement your Dyads currently):

    public static class CognitiveFunctions
    {
        public static CognitiveFunction ObjectiveIntuition = new CognitiveFunction() { Mind = CognitiveFunctionMind.Subconscious, Direction = CognitiveFunctionDirection.Objective, Type = CognitiveFunctionType.Thinking };
        public static CognitiveFunction SubjectiveIntuition = new CognitiveFunction() { Mind = CognitiveFunctionMind.Subconscious, Direction = CognitiveFunctionDirection.Subjective, Type = CognitiveFunctionType.Thinking };

        public static CognitiveFunction ObjectiveThinking = new CognitiveFunction() { Mind = CognitiveFunctionMind.Conscious, Direction = CognitiveFunctionDirection.Objective, Type = CognitiveFunctionType.Thinking };
        public static CognitiveFunction SubjectiveThinking = new CognitiveFunction() { Mind = CognitiveFunctionMind.Conscious, Direction = CognitiveFunctionDirection.Subjective, Type = CognitiveFunctionType.Thinking };

        public static CognitiveFunction ObjectiveFeeling = new CognitiveFunction() { Mind = CognitiveFunctionMind.Subconscious, Direction = CognitiveFunctionDirection.Objective, Type = CognitiveFunctionType.Sensing };
        public static CognitiveFunction SubjectiveFeeling = new CognitiveFunction() { Mind = CognitiveFunctionMind.Subconscious, Direction = CognitiveFunctionDirection.Subjective, Type = CognitiveFunctionType.Sensing };

        public static CognitiveFunction ObjectiveSensing = new CognitiveFunction() { Mind = CognitiveFunctionMind.Conscious, Direction = CognitiveFunctionDirection.Objective, Type = CognitiveFunctionType.Sensing };
        public static CognitiveFunction SubjectiveSensing = new CognitiveFunction() { Mind = CognitiveFunctionMind.Conscious, Direction = CognitiveFunctionDirection.Subjective, Type = CognitiveFunctionType.Sensing };
    }

    public struct CognitiveFunction
    {
        public CognitiveFunctionType Type { get; set; }
        public CognitiveFunctionMind Mind { get; set; }
        public CognitiveFunctionDirection Direction { get; set; }
    }

    public enum CognitiveFunctionType
    {
        Thinking,
        Sensing
    }

    public enum CognitiveFunctionMind
    {
        Conscious,
        Subconscious
    }

    public enum CognitiveFunctionDirection
    {
        Objective,
        Subjective
    }

 

[Aetherius Rimor]

With comments:

    public static class CognitiveFunctions
    {
        /// <summary>
        /// Equivalent to Ne in MBTI.
        /// </summary>
        public static CognitiveFunction ObjectiveIntuition = new CognitiveFunction() { Mind = CognitiveFunctionMind.Subconscious, Direction = CognitiveFunctionDirection.Objective, Type = CognitiveFunctionType.Thinking };
        /// <summary>
        /// Equivalent to Ni in MBTI.
        /// </summary>
        public static CognitiveFunction SubjectiveIntuition = new CognitiveFunction() { Mind = CognitiveFunctionMind.Subconscious, Direction = CognitiveFunctionDirection.Subjective, Type = CognitiveFunctionType.Thinking };

        /// <summary>
        /// Equivalent to Te in MBTI.
        /// </summary>
        public static CognitiveFunction ObjectiveThinking = new CognitiveFunction() { Mind = CognitiveFunctionMind.Conscious, Direction = CognitiveFunctionDirection.Objective, Type = CognitiveFunctionType.Thinking };
        /// <summary>
        /// Equivalent to Ti in MBTI.
        /// </summary>
        public static CognitiveFunction SubjectiveThinking = new CognitiveFunction() { Mind = CognitiveFunctionMind.Conscious, Direction = CognitiveFunctionDirection.Subjective, Type = CognitiveFunctionType.Thinking };

        /// <summary>
        /// Equivalent to Fe in MBTI.
        /// </summary>
        public static CognitiveFunction ObjectiveFeeling = new CognitiveFunction() { Mind = CognitiveFunctionMind.Subconscious, Direction = CognitiveFunctionDirection.Objective, Type = CognitiveFunctionType.Sensing };
        /// <summary>
        /// Equivalent to Fi in MBTI.
        /// </summary>
        public static CognitiveFunction SubjectiveFeeling = new CognitiveFunction() { Mind = CognitiveFunctionMind.Subconscious, Direction = CognitiveFunctionDirection.Subjective, Type = CognitiveFunctionType.Sensing };

        /// <summary>
        /// Equivalent to Se in MBTI.
        /// </summary>
        public static CognitiveFunction ObjectiveSensing = new CognitiveFunction() { Mind = CognitiveFunctionMind.Conscious, Direction = CognitiveFunctionDirection.Objective, Type = CognitiveFunctionType.Sensing };
        /// <summary>
        /// Equivalent to Si in MBTI.
        /// </summary>
        public static CognitiveFunction SubjectiveSensing = new CognitiveFunction() { Mind = CognitiveFunctionMind.Conscious, Direction = CognitiveFunctionDirection.Subjective, Type = CognitiveFunctionType.Sensing };
    }

    public struct CognitiveFunction
    {
        /// <summary>
        /// Function type.
        /// </summary>
        public CognitiveFunctionType Type { get; set; }
        /// <summary>
        /// Which mind is responsible for processing or sensing data.
        /// </summary>
        public CognitiveFunctionMind Mind { get; set; }
        /// <summary>
        /// Direction targeted by the function.
        /// </summary>
        public CognitiveFunctionDirection Direction { get; set; }

        /// <summary>
        /// Profeciency with the cognitive function as a percentage score.
        /// </summary>
        public decimal Aptitude { get; set; }
    }

    public enum CognitiveFunctionType
    {
        Thinking,
        Sensing
    }

    public enum CognitiveFunctionMind
    {
        Conscious,
        Subconscious
    }

    public enum CognitiveFunctionDirection
    {
        Objective,
        Subjective
    }

 

[scenefinale]

I've broken it down like this...

sealed trait Attitude
case object Introverted extends Attitude
case object Extroverted extends Attitude
object Attitudes extends SetOf[Attitude](
List(Introverted, Extroverted))

sealed trait CognitiveProcess
sealed trait JudgingCP extends CognitiveProcess
sealed trait PerceivingCP extends CognitiveProcess

case object Thinking extends JudgingCP
case object Feeling extends JudgingCP
case object Sensing extends PerceivingCP
case object Intuiting extends PerceivingCP

Etc. I have specific vocabulary I prefer to use.

 

[Aetherius Rimor]

Here's a segment from my expansion to MBTI to create a behavioral profiles implemented in software. Currently have a few expansions, and remove the arbitrary limitation of dominant and auxillary functions requiring opposite directions (can't be Ni Ti in current MBTI). I did this by allowing arbitrary order of operations in functions, which increases the number of personality profiles with base MBTI functions to 40320 I believe (8!).

The below classes encapsulate a piece of their introverted/extroverted nature, but much more than currently encapsulated in MBTI. It has 4 operation types with 4! mutations (24).

I also added an aptitude percentile property to cognitive function, to measure level of proficiency (since a lot of sites talk about developing non-dominant functions). Which of course adds a huge variability, but coupled with my expanded MBTI, that's 967680 possible base permutations of personality.

    public enum DataCommunicationMethod
    {
        /// <summary>
        /// Data is shared in the form of talking, teaching, writing, etc.
        /// </summary>
        Share,
        /// <summary>
        /// Data is acquired in the form of listening, learning, reading, etc.
        /// </summary>
        Acquire
    }

    public enum DataCommunicationMode
    {
        /// <summary>
        /// Data from a small range of subjects, an expert.
        /// </summary>
        Depth,
        /// <summary>
        /// Data from a broad range of subjects, a jack of all trades.
        /// </summary>
        Diversity
    }
    
    public struct DataCommunicationFunction
    {
        /// <summary>
        /// Subjects in depth or a diverse number of subjects.
        /// </summary>
        public DataCommunicationMode Mode;
        /// <summary>
        /// Teach or learn.
        /// </summary>
        public DataCommunicationMethod Method;
    }

    public class DataCommunicationFunctions
    {
        /// <summary>
        /// Learn a subject in depth, to become an expert.
        /// </summary>
        public static DataCommunicationFunction LearnDepth = new DataCommunicationFunction() { Mode = DataCommunicationMode.Diversity, Method = DataCommunicationMethod.Share };
        /// <summary>
        /// Learn a subject until gist is understood and move on, to become a jack of all trades.
        /// </summary>
        public static DataCommunicationFunction LearnDiversity = new DataCommunicationFunction() { Mode = DataCommunicationMode.Diversity, Method = DataCommunicationMethod.Share };

        /// <summary>
        /// Teach or discuss a subject at a level more suitable for higher education.
        /// </summary>
        public static DataCommunicationFunction TeachDepth = new DataCommunicationFunction() { Mode = DataCommunicationMode.Diversity, Method = DataCommunicationMethod.Share };
        /// <summary>
        /// Teach or discuss a subject at a casual level, or more suitable for grade school.
        /// </summary>
        public static DataCommunicationFunction TeachDiversity = new DataCommunicationFunction() { Mode = DataCommunicationMode.Diversity, Method = DataCommunicationMethod.Share };

    }

 

[scenefinale]

Lol, I've started with 32 types. E.g. an ENTP with aux Fe. (A good example being Skyler from Breaking Bad.) I'm glad somebody noticed the implication of more types.