如何使用序列在 F# 中创建无限集的幂集（组合）？

Question

这是我在这个问题上的失败尝试，如果有任何帮助，我们将不胜感激。

我试图为在急切列表上工作的电源组提出最佳算法。这部分似乎工作正常。我遇到问题的部分是将其翻译为与序列一起使用，以便它可以在流式\无限列表上运行它。我真的不喜欢 yield 语法可能是因为我不太了解它，但我宁愿拥有它而不使用 yield 语法。

//All Combinations of items in a list
//i.e. the Powerset given each item is unique
//Note: lists are eager so can't be used for infinite
let listCombinations xs =
    List.fold (fun acc x ->
        List.collect (fun ys -> ys::[x::ys]) acc) [[]] xs

//This works fine (Still interested if it could be faster)
listCombinations [1;2;3;4;5] |> Seq.iter (fun x -> printfn "%A" x)

//All Combinations of items in a sequence
//i.e. the Powerset given each item is unique
//Note: Not working
let seqCombinations xs =
    Seq.fold (fun acc x ->
        Seq.collect (fun ys -> 
            seq { yield ys
                  yield seq { yield x
                              yield! ys} }) acc) Seq.empty xs

//All Combinations of items in a sequence
//i.e. the Powerset given each item is unique
//Note: Not working (even wrong type signature)
let seqCombinations2 xs =
    Seq.fold (fun acc x ->
        Seq.collect (fun ys ->
            Seq.append ys (Seq.append x ys)) acc) Seq.empty xs

//Sequences to test on
let infiniteSequence = Seq.initInfinite (fun i -> i + 1)
let finiteSequence = Seq.take 5 infiniteSequence

//This should work easy since its in a finite sequence
//But it does not, so their must be a bug in 'seqCombinations' above
for xs in seqCombinations finiteSequence do
    for y in xs do
        printfn "%A" y

//This one is much more difficult to get to work
//since its the powerset on the infinate sequence
//None the less If someone could help me find a way to make this work
//This is my ultimate goal
let firstFew = Seq.take 20 (seqCombinations infiniteSequence)
for xs in firstFew do
    for y in xs do
        printfn "%A" y

Answer 1

您的seqCombinations 几乎是正确的，但您没有正确地将其从列表转换为序列。 [[]] 的等价物不是Seq.empty，而是Seq.singleton Seq.empty：

let seqCombinations xs =
    Seq.fold (fun acc x ->
        Seq.collect (fun ys -> 
            seq { yield ys
                  yield seq { yield x
                              yield! ys} }) acc) (Seq.singleton Seq.empty) xs

上面的代码适用于有限序列。但是对于无限序列，它不起作用，因为它首先尝试到达终点，而对于无限序列，它显然永远不会这样做。

如果你想要一个可以处理无限序列的函数，我想出了两种方法，但它们都不是特别好。其中之一使用可变状态：

let seqCombinations xs =
    let combs = ref [[]]
    seq {
        yield! !combs
        for x in xs do
            let added = List.map (fun ys -> x::ys) !combs
            yield! added
            combs := !combs @ added
    }

另外一个就是过多处理seq<T>的细节：

open System.Collections.Generic

let seqCombinations (xs : seq<_>) =
    let rec combs acc (e : IEnumerator<_>) =
        seq {
            if (e.MoveNext()) then
                let added = List.map (fun ys -> (e.Current)::ys) acc
                yield! added
                yield! combs (acc @ added) e }

    use enumerator = xs.GetEnumerator()
    seq {
        yield []
        yield! combs [[]] enumerator
    }

我认为，如果您可以将无限序列视为头尾，就像 F# 中的有限列表或 Haskell 中的任何序列一样，这会容易得多。但肯定有可能在 F# 中有一种很好的方式来表达这一点，我只是没找到。

Answer 2

我最近在Generate powerset lazily 上问了一个类似的问题，并得到了一些不错的答案。

对于有限集的幂集，@Daniel 在上述链接中的答案是一个有效的解决方案，可能适合您的目的。你可以拿出一个测试用例来比较他和你的方法。

关于无限集的幂集，这里有一些数学知识。根据Cantor's theorem，可数无限集的幂集是不可数无限的。这意味着即使以惰性方式也无法枚举所有整数（可数无限）的幂集。实数的直觉是相同的。由于实数是不可数无限的，我们实际上无法使用无限序列对其进行建模。

因此，没有算法可以枚举可数无限集的幂集。或者那种算法根本没有意义。

Answer 3

这有点像玩笑，但实际上会为无限序列生成正确的结果（只是无法证明——经验上，而不是数学上）。

let powerset s =
  seq {
    yield Seq.empty
    for x in s -> seq [x]
  }