Maximizing

[Richard_Marken2]

[From Rick Marken (2005.05.07.1200)]

I have recently discovered the work of Vernon Smith, the founder of "Experimental Economics" and the winner (along with Daniel Kahneman) of the 2002 Nobel in Economics. I haven't read Smith in great detail yet -- and I'm not sure I fully understand his experiments. But my sense is that what we are seeing is a phenomenon something like what is demonstrated in the CROWD program, where a group result, such as the arcs and rings of people in the CROWD program, emerges from the independent controlling of the individuals that make up the group.

Smith's experiments are simulated markets where people acting as buyers and sellers try to make contracts that meet certain requirements (in terms of the maximum the buyer can spend and the minimum the seller can accept). The markets are conducted as a sequences of auctions where the sellers announce their prices and buyers announce their bids. I'd like to watch one of these simulated market experiments to get a better idea of what's actually going on. But what seems to happen is that the contracts (perhaps it's the average contract value; I can't tell from reading the papers) seem to converge to an equilibrium value which is somewhere in the middle of the distribution maximum buyer and minimum seller prices that exist in the market. IT's this equilibrium value that seems to me to be equivalent the arcs and rings in CROWD.

Although I don't understand the details of the experiments that well, it looks to me like what Smith has created is a situation where he has a group of people -- divided into buyers and sellers -- controlling for different values of the same variable: money. Buyers are controlling for spending no more money than what they are told they can afford and sellers are controlling for getting no less money than what they are told is the cost of their product to them. Actually, sellers are told that the monetary difference between the maximum they can spend and what they actually spend is money they get to keep. If the most a buyer can spend is $100, then if he manages to contract to buy at $50, he gets $50 from the experimenter (I presume this is what Smith's grant money went for;-)). Similarly, if the least a seller can sell for to cover his costs is $100, then if he manages to contract to sell for $150, then he has also made $50 from the experimenter.

So it seems to me like buyers would be controlling for _maximizing_ the dollar amount of difference between the most they can spend and what they actually spend and sellers would be controlling for _maximizing_ the dollar amount of difference between the least they can sell for and what they actually sell for.

My problem is that I don't know how to put maximization into a model of buyers and sellers. If the variable being controlled is the difference between what can be and what actually is spent (call it t D) then maximizing (in a control system) might mean having an infinitely large reference for D, and the control system would always be acting to make D bigger than it currently is. If the variable controlled is the derivative of D (dD/dt) then maximizing might be achieved by setting a reference that keep the derivative positive. Maybe this would work better.

I know that there have been discussions of "maximization vs control" on CSGNet way back when. But I would appreciate it if someone (like Bill Powers, for example) could help me understand how to approach using PCT to model behavior that _seems_ to involved maximization.

Thanks

Rick

···

---
Richard S. Marken
marken@mindreadings.com
Home 310 474-0313
Cell 310 729-1400

[Bill_Powers1]

[From Bill Powers (2005.05.07.1345 MDT)]

Rick Marken (2005.05.07.1200)]

I have recently discovered the work of Vernon Smith, the founder of "Experimental Economics" and the winner (along with Daniel Kahneman) of the 2002 Nobel in Economics. ... Smith's experiments are simulated markets where people acting as buyers and sellers try to make contracts that meet certain requirements (in terms of the maximum the buyer can spend and the minimum the seller can accept). ... But what seems to happen is that the contracts (perhaps it's the average contract value; I can't tell from reading the papers) seem to converge to an equilibrium value which is somewhere in the middle of the distribution maximum buyer and minimum seller prices that exist in the market. IT's this equilibrium value that seems to me to be equivalent the arcs and rings in CROWD.

We can get closer than that. Appended to the text is a Turbo Pascal 7.0 program that I wrote in 1995, called Bargain2.pas. The source code includes a description of how it works. The buyer and seller set internal reference levels for the worst deal they will accept -- the seller decides on the lowest bid he will accept, the buyer decides on the highest offer he will make. I suppose these numbers could be derived from knowledge of the market, but in this program the user simply enters the two numbers. Then the bargaining begins; each party perceives a projected closing price from knowing the last bid-ask pair and uses the error to adjust the bid or ask price. It would be nice to see if the convergence to a deal (when one is made) is anything like what the players in the game do, or if the model can be made like the real case by adjusting the parameters.

