Blame for tests/test_geometry.py

import unittest

from hdc import crystal, fractal, manifold, state
from hdc.entropy import entropy_bits, entropic_octave, level_histogram, max_bits
from hdc.hypervec import hvc, sim
from hdc.shader import ShaderFabric
from hdc.shader3d import Volume, cube_volume
from hdc.shader4d import Volume4D, sweep_volume

D = 2000


def fabric():
    return ShaderFabric(d=D)


def solid(size=5, value=180):
    return Volume.from_levels(
        [[[value for _ in range(size)] for _ in range(size)] for _ in range(size)], fabric()
    )


class TestGeodesic(unittest.TestCase):
    def test_distance_is_manhattan_on_a_solid(self):
        vol = solid()
        self.assertEqual(manifold.geodesic_distance(vol, (0, 0, 0), (4, 4, 4)), 12)
        self.assertEqual(manifold.geodesic_distance(vol, (0, 0, 0), (0, 0, 4)), 4)

    def test_seed_is_distance_zero(self):
        vol = solid()
        field = manifold.geodesic_field(vol, (2, 2, 2))
        self.assertEqual(field.levels()[2][2][2], 0)
        # every voxel of a 5-cube is within 6 steps of the centre
        self.assertEqual(max(v for p in field.levels() for r in p for v in r), 6)

    def test_disconnected_returns_none(self):
        rows = [[[0] * 5 for _ in range(5)] for _ in range(5)]
        rows[0][0][0] = 180
        rows[4][4][4] = 180
        vol = Volume.from_levels(rows, fabric())
        self.assertIsNone(manifold.geodesic_distance(vol, (0, 0, 0), (4, 4, 4)))

    def test_empty_seed_is_all_unreached(self):
        vol = Volume.from_levels([[[0] * 3 for _ in range(3)] for _ in range(3)], fabric())
        field = manifold.geodesic_field(vol, (1, 1, 1))
        self.assertEqual(set(v for p in field.levels() for r in p for v in r), {255})


class TestCurvature(unittest.TestCase):
    def test_uniform_block_is_flat(self):
        vol = solid()
        self.assertEqual(set(v for p in manifold.curvature(vol).levels() for r in p for v in r), {128})
        self.assertEqual(max(v for p in manifold.laplacian(vol).levels() for r in p for v in r), 0)

    def test_hollow_shell_has_ridges_and_valleys(self):
        rows = [[[180 if (x in (0, 4) or y in (0, 4) or z in (0, 4)) else 0
                  for x in range(5)] for y in range(5)] for z in range(5)]
        vol = Volume.from_levels(rows, fabric())
        codes = [v for p in manifold.curvature(vol).levels() for r in p for v in r]
        self.assertIn(255, codes)
        self.assertIn(0, codes)

    def test_laplacian_detects_a_gap(self):
        rows = [[[100] * 5 for _ in range(5)] for _ in range(5)]
        rows[2][2][2] = 0
        vol = Volume.from_levels(rows, fabric())
        lap = manifold.laplacian(vol)
        self.assertEqual(lap.levels()[2][2][2], 600)  # six 100s, centre zero
        self.assertEqual(lap.levels()[2][2][1], 100)  # one missing neighbour

    def test_manifold_shade_equals_plain_shade_when_flat(self):
        vol = solid()
        self.assertEqual(manifold.manifold_shade(vol).levels(), vol.shade().levels())

    def test_manifold_shade_differs_where_curvature_is_nonzero(self):
        rows = [[[180] * 5 for _ in range(5)] for _ in range(5)]
        rows[2][2][2] = 0
        vol = Volume.from_levels(rows, fabric())
        self.assertNotEqual(manifold.manifold_shade(vol).levels(), vol.shade().levels())


class TestFractal(unittest.TestCase):
    def test_sierpinski_pattern_is_exact(self):
        img = fractal.sierpinski(3)
        levels = img.levels()
        self.assertEqual(len(levels), 8)
        for y in range(8):
            for x in range(8):
                self.assertEqual(levels[y][x], 255 if (x & y) == 0 else 0)

    def test_fbm_octaves_halve(self):
        img = fractal.fbm(16, 16, 4, 4, 7, fabric())
        peaks = fractal.octave_peaks(img)
        self.assertGreaterEqual(peaks[0], 200)
        for coarser, finer in zip(peaks, peaks[1:]):
            self.assertLessEqual(abs(finer - coarser // 2), 3, msg=str(peaks))

    def test_fbm_values_stay_in_range(self):
        levels = [v for row in fractal.fbm(12, 12, 3, 4, 7, fabric()).levels() for v in row]
        self.assertGreaterEqual(min(levels), 0)
        self.assertLessEqual(max(levels), 255)

    def test_fern_draws_something_inside_the_frame(self):
        levels = [v for row in fractal.fern(800, 20, 24, fabric()).levels() for v in row]
        self.assertGreater(sum(1 for v in levels if v), 20)

    def test_detail_keeps_the_base_at_least_as_bright(self):
        base = fractal.sierpinski(3, 200, fabric())
        out = fractal.detail(base, octaves=2, strength=1)
        for row_base, row_out in zip(base.levels(), out.levels()):
            for a, b in zip(row_base, row_out):
                self.assertGreaterEqual(b, a)


class TestCrystal(unittest.TestCase):
    def test_lattice_site_counts(self):
        self.assertEqual(len(crystal.lattice_sites(4, "cubic")), 64)
        self.assertEqual(len(crystal.lattice_sites(4, "hex")), 2 * 2 * 2 * 3)
        with self.assertRaises(ValueError):
            crystal.lattice_sites(4, "quasicrystal")

    def test_crystallize_covers_every_occupied_voxel(self):
        vol = solid(5)
        grains = crystal.crystallize(vol, [(0, 0, 0), (4, 4, 4)])
        levels = [v for p in grains.levels() for r in p for v in r]
        self.assertNotIn(255, levels)          # nothing left ungrown
        self.assertEqual(set(levels), {0, 1})   # every voxel took one of the two seeds

    def test_every_voxel_is_its_own_grain_when_seeded_everywhere(self):
        vol = solid(5)
        grains = crystal.crystallize(vol, crystal.lattice_sites(5, "cubic"))
        self.assertEqual(len(set(v for p in grains.levels() for r in p for v in r)), 125)

    def test_two_seeds_split_a_bar(self):
        rows = [[[100 if 1 <= x <= 6 else 0 for x in range(8)] for _ in range(3)] for _ in range(3)]
        vol = Volume.from_levels(rows, fabric())
        grains = crystal.crystallize(vol, [(1, 1, 1), (6, 1, 1)])
        left = grains.levels()[1][1][1]
        right = grains.levels()[1][1][6]
        self.assertNotEqual(left, right)
        walls = crystal.grain_boundaries(grains)
        self.assertEqual(walls.levels()[1][1][3] + walls.levels()[1][1][4], 255)

    def test_periodicity_recovers_a_two_plane_lattice(self):
        rows = [[[180 if x % 2 == 0 and 1 <= y <= 3 and 1 <= z <= 3 else 0
                  for x in range(8)] for y in range(5)] for z in range(5)]
        vol = Volume.from_levels(rows, fabric())
        spacing, score = crystal.periodicity(vol, axis=0)
        self.assertEqual(spacing, 2)
        self.assertGreater(score, 0.5)

    def test_uniform_volume_has_no_period(self):
        self.assertEqual(crystal.periodicity(solid(5), axis=0)[0], 0)

    def test_facet_histogram_covers_surface_codes_only(self):
        hist = crystal.facet_histogram(solid(5))
        self.assertTrue(hist)
        self.assertTrue(all(0 <= code <= 6 for code in hist))


class TestEntropy(unittest.TestCase):
    def test_flat_field_is_zero_bits(self):
        bits, counts = entropy_bits([100] * 8, 8, 0, 255, fabric())
        self.assertEqual(bits, 0.0)
        self.assertEqual(counts[3], 8)

    def test_two_values_is_one_bit(self):
        bits, _ = entropy_bits([0, 255] * 4, 8, 0, 255, fabric())
        self.assertAlmostEqual(bits, 1.0, places=6)

    def test_uniform_eight_bins_is_three_bits(self):
        bits, _ = entropy_bits([0, 32, 64, 96, 128, 160, 192, 255], 8, 0, 255, fabric())
        self.assertAlmostEqual(bits, 3.0, places=6)

    def test_single_bucket_histogram_has_no_entropy(self):
        self.assertEqual(level_histogram([7, 7, 7], 1, 0, 255, fabric()), [3])

    def test_octave_is_monotone_in_entropy(self):
        ceiling = max_bits(8)
        values = [entropic_octave(b, ceiling) for b in (0.0, 0.5, 1.0, 2.0, 3.0)]
        self.assertEqual(values, sorted(values, reverse=True))
        self.assertEqual(values[0], 4)
        self.assertEqual(values[-1], 0)


class TestVolume4D(unittest.TestCase):
    def setUp(self):
        self.vol = sweep_volume(step=4, size=5, value=200, fabric=fabric())

    def test_shape_and_slices(self):
        self.assertEqual((self.vol.w, self.vol.h, self.vol.depth, self.vol.u), (5, 5, 5, 4))
        self.assertEqual(self.vol.stat()["voxels"], 500)

    def test_slices_differ_and_drift_is_positive(self):
        self.assertNotEqual(self.vol.levels()[0], self.vol.levels()[1])
        self.assertGreater(self.vol.drift(), 0.0)

    def test_static_stack_has_zero_entropy_and_drift(self):
        block = [[[[180] * 4 for _ in range(3)] for _ in range(3)] for _ in range(3)]
        vol = Volume4D.from_levels(block, fabric())
        self.assertEqual(vol.drift(), 0.0)
        entropy = vol.entropy_along_u(8)
        self.assertEqual(max(v for p in entropy.levels() for r in p for v in r), 0)
        self.assertEqual(set(v for p in vol.entropic_octaves(8).levels() for r in p for v in r), {2})

    def test_eight_equally_likely_values_saturate_entropy(self):
        block = [
            [[[u * 32 for _ in range(2)] for _ in range(2)] for _ in range(2)]
            for u in range(8)
        ]
        vol = Volume4D.from_levels(block, fabric())
        entropy = vol.entropy_along_u(8)
        self.assertEqual(max(v for p in entropy.levels() for r in p for v in r), 255)

    def test_two_alternating_values_reach_one_third(self):
        block = [
            [[[0 if u % 2 else 255 for _ in range(2)] for _ in range(2)] for _ in range(2)]
            for u in range(4)
        ]
        vol = Volume4D.from_levels(block, fabric())
        entropy = vol.entropy_along_u(8)
        self.assertEqual(max(v for p in entropy.levels() for r in p for v in r), 85)

    def test_projection_collapses_u(self):
        projected = self.vol.project_u()
        self.assertEqual((projected.w, projected.h, projected.depth), (5, 5, 5))

    def test_entropic_shade_is_darker_than_plain_projection(self):
        plain = self.vol.project_u().shade()
        entropic = self.vol.shade_entropic()
        peak_plain = max(v for p in plain.levels() for r in p for v in r)
        peak_entropic = max(v for p in entropic.levels() for r in p for v in r)
        self.assertLessEqual(peak_entropic, peak_plain)


class TestPredictiveState(unittest.TestCase):
    def setUp(self):
        self.model, self.states, self.world = state.trained_model(8, D)

    def test_learned_transition_is_exact(self):
        for i, s in enumerate(self.states):
            predicted, confidence = self.model.predict(s, "next")
            self.assertEqual(predicted, self.states[(i + 1) % 8])
            self.assertGreater(confidence, 0.2)

    def test_unseen_action_predicts_nothing(self):
        self.assertEqual(self.model.predict(self.states[0], "jump"), (None, 0.0))

    def test_surprise_is_zero_when_the_model_is_right(self):
        surprise = self.model.surprise(self.states[0], "next", self.states[1])
        self.assertAlmostEqual(surprise, 0.0, places=6)

    def test_surprise_is_high_when_the_world_disagrees(self):
        surprise = self.model.surprise(self.states[0], "next", self.states[5])
        self.assertGreater(surprise, 0.9)

    def test_plan_finds_the_short_path(self):
        plan = self.model.plan(self.states[0], self.states[6], ["next", "prev"], horizon=4)
        self.assertEqual(plan["actions"], ["prev", "prev"])
        self.assertGreater(plan["expanded"], 0)

    def test_plan_to_current_state_is_empty(self):
        plan = self.model.plan(self.states[3], self.states[3], ["next", "prev"], horizon=2)
        self.assertEqual(plan["actions"], [])

    def test_agent_reaches_goal_and_reports_zero_loss(self):
        agent = state.StateAgent(self.model, ["next", "prev"], goal=self.states[6])
        episode = agent.run(self.states[0], lambda s, a: self.world[a](s), steps=4)
        self.assertEqual(len(episode), 2)
        self.assertAlmostEqual(agent.loss(), 0.0, places=6)

    def test_agent_learns_an_unmodelled_world(self):
        model = state.PredictiveModel(d=D, alphabet=self.states)
        agent = state.StateAgent(model, ["next"], goal=self.states[2])
        agent.run(self.states[0], lambda s, a: self.world[a](s), steps=3)
        # every step is a surprise the first time, then the model knows it
        self.assertGreater(agent.episode[0]["surprise"], 0.5)
        self.assertAlmostEqual(model.surprise(self.states[0], "next", self.states[1]), 0.0, places=6)


class TestSignedCompare(unittest.TestCase):
    def test_negative_is_less_than_zero(self):
        f = fabric()
        self.assertEqual(f.compare(f.sub(f.level(0), f.level(180)), f.level(0)), -1)
        self.assertEqual(f.compare(f.level(0), f.sub(f.level(0), f.level(180))), 1)


if __name__ == "__main__":
    unittest.main()