Finite-volume methods

The catalogue's first page explains what each entry shows.

Chapter 1 · Introduction all chapters

  • Result

    LeVeque's hyperbolicity definition is exactly the existence of m linearly independent corresponding real eigenvectors.

    Lean statement
    theorem leveque01_hyperbolicMatrixDefinition {m : ℕ}
        (coefficient : Matrix (Fin m) (Fin m) ℝ) :
        leveque01IsHyperbolicMatrix coefficient ↔
          ∃ (eigenvalues : Fin m → ℝ)
              (eigenvectors : Fin m → (Fin m → ℝ)),
            LinearIndependent ℝ eigenvectors ∧
              ∀ p, coefficient.mulVec (eigenvectors p) =
                eigenvalues p • eigenvectors p

    leveque01_hyperbolicMatrixDefinition

  • Result

    The Chapter 1 cell-average definition, with the nondegenerate-cell and Bochner-integrability assumptions made explicit.

    Lean statement
    theorem leveque01_finiteVolumeCellAverage_spec {m : ℕ}
        (state : ℝ → (Fin m → ℝ)) {left right : ℝ}
        (hcell : left < right)
        (hstate : IntervalIntegrable state MeasureTheory.volume left right) :
        IsOneDimensionalCellAverage state left right
          (leveque01_finiteVolumeCellAverage state left right)

    leveque01_finiteVolumeCellAverage_spec

  • Result

    Local normalized reference averages, numerical flux update, and conditional error control.

    Lean statement
    theorem leveque01_finiteVolumeLocalFluxUpdate_sourceContract {m : ℕ} (hm : 0 < m)
        {Cell Face : Type*}
        (q : ℝ → ℝ → (Fin m → ℝ)) (flux : (Fin m → ℝ) → (Fin m → ℝ))
        (numericalOld : Cell → (Fin m → ℝ)) (rule : (Cell → (Fin m → ℝ)) → Face → (Fin m → ℝ))
        (cell : Cell) (leftFace rightFace : Face)
        {a b s t : ℝ} (hab : a < b) (hst : s < t)
        (holdDensity : IntervalIntegrable (fun x => q x s) volume a b)
        (hnewDensity : IntervalIntegrable (fun x => q x t) volume a b)
        (hleftFlux : IntervalIntegrable (fun τ => flux (q a τ)) volume s t)
        (hrightFlux : IntervalIntegrable (fun τ => flux (q b τ)) volume s t)
        (hphysicalBalance : (∫ x in a..b, (fun x => q x t) x) - (∫ x in a..b, (fun x => q x s) x) =
          ∫ τ in s..t, (flux (q a τ) - flux (q b τ))) :
        0 < m ∧
        IsOneDimensionalCellAverage (fun x => q x s) a b (oneDimensionalCellAverage (fun x => q x s) a b) ∧
        IsOneDimensionalCellAverage (fun x => q x t) a b (oneDimensionalCellAverage (fun x => q x t) a b) ∧
        IsOneDimensionalCellAverage (fun τ => flux (q a τ)) s t
          (oneDimensionalCellAverage (fun τ => flux (q a τ)) s t) ∧
        IsOneDimensionalCellAverage (fun τ => flux (q b τ)) s t
          (oneDimensionalCellAverage (fun τ => flux (q b τ)) s t) ∧
        oneDimensionalCellAverage (fun x => q x s) a b =
          cellVolumeAverage volume (Set.Ioc a b) (fun x => q x s) ∧
        oneDimensionalCellAverage (fun τ => flux (q a τ)) s t =
          cellVolumeAverage volume (Set.Ioc s t) (fun τ => flux (q a τ)) ∧
        finiteVolumeCellAverageUpdate (t - s) (b - a) (numericalOld cell)
          (rule numericalOld rightFace - rule numericalOld leftFace) =
          numericalOld cell - ((t - s) / (b - a)) •
            (rule numericalOld rightFace - rule numericalOld leftFace) ∧
        (b - a) • (finiteVolumeCellAverageUpdate (t - s) (b - a) (numericalOld cell)
          (rule numericalOld rightFace - rule numericalOld leftFace) -
          oneDimensionalCellAverage (fun x => q x t) a b) =
          (b - a) • (numericalOld cell - oneDimensionalCellAverage (fun x => q x s) a b) +
            (t - s) • ((rule numericalOld leftFace - oneDimensionalCellAverage (fun τ => flux (q a τ)) s t) -
              (rule numericalOld rightFace - oneDimensionalCellAverage (fun τ => flux (q b τ)) s t)) ∧
        ∀ oldBound leftBound rightBound : ℝ,
          ‖numericalOld cell - oneDimensionalCellAverage (fun x => q x s) a b‖ ≤ oldBound →
          ‖rule numericalOld leftFace - oneDimensionalCellAverage (fun τ => flux (q a τ)) s t‖ ≤ leftBound →
          ‖rule numericalOld rightFace - oneDimensionalCellAverage (fun τ => flux (q b τ)) s t‖ ≤ rightBound →
          ‖finiteVolumeCellAverageUpdate (t - s) (b - a) (numericalOld cell)
            (rule numericalOld rightFace - rule numericalOld leftFace) -
            oneDimensionalCellAverage (fun x => q x t) a b‖ ≤
            oldBound + (t - s) / (b - a) * (leftBound + rightBound)

    leveque01_finiteVolumeLocalFluxUpdate_sourceContract

  • Result

    Conservation of contaminant mass with the constant physical flux f(q) = ū q implies the scalar advection equation under explicit classical smoothness and differentiation-under-the-integral hypotheses. This records the source's conservation-to-advection direction rather than assuming the PDE as the theorem above does.

    Lean statement
    theorem leveque01_advectionLinearFlux_fromMassConservation
        (q : ℝ → ℝ → ℝ) (speed t : ℝ)
        (qt qx fluxx : ℝ → (Fin 1 → ℝ))
        (hintegralMass : IsIntegralConservationLawSolution
          (scalarAsOneComponentSystem q)
          (constantLinearFlux (constantCoefficientScalarMatrix speed)))
        (hqt : ∀ x,
          HasDerivAt (fun τ => scalarAsOneComponentSystem q x τ) (qt x) t)
        (hqx : ∀ x,
          HasDerivAt (fun ξ => scalarAsOneComponentSystem q ξ t) (qx x) x)
        (hfluxx : ∀ x,
          HasDerivAt
            (fun ξ => constantLinearFlux
              (constantCoefficientScalarMatrix speed)
              (scalarAsOneComponentSystem q ξ t))
            (fluxx x) x)
        (hqtIntegrable : ∀ a b, IntervalIntegrable qt volume a b)
        (hfluxxIntegrable : ∀ a b, IntervalIntegrable fluxx volume a b)
        (hinterchange : ∀ a b,
          HasDerivAt
            (fun τ => ∫ x in a..b, scalarAsOneComponentSystem q x τ)
            (∫ x in a..b, qt x) t)
        (hresidualContinuous : Continuous fun x => qt x + fluxx x) :
        (∀ state : Fin 1 → ℝ,
          constantLinearFlux (constantCoefficientScalarMatrix speed) state =
            fun _ => speed * state 0) ∧
          ∀ x, leveque01_equation02_scalarAdvectionAt q speed x t

    leveque01_advectionLinearFlux_fromMassConservation

  • Result

    If the state itself has a spatial derivative, equation (1.8) with f(q) = A q and equation (1.1) are equivalent pointwise.

    Lean statement
    theorem leveque01_linearFlux_specializesEquation01
        {m : ℕ} (q : ℝ → ℝ → (Fin m → ℝ))
        (coefficient : Matrix (Fin m) (Fin m) ℝ) (x t : ℝ)
        (qx : Fin m → ℝ)
        (hqx : HasDerivAt (fun ξ => q ξ t) qx x) :
        leveque01_equation08_conservationLawAt q
            (constantLinearFlux coefficient) x t ↔
          leveque01_equation01_constantLinearSystemAt q coefficient x t

    leveque01_linearFlux_specializesEquation01

  • Result

    The positive-material sound speed in (1.7) gives the hyperbolic second-order principal part asserted immediately after that equation.

    Lean statement
    theorem leveque01_equation07_secondOrderHyperbolic
        (bulkModulus density : ℝ)
        (hbulkModulus : 0 < bulkModulus) (hdensity : 0 < density) :
        (wavePrincipalPart (Real.sqrt (bulkModulus / density))).IsHyperbolic

    leveque01_equation07_secondOrderHyperbolic

  • Result

    General scalar-equation decomposition on printed page 3. One eigenbasis is fixed for all fields and all points; the equivalence includes the reverse reconstruction of a system solution from its scalar equations.

    Lean statement
    theorem leveque01_hyperbolicSystem_scalarWaveDecomposition {m : ℕ}
        (A : Matrix (Fin m) (Fin m) ℝ) (hA : IsRealHyperbolicMatrix A) :
        ∃ (speeds : Fin m → ℝ) (b : Module.Basis (Fin m) ℝ (Fin m → ℝ)),
          (∀ i, A.mulVec (b i) = speeds i • b i) ∧
          ∀ (q : ℝ → ℝ → (Fin m → ℝ)) (x t : ℝ),
            IsConstantCoefficientLinearSystemSolutionAt q A x t ↔
              ∀ i, IsLinearAdvectionSolutionAt
                (fun ξ τ => b.equivFun (q ξ τ) i) (speeds i) x t

    leveque01_hyperbolicSystem_scalarWaveDecomposition

  • Result

    A positive smooth pointwise hyperbolic scalar transport coefficient need not admit any local flux for the unchanged density, even when that flux is allowed to depend explicitly on position. This does not rule out changes of density or integrating factors.

    Lean statement
    theorem leveque01_exists_hyperbolic_variableCoefficient_without_localFlux :
        ∃ coefficient : ℝ → ℝ,
          ContDiff ℝ (⊤ : ℕ∞) coefficient ∧
          (∀ x, 0 < coefficient x) ∧
          (∀ x, IsRealHyperbolicMatrix (constantCoefficientScalarMatrix (coefficient x))) ∧
          ¬ ∃ flux : ℝ → ℝ → ℝ, RepresentsScalarTransportFlux coefficient flux

    leveque01_exists_hyperbolic_variableCoefficient_without_localFlux

  • Result

    For a scalar contaminant with constant advective speed, the source integral is exactly the mass change after boundary exchange. Homogeneous conservation holds precisely when every rectangle source contribution vanishes. The last clause permits an exceptional time set depending on the fixed spatial interval. No spatial state derivative or source sign is prescribed.

    Lean statement
    theorem leveque01_sourceTermsRectangleBalance
        {q production : ℝ → ℝ → Fin 1 → ℝ} (speed : ℝ)
        (h : IsRectangleBalanceLawSolution q (fun state => speed • state) production) :
        IsRectangleBalanceLawSolution q (fun state => speed • state) production ∧
        (∀ a b s t,
          (∫ τ in s..t, ∫ x in a..b, production x τ) =
            ((∫ x in a..b, q x t) - (∫ x in a..b, q x s)) -
              (∫ τ in s..t, speed • q a τ - speed • q b τ)) ∧
        (IsRectangleConservationLawSolution q (fun state => speed • state) ↔
          ∀ a b s t, (∫ τ in s..t, ∫ x in a..b, production x τ) = 0) ∧
        (¬ IsRectangleConservationLawSolution q (fun state => speed • state) ↔
          ∃ a b s t, (∫ τ in s..t, ∫ x in a..b, production x τ) ≠ 0) ∧
        (∀ a b, ∀ᵐ t,
          HasDerivAt (fun s => ∫ x in a..b, q x s)
            (speed • q a t - speed • q b t + ∫ x in a..b, production x t) t)

    leveque01_sourceTermsRectangleBalance

  • Result

    Dependence only on current data is exactly an update on attainable current data, with arbitrary admissible histories and next-time solution types.

    Lean statement
    theorem leveque01_oneStepMethod_iff_attainableCurrentDataMap
        {History : Sort*} {CurrentData : Type*} {NextData : Sort*}
        (current : History → CurrentData) (advance : History → NextData) :
        (∀ history₁ history₂, current history₁ = current history₂ →
          advance history₁ = advance history₂) ↔
          ∃ step : Set.range current → NextData,
            advance = step ∘ Set.rangeFactorization current

    leveque01_oneStepMethod_iff_attainableCurrentDataMap

  • Result

    The local-material interpretation gives both actual component jumps, with separate side inequalities. Initial data retains its free origin value, while the material need not be constant away from the interface.

    Lean statement
    theorem leveque01_materialInterfaceLocalRiemannData {Material State : Type*}
        [TopologicalSpace Material] [TopologicalSpace State]
        [T2Space Material] [T2Space State]
        {medium : ℝ → Material} {initialState : ℝ → State}
        {leftMaterial rightMaterial : Material} {leftState rightState : State}
        (hmedium : HasJumpAt medium 0 leftMaterial rightMaterial)
        (hstate : IsRiemannData initialState leftState rightState)
        (hdistinct : leftState ≠ rightState) :
        (HasJumpAt medium 0 leftMaterial rightMaterial ∧
          HasJumpAt initialState 0 leftState rightState) ∧
        (Tendsto (fun x => (medium x, initialState x)) (𝓝[<] 0)
            (𝓝 (leftMaterial, leftState)) ∧
          Tendsto (fun x => (medium x, initialState x)) (𝓝[>] 0)
            (𝓝 (rightMaterial, rightState)) ∧
          leftMaterial ≠ rightMaterial ∧ leftState ≠ rightState) ∧
        IsRiemannData initialState leftState rightState ∧
        ¬ ContinuousAt medium 0 ∧ ¬ ContinuousAt initialState 0 ∧
        (∃ originState, initialState = riemannData leftState originState rightState)

    leveque01_materialInterfaceLocalRiemannData

  • Result

    A nonlinear C1 flux admits a conserved field that starts smoothly, remains spatially continuous before a positive time, and has distinct shock traces then.

    Lean statement
    theorem leveque01_nonlinear_shock_formation :
        ∃ (flux : ℝ → ℝ) (q : ℝ → ℝ → ℝ) (T ξ qL qR : ℝ),
          ContDiff ℝ 1 flux ∧
          (¬ ∃ a b : ℝ, ∀ u, flux u = a * u + b) ∧
          IsRectangleConservationLawSolution q flux ∧
          ContDiff ℝ ⊤ (fun x => q x 0) ∧
          0 < T ∧
          (∀ t, 0 ≤ t → t < T → Continuous (fun x => q x t)) ∧
          Tendsto (fun x => q x T) (𝓝[<] ξ) (𝓝 qL) ∧
          Tendsto (fun x => q x T) (𝓝[>] ξ) (𝓝 qR) ∧ qR < qL

    leveque01_nonlinear_shock_formation

  • Result

    The selected first-order problem-data classification and its explicit equal-state and distinct-jump constructor branches.

    Lean statement
    theorem leveque01_riemannProblemDataClassification {m : ℕ}
        (problem : FirstOrderInitialValueProblem (Fin (m + 1))) :
        (problem.IsRiemann ↔
          (∃ leftState rightState,
            problem.governing.IsHyperbolic ∧
            leftState ∈ problem.governing.admissibleStates ∧
            rightState ∈ problem.governing.admissibleStates ∧
            (∀ x, x < 0 → problem.initialState x = leftState) ∧
            (∀ x, 0 < x → problem.initialState x = rightState)) ∧
          (∀ x t state qt qx,
            problem.governing.residual x t state qt qx = 0 ↔
              qt + (problem.governing.principal x t state).mulVec qx =
                problem.governing.forcing x t state)) ∧
        (problem.IsJumpRiemann ↔
          ∃ leftState rightState,
            problem.IsRiemannWithStates leftState rightState ∧ leftState ≠ rightState) ∧
        (∀ (leftState origin rightState : Fin (m + 1) → ℝ),
          problem.governing.IsHyperbolic →
          leftState ∈ problem.governing.admissibleStates →
          rightState ∈ problem.governing.admissibleStates →
          (fromStates problem.governing leftState origin rightState).IsRiemannWithStates
              leftState rightState ∧
          (leftState = rightState →
            ¬ (fromStates problem.governing leftState origin rightState).IsJumpRiemann) ∧
          (leftState ≠ rightState →
            (fromStates problem.governing leftState origin rightState).IsJumpRiemann))

    leveque01_riemannProblemDataClassification

  • Result

    A real hyperbolic matrix gives a Riemann solution by finite eigenmode superposition. Conservation is the time-integrated rectangle balance, and the origin value is independently selected.

    Lean statement
    theorem leveque01_linearRiemann_eigensolution
        {ι : Type*} [Fintype ι] {coefficient : Matrix ι ι ℝ}
        (hcoefficient : IsRealHyperbolicMatrix coefficient)
        (leftState valueAtOrigin rightState : ι → ℝ) :
        ∃ (eigenvalues : ι → ℝ) (eigenbasis : Module.Basis ι ℝ (ι → ℝ)),
          (∀ p, coefficient.mulVec (eigenbasis p) = eigenvalues p • eigenbasis p) ∧
          IsRectangleConservationLawSolution
            (linearRiemannSolution eigenbasis eigenvalues leftState valueAtOrigin rightState)
            coefficient.mulVec ∧
          (∀ x, linearRiemannSolution eigenbasis eigenvalues leftState valueAtOrigin rightState x 0 =
            riemannData leftState valueAtOrigin rightState x) ∧
          (∀ x t, 0 < t →
            linearRiemannSolution eigenbasis eigenvalues leftState valueAtOrigin rightState x t =
            linearRiemannSolution eigenbasis eigenvalues leftState valueAtOrigin rightState (x / t) 1)

    leveque01_linearRiemann_eigensolution

  • Result

    Sufficient classical smoothness and differentiation under the integral turn equation (1.10) into the pointwise equation (1.8).

    Lean statement
    theorem leveque01_integralLaw_impliesDifferentialLaw_of_smooth
        {m : ℕ} (q : ℝ → ℝ → (Fin m → ℝ))
        (flux : (Fin m → ℝ) → (Fin m → ℝ))
        (qt fluxx : ℝ → (Fin m → ℝ)) (t : ℝ)
        (hintegralLaw : leveque01Equation10IntegralConservation q flux)
        (hqt : ∀ x, HasDerivAt (fun τ => q x τ) (qt x) t)
        (hfluxx : ∀ x,
          HasDerivAt (fun ξ => flux (q ξ t)) (fluxx x) x)
        (hqtIntegrable : ∀ a b, IntervalIntegrable qt volume a b)
        (hfluxxIntegrable : ∀ a b, IntervalIntegrable fluxx volume a b)
        (hinterchange : ∀ a b,
          HasDerivAt (fun τ => ∫ x in a..b, q x τ)
            (∫ x in a..b, qt x) t)
        (hresidualContinuous : Continuous fun x => qt x + fluxx x) :
        ∀ x, leveque01_equation08_conservationLawAt q flux x t

    leveque01_integralLaw_impliesDifferentialLaw_of_smooth

  • Result

    The acoustics matrix has the two nonzero eigenvectors displayed here, with eigenvalues -c and +c for c = sqrt (K / ρ). Carrying an arbitrary differentiable profile by either eigenvector gives a system solution translated at that eigenvalue, making the source's wave-speed interpretation explicit.

    Lean statement
    theorem leveque01_acousticsMatrixEigenvalues
        {bulkModulus density : ℝ}
        (hbulkModulus : 0 < bulkModulus) (hdensity : 0 < density) :
        let soundSpeed := Real.sqrt (bulkModulus / density)
        0 < soundSpeed ∧
          linearAcousticsLeftEigenvector density soundSpeed ≠ 0 ∧
          (linearAcousticsMatrix bulkModulus density).mulVec
              (linearAcousticsLeftEigenvector density soundSpeed) =
            (-soundSpeed) • linearAcousticsLeftEigenvector density soundSpeed ∧
          (∀ {profile : ℝ → ℝ} {profile' : ℝ} (x t : ℝ),
            HasDerivAt profile profile' (x - (-soundSpeed) * t) →
              IsConstantCoefficientLinearSystemSolutionAt
                (eigenmodeTravelingWave profile (-soundSpeed)
                  (linearAcousticsLeftEigenvector density soundSpeed))
                (linearAcousticsMatrix bulkModulus density) x t) ∧
          linearAcousticsRightEigenvector density soundSpeed ≠ 0 ∧
          (linearAcousticsMatrix bulkModulus density).mulVec
              (linearAcousticsRightEigenvector density soundSpeed) =
            soundSpeed • linearAcousticsRightEigenvector density soundSpeed ∧
          ∀ {profile : ℝ → ℝ} {profile' : ℝ} (x t : ℝ),
            HasDerivAt profile profile' (x - soundSpeed * t) →
              IsConstantCoefficientLinearSystemSolutionAt
                (eigenmodeTravelingWave profile soundSpeed
                  (linearAcousticsRightEigenvector density soundSpeed))
                (linearAcousticsMatrix bulkModulus density) x t

    leveque01_acousticsMatrixEigenvalues

  • Result

    Every pointwise solution of the linear-acoustics equations is a conservation-law solution with flux q ↦ A q for the acoustics matrix.

    Lean statement
    theorem leveque01_acoustics_hasConservationForm
        (pressure velocity : ℝ → ℝ → ℝ)
        (bulkModulus density x t : ℝ) (hdensity : density ≠ 0)
        (hacoustics : leveque01_equation05_linearAcousticsAt
          pressure velocity bulkModulus density x t) :
        leveque01_equation08_conservationLawAt
          (linearAcousticsState pressure velocity)
          (constantLinearFlux (linearAcousticsMatrix bulkModulus density)) x t

    leveque01_acoustics_hasConservationForm

  • Result

    The notation denotes the value on the entire positive-time ray x/t=0. Initial data and the evolution equation are retained for the selected field; uniqueness between different selected fields is not a premise or conclusion.

    Lean statement
    theorem leveque01_riemannRayZeroValue_iff {State : Type*}
        (evolutionEquation : (ℝ → ℝ → State) → Prop)
        (leftState rightState : State) (q : ℝ → ℝ → State)
        (_hriemann : leveque01RiemannInitialConfiguration evolutionEquation leftState rightState q)
        (hself : IsPositiveTimeSelfSimilar q) (value : State) :
        leveque01RiemannRayZeroValue q = value ↔ ∀ t, 0 < t → q 0 t = value

    leveque01_riemannRayZeroValue_iff

  • Result

    The flux is hyperbolic at a state exactly when its actual Jacobian admits a complete independent real eigenvector family. Repeated eigenvalues are allowed.

    Lean statement
    theorem leveque01_fluxJacobian_hyperbolicity_iff {m : ℕ}
        (flux : (Fin m → ℝ) → (Fin m → ℝ)) (state : Fin m → ℝ)
        (derivative : (Fin m → ℝ) →L[ℝ] (Fin m → ℝ))
        (hderivative : HasFDerivAt flux derivative state) :
        IsHyperbolicFluxAt flux state ↔
          ∃ (eigenvalues : Fin m → ℝ) (eigenvectors : Fin m → (Fin m → ℝ)),
            LinearIndependent ℝ eigenvectors ∧
              ∀ p, derivative (eigenvectors p) = eigenvalues p • eigenvectors p

    leveque01_fluxJacobian_hyperbolicity_iff

  • Result

    Every real scalar constant-coefficient equation is hyperbolic. Its one-by-one coefficient matrix has eigenvalue speed and the standard basis as a corresponding real eigenbasis.

    Lean statement
    theorem leveque01_scalarEquation_isHyperbolic (speed : ℝ) :
        leveque01IsHyperbolicMatrix
          (constantCoefficientScalarMatrix speed)

    leveque01_scalarEquation_isHyperbolic

  • Result

    The two acoustic characteristic variables satisfy scalar one-way wave equations with the opposite speeds +c and -c.

    Lean statement
    theorem leveque01_acousticsTwoWaveDecomposition
        {bulkModulus density : ℝ}
        (system : LinearAcousticsSolution bulkModulus density)
        (hbulkModulus : 0 < bulkModulus) (hdensity : 0 < density) :
        ∀ x t,
          leveque01_equation04_oneWayWaveAt
              (linearAcousticsRightInvariant system.pressure system.velocity
                density (Real.sqrt (bulkModulus / density)))
              (Real.sqrt (bulkModulus / density)) x t ∧
            leveque01_equation04_oneWayWaveAt
              (linearAcousticsLeftInvariant system.pressure system.velocity
                density (Real.sqrt (bulkModulus / density)))
              (-Real.sqrt (bulkModulus / density)) x t

    leveque01_acousticsTwoWaveDecomposition

  • Result

    The actual left invariant and the independently specified profile domains, under the explicitly selected physical and analytic conventions.

    Lean statement
    theorem leveque01_acousticsLeftSolutionDomains
        {bulkModulus density : ℝ}
        (system : LinearAcousticsSolution bulkModulus density)
        (hbulkModulus : 0 < bulkModulus) (hdensity : 0 < density) :
        0 < Real.sqrt (bulkModulus / density) ∧
          IsLinearAdvectionSolution
            (linearAcousticsLeftInvariant system.pressure system.velocity
              density (Real.sqrt (bulkModulus / density)))
            (-Real.sqrt (bulkModulus / density)) ∧
          ∀ profile : ℝ → ℝ,
            (∀ x t, travelingWave profile (-Real.sqrt (bulkModulus / density)) x t =
              profile (x + Real.sqrt (bulkModulus / density) * t)) ∧
            (∀ x t, travelingWave profile (-Real.sqrt (bulkModulus / density))
              (x - Real.sqrt (bulkModulus / density) * t) t = profile x) ∧
            (IsLinearAdvectionSolution
              (travelingWave profile (-Real.sqrt (bulkModulus / density)))
              (-Real.sqrt (bulkModulus / density)) ↔ Differentiable ℝ profile) ∧
            (IsRectangleConservationLawSolution
              (travelingWave profile (-Real.sqrt (bulkModulus / density)))
              (fun state => -Real.sqrt (bulkModulus / density) * state) ↔
              ∀ a b, IntervalIntegrable profile volume a b)

    leveque01_acousticsLeftSolutionDomains

  • Equation (1.4)

    The complete positive-speed scalar contract, together with the acoustic realization w = p + ρ c u, c = sqrt (K / ρ), for every given classical pressure--velocity solution with positive material parameters. The profile derivative hypothesis applies only to the constructed-profile clause; the given-system clause uses the actual partial derivatives in its certificate.

    Lean statement
    theorem leveque01_equation04_acousticOneWayModel :
        (∀ (c : ℝ), 0 < c →
          leveque01IsHyperbolicMatrix (constantCoefficientScalarMatrix c) ∧
            (∀ x t₁ t₂ : ℝ, t₁ < t₂ → x + c * t₁ < x + c * t₂) ∧
            ∀ {profile : ℝ → ℝ} {profile' : ℝ} (x t : ℝ),
              HasDerivAt profile profile' (x - c * t) →
                leveque01_equation04_oneWayWaveAt
                    (travelingWave profile c) c x t ∧
                  travelingWave profile c (x + c * t) t = profile x) ∧
          ∀ {bulkModulus density : ℝ}
            (system : LinearAcousticsSolution bulkModulus density),
            0 < bulkModulus → 0 < density →
            ∃ (c : ℝ), c = Real.sqrt (bulkModulus / density) ∧ 0 < c ∧
              ∃ w : ℝ → ℝ → ℝ,
                (∀ x t, w x t = system.pressure x t + density * c * system.velocity x t) ∧
                ∀ x t, leveque01_equation04_oneWayWaveAt w c x t

    leveque01_equation04_acousticOneWayModel · 1 more declaration under this item

  • Equation (1.6)

    The pressure--velocity equations (1.5) are exactly the constant-coefficient system with state (p,u) and matrix [[0,K],[1/ρ,0]].

    Lean statement
    theorem leveque01_equation06_acousticsMatrixForm
        (pressure velocity : ℝ → ℝ → ℝ)
        (bulkModulus density x t : ℝ) (_hdensity : density ≠ 0) :
        leveque01_equation01_constantLinearSystemAt
            (linearAcousticsState pressure velocity)
            (linearAcousticsMatrix bulkModulus density) x t ↔
          leveque01_equation05_linearAcousticsAt
            pressure velocity bulkModulus density x t

    leveque01_equation06_acousticsMatrixForm

  • Equation (1.9)

    The spatial chain rule rewrites equation (1.8) as equation (1.9), under explicit derivatives of the state slice and the flux at the current state.

    Lean statement
    theorem leveque01_equation09_quasilinearForm
        {m : ℕ} (q : ℝ → ℝ → (Fin m → ℝ))
        (flux : (Fin m → ℝ) → (Fin m → ℝ))
        (fluxDerivative :
          (Fin m → ℝ) → ((Fin m → ℝ) →L[ℝ] (Fin m → ℝ)))
        (x t : ℝ) (qx : Fin m → ℝ)
        (hqx : HasDerivAt (fun ξ => q ξ t) qx x)
        (hflux : HasFDerivAt flux (fluxDerivative (q x t)) (q x t)) :
        leveque01_equation08_conservationLawAt q flux x t ↔
          leveque01_equation09_quasilinearAt q fluxDerivative x t

    leveque01_equation09_quasilinearForm

  • Equation (1.10)

    Rectangle conservation with its integrated balance and intervalwise almost-everywhere mass rate.

    Lean statement
    theorem leveque01_equation10_rectangleConservation_iff_integrated_and_ae_rate
        {m : ℕ} (q : ℝ → ℝ → Fin m → ℝ)
        (flux : (Fin m → ℝ) → Fin m → ℝ) :
        IsRectangleConservationLawSolution q flux ↔
          (∀ a b t, IntervalIntegrable (fun x => q x t) volume a b) ∧
          (∀ x s t, IntervalIntegrable (fun τ => flux (q x τ)) volume s t) ∧
          (∀ a b s t,
            (∫ x in a..b, q x t) - (∫ x in a..b, q x s) =
              ∫ τ in s..t, (flux (q a τ) - flux (q b τ))) ∧
          (∀ a b, ∀ᵐ t, HasDerivAt (fun s => ∫ x in a..b, q x s)
            (flux (q a t) - flux (q b t)) t)

    leveque01_equation10_rectangleConservation_iff_integrated_and_ae_rate

  • Equation (1.11)

    Equation (1.11) permits exactly one free datum: the value at the origin.

    Lean statement
    theorem leveque01_equation11_characterization {m : ℕ}
        (initialState : ℝ → (Fin m → ℝ))
        (leftState rightState : Fin m → ℝ) :
        leveque01Equation11RiemannData initialState leftState rightState ↔
          ∃ valueAtOrigin,
            initialState = riemannData leftState valueAtOrigin rightState

    leveque01_equation11_characterization

Chapter 1 · Introduction all chapters

  • Result

    The introductory local-conservativity terminology is precisely the opposite-sign identity for the outward numerical fluxes at each interface.

    Lean statement
    theorem localConservativity : localConservativityTarget

    localConservativity

  • Result

    Section 2.2's cell data are indexed by a natural time level and a cell.

    Lean statement
    theorem cellUnknowns : cellUnknownsTarget

    cellUnknowns

  • Result

    Ordered-pair incidence gives exactly the source's numerical-exchange antisymmetry condition, at every natural time level and every cell pair.

    Lean statement
    theorem conservativeExchange : conservativeExchangeTarget

    conservativeExchange