I had this idea quite some time ago for a fractal decision-making platform, but never publicly shared it, and instead of leaving it stagnated, I’ll share it now. It works like this:
Problem is posed
Solutions proposed
Arguments for and against solutions can be made
Arguments can be made for and against arguments, nesting these, like in reddit.
Voting can be made on any node, on any argument on any level of the tree, including, of course on the roots, the actual proposed solutions.
Total rating of solution is some form of weighted combination of everything under its treeish (using git terms lol, but meaning under it in the tree), with positive votes adding and negative ones substracting, with the value of the vote inversely proportional to how deep in the tree is in some way. Votes could also be made proportional to a reputation value of the voter. The precise algorithm for combining these is the main feature that needs to be designed. Maybe an idea would be to just add a constant factor r<1 for each level down the tree, with r maybe starting out at 1/2, and optimized empirically.
It reminds me a bit of Canonizer, but for solving problems rather than quantifying opinions on specific questions, and with a slightly different approach.
In any case, the weighting algorithm seems to be the core piece of this software. With the quality of that algorithm the idea will be a success or a failure. So, let’s see how the algorithm has to be designed.
I see one major problem: I assume that at least some people tend to favour certain solutions for ideological reasons or reasons that don’t have to do with any of the proposed arguments. These “solution fans” will vote every argument in favour of the proposed solution up, no matter whether it’s good or not.
An attempt for a possible solution to this problem is to make the algorithm so that changing your vote for the arguments doesn’t impact your vote on the solution. Each solution would have a “solution score” and an “argument score”. But it wouldn’t really solve the problem, because the solution fans would still skew the argument score by still upvoting all arguments in favour of the solution!
Another attempt to resolve this issue: For every proposed solution you have a fixed quota of votes which you can allocate to the different arguments. So, you would want to use your votes on the very best or worst arguments. Alternatively, you have a normalized vote power of 1 for each solution (or else, depending on your reputation) and this vote power gets distributed over all your votes. So, if you do 7 upvotes and 3 downvotes, each of those votes will have a power of 0.1 (perhaps the power is also dependent on the depth of the tree, not sure whether that’s a good idea). So, every time you use another vote, it will reduce the power of the votes you’ve already used.
The software should be used to inform decision-making, not to automatize it.
After all of these considerations the idea still looks promising. Of course, it needs a good name. Perhaps something like
Thanks for the feedback. That is a very good point! And you offer some good solutions. Another idea that I think may work is similar, but taking into account the tree structure. Let just say that the total value of your vote cannot exceed one (or some other number, if reputation is taken into account). So that if you vote on several levels, you may have a total vote value of 2r^2+3r^3+r and that can’t exceed one say.I think this is better than normalizing the vote to one, whatever you do, because then there is no incentive to do anything but just vote once, and I can’t find another normalizing scheme, that would work well with the tree structure.
The good thing about the structure, though, is that if you find yourself limited with your low reputation, you can always make a good argument to support something. Simple idea fans, probably won’t make good arguments, and will get hopefully negatively voted if they reveal themselves by just arguing something dumb…
Also for some reason the canonizer website doesn’t open, but I think I may have seen it before.
As for the name, I haven’t thought about it, but Decision forest sounds quite good to me.
To avoid any complexity, lets figure how to give factual basis to ideological conundrums. We can avoid treating people always as brutes while acknowledging their biases.
Adding the “ideas based on ideas” system, this platform can solve such a voting problem. Instead of adding a score in numbers, lets link approval or disapproval on arguments directly to other arguments on which the decision was made. Therefore we have clear the reasons of the vote, and we can have our say on it.
And yes, we can overcome any nested discussion with another system: SAM Split discussions which might have more than one idea in debate. And Merge discussions which might have the same idea on debate.
It is what Wikipedia does, even with slow implementation.
I don’t see how you arrive at that formula. Can you elaborate on that? Why the factors 1,2,3 that are proportional to the depth factor?
The more I think about it, the more I am convinced that we really should separate the votes for the solutions from the votes for the arguments. There are a couple of reasons for that:
People might prefer certain solutions for reasons other than mentioned in the arguments and may not be inclined to mention their personal reasons. This could be seen as a bad thing, but I think it’s realistic and the more you try to force people to be rational, the more they will loathe the system and not bother using it.
If the votes for a solution depend of the votes for its arguments, people will be inclined to vote on the arguments so that the solution will get a maximum vote from them. This tactical voting on arguments would create a distorted representation of people’s actual opinions of those arguments.
In the end, it would be most informative for each solution tree to have two scores: First the direct solution votes and second an argument score that is computed from the votes for each argument. So, it will be easy to see which solutions are popular, but also which solutions are controversial, or have good arguments in favour for them. Ideally, a good solution would be popular, uncontroversial, and have a very high argument score. If one of those measures is suboptimal, then this may be a sign that further debate is necessary.
From this it would follow that there are two different voting systems: A simple voting system for the solution themselves, and a more complicated voting system for the arguments. The more complicated voting system still would need to be normalized, otherwise the argument score could be pushed through the roof tactically. All the argument vote weights would be normalized to add up to 1 (or something reputation dependent).
I think you need to elaborate on this. You mean, instead of voting for an argument, you just link it to another argument (or axiom) that you already approve of? That’s an interesting idea, but rather than avoiding complexity, it makes the system much more complex.
Sooner or later we would indeed have to think how to moderate or administrate the decision trees, but for now, we still have to find out whether the system itself is viable. Anyway, there’s a big issue here: Who is authorized to split or merge trees? Wouldn’t that interfere with the decision making process? What about only being able to split or merge trees once an active phase of voting has already passed? There would be different stages and between each stage, splitting, merging, adding new trees and branches, removing trees and branches could all happen.
I don’t see how you arrive at that formula. Can you elaborate on that? Why the factors 1,2,3 that are proportional to the depth factor?
Sorry that wasn’t an universal formula. It was an example of someone who voted up twice at level 2, thrice at level 3 and once at level 1. It was just coincidence that the numbers I chose were that . I guess the general formula for the weight is
$$w=\sum_{i=0}^{N} r^i(U_i - D_i)$$
where $N$ is the number of levels, $U_i$ is the number of upvotes in level $i$, and $D_i$ is the number of downvotes in level $i$. The we say that that number can’t exceed a certain number; let’s say it can’t exceed 2 (+reputation maybe). I put two so that if you vote on the 0th level (on the solution), you can still vote on some arguments. I think this is better than normalizing to 1, because that would mean your vote is worth 1 whatever you do right? So why do anything?
People might prefer certain solutions for reasons other than mentioned in the arguments and may not be inclined to mention their personal reasons. This could be seen as a bad thing, but I think it’s realistic and the more you try to force people to be rational, the more they will loathe the system and not bother using it.
But I think it’s fine if people don’t want to put their reasons. Putting your reasons in is just another way to gain (or loose) the weight of your vote, but you don’t need to use it.
Also, on your argument on people using votes strategically and creating bias. Well yes that can happen with any system I think. The key is limiting its effect, so put a limit on your vote value for example, like the system proposed above.
Your point of stating both voting values being more informative is good, but debatable. I mean on one hand, you can always argue that getting more information is always more informative xD, but I think one nice thing about the design of this platform is that it puts the solutions and arguments on the same footing more or less, and they are not treated differently on a fundamental level (apart from being in different levels of the tree).
I think it’s important to treat solutions and argument differently, because they are not the same thing. If they were mutually exchangable, for example turning an argument into a real solution, then it would make sense to use a universal formula for both, but they are not equivalent.
It would be different if the platform was only for arguments and sub-arguments or only for solutions and sub-solutions, but it mixes solutions with arguments and treating them both as if they were basically the same is not really appropriate from my point of view.
Hm, yeah I think you are right. I was thinking of them generally as “ideas”. But they are different, true. Ok so we can keep them separate as you said. Your comment on solutions as sub-solutions though did give me the idea that over the tree of arguments there could be a tree of solutions, and above it, maybe a tree of problems/goals.
This is stranding away from the decision making platform, but it does link it nicely with the idea of Jera of organizing Projects and Goals. This makes me think that the structure of the goals in Jera is actually more of an unhierarchical network instead of a tree. If that was applied to arguments, I guess we would be talking about Maximo’s idea. In this system, you could make an argument for/against more than one arguments/solutions.
That’s certainly an interesting idea. But you need to consider that one problem can have many potential solutions, but also that one solution might solve multiple solutions simultaneously. So, a simple hierarchy isn’t appropriate when you both have problems and solutions. The real structure would be a rather complicated network of relations: Problem-subproblem relations, solution-subsolution relations and problem-solution relations.
Yes, that’s why the Jera structure isn’t simply a hierarchical tree, but allows for hierarchical and unhierarchical connections, and even for the hierarchical ones it doesn’t form a tree because a child may have more than one parent (which doesn’t happen in trees), which may correspond to a solution for more than one problem.
It seems that there are basically two different approaches here:
Is to make a really big platform with a huge network of relations between problems, solutions, and arguments. This would be enlightening in its own right. Also, this could be combined with some kind of voting system or not.
Focusing on the decision making part: There’s only the decision/argument tree and votes are separate for decisions and arguments. This is still relatively simply, so it doesn’t confront the user with a huge network of interrelations.
Both approaches have their own advantages and disadvantages. It might make sense to create a project for each one. Or just to pick the one with the most promising potential. I think the decision forest idea seems more immediately promising and useful. The large network project would be rather some long-term project.
I’ve recently started working on concept for a collaborative problem solving platform. There is a landing page at www.BUMPconductor.com. First goal is to create an open database of big unsolved meaningful problems worth solving (BUMPs). Am calling this database ‘‘OpenBump’’.
Am at a very early stage with all of this - but would be good to have a chat to see if we could collaborate in someway.
Excellent Guillermo. We seem to headed in the same direction - I see a great opportunity here. I sincerely hope we can find a way for us all to pull together.
As a bit of background, besides the BumpConductor concept have also begun working on a complementary system called ‘‘The Internet-of-Thinkers’’. Besides the software and overall architecture side of things have spent quite some time thinking about these concepts from a commercial/product point of view - though I must stress that my motivation for these initiatives isn’t financial. Obviously we need financial fuel to help make our dreams reality (at least until we can change things).
Also been contacting other parties who are also either working or talking about similar initiatives. Have met with a few people so far and have other meetings planned - including one tomorrow morning here in Amsterdam.
Generally I’ve been ‘connecting the dots’ and I think I can see how this can done.
We can absolutely make this happen if we can create a mission driven team, organize ourselves, get some fuel, and start to deliver something of value.
Regarding your spec - Have had a quick look on github and will take time tomorrow afternoon to give it a good read through. Am wondering if any of you have an experience with agile delivery techniques and capturing requirements using ‘user stories’?
Hello, I found this group as it was linked from the Zero State Facebook group.
In 2012, I designed an algorithm to determine the rating system for exactly the kind of system described here. Basically, problems presented were tagged by the userbase, and multiple tags would be used, and the tags would even be weighted. So eventually the system could see a problem which is 80 percent of topic A, 15 percent topic B, 5 percent topic C. Each user would also have a perceived skill level, which is a combination of a “global skill level” and the skill level of the various topics that they have, in relation to the tags.
I still have a spreadsheet which describes the algorithm. It’s never been built/implemented, so it would need some further research and testing. But the basic foundations are there.
I discussed the idea and the algorithm with Ben Goertzel, and his response seemed rather enthusiastic and he suggested turning it into an open source discussion platform of some sort.
I don’t believe the rating system would have to be tied to the problem and solution system. A library could be built which has the abstract building blocks to determine the ratings and so on. Then a service which is more specialized towards problem solving and finding solutions, could be built on top of it. And other services similar to Reddit or other tagging systems could be built on top of the library as well.
I’m interested in chatting about this sometime with whomever is interested. I don’t have time to do any coding right now as I work a very busy day job as a software engineer. But I could work alongside a developer that wishes to do this.
Awesome! Thanks for telling us how you found us! Welcome to the Fractal Future Forum, where interesting people meet and find out that there something thinking along very similar or complementary lines.
Wow, that beautifully ties into the crowd tagging and tag rating system that I’ve proposed to Democratic Intelligence and the Future Portal project. It’s cool to hear that you already have a fully developed algorithm that does that beautifully.
You could upload the spreadsheet to a post of yours, if you feel generous and courageous. Otherwise, there’s also the possibility to send it to select users of this forum via private messages. I am quite interested in the algorithm, certainly. It seems to be such a useful building block for complex crowd-based platforms.
I really like that you are aiming so high and contact geniuses like Ben Goertzel who actually validate your idea I should be doing more of this, but I seem to be a little bit too shy.
Ah, I can totally empathize with your situation. There are a lot of people with great ideas here. Many also have some good coding experience. Many also do not have much spare time. This suggests to me that we should reach out to hobby coders who want to try out their coding skills by implementing cool ideas. If you know such people, please invite them in! Your system is not the only one that needs to be implemented.
I am looking to collaborate on this, but sharing the intimate technical details will come at a later phase of the project. Finding out who the right people are, if any, comes before that. For every 10 people who have stated that they are interested, I see about 1 person who is serious about it.
The engineering portion of the project is definitely not for hobbyist coders and would have a better chance with two serious engineers with the motivation and commitment to see the project through.
But anyone who has serious interest in such a system should join in on the discussion to help think about and decide what the system should actually do, what the target audience would be, whether it would be a commercial project, and so on.
Why? People might pick up your idea and implement it in their own projects. Wouldn’t you want that to happen?
That sounds like an unusually high ratio! You should be happy about that! Usually, this ratio is more like 100:1.
You are defining high demands. In this case, and given how I see your system, I see different paths to proceed:
Create a start-up that focuses on building something with your system.
Open source what you have and hope that the open source community picks up on it and implements the bits and pieces that are useful into various different projects. This may indeed the better way to go, since your algorithm feels more like a general purpose tool for collaborative software than a stand-alone product. In that sense, it’s quite comparable to my reputation system Quantified Prestige.
. I guess the general formula for the weight is
It seems to be such a useful building block for complex crowd-based platforms.