## Babylonian Brothers Inheritance Problems Algorithm and TCL demo example calculator, numerical analysis

### Preface

gold Here are some TCL calculations on brothers inheritance problems algorithm in calculator shell. The initial console program below was used to check the false position concept and generate testcases before loading the calculator shell.

In the cuneiform math problems and coefficient lists on clay tablets, there are coefficient numbers which were used in determining the amount of materials and the daily work rates of the workers. In most cases, the math problem is how the coefficient was used in estimating materials, work rates, and math problems. One difficulty is determining the effective magnitude or power of the number coefficient in the base 60 notation. In cuneiform, numbers in base 60 are written using a relative notation. For example, 20 could represent either 20*3600,20,20/60, 20/3600, or even 1/20. The basic dimensions and final tallies were presented in the cuneiform accounts on clay tablets, but some calculations, some units, and some problem answers (aw shucks!) were left off the tablet. Successive or iterated math solutions are called algorithms and the Babylonian methods are some of the earliest algorithms documented circa 1600 BCE. The TCL procedures are descendants of this idea. The Babylonians did not use algebra notation, decimal notation, or modern units, so the reader will have to bear some anachronisms in the TCL code. At least one approach for the modern reader and using modern terminology is to develop the implied algebraic equations and decimal equivalents from the cuneiform numbers. Then the TCL calculator can be run over a number of testcases to validate the algebraic equations.

### Introduction

The TCL calculator used Babylonian single false position methods for the brother inheritance problem, but that is probably not the only method the Babylonians could use. The Babylonians did not use algebra notation, so the reader will have to bear some anachronisms in the TCL pseudocode. Generally, the brothers inherit land or silver pieces in arithmetic progression with the eldest brother receiving the greatest share and the youngest brother the least. In the extant problems, the number (n) of brothers range from 3 to 10 brothers. Each brother received an integral fraction of his next elder in a stair step fashion. The nominal fraction was 1/<integer number of brothers>. The share of the younger brothers would be x-x/n or x*(1-1/n) in succession. Integer fractions such as <1/6,1/7,1/11> were presented as decrements in the extant problems. The normal solution was presented from elder brother to youngest brother and lowest amount, down the staircase. However, there are some brother inheritance solutions that are presented youngest to elder brother, up the staircase. In some cases, the beginning or setup of the problem is available, without a worked method of solution. Not all problems have sufficient information or initial conditions to solve the problem, however, the analysis has a bag of assumptions from similar problems. The most consistent error check should be that the sum of the brother shares should equal the original bequest.

### Calculator Algorithm

The TCL calculator computes a false share for each brother, sums the false shares, and rescales the false shares for the solution. Since the Babylonian problem is set up for integer fractions, the initial false share for elder brother is set to be factored by 1/n. Allowing for multiplication by 1/n or dividing n times for the number (n) of the brothers, the initial false share is set to n**n in the eTCL code (for the eldest brother). From an initial false share of n**n, the share x*(1-1/n) for successive brothers is calculated in an iterative solution. The stored shares are summed and the scale factor used for the false shares is real_estate over the sum of false shares.

Algebraic peg points for the brother shares and solution can be developed. The ratio of brother n-1 over n is < x*(1-1/n)*(1-1/n) > / <x*(1-1/n)> . The share of brother n-1 is ratio < x*(1-1/n)*(1-1/n) > / <x*(1-1/n)> times the share of brother n. The average of brother n-1 and n is << x*(1-1/n)*(1-1/n) > * <x*(1-1/n)> > / 2. The average of two brothers shares reduces to (1-1/n)/2. The average share for all brothers is real_estate / number of brothers, which should be in order of magnitude with the elder shares.

For the initial testcase of 5 brothers, some approximate formulas were developed. The average share for all 5 brothers was 60/5 or 12. The exact fraction for younger brother5 was <expr (1.-1./5.)*(1.-1./5.)*(1.-1./5.)*(1.-1./5.)> or 0.40960. The share of younger brother5 was elder brother1 times 0.409 was 7.2802 ( for youngest brother5). The average share between eldest and youngest is (17.85+7.3)/2 or 12.575. Within an order of magnitude , the average share between eldest and youngest approximates the average share for all 5 brothers. By observation, the average share for all 5 brothers equaled int (average share between eldest and youngest brother ). The ratios for real_estate/ number_brothers approximated (brother1 + brother5) /2. Rearranging terms, brother1 approximated 2*(real_estate/ number_brothers ) - brother5. Rearranging terms, brother5 approximated 2*(real_estate/ number_brothers ) - brother1.

