DibyashanuPati/PhysLean
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

feat: make informal_definition and informal_lemma commands (#300)

Browse source 
* make informal_definition and informal_lemma commands
* drop the fields "math", "physics", and "proof" from InformalDefinition/InformalLemma and use docstrings instead
* render informal docstring in dependency graph
This commit is contained in:
KUO-TSAN HSU (Gordon) 2025-02-02 03:17:17 +08:00 • committed by GitHub
parent 6aab0ba3cd
commit f8f94979ab
No known key found for this signature in database
GPG key ID: B5690EEEBB952194
33 changed files with 666 additions and 1089 deletions
Download patch file Download diff file Expand all files Collapse all files

33
HepLean/BeyondTheStandardModel/GeorgiGlashow/Basic.lean
View file

@ -17,27 +17,30 @@ This file currently contains informal-results about the Georgi-Glashow group.
namespace GeorgiGlashow
/-- The gauge group of the Georgi-Glashow model, i.e., `SU(5)`. -/
informal_definition GaugeGroupI where
math :≈ "The group `SU(5)`."
physics :≈ "The gauge group of the Georgi-Glashow model."
deps := []
/-- The homomorphism of the Standard Model gauge group into the Georgi-Glashow gauge group, i.e.,
the group homomorphism `SU(3) × SU(2) × U(1) → SU(5)` taking `(h, g, α)` to
`blockdiag (α ^ 3 g, α ^ (-2) h)`.
See page 34 of https://math.ucr.edu/home/baez/guts.pdf
-/
informal_definition inclSM where
physics :≈ "The homomorphism of the Standard Model gauge group into the
Georgi-Glashow gauge group."
math :≈ "The group homomorphism `SU(3) x SU(2) x U(1) -> SU(5)`
taking (h, g, α) to (blockdiag (α ^ 3 g, α ^ (-2) h)."
ref :≈ "Page 34 of https://math.ucr.edu/home/baez/guts.pdf"
deps :≈ [``GaugeGroupI, ``StandardModel.GaugeGroupI]
deps := [``GaugeGroupI, ``StandardModel.GaugeGroupI]
/-- The kernel of the map `inclSM` is equal to the subgroup `StandardModel.gaugeGroupℤ₆SubGroup`.
See page 34 of https://math.ucr.edu/home/baez/guts.pdf
-/
informal_lemma inclSM_ker where
math :≈ "The kernel of the map ``inclSM is equal to the subgroup
``StandardModel.gaugeGroupℤ₆SubGroup."
ref :≈ "Page 34 of https://math.ucr.edu/home/baez/guts.pdf"
deps :≈ [``inclSM, ``StandardModel.gaugeGroupℤ₆SubGroup]
deps := [``inclSM, ``StandardModel.gaugeGroupℤ₆SubGroup]
/-- The group embedding from `StandardModel.GaugeGroupℤ₆` to `GaugeGroupI` induced by `inclSM` by
quotienting by the kernal `inclSM_ker`.
-/
informal_definition embedSMℤ₆ where
math :≈ "The group embedding from ``StandardModel.GaugeGroupℤ₆ to ``GaugeGroupI
induced by ``inclSM by quotienting by the kernal ``inclSM_ker."
deps :≈ [``inclSM, ``StandardModel.GaugeGroupℤ₆, ``GaugeGroupI, ``inclSM_ker]
deps := [``inclSM, ``StandardModel.GaugeGroupℤ₆, ``GaugeGroupI, ``inclSM_ker]
end GeorgiGlashow

70
HepLean/BeyondTheStandardModel/PatiSalam/Basic.lean
View file

@ -22,54 +22,62 @@ namespace PatiSalam
-/
/-- The gauge group of the Pati-Salam model (unquotiented by ℤ₂), i.e., `SU(4) × SU(2) × SU(2)`. -/
informal_definition GaugeGroupI where
math :≈ "The group `SU(4) x SU(2) x SU(2)`."
physics :≈ "The gauge group of the Pati-Salam model (unquotiented by ℤ₂)."
deps := []
/-- The homomorphism of the Standard Model gauge group into the Pati-Salam gauge group, i.e., the
group homomorphism `SU(3) × SU(2) × U(1) → SU(4) × SU(2) × SU(2)` taking `(h, g, α)` to
`(blockdiag (α h, α ^ (-3)), g, diag (α ^ 3, α ^(-3))`.
See page 54 of https://math.ucr.edu/home/baez/guts.pdf
-/
informal_definition inclSM where
physics :≈ "The homomorphism of the Standard Model gauge group into the Pati-Salam gauge group."
math :≈ "The group homomorphism `SU(3) x SU(2) x U(1) -> SU(4) x SU(2) x SU(2)`
taking (h, g, α) to (blockdiag (α h, α ^ (-3)), g, diag(α ^ (3), α ^(-3)))."
ref :≈ "Page 54 of https://math.ucr.edu/home/baez/guts.pdf"
deps :≈ [``GaugeGroupI, ``StandardModel.GaugeGroupI]
deps := [``GaugeGroupI, ``StandardModel.GaugeGroupI]
/-- The kernel of the map `inclSM` is equal to the subgroup `StandardModel.gaugeGroupℤ₃SubGroup`.
See footnote 10 of https://arxiv.org/pdf/2201.07245
-/
informal_lemma inclSM_ker where
math :≈ "The kernel of the map ``inclSM is equal to the subgroup
``StandardModel.gaugeGroupℤ₃SubGroup."
ref :≈ "Footnote 10 of https://arxiv.org/pdf/2201.07245"
deps :≈ [``inclSM, ``StandardModel.gaugeGroupℤ₃SubGroup]
deps := [``inclSM, ``StandardModel.gaugeGroupℤ₃SubGroup]
/-- The group embedding from `StandardModel.GaugeGroupℤ₃` to `GaugeGroupI` induced by `inclSM` by
quotienting by the kernal `inclSM_ker`.
-/
informal_definition embedSMℤ₃ where
math :≈ "The group embedding from ``StandardModel.GaugeGroupℤ₃ to ``GaugeGroupI
induced by ``inclSM by quotienting by the kernal ``inclSM_ker."
deps :≈ [``inclSM, ``StandardModel.GaugeGroupℤ₃, ``GaugeGroupI, ``inclSM_ker]
deps := [``inclSM, ``StandardModel.GaugeGroupℤ₃, ``GaugeGroupI, ``inclSM_ker]
/-- The equivalence between `GaugeGroupI` and `Spin(6) × Spin(4)`. -/
informal_definition gaugeGroupISpinEquiv where
math :≈ "The equivalence between `GaugeGroupI` and `Spin(6) × Spin(4)`."
deps :≈ [``GaugeGroupI]
deps := [``GaugeGroupI]
/-- The ℤ₂-subgroup of the un-quotiented gauge group which acts trivially on all particles in the
standard model, i.e., the ℤ₂-subgroup of `GaugeGroupI` with the non-trivial element `(-1, -1, -1)`.
See https://math.ucr.edu/home/baez/guts.pdf
-/
informal_definition gaugeGroupℤ₂SubGroup where
physics :≈ "The ℤ₂-subgroup of the un-quotiented gauge group which acts trivially on
all particles in the standard model."
math :≈ "The ℤ₂-subgroup of ``GaugeGroupI with the non-trivial element (-1, -1, -1)."
ref :≈ "https://math.ucr.edu/home/baez/guts.pdf"
deps :≈ [``GaugeGroupI]
deps := [``GaugeGroupI]
/-- The gauge group of the Pati-Salam model with a ℤ₂ quotient, i.e., the quotient of `GaugeGroupI`
by the ℤ₂-subgroup `gaugeGroupℤ₂SubGroup`.
See https://math.ucr.edu/home/baez/guts.pdf
-/
informal_definition GaugeGroupℤ₂ where
physics :≈ "The gauge group of the Pati-Salam model with a ℤ₂ quotient."
math :≈ "The quotient of ``GaugeGroupI by the ℤ₂-subgroup `gaugeGroupℤ₂SubGroup`."
ref :≈ "https://math.ucr.edu/home/baez/guts.pdf"
deps :≈ [``GaugeGroupI, ``gaugeGroupℤ₂SubGroup]
deps := [``GaugeGroupI, ``gaugeGroupℤ₂SubGroup]
/-- The group `StandardModel.gaugeGroupℤ₆SubGroup` under the homomorphism `embedSM` factors through
the subgroup `gaugeGroupℤ₂SubGroup`.
-/
informal_lemma sm_ℤ₆_factor_through_gaugeGroupℤ₂SubGroup where
math :≈ "The group ``StandardModel.gaugeGroupℤ₆SubGroup under the homomorphism ``embedSM factors
through the subgroup ``gaugeGroupℤ₂SubGroup."
deps :≈ [``inclSM, ``StandardModel.gaugeGroupℤ₆SubGroup, ``gaugeGroupℤ₂SubGroup]
deps := [``inclSM, ``StandardModel.gaugeGroupℤ₆SubGroup, ``gaugeGroupℤ₂SubGroup]
/-- The group homomorphism from `StandardModel.GaugeGroupℤ₆` to `GaugeGroupℤ₂` induced by `embedSM`.
-/
informal_definition embedSMℤ₆Toℤ₂ where
math :≈ "The group homomorphism from ``StandardModel.GaugeGroupℤ₆ to ``GaugeGroupℤ₂
induced by ``embedSM."
deps :≈ [``inclSM, ``StandardModel.GaugeGroupℤ₆, ``GaugeGroupℤ₂,
deps := [``inclSM, ``StandardModel.GaugeGroupℤ₆, ``GaugeGroupℤ₂,
``sm_ℤ₆_factor_through_gaugeGroupℤ₂SubGroup]
end PatiSalam

47
HepLean/BeyondTheStandardModel/Spin10/Basic.lean
View file

@ -16,37 +16,42 @@ is Spin(10).
namespace Spin10Model
/-- The gauge group of the Spin(10) model, i.e., the group `Spin(10)`. -/
informal_definition GaugeGroupI where
math :≈ "The group `Spin(10)`."
physics :≈ "The gauge group of the Spin(10) model (aka SO(10)-model.)"
deps := []
/-- The inclusion of the Pati-Salam gauge group into Spin(10), i.e., the lift of the embedding
`SO(6) × SO(4) → SO(10)` to universal covers, giving a homomorphism `Spin(6) × Spin(4) → Spin(10)`.
Precomposed with the isomorphism, `PatiSalam.gaugeGroupISpinEquiv`, between `SU(4) × SU(2) × SU(2)`
and `Spin(6) × Spin(4)`.
See page 56 of https://math.ucr.edu/home/baez/guts.pdf
-/
informal_definition inclPatiSalam where
physics :≈ "The inclusion of the Pati-Salam gauge group into Spin(10)."
math :≈ "The lift of the embedding `SO(6) x SO(4) → SO(10)` to universal covers,
giving a homomorphism `Spin(6) x Spin(4) → Spin(10)`. Precomposed with the isomorphism,
``PatiSalam.gaugeGroupISpinEquiv, between `SU(4) x SU(2) x SU(2)` and `Spin(6) x Spin(4)`."
ref :≈ "Page 56 of https://math.ucr.edu/home/baez/guts.pdf"
deps :≈ [``GaugeGroupI, ``PatiSalam.GaugeGroupI, ``PatiSalam.gaugeGroupISpinEquiv]
deps := [``GaugeGroupI, ``PatiSalam.GaugeGroupI, ``PatiSalam.gaugeGroupISpinEquiv]
/-- The inclusion of the Standard Model gauge group into Spin(10), i.e., the compoisiton of
`embedPatiSalam` and `PatiSalam.inclSM`.
See page 56 of https://math.ucr.edu/home/baez/guts.pdf
-/
informal_definition inclSM where
physics :≈ "The inclusion of the Standard Model gauge group into Spin(10)."
math :≈ "The compoisiton of ``embedPatiSalam and ``PatiSalam.inclSM."
ref :≈ "Page 56 of https://math.ucr.edu/home/baez/guts.pdf"
deps :≈ [``inclPatiSalam, ``PatiSalam.inclSM]
deps := [``inclPatiSalam, ``PatiSalam.inclSM]
/-- The inclusion of the Georgi-Glashow gauge group into Spin(10), i.e., the Lie group homomorphism
from `SU(n) → Spin(2n)` discussed on page 46 of https://math.ucr.edu/home/baez/guts.pdf for `n = 5`.
-/
informal_definition inclGeorgiGlashow where
physics :≈ "The inclusion of the Georgi-Glashow gauge group into Spin(10)."
math :≈ "The Lie group homomorphism from SU(n) → Spin(2n) dicussed on page 46 of
https://math.ucr.edu/home/baez/guts.pdf for n = 5."
deps :≈ [``GaugeGroupI, ``GeorgiGlashow.GaugeGroupI]
deps := [``GaugeGroupI, ``GeorgiGlashow.GaugeGroupI]
/-- The inclusion of the Standard Model gauge group into Spin(10), i.e., the composition of
`inclGeorgiGlashow` and `GeorgiGlashow.inclSM`.
-/
informal_definition inclSMThruGeorgiGlashow where
physics :≈ "The inclusion of the Standard Model gauge group into Spin(10)."
math :≈ "The composition of ``inclGeorgiGlashow and ``GeorgiGlashow.inclSM."
deps :≈ [``inclGeorgiGlashow, ``GeorgiGlashow.inclSM]
deps := [``inclGeorgiGlashow, ``GeorgiGlashow.inclSM]
/-- The inclusion `inclSM` is equal to the inclusion `inclSMThruGeorgiGlashow`. -/
informal_lemma inclSM_eq_inclSMThruGeorgiGlashow where
math :≈ "The inclusion ``inclSM is equal to the inclusion ``inclSMThruGeorgiGlashow."
deps :≈ [``inclSM, ``inclSMThruGeorgiGlashow]
deps := [``inclSM, ``inclSMThruGeorgiGlashow]
end Spin10Model

18
HepLean/BeyondTheStandardModel/TwoHDM/GaugeOrbits.lean
View file

@ -84,17 +84,19 @@ lemma prodMatrix_smooth (Φ1 Φ2 : HiggsField) :
simpa only [prodMatrix, Fin.zero_eta, Fin.isValue, of_apply, cons_val', cons_val_zero,
empty_val', cons_val_fin_one] using smooth_innerProd _ _
/-- The map `prodMatrix` is invariant under the simultanous action of `gaugeAction` on the two Higgs
fields. -/
informal_lemma prodMatrix_invariant where
math :≈ "The map ``prodMatrix is invariant under the simultanous action of ``gaugeAction
on the two Higgs fields."
deps :≈ [``prodMatrix, ``gaugeAction]
deps := [``prodMatrix, ``gaugeAction]
/-- Given any smooth map `f` from spacetime to 2-by-2 complex matrices landing on positive
semi-definite matrices, there exist smooth Higgs fields `Φ1` and `Φ2` such that `f` is equal to
`prodMatrix Φ1 Φ2`.
See https://arxiv.org/pdf/hep-ph/0605184
-/
informal_lemma prodMatrix_to_higgsField where
math :≈ "Given any smooth map ``f from spacetime to 2 x 2 complex matrices landing on positive
semi-definite matrices, there exist smooth Higgs fields ``Φ1 and ``Φ2 such that
``f is equal to ``prodMatrix Φ1 Φ2."
deps :≈ [``prodMatrix, ``HiggsField, ``prodMatrix_smooth]
ref :≈ "https://arxiv.org/pdf/hep-ph/0605184"
deps := [``prodMatrix, ``HiggsField, ``prodMatrix_smooth]
end
end TwoHDM

18
HepLean/Lorentz/ComplexTensor/Bispinors/Basic.lean
View file

@ -80,15 +80,19 @@ lemma tensorNode_coBispinorDown (p : complexCo) :
-/
informal_lemma contrBispinorUp_eq_metric_contr_contrBispinorDown where
math :≈ "{contrBispinorUp p | α β = εL | α α' ⊗ εR | β β'⊗ contrBispinorDown p | α' β' }ᵀ"
proof :≈ "Expand `contrBispinorDown` and use fact that metrics contract to the identity."
deps :≈ [``contrBispinorUp, ``contrBispinorDown, ``leftMetric, ``rightMetric]
/-- `{contrBispinorUp p | α β = εL | α α' ⊗ εR | β β'⊗ contrBispinorDown p | α' β' }ᵀ`.
Proof: expand `contrBispinorDown` and use fact that metrics contract to the identity.
-/
informal_lemma contrBispinorUp_eq_metric_contr_contrBispinorDown where
deps := [``contrBispinorUp, ``contrBispinorDown, ``leftMetric, ``rightMetric]
/-- `{coBispinorUp p | α β = εL | α α' ⊗ εR | β β'⊗ coBispinorDown p | α' β' }ᵀ`.
proof: expand `coBispinorDown` and use fact that metrics contract to the identity.
-/
informal_lemma coBispinorUp_eq_metric_contr_coBispinorDown where
math :≈ "{coBispinorUp p | α β = εL | α α' ⊗ εR | β β'⊗ coBispinorDown p | α' β' }ᵀ"
proof :≈ "Expand `coBispinorDown` and use fact that metrics contract to the identity."
deps :≈ [``coBispinorUp, ``coBispinorDown, ``leftMetric, ``rightMetric]
deps := [``coBispinorUp, ``coBispinorDown, ``leftMetric, ``rightMetric]
lemma contrBispinorDown_expand (p : complexContr) :
{contrBispinorDown p | α β}ᵀ.tensor =

66
HepLean/Lorentz/ComplexTensor/Metrics/Lemmas.lean
View file

@ -31,29 +31,29 @@ namespace complexLorentzTensor
-/
/-- The covariant metric is symmetric `{η' | μ ν = η' | ν μ}ᵀ`. -/
informal_lemma coMetric_symm where
math :≈ "The covariant metric is symmetric {η' | μ ν = η' | ν μ}ᵀ"
deps :≈ [``coMetric]
deps := [``coMetric]
/-- The contravariant metric is symmetric `{η | μ ν = η | ν μ}ᵀ`. -/
informal_lemma contrMetric_symm where
math :≈ "The contravariant metric is symmetric {η | μ ν = η | ν μ}ᵀ"
deps :≈ [``contrMetric]
deps := [``contrMetric]
/-- The left metric is antisymmetric `{εL | α α' = - εL | α' α}ᵀ`. -/
informal_lemma leftMetric_antisymm where
math :≈ "The left metric is antisymmetric {εL | α α' = - εL | α' α}ᵀ"
deps :≈ [``leftMetric]
deps := [``leftMetric]
/-- The right metric is antisymmetric `{εR | β β' = - εR | β' β}ᵀ`. -/
informal_lemma rightMetric_antisymm where
math :≈ "The right metric is antisymmetric {εR | β β' = - εR | β' β}ᵀ"
deps :≈ [``rightMetric]
deps := [``rightMetric]
/-- The alt-left metric is antisymmetric `{εL' | α α' = - εL' | α' α}ᵀ`. -/
informal_lemma altLeftMetric_antisymm where
math :≈ "The alt-left metric is antisymmetric {εL' | α α' = - εL' | α' α}ᵀ"
deps :≈ [``altLeftMetric]
deps := [``altLeftMetric]
/-- The alt-right metric is antisymmetric `{εR' | β β' = - εR' | β' β}ᵀ`. -/
informal_lemma altRightMetric_antisymm where
math :≈ "The alt-right metric is antisymmetric {εR' | β β' = - εR' | β' β}ᵀ"
deps :≈ [``altRightMetric]
deps := [``altRightMetric]
/-!
@ -61,35 +61,41 @@ informal_lemma altRightMetric_antisymm where
-/
/-- The contraction of the covariant metric with the contravariant metric is the unit
`{η' | μ ρ ⊗ η | ρ ν = δ' | μ ν}ᵀ`.
-/
informal_lemma coMetric_contr_contrMetric where
math :≈ "The contraction of the covariant metric with the contravariant metric is the unit
{η' | μ ρ ⊗ η | ρ ν = δ' | μ ν}ᵀ"
deps :≈ [``coMetric, ``contrMetric, ``coContrUnit]
deps := [``coMetric, ``contrMetric, ``coContrUnit]
/-- The contraction of the contravariant metric with the covariant metric is the unit
`{η | μ ρ ⊗ η' | ρ ν = δ | μ ν}ᵀ`.
-/
informal_lemma contrMetric_contr_coMetric where
math :≈ "The contraction of the contravariant metric with the covariant metric is the unit
{η | μ ρ ⊗ η' | ρ ν = δ | μ ν}ᵀ"
deps :≈ [``contrMetric, ``coMetric, ``contrCoUnit]
deps := [``contrMetric, ``coMetric, ``contrCoUnit]
/-- The contraction of the left metric with the alt-left metric is the unit
`{εL | α β ⊗ εL' | β γ = δL | α γ}ᵀ`.
-/
informal_lemma leftMetric_contr_altLeftMetric where
math :≈ "The contraction of the left metric with the alt-left metric is the unit
{εL | α β ⊗ εL' | β γ = δL | α γ}ᵀ"
deps :≈ [``leftMetric, ``altLeftMetric, ``leftAltLeftUnit]
deps := [``leftMetric, ``altLeftMetric, ``leftAltLeftUnit]
/-- The contraction of the right metric with the alt-right metric is the unit
`{εR | α β ⊗ εR' | β γ = δR | α γ}ᵀ`.
-/
informal_lemma rightMetric_contr_altRightMetric where
math :≈ "The contraction of the right metric with the alt-right metric is the unit
{εR | α β ⊗ εR' | β γ = δR | α γ}ᵀ"
deps :≈ [``rightMetric, ``altRightMetric, ``rightAltRightUnit]
deps := [``rightMetric, ``altRightMetric, ``rightAltRightUnit]
/-- The contraction of the alt-left metric with the left metric is the unit
`{εL' | α β ⊗ εL | β γ = δL' | α γ}ᵀ`.
-/
informal_lemma altLeftMetric_contr_leftMetric where
math :≈ "The contraction of the alt-left metric with the left metric is the unit
{εL' | α β ⊗ εL | β γ = δL' | α γ}ᵀ"
deps :≈ [``altLeftMetric, ``leftMetric, ``altLeftLeftUnit]
deps := [``altLeftMetric, ``leftMetric, ``altLeftLeftUnit]
/-- The contraction of the alt-right metric with the right metric is the unit
`{εR' | α β ⊗ εR | β γ = δR' | α γ}ᵀ`.
-/
informal_lemma altRightMetric_contr_rightMetric where
math :≈ "The contraction of the alt-right metric with the right metric is the unit
{εR' | α β ⊗ εR | β γ = δR' | α γ}ᵀ"
deps :≈ [``altRightMetric, ``rightMetric, ``altRightRightUnit]
deps := [``altRightMetric, ``rightMetric, ``altRightRightUnit]
/-!

32
HepLean/Lorentz/ComplexTensor/Units/Symm.lean
View file

@ -31,32 +31,32 @@ namespace complexLorentzTensor
-/
/-- Swapping indices of `coContrUnit` returns `contrCoUnit`: `{δ' | μ ν = δ | ν μ}ᵀ`. -/
informal_lemma coContrUnit_symm where
math :≈ "Swapping indices of coContrUnit returns contrCoUnit, i.e. {δ' | μ ν = δ | ν μ}.ᵀ"
deps :≈ [``coContrUnit, ``contrCoUnit]
deps := [``coContrUnit, ``contrCoUnit]
/-- Swapping indices of `contrCoUnit` returns `coContrUnit`: `{δ | μ ν = δ' | ν μ}ᵀ`. -/
informal_lemma contrCoUnit_symm where
math :≈ "Swapping indices of contrCoUnit returns coContrUnit, i.e. {δ | μ ν = δ' | ν μ}ᵀ"
deps :≈ [``contrCoUnit, ``coContrUnit]
deps := [``contrCoUnit, ``coContrUnit]
/-- Swapping indices of `altLeftLeftUnit` returns `leftAltLeftUnit`: `{δL' | α α' = δL | α' α}ᵀ`. -/
informal_lemma altLeftLeftUnit_symm where
math :≈ "Swapping indices of altLeftLeftUnit returns leftAltLeftUnit, i.e.
{δL' | α α' = δL | α' α}ᵀ"
deps :≈ [``altLeftLeftUnit, ``leftAltLeftUnit]
deps := [``altLeftLeftUnit, ``leftAltLeftUnit]
/-- Swapping indices of `leftAltLeftUnit` returns `altLeftLeftUnit`: `{δL | α α' = δL' | α' α}ᵀ`. -/
informal_lemma leftAltLeftUnit_symm where
math :≈ "Swapping indices of leftAltLeftUnit returns altLeftLeftUnit, i.e.
{δL | α α' = δL' | α' α}ᵀ"
deps :≈ [``leftAltLeftUnit, ``altLeftLeftUnit]
deps := [``leftAltLeftUnit, ``altLeftLeftUnit]
/-- Swapping indices of `altRightRightUnit` returns `rightAltRightUnit`:
`{δR' | β β' = δR | β' β}ᵀ`.
-/
informal_lemma altRightRightUnit_symm where
math :≈ "Swapping indices of altRightRightUnit returns rightAltRightUnit, i.e.
{δR' | β β' = δR | β' β}ᵀ"
deps :≈ [``altRightRightUnit, ``rightAltRightUnit]
deps := [``altRightRightUnit, ``rightAltRightUnit]
/-- Swapping indices of `rightAltRightUnit` returns `altRightRightUnit`:
`{δR | β β' = δR' | β' β}ᵀ`.
-/
informal_lemma rightAltRightUnit_symm where
math :≈ "Swapping indices of rightAltRightUnit returns altRightRightUnit, i.e.
{δR | β β' = δR' | β' β}ᵀ"
deps :≈ [``rightAltRightUnit, ``altRightRightUnit]
deps := [``rightAltRightUnit, ``altRightRightUnit]
end complexLorentzTensor

12
HepLean/Lorentz/Group/Restricted.lean
View file

@ -4,6 +4,7 @@ Released under Apache 2.0 license as described in the file LICENSE.
Authors: Joseph Tooby-Smith
-/
import HepLean.Lorentz.Group.Orthochronous
import HepLean.Meta.Informal.Basic
/-!
# The Restricted Lorentz Group
@ -16,17 +17,10 @@ TODO "Prove that every member of the restricted Lorentz group is
TODO "Prove restricted Lorentz group equivalent to connected component of identity
of the Lorentz group."
noncomputable section
open Matrix
open Complex
open ComplexConjugate
namespace LorentzGroup
/-- The subgroup of the Lorentz group consisting of elements which are proper and orthochronous. -/
informal_definition Restricted where
math :≈ "The subgroup of the Lorentz group consisting of elements which
are proper and orthochronous."
deps :≈ [``LorentzGroup, ``IsProper, ``IsOrthochronous]
deps := [``LorentzGroup, ``IsProper, ``IsOrthochronous]
end LorentzGroup

1
HepLean/Lorentz/RealVector/Modules.lean
View file

@ -3,7 +3,6 @@ Copyright (c) 2024 Joseph Tooby-Smith. All rights reserved.
Released under Apache 2.0 license as described in the file LICENSE.
Authors: Joseph Tooby-Smith
-/
import HepLean.Meta.Informal.Basic
import HepLean.Lorentz.PauliMatrices.SelfAdjoint
/-!

4
HepLean/Lorentz/SL2C/Basic.lean
View file

@ -307,9 +307,9 @@ lemma toLorentzGroup_det_one (M : SL(2, ℂ)) : det (toLorentzGroup M).val = 1 :
_ = M.val.det := congrArg det h.symm
_ = 1 := M.property
/-- The homomorphism from `SL(2, ℂ)` to the restricted Lorentz group. -/
informal_lemma toRestrictedLorentzGroup where
math :≈ "The homomorphism from `SL(2, ℂ)` to the restricted Lorentz group."
deps :≈ [``toLorentzGroup, ``toLorentzGroup_det_one, ``toLorentzGroup_isOrthochronous,
deps := [``toLorentzGroup, ``toLorentzGroup_det_one, ``toLorentzGroup_isOrthochronous,
``LorentzGroup.Restricted]
TODO "Define homomorphism from `SL(2, ℂ)` to the restricted Lorentz group."

14
HepLean/Lorentz/Weyl/Basic.lean
View file

@ -284,15 +284,17 @@ lemma leftHandedAltEquiv_inv_hom_apply (ψ : altLeftHanded) :
leftHandedAltEquiv.inv.hom ψ =
LeftHandedModule.toFin2ℂEquiv.symm (!![0, -1; 1, 0] *ᵥ ψ.toFin2ℂ) := rfl
/-- The linear equivalence between `rightHandedWeyl` and `altRightHandedWeyl` given by multiplying
an element of `rightHandedWeyl` by the matrix `εᵃ⁰ᵃ¹ = !![0, 1; -1, 0]]`.
-/
informal_definition rightHandedWeylAltEquiv where
math :≈ "The linear equiv between rightHandedWeyl and altRightHandedWeyl given
by multiplying an element of rightHandedWeyl by the matrix `εᵃ⁰ᵃ¹ = !![0, 1; -1, 0]]`"
deps :≈ [``rightHanded, ``altRightHanded]
deps := [``rightHanded, ``altRightHanded]
/-- The linear equivalence `rightHandedWeylAltEquiv` is equivariant with respect to the action of
`SL(2,C)` on `rightHandedWeyl` and `altRightHandedWeyl`.
-/
informal_lemma rightHandedWeylAltEquiv_equivariant where
math :≈ "The linear equiv rightHandedWeylAltEquiv is equivariant with respect to the
action of SL(2,C) on rightHandedWeyl and altRightHandedWeyl."
deps :≈ [``rightHandedWeylAltEquiv]
deps := [``rightHandedWeylAltEquiv]
end

3
HepLean/Meta/AllFilePaths.lean
View file

@ -3,7 +3,6 @@ Copyright (c) 2024 Joseph Tooby-Smith. All rights reserved.
Released under Apache 2.0 license.
Authors: Joseph Tooby-Smith
-/
import Lean
import HepLean.Meta.TODO.Basic
/-!
@ -11,7 +10,7 @@ import HepLean.Meta.TODO.Basic
-/
open Lean Elab System
open System
TODO "Make this definition more functional in style. In other words, remove the for loop."

218
HepLean/Meta/Basic.lean
View file

@ -3,19 +3,23 @@ Copyright (c) 2024 Joseph Tooby-Smith. All rights reserved.
Released under Apache 2.0 license.
Authors: Joseph Tooby-Smith
-/
import Batteries.Lean.HashSet
import Mathlib.Lean.Expr.Basic
import Mathlib.Lean.CoreM
import ImportGraph.RequiredModules
import HepLean.Meta.Informal.Basic
/-!
## Basic Lean meta programming commands
-/
namespace HepLean
open Lean System Meta
/-- The size of a flattened array of arrays. -/
def Array.flatSize {α} : Array (Array α) → Nat :=
foldl (init := 0) fun sizeAcc as => sizeAcc + as.size
/-- The size of a flattened array of arrays after applying an element-wise filter. -/
def Array.flatFilterSizeM {α m} [Monad m] (p : α → m Bool) : Array (Array α) → m Nat :=
foldlM (init := 0) fun sizeAcc as => return sizeAcc + (← as.filterM p).size
open Lean
/-!
@ -24,194 +28,166 @@ open Lean System Meta
-/
/-- Gets all imports within HepLean. -/
def allImports : IO (Array Import) := do
def HepLean.allImports : IO (Array Import) := do
initSearchPath (← findSysroot)
let mods : Name := `HepLean
let imp : Import := {module := mods}
let mFile ← findOLean imp.module
unless (← mFile.pathExists) do
throw <| IO.userError s!"object file '{mFile}' of module {imp.module} does not exist"
let mods := `HepLean
let mFile ← findOLean mods
unless ← mFile.pathExists do
throw <| IO.userError s!"object file '{mFile}' of module {mods} does not exist"
let (hepLeanMod, _) ← readModuleData mFile
let imports := hepLeanMod.imports.filter (fun c => c.module ≠ `Init)
return imports
hepLeanMod.imports.filterM fun c => return c.module != `Init
/-- Number of files within HepLean. -/
def noImports : IO Nat := do
def HepLean.noImports : IO Nat := do
let imports ← allImports
pure imports.size
return imports.size
/-- Gets all constants from an import. -/
def Imports.getConsts (imp : Import) : IO (Array ConstantInfo) := do
def HepLean.Imports.getConsts (imp : Import) : IO (Array ConstantInfo) := do
let mFile ← findOLean imp.module
let (modData, _) ← readModuleData mFile
pure modData.constants
return modData.constants
/-- Gets all user defined constants from an import. -/
def Imports.getUserConsts (imp : Import) : MetaM (Array ConstantInfo) := do
def HepLean.Imports.getUserConsts (imp : Import) : CoreM (Array ConstantInfo) := do
let env ← getEnv
let x := (← Imports.getConsts imp).filter (fun c => ¬ c.name.isInternal)
let x := x.filter (fun c => ¬ Lean.isCasesOnRecursor env c.name)
let x := x.filter (fun c => ¬ Lean.isRecOnRecursor env c.name)
let x := x.filter (fun c => ¬ Lean.isNoConfusion env c.name)
let x := x.filter (fun c => ¬ Lean.isBRecOnRecursor env c.name)
let x := x.filter (fun c => ¬ Lean.isAuxRecursorWithSuffix env c.name Lean.binductionOnSuffix)
let x := x.filter (fun c => ¬ Lean.isAuxRecursorWithSuffix env c.name Lean.belowSuffix)
let x := x.filter (fun c => ¬ Lean.isAuxRecursorWithSuffix env c.name Lean.ibelowSuffix)
let consts ← Imports.getConsts imp
consts.filterM fun c =>
let name := c.name
return !name.isInternal
&& !isCasesOnRecursor env name
&& !isRecOnRecursor env name
&& !isNoConfusion env name
&& !isBRecOnRecursor env name
&& !isAuxRecursorWithSuffix env name binductionOnSuffix
&& !isAuxRecursorWithSuffix env name belowSuffix
&& !isAuxRecursorWithSuffix env name ibelowSuffix
/- Removing syntax category declarations. -/
let x := x.filter (fun c => ¬ c.name.toString = "Informal.informalAssignment.quot")
let x := x.filter (fun c => ¬ c.name.toString = "TensorTree.indexExpr.quot")
let x := x.filter (fun c => ¬ c.name.toString = "TensorTree.tensorExpr.quot")
pure x
&& name.toString != "TensorTree.indexExpr.quot"
&& name.toString != "TensorTree.tensorExpr.quot"
/-- Turns a name into a system file path. -/
def Lean.Name.toFilePath (c : Name) : System.FilePath :=
System.mkFilePath (c.toString.splitOn ".") |>.addExtension "lean"
/-- Lines from import. -/
def Imports.getLines (imp : Import) : IO (Array String) := do
let filePath := (mkFilePath (imp.module.toString.split (· == '.'))).addExtension "lean"
let lines ← IO.FS.lines filePath
return lines
def HepLean.Imports.getLines (imp : Import) : IO (Array String) := do
IO.FS.lines imp.module.toFilePath
namespace Lean.Name
/-!
## Name
-/
variable {m} [Monad m] [MonadEnv m] [MonadLiftT BaseIO m]
/-- Turns a name into a Lean file. -/
def Name.toFile (c : Name) : MetaM String := do
return s!"./{c.toString.replace "." "/" ++ ".lean"}"
def toRelativeFilePath (c : Name) : System.FilePath :=
System.FilePath.join "." c.toFilePath
/-- Turns a name, which represents a module, into a link to github. -/
def Name.toGitHubLink (c : Name) (l : Nat := 0) : MetaM String := do
let headerLink := "https://github.com/HEPLean/HepLean/blob/master/"
let filePart := (c.toString.replace "." "/") ++ ".lean"
let linePart := "#L" ++ toString l
return headerLink ++ filePart ++ linePart
def toGitHubLink (c : Name) (line : Nat) : String :=
s!"https://github.com/HEPLean/HepLean/blob/master/{c.toFilePath}#L{line}"
/-- Given a name, returns the line number. -/
def Name.lineNumber (c : Name) : MetaM Nat := do
def lineNumber (c : Name) : m Nat := do
match ← findDeclarationRanges? c with
| some decl => pure decl.range.pos.line
| some decl => return decl.range.pos.line
| none => panic! s!"{c} is a declaration without position"
/-- Given a name, returns the file name corresponding to that declaration. -/
def Name.fileName (c : Name) : MetaM Name := do
def fileName (c : Name) : m Name := do
let env ← getEnv
let x := env.getModuleFor? c
match x with
| some c => pure c
match env.getModuleFor? c with
| some decl => return decl
| none => panic! s!"{c} is a declaration without position"
/-- Returns the location of a name. -/
def Name.location (c : Name) : MetaM String := do
def location (c : Name) : m String := do
let env ← getEnv
let x := env.getModuleFor? c
match x with
| some decl => pure ((← Name.toFile decl) ++ ":" ++ toString (← Name.lineNumber c) ++ " "
++ c.toString)
match env.getModuleFor? c with
| some decl => return s!"{decl.toRelativeFilePath}:{← c.lineNumber} {c}"
| none => panic! s!"{c} is a declaration without position"
/-- Determines if a name has a location. -/
def Name.hasPos (c : Name) : MetaM Bool := do
match ← findDeclarationRanges? c with
| some _ => pure true
| none => pure false
def hasPos (c : Name) : m Bool := do
let ranges? ← findDeclarationRanges? c
return ranges?.isSome
/-- Determines if a name has a doc string. -/
def Name.hasDocString (c : Name) : MetaM Bool := do
def hasDocString (c : Name) : CoreM Bool := do
let env ← getEnv
let doc ← Lean.findDocString? env c
match doc with
| some _ => pure true
| none => pure false
let doc? ← findDocString? env c
return doc?.isSome
/-- The doc string from a name. -/
def Name.getDocString (c : Name) : MetaM String := do
def getDocString (c : Name) : CoreM String := do
let env ← getEnv
let doc ← Lean.findDocString? env c
match doc with
| some doc => pure doc
| none => pure ""
let doc? ← findDocString? env c
return doc?.getD ""
/-- Given a name, returns the source code defining that name. -/
def Name.getDeclString (name : Name) : MetaM String := do
def getDeclString (name : Name) : CoreM String := do
let env ← getEnv
let decl ← findDeclarationRanges? name
match decl with
| some decl =>
let startLine := decl.range.pos
let endLine := decl.range.endPos
let fileName? := env.getModuleFor? name
match fileName? with
match ← findDeclarationRanges? name with
| some { range := { pos, endPos, .. }, .. } =>
match env.getModuleFor? name with
| some fileName =>
let fileContent ← IO.FS.readFile { toString := (← Name.toFile fileName)}
let fileContent ← IO.FS.readFile fileName.toRelativeFilePath
let fileMap := fileContent.toFileMap
let startPos := fileMap.ofPosition startLine
let endPos := fileMap.ofPosition endLine
let text := fileMap.source.extract startPos endPos
pure text
| none =>
pure ""
| none => pure ""
return fileMap.source.extract (fileMap.ofPosition pos) (fileMap.ofPosition endPos)
| none => return ""
| none => return ""
end Lean.Name
namespace HepLean
/-- Number of definitions. -/
def noDefs : MetaM Nat := do
let imports ← allImports
let x ← imports.mapM Imports.getUserConsts
let x := x.flatten
let x := x.filter (fun c => c.isDef)
let x ← x.filterM (fun c => (Name.hasPos c.name))
pure x.toList.length
def noDefs : CoreM Nat := do
let imports ← HepLean.allImports
let x ← imports.mapM HepLean.Imports.getUserConsts
x.flatFilterSizeM fun c => return c.isDef && (← c.name.hasPos)
/-- Number of definitions. -/
def noLemmas : MetaM Nat := do
let imports ← allImports
let x ← imports.mapM Imports.getUserConsts
let x := x.flatten
let x := x.filter (fun c => ¬ c.isDef)
let x ← x.filterM (fun c => (Name.hasPos c.name))
pure x.toList.length
def noLemmas : CoreM Nat := do
let imports ← HepLean.allImports
let x ← imports.mapM HepLean.Imports.getUserConsts
x.flatFilterSizeM fun c => return !c.isDef && (← c.name.hasPos)
/-- Number of definitions without a doc-string. -/
def noDefsNoDocString : MetaM Nat := do
let imports ← allImports
let x ← imports.mapM Imports.getUserConsts
let x := x.flatten
let x := x.filter (fun c => c.isDef)
let x ← x.filterM (fun c => (Name.hasPos c.name))
let x ← x.filterM (fun c => do
return Bool.not (← (Name.hasDocString c.name)))
pure x.toList.length
def noDefsNoDocString : CoreM Nat := do
let imports ← HepLean.allImports
let x ← imports.mapM HepLean.Imports.getUserConsts
x.flatFilterSizeM fun c =>
return c.isDef && (← c.name.hasPos) && !(← c.name.hasDocString)
/-- Number of definitions without a doc-string. -/
def noLemmasNoDocString : MetaM Nat := do
let imports ← allImports
let x ← imports.mapM Imports.getUserConsts
let x := x.flatten
let x := x.filter (fun c => ¬ c.isDef)
let x ← x.filterM (fun c => (Name.hasPos c.name))
let x ← x.filterM (fun c => do
return Bool.not (← (Name.hasDocString c.name)))
pure x.toList.length
def noLemmasNoDocString : CoreM Nat := do
let imports ← HepLean.allImports
let x ← imports.mapM HepLean.Imports.getUserConsts
x.flatFilterSizeM fun c =>
return !c.isDef && (← c.name.hasPos) && !(← c.name.hasDocString)
/-- The number of lines in HepLean. -/
def noLines : IO Nat := do
let imports ← HepLean.allImports
let x ← imports.mapM HepLean.Imports.getLines
let x := x.flatten
pure x.toList.length
return x.flatSize
/-- The number of TODO items. -/
def noTODOs : IO Nat := do
let imports ← HepLean.allImports
let x ← imports.mapM HepLean.Imports.getLines
let x := x.flatten
let x := x.filter fun l => l.startsWith "TODO "
pure x.size
x.flatFilterSizeM fun l => return l.startsWith "TODO "
/-- The number of files with a TODO item. -/
def noFilesWithTODOs : IO Nat := do
let imports ← HepLean.allImports
let x ← imports.mapM HepLean.Imports.getLines
let x := x.filter (fun M => M.any fun l => l.startsWith "TODO ")
pure x.size
let x := x.filter fun bs => bs.any fun l => l.startsWith "TODO "
return x.size
end HepLean

240
HepLean/Meta/Informal/Basic.lean
View file

@ -3,245 +3,57 @@ Copyright (c) 2024 Joseph Tooby-Smith. All rights reserved.
Released under Apache 2.0 license.
Authors: Joseph Tooby-Smith
-/
import Lean
import HepLean.Meta.TODO.Basic
import Lean.Parser.Term
/-!
## Informal definitions and lemmas
This file contains the necessary structures that must be imported into a file
for it to contain informal definitions and lemmas.
This file contains the necessary structures that must be imported into a file for it to contain
informal definitions and lemmas.
Everything else about informal definitions and lemmas are in the `Informal.Post` module.
-/
open Lean Elab System
TODO "Can likely make this a bona-fide command."
/-- The structure representing an informal definition. -/
structure InformalDefinition where
/-- The name of the informal definition. This is autogenerated. -/
name : Name
/-- The mathematical description of the definition. -/
math : String
/-- The physics description of the definition. -/
physics : String
/-- References. -/
ref : String
/-- The names of top-level commands we expect this definition to depend on. -/
dependencies : List Name
deps : List Lean.Name
/-- The structure representing an informal proof. -/
/-- The structure representing an informal lemma. -/
structure InformalLemma where
/-- The name of the informal lemma. This is autogenerated. -/
name : Name
/-- The mathematical description of the lemma. -/
math : String
/-- The physics description of the lemma. -/
physics : String
/-- A description of the proof. -/
proof : String
/-- References. -/
ref : String
/-- The names of top-level commands we expect this lemma to depend on. -/
dependencies : List Name
deps : List Lean.Name
namespace Informal
/-- The Parser.Category we will use for assignments. -/
declare_syntax_cat informalAssignment
/-- The syntax describing an informal assignment of `ident` to a string. -/
syntax (name := informalAssignment) ident ":≈" str : informalAssignment
/-- The syntax describing an informal assignment of `ident` to a list. -/
syntax (name := informalAssignmentDeps) ident ":≈" "[" sepBy(term, ",") "]" : informalAssignment
/-!
## Syntax
Using macros for syntax rewriting works better with the language server compared to
`Lake.DSL.LeanLibDecl`. Hovering over any definition of `informal_definition` or `informal_lemma`
gives a proper type hint like any proper definition using `def` whereas definitions of `lake_lib`
and `lake_exe` don't show docstrings and infer the type `Lean.Name`.
-/
/-- The syntax for the command informal_definition. -/
syntax (name := informal_definition) "informal_definition " ident
" where " (colGt informalAssignment)* : command
/-- An informal definition is a definition which is not type checked, and is written
as a string literal. It can be used to plan out sections for future formalization, or to
include results which the formalization is not immediately known.
Each informal definition must included a
`math :≈ "..."`
entry, but can also include the following entries
`physics :≈ "..."`, `ref :≈ "..."`, and `deps :≈ [...]`. -/
macro "informal_definition " name:ident " where " assignments:informalAssignment* : command => do
let mut math_def? : Option (TSyntax `term) := none
let mut physics_def? : Option (TSyntax `term) := none
let mut ref_def? : Option (TSyntax `term) := none
let mut dep_def? : Option (TSyntax `term) := none
for assignment in assignments do
match assignment with
| `(informalAssignment| physics :≈ $val:str) =>
let some strVal := val.raw.isStrLit? | Macro.throwError "Expected string literal for physics"
physics_def? := some (← `($(Lean.quote strVal)))
| `(informalAssignment| math :≈ $val:str) =>
let some strVal := val.raw.isStrLit? | Macro.throwError "Expected string literal for math"
math_def? := some (← `($(Lean.quote strVal)))
| `(informalAssignment| ref :≈ $val:str) =>
let some strVal := val.raw.isStrLit? | Macro.throwError "Expected string literal for ref"
ref_def? := some (← `($(Lean.quote strVal)))
| `(informalAssignmentDeps| deps :≈ [$deps,*]) =>
dep_def? := some (← `([$deps,*]))
| _ => Macro.throwError "invalid assignment syntax in informal_definition"
unless math_def?.isSome do
Macro.throwError "A 'math' assignments is required"
`(
/-- An informal definition. -/
def $name : InformalDefinition := {
name := $(Lean.quote name.getId),
physics := $(physics_def?.getD (← `("No physics description provided"))),
math := $(math_def?.getD (panic! "math not assigned")),
ref := $(ref_def?.getD (← `("No references provided"))),
dependencies := $(dep_def?.getD (← `([])))
})
open Lean.Parser.Term
/-- The syntax for the command informal_definition. -/
syntax (name := informal_definition_note) "informal_definition_note " ident
" where " (colGt informalAssignment)* : command
/-- A placeholder for definitions to be formalized in the future. Docstrings of informal definitions
should outline its mathematical or physical content and specify useful references. Use the attribute
`note_attr_informal` from `HepLean.Meta.Notes.Basic` to mark the informal definition as a note.
-/
macro (name := informalDefinitionDecl)
doc?:(docComment)? attrs?:(attributes)? "informal_definition " name:ident body:declVal : command =>
`($[$doc?]? $[$attrs?]? def $name : InformalDefinition $body:declVal)
/-- An informal definition is a definition which is not type checked, and is written
as a string literal. It can be used to plan out sections for future formalization, or to
include results which the formalization is not immediately known.
Each informal definition must included a
`math :≈ "..."`
entry, but can also include the following entries
`physics :≈ "..."`, `ref :≈ "..."`, and `deps :≈ [...]`. -/
macro "informal_definition_note " name:ident " where " assignments:informalAssignment* :
command => do
let mut math_def? : Option (TSyntax `term) := none
let mut physics_def? : Option (TSyntax `term) := none
let mut ref_def? : Option (TSyntax `term) := none
let mut dep_def? : Option (TSyntax `term) := none
for assignment in assignments do
match assignment with
| `(informalAssignment| physics :≈ $val:str) =>
let some strVal := val.raw.isStrLit? | Macro.throwError "Expected string literal for physics"
physics_def? := some (← `($(Lean.quote strVal)))
| `(informalAssignment| math :≈ $val:str) =>
let some strVal := val.raw.isStrLit? | Macro.throwError "Expected string literal for math"
math_def? := some (← `($(Lean.quote strVal)))
| `(informalAssignment| ref :≈ $val:str) =>
let some strVal := val.raw.isStrLit? | Macro.throwError "Expected string literal for ref"
ref_def? := some (← `($(Lean.quote strVal)))
| `(informalAssignmentDeps| deps :≈ [$deps,*]) =>
dep_def? := some (← `([$deps,*]))
| _ => Macro.throwError "invalid assignment syntax in informal_definition"
unless math_def?.isSome do
Macro.throwError "A 'math' assignments is required"
`(
/-- An informal definition. -/
@[note_attr_informal]
def $name : InformalDefinition := {
name := $(Lean.quote name.getId),
physics := $(physics_def?.getD (← `("No physics description provided"))),
math := $(math_def?.getD (panic! "math not assigned")),
ref := $(ref_def?.getD (← `("No references provided"))),
dependencies := $(dep_def?.getD (← `([])))
})
/-- The syntax for the command `informal_lemma`. -/
syntax (name := informal_lemma) "informal_lemma " ident " where "
(colGt informalAssignment)* : command
/-- An informal lemma is a lemma which is not type checked, and is written
as a string literal. It can be used to plan out sections for future formalization, or to
include results which the formalization is not immediately known.
Every informal lemma must included a
`math :≈ "..."`
entry, but can also include the following entries
`physics :≈ "..."`, `proof :≈ "..."`, `ref :≈ "..."`, and `deps :≈ [...]`. -/
macro "informal_lemma " name:ident " where " assignments:informalAssignment* : command => do
let mut math_def? : Option (TSyntax `term) := none
let mut physics_def? : Option (TSyntax `term) := none
let mut proof_def? : Option (TSyntax `term) := none
let mut ref_def? : Option (TSyntax `term) := none
let mut dep_def? : Option (TSyntax `term) := none
for assignment in assignments do
match assignment with
| `(informalAssignment| physics :≈ $val:str) =>
let some strVal := val.raw.isStrLit? | Macro.throwError "Expected string literal for physics"
physics_def? := some (← `($(Lean.quote strVal)))
| `(informalAssignment| math :≈ $val:str) =>
let some strVal := val.raw.isStrLit? | Macro.throwError "Expected string literal for math"
math_def? := some (← `($(Lean.quote strVal)))
| `(informalAssignment| proof :≈ $val:str) =>
let some strVal := val.raw.isStrLit? | Macro.throwError "Expected string literal for proof"
proof_def? := some (← `($(Lean.quote strVal)))
| `(informalAssignment| ref :≈ $val:str) =>
let some strVal := val.raw.isStrLit? | Macro.throwError "Expected string literal for ref"
ref_def? := some (← `($(Lean.quote strVal)))
| `(informalAssignmentDeps| deps :≈ [$deps,*]) =>
dep_def? := some (← `([$deps,*]))
| _ => Macro.throwError "invalid assignment syntax"
unless math_def?.isSome do
Macro.throwError "A 'math' assignments is required"
`(
/-- An informal lemma. -/
def $name : InformalLemma := {
name := $(Lean.quote name.getId),
physics := $(physics_def?.getD (← `("No physics description provided"))),
math := $(math_def?.getD (panic! "math not assigned")),
proof := $(proof_def?.getD (← `("No proof description provided"))),
ref := $(ref_def?.getD (← `("No references provided"))),
dependencies := $(dep_def?.getD (← `([])))
})
/-- The syntax for the command `informal_lemma`. -/
syntax (name := informal_lemma_note) "informal_lemma_note " ident " where "
(colGt informalAssignment)* : command
/-- An informal lemma is a lemma which is not type checked, and is written
as a string literal. It can be used to plan out sections for future formalization, or to
include results which the formalization is not immediately known.
Every informal lemma must included a
`math :≈ "..."`
entry, but can also include the following entries
`physics :≈ "..."`, `proof :≈ "..."`, `ref :≈ "..."`, and `deps :≈ [...]`. -/
macro "informal_lemma_note " name:ident " where " assignments:informalAssignment* : command => do
let mut math_def? : Option (TSyntax `term) := none
let mut physics_def? : Option (TSyntax `term) := none
let mut proof_def? : Option (TSyntax `term) := none
let mut ref_def? : Option (TSyntax `term) := none
let mut dep_def? : Option (TSyntax `term) := none
for assignment in assignments do
match assignment with
| `(informalAssignment| physics :≈ $val:str) =>
let some strVal := val.raw.isStrLit? | Macro.throwError "Expected string literal for physics"
physics_def? := some (← `($(Lean.quote strVal)))
| `(informalAssignment| math :≈ $val:str) =>
let some strVal := val.raw.isStrLit? | Macro.throwError "Expected string literal for math"
math_def? := some (← `($(Lean.quote strVal)))
| `(informalAssignment| proof :≈ $val:str) =>
let some strVal := val.raw.isStrLit? | Macro.throwError "Expected string literal for proof"
proof_def? := some (← `($(Lean.quote strVal)))
| `(informalAssignment| ref :≈ $val:str) =>
let some strVal := val.raw.isStrLit? | Macro.throwError "Expected string literal for ref"
ref_def? := some (← `($(Lean.quote strVal)))
| `(informalAssignmentDeps| deps :≈ [$deps,*]) =>
dep_def? := some (← `([$deps,*]))
| _ => Macro.throwError "invalid assignment syntax"
unless math_def?.isSome do
Macro.throwError "A 'math' assignments is required"
`(
/-- An informal lemma. -/
@[note_attr_informal]
def $name : InformalLemma := {
name := $(Lean.quote name.getId),
physics := $(physics_def?.getD (← `("No physics description provided"))),
math := $(math_def?.getD (panic! "math not assigned")),
proof := $(proof_def?.getD (← `("No proof description provided"))),
ref := $(ref_def?.getD (← `("No references provided"))),
dependencies := $(dep_def?.getD (← `([])))
})
/-- A placeholder for lemmas to be formalized in the future. Docstrings of informal lemmas
should outline its mathematical or physical content and specify useful references. Use the attribute
`note_attr_informal` from `HepLean.Meta.Notes.Basic` to mark the informal definition as a note.
-/
macro (name := informalLemmaDecl)
doc?:(docComment)? attrs?:(attributes)? "informal_lemma " name:ident body:declVal : command =>
`($[$doc?]? $[$attrs?]? def $name : InformalLemma $body:declVal)
end Informal

49
HepLean/Meta/Informal/Post.lean
View file

@ -4,74 +4,61 @@ Released under Apache 2.0 license.
Authors: Joseph Tooby-Smith
-/
import HepLean.Meta.Basic
import HepLean.Meta.Informal.Basic
/-!
## Informal definitions and lemmas
-/
open Lean Elab System
open Lean
namespace Informal
/-- Is true if and only if a `ConstantInfo` corresponds to an `InformalLemma` or a
`InformalDefinition`. -/
def isInformal (c : ConstantInfo) : Bool :=
match c with
| ConstantInfo.defnInfo c =>
if c.type.isAppOf ``InformalDefinition ∨ c.type.isAppOf ``InformalLemma then true else false
def isInformal : ConstantInfo → Bool
| .defnInfo c => c.type.isConstOf ``InformalDefinition ∨ c.type.isConstOf ``InformalLemma
| _ => false
/-- Is true if and only if a `ConstantInfo` corresponds to an `InformalLemma`. -/
def isInformalLemma (c : ConstantInfo) : Bool :=
match c with
| ConstantInfo.defnInfo c =>
if c.type.isAppOf ``InformalLemma then true else false
def isInformalLemma : ConstantInfo → Bool
| .defnInfo c => c.type.isConstOf ``InformalLemma
| _ => false
/-- Is true if and only if a `ConstantInfo` corresponds to an `InformalDefinition`. -/
def isInformalDef (c : ConstantInfo) : Bool :=
match c with
| ConstantInfo.defnInfo c =>
if c.type.isAppOf ``InformalDefinition then true else false
def isInformalDef : ConstantInfo → Bool
| .defnInfo c => c.type.isConstOf ``InformalDefinition
| _ => false
/-- Takes a `ConstantInfo` corresponding to a `InformalLemma` and returns
the corresponding `InformalLemma`. -/
unsafe def constantInfoToInformalLemma (c : ConstantInfo) : MetaM InformalLemma := do
unsafe def constantInfoToInformalLemma (c : ConstantInfo) : CoreM InformalLemma := do
match c with
| ConstantInfo.defnInfo c =>
Lean.Meta.evalExpr' InformalLemma ``InformalLemma c.value
| .defnInfo c => evalConstCheck InformalLemma ``InformalLemma c.name
| _ => panic! "Passed constantInfoToInformalLemma a `ConstantInfo` that is not a `InformalLemma`"
/-- Takes a `ConstantInfo` corresponding to a `InformalDefinition` and returns
the corresponding `InformalDefinition`. -/
unsafe def constantInfoToInformalDefinition (c : ConstantInfo) : MetaM InformalDefinition := do
unsafe def constantInfoToInformalDefinition (c : ConstantInfo) : CoreM InformalDefinition := do
match c with
| ConstantInfo.defnInfo c =>
Lean.Meta.evalExpr' InformalDefinition ``InformalDefinition c.value
| _ => panic! "Passed constantInfoToInformalDefinition a
`ConstantInfo` that is not a `InformalDefinition`"
| .defnInfo c => evalConstCheck InformalDefinition ``InformalDefinition c.name
| _ => panic!
"Passed constantInfoToInformalDefinition a `ConstantInfo` that is not a `InformalDefinition`"
end Informal
namespace HepLean
/-- The number of informal lemmas in HepLean. -/
def noInformalLemmas : MetaM Nat := do
def noInformalLemmas : CoreM Nat := do
let imports ← allImports
let x ← imports.mapM Imports.getUserConsts
let x := x.flatten
let x := x.filter (Informal.isInformal)
let x := x.filter (Informal.isInformalLemma)
pure x.toList.length
x.flatFilterSizeM fun c => return Informal.isInformalLemma c
/-- The number of informal definitions in HepLean. -/
def noInformalDefs : MetaM Nat := do
def noInformalDefs : CoreM Nat := do
let imports ← allImports
let x ← imports.mapM Imports.getUserConsts
let x := x.flatten
let x := x.filter (Informal.isInformal)
let x := x.filter (Informal.isInformalDef)
pure x.toList.length
x.flatFilterSizeM fun c => return Informal.isInformalDef c
end HepLean

5
HepLean/Meta/Notes/Basic.lean
View file

@ -3,10 +3,7 @@ Copyright (c) 2024 Joseph Tooby-Smith. All rights reserved.
Released under Apache 2.0 license.
Authors: Joseph Tooby-Smith
-/
import Batteries.Lean.HashSet
import Mathlib.Lean.Expr.Basic
import Mathlib.Lean.CoreM
import ImportGraph.RequiredModules
/-!
## Underlying structure for notes
@ -24,7 +21,7 @@ Other results relating to notes are in other files.
-/
namespace HepLean
open Lean System Meta
open Lean
/-- The information from a `note ...` command. To be used in a note file-/
structure NoteInfo where

84
HepLean/Meta/Notes/HTMLNote.lean
View file

@ -3,8 +3,9 @@ Copyright (c) 2024 Joseph Tooby-Smith. All rights reserved.
Released under Apache 2.0 license.
Authors: Joseph Tooby-Smith
-/
import HepLean.Meta.Notes.NoteFile
-- import DocGen4.Output.DocString
import HepLean.Meta.Informal.Post
import HepLean.Meta.Notes.NoteFile
/-!
## Turns a delaration into a html note structure.
@ -12,7 +13,7 @@ import HepLean.Meta.Informal.Post
-/
namespace HepLean
open Lean System Meta
open Lean
/-- A `HTMLNote` is a structure containing the html information from
individual contributions (commands, informal commands, note ..) etc. to a note file. -/
@ -25,47 +26,52 @@ structure HTMLNote where
line : Nat
/-- Converts a note infor into a HTMLNote. -/
def HTMLNote.ofNodeInfo (ni : NoteInfo) : MetaM HTMLNote := do
let line := ni.line
let decl := ni.content
let fileName := ni.fileName
pure { content := decl, fileName := fileName, line := line }
def HTMLNote.ofNodeInfo (ni : NoteInfo) : HTMLNote :=
{ ni with }
/-- An formal definition or lemma to html for a note. -/
def HTMLNote.ofFormal (name : Name) : MetaM HTMLNote := do
let line ← Name.lineNumber name
let decl ← Name.getDeclString name
let fileName ← Name.fileName name
let webAddress : String ← Name.toGitHubLink fileName line
let content :=
"<div class=\"code-block-container\">"
++ "<a href=\"" ++ webAddress ++ "\" class=\"code-button\">View/Improve</a>"
++"<pre><code>"
++ decl ++
"</code></pre></div>"
pure { content := content, fileName := fileName, line := line }
def HTMLNote.ofFormal (name : Name) : CoreM HTMLNote := do
let line ← name.lineNumber
let fileName ← name.fileName
return {
fileName, line,
content := s!"
<div class=\"code-block-container\">
<a href=\"{fileName.toGitHubLink line}\" class=\"code-button\">View/Improve</a>
<pre><code>{← name.getDeclString}</code></pre>
</div>"
}
/-- An informal definition or lemma to html for a note. -/
unsafe def HTMLNote.ofInformal (name : Name) : MetaM HTMLNote := do
let line ← Name.lineNumber name
let fileName ← Name.fileName name
let constInfo ← getConstInfo name
let webAddress : String ← Name.toGitHubLink fileName line
unsafe def HTMLNote.ofInformal (name : Name) : CoreM HTMLNote := do
let line ← name.lineNumber
let fileName ← name.fileName
let constInfo ← getConstInfoDefn name
let webAddress := fileName.toGitHubLink line
let mut content := ""
if Informal.isInformalDef constInfo then
let X ← Informal.constantInfoToInformalDefinition constInfo
content := "<div class=\"informal-def\">"
++ "<a href=\"" ++ webAddress ++ "\" class=\"button\">Improve/Formalize</a>"
++"<b>Informal definition:</b> " ++ name.toString ++ "<br>"
++ X.math.replace "\n" "<br>"
++ "</div>"
else if Informal.isInformalLemma constInfo then
let X ← Informal.constantInfoToInformalLemma constInfo
content := "<div class=\"informal-def\">"
++ "<a href=\"" ++ webAddress ++ "\" class=\"button\">Improve/Formalize</a>"
++"<b>Informal lemma:</b> " ++ name.toString ++ "<br>"
++ X.math.replace "\n" "<br>"
++ "</div>"
pure { content := content, fileName := fileName, line := line }
if constInfo.type.isConstOf ``InformalDefinition then
let doc ← name.getDocString
-- let html ← DocGen4.Output.docStringToHtml doc name.toString
-- let X ← Informal.constantInfoToInformalDefinition constInfo
-- let fragment := X.math.replace "\n" "<br>"
let fragment := doc.replace "\n" "<br>"
content := s!"
<div class=\"informal-def\">
<a href=\"{webAddress}\" class=\"button\">Improve/Formalize</a>
<b>Informal definition:</b> {name}<br>
{fragment}
</div>"
else if constInfo.type.isConstOf ``InformalLemma then
-- let X ← Informal.constantInfoToInformalLemma constInfo
-- let fragment := X.math.replace "\n" "<br>"
let doc ← name.getDocString
let fragment := doc.replace "\n" "<br>"
content := s!"
<div class=\"informal-def\">
<a href=\"{webAddress}\" class=\"button\">Improve/Formalize</a>
<b>Informal lemma:</b> {name}<br>
{fragment}
</div>"
return { content, fileName, line }
end HepLean

2
HepLean/Meta/Notes/NoteFile.lean
View file

@ -13,7 +13,7 @@ A note file is a structure which contains the information to go into a note.
-/
namespace HepLean
open Lean System Meta
open Lean
/-- A note consists of a title and a list of Lean files which make up the note. -/
structure NoteFile where

4
HepLean/Meta/Notes/ToHTML.lean
View file

@ -24,12 +24,12 @@ def sortLE (ni1 ni2 : HTMLNote) : Bool :=
ni1.line ≤ ni2.line
/-- Returns a sorted list of NodeInfos for a file system. -/
unsafe def getNodeInfo : MetaM (List HTMLNote) := do
unsafe def getNodeInfo : CoreM (List HTMLNote) := do
let env ← getEnv
let allNotes := (noteExtension.getState env)
let allDecl := (noteDeclExtension.getState env)
let allInformalDecl := noteInformalDeclExtension.getState env
let allNoteInfo := (← allNotes.mapM HTMLNote.ofNodeInfo) ++ (← allDecl.mapM HTMLNote.ofFormal)
let allNoteInfo := allNotes.map HTMLNote.ofNodeInfo ++ (← allDecl.mapM HTMLNote.ofFormal)
++ (← allInformalDecl.mapM HTMLNote.ofInformal)
let noteInfo := allNoteInfo.filter (fun x => x.fileName ∈ N.files)
let noteInfoSort := noteInfo.toList.mergeSort N.sortLE

9
HepLean/Meta/Remark/Basic.lean
View file

@ -3,17 +3,14 @@ Copyright (c) 2024 Joseph Tooby-Smith. All rights reserved.
Released under Apache 2.0 license.
Authors: Joseph Tooby-Smith
-/
import Batteries.Lean.HashSet
import Mathlib.Lean.Expr.Basic
import Mathlib.Lean.CoreM
import ImportGraph.RequiredModules
import Lean.Elab.Command
/-!
## Underlying structure for remarks
-/
namespace HepLean
open Lean System Meta
open Lean
/-- The information from a `remark ...` command. To be used in a note file-/
structure RemarkInfo where
@ -41,7 +38,7 @@ syntax (name := remark_syntax) "remark " ident ":=" str : command
/-- Elaborator for the `note ...` command -/
@[command_elab remark_syntax]
def elabRemark : Lean.Elab.Command.CommandElab := fun stx =>
def elabRemark : Elab.Command.CommandElab := fun stx =>
match stx with
| `(remark $n := $s) => do
let str : String := s.getString

29
HepLean/Meta/Remark/Properties.lean
View file

@ -10,35 +10,32 @@ import HepLean.Meta.Remark.Basic
-/
namespace HepLean
open Lean System Meta
open Lean
variable {m} [Monad m] [MonadEnv m] [MonadError m]
/-- All remarks in the enviroment. -/
def Name.allRemarkInfo : MetaM (List RemarkInfo) := do
def allRemarkInfo : m (Array RemarkInfo) := do
let env ← getEnv
let allRemarks := (remarkExtension.getState env)
pure allRemarks.toList
return remarkExtension.getState env
/-- The full name of a remark (name and namespace). -/
def RemarkInfo.toFullName (r : RemarkInfo) : Name :=
if r.nameSpace != .anonymous then
(r.nameSpace.toString ++ "." ++ r.name.toString).toName
.str r.nameSpace r.name.toString
else
r.name
/-- A Bool which is true if a name correponds to a remark. -/
def RemarkInfo.IsRemark (n : Name) : MetaM Bool := do
let allRemarks ← Name.allRemarkInfo
let r := allRemarks.find? (fun r => r.toFullName = n)
match r with
| some _ => pure true
| none => pure false
def RemarkInfo.IsRemark (n : Name) : m Bool := do
let allRemarks ← allRemarkInfo
let r := allRemarks.find? fun r => r.toFullName == n
return r.isSome
/-- Gets the remarkInfo from a name corresponding to a remark.. -/
def RemarkInfo.getRemarkInfo (n : Name) : MetaM RemarkInfo := do
let allRemarks ← Name.allRemarkInfo
let r := allRemarks.find? (fun r => r.toFullName = n)
match r with
| some r => pure r
def RemarkInfo.getRemarkInfo (n : Name) : m RemarkInfo := do
let allRemarks ← allRemarkInfo
match allRemarks.find? fun r => r.toFullName == n with
| some r => return r
| none => throwError s!"No remark named {n}"
end HepLean

9
HepLean/Meta/TODO/Basic.lean
View file

@ -3,10 +3,7 @@ Copyright (c) 2024 Joseph Tooby-Smith. All rights reserved.
Released under Apache 2.0 license.
Authors: Joseph Tooby-Smith
-/
import Batteries.Lean.HashSet
import Mathlib.Lean.Expr.Basic
import Mathlib.Lean.CoreM
import ImportGraph.RequiredModules
import Lean.Elab.Command
/-!
# Basic underlying structure for TODOs.
@ -14,7 +11,7 @@ import ImportGraph.RequiredModules
-/
namespace HepLean
open Lean System Meta
open Lean
/-- The information from a `TODO ...` command. -/
structure todoInfo where
@ -38,7 +35,7 @@ syntax (name := todo_comment) "TODO " str : command
/-- Elaborator for the `TODO ...` command -/
@[command_elab todo_comment]
def elabTODO : Lean.Elab.Command.CommandElab := fun stx =>
def elabTODO : Elab.Command.CommandElab := fun stx =>
match stx with
| `(TODO $s) => do
let str : String := s.getString

95
HepLean/StandardModel/Basic.lean
View file

@ -26,45 +26,56 @@ open ComplexConjugate
abbrev GaugeGroupI : Type :=
specialUnitaryGroup (Fin 3) ℂ × specialUnitaryGroup (Fin 2) ℂ × unitary ℂ
/-- The subgroup of the un-quotiented gauge group which acts trivially on all particles in the
standard model, i.e., the ℤ₆-subgroup of `GaugeGroupI` with elements `(α^2 * I₃, α^(-3) * I₂, α)`,
where `α` is a sixth complex root of unity.
See https://math.ucr.edu/home/baez/guts.pdf
-/
informal_definition gaugeGroupℤ₆SubGroup where
physics :≈ "The subgroup of the un-quotiented gauge group which acts trivially on
all particles in the standard model. "
math :≈ "The ℤ₆-subgroup of ``GaugeGroupI with elements (α^2 * I₃, α^(-3) * I₂, α), where `α`
is a sixth complex root of unity."
ref :≈ "https://math.ucr.edu/home/baez/guts.pdf"
deps :≈ [``GaugeGroupI]
deps := [``GaugeGroupI]
/-- The smallest possible gauge group of the Standard Model, i.e., the quotient of `GaugeGroupI` by
the ℤ₆-subgroup `gaugeGroupℤ₆SubGroup`.
See https://math.ucr.edu/home/baez/guts.pdf
-/
informal_definition GaugeGroupℤ₆ where
physics :≈ "The smallest possible gauge group of the Standard Model."
math :≈ "The quotient of ``GaugeGroupI by the ℤ₆-subgroup `gaugeGroupℤ₆SubGroup`."
ref :≈ "https://math.ucr.edu/home/baez/guts.pdf"
deps :≈ [``GaugeGroupI, ``StandardModel.gaugeGroupℤ₆SubGroup]
deps := [``GaugeGroupI, ``StandardModel.gaugeGroupℤ₆SubGroup]
/-- The ℤ₂subgroup of the un-quotiented gauge group which acts trivially on all particles in the
standard model, i.e., the ℤ₂-subgroup of `GaugeGroupI` derived from the ℤ₂ subgroup of
`gaugeGroupℤ₆SubGroup`.
See https://math.ucr.edu/home/baez/guts.pdf
-/
informal_definition gaugeGroupℤ₂SubGroup where
physics :≈ "The ℤ₂subgroup of the un-quotiented gauge group which acts trivially on
all particles in the standard model. "
math :≈ "The ℤ₂-subgroup of ``GaugeGroupI derived from the ℤ₂ subgroup of `gaugeGroupℤ₆SubGroup`."
ref :≈ "https://math.ucr.edu/home/baez/guts.pdf"
deps :≈ [``GaugeGroupI, ``StandardModel.gaugeGroupℤ₆SubGroup]
deps := [``GaugeGroupI, ``StandardModel.gaugeGroupℤ₆SubGroup]
/-- The guage group of the Standard Model with a ℤ₂ quotient, i.e., the quotient of `GaugeGroupI` by
the ℤ₂-subgroup `gaugeGroupℤ₂SubGroup`.
See https://math.ucr.edu/home/baez/guts.pdf
-/
informal_definition GaugeGroupℤ₂ where
physics :≈ "The guage group of the Standard Model with a ℤ₂ quotient."
math :≈ "The quotient of ``GaugeGroupI by the ℤ₂-subgroup `gaugeGroupℤ₂SubGroup`."
ref :≈ "https://math.ucr.edu/home/baez/guts.pdf"
deps :≈ [``GaugeGroupI, ``StandardModel.gaugeGroupℤ₂SubGroup]
deps := [``GaugeGroupI, ``StandardModel.gaugeGroupℤ₂SubGroup]
/-- The ℤ₃-subgroup of the un-quotiented gauge group which acts trivially on all particles in the
standard model, i.e., the ℤ₃-subgroup of `GaugeGroupI` derived from the ℤ₃ subgroup of
`gaugeGroupℤ₆SubGroup`.
See https://math.ucr.edu/home/baez/guts.pdf
-/
informal_definition gaugeGroupℤ₃SubGroup where
physics :≈ "The ℤ₃-subgroup of the un-quotiented gauge group which acts trivially on
all particles in the standard model. "
math :≈ "The ℤ₃-subgroup of ``GaugeGroupI derived from the ℤ₃ subgroup of `gaugeGroupℤ₆SubGroup`."
ref :≈ "https://math.ucr.edu/home/baez/guts.pdf"
deps :≈ [``GaugeGroupI, ``StandardModel.gaugeGroupℤ₆SubGroup]
deps := [``GaugeGroupI, ``StandardModel.gaugeGroupℤ₆SubGroup]
/-- The guage group of the Standard Model with a ℤ₃-quotient, i.e., the quotient of `GaugeGroupI` by
the ℤ₃-subgroup `gaugeGroupℤ₃SubGroup`.
See https://math.ucr.edu/home/baez/guts.pdf
-/
informal_definition GaugeGroupℤ₃ where
physics :≈ "The guage group of the Standard Model with a ℤ₃-quotient."
math :≈ "The quotient of ``GaugeGroupI by the ℤ₃-subgroup `gaugeGroupℤ₃SubGroup`."
ref :≈ "https://math.ucr.edu/home/baez/guts.pdf"
deps :≈ [``GaugeGroupI, ``StandardModel.gaugeGroupℤ₃SubGroup]
deps := [``GaugeGroupI, ``StandardModel.gaugeGroupℤ₃SubGroup]
/-- Specifies the allowed quotients of `SU(3) x SU(2) x U(1)` which give a valid
gauge group of the Standard Model. -/
@ -81,12 +92,14 @@ inductive GaugeGroupQuot : Type
/-- The element of `GaugeGroupQuot` corresponding to the full SM gauge group. -/
| I : GaugeGroupQuot
/-- The (global) gauge group of the Standard Model given a choice of quotient, i.e., the map from
`GaugeGroupQuot` to `Type` which gives the gauge group of the Standard Model for a given choice of
quotient.
See https://math.ucr.edu/home/baez/guts.pdf
-/
informal_definition GaugeGroup where
physics :≈ "The (global) gauge group of the Standard Model given a choice of quotient."
math :≈ "The map from `GaugeGroupQuot` to `Type` which gives the gauge group of the Standard Model
for a given choice of quotient."
ref :≈ "https://math.ucr.edu/home/baez/guts.pdf"
deps :≈ [``GaugeGroupI, ``gaugeGroupℤ₆SubGroup, ``gaugeGroupℤ₂SubGroup, ``gaugeGroupℤ₃SubGroup,
deps := [``GaugeGroupI, ``gaugeGroupℤ₆SubGroup, ``gaugeGroupℤ₂SubGroup, ``gaugeGroupℤ₃SubGroup,
``GaugeGroupQuot]
/-!
@ -95,20 +108,20 @@ informal_definition GaugeGroup where
-/
/-- The gauge group `GaugeGroupI` is a Lie group. -/
informal_lemma gaugeGroupI_lie where
math :≈ "The gauge group `GaugeGroupI` is a Lie group.."
deps :≈ [``GaugeGroupI]
deps := [``GaugeGroupI]
/-- For every `q` in `GaugeGroupQuot` the group `GaugeGroup q` is a Lie group. -/
informal_lemma gaugeGroup_lie where
math :≈ "For every q in ``GaugeGroupQuot the group ``GaugeGroup q is a Lie group."
deps :≈ [``GaugeGroup]
deps := [``GaugeGroup]
/-- The trivial principal bundle over SpaceTime with structure group `GaugeGroupI`. -/
informal_definition gaugeBundleI where
math :≈ "The trivial principal bundle over SpaceTime with structure group ``GaugeGroupI."
deps :≈ [``GaugeGroupI, ``SpaceTime]
deps := [``GaugeGroupI, ``SpaceTime]
/-- A global section of `gaugeBundleI`. -/
informal_definition gaugeTransformI where
math :≈ "A global section of ``gaugeBundleI."
deps :≈ [``gaugeBundleI]
deps := [``gaugeBundleI]
end StandardModel

8
HepLean/StandardModel/HiggsBoson/Basic.lean
View file

@ -171,11 +171,11 @@ def ofReal (a : ℝ) : HiggsField := (HiggsVec.ofReal a).toField
/-- The higgs field which is all zero. -/
def zero : HiggsField := ofReal 0
/-- The zero Higgs field is the zero section of the Higgs bundle, i.e., the HiggsField `zero`
defined by `ofReal 0` is the constant zero-section of the bundle `HiggsBundle`.
-/
informal_lemma zero_is_zero_section where
physics :≈ "The zero Higgs field is the zero section of the Higgs bundle."
math :≈ "The HiggsField `zero` defined by `ofReal 0`
is the constant zero-section of the bundle `HiggsBundle`."
deps :≈ [`StandardModel.HiggsField.zero]
deps := [`StandardModel.HiggsField.zero]
end HiggsField

46
HepLean/StandardModel/HiggsBoson/GaugeAction.lean
View file

@ -215,25 +215,24 @@ theorem rotate_fst_real_snd_zero (φ : HiggsVec) :
· simp only [Fin.mk_one, Fin.isValue, Pi.smul_apply, Function.comp_apply, cons_val_one, head_cons,
tail_cons, smul_zero]
/-- There exists a `g` in `GaugeGroupI` such that `rep g φ = φ'` iff `‖φ‖ = ‖φ'‖`. -/
informal_lemma guage_orbit where
math :≈ "There exists a `g` in ``GaugeGroupI such that `rep g φ = φ'` if and only if
‖φ‖ = ‖φ'‖."
deps :≈ [``rotate_fst_zero_snd_real]
deps := [``rotate_fst_zero_snd_real]
/-- The Higgs boson breaks electroweak symmetry down to the electromagnetic force, i.e., the
stablity group of the action of `rep` on `![0, Complex.ofReal ‖φ‖]`, for non-zero `‖φ‖`, is the
`SU(3) × U(1)` subgroup of `gaugeGroup := SU(3) × SU(2) × U(1)` with the embedding given by
`(g, e^{i θ}) ↦ (g, diag (e ^ {3 * i θ}, e ^ {- 3 * i θ}), e^{i θ})`.
-/
informal_lemma stability_group_single where
physics :≈ "The Higgs boson breaks electroweak symmetry down to the electromagnetic force."
math :≈ "The stablity group of the action of `rep` on `![0, Complex.ofReal ‖φ‖]`,
for non-zero `‖φ‖` is the `SU(3) x U(1)` subgroup of
`gaugeGroup := SU(3) x SU(2) x U(1)` with the embedding given by
`(g, e^{i θ}) ↦ (g, diag (e ^ {3 * i θ}, e ^ {- 3 * i θ}), e^{i θ})`."
deps :≈ [``StandardModel.HiggsVec, ``StandardModel.HiggsVec.rep]
deps := [``StandardModel.HiggsVec, ``StandardModel.HiggsVec.rep]
/-- The subgroup of `gaugeGroup := SU(3) × SU(2) × U(1)` which preserves every `HiggsVec` by the
action of `StandardModel.HiggsVec.rep` is given by `SU(3) × ℤ₆` where `ℤ₆` is the subgroup of
`SU(2) × U(1)` with elements `(α^(-3) * I₂, α)` where `α` is a sixth root of unity.
-/
informal_lemma stability_group where
math :≈ "The subgroup of `gaugeGroup := SU(3) x SU(2) x U(1)` which preserves every `HiggsVec`
by the action of ``StandardModel.HiggsVec.rep is given by `SU(3) x ℤ₆` where ℤ₆
is the subgroup of `SU(2) x U(1)` with elements `(α^(-3) * I₂, α)` where
α is a sixth root of unity."
deps :≈ [``HiggsVec, ``rep]
deps := [``HiggsVec, ``rep]
end HiggsVec
@ -249,20 +248,21 @@ namespace HiggsField
-/
/-- The action of `gaugeTransformI` on `HiggsField` acting pointwise through `HiggsVec.rep`. -/
informal_definition gaugeAction where
math :≈ "The action of ``gaugeTransformI on ``HiggsField acting pointwise through
``HiggsVec.rep."
deps :≈ [``HiggsVec.rep, ``gaugeTransformI]
deps := [``HiggsVec.rep, ``gaugeTransformI]
/-- There exists a `g` in `gaugeTransformI` such that `gaugeAction g φ = φ'` iff
`φ(x)^† φ(x) = φ'(x)^† φ'(x)`.
-/
informal_lemma guage_orbit where
math :≈ "There exists a `g` in ``gaugeTransformI such that `gaugeAction g φ = φ'` if and only if
φ(x)^† φ(x) = φ'(x)^† φ'(x)."
deps :≈ [``gaugeAction]
deps := [``gaugeAction]
/-- For every smooth map `f` from `SpaceTime` to `ℝ` such that `f` is positive semidefinite, there
exists a Higgs field `φ` such that `f = φ^† φ`.
-/
informal_lemma gauge_orbit_surject where
math :≈ "For every smooth map f from ``SpaceTime to ℝ such that `f` is positive semidefinite,
there exists a Higgs field φ such that `f = φ^† φ`."
deps :≈ [``HiggsField, ``SpaceTime]
deps := [``HiggsField, ``SpaceTime]
end HiggsField

10
HepLean/StandardModel/HiggsBoson/Potential.lean
View file

@ -323,12 +323,12 @@ lemma isBounded_of_𝓵_pos (h : 0 < P.𝓵) : P.IsBounded := by
have h2' := h2 φ x
linarith
/-- When there is no quartic coupling, the potential is bounded iff the mass squared is
non-positive, i.e., for `P : Potential` then `P.IsBounded` iff `P.μ2 ≤ 0`. That is to say
`- P.μ2 * ‖φ‖_H^2 x` is bounded below ifff `P.μ2 ≤ 0`.-/
informal_lemma isBounded_iff_of_𝓵_zero where
physics :≈ "When there is no quartic coupling, the potential is bounded iff the mass squared is
non-positive."
math :≈ "For `P : Potential` then P.IsBounded if and only if P.μ2 ≤ 0.
That is to say `- P.μ2 * ‖φ‖_H^2 x` is bounded below if and only if `P.μ2 ≤ 0`."
deps :≈ [`StandardModel.HiggsField.Potential.IsBounded, `StandardModel.HiggsField.Potential]
deps := [`StandardModel.HiggsField.Potential.IsBounded, `StandardModel.HiggsField.Potential]
/-!
## Minimum and maximum

7
HepLean/Tensors/OverColor/Lift.lean
View file

@ -895,10 +895,11 @@ lemma forgetLiftAppCon_naturality_eqToHom_apply (c c1 : C) (h : c = c1)
rw [forgetLiftAppCon_naturality_eqToHom]
rfl
/-- The natural isomorphism between `lift (C := C) ⋙ forget` and
`Functor.id (Discrete C ⥤ Rep k G)`.
-/
informal_definition forgetLift where
math :≈ "The natural isomorphism between `lift (C := C) ⋙ forget` and
`Functor.id (Discrete C ⥤ Rep k G)`."
deps :≈ [``forget, ``lift]
deps := [``forget, ``lift]
end
end OverColor

20
HepLean/Tensors/TensorSpecies/Contractions/Basic.lean
View file

@ -48,17 +48,19 @@ lemma contractSelfField_equivariant {S : TensorSpecies} {c : S.C} {g : S.G}
simpa using congrFun (congrArg (fun x => x.hom.toFun)
((S.contractSelfHom c).comm g)) (ψ ⊗ₜ[S.k] φ)
informal_lemma contractSelfField_non_degenerate where
math :≈ "The contraction of two vectors of the same color is non-degenerate.
I.e. ⟪ψ, φ⟫ₜₛ = 0 for all φ implies ψ = 0."
proof :≈ "The basic idea is that being degenerate contradicts the assumption of having a unit
in the tensor species."
deps :≈ [``contractSelfField]
/-- The contraction of two vectors of the same color is non-degenerate, i.e., `⟪ψ, φ⟫ₜₛ = 0` for all
`φ` implies `ψ = 0`.
Proof: the basic idea is that being degenerate contradicts the assumption of having a
unit in the tensor species.
-/
informal_lemma contractSelfField_non_degenerate where
deps := [``contractSelfField]
/-- The contraction `⟪ψ, φ⟫ₜₛ` is related to the tensor tree
`{ψ | μ ⊗ (S.dualRepIsoDiscrete c).hom φ | μ}ᵀ`. -/
informal_lemma contractSelfField_tensorTree where
math :≈ "The contraction ⟪ψ, φ⟫ₜₛ is related to the tensor tree
{ψ | μ ⊗ (S.dualRepIsoDiscrete c).hom φ | μ}ᵀ "
deps :≈ [``contractSelfField, ``TensorTree]
deps := [``contractSelfField, ``TensorTree]
/-!

25
HepLean/Tensors/TensorSpecies/DualRepIso.lean
View file

@ -241,27 +241,28 @@ def dualRepIsoDiscrete (c : S.C) : S.FD.obj (Discrete.mk c) ≅ S.FD.obj (Discre
ext x
exact S.fromDualRep_toDualRep_eq_self c x
/-- Given a `i : Fin n` the isomorphism between `S.F.obj (OverColor.mk c)` and
`S.F.obj (OverColor.mk (Function.update c i (S.τ (c i))))` induced by `dualRepIsoDiscrete` acting on
the `i`-th component of the color.
-/
informal_definition dualRepIso where
math :≈ "Given a `i : Fin n` the isomorphism between `S.F.obj (OverColor.mk c)` and
`S.F.obj (OverColor.mk (Function.update c i (S.τ (c i))))` induced by `dualRepIsoDiscrete`
acting on the `i`-th component of the color."
deps :≈ [``dualRepIsoDiscrete]
deps := [``dualRepIsoDiscrete]
/-- Acting with `dualRepIso` on the fst component of a `unitTensor` returns a metric. -/
informal_lemma dualRepIso_unitTensor_fst where
math :≈ "Acting with `dualRepIso` on the fst component of a `unitTensor` returns a metric."
deps :≈ [``dualRepIso, ``unitTensor, ``metricTensor]
deps := [``dualRepIso, ``unitTensor, ``metricTensor]
/-- Acting with `dualRepIso` on the snd component of a `unitTensor` returns a metric. -/
informal_lemma dualRepIso_unitTensor_snd where
math :≈ "Acting with `dualRepIso` on the snd component of a `unitTensor` returns a metric."
deps :≈ [``dualRepIso, ``unitTensor, ``metricTensor]
deps := [``dualRepIso, ``unitTensor, ``metricTensor]
/-- Acting with `dualRepIso` on the fst component of a `metricTensor` returns a unitTensor. -/
informal_lemma dualRepIso_metricTensor_fst where
math :≈ "Acting with `dualRepIso` on the fst component of a `metricTensor` returns a unitTensor."
deps :≈ [``dualRepIso, ``unitTensor, ``metricTensor]
deps := [``dualRepIso, ``unitTensor, ``metricTensor]
/-- Acting with `dualRepIso` on the snd component of a `metricTensor` returns a unitTensor. -/
informal_lemma dualRepIso_metricTensor_snd where
math :≈ "Acting with `dualRepIso` on the snd component of a `metricTensor` returns a unitTensor."
deps :≈ [``dualRepIso, ``unitTensor, ``metricTensor]
deps := [``dualRepIso, ``unitTensor, ``metricTensor]
end TensorSpecies

8
HepLean/Tensors/Tree/NodeIdentities/Basic.lean
View file

@ -30,13 +30,13 @@ variable {S : TensorSpecies}
-/
/-- A `constVecNode` has equal tensor to the `vecNode` with the map evaluated at 1. -/
informal_lemma constVecNode_eq_vecNode where
math :≈ "A constVecNode has equal tensor to the vecNode with the map evaluated at 1."
deps :≈ [``constVecNode, ``vecNode]
deps := [``constVecNode, ``vecNode]
/-- A `constTwoNode` has equal tensor to the `twoNode` with the map evaluated at 1. -/
informal_lemma constTwoNode_eq_twoNode where
math :≈ "A constTwoNode has equal tensor to the twoNode with the map evaluated at 1."
deps :≈ [``constTwoNode, ``twoNode]
deps := [``constTwoNode, ``twoNode]
/-!

505
scripts/MetaPrograms/informal.lean
View file

@ -3,12 +3,8 @@ Copyright (c) 2024 Joseph Tooby-Smith. All rights reserved.
Released under Apache 2.0 license.
Authors: Joseph Tooby-Smith
-/
import Batteries.Lean.HashSet
import Lean
import Mathlib.Lean.Expr.Basic
import Mathlib.Lean.CoreM
import HepLean.Meta.Informal.Post
import ImportGraph.RequiredModules
import Mathlib.Lean.CoreM
/-!
# Extracting information about informal definitions and lemmas
@ -19,125 +15,101 @@ To make the dot file for the dependency graph run:
- or dot -Tpng -Gdpi=300 -o ./Docs/graph.png ./Docs/InformalDot.dot
-/
open Lean System Meta
open Lean
def getConst (imp : Import) : IO (Array (Import × ConstantInfo)) := do
let mFile ← findOLean imp.module
let (modData, _) ← readModuleData mFile
pure (modData.constants.map (fun c => (imp, c)))
/- To make private definitions completely invisible, place them in a separate importable file. -/
def getLineNumber (c : Name) : MetaM Nat := do
match ← findDeclarationRanges? c with
| some decl => pure decl.range.pos.line
| none => panic! s!"{c} is a declaration without position"
structure Decl where
name : Name
module : Name
lineNo : Nat
docString : String
def getModule (c : Name) : MetaM Name := do
match Lean.Environment.getModuleFor? (← getEnv) c with
| some mod => pure mod
| none => panic! s!"{c} is a declaration without position"
inductive InformalDeclKind
| def | lemma
def getConstInfo (n : Name) : MetaM ConstantInfo := do
match (← getEnv).find? n with
| some c => pure c
| none => panic! s!"{n} is not a constant"
instance : ToString InformalDeclKind where
toString
| .def => "def"
| .lemma => "lemma"
/-- Gets the docstring from a name, if it exists, otherwise the string "No docstring."-/
def getDocString (n : Name) : MetaM String := do
match ← Lean.findDocString? (← getEnv) n with
| some doc => pure doc
| none => pure "No docstring."
structure InformalDecl extends Decl where
kind : InformalDeclKind
deps : Array Decl
def depToString (d : Name) : MetaM String := do
let lineNo ← getLineNumber d
let mod ← getModule d
pure s!" * {d}: ./{mod.toString.replace "." "/" ++ ".lean"}:{lineNo}"
structure DepDecls where
private mk::
private decls : Std.HashMap Name Decl
formalDecls : Array Decl
/-- Pairs of informal declarations and their enclosing modules. -/
informalModuleMap : Array (Name × Array InformalDecl)
def depToWebString (d : Name) : MetaM String := do
let lineNo ← getLineNumber d
let mod ← getModule d
let webPath := "https://github.com/HEPLean/HepLean/blob/master/"++
(mod.toString.replace "." "/") ++ ".lean"
pure s!" * [{d}]({webPath}#L{lineNo})"
private abbrev DeclsM := StateRefT (Std.HashMap Name Decl) CoreM
unsafe def informalDependencies (c : ConstantInfo) : MetaM (Array Name) := do
if Informal.isInformalLemma c then
let informal ← Informal.constantInfoToInformalLemma c
pure informal.dependencies.toArray
else if Informal.isInformalDef c then
let informal ← Informal.constantInfoToInformalDefinition c
pure informal.dependencies.toArray
else
pure #[]
private def Decl.ofName (name : Name) (module : Option Name := none) : DeclsM Decl := do
if let some decl := (← get).get? name then
return decl
let env ← getEnv
let decl : Decl := {
name
module := module.getD (env.getModuleFor? name).get!
lineNo := (← findDeclarationRanges? name).get!.range.pos.line
docString := (← findDocString? env name).getD "No docstring."
}
modifyGet fun decls => (decl, decls.insert name decl)
unsafe def informalLemmaToString (c : Import × ConstantInfo) : MetaM String := do
let lineNo ← getLineNumber c.2.name
let informalLemma ← Informal.constantInfoToInformalLemma c.2
let dep ← informalLemma.dependencies.mapM fun d => depToString d
pure s!"
Informal lemma: {informalLemma.name}
- ./{c.1.module.toString.replace "." "/" ++ ".lean"}:{lineNo}
- Math description: {informalLemma.math}
- Physics description: {informalLemma.physics}
- Proof description: {informalLemma.proof}
- References: {informalLemma.ref}
- Dependencies:\n{String.intercalate "\n" dep}"
private unsafe def InformalDecl.ofName? (name module : Name) : DeclsM (Option InformalDecl) := do
unless name.isInternalDetail do
if let some const := (← getEnv).find? name then
if Informal.isInformalDef const then
return ← ofName .def (← evalConst InformalDefinition name).deps
else if Informal.isInformalLemma const then
return ← ofName .lemma (← evalConst InformalLemma name).deps
return none
where
ofName (kind : InformalDeclKind) (deps : List Name) : DeclsM InformalDecl :=
return {← Decl.ofName name module with kind, deps := ← deps.toArray.mapM Decl.ofName}
unsafe def informalLemmaToWebString (c : Import × ConstantInfo) : MetaM String := do
let lineNo ← getLineNumber c.2.name
let informalLemma ← Informal.constantInfoToInformalLemma c.2
let dep ← informalLemma.dependencies.mapM fun d => depToWebString d
let webPath := "https://github.com/HEPLean/HepLean/blob/master/"++
(c.1.module.toString.replace "." "/") ++ ".lean"
pure s!"
**Informal lemma**: [{informalLemma.name}]({webPath}#L{lineNo}) :=
*{informalLemma.math}*
- Physics description: {informalLemma.physics}
- Proof description: {informalLemma.proof}
- References: {informalLemma.ref}
- Dependencies:\n{String.intercalate "\n" dep}"
unsafe def DepDecls.ofRootModule (rootModule : Name) : CoreM DepDecls := do
let (informalModuleMap, decls) ← getAllDecls.run ∅
unsafe def informalDefToString (c : Import × ConstantInfo) : MetaM String := do
let lineNo ← getLineNumber c.2.name
let informalDef ← Informal.constantInfoToInformalDefinition c.2
let dep ← informalDef.dependencies.mapM fun d => depToString d
pure s!"
Informal def: {informalDef.name}
- ./{c.1.module.toString.replace "." "/" ++ ".lean"}:{lineNo}
- Math description: {informalDef.math}
- Physics description: {informalDef.physics}
- References: {informalDef.ref}
- Dependencies:\n{String.intercalate "\n" dep}"
let mut informalNames : Std.HashSet Name := ∅
for (_, informalDecls) in informalModuleMap do
for {name, ..} in informalDecls do
informalNames := informalNames.insert name
unsafe def informalDefToWebString (c : Import × ConstantInfo) : MetaM String := do
let lineNo ← getLineNumber c.2.name
let informalDef ← Informal.constantInfoToInformalDefinition c.2
let dep ← informalDef.dependencies.mapM fun d => depToWebString d
let webPath := "https://github.com/HEPLean/HepLean/blob/master/"++
(c.1.module.toString.replace "." "/") ++ ".lean"
pure s!"
**Informal def**: [{informalDef.name}]({webPath}#L{lineNo}) :=
*{informalDef.math}*
- Physics description: {informalDef.physics}
- References: {informalDef.ref}
- Dependencies:\n{String.intercalate "\n" dep}"
let mut formalDecls : Array Decl := #[]
for (name, decl) in decls do
unless informalNames.contains name do
formalDecls := formalDecls.push decl
unsafe def informalToString (c : Import × ConstantInfo) : MetaM String := do
if Informal.isInformalLemma c.2 then
informalLemmaToString c
else if Informal.isInformalDef c.2 then
informalDefToString c
else
pure ""
return {decls, formalDecls, informalModuleMap}
where
getAllDecls : DeclsM (Array (Name × Array InformalDecl)) := do
let ({imports, ..}, _) ← readModuleData (← findOLean rootModule)
imports.filterMapM fun {module, ..} => do
if module.getRoot == rootModule then
let ({constNames, ..}, _) ← readModuleData (← findOLean module)
let informalDecls ← constNames.filterMapM fun name => InformalDecl.ofName? name module
unless informalDecls.isEmpty do
let informalDecls := informalDecls.qsort fun a b => a.lineNo < b.lineNo
printInformalDecls module informalDecls
return (module, informalDecls)
return none
printInformalDecls (module : Name) (informalDecls : Array InformalDecl) : CoreM Unit := do
println! module
for {kind, name, lineNo, docString, deps, ..} in informalDecls do
println! s!"
Informal {kind}: {name}
- {module.toRelativeFilePath}:{lineNo}
- Description: {docString}
- Dependencies:"
for {name, module, lineNo, ..} in deps do
println! s!" * {name}: {module.toRelativeFilePath}:{lineNo}"
unsafe def informalToWebString (c : Import × ConstantInfo) : MetaM String := do
if Informal.isInformalLemma c.2 then
informalLemmaToWebString c
else if Informal.isInformalDef c.2 then
informalDefToWebString c
else
pure ""
def informalFileHeader : String := s!"
/-- Making the Markdown file for dependency graph. -/
def mkMarkdown (depDecls : DepDecls) : IO Unit := do
println! "
# Informal definitions and lemmas
See [informal definitions and lemmas as a dependency graph](https://heplean.github.io/HepLean/graph.svg).
@ -151,143 +123,19 @@ There is an implicit invitation to the reader to contribute to the formalization
background in Lean.
"
open Informal
/-- Takes an import and outputs the list of `ConstantInfo` corresponding
to an informal definition or lemma in that import, sorted by line number. -/
def importToInformal (i : Import) : MetaM (Array (Import × ConstantInfo)) := do
let constants ← getConst i
let constants := constants.filter (fun c => ¬ Lean.Name.isInternalDetail c.2.name)
let informalConst := constants.filter fun c => Informal.isInformal c.2
let informalConstLineNo ← informalConst.mapM fun c => getLineNumber c.2.name
let informalConstWithLineNo := informalConst.zip informalConstLineNo
let informalConstWithLineNoSort := informalConstWithLineNo.qsort (fun a b => a.2 < b.2)
return informalConstWithLineNoSort.map (fun c => c.1)
for (module, informalDecls) in depDecls.informalModuleMap do
println! s!"## {module}"
for {kind, name, lineNo, docString, deps, ..} in informalDecls do
println! s!"
**Informal {kind}**: [{name}]({module.toGitHubLink lineNo}) :=
*{docString}*
- Dependencies:"
for {name, module, lineNo, ..} in deps do
println! s!" * {name}: {module.toRelativeFilePath}:{lineNo}"
unsafe def importToString (i : Import) : MetaM String := do
let informalConst ← importToInformal i
let informalPrint ← (informalConst.mapM informalToString).run'
if informalPrint.isEmpty then
pure ""
else
pure ("\n\n" ++ i.module.toString ++ "\n" ++ String.intercalate "\n\n" informalPrint.toList)
unsafe def importToWebString (i : Import) : MetaM String := do
let informalConst ← importToInformal i
let informalPrint ← (informalConst.mapM informalToWebString).run'
if informalPrint.isEmpty then
pure ""
else
pure ("\n\n## " ++ i.module.toString ++ "\n" ++ String.intercalate "\n\n" informalPrint.toList)
section dotFile
/-!
## Making the dot file for dependency graph.
-/
/-- Turns a formal definition or lemma into a node of a dot graph. -/
def formalToNode (nameSpaces : Array Name) (d : Name) : MetaM String := do
let lineNo ← getLineNumber d
let mod ← getModule d
let webPath := "https://github.com/HEPLean/HepLean/blob/master/"++
(mod.toString.replace "." "/") ++ ".lean"
let docstring ← getDocString d
let prefixName := if nameSpaces.contains d then d else
d.getPrefix
let nodeStr := s!"\"{d}\"[label=\"{d}\", shape=box, style=filled, fillcolor=steelblue,
tooltip=\"{docstring}\"]"
if prefixName = Lean.Name.anonymous then
pure nodeStr
else
pure ("subgraph cluster_" ++ prefixName.toString.replace "." "_" ++ " { " ++ nodeStr ++ "; }")
unsafe def informalLemmaToNode (nameSpaces : Array Name) (c : Import × ConstantInfo) : MetaM String := do
let lineNo ← getLineNumber c.2.name
let webPath := "https://github.com/HEPLean/HepLean/blob/master/"++
(c.1.module.toString.replace "." "/") ++ ".lean"
let informalLemma ← (Informal.constantInfoToInformalLemma c.2)
let prefixName := if nameSpaces.contains c.2.name then c.2.name else
c.2.name.getPrefix
let nodeStr := s!"\"{c.2.name}\"[label=\"{c.2.name}\", shape=ellipse, style=filled, fillcolor=lightgray,
tooltip=\"{informalLemma.math}\"]"
if prefixName = Lean.Name.anonymous then
pure nodeStr
else
pure ("subgraph cluster_" ++ prefixName.toString.replace "." "_" ++ " { " ++ nodeStr ++ "; }")
unsafe def informalDefToNode (nameSpaces : Array Name) (c : Import × ConstantInfo) : MetaM String := do
let lineNo ← getLineNumber c.2.name
let webPath := "https://github.com/HEPLean/HepLean/blob/master/"++
(c.1.module.toString.replace "." "/") ++ ".lean"
let informalDef ← (constantInfoToInformalDefinition c.2)
let prefixName := if nameSpaces.contains c.2.name then c.2.name else
c.2.name.getPrefix
let nodeStr := s!"\"{c.2.name}\"[label=\"{c.2.name}\", shape=box, style=filled, fillcolor=lightgray,
tooltip=\"{informalDef.math}\"]"
if prefixName = Lean.Name.anonymous then
pure nodeStr
else
pure ("subgraph cluster_" ++ prefixName.toString.replace "." "_" ++ " { " ++ nodeStr ++ "; }")
unsafe def informalToNode (nameSpaces : Array Name) (c : Import × ConstantInfo) : MetaM String := do
if Informal.isInformalLemma c.2 then
informalLemmaToNode nameSpaces c
else if Informal.isInformalDef c.2 then
informalDefToNode nameSpaces c
else
pure ""
unsafe def informalLemmaToEdges (c : Import × ConstantInfo) : MetaM (String) := do
let informalLemma ← constantInfoToInformalLemma c.2
let deps := informalLemma.dependencies
let edge := deps.map (fun d => s!"\"{d}\" -> \"{c.2.name}\"")
pure (String.intercalate "\n" edge)
unsafe def informalDefToEdges (c : Import × ConstantInfo) : MetaM (String) := do
let informalDef ← constantInfoToInformalDefinition c.2
let deps := informalDef.dependencies
let edge := deps.map (fun d => s!"\"{d}\" -> \"{c.2.name}\"")
pure (String.intercalate "\n" edge)
unsafe def informalToEdges (c : Import × ConstantInfo) : MetaM (String) := do
if Informal.isInformalLemma c.2 then
informalLemmaToEdges c
else if Informal.isInformalDef c.2 then
informalDefToEdges c
else
pure ""
unsafe def namespaceToCluster (name : Name) : MetaM String := do
let nameUnder := name.toString.replace "." "_"
if name = Lean.Name.anonymous then
pure ""
else
pure ("subgraph cluster_" ++ nameUnder ++ "
{
label=\"" ++ name.toString ++ "\";
color=steelblue;
}")
unsafe def mkDot (imports : Array Import) : MetaM String := do
let informal ← imports.mapM importToInformal
let informal := informal.flatten
let deps ← (informal.map (fun c => c.2)).mapM informalDependencies
let deps := deps.flatten
let informal_name := informal.map (fun c => c.2.name)
let informalNameSpaces := informal.map fun c => c.2.name.getPrefix
let clusters ← informalNameSpaces.mapM fun c => namespaceToCluster c
let clusters := String.intercalate "\n" clusters.toList.eraseDups
let formal_deps := deps.filter (fun d => d ∉ informal_name)
let formal_nodes ← formal_deps.mapM (formalToNode informalNameSpaces)
let nodes := String.intercalate "\n" formal_nodes.toList
let informalNodes ← informal.mapM (informalToNode informalNameSpaces)
let informalNodes := String.intercalate "\n" informalNodes.toList
let edges ← informal.mapM informalToEdges
let edges := String.intercalate "\n" edges.toList
let header := "strict digraph G {
/-- Making the DOT file for dependency graph. -/
def mkDOT (depDecls : DepDecls) : IO Unit := do
IO.println "strict digraph G {
graph [
pack=true;
packmode=\"array1\";
@ -298,77 +146,48 @@ unsafe def mkDot (imports : Array Import) : MetaM String := do
labelloc=\"t\";
labeljust=\"l\";
edge [arrowhead=vee];"
let footer := "}"
pure (header ++ "\n" ++clusters ++ "\n" ++ nodes ++ "\n" ++
informalNodes ++ "\n" ++ edges ++ "\n" ++ footer)
end dotFile
let mut clusters : Std.HashSet Name := ∅
for (_, informalDecls) in depDecls.informalModuleMap do
for {name, ..} in informalDecls do
let cluster := name.getPrefix
unless cluster.isAnonymous do
clusters := clusters.insert cluster
println! s!"subgraph cluster_{cluster.toString.replace "." "_"}" ++ "
{
label=\"" ++ cluster.toString ++ "\";
color=steelblue;
}"
section htmlFile
for decl in depDecls.formalDecls do
println! toNode clusters decl "box" "steelblue"
/-!
for (_, informalDecls) in depDecls.informalModuleMap do
for {toDecl := decl, kind, ..} in informalDecls do
match kind with
| .def => println! toNode clusters decl "box" "lightgray"
| .lemma => println! toNode clusters decl "ellipse" "lightgray"
## Making the html file for dependency graph.
for (_, informalDecls) in depDecls.informalModuleMap do
for informalDecl in informalDecls do
for dep in informalDecl.deps do
println! s!"\"{dep.name}\" -> \"{informalDecl.name}\""
-/
def formalToHTML (d : Name) : MetaM String := do
let lineNo ← getLineNumber d
let mod ← getModule d
let webPath := "https://github.com/HEPLean/HepLean/blob/master/"++
(mod.toString.replace "." "/") ++ ".lean"
let docstring ← getDocString d
pure s!"
<div id=\"{d}\" class=\"node-text\">
<b><a href=\"{webPath ++ "#L" ++ toString lineNo}\">{d}</a></b><br>
<b>Docstring: </b>{docstring}
</div>"
unsafe def informalLemmaToHTML (c : Import × ConstantInfo) : MetaM String := do
let lineNo ← getLineNumber c.2.name
let webPath := "https://github.com/HEPLean/HepLean/blob/master/"++
(c.1.module.toString.replace "." "/") ++ ".lean"
let informalLemma ← (constantInfoToInformalLemma c.2)
pure s!"
<div id=\"{c.2.name}\" class=\"node-text\">
<b><a href=\"{webPath ++ "#L" ++ toString lineNo}\">{c.2.name}</a></b><br>
<b>Math description: </b>{informalLemma.math}<br>
<b>Physics description: </b>{informalLemma.physics}<br>
</div>"
unsafe def informalDefToHTML (c : Import × ConstantInfo) : MetaM String := do
let lineNo ← getLineNumber c.2.name
let webPath := "https://github.com/HEPLean/HepLean/blob/master/"++
(c.1.module.toString.replace "." "/") ++ ".lean"
let informalDef ← (constantInfoToInformalDefinition c.2)
pure s!"
<div id=\"{c.2.name}\" class=\"node-text\">
<b><a href=\"{webPath ++ "#L" ++ toString lineNo}\">{c.2.name}</a></b><br>
<b>Math description: </b>{informalDef.math}<br>
<b>Physics description: </b>{informalDef.physics}<br>
</div>"
unsafe def informalToHTML (c : Import × ConstantInfo) : MetaM String := do
if Informal.isInformalLemma c.2 then
informalLemmaToHTML c
else if Informal.isInformalDef c.2 then
informalDefToHTML c
println! "}"
where
toNode (clusters : Std.HashSet Name) (decl : Decl) (shape color : String) : String :=
let {name, docString, ..} := decl
let prefixName := if clusters.contains name then name else name.getPrefix
let nodeStr := s!"\"{name}\"[label=\"{name}\", shape={shape}, style=filled, fillcolor={color},
tooltip=\"{docString}\"]"
if prefixName.isAnonymous then
nodeStr
else
pure ""
s!"subgraph cluster_{prefixName.toString.replace "." "_"} \{ {nodeStr}; }"
unsafe def toHTML (imports : Array Import) : MetaM String := do
let informal ← imports.mapM importToInformal
let informal := informal.flatten
let deps ← (informal.map (fun c => c.2)).mapM informalDependencies
let deps := deps.flatten
let informal_name := informal.map (fun c => c.2.name)
let formal_deps := deps.filter (fun d => d ∉ informal_name)
let formal_nodes ← formal_deps.mapM (formalToHTML)
let nodes := String.intercalate "\n" formal_nodes.toList
let informalNodes ← informal.mapM (informalToHTML)
let informalNodes := String.intercalate "\n" informalNodes.toList
let header := "---
/-- Making the HTML file for dependency graph. -/
def mkHTML (depDecls : DepDecls) : IO Unit := do
IO.println "---
layout: default
---
<!DOCTYPE html>
@ -412,7 +231,15 @@ layout: default
<div id=\"includedContent\"></div>
<!-- Div to display the message when a node is clicked -->
<div id=\"message\"></div>"
let footer := "
for decl in depDecls.formalDecls do
println! toHTML decl
for (_, informalDecls) in depDecls.informalModuleMap do
for {toDecl := decl, ..} in informalDecls do
println! toHTML decl
IO.println "
<script type=\"text/javascript\">
// Load the DOT file and render the graph
d3.text(\"InformalDot.dot\").then(function(dotSrc) {
@ -451,43 +278,39 @@ layout: default
</body>
</html>
"
pure (header ++ "\n" ++ nodes ++ "\n" ++
informalNodes ++ "\n" ++ footer)
where
toHTML (decl : Decl) : String :=
let {name, module, lineNo, docString} := decl
s!"
<div id=\"{name}\" class=\"node-text\">
<b><a href=\"{module.toGitHubLink lineNo}\">{name}</a></b><br>
<b>Description: </b>{docString}
</div>"
end htmlFile
/-!
## Main function
-/
unsafe def main (args : List String) : IO UInt32 := do
def IO.withStdoutRedirectedTo {α} (filePath : System.FilePath) (action : IO α) : IO α :=
FS.withFile filePath .write fun handle => withStdout (.ofHandle handle) action
unsafe def main (args : List String) : IO Unit := do
initSearchPath (← findSysroot)
let mods : Name := `HepLean
let imp : Import := {module := mods}
let mFile ← findOLean imp.module
unless (← mFile.pathExists) do
throw <| IO.userError s!"object file '{mFile}' of module {imp.module} does not exist"
let (hepLeanMod, _) ← readModuleData mFile
let imports := hepLeanMod.imports.filter (fun c => c.module ≠ `Init)
let importString ← CoreM.withImportModules #[`HepLean] (imports.mapM importToString).run'
IO.println (String.intercalate "" importString.toList)
/- Writing out informal file. -/
let fileOut : System.FilePath := {toString := "./docs/Informal.md"}
let rootModule := `HepLean
CoreM.withImportModules #[rootModule] do
/- Build informal dependencies with all information necessary. -/
let depDecls ← DepDecls.ofRootModule rootModule
/- Stay inside `CoreM.withImportModules` so that references to objects in `env` are not yet
destroyed. -/
if "mkFile" ∈ args then
let importWebString ← CoreM.withImportModules #[`HepLean] (imports.mapM importToWebString).run'
let out := String.intercalate "\n" importWebString.toList
IO.println (s!"Informal file made.")
IO.FS.writeFile fileOut (informalFileHeader ++ out)
/- Making the dot file. -/
IO.withStdoutRedirectedTo "./docs/Informal.md" do mkMarkdown depDecls
println! "Markdown file made."
if "mkDot" ∈ args then
let dot ← CoreM.withImportModules #[`HepLean] (mkDot imports).run'
let dotFile : System.FilePath := {toString := "./docs/InformalDot.dot"}
IO.FS.writeFile dotFile dot
IO.println (s!"Dot file made.")
/- Making the html file. -/
IO.withStdoutRedirectedTo "./docs/InformalDot.dot" do mkDOT depDecls
println! "DOT file made."
if "mkHTML" ∈ args then
let html ← CoreM.withImportModules #[`HepLean] (toHTML imports).run'
let htmlFile : System.FilePath := {toString := "./docs/InformalGraph.html"}
IO.FS.writeFile htmlFile html
IO.println (s!"HTML file made.")
pure 0
IO.withStdoutRedirectedTo "./docs/InformalGraph.html" do mkHTML depDecls
println! "HTML file made."

45
scripts/MetaPrograms/no_docs.lean
View file

@ -1,45 +0,0 @@
/-
Copyright (c) 2024 Joseph Tooby-Smith. All rights reserved.
Released under Apache 2.0 license.
Authors: Joseph Tooby-Smith
-/
import HepLean.Meta.Basic
/-!
# Extracting commands with no doc strings.
-/
open Lean System Meta HepLean
def Imports.NoDocStringDef (imp : Import) : MetaM UInt32 := do
let x := (← Imports.getUserConsts imp).filter (fun c => c.isDef)
let x ← x.filterM (fun c => do
return Bool.not (← (Name.hasDocString c.name)))
let y ← x.filterM (fun c => Name.hasPos c.name)
let loc ← y.mapM (fun c => (Name.location c.name))
if loc.toList.length > 0 then
IO.println "\n"
IO.println s!"Module {imp.module} has the following definitions without doc strings:"
IO.println (String.intercalate "\n" loc.toList.mergeSort)
pure 0
def Imports.NoDocStringLemma (imp : Import) : MetaM UInt32 := do
let x := (← Imports.getUserConsts imp).filter (fun c => ¬ c.isDef)
let x ← x.filterM (fun c => do
return Bool.not (← (Name.hasDocString c.name)))
let y ← x.filterM (fun c => Name.hasPos c.name)
let loc ← y.mapM (fun c => (Name.location c.name))
if loc.toList.length > 0 then
IO.println "\n"
IO.println s!"Module {imp.module} has the following lemmas without doc strings:"
IO.println (String.intercalate "\n" loc.toList.mergeSort)
pure 0
unsafe def main (args : List String) : IO UInt32 := do
initSearchPath (← findSysroot)
let imports ← allImports
let _ ← CoreM.withImportModules #[`HepLean] (imports.mapM Imports.NoDocStringDef).run'
if "--lemmas" ∈ args then
let _ ← CoreM.withImportModules #[`HepLean] (imports.mapM Imports.NoDocStringLemma).run'
pure 0

9
scripts/lint_all.lean
View file

@ -3,12 +3,6 @@ Copyright (c) 2024 Joseph Tooby-Smith. All rights reserved.
Released under Apache 2.0 license.
Authors: Joseph Tooby-Smith
-/
import Batteries.Lean.HashSet
import Lean
import Mathlib.Lean.Expr.Basic
import Mathlib.Lean.CoreM
import HepLean.Meta.Informal.Post
import ImportGraph.RequiredModules
def main (_: List String) : IO UInt32 := do
println! "Style lint ... "
@ -20,9 +14,6 @@ def main (_: List String) : IO UInt32 := do
println! "File imports ... "
let importCheck ← IO.Process.output {cmd := "lake", args := #["exe", "check_file_imports"]}
println! importCheck.stdout
println! "Doc check ..."
let docCheck ← IO.Process.output {cmd := "lake", args := #["exe", "no_docs"]}
println! docCheck.stdout
println! "Lean linter ..."
let leanCheck ← IO.Process.output {cmd := "lake", args := #["exe", "runLinter", "HepLean"]}
println! leanCheck.stdout