# data[].attributes.body
1. How many points should we try to make sure our mapping notation is correct?
2. Are there multiple image points?
3. Should we just rotate points? Or should we try to construct a line or a circle? Could we use multiple points to construct this circle?
4. Could we make the point we are rotating around be the origin? Like make a new coordinate plane where its the center?

# data[].attributes.body
1. What does "applied to" means?
2.  Does drawing a line from the  points help?
3. Will (a,b) be important to finding the general mapping notation?
4. What is mapping notation really?
5.  What quadrant is the point in?
6. Will it be easier to do this problem algebraically or graphically?

# data[].attributes.body
Can we use resources like patty paper or a compass?
What does “applied to” mean?
Can we eventually use numbers that aren’t multiples of 90?
Will it be like the vertical/horizontal lines where we had it in terms of the line instead of quadrants?

# data[].attributes.body
1)When you turn the object 180 degrees will the  x and y coordinates swap?
2)Can this be redrawn with it centered at 0,0?
3)Is the line between the image and pre-image straight?
4)Can the slope of the line between the image and point of rotation be used to solve?

# data[].attributes.body
1. Can we construct a line through (-3,4) and (-5,1) and the Pythagorean theorem to find the coordinates?
2. Are there other figures one could construct to more accurately map the image on a graph?

# data[].attributes.body
1.  when we do the half turn (180 degrees) do we just flip the points?
2.

# data[].attributes.body
1. can you make the point that the rotation is centered on into the origin of a new coordinate plane within the old one.

# data[].attributes.body
1. is there a pattern visually on the graph that we can look for to help us?
2. how many image points are there?
3. is there an algebraic formula we can apply to this to help?
4. will we need to use an equation to solve this?

# data[].attributes.body
180: -(x-a)+a, -(y-b)+b
90: -(y-b)+a, (x-a)+b
270: (y-b)+a, -(x-a)+b

# data[].attributes.headline
Imani-General Mapping Notation for 180 degrees

# data[].attributes.subject
Imani-General Mapping Notation for 180 degrees

# data[].attributes.body
(x,y) > (-x+2a , -y+2b)

# data[].attributes.body
180 degrees: (x,y)---(2ca - x, 2cb - y)
Where a and b stand for the centered point (a,b).
90 degrees: (x,y)---(x+1, 2cb - y + 1)
270 degrees: (x,y)---(2ca - x - 1, y - 1)

# data[].attributes.body
180 degrees (2a-x, 2b-y)
90 degrees (a+b-y, b-a+x)
270 degrees (a-b+y, a+b-x)

# data[].attributes.body
180: -(x-a)+a, -(x-b)+b
90: -(y-b)+b, (x-a)+a
270: (y-b)+b, -(x-a)+a

# data[].attributes.body
i didn't find a way to write it prettily, but what i found was: subtract the x & y values of the point of rotation from the point being rotated, perform the rotation with the new point, and then add the x & y values of the point of rotation to the image and preimage

# data[].attributes.body
90 degrees: -(y-b)+b, (x-a)+a
180 degrees: -(x-a)+a, -(x-b)+b
270 degrees: (y-b)+b, -(x-a)+a

# data[].attributes.body
to execute a 90 degree rotation around point (a,b)applied to point (x,y), first translate (a,b) to be the origin, and translate (x,y)-->(x-a, y-b). Then use mapping notation for a 90 degree rotation (x,y)--->(-y,x). Then, translate all points by the reciprocal of the values you originally translated them by.

to execute a 180 degree rotation around point (a,b)applied to point (x,y), first translate (a,b) to be the origin, and translate (x,y)-->(x-a, y-b).. Then use mapping notation for a 180 degree rotation (x,y)--->(-x,-y). Then, translate all points by the reciprocal of the values you originally translated them by.

to execute a 270 degree rotation around point (a,b)applied to point (x,y), first translate (a,b) to be the origin, and translate (x,y)-->(x-a, y-b). Then use mapping notation for a 270 degree rotation (x,y)--->(y,-x). Then, translate all points by the reciprocal of the values you originally translated them by.