![[Home]](http://www.bayleshanks.com/cartoonbayle.png)
Note: this document is under construction! See the introduction.
It is not even a finished draft yet, just parts of a draft interspered with notes.
First, I decided what I thought the size of the senate should be. I wanted a formula that took as input the size of the electorate, and yielded the size of the Senate. I wanted this formula to be scalable, that is, to give reasonable answers for moderately small groups and also for groups the size of the entire population of Earth, and larger. In numerical terms, I require a rule that scales for groups of about 1000 up to groups of about 9 billion. If possible, it would be nice if the rule would scale down to about 15 and up to about 1e12.
Some approximate example group sizes to help get a handle on these numbers:
| 30 | the number of students in a small graduate program | ||||
| 65 | the number of students in my elementary school class | ||||
| 600 | the number of students in my high school class | ||||
| 1900 | the number of developers in Debian 1 | ||||
| 2500 | the number of UCSD graduate students2 | ||||
| 1.2e6 | the population of San Diego | ||||
| 3.5e8 | the population of the USA | ||||
| 6e9 | the (current) population of the Earth | ||||
| 1e12 | 100x an estimate of the peak population of the Earth during this century3 |
Size of representative bodies in this system with those numbers, and 8,15 and 1e18 thrown in just to see what happens with really small and with ridiculously large groups4
:
| 5 | |||
| 8 | |||
| 15 | |||
| 30 | |||
| 65 | |||
| 600 | |||
| 1900 | |||
| 2500 | |||
| 1.2e6 | |||
| 3.5e8 | |||
| 6e9 | |||
| 1e12 | |||
| 1e18 |
By the reasoning given elsewhere, I felt that the current size of the U.S. Senate, 100, is significantly too large. The Senate, I feel, should be as small as possible, a tiny body that is small enough to sit down together and have serious discussions; the only reason it needs to grow with population at all is to allow all of the major political viewpoints to have a voice (and to allow each major viewpoint to be represented by more than one member so that the personal preferences of one person doesn't overly dominate the expression of the will of their faction).
Let me emphasize that: I see the proper role of the Senate as a guide for public discourse and a focus for attention. So, the number of Senators should grow in proportion to the number of points of view that the public should be made to focus upon. This is in opposition to an idea in which the number of Senators should grow roughly in proportion to the size of the population itself, in order to ensure each faction of some fixed size at least one representative in the Senate.
Now, the simple fact is that, no matter how much you would like the public to devote sufficient time to be able to understand all of the subtleties of politics, that people will refuse (and rightly so) to spend too much time on this, and so the media will simplify the world into a small number of factions. In the United States today, by looking at how the media talks about political factions, I guess they divide domestic politics into about 6 factions: (religious Republicans, other Republicans, anti-corporate Democrats, other Democrats, greens, "other"). So let's say that the magic number is between 5 and 7. Since we will allow each of these factions (except "other") to field 2 reps, we have a body of at least 9 to 13. Now, if even the small factions such as the greens have 2 reps, surely some of the larger ones will have more. So we want a Senate of about 13 to 24 members.
Nth-root formulas are one alterantive, but n must be 6 or more in order to bring the Senate below 50 for 350,000,000 people. I worry that this scheme would not scale too well if the population continues to increase exponentially. For example, for 18 trillion people, the 6-th root rule yields about 162 senators, which seems like a lot to me. Does this fit with out intuitions? This would mean that with a population 3000 times larger than the current population of the entire Earth, the media would pretend that there is about 40-56 factions. This seems like too many to me.
On the other end of the scale, this formula gives Senate sizes that I feel are too slightly too low for small groups. For example, the 6-th root rule would give 3 senators for a group of 500, which seems like too few; would a 500 employee company have a board of directors of only 3 people?
In addition, the 6 seems like a kludge.
All in all a 6-th root rule would not be too bad, but log seems better. Log gives answers that seem better for very small and very large groups.
To start with, I tried natural log. log(350000000) \approx 19.7, which seems like a reasonable size for the Senate of the United States. log(25e9) \approx 24, so even with a population of more than twice current projections for the maximum world population within the forseeable future, this rule yields a suitably small Senate size. log(18e12) is only 30.5. Does this fit with out intuitions? This would mean that even with a population 3000 times larger than the current population of the entire Earth, the media would pretend that there is only about 7-11 factions. This seems too small to me, but I think it's closer than the guess of 40.
On the other end of the scale, for a 30 person group, which is about the size of the computational neurobiology graduate subprogram that until recently i was part of, we get a senate of 3.4, which seems about right. For a 65 person group, about the size of my class in elementary school we get a senate of 4.2, which also seems reasonable. For a
One model that would justify this is if we assume that the cognitive cost of holding in mind n factions is exponential in the number of factions, and the benefits of adding a new faction is directly proportional to the number of people who will be represented by that faction.
In this case, if we have P people and F factions, then that must be because the benefits of creating the last faction outweighed the costs. The benefits are proportional to P/F. The costs are proportional to exp(F) - exp(F-1). We have
exp(F) - exp(F-1) = P/F
F*(exp(F) - exp(F-1)) = P
F*(F e^{F-1} - e^{F-1}) = P
F*e^{F-1}*(F - 1) = P
ln F*e^{F-1}*(F - 1) = ln P
ln (F*(F-1)) + ln(e^{F-1}) = ln P
ln (F*(F-1)) + F-1 = ln P
F = O(ln P)
Natural log seems to wor
For example, according to http://physics.ucsd.edu/was-sdphul/dept/pr/gintro.html, UCSD currently has on the order of 2500 graduate students. The Senate would correspond to the size of the Graduate Student Council, our student government.
\begin{comment} (log_S P -1 - L)/(\sum_{j=1}^L j) = k
log_S P = 1 + L + k*(\sum_{j=1}^L j)
log_S P = log_S S^{1 + L + k*(\sum_{j=1}^L j)}
P = S^{1 + L + k*(\sum_{j=1}^L j)}
P = S^{1 + L + k + 2*k + .... + ik + .... + L*K}
P = S^{1 + (1 + k) + (1 + 2*k) + .... + (1 + ik) + .... + (1 + L*K)}
P = \prod_{i=0}^L S^1 S^{1 + k} S^{1 + 2*k} * ... * S^{1 + ik} * .... * S^{1 + L*K}
P = \prod_{i=0}^L S^{1+k i}
x = \prod_{i=0}^{ceil(log(ceil(log(x))))} (ceil(log(x))^{1+k i}
If each individual in the electorate
5 \end{comment}
Corporation: An abstract entity representing a group of people in some capacity which is not itself capable of consciousness.
Person: Sentient being.
Renew: A Renewable bill may be Renewed by being repassed, exactly as before, except with dates advanced to the current time period.6
Renewable: A bill is Renewable if it specifies in its text that it is Renewable.
The Tribunes might be thought of as the "conscience of the State", or as the "enemy of the government", or as "anti-Prime Ministers".
I created the position of Tribune to fulfill some of what I consider the useful function of the USA President which are not fulfilled by the Prime Minister under the parliamentary system.
The U.S. President is a powerful, prestigious individual who is independent of the other branches of government. This allow hir to point out/publicize/preach against whatever systemic failings afflict the other branches (partisanship in Congress, etc). The Tribunes are also powerful, prestigious, and independent, and they are uniquely empowered to attract publicity and preach.
The U.S. President is an individual with the powers of veto and pardon. This allows hir to use their individual conscience to check the other branches of government. The Tribunes are also individuals, and although they do not have veto power, their power to publicize wrongs will allow them to effectively check the other branches.
The Tribunes improve on the USA President in, while the USA President is often someone who supports the expansion of government power, the Tribunes can be expected to frequently be opposed to the Prime Minister and the Senate.
The Tribunes also improve on the USA President by fulfilling a new function, a function not fulfilled by any official in the USA: looking at the most secret information. This allows them to expose high-level corruption and conspiracies. Just as important, their very existence will act against the expansion of secrecy and the use of secrecy for tactical political ends, since there is always the danger that a Tribune will choose to declassify something that they personally consider not worthy of secrecy.
The Tribunes might be called Anti-Prime Ministers, but that sounds too silly.
Because Tribunes are supposed to be individuals, and to gain all the prestige that attaches to the USA President, it would be nice to just have one Tribune, instead of three. But having three provides important benefits:
In the modern world, we see how only the few most prestigious individuals in politics attract the attention of the nation. Attention is a limited quantity, and there are too many political representatives for a typical individual to become aware of. For example, a typical individual can vote for their mayor, their state assemblyperson, their state senator, their state governor, their federal assemblyperson, two federal senators, the federal president, possibly other state officials, and possibly some state and county judges. This is a total of more than 7 people. This proves too much, as most people seem to only pay attention to the presidential candidates, and even the more informed often pay attention to only 3 or 4 of these positions.
In addition, it would seem that the public "should" pay attention to the personalities and doings of the 12 Supreme Court members and the leaders of the two major parties in the two houses of the legislature. The more informed pay attention to maybe another 3 out of this list.
Furthermore, it would be nice if the public could pay some degree of attention not just to their own representatives, but also to the other representatives of other parts of the country. To the extent that this is possible, the public could pay attention to the debates in the legislature.
Therefore, the number of high officials to which the public needs to pay attention should be minimized.
The USA House of Representatives initially had 65 members, in 1789. In my personal experience, this number is about the same as the number of people in my class in elementary school. I'd guess that this is about the maximium number to effectively have "collegiality", or a situation in which each member of a group has a vague idea of who each other member is and where they stand, and in which each person can consider each other person an acquaintance. Of course, politicians can be expected to be better at this than ordinary humans, and so perhaps the number is a bit higher for them, but it seems to me that the number shouldn't go above what can be expected for ordinary humans.
Certainly, the number should not exceed Dunbar's Number (150) (http://en.wikipedia.org/wiki/Dunbar's_number).
In 2007, the size of the USA House of Representatives is 435. This is way too large.
While I think around 65 is the maximum that should be tolerated, I think there are benefits to going as low as possible. I would imagine that with 65 people, it might be possible to stay acquainted with everybody, to learn their positions on important issues, and to negotiate on important issues with a majority of the other members, but I imagine that these activities would be in themselves a full time job, leaving little time to actually learn about, weigh, and discuss with others the merits of the issues.
With around 20 people, I imagine that there would be time to keep in touch with everyone, to know everyone's position, and to spend some time actually discussing the issues themselves rather than merely negotiating.
With 12 people, I would imagine that everyone would know each other very well, that substantial issue discussion would be the norm, and that substantial compromise would often be feasible.
With 4 people, I would imagine that compromise would be the norm and that business could be transacted rapidly.
Each person has to vote for three federal representatives; the Tribunes, their delegate to the under-Senate, and their delegate to the under-Senate of Foreign Affairs.
The small size of the domestic Senate (20, for a population of 350,000,000) ensures both collegiality and allows the more informed segment of the public to actually keep track of Senate politics.
The small size of the Senate of Foreign Affairs allows the more informed segment of the public to keep track of what is going on, and
The total number of important people to keep track of is:
Total: 33
Compare to the US government:
Total: 113
The structure is in some sense an embodiment of the One (the Prime Minister, and , the Few, and the Many.
One phenomenon that I noticed in modern democracies is that often top officials are given the power to set policy over both domestic and foreign affairs. However, often those officials are elected based mainly on the public's affinity for their views on just out of these two spheres, and often their views on the other sphere does not match the public's. In addition, often they have experience or competence in only one of these two spheres, and sometimes they appear to be incompetent in the other one. Finally, individual voters will often agree with some candidate or party in one of these spheres but not in the other.
This division could of course be said to exist for any two issues, but when you think about categorizing and clustering voters and candidates, it seems like the distinction between foreign and domestic issues is often one of the most useful distinctions to be made.
Therefore, one design principal is to have one set of officials with power over foreign affairs, and another set of officials with power over domestic affairs.
This is realized in the separation of the legislative upper house into Senate and a Board of Foreign Affairs, and the parallel separation of the executive into Prime Minister and Foreign Minister.
I observe that generally people are more concerned with domestic affairs with foreign, and hence I have given the domestic side, the Senate, the greater portfolio. By default, matters fall to the Senate, except for foreign affairs, which fall to the Board of Foreign Affairs. Emergency powers fall to the Prime Minister, rather than the Foreign Minister. The question of what constitutes a "foreign affair" falls to the Senate.
You might think that this would encourage the Senate to define "foreign affairs" ridiculously narrowly and so to effectively conduct foreign affairs itself; but remember that the Senate cannot pass bills without the House of the People.
here's an example of a real-world legislature with 42 members, all elected from the whole country, all by STV: http://en.wikipedia.org/wiki/New_South_Wales_Legislative_Council
21 members (half) are elected each cycle
note that the wikipedia STV page points out that its proportionality is lost if there is gerrymandering (voters are broken into districts)
Unfortunately, I was not able to completely achieve this important goal, and this is currently a weakness of this system.
The fundamental problem is introduced by vote delegation. It is desirable for the original voter to know how their vote was ultimately spent by their representatives. But this seems to require that the vote by the representatives be public. It has been proposed elsewhere7 that representatives or proxy holders be able to cast each of their votes differently, and that each original vote holder would only be told the final disposition of their own vote. The idea was that, if someone was trying to intimidate you to vote a certain way, you vote that way with their vote and their friends' votes, but vote the rest of your votes the way you want. However, it seems to me that a corrupt organization trying to use intimidation to control others' voting would likely to be able to scrounge up a few tattletales, people whom you didn't know were their friends, who would rat you out if you tried to deceive them in this way. So, my current hypothesis is that transitive proxy voting, and also indirect representation, is antithetical to a secret ballot. In support of this, you notice that in today's systems, representatives (legislators) are required to openly disclose their votes, whereas individuals have a secret ballot. I'm guessing that the reason this is so is that representatives are in a sense casting the vote on behalf of others, and hence must be accountable to the original vote holders, and also that representatives are few enough in number and powerful enough that they can resist intimidation better than individuals. Whereas individuals are too weak to resist intimidation, but on the other hand don't need to be made accountable to others.
But in a transitive proxy voting system, individuals are also representatives. So we have a problem.
My solution is to allow individual voters to secretly divert their own, personal vote, but not to provide any secrecy or anonymity to the representatives or holders of proxies, insofar as they cast their borrowed votes.
Principals:
The last principal is because this would allow representatives to be their own constituents. This would, first, take up their time, as they would have to deal with two groups of constituents (theirs as an upper-layer rep, and theirs as a lower-layer rep), and second, it would allow high-profile individuals to run for Senate "directly", by accumulating a massive amount of votes from individuals in the first round, and then passing these votes up to themselves.
The second situation is not really prevented by the proposed system, however, in order to accomplish this, high-profile individuals would have to ask voters to entrust their votes to allies who would pass the votes up to the high-profile candidate. This ensures that after the election, the high-profile individual is still responsible to other people, even if these people are their allies.
design principals of the direct democracy:
design principals of the senate:
\begin{comment} more ideas for determining levels:
log(log(x)) = levels
log(log(x)) = multiple of log(x) added at ea level
example: 350000000:
log(x) is about 20 ceil(log(log(x))) is 3
260*200*140*80*20
log(log(x)) = difference between multiples of log(x) added at ea level
example: 350000000:
380*200*80*20
---
so let x be the total population. #lvls is ceil(log(ceil(log(x)))) + 1, where the lowest level is the electorate, and the highest level is the senate.
ceil(log(x)) * k * ((\sum_j=0^i j) + 1)
where k is chosen to give enough reps to represent the population, that is, k is chosen to make the following equation hold:
x = \pi_{i=0}^#lvls (# of reps per group for level i)
expanding,
\pi_{i=0}^{ceil(log(ceil(log(x))))} (ceil(log(x)) * (k * (\sum_j=0^i j) + 1)) = x
and solving for k,
\pi_{i=0}^{ceil(log(ceil(log(x))))} (ceil(log(x)) * (k * (\sum_j=0^i j) + 1)) = x ceil(log(x))^{ceil(log(ceil(log(x)))) + 1} * \pi_{i=0}^{ceil(log(ceil(log(x))))} ((k * (\sum_j=0^i j) + 1)) = x \pi_{i=0}^{ceil(log(ceil(log(x))))} ((k * (\sum_j=0^i j) + 1)) = \frac{x}{ceil(log(x))^{ceil(log(ceil(log(x)))) + 1>>
so we see that this equation is a polynomial in k of degree ceil(log(ceil(log(x)))) with constant factor 1 - \frac{x}{ceil(log(x))^{ceil(log(ceil(log(x)))) + 1>>, and with coefficients ...
wait i guess we can make it simpler by taking out the senate as a special case:
ceil(log(x)) for i=0 or ceil(log(x)) * k * (\sum_j=0^i j) o.w.
hmmm but then the properties of the gap between the sz of the senate and the size of the guys underneath changes with k.
but the effect is just that, for k > 1, k will end up a little bit bigger than otherwise, and the assembly a little smaller. which is good if we want a small assembly (but bad if we want recursive properties).
that way would boil down to:
i guess that's good. the recursive properties aren't as important as ensuring collegial discourse in the senate.
although if the recursive solution gave something nearby, that would be even better.
what would the pure recursive solution look like, with only the # of levels fixed, and the 0th level now not the senate, but rather the prime minister?
it would be:
k * ((\sum_j=0^i j) + 1)
not much different, i guess
so, if there were four levels (which is right for x = 350,000,000), then we'd have
\pi_i=0^4 k * ((\sum_j=0^i j) + 1) = x (1)(k * ((\sum_j=0^1 j) + 1)(k * ((\sum_j=0^2 j) + 1)(k * ((\sum_j=0^3 j) + 1) = x (k + 1)(3k + 1)(6k + 1) = x 18k^3 + 3k^2 + 6k^2 + 18k^2 + k + 3k + 6k + 1 = x 18k^3 + 27k^2 + 10k + 1 = x 18k^3 + 27k^2 + 10k + (1 - x) = 0
for x=350000000, k= between 268 and 269 is a root
meaning that the levels would be
1, 269, 3*269, 6*269
1, 269, 807, 1614
multiplied together, these are
350371972
so that's about right.
note that all the polynomial coeficients are positive, so i think there's only one real positive root.q
the senate came out to be too big, tho. maybe if we add one to the number of lvls (to make up for the addition of the "prime minister" level?)
\pi_i=0^5 k * ((\sum_j=0^i j) + 1) = x (1)(k * ((\sum_j=0^1 j) + 1)(k * ((\sum_j=0^2 j) + 1)(k * ((\sum_j=0^3 j) + 1)(k * ((\sum_j=0^4 j) + 1) = x (k + 1)(3k + 1)(6k + 1)(10k + 1) = x 180k^4 + 18k^3 + 30k^3 + 60k^3 + 180k^3 + 3k^2 + 6k^2 + 18k^2 + 10k^2 + 30k^2 + 60k^2 + k + 3k + 6k + 10k + 1 = x 180k^4 + 288k^3 + 127k^2 + 20k + 1 = x 180k^4 + 288k^3 + 127k^2 + 20k + 1 - x = x
for x=350000000, k= between 36 and 37 is a root
meaning that the levels would be
1, 37+1, 3*37+1, 6*37+1, 10*37+1
1, 38, 112, 223, 371
multiplied together, these are
352111648
so that's about right.
compare this to the arrangement that i found by the old method that i liked:
380,200,80,20
that only multiplies to
121600000
so actually, in that system, k should have been about 4.5, rather than 3.
in that case, the levels would have been
20, 5.5*20, 14.5*20, 27*20 20, 110, 290, 560
this suggests that if we want a rule without an exception for the senate level, and we want the senate to stay small, then we need to scale more nonlinearly than that.
how about if we find a power? didnt i do that before? mb not
level i = senate^{ki}
x = \prod_{i=0}^{ceil(log(ceil(log(x))))} (ceil(log(x))^{1+k i}
for x = 350000000,
k = .428 is close, yielding
20,73,260,937
which multiplies to 355685200
so i guess that's the best system so far -- it's simple and recursive and has a natural way to insert the constraint on the senate size, and it gets a pretty good answer, even though i think it is a little too nonlinear.
for x = 6 billion, k = about .474, yielding
23,102,450, 1986, 8781
) (how does that compare to how many people per rep in the current house of representatives? maybe there are about 600,000 per rep? in this system, each 2nd-level rep represents 17438966 people for 6 billion, and there are 23*102*450 second level reps; for 350000000, they represent 234620, and there are 20*73 second level reps)
for 18 trillion, which is the upper limit that i'm considering, we have a senate of 31 and four levels of representation (i.e. 3 levels of intermediate reps in between the people and the senators)
(log(P)/log(S) -1 - L)/6 ans = 1.0268
k = 1.0268
check:
octave:24> 41^(5 + 1.0268*6) ans = 9.9990e+17
levels:
octave:28> 41^(1 + 1.0268*0) ans = 41 octave:29> 41^(1 + 1.0268*1) ans = 1856.9 octave:30> 41^(1 + 1.0268*2) ans = 8.4100e+04 octave:31> 41^(1 + 1.0268*3) ans = 3.8089e+06 octave:32> 41^(1 + 1.0268*4) ans = 1.7251e+08
(btw i wonder how all this would come out if we also varied the base of the log? that would give us less levels at 6 billion, which seems appropriate; maybe base 3 would be better? does that make a diff?)
new examples
P = 3.5e8 S = floor(log(P)) L = floor(sqrt(S)) - 1 % L = 3 k = (log(P)/log(S) -1 - L)/(1+2+3)
%dblcheck: should return 1 ceil(S^(1 + k*0))*ceil(S^(1 + k*1))*ceil(S^(1 + k*2))*ceil(S^(1 + k*3)) > P
ceil(S^(1 + k*0)) ceil(S^(1 + k*1)) ceil(S^(1 + k*2))
ceil(S^(1 + k*3))
yields 19,71,265,985
1e12: 100x the predicted peak population of the Earth
P = 1e12 S = floor(log(P)) L = floor(sqrt(S)) - 1 % L = 4 k = (log(P)/log(S) -1 - L)/(1+2+3+4)
ceil(S^(1 + k*0))*ceil(S^(1 + k*1))*ceil(S^(1 + k*2))*ceil(S^(1 + k*3))*ceil(S^(1 + k*4)) > P
ceil(S^(1 + k*0)) ceil(S^(1 + k*1)) ceil(S^(1 + k*2)) ceil(S^(1 + k*3))
ceil(S^(1 + k*4))
yields 27, 83, 252, 767, 2337
so, the number of people represented by ea. lvl 1 rep would be 2337 so, the number of people represented by ea. lvl 2 rep would be 767*2337 = 1,792,479, a bit more than the population of San Diego so, the number of people represented by ea. lvl 3 rep would be 252*767*2337 = 451,704,708, a bit more than the population of the USA so, the number of people represented by ea. Senator would be 3.3e10, about 4x the predicted peak population of the Earth
interestingly, the diff between using sqrt and log for the levels isn't really seen until way past 1e12 (for instance, at 1e16), where sqrt adds another level of representation, and log doesn't. seems to me that at these ridiculously large population levels, another level of representation is justified, in order to keep down the sizes of the direct constituencies.
P = 1e18 S = floor(log(P)) L = floor(sqrt(S)) - 1 % L = 5 k = (log(P)/log(S) -1 - L)/(1+2+3+4+5)
ceil(S^(1 + k*0))*ceil(S^(1 + k*1))*ceil(S^(1 + k*2))*ceil(S^(1 + k*3))*ceil(S^(1 + k*4))*ceil(S^(1 + k*5)) > P
ceil(S^(1 + k*0)) ceil(S^(1 + k*1)) ceil(S^(1 + k*2)) ceil(S^(1 + k*3)) ceil(S^(1 + k*4))
ceil(S^(1 + k*5))
yields 41, 148, 528, 1895, 6798, 24391
so, the number of people represented by ea. lvl 1 rep would be 24391 so, the number of people represented by ea. lvl 2 rep would be 165,810,018 (.5 the pop of the USA so, the number of people represented by ea. lvl 3 rep would be 314,210,000,000 (>30x the predicted peak pop of the Earth)
this 1e18 is just too much for me to get a handle on. let's try something smaller.
\end{comment}
The "group sizes" of a body such as the Senate refers to a list of one number for the Senate and one number for each level of the Undersenate. For each level n, the n-th number in the list denotes how many direct constituents are in a n-th level representative's constituency in an idealized situation in which everyone votes, no votes are forfeit, and the size of the direct constituencies of all of the representatives on any given level are made equal.
For instance, if there are 2 levels in the Undersenate, and the group size of the Senate 10,100,1000, then that would indicate that each Senator has 10 level 2 Undersenators in hir direct constituency; and each of those level 2 Undersenators have 100 level 1 Undersenators in hir direct constituency; and each of those level 1 Undersenators have 1000 ordinary citizens in their direct constituency. There is some rounding in the figures given for calculation of group size and vote thresholds
"vote thresholds" is a list, like group sizes, with the first number corresponding to the minimal vote threshold to become a Senator, and the other numbers corresponding to the vote thresholds to become a representative in each layer of the Undersenate.
In the table below, the following abbreviations are used:
| E | the size of the electorate (population) | ||||
| P.M. | Method of election of the Prime Minister | ||||
| F.M. | Method of election of the Foreign Minister | ||||
| S | Senate | ||||
| uS | Undersenate | ||||
| BFA | Board of Foreign Affairs | ||||
| uBFA | Under-board of Foreign Affairs | ||||
| sz(x) | size of x (x is either the Senate or the BFA) | ||||
| lvl(x) | how many levels are in x | ||||
| groupSz(x) | "group sizes" of x (see above) | ||||
| voting thresholds | "group sizes" of x (see above) |
| E | P.M. | Size of S | Levels of US | groupSz(S, uS) | Vote thresholds (S, uS) | F.M. | Size of BFA | Vote thresholds (BFA) | |||||||||||
| 30 | Direct | N/A | N/A | N/A | N/A | None | N/A | N/A | |||||||||||
| 65 | By Senate | 4 | 0 | 16 | 16 | Direct | N/A | N/A | |||||||||||
| 600 | By Senate | 6 | 0 | 99 | 99 | Direct | N/A | N/A | |||||||||||
| 1900 | By Senate | 7 | 0 | 271 | 271 | Direct | N/A | N/A | |||||||||||
| 2500 | By Senate | 7 | 0 | 357 | 357 | Direct | N/A | N/A | |||||||||||
| 1.2e6 | By Senate | 13 | 1 | 106, 868 | 92008, 868 | Direct | N/A | N/A | |||||||||||
| 3.5e8 | By Senate | 19 | 2 | 70, 264, 984 | 18184320, 259776, 984 | By BFA | 4 | 87500000 | |||||||||||
| 6e9 | By Senate | 22 | 2 | 119, 648, 3520 | 271434240, 2280960, 3520 | By BFA | 4 | 1.5e9 | |||||||||||
| 1e12 | By Senate | 27 | 3 | 82, 251, 766, 2336 | 3.6829e10, 449133376, 1789376, 2336 | By BFA | 5 | 2e11 | |||||||||||
| 1e18 | By Senate | 41 | 4 | 147, 527, 1894, 6797, 24390 | 2.4324e+16, 1.6547e+14, 3.1399e+11, 165778830, 24390 | By BFA | 6 | 1.6667e+17 |
You might wonder why there are no columns for "levels of UnderBFA?" or "group size of underBFA". This is because, according to the system, there are never any underBFA levels at these population numbers; population would have to rise past 1.5061e+35 before an UnderBFA? would be created. This is unlikely to happen; so, we can assume that there is never an underBFA, even though the rules don't bother to say that.
For completeness, the following table lists all of the "transition points" where the number of Senators increase (BFA transition points are a subset of Senate transition points), from E=5 thru E=6e9.
| E | P.M. | Size of S | Levels of US | groupSz(S, uS) | Vote thresholds (S, uS) | F.M. | Size of BFA | Vote thresholds (BFA) | |||||||||||
| 54 | Direct | N/A | N/A | N/A | N/A | None | N/A | N/A | |||||||||||
| 55 | By Senate | 4 | 0 | 13 | 13 | Direct | N/A | N/A | |||||||||||
| 149 | By Senate | 5 | 0 | 29 | 29 | Direct | N/A | N/A | |||||||||||
| 404 | By Senate | 6 | 0 | 67 | 67 | Direct | N/A | N/A | |||||||||||
| 1097 | By Senate | 7 | 0 | 156 | 156 | Direct | N/A | N/A | |||||||||||
| 2981 | By Senate | 8 | 0 | 372 | 372 | Direct | N/A | N/A | |||||||||||
| 8104 | By Senate | 9 | 1 | 20,44 | 880,44 | Direct | N/A | N/A |
P = ? P = ceil(exp(9))
S = floor(log(P)) L = floor(sqrt(S)) - 1 Lundersenate = L-1 k = (log(P)/log(S) -1 - L)/(sum(1:L)) BFA = floor(sqrt(S)) BFAlvl = floor(sqrt(BFA)) - 1 uBFAlvl = BFAlvl - 1 kBFA = (log(P)/log(BFA) -1 - BFAlvl)/(sum(1:BFAlvl))
floor(S^(1 + k*0)) floor(S^(1 + k*1)) floor(S^(1 + k*2)) floor(S^(1 + k*3)) floor(S^(1 + k*4))
floor(S^(1 + k*5))
floor(BFA^(1 + kBFA*0)) floor(BFA^(1 + kBFA*1)) floor(BFA^(1 + kBFA*2)) floor(BFA^(1 + kBFA*3)) floor(BFA^(1 + kBFA*4))
floor(BFA^(1 + kBFA*5))
note: neither the senate, the BFA, nor the ministers have sole jurisdiction over anything -- policy in all spheres can be set by statue. (this is in contrast with certain theories of the USA constitution, which hold that the president as "commander-in-chief" has sole authority to decide on military matters. of course, in most occasions it would not be wise for the legislature to issue orders directly to the battlefield, but i trust that the either the house of the people or the senators would show some restraint when it is needed)
--
note: the Senate needs to have a Condorcet winner in order to replace the current Prime Minister. So we don't care if they have an even number of members, because ties aren't bad.
exception: directly after Senate elections, the first order of business for the new Senate is to decide whether or not to replace the current P.M. This is not treated like a replacement, but like a clean selection; i.e., in order for the current P.M. to stay, s/he must be the Condorcet winner of the new senate's vote. If there is not Condorcet winner of the Senate vote, then the House of the People vote on the remaining candidates. In this secondary vote, we use a modified Condorcet method that always yields an answer even if there is no Condorcet winner.
note: the House of the People may dismiss the P.M. with a 2/3 vote without a reason. In this case the Senate must find candidates and hold another vote, just as if it were a new senate, except that the current P.M. can't be a candidate.
during such "new senate" elections, the current PM remains the PM until the new guy is selected; with the exception that the House of the People can choose to dismiss the PM immediately if they want (they acheiving the 2/3 to dismiss, they only need a simple majority to modify the dismissal to make it an immediate dismissal). Such a resolution by the HOP may specify who the acting PM will be; otherwise, it is the newest Censor. (in other cases, like accidental death, the Senate should specify a procedure by statue).
comments: the senate is a really small body, small enough that they can all sit down together and actually talk; small enough that the media should be able to follow all of them.
it's not expected that the senate actually carry the greater burden of legislation; i expect that the mass parallel nature of the house of the people will allow it to do that much more efficiently.
following bagehot's comments on the roles of the houses of the english legislature, the roles of the senate are:
1) most importantly, to select the prime minister, and to hold hir accountable 2) second, to focus the public's attention on important issues when the decentralized nature of the house of the people prevents it from focusing its attention 3) third, to educate the people through its public debates 4) fourth, serving the functions of "an upper house" to delay and to speak against whatever bad ideas the House of the People happens to come up with
the BFA is basically a "Foreign Senate" but I thought that term would be confusing; because the main Senate is not just a "domestic Senate", but rather a "primary Senate", since it also considers constitutional matters, and defines what is domestic and what is foreign. So I wanted to just call the main Senate "Senate"; and then it would have been confusing to have a "Senate" and also a "Foreign Senate".
The BFA is much smaller than the Senate for three reasons. First, I don't want to overburden the public's attention; having a second representative body at all is already pushing it. Second, I don't expect the public to care as much about the selection of the BFA representatives, since I've noticed that countries today, where there is only one set of reps for both domestic and foreign things combined, often prefer to select reps that match the country's mood domestically, even if they aren't the best choice for foreign affairs. Since the public won't care as much, they won't devote enough attention to keep up with a body with many representatives, so we need to make it small. Third, it's important that the other "foreign" entities with which our country will be negotiating, etc, can understand our country's decision-making process well enough to be able to interpret and trust the offers that we make. Due to the separation of domestic and foreign issues, the BFA members won't have anything to do but set foreign policy, and so we can expect that the BFA will take a more active role in foreign policy than legislatures today usually do. So even if other countries are, in name, negotiating with a single individual (the foreign minister), they will in effect be negotiating with a committee (the F.M. plus the BFA) -- so it's essential that this committee be small so that it can make decisions and firm offers.
--
--
main features:
--
in comparison to the USA,
---
todo: http://www.hrcr.org/chart/categories.html
todo: http://www.google.com/search?hl=en&q=comparative+constitutional&btnG=Search
todo:
antitrust (votes) judge appointment and impeachment geographic districts
note: design goal of simplicity over comprehensiveness. A common law system is more comprehensive in that various detailed situations will have been dealt with by a court in the past, yielding precedent, which makes the law more precise and predictable to entities in the future. But this additional precision relies upon the theory that future entities can look through the precedents to determine what the law is. Following the principal that computation is not free, I note that in practice this means having the money to pay lawyers to go to law school and look up the precedents and tell you what the law is in your particular situation. Therefore, I don't think this comprehensiveness is very valuable, as only the rich can use it. So not much is lost, and simplicity is gained. And simplicity is valued for other reasons presented elsewhere.
Note that makes the law less precise empowers judges; another advantage of a more precise law is as a check upon judicial corruption.
new cleaner formula
k is a user-specified constant. Let k be 1 for the Senate and 2 for the BFA.
Let L be the # of levels of allsenate.
Let R_n, the number of direct constituents on level n who form a constituency, be
R_n = floor(P^(((L-n)*m)^k + b))
(note that when determining vote thresholds, though, we must use ceil instead of floor)
First, we must determine the y-intercept (b). We do this by setting level R_L, the number of prime ministers, to 1.
We have
floor(P^(((L-L)*m)^k + b)) = 1 P^(((L-L)*m)^k + b) < 2 P^(0 + b) < 2 P^b < 2 b < log_P 2
(for simplicity, take b = log_P 2)
Now, we must determine the slope (m).
We have (omitting the "floor"s in R_n):
P = \Prod_{i=1}^{L-1} R_n P = \Prod_{i=1}^{L-1} P^(((L-n)*m)^k + b) P = P^((\Sum_{i=1}^{L-1}(im)^k) + b*(L-1)) 1 = (\Sum_{i=1}^{L-1}(im)^k) + b*(L-1) 1 - b*(L-1) = \Sum_{i=1}^{L-1}(im)^k 1 - b*(L-1) = \Sum_{i=1}^{L-1} i^k m^k 1 - b*(L-1) = (\Sum_{i=1}^{L-1} i^k) m^k \frac{1 - b*(L-1)}{(\Sum_{i=1}^{L-1} i^k) } = m^k (\frac{1 - b*(L-1)}{(\Sum_{i=1}^{L-1} i^k) })^{\frac{1}{k}} = m
P = 3.5e8; b = log(2)/log(P) m = ((1 - b*4)/(1+2+3+4))^(1/1) P^(4*m + b)*P^(3*m + b)*P^(2*m + b)*P^(m + b) R = [P^(4*m + b) P^(3*m + b) P^(2*m + b) P^(m + b)]
R =
1725.875 318.430 58.752 10.840
b = 0 % duh m = ((1 - b*4)/(1+2+3+4))^(1/1) P^(4*m + b)*P^(3*m + b)*P^(2*m + b)*P^(m + b) R = [P^(4*m + b) P^(3*m + b) P^(2*m + b) P^(m + b)]
R =
2615.9366 365.7804 51.1462 7.1517
test loss fn
loss = exp(a)+exp(b)^2+exp(c)^3+exp(d)^4; ... what to do now? ...
loss = exp(a)*exp(b)^2*exp(c)^3*exp(d)^4; loss = exp(a)*exp(2b)*exp(3c)*exp(4d); loss = exp(a+2b+3c+4d); loss -> a+2b+3c+4d
constraint: P = a*b*c*d
R * [1:4]' = 2582.3 sum(floor(R)) = 2111 prod(R) = P
R(1) = 1800 R(4) = P/(R(1)*R(2)*R(3)) prod(R) ans = 350000000 R * [1:4]' ans = 2654.7
R =
300.000 200.000 100.000 58.333
octave:353> R * [1:4]' ans = 1233.3
% so this way wants to be "too even"
loss = exp(a)*exp(b^2)*exp(c^3)*exp(d^4); loss = exp(a+b^2+c^3+d^4); loss -> a+b^2+c^3+d^4
R(1)+R(2)^2+R(3)^3+R(4)^4 = 3.1973e+05
R(1) = 1800 R(4) = P/(R(1)*R(2)*R(3)) ans = 3.1766e+05 R =
3500.000 150.000 50.000 13.333
octave:395> R(1)+R(2)^2+R(3)^3+R(4)^4 ans = 1.8260e+05
a+b^a+c^(b^a)+d^(c^(b^a))
R(1)+R(2)^R(1)+R(3)^(R(2)^R(1))+R(4)^(R(3)^(R(2)^R(1)))
dominated by final term
try smaller numbers
P = 50 L = 4 b = log(2)/log(P) m = ((1 - b*3)/(1+2+3))^(1/1) P^(3*m + b)*P^(2*m + b)*P^(m + b) R = [P^(3*m + b) P^(2*m + b) P^(m + b)] R(3)^(R(2)^R(1)) ans = 1.9719e+294
Rr = R; R(1) = 5.1; R(3) = P/(R(1)*R(2))
R(3)^(R(2)^R(1))
R(1) = 4.9; R(3) = P/(R(1)*R(2))
R(3)^(R(2)^R(1))
R(1) = 4; octave:444> R(3) = P/(R(1)*R(2)) R =
4.0000 3.6840 3.3930
octave:445> R(3)^(R(2)^R(1)) ans = 5.4313e+97
% so this way wants evenness even more
a*b*c + b*c + c
R(1)+R(2)^2+R(3)^3+R(4)^4 seems interesting, let's optimize it
if optimal, then moving some people out of a at the expense of d won't help:
a2 = a + a' d2 = a*b*c*d/(a2*b*c) a2+b^2+c^3+d2^4 > a+b^2+c^3+d^4
simplify:
a2 = a + a' d2 = a*d/(a+a') (a+a')+b^2+c^3+(a*d/(a+a'))^4 > a+b^2+c^3+d^4
a'+(a*d/(a+a'))^4 > d^4 a'+a^4*d^4/(a+a')^4 > d^4 a'+a^4*d^4/(a+a')^4 - d^4 > 0
to first order
a^4*d^4/(a+a')^4 - d^4 > 0 a^4*d^4 - d^4*(a+a')^4 > 0
arg
let's work backwards from the power law formula
R_n = P^((q*m)^k + b)
consider when k = 1
R_n = P^(q*m + b)
find a function that is equal for each level
note: b/c of the constraint a*b*c*d = P, to switch out of a into d, we have
a*b*c*d = P (a+a')*b*c*(d+d') = P
a*b*c*d = (a+a')*b*c*(d+d') a*d = (a+a')*(d+d')
solving for d',
a*d/(a+a') = d+d' a*d/(a+a') - d = d'
in multiplicative terms,
a*b*c*d = (a*r)*b*c*(d*s) r*s = 1 s = 1/r
so we gotta find a loss formula that always increases when
R_n = P^(q*m + b)
and when you multiply R_i by r and R_j by 1/r.
if there's a log then the multiplication turns into addition
log(a)+log(b)+log(c)+log(d)
(b and c are constant, so...) log(a)+log(d) log(a*r)+log(d*1/r) log(a) + log(r)+log(d) + log(1/r)
--
there's an infinite cost if L5 is > 2, and no gain if L5 < 2...
loss(R_5) = (R_5 - 1)^\infty
now, it would suffice to penalize the others when they don't lie on a line in log space
that is, if
d = P^(m + b)
then we had better have
c = P^(2*m + b)
otherwise there's potential gain.
so, we want (with e=2)
log_P(e) = b log_P(d) = m + b
to imply
log_P(c) = 2*m + b
that is, we want
log_P(c) - log_P(d) = m = log_P(d) - log_P(e)
P^(log_P(c) - log_P(d)) = P^(log_P(d) - log_P(e)) P^log_P(c)/P^log_P(d) = P^log_P(d)/P^log_P(e) c/d = d/e = P^m
wait btw i just noticed something
P = 3.5e8; b = log(1 + 1e-10)/log(P) m = ((1 - b*4)/(1+2+3+4))^(1/1) P^(4*m + b)*P^(3*m + b)*P^(2*m + b)*P^(m + b) R = [P^(4*m + b) P^(3*m + b) P^(2*m + b) P^(m + b)]
seems to converge as that 1e-10 gets smaller. It seems to converge to
2615.9366 365.7804 51.1462 7.1517
so maybe we should use that.
test:
P = 6e9 L = ceil(log(ceil(log(P)))) + 2 b = log(1 + 1e-10)/log(P) m = ((1 - b*5)/(1+2+3+4+5))^(1/1) P^(5*m+b)*P^(4*m + b)*P^(3*m + b)*P^(2*m + b)*P^(m + b) R = [P^(5*m+b) P^(4*m + b) P^(3*m + b) P^(2*m + b) P^(m + b)]
not so good; too many levels
L = ceil(log(ceil(log(P)))) + 1 b = log(1 + 1e-10)/log(P) m = ((1 - b*4)/(1+2+3+4))^(1/1) P^(4*m + b)*P^(3*m + b)*P^(2*m + b)*P^(m + b) R = [P^(4*m + b) P^(3*m + b) P^(2*m + b) P^(m + b)]
try 3.5e8 P = 3.5e8 L = ceil(log(ceil(log(P)))) + 1 b = log(1 + 1e-10)/log(P) m = ((1 - b*3)/(1+2+3))^(1/1) P^(3*m + b)*P^(2*m + b)*P^(m + b) R = [P^(3*m + b) P^(2*m + b) P^(m + b)]
alternate idea; rather than picking # of levels, pick size of senate first and use that for slope
P = 3.5e8 b = log(1 + 1e-10)/log(P) R(1) = floor(log(P)); R(2) = R(1)^2; R(3) = R(1)^3; R(4) = R(1)^4; etc until
prod(R) >= P
code:
R = floor(log(P)); i = 1; while (prod(R) < P) i = i+1; R(i) = R(1)^i; end
now, fixing those levels, drop down the senate size until we hit a minimum
L = length(R);
while (prod(R) >= P) R = R(1) - 1; for i = 1:L R(i) = R(1)^i; end end R = R(1) + 1; for i = 1:L R(i) = R(1)^i; end
and finally, adjust the level 1 threshold
R(L) = P/prod(R(1:(L-1)))
uh, wait, this is the same as before but worse :). btw, P^0 = 1 so b should really be 0. duh :)
P = 3.5e8 m = (1/(1+2+3+4))^(1/1) P^(4*m)*P^(3*m)*P^(2*m)*P^(m) R = [P^(4*m) P^(3*m) P^(2*m) P^(m)]
R =
2615.9366 365.7804 51.1462 7.1517
note: R(4)*R(4)^2*R(4)^3*R(4)^4 = P
m = 1/10 b/c nthroot(P,10) is the size of the senate
(that is; nthroot(P,sum(1:(L-1)), where L is levels in allsenate)
P = 6e9 m = (1/(1+2+3+4))^(1/1) P^(4*m)*P^(3*m)*P^(2*m)*P^(m) R = [P^(4*m) P^(3*m) P^(2*m) P^(m)] R =
8151.9311 857.9172 90.2880 9.5020
P = 6e12 m = (1/(1+2+3+4))^(1/1) P^(4*m)*P^(3*m)*P^(2*m)*P^(m) R = [P^(4*m) P^(3*m) P^(2*m) P^(m)] R =
1.2920e+05 6.8147e+03 3.5944e+02 1.8959e+01
P = 3.5e8 m = (1/(1+2+3))^(1/1) P^(3*m)*P^(2*m)*P^(m) R = [P^(3*m) P^(2*m) P^(m)]
R =
1.8708e+04 7.0473e+02 2.6547e+01
P = 6e12 m = (1/(1+2+3))^(1/1) P^(3*m)*P^(2*m)*P^(m) R = [P^(3*m) P^(2*m) P^(m)]
R =
2.4495e+06 1.8171e+04 1.3480e+02
seems too large; if we use log as a ceiling, and if L is the number of 1 + undersenate + 1, then we have
log(P) >= nthroot(P,sum(1:L))
log(P) >= P^(1/sum(1:L))
note that d/dL(sum(1:L)) = L
so we can integrate to get the continuous analog:
\int x dx = .5*x^2
(a closer match seems to be .5*(x+.5)^2, which has the same derivative, and similar results)
so let's just use that in the level choosing calculations. if log is our upper limit,
log(P) = P^(1/(.5*(L+.5)^2)) log_P(log(P)) = 1/(.5*(L+.5)^2) 1/log_P(log(P)) = (.5*(L+.5)^2) 2/log_P(log(P)) = (L+.5)^2 sqrt(2/log_P(log(P))) = (L+.5) sqrt(2/log_P(log(P))) - .5 = L sqrt(2/(log(log(P))/log(P))) - .5 = L
x = logspace(0,10,1000); y = sqrt(2./(log(log(x))./log(x))) - .5; semilogx(x,y) % something weird happens when there is less than 3 people; that's fine :) x = logspace(log(3)/log(10),10,1000); y = sqrt(2./(log(log(x))./log(x))) - .5; semilogx(x,y) % something weird happens when there is less than 16 people; that's fine :) x = logspace(log(16)/log(10),10,1000); y = sqrt(2./(log(log(x))./log(x))) - .5; semilogx(x,y)
x = logspace(log(16)/log(10),30,1000); y = sqrt(2./(log(log(x))./log(x))) - .5; semilogx(x,y)
x = logspace(log(16)/log(10),4,1000); y = sqrt(2./(log(log(x))./log(x))) - .5; semilogx(x,y)
x = logspace(log(16)/log(10),10,1000); y = sqrt(2./(log(log(x))./log(x))) - .5; semilogx(x,y)
what if we set
1/R_n^n = constant ?
we'd have
1/R_1 = constant R_1 = 1/constant 1/R_2^2 = constant R_2^2 = 1/constant R_2 = sqrt(1/constant) ...
k = 1e5; R(1) = k; R(2) = sqrt(k); R(3) = nthroot(k, 3); prod(R)
k = 4.6e4; R(1) = k; R(2) = sqrt(k); R(3) = nthroot(k, 3); prod(R) ans = 3.5350e+08
R R =
4.6000e+04 2.1448e+02 3.5830e+01
k = 1.26e4; R(1) = k; R(2) = sqrt(k); R(3) = nthroot(k, 3); R(4) = nthroot(k, 4); prod(R) ans = 3.4869e+08 R R =
1.2600e+04 1.1225e+02 2.3270e+01 1.0595e+01
now instead of making them equal, make that the loss function
utility = \prod_{i=1}^L 1/R_i^i
for L=3, we have utility = 1/(R_1*R_2^2*R_3^3)
subbing in the population constraint,
utility = 1/(P/(R_2*R_3)*R_2^2*R_3^3) utility = 1/(P*R_2*R_3^2)
P is a constant factor that we cannot optimize so
utility = 1/(R_2*R_3^2)
which has a max at
R_2 = R_3 = 0
that can't be right; the utility is now 1/P*1/0*1/0. if we only allow it to go to 1, it says to put all the population into 1 layer, where there are the least communications losses. doubling a higher layer to 2 would more than halve our utility.
mb we want
utility = \sum_{i=1}^L 1/R_i^i
ok how about
utility = \prod log(R_n)/n
b/c:
trading off between two levels, given the constraint, means multiplying one of them by a factor j, and the other one by 1/j. So, after the log transformation, this should add the same amount to one term that it takes away from the other.
and then since there is a product being maximized, the best thing to do is to equalize the things being producted.
P = 3.5e8; b = 0 m = (1/(1+2+3+4))^(1/1) P^(4*m)*P^(3*m)*P^(2*m)*P^(m) R = [P^(4*m) P^(3*m ) P^(2*m) P^(m)];
Rr = R;
x = 1:6000; util = log(x).*nthroot(log(R(2)),2).*nthroot(log(R(3)),3).*nthroot(log(P./(x*R(2)*R(3))),4); plot(x,util); [v, maxR1] = max(util) v = 35.745 l = 2616
R = Rr; x = 1:floor(P./(R(1)*R(3))); util = log(R(1)).*nthroot(log(x),2).*nthroot(log(R(3)),3).*nthroot(log(P./(R(1)*x*R(3))),4); plot(x,util); [v, maxR2] = max(util)
R = Rr; x = 1:floor(P./(R(1)*R(2))); util = log(R(1)).*nthroot(log(R(2)),2).*nthroot(log(x),3).*nthroot(log(P./(R(1)*R(2)*x)),4); plot(x,util); [v, maxR3] = max(util)
log(R(1)).*nthroot(log(R(2)),2).*nthroot(log(R(3)),3).*nthroot(log(P./(R(1)*R(2)*R(3))),4)
% try again
P = 3.5e8; b = 0 m = (1/(1+2+3+4))^(1/1) P^(4*m)*P^(3*m)*P^(2*m)*P^(m) R = [P^(4*m) P^(3*m ) P^(2*m) P^(m)];
Rr = R;
R = Rr; x = 1:6000; util = log(x/(7.15)^4).*log(R(2)/(7.15)^3).*log(R(3)/(7.15)^2).*log(P./(x*R(2)*R(3))); plot(x,util); [v, maxR1] = max(util) v = 35.745 l = 2616
R = Rr; x = 1:floor(P./(R(1)*R(3))); util = log(R(1)/(7.15)^4).*log(x/(7.15)^3).*log(R(3)/(7.15)^2).*log(P./(R(1)*x*R(3))); plot(x,util); [v, maxR2] = max(util)
R = Rr; x = 1:floor(P./(R(1)*R(2))); util = log(R(1)/(7.15)^4).*log(R(2)/(7.15)^3).*log(x/(7.15)^2).*log(P./(R(1)*R(2)*x)); plot(x,util); [v, maxR3] = max(util)
log(R(1)/(7.15)^4).*log(R(2)/(7.15)^3).*log(R(3)/(7.15)^2).*log(P./(R(1)*R(2)*R(3)))
% try again
P = 3.5e8; b = 0 m = (1/(1+2+3+4))^(1/1) P^(4*m)*P^(3*m)*P^(2*m)*P^(m) R = [P^(4*m) P^(3*m ) P^(2*m) P^(m)];
Rr = R;
R = Rr; x = 1:6000; util = (log(x) + log(7.15)).*(log(R(2)) + log(7.15^2)).*(log(R(3)) + log(7.15^3)).*(log(P./(x*R(2)*R(3))) + log(7.15^4)); plot(x,util); [v, maxR1] = max(util) v = 9360.5 maxR1 = 2615
R = Rr; x = 1:floor(P./(R(1)*R(3))); util = (log(R(1)) + log(7.15)).*(log(x) + log(7.15^2)).*(log(R(3)) + log(7.15^3)).*(log(P./(R(1)*x*R(3))) + log(7.15^4)); plot(x,util); [v, maxR2] = max(util) v = 9360.5 maxR2 = 366
R = Rr; x = 1:floor(P./(R(1)*R(2))); util = (log(R(1)) + log(7.15)).*(log(R(2)) + log(7.15^2)).*(log(x) + log(7.15^3)).*(log(P./(R(1)*R(2)*x)) + log(7.15^4)); plot(x,util); [v, maxR3] = max(util) v = 9360.5 maxR3 = 51
R = Rr (log(R(1)) + log(7.15)).*(log(R(2)) + log(7.15^2)).*(log(R(3)) + log(7.15^3)).*(log(P./(R(1)*R(2)*R(3))) + log(7.15^4))
%% this one works!!
R = Rr; x = 1:floor(P./(R(1)*R(3))); util = (log(R(1)) + log(1e1)).*(log(x) + log(1e2)).*(log(R(3)) + log(1e3)).*(log(P./(R(1)*x*R(3))) + log(1e4)); plot(x,util); [v, maxR2] = max(util) v = 9360.5 maxR2 = 366
%% but at a miserable cost... the objective function contains the answer
R = Rr; x = 1:floor(P./(R(1)*R(3))); util = (log(R(1))).*(log(x) + log(1e1)).*(log(R(3)) + log(1e2)).*(log(P./(R(1)*x*R(3))) + log(1e3)); plot(x,util); [v, maxR2] = max(util) v = 9360.5 maxR2 = 366
%% same result
ok how about something like
loss = log(a)^2 + 2*log(b)^2 + 3*log(c)^2
now, with P fixed, we have a*b*c = P, therefore the only way you can go from one valid choice of (a,b,c) to another (a2,b2,c2) is by a sequence of choosing pairs, say (a,c), and multiplying one by one factor and the other by its reciprocal, say a2 = ka, c2 = (1/k)c.
so, we have to show that the loss function does not improve when you do an operation like that when you have a choice (a,b,c) such that a/b = b/c.
Doing this operation increases the log(a) term by the same amount as it decreases the log(c) term:
log(a2) = log(ka) = (log(k) + log(a)) log(c2) = log((1/k)c) = (log(c) - log(k))
let q=log(a), r=log(b), s=log(c)
loss = q^2 + 2*r^2 + 3*s^2
exp(q+r+s) = exp(log(a)+log(b)+log(c)) = exp(log(abc)) = abc = P therefore q+r+s= log(P)
so, this is equiv to minimizing
loss = q^2 + 2*r^2 + 3*s^2
when q+r+s = a constant
So if you are moving q to r, we have q2 = q - x, r2 = r + x. Let x be infintesimal.
d(loss)/d(x)
Setting d(loss)/d(x) = 0, we have
0 = -2q + 2*2r 2q = 2*2r q = 2r
Subbing in,
log(a) = 2*log(b)
Similarly, we would have
2r = 3s r = 3/2s log(b) = 3/2(log(c)) log(a) = 3*log(c)
so
a = b*e^2 b = c*e^(3/2) a = c*e^3
a/b = e^2 b/c = e^(3/2)
what if it were
loss = log(a)^2 + 2*log(b)^2 + 4*log(c)^2
then mb it would be
a/b = e^2 b/c = e^(4/2) = e^2
arg but do i really want to fix the scale in this way?
lets work backwards
a/b = b/c
let q=log(a), r=log(b), s=log(c)
a/b = b/c log(a) - log(b) = log(b) - log(c) q - r = r - s
in other words, q,r,s lie on a line
loss = q^2 + 2r^2 + 2qs q2 = q - x, r2 = r + x d(loss)/d(x) 0 = -2q + 4r + 2s q - r = r - s
loss = q^2 + 2r^2 - 2rs q - r = r - s
loss = q^2 + 2r^2 - 2rs -2qr q - r - r = r - s -q
loss = -rs -qr 0 = r -s -q q - r = -s
loss = rs -qr 0 = r -s -q q - r = s
now, switching from r to s
loss = rs -qr 0 = -s + r + q q + r = s
m.b. it's easier to start from orig space
loss = a^2 + m*b^2 + m^2*c^2
a = mb b = mc
again, m is already fixed
a/b = b/c ac = b^2 b^2 - ac = 0
should be derived from the results of: taking x out of a, into b, and out of b, into c
alternately, in log space,
a - b = b - c = c a = 3c b = 2c
wait, i think my conclusion way above was wrong, and an older loss fn works. the wrong part was:
log(a) = 2*log(b) log(b) = 3/2(log(c)) log(a) = 3*log(c)
so
a = b*e^2 b = c*e^(3/2) a = c*e^3
but try this with (a,c) = (10,1000) log(a) = 3*log(c) but a != c*e^3
i had translated exp(x*y) to exp(x)exp(y), actually its exp(x)^y. the correct answer is:
log(a) = 3*log(c) exp(log(a)) = exp(3*log(c)) a = (exp(log(c)))^3 a = c^3
which is indeed what we want. So i think that
loss = log(a)^2 + 2*log(b)^2 + 3*log(c)^2
is indeed a loss fn that implies this relationship!
meaning that
exp(loss) = exp(log(a)^2 + 2*log(b)^2 + 3*log(c)^2) exp(loss) = exp(log(a)^2)*exp(2*log(b)^2)*exp(3*log(c)^2) exp(loss) = exp(log(a)log(a))*exp(2*log(b)log(b))*exp(3*log(c)log(c)) exp(loss) = (exp(log(a)))^log(a)*(exp(log(b)))^(2*log(b))*(exp(log(c)))^(3*log(c)) exp(loss) = a^log(a)*b^(2log(b))*c^(3log(c))
is also good, since it's a monotonic transformation. so we may as well say
loss = a^log(a)*b^(2log(b))*c^(3log(c))
which can perhaps be interpreted as something like the chance that a voter's message will get lost as it ascends up the chain (?)
maybe the things being multiplied are odds? do odds multiply? if you have a 1 in 2 chance of it being rainy and a 1 in 3 chance of it being windy, then you have a 1 in 6 chance of it being both rainy and windy; so if the second number is the odds then i guess they do. (umm, by "odds" here, i don't mean the odds ratio; mb i should use a different term)
so, say the chance of your message surviving assembly i is only 1 in x_i (1/x_i). and say it passes through three assemblies. Now it has a chance of
(1/x_1)*(1/x_2)*(1/x_3)
or,
1/(x_1*x_2*x_3)
So, if x_i is sz_i^(i*log(sz_i)) then
our utility function is
utility = (1/a^log(a))*(1/b^(2log(b)))*(1/c^(3log(c)))
maximizing this is the same as minimizing
a^log(a)*b^(2log(b))*c^(3log(c))
and we're good to go.
So, the assumption is:
If your message passes through an assembly which is (i-1) steps away from you, and there are sz_i people in the assembly, then the chance that your message makes it through the assembly (isn't lost) is:
1/sz_i^(i*log(sz_i))
whew, finally!
check:
P = 3.5e8; b = 0 m = (1/(1+2+3+4))^(1/1) P^(4*m)*P^(3*m)*P^(2*m)*P^(m) R = [P^(4*m) P^(3*m ) P^(2*m) P^(m)];
Rr = R;
R = Rr; x = 1:floor(P./(R(2)*R(3))); %R(4) = util = (1./x.^(1.*log(x))).*(1./R(2).^(2.*log(R(2)))).*(1./R(3).^(3.*log(R(3)))).*(1./(P./(x.*R(2).*R(3))).^(4.*log((P./(x.*R(2).*R(3)))))); plot(x,util); [v, maxR1] = max(util)
R = Rr; x = 1:floor(P./(R(1)*R(3))); util = (1./R(1).^(1.*log(R(1)))).*(1./x.^(2.*log(x))).*(1./R(3).^(3.*log(R(3)))).*(1./(P./(R(1).*x.*R(3))).^(4.*log((P./(R(1).*x.*R(3)))))); plot(x,util); [v, maxR2] = max(util)
R = Rr; x = 1:floor(P./(R(1)*R(2))); util = (1./R(1).^(1.*log(R(1)))).*(1./R(2).^(2.*log(R(2)))).*(1./x.^(3.*log(x))).*(1./(P./(R(1).*R(2).*x)).^(4.*log((P./(R(1).*R(2).*x))))); plot(x,util); [v, maxR3] = max(util)
R = Rr
util = (1./R(1).^(1.*log(R(1)))).*(1./R(2).^(2.*log(R(2)))).*(1./R(3).^(3.*log(R(3)))).*(1./R(4).^(4.*log((R(4)))))
R2 = Rr
R2 = [maxR1 maxR2 maxR3] R2 =
7842 168 33
% third iteration
% 4th iteration: R2 =
6921.0000 122.0000 24.0000 8.0504
R2(4) = (P./(R(1).*R(2).*R(3)))
ummm let's do this iteration thing in code
P = 3.5e8; b = 0 m = (1/(1+2+3+4))^(1/1) P^(4*m)*P^(3*m)*P^(2*m)*P^(m) R = [P^(4*m) P^(3*m ) P^(2*m) P^(m)];
Rr = R;
for it=1:15
maxR1 = R(1); maxR2 = R(2); maxR3 = R(3);
if ~mod(it,3)
x = 1:floor(P./(R(2)*R(3))); %R(4) = util = (1./x.^(1.*log(x))).*(1./R(2).^(2.*log(R(2)))).*(1./R(3).^(3.*log(R(3)))).*(1./(P./(x.*R(2).*R(3))).^(4.*log((P./(x.*R(2).*R(3)))))); %plot(x,util); [v, maxR1] = max(util)
end
if ~mod(it+1,3)
x = 1:floor(P./(R(1)*R(3))); util = (1./R(1).^(1.*log(R(1)))).*(1./x.^(2.*log(x))).*(1./R(3).^(3.*log(R(3)))).*(1./(P./(R(1).*x.*R(3))).^(4.*log((P./(R(1).*x.*R(3)))))); %plot(x,util); [v, maxR2] = max(util)
end
if ~mod(it+2,3)
x = 1:floor(P./(R(1)*R(2))); util = (1./R(1).^(1.*log(R(1)))).*(1./R(2).^(2.*log(R(2)))).*(1./x.^(3.*log(x))).*(1./(P./(R(1).*R(2).*x)).^(4.*log((P./(R(1).*R(2).*x))))); %plot(x,util); [v, maxR3] = max(util)
end
R = [maxR1 maxR2 maxR3]; R(4) = (P./(R(1).*R(2).*R(3)))
util = (1./R(1).^(1.*log(R(1)))).*(1./R(2).^(2.*log(R(2)))).*(1./R(3).^(3.*log(R(3)))).*(1./R(4).^(4.*log((R(4)))))
end
% seems to hit a fixpoint at: 12688 113 23 10.614
% so i guess i did something wrong. oh well, time to go to sleep
---
util = (1./R(1).^(1.*log(R(1)))).*(1./R(2).^(2.*log(R(2)))).*(1./R(3).^(3.*log(R(3)))).*(1./R(4).^(4.*log((R(4)))))
loss1 = log(R(1)).^2 + 2.*log(R(2)).^2 + 3.*log(R(3)).^2 + 4.*log(R(4)).^2 util2 = 1/exp(loss1)
% this does equal util....
% and [12688 113 23 10.614] does have greater util than [2615.9366 365.7804 51.1462 7.1517]....
% so my optimization argument must be wrong...
% ok, example; the desired optimum is
R = Rr %R = % % 2615.9366 365.7804 51.1462 7.1517
util = (1./R(1).^(1.*log(R(1)))).*(1./R(2).^(2.*log(R(2)))).*(1./R(3).^(3.*log(R(3)))).*(1./R(4).^(4.*log((R(4))))) %util = 9.0028e-85
R2 = Rr; R2(1) = 2*R2(1); R2(2) = .5*R2(2); R = R2 %R = % % 5231.8732 182.8902 51.1462 7.1517
util = (1./R(1).^(1.*log(R(1)))).*(1./R(2).^(2.*log(R(2)))).*(1./R(3).^(3.*log(R(3)))).*(1./R(4).^(4.*log((R(4))))) %util = 4.9811e-83
R = Rr log(R(1)).^2 ans = 61.927 2.*log(R(2)).^2 ans = 69.668 log(R(1)).^2 + 2.*log(R(2)).^2 ans = 131.60
R(1) = 2615.9 R(2) = 365.78 log(R(1)) = 7.8694 log(R(2)) = 5.9020
R = R2 log(R(1)).^2 ans = 73.317 2.*log(R(2)).^2 ans = 54.265 log(R(1)).^2 + 2.*log(R(2)).^2 ans = 127.58
R(1) = 5231.9 R(2) = 182.89 log(R(1)) = 8.5625 log(R(2)) = 5.2089
x = 8.5625 - 7.8694 = 0.69310
a = 7.8694; b = 5.9020;
(a+x).^2 + 2 * (b-x).^2 % = 127.58, the loss for R2, as expected (a^2 + 2*a*x + x^2) + 2*(b^2 - 2*b*x + x^2) % = 127.58, the loss for R2, as expected
(a+x).^2 + 2 * (b-x).^2 - (a.^2 + 2 * b.^2) % -4.0130
xr = x x = .001 (a+x).^2 + 2 * (b-x).^2 - (a.^2 + 2 * b.^2) ans = -0.0078662
d(loss)/d(x) = 2*a + 2*x - 4*b + 2*x
(2*a + 2*x - 4*b + 2*x)*x ans = -0.0078652
0 = 2a + 2x - 4b + 2x
for small x..
0 = 2a - 4b 4b = 2a 2b = a
ummm, mb i just got the coeffs wrong?
want
a = 3c b = 2c a = (3/2)b
so want to solve
cc/ca = 3 cc/cb = 2 cb/ca = 3/2
using a,b,c and solving,
c = 3a c = 2b b = 3/2*a
setting a scale,
a = 1
c = 3 c = 2b b = 3/2
so a=1, b=3/2, c=3
ok wait tho that doesn't work -- but then, we have c = 3 rather than d =4.
so
ca = 1 cd = 4*ca = 4 cd = 2*cc cd = 3*cb
cc = cd/2 = 2 cb = cd/3 = 4/3
a = 1, b=4/3, c=4/2, d=4
check
R = Rr R =
2615.9366 365.7804 51.1462 7.1517
octave:110> log(R(1)).^2 + (4/3).*log(R(2)).^2 ans = 108.37 octave:111> R = R2 R =
5231.8732 182.8902 51.1462 7.1517
octave:112> log(R(1)).^2 + (4/3).*log(R(2)).^2 ans = 109.49
check with program
P = 3.5e8; b = 0 m = (1/(1+2+3+4))^(1/1) P^(4*m)*P^(3*m)*P^(2*m)*P^(m) R = [P^(4*m) P^(3*m ) P^(2*m) P^(m)];
Rr = R;
for it=1:15
maxR1 = R(1); maxR2 = R(2); maxR3 = R(3);
if ~mod(it,3)
x = 1:floor(P./(R(2)*R(3))); %R(4) = util = (1./x.^(1.*log(x))).*(1./R(2).^(4/3.*log(R(2)))).*(1./R(3).^(4/2.*log(R(3)))).*(1./(P./(x.*R(2).*R(3))).^(4.*log((P./(x.*R(2).*R(3)))))); %plot(x,util); [v, maxR1] = max(util)
end
if ~mod(it+1,3)
x = 1:floor(P./(R(1)*R(3))); util = (1./R(1).^(1.*log(R(1)))).*(1./x.^(4/3.*log(x))).*(1./R(3).^(4/2.*log(R(3)))).*(1./(P./(R(1).*x.*R(3))).^(4.*log((P./(R(1).*x.*R(3)))))); %plot(x,util); [v, maxR2] = max(util)
end
if ~mod(it+2,3)
x = 1:floor(P./(R(1)*R(2))); util = (1./R(1).^(1.*log(R(1)))).*(1./R(2).^(4/3.*log(R(2)))).*(1./x.^(4/2.*log(x))).*(1./(P./(R(1).*R(2).*x)).^(4.*log((P./(R(1).*R(2).*x))))); %plot(x,util); [v, maxR3] = max(util)
end
R = [maxR1 maxR2 maxR3]; R(4) = (P./(R(1).*R(2).*R(3)))
util = (1./R(1).^(1.*log(R(1)))).*(1./R(2).^(4/3.*log(R(2)))).*(1./R(3).^(4/2.*log(R(3)))).*(1./R(4).^(4.*log((R(4)))))
end
success!
so, regoing through the backwards derivation, we just have
If your message passes through an assembly which is (i-1) steps away from you, and there are sz_i people in the assembly, then the chance that your message makes it through the assembly (isn't lost) is:
1/sz_i^((L/(L-i))*log(sz_i))
Where L is the # of levels, and i ranges from 0 to L-1.
shew!
now we can evaluate the # of levels:
P = 3.5e8;
for L = 1:100 m = 1/sum(1:L); R = []; for i=1:L R(L-i+1) = P^(i*m); end
util = 1;
for i = 0:(L-1)
util = util.*(1./R(i+1).^(((L/(L-i))).*log(R(i+1))));
end
L
R
util
''end% whoops, well, utility doesn't provide good guidance here; it's always better to add more levels :(
let's try raising the level penalty
plot(1:4,[1 4/3 4/2 4], 1:4, exp(1:4)/10, 'g')
P = 3.5e8;
for L = 1:70 m = 1/sum(1:L); R = []; for i=1:L R(L-i+1) = P^(i*m); end
util = 1;
for i = 0:(L-1)
util = util.*(1./R(i+1).^((exp(i)/sum(1:L)).*log(R(i+1))));
end
L
R
util
''endumm... wait... we can't do that without rederiving a different solution based on this loss fn...
well ok that shouldnt be too hard
we've only changed the exponents, which means that the exponents in the desired function are not linear, but rather given by:
exponent_i = coeff(end)/coeff(i)
in the linear case, above, we had
exponent_0 = L/1 = 4/1 = 4 exponent_1 = L/(L/2) = 4/(4/2) = 2 exponent_2 = L/(L/3) = 4/(4/3) = 3 exponent_3 = L/(L/4) = 4/(4/4) = 1
that is,
exponent_i = (L-i)
and now we have
exponent_i = (exp(L)/sum(1:L))/(exp(i)/sum(1:L)) exponent_i = exp(L)/exp(i)
So, for instance, for 4 levels,
54 20 7 2
now we have to choose m
m = 1/sum(exp(L)./exp((1:4)-1));
R = [];
for i=1:L
R(i) = P^(exp(L)/exp(i-1)*m);
endway too strong
try sq:
m = 1/sum(L.^2./((1:4)).^2)
R = [];
for i=1:L
R(i) = P^((L.^2/i^2)*m);
endway too strong
orig again:
for L = 1:10
coeffs = fliplr((L./(1:L))) exponents = coeffs(end)./coeffs m = 1/sum(exponents)
%plot(1:L, [exponents]*m)
R = [];
for i=1:L
R(i) = P^(exponents(i)*m);
end
util = 1;
for i = 0:(L-1)
util = util.*(1./R(i+1).^(coeffs(i+1).*log(R(i+1))));
endL R util ''end
L = 4 coeffs = fliplr( ( L./((1:L).^2) ) ) exponents = coeffs(end)./coeffs m = 1/sum(exponents) plot(1:L, [exponents]*m)
% wrong way. test:
for L = 1:70
coeffs = fliplr( ( L./((1:L).^2) ) ) exponents = coeffs(end)./coeffs; m = 1/sum(exponents)
%plot(1:L, [exponents]*m)
R = [];
for i=1:L
R(i) = P^(exponents(i)*m);
end
util = 1;
for i = 0:(L-1)
util = util.*(1./R(i+1).^(coeffs(i+1).*log(R(i+1))));
endL R util ''end
L = 4 coeffs = fliplr( ( L./((1:L).^.00000000000001) ) ) exponents = coeffs(end)./coeffs m = 1/sum(exponents) plot(1:L, [exponents]*m)
L = 4 coeffs = fliplr( ( L./(log(2:(L+1))) ) ) exponents = coeffs(end)./coeffs m = 1/sum(exponents) plot(1:L, [exponents]*m)
for L = 1:70
% coeffs = fliplr( ( L./(log(1:L)) ) ) coeffs = fliplr( ( L./(log(2:(L+1))) ) ) exponents = coeffs(end)./coeffs; m = 1/sum(exponents)
%plot(1:L, [exponents]*m)
R = [];
for i=1:L
R(i) = P^(exponents(i)*m);
end
util = 1;
for i = 0:(L-1)
util = util.*(1./R(i+1).^(coeffs(i+1).*log(R(i+1))));
endL R util ''end
L = 4 coeffs = fliplr( ( L./((1:L).^.000001) ) ) exponents = coeffs(end)./coeffs m = 1/sum(exponents) plot(1:L, [exponents]*m) plot(1:L, fliplr([1./coeffs])) plot(1:4,(1:4).^.0001)
L = 4 coeffs = fliplr( ( L./((1:L).^.1) ) ) exponents = coeffs(end)./coeffs m = 1/sum(exponents) plot(1:L, [exponents]*m) plot(1:L, fliplr([1./coeffs])) plot(1:4,(1:4).^.1)
% sigmoid L = 4 coeffs = fliplr( ( L./(1./(1+exp(-(1:L)))) ) ) exponents = coeffs(end)./coeffs m = 1/sum(exponents) plot(1:L, [exponents]*m) plot(1:L, fliplr([1./coeffs]))
% super-strong sigmoid L = 4 coeffs = fliplr( ( L./(1./(1+exp(-10.*(1:L)))) ) ) exponents = coeffs(end)./coeffs m = 1/sum(exponents) plot(1:L, fliplr([1./coeffs])) plot(1:L, [exponents]*m)
for L = 1:10
coeffs = fliplr( ( L./(1./(1+exp(-10*(1:L)))) ) ) exponents = coeffs(end)./coeffs m = 1/sum(exponents)
%plot(1:L, [exponents]*m)
R = [];
for i=1:L
R(i) = P^(exponents(i)*m);
end
util = 1;
for i = 0:(L-1)
util = util.*(1./R(i+1).^(coeffs(i+1).*log(R(i+1))));
endL R util ''end
huh, looking at the exponents i'm doing something wrong. back to orig:
for L = 1:10
coeffs = fliplr((L./(1:L))) exponents = coeffs(end)./coeffs m = 1/sum(exponents)
%plot(1:L, [exponents]*m)
R = [];
for i=1:L
R(i) = P^(exponents(i)*m);
end
util = 1;
for i = 0:(L-1)
util = util.*(1./R(i+1).^(coeffs(i+1).*log(R(i+1))));
endL R util ''end
coeffs = fliplr((L./(1:L))) exponents = coeffs(end)./coeffs m = 1/sum(exponents); m*exponents
coeffs = fliplr((L./(1:L).^2)) exponents = coeffs(end)./coeffs m = 1/sum(exponents); m*exponents
for L = 1:10
coeffs = fliplr((L./(1:L).^2)) exponents = coeffs(end)./coeffs m = 1/sum(exponents)
%plot(1:L, [exponents]*m)
R = [];
for i=1:L
R(i) = P^(exponents(i)*m);
end
util = 1;
for i = 0:(L-1)
util = util.*(1./R(i+1).^(coeffs(i+1).*log(R(i+1))));
endL R util ''end
so, penalizing the later assemblies even more DOESN'T HELP; in fact, it seems to always make you want to add even more levels, because i guess the additional penalty on the last term is outweighed by the lessening of how many people are put into the last assembly.
try some more:
coeffs = fliplr((L./exp(1:L))) exponents = coeffs(end)./coeffs m = 1/sum(exponents); m*exponents
for L = 1:70
coeffs = fliplr((L./exp(1:L))) exponents = coeffs(end)./coeffs m = 1/sum(exponents)
%plot(1:L, [exponents]*m)
R = [];
for i=1:L
R(i) = P^(exponents(i)*m);
end
util = 1;
for i = 0:(L-1)
util = util.*(1./R(i+1).^(coeffs(i+1).*log(R(i+1))));
endL R util ''end
the utility asymptotes to 1
however, for high # of levels, the # of members also asymptotes! so you can round.
In the previous example, the last row of R_70 was
2.5170e+05 9.7023e+01 5.3818e+00 1.8574e+00 1.2558e+00 1.0874e+00
so, basically, that's a 3 level assembly with about
2517, 97, 5
but the prod doesn't match! i guess that "tail" did a lot after all :(. well, let's round up a bit:
2517, 97, P/(2517*97) = 1434... no...
% lets just take when the asymptote drops below 1, call that the prime minister, and then use the formula.
for L = 1:10
coeffs = fliplr((L./exp(1:L))) exponents = coeffs(end)./coeffs m = 1/sum(exponents)
%plot(1:L, [exponents]*m)
R = [];
for i=1:L
R(i) = P^(exponents(i)*m);
end
util = 1;
for i = 0:(L-1)
util = util.*(1./R(i+1).^(coeffs(i+1).*log(R(i+1))));
endL R util ''
if R(end) < 2
R = RM1;
break;
else
RM1 = R
endendnow try with less falloff:
for L = 1:70
coeffs = fliplr( ( L./(1:L) ) ) exponents = coeffs(end)./coeffs m = 1/sum(exponents)
%plot(1:L, [exponents]*m)
R = [];
for i=1:L
R(i) = P^(exponents(i)*m);
end
util = 1;
for i = 0:(L-1)
util = util.*(1./R(i+1).^(coeffs(i+1).*log(R(i+1))));
endL R util ''
if R(end) < 2
R = RM1;
break;
else
RM1 = R
endendR =
136.7782 67.7441 33.5526 16.6181 8.2307 4.0765 2.0190
% a little more falloff than that...
for L = 1:70
coeffs = fliplr( ( L./(1:L).^2 ) ) exponents = coeffs(end)./coeffs m = 1/sum(exponents)
%plot(1:L, [exponents]*m)
R = [];
for i=1:L
R(i) = P^(exponents(i)*m);
end
util = 1;
for i = 0:(L-1)
util = util.*(1./R(i+1).^(coeffs(i+1).*log(R(i+1))));
endL R util ''
if R(end) < 2
R = RM1;
break;
else
RM1 = R
endendR =
3.1090e+05 2.7616e+02 4.0765e+00
% too much.. try varying the exp base...
for L = 1:70
coeffs = fliplr( ( L./(2.^(1:L)) ) ) exponents = coeffs(end)./coeffs m = 1/sum(exponents)
%plot(1:L, [exponents]*m)
R = [];
for i=1:L
R(i) = P^(exponents(i)*m);
end
util = 1;
for i = 0:(L-1)
util = util.*(1./R(i+1).^(coeffs(i+1).*log(R(i+1))));
endL R util ''
if R(end) < 2
R = RM1;
break;
else
RM1 = R
endendR =
3.6044e+04 1.8985e+02 1.3779e+01 3.7120e+00
% still too much..
L = 4 coeffs = fliplr( ( L./((1:L).^1.5) ) ) exponents = coeffs(end)./coeffs m = 1/sum(exponents) plot(1:L, [exponents]*m)
for L = 1:70
coeffs = fliplr( ( L./(1.5.^(1:L)) ) ) exponents = coeffs(end)./coeffs m = 1/sum(exponents)
%plot(1:L, [exponents]*m)
R = [];
for i=1:L
R(i) = P^(exponents(i)*m);
end
util = 1;
for i = 0:(L-1)
util = util.*(1./R(i+1).^(coeffs(i+1).*log(R(i+1))));
endL R util ''
if R(end) < 2
R = RM1;
break;
else
RM1 = R
endendR =
1324.7017 120.6180 24.4123 8.4153 4.1373 2.5772
for L = 1:70
coeffs = fliplr( ( L./((1:L).^1.5) ) ) exponents = coeffs(end)./coeffs m = 1/sum(exponents)
%plot(1:L, [exponents]*m)
R = [];
for i=1:L
R(i) = P^(exponents(i)*m);
end
util = 1;
for i = 0:(L-1)
util = util.*(1./R(i+1).^(coeffs(i+1).*log(R(i+1))));
endL R util ''
if R(end) < 2
R = RM1;
break;
else
RM1 = R
endendR =
2436.9199 265.1101 37.5026 7.1914 2.0088
for L = 1:70
coeffs = fliplr( ( L./((1:L).^1.5) ) ) exponents = coeffs(end)./coeffs m = 1/sum(exponents)
%plot(1:L, [exponents]*m)
R = [];
for i=1:L
R(i) = P^(exponents(i)*m);
end
util = 1;
for i = 0:(L-1)
util = util.*(1./R(i+1).^(coeffs(i+1).*log(R(i+1))));
endL R util ''
if R(end) < 2
R = RM1;
break;
else
RM1 = R
endendfor L = 1:70
coeffs = fliplr( ( L./(1.75.^(1:L)) ) ) exponents = coeffs(end)./coeffs m = 1/sum(exponents)
%plot(1:L, [exponents]*m)
R = [];
for i=1:L
R(i) = P^(exponents(i)*m);
end
util = 1;
for i = 0:(L-1)
util = util.*(1./R(i+1).^(coeffs(i+1).*log(R(i+1))));
endL R util ''
if R(end) < 2
R = RM1;
break;
else
RM1 = R
endend% arg, i keep getting two really small assemblies at the end!
% look at orig again for inspiration...
for L = 1:70
coeffs = fliplr( ( L./((1:L)) ) ) exponents = coeffs(end)./coeffs m = 1/sum(exponents)
%plot(1:L, [exponents]*m)
R = [];
for i=1:L
R(i) = P^(exponents(i)*m);
end
util = 1;
for i = 0:(L-1)
util = util.*(1./R(i+1).^(coeffs(i+1).*log(R(i+1))));
endL R util ''
if R(end) < 2
R = RM1;
break;
else
RM1 = R
endend% i guess my problem is that i just think it's absurd to add a layer just to go below 7. maybe my additional layer penality isn't as reliant on the # of people in the level as i think.
% mb add util penality term for # of layers... 1/e chance of losing message per layer...
for L = 1:70
coeffs = fliplr( ( L./((1:L)) ) ); exponents = coeffs(end)./coeffs; m = 1/sum(exponents);
%plot(1:L, [exponents]*m)
R = [];
for i=1:L
R(i) = P^(exponents(i)*m);
end
util = 1;
for i = 0:(L-1)
util = util.*(1./R(i+1).^(coeffs(i+1).*log(R(i+1))));
end
util = util./factorial(factorial(L));L; R util ''
if R(end) < 2
R = RM1;
break;
else
RM1 = R;
endend% works, but oh, is it kludgey
% idea: an opposing force representing the chance that your message passes through someone whom you disagree with
coeffs = fliplr( ( L./((1:L)) ) ); exponents = coeffs(end)./coeffs; m = 1/sum(exponents);
%plot(1:L, [exponents]*m)
R = [];
for i=1:L
R(i) = P^(exponents(i)*m);
end
util = 1;
for i = 0:(L-1)
util = util.*(1./R(i+1).^(coeffs(i+1).*log(R(i+1))));
end
%util = util./factorial(factorial(L));L; R util ''
[a,b]=max((1./x.^(1.*log(x))).*(1./(P).^(log(P./x)))) a = 2.8674e-16 b = 32
[a,b]=max((1./x.^(1.1.*log(x))).*(1./(P).^(1.2*log(P./x)))) a = 8.2077e-19 b = 43 exp((2*1.1/1.2 - 1)*log(43)) ans = 22.973 octave:803> 43*22.973 ans = 987.84
P = 1000; x = 1:1000;
k1=7; k2=8; k3=10/9*k2 k4=11/10*k3
a=16; b=8; c=4; d=2;
p=a*b*c*d (2*k3/k4-1)*(2*k2/k3-1)*(2*k1/k2-1)+(2*k3/k4-1)*(k2/k3-1)+(k3/k4-1)*(2*k1/k2) %ans = 0.25000
[util,za]=max(((1./x).^(k1.*log(x))).*((1./(x.*b)).^(k2*log(b))).*((1./(x.*b.*c)).^(k3*log(c))).*((1./(p)).^(k4*log(p./(x.*b.*c)))))
[util,zb]=max(((1./a).^(k1.*log(a))).*((1./(a.*x)).^(k2*log(x))).*((1./(a.*x.*c)).^(k3*log(c))).*((1./(p)).^(k4*log(p./(a.*x.*c)))))
[util,zc]=max(((1./a).^(k1.*log(a))).*((1./(a.*b)).^(k2*log(b))).*((1./(a.*b.*x)).^(k3*log(x))).*((1./(p)).^(k4*log(p./(a.*b.*x)))))
[util,zd]=max(((1./(p./(b.*c.*x))).^(k1*log(p./(b.*c.*x)))).*((1./((p./(b.*c.*x)).*b)).^(k2*log(b))).*((1./((p./(b.*c.*x)).*b.*c)).^(k3*log(c))).*((1./((p./(b.*c.*x)).*b.*c.*x)).^(k4.*log(x))))
max([za zb zc zd] - [a b c d])
util =((1./a).^(k1.*log(a))).*((1./(a.*b)).^(k2*log(b))).*((1./(a.*b.*c)).^(k3*log(c))).*((1./(a*b*c*d)).^(k4*log(d)))
plot(1:4, [k1 k2 k3 k4], 1:4, [k1 (k1*2/3+k4*1/3) (k1*1/3+k4*2/3) k4], 'g') % shows that the derived coefficients are very close to a straight line
rba = .75 rca = .5 rda = .25
%k2 2*k1/(log(b)/(log(a))+1) 2*k1/(rba+1)
%k3 k2*(2*log(b)/log(a)+1)/(1+log(b)/log(a)+log(c)/log(a)) k2*(2*rba+1)/(1+rba+rca)
%k4 k3*(2*rca+rba+1)/(1+rba+rca+rda)
rba = .8 rca = .6 rda = .4 rea = .2
k1 = 1 k2 = 2*k1/(rba+1) k3 = k2*(2*rba+1)/(1+rba+rca) k4 = k3*(2*rca+rba+1)/(1+rba+rca+rda)
%k5? k5 = k4*(2*rda+rca+rba+1)/(1+rba+rca+rda+rea)
e=2; d=2^2; c=2^3; b=2^4; a=2^5; p=a*b*c*d*e;
[util,za]=max(((1./x).^(k1.*log(x))).*((1./(x.*b)).^(k2*log(b))).*((1./(x.*b.*c)).^(k3*log(c))).*((1./(x.*b.*c.*d)).^(k4*log(d))).*((1./(p)).^(k5*log(p./(x.*b.*c.*d)))))
[util,zb]=max(((1./a).^(k1.*log(a))).*((1./(a.*x)).^(k2*log(x))).*((1./(a.*x.*c)).^(k3*log(c))).*((1./(a.*x.*c.*d)).^(k4*log(d))).*((1./(p)).^(k5*log(p./(a.*x.*c.*d)))))
[util,zc]=max(((1./a).^(k1.*log(a))).*((1./(a.*b)).^(k2*log(b))).*((1./(a.*b.*x)).^(k3*log(x))).*((1./(a.*b.*x.*d)).^(k4*log(d))).*((1./(p)).^(k5*log(p./(a.*b.*x.*d)))))
[util,zd]=max(((1./a).^(k1.*log(a))).*((1./(a.*b)).^(k2*log(b))).*((1./(a.*b.*c)).^(k3*log(c))).*((1./(a.*b.*c.*x)).^(k4*log(x))).*((1./(p)).^(k5*log(p./(a.*b.*c.*x)))))
[util,ze]=max(((1./(p./(b.*c.*d.*x))).^(k1.*log((p./(b.*c.*d.*x))))).*((1./((p./(b.*c.*d.*x)).*b)).^(k2*log(b))).*((1./((p./(b.*c.*d.*x)).*b.*c)).^(k3*log(c))).*((1./((p./(b.*c.*d.*x)).*b.*c.*d)).^(k4*log(d))).*((1./((p./(b.*c.*d.*x)).*b.*c.*d.*x)).^(k5.*log(x))))
[util,ze]=max(((1./a).^(k1.*log(a))).*((1./(a.*(p./(a.*c.*d.*x)))).^(k2*log((p./(a.*c.*d.*x))))).*((1./(a.*(p./(a.*c.*d.*x)).*c)).^(k3*log(c))).*((1./(a.*(p./(a.*c.*d.*x)).*c.*d)).^(k4*log(d))).*((1./(a.*(p./(a.*c.*d.*x)).*c.*d.*x)).^(k5.*log(x))))
util = max(((1./a).^(k1.*log(a))).*((1./(a.*b)).^(k2*log(b))).*((1./(a.*b.*c)).^(k3*log(c))).*((1./(a.*b.*c.*d)).^(k4*log(d))).*((1./(a*b*c*d*e)).^(k5*log(e)))) % ok, my guess for the formula for k5 seems to work
k1 k1 = 1 octave:108> k2 k2 = 1.1111 octave:109> k3 k3 = 1.2037 octave:110> k4 k4 = 1.2897 octave:111> k5 k5 = 1.3757
% formula for finding the ks L = 20;
k = [];
k(1) = 1 k(2) = 2*k1/((1-1/L)+1)
for i=3:L k(i) = k(i-1)*(2*(1 - (1/L)*(i-2)) + sum(1 - (1/L).*(1:(i-3)) ) +1)/(1+sum(1 - (1/L)*(1:(i-1)) )) end
%P = 16*8*4*2; P = 3.5e8
for L = 1:70
coeffs = [];
coeffs(1) = 2; coeffs(2) = 2*coeffs(1)/((1-1/L)+1);
for i=3:L
coeffs(i) = coeffs(i-1)*(2*(1 - (1/L)*(i-2)) + sum(1 - (1/L).*(1:(i-3)) ) +1)/(1+sum(1 - (1/L)*(1:(i-1)) ));
endcoeffs
exponents = fliplr(1:L); % NOTE: this is just the power law exponents;
% the program does not calc the exponents
% based on the coeffs
m = 1/sum(exponents);%plot(1:L, [exponents]*m)
R = [];
for i=1:L
R(i) = P^(exponents(i)*m);
end
util = 1;
for i = 0:(L-1)
util = util.*(1./prod(R(1:(i+1))).^(coeffs(i+1).*log(R(i+1))));
end
%util = util./factorial(factorial(L));L; R util ''
if R(end) < 2
R = RM1;
break;
else
RM1 = R;
endenda = 8; b = 4; c = 2; p=a*b*c;
x=1:(p/c);
(a.^(log(b)).*b.^(log(c)))./(b.^log(b)).^.5 % note: this is the same as b.^(log(a)+log(c)-.5*log(b))
(x.^(log((p./(x*c)))).*(p./(x*c)).^(log(c)))./((p./(x*c)).^log((p./(x*c)))).^.5
[val,za] = max((x.^(log((p./(x.*c)))).*(p./(x.*c)).^(log(c)))./((p./(x.*c)).^log((p./(x.*c)))).^.5)
[val,za] = max((x.^(log(b)).*b.^(log((p./(x.*b)))))./(b.^log(b)).^.5) % this is meaningless rounding error; all values are the same; that is to say, this fn doesn't tell you how to trade off between a and c!
b.^(log(a)+log(c)-.5*log(b)).*c.^(log(b)+log(1)-.5*log(c))
[val,za_b] = max((p./(x.*c)).^(log(x)+log(c)-.5*log((p./(x.*c)))).*c.^(log((p./(x.*c)))+log(1)-.5*log(c))) % nope; gives 6
[val,za_b] = max(x.^(log((p./(x.*c)))-.5*log(x)).*(p./(x.*c)).^(log(x)+log(c)-.5*log((p./(x.*c)))).*c.^(log((p./(x.*c)))+log(1)-.5*log(c))) % nope; gives 5
%let's try it anyhow
%util = a.^(log(b)-.5*log(a)).*b.^(log(a)+log(c)-.5*log(b)).*c.^(log(b)+log(1)-.5*log(c))
ra = a; rb=b; rc=c;
[val_1,za_b] = max(x.^(log((p./(x.*c)))-.5*log(x)).*(p./(x.*c)).^(log(x)+log(c)-.5*log((p./(x.*c)))).*c.^(log((p./(x.*c)))+log(1)-.5*log(c))) [val_2,za_c] = max(x.^(log(b)-.5*log(x)).*b.^(log(x)+log((p./(x.*b)))-.5*log(b)).*(p./(x.*b)).^(log(b)+log(1)-.5*log((p./(x.*b))))) [val_3,zb_c] = max(a.^(log(x)-.5*log(a)).*x.^(log(a)+log((p./(a.*x)))-.5*log(x)).*(p./(a.*x)).^(log(x)+log(1)-.5*log((p./(a.*x)))))
if val_1 >= val_2 && val_2 >= val_3 disp('Trading off: a and b'); a = za_b; b = p./(a*c); printf('Achieved value %f\n', val_1'); elseif val_2 >= val_1 && val_2 >= val_3 disp('Trading off: a and c'); a = za_c; c = p./(a*b); printf('Achieved value %f\n', val_2'); elseif val_3 >= val_1 && val_3 >= val_2 disp('Trading off: b and c'); b = zb_c; c = p./(a*b); printf('Achieved value %f\n', val_3'); end
% converged for p=64 at 3, 6.4, 3.333 % starting from 4,4,4, converged for p=64 at 3, 7, 3.04
% starting from 704,704,704, converged for 3.5e8 to 32, 15520, 704 % forcing an a/c trade at that point, converged for 3.5e8 to 32, 5204, 2102 (not as high util as previously, tho)
% try without the weirdo a term:
%util = b.^(log(a)+log(c)-.5*log(b)).*c.^(log(b)+log(1)-.5*log(c))
ra = a; rb=b; rc=c;
[val_1,za_b] = max((p./(x.*c)).^(log(x)+log(c)-.5*log((p./(x.*c)))).*c.^(log((p./(x.*c)))+log(1)-.5*log(c))) [val_2,za_c] = max(b.^(log(x)+log((p./(x.*b)))-.5*log(b)).*(p./(x.*b)).^(log(b)+log(1)-.5*log((p./(x.*b))))) [val_3,zb_c] = max(x.^(log(a)+log((p./(a.*x)))-.5*log(x)).*(p./(a.*x)).^(log(x)+log(1)-.5*log((p./(a.*x)))))
if val_1 >= val_2 && val_2 >= val_3 disp('Trading off: a and b'); a = za_b; b = p./(a*c); printf('Achieved value %f\n', val_1'); elseif val_2 >= val_1 && val_2 >= val_3 disp('Trading off: a and c'); a = za_c; c = p./(a*b); printf('Achieved value %f\n', val_2'); elseif val_3 >= val_1 && val_3 >= val_2 disp('Trading off: b and c'); b = zb_c; c = p./(a*b); printf('Achieved value %f\n', val_3'); end
% converged for 3.5e8 from (8,4,2 (!?!)) to (2, 1.4e4, 1.3e4)
try with just b term, just to be sure
%util = b.^(log(a)+log(c)-.5*log(b))
util = b.^(log(a)+log(c)-.5*log(b)); [val_1,za_b] = max((p./(x.*c)).^(log(x)+log(c)-.5*log((p./(x.*c))))) [val_2,za_c] = max(b.^(log(x)+log((p./(x.*b)))-.5*log(b))) [val_3,zb_c] = max(x.^(log(a)+log((p./(a.*x)))-.5*log(x)))
if val_1 >= val_2 && val_2 >= val_3 && (val_1 - util > 1) disp('Trading off: a and b'); a = za_b; b = p./(a*c); printf('Achieved value %f\n', val_1'); elseif val_2 >= val_1 && val_2 >= val_3 && (val_2 - util > 1) disp('Trading off: a and c'); a = za_c; c = p./(a*b); printf('Achieved value %f\n', val_2'); elseif val_3 >= val_1 && val_3 >= val_2 && (val_3 - util > 1) disp('Trading off: b and c'); b = zb_c; c = p./(a*b); printf('Achieved value %f\n', val_3'); end
% converged to 3,4,5.333; yep
% try modified version (avoids noise) on other objective functions again
util = b.^(log(a)+log(c)-.5*log(b)).*c.^(log(b)+log(1)-.5*log(c)); [val_1,za_b] = max((p./(x.*c)).^(log(x)+log(c)-.5*log((p./(x.*c)))).*c.^(log((p./(x.*c)))+log(1)-.5*log(c))) [val_2,za_c] = max(b.^(log(x)+log((p./(x.*b)))-.5*log(b)).*(p./(x.*b)).^(log(b)+log(1)-.5*log((p./(x.*b))))) [val_3,zb_c] = max(x.^(log(a)+log((p./(a.*x)))-.5*log(x)).*(p./(a.*x)).^(log(x)+log(1)-.5*log((p./(a.*x)))))
if val_1 >= val_2 && val_2 >= val_3 && (val_1 - util > 1) disp('Trading off: a and b'); a = za_b; b = p./(a*c); printf('Achieved value %f\n', val_1'); elseif val_2 >= val_1 && val_2 >= val_3 && (val_2 - util > 1) disp('Trading off: a and c'); a = za_c; c = p./(a*b); printf('Achieved value %f\n', val_2'); elseif val_3 >= val_1 && val_3 >= val_2 && (val_3 - util > 1) disp('Trading off: b and c'); b = zb_c; c = p./(a*b); printf('Achieved value %f\n', val_3'); end
% converged to (2,15488,11264)
util = a.^(log(b)-.5*log(a)).*b.^(log(a)+log(c)-.5*log(b)).*c.^(log(b)+log(1)-.5*log(c)) [val_1,za_b] = max(x.^(log((p./(x.*c)))-.5*log(x)).*(p./(x.*c)).^(log(x)+log(c)-.5*log((p./(x.*c)))).*c.^(log((p./(x.*c)))+log(1)-.5*log(c))) [val_2,za_c] = max(x.^(log(b)-.5*log(x)).*b.^(log(x)+log((p./(x.*b)))-.5*log(b)).*(p./(x.*b)).^(log(b)+log(1)-.5*log((p./(x.*b))))) [val_3,zb_c] = max(a.^(log(x)-.5*log(a)).*x.^(log(a)+log((p./(a.*x)))-.5*log(x)).*(p./(a.*x)).^(log(x)+log(1)-.5*log((p./(a.*x)))))
if val_1 >= val_2 && val_2 >= val_3 && (val_1 - util > 1) disp('Trading off: a and b'); a = za_b; b = p./(a*c); printf('Achieved value %f\n', val_1'); elseif val_2 >= val_1 && val_2 >= val_3 && (val_2 - util > 1) disp('Trading off: a and c'); a = za_c; c = p./(a*b); printf('Achieved value %f\n', val_2'); elseif val_3 >= val_1 && val_3 >= val_2 && (val_3 - util > 1) disp('Trading off: b and c'); b = zb_c; c = p./(a*b); printf('Achieved value %f\n', val_3'); end
% converged to 32, 15488, 704
% try addition
util = a.^(log(b)-.5*log(a)) + b.^(log(a)+log(c)-.5*log(b)) + c.^(log(b)+log(1)-.5*log(c)); [val_1,za_b] = max(x.^(log((p./(x.*c)))-.5*log(x)) + (p./(x.*c)).^(log(x)+log(c)-.5*log((p./(x.*c)))) + c.^(log((p./(x.*c)))+log(1)-.5*log(c))) [val_2,za_c] = max(x.^(log(b)-.5*log(x)) + b.^(log(x)+log((p./(x.*b)))-.5*log(b)) + (p./(x.*b)).^(log(b)+log(1)-.5*log((p./(x.*b))))) [val_3,zb_c] = max(a.^(log(x)-.5*log(a)) + x.^(log(a)+log((p./(a.*x)))-.5*log(x)) + (p./(a.*x)).^(log(x)+log(1)-.5*log((p./(a.*x)))))
if val_1 >= val_2 && val_2 >= val_3 && (val_1 - util > 1) disp('Trading off: a and b'); a = za_b; b = p./(a*c); printf('Achieved value %f\n', val_1'); elseif val_2 >= val_1 && val_2 >= val_3 && (val_2 - util > 1) disp('Trading off: a and c'); a = za_c; c = p./(a*b); printf('Achieved value %f\n', val_2'); elseif val_3 >= val_1 && val_3 >= val_2 && (val_3 - util > 1) disp('Trading off: b and c'); b = zb_c; c = p./(a*b); printf('Achieved value %f\n', val_3'); end
% from 704,704,704, converged to 9,704,5.5068e4 % went back after i set a to 3 % went back after i set a to 20 % did not go back after i set b to 700 % after i set b to 500, went back to 10,675,5.1691e4
note: a scale free senate structure is an example of an "exponential tree", according to wikipedia's definition. but some papers define exponential tree in analogy with exponential network, meaning a network whose node degree distribution is the exponential distribution. i don't think that's what we want; in the thing i'm talking about, the HIGH degree nodes are common.
in "exponential structures for efficient cache-oblivious algorithms" the authors say "an exponential tree is a tree of O(log log N) levels where the degrees of nodes descending from the root level decrease doubly exponentially, e.g. as in the series N^(1/2), N^(1/4), N^(1/8), ..., 2." This is kind of upside-down from my thing (and the wikipedia definition), where the node degrees INCREASE as you get farther from the root
trying to find factor to compensate for the gain that you get by increasing levels
u_L = 1/(\sum_i=1^L i) u_1
so if x^2 2a^2 + (2a)^2 3(b)^2 + 2(2b)^2 + (3b)^2
then a = 1/3x b = 1/2a = 1/6x etc
2a^2+(2a)^2
(= 2/3)
3b^2 + 2(2b)^2 + (3b)^2 3(x/6)^2 + 2(2*x/6)^2 + (3x/6)^2 3/36x^2 + 2*4/36x^2 + 9/36x^2 (3+8+9)/36 = 20/36 = 10/18 = 5/9
4c^2 + 3(2c)^2 + 2(3c)^2 + (4c)^2 (4 + 3*2^2 + 2*3^2 + 4^2)/10^2 (4+12+18+16)/100 = 1/2
5d^2+4(2d)^2+3(3d)^2+2(4d)^2+(5d)^2 (5+4*2^2+3*3^2+2*4^2+5^2)/15^2 (5+16+27+32+25)/225 = 105/225 = .46666
for L=1:5 for i=1:L mi = L-i+1;
nov 08
new idea for cost:
let y_i = x_i/x_(i+1)
c_i = y_i^1.5 + y_i^.5
fix y_i = k (umm, wrong..)
c_i = k^1.5 + k^.5
why k^1.5? b/c need > k^1 in order to encourage small groups, but k^2 seems like too much
the k^.5 term discourages too many levels
ummm... this doesn't account for inhomogeneity in the levels...
maybe "the more distorted it already is, the easier it is to distort" -- or rather the opposite, "the more distorted it will be, the easier it is to distort"
c_i = c_(i+1)*k^1.5
(the PM is treated as c=1)
total cost = \sum
P = 3.5e8 S = ceil(log(P)) L = floor(sqrt(S)) - 1 k = (log(P)/log(S) - 1 - L)/sum(1:L)
c3_ = (S^(1+k*(L - 3)))^1.5 c2_ = (S^(1+k*(L - 2)))^1.5 c1_ = (S^(1+k*(L - 1)))^1.5 c0_ = (S^(1+k*(L - 0)))^1.5
c3 = 1 * c3_ c2 = c3 * c2_ c1 = c2 * c1_ c0 = c1 * c0_
c = c3 + c2 + c1 + c0
L = 4
k = (log(P)/log(S) - 1 - L)/sum(1:L)
c4_ = (S^(1+k*(L - 4)))^1.5 c3_ = (S^(1+k*(L - 3)))^1.5 c2_ = (S^(1+k*(L - 2)))^1.5 c1_ = (S^(1+k*(L - 1)))^1.5 c0_ = (S^(1+k*(L - 0)))^1.5
c4 = 1 * c4_ c3 = c4 * c3_ c2 = c3 * c2_ c1 = c2 * c1_ c0 = c1 * c0_
c = c4 + c3 + c2 + c1 + c0
L = 2
k = (log(P)/log(S) - 1 - L)/sum(1:L)
c2_ = (S^(1+k*(L - 2)))^1.5 c1_ = (S^(1+k*(L - 1)))^1.5 c0_ = (S^(1+k*(L - 0)))^1.5
c2 = 1 * c2_ c1 = c2 * c1_ c0 = c1 * c0_
c = c2 + c1 + c0
L = 1
k = (log(P)/log(S) - 1 - L)/sum(1:L)
c1_ = (S^(1+k*(L - 1)))^1.5 c0_ = (S^(1+k*(L - 0)))^1.5
c1 = 1 * c1_ c0 = c1 * c0_
c = c1 + c0
let's try linear addition of costs for a moment...
L=4
k = (log(P)/log(S) - 1 - L)/sum(1:L)
c4 = (S^(1+k*(L - 4)))^1.5 c3 = (S^(1+k*(L - 3)))^1.5 c2 = (S^(1+k*(L - 2)))^1.5 c1 = (S^(1+k*(L - 1)))^1.5 c0 = (S^(1+k*(L - 0)))^1.5
c = c4 + c3 + c2 + c1 + c0
L=3
k = (log(P)/log(S) - 1 - L)/sum(1:L)
c3 = (S^(1+k*(L - 3)))^1.5 c2 = (S^(1+k*(L - 2)))^1.5 c1 = (S^(1+k*(L - 1)))^1.5 c0 = (S^(1+k*(L - 0)))^1.5
c = c3 + c2 + c1 + c0
L=2
k = (log(P)/log(S) - 1 - L)/sum(1:L)
c2 = (S^(1+k*(L - 2)))^1.5 c1 = (S^(1+k*(L - 1)))^1.5 c0 = (S^(1+k*(L - 0)))^1.5
c = c2 + c1 + c0
L=1
k = (log(P)/log(S) - 1 - L)/sum(1:L)
c1 = (S^(1+k*(L - 1)))^1.5 c0 = (S^(1+k*(L - 0)))^1.5
c = c1 + c0
we could just add in an exponential term to make few levels...
L=4
k = (log(P)/log(S) - 1 - L)/sum(1:L)
c4 = (S^(1+k*(L - 4)))^1.5 c3 = (S^(1+k*(L - 3)))^1.5 c2 = (S^(1+k*(L - 2)))^1.5 c1 = (S^(1+k*(L - 1)))^1.5 c0 = (S^(1+k*(L - 0)))^1.5
c = c4 + c3 + c2 + c1 + c0 + exp(L)
L=3
k = (log(P)/log(S) - 1 - L)/sum(1:L)
c3 = (S^(1+k*(L - 3)))^1.5 c2 = (S^(1+k*(L - 2)))^1.5 c1 = (S^(1+k*(L - 1)))^1.5 c0 = (S^(1+k*(L - 0)))^1.5
c = c3 + c2 + c1 + c0 + exp(L)
L=2
k = (log(P)/log(S) - 1 - L)/sum(1:L)
c2 = (S^(1+k*(L - 2)))^1.5 c1 = (S^(1+k*(L - 1)))^1.5 c0 = (S^(1+k*(L - 0)))^1.5
c = c2 + c1 + c0 + exp(L)
L=1
k = (log(P)/log(S) - 1 - L)/sum(1:L)
c1 = (S^(1+k*(L - 1)))^1.5 c0 = (S^(1+k*(L - 0)))^1.5
c = c1 + c0 + exp(L)
j = 1.5
L=4
k = (log(P)/log(S) - 1 - L)/sum(1:L)
c4 = exp(4)*(S.^(1+k*(L - 4))).^j c3 = exp(3)*(S.^(1+k*(L - 3))).^j c2 = exp(2)*(S.^(1+k*(L - 2))).^j c1 = exp(1)*(S.^(1+k*(L - 1))).^j c0 = exp(0)*(S.^(1+k*(L - 0))).^j
c = c4 + c3 + c2 + c1 + c0
L=3
k = (log(P)/log(S) - 1 - L)/sum(1:L)
c3 = exp(3)*(S.^(1+k*(L - 3))).^j c2 = exp(2)*(S.^(1+k*(L - 2))).^j c1 = exp(1)*(S.^(1+k*(L - 1))).^j c0 = exp(0)*(S.^(1+k*(L - 0))).^j
c = c3 + c2 + c1 + c0
L=2
k = (log(P)/log(S) - 1 - L)/sum(1:L)
c2 = exp(2)*(S.^(1+k*(L - 2))).^j c1 = exp(1)*(S.^(1+k*(L - 1))).^j c0 = exp(0)*(S.^(1+k*(L - 0))).^j
c = c2 + c1 + c0
L=1
k = (log(P)/log(S) - 1 - L)/sum(1:L)
c1 = exp(1)*(S.^(1+k*(L - 1))).^j c0 = exp(0)*(S.^(1+k*(L - 0))).^j
c = c1 + c0
L=4
k = (log(P)/log(S) - 1 - L)/sum(1:L)
s4 = S.^(1+k*(L - 4)) s3 = S.^(1+k*(L - 3)) s2 = S.^(1+k*(L - 2)) s1 = S.^(1+k*(L - 1)) s0 = S.^(1+k*(L - 0))
c4 = s4.^(4+1) c3 = s3.^(3+1) c2 = s2.^(2+1) c1 = s1.^(1+1) c0 = s0.^(0+1)
c = c4 + c3 + c2 + c1 + c0
L=3
k = (log(P)/log(S) - 1 - L)/sum(1:L)
s3 = S.^(1+k*(L - 3)) s2 = S.^(1+k*(L - 2)) s1 = S.^(1+k*(L - 1)) s0 = S.^(1+k*(L - 0))
c3 = s3.^(3+1) c2 = s2.^(2+1) c1 = s1.^(1+1) c0 = s0.^(0+1)
c = c3 + c2 + c1 + c0
L=2
k = (log(P)/log(S) - 1 - L)/sum(1:L)
s2 = S.^(1+k*(L - 2)) s1 = S.^(1+k*(L - 1)) s0 = S.^(1+k*(L - 0))
c2 = s2.^(2+1) c1 = s1.^(1+1) c0 = s0.^(0+1)
c = c2 + c1 + c0
L=1
k = (log(P)/log(S) - 1 - L)/sum(1:L)
s1 = S.^(1+k*(L - 1)) s0 = S.^(1+k*(L - 0))
c1 = s1.^(1+1) c0 = s0.^(0+1)
c = c1 + c0
(prev is best so far today)
L=4
k = (log(P)/log(S) - 1 - L)/sum(1:L)
s4 = S.^(1+k*(L - 4)) s3 = S.^(1+k*(L - 3)) s2 = S.^(1+k*(L - 2)) s1 = S.^(1+k*(L - 1)) s0 = S.^(1+k*(L - 0))
c4 = s4 c3 = s4*s3 c2 = s4*s3*s2 c1 = s4*s3*s2*s1 c0 = s4*s3*s2*s1*s0
c = c4 + c3 + c2 + c1 + c0
L=3
k = (log(P)/log(S) - 1 - L)/sum(1:L)
s3 = S.^(1+k*(L - 3)) s2 = S.^(1+k*(L - 2)) s1 = S.^(1+k*(L - 1)) s0 = S.^(1+k*(L - 0))
c3 = s3 c2 = s3*s2 c1 = s3*s2*s1 c0 = s3*s2*s1*s0
c = c3 + c2 + c1 + c0
L=2
k = (log(P)/log(S) - 1 - L)/sum(1:L)
s2 = S.^(1+k*(L - 2)) s1 = S.^(1+k*(L - 1)) s0 = S.^(1+k*(L - 0))
c2 = s2 c1 = s2*s1 c0 = s2*s1*s0
c = c2 + c1 + c0
L=1
k = (log(P)/log(S) - 1 - L)/sum(1:L)
s1 = S.^(1+k*(L - 1)) s0 = S.^(1+k*(L - 0))
c1 = s1 c0 = s1*s0
c = c1 + c0
(prev is nogood)
j=1.5 L=4
k = (log(P)/log(S) - 1 - L)/sum(1:L)
s4 = S.^(1+k*(L - 4)) s3 = S.^(1+k*(L - 3)) s2 = S.^(1+k*(L - 2)) s1 = S.^(1+k*(L - 1)) s0 = S.^(1+k*(L - 0))
c4 = s4 c3 = s4*s3 c2 = s4*s3*s2 c1 = s4*s3*s2*s1 c0 = s4*s3*s2*s1*s0
c = c4^j + c3^j + c2^j + c1^j + c0^j
L=3
k = (log(P)/log(S) - 1 - L)/sum(1:L)
s3 = S.^(1+k*(L - 3)) s2 = S.^(1+k*(L - 2)) s1 = S.^(1+k*(L - 1)) s0 = S.^(1+k*(L - 0))
c3 = s3 c2 = s3*s2 c1 = s3*s2*s1 c0 = s3*s2*s1*s0
c = c3^j + c2^j + c1^j + c0^j
L=2
k = (log(P)/log(S) - 1 - L)/sum(1:L)
s2 = S.^(1+k*(L - 2)) s1 = S.^(1+k*(L - 1)) s0 = S.^(1+k*(L - 0))
c2 = s2 c1 = s2*s1 c0 = s2*s1*s0
c = c2^j + c1^j + c0^j
L=1
k = (log(P)/log(S) - 1 - L)/sum(1:L)
s1 = S.^(1+k*(L - 1)) s0 = S.^(1+k*(L - 0))
c1 = s1 c0 = s1*s0
c = c1^j + c0^j
should also look at 12 million (approx pop of illinois), 22 million (approx pop of texas), 66 million (approx pop of US midwest), according to http://www.factmonster.com/ipka/A0004986.html and http://www.factmonster.com/ipka/A0764220.html , both in themselves and as subunits of a U.S. senate
with the 19 person senate, 3.5e8/19 = about 18 million. so texas gets a rep if it wants... more likely, the texans will be split in various ways, but the midwest will probably get a rep..
in debian, about 400 people vote out of about 1000: http://www.debian.org/vote/2008/vote_001_voters.txt http://www.debian.org/vote/2007/vote_003_quorum.log
Footnotes:
1. by counting the names in http://www.debian.org/devel/people
2. according to according to http://physics.ucsd.edu/was-sdphul/dept/pr/gintro.html
3. According to http://en.wikipedia.org/wiki/Human_population#Forecast_of_world_population, among other places
4. 1e18 is one estimate for the population supportable by a Dyson sphere (or swarm, whatever):
To estimate the population supportable by a Dyson sphere, I'll look at energy and land. The total energy output of the sun is about 4e26 watts (according to http://www.wisegeek.com/what-is-a-dyson-sphere.htm and http://www.nada.kth.se/~asa/dysonFAQ.html). The current energy flux into the Earth is about 174e15 watts (according to http://en.wikipedia.org/wiki/Earth%27s_energy_budget). So energy-wise, a Dyson sphere would gain a factor of about 10^11 compared to the Earth. A Dyson sphere with a radius of one AU would have a surface area of at least 2.72e17 km^2, around 600 million times the surface area of the Earth. (according to http://www.nada.kth.se/~asa/dysonFAQ.html). http://users.rcn.com/jasp.javanet/dyson/ estimates a factor of about 300 million. So land-wise, that's a factor of about 10^8 compared to the Earth. So land appears to be the bottleneck. So we estimate a population gain of about 10^8. http://class.ee.iastate.edu/berleant/home/Research/Future/Course/sessionGott.html agrees with this estimate.
A current estimate for the peak population of the Earth, for the foreseeable future, is about 9e9; multiplied by 10^8, we get something on the order of 1e18.
Of course, if we were to build a Dyson sphere, other things would probably change in the meantime that would render these estimates incorrect, and perhaps someday there could be an assemblage of more than 1e18 individuals. But 1e18 is anyhow a number that is much, much, much, larger than anything we'll have to deal with in the forseeable future, so in any case, it's a ridiculously large number.
5. "voluntary constituencies"
6. For example, a budget for 2006 may be Renewed
7. I'd like to cite the twisted matrix lisquid democracy pages, but they're down and they're not in the Archive.
