[Question]
  [
Giving **`n`**(any amount) of points `(x,y)`. What's the minimum amount of circles required to cross every point given?
## Task
Your program will get `n` (you can have `n` as part of input or use EOF instead) points `(x,y)`.
The points might at same place => `(x1,y1) = (x2,y2)` **can happen**
`x` and `y` will be *integer* of range `-10000~10000`, while `n`, if you need it, will be *integer* too.
You should output an integer `A` which represent the minimum amount of circle needed to intersect all of the points. Those circle are not required to intersect each other.
## Explanation
For example:
1, 2 points will need 1 circle only to be sure that the points touch the circles boundary
but 3, 4 points may need 2 circles, or 1 (Determined by where the points are)
```
Basic test cases:
(10,10), (0,5), (0,0), (5,10) => 1 circle
(10,10), (5,5), (0,0), (5,10) => 2 circles
(1,1), (2,2), (5,3), (-1,5), (0,0) => 2
(0,0), (1,1), (2,2), (3,3), (4,4), (5,5) => 3 
```
**Line are NOT considered as a circle**
If there are 3 points `(0,0)` `(5,5)` `(10,10)`. Then the answer would be `2` since those 3 points forms a line if you try to force a circle out of it.
## Rules
* Input can be taken in any convenient format.
* Output can be in any convenient format as well. As long as it follow the input-reversed input order.
* Standard Loopholes are forbidden.
## Scoring
Golf your way to the shortest code!
  
[Answer]
# [Haskell](https://www.haskell.org/), ~~252~~… 203 bytes
```
minimum.map g.permutations.nub
g[]=0
g(p:q:r)=1+g(snd$span(p#q$r!!0)r)
g _=1
(a#b)c d|t<-c!a?j(b!a)=t!!1/=0&&b!d?t?j(c!d)!!1==0
j[x,y]=[x,-y]
[x,y]?[z,t]=[x*z-y*t,x*t+y*z]
(!)=zipWith(-)
import Data.List
```
[Try it online!](https://tio.run/##bZDLbsIwEEX3/gobomITGxIeG4Rh0yX7LtKoch4EU@KYxEgk4tubOoG2QupmRnPnzJ2xD6L6TE@nVua6KA18FUZMdrIyYM/f21wqmV/ySS40zCY6LfOLEUYWqpqoSwSyIOQeyLBenVcl4b6b4UolTqWFwnp4dkqEPFISkMEP7gMshhGJYXIzaxYjsT3iCAnCDUL@lHsvLxFKtsaqMUqI1bi1PgZXWofcRlaHoC@2QUNNJ40bVo8NvY6NW4@bEGBEeCP1mzQHzAhg7Pk9bS6k4kkBIMSSFmTN@jOnfMRHZO1sstTspEpt@5QaqAupTMWDfuUN22gHylQkziAYuK503UE4CC3MWIcLVUEO@35SFhrOYLdHl9bE2T/MrNCd0GLfo75HKMQeXd5TXy07FfINtD/1iyz/R2YWoX4nzejs3pl3ifl//IN7jD7j8zu@oIufJR09h1/x/iSyqmWx1t8 "Haskell – Try It Online")
The relevant function is `minimum.map g.permutations.nub`, which takes a list of points as input (each point as a list `[x,y]`) and returns an integer as output.
This solution uses only integer arithmetic, and therefore does not suffer from accuracy problems stemming from floating point errors.
## How?
Coming soon, after I finish golfing this and convincing myself that the formulas are right.
[Answer]
# [Wolfram Language (Mathematica)](https://www.wolfram.com/wolframscript/), 86 bytes
-5 bytes thanks to @att.
```
CircleThrough@#/.{_@{_.,_.}|_Circle:>1,_:>Min[#+Reverse@#&[#0/@Subsets[#][[2;;-2]]]]}&
```
[Try it online!](https://tio.run/##fY1JC8IwEIXv/oqBQC@mS7pcKpaAZ8HtFkqoJbUBF2hTLzG/vcbainhwLjNv3vdmLoWqxaVQsiz6Cpb9SjblWRzq5tadaop8T3OquYe5Zx78baYZwTzN1vLK0Hwn7qJpBUUOQ4FP992xFaplKGcsXCzcMLdlnH7bSaHYppFXxRC4GVQWyXNwwKczAK01CTCQwGDQdkjGPuhkMAy2HHxzyX/Oqtc2xBCObvTqLvmOTfR04zcVjakYQ/z5aUz/BA "Wolfram Language (Mathematica) – Try It Online")
]