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

This page is under development. Comments are welcome, but please load any comments in the comments section at the bottom of the page. Please include your wiki MONIKER in your comment with the same courtesy that I will give you. Its very hard to reply intelligibly without some background of the correspondent. Thanks,goldPage contents

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 1 | printed 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 4 | printed 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 5 | printed 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 6 | printed 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 7 | printed 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 8 | printed 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

### Screenshots Section

#### figure 1.

### 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 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 answer2 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 .about -text about -command {about} ::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 asputs " %| 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.111gold This page is copyrighted under the TCL/TK license terms, this license.

## Comments Section edit

Please place any comments here, Thanks.

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