First you can add text to any field either by declaring to be text (use the menu above) or by placing it between  (*   text text   *)

Input  press [shift]+[return]

2+2

Notice the In[] and Out[]  labels. these can be used to refer back  to these items.  % refers back to the last output

%+5

Standard symbols work for multiplication, subtraction and division.  Answers are always exact unless you ask otherwise.

5+4*5-4/6

Power is indicated by ^ symbol.

(5-3)^2/3

There are a vast number of functions built in.  Some of them are usual, and some require multiple inputs.  Functions are invoked by [].

Min[3,4]

GCD[24,28]

Some irrational numbers are represented by symbols.

Sin[Pi/2]

Exp[1]

Be careful with brackets.  Mathematica helps you by highlighting the related brackets.

(1+Sqrt[5])/(1+1)

(1+Sqrt[5]/1+1)

Make your first plot.  Add axis, frame, labels, etc.

Plot[Cos[x],{x,0,3Pi}]

Plot[Cos[x],{x,0,3Pi},Frame -> True]

Plot[Cos[x],{x,0,3Pi},Frame-> True, FrameLabel-> {"Time (sec)", "up/down, meters" }]

Data is represented in lists indicated by {...}.  There can be lists of lists.  They can contain numbers, variables, text, and even functions.  There are many operations on lists.

Myfirstlist={1,2,3}

Myfirstlist

{1,2,3}+4

Myfriends={Raju, Manu, Alisha, Gina, Manju}

Get an element of a list. use [[ ]]

{1,2,3}[[2]]

construct lists with simple commands

Range[10]

Table[1/i, {i,1,20}]

Lists are the most important data concept in Mathematica (it is also the case in many other programming languages). It is the basis of much of the programming.  And a huge number of operations are based on list manipulation. In fact, most of the symbolic algebra, manipulation of equations, etc., is all list based.  Recall: equation is simply a list of symbols !  

Lists can be nested, have a variety of structures, have any type of element.  You can make list of equations, and associated names, for example.

Map a function onto a list

Sin @ {0, Pi/4, Pi/2, Pi}

List itself is an operator, it turns a list of objects into a List.  You can tell it is map itself on to other lists to make a list.  This is how computer programming languages can become abstract.

List@@ (a^2+b+1)

?List

Some rules with numbers.  Exact input gets exact output.  
Decimal input will get approximate output.

(1/3)+(2/Pi)

N[..] function will convert exact output to approximate.  
ScientificForm[..] will convert to scientific notation output.

N[1/3+1/2]

Can also do  //N ..   “//” stands for postprocessing

1/3+1/2 //N

Pi/2 //Cos

There are many ways of presenting numbers and data

ScientificForm[0.00082712/10132.0898]

You can use variables to represent almost anything. Usually lower case letters are used as variables. Upper cases for functions and built in constants.

(x+2)/5

Use space or * to indicate multiplication

(x y+55*x+14)/y^3

use /. and -> to make substitutions on the fly.

(x y+55*x+14)/y^3/.{y->3,x->4}

variables can be assigned with = .  Use ; to have multiple statements in one executation.

x=4; y=5; (x+y)/4

use Clear[]  to clear assignment

Clear[x];  (x+y)/4

Use :=    to create definitions for custom functions.  Notice the x_ which means x is a pattern to be substituted.  := means that arguments that are passed to f get substituted on the right.

f[x_] :=   Sin[x]*Exp[x]; 
f[y]

A little bit of Algebra.

First   get used to the idea of   the three different “equal” signs.  

=  means assignment.     Right side is assigned to the symbol on the left  
:=  means a definition of a function to which arguments are passed  
== really means a equal sign that is used in equations.  The entire equation becomes an expression that either true or false.

Factor an equation, simplify, or make partial fractions separation.

Factor[x^2+2x+1]

Simplify[x^2(1-y^2)*x/(x^2+2x+1)]

Apart[(x^2-1)/(x^2+2x+1)]

2+2==3

This is an equation

1+z==5/.{z->4}

How do we solve quadratic equations etc. Solve produces answers in the form of substitution rules.  Nsolve gives numerical answers in case the answer is difficult to get.

Solve[{a*x^2 + b*x + c == 0}, x]

Solve[x^2+6x-6==0,x]

NSolve[x^3+6x-6==0,x]

How about  a system of equations !

Solve[{x^2+z==0, 8 x -5 == z}, {x,z}]

How about plotting functions ? The most basic command is plot. Plot has a huge number of options for making fancy looking pictures or overlapping plots.

?Plot

?RegionPlot

f1 = Plot[Sin[x]/x,{x,-3Pi,3Pi},PlotRange->{{-3Pi,3Pi},{-0.5,1.0}}]

f2 = Plot[1/x,{x,-3Pi,3Pi},PlotStyle->Red, PlotRange->{{-3Pi,3Pi},{-0.5,1.0}}]

f3=RegionPlot[Abs[y]<Cos[x]&& Abs[x]<Pi&&y>0,{x,-3Pi,3Pi},{y,-0.5,1.}]

Show[{f1,f2,f3}]

ParametricPlot[{t^2*Cos[t], 10Sin[50t]},{t, -2Pi, 2Pi}]

We will do more with plotting over the next several units. There is almost infinite flexibility and you can also write manually on the plots if you want to.

Let’s do some simple puzzles now.  There are no definite correct answers. Let’s try to figure these out.

How much blood is in a typical Human body ?

typweight = 70;  (* Kg *)  
watercontent = 0.95;  
litersofwater = typweight*0.95*1;  (* liters per kg *)  
fractionofbloodmax = 0.1;  (* higher than this does not seem correct *)  
fractionofbloodmin = 0.05;   (* lower than this seems too low *)  
bloodcontent = {fractionofbloodmin*litersofwater, fractionofbloodmax*litersofwater}

How many insects does a typical Robin eat in a day ?

secondsinaday = 24*3600;  
fractionoftimeeating = 0.4; 
peckspersecondmin = 0.1; 
peckspersecondmax= 2.0;
insectsperday = { secondsinaday*fractionoftimeeating*peckspersecondmin, secondsinaday*fractionoftimeeating*peckspersecondmax}; 
numberofbirdsintheyard = 50; 
insectsperday*numberofbirdsintheyard

Massofbird = 10*5*5;  (* assume 1 gm/cm^3 and dimensions of 10*5*5 cm^3 *)  
typicalfractioneaten = 0.1;  (* 1/20 of body weight seems about the max *)  
weightofinsect = 0.1*0.1*0.1;  (* gm assuming insect is 1 mm x 1 mm X 0.1 mm seems about right when you average larger worms and small mites*) 
numberofinsectsperbird = Massofbird*typicalfractioneaten/weightofinsect *numberofbirdsintheyard

What has any of this to do with Neutrinos ? 

We have to get good at using our instincts to answer basic questions.  These work because we use our everyday experience to judge our own answers.  

The joy of doing something new is in developing  these instincts in a new direction.  Particle and astrophysics (and in fact most of the universe) is so different from our everyday experience, that our instincts can fail spectacularly.   

You can visualize and imagine a single planet and a moon (because you are now used to it), but can you visualize 100  billion Suns and their planets and moons.  What about  1000 billion galaxies composed of 100 billion Suns ? Each so far apart that when light starts from one Galaxy it spreads out like slow ripple across a lake. 

New science results in when we deeply understand entirely different scales of fundamental dimensions in time, distance, and mass, and charge.