There are some rules of thumb that can put outer boundaries on the brother inheritance solutions. The average for all the brothers is real_estate over number of brothers, average = <expr real_estate/ n>. The elder brother1 share approximates the average plus (1/2)* average. The younger brother_n share approximates the average minus (1/2)* average. The distance between brothers is variable on the number line, but a rough approximation for a constant distance or step between brothers is average over (n-1), <expr (real_estate/ n)/(n-1)> . An example is the testcase of 5 brothers receiving estate of 60 silver pieces by the fifth, modern notation of factor (1+1/5). The average for the 5 brothers testcase is <expr real_estate/ n>, <expr 60./5.>, or 12 silver pieces. The elder brother1 share approximates <expr average + (1/2)*average>, <expr 12+6>, 18 silver pieces. The younger brother_5 share approximates <expr average - (1/2)*average>, <expr 12-6>, 6 silver pieces. The approximate solution 6...18 puts upper and lower bounds on the textbook solution of 7.3...17.8. A constant step or slot distance between the 5 brothers would be <expr (real_estate / n)/(n-1)>, <expr (60/ 5)/(4)>, <expr (12/4>, 3. The descending 5 steps would be 18,18-3,18-3-3,18-3-3-3,18-3-3-3-3 or a sequence of 18,15,12,9,6. The stair steps of the constant step sequence 18,15,12,9,6 are within +-2 units of the textbook solution 17.8,14.2,11.4,9.1,7.3. The distances or slots between the 5 brothers were the sequence 3.6,2.8,2.3,1.8. If the elder brothers slot is known, a log solution is also possible. The natural log for (1-1/5) or 0.8 would be <log 0.8> or -0.2231. Multiplying the elder brothers step (3.6) by successive powers of exp(-.2231) should reconstitute the textbook sequence as <expr 3.6*exp(-.2231*b)> for b = 0,1,2,3 as step distances for 3.6,2.88,2.3,1.84 silver pieces. Going up the staircase from the youngest brother, the step distances are <expr 1.84*exp(+.2231*c)> for c = 0,1,2,3. These rules of thumb can put some outer boundaries on the brothers inheritance problems. Given the Babylonian roundoff of significant base_60 figures, error propagation, and obscuration on the tablets, there is bound to be some slop on the tablet solutions.

### Historic math problems

In Mathematical Cuneiform Texts, Neuberger outlined a brother inheritance problem for 5 brothers. The solution was given as a geometric series of numbers <1 4 2 8 3 14 4 16 5 20?>. The <1 2 3 4 5> are the line numbers on the tablet and omitting the line numbers, the solution was given without calculations as < 4 8 14 16 20?> with a common factor of 4 by inspection. The steps of the brother shares are constant of 4, so no decrement of the form (1+1/n) is necessary. The total inheritance is <expr 4+8+12 +16 +20?> or 60. Dividing the sequence < 4 8 14 16 20?> by the common factor 4 gives < 4 8 14 16 20?> /4 or < 1 2 3 4 5?>, which are the line numbers! Not sure the Babylonians used the line numbers to generate this problem, but the coincident numbers are suggestive. Lets look at several methods of solution for the inheritance sequence < 4 8 14 16 20?> , including those using algebra notation or not known available to the Babylonians (algebra,SFP,DFB, and building series method). For an algebra solution, 1x+2x+3x+4x+5x=60, 15*x=60, x=60/15 or 4. Algebraic series would be 1*4,2*4,3*4,4*4,5*4,=60. For the single false position with an initial guess of fp=3, 15*3=45 , SFP solution=(fx/fx(fp))*fp, (60/45)*3=(4/3)*3=4. A modern algebraic expression for double false position is solution = (e2*f1-e1*f2)/(e2-e1), with the errors as e1&e2 and the false positions as f1&f2 . For the double false position with an initial guess of f1=3 and f2=6, error e1= 15*3-60=-15, error e2=15*7-60=45, DFP solution = (e2*f1-e1*f2)/(e2-e1), (45*3)-(-15*7 )/ (45--15), DFP solution = 240/60=4. The expression expr (45*3)-(-15*7 )/ (45--15) is pastable into the eTCL console. The building series method from youngest brother up the scale is share of youngest brother equals 4 (given in problem) and difference between brothers shares is that of youngest brother (4). Initial shares are built as 4, 4+4, 4+4+4 and continue until the total shares reach 60. The available problem text defined with the youngest brother suggests that the building series method was intended for the 5 brothers. The main differences from this problem and some other inheritance problems is that the series starts or is defined with the youngest brother and that the brother shares have a constant differences (of 4), rather than decrements.

Prpfessor Friberg has reported an interesting math problem on IM 31210 #3, which has three partners sharing an uncertain amount of beer. In the text the glyphs are ki-si-ri, which is transliterated as kisiru. The Akkadian equivalent terms is sikaru “beer” or siras <BEER>. Using linguistic agglutination or extension, the ki term is linked as sprouted grain, so ki-si-ri may mean something like <sprouted grain strained beer >. The total capacity of containers(s) or jars for sharing is uncertain, it possible that the one ban <ten bowls of grain> or a larger jar are meant. A lesser possibility is that the Sumerians brewed beer or beer mash in the larger jars of 25,28,and 30 silas. Usually 300 sila of grain was valued at 1 silver piece, so the value of the product was possibly 2/60 silver piece. But the total amount of 1 ban or ten bowls do not seem to match the 7 and double 7 statements in the algorithm. The middle of the algorithm has statements "you take 7", the beer of one partner or sum of two partners is twice your beer (7), and later, you keep 14 in your mind. The Babylonian mathematicians did not use symbolic algebra, but most modern linguists try to force the tablet arguments into simultaneous equations. The seven and multiple of 7 seem to be striking against the normal Babylonian number with factors of < 2 3 5 >. There is an intuition that multiples of 7 have something to do with a weekly ration of beer for the three partners. With the middle statements, it is believed that gaming with the middle statements in the math problem could get closer to a solution.

Professor Friberg has provided commentary on an interesting math problem on IM 31210 #3, which has three partners sharing an uncertain amount of beer. Although amount is uncertain, the TCL program seems to be working correctly, if not all the method on tablet understood here. A companion problem seemed to convert " 1 ban-bi" into 60 units for solving the math problem. Kind of hokey math but the statements on the clay may lead to a starting series like this. The given of the first share is seven. The second share would twice seven would be < expr { 2*7} > or 14. For a constant increase to the third share, the third share should equal < expr { 14.*(14./7) } > or 28. The total shares would be < expr { 7+14+28.) } > or 49. Here we started with first smallest share as 7. This may be considered an alternate solution, but perhaps not a unique or only solution.

gold 6/3/2021. Professor Joran Firberg outlined a Babylonian partner or brother inheritance problem for 7 brothers sharing the available silver of 100 shekels on tablet, IM31210P2, ref Friberg, New Mathematical Cuneiform Texts, Springer 2016. Professor Firberg gives the solution as a series of integer numbers < 16 14 12 10 8 6 4 > with the commentary on the Babylonian false shares algorithm. One can see that the sum of the shares sequence as expr { 16 + 14 + 12 + 10 + 8 + 6 + 4 } returns 70 silver shekels. For the TCL calculations, the problem constraints developed a normalized sequence of brother shares or multiple ratios, starting with the eldest brother with largest share as normalized 1. Each younger brother receives a share less or subtracted as rational fraction (1/8 ). In other words, subtract expr { 1/8. } = 0.125 shekel for the next younger brothers share. The second eldest brother would receive a normalized share of expr { 1.-1/8. } = 0.875 shekels, Base_10 decimal. The normalized sequence for each brothers share is < 1. 0.875 .75 .625 .5 .375 .25 > decimal notation. The sum of the normalized sequence for each brothers share is expr { 1. + 0.875 + .75 + .625 + .5 + .375 + .25 }, 4.375. As an alternate algebraic gist of the false shares method, the equation < \$false_share * 4.375 = 70 > transposes to \$false_share = expr { 70/4.375 }, 16. Use the \$false_share of 16 to multiply the normalized sequence for brother shares and the share of eldest brother falls out as expr { 16*1 } = 16, and so on with the younger brothers. Using some alternate calculations on market rates, I posted a Math proc Template called ::math::quantity_into_ratios on the wiki. For the initial available silver of 70 pieces, eval < ::math::quantity_into_ratios 70 1. 0.875 .75 .625 .5 .375 .25 > returns < 16.0 14.0 12.0 10.0 8.0 6.0 4.0 > silver pieces. As a check, the sum of all brothers shares is expr {16.0 + 14.0 + 12.0 + 10.0 + 8.0 + 6.0 + 4.0 }, 70.

gold 6/3/2021. Professor Joran Firberg offered some commentary on a Babylonian partner or brother inheritance problem for 10 brothers sharing the available silver of 100 shekels on tablet, IM31210P7, ref Friberg, A Remarkable Collection of Babylonian Mathematical Texts. The Babylonian mathematicians are showing considerable sophistication is solving some of the constraints with the arithmetic mean. The Babylonian text reported that total of first 3 shares was 46.8 shekels. Collateral inference was that the next to eldest brother share was expr { 46.8 / 3 } = 15.6 shekels. This problem lacked some parts of a complete answer on the tablet, but believe that the available tablet content can be loaded into a provisional TCL solution in Base_10 decimal. For the TCL calculations, the problem constraints developed a normalized sequence of brother shares or multiple ratios, starting with the eldest brother with largest share as normalized 1. Each younger brother receives a share less or subtracted as fraction 0.09302 decimal. In other words, subtract 0.093023 for the next younger brothers share. The second eldest brother would receive a normalized share of expr { 1.- 0.09302 } = 0.906977 , Base_10 decimal. The normalized sequence for each brothers share is < 1. 0.90698 0.8139 0.72094 0.62792 0.5349 0.44188 0.34886 0.25584 0.16282 > decimal notation. The sum of the normalized sequence for each brothers share is expr { 1. + 0.90698 + 0.8139 + 0.72094 + 0.62792 + 0.5349 + 0.44188 0.34886 + 0.25584 + 0.16282 }, 5.8141. As an alternate algebraic gist of the false shares method, the equation < \$false_share * 5.8141 = 100 > transposes to \$false_share = expr { 100/5.8141 }, 17.1995, rounded to 17.2 shekels. Using some alternate calculations on market rates, I posted a Math proc Template called ::math::quantity_into_ratios on the wiki. For the initial available silver of 100 pieces, eval < ::math::quantity_into_ratios 100 1. 0.90698 0.8139 0.72094 0.62792 0.5349 0.44188 0.34886 0.25584 0.16282 > returns < 17.1997 15.5998 13.9988 12.3999 10.80006 9.20014 7.60022 6.0003 4.40038 2.80046 > silver pieces. As a check, the sum of all brothers shares is expr {17.1997 + 15.5998 + 13.9988 + 12.3999 +10.80006 + 9.20014 + 7.60022 + 6.0003 + 4.40038 + 2.80046}, 99.9997, rounds to 100.

```            ;# code snippet for printing IM31210P7 sequence
set sum_natural [ expr {10*(10.+1.)/2.  } ]
set share 1.
set sum 1.
set answer [list  ]
foreach val {1 2 3 4 5 6 7 8 9 }  {
set share [ expr { \$share - 0.09302 } ]
set sum [ expr { \$sum + \$share  } ]
}
puts " answer sequence =  1.  \$answer "
puts " sum \$sum "```

table 10 brothers, solution of IM31210P7 printed in tcl wiki format
quantity value comment, if any
15:testcase_number
100.0 :initial real estate
10.0 :number of brothers
1.6 :less decrement decimal
overflow table entries overflow brothers, esp for N > 5
17.2 :1 nth brother
15.6 :2 nth brother
14.0 :3 nth brother
12.4 :4 nth brother
10.8 :5 nth brother
10.0 :5.5~ nth brother mean 100/10 = 10 falls at midpoint
9.2 :6 nth brother
7.6 :7 nth brother
6.0 :8 nth brother
4.4 :9 nth brother
2.8 :10 nth brother

There was an alternate algebraic solution to the tablet solution of IM31210P7, ref Friberg. Continuing in modern terms, the arithmetic mean of the available silver was expr { 100./ 10 } = 10 shekels, at the midpoint between brother 5 and brother 6. The Babylonian text reported that total of first 3 shares was 46.8 shekels. Collateral inference was that the next to eldest brother share or brother 2 was expr { 46.8 / 3 }, 15.6 shekels. The dip or modern slope was expr {(15.6 - 10)/(9.-5.5) }, 1.5999, rounds to a dip of 1.6 shekels decimal per brother. The elder brother would be expr { 15.6 +1.6 }, 17.2 shekels. The youngest brother or brother 10 would be expr { 15.6 - 8* 1.6 }, 2.7999 rounds to 2.8. As a check, the sum of all brothers shares is expr { 17.2 15.6 14.0 12.4 10.8 9.2 7.6 6.0 4.4 2.8 }, 99.99, rounds to 100. From the formula for sum of arithmetic progressive series, the sum would be set sum_ap < expr {10./ 2.*(2.*2.8 + (10-1.)*1.6) } >, 100. set sum_natural < expr {10*(10.+1.)/2. } >,55.0

Neugebauer in MKT I (1935) published tablet Str. 362P1 that had 10 partners and ten steadily decreasing shares of total amount 100 shekels. The Babylonian text reported that there was a constant difference with the 8th share of 6 shekels. Collateral inference was that the average share was expr { ( 100/10. } = 10 shekels, effectively at the midpoint between brother 5 and 6. As an alternate algebraic gist to the tablet solution, the average dip between the midpoint at brother ~ 5.5 distance and the 8th brother was expr { ( 10-6.) / (8-5.5) }, dip was 1.6 decimal shekels per brother. A dip was 1.6 decimal shekels was 1+ 36./60 Base_60 fraction. The first brother share would be that share 6 shekels of brother 8 and the difference expr { 6.+ 7*1.6 }, 17.2. As a check, the sum of all brothers shares is expr { 17.2 15.6 14.0 12.4 10.8 9.2 7.6 6.0 4.4 2.8 }, 99.99, rounds to 100.

### Unusual Babylonian partner distribution of 13 shares

gold 6/4/2021. Professor Joran Firberg outlined a Babylonian partner or brother inheritance problem for 13 brothers sharing the available amount and uncertain defined quantity of 10 ban? on tablet, IM31210P6, ref Friberg, New Mathematical Cuneiform Texts, Springer 2016. Believe that the available tablet content can be loaded into a provisional TCL solution in Base_10 decimal. The normalized sequence for each brothers share is < 1. 0.5 0.5 0.25 0.25 0.25 0.25 0.25 0.25 0.25 0.25 0.25 0.25 > decimal notation. The sum of the normalized sequence for each brothers share is expr { 1. + 0.5 + 0.5 + 0.25 + 0.25 + 0.25 + 0.25 + 0.25 + 0.25 + 0.25 + 0.25 + 0.25 + 0.25 }, 4.5 . As an alternate algebraic gist of the false shares method, the equation < \$false_share * 4.5 = 60 > tranposes to \$false_share = expr { 60/4.5 }, 13.3333. Using some alternate calculations on market rates, the Math proc Template called ::math::quantity_into_ratios was used to check the results. For the initial available and uncertain amount of 10 ban? or 60? parts, eval < ::math::quantity_into_ratios 60 1. 1. 0.5 0.5 0.25 0.25 0.25 0.25 0.25 0.25 0.25 0.25 0.25 0.25 > returns < 13.3333 6.6666 6.6666 3.3333 3.3333 3.3333 3.3333 3.33333 3.3333 3.3333 3.3333 3.3333 3.3333 > fractions for uncertain amount of 60? parts.

My observation is that the number and distribution of shares on IM31210P6 looks similar to the work gangs in the NeoSumerian Ur 111 period. The Ur 111 tablets suggest a work gang would consist of 1 overseer, 2-3 junior accounting scribes, and 10 to 20 common workers. Some commodity price records are known for various eras in Sumerian accounts, Babylonian astronomer tablets, and partly in the coefficient lists. Craftsmen were normally paid 1 ban or 10 liters of grain. The craftsman and other wages can be calculated in terms of silver. One silver piece bought a gur or 6 ban of grain. In terms of accounting, a craftsman could be paid in 1 ban of grain, 10 liters of grain, 1/6 gur of grain, or 1/6 silver piece. Generally, unskilled workmen, field labor, or hirelings were paid on the books in 2 bowls or 1 liters of grain, 1/5 ban of grain, 1/30 gur of grain, or 1/30 silver piece. On the books, the foreman would be paid 5 ban, 50 liters of grain, 5/6 gur of grain, and 5/6 silver piece. From some accounts, the foreman was responsible was responsible for accounting for the labor, and for arranging distribution of grain, meat, cloth, and bonus goods to the higher status workers, and for furnishing bowls of hot barley gruel or hot mutton soup to the lower status workers. As an assessment, the elder brothers “pay” is 4 times the common brother “pay”, whereas in the Ur 111 tablets, the overseer pay was about 5 times the skilled craftsman in the Ur 111 tablets and the skilled craftsman was paid 5 times the common worker. From the extant tablets, the work gangs of skilled workers like potters and weavers tended to be smaller than the unskilled labor like field hands and brush cutters. The total “pay” in IM31210P6 as UR 111 wages might be assessed as expr {5 + 1 + 1 + 10*(1/5.)}, 9 ban of grain a day. 9 ban would be pretty close to the uncertain amount of 10 ban? in tablet IM31210P6. Ref Joran Friberg, New Mathematical Cuneiform Texts, Springer 2016.

### The TCL calculator provides trial solutions to other Babylonian Math problems and unusual features

Using proportions and gaming, the conventional solution from the TCL calculator might be modified or adapted to unusual features or missing calculations on a clay tablet. The clay tablet MS 1844 in the Schoyen collection has some brother inheritance calculations from about 1900 BCE, as discussed by Joran Friberg in Remarkable Collection of Babylonian Mathematical Texts. The amount of the initial inheritance is either uncertain or not given correctly on the tablet. The calculations showed 7 brothers receiving shares of 1/6 increments starting with the younger brother inheriting 2 silver pieces and going up the staircase. While the eTCL calculator normally goes down the staircase, starting with the elder brother and decrements of (1+1/6). The analysis can generate a trial solution and game the total inheritance, until the 2 silver pieces fall out for the youngest brother. Loading 60 silver, 7 brothers, and (1-1/6) decrements in the eTCL calculator gives a conventional trial solution with 4.645435 silver pieces for the younger brother. Loading 30 silver, 7 brothers, and (1-1/6) decrements in the eTCL calculator gives a conventional trial solution with 2.3227 silver pieces. Loading 25.7 silver, 7 brothers, and (1-1/6) decrements in the eTCL calculator gives a conventional trial solution with 1.989 silver pieces. Using proportions as an alternate method on the unknown total inheritance, 60/unk = 4.645/2, unk= <expr (60*2)/4.645>, total inheritance = 25.8342 silver pieces.

### Checking solutions and adapting to other Babylonian Math problems

There are some interesting checks or fudging tactics on the brother inheritance problems. The TCL calculator is using the Babylonian False Share Algorithm to solve the Brothers Inheritance problems, but that does not mean the False Share Algorithm is the only possible math solution. Especially for odd number sets of brothers, the middle brother receives close to the average share. For example, 5 brothers share an inheritance of 60 shekels at 1-1/5. From the hand calculations, the average share is expr <60./5> or 12. From the TCL calculator solution, the average share is <expr (17.84+ 14.27+ 11.42+ 9.13+7.31) /5. > or <60./5> or rounded 12. The middle brother or third brother receives 11.42 from the calculator, fairly close to 12. Assuming the middle share, one can multiply 1+1/5 or 6/5 for the fourth brother at < expr (6./5)*12 > for 14.39. The eldest brother would receive < expr 12.* (6./5) * (6./5) > or 17.27. The second brother should received less one fifth than the middle brother or < expr 12.* (4./5) >, 9.6. The fifth brother should receive a factor (4./5)*(4./5) less than the middle brother or < expr 12.* (4./5)*(4./5) >, 7.68. With rounding in base_60 to whole shekels, this approximation gets pretty close to the available tablet solutions. In fact, some of the Babylonian math problems for brothers inheritance do not show their work or the answers. So a cynic might wonder if this short cut might be used rather that the full Babylonian False Position method, which does take a lot more calculations. But for the design and checking of the TCL calculator, the important point is that there is a check or fudge that the hand calculations can use more quickly in alternate calculations.

There is one key statement in the TCL code that sets the decrement or increment: set decrement </ 1. \$integer_denominator2 >. Particularly whether that increment is positive or negative. So one can adapt the from an arithmetic sequence for the brothers to a geometric sequence or more complex formula. The linguists have found a number of geometry problems that are an set or sequence of geometric figures like triangles, squares, circles, and trapezoids that grow in size. The reported growth sequence over one set of triangles was <1 3 5 7 11 >. This is an arithmetic sequence since there is a common difference between each term. In this case, adding 2 to the previous term in the sequence gives the next term. The ratio sequence in triangle growth would be < 3/1 5/3 7/5 11/7 >. These math problems would be quite a daring challenge for the Babylonian Base_60 system of regular numbers that contain factors of 2,3, and 5. Note that the growth sequence were prime numbers and ratios of prime numbers. In some cases, the geometric growth problems are written as brothers or soldiers receiving plots of land that increase or decrease in size.

### The Arakarum Operator Stage is found in some Babylonian Algorithms

Aside from multiple operators for addition and multiplication, the Babylonian mathematicians used the Arakarum math operation. Essentially in reciprocal and algorithm operations, Arakarum means take a take reciprocal of a number N and multiply by another factor usually integer 2, 3, or some other factor, < 2./N1 >. The Arakarum is a combined term of ara for raise or multiply and karum which means factor. In the older texts, the phrases usually was Arakarum 2, Arakarum 3, and Arakarum N1 in the texts. Some example values in modern notation are < 2./N1 >, < 3./N1 >, & < 5./N1 >. But for most cuneiform texts, the factor number in the Arakarum operation was either dropped for abbreviation, assumed to be 2 , or assumed known from context.

For the Arakarum operation, multiplication is associative in that < (1/N1) * 2 = 2* (1/N1) >. So there are instances where the reciprocal is taken first and then multiplied by the factor as well as instances where the factor is applied first and then the reciprocal is taken. Sometimes the Arakarum operation was off the math tablet, so the order of multiplication and reciprocation is not known.

The Babylonian number system used regular numbers with factors of < 2,3,5 >, so multiplication by two would assure the number was changed to an even number. Not sure about the entire number line, but multiplication by some factor would ensure the new number was a factorable number and especially not a prime number. In some of the Babylonian market rate algorithms, the appearance of the Arakarum math operation is striking because there seems no purpose to the modern reader. In most instances, the Arakarum math operation is either factored back out in the line of calculations or else not reported in the answer. Whether caused by a tablet copyist error, line dropped, or scribal mistake, sometimes the Arakarum factor of 2 and other factors was sometimes introduced and not removed.

There are a number of "scratch" tablets with three or four columns of numbers which highlight the Arakarum operation. While the Arakarum operation is a mid stage in most Brothers Inheritance problems, believe that additional study on the Arakarum operation may furnish some insights into Babylonian number theory.

*Alternate Text Gist***

gold 2/28/2024 Update on Gist. Understanding the distribution of inheritance among brothers can be simplified by using some rules of thumb. These rules can provide an approximate solution, setting outer boundaries for the textbook solution.

1. First, let's calculate the average share for all the brothers. This can be done by dividing the total real estate value by the number of brothers: Average = <expr real_estate / n>

2. Next, we can approximate the elder brother's share by adding half of the average to the average itself: Elder brother's share ≈ Average + (1/2) * Average

3. Similarly, we can approximate the younger brother's share by subtracting half of the average from the average: Younger brother's share ≈ Average - (1/2) * Average To calculate the constant step or slot distance between the brothers, we can divide the average by the number of brothers minus one: Constant step = <expr (real_estate / n) / (n - 1)>

4. An example of this calculation can be seen in a test case with 5 brothers receiving an estate of 60 silver pieces. The average for this scenario would be: Average = <expr 60 / 5> = 12 silver pieces The elder brother's share would be: Elder brother's share ≈ 12 + 6 = 18 silver pieces And the younger brother's share would be: Younger brother's share ≈ 12 - 6 = 6 silver pieces The approximate solution of 6...18 silver pieces sets upper and lower bounds on the textbook solution of 7.3...17.8 silver pieces.

5. In cases where the step or slot distance between the brothers is constant, the sequence of shares can be calculated using the formula: Constant step sequence = 18, 18 - 3, 18 - 3 - 3, 18 - 3 - 3 - 3, 18 - 3 - 3 - 3 - 3 This results in a sequence of 18, 15, 12, 9, 6 silver pieces, which closely matches the textbook solution of 17.8, 14.2, 11.4, 9.1, 7.3 silver pieces.

6.The distances or slots between the brothers can also be calculated using the formula: Distance between brothers = <expr (real_estate / n) / (n - 1)> In our example, the distances would be 3.6, 2.8, 2.3, 1.8 silver pieces.

7. Alternatively, if the elder brother's slot is known, a logarithmic solution is possible. By taking the natural logarithm of (1 - 1/5), we can calculate the logarithmic step: Log step = <log (1 - 1/5)> = -0.2231 Multiplying the elder brother's step by successive powers of the exponential of the log step should reconstitute the textbook sequence: <expr 3.6 * exp(-0.2231 * b)> for b = 0, 1, 2, 3 This results in step distances of 3.6, 2.88, 2.3, 1.84 silver pieces. Going up the staircase from the youngest brother, the step distances can be calculated using the formula: <expr 1.84 * exp(+0.2231 * c)> for c = 0, 1, 2, 3

8. These rules of thumb can help put some outer boundaries on the complex brother inheritance problems. Given the Babylonian roundoff of significant base_60 figures, error propagation, and obscuration on the tablets, there is bound to be some slop on the tablet solutions.

### Conclusions

The TCL calculator is working as it stands. However, the TCL calculator was designed for a geometric series, which was carried out from the first translations that I saw. It turns out that the Babylonian mathematicians wrote problems for either arithmetic series or geometric series, reference Friberg papers. When a Babylonian mathematician says the shares decrease or increase, its difficult for the modern layman to recognize if decrements pertain to a arithmetic series or geometric series on the tablet. Also, in the more difficult Babylonian problems, the Babylonian mathematician is sitting special conditions on the second, eighth, or Nth shares. Setting special conditions on individual shares was found to be difficult to program here. However, it may be possible to install a separate subroutine for formula on arithmetic series as an alternate solution.

It is difficult to judge the impact of these historic Babylonian Brothers Inheritance problems on later mathematicians, but Al-Khuwarizmi has about a third of his original algebra work on Islamic inheritance problems. Some of the Brothers Inheritance problems involving land or striped triangles have a similar appearance to the numerical integration using trapezoidal strips or formulas. In a few cases, the Brothers Inheritance problems are asking for the total amount of land or inheritance rather than computing individual shares or the constant increase. Although not all the work problems have swank sketches or graphs, the set up of the some problems including piece wise sections suggest elements of modern numerical integration.

## Pseudocode Section

```       # using pseudocode
# possible problem instances, 3 to 10 brothers
initialize algorithm_result = 1.
nominal fraction was 1/<integer number of brothers>
eldest share is n**n, so factorable n times in Babylonian integer math
share of the younger brothers would be x-x/n or x*(1-1/n) in succession.
??? code [expr xxx*(1.-1./5.)*(1.-1./5.)*(1.-1./5.)*(1.-1./5.)*(1.-1./5.)], ?.32768?
scale factor = real_estate over the sum of false shares
check algorithm
check_sum = a+b+c+d+e = original real estate
set answers and printout with resulting values
pseudocode: need test cases > small,medium, giant
pseudocode: need testcases within range of expected operation.
pseudocode: are there any cases too small or large to be solved?
[expr (1.-1./5.)*(1.-1./5.)*(1.-1./5.)*(1.-1./5.)] =0.40960
elder brother1 * 0.409 = 7.2802 ( youngest brother5)
average share for all 5 brothers  =  60/5 = 12
average share between eldest and youngest is  (17.85+7.3)/2 or 12.575
theorem that  average share for all 5 brothers  =
int (average share between eldest and youngest )
within order of magnitude , average share between eldest and youngest
~~ average share for all 5 brothers
real_estate/ number_brothers ~~~ (brother1 + brother5) /2
brother1 ~~ 2*(real_estate/ number_brothers ) - brother5
brother5 ~~ 2*(real_estate/ number_brothers ) - brother1
```

Trial reformat of Pseudocode

```#   Trial reformat of Pseudocode
#   Babylonian Brothers Inheritance Problem Algorithm
1.  Set the number of brothers as \$number_of_brothers
2.  Calculate the decrement by dividing 1 by the integer_denominator2
3.  Calculate the inheritance by raising \$number_of_brothers to the power of \$number_of_brothers
4.  Calculate the keeper by subtracting 1 from \$number_of_brothers
5.  Initialize an empty list called keeperlist
6.  Set the variable i to the value of \$number_of_brothers
7.  Initialize the total_false_position variable to 0
8.  Start a while loop that continues until i > 0
9.  Calculate the inheritance by subtracting the product of inheritance and decrement from inheritance
10.  Check if the new inheritance is less than 0; if true, break the while loop
11.  Append the inheritance value to the keeperlist
12.  Add the inheritance value to the total_false_position variable
13.  Decrement i by 1
14.  Calculate the scale_factor by dividing the real_estate by the total_false_position
15.  Set the counter to 4
16.  Initialize an empty list called real_scaled_results
17.  Loop through each item in the keeperlist
18.  Multiply the item by the scale_factor and append the result to the real_scaled_results list
19.  Multiply the item by the scale_factor and assign the result to the variable side\$counter
20.  Increment the counter by 1
21.  If the counter is greater than 4 and less than or equal to the number of brothers, break the loop
22.  Calculate the average_all_brothers by dividing the real_estate by the number_of_brothers
23.  Calculate the upper_bound by adding the product of 0.5 and the average_all_brothers to the average_all_brothers
24.  Calculate the lower_bound by subtracting the product of 0.5 and the average_all_brothers from the average_all_brothers
25.  Calculate the bound_constant_step by dividing the real_estate by the product of the number_of_brothers and the number_of_brothers minus 1
26.  Initialize an empty list called check_if_constant_steps
27.  Set the counter5 to 0
28.  Loop through each item in the keeperlist
29.  Calculate the check_if_constant_steps by subtracting the product of the counter5 and the bound_constant_step from the upper_bound
30.  Append the result to the check_if_constant_steps list
31.  Increment the counter5 by 1
32.  End the program```

### Testcases Section

In planning any software, it is advisable to gather a number of testcases to check the results of the program. The math for the testcases can be checked by pasting statements in the TCL console. Aside from the TCL calculator display, when one presses the report button on the calculator, one will have console show access to the capacity functions (subroutines).

#### Testcase 1

table 1printed in tcl wiki format
quantity value comment, if any
1:testcase_number
60.0 :initial real estate
5.0 :number of brothers
5.0 :less fraction 1/b (usually number of brothers)
17.848 :answers: elder brother
14.278 :2nd brother
11.423 :3ird brother
9.138 :4th brother
7.310 :5th brother

``` brother brother1 inherits  500.0  false shares  but real shares are 17.848
brother brother2 inherits  400.0  false shares  but real shares are 14.278
brother brother3 inherits  320.0  false shares  but real shares are 11.423
brother brother4 inherits  256.0  false shares  but real shares are 9.138
brother brother5 inherits  204.800  false shares  but real shares are 7.310
sum of false shares is 1680.8
scale factor for false shares is 0.0356
real estate or inheritance is  60.
average for n brothers is real_estate/ brothers 12.0
upper bound is average + .5*average 18.0
lower bound is average - .5*average 6.0
bound:: constant distance or slot (real_estate/ brothers)/(brothers-1.) is 3.0
Ref. similar to YBC9856 5 brothers receive 60 shekels.
#originally published by Neugebauer and Sachs in MCT
possible Neugebauer solution 4,8,12,16,20 with constant delta.  ```

#### Testcase 2

 2: testcase_number 120.0 : initial real estate 5.0 : number of brothers 5.0 : less fraction 1/b (usually number of brothers) 35.697 : answers: elder brother 28.557 : 2nd brother 22.846 : 3ird brother 18.277 : 4th brother 14.621 : 5th brother

#### Testcase 3

 3: testcase_number 3600.0 : initial real estate 5.0 : number of brothers 5.0 : less fraction 1/b (usually number of brothers) 1070.918 : answers: elder brother 856.734 : 2nd brother 685.387 : 3ird brother 548.310 : 4th brother 438.648 : 5th brother

#### Testcase 4

table 4printed in tcl wiki format
quantity value comment, if any
4:testcase_number
60.0 :initial real estate
4.0 :number of brothers
7.0 :less fraction 1/b (usually number of brothers)
18.624 :answers: elder brother
15.963 :2nd brother
13.683 :3ird brother
11.728 :4th brother
0. :5th brother
15.0 :for check, average_all_brothers
22.5 :for check, upper_bound
7.5 :for check, lower_bound
5.0 :for check, bound_constant_step, if no 1/n less
22.5 17.5 12.5 7.5 :for check, list bound_if_constant_steps, if no 1/n less
706.905 :total false position
60.0:for check, total_false_position * sf =? initial real_estate
18.624 15.963 13.683 11.728 :list of scaled brother shares

``` 4 brothers receive 60? at fraction (1-1/7)
elder brother has 7*3 for false share.
brother brother4 inherits  294.0 (elder brother)
brother brother3 inherits  252.0
brother brother2 inherits  216.0
brother brother1 inherits  185.142 (youngest brother)
sum of false shares is 1105.836
scale factor for false shares is 0.0332
elder brother's share is (7**3)*(36.8 / 1105.836) answer = 11.414
younger brother's share is last*(36.8 / 1105.836) answer = 5.281
#  hand calculations follow  (good)
[expr (1.-1./7.)*(1.-1./7.)*(1.-1./7.)]= 0.6297
youngest brother4 = [expr  0.6297* 11.433]= 7.1993
1st brother[expr (5.*60+43.)*(2./60.)] = 11.433
2nd brother=[expr (4.*60+54.)*(2./60.)]= 9.8
3ird brother=[expr (4.*60+12.)*(2./60.)]=8.4
4th brother=[expr (3.*60+36.)*(2./60.)]= 7.2
[expr 11.43+9.8+8.4+7.2] = 36.830
Ref. MS1844, 1d, Joran Friberg, difficulty with inheritance amount```

4b:check on different changed amount of 36.8 silver pieces, ref. Friberg
11.422 :answers: elder brother
9.791 :2nd brother
8.392 :3ird brother
7.193 :4th brother

#### Testcase 5

table 5printed in tcl wiki format
quantity value comment, if any
5:testcase_number
100.0 :initial real estate
10.0 :number of brothers
10.0 :less fraction 1/b (usually number of brothers)
15.353 :answers: elder brother
13.818 :2nd brother
12.436 :3ird brother
11.192 :4th brother
10.0733 :5th brother
10.0 :for check, average_all_brothers
15.0 :for check, upper_bound
5.0 :for check, lower_bound
1.111 :for check, bound_constant_step, if no 1/n less
15.0 13.888 12.777 11.666 10.555 9.444 8.333 7.222 6.111 5.0 :for check, list bound_if_constant_steps, if no 1/n less
58618940391.0 :total false position
100.0:for check, total_false_position * sf =? initial real_estate
15.353 13.818 12.436 11.192 10.07337 9.066 8.159 7.343 6.609 5.9482 :list of scaled brother shares
overflow table entries overflow brothers, esp for N > 5
15.353 :1 nth brother
13.818 :2 nth brother
12.436 :3 nth brother
11.192 :4 nth brother
10.073 :5 nth brother
9.066 :6 nth brother
8.159 :7 nth brother
7.343 :8 nth brother
6.609 :9 nth brother
5.9482 :10 nth brother

``` 10 brothers receive 100? at fraction (1-1/10)?
brother brother1 inherits  562.5  false shares  but real shares are 15.353
brother brother2 inherits  506.25  false shares  but real shares are 13.818
brother brother3 inherits  455.625  false shares  but real shares are 12.436
brother brother4 inherits  410.0625  false shares  but real shares are 11.1926
brother brother5 inherits  369.056  false shares  but real shares are 10.0733
brother brother6 inherits  332.150  false shares  but real shares are 9.066
brother brother7 inherits  298.935  false shares  but real shares are 8.159
brother brother8 inherits  269.042  false shares  but real shares are 7.343
brother brother9 inherits  242.137  false shares  but real shares are 6.609
brother brother10 inherits  217.924  false shares  but real shares are 5.948
sum of false shares is 3663.683
scale factor for false shares is 0.0272
real estate or inheritance is  100.
average for n brothers is real_estate/ brothers 10.0
upper bound is average + .5*average 15.0
lower bound is average - .5*average 5.0
bound:: constant distance or slot (real_estate/ brothers)/(brothers-1.) is 1.111
elder brother's share is (10**3)*(100. / 5861.894) 17.059
younger brother's share is last*(100. / 5861.894) 5.948
#  hand calculations follow  (good)
average = 120/10 = 12
[expr (1.-1./10.)*(1.-1./10.)*(1.-1./10.)*(1.-1./10.)*(1.-1./10.)*(1.-1./10.)*(1.-1./10.)*(1.-1./10.)*(1.-1./10.)]=
0.38742 = factor for youngest brother.
8th brother cited as 8 silver pieces
8th brother calculated as 430.46*0.01705
or 7.3 silver pieces as computer solution stands above.
elder brother1 approximates [expr 2*(100./10.)-3.] or 17, order of magnitude
This problem has factor 1+1/n omitted or obscured,
Another problem cited factor of eleventh part or algebraic 1+1/11.
Maybe this factor should be 11 instead of 10.
Note that the 1+1/n factor may be set at a prime number,
even when there are 4 brothers, the factor is seventh or 1+1/7.
#Refs. YBC9856, problem 1, Melville YBC 9856, Muroi,
#originally published by Neugebauer and Sachs in MCT  [15:99-100].
#Refs. similar in STR362, published by Neugebauer in MKT I [14: 239-243]. ```

#### Testcase 6

table 6printed in tcl wiki format
quantity value comment, if any
6:testcase_number
72.0 :initial real estate
4.0 :number of brothers
6.0 :less fraction 1/b (usually number of brothers)
23.177 :answers: elder brother
19.314 :2nd brother
16.095 :3ird brother
13.412 :4th brother
0. :5th brother
18.0 :for check, average_all_brothers
27.0 :for check, upper_bound
9.0 :for check, lower_bound
6.0 :for check, bound_constant_step, if no 1/n less
27.0 21.0 15.0 9.0 :for check, list bound_if_constant_steps, if no 1/n less
662.716 :total false position
72.0:for check, total_false_position * sf =? initial real_estate
23.177 19.314 16.095 13.412 :list of scaled brother shares

``` 4 brothers receive 72? at fraction (1-1/6)?
This problem has the inheritance omitted or obscured.
However, almost certain number inheritance is 1 mina (60 bucks)
and some 1/6 fraction multiple,
like 66 or 72 silver pieces. Solution is not repeat not given.
brother brother1 inherits  192.0  false shares  but real shares are 26.331
brother brother2 inherits  144.0  false shares  but real shares are 19.748
brother brother3 inherits  108.0  false shares  but real shares are 14.811
brother brother4 inherits  81.0  false shares  but real shares are 11.108
sum of false shares is 525.0
scale factor for false shares is 0.137
real estate or inheritance is  72.
average for n brothers is real_estate/ brothers 18.0
upper bound is average + .5*average 27.0
lower bound is average - .5*average 9.0
bound:: constant distance or slot (real_estate/ brothers)/(brothers-1.) is 6.0
#  hand calculations follow  (good)
average = 72/4 =  18 silver pieces
[expr (1.-1./6.)*(1.-1./6.)*(1.-1./6.)] or fraction 0.5787037 for youngest brother
elder brother1 approximates [expr 2*(72./4.)-3.] or 33 silver pieces, order of magnitude
younger brother4 approximates  [expr  33*.5787] or 19.097 silver pieces, order of magnitude
Ref. MS2830, problem 1c, Joran Friberg```

#### Testcase 7

table 7printed in tcl wiki format
quantity value comment, if any
7:testcase_number
1440.0 :initial real estate
7.0 :number of brothers
7.0 :less fraction 1/b (usually number of brothers)
311.648 :answers: elder brother
267.127 :2nd brother
228.966 :3ird brother
196.257 :4th brother
168.220 :5th brother
205.714 :for check, average_all_brothers
308.571 :for check, upper_bound
102.857 :for check, lower_bound
34.285 :for check, bound_constant_step, if no 1/n less
308.571 274.285 240.0 205.714 171.428 137.142 102.857 :for check, list bound_if_constant_steps, if no 1/n less
3261642.0 :total false position
1440.0:for check, total_false_position * sf =? initial real_estate
311.648 267.127 228.966 196.257 168.220 144.188 123.590 :list of scaled brother shares
overflow table entries overflow brothers, esp for N > 5
311.648 :1 nth brother
267.127 :2 nth brother
228.966 :3 nth brother
196.257 :4 nth brother
168.220 :5 nth brother
144.188 :6 nth brother
123.590 :7 nth brother

``` 7 brothers receive 1440? at fraction (1-1/7)?
Solution is not repeat not given.
brother brother1 inherits  14406.0  false shares  but real shares are 311.648
brother brother2 inherits  12348.0  false shares  but real shares are 267.127
brother brother3 inherits  10584.0  false shares  but real shares are 228.966
brother brother4 inherits  9072.0  false shares  but real shares are 196.257
brother brother5 inherits  7776.0  false shares  but real shares are 168.220
brother brother6 inherits  6665.142  false shares  but real shares are 144.188
brother brother7 inherits  5712.979  false shares  but real shares are 123.590
sum of false shares is 66564.122
scale factor for false shares is 0.0216
real estate or inheritance is  1440.
average for n brothers is real_estate/ brothers 205.714
upper bound is average + .5*average 308.571
lower bound is average - .5*average 102.857
bound:: constant distance or slot (real_estate/ brothers)/(brothers-1.) is 34.285
# hand calculations follow (good)
average = [expr 1440./7]= 205.714 silver pieces
[expr (1.-1./7.)*(1.-1./7.)*(1.-1./7.)*(1.-1./7.)*(1.-1./7.)*(1.-1./7.)]= 0.3965
youngest brother7 ~~ [expr 0.3965 * 310.7]= 123.215 silver pieces, order of magnitude
elder brother1 approximates 310.7 silver pieces, order of magnitude
Ref. MS1844, corrected problem 1, Joran Friberg```

#### Testcase 8

table 8printed in tcl wiki format
quantity value comment, if any
8:testcase_number
61.0 :initial real estate
4.0 :number of brothers
11.0 :less fraction 1/b (usually number of brothers)
17.494 :answers: elder brother
15.903 :2nd brother
14.458 :3ird brother
13.143 :4th brother
0. :5th brother
15.25 :for check, average_all_brothers
22.875 :for check, upper_bound
7.625 :for check, lower_bound
5.083 :for check, bound_constant_step, if no 1/n less
22.875 17.791 12.708 7.625 :for check, list bound_if_constant_steps, if no 1/n less
811.485 :total false position
60.999:for check, total_false_position * sf =? initial real_estate
17.494 15.903 14.458 13.143 :list of scaled brother shares

``` 4 brothers receive 61 at fraction (1-1/11)?
Solution is not repeat not given.
brother brother1 inherits  232.727  false shares  but real shares are 17.494
brother brother2 inherits  211.570  false shares  but real shares are 15.903
brother brother3 inherits  192.336  false shares  but real shares are 14.458
brother brother4 inherits  174.851  false shares  but real shares are 13.143
sum of false shares is 811.485
scale factor for false shares is 0.0751
real estate or inheritance is  61.
average for n brothers is real_estate/ brothers 15.25
upper bound is average + .5*average 22.875
lower bound is average - .5*average 7.625
bound:: constant distance or slot (real_estate/ brothers)/(brothers-1.) is 5.0833
Ref. MS2830, problem 1e, Joran Friberg```

#### Testcase 9

table 9 Babylonian Method of False Shares printed in tcl format
quantity value comment, if any
9:testcase_number
60.0 :initial and total estate (usually 60 shekels or 1 unit)
5.0 :number of brothers
5.0 : share of 5th brother equals increment and increasing up staircase
12. : average per brother expr {60/5.} = 12
12. rule of thumb, middle brother has average share. check on answer?
X+X+X+X+X elder brother expr {5*4} = 20
X+X+X+X 2nd brother expr {4*4} = 16
X+X+X 3ird brother expr {3*4} =12
X+X 4th brother expr {2*4} = 8
X 5th brother expr {1*4} = 4
>>>>> total number of false shares <<<<<
15X solution, 5th brother = 4, etc X=expr { 60/15.} or 4
1 4 2 8 3 12 4 16 5 20 Babylonian answer with no work shown on tablet

Note: a. Reference. YBC 9856, originally published by Neugebauer and Sachs in , Also Sequences and Series in Old Babylonian Mathematics, Duncan J. Melville b. Babylonian Brothers Inheritance problems. Each brother receives a different value of false shares. The total number of false shares is scaled from the original total estate or treasure. In the early problems, each share had a constant increment or decrement from the preceding share. More complex problems in Brothers Inheritance have different and non constant increments for some brothers, representing additional simultaneous equations to be solved.

#### Testcase 10

table 10 Babylonian Method of False Shares printed in tcl format
quantity value comment, if any
10:testcase_number
100.0 :initial and total estate (usually 60 shekels or 1 unit)
10.0 :number of brothers
6.0 : share of 8th brother and increasing up staircase
10. : average per brother expr {100/10.} = 10
10. rule of thumb, middle brother has average share. check on answer?
X+X+X+X+X+X+X+X+X+X elder brother < expr { 10*1.818 } >= 18.18, rounded to 19
X+X+X+X+X+X+X+X+X 2nd brother < expr { 9*1.818 } > =16.3, rounded to 17
X+X+X+X+X+X+X+X 3ird brother < expr { 8*1.818 } > =14.5, rounded to 15
X+X+X+X+X+X+X 4th brother < expr { 7*1.818 } > = 12.726, rounded to 13
X+X+X+X+X+X 5th brother < expr { 6*1.818 } > = 10.9, rounded to 11
X+X+X+X+X :6 nth brother < expr { 5*1.818 > = 9.09, rounded to 10
X+X+X+X :7 nth brother < expr { 4*1.818 } > = 7.272, rounded to 8
X+X+X :8 nth brother < expr {3*1.818= 5.454 > , rounded to 6
X+X :9 nth brother < expr {2*1.818= 3.636 > , rounded to 4
X :10 nth brother < expr {1*1.818= 1.818 > , rounded to 2
>>>>> total number of false shares <<<<<
55X solution, 10th brother = 1.818, etc X=expr { 100/55.} or 1.818

Note: Reference. Str 362, published by Neugebauer in MKT, Also Sequences and Series in Old Babylonian Mathematics, Duncan J. Melville, also New Mathematical Cuneiform Texts, by Jöran Friberg & Farouk N.H. Al-Rawi. My solution used decimal fractions, but is slightly off the tablet & textbook solution for some unaccounted reason.

#### Testcase 11

table 11printed in tcl format
quantity value comment, if any
11:testcase_number
49.0 :initial and total estate (usually 60 shekels or 1 unit)
3.0 :number of brothers
2.0 :next share factor (usually 1-1/b, or else 1-1/c, or else 1+1/c)
28.0 :answers: elder brother
14.0 :2nd brother
7.0 :3ird brother
0. :4th brother
0. :5th brother
16.333333333333332 :for check, average_all_brothers
24.5 :for check, upper_bound
8.1666666666666661 :for check, lower_bound
8.1666666666666661 :for check, bound_constant_step, if no 1/n less
24.5 16.333333333333336 8.1666666666666679 :for check, list bound_if_constant_steps, if no 1/n less
23.625 :total false position
49.0:for check, total_false_position * sf =? initial real_estate
28.0 14.0 7.0 :list of scaled brother shares

Notes: Professor Friberg has reported an interesting math problem on IM 31210 #3, which has three partners sharing an uncertain amount of beer. Although amount is uncertain, the TCL program seems to be working correctly, if not all the method on tablet understood here. A companion problem seemed to convert " 1 ban-bi" into 60 units for solving the math problem. Here we started with first smallest share as 7. This may be considered an alternate solution, but perhaps not a unique or only solution.

### References:

• A Remarkable Collection of Babylonian Mathematical Texts, Joran Friberg,
• Chalmers University of Technology, Gothenburg, Sweden
• (major work on Babylonian inheritance problems)
• Muroi, Kazuo (1988). Inheritance problems of Babylonian mathematics.
• Historia Scientiarum , 34, 11-19
• The Algebra of Inheritance: A Rehabilitation of Al-Khuwarizmi,
• Solomon Gandz Source: Osiris, Vol. 5 (1938), pp. 319-391
• A Note to Kazuo Muroi, Inheritance Problems in
• Susa Mathematical Text No. 26, Jens Hoyrupt
• Mathematical Cuneiform Texts, Neugebauer and Sachs
• Extraction of Cube Roots in Babylonian Mathematics, Kazuo Muroi, Centaurus Volume 31, issue 3, 1988
• Babylonian Mathematical Texts II-III Author(s): A. Sachs Source: Journal of Cuneiform Studies, Vol. 6, No. 4
• (1952), pp. 151-156 Published by: The American Schools of Oriental Research
• Computing the Cube Root, Ken Turkowski, Apple Computer Technical Report #KT-32 10 February 1998
• Approximating Square Roots and Cube Roots , Ali Ibrahim Hussenom, 2014/11/04
• Aryabhata’s Root Extraction Methods, Abhishek Parakh , Louisiana State University, Aug 31st 2006
• Another Method for Extracting Cube Roots, Brian J. Shelburne,
• Dept of Math and Computer, Science Wittenberg University
• Jeanette C. Fincke* and Mathieu Ossendrijver* BM 46550 – a Late Babylonian Mathematical Tablet with
• Computations of Reciprocal Numbers,Zeitschrift für Assyriologie 2016; 106(2): 185–197
• Interpretation of reverse algorithms in several mesopotamian texts, Christine Proust
• A Geometric Algorithm with Solutions to Quadratic Equations
• in a Sumerian Juridical Document from Ur III Umma
• Joran Friberg, Chalmers University of Technology, Gothenburg, Sweden
• google search engine <Trapezoid area bisection>
• Wikipedia search engine <Trapezoid area >
• mathworld.wolfram.com, Trapezoid and right trapezoid
• Mathematical Treasure: Old Babylonian Area Calculation, uses ancient method
• Frank J. Swetz , Pennsylvania State University
• Wikipedia, see temple of Edfu, area method used as late as 200 BC in Egypt.
• Oneliner's Pie in the Sky
• One Liners
• Category Algorithm
• Babylonian Number Series and eTCL demo example calculator
• Brahmagupta Area of Cyclic Quadrilateral and eTCL demo example calculator
• Gauss Approximate Number of Primes and eTCL demo example calculator
• Land surveying in ancient Mesopotamia, M. A. R. Cooper
• Sumerian Approximate Area Quadrilateral and eTCL Slot Calculator Demo Example , numerical analysis
• Thomas G. Edwards, Using the Ancient Method of False Position to Find Solutions
• Joy B. Easton, rule of double false position
• Vera Sanford, rule of false position
• www.britannica.com, topic, mathematics trapezoid
• Sumerian Equivalency Values, Ratios, and the Law of Proportions with Demo Example Calculator
• Babylonian Sexagesimal Notation for Math on Clay Tablets in Console Example
• Babylonians Tracked Jupiter With Advanced Tools: Trapezoids, Michael Greshko, news.nationalgeographic.com
• Geometry in Babylonian Astronomy, Cluster of Excellence Topology, Humboldt University of Berlin
• Mathieu Ossendrijver: „Ancient Babylonian astronomers calculated Jupiter’s position
• from the area under a time-velocity graph“, in: Science, January 29, 2016.
• Late Babylonian Field Plans in the British Museum, books.google.com/books
• Karen Rhea Nemet-Nejat
• Late Babylonian Surface Mensuration Author(s): Marvin A. Powell Source: jstor
• translation: trapezoid in two babylonian astronomical cuneiform
• texts for jupiter (act 813 & act 817) from the seleucid era , 310 BC -75 AD
• Otto Neugebauer, Astronomical Cuneiform Texts, 3 Vols.
• Lund Humphreys, London, 1955:405,430-31.
• DeSegnac, MS 3908 A RE-CONSTRUCTION, D.A.R. DeSegnac
• A draft for an essay
• DeSegnac, MENTAL COMPUTING OF THREE ARCHAIC
• MESOPOTAMIAN PUZZLES W 20044, 35, W 20044, 20 & W 20214, essay draft
• DeSegnac, HARMONY OF NUMBERS I and II, D.A.R. DeSegnac, A draft for an essay

## Appendix Code

### appendix TCL programs and scripts

```        # pretty print from autoindent and ased editor
# Babylonian Brothers Inheritance Problems Algorithm calculator
# written on Windows XP on eTCL
# working under TCL version 8.5.6 and 1.0.1
# gold on TCL WIKI, 25jan2017
package require Tk
package require math::numtheory
namespace path {::tcl::mathop ::tcl::mathfunc math::numtheory }
set tcl_precision 17
frame .frame -relief flat -bg aquamarine4
pack .frame -side top -fill y -anchor center
set names {{} { initial estate  :} }
lappend names { number of brothers (b) :}
lappend names { next brother etc, his elder share less fraction (usually 1/b ) : }
lappend names { answers: elder brother : }
lappend names { 2nd brother :}
lappend names { 3ird brother : }
lappend names { 4th brother : }
lappend names { 5th brother   :}
foreach i {1 2 3 4 5 6 7 8} {
label .frame.label\$i -text [lindex \$names \$i] -anchor e
entry .frame.entry\$i -width 35 -textvariable side\$i
grid .frame.label\$i .frame.entry\$i -sticky ew -pady 2 -padx 1 }
proc about {} {
set msg "Calculator for Babylonian Brothers Inheritance Problems Algorithm
from TCL WIKI,
written on eTCL "
tk_messageBox -title "About" -message \$msg }
proc calculate {     } {
global side1 side2 side3 side4 side5
global side6 side7 side8
global testcase_number
global real_scaled_results number_of_brothers check_if_constant_steps
global average_all_brothers upper_bound lower_bound bound_constant_step
global total_false_position scale_factor
incr testcase_number
set side1 [* \$side1 1. ]
set side2 [* \$side2 1. ]
set side3 [* \$side3 1. ]
set side4 [* \$side4 1. ]
set side5 [* \$side5 1. ]
set side6 [* \$side6 1. ]
set side7 [* \$side7 1. ]
set side8 [* \$side8 1. ]
set real_estate \$side1
set number_of_brothers \$side2
set integer_denominator2 \$side3
# initialize placeholder answer
set result 1.
set side4 0.
set side5 0.
set side6 0.
set side7 0.
set side8 0.
#set brothers \$number_of_brothers
set decrement [/ 1. \$integer_denominator2 ]
set inheritance [** \$number_of_brothers \$number_of_brothers]
set keeper [int [- \$number_of_brothers 1] ]
set keeperlist {}
set i [int  \$number_of_brothers ]
set total_false_position 0.
while {\$i>0} {
set inheritance [- \$inheritance [* \$inheritance \$decrement]]
if { \$inheritance < 0 } { break }
#set side\$keeper \$inheritance
set keeperlist [ lappend keeperlist \$inheritance ]
set total_false_position [+ \$total_false_position \$inheritance  ]
incr i -1
}
set scale_factor [/ \$real_estate \$total_false_position ]
set counter 4
set real_scaled_results {}
foreach item \$keeperlist {
lappend real_scaled_results [* \$item \$scale_factor ]
set side\$counter [* \$item \$scale_factor ]
incr counter
if { [- \$counter 4 ] > \$number_of_brothers } {break}
}
# begin bounds and error checks
set average_all_brothers [expr \$real_estate/ \$number_of_brothers  ]
set upper_bound [+ \$average_all_brothers [* 0.5 \$average_all_brothers]]
set lower_bound [- \$average_all_brothers [* 0.5 \$average_all_brothers]]
set bound_constant_step [expr (\$real_estate/ \$number_of_brothers)/ (\$number_of_brothers-1.) ]
set check_if_constant_steps {}
set counter5 0
foreach item \$keeperlist {lappend check_if_constant_steps [- \$upper_bound [* \$counter5 \$bound_constant_step ]]
incr counter5 }
}
proc fillup {aa bb cc dd ee ff gg hh} {
.frame.entry1 insert 0 "\$aa"
.frame.entry2 insert 0 "\$bb"
.frame.entry3 insert 0 "\$cc"
.frame.entry4 insert 0 "\$dd"
.frame.entry5 insert 0 "\$ee"
.frame.entry6 insert 0 "\$ff"
.frame.entry7 insert 0 "\$gg"
.frame.entry8 insert 0 "\$hh"
}
proc clearx {} {
foreach i {1 2 3 4 5 6 7 8 } {
.frame.entry\$i delete 0 end } }
proc reportx {} {
global side1 side2 side3 side4 side5
global side6 side7 side8
global testcase_number
global real_scaled_results number_of_brothers check_if_constant_steps
global average_all_brothers upper_bound lower_bound bound_constant_step
global total_false_position scale_factor
console show;
puts "%|table \$testcase_number|printed in| tcl wiki format|% "
puts "&| quantity| value| comment, if any|& "
puts "&| \$testcase_number:|testcase_number | |& "
puts "&| \$side1 :|initial real estate   |   |&"
puts "&| \$side2 :|number of brothers | |& "
puts "&| \$side3 :|less fraction 1/b (usually number of brothers) | |& "
puts "&| \$side4 :|answers: elder brother   | |&"
puts "&| \$side5 :|2nd brother | |&"
puts "&| \$side6 :|3ird brother |  |&"
puts "&| \$side7 :|4th brother  |  |&"
puts "&| \$side8 :|5th brother  |  |&"
puts "&| \$average_all_brothers :|for check, average_all_brothers |  |&"
puts "&| \$upper_bound  :|for check, upper_bound  |  |&"
puts "&| \$lower_bound :|for check, lower_bound  |  |&"
puts "&| \$bound_constant_step :|for check, bound_constant_step, if no 1/n less  |  |&"
puts "&| \$check_if_constant_steps :|for check, list bound_if_constant_steps, if no 1/n less  |  |&"
puts "&| \$total_false_position :|total false position |  |&"
puts "&| [* \$total_false_position \$scale_factor]:|for check, total_false_position * sf =? initial real_estate | |&"
puts "&| \$real_scaled_results :|list of scaled brother shares  |  |&"
# begin following for overflow brothers,  esp for brothers N > 5
set counter 1
if {\$number_of_brothers > 5 } {puts "&| overflow table entries |overflow brothers, esp for N > 5  |  |&"}
foreach item \$real_scaled_results {
if {\$number_of_brothers < 6 } {break}
puts "&| \$item :|\$counter nth brother  |  |&"
incr counter 1
if { \$counter > \$number_of_brothers } {break}}
# end overflow section
}
frame .buttons -bg aquamarine4
::ttk::button .calculator -text "Solve" -command { calculate   }
::ttk::button .test2 -text "Testcase1" -command {clearx;fillup 60.   5.   5.0  17.  14.  11. 9. 7.0}
::ttk::button .test3 -text "Testcase2" -command {clearx;fillup 120.  5.0  5.0  35.  28.  22. 18. 14.0 }
::ttk::button .test4 -text "Testcase3" -command {clearx;fillup 3600. 5.0  5.0  1070. 856.  685. 548. 438.0 }
::ttk::button .clearallx -text clear -command {clearx }
::ttk::button .cons -text report -command { reportx }
::ttk::button .exit -text exit -command {exit}
pack .calculator  -in .buttons -side top -padx 10 -pady 5
pack  .clearallx .cons .about .exit .test4 .test3 .test2   -side bottom -in .buttons
grid .frame .buttons -sticky ns -pady {0 10}
. configure -background aquamarine4 -highlightcolor brown -relief raised -border 30
wm title . "Babylonian Brothers Inheritance Problems Algorithm"    ```

### Pushbutton Operation

For the push buttons, the recommended procedure is push testcase and fill frame, change first three entries etc, push solve, and then push report. Report allows copy and paste from console.

For testcases in a computer session, the eTCL calculator increments a new testcase number internally, eg. TC(1), TC(2) , TC(3) , TC(N). The testcase number is internal to the calculator and will not be printed until the report button is pushed for the current result numbers. The current result numbers will be cleared on the next solve button. The command { calculate; reportx } or { calculate ; reportx; clearx } can be added or changed to report automatically. Another wrinkle would be to print out the current text, delimiters, and numbers in a TCL wiki style table as

```  puts " %| testcase \$testcase_number | value| units |comment |%"
puts " &| volume| \$volume| cubic meters |based on length \$side1 and width \$side2   |&"  ```

## Console program for testing concept

```        # pretty print from autoindent and ased editor
# initial console program,  Babylonian Brothers false shares
# written on Windows XP on eTCL
# working under TCL version 8.5.6 and eTCL 1.0.1
# gold on TCL WIKI, 10feb2017
package require Tk
package require math::numtheory
namespace path {::tcl::mathop ::tcl::mathfunc math::numtheory }
set tcl_precision 17
console show
set brothers 10
set i 10
set decrement [/ 1. \$brothers ]
set inheritance  [expr 5**4]
set false_sum 0
set real_estate 100.
# can not have scale factor without solving deck once
while {\$i>0} {
set inheritance [- \$inheritance [* \$inheritance \$decrement]]
if { \$inheritance < 0 } { break }
set side\$i \$inheritance
set false_sum [+ \$false_sum \$inheritance]
incr i -1
}
set brothers 10
set i 10
set g 1
set decrement [/ 1. \$brothers ]
set inheritance  [expr 5**4]
#set false_sum 0
set real_estate 100.
set scale_factor [expr \$real_estate / \$false_sum ]
set false_sum 0
# begin second solution with solved scale factor for output
while {\$i>0} {
set inheritance [- \$inheritance [* \$inheritance \$decrement]]
if { \$inheritance < 0 } { break }
puts "brother brother\$g inherits  \$inheritance  false shares  but real shares are [expr \$scale_factor*\$inheritance ] "
set side\$i \$inheritance
set false_sum [+ \$false_sum \$inheritance]
incr i -1
incr g  1
}
puts " sum of false shares is \$false_sum "
puts " scale factor for false shares is [expr \$real_estate / \$false_sum ]"
puts " real estate or inheritance is  \$real_estate "
puts " average for n brothers is real_estate/ brothers [expr \$real_estate/ \$brothers ] "
puts " upper bound is average + .5*average [expr  (\$real_estate/ \$brothers) + (.5*\$real_estate/ \$brothers)  ]"
puts " lower bound is average - .5*average [expr  (\$real_estate/ \$brothers) - (.5*\$real_estate/ \$brothers)  ]"
puts " bound:: constant distance or slot (real_estate/ brothers)/(brothers-1.) is [expr (\$real_estate/ \$brothers)/ (\$brothers-1.) ]"```

output for false shares

``` brother brother1 inherits  562.5  false shares  but real shares are 15.353
brother brother2 inherits  506.25  false shares  but real shares are 13.818
brother brother3 inherits  455.625  false shares  but real shares are 12.436
brother brother4 inherits  410.0625  false shares  but real shares are 11.192
brother brother5 inherits  369.056  false shares  but real shares are 10.073
brother brother6 inherits  332.150  false shares  but real shares are 9.066
brother brother7 inherits  298.935  false shares  but real shares are 8.159
brother brother8 inherits  269.042  false shares  but real shares are 7.343
brother brother9 inherits  242.137  false shares  but real shares are 6.609
brother brother10 inherits  217.924  false shares  but real shares are 5.948
sum of false shares is 3663.683
scale factor for false shares is 0.0272
real estate or inheritance is  100.
average for n brothers is real_estate/ brothers 10.0
upper bound is average + .5*average 15.0
lower bound is average - .5*average 5.0
bound:: constant distance or slot (real_estate/ brothers)/(brothers-1.) is 1.111```

## Hidden Comments Section

### subject: Problem IM31210P6, ref Friberg

Professor Joran Friberg in 7/7/2021 pm. Thank you for this very interesting work gang interpretation of the Old Babylonian brothers’ shares problem in the cuneiform text IM 31210 #6. (A correction: The text was published in Ch. 7 of J. Friberg et al, New Mathematical Cuneiform Texts, Springer 2016.)

gold corrected reference.

Please place any comments here with your wiki MONIKER and date, Thanks.gold12Dec2018

 Category Numerical Analysis Category Toys Category Calculator Category Mathematics Category Example Toys and Games Category Games Category Application Category GUI

 Category Development Category Concept Category Algorithm