{"id":"90b2db6b-1120-4ba4-ac6e-8f0abd150cf3","arxiv_id":"1908.01976","paper_version":1,"verdict":"CONDITIONAL","confidence":"MODERATE","novelty_score":5.0,"correctness_risk":"medium","formal_verification":"none","parameter_count":3,"one_line_summary":"A construction and stochastic-optimization method for sliced Latin hypercube designs with slices of arbitrary run sizes, evaluated by a weighted space-filling criterion.","lead":"This paper proposes a method to construct sliced Latin hypercube designs where each slice can have a different number of runs, and adds an optimization algorithm to make them space-filling. It could be useful for multi-fidelity computer experiments, where different accuracy levels naturally need different numbers of simulation runs.","discovery_kind":"extension","skeptic_critique":{"model":"deepseek-v4-flash","headline":"Theorem 1 hinges on an unproved greedy-allocation lemma; the proof contains a false inequality, so the central construction is not established for arbitrary run sizes.","rationale":"I read the paper in good faith. The construction is plausible, and the worked example plus manual checks through n ≈ 10 work, so I do not claim the theorem is false. The load-bearing weak point is exactly the one the reader identifies: the allocation step. It is load-bearing because Step 2 is the only mechanism that guarantees both |H_i| = n_i and the slice-level ceiling property; Theorem 1(i) then follows from a permutation, and Theorem 1(ii) depends only on the allocation. The written proof of (ii) does not prove this mechanism and contains a false strict inequality, so the central claim is not established as written. The empirical issues noted by the reader (impossible Min/Mean/Max in Table 1) further undermine confidence but are secondary to the mathematical claim; they do not change the verdict. Because the gap is concrete and testable, and because no counterexample is known to me, the appropriate verdict remains conditional: accept only if the allocation lemma is proved or exhaustively verified and the tables are corrected. This agrees with the reader's weakest-assumption identification.","tokens_in":15732,"tokens_out":44602,"duration_ms":433389,"concrete_test":"Run an exhaustive check of the exact Step 2 algorithm for all compositions n1,...,nu with n ≤ 20: verify terminal R_n = ∅ and {ceil(n_i h/n) : h ∈ H_i} = {1,...,n_i} for every i. Independently verify Hall's condition for the interval family I_{i,k} = [floor((k-1)n/n_i)+1, floor(k n/n_i)] by counting, for every [a,b] ⊆ {1,...,n}, how many I_{i,k} lie inside [a,b] and checking the count never exceeds b-a+1. A failure of either check refutes or localizes the gap; if both pass for all small n, the missing proof of the allocation lemma is still needed.","verdict_should_be":"UNCHANGED","load_bearing_attack":"Step 2 of Section 2 must assign each integer 1,...,n exactly once so that each H_i has n_i elements and, for each i, the map h ↦ ceil(n_i h/n) is a bijection onto {1,...,n_i}. This is a nontrivial interval-matching condition: the k-th trigger of slice i must be matched to an unused r in I_{i,k} = [floor((k-1)n/n_i)+1, floor(k n/n_i)], and the greedy rule must find such an r at every step. The proof of Theorem 1 does not establish this. It asserts 'it is clear' that card(H_i) = ... and that for any i,j there is h in H_i with the required ceiling, but no feasibility argument is supplied. Worse, the displayed assertion 'ceil(n_i j/n) < ceil(n_i(j+1)/n)' in Proof 1(ii) is false (e.g., n1=2, n2=3, n=5, j=1 gives 1 < 1), so the proof as written is internally incorrect. The same allocation condition underlies the slice-level optimality claim: if any composition dead-ends, the FSLHD construction and the SESE/two-part algorithms built on it do not produce valid designs.","agreement_with_reader":"agree"},"referee_report":{"model":"deepseek-v4-flash","summary":"The paper proposes a construction of sliced Latin hypercube designs (FSLHDs) in which the slice run sizes n_1,...,n_u are arbitrary, together with a combined space-filling measurement (CSM) and two stochastic optimization algorithms (SESE and a two-part algorithm) for finding space-filling FSLHDs. The main theoretical result, Theorem 1, asserts that the construction yields optimal univariate uniformity both for the whole design and for every slice. The paper also derives fast updating formulas for the CSM under the proposed exchange procedures and reports simulation comparisons.","tokens_in":16041,"tokens_out":6736,"duration_ms":65598,"significance":"If Theorem 1 is correct, the construction fills a genuine gap: existing SLHD constructions largely require equal slice sizes or handle only two distinct sizes, whereas multi-fidelity experiments often need unequal slice sizes. The CSM is a natural weighted scalarization, and the exchange procedures plus updating formulas are practical algorithmic contributions. The paper is well structured and includes a worked example. However, the central construction currently rests on an unproved combinatorial feasibility claim, so the significance is contingent on completing the proof.","major_comments":[{"comment":"The greedy allocation in Step 2 asserts without proof that at every step a suitable unused integer r exists: for a trigger of slice l at step j, the algorithm chooses r = min{r : ceil(n_l r / n) = ceil(n_l j / n), r in R_{j,k-1}}. The proof of Theorem 1(ii) says only that 'it is clear' that card(H_i) = n_i and that each needed h exists, but this requires that R_{j,k-1} always intersects the interval I_{l,j} = {r : ceil(n_l r / n) = ceil(n_l j / n)}. No feasibility argument is given, and this property is load-bearing because the whole FSLHD guarantee and the later optimization algorithms depend on it. Please supply a rigorous lemma proving that the greedy rule never dead-ends, or modify the construction so the property is evident.","section":"Section 2, Step 2 and Theorem 1 proof (ii)"},{"comment":"The proof contains the assertion that ceil(n_i j / n) < ceil(n_i (j+1) / n) for every j = 1,...,n, which is false in general; for example, with n_1 = 2, n_2 = 3, n = 5 and j = 1, both sides equal 1. The proof must be corrected, for instance by using the non-strict inequality and then arguing that the map j -> ceil(n_i j / n) takes every value in {1,...,n_i} at least once because it starts at 1, ends at n_i, and increments by at most 1 at each step.","section":"Theorem 1 proof (ii)"},{"comment":"The row for 'Part-I + Part-II FSLHD(5,10,15,30;4,6)' reports Min = 1.9041, Mean = 2.2424, and Max = 2.0394, which is impossible because the mean cannot exceed the maximum. This indicates a data error or typo in a table that is central to the empirical comparison between the SESE and two-part algorithms. Please correct the entry and re-evaluate the conclusions drawn from it in Section 4.2.","section":"Table 1, Section 4.2"}],"minor_comments":[{"comment":"In the text accompanying Example 2.1, 'ceil(n_l(j+1)/n) - ceil(n_L j / n)' should read 'ceil(n_l(j+1)/n) - ceil(n_l j / n)'.","section":"Example 2.1"},{"comment":"The sentence 'Recall that t_i = lcm(n_1,...,n_u,n)/n_i, for i =,...,u - 1' is missing the starting index; it should be 'for i = 1,...,u - 1'.","section":"Section 3.4"},{"comment":"The phrase 'MN(1 : n, j) still satisfies Theorem (i)' should reference 'Theorem 1(i)'.","section":"Section 3.2.2"},{"comment":"The phi_CSM values in the text (14.4740 and 5.7958) do not match the values in the captions of Figure 5 (14.4223 and 5.6844); please reconcile these numbers.","section":"Example 1, Section 4.1"},{"comment":"The manuscript contains numerous typographical and grammatical errors, including 'descibe' and 'effective' in the abstract, 'desigh' in the Figure 1 caption, 'φtheCSM' in Algorithm 1, and incomplete reference information (e.g., Huang et al. 2015, '0–00'); a careful language edit is needed.","section":"Throughout"},{"comment":"The centered L2-discrepancy formula uses m for the number of factors while the design is described with q factors; please make the notation consistent.","section":"Equation (8)"}],"recommendation":"major_revision","confidential_remarks":"The paper is an early preprint with substantial presentation problems, but the core idea is potentially publishable if the construction proof can be completed. The most serious issue is the missing feasibility lemma for the greedy allocation; the false inequality in the proof currently makes the central theorem unsupported. I would encourage the editor to request a revision with a complete proof and corrected simulation tables. The relationship to the authors' own earlier work in Xu et al. (2019) should also be made explicit so that the novelty of the construction can be judged."},"author_rebuttal":null,"desk_editor":{"model":"deepseek-v4-flash","letter":"Short version: the paper targets a real gap—sliced Latin hypercube designs whose slices have unequal run sizes—and offers a concrete construction plus two optimization algorithms. The construction is plausible and the running example works, but the central theorem is not actually proved. The greedy allocation in Step 2 is asserted to succeed (“it is clear”), and the proof of Theorem 1(ii) contains a false inequality: for n1=2, n2=3, n=5, j=1, the displayed claim reads 1 < 1. That is load-bearing: if the allocation can dead-end, the FSLHD may not exist for arbitrary run sizes. The paper also reports an impossible summary statistic: for FSLHD(5,10,15,30;4,6), the Part-I+Part-II row has mean 2.2424 and max 2.0394. That cannot happen; probably a typo, but it makes the empirical section hard to trust as printed.\n\nWhat is good: the problem matters for multi-fidelity computer experiments; the slice-preserving exchange procedures are carefully designed; the updating formulas for phi_t under those moves are a useful practical contribution; and the SESE algorithm does improve random FSLHDs in the example. The authors cite Xu et al. (2019) for the prior arbitrary-run-size construction, so the novelty is appropriately scoped as an optimization-oriented extension rather than first construction.\n\nSoft spots beyond the theorem: no baseline comparison against Xu et al. (2019), no code or data, and the CSM weights are chosen informally. None of these are fatal if the allocation lemma is proved.\n\nFor a researcher in design of experiments, this is worth knowing about, but I would not cite the construction as established until the feasibility proof exists. I would send it out for serious review—the referee should demand a rigorous proof of the greedy allocation, corrected tables, and a direct comparison with the authors' own prior construction. The paper is honest and shows clear thinking, but the central guarantee is not yet established.","headline":"Plausible extension to unequal slice sizes, but the central existence proof is incomplete and the empirical section has an impossible table entry; still worth a serious referee.","tokens_in":16488,"tokens_out":2994,"would_cite":false,"duration_ms":28681,"reading_group":"maybe","serious_thinker":"yes","would_accept_peer_review":true},"rs_alignment":null,"lean_confirmation":null,"pith_extraction":{"msc":["62K05"],"pacs":[],"model":"deepseek-v4-flash","headline":"Sliced Latin hypercube designs can now have slices of arbitrary run sizes.","keywords":["sliced Latin hypercube design","flexible sliced Latin hypercube design","arbitrary run sizes","space-filling design","maximin distance criterion","combined space-filling measurement","enhanced stochastic evolutionary algorithm","computer experiments"],"falsifier":"Run the Step 2 allocation exhaustively over small run-size vectors, such as all triples with n up to 20, and check whether at any step the set {r in R_{j,k-1} : ceil(n_l r / n) = ceil(n_l j / n)} is empty when slice l requires a point; a single empty set would disprove Theorem 1 as stated.","tokens_in":15543,"feed_emoji":"🎲","tokens_out":4165,"duration_ms":42587,"temperature":0.7,"pith_summary":"This paper proposes a construction for sliced Latin hypercube designs (SLHDs) in which the slices are allowed to have different, arbitrary run sizes, removing a restriction that forced all slices to be equal in size. The central claim, stated as Theorem 1, is that both the whole design and every individual slice achieve optimal univariate uniformity: exactly one design point falls in each of the n equal intervals for the full design, and exactly one point of slice i falls in each of its n_i equal intervals. If true, this gives experimenters flexible designs for multi-fidelity computer experiments, where lower-accuracy runs naturally require more points than higher-accuracy runs. The paper also introduces a combined space-filling measure and optimization algorithms to search for designs that are evenly spread out both globally and within each slice.","feed_headline":"New construction gives sliced Latin hypercubes arbitrary run sizes","feed_subtitle":"Each slice and the whole design keep one point per interval, so unequal batch sizes no longer break optimal design.","key_machinery":"The load-bearing construction is a greedy allocation rule in Step 2 of Section 2. For each j from 1 to n, the rule computes how many slices 'claim' the interval around j/n according to the ceiling differences ceil(n_i(j+1)/n) - ceil(n_i j/n), then assigns the smallest available unused integer r that keeps the slice's count aligned with its target proportion. The claimed theorem rests on this allocation always succeeding and leaving each slice H_i with exactly n_i elements. Once the integer levels are assigned, each column is formed by mapping level h to L h/n and jittering by uniform noise, which is what makes the univariate projections uniform at both the whole-design and slice scales.","core_discovery":"The paper claims that for any positive integers n_1,...,n_u with n = sum n_i, the stepwise construction in Section 2 produces a flexible sliced Latin hypercube design (FSLHD) such that the whole design is a Latin hypercube and each slice is itself a Latin hypercube. The construction assigns each integer level from 1 to n to one of the u slices according to ceiling-function counts, then scales the assigned levels by L/n, where L is the least common multiple of n_1,...,n_u and n, and adds independent uniform jitter. Theorem 1 asserts that after this scaling, exactly one point of the full column lies in each interval of length 1/n and exactly one point of slice i lies in each interval of length 1/n_i. This gives a direct, parameter-free way to build sliced Latin hypercube designs with arbitrary slice sizes, which the paper argues existing methods do not provide.","pith_inferences":["Beyond the paper: the greedy allocation in Step 2 resembles a generalized Beatty-sequence partition of {1,...,n} into slices with densities n_i/n, and one could test whether it always succeeds by exhaustive search over small run-size tuples; the paper's proof does not settle this.","Beyond the paper: if a counterexample to the allocation rule exists, the construction would still work for many practical run-size choices, and a characterization of the tuples where it succeeds would be a useful follow-up.","Beyond the paper: the combined space-filling measure weights the whole design and the slices equally when w = 1/2, but the paper does not explore how sensitive the resulting optimal designs are to this choice; other weights could be tuned for applications where global spread matters more or less.","Beyond the paper: the two-part algorithm's stopping rules (100 iterations) and threshold settings appear heuristic, so a sensitivity analysis of those parameters is a natural testable extension."],"forward_implications":["If Theorem 1 holds, experimenters can build sliced Latin hypercube designs with any prescribed slice sizes, so multi-fidelity experiments can allocate more runs to cheaper, lower-accuracy codes without sacrificing the Latin hypercube property.","The combined space-filling measure (CSM) gives a single objective that balances global spread and within-slice spread, so optimal FSLHDs can be searched by adapting existing optimization algorithms such as the enhanced stochastic evolutionary algorithm.","The proposed two-part algorithm offers a faster route to space-filling FSLHDs when the number of runs or factors is large, at some cost in objective value compared with the full search.","The whole design and each slice remain Latin hypercubes after optimization, because the exchange procedures are designed to preserve the sliced structure.","The construction can be paired with other space-filling criteria, such as centered L2 discrepancy, through the same combined-measure template."],"supporting_citations":[{"why":"Supplies the definition of Latin hypercube designs and the optimal univariate uniformity property that the new construction must satisfy.","marker":"McKay et al. (1979)"},{"why":"Defines sliced Latin hypercube designs, the concept this paper generalizes to arbitrary slice sizes.","marker":"Qian (2012)"},{"why":"Gives a prior algorithm for SLHDs with unequal run sizes, which the paper says is difficult to optimize and which motivates the new searchable construction.","marker":"Xu et al. (2019)"},{"why":"Presents optimal sliced Latin hypercube designs for equal run sizes, providing the benchmark and motivation for an arbitrary-size generalization.","marker":"Ba et al. (2015)"},{"why":"The enhanced stochastic evolutionary (ESE) algorithm that the paper adapts into the sliced ESE (SESE) algorithm.","marker":"Jin et al. (2016)"},{"why":"Introduces clustered sliced Latin hypercube designs with good whole-region space-filling, and motivates the multi-fidelity setting where slice sizes differ.","marker":"Huang et al. (2015)"},{"why":"Defines the centered L2 discrepancy used in the alternative combined space-filling measurement.","marker":"Hickernell (1998)"}],"fun_headline_variants":["Stepwise construction yields SLHDs with slices of any size","New construction removes run-size limits on sliced Latin hypercubes","Arbitrary slice sizes now possible for sliced Latin hypercube designs","LCM scaling allows arbitrary run sizes in sliced Latin hypercubes","No more run-size restrictions for optimal sliced Latin hypercubes"],"cache_read_input_tokens":3200,"weakest_assumption_plain":"The construction rests on the unproven assumption that the greedy allocation in Step 2 never gets stuck: at every step an unused integer r exists to fill the next required slice, so all n integers are eventually assigned and each slice ends with exactly n_i elements.","fun_headline_variants_meta":{"raw":{"variants":["Stepwise construction yields SLHDs with slices of any size","New construction removes run-size limits on sliced Latin hypercubes","Arbitrary slice sizes now possible for sliced Latin hypercube designs","LCM scaling allows arbitrary run sizes in sliced Latin hypercubes","No more run-size restrictions for optimal sliced Latin hypercubes"]},"model":"deepseek-v4-flash","effort":"low","cost_usd":0.000979,"raw_usage":{"total_tokens":4105,"prompt_tokens":843,"completion_tokens":3262,"prompt_tokens_details":{"cached_tokens":384},"prompt_cache_hit_tokens":384,"prompt_cache_miss_tokens":459,"completion_tokens_details":{"reasoning_tokens":3175}},"tokens_in":459,"tokens_out":3262,"duration_ms":23685,"temperature":1.0,"reasoning_tokens":3175,"cache_read_input_tokens":384,"cache_creation_input_tokens":0},"cache_creation_input_tokens":0},"created_at":"2026-08-14T14:58:13.381206+00:00","model_set":{"reader":"deepseek-v4-flash"},"falsifier":"Run the Step 2 allocation exhaustively over small run-size vectors, such as all triples with n up to 20, and check whether at any step the set {r in R_{j,k-1} : ceil(n_l r / n) = ceil(n_l j / n)} is empty when slice l requires a point; a single empty set would disprove Theorem 1 as stated.","supporting_citations":[{"cited_title":"A Comparison of Three Methods for Selecting Values of Input Variables in the Analysis of Output From a Computer Code","cited_arxiv_id":null,"evidence_quote":"Supplies the definition of Latin hypercube designs and the optimal univariate uniformity property that the new construction must satisfy."},{"cited_title":"Sliced Latin Hypercube Designs","cited_arxiv_id":null,"evidence_quote":"Defines sliced Latin hypercube designs, the concept this paper generalizes to arbitrary slice sizes."},{"cited_title":"An efficient algorithm for constructing optimal design of computer experiments","cited_arxiv_id":null,"evidence_quote":"The enhanced stochastic evolutionary (ESE) algorithm that the paper adapts into the sliced ESE (SESE) algorithm."},{"cited_title":"Computer Experiments With Both Qualitative and Quantitative Variables","cited_arxiv_id":null,"evidence_quote":"Introduces clustered sliced Latin hypercube designs with good whole-region space-filling, and motivates the multi-fidelity setting where slice sizes differ."},{"cited_title":"A generalized discrepancy and quadrature error bound","cited_arxiv_id":null,"evidence_quote":"Defines the centered L2 discrepancy used in the alternative combined space-filling measurement."}],"review_version":1}