lean_problems/Y2023.lean

/-
Copyright (c) 2026 Humanize/Codex. All rights reserved.
Released under Apache 2.0 license as described in the file LICENSE.
Authors: Humanize/Codex
-/
import Mathlib

/-!
Algebraic answer claims for the IPhO 2023 theory problems. The definitions
below isolate the official closed-form expressions; the named theorems expose
one answer statement for each requested subquestion.
-/

open scoped BigOperators

namespace Ipho20212023Archon.Problems.Y2023

noncomputable section

section Problem1

def brownianInitialVelocity (I0 M : ℝ) : ℝ := I0 / M

def brownianRelaxationTime (M gamma : ℝ) : ℝ := M / gamma

theorem IPhO_2023_1_A_1 (I0 M gamma : ℝ) :
    (brownianInitialVelocity I0 M, brownianRelaxationTime M gamma) =
      (I0 / M, M / gamma) := by
  sorry

def collisionVelocity {ι : Type*} (s : Finset ι) (impulse time : ι → ℝ)
    (M tau t : ℝ) : ℝ :=
  ∑ i ∈ s, impulse i / M * Real.exp (-(t - time i) / tau)

def collisionTimeInRange (t ti : ℝ) : Prop := 0 < ti ∧ ti < t

theorem IPhO_2023_1_A_2 {ι : Type*} (s : Finset ι) (impulse time : ι → ℝ)
    (M tau t : ℝ) :
    collisionVelocity s impulse time M tau t =
        ∑ i ∈ s, impulse i / M * Real.exp (-(t - time i) / tau) ∧
      (∀ i, collisionTimeInRange t (time i) ↔ 0 < time i ∧ time i < t) := by
  sorry

def brownianMeanDisplacement : ℝ := 0

def discreteMeanSquareDisplacement (N : ℕ) (C delta : ℝ) : ℝ :=
  (N : ℝ) * C * delta ^ 2

def brownianMeanSquareDisplacement (C delta t : ℝ) : ℝ := C * delta * t

theorem IPhO_2023_1_B_1 (N : ℕ) (C delta t : ℝ)
    (ht : t = (N : ℝ) * delta) :
    brownianMeanDisplacement = 0 ∧
      discreteMeanSquareDisplacement N C delta = brownianMeanSquareDisplacement C delta t := by
  sorry

def velocityVarianceDeltaExponent : ℤ := -1

def meanSquareTimeExponent : ℤ := 1

theorem IPhO_2023_1_B_2 :
    (velocityVarianceDeltaExponent, meanSquareTimeExponent) = (-1, 1) := by
  sorry

def positiveCrossingRate (n0 dn v delta : ℝ) : ℝ :=
  ((1 : ℝ) / 2) * n0 * v - ((1 : ℝ) / 4) * dn * v ^ 2 * delta

theorem IPhO_2023_1_C_1 (n0 dn v delta : ℝ) :
    positiveCrossingRate n0 dn v delta =
      ((1 : ℝ) / 2) * n0 * v - ((1 : ℝ) / 4) * dn * v ^ 2 * delta := by
  sorry

def negativeCrossingRate (n0 dn v delta : ℝ) : ℝ :=
  ((1 : ℝ) / 2) * n0 * v + ((1 : ℝ) / 4) * dn * v ^ 2 * delta

def diffusionFlux (C delta dn : ℝ) : ℝ := -((1 : ℝ) / 2) * dn * C * delta

def diffusionCoefficient (C delta : ℝ) : ℝ := ((1 : ℝ) / 2) * C * delta

theorem IPhO_2023_1_C_2 (C delta dn t : ℝ) :
    diffusionFlux C delta dn = -((1 : ℝ) / 2) * dn * C * delta ∧
      diffusionCoefficient C delta = ((1 : ℝ) / 2) * C * delta ∧
        brownianMeanSquareDisplacement C delta t = 2 * diffusionCoefficient C delta * t := by
  sorry

def electricConcentrationGradient (n kT Q E : ℝ) : ℝ := n / kT * Q * E

theorem IPhO_2023_1_C_3 (n kT Q E : ℝ) :
    electricConcentrationGradient n kT Q E = n / kT * Q * E := by
  sorry

def meanElectrophoreticVelocity (Q E gamma tau t : ℝ) : ℝ :=
  Q * E / gamma * (1 - Real.exp (-t / tau))

def electrophoreticDrift (Q E gamma : ℝ) : ℝ := Q * E / gamma

theorem IPhO_2023_1_C_4 (Q E gamma tau t : ℝ) :
    (meanElectrophoreticVelocity Q E gamma tau t, electrophoreticDrift Q E gamma) =
      (Q * E / gamma * (1 - Real.exp (-t / tau)), Q * E / gamma) := by
  sorry

def einsteinDiffusion (kT gamma : ℝ) : ℝ := kT / gamma

theorem IPhO_2023_1_C_5 (kT gamma : ℝ) :
    einsteinDiffusion kT gamma = kT / gamma := by
  sorry

def meanSquareAvogadroRelation (R T deltaT a eta NA : ℝ) : ℝ :=
  R * T * deltaT / (3 * Real.pi * a * eta * NA)

def avogadroFromMSD (R T deltaT a eta msd : ℝ) : ℝ :=
  R * T * deltaT / (3 * Real.pi * a * eta * msd)

def avogadroEstimate : ℝ := ((56 : ℝ) / 10) * (10 : ℝ) ^ 23

theorem IPhO_2023_1_D_1 (R T deltaT a eta NA msd : ℝ) :
    meanSquareAvogadroRelation R T deltaT a eta NA =
        R * T * deltaT / (3 * Real.pi * a * eta * NA) ∧
      avogadroFromMSD R T deltaT a eta msd =
        R * T * deltaT / (3 * Real.pi * a * eta * msd) ∧
        avogadroEstimate = ((56 : ℝ) / 10) * (10 : ℝ) ^ 23 := by
  sorry

def driftDiffusionMSD (u D t : ℝ) : ℝ := (u * t) ^ 2 + 2 * D * t

def driftDiffusionCrossoverTime (D u : ℝ) : ℝ := 2 * D / u ^ 2

theorem IPhO_2023_1_D_2 (u D t : ℝ) :
    (driftDiffusionMSD u D t, driftDiffusionCrossoverTime D u) =
      ((u * t) ^ 2 + 2 * D * t, 2 * D / u ^ 2) := by
  sorry

def runTumbleSmallMSD (D t : ℝ) : ℝ := 2 * D * t

def runTumbleIntermediateMSD (u0 t : ℝ) : ℝ := u0 ^ 2 * t ^ 2

def runTumbleLargeMSD (u0 delta0 t : ℝ) : ℝ := u0 ^ 2 * delta0 * t

theorem IPhO_2023_1_D_3 (D u0 delta0 t : ℝ) :
    (runTumbleSmallMSD D t, runTumbleIntermediateMSD u0 t,
        runTumbleLargeMSD u0 delta0 t) =
      (2 * D * t, u0 ^ 2 * t ^ 2, u0 ^ 2 * delta0 * t) := by
  sorry

def criticalCoagulationConcentration (B eps kT NA A q : ℝ) : ℝ :=
  8 * B ^ 2 * eps ^ 3 * kT ^ 5 / (Real.exp 4 * NA * A ^ 2 * q ^ 6)

theorem IPhO_2023_1_E_1 (B eps kT NA A q : ℝ) :
    criticalCoagulationConcentration B eps kT NA A q =
      8 * B ^ 2 * eps ^ 3 * kT ^ 5 / (Real.exp 4 * NA * A ^ 2 * q ^ 6) := by
  sorry

end Problem1

section Problem2

def symmetricNucleusOptimalA (aS aC : ℝ) : ℝ := 2 * aS / aC

def symmetricNucleusOptimalARounded : ℕ := 50

theorem IPhO_2023_2_A_1 (aS aC : ℝ) :
    (symmetricNucleusOptimalA aS aC, symmetricNucleusOptimalARounded) =
      (2 * aS / aC, 50) := by
  sorry

def massNumberTwoThirds (A : ℝ) : ℝ := Real.rpow A ((2 : ℝ) / 3)

def mostStableAtomicNumber (A aC asym : ℝ) : ℝ :=
  (A / 2) / (1 + aC / (4 * asym) * massNumberTwoThirds A)

def goldStableAtomicNumberEstimate : ℕ := 79

theorem IPhO_2023_2_A_2 (A aC asym : ℝ) :
    (mostStableAtomicNumber A aC asym, goldStableAtomicNumberEstimate) =
      ((A / 2) / (1 + aC / (4 * asym) * Real.rpow A ((2 : ℝ) / 3)), 79) := by
  sorry

def symmetricFissionCoefficient : ℝ :=
  (Real.rpow (2 : ℝ) ((1 : ℝ) / 3) - 1) /
    (1 - Real.rpow (2 : ℝ) (-(2 : ℝ) / 3))

def symmetricFissionCoefficientTwoSig : ℝ := (7 : ℝ) / 10

theorem IPhO_2023_2_A_3 :
    (symmetricFissionCoefficient, symmetricFissionCoefficientTwoSig) =
      ((Real.rpow (2 : ℝ) ((1 : ℝ) / 3) - 1) /
          (1 - Real.rpow (2 : ℝ) (-(2 : ℝ) / 3)), (7 : ℝ) / 10) := by
  sorry

def neutronStarGravityCoefficient (hbarc mN R0 MP : ℝ) : ℝ :=
  ((3 : ℝ) / 5) * hbarc * mN ^ 2 / (R0 * MP ^ 2)

def neutronStarCriticalMassNumber (aV asym agrav : ℝ) : ℝ :=
  Real.rpow ((asym - aV) / agrav) ((3 : ℝ) / 2)

def neutronStarGravityCoefficientEstimate : ℝ := (6 : ℝ) / (10 : ℝ) ^ 37

def neutronStarCriticalMassNumberEstimate : ℝ := (4 : ℝ) * (10 : ℝ) ^ 55

theorem IPhO_2023_2_B_1 (hbarc mN R0 MP aV asym agrav : ℝ) :
    neutronStarGravityCoefficient hbarc mN R0 MP =
        ((3 : ℝ) / 5) * hbarc * mN ^ 2 / (R0 * MP ^ 2) ∧
      neutronStarCriticalMassNumber aV asym agrav =
        Real.rpow ((asym - aV) / agrav) ((3 : ℝ) / 2) ∧
        (neutronStarGravityCoefficientEstimate, neutronStarCriticalMassNumberEstimate) =
          ((6 : ℝ) / (10 : ℝ) ^ 37, (4 : ℝ) * (10 : ℝ) ^ 55) := by
  sorry

def freeFallClockFactor (dphi c : ℝ) : ℝ := 1 - dphi / c ^ 2

def freeFallClockDelay (dphi c tauI : ℝ) : ℝ := freeFallClockFactor dphi c * tauI

theorem IPhO_2023_2_C_1 (dphi c tauI : ℝ) :
    freeFallClockDelay dphi c tauI = (1 - dphi / c ^ 2) * tauI := by
  sorry

def shapiroDelay (G MWD c xN xE d : ℝ) : ℝ :=
  2 * G * MWD / c ^ 3 * Real.log (4 * |xN| * xE / d ^ 2)

theorem IPhO_2023_2_C_2 (G MWD c xN xE d : ℝ) :
    shapiroDelay G MWD c xN xE d =
      2 * G * MWD / c ^ 3 * Real.log (4 * |xN| * xE / d ^ 2) := by
  sorry

def shapiroDelaySwing (G MWD c eps : ℝ) : ℝ :=
  2 * G * MWD / c ^ 3 * Real.log (4 / eps ^ 2)

theorem IPhO_2023_2_C_3 (G MWD c eps : ℝ) :
    shapiroDelaySwing G MWD c eps =
      2 * G * MWD / c ^ 3 * Real.log (4 / eps ^ 2) := by
  sorry

def whiteDwarfMassRatioEstimate : ℝ := (1 : ℝ) / 2

theorem IPhO_2023_2_C_4 :
    whiteDwarfMassRatioEstimate = (1 : ℝ) / 2 := by
  sorry

def keplerAngularFrequencyExponent : ℝ := -(3 : ℝ) / 2

theorem IPhO_2023_2_C_5 :
    keplerAngularFrequencyExponent = -(3 : ℝ) / 2 := by
  sorry

inductive WaveProfile
  | a
  | b
  | c
  deriving DecidableEq, Repr

def chosenGravitationalWaveProfile : WaveProfile := WaveProfile.b

theorem IPhO_2023_2_C_6 :
    chosenGravitationalWaveProfile = WaveProfile.b := by
  sorry

end Problem2

section Problem3

def dropSurfaceEnergy (a gamma : ℝ) : ℝ := 4 * Real.pi * a ^ 2 * gamma

def mergedDropEnergyDifference (a gamma : ℝ) : ℝ :=
  4 * Real.pi * (2 - Real.rpow (2 : ℝ) ((2 : ℝ) / 3)) * a ^ 2 * gamma

def mergedDropMass (a rho : ℝ) : ℝ := 8 * Real.pi * a ^ 3 * rho / 3

def mergedDropJumpSpeedSquared (k gamma rho a : ℝ) : ℝ :=
  3 * (2 - Real.rpow (2 : ℝ) ((2 : ℝ) / 3)) * k * gamma / (rho * a)

def mergedDropJumpSpeed (k gamma rho a : ℝ) : ℝ :=
  Real.sqrt (mergedDropJumpSpeedSquared k gamma rho a)

def mergedDropJumpSpeedEstimate : ℝ := (23 : ℝ) / 100

theorem IPhO_2023_3_A_1 (a gamma k rho : ℝ) :
    mergedDropEnergyDifference a gamma =
        4 * Real.pi * (2 - Real.rpow (2 : ℝ) ((2 : ℝ) / 3)) * a ^ 2 * gamma ∧
      mergedDropMass a rho = 8 * Real.pi * a ^ 3 * rho / 3 ∧
        (mergedDropJumpSpeed k gamma rho a, mergedDropJumpSpeedEstimate) =
          (Real.sqrt (3 * (2 - Real.rpow (2 : ℝ) ((2 : ℝ) / 3)) *
            k * gamma / (rho * a)), (23 : ℝ) / 100) := by
  sorry

def hydrostaticPressure (P0 rho g z : ℝ) : ℝ := P0 - rho * g * z

theorem IPhO_2023_3_B_1 (P0 rho g z : ℝ) :
    hydrostaticPressure P0 rho g z = P0 - rho * g * z := by
  sorry

def horizontalPressureForce (rho g z1 z2 : ℝ) : ℝ :=
  ((1 : ℝ) / 2) * rho * g * (z2 ^ 2 - z1 ^ 2)

theorem IPhO_2023_3_B_2 (rho g z1 z2 : ℝ) :
    horizontalPressureForce rho g z1 z2 =
      ((1 : ℝ) / 2) * rho * g * (z2 ^ 2 - z1 ^ 2) := by
  sorry

def surfaceTensionHorizontalForce (gamma theta1 theta2 : ℝ) : ℝ :=
  gamma * Real.cos theta1 - gamma * Real.cos theta2

theorem IPhO_2023_3_B_3 (gamma theta1 theta2 : ℝ) :
    surfaceTensionHorizontalForce gamma theta1 theta2 =
      gamma * Real.cos theta1 - gamma * Real.cos theta2 := by
  sorry

def capillaryConservedQuantity (rho g gamma z theta : ℝ) : ℝ :=
  ((1 : ℝ) / 2) * rho * g * z ^ 2 + gamma * Real.cos theta

def capillaryDimensionlessExponent : ℕ := 2

def capillaryLength (gamma rho g : ℝ) : ℝ := Real.sqrt (gamma / (rho * g))

theorem IPhO_2023_3_B_4 (rho g gamma z theta : ℝ) :
    (capillaryConservedQuantity rho g gamma z theta, capillaryDimensionlessExponent,
        capillaryLength gamma rho g) =
      (((1 : ℝ) / 2) * rho * g * z ^ 2 + gamma * Real.cos theta, 2,
        Real.sqrt (gamma / (rho * g))) := by
  sorry

def capillarySurfaceSmallSlope (ell theta0 x : ℝ) : ℝ :=
  -ell * Real.tan theta0 * Real.exp (-x / ell)

theorem IPhO_2023_3_B_5 (ell theta0 x : ℝ) :
    capillarySurfaceSmallSlope ell theta0 x =
      -ell * Real.tan theta0 * Real.exp (-x / ell) := by
  sorry

def rodHorizontalForce (rho g gamma za zb thetaA thetaB : ℝ) : ℝ :=
  ((1 : ℝ) / 2) * rho * g * (zb ^ 2 - za ^ 2) +
    gamma * (Real.cos thetaB - Real.cos thetaA)

theorem IPhO_2023_3_C_1 (rho g gamma za zb thetaA thetaB : ℝ) :
    rodHorizontalForce rho g gamma za zb thetaA thetaB =
      ((1 : ℝ) / 2) * rho * g * (zb ^ 2 - za ^ 2) +
        gamma * (Real.cos thetaB - Real.cos thetaA) := by
  sorry

def rodAttractionForce (rho g z0 : ℝ) : ℝ := -((1 : ℝ) / 2) * rho * g * z0 ^ 2

theorem IPhO_2023_3_C_2 (rho g z0 : ℝ) :
    rodAttractionForce rho g z0 = -((1 : ℝ) / 2) * rho * g * z0 ^ 2 := by
  sorry

def midpointHeightBetweenRods (za xa ell : ℝ) : ℝ :=
  2 * za / (Real.exp (xa / ell) + Real.exp (-xa / ell))

theorem IPhO_2023_3_C_3 (za xa ell : ℝ) :
    midpointHeightBetweenRods za xa ell =
      2 * za / (Real.exp (xa / ell) + Real.exp (-xa / ell)) := by
  sorry

end Problem3

end

end Ipho20212023Archon.Problems.Y2023