Pronunciation of the integers with full use of the place value system

Thomas Colignatus
http://thomascool.eu
May 9 & 17 2018

© Thomas Cool CC-BY-NC-ND

Abstract

Kids in kindergarten and Grade 1 live in a world of sounds so that the pronunciation of numbers is important. When they are learning to read and write, the co-ordination of (i) sounds, (ii) numerals and (iii) written words is important. We already have the place value system fully in the numerals but not yet in pronunciation and written words. The following provides for this. The definition should become an ISO standard, though the notebook with package is quite simple because of the nature of the issue. The notebook with package provides an implementation and transliteration for English, German, French, Dutch and Danish, while other languages might employ Mathematica’s IntegerName and WordTranslation without transliteration. Four levels in the curriculum are recognised for which routines are provided: (1) sounds, codified by words, (2) learning the numerals, (3) advanced: numerals in blocks of three digits, such that 123456 = {1 hundred, 2 ten, 3} thousand & {4 hundred, 5 ten, 6}, with the comma pronounced as “&” too, and (4) accomplished: 123 thousand 456 pronounced in above place value manner. The traditional pronunciation has level -4.

Keywords

mathematics education, place value system, pronunciation, Common Core, Mathematica, Wolfram language, programming, package

MSC2010

97M70 Mathematics education. Behavioral and social sciences

Cloud

This notebook with package (updated version) is also available at:

(1)  http://community.wolfram.com/groups/-/m/t/1334793

(2) https://www.wolframcloud.com/objects/thomas-cool/MathEd/2018-05-09-Pronunciation-of-integers.nb

(3) for this notebook with package: https://zenodo.org/record/1244008 or DOI 10.5281/zenodo.1244008

(4) for the PDF: https://zenodo.org/record/1244063  or DOI 10.5281/zenodo.1244063

I have not seen this implementation of pronunciation elsewhere (except in Chinese though without &), so please refer to these locations so that others can find the full documentation.

Contents

. Introduction

. Example in English

. History, tradition, assumptions, advantages

. A structure for the curriculum

. Zig in German and tig in Dutch

. Translate, transliterate and quality control

. Conversion tables

. ISO standard

. Conclusions

. Appendix. The package

. Literature

Start (subsection for the initialisation cell with the package)

MathEd`PronounceInteger`

(*******************************************

Cool`MathEd`PronounceInteger` package

*******************************************)
(* :Author: Thomas Cool*)
(* :Copyright: Copyright 2018 Thomas Cool*)
(* :Package Version:2.0, May 17 2018*)
(* :Mathematica Version:11.2*)
(* :Keywords:*)
(* :Limitation:*)
(* :License: see http://thomascool.eu/TheEconomicsPack/index.html*)

BeginPackage["Cool`MathEd`PronounceInteger`", {"Cool`MathEd`H`"}];

Unprotect[PlaceValue, PlaceValueH,PronounceIntegers, SpeakTransliteration,PlaceValueBlock, PlaceValueDigits, PlaceValueDigits$Language,PronounceIntegerReadMe, PronounceInteger, PartialPlaceValue, PlaceValueTable];

LatestPronunciation::usage = "LatestPronunciation[] contains what a routine in the MathEd`PronounceInteger` package could have spoken (but perhaps suppressed by an option choice not to speak)";

PronounceIntegerReadMe::usage  = "PronounceIntegerReadMe[] explains the package";

PronounceIntegerReadMe[]= 
"Mathematica already provides for (i) IntegerName[n, \"language\"], (ii) IntegerName[n, \"DigitsWords\"] for blocks of three digits, and (iii) WordTranslation for \"negative\", and (iv) a wealth of expression in IntegerString. These all encode tradition: with 56 = fifty-six instead of ten·five & six, except in IntegerString[n, \"TraditionalChineseDecimal\"]. Also, these all tend to hide the steps in the place value system that we want to show. Our routines are:\n(1) PronounceInteger provides a switch between methods, and helps to focus on your preferred method\n(2) PlaceValue (main routine): word based, so that the pronunciation is unambiguous for the particular language. It also allows transliteration (speaking foreign words with approximations in English)\n(3) PlaceValueDigits: integer based, for when kids go from sounds to reading and writing numerals\n(4)PlaceValueBlock: show in blocks of three digits (quite alike DigitsWords, but notice the differences).\n(5) PlaceValueIntegerName builds around IntegerName DigitsWords for full place value speech\nLikely, teaching is best done likely in order (2)-(5) so that first the individual steps are shown and then the block form. PM. A routine f stores what is spoken in LatestPronunciation[] and may display differently, see the documentation of f";


PlaceValueRules::usage ="PlaceValueRules[\"Language\"] = {True -> t, \"OtherLanguage\" -> f}, with t = {Negative -> string, And -> \"&\", N -> {strings for 0...9}, Power -> {strings for 10, ..., 10^6}}, for the true way of writing and pronunciation (when this original language = $Language), and f = {... similar ...} for the transliteration into the actual $Language. See the examples for \"English\" (f is not required given $Language = \"English\") and \"Dutch\" (t <> f).\nNegative -> how the sign of a negative number is written or pronounced\nAnd-> what string is used to separate the product terms of weights and place values\nN -> {names how the digits 0 ... 9 are written or pronounced}\nPower -> {names how 10 ... 10^6 are written or pronounced}.\nSee SpeakTransliteration for checking on $Language.\nImplemented are English, German, French, Dutch and Danish (with some guessing on transliteration). The language Amplish has True -> with an ampersand in a smaller font, and otherwise English. Englishty has ty for 10 pronounced as tee. The languages have (Greek) myriad for 10^4 and (Indian) lakh for 10^5\nPlaceValueRules[] contains the list of languages for which there is transliteration\nPlaceValueRules[Select, item, lan, translit:\"English\"] selects for lan the item (e.g. Power) from both True and translit, and gives a rule or list of rules (true -> transliteration) for replacement\nPlaceValueRules[Set, \"ToLanguage\", FromLanguage:\"English\"] uses IntegerName for the digits and WordTranslation for \"negative\", \"and\" and \"million\" and imposes myriad and lakh. These routines may take time, and thus one is advised to save the result. There is no automation for the transliteration\nPlaceValueRules[Check, \"Language\"] for another language than in PlaceValueRules[\"Checked\"] will issue a warning that the place value pronunciation is generated by automation and hasn't been checked on conflicts. When you have done the checking then this list can be adapted manually or by AppendTo";

SpeakTransliteration ::usage = "SpeakTransliteration is an option of PlaceValue with default $Language. It selects the relevant setting from the PlaceValueRules. If the Language option is equal to the transliterator ($Language) then writing and speaking will be done from the True rule. When the option Language is set to another value, then the integers are written from True but spoken by the transliterator";

PlaceValue::usage = "PlaceValue[n] gives n in the full place value system, as text or in Speak, and the latter with pauses for hearing and possible transliteration in the system default language (e.g. $Language = English). n is in (-10^7, 10^7).\nThe routine is also called with PronounceInteger[n, Level -> 1]\nOptions with defaults are:\nLanguage -> \"Amplish\" uses PlaceValueRules[\"Amplish\"], see there\nWordTranslation -> Automatic calls IntegerName and WordTranslation when the language is not available in PlaceValueRules, which takes some time for initialisation and does not provide for transliteration\nSpeakTransliteration :> $Language (often \"English\"), see there\nSpeak -> True,\nLength -> 300, an integer for the duration of pause between the positions,\nJoin -> \"·\" (unpronounced center dot) between the texts of the weight and place value\nSimplify -> True eliminates terms with 0 weights and replaces 1 P by P, for P = 1, 10, ..., 10^6\nShow -> False does not show the input for Speak, so that one reads the words in the language itself and hears the transliteration (while reading affects hearing)\nPronounceInteger[Options, \"Reset\"] resets the options to loading time";

PlaceValueH::usage = "PlaceValueH[expr] is PlaceValue[expr /. H -> -1]";

PronounceIntegers::usage ="PronounceIntegers is obsolete (first version of the package), see PlaceValue";

PlaceValueDigits$Language::usage = "PlaceValueDigits$Language[n] pronounces n by using digits for the place values rather than words (PlaceValue): n can be as large as Mathematica allows, but also relies on how $Language pronounces those integers. In English 2 100 is pronounced as \"two one-hundred\". Option Simplify -> True (default) for handling of 0 and 1 weights, StepMonitor -> False (default) whether to show an intermediate step, Length -> 300 (default) for the pause, Join -> \"·\" (default) for connection of terms in display (not spoken), Speak -> True (default).\nThe routine is also called as a subroutine by PlaceValueDigits[n], which is also called by PronounceInteger[n, Level -> 2]";

PlaceValueBlock::usage = "PlaceValueBlock[n] pronounces n in digit blocks of 3, and within those blocks in place value manner.\nThe routine is also called with PronounceInteger[n, Level -> 3]\nFor example 123456 = {{1 hundred & 2 ten & 3}, thousand} & {4 hundred & 5 ten & 6}. This is like common usage except for the integers in 11-99. Option Length -> 300 (default) puts \"&\" in the middle of that pause. Option Power -> {...} by default replaces 100 by hundred, 1000 by thousand and 10^6 by million. (This is not done in PlaceValueDigits$Language, because there are more words, like for the digits, and including the awkward 10^4 and 10^5). The numbers 11-99 use the options of PlaceValueDigits$Language, namely to display in numbers and not words. If your $Language is not \"English\", then you might consider to adapt the settings manually. The following is an automation though:\nPlaceValueBlock[SetOptions, \"language\"] sets the options to stated \"language\", using WordTranslation from the current language in the Options (default \"English\")\nPlaceValueBlock[Options, \"Reset\"] resets to the Options at loading";

PlaceValueIntegerName::usage = "PlaceValueIntegerName[n] lets IntegerName[n, \"DigitsWords\"] make the blocks of 3 digits, and then calls PlaceValue on these digits. IntegerName DigitsWords uses text for Abs[n] < 1000, and we follow this. The block bases of thousand, million etcetera are translated by WordTranslation. The text displayed has blocks of digits, with block bases separated by option And -> \", \" (default). This option is not passed on to PlaceValue for speech of the blocks. The spoken text can be recovered from LatestPronunciation[]. Transliteration is called but will slow the execution\nThe routine is also called with PronounceInteger[n, Level -> 4]";

PronounceInteger::usage = "PronounceInteger[n] pronounces n. Options are passed on to the routine that is called, except: if the chosen Language is equal to $Language then it is not passed on. It uses first the Level and then the Method setting in the options, default Level -> 1, Method -> PlaceValue. Option All -> {...} gives the methods in the MathEd`PronounceInteger` package. See the documentation per routine. If you want to specify the selection by Method -> routine name, select also Level -> 0. Perhaps easier to remember than the routine names, and taking advantage of the levels of understanding, you can also specify the Level -> lev:\nchosen =Switch[lev, \n 1, PlaceValue,\n 2, PlaceValueDigits,\n 3, PlaceValueBlock,\n 4, PlaceValueIntegerName,\n-4, PartialPlaceValue,\n_, Null];\n If none of these is used (say with Level -> 0) then the Method -> m option is used. If no method is in the list that All provided: $Failed";

PartialPlaceValue::usage = "PartialPlaceValue[n] has the traditional pronunciation and words of the numbers 11-99, thus in opposite order of the place value system, when speaking the number from Left To Right, and morphing of words. It calls IntegerName with DigitsWords. If Abs[n] < 1000 then there are words only, and higher n get combinations of both digit blocks and words for digit block values (thousand, million). Option defaults are Language -> \"English\" and Speak -> True. Speak apparently fails on the hyphen and thus this replaced by a space. Speak[-10] says Minus 10 but IntegerName uses Negative 10. There is no transliteration.\nThe routine is also called with PronounceInteger[n, Level -> -4]";


PlaceValueDigits::usage = "PlaceValueDigits[n] pronounces n by PlaceValue[n] and displays by PlaceValueDigits$Language[n]\nOptions are passed on to said routines, and see their own options, like Simplify and Show\nOwn options are Speak -> True (default), Print -> True (default) prints the outcome of PlaceValue[n]. LatestPronunciation[Print] stores what is printed\nThe routine is also called with PronounceInteger[n, Level -> 2]";

PlaceValueTable::usage = "PlaceValueTable[{n}] gives a table of {n} with rows {n, pronunciation in PlaceValue, PV Digits, traditional pronunciation}. Options are passed on to PlaceValue (default Speak -> True) and PartialPlaceValue(default Speak -> False)\nPlaceValueTable[n] gives the table with only n\nPlaceValueTable[Row, n || {n}] gives the rows as lists only\nPlaceValueTable[First, n] gives {n, PV, PV Digits}";

Begin["`Private`"];

PlaceValueRules::wrn = "Warning: automated translation of `1` and not carefully checked on conflicts and peculiarities";

PlaceValueRules[Check, lan_String]:=
If[!MemberQ[PlaceValueRules["Checked"], lan], Message[PlaceValueRules::wrn, lan]];

PlaceValueTable[First, n_Integer, opts___Rule] := 
{n, PlaceValue[n, opts], PlaceValueDigits[n, Print -> False, Speak -> False, opts]}

PlaceValueTable[Row, n_Integer, opts___Rule] := 
{n, " ", PlaceValue[n, opts], 
PlaceValueDigits[n, Print -> False, Speak -> False, opts],
  " ",PartialPlaceValue[n, opts, Speak -> False]}

PlaceValueTable[Row, {n__Integer}, opts___Rule] := 
PlaceValueTable[Row,#, opts]& /@ {n}

PlaceValueTable[ n_Integer, opts___Rule] := 
PlaceValueTable[ {n}, opts]

PlaceValueTable[{n__Integer}, opts___Rule] := 
(PlaceValueRules[Check, Language /. {opts} /. Options[PlaceValue]];
TableForm[PlaceValueTable[Row, {n}, opts],opts, TableSpacing -> {1.5, 3},
 TableHeadings -> {None,
{"Integer", "", "Place Value", "PV Digits", "", "Traditional"}}])

Options[PlaceValueDigits] = {Speak -> True, Print -> True} ;

PlaceValueDigits[n_Integer, opts___Rule] := 
Module[{res, speakq,  toshow, prq}, 
(*split show and speak *)
{speakq, prq} = {Speak, Print} /. {opts} /. Options[PlaceValueDigits];
toshow = PlaceValueDigits$Language[n, Speak -> False, opts];
res =  PlaceValue[n, Speak -> speakq, opts];
If[prq === True,  LatestPronunciation[Print] = res;Print[res]]; 
(* LatestPronunciation[] set by P.V.O. *)
toshow]

Options[PartialPlaceValue] = {Language -> "English", Speak -> True};

PartialPlaceValue[n_Integer, opts___Rule] :=
Module[{res, lan, speakq, rul},
{lan, speakq} = {Language, Speak} /. {opts} /. Options[PartialPlaceValue] ;
rul = If[MemberQ[{$Language, "Amplish", "Englishty"}, lan], 
ToExpression["Sequence[]"], Language -> lan];
res =  IntegerName[n, {"DigitsWords"}, rul] ;
res = StringReplace[res, "\[Hyphen]" -> " "];
LatestPronunciation[] =res;
If[speakq, Speak[res]];
res]

Options[PronounceInteger] = {Level -> 1, Method -> PlaceValue, Language -> "English",  
Speak -> True, All -> {
PlaceValue, PlaceValueH, PlaceValueDigits,
PlaceValueDigits$Language,PlaceValueBlock,
PlaceValueIntegerName, PartialPlaceValue, PlaceValueTable}};

PronounceInteger::unk = "Unknown Level -> `1` and Method -> `2`";

PronounceInteger[n_Integer, opts___Rule] :=
Module[{m, lan, all, rul, res, speakq, lev, k},
{lev, m, lan, all, speakq} = {Level, Method, Language, All, Speak} /. {opts} /. Options[PronounceInteger] ;
rul = If[lan === $Language, ToExpression["Sequence[]"], Language -> lan];
k =Switch[lev, 
1, PlaceValue,
2, PlaceValueDigits,
3, PlaceValueBlock,
4, PlaceValueIntegerName,
-4, PartialPlaceValue,
_, Null];
If[MemberQ[{-4, 1, 2, 3, 4}, lev], Return[k[n, rul, Speak -> speakq, opts]]];
(* routines that have not been assigned a level*)
If[MemberQ[all, m], Return[m[n, rul, Speak -> speakq, opts]]];
Message[PronounceInteger::unk, lev, m]; 
$Failed]

Options[PlaceValueIntegerName] = {Language -> "English", Speak -> True, And -> ", "};

pvoin[x_, lan_String] := If[lan === "English", x,
First[WordTranslation[x, "English" -> lan]]];

pvoin[x_, lan_String, rul_] := If[lan === "English", x,
(First[WordTranslation[x, "English" -> lan]]) /. rul];

PlaceValueIntegerName[n_Integer, opts___Rule] := 
Module[{lan},
lan= Language /. {opts} /. Options[PlaceValueIntegerName];
If[lan === $Language,
PlaceValueIntegerName["Fast", n, opts],
PlaceValueIntegerName["Slow", n, opts]]
]


PlaceValueIntegerName["Fast", n_Integer, opts___Rule] := 
Module[{res, lan, speakq, rul, toshow, tospeak, and,nopts, na}, 
(*IntegerName in English displays blocks of 3 digits, 
but for values Abs[n] < 1000 and in 
translation it switches to names. We need the digits*)
{lan, speakq, and} = {Language, Speak, And} /. {opts} /. Options[PlaceValueIntegerName];
Check[IntegerName[0, "Words", Language -> lan], Return[$Failed]];
speakq = speakq === True;
If[!StringQ[and],  Message[PlaceValue::str , And, and];Return[$Failed]];
nopts = Sequence @@ ({opts} /. (Rule[And, x_] :> Sequence[]));
rul = If[lan === $Language, ToExpression["Sequence[]"], Language -> lan];
If[Abs[n] < 1000,
Return[PlaceValue[n, rul, Speak -> speakq, nopts]],
(*else*)
res = IntegerName[n, {"DigitsWords", "English"}] ;
res = StringSplit[res];
toshow = If[DigitQ[#], #, pvoin[#, lan]<>and]& /@ res;
toshow = StringJoin @@  Riffle[toshow , "  "];
na= StringLength[and];
If[StringTake[toshow, -na] ===  and, toshow = StringDrop[toshow, -na]];
res = If[DigitQ[#], ToExpression[#], pvoin[#, lan]<> and]& /@ res;
(* re-introduce English because of Amplish *)
res = res /. x_Integer :> PlaceValue[x, rul, Language -> "English", Speak -> False, nopts];
tospeak = StringJoin @@  Riffle[res, "  "];
If[StringTake[tospeak, -na] ===  and, tospeak = StringDrop[tospeak, -na]];
];
LatestPronunciation[]= tospeak;
If[speakq === True, Speak[tospeak]]; 
toshow
]

PlaceValueIntegerName["Slow", n_Integer, opts___Rule] := 
Module[{res, lan, speakq, rul, toshow, tospeak, and,na, nopts, sp, h, trans, las}, 
(*IntegerName in English displays blocks of 3 digits, 
but for values Abs[n] < 1000 and in 
translation it switches to names. We need the digits*)
{lan, speakq, and} = {Language, Speak, And} /. {opts} /. Options[PlaceValueIntegerName];
Check[IntegerName[0, "Words", Language -> lan], Return[$Failed]];
speakq = speakq === True;
If[!StringQ[and],  Message[PlaceValue::str , And, and];Return[$Failed]];
nopts = Sequence @@ ({opts} /. (Rule[And, x_] :> Sequence[]));
rul = If[lan === $Language, ToExpression["Sequence[]"], Language -> lan];
If[Abs[n] < 1000,
Return[PlaceValue[n, rul, Speak -> speakq, nopts]],
(*else*)
res = IntegerName[n, {"DigitsWords", "English"}] ;
res = StringSplit[res];
(*toshow*)
toshow = If[DigitQ[#], #, pvoin[#, lan]<> and]& /@ res;
toshow = StringJoin @@  Riffle[toshow , "  "];
na= StringLength[and];
If[StringTake[toshow, -na] ===  and, toshow = StringDrop[toshow, -na]];
(*tospeak*)
h[x_] := (Speak[x];x);
sp[x_] := If[speakq, Hold[h][x], x];
trans = PlaceValueRules[Select,Power, lan];
If[trans === $Failed || !speakq, trans = ToExpression["Sequence[]"]];
res = If[DigitQ[#], 
Hold[ PlaceValue][ToExpression[#], rul, Speak -> speakq, Show -> True, nopts],
sp[pvoin[#, lan, trans]<> and]]& /@ res;
(* clean up if last is a base with and *)
las = Last[res];
las = las /. x_String :> If[StringTake[x, -na] ===  and, StringDrop[x, -na], x];
res = Append[Drop[res, -1], las];
res = ReleaseHold[res];
tospeak = StringJoin @@  Riffle[res, "  "];
LatestPronunciation[]= tospeak;
];
toshow]


Options[PlaceValueDigits$Language] = {Length -> 300, Simplify -> True, Join -> "·", And -> "&", StepMonitor -> False,
Speak -> True} // Sort;

PlaceValueDigits$Language[n_Integer, opts___Rule] :=
Module[{g, h, len, res, pause, simpq, np, join, smq, temp, speakq, and, paund},
{simpq, pause, join, smq, speakq, and} = {Simplify, Length, Join, StepMonitor, Speak, And} /. {opts} /. Options[PlaceValueDigits$Language] ;
 If[!StringQ[and], Message[PlaceValue::str, "and", and]; Return[$Failed]];
join = StringJoin[" ", join, " "];
If[NumberQ[pause],
pause = " <silence msec=\"" <> ToString[pause] <> "\"/> " ,
 Message[PlaceValue::pau, pause];Return[]];
h = IntegerDigits[n];
len = Length[h];
g = Table[10^k, {k, 0, len}];
g = Reverse[Take[g, len]];
res = Inner[times, h, g, TheSum];
(* no speaking since wrong pauses*)
If[smq === True , 
temp = ToString[res];
temp = StringReplace[temp,{ToString[times] -> "times", ToString[TheSum] -> "TheSum"}];
Print[temp]; 
(*Speak[temp] *)];
If[simpq === True,
res = res /. times[0, x_] :> Sequence[];
res = res /. times[ 1, x_] :> x;
res = res /. times[ x_, 1] :> x;
If[n === 0, res = {0}]
]; 
res = res /. TheSum -> List;
paund = pause <> " " <> and <> "   ";
res = StringJoin[paund, ToString[#]]& /@ res;
res = StringJoin @@ res;
res = StringDrop[res,  StringLength[paund]];
If[n < 0,  res = StringJoin["negative ", res]];
res = StringReplace[res, { ToString[TheSum]-> "", ToString[times]-> "",  ", " ->  join, "[" -> "", "]" -> ""}];
If[speakq === True, Speak[res]];
LatestPronunciation[] =res;
StringReplace[res, pause -> "  "]
]

PronounceIntegers[x__] := PlaceValue[x]

PlaceValueH[n_, opts___Rule] := PlaceValue[n /. H -> -1, opts]

digits = {"zero", "one", "two", "three", "four", "five", "six", "seven", "eight", "nine"};
powers = {"ten", "hundred", "thousand", "myriad", "lakh", "million"};

PlaceValue[IntegerDigits] = digits;
PlaceValue[Power] = powers;

amp =  "&";

PlaceValueRules["English"]  = 
{True ->  {Negative -> "negative",  And  -> "&", N -> digits, Power ->  powers}};

PlaceValueRules["Amplish"]  = 
{True ->  {Negative -> "negative",  And  -> amp, N -> digits, Power ->  powers},
"English" ->  {Negative -> "negative",  And  ->  "&", N -> digits, Power ->  powers}
};

PlaceValueRules["Englishty"]  = 
{True ->  {Negative -> "negative",  And  -> amp, N -> digits, 
Power ->  {"ty", "hundred", "thousand", "myriad", "lakh", "million"}},
"English" ->  {Negative -> "negative",  And  ->  "&", N -> digits, Power ->  {"tee", "hundred", "thousand", "myriad", "lakh", "million"}}
};

PlaceValueRules[] = {(* not "English", *) "Dutch", "French", "German", "Danish", "Amplish", "Englishty"} // Sort;

PlaceValueRules["Checked"] = {"English"} ~Join~  PlaceValueRules[];

PlaceValueRules["Dutch"]  = 
{True ->  {Negative -> "min" (* "negatief" *), And  -> amp, (*"en"*)
N -> {"nul", "een", "twee", "drie", "vier", "vijf", "zes", "zeven", "acht", "negen"}, 
Power ->  {"tig", "honderd", "duizend", "myriad", "lakh", "miljoen"}},  
"English"->  {
Negative -> "min" (*"nayguhteef"*), And -> "n",
N ->  {"nuhl", "ayn", "tway", "dree", "fear", "vaif", "zes" ,"zayven",  "ahgt"(*"akht" "ugt"*),  "naigen" }, 
Power -> {"tikgh", "hon dairt", "duuzand", "myriad", "lakh", "milyoon"}}};

(* deux as in bird, but no way to get it*)

PlaceValueRules["French"]  = 
{True ->  {Negative -> "negative" , And  ->  amp, (* And -> "et", *)
N -> {"zero", "un", "deux", "trois", "quatre", "cinq", "six", "sept", "huit", "neuf" }, 
Power ->  {"dix", "cent", "mille", "myriade", "lakh", "million"}},  
"English"->  {Negative -> "nayguhteef", And -> "ayh",
N ->  {"zeyrouh", "uhnn", "duh", "trouwah", "kahtruh", "saink", "sees", "seht", "weet", "neuhf" }, 
Power -> {"dees", "sun", "meel", "meeri udd", "lakh", "meelyon"}}};

PlaceValueRules["German"]  = 
{True ->  {Negative -> "negativ" , And  -> amp, (*And -> "und",*)
N -> {"null", "ein", "zwei", "drei", "vier", "fuenf", "sechs", "sieb", "acht", "neun" }, 
Power ->  {"zig", "hundert", "tausend", "myriad", "lakh", "million"}},  
"English"->  {Negative -> "nayguhteef", And -> "oond",
N ->  {"noul", "ayen", "tsvwaayie", "dryie", "fear", "fuihnf", "sex", "sieb", "akht", "noin" }, 
Power -> {"tzeeg", "hoondert", "tausand", "myriad", "lakh", "meelyohn"}}};

PlaceValueRules["Danish"]  = 
{True ->  {Negative -> "negativ" , And  -> amp, (*And -> "og",*)
N -> {"nul", "en", "to", "tre", "fire", "fem", "seks", "syv", "otte", "ni" }, 
Power ->  {"ti", "hundrede", "tusind", "myriade", "lakh", "million"}},  
"English"->  {Negative -> "nayguhtew", And -> "oh",
N ->  {"nul", "ayn", "toh", "trya", "fear", "fem", "sex", "suwe", "ude", "knee" }, 
Power -> {"tee", "hoonah", "toosind", "myriade", "lakh", "meelyohn"}}};


PlaceValueRules[Set, lan_String, org_String:"English"]  :=
Module[{res, f, g, zero},
Check[IntegerName[0, "Words", Language -> lan], Return[$Failed]];
f[x_] := IntegerName[x, "Words", Language -> lan];
g[x_] := First[WordTranslation[x, org -> lan]];
res = {Negative -> g["negative"], And -> g["and"],
N -> (f /@ Range[0, 9]), 
Power ->  {f[10], f[100], f[100], "myriad", "lakh",  g["million"]}
};
AppendTo[PlaceValueRules[], lan];
PlaceValueRules[Check, lan];
Set[PlaceValueRules[lan], {True -> res,  org -> res}]
]

PlaceValueRules[Select, item_, lan_String, trans_String:"English"] :=
Module[{res, true},
If[MemberQ[PlaceValueRules[], lan],
res = PlaceValueRules[lan];
true = True /. res;
true = item /. true;
res = trans /. res;
res = item/. res;
Thread[true -> res], $Failed]]

compose[digits_List, lis_List, pause_String, s_Integer, neg_String, and_String] :=
Module[{combination, paund},
paund = pause <> " "  <> and <> "  ";
combination =  MapThread[StringJoin, {digits , lis}];
combination = paund <> #  &/@ combination;
combination = StringJoin @@ combination;
combination = StringDrop[combination, StringLength[paund]];
If[s < 0, neg <> pause <> combination, combination]]

Options[PlaceValue] = reset = {Show -> False, Speak -> True, 
Language -> "Amplish", SpeakTransliteration  :> $Language,
Length -> 300 (* was " <silence msec=\"300\"/> " *), 
Simplify ->  True, Join -> "·",
WordTranslation -> Automatic}  // Sort;

PlaceValue[Options, "Reset"] :=
(Unprotect[PlaceValue];
Options[PlaceValue] = reset;
Protect[PlaceValue]; reset )

PlaceValue::rul = "No list of rules found for `1` `2`";
PlaceValue::int = "Initialisation with IntegerName and WordTranslation: please wait";
PlaceValue::len = "Length of `1` is not `2` but `3`";
PlaceValue::num = "No list of names found for `1` `2`";
PlaceValue::not = "Not tested: Speak with other than $Language";
PlaceValue::ran = "Integer not in domain -`1` < `2` < `1`";
PlaceValue::pau = "Pause length `1` must be a number";
PlaceValue::str = "Symbol for `1` is `2` but must be a string";

inputtest[ns_, ps_, type_, neg_, and_] :=
(If[!ListQ[ns], Message[PlaceValue::num , {type,"digits"}, ns];Throw[$Failed]];
If[!ListQ[ps], Message[PlaceValue::num ,{type,"powers"}, ps];Throw[$Failed]];
If[Length[ns] =!= 10, Message[PlaceValue::len ,{type,"digits"}, 10, Length[ns]]; Throw[$Failed]];
If[Length[ps] =!= 6, Message[PlaceValue::len , {type,"powers"}, 6, Length[ps]]; Throw[$Failed]];
  If[!StringQ[neg], Message[PlaceValue::str, "negative", neg]; Throw[$Failed]];
 If[!StringQ[and], Message[PlaceValue::str, "and", and]; Throw[$Failed]];
  )

pihelper[n_Integer, neg_String, ipause_String, nsi_List, psi_List, simpq_, join_String, speakq_, and_String] :=
Module[{pause, s, powers, d, digits, len, lis, sel, h, zeros, pos, ns , ps},
pause = If[speakq =!= True, " ", ipause];
s = Sign[n]; ns = nsi; ps = psi;
(*** actual ***)
PrependTo[ps, ns[[2]]];
powers = Table[10^k, {k, 0, 6}];
d= IntegerDigits[n];
digits = ns[[#+1]]& /@ d; 
len = Length[d];
lis = Take[ps, len];
(* basically finished but simplification*)
(* 1 *)
If[simpq === True,  
h = Last[d];
AppendTo[ns, ""];
d = d /. 1 -> 10  ;
digits = ns[[#+1]]& /@ d; 
If[h =!= 1, (*then not removed at the last position, and thus adjust lis*)
lis = {""} ~Join~ Rest[lis]; (* reverse: india and arabia *) 
]]; (*end simpq*)
lis =  Reverse[join <> #  &/@ lis];
(* 0 *)
If[simpq === True && d =!= {0},
zeros = If[# === 0, 0, 1]& /@ d;
pos = Position[zeros, 1];
If[pos =!= {},  (*superfluous ...*)
digits = Extract[digits, pos];
lis = Extract[lis, pos];
]]; (*end simpq*)
compose[digits, lis, pause, s, neg, and]
]

PlaceValue[n_Integer, opts___Rule] := 
Catch[Module[{ns, ps, speakq,  combination, pause, neg, simpq, join, translit, lan, rul,  lanrul, nottested, showq, missingq, and},
{speakq, pause, simpq, join, translit, lan, showq, missingq}  =
{Speak, Length, Simplify, Join,SpeakTransliteration, Language, Show, WordTranslation} /. {opts} /. Options[PlaceValue];
(*** input and testing of it ***)
(* also test even when not spoken *)
If[NumberQ[pause],
pause = " <silence msec=\"" <> ToString[pause] <> "\"/> " ,
 Message[PlaceValue::pau, pause];Throw[$Failed]];
If[Abs[n] > 10^7-1, Message[PlaceValue::ran,  "10^7", n];Throw[$Failed]];
nottested = (speakq === True && translit =!= $Language);
If[nottested, Message[PlaceValue::not]];
(* if lan <> $Language then write in lan True or speak in translit*)
lanrul =  PlaceValueRules[lan];
If[!ListQ[lanrul], 
Message[PlaceValue::rul , "language", lan];
If[missingq === Automatic,
Message[PlaceValue::int];
Check[IntegerName[0, "Words", Language -> lan], Throw[$Failed]];
PlaceValueRules[Set,lan],
Throw[$Failed]]];
If[lan === translit, translit = True]; (*key*)

(* using a switch in case only one call suffices *)
rul = If[(speakq === True), translit, True] /. lanrul;
If[!ListQ[rul], Message[PlaceValue::rul ,{translit, True}, rul];Throw[$Failed]];
{ns, ps,  neg, and}  = {N, Power, Negative, And} /. {opts} /. rul;
inputtest[ns, ps, speakq, neg, and] ;
combination = pihelper[n, neg, pause, ns, ps, simpq, join, speakq, and] ;

LatestPronunciation[] =combination;
If[speakq =!= True, 
combination,
Speak[combination];
If[showq === True, combination,
(* redo the whole thing for the written version *)
(* overdone to turn this into a subroutine *)
rul = True /. lanrul;
If[!ListQ[rul], Message[PlaceValue::rul ,{translit, True}, rul];Throw[$Failed]];
{ns, ps,  neg,and}  = {N, Power, Negative, And} /. {opts} /. rul;
inputtest[ns, ps, False, neg, and] ;
combination = pihelper[n, neg, pause, ns, ps, simpq, join, False,and] 
]] (*endif*)
]] (*end catch module*)


tosimp[{0, 0, 0}] := {}
tosimp[{0, y_, x_}] := { myspeak[y * 10 + x]}
tosimp[{z_, 0, 0}] := {speak[ToString[z] <>  hundred]}
tosimp[{z_, y_, x_}] := {speak[ToString[z] <> hundred], nfx, myspeak[y * 10 + x]}
tosimp[{0, 0}] := {}
tosimp[{y_, x_}] := {myspeak[y * 10 + x]}
tosimp[{0}] := {}
tosimp[{x_}] := {speak[x]}

tospeak[{z_, y_, x_}] := {speak[ToString[z] <> hundred],nfx,  myspeak[y * 10 + x]}
tospeak[{y_, x_}] := {myspeak[y * 10 + x]}
tospeak[{x_}] := {speak[x]}
(* this applies to g *)
tospeak[1] := one
tospeak[x_Integer] := speak[x]

Options[PlaceValueBlock] = resetblock =
{Language  -> "Amplish", And -> "&",
Length -> 300, Speak -> True, Join  -> "·", Simplify -> True,
Power ->  {10^6 -> "million", 10^3 -> "thousand", 100 -> "hundred"}} // Sort;

PlaceValueBlock[Options, "Reset"] :=
(Unprotect[PlaceValueBlock];
Options[PlaceValueBlock] = resetblock;
Protect[PlaceValueBlock]; resetblock )


PlaceValueBlock[SetOptions, lan_String] :=
Module[{rul, numbers, words, trans, default},
{default, rul} = {Language, Power} /. Options[PlaceValueBlock];
{numbers, words} = Transpose[rul /. Rule -> List];
trans = WordTranslation[#, default -> lan]& /@ words;
trans = First /@ trans;
SetOptions[PlaceValueBlock, Language -> lan, Power -> Thread[numbers -> trans]]
]

PlaceValueBlock[n_Integer, opts___Rule] :=
Module[{h, len, g, q, p, res, pause, rep, speakq, join, rule100, simpq, and, paund},
{pause, rep, speakq, join, simpq, and}  = {Length, Power, Speak, Join, Simplify, And} /. {opts} /. Options[PlaceValueBlock];
hundred = " " <> join <> " " <>  (100 /. rep);
 If[!StringQ[and], Message[PlaceValue::str, "and", and]; Return[$Failed]];
rule100 = (100 /. rep) ->  "100";
speakq = speakq === True;
If[NumberQ[pause],
pause = " <silence msec=\"" <> ToString[Round[pause/2]] <> "\"/> " ,
 Message[PlaceValue::pau, pause];Return[]];
h = IntegerDigits[n];
len = Length[h];
g = Table[10^k, {k, 0, len-1, 3}] //Reverse;
p = Partition[Reverse[h], UpTo[3]];
p = Reverse[Reverse /@ p];
If[simpq === True, q = (u/@ (tosimp /@ p))  /. u[{}] :> u[] ];  
If[simpq =!= True, q = (u/@ (tospeak /@ p))  /. u[{}] :> u[] ];
g = (u /@ (tospeak /@ g));
res = Inner[w, q,  g,  head]/. u -> Sequence ;
res = res /. w[] :> Sequence[]  /. w[speak[y_]] :> Sequence[];  (*zero weights*)
res =res /.  w -> List /. head -> List;
res = res /. {x___List, one} :> x;
If[speakq,
sp[x_] := Hold[Speak[x]; x],
sp[x_] := Hold[x]];
mysp[x_] := Hold[PlaceValueDigits$Language[x, Evaluate[Speak -> speakq, And -> and,  opts]]];
(* never show the pause *)
paund = pause <>and <> pause;
and = " "<>and<>" ";
res = Riffle[res, If[speakq, Hold[Speak[paund]; and], and]];
If[n < 0, PrependTo[res, Hold[Speak["negative"];"negative"]]];
res = res /. rep;
res = res /. nfx -> sp[and];
res = res /. {myspeak -> mysp, speak -> sp};
LatestPronunciation[Hold] =res;
res = ReleaseHold[res];
LatestPronunciation[] =res;
res = res /. (rep /. Rule[a_, b_] :> Rule[b, a]);
res /. x_String :> StringReplace[x, rule100]
]

End[];

Protect[PlaceValue, PlaceValueH, PronounceIntegers, SpeakTransliteration, PlaceValueBlock, PlaceValueDigits, PlaceValueDigits$Language,PronounceIntegerReadMe, PronounceInteger, PartialPlaceValue, PlaceValueTable];

EndPackage[];

MathEd`CCSSMath`

(*******************************************

Cool`MathEd`CCSSMath` package

*******************************************)
(* :Author: Thomas Cool*)
(* :Copyright: Copyright 2018 Thomas Cool - except for CCSS texts of course*)
(* :Package Version: 1.0, May 16 2018*)
(* :Mathematica Version:11.2*)
(* :Reference: http://www.corestandards.org/Math/Content/NBT *)
(* :Keywords:*)
(* :Limitation:*)
(* :License: see http://thomascool.eu/TheEconomicsPack/index.html*)

BeginPackage["Cool`MathEd`CCSSMath`", {"Cool`MathEd`PronounceInteger`"}];

Unprotect[CCSSMathContent, CCSSMathExercise];

CCSSMathContent::usage = "CCSSMathContent[domain, grade, labels] quotes the CCCSS standards for the domain and grade.\nCCSSMathContent[] contains the list what is included in the package. Only included is NBT = Number & Operations in Base Ten, and then only for Kindergarten, Grade 1 and a bit of Grade 2";

CCSSMathExercise::usage = "CCSSMathExercise[n, ..., m, opts] passes the numbers on to a routine that recognises the CCSSMathContent labels in opts, see Options[CCSSMathExercise] and CCSSMathContent. When Show -> True then the CCSSMathContent on those labels is shown (default False)\nCCSSMathExercice[n, m:10] for \"Grade\" -> \"Kindergarten\" or \"Grade 1\" counts from m to n. Defaults Speak -> False, IntegerDigits -> False (if True, the exercise question shows digits, but still speaks full place value)";



Begin["`Private`"];



Options[CCSSMathExercise] = {Domain -> "NBT", "Grade" -> "Kindergarten", "Code" -> "A.1", Show -> False, Speak -> False, IntegerDigits-> False};

CCSSMathExercise[n__Integer, opts___Rule] := 
Module[{sq, kind, res},
kind = {"Grade",Domain, "Code"} /. {opts} /. Options[CCSSMathExercise];
sq = Show /. {opts} /. Options[CCSSMathExercise] ;
If[sq === True, 
res = CCSSMathContent @@ kind; Print[res]];
CCSSMathExercise[n,  kind, opts]]

CCSSMathExercise::ran = "Number `1` must be in range `2`";

CCSSMathExercise[n_Integer,m___Integer , {"Kindergarten", "NBT", "A.1"}, opts___Rule] :=
If[10 < n < 20,
CCSSMathExercise["Kindergarten", Count, n,m, opts] , Message[CCSSMathExercise::ran, n, "11-19"]]

CCSSMathExercise["Kindergarten", Count,xtext_String, basetext_String, ytext_String] :=
StringReplace["You know the numbers yyy and base, and how to speak them. You now count yyy up from base, and then you find the number xxx. You now learn to speak the number xxx.", {"xxx" ->  xtext, "base" -> basetext, "yyy" ->  ytext}]

CCSSMathExercise["Kindergarten", Count, x_Integer, base_Integer:10, opts___Rule] := 
Module[{xtext, basetext, ytext, digits, speakq, f, famp, fpv, toshow, tospeak},
{digits, speakq} = {IntegerDigits, Speak} /. {opts} /. Options[CCSSMathExercise] ;
fpv = (PlaceValue[#, Speak -> False, Language -> "English", opts]&);
famp = (PlaceValue[#, Speak -> False, Language -> "Amplish", opts]&);
(* to show *)
f = If[digits === False, famp, ToString];
{xtext, basetext, ytext} = f /@ {x, base, x - base};
toshow = CCSSMathExercise["Kindergarten", Count,xtext, basetext, ytext] ;
(* to speak *)
If[speakq === True,
{xtext, basetext, ytext} = fpv /@ {x, base, x - base};
tospeak = CCSSMathExercise["Kindergarten", Count,xtext, basetext, ytext] ;
LatestPronunciation[] = tospeak;
Speak[tospeak]
]; 
toshow]


CCSSMathExercise[n_Integer, m___Integer, {"Grade 1", "NBT", "A.1"}, opts___Rule] :=
If[0 <= n <= 120,
CCSSMathExercise[Count, n, m, opts] , Message[CCSSMathExercise::ran, n, "0-120"]]

CCSSMathExercise[Count,xtext_String, basetext_String, ytext_String] :=
StringReplace["You know the numbers yyy and base, and how to write and speak them. You now count yyy up from base, and then you find the number xxx. You now learn to write and speak the number xxx.", {"xxx" ->  xtext, "base" -> basetext, "yyy" ->  ytext}]


CCSSMathExercise[Count, x_Integer, base_Integer:10, opts___Rule] := 
Module[{xtext, basetext, ytext, digits, speakq, f, famp, fpv, toshow, tospeak},
{digits, speakq} = {IntegerDigits, Speak} /. {opts} /. Options[CCSSMathExercise] ;
fpv = (PlaceValue[#, Speak -> False, Language -> "English", opts]&);
famp = (PlaceValue[#, Speak -> False, Language -> "Amplish", opts]&);
(* to show *)
f = If[digits === False, famp, ToString];
{xtext, basetext, ytext} = f /@ {x, base, x - base};
toshow = CCSSMathExercise[Count,xtext, basetext, ytext] ;
(* to speak *)
If[speakq === True,
{xtext, basetext, ytext} = fpv /@ {x, base, x - base};
tospeak = CCSSMathExercise[Count,xtext, basetext, ytext] ;
LatestPronunciation[] = tospeak;
Speak[tospeak]
]; 
toshow]




CCSSMathContent[]={List["Kindergarten", "NBT","A.1"],List["Grade 1", "NBT","A.1"],List["Grade 1", "NBT","B.2"],List["Grade 1", "NBT","B.2.A"],List["Grade 1", "NBT","B.2.B"],List["Grade 1", "NBT","B.2.C"],List["Grade 1", "NBT","B.3"],List["Grade 1", "NBT","C.4"],List["Grade 1", "NBT","C.5"],List["Grade 1", "NBT","C.6"],List["Grade 2", "NBT","A.1"],List["Grade 2", "NBT","A.1.A"],List["Grade 2", "NBT","A.1.B"],List["Grade 2", "NBT","A.2"],List["Grade 2", "NBT","A.3"],List["Grade 2", "NBT","A.4"],List["Grade 2", "NBT","B.5"]};

CCSSMathContent["Kindergarten", "NBT","A.1"]= "Work with numbers 11-19 to gain foundations for place value. CCSS.Math.Content.K.NBT.A.1.\n  Compose and decompose numbers from 11 to 19 into ten ones and some further ones, e.g., by using objects or drawings, and record each composition or decomposition by a drawing or equation (such as 18 = 10 + 8); understand that these numbers are composed of ten ones and one, two, three, four, five, six, seven, eight, or nine ones.";

CCSSMathContent["Grade 1", "NBT","A.1"]="Extend the counting sequence. CCSS.Math.Content.1.NBT.A.1
  Count to 120, starting at any number less than 120. In this range, read and write numerals and represent a number of objects with a written numeral.";
CCSSMathContent["Grade 1", "NBT","B.2"]="Understand place value. CCSS.Math.Content.1.NBT.B.2
Understand that the two digits of a two-digit number represent amounts of tens and ones. Understand the following as special cases: B.2.A, B.2.B, B.2.C";
CCSSMathContent["Grade 1", "NBT","B.2.A"]="Understand place value. CCSS.Math.Content.1.NBT.B.2.A
  10 can be thought of as a bundle of ten ones — called a \"ten.\"";
CCSSMathContent["Grade 1", "NBT","B.2.B"]=
"Understand place value. CCSS.Math.Content.1.NBT.B.2.B
  The numbers from 11 to 19 are composed of a ten and one, two, three, four, five, six, seven, eight, or nine ones.";
CCSSMathContent["Grade 1", "NBT","B.2.C"]="Understand place value. CCSS.Math.Content.1.NBT.B.2.C
The numbers 10, 20, 30, 40, 50, 60, 70, 80, 90 refer to one, two, three, four, five, six, seven, eight, or nine tens (and 0 ones)";
CCSSMathContent["Grade 1", "NBT","B.3"]="Understand place value. CCSS.Math.Content.1.NBT.B.3
  Compare two two-digit numbers based on meanings of the tens and ones digits, recording the results of comparisons with the symbols >, =, and <.
  Use place value understanding and properties of operations to add and subtract.";
CCSSMathContent["Grade 1", "NBT","C.4"]="Use place value understanding and properties of operations to add and subtract. CCSS.Math.Content.1.NBT.C.4
  Add within 100, including adding a two-digit number and a one-digit number, and adding a two-digit number and a multiple of 10, using concrete models or drawings and strategies based on place value, properties of operations, and/or the relationship between addition and subtraction; relate the strategy to a written method and explain the reasoning used. Understand that in adding two-digit numbers, one adds tens and tens, ones and ones; and sometimes it is necessary to compose a ten.";
CCSSMathContent["Grade 1", "NBT","C.5"]="Use place value understanding and properties of operations to add and subtract. 
CCSS.Math.Content.1.NBT.C.5
  Given a two-digit number, mentally find 10 more or 10 less than the number, without having to count; explain the reasoning used.";
CCSSMathContent["Grade 1", "NBT","C.6"]="Use place value understanding and properties of operations to add and subtract. CCSS.Math.Content.1.NBT.C.6
Subtract multiples of 10 in the range 10-90 from multiples of 10 in the range 10-90 (positive or zero differences), using concrete models or drawings and strategies based on place value, properties of operations, and/or the relationship between addition and subtraction; relate the strategy to a written method and explain the reasoning used.";
CCSSMathContent["Grade 2", "NBT","A.1"]="Understand place value. CCSS.Math.Content.2.NBT.A.1
Understand that the three digits of a three-digit number represent amounts of hundreds, tens, and ones; e.g., 706 equals 7 hundreds, 0 tens, and 6 ones. Understand the following as special cases: A.1.A, A.1.B";
CCSSMathContent["Grade 2", "NBT","A.1.A"]="Understand place value. CCSS.Math.Content.2.NBT.A.1.A
  100 can be thought of as a bundle of ten tens — called a \"hundred.\"";
CCSSMathContent["Grade 2", "NBT","A.1.B"]="Understand place value. CCSS.Math.Content.2.NBT.A.1.B
  The numbers 100, 200, 300, 400, 500, 600, 700, 800, 900 refer to one, two, three, four, five, six, seven, eight, or nine hundreds (and 0 tens and 0 ones).";
CCSSMathContent["Grade 2", "NBT","A.2"]="Understand place value. CCSS.Math.Content.2.NBT.A.2
  Count within 1000; skip-count by 5s, 10s, and 100s.";
CCSSMathContent["Grade 2", "NBT","A.3"]="Understand place value. CCSS.Math.Content.2.NBT.A.3
  Read and write numbers to 1000 using base-ten numerals, number names, and expanded form.";
CCSSMathContent["Grade 2", "NBT","A.4"]="Understand place value. CCSS.Math.Content.2.NBT.A.4
  Compare two three-digit numbers based on meanings of the hundreds, tens, and ones digits, using >, =, and < symbols to record the results of comparisons.
  Use place value understanding and properties of operations to add and subtract.";
CCSSMathContent["Grade 2", "NBT","B.5"]="Use place value understanding and properties of operations to add and subtract. CCSS.Math.Content.2.NBT.B.5
  Fluently add and subtract within 100 using strategies based on place value, properties of operations, and/or the relationship between addition and subtraction.";

CCSSMathContent["Grade 3","OA","D.9"]="Solve problems involving the four operations, and identify and explain patterns in arithmetic. CCSS.Math.Content.3.OA.D.9
Identify arithmetic patterns (including patterns in the addition table or multiplication table), and explain them using properties of operations.";
CCSSMathContent["Grade 4","NBT","A.2"]="Generalize place value understanding for multi-digit whole numbers. CCSS.Math.Content.4.NBT.A.2
Read and write multi-digit whole numbers using base-ten numerals, number names, and expanded form. Compare two multi-digit numbers based on meanings of the digits in each place, using >, =, and < symbols to record the results of comparisons.";

End[];

Protect[CCSSMathContent, CCSSMathExercise];
EndPackage[];

. Introduction

.. Key example

A picture says more than a thousand words:

25 = 2 × 10  +  5 = two·ten  &  five

The default is Speak -> True.

PlaceValue[25]

The connectives “&” and “·” are used to codify the sound, and differ from the operators “plus” and “group” (multi-plus, repeat, times), since + and × have commutation, association and distribution.

The center dot (·) is unpronounced. The trailing center dot is deliberate and indicates the ghost of the departed one. The strict use of the place value system is that 1 is actually 1 of 1 (also distinguishing numbers and digits). Normally we simplify, but we should be able to show how the system actually works.

PlaceValue[25, Speak -> False, Simplify -> False]

The ampersand (&) will surprise native speakers of English but derives from quite some consideration. German (“und”), Dutch (“en”) and Danish (“og”) have the “&” connective and for good reason. See the discussion of the connectives below.

PlaceValueTable[25, Speak -> False]

PlaceValueTable[25, Language -> "Danish", Speak -> True]

.. Kids live in a world of sounds

A number consists of sound, numeral, word (that records the sound). Kids in kindergarten and Grade 1 live in a world of sounds so that the pronunciation of numbers is important. When they are learning to read and write, the co-ordination of (i) sounds, (ii) numerals and (iii) written words (subvocalisation but still sounds) is important. We already have the place value system fully in the numerals but not yet in pronunciation and words.

The place value system puts digits in positions, with the digit being the weight and the position the place value (in our case a power of 10). The traditional pronunciation  has these breaches upon the full use of the place value system:

On order: nine-teen instead of ten & nine. (Rule: speak the highest place value first.)

On weights: twenty instead of two·ten. (Rule: speak the weight of the place value.)

We do not have to assume that kids must learn formal multiplication (grouping) and the table and the powers of 10 before they can work with the numbers and the place value system. But it is another thing to hide the very structure that is the object of learning. It is better to use the full place value system, which will support the involved learning of arithmetic.

The US Common Core State Standards (2018) rightly wants for kindergarten: “Work with numbers 11-19 to gain foundations for place value: CCSS.Math.Content.K.NBT.A.1.” They do not say that they implement only a partial and not the full place value system.

PM. The West reads and writes from left to right, while the numbers came from a region in India that read and wrote from right to left. We can leave this phenomenon as it is because there is advantage in beginning the pronunciation with the highest place value with nonzero weight.

.. What this notebook with package provides

This notebook with package provides an implementation for English, German, French, Dutch and Danish. For these languages there is a transliteration in English. For other languages Mathematica's IntegerName and WordTranslation can be used for an automated translation, see the examples for Italian and Spanish, but then without transliteration. Only needed are 18 terms, for sign, “&”, ten digits and the powers of 10 to a million (for our main application). The ampersand (&) is quite universal but will be pronounced differently, and the center dot (·) remains unpronounced.

The reason to have more languages is that this is an international issue, though fragmented over the languages. A windfall benefit is that the reader and listener may experience a little bit how it would be for kids to rely on sounds  to learn about numbers and their structure.

Colignatus (2015b, 2018a) manually typed out conversion tables for English, German, French, Dutch and Danish. This close reading is important since natural languages (and their language committees) develop peculiarities, while there also can be conflicts between current pronunciation and the simple elaboration with 10, see German zehn | zig and Dutch tien | tig below. Adapting to another language than those checked ones may still cause such conflicts for the proposed full use of the place value system. The feature of transliteration started out for presentation (of the checked languages) but appears to be important as a gateway for quality control (of unchecked languages) as well.

The US Common Core (2018) has negative numbers only in Grade 6, and Holland and the UK only in Grade 7 (junior highschool). For us it remains useful to include the negative sign too.

.. A natural language as a dialect of mathematics

We tend to use the term “natural language” but we should not forget that scores of influential authors and committees have been working on the traditional pronunciation of the natural numbers. When there is scope for improvement then it can be discussed. This is not an issue of spelling reform but an issue of mathematics education. Arithmetic and number sense are not only about numerals and the operations but also about how you pronounce the numbers, especially for kids who cannot read or write yet, and how it percolates into later thought (that might be “subvocalised speaking”).

The suggestion is that schools indeed embrace this full use of the place value system, so that language at school is the language of arithmetic, and so that the common language on the numbers used at home can be regarded as a dialect of this language of arithmetic. Kids can deal with such differences in language. It is 12 years after the implementation from kindergarten and up that the national judicial system must have worked out whether the pronunciation of arithmetic would also be relevant and acceptable for legal issues.

Colignatus (2015a), A child wants nice and no mean numbers.

.. The need for an ISO standard

The system proposed here is simple but still supports a full use of the place value system for education in kindergarten and elementary school. It must become an ISO standard, so that educators and textbook & software publishers but also researchers have stability of their environment. Even when schools would not implement the system (so fast), researchers and teacher trainers require a standard to correct their research findings for confounding by the natural languages. The definition of this standard is given here, and this notebook with package only provide an implementation:

Colignatus (2015b, 2018a), The need for a standard for the mathematical pronunciation of the natural numbers. Suggested principles of design. Implementation for English, German, French, Dutch and Danish.

The amendment in 2018a is the use of the connectives, see below.

.. Discussion on content and a technical report

The suggestion for a full place value system was motivated by education. The package implements this, and this notebook contains much of a technical discussion on how to use the package. However, the very reason to make the suggestion derives from education, and we should not forget about this very motivation. This notebook thus also looks at how the package might be applied for the Common Core State Standards (2018). We can identify 4 levels of number sense relevant for pronunciation and the full use of the place value system that are supported by 4 routines in the package. This discussion is not intended as a comment on the curriculum or as a suggestion how the curriculum might look like.

This present discussion on content does not discuss the fundamentals for the standard, and the reader is referred to (2015ab, 2018a) for the more involved discussion. This present notebook with package provides for a software implementation in Mathematica, and we concentrate on the latter.

Though the package contains the full system - with the definition that must become an ISO standard - it has practical limitations. The main purpose of this notebook is to set some first steps towards implementation and to circulate the idea. Programming on language is quite involved, and implementing change even more.

.. Transliteration for a quick impression

When you install Mathematica you select your $Language in the Preferences. You can change the Preferences for another language and then do a restart. A setting of $Language will also provide for such pronunciation of the digits and numerals, though in traditional fashion. The routines provided here should give access to the full place value system of your $Language, though with these warnings: (i) except for the comment on quality control (see above), (ii) and perhaps except for the setting of some options, likely an adaptation of the connectives (see below). I did not test changing $Language from “English”.

At times it is an acceptable and faster way to transliterate words. Tourists are familiar with transliterations in their tourist guides. For example, French "deux" is pronounced in English as "duh". We use this transliteration now since it provides for a quick impression (without restart) how the full use of the place value system would look also in some other languages. This helps to identify that this is an international issue that is served by an ISO standard. Indeed, other languages are also included in the proposal Colignatus (2015b, 2018a) but it makes a difference to actually hear it pronounced.

The transliteration must be defined for the $Language in your installment of Mathematica. The package basically allows for different settings, yet has been developed while using $Language = "English".

.. Structure of the paper

Below, I briefly indicate some history and other researchers. The main section explains the working of the package. It will be most instructive though to start with examples that highlight the properties. The main body of the text will use English, French and German while there will be a bit more later about Dutch and Danish. The definitions of the routines are printed in the Appendix. The standard routines in Mathematica provide for a link to the current (traditional) pronunciation in the natural languages. The traditional (wrong) pronunciation and notation has received quite some support, but let us now look at the full use of the place value system.

. Example in English

The following describes our implementation (and not the English language as it is). There could be a difference between the output that the package generates, intended for interactive learning, and texts that a textbook could show. For example, a textbook could have two·ten & five but the package may put in some more blanks.

.. Speaking and writing

There is a difference between speaking and writing. Speaking uses a pause. The present pause might be a bit long, but this length was pleasant for the transliteration of other languages. The routines tend to have default Speak -> True, but you can turn it off. The routines show the words in the chosen language and not the transliterations, unless you explicitly ask for the transliterations.

PlaceValue[21]   (*default Speak -> True *)

The routines store what was spoken (or often what could have been spoken if not turned off).

LatestPronunciation[]

.. Simplify

For the place value system, it is important to recognise that 1 is actualy 1 of 1 (with a conceptual difference between digits and single digit numbers). After a short while this meticulous accuracy becomes annoying whence we simplify. It is advisable to teach the place value system, but it is also acceptable to simplify “one hundred” into “hundred”, and to pronounce 10 as “ten” and not as “0 hundred, 1 ten, 0 one”. Nevertheless, for teaching it is important to show both the whole system and its simplification. The trailing dot appears to be a quite useful indicator of this simplification.

PlaceValue[1, Speak -> False]

PlaceValue[1, Speak -> False, Simplify -> False]

Above, there has been simplification of 21, indicated by a trailing dot.

PlaceValue[21, Speak -> False, Simplify -> False]

.. Traditional pronunciation

PartialPlaceValue calls Mathematica’s IntegerName and gives the traditional pronunciation.

PartialPlaceValue[123]

PlaceValue gives the full place value pronunciation.

PlaceValue[123]

.. The connectives

The connectives “&” and “·” have an important role. They differ from the operators “plus” and “group” (multi-plus, repeat, times), since + and × have commutation, association and distribution.

The ampersand (&) is the ghost of addition, but simply “and”, and not the operator “plus” with all its properties. The ampersand should be pronounced, namely to separate the place value positions. It is already (often) pronounced in German, Dutch and Danish. Other languages better adopt this practice too. Remember that we are speaking about the language of arithmetic to be used in school and not about an integral language reform (that would evolve).

The center dot (not pronounced) is the ghost of multiplication of the weight and the place value. Remember: 5 days 2 hamburgers is not the same as 2 days 5 hamburgers.

Kids in kindergarten and Grade 1 live in a world of sounds. Thus they should be provided with the &-separator of the place value positions, so that they have this anchor on which is what. For adults and native speakers of English it may seem superfluous. Indeed, I myself in (2015a, footnote 10, and 2015b before the amendment in 2018a) found the use of “&” “distractive”. My proposal then was to use the center dot for “&” too: thus without the distinction and merely as an unpronounced connective, as 25 = two·ten·five. However, in reconsideration, the empirical observation is that the &-separator really is there. Its existence must be acknowledged instead of hidden from sight.

Namely, in natural language, putting two terms alongside, like in 2 km, means scalar multiplication. In multiplication as grouping, kids learn to use the times-symbol, but we do not write 2 × km. Later students will learn that 2 a is multiplication in general, also dropping the times-symbol. If they would have been trained by the pronunciation of the very numbers (and a in 2a would be a number, in this scenario like a = 25 = two·ten five, thus without the “&”) then we create a conundrum: (1) within “a = 25 = two·ten five” the lack of an interfix means addition and (ii) outside of this, in 2 a, the lack of an interfix means multiplication ? We should not create conundrums. Thus 25 =  two·ten & five. It should help understand 2 × 25. Perhaps adults might not speak the ampersand but for kindergarten and elementary school it is part of the system.

Indeed, in kindergarten and Grade 1 kids will tend to focus on the & as an important new symbol in their universe, but this is not “distractive” but only fortunate, because it will form a stepping stone for the later learning on addition, i.e. using plus. Eventually they would tend to focus on the figures in the numbers and not the connectives.

NB. The ampersand is remarkably large in common fonts (like upper case), and it is better displayed in a smaller font (like lower case). It appears that Speak cannot deal with a Stylebox in the strings that we are using. The solution was to create the language “Amplish”, that has the True form with the smaller font for the ampersand, and that is transliterated in English in the default font. This worked fine, and thus all languages here have the smaller ampersand (which might cause that one has to adapt the package to work under a different $Language). The functionality of providing transliteration was useful here too. This only applies for the routines PlaceValue and PlaceValueRules.  It is useful to know for the option settings. Check the visual difference:

PlaceValue[25, Language -> "Amplish"]  (*default*)

PlaceValue[25, Language -> "English"]

.. Do not use ones, tens, hundreds

The Common Core (2018) has:

CCSSMathContent["Grade 1", "NBT","B.2.C"]

CCSS writes about “tens”, and elsewhere also about “ones”.  CCSS likely can be so sloppy since common English has “twenty” instead of “two·tens” etcetera. If English had adopted such system with the plurals of the bases, with a multitude of s’s, then the abuse might be noticed sooner.

For CCSS "two × three" should also be "twos × threes", because the two implies that the threes are plural, and the three implies that the twos are plural. It shows that one doesn’t understand what a number is. Instead of “5 tens” one better says “5 of ten”, since “of” means grouping (multiplication).

The use of “ones” and “tens” pre-dates the development of the place value system, and is not supported in pronunciation, since the numbers 11-19 are properly pronounced in place value manner. The proper expression for 20 is 2·10, and we speak the base, which is 10 and not “tens”. One should avoid speaking about “ones” and “tens”. These plurals arise in a context when teachers are groping for a way of expression, but those words are confusing for kids as if these words would really be defined. Likely this is similar to 1 car versus 2 cars, but a base has a different linguistic treatment. (We are not pronouncing telephone numbers by rattling of the digits either.)

Remember that a puzzle is only complete when all pieces are in the proper places. When something has a logical structure then people are bound to get at least one piece wrong and develop an emotional hangup on it, and each person or nation another piece. There is no other solution than to clarify the logical structure.

.. Myriad and lakh

The figure 10,000 tends to be pronounced commonly as “ten thousand”. Remarkably, there are no specific terms for (10^(4 ))and (10^5) in all the languages in the package. Perhaps French may have a more common acceptance of the Greek myriad = (100^2). This is another breach of the place value system. Wikipedia (a portal and no source) observes the lack too, and mentions Greek myriad and Indian lakh. I have adopted these words for the languages mentioned in the packages too. It takes some adjustment to hear 500,000 being pronounced as 5 lakh, but such adjustment is the very purpose of the exercise. It is not an urgent issue for kindergarten though.

PlaceValue[500000, Speak -> False]

These names are used in the main method that pronounces each entry separately. When the blocks of 3 digits are pronounced then they are superfluous.

.. The sign

The proper pronunciation of the minus sign in numbers is “negative”, because “minus” is used for the binary operation. Mathematica’s IntegerName gives the number and uses “negative” indeed.

PartialPlaceValue[-10]

The new routines allow us to show the structure of the place value system.

PlaceValue[-10, Speak -> False, Simplify -> False]

Unfortunately Mathematica uses Minus[x] for -x, and also pronounces it that way (it may pronounces the format in Mathematica rather than the number). Wikipedia (a portal and no source) regards “negative” as American English, but the better diagnosis is that British English is imprecise. Dutch can distinguish 7 minus 10 = min 3.

?Minus

{Minus[10], -10}

Speak[%]

. History, tradition, assumptions, advantages

.. History of proposals for change

Jane Austen (1775-1817) apparently still wrote “three and twenty” insteady of “twenty-three”. The English speaking people are lucky that they managed the change on the order (major) though unlucky with the loss of “and” (minor).

Norway managed the change in the 1950s.

Fred Schuh (1875-1966) of TU Delft proposed this in the 1950s in Holland but he didn’t convince the minister of education. I am not aware of other Dutch authors who propose this nowadays.

In Germany there is a small movement with Lothar Gerritzen to change their "ein und zwanzig" (perhaps no blanks) into "zwanzigeins" (apparently no blanks): https://zwanzigeins.jetzt/

In Denmark there are Lisser Rye Ejersbo and Morten Misfeldt at Aarhus. Ejersbo recommends the recent book of the 23rd ICMI conference,  Bussi & Sun (ed.)(2018). See http://vbn.aau.dk/da/publications/danish-number-names-and-number-concepts(7b79a70d-d42b-49dc-af1f-75775c9292f6)/export.html

China uses the place value system in the form of Level 2 discussed below. I am only kicking in open doors. It might be an option to translate a number first into Chinese and then transcribe back, see Uy (2003) . However, this present notebook with package gives more control and includes didactic notions. Chinese does not pronounce the connective “&” (though it is implied) and we should better use it. Mathematica already provides this routine.

Table[IntegerString[10^k, "TraditionalChineseDecimal"], {k, 0, 4}]

Fateman (2013) discusses computerised speaking of math, with a proper distinction between how we currently pronounce the numbers and how we “should” do this. It is much wider and deeper than my  present purposes.

Mathematica provides routines IntegerName and WordTranslation but we cannot always use them, since (i) we must avoid the breaches, put terms into proper order and get rid of “twenty” and “ten thousand”, and (ii) we want to show the intermediate steps without simplification so that kids can see what the place value system actually is.

.. Tradition is not without reason but still counterproductive

Traditional pronunciation and its didactics are not without reason.

Kids start with 0-10, in which 10 is a new name "ten" and not "1·ten" and then simplified. These kids would use grouping (multiplication) but have no developed vocabulary and command on this. When continuing with 11-20 ("eleven" is "one left over" after 10) and speaking from right to left (and perhaps writing so too), they write 19 and in the conventional dialect speak "nine-teen", which fits the order of their low numbers writing from right to left. Our reference to left and right is tricky since kids might still be struggling with which is what. "Twenty" again is a single notion, since kids might not have command of multiplication yet. In English kids make the switch to "speak the highest place value first" at 20. In German and Dutch they do so at 100. This focus might make sense in kindergarten and Grade 1, if we neglect the existence of other numbers, or if we neglect that the same kids in kindergarten and Grade 1 grow up and have to learn those other numbers too.

If kids in kindergarten and elementary really started out writing from right to left in general, also for words, from the argument that empirical research has shown that this would be easier for them, then one might have an argument that 13 best is pronounced from right to left. Likely though, the order survives from the Fibonacci’s Liber Abaci of 1202. Not only the current order but also the traditional pronunciation is simply imposed upon them, with the only argument that school teaches tradition for the sake of tradition. A change may require retraining kindergarten teachers who may be weak on arithmetic anyway yet this is a one-time investment with major persistent benefits.

.. Assumptions

Full use of the place value system:

does not require kids to understand formal multiplication and have command of the table of 10 and later the powers of 10, but only adopts a pronunciation and way of writing of both numerals and words that support this later development rather than hindering it

makes the switch to "spreak the highest place value first" already at 10 (and not 20 or 100), which is precisely the moment when the phenomenon occurs for the first time, and which thus establishes the system without exception (and kids can be told about this rule)

recognises that "teen" and "ty" (indeed in the world of sounds) are useful indicators for value (compare: three, thirteen, thirty, third) but sees more profit in fully using the place value system so that value transpires from the structure in the pronunciation rather than from employing different sounds (since sounds can also sabotage and obscure the structure).

This approach makes the assumption that kids can acquire a structure. This is a weak assumption since kids can already acquire language and a sense of reality that are filled with all kinds of structures. If kids can learn something illogical then they should be able to learn something logical. Chinese kids learn the place value system on a regular basis. Our topic is not really an issue of empirical research but one of traditional thinking in the world of educators and researchers. Complications are: The latter world of education may have little command of mathematics and think that tradition already captures mathematics. Sacrosanct means: high respect for something that you do not grasp. Mathematicians dealing with arithmetic in school may think abstractly and have no background in empirics, and focus on learning the numerals.

.. Main advantages

To teach the place value system, it is advisable to actually use it.

Pronuncation (that kids start with) would be co-ordinated with the numerals, and later with the written words. (Number: pronunciation, numeral, word.)

The workflow is into a single direction, and does not jump around.

Merely speaking a number aloud can already solve calculation questions. (For many kids: thinking may be “subvocalised speaking”, as reading is subvocalised.)

Current co-ordination failures (i.e. the breaches) often are not discussed so that kids simply do not know why they find issues complicated, and they are groping in the dark.

There will be a sizeable savings in teaching and learning time, that can be spent on real issues.

Research on mathematical skill and number sense is highly contaminated by this pronunciation issue. Much research draws invalid conclusions. Doing good research is quite impossible because you cannot simply experiment on kids by first training them on your own theory on the place value method. We neither can compare international results when there is such variety and invalidity. (In studies in Holland and Denmark, kids were observed to use English, and telling others to do so too, because they better understood the numbers in that way.)

. A structure for the curriculum

.. Overview

This notebook with package is not intended as a course on the full place value system for kindergarten and elementary school. Teachers would tend to start with discussion in print for their first orientation. Colignatus (2015b, 2018a) is such an introduction, and provides tables for the pronunciation of the integers in the full place value system, for English, German, French, Dutch and Danish. This notebook with package supplements this material with the ability of sound (basically in $Language, but for practical purposes now in transliteration). We mimick the situations that kids would be in, at different levels of competence. The purpose of this Section is to indicate which aspect of the place value system is highlighted by what routine.

We will quote from: http://www.corestandards.org/Math/Content/NBT.

Below we start with counting but of course quickly meet with the transition from counting to addition. We focus on the pronunciation and leave this transition aside, though there is a clear link of course between the ampersand and plus. See Colignatus (2018b), Tables for addition and subtraction with better use of the place value system.

For the curriculum on the place value system we can recognise a structure with the following levels. Per level there is a supporting routine. We first discuss the levels, and later collect them into a switching routine. This switching routine can now be used for a quick overview of what the routines do. These examples use higher numbers merely to show the properties. Obviously kids start with 0-10 but such a number doesn’t highlight what the routine does.

Level 1. Sounds only (kids cannot read and write). Words record the sounds for us. Speaking them gives their world.

PronounceInteger[12, Level -> 1, Speak -> False]   (*overview without Speak*)

Level 2. Learning the digits and numerals (already having the sounds for the digits).

PronounceInteger[1234, Level -> 2, Speak -> False, Print -> False] (*overview without Speak*)

Also learning how to write the words.

PronounceInteger[1234, Level -> 2, Speak -> False] (*default*)

Level 3. Advanced: putting digits in blocks of three. (There are slightly special lists because we want to Speak “one hundred” instead of “one one-hundred”.)

PronounceInteger[123456, Level -> 3, Speak -> False] (*overview without Speak*)

Level 4. Accomplished: using blocks of three digits (but pronounced in full place value).

PronounceInteger[123456, Level -> 4, Speak -> False] (*overview without Speak*)

LatestPronunciation[]

.. Level 1. Sounds

... No reading and writing yet

Kids in kindergarten start with pronunciation. They cannot read and write yet. Their sounds are encoded in words but only the teacher would know how to write those words. The teacher must get used to the full place value system, and will first rely on written words. The advantage of using words is that the pronunciation becomes unambiguous for the particular language.

The main routine supports this situation by using words for pronunciation and transliteration.  We produce the sounds that kids would hear and what they would copy in rehearsing, and we print the spoken words in the chosen language for the sake of the teacher. The routine speaks in $Language (here "English") but may use transliteration.

PlaceValue[#, Language -> "French"]& /@ Range[0, 10]

Rehearsing the sequence will cause kids to regard these words as a sequence, and the sequence can be related to other phenomena.

... Common Core on 11-19 in sounds

CCSSMathContent["Kindergarten", "NBT", "A.1"]

Observe that CCSS speaks about “ten ones” instead of “ten of one”, and see the rejection of “ones”, “tens” and “hundreds” above. Kids can collect ten apples in a basket of ten. They can agree that there are ten of 1 apple and 1 basket of ten apples. If kids can count, then they also should know what they are counting (fingers, cars, baskets), and thus it is proper to explicitly discuss with them what to take as unit of account. Taking the basket of ten as the base, they may accept that a number is spoken as “one of ten” but simplified to ten since this is the base.

Instead of rehearsing all numbers from 0 to 20, we speak a small selection now.

(PlaceValue /@ Range[8, 13]) // MatrixForm

The latter in French.

(PlaceValue[#, Language -> "French"]& /@ Range[8, 13]) // MatrixForm

If your $Language = “English” too, then you can verify that the latter French words were transliterated in English.

LatestPronunciation[]

... A possible exercise still in speaking only

The following exercise is only in English and not in the other languages. The routine has the answer of the sum as input. In this case we select an outcome less than 20.

CCSSMathExercise[15, 12, Speak -> True]

The exercise is done by speaking the counts.

(PlaceValue /@ Range[12, 15]) // MatrixForm

.. Level 2. Sounds and numerals, and then reading and writing

At the second level, kids learn to read and write the digits 0, ..., 9 and the numerals 0, ..., 9.

... Showing the numeral and speaking it

The first step mimicks this learning process by showing the numeral and speaking the (transliterated) word. Running this routine often might cause that the association between the sound and the picture is transferred into human memory.

PlaceValueDigits[4, Language ->  "French", Print -> False]

Of course, this does not yet give information about how this 4 relates to the other numbers. We are only discussing the link between the pronunciation (often already known) and the figure.

... Showing the numeral, speaking it, and learning the word

In a second step kids also learn the word. The routine shows the numeral and official word, and speaks the (transliterated) word. Again, running the routine often might cause that the association is transferred into human memory. I do not want to imply that kids first must learn to write the word before they can continue with the numerals. This only intends to show that the routines can support such learning, assuming having or getting command of sounds.

result = PlaceValueDigits[4, Language ->  "French"]  (*Print default*)

The following statement collects the input, what has been printed and spoken, and the output.

{4, LatestPronunciation[Print], LatestPronunciation[], result}

... The digit / numeral by itself is not place value yet

Observe that digits do not have a trailing dot. Learning the digits differs from learning the numbers in a place value system. The digits could also be used in another system.

It depends upon didactics and empirical research whether it is useful at this stage to discuss that 4 can also be understood as 4·1 in full place value system. Likely this would be totally confusing. I advise against this, and I actually do not think that research on this would be so urgent.

result = PlaceValueDigits[4, Language ->  "French", Simplify -> False]

The latter gives the new number denoted in the place value system (though not yet constructed at this stage), its unsimplified pronunciation, and its decomposition in the weighted place values. Do not use this here. It only becomes a useful insight when the system is already quite developed. I only mention it here to issue the warning not to use it here.

... Introducing the symbol 10

Once the digits and numbers 0 ... 9 have been mastered (to a sufficient degree to move on) there is the crucial step of creating the positional system, moving into the numerals of 10 ... 20.

CCSSMathContent["Grade 1", "NBT","B.2.A"]

CCSS seems confused between (i) learning what ten is and (ii) learning how to write it in numeral and word. CCSS again speaks about “ten ones” instead of “ten of one”.

Likely Grade 1 has already been counting from zero to ten because of the fingers. In that case the sound “ten”with its numerical meaning would have been introduced above already. (Remember CCSS.Math.Content.K.NBT.A.1 above !) The crux here is to relate the familiar sound to the new picture of 10 (writing is drawing small pictures). The teacher can explain that there are ten digits 0, ..., 9, and that we need a new symbol for ten, and that this new symbol is 10. This will not be the telephone number “one-zero” but a written “10” is pronounced as “ten”.

Running this routine often might cause that the association between the sound and the picture is transferred into human memory. (It is important to identify the moments and methods of learning.)

PlaceValueDigits[10]

PlaceValueDigits[10, Language -> "French"]

... Building up 11-19 as symbols

Having 10, it is easy to say that additional counts 1, ..., 9 will be recorded in the position of the 0. Again, kids have already learned aspects about the numbers 11, ..., 19 entirely in their world of sounds (see the subsection above), and the learning goal now is to read and write the figures. A major issue is to write (from left to right) first the 1 and then the additional count, The 1 is higher because it represents 10. The shortcut (pons asinorum) is that the count is recorded in the place of the 0.

CCSSMathContent["Grade 1", "NBT","B.2.B"]

Basically we have vector addition.

{1, 0} + {0, count}  (* 10 + count, decomposed by positions *)

It might become feasible to show the kids numerals in a question like this.

CCSSMathExercise[15, 12,"Grade" -> "Grade 1",  Speak -> True, IntegerDigits -> True]

The above was spoken in full place value manner. You might recognise the larger ampersand.

LatestPronunciation[]

result = PlaceValueDigits[inp = 15, Language -> "French"]

We thus have the new number denoted in the place value system, its pronunciation, and its decomposition in the weighted place values.

{inp, LatestPronunciation[Print],  result}

... Introducing 20

CCSSMathContent["Grade 1", "NBT","B.2"]

After 9, we have no longer digits available to record at the position zero, and we make the transition of the position.

{1, 0} + {1, 0}   (* 10 + 10 decomposed by positions*)

CCSSMathExercise[inp = 20, 19,"Grade" -> "Grade 1",  Speak -> True, IntegerDigits -> True]

From the rehearsing the sequences before, the kid likely already knows that 20 comes after 19. The present learning goal is how to record the sound using digits.

It depends upon empirics how much can be discussed about place value arithmetic. We have: 19 + 1 = 10 + 9 + 1 = 10 + 10 = 20. Thus we unpack 19, reorder, pack 9 + 1 and pack 10 + 10 .

result = PlaceValueDigits[inp, Language ->  "French"]

We thus have the new number denoted in the place value system, its pronunciation, and its decomposition in the weighted place values.

{inp, LatestPronunciation[Print],  result}

... Building up 21-29

CCSSMathContent["Grade 1", "NBT","B.2"]

See Colignatus (2018b) for tables of addition and subtraction with full use of place value.

{1,2} + {1, 4}

The excercise mentions counting but we are not looking at the shift from counting to addition here. Numerals are shown but the exercise is pronounced in full place value manner.

CCSSMathExercise[inp =26, 12, "Grade" -> "Grade 1",  Speak -> True, IntegerDigits -> True]

LatestPronunciation[]

result = PlaceValueDigits[inp, Language ->  "French"]

We thus have the new number denoted in the place value system, its pronunciation, and its decomposition in the weighted place values.

{inp, LatestPronunciation[Print],  result}

... The table of 10

CCSSMathContent["Grade 1", "NBT","B.2.C"]

See the comment above on avoiding “tens”, and how the “s” would pollute the table of ten.

PlaceValueTable[Range[10, 90, 10], Language -> "French"]

?PlaceValueTable

... Building up the positional system

We now repeat the above, in ever higher numbers, with the next place value transition at (10^2).

CCSSMathContent["Grade 1", "NBT","A.1"]

{1, 0, 0} + {0, count10, count1}

The following is spoken in full place value manner.

CCSSMathExercise[120, 119,"Grade" -> "Grade 1",  Speak -> True, IntegerDigits -> True]

LatestPronunciation[]

result = PlaceValueDigits[inp = 120, Language -> "French"]

We thus have the new number denoted in the place value system, its pronunciation, and its decomposition in the weighted place values.

{inp, LatestPronunciation[Print],  result}

... Grade 2 and 100

CCSSMathContent["Grade 2", "NBT", "A.1.A"]

Surprisingly, CCSS requires kids of Grade 1 to count to 120 but CCSS also wants that the word “hundred” is mentioned only in Grade 2 ? Likely kids at that stage would also know that 100 is 10 of 10. My impression is: CCSS wants Grade 2 to grow aware that 100 features in the place value system precisely because it is a power of 10. My other impression is that it suffices to show the role of 10, 100, 1000 etcetera but discuss the power structure only later. Often you better use something first, so that the explanation can better be understood once you know what it is about. Dutch mathematician and teacher Gerrit Mannoury (1867-1956): “The meaning of words is their use.” (my transscription) - and this was later also seen by Ludwig Wittgenstein (1889-1951), and likely before by C.S. Peirce (1839-1914) though I do not have a quote. Do not wait too long with the explanation otherwise students develop awkward misunderstandings and habits. My third impression is that CCSS is pernicious on grouping. They avoid the term “grouping” (multiplication) but use “bundling”, as a lawyer might suggest that bundling doesn’t necessarily mean grouping, and hide definitions to make it seem serious. My suggestion is to do a proper table of 10, so that also 10 of 10 = 100 = hundred is included (and not limit this to 90 as in CCSS.Math.Content.1.NBT.B.2.C above). In the full place value, 100 is not decomposed in ten·ten. But we obviously want kids to know this. At some point it can be explained that using ten digits to construct numerals causes the use of the powers of ten. A square of (10^2) and a cube of (10^3) should not be hard to grasp. PM. Tradition simplifies for one 1 but curiously doesn’t simplify fully for one 100.

PlaceValueTable[100]

PlaceValueTable[100, Simplify -> False]

... Grade 2 and 100 - 1000

CCSSMathContent["Grade 2", "NBT", "A.1"]

PlaceValueDigits[706, Language ->  "French"]

PlaceValueDigits[706, Language ->  "French", Simplify -> False]

CCSSMathContent["Grade 2", "NBT", "A.1.B"]

CCSSMathContent["Grade 2", "NBT", "A.2"]

CCSSMathContent["Grade 2", "NBT", "A.3"]

From the Glossary: “Expanded form. A multi-digit number is expressed in expanded form when it is written as a sum of single-digit multiples of powers of ten. For example, 643 = 600 + 40 + 3.”

Our routines allow digging deeper.

PlaceValueDigits[643, Language ->  "French", And -> "+"]

We already had this in “&” but CCSS only knows about “+“. My suggestion is that kids know about secret codes, and thus know about the distinction between content and coding. They should be able to understand that “&” and “·” are used to encode the pronunciation of the numbers and that “+“ and “×” are the operators with properties of commutation, association and distribution.  If they don’t get it then it is the objective of education that they get it. Watching movies with secret codes is an acquired taste.

... Grades 3 & 4 and 100 - 1000

Grade 3 has multiplication and Grade 4 is more aware of complexities.

CCSSMathContent["Grade 3","OA","D.9"]

CCSSMathContent["Grade 4","NBT","A.2"]

Students are now up to a discussion of the full place value system using their command of numbers and multiplication. This shows how the place value system works, though using $Language for the (single) StepMonitor and again using “+“. We might show with and without simplification.

PlaceValueDigits[643, Language ->  "French", StepMonitor -> True, And -> "+"]

PM. The place value system speaks all positions separately, e.g. also (10^(4 ))and (10^5). We write out all zeros (1000) and do not use exponents since we assume that kids haven’t had exponents yet but they can count the number of zeros.  The following obviously is not for 2nd Grade, but it shows how the routine works. The spoken and written version is actually the Chinese method, see Uy (2003), though with the added feature here of the ampersand infixes. We have freedom to choose the infix (but a StyleBox will not work).

PlaceValueDigits[1115124, And -> ","]

.. Level 3. Blocks of three digits

I did not see the following in the CCSS but may have overlooked it.

The students learn higher numbers, and how to pronounce them by blocks of 3 digits. This convention is efficient - and avoids the need for special names for (10^4) and (10^5). The insertion of “and” between the blocks and their weights provides a useful resting pause.

result = PlaceValueBlock[654121]

For larger values we might display without the ampersand (which is the form in the Abstract).

PlaceValueBlock[654121, And -> "", Speak -> False]

The layout of these lists has the following explanation: The routine PlaceValueBlock only uses $Language. The package was written with $Language = “English”.  It appears that Speak[100] is “one hundred” and Speak[1·100] thus is “one one-hundred”. The “one one-hundred” and “one one-thousand” were so annoying, if not confusing, in combination with pronouncing the three digits and their place values, that I changed to “hundred” and “thousand” in speech.

There is a difference between what we want Mathematica to Speak (with the infixes) and what we want to Show now (at the head of the expression). The following is somewhat okay.

TreeForm[result/. List[x_, " & ", y_] :> (x ~" & "~ y)]

.. Level 4. Daily use

In the final phase kids are mastering or have mastered the place value system. The following routine adopts the convention of Mathematica’s IntegerName: absolute values less than 1000 are given as words (effectively PlaceValue), and higher values are combinations of blocks of digits and their bases in words (thousand, million, etc.). This allows high numbers. The block bases can be submitted to WordTranslation. Drawbacks: (i) The use of another language is relatively slow because of WordTranslation. (ii) Transliteration was included later and wasn’t designed for speed.  PM. We separate the digit bases by a comma. This option for And can be adapted but is not passed on to PlaceValue.

PlaceValueIntegerName[99, Language -> "French"]

PlaceValueIntegerName[1011, Language -> "French"]   (* above 999 *)

LatestPronunciation[]

PlaceValueIntegerName[1090011]

LatestPronunciation[]

PlaceValueIntegerName[1234451011, Language -> "French", Speak -> False]

LatestPronunciation[]

Just to be sure: WordTranslation provided two possibilities, and the routine always takes the first.

WordTranslation["billion", "English" -> "French"]

The LatestPronunciation[] gives  words in French without transliteration into English, because of the option Speak -> False. Speaking it in English will be far removed from the actual pronunciation in French. If you want a transliteration then use Speak -> True, or Level 1 again (that also drops the first “un”). In all cases transliteration is restricted to absolute numbers less than (10^7) (and thus “billion” is pronounced in English).

.. Level -4. Traditional pronunciation

Traditional pronunciation uses the place value system partially, with breaches of order and structure. Given the diagnosis in my booklet (2015a) A child wants nice and no mean numbers, it was tempting to use the name MeanNumbers for the tradition routine, but there is a difference between an expresssive book title and programming, and thus I settled for PartialPlaceValue. It is at level -4. Conventionally it uses the blocks of 3 digits. The routine uses Mathematica’s IntegerName using DigitsWords and adopts its convention: For -1000 < n < 1000 only words are shown but for higher absolute values the blocks of digits are shown. Drawback: no transliteration.

PartialPlaceValue[321]

PartialPlaceValue[654321]

Speak stops when meeting a hyphen, and thus hyphens are replaced by blanks. Unfortunately for other languages, IntegerName concatenates the words. It is too involved to undo this.

PartialPlaceValue[21, Language -> "German"]

StringReplace[%, "und" -> " oond "]  // Speak

When kids have classes on programming, writing code, it might be a nice suggestion to let them program the way how they pronounce the integers in the full place value system, and how their parents pronounce them in the dialect of traditional English.

.. One switching routine to rule them all

When you are new to these routines (like I was while writing them) then it may be easy to get lost for a moment. With some structure it is easier to see how they hang together. Therefor, PronounceInteger is a switching routine for selecting Level -> level, with above levels 1, 2, 3, 4 and -4.

?PronounceInteger

Options[PronounceInteger]

Who knows about PlaceValue or PlaceValueTable would tend to call them directly, but the following serves as an illustration. Observe the special role of the Language option. We may set the option to say “Italian”, and then PronounceInteger will call the routines with that setting. However, when the call uses Language -> $Language, then the option is not passed on, and the option settings of the subroutines take precedence. PlaceValue has its own setting Language -> “Amplish”, and thus we can still get the ampersand in smaller FontSize.

PronounceInteger[12]

PlaceValueTable itself would not include the traditional pronunciation but this call via PronounceInteger inserts the option Speak -> True. Note: “twelve” is “two left over after 10” and “ten & two” then is clearer.

PronounceInteger[12, Level -> 0, Method -> PlaceValueTable]

. Zig in German and tig in Dutch

.. Conflict of traditional and proper pronunciation

For English, traditional 19 = nine-teen and place value 90 = nine·ten (traditionally ninety) are not in conflict.

For German, traditional 19 = neun-zehn and place value 90 = neun·zehn (traditionally neunzig) are in conflict. Making a transition will cause much confusion. Dutch has the same problem.

.. A solution is to use zig in German and tig in Dutch for 10

Like English “-ty”, German uses “-zig” at the end of 20, (30,) 40 through 90. Dutch has “-tig”. Thus we may use zig for 10 in German and tig for 10 in Dutch. For me, this flash of insight in 2012 was a major step for accepting that there is scope for a full use of the place value system (in Holland). The changes in pronunciation are least with zig and tig.

Germans or Dutch who have a problem with zig or tig - with the new phenomenon of “Zehnsucht” -  and who still want to make full use of the place value system, could also consider borrowing “ten” from English, or use scientific “deca” (though with two syllables). Or Germans could use “tien” from Dutch, and the Dutch “zehn” from German. In Dutch “tig” already is used sometimes in the sense of “some unknown very big number” and the change to tig = 10 can still be made.

For the following, observe the usefulness of the trailing dot again, that helps identify the difference between “zig & neun” and “neun·zig”. If you reading this, remember that the routines speak the numbers as well.

PlaceValueTable[{19, 90}, Language -> "German"]

PlaceValueTable[{19, 90}, Language -> "Dutch"]

The German association “Zwanzig-eins” are not fundamentalists in terms of the full place value system.

PlaceValue[21, Speak -> False, Simplify -> False, Language -> "German"]

PlaceValue[21, Speak -> False,  Language -> "German"]

.. Comparison with English

Remarkably, the changes for English could well be larger than for German. E.g. 60 changes from “sixty” to “six·ten”. An English speaking nation might prefer to change “ten” into “ty” and pronounce this as “t” or “tee” (like in Danish), which gives “six·ty” again. This would actually minimise the changes, even allowing for the special twenty, thirty, forty and fifty. English would also re-introduce the “and” again that German never abolished. Kids find English easier than the reversed order in German, Dutch and Danish, which only shows how important that order is, and which likely does not give evidence on the “and”. My impression is that English would rather stick to “ten” and accept the consequences. But, with the available routines, we may create an alternative “Englishty” and check how it sounds.

PlaceValue[11, Language -> "Englishty", Show -> True]

PlaceValueTable[{10, 11, 20, 21, 60, 61}, Language -> "Englishty"]

.. When 10 might be changed anyway

I was surprised to see that Finnish 10 is quite a long word. When adapting to the full use of the place value system anyway, one might imagine that there is a Finnish National Committee on the Pronunciation of 10 that chooses a shorter word.

PlaceValue[10, Language -> "Finnish"]

.. Peculiarities in natural language

Current German makes a distinction between “eins” for 1 separately and “ein” for further use. Current German uses “sieben” for 7 separately, and uses “sieb” for combinations. Such deviations happen in natural language but a systematic use has only one application. I took what currently are most frequent: ein and sieb. (Danish has “syv”.)

PlaceValue[77,  Language -> "German"]

The advantage of the routine with the pronunciation and transliteration now clearly shows, in that we do not just have the words (for writing essays) but also have an approximation how it would sound in rehearsing in class in (original) kindergarten (German word), to help judge whether the suggestion to adapt “ein” and “sieb” could be acceptable to consider.

PlaceValue[#,  Language -> "German"]& /@ Range[0, 10]

The present proposal clashes with the “Zwanzigeins” movement on the numbers 0-20 that are important for education: zig for zehn, and thus also 11-19 using zig, and zwei·zig, to show the working of the place value system. Arbitrary in my implementation are: ein for eins, sieb for sieben, dreißig would also become drei·zig. See Colignatus (2015b, 2018a). Remember also my distinction between the math language in school and the dialect of current language outside of school. My suggestion is that the 21 movement could become stronger if it includes the full place value system alongside their original views, as one of the issues to consider.

. Translate, transliterate and quality control

.. Translate versus transliterate

To Speak in another language, the user can adapt the $Language in the Preferences of Mathematica, then restart. Both the numbers and words should be pronounced in the specified language, though in traditional manner.

There will be users who have Mathematica running under one specific language (e.g. $Language = “English”) and who still have interest in the pronunciation of the different languages. In that case, transliteration may help. The transliteration is provided in PlaceValueRules[“yourlanguage”] with the option “transliteratorlanguage” -> {...}.

PlaceValue and PlaceValueRules can also call WordTranslation from English to automatically supply the words of another languague. The call PlaceValueRules[Set, “youlanguage”]. This does not provide for the transliteration. One is advised to save the resulting PlaceValueRules[“yourlanguage”] because the initialisation takes some moments. The words for (10^4) and (10^5) are generally missing and thus replaced by myriad and lakh.

.. Warning: automation does not guarantee quality

PlaceValueRules[Set, “youlanguage”] issues a warning when the submitted language isn't in the list PlaceValueRules["Checked"]. One may turn off the message or include a language in PlaceValueRules[“Checked”] provisionally, but it is better to actually check first (and then use AppendTo on the list of checked languages).  The package is conservative on giving the message but will repeat it on the tables, see below.

.. Checked in PlaceValueRules: English, German, French, Dutch and Danish

The package can be simple since we only require 2+10+6 = 18 transliterations per language, to pronounce the integers with absolute values less than (10^7).

The routine PlaceValue[n] takes the true words and transliterations from the PlaceValueRules[“language”]. Implemented have only been English, German, French, Dutch and Danish, up to (10^7). They have been checked on name conflicts and language peculiars. Amplish and Englishty are variants of English that have a role in the exposition.

PlaceValueRules["Checked"]

... German

PlaceValue[9189, Speak -> False, Language -> "German"]

PlaceValueRules["German"]

Above, we saw “zig” in German being transliterated by “tzeeg” in English, for the simple reason that the current setting of $Language is “English”.

... French

French can use dix.

PlaceValue[9189, Speak -> False, Language -> "French"]

PlaceValueRules["French"]

... Dutch

For Dutch, the design questions are alike those for German. The best solution would be to use “tig” for “tien”.

PlaceValue[9189, Speak -> False, Language -> "Dutch"]

PlaceValueRules["Dutch"] (*distinction between minus and min*)

... Danish

Danish can use ti.

PlaceValue[9189, Speak -> False, Language -> "Danish"]

For Danish, I transliterated listening to Google Translate. I might not hear subtleties that native speakers would hear. The connective “and” is “og”, which reminds of German “auch” and Dutch “ook” meaning “also”. It is quite a diaspora.

PlaceValueRules["Danish"]

.. Using non-implemented languages, e.g. Italian and Spanish

Please remember that there is no automated transliteration.

... Italian

PlaceValueRules["Italian"]   (*unknown*)

PlaceValue[134, Language -> "Italian"]

After this initialisation, the call is much faster. The user must provide a transliteration of “e” but “con” already provides a more Italian sound.

PlaceValue[134, Language -> "Italian", And -> "con"]

PlaceValueRules["Italian"]

... Spanish

PlaceValueRules["Spanish"]  (*unknown*)

PlaceValue[134, Language -> "Spanish"]

After this initialisation, the call is much faster. A quick fix for pronunciation is perhaps this.

PlaceValue[134, Language -> "Spanish", And -> "e"]

PlaceValueRules["Spanish"]

.. A general comment

“Deux” in French has been transliterated here as “duh”. English has a closer sound in “bird” and “dirt”. I found no way to unpack this sound from “bird” and paste it into “d...h”.

res = WordData["bird", "PhoneticForm"]

InputForm:

Submitting this to Speak generates a blank.

Speak["'ɝ"]

SpokenString["'ɝ"]

Speak[%]

For transliteration it would be useful when such phonetic forms could also be submitted to Speak.

I don’t know anything about linguistics, and the following are some first discoveries.

In evolution, disregarding sign language, pronunciation came first, and writing was developed by encoding how someone pronounced something (beth = house with two rooms = B). In computer programming, the words and translations between languages were first, and the pronunciations came later. We take pronunciation as (conceptually) basic again since kids live in world of sound and only learn to read and write later on.

The International Phonetic Alphabet (IPA). Wikipedia (a portal and no source): https://en.wikipedia.org/wiki/International_Phonetic_Alphabet.

https://en.wikipedia.org/wiki/Orthography#Correspondence_with_pronunciation

See also: http://www.wolframalpha.com/input/?i=pronunciation+of+bird

. Conversion tables

The routine PlaceValueTable allows the automatic generation of tables of conversion, and thus comes with a big warning. Automated translations must be scrutinised for flukes. However, creating such tables is quite useful to start with the required close reading. For these tables, the message that an automated translation hasn’t been checked is a useful reminder at each call. Please do not turn this off, but do the checking and correcting, and then do an AppendTo[PlaceValueRules[“Checked”], “yournewlanguage”]].

Standard conversion tables would be 0-10, 20-30, 30-40, etcetera. We can also consider other tables.

The table of 7 in English.

PlaceValueTable[Range[7, 70, 7]]

The table of 7 in unchecked Spanish, installed above.

PlaceValueTable[Range[7, 70, 7], Language -> "Spanish"]

The package is conservative on the warning, and only generates it at installation and for these tables.

PlaceValue[1234, Language -> "Spanish"]

The table of 7 in unchecked Swedish. The warning is issued twice: first at installation and secondly at creating the Table.

PlaceValueTable[Range[7, 70, 7], Language -> "Swedish"]

. ISO standard

.. ISO and NEN

Colignatus (2015b, 2018a) contains the definition for the full use of the place value system in a way that fits education. It should become an ISO standard, so that educators, researchs and textbook and software publishers have a persistent environment. This notebook with package implements this. The latter has some limitations on maximum place value million, and has some language particulars, but those are not material to the standard.

In Holland, NEN is the portal for International ISO: https://www.nen.nl/About-NEN.htm. They are no public utility so that the development of norms and standards must be paid for by users. They also have a crowd-funding option for such initiatives: https://nencrowd.nl. Before they allow their crowd-funding support, they want some guarantee that there is a community with an interest in the project. For this issue it would be researchers, the Ministry of Education and publishers. To my regret, I have met no interest yet.

.. Open source journals

Publication could be done in an open access journal, and the proper way to get open access journals is by the universities, see Gowers (2017) and my letter to VSNU, Colignatus (2016). Present (paywall) journals tend to be specialised on approaches to education and psychology, and may require field testing on actual implementation, and apparently are not open to the particular approach of redesign of mathematics education that this notebook with package presents. Thus I observed that such journals can publish invalid research but will not publish or even report about this present proposal for improvement. Quis custodiet ipsos custodes ?

. Conclusions

We already have the place value system in the numerals but not yet in pronunciation and written words. A unity of using the full place value system will work wonders in school. This is an issue of mathematics education, with the distinction between the language of arithmetic in school and its dialect of the common language outside of school. It is only a question whether the educational system would be willing to adapt.

Colignatus (2015b, 2018a) gives the definition for a full use of the place value system for kindergarten and elementary school. This is simple by the nature of the issue. My own change from (2015b) to (2018a) on the “&” connective shows that this simplicity still can be quite involved, but also that the key design features have been well-considered. This notebook with package implements this system. There must be some features in the package that are arbitrary. The transliteration is only provided for some quick indications and not the key part. The notebook with package looks meagre compared to the wealth and subtlety that already exist for the pronunciation of the natural languages and current conventions on pronouncing the numbers. The awkward ways of the past are being hardcoded now. Hopefully some of those resources can be used to support the full use of the place value system.

I have not seen this implementation of pronunciation elsewhere (except in Chinese though without the “and”), so please refer to these locations so that others can find the full documentation.

. Appendix. The package

.. Key properties of PlaceValue

The PlaceValue routine (PronounceInteger with Level -> 1) is the main routine. Key properties are:

The Language -> “language” option selects the language, and determines how integers are written and spoken.

Implemented are English, German, French, Dutch and Danish, assuming that $Language (the transliterator) is English. Also given are Amplish (writes an ampersand in smaller FontSize) and Englishty (writing “ty” and speaking “tee” for 10).

Written output is in the words of PlaceValueRules["language"], option True -> {settings}.

Spoken output is in the words of PlaceValueRules[“language”], option “transliterator” -> {settings}. These words are submitted to Speak. The transliterator that speaks this transliteration is $Language (often “English”).

For each language  the user provides, in PlaceValueRules: (i) option True -> {words for the minus sign, “&”, digits 0 ... 9 and values (10^1), ..., (10^6), in the relevant language}, and (ii) option “transliterator” -> {words for the same input as above but now as a transliteration in terms of that transliterator language (commonly $Language)}. See for example PlaceValueRules[“German”].

If PlaceValue is called for a language lan that is not in PlaceValueRules[] then it calls PlaceValueRules[Set, lan].

SpeakTransliteration -> "language" currently only works for $Language. Perhaps in the future it might be possible to have access to other languages without a restart.

$Language has been set in the Preferences of Mathematica. The user can set to to another language and do a restart.

.. Overview

The package has:

?Cool`MathEd`PronounceInteger`*

?PronounceIntegerReadMe

PronounceIntegerReadMe[]

The discussion in the notebook also uses - but not directly on pronunciation:

?Cool`MathEd`CCSSMath`*

?CCSSMathExercise

.. Switching routine

The PronounceInteger routine and its options were already shown above.

PronounceInteger[12, Level -> 0, Method -> Random]

.. Level 1

?PlaceValue

Options[PlaceValue]

?SpeakTransliteration

?PlaceValueRules

PlaceValueRules[]

PlaceValueRules["Checked"]

PlaceValueRules[Select, Power, "French"]

.. Level 2

?PlaceValueDigits

Options[PlaceValueDigits]

?PlaceValueDigits$Language

Options[PlaceValueDigits$Language]

PlaceValueDigits$Language[22324443224, And -> ",", Speak -> False]

.. Level 3

?PlaceValueBlock

Options[PlaceValueBlock]

PlaceValueBlock[123456]

LatestPronunciation[]

.. Level 4

?PlaceValueIntegerName

Options[PlaceValueIntegerName]

PlaceValueIntegerName[1234451011]

LatestPronunciation[]

.. Level -4

?PartialPlaceValue

Options[PartialPlaceValue]

PartialPlaceValue[1234451011]

LatestPronunciation[]  (*in traditional manner*)

. Literature

Thomas Colignatus is the scientific name of Thomas Cool, econometrician and teacher of mathematics, Scheveningen, Holland.

Bussi, M. G. B. & Sun X. H. (ed.)(2018), Building the Foundation: Whole Numbers in the Primary Grades,The 23rd ICMI Study, Springer International publishing AG

Colignatus, Th. (2015a), A child wants nice and no mean numbers, 
(1) website: http://thomascool.eu/Papers/NiceNumbers/Index.html
(2) PDF on Zenodo: https://zenodo.org/record/291979
(3) Publisher for a print: https://www.mijnbestseller.nl/shop/index.php/catalog/product/view/id/118082/s/a-child-wants-nice-and-no-mean-numbers-79074-www-mijnbestseller-nl/

Colignatus, Th. (2015b, 2018a), The need for a standard for the mathematical pronunciation of the natural numbers. Suggested principles of design. Implementation for English, German, French, Dutch and Danish, https://doi.org/10.5281/zenodo.774866

Colignatus, Th. (2016), Letter to VSNU and others on membership dues and open access publishing, https://boycottholland.wordpress.com/2016/10/12/letter-to-vsnu-and-others-on-membership-dues-and-open-access-publishing/

Colignatus, Th. (2018b), Tables for addition and subtraction with better use of the place value system, PDF  https://doi.org/10.5281/zenodo.1241349 and notebook with package https://doi.org/10.5281/zenodo.1241404 and http://community.wolfram.com/groups/-/m/t/1313408 (update May 5)

Common Core Standards (2018), Number & Operations in Base Ten, http://www.corestandards.org/Math/Content/NBT/ with also Understand place value

Fateman, R. (2013), How can we speak math?, https://people.eecs.berkeley.edu/~fateman/papers/speakmath.pdf

Gowers, T. (2017), The end of an error?, https://www.the-tls.co.uk/articles/public/the-end-of-an-error-peer-review/

Uy, F.L. (2003), The Chinese Numeration System and Place Value, Teachting Children Mathematics, NCTM, p244-247

Wolfram Research, Inc. (2017), Mathematica, Version 11.2, http://www.wolfram.com