Updated 2017-02-19 10:57:59 by gold

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

gold Here is some eTCL starter code for 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.

The eTCL 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 eTCL 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.

The eTCL 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.

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.

Using proportions and gaming, the conventional solution from the eTCL 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) decrement 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) decrement in the eTCL calculator gives a conventional trial solution with 2.3227 silver pieces. Loading 25.7 silver, 7 brothers, and (1-1/6) decrement 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.

It is difficult to judge the impact of these historic problems on later mathematicians, but Al-Khuwarizmi has about a third of his algebra work on Islamic inheritance problems.

## Pseudocode Section edit

```       # 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
```

### 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)
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.
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)
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
[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
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)
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
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,
#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)
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
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)
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
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)
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```

### 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 edit

### 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
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
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  .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  edit

```        # 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```