1. Abridged Problem Statement
Given n side lengths a₁,…,aₙ (3 ≤ n ≤ 10), there exists at least one simple polygon with these sides. Find the infimum of the areas of all simple polygons realizable with those side lengths. Output the result with absolute or relative error ≤ 1e–6.

2. Detailed Editorial
Core idea: any simple polygon can be "collapsed" toward a triangle whose sides are formed by grouping the original edges into three "super-edges" in sequence. By sliding edges so that each super-edge becomes a single vector (sum of its constituent directed edges), the polygon's area approaches the area of the triangle spanned by those three vectors.

Concretely: label the three super-edges X, Y, Z. For each original side length aᵢ, decide:
  - which super-edge it contributes to (X, Y, or Z),
  - whether it is added in the forward direction or backward direction along that super-edge.

Thus each side has 3 × 2 = 6 choices, and over n sides there are 6ⁿ possibilities (≈ 60 million when n=10), which is feasible in optimized C++. For each assignment we compute the scalar sums x, y, z of the lengths (signed) in groups X, Y, Z. If the triple (|x|,|y|,|z|) satisfies the triangle inequality, the area is given by Heron's formula:

  s = (|x| + |y| + |z|)/2
  area = √(s(s–|x|)(s–|y|)(s–|z|))

We take the minimum of these areas over all assignments. If no assignment yields a valid triangle, its contribution is +∞ and is ignored. The result is the infimum of achievable areas.

3. C++ Solution

```cpp
#include <bits/stdc++.h>

using namespace std;

template<typename T1, typename T2>
ostream& operator<<(ostream& out, const pair<T1, T2>& x) {
    return out << x.first << ' ' << x.second;
}

template<typename T1, typename T2>
istream& operator>>(istream& in, pair<T1, T2>& x) {
    return in >> x.first >> x.second;
}

template<typename T>
istream& operator>>(istream& in, vector<T>& a) {
    for(auto& x: a) {
        in >> x;
    }
    return in;
};

template<typename T>
ostream& operator<<(ostream& out, const vector<T>& a) {
    for(auto x: a) {
        out << x << ' ';
    }
    return out;
};

int n;
vector<int> a;

void read() {
    cin >> n;
    a.resize(n);
    cin >> a;
}

double area(int a, int b, int c) {
    double s = (a + b + c) / 2.0;
    return sqrt(s * (s - a) * (s - b) * (s - c));
}

double rec(int i, int x, int y, int z) {
    if(i == n) {
        if(x + y < z || y + z < x || z + x < y) {
            return 1e18;
        }
        return area(abs(x), abs(y), abs(z));
    }
    double res = 1e18;
    res = min(res, rec(i + 1, x + a[i], y, z));
    res = min(res, rec(i + 1, x, y + a[i], z));
    res = min(res, rec(i + 1, x, y, z + a[i]));
    res = min(res, rec(i + 1, x - a[i], y, z));
    res = min(res, rec(i + 1, x, y - a[i], z));
    res = min(res, rec(i + 1, x, y, z - a[i]));
    return res;
}

void solve() {
    // Fundamentally the solution is simple - we can notice n <= 10, so this
    // immediately suggests that we can use a brute force solution. The main
    // observations is that we should always aim for an area 0.0 polygon (e.g.
    // say if we have 5, 5, 5, and 5). If this is impossible, we should make a
    // triangle. We can note that we should always be able to make on of these
    // two. This idea generalizes - instead of sequentially attaching the sides,
    // we can make an area 0.0 zone as part of a side of the triangle, and
    // essentially get a "smaller" triangle. This leads to the idea of brute
    // forcing the sides of a triangle but we can move the sides in both
    // directions, positive meaning we extend the side, negative meaning we
    // create a zone with almost no area.

    cout << setprecision(10) << fixed << rec(0, 0, 0, 0) << endl;
}

int main() {
    ios_base::sync_with_stdio(false);
    cin.tie(nullptr);

    int T = 1;
    // cin >> T;
    for(int test = 1; test <= T; test++) {
        read();
        // cout << "Case #" << test << ": ";
        solve();
    }

    return 0;
}
```

4. Python Solution with Detailed Comments
```python
import sys
sys.setrecursionlimit(10000)

# Read input
n = int(sys.stdin.readline().strip())
a = list(map(int, sys.stdin.readline().split()))

# Heron's formula for triangle area
def triangle_area(A, B, C):
    s = (A + B + C) / 2.0
    return (s * (s - A) * (s - B) * (s - C)) ** 0.5

# Recursive brute-force: i = current index, x,y,z = signed group sums
def rec(i, x, y, z):
    if i == n:
        # Check if |x|,|y|,|z| can form a valid triangle
        X, Y, Z = abs(x), abs(y), abs(z)
        if X + Y < Z or Y + Z < X or Z + X < Y:
            return float('inf')
        return triangle_area(X, Y, Z)
    best = float('inf')
    length = a[i]
    # Six choices: assign to X,Y,Z with +/-
    best = min(best, rec(i+1, x + length, y, z))
    best = min(best, rec(i+1, x - length, y, z))
    best = min(best, rec(i+1, x, y + length, z))
    best = min(best, rec(i+1, x, y - length, z))
    best = min(best, rec(i+1, x, y, z + length))
    best = min(best, rec(i+1, x, y, z - length))
    return best

ans = rec(0, 0, 0, 0)
# If inf (no valid triangle), answer is zero
if ans == float('inf'):
    ans = 0.0
print(f"{ans:.10f}")
```

5. Compressed Editorial
Group the n edges into three "super-edges" X, Y, Z. Each original side picks one group and a ± orientation, yielding signed sums x,y,z. If (|x|,|y|,|z|) obey the triangle inequality, compute its area by Heron's formula. Brute-force all 6ⁿ assignments (n≤10) and take the minimum area.
