/**
 * ConjectureGenerator is the GENERATE leg of the conjecture engine: instead of
 * a hand-coded one-off candidate, it emits a *parametric family* of
 * `GeometryConjectureCandidate`s across a swept parameter. A conjecture is then
 * evaluated over the whole family — it survives only if every generated member
 * passes, and a falsifier identifies the exact parameter value that broke the
 * invariant. This is the "discover" leg: the machine generates the candidates
 * and discovers the falsifying parameter, rather than a human supplying one.
 *
 * Receipt-carrying geometry (deterministic invariant probes), NOT a Lean proof.
 */
import type { GeometryConjectureCandidate } from './ConjectureEngine';
export interface RegularPolygonSheetFamilyOptions {
    /** Smallest polygon (inclusive). Must be >= 3. Default 3. */
    minSides?: number;
    /** Largest polygon (inclusive). Default 8. */
    maxSides?: number;
    /** Circumradius of each generated polygon. Default 1. */
    radius?: number;
}
export interface CollapsingTriangleFamilyOptions {
    /** Number of swept steps (inclusive endpoints). Must be >= 2. Default 6. */
    steps?: number;
    /** Apex height at the first step. Default 1. */
    startHeight?: number;
    /** Apex height at the final step. Default 0 (collinear/degenerate). */
    endHeight?: number;
}
export interface SharedEdgeFanFamilyOptions {
    /** Largest blade count (inclusive). Must be >= 1. Default 4. */
    maxBlades?: number;
}
export interface CollisionEquivalenceFamilyOptions {
    /** Rotation sweep in degrees. Default [0, 45]. */
    rotationsDegrees?: ReadonlyArray<number>;
    /** Half-width/half-height of the generated quad before rotation. Default 1. */
    halfExtent?: number;
}
export interface CurvatureConeFamilyOptions {
    /** Cone/bipyramid apex-height sweep. Default [0.5, 2]. */
    apexHeights?: ReadonlyArray<number>;
    /** Number of vertices around the equator. Must be >= 3. Default 8. */
    sides?: number;
    /** Equator radius. Default 1. */
    radius?: number;
}
export interface TraitSumGeometryFamilyOptions {
    source?: string;
}
/**
 * Fan-triangulated regular polygon disk (one center vertex + `sides` boundary
 * vertices, `sides` triangles). For any `sides >= 3` this is an open disk:
 * V = sides + 1, E = 2*sides, F = sides  =>  Euler characteristic = 1.
 */
export declare function regularPolygonSheetCandidate(sides: number, options?: {
    id?: string;
    radius?: number;
}): GeometryConjectureCandidate;
/**
 * Generate a swept family of regular polygon sheets for sides in
 * [minSides, maxSides]. Conjecture under test: "every generated regular-polygon
 * sheet is non-degenerate and has Euler characteristic 1."
 */
export declare function generateRegularPolygonSheetFamily(options?: RegularPolygonSheetFamilyOptions): ReadonlyArray<GeometryConjectureCandidate>;
/**
 * Lower language-level additive trait sums from .hsplus into candidate
 * alternatives. This is the Conjecture Engine "discover" bridge: alternatives
 * come from the parsed AST instead of a hand-written parametric loop.
 */
export declare function generateTraitSumGeometryFamily(options?: TraitSumGeometryFamilyOptions): ReadonlyArray<GeometryConjectureCandidate>;
/**
 * A single triangle whose apex height parameterizes its area. As `apexHeight`
 * approaches 0 the triangle collapses to a collinear (degenerate) primitive.
 */
export declare function collapsingTriangleCandidate(apexHeight: number, options?: {
    id?: string;
}): GeometryConjectureCandidate;
/**
 * Generate a swept family of triangles whose apex height descends from
 * `startHeight` to `endHeight`. Conjecture under test: "every generated
 * triangle in the sweep is non-degenerate." The sweep DISCOVERS the falsifying
 * apex height (the collinear member at height 0), so the counterexample carries
 * the exact parameter that broke the invariant.
 */
export declare function generateCollapsingTriangleFamily(options?: CollapsingTriangleFamilyOptions): ReadonlyArray<GeometryConjectureCandidate>;
/**
 * `blades` triangles all sharing one common edge (v0,v1), each with its own
 * apex placed around that edge. The shared edge has incidence == blades:
 * for blades <= 2 the surface is edge-manifold; for blades >= 3 it is NOT
 * (an edge shared by 3+ triangles is the canonical non-manifold defect).
 * Every triangle is non-degenerate, so the manifold probe is the only signal.
 */
export declare function sharedEdgeFanCandidate(blades: number, options?: {
    id?: string;
}): GeometryConjectureCandidate;
/**
 * Generate a swept family of shared-edge fans for blade counts 1..maxBlades.
 * Conjecture under test: "every generated shared-edge fan is edge-manifold."
 * The sweep DISCOVERS the manifoldness boundary — the first non-manifold member
 * is the 3-blade fan — so the counterexample carries the exact blade count that
 * broke the invariant.
 */
export declare function generateSharedEdgeFanFamily(options?: SharedEdgeFanFamilyOptions): ReadonlyArray<GeometryConjectureCandidate>;
/**
 * A quad whose rotation parameter determines whether its exact convex hull is
 * equivalent to its AABB collision proxy. At 0/90 degree rotations the proxies
 * agree; at 45 degrees the AABB over-approximates the hull, so swept points in
 * the AABB corners become deterministic counterexamples.
 */
export declare function collisionEquivalenceQuadCandidate(rotationDegrees: number, options?: {
    id?: string;
    halfExtent?: number;
}): GeometryConjectureCandidate;
/**
 * Generate a rotation sweep for the collision-equivalence invariant. The
 * default sweep intentionally includes one survivor (0 degrees) and one
 * falsifier (45 degrees) so the receipt preserves the discovered transform.
 */
export declare function generateCollisionEquivalenceFamily(options?: CollisionEquivalenceFamilyOptions): ReadonlyArray<GeometryConjectureCandidate>;
/**
 * A closed triangular bipyramid whose apex height controls discrete Gaussian
 * curvature. Low height spreads vertex angle around the apices and survives a
 * modest bound; high height sharpens the apices and becomes the falsifier.
 */
export declare function curvatureConeCandidate(apexHeight: number, options?: {
    id?: string;
    sides?: number;
    radius?: number;
}): GeometryConjectureCandidate;
/**
 * Generate a cone sharpness sweep for the curvature-bound invariant. The
 * default pair intentionally gives one gentle survivor and one sharp falsifier.
 */
export declare function generateCurvatureConeFamily(options?: CurvatureConeFamilyOptions): ReadonlyArray<GeometryConjectureCandidate>;
//# sourceMappingURL=ConjectureGenerator.d.ts.map