<?xml version='1.0' encoding='utf-8' standalone='no'?>

<!DOCTYPE issue SYSTEM "lwg-issue.dtd">

<issue num="4289" status="New">

<title>Seed sequence is overspecified</title>

<section>

<sref ref="[rand.req.seedseq]"/>

</section>

<submitter>Magnus Fromreide</submitter>

<date>22 Jun 2025</date>

<priority>99</priority>

<discussion>

<p>

The requirements on a seed sequence are so strict that it is forbidden to initialize a random number

generator directly from a hardware random number generator without lots of boiler plate and intermediary objects.

<p/>

The main problem is that the seed sequence requirements state that a seed sequence must be "kind of copyable"

and that calls to the copy must generate the same output as calls to the original.

<p/>

If one checks the uses of seed sequences then nothing makes use of this capability so I propose to just drop it.

<p/>

There has been a previous attempt to handle this issue using <paper num="P0205"/> which preserved the old seed

sequence and added a new concept that it used to seed generators. That effort stalled with the comment that

it should be solved without the new `std::seed_adapter`. This DR sidesteps that whole issue by simply removing

the unused requirements from the seed sequence concept.

<p/>

I will admit that I am unsure about the deletion of Note 1 but since it only seems to attempt to motivate the

copyability I opted to let it go along with the requirements.

</p>

</discussion>

<resolution>

<p>

This wording is relative to <paper num="N5008"/>.

</p>

<ol>

<li><p>Modify <sref ref="[rand.req.seedseq]"/> as indicated:</p>

<blockquote>

<p>

-1- A <i>seed sequence</i> is an object that <del>consumes a sequence of integer-valued data and</del>

produces a requested number of unsigned integer values <tt><i>i</i></tt>, <tt>0 = i &lt; 2³²</tt><del>,

based on the consumed data</del>.

<p/>

<del>[<i>Note 1</i>: Such an object provides a mechanism to avoid replication of streams of random variates. This can be

useful, for example, in applications requiring large numbers of random number engines. &mdash; <i>end note</i>]</del>

<p/>

-2- A class `S` meets the requirements of a seed sequence if the expressions shown in

Table 124 <sref ref="[tab:rand.req.seedseq]"/> are valid and have the indicated semantics, and if `S` also meets

all other requirements of <sref ref="[rand.req.seedseq]"/>. In Table 124 [tab:rand.req.seedseq] and throughout

this subclause:

</p>

<ol style="list-style-type: none">

<li><p>(2.1) &mdash; `T` is the type named by `S`' s associated `result_type`;</p></li>

<li><p>(2.2) &mdash; `q` is a value of type `S` <del>and `r` is a value of type `S` or `const S`</del>; <ins>and</ins></p></li>

<li><p><del>(2.3) &mdash; `ib` and `ie` are input iterators with an unsigned integer `value_type` of at least 32 bits;</del></p></li>

<li><p>(2.4) &mdash; `rb` and `re` are mutable random access iterators with an unsigned integer `value_type` of

at least 32 bits<del>;</del><ins>.</ins></p></li>

<li><p><del>(2.5) &mdash; `ob` is an output iterator; and</del></p></li>

<li><p><del>(2.6) &mdash; `il` is a value of type <tt>initializer_list&lt;T&gt;</tt>.</del></p></li>

</ol>

<blockquote>

<table border="1">

<caption>Table 124 &mdash; Seed sequence requirements [tab:rand.req.seedseq]</caption>

<tr>

<th align="center">Expression</th>

<th align="center">Return type</th>

<th align="center">Pre/post-condition</th>

<th align="center">Complexity</th>

</tr>

<tr>

<td>

`S::result_type`

</td>

<td>

`T`

</td>

<td>

`T` is an unsigned integer<br/>

type (<sref ref="[basic.fundamental]"/>) of at least 32 bits.

</td>

<td>

</td>

</tr>

<tr>

<td>

<del><tt>S()</tt></del>

</td>

<td>

<tt></tt>

</td>

<td>

<del>Creates a seed sequence with</del><br/>

<del>the same initial state as all</del><br/>

<del>other default-constructed seed</del><br/>

<del>sequences of type `S`.</del>

</td>

<td>

<del>constant</del>

</td>

</tr>

<tr>

<td>

<del>`S(ib,ie)`</del>

</td>

<td>

<tt></tt>

</td>

<td>

<del>Creates a seed sequence having</del><br/>

<del>internal state that depends on</del><br/>

<del>some or all of the bits of the</del><br/>

<del>supplied sequence `[ib, ie)`.</del>

</td>

<td>

<del>&#x1d4aa;(ie - ib)</del>

</td>

</tr>

<tr>

<td>

<del>`S(il)`</del>

</td>

<td>

<tt></tt>

</td>

<td>

<del>Same as <tt>S(il.begin(), il.end())</tt>.</del>

</td>

<td>

<del>same as <tt>S(il.begin(), il.end())</tt></del>

</td>

</tr>

<tr>

<td>

<tt>q.generate(rb,re)</tt>

</td>

<td>

<tt>void</tt>

</td>

<td>

Does nothing if `rb == re`.<br/>

Otherwise, fills the supplied<br/>

sequence `[rb, re)` with 32-bit<br/>

quantities <del>that depend on the</del><br/>

<del>sequence supplied to the</del><br/>

<del>constructor and possibly also</del><br/>

<del>depend on the history of</del><br/>

<del>`generate`'s previous</del><br/>

<del>invocations</del>.

</td>

<td>

&#x1d4aa;(re - rb)

</td>

</tr>

<tr>

<td>

<del><tt>r.size()</tt></del>

</td>

<td>

<del><tt>size_t</tt></del>

</td>

<td>

<del>The number of 32-bit units that</del><br/>

<del>would be copied by a call to</del><br/>

<del>`r.param`.</del>

</td>

<td>

<del>constant</del>

</td>

</tr>

<tr>

<td>

<del><tt>r.param(ob)</tt></del>

</td>

<td>

<del><tt>void</tt></del>

</td>

<td>

<del>Copies to the given destination</del><br/>

<del>a sequence of 32-bit units that</del><br/>

<del>can be provided to the</del><br/>

<del>constructor of a second object of</del><br/>

<del>type `S`, and that would</del><br/>

<del>reproduce in that second object</del><br/>

<del>a state indistinguishable from</del><br/>

<del>the state of the first object.</del>

</td>

<td>

<del>&#x1d4aa;(r.size())</del>

</td>

</tr>

</table>

</blockquote>

</blockquote>

</li>

</ol>

</resolution>

</issue>