The program could still use a little tweaking -- if the least acceptable bid and highest acceptable price are the same, the result is "no deal" whereas the deal should be made. Probably a "greater or less than" is needed in place of a "greater than" somewhere, or something like that. I wrote it to show to Bill Williams, but he was too busy to look at it.

Best,

Bill P.

···

==========================================================================
program bargain2;

{ Program to simulate price bidding for one item between two people.
   The bidder begins with a reference level for the highest bid, the
   asker begins with a reference level for the lowest asking price.
   The bidder moves first, bidding half of the reference value; the
   asker's initial asking price is twice the asking reference level.
   Although this program doesn't try to find regularities in the other
   person's behavior, the initial bid and ask are somewhat randomized
   to prevent such strategies.

   After an initial bid and ask, the bidder projects the closing price
   as (3*bid + ask)/4. The asker projects it as (3*ask + bid)/4. These
   proportions are adjustable parameters of the model.

   The error signal for the bidder is the bid reference signal minus
   the projected closing price; for the asker it is the ask reference
   signal minus the projected closing price. The error, divided by
   bidstep or askstep, is added to the respective old bid or ask to
   generate the new bid or ask. Bidstep and askstep are more adjustable
   parameters, determining how rapidly the bid or ask changes for a
   given amount of error.

   Bidding terminates successfully when bid > ask. If two successive
   bids and asks are the same, bidding terminates with "no deal."

   Bid must exceed ask by a small amount for a deal to be struck (a
   side-effect of the choices of parameters).
}
uses dos,crt;

var bid,ask,bidref,askref,lastbid,lastask,bidstep,askstep: real;
     done,deal: boolean;
     ch: char;

function makeadeal(bidref,askref: real): boolean;
var bidpercep,askpercep,biderr,askerr: real;

begin
  bid := bidref/2.0 + random * bidref/4.0;
  ask := 2.0*askref + random * askref/2.0;
  repeat
   writeln('Bid = ', bid:5:2,' ask = ',ask:5:2);
   bidpercep := (3*bid + ask)/4.0;
   biderr := bidref - bidpercep;
   if biderr < 0 then biderr := 0;
   lastbid := bid;
   bid := bid + biderr/bidstep;
   done := round(bid) >= round(ask);
   if not done then
   begin
    askpercep := (bid + 3*ask)/4.0;
    askerr := askref - askpercep;
    if askerr > 0 then askerr := 0;
    lastask := ask;
    ask := ask + askerr/askstep;
    done := round(ask) <= round(bid);
   end;
   deal := not (
                 (round(lastbid) = round(bid)) and
                 (round(lastask) = round(ask))
               );
  until done or (not deal) or keypressed;
  makeadeal := deal;
end;

begin
  bidstep := 2;
  askstep := 2;
  repeat
  clrscr;
  write('bid ref level = '); readln(bidref);
  write('ask ref level = '); readln(askref);
  if makeadeal(bidref,askref) then write('Deal at ') else write('no deal');
  if deal then
   begin if bid > ask then writeln(bid:5:2) else writeln(ask:5:2) end
  else writeln;
  writeln('press "q" to exit, space to do again');
  ch := readkey;
  until ch = 'q';
end.

[Richard_Marken2]

[From Rick Marken (2005.05.07.1540)]

Bill Powers (2005.05.07.1345 MDT)--

Rick Marken (2005.05.07.1200)--

I have recently discovered the work of Vernon Smith, the founder of "Experimental Economics" and the winner (along with Daniel Kahneman) of the 2002 Nobel in Economics...

We can get closer than that. Appended to the text is a Turbo Pascal 7.0 program that I wrote in 1995, called Bargain2.pas. The source code includes a description of how it works.

Thanks! Very nice and clear.

Best

Rick

···

---
Richard S. Marken
marken@mindreadings.com
Home 310 474-0313
Cell 310 729-1400