Save a copy. Otherwise many answers refer to the same list, which later choices and undo operations will change. Restoring a working object is different from preserving a completed result.

Assume the input items are distinct.

def subsets(values):
    answers, path = [], []
    def visit(i):
        if i == len(values):
            answers.append(path.copy())
            return
        visit(i + 1)               # Exclude this item.
        path.append(values[i])     # Include this item.
        visit(i + 1)
        path.pop()                 # Restore the caller's path.
    visit(0)
    return answers

assert subsets(["A", "B"]) == [[], ["B"], ["A"], ["A", "B"]]
assert subsets([]) == [[]]

Each call returns with path exactly as it found it. That local promise prevents a sibling branch from inheriting another branch’s choice. Recursion itself does not automatically undo mutations to shared objects.

There are 2**n outputs, with Θ(n·2**n) total copying time and output storage. Working path and recursion depth use O(n) extra space excluding output. A generator can reduce retained output memory, but still needs to generate every requested result.

Recognition test: are you required to list configurations, or do constraints depend on the partial construction? A choice search is a useful baseline. For existence, stop at the first success. For a count or optimum, ask next whether repeated sufficient states can share an answer.

Analogy limit: backtracking does not always require an explicit pop. Passing a new immutable tuple to each child achieves branch separation through new values, at a copying cost.

No. It treats positions as distinct choices and emits ["A"] twice. You need a duplicate policy derived from whether identity belongs to positions or values.