Restrict 4x4x4 wide moves to R/U/F

[Nogesma]

I'm starting to use this scrambler for my project (https://codeberg.org/Nogesma/cube-bot), and noticed that 4x4 scrambles can return wide moves for L/D/B faces. They're a bit weird to do for big cubes so I was wondering if it would be possible to remove them?

I noticed they're already highlighted as "probably" redundant in the phase1 solver here:

twips/src/lib/scramble/puzzles/cube4x4x4/cube4x4x4_scramble_finder.rs

Lines 140 to 144 in f90bbc8

	// TODO: should we reduce the move count here as we've done for phase2? For example, Fw and
	// Bw are redundant, right?
	let phase1_generator_moves = move_list_from_vec(vec![
	"Uw", "U", "Lw", "L", "Fw", "F", "Rw", "R", "Bw", "B", "Dw", "D",
	]);

Is it as simple as just removing "Lw", "Bw" and "Dw" from this array or is more work involved?

EDIT: I noticed there's the same issue with L moves for 2x2, and 3Lw/3Dw moves for 6x6

[lgarron]

Is it as simple as just removing "Lw", "Bw" and "Dw" from this array or is more work involved?

Well, the work involved would at least be determining if it's that simple. :P

4×4×4 still has performance issues, but removing those moves should be easy if we can determine that it doesn't cause a performance regression.

[Nogesma]

I just benchmarked the solver with and without wide LBD moves and there's unfortunately a regression.

Here's the benchmark:

use std::{hint::black_box, str::FromStr, time::Duration};

use criterion::{criterion_group, criterion_main, Criterion, SamplingMode};
use twips::scramble::{derive_scramble_for_event, DerivationSeed, Event};

// Generated randomly with `DerivationSeed::from_thread_rng()`
const SEEDS: &[&str] = &[
    "67ffb1b6264c1fb98a30d22b4024d18099cc1678aaa0d995ec5b94e4723582ae",
    "67ff335173b8de81e84d6f7cb0c73a468555c080727a41c315d12053fc72f072",
    "67ff421e3036174cd3d05f29ca5eb776da3b6e1f09042776d6a264ed051e9c86",
    "67ff6da8e32be39c519639824f7268097a2cf838cadc4e2bbd375f41bb331422",
    "67ff48d8d567c3ef7671e2d325ebf9d1ef88f1e0b5dccd2449ac8e97d6755383",
];

fn bench_444_scrambler_fixed_seed(c: &mut Criterion) {
    let mut group = c.benchmark_group("derive_scramble_444");
    group.sampling_mode(SamplingMode::Flat);
    group.sample_size(2);
    group.warm_up_time(Duration::from_millis(500));

    for (i, seed_hex) in SEEDS.iter().enumerate() {
        let derivation_seed = DerivationSeed::from_str(seed_hex).unwrap();

        group.bench_function(format!("seed_{i}"), |b| {
            b.iter(|| {
                black_box(
                    derive_scramble_for_event(Event::Cube4x4x4Speedsolving, derivation_seed)
                        .unwrap(),
                )
            });
        });
    }

    group.finish();
}

criterion_group!(benches, bench_444_scrambler_fixed_seed);
criterion_main!(benches);

And the results:
All moves:

derive_scramble_444/seed_0
                        time:   [21.255 s 21.311 s 21.397 s]
derive_scramble_444/seed_1
                        time:   [4.5261 s 4.5401 s 4.5541 s]
derive_scramble_444/seed_2
                        time:   [33.459 s 33.544 s 33.630 s]
derive_scramble_444/seed_3
                        time:   [15.252 s 15.287 s 15.322 s]
derive_scramble_444/seed_4
                        time:   [63.422 s 63.556 s 63.726 s]

And without wide LBD:

derive_scramble_444/seed_0
                        time:   [25.052 s 25.160 s 25.270 s]
                        change: [+17.359% +18.060% +18.718%] (p = 0.00 < 0.05)
                        Performance has regressed.
derive_scramble_444/seed_1
                        time:   [8.3881 s 8.5626 s 8.7598 s]
                        change: [+84.460% +88.600% +92.884%] (p = 0.00 < 0.05)
                        Performance has regressed.
derive_scramble_444/seed_2
                        time:   [33.280 s 33.333 s 33.390 s]
                        change: [−0.9308% −0.6279% −0.3222%] (p = 0.00 < 0.05)
                        Change within noise threshold.
derive_scramble_444/seed_3
                        time:   [95.532 s 95.750 s 95.977 s]
                        change: [+524.37% +526.35% +528.44%] (p = 0.00 < 0.05)
                        Performance has regressed.
derive_scramble_444/seed_4
                        time:   [24.553 s 24.653 s 24.772 s]
                        change: [−61.406% −61.211% −60.982%] (p = 0.00 < 0.05)
                        Performance has improved.

As it's a pretty heavy regression in most cases, I just added a function in my code to convert those LBD moves to RUF outside of twips.