feat(periodic-search): make periodic search solver settings visible

Author: namvdo

frontend/src/Anton.tsx

@@ -27,6 +27,7 @@ import {
     shouldRecordTrajectoryHistoryPoint
 } from './utils/trajectoryState';
 import {
+    buildVerifiedBoundaryCycles,
     collectGeometricOffsetBoundaryPoints,
     collectExtendedManifoldBranches,
 } from './utils/geometricOffsetSeed';
@@ -497,11 +498,20 @@ const SetValuedViz = () => {
         [boundarySourceManifolds]
     );
 
-    const calculatedBoundaryBranches = useMemo(
-        () => collectExtendedManifoldBranches(boundarySourceManifolds),
+    const verifiedBoundaryCycles = useMemo(
+        () => buildVerifiedBoundaryCycles(boundarySourceManifolds),
         [boundarySourceManifolds]
     );
 
+    const calculatedBoundaryBranches = useMemo(
+        () => verifiedBoundaryCycles.length > 0
+            ? verifiedBoundaryCycles
+            : collectExtendedManifoldBranches(boundarySourceManifolds),
+        [boundarySourceManifolds, verifiedBoundaryCycles]
+    );
+
+    const hasVerifiedBoundaryCycles = verifiedBoundaryCycles.length > 0;
+
     const boundaryLayers = useMemo(() => {
         if (calculatedBoundaryBranches.length === 0) {
             return {
@@ -2478,6 +2488,7 @@ const SetValuedViz = () => {
                         3.4,
                         0.24,
                         'unstable-manifold',
+                        hasVerifiedBoundaryCycles,
                     );
                 }
             });
@@ -2498,6 +2509,7 @@ const SetValuedViz = () => {
                             2.6,
                             0.23,
                             'deterministic-image',
+                            hasVerifiedBoundaryCycles,
                         );
                     }
                 });
@@ -2806,7 +2818,7 @@ const SetValuedViz = () => {
             scene.add(sphere);
         }
 
-    }, [manifoldState, geometricOffsetState, bdeState, dynamicSystem, type, viewRange, readViewportSize, geometricOffsetBoundaryPoints, boundaryLayers, hasBoundarySamples, params.epsilon]);
+    }, [manifoldState, geometricOffsetState, bdeState, dynamicSystem, type, viewRange, readViewportSize, geometricOffsetBoundaryPoints, boundaryLayers, hasBoundarySamples, hasVerifiedBoundaryCycles, params.epsilon]);
 
     useEffect(() => {
         if (!sceneRef.current) return;

frontend/src/components/sidebar/PeriodicSearchPanel.test.tsx

@@ -80,6 +80,11 @@ describe('PeriodicSearchPanel', () => {
       thetaGridSize: 24,
       residualThreshold: 1e-10,
       useContinuation: false,
+      maxNewtonIterations: 100,
+      newtonBeta: null,
+      deduplicationTolerance: 1e-3,
+      supportFilterSubdivisions: 64,
+      supportThreshold: 1e-10,
     });
   });
 
@@ -113,4 +118,21 @@ describe('PeriodicSearchPanel', () => {
     const result = screen.getByLabelText('Current periodic orbit result configuration');
     expect(result).toHaveTextContent('ε = 0.0625; P ≤ 4, 8 × 8 positions, 12 angles, tolerance 1e-9');
   });
+
+  it('allows configuring advanced solver settings', () => {
+    const onUpdate = vi.fn();
+    render(<PeriodicSearchPanel {...baseProps} updatePeriodicSearchSettings={onUpdate} />);
+
+    fireEvent.change(screen.getByLabelText('Max Newton iterations'), { target: { value: '250' } });
+    expect(onUpdate).toHaveBeenCalledWith({ maxNewtonIterations: 250 });
+
+    fireEvent.change(screen.getByLabelText('Damping β (Davidchack-Lai)'), { target: { value: '1.5' } });
+    expect(onUpdate).toHaveBeenCalledWith({ newtonBeta: 1.5 });
+
+    fireEvent.change(screen.getByLabelText('Damping β (Davidchack-Lai)'), { target: { value: 'auto' } });
+    expect(onUpdate).toHaveBeenCalledWith({ newtonBeta: null });
+
+    fireEvent.change(screen.getByLabelText('Deduplication tolerance'), { target: { value: '1e-4' } });
+    expect(onUpdate).toHaveBeenCalledWith({ deduplicationTolerance: 1e-4 });
+  });
 });

frontend/src/components/sidebar/PeriodicSearchPanel.tsx

@@ -67,6 +67,25 @@ export const PeriodicSearchPanel = ({
     updatePeriodicSearchSettings?.({ useContinuation: value });
   };
 
+  const updateMaxNewtonIterations = (e: ChangeEvent<HTMLInputElement>): void => {
+    const val = parseInt(e.target.value, 10);
+    updatePeriodicSearchSettings?.({ maxNewtonIterations: Number.isFinite(val) ? val : 100 });
+  };
+
+  const updateNewtonBeta = (e: ChangeEvent<HTMLInputElement>): void => {
+    const raw = e.target.value.trim();
+    if (raw === '' || raw.toLowerCase() === 'auto') {
+      updatePeriodicSearchSettings?.({ newtonBeta: null });
+    } else {
+      const val = parseFloat(raw);
+      updatePeriodicSearchSettings?.({ newtonBeta: Number.isFinite(val) ? val : null });
+    }
+  };
+
+  const updateDeduplicationTolerance = (e: ChangeEvent<HTMLInputElement>): void => {
+    updatePeriodicSearchSettings?.({ deduplicationTolerance: Number(e.target.value) });
+  };
+
   const seedCount = estimatePeriodicGridSeedCount(
     maxPeriod,
     periodicSearchSettings.gridSize,
@@ -177,6 +196,51 @@ export const PeriodicSearchPanel = ({
         <div><span>Newton starts</span><strong>{seedCount.toLocaleString()}</strong></div>
       </div>
 
+      <Collapsible title="Advanced solver settings" defaultOpen={false}>
+        <div className="periodic-search-grid">
+          <div className="start-field">
+            <label htmlFor="periodic-max-iterations">Max Newton iterations</label>
+            <input
+              id="periodic-max-iterations"
+              type="number"
+              min="10"
+              max="1000"
+              step="10"
+              value={periodicSearchSettings?.maxNewtonIterations ?? 100}
+              onChange={updateMaxNewtonIterations}
+              disabled={disabled}
+            />
+            <small>Steps per seed before giving up</small>
+          </div>
+          <div className="start-field">
+            <label htmlFor="periodic-newton-beta">Damping β (Davidchack-Lai)</label>
+            <input
+              id="periodic-newton-beta"
+              type="text"
+              placeholder="Auto (15·1.3^p)"
+              value={periodicSearchSettings?.newtonBeta !== null && periodicSearchSettings?.newtonBeta !== undefined ? periodicSearchSettings.newtonBeta : ''}
+              onChange={updateNewtonBeta}
+              disabled={disabled}
+            />
+            <small>0 for pure Newton; leave blank for Auto</small>
+          </div>
+          <div className="start-field">
+            <label htmlFor="periodic-dedup-tolerance">Deduplication tolerance</label>
+            <input
+              id="periodic-dedup-tolerance"
+              type="number"
+              min="1e-6"
+              max="1e-1"
+              step="any"
+              value={periodicSearchSettings?.deduplicationTolerance ?? 1e-3}
+              onChange={updateDeduplicationTolerance}
+              disabled={disabled}
+            />
+            <small>Cluster radius to merge duplicate orbits</small>
+          </div>
+        </div>
+      </Collapsible>
+
       <Toggle
         label="Use cached-orbit continuation on ordinary compute"
         checked={Boolean(periodicSearchSettings?.useContinuation)}

frontend/src/components/ui/Collapsible.tsx

@@ -4,14 +4,20 @@ interface CollapsibleProps {
   title: string;
   children: ReactNode;
   defaultOpen?: boolean;
+  className?: string;
 }
 
-export const Collapsible = ({ title, children, defaultOpen = true }: CollapsibleProps) => {
+export const Collapsible = ({
+  title,
+  children,
+  defaultOpen = true,
+  className = '',
+}: CollapsibleProps) => {
   const [isOpen, setIsOpen] = useState(defaultOpen);
   const panelId = `section-${title.toLowerCase().replace(/[^a-z0-9]+/g, '-')}`;
 
   return (
-    <div className={`section ${isOpen ? 'open' : ''}`}>
+    <div className={`section ${isOpen ? 'open' : ''} ${className}`.trim()}>
       <button
         type="button"
         className="sec-head"

frontend/src/compute.worker.ts

@@ -262,10 +262,13 @@ const computePeriodic = async (payload: PeriodicComputePayload): Promise<Periodi
     let support = null;
 
     if (dynamicSystem === 'henon') {
+      const supportSubdivisions = periodicSearchSettings.supportFilterSubdivisions ?? MIS_FILTER_SUBDIVISIONS;
+      const supportThreshold = periodicSearchSettings.supportThreshold ?? MIS_SUPPORT_THRESHOLD;
+
       supportComputer = new wasm.UlamComputer(
         params.a,
         params.b,
-        MIS_FILTER_SUBDIVISIONS,
+        supportSubdivisions,
         MIS_FILTER_POINTS_PER_BOX,
         params.epsilon,
         viewRange.xMin,
@@ -276,12 +279,12 @@ const computePeriodic = async (payload: PeriodicComputePayload): Promise<Periodi
 
       support = {
         invariantMeasure: supportComputer.get_invariant_measure() as number[],
-        subdivisions: MIS_FILTER_SUBDIVISIONS,
+        subdivisions: supportSubdivisions,
         xMin: viewRange.xMin,
         xMax: viewRange.xMax,
         yMin: viewRange.yMin,
         yMax: viewRange.yMax,
-        threshold: MIS_SUPPORT_THRESHOLD
+        threshold: supportThreshold
       };
 
       orbits = filterOrbitsBySupport(orbits, support);

frontend/src/index.css

@@ -296,12 +296,32 @@ select:disabled { cursor: not-allowed; }
   transition: transform .18s;
   color: var(--text-3);
 }
-.section.open .sec-caret { transform: rotate(90deg); }
+.section.open > .sec-head .sec-caret { transform: rotate(90deg); }
 .sec-body {
   padding: 2px 14px 14px;
   display: none;
 }
-.section.open .sec-body { display: block; }
+.section.open > .sec-body { display: block; }
+
+/* Sub-collapsible inside sections */
+.section .section {
+  border: 1px solid var(--line);
+  border-radius: 6px;
+  margin: 10px 0;
+  background: rgba(255, 255, 255, 0.015);
+}
+.section .section .sec-head {
+  min-height: 36px;
+  padding: 8px 12px;
+}
+.section .section .sec-title {
+  font-size: 11px;
+  font-weight: 650;
+  color: var(--text-2);
+}
+.section .section .sec-body {
+  padding: 8px 12px 12px;
+}
 
 /* ─── Param row ─────────────────────────────────────── */
 .p-row { margin-bottom: 13px; }

frontend/src/test/PeriodicSearchSettings.test.tsx

@@ -57,11 +57,37 @@ describe('normalizePeriodicSearchSettings', () => {
       thetaGridSize: 12,
       residualThreshold: 1e-9,
       useContinuation: true,
+      maxNewtonIterations: 200,
+      newtonBeta: 2.5,
+      deduplicationTolerance: 5e-4,
+      supportFilterSubdivisions: 32,
+      supportThreshold: 1e-8,
     })).toEqual({
       gridSize: 16,
       thetaGridSize: 12,
       residualThreshold: 1e-9,
       useContinuation: false,
+      maxNewtonIterations: 200,
+      newtonBeta: 2.5,
+      deduplicationTolerance: 5e-4,
+      supportFilterSubdivisions: 32,
+      supportThreshold: 1e-8,
     });
   });
+
+  it('normalizes advanced solver parameters within valid bounds', () => {
+    const normalized = normalizePeriodicSearchSettings({
+      maxNewtonIterations: 5,
+      newtonBeta: -10,
+      deduplicationTolerance: 1e-8,
+      supportFilterSubdivisions: 512,
+      supportThreshold: 0,
+    });
+
+    expect(normalized.maxNewtonIterations).toBe(10);
+    expect(normalized.newtonBeta).toBe(0);
+    expect(normalized.deduplicationTolerance).toBe(1e-6);
+    expect(normalized.supportFilterSubdivisions).toBe(256);
+    expect(normalized.supportThreshold).toBe(1e-10);
+  });
 });

frontend/src/types/domain.ts

@@ -69,6 +69,11 @@ export interface PeriodicSearchSettings {
   thetaGridSize: number;
   residualThreshold: number;
   useContinuation: boolean;
+  maxNewtonIterations?: number;
+  newtonBeta?: number | null;
+  deduplicationTolerance?: number;
+  supportFilterSubdivisions?: number;
+  supportThreshold?: number;
 }
 
 export interface PeriodicOrbit extends UnknownRecord {

frontend/src/utils/experimentBundle.ts

@@ -1215,6 +1215,11 @@ export const experimentConfigurationToUiState = (configuration: unknown) => {
       thetaGridSize: value.solvers.periodicSearch.thetaGridSize,
       residualThreshold: value.solvers.periodicSearch.residualThreshold,
       useContinuation: value.solvers.periodicSearch.useContinuation,
+      maxNewtonIterations: value.solvers.periodicSearch.maxNewtonIterations,
+      newtonBeta: value.solvers.periodicSearch.newtonBeta,
+      deduplicationTolerance: value.solvers.periodicSearch.deduplicationTolerance,
+      supportFilterSubdivisions: value.solvers.periodicSearch.supportFilterSubdivisions,
+      supportThreshold: value.solvers.periodicSearch.supportThreshold,
     },
     startPoint: cloneJsonValue(value.initialExtendedState),
     manifoldSettings: cloneJsonValue(value.solvers.manifold),

frontend/src/utils/geometricOffsetSeed.test.ts

@@ -93,6 +93,25 @@ describe('verified geometric-offset seed', () => {
     expect(buildVerifiedBoundaryCycle(manifolds)).toEqual([]);
   });
 
+  it('preserves two independent invariant lobes as separate verified cycles', () => {
+    const leftLower = [point(0, 0), point(0.5, -0.1), point(1, 0)];
+    const leftUpper = [point(1, 0.4), point(0.5, 0.5), point(0, 0.4)];
+    const rightLower = [point(2, 0), point(2.5, -0.1), point(3, 0)];
+    const rightUpper = [point(3, 0.4), point(2.5, 0.5), point(2, 0.4)];
+
+    const cycles = buildVerifiedBoundaryCycles([
+      arc(10, 11, leftLower),
+      arc(11, 10, leftUpper),
+      arc(20, 21, rightLower),
+      arc(21, 20, rightUpper),
+    ]);
+
+    expect(cycles).toEqual([
+      [...leftLower, ...leftUpper],
+      [...rightLower, ...rightUpper],
+    ]);
+  });
+
   it('keeps every calculated point without seed downsampling', () => {
     const upper = Array.from({ length: 2050 }, (_, index) => point(index / 2049, 0));
     const lower = Array.from({ length: 2050 }, (_, index) => point(1 - index / 2049, 1));