• The Black Pearl Necklace

      Friday, 18 Jan 2008 - 00:27 GMT

      This blog post is to report an interesting problem I’ve found while working with a school assignment. I’ve studied a number of Adaptive Finite Automata , doing a research similar to what Wolfram did to binary unidimensional CAs in 1981.

      In my research I found an interesting machine described by the program:

      FUN PRE F: GEN; N 1 T11 G; T1 1 N; END;
      FUN PRE G: T1 1 T11 F; T 1 T1; END;
      q1 1 q1 F; INIT q1; FINAL q1;

      I think any good hacker can find out how this language works, and what this program means… But you can run this automaton using my C++ library called adaptoide .

      I’ve created an anecdotal, mythological description of the problem, which I give below. You can find the original Portuguese version in my other blog.


      THE BLACK PEARL NECKLACE PROBLEM

      At the famous Greek island of Lesbos in the ancient Greece times, there was a young girl who was a mathematician, called Sapro. When she completed 16 years old, Sapro made an oath to give herself to a man only if he shown himself capable of solving a certain mathematical problem she proposed.

      Sapro took a string, and put in it three pearls, a black and two whites, and tied it making a necklace. (yes, it wasn’t a quite fashionable necklace…)

      Every new year of her life Sapro would untie the necklace, and make it bigger, putting new stones to form a new pattern according to the older one, picking up each bead as in a Byzantine string of prayer beads. The new beads had to be put in the following way:

      To each black pearl found in the old necklace, put it in the new necklace, and substitute the following stone by a haematite and a white pearl. (Notice this white pearl becomes the next bead to be counted.)

      Each white pearl found must be immediately passed to the new necklace.

      To each haematite found you must put a white pearl in the new necklace, discard the haematite, and replace the next bead in the old necklace by a black pearl.

      Notice that it can happen that the last bead be an haematite or a black pearl, what requires you to substitute the next bead. In this case you simple substitute the bead in the beginning of the new necklace, which are the “next ones” when you tie the string again.

      Sapro then proposed: “A man shall only have me if one day one come to me and present me with a closed algebraic formula for the number of beads in my necklace even if should I live forever as an Olympian goddess might!”

      At 16 then, her necklace had 3 beads. By 17, 5 beads, being one of it an haematite that was a pendant. At 18 years old, her necklace acquired 7 beads. It is said that by this time Theseus tried to marry Sapro, saying her necklace would acquire successive odd numbers, and foresaw 9 as the number of beads for the new necklace when the young woman would complete 19 years old.

      He was disappointed, tough, as when she did 19 years old, Sapro reformulated her necklace, and this acquired 10 beads instead of 9.

      The mathematician Hipparchus foresaw that the necklace would eventually grow with an exponential formula, with an error that would decrease exponentially and alternating between positive and negative values. This seemed accurate when Sapro had from 27 to 32 years old, but when she made 33 the error became positive two successive times. Hipparchus’ formula was

      (73/40) \times (3/2)^(n-15) .

      Sapro died this same year, at the Siege of Corinth in 146 BC, in her way to the -XXVIIIth Congress of Pure and Applied Math in Syracuse.

      The following picture shows the yearly process of updating the necklace:

      The configuration of the first of Sapro’s necklaces ever since she was 16, is below. At the left is the number of beads. (‘F’s are the black pearls, ‘o’s are the white ones, and ‘G’s are haematites.)

      3: Foo
      5: oGooF
      7: oGoFooF
      10: oGoFooFooF
      14: FoFooFooFooFoo
      21: FooFooFooFooFooFooFoo
      32: oGooFooFooFooFooFooFooFooFooFooF
      47: FoFooFooFooFooFooFooFooFooFooFooFooFooFooFooFoo
      71: oGooFooFooFooFooFooFooFooFooFooFooFooFooFooFooFooFo oFooFooFooFooFooFooF
      106: oGoFooFooFooFooFooFooFooFooFooFooFooFooFooFooFooFoo FooFooFooFooFooFooFooFooFooFooFooFooFooFooFooFooFoo FooF



      Unfortunately, you can’t marry the fictional lesbian mathematician any more. But I shall give R$5,00 to anyone how find a recursion relation, and R$10,00 for a closed formula, if it exists!... I do suspect it might be simply something involving exponentials, and modulus, such as T<-(T%n==0)?T\times p0+q0:(T%n==1)?T\times p1+q1:(T%n==2)?T\times p2+q2 …

      Last updated: Friday, 18 Jan 2008 - 00:27 GMT

        • all tags

          • No tags for this post.
      • Comments

        • Date:
          Friday, 18 Jan 2008 - 13:30 GMT
          Nicolau Werneck said:

          UPDATE:
          There are only four possible patterns:

          1. oGoo( Nx Foo)F
          2. oGo( Nx Foo)F
          3. Fo( Nx Foo)
          4. ( Nx Foo)

          Here are the first strings that I calculated, in the new abridged format.

          1. 3: ( 1 Foo)
          2. 5: oGoo( 0 Foo)F
          3. 7: oGo( 1 Foo)F
          4. 10: oGo( 2 Foo)F
          5. 14: Fo( 4 Foo)
          6. 21: ( 7 Foo)
          7. 32: oGoo( 9 Foo)F
          8. 47: Fo( 15 Foo)
          9. 71: oGoo( 22 Foo)F
          10. 106: oGo( 34 Foo)F
          11. 158: Fo( 52 Foo)
          12. 237: ( 79 Foo)
          13. 356: oGoo( 87 Foo)F
          14. 533: Fo(177 Foo)
          15. 800: oGoo(265 Foo)F
          16. 1199: Fo(399 Foo)
          17. 1799: oGoo(598 Foo)F
          18. 2698: oGo(898 Foo)F
        • Date:
          Wednesday, 30 Jan 2008 - 20:34 GMT
          Nicolau Werneck said:

          This problem has been further analysed at the NKS forum . We have found a recursion formula, but not an absolute.

        • Date:
          Friday, 08 Feb 2008 - 14:51 GMT
          Nicolau Werneck said:

          ...And here is a C++ program that can (recursively) generate the series:


          #include
          using namespace std;

          int main () {
          long unsigned int len=3, knot=3, n=0, k=0;
          while (len< (long unsigned int) -1 ) {
          if (len==knot) {
          cout.width(3); cout << k++ << ”: ”;
          cout.width(20); cout << n << “( ”;
          cout.width(1); cout << n%9 << ” mod9) – ”;
          cout << len << endl; }

          if (n%3==0) len++;
          if (knot==1) {
          knot = len;
          } else if (n%3!=0 ) knot—;

          n++;
          }
          return 0;
          }


Search blogs

web feed Want a blog?

Submit this post to

Advertisement