View source for Math notes / 'elementary mathematics' and similar concepts

{{#addbodyclass:tag_math}}

{{Math notes}}

__TOC__

Terms like ''elementary mathematics'' (and various others) often means something like 
* "things common to many mathematical fields"
* "generally useful, taught once comfortable with arithmetic"


Much of it is less than day-to-day, but useful with some frequency.

Ideally, these are the things that turn up with some frequency in non-math fields,
for example in various academic fields, 
and in particular those related to physics and engineering.


==Common number sets==

* &#8484; - whole numbers, positive and negative integers, ''{...,-2,-1,0,1,2,...}''


* &#8469; - natural numbers, used in real-world counting. 
** Whether zero is included in this depends a little who you ask - which field of math (or computer scientists). To be unambiguous, it is now relatively common to use:
** &#8469;<sub>0</sub> to refer to {0,1,2,...} and 
** &#8469;<sup>*</sup> or &#8469;<sub>1</sub> to refer to {1,2,3,...}
:: {{comment|(Use of a plus is discouraged as confusing, as in &#8484;<sup>+</sup> and &#8477;<sup>+</sup> it signifies non-negative)}}


* &#8474; - rational numbers, those in the form ''a/b'' where a&#8712;&#8484; and b&#8712;&#8484; but b&#8800;0. 
** You also see &#8474;<sup>+</sup> and &#8474;<sup>-</sup> as non-negative and non-positive rationals


* &#8477; - real numbers. 
** You also see &#8477;<sub>+</sub> referring to non-negative reals (including 0), and &#8477;<sub>-</sub> as non-positive reals (including 0)


Note that &#8469; &#8834; &#8484; &#8834; &#8474; &#8834; &#8477; (you can bake a subset typology of these and quite a few more, see e.g. {{imagesearch|number set venn diagram}})

Superscript tends to refer to multiple-dimensional vectors. For example [[vectors]] in &#8477;<sup>2</sup>, for example (1,2)



Once you get to [[algebra]], you also get:

* &#x2102; - Complex numbers
:: https://en.wikipedia.org/wiki/Complex_number
<!--
:: (real, imaginary)
:: useful in algebra, e.g. 
:: There is a geometric interpretation in drawing these on a basic cartesian plane, which helps intuit some of the operations


There is a further extension of this idea in quaternions, though they are seen mostly around [[pure mathematics]], and which happen to have a singularly useful application expressing rotations in 3D, e.g. in computer graphics.

-->


See also:
* http://en.wikipedia.org/wiki/Natural_numbers 
* http://en.wikipedia.org/wiki/Rational_numbers
* http://en.wikipedia.org/wiki/Real_numbers
* http://thinkzone.wlonk.com/Numbers/NumberSets.htm

* https://en.wikipedia.org/wiki/Complex_number

==Functions/maps, images, and such==

While the intuitive use of these is fairly obvious,
it is useful, sometimes crucial, to understand the more formal definitions as well.

Practical functions often deal with (infinite) number sets, though in example diagrams (also for injection/bijection/surjection) you may see small finite sets.


Given A and B as two sets, a '''function''' or '''map''' maps elements in A to B. 
More specifically, each element in A is associated with an element in B. 
For each such pair, the element in B is the '''image''' of the respective element in A (sometimes called the '''argument''').



A function in math is much like a function as programmers might be used to: You hand in a value, name it x, and get back a value, f(x). Exactly how that happened is only your concern if you make it that.


In such a relation, A is called the '''domain''' (the 'input' for which the function is defined), B is the '''range''' (and sometimes '''image''').


{{comment|('Map' and 'function' are usually synonyms of each other. People tend to have preference for one or another, or may e.g. prefer 'map' when using with smallish finite sets and 'function' when dealing with a named general-purpose mappers.)}}


You can describe a formula 
* by a formula (in purer mathematics often specifically using set theory)
* by its relationship to other functions - for example in the case of inverse functions
* by an algorithm that computes it
* by a description of its properties
* by table, plot or graph (often in applied contexts)



'''On names'''

Common enough functions have widely used names (e.g. sin, abs, and such) with well-settled definitions.

It is also common to name functions (often letters like f, g), when they are used more than once in an analysis of a problem - or just out of this habit.

You will also see use of mostly f purely within an otherwise anonymous function definitions.

When a name isn't needed at all, such as in one-off mentions, you will also see nameless function definitions (such as y=2x+1 instead of f(x)=2x+1).


Notations related to (set theory style) function definitions include:
* f : A &#8594; B'' {{comment|(function details to be mentioned later)}}
* f : &#8477; &#8594; &#8477; with f = x &#x21A6; e<sup>x</sup>
* f : &#8477; &#8594; &#8477;<sup>+</sup> : x &#x21A6; e<sup>x</sup>


You could define functions for specific domain/range intervals, for example when you want to avoid certain problem cases outside a range that applies to a specific problem (though many prefer to work with functions that are as general as possible) for example:
* f : [-1,1] &#8594; [0,1] : x &#x21A6; something


Elements on which functions act need not be atomic. That is, you can define things as being members of the cartesian product of sets. For example:
* f : &#8477;&#xD7;&#8477; &#8594; &#8477;'' might define some flattening from two-dimensional coordinates to one, ro so.


(functions of multiple arguments can however be a little more involved, with more combinations that can lead to problem cases)



An/the '''identity function''' (completely) maps a/any set to itself with identical values.



'''mapping properties:'''
{{stub}}

While there are more, injective, surjective, and bijective are most interesting for most fields of mathematics.


Maps/functions (for the sake of brevity, assume a map from A to B) are...
* '''injections / injective functions''' are those where each image is mapped to by at most one (so zero or one) argument. 
** Intuitively, that mappings are one-to-one, though not necessarily using all the values of B. 
** Applying this function and then its inverse would be the identity function on 


* '''surjections / surjective functions''' are those where every image is mapped to by one (or more) arguments -- when for all b&#8712;B, there is at least one a&#8712;A so that f(a)=b.



* '''bijections/bijective''' for things that are injective and surjective. In other words, when the mapping maps all values in one set to all values in the other in a one-to-one style, and leaving no unmapped elements in either set. This is in effect a permutation (although that is harder to untuit for non-finite sets).


These properties can be useful in some restrictions and definitions. For example, a function is bijective [[iff]] it has an inverse. Intuitively speaking, for each value in B you can 


http://en.wikipedia.org/wiki/Bijection,_injection_and_surjection


See also the properties of functions heading under abstract algebra.

==Logarithms==

The logarithm of a number, to a given base, is the power to which the base must be raised to produce the number. For example, the logarithm of 100 in base 10, or log<sub>10</sub>1000 is 3 (10<sup>3</sup> = 1000).

http://en.wikipedia.org/wiki/Logarithms


The most commonly used bases are:
* e (natural logarithm)
* 10
* 2 (happens where binary choices are involved, e.g. in computer algorithmics)

Mathematicians and computer scientists have been a little inconsistent in implying different bases, meaning that when you see log(x), you may have to deduce or guess.

[[ISO]], [[NIST]], and others suggest that to avoid confusion, you should use ''ln'' to indicate e, ''lg'' for base 10, and ''lb'' for base 2. I've not much seen the last, but the other two seem to be pretty well accepted.

<!--
===Side notes for programmers===
{{stub}}
Some languages have a log1p() function, which returns log(1 + given_value), in other words, the function shifted left to show no negative values for positive inputs, and input of zero is now not a special math error case. 

It's handy when you want log-style warping of input but don't want to think about low numbers  causing problems.

The implementation is usually an approximation, to avoid certain different floating point math problems.




When multiplying many small probabilities, you are likely to get math underflow. For example, 0.0001<sup>81</sup> underflows 64-bit floats (doubles).

You can alleviate this by adding the log of the probabilities instead of multiplying them, which will yield relatively small negative numbers of different magnitudes. The above example would result not in underflow but in negative a few hundred (depending on the base you use). For example, instead of 0.0001*0.0001*0.0001 = 0.000000000001 (1E-12), you would get about -12.0 (if you use base 10). 


In this type of example the base may be immaterial, particularly when all you want is to know which is the highest/lowest probability among a lot of probabilities (think e.g. bayes classifier) and not the actual probability.

Mathematically you can get back the original, but if the resulting value would indeed underflow when stored in the FPU, this would be pointless, unless perhaps you don't mind using arbitrary precision floats just to print the value somewhat nicely. 

Note also that you effectively decimate the resolution a little.

-->