anchor.diff:              | _ -> 
                   let root = int (sqrt (float n))
                   seq {3..2..root} |> Seq.forall (fun i -> n % i <> 0)
  +
  +module Triangles =
  +    // https://en.wikipedia.org/wiki/Tree_of_primitive_Pythagorean_triples
  +    let pythagoreanTriplesWithSumBelow num =
  +        let rec enumerate (a, b, c) =
  +            seq {
  +                if a + b + c <= num then
  +                    let nextScaled ((a, b, c), i) =
  +                        if (a + b + c) * i <= num then
  +                            Some((a * i, b * i, c * i), ((a, b, c), i + 1))
  +                        else
  +                            None
  +
  +                    yield! Seq.unfold nextScaled ((a, b, c), 1)
  +
  +                    let a1, b1, c1 = a + -2 * b + 2 * c, 2 * a + -b + 2 * c, 2 * a + -2 * b + 3 * c
  +                    yield! enumerate (a1, b1, c1)
  +
  +                    let a2, b2, c2 = a + 2 * b + 2 * c, 2 * a + b + 2 * c, 2 * a + 2 * b + 3 * c
  +                    yield! enumerate (a2, b2, c2)
  +
  +                    let a3, b3, c3 = -1 * a + 2 * b + 2 * c, -2 * a + b + 2 * c, -2 * a + 2 * b + 3 * c
  +                    yield! enumerate (a3, b3, c3)
  +            }
  +
  +        enumerate (3, 4, 5)
   
   module Problem1 =
       let answer =
  
positive.code:         pandigitalsDecreasing
          |> Seq.find isConcatenatedProduct
  
  module Problem48 =
      let sum =
          seq { 1..1000 }
  
negative.code:         |> System.String.Join
  
  module Problem75 =
      let answer =
          Triangles.pythagoreanTriplesWithSumBelow 1500000
          |> Seq.groupBy (fun (a, b, c) -> a + b + c)
          |> Seq.filter (fun (sum, triples) -> (triples |> Seq.length) = 1)
          |> Seq.length