Можно ли указать два треугольника с вершинами в данном множестве точек и с равными площадями?

for (int i = 0; i < points.Length - 2; i++)
{
    for (int j = i + 1; j < points.Length - 1; j++)
    {
        for (int k = j + 1; k < points.Length; k++)
        {
            // новый треугольник (его точки)
            // A = points[i];
            // B = points[j];
            // C = points[k];
        }
    }
}

    /// <summary>Класс для представления точки на плоскости</summary>
    public struct Point
    {
        /// <summary>Координата X</summary>
        public double X { get; }
        /// <summary>Координата Y</summary>
        public double Y { get; }
 
        /// <summary>Конструктор задающий значения свойствам</summary>
        /// <param name="x">Координата X</param>
        /// <param name="y">Координата Y</param>
        public Point(double x, double y)
        {
            X = x;
            Y = y;
        }
 
        /// <summary>Статический метод возвращающий расстояние между точками</summary>
        /// <param name="a">Точка на плоскости</param>
        /// <param name="b">Точка на плоскости</param>
        /// <returns>double расстояния</returns>
        public static double Distance(Point a, Point b)
        {
            double deltaX = a.X - b.X;
            double deltaY = a.Y - b.Y;
 
            return Math.Sqrt(deltaX * deltaX + deltaY * deltaY);
        }
 
        /// <summary>Метод возвращающий расстояние до другой точки</summary>
        /// <param name="other">Другая точка</param>
        /// <returns>double расстояния</returns>
        public double Distance(Point other)
            => Distance(other, this);
 
        /// <summary>Возвращает экземпляр Point из строкового представления</summary>
        /// <param name="value">Строка со значениями X и Y через пробел</param>
        /// <returns>Point точки</returns>
        public static Point Parse(string value)
        {
            var nums = value?.Split(new char[] { ' ' }, StringSplitOptions.RemoveEmptyEntries)
                .Select(double.Parse);
            return new Point(nums.First(), nums.Last());
        }
        /// <summary>Возвращает <see langword="true"/> если из строкового 
        /// представления можно получить экземпляр Poin</summary>
        /// <param name="value">Строка со значениями X и Y через пробел</param>
        /// <param name="point">Полученный экземпляр Point или null</param>
        /// <returns>bool <see langword="true"/> если успешно</returns>
        public static bool TryParse(string value, out Point point)
        {
            try
            {
                point = Parse(value);
                return true;
            }
            catch
            {
                point = default;
                return false;
            }
        }
 
        /// <summary>Строковое представление точки</summary>
        /// <returns>string со строковым представлением</returns>
        public override string ToString() => $"{X} {Y}";
 
        /// <summary>Возвращаете площадь многоугольника с заданными вершинами</summary>
        /// <param name="polygon">Вершины многоугольника</param>
        /// <returns>double - площадь вершин</returns>
        /// <remarks> Создана по примеру kolorotur https://www.cyberforum.ru/windows-forms/thread1428726.html#post7529234
        /// Worldmen, можно взять за основу теорему Грина, на принципах которой работает планиметр.
        /// Предполагается, конечно, что полигон простой, то есть не самопересекающийся и без "дырок".</remarks>
        public static double Area(IEnumerable<Point> polygon)
        {
            double area = 0;
            Point a = polygon.First();
            foreach (Point b in polygon.Skip(1).Append(a))
            {
                area += a.X * b.Y - a.Y * b.X;
                a = b;
            }
            return Math.Abs(area) / 2;
        }
    }

    public struct Triangle
    {
        public Point A { get; }
        public Point B { get; }
        public Point C { get; }
        public double Area { get; }
 
        public Triangle(Point a, Point b, Point c)
        {
            A = a;
            B = b;
            C = c;
 
            double ab = Point.Distance(a, b);
            double bc = Point.Distance(b, c);
            double ca = Point.Distance(c, a);
            double p = (ab + bc + ca) / 2.0;
            Area = Math.Sqrt(p * (p - ab) * (p - bc) * (p - ca));
        }
 
        public override string ToString()
            => $"({A})({B})({C})=({Area})";
    }

        static void Main(string[] args)
        {
 
            List<Point> points = new List<Point>()
            {
                Point.Parse("0 0"),
                Point.Parse("2 0"),
                Point.Parse("0 2"),
                Point.Parse("1 2"),
                Point.Parse("3 5"),
                Point.Parse("8 10"),
                Point.Parse("10 15"),
                Point.Parse("-5 6"),
                Point.Parse("-10 9"),
                Point.Parse("-10 -10"),
                Point.Parse("9 4"),
            };
 
            List<Triangle> triangles = new List<Triangle>();
 
            for (int i = 0; i < points.Count - 2; i++)
            {
                for (int j = i + 1; j < points.Count - 1; j++)
                {
                    for (int k = j + 1; k < points.Count; k++)
                    {
                        triangles.Add(new Triangle(points[i], points[j], points[k]));
                    }
                }
            }
 
            foreach(var group in triangles.GroupBy(tr => tr.Area).Where(gr => gr.Count()>1).OrderBy(gr => gr.Count()))
            {
                Console.WriteLine("Треугольники площадью " + group.First().Area);
                Console.WriteLine(string.Join("\r\n", group.Select(tr => "\t" + tr)));
            }

using System;
using System.Linq;
 
class Program
{
    static void Main()
    {
        var m = new (double x, double y)[] { (1, 1), (10, 10), (2, 2), (13, 14), (3, 4), (12, 12) };
 
        Console.WriteLine(Enumerable.Range(0, m.Length).Join(Enumerable.Range(1, m.Length - 1), x => true, y => true, (x, y) => (a: x, b: y)).Where(x => x.b > x.a)
            .Join(Enumerable.Range(2, m.Length - 2), x => true, y => true, (x, y) => (a: x.a, b: x.b, c: y)).Where(x => x.c > x.b).Select(x => (a: m[x.a], b: m[x.b], c: m[x.c]))
            .Select(x => Math.Round(0.5 * Math.Abs((x.b.x - x.a.x) * (x.c.y - x.a.y) - (x.c.x - x.a.x) * (x.b.y - x.a.y)), 5))
            .Where(x => x > 0).GroupBy(g => g).Where(x => x.Count() > 1).Any() ? "True" : "False");
 
        Console.ReadKey();
    }
}

using System;
using System.Linq;
 
class Program
{
    static void Main()
    {
        var m = new (double x, double y)[] { (1, 1), (10, 10), (2, 2), (13, 14), (3, 4), (12, 12) };
 
        Console.WriteLine(Enumerable.Range(0, m.Length * m.Length * m.Length).Select(x => (a: x / m.Length / m.Length, b: x / m.Length % m.Length, c: x % m.Length))
            .Where(x => x.b > x.a && x.c > x.b).Select(x => Math.Round(0.5 * Math.Abs((m[x.b].x - m[x.a].x) * (m[x.c].y - m[x.a].y) - (m[x.c].x - m[x.a].x) * (m[x.b].y - m[x.a].y)), 5))
            .GroupBy(g => g).Where(x => x.Count() > 1 && x.Key > 0).Any());
 
        Console.ReadKey();
    }
}