mjhjmtu

Say I have a list:

Line[-Sqrt[5/8 - Sqrt[5]/8], 1/4 (-1 - Sqrt[5]), 0, 1], 
Line[Sqrt[5/8 - Sqrt[5]/8], 1/4 (-1 - Sqrt[5]), 0,1], 
Line[-Sqrt[5/8 + Sqrt[5]/8],1/4 (-1 + Sqrt[5]), Sqrt[5/8 - Sqrt[5]/8], 1/4 (-1 - Sqrt[5])], 
Line[Sqrt[5/8 - Sqrt[5]/8], 1/4 (-1 - Sqrt[5]), 0, 1]

So that each sublist of that list consist of, in this case, two lines. All the points that tell us about the position of the line appear in another list, call this list points. Now, I want to extract the position of all the points from the above list in that points list. I'm aware of Position function but I'm not sure how to effectively apply it to my big list above in order to get the list of positions. AI'd very much appreciate some help.

You can use Cases for this:

lines = Line[-Sqrt[5/8 - Sqrt[5]/8], 
 1/4 (-1 - Sqrt[5]), 0, 1], 
 Line[Sqrt[5/8 - Sqrt[5]/8], 1/4 (-1 - Sqrt[5]), 0, 
 1], Line[-Sqrt[5/8 + Sqrt[5]/8], 
 1/4 (-1 + Sqrt[5]), Sqrt[5/8 - Sqrt[5]/8], 
 1/4 (-1 - Sqrt[5])], 
 Line[Sqrt[5/8 - Sqrt[5]/8], 1/4 (-1 - Sqrt[5]), 0, 1];

Catenate @ Cases[lines, Line[pts : _, _ ..] :> pts, Infinity]

Out[5]= -Sqrt[5/8 - Sqrt[5]/8], 1/4 (-1 - Sqrt[5]), 0, 1, Sqrt[
5/8 - Sqrt[5]/8], 1/4 (-1 - Sqrt[5]), 0,
1, -Sqrt[5/8 + Sqrt[5]/8], 1/4 (-1 + Sqrt[5]), Sqrt[
5/8 - Sqrt[5]/8], 1/4 (-1 - Sqrt[5]), Sqrt[5/8 - Sqrt[5]/8],
1/4 (-1 - Sqrt[5]), 0, 1

What about /.Line->List

lines /. Line -> (Flatten[ List[#], 1] &)

Answer to what you want

lines = 
 Line[-Sqrt[5/8 - Sqrt[5]/8], 1/4 (-1 - Sqrt[5]), 0,1]
 , Line[Sqrt[5/8 - Sqrt[5]/8], 1/4 (-1 - Sqrt[5]), 0,1]
 
 , Line[-Sqrt[5/8 + Sqrt[5]/8], 1/4 (-1 + Sqrt[5]), Sqrt[5/8 - Sqrt[5]/8], 1/4 (-1 - Sqrt[5])]
 , Line[Sqrt[5/8 - Sqrt[5]/8], 1/4 (-1 - Sqrt[5]), 0, 1]
 
; 

lines /. Line[ l : _, _ .. ] :> l

(* or as WReach has pointed out: lines /. Line -> Sequence *)

Simple and expressive - no remembering whether its Flatten[ ... , 1 ] or Flatten[ ... , 1 ], or Flatten[ ... , -1 ] and what have you.

Different Approach Making Use of Datatypes

While having lists is very compact we can easily get lost in different levels. Why not simply give each single point the head Point (Point can also contain a list of x,y tuples like Line, but giving each point a head of its own simplifies counting and identification of duplicates imo). You can then use pattern matching quite easily, count points, and immediately visualize the data:

Here I turn a list of lines into a list of points, thus not adding another level for each line:

points = lines /. Line[ l : _, _ .. ] :> ( Sequence @@ Point /@ l )

(* if you do not want this you can simply do: lines /. Line -> Point *)

Point[-Sqrt[5/8-Sqrt[5]/8],1/4 (-1-Sqrt[5])],Point[0,1],Point[Sqrt[5/8-Sqrt[5]/8],1/4 (-1-Sqrt[5])],Point[0,1],Point[-Sqrt[5/8+Sqrt[5]/8],1/4 (-1+Sqrt[5])],Point[Sqrt[5/8-Sqrt[5]/8],1/4 (-1-Sqrt[5])],Point[Sqrt[5/8-Sqrt[5]/8],1/4 (-1-Sqrt[5])],Point[0,1]

Now it is easy to count points:

Count[ points, Point[ _ ], Infinity ]

8

It is easy to discover that there are only four unique points:

Flatten @ points // Union

Point[0, 1], Point[-Sqrt[5/8 - Sqrt[5]/8], 1/4 (-1 - Sqrt[5])],
Point[Sqrt[5/8 - Sqrt[5]/8], 1/4 (-1 - Sqrt[5])],
Point[-Sqrt[5/8 + Sqrt[5]/8], 1/4 (-1 + Sqrt[5])]

And we can immediately visualize the results:

Graphics[ Red, PointSize -> Large, points ]

Don't care for Point anymore? Get back to lists:

points /. Point[ pos : _, _ ] :> pos

To make things easier to read, let's use these lines (with the same nested structure as in the question):

lines =
 Line[60, 50, 60, 70]
 , Line[40, 30, 40, 50]
 
 , Line[20, 10, 20, 30]
 
 ;

Furthermore, let's define the list points as this:

points = 20, 10, 20, 30, 40, 30, 40, 50, 60, 50, 60, 70;

We can get the positions of each point in this list as follows:

pointPosition = points // PositionIndex // Map[First]

(* <|20, 10 -> 1, 20, 30 -> 2, 40, 30 -> 3, 40, 50 -> 4, 60, 50 -> 5, 60, 70 -> 6|> *)

This association can tell us, for example, that the point 40, 30 appears at position 3 in points.

pointPosition[40, 30]

(* 3 *)

We can now convert the line list into a similarly structured list where each point has been replaced by a pair of corresponding positions:

lines /. Line[pts__] :> pointPosition /@ pts

(* 5, 6, 3, 4, 1, 2 *)

Or, should we desire, we could retain the List heads in the result:

lines /. Line[pts__] :> Line[pointPosition /@ pts]

(* Line[5, 6], Line[3, 4], Line[1, 2] *)

This latter form has the advantage that we can still draw the resultant lines by means of GraphicsComplex:

newLines = lines /. Line[pts__] :> Line[pointPosition /@ pts];

Graphics[GraphicsComplex[points, newLines]]

As bad as it may look, this seems to be working fine:

Partition[Partition[Flatten[Position[points, #] & /@ Catenate @ Cases[lines, Line[pts : _, _ ..] :> pts, Infinity]],2],Length[l]]