phanerozoic/Lean4-PhysLean · Datasets at Hugging Face

fact stringlengths 19 8.26k	type stringclasses 8 values	library stringclasses 2 values	imports listlengths 0 7	filename stringclasses 397 values	symbolic_name stringlengths 1 73	docstring stringlengths 20 499 ⌀
addModulesIn (recurse : Bool) (prev : Array Name) (root : Name := .anonymous) (path : FilePath) : IO (Array Name) := do let mut r := prev for entry in ← path.readDir do if ← entry.path.isDir then if recurse then r ← addModulesIn recurse r (root.mkStr entry.fileName) entry.path else let .some mod := FilePath.fileStem entry.fileName \| continue r := r.push (root.mkStr mod) pure r /-- Compute imports expected by `PhysLean.lean` by looking at file structure. -/	def	scripts	[ "import Batteries.Lean.HashSet", "import Lean" ]	scripts/check_file_imports.lean	addModulesIn	/-- Recursively finds files in directory. -/
expectedPhysLeanImports : IO (Array Name) := do let mut needed := #[] for top in ← FilePath.readDir "PhysLean" do let nm := `PhysLean let rootname := FilePath.withExtension top.fileName "" let root := nm.mkStr rootname.toString if ← top.path.isDir then needed ← addModulesIn (recurse := true) needed (root := root) top.path else needed := needed.push root pure needed	def	scripts	[ "import Batteries.Lean.HashSet", "import Lean" ]	scripts/check_file_imports.lean	expectedPhysLeanImports	/-- Compute imports expected by `PhysLean.lean` by looking at file structure. -/
listDif : (a: List String) → (b : List String) → (List String × List String) \| [], [] => ([], []) \| a :: as, [] => (a :: as, []) \| [], b :: bs => ([], b :: bs) \| a :: as, b :: bs => if a = b then listDif as bs else (a :: (listDif as bs).1, b :: (listDif as bs).2) /-- Checks whether an array `imports` is sorted after `Init` is removed. -/	def	scripts	[ "import Batteries.Lean.HashSet", "import Lean" ]	scripts/check_file_imports.lean	listDif	null
arrayImportSorted (imports : Array Import) : IO Bool := do let X := (imports.map (fun x => x.module.toString)).filter (fun x => x != "Init") let mut warned := false if ! X = X.qsort (· < ·) then IO.print s!"Import file is not sorted. \n" let ldif := listDif X.toList (X.qsort (· < ·)).toList let lzip := List.zip ldif.1 ldif.2 let lstring := String.intercalate "\n" (lzip.map (fun x => s!"{x.1} > {x.2}")) println! lstring warned := true pure warned /-- Checks every file in `reqImports` is imported into `modData` return true if this is NOT the case. -/	def	scripts	[ "import Batteries.Lean.HashSet", "import Lean" ]	scripts/check_file_imports.lean	arrayImportSorted	/-- Checks whether an array `imports` is sorted after `Init` is removed. -/
checkMissingImports (modData : ModuleData) (reqImports : Array Name) : IO Bool := do let names : Std.HashSet Name := Std.HashSet.ofArray (modData.imports.map (·.module)) let mut warned := false let nameArray := reqImports.filterMap ( fun req => if !names.contains req then some req else none) if nameArray.size ≠ 0 then let nameArraySort := nameArray.qsort (·.toString < ·.toString) IO.print s!"Files are not imported add the following to the `PhysLean` file: \n" for name in nameArraySort do IO.print s!"import {name}\n" warned := true pure warned	def	scripts	[ "import Batteries.Lean.HashSet", "import Lean" ]	scripts/check_file_imports.lean	checkMissingImports	/-- Checks every file in `reqImports` is imported into `modData` return true if this is NOT the case. -/
main (_ : List String) : IO UInt32 := do initSearchPath (← findSysroot) let mods : Name := `PhysLean 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 ePhysLeanImports ← expectedPhysLeanImports let sortedWarned ← arrayImportSorted hepLeanMod.imports let warned ← checkMissingImports hepLeanMod ePhysLeanImports if (warned ∨ sortedWarned) then throw <\| IO.userError s!"\x1b[31mThe PhysLean.lean file is not sorted, or has missing imports.\x1b[0m" else IO.println s!"\x1b[32mAll files are imported correctly into PhysLean.lean.\x1b[0m" pure 0	def	scripts	[ "import Batteries.Lean.HashSet", "import Lean" ]	scripts/check_file_imports.lean	main	null
PhysLeanTODOItem : Type := Array String → Array (String × ℕ) /-- Checks if a . -/	def	scripts	[ "import Lean", "import Batteries.Data.String.Matcher", "import Mathlib.Data.Nat.Notation" ]	scripts/find_TODOs.lean	PhysLeanTODOItem	/-- Given a list of lines, outputs an error message and a line number. -/
TODOFinder : PhysLeanTODOItem := fun lines ↦ Id.run do let enumLines := (lines.toList.enumFrom 1) let todos := enumLines.filterMap (fun (lno1, l1) ↦ if l1.startsWith "/-! TODO:" then some ((l1.replace "/-! TODO: " "").replace "-/" "", lno1) else none) todos.toArray	def	scripts	[ "import Lean", "import Batteries.Data.String.Matcher", "import Mathlib.Data.Nat.Notation" ]	scripts/find_TODOs.lean	TODOFinder	/-- Checks if a . -/
TODOContext where /-- The underlying `message`. -/ statement : String /-- The line number -/ lineNumber : ℕ /-- The file path -/ path : FilePath	structure	scripts	[ "import Lean", "import Batteries.Data.String.Matcher", "import Mathlib.Data.Nat.Notation" ]	scripts/find_TODOs.lean	TODOContext	/-- Checks if a . -/
printTODO (todos : Array TODOContext) : IO Unit := do for e in todos do IO.println (s!"{e.path}:{e.lineNumber}: {e.statement}")	def	scripts	[ "import Lean", "import Batteries.Data.String.Matcher", "import Mathlib.Data.Nat.Notation" ]	scripts/find_TODOs.lean	printTODO	/-- The file path -/
filePathToGitPath (S : FilePath) (n : ℕ) : String := "https://github.com/HEPLean/PhysLean/blob/master/"++ (S.toString.replace "." "/").replace "/lean" ".lean" ++ "#L" ++ toString n	def	scripts	[ "import Lean", "import Batteries.Data.String.Matcher", "import Mathlib.Data.Nat.Notation" ]	scripts/find_TODOs.lean	filePathToGitPath	/-- The file path -/
docTODO (todos : Array TODOContext) : IO String := do let mut out := "" for e in todos do out := out ++ (s!" - [{e.statement}]("++ filePathToGitPath e.path e.lineNumber ++ ")\n") return out	def	scripts	[ "import Lean", "import Batteries.Data.String.Matcher", "import Mathlib.Data.Nat.Notation" ]	scripts/find_TODOs.lean	docTODO	/-- The file path -/
hepLeanLintFile (path : FilePath) : IO String := do let lines ← IO.FS.lines path let allOutput := (Array.map (fun lint ↦ (Array.map (fun (e, n) ↦ TODOContext.mk e n path)) (lint lines))) #[TODOFinder] let errors := allOutput.flatten printTODO errors docTODO errors	def	scripts	[ "import Lean", "import Batteries.Data.String.Matcher", "import Mathlib.Data.Nat.Notation" ]	scripts/find_TODOs.lean	hepLeanLintFile	null
todoFileHeader : String := s!" # TODO List This is an automatically generated list of TODOs appearing as `/-! TODO:...` in PhysLean. Please feel free to contribute to the completion of these tasks. "	def	scripts	[ "import Lean", "import Batteries.Data.String.Matcher", "import Mathlib.Data.Nat.Notation" ]	scripts/find_TODOs.lean	todoFileHeader	null
main (args : List String) : IO UInt32 := do initSearchPath (← findSysroot) let mods : Name := `PhysLean 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 mut out : String := "" for imp in hepLeanMod.imports do if imp.module == `Init then continue let filePath := (mkFilePath (imp.module.toString.split (· == '.'))).addExtension "lean" let l ← hepLeanLintFile filePath if l != "" then out := out ++ "\n### " ++ imp.module.toString ++ "\n" out := out ++ l let fileOut : System.FilePath := {toString := "./docs/TODOList.md"} /- Below here is concerned with writing out to the docs. -/ if "mkFile" ∈ args then IO.println (s!"TODOList file made.") IO.FS.writeFile fileOut (todoFileHeader ++ out) return 0	def	scripts	[ "import Lean", "import Batteries.Data.String.Matcher", "import Mathlib.Data.Nat.Notation" ]	scripts/find_TODOs.lean	main	null
main (args : List String) : IO UInt32 := do println! "\x1b[36m(1/7) Style lint \x1b[0m" println! "\x1b[2mThis linter is not checked by GitHub but if you have time please fix these errors.\x1b[0m" let styleLint ← IO.Process.output {cmd := "lake", args := #["exe", "style_lint"]} println! styleLint.stdout println! "\x1b[36m(2/7) Building \x1b[0m" let build ← IO.Process.output {cmd := "lake", args := #["build"]} let s1 := "Build completed successfully" let s2 := build.stdout if ¬ (s2.splitOn s1).length = 2 then println! "\x1b[31mError: Build failed. Run `lake build` to see the errors.\x1b[0m\n" else println! "\x1b[32mBuild is successful.\x1b[0m\n" println! "\x1b[36m(3/7) File imports \x1b[0m" let importCheck ← IO.Process.output {cmd := "lake", args := #["exe", "check_file_imports"]} println! importCheck.stdout println! "\x1b[36m(4/7) TODO tag duplicates \x1b[0m" let todoCheck ← IO.Process.output {cmd := "lake", args := #["exe", "check_dup_tags"]} println! todoCheck.stdout println! "\x1b[36m(5/7) Sorry and pseudo attribute linter \x1b[0m" let sorryPseudoCheck ← IO.Process.output {cmd := "lake", args := #["exe", "sorry_lint"]} println! sorryPseudoCheck.stdout if ¬ "--fast" ∈ args then println! "\x1b[36m(6/7) Lean linter \x1b[0m" println! "\x1b[2mExpect this linter to take a while to run, it can be skipped with lake exe lint_all --fast" println! "You can manually perform this linter by placing `#lint` at the end of the files you have modified.\x1b[0m" let leanCheck ← IO.Process.output {cmd := "lake", args := #["exe", "runPhysLeanLinters", "PhysLean"]} println! leanCheck.stdout println! "\x1b[36m(7/7) Transitive imports \x1b[0m" println! "\x1b[2mExpect this linter to take a while to run, it can be skipped with lake exe lint_all --fast\x1b[0m" let redundentImports ← IO.Process.output {cmd := "lake", args := #["exe", "redundant_imports"]} println! redundentImports.stdout pure 0	def	scripts	[]	scripts/lint_all.lean	main	null
lintStyleCli (args : Cli.Parsed) : IO UInt32 := do let mode : OutputSetting := match (args.hasFlag "update", args.hasFlag "github") with \| (true, _) => OutputSetting.update \| (false, true) => OutputSetting.print ErrorFormat.github \| (false, false) => OutputSetting.print ErrorFormat.humanReadable let mut allModules := #[] for s in ["PhysLean.lean"] do allModules := allModules.append ((← IO.FS.lines s).filter (!·.containsSubstr "Batteries") \|>.map (·.stripPrefix "import ")) let numberErrorFiles ← lintModules allModules mode return min numberErrorFiles 125 /-- Setting up command line options and help text for `lake exe lint_style`. -/ -- so far, no help options or so: perhaps that is fine?	def	scripts	[ "import Mathlib.Tactic.Linter.TextBased", "import Cli.Basic" ]	scripts/mathlib_textLint_on_hepLean.lean	lintStyleCli	/-- Implementation of the `lint_style` command line program. -/
heplean_lint_style : Cmd := `[Cli\| lint_style VIA lintStyleCli; ["0.0.1"] "Run text-based style linters on every Lean file in PhysLean (adapted from mathlib's lint_style). Print errors about any unexpected style errors to standard output." FLAGS: github; "Print errors in a format suitable for github problem matchers\n\ otherwise, produce human-readable output" update; "Print errors solely for the style exceptions file" ] /-- The entry point to the `lake exe mathlib_textLint_on_hepLean` command. -/	def	scripts	[ "import Mathlib.Tactic.Linter.TextBased", "import Cli.Basic" ]	scripts/mathlib_textLint_on_hepLean.lean	heplean_lint_style	/-- Setting up command line options and help text for `lake exe lint_style`. -/
main (args : List String) : IO UInt32 := do heplean_lint_style.validate args	def	scripts	[ "import Mathlib.Tactic.Linter.TextBased", "import Cli.Basic" ]	scripts/mathlib_textLint_on_hepLean.lean	main	/-- The entry point to the `lake exe mathlib_textLint_on_hepLean` command. -/
getDocString (constName : Array ConstantInfo) : MetaM String := do let env ← getEnv let mut docString := "" for c in constName do if ¬ Lean.Name.isInternalDetail c.name then let doc ← Lean.findDocString? env c.name match doc with \| some x => docString := docString ++ "- " ++ x ++ "\n" \| none => docString := docString return docString	def	scripts	[ "import Batteries.Lean.IO.Process", "import Lean", "import Lean.Parser", "import Lean.Data.Json", "import Mathlib.Lean.CoreM", "import LLM.GPT.Json", "import LLM.GPT.API" ]	scripts/openAI_doc_check.lean	getDocString	null
header : String := " Answer as if you an expert mathematician, physicist and software engineer. Below I have listed the doc strings of definitions and theorems in a Lean 4 file. Output a list of 1) spelling mistakes. 2) grammatical errors. 3) suggestions for improvement. Note that text within `...` should be treated as code and not spellchecked. Doc strings should be a complete sentence, or a noun phrase. "	def	scripts	[ "import Batteries.Lean.IO.Process", "import Lean", "import Lean.Parser", "import Lean.Data.Json", "import Mathlib.Lean.CoreM", "import LLM.GPT.Json", "import LLM.GPT.API" ]	scripts/openAI_doc_check.lean	header	null
main (args : List String) : IO UInt32 := do initSearchPath (← findSysroot) let firstArg := args.head? match firstArg with \| some x => do let mut imp : Import := Import.mk x.toName false if x == "random" then let mods : Name := `PhysLean let imps : Import := {module := mods} let mFile ← findOLean imps.module unless (← mFile.pathExists) do throw <\| IO.userError s!"object file '{mFile}' of module {imps.module} does not exist" let (hepLeanMod, _) ← readModuleData mFile let imports := hepLeanMod.imports let y ← IO.rand 0 (imports.size -1) imp := imports.get! y let mFile ← findOLean imp.module let filePath := (mkFilePath (imp.module.toString.split (· == '.'))).addExtension "lean" IO.println s!"Checking: {filePath}" let (modData, _) ← readModuleData mFile let cons := modData.constants let docString ← CoreM.withImportModules #[imp.module] (getDocString cons).run' let message : LLM.Message := {role := Role.user, content := header ++ docString} let request : GPT.Request := {messages := [message]} let response ← LLM.GPT.chat (toString <\| ToJson.toJson request) let parsedRespone := GPT.parse response match parsedRespone with \| .ok x => IO.println x \| .error e => IO.println e \| none => IO.println "No module provided." return 0	def	scripts	[ "import Batteries.Lean.IO.Process", "import Lean", "import Lean.Parser", "import Lean.Data.Json", "import Mathlib.Lean.CoreM", "import LLM.GPT.Json", "import LLM.GPT.API" ]	scripts/openAI_doc_check.lean	main	null
getStats : MetaM String := do let noDefsVal ← noDefs let noLemmasVal ← noLemmas let noImportsVal ← noImports let noDefsNoDocVal ← noDefsNoDocString let noLemmasNoDocVal ← noLemmasNoDocString let noLinesVal ← noLines let noInformalLemmasVal ← noInformalLemmas let s := s!" Number of Files 📄: {noImportsVal} Number of lines 💻: {noLinesVal} Number of Definitions (incl. instances): {noDefsVal - noInformalLemmasVal} - Of which {noDefsNoDocVal} do not have doc-strings Number of Lemmas: {noLemmasVal + noInformalLemmasVal} - Of which {noLemmasNoDocVal} do not have doc-strings" pure s	def	scripts	[ "import PhysLean.Meta.Informal.Post", "import Mathlib.Lean.CoreM" ]	scripts/stats.lean	getStats	null
Stats.toHtml : MetaM String := do let noDefsVal ← noDefs let noLemmasVal ← noLemmas let noImportsVal ← noImports let noDefsNoDocVal ← noDefsNoDocString let noLemmasNoDocVal ← noLemmasNoDocString let noLinesVal ← noLines let noInformalDefsVal ← noInformalDefs let noInformalLemmasVal ← noInformalLemmas let noTODOsVal ← noTODOs let noFilesWithTODOsVal ← noFilesWithTODOs let header := "--- layout: default --- <!DOCTYPE html> <html> <head> <title>Stats for PhysLean</title> <meta name=\"viewport\" content=\"width=device-width, initial-scale=1.0\"> <style> /* Style the progress bar to be wider and take up more space / progress { width: 80%; / Adjust to take up more horizontal space / height: 30px; / Increase height to make it wider / appearance: none; / Remove default browser styles / } / Change the color for WebKit browsers (Chrome, Safari, etc.) / progress::-webkit-progress-bar { background-color: #f3f3f3; / Background color / border-radius: 5px; overflow: hidden; } progress::-webkit-progress-value { background-color: #157878; / Change this to your desired color / border-radius: 5px; } / Change the color for Firefox / progress::-moz-progress-bar { background-color: #157878; / Change this to your desired color */ } </style> </head> <body>" let body := s!" <h1>Stats for PhysLean</h1> <h3>Number of Files 📄: {noImportsVal}</h3> <h3>Number of lines 💻: {noLinesVal}</h3> <h3>Number of Definitions (incl. instances): {noDefsVal - noInformalLemmasVal}</h3> <p>- Of which {noDefsVal - noDefsNoDocVal- noInformalLemmasVal} have doc-strings:</p> <progress value=\"{noDefsVal - noDefsNoDocVal- noInformalLemmasVal}\" max=\"{noDefsVal- noInformalLemmasVal}\"></progress> <p>- Of which {noDefsVal - noInformalLemmasVal - noInformalDefsVal} are not <a href=\"https://heplean.github.io/HepLean/InformalGraph.html\">informal definitions</a>:</p> <progress value=\"{noDefsVal - noInformalLemmasVal - noInformalDefsVal}\" max=\"{noDefsVal - noInformalLemmasVal}\"></progress> <h3>Number of Lemmas: {noLemmasVal + noInformalLemmasVal}</h3> <p>- Of which {noLemmasVal - noLemmasNoDocVal + noInformalLemmasVal} have doc-strings:</p> <progress value=\"{noLemmasVal - noLemmasNoDocVal + noInformalLemmasVal}\" max=\"{noLemmasVal + noInformalLemmasVal}\"></progress> <p>- Of which {noLemmasVal} are not <a href=\"https://heplean.github.io/HepLean/InformalGraph.html\">informal lemmas</a>:</p> <progress value=\"{noLemmasVal}\" max=\"{noLemmasVal + noInformalLemmasVal}\"></progress> <h3>Number of <a href=\"https://heplean.github.io/HepLean/TODOList\">TODOs</a>: {noTODOsVal}</h3> <p>- There are {noImportsVal - noFilesWithTODOsVal} (of {noImportsVal}) files which are TODO free:</p> <progress value=\"{noImportsVal - noFilesWithTODOsVal}\" max=\"{noImportsVal}\"></progress> " let footer := " </body> </html> " pure (header ++ "\n" ++ body ++ "\n" ++ footer)	def	scripts	[ "import PhysLean.Meta.Informal.Post", "import Mathlib.Lean.CoreM" ]	scripts/stats.lean	Stats.toHtml	null
main (args : List String) : IO UInt32 := do let _ ← noImports let statString ← CoreM.withImportModules #[`PhysLean] (getStats).run' println! statString if "mkHTML" ∈ args then let html ← CoreM.withImportModules #[`PhysLean] (Stats.toHtml).run' let htmlFile : System.FilePath := {toString := "./docs/Stats.html"} IO.FS.writeFile htmlFile html IO.println (s!"HTML file made.") pure 0	def	scripts	[ "import PhysLean.Meta.Informal.Post", "import Mathlib.Lean.CoreM" ]	scripts/stats.lean	main	null
baseHtmlGenerator (title : String) (site : Array Html) : BaseHtmlM Html := do let moduleConstant := if let some module := ← getCurrentName then #[<script>{.raw s!"const MODULE_NAME={String.quote module.toString};"}</script>] else #[] pure <html lang="en"> <head> [← baseHtmlHeadDeclarations] <title>{title}</title> <script defer="true" src={s!"{← getRoot}mathjax-config.js"}></script> <script defer="true" src="https://cdnjs.cloudflare.com/polyfill/v3/polyfill.min.js?features=es6"></script> <script defer="true" src="https://cdn.jsdelivr.net/npm/mathjax@3/es5/tex-mml-chtml.js"></script> <script>{.raw s!"const SITE_ROOT={String.quote (← getRoot)};"}</script> [moduleConstant] <script type="module" src={s!"{← getRoot}jump-src.js"}></script> <script type="module" src={s!"{← getRoot}search.js"}></script> <script type="module" src={s!"{← getRoot}expand-nav.js"}></script> <script type="module" src={s!"{← getRoot}how-about.js"}></script> <script type="module" src={s!"{← getRoot}instances.js"}></script> <script type="module" src={s!"{← getRoot}importedBy.js"}></script> </head> <body> <input id="nav_toggle" type="checkbox"/> <header style="background-color: #2C3E50; color: #fff;"> <h1><label for="nav_toggle"></label><span> <a href="heplean.com" style="color: #fff; text-decoration: none; font-family: serif"> PhysLean Documentation</a> </span></h1> <h2 style="color: #fff; font-family: serif">[breakWithin title]</h2> <form action="https://google.com/search" method="get" id="search_form" style="color: var(--text-color);"> <input type="hidden" name="sitesearch" value="https://leanprover-community.github.io/mathlib4_docs"/> <input type="text" name="q" autocomplete="off"/>{.raw " "} <button id="search_button" onclick={s!"javascript: form.action='{← getRoot}search.html';"}>Search</button> <button>Google site search</button> </form> </header> [site] <nav class="nav"> <iframe src={s!"{← getRoot}navbar.html"} class="navframe" frameBorder="0"></iframe> </nav> </body> </html> /-- A comfortability wrapper around `baseHtmlGenerator`. -/	def	scripts	[ "import DocGen4.Output.ToHtmlFormat", "import DocGen4.Output.Navbar" ]	scripts/Template.lean	baseHtmlGenerator	/-- The HTML template used for all pages. -/
baseHtml (title : String) (site : Html) : BaseHtmlM Html := baseHtmlGenerator title #[site]	def	scripts	[ "import DocGen4.Output.ToHtmlFormat", "import DocGen4.Output.Navbar" ]	scripts/Template.lean	baseHtml	/-- A comfortability wrapper around `baseHtmlGenerator`. -/
IsUpperCamal (s : String) : Bool := let parts := s.splitOn "." let lastPart := parts.get! (parts.length - 1) lastPart = "noConfusionType" ∨ (¬ (lastPart.get 0 ≥ 'A' ∧ lastPart.get 0 ≤ 'z')) ∨ (lastPart.get 0 ≥ 'A' ∧ lastPart.get 0 ≤ 'Z')	def	scripts	[ "import Batteries.Lean.HashSet", "import Lean" ]	scripts/type_former_lint.lean	IsUpperCamal	/-- A rough definition of Upper Camal, checking that if a string starts with a latin letter then that letter is capital. -/
main (_ : List String) : IO UInt32 := do initSearchPath (← findSysroot) let mods : Name := `PhysLean 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 mut warned := false for imp in hepLeanMod.imports do let mFile ← findOLean imp.module let (modData, _) ← readModuleData mFile let cons := modData.constants for c in cons do if c.hasValue ∧ ¬ Lean.Name.isInternal c.name ∧ Lean.Compiler.LCNF.isTypeFormerType c.type ∧ ¬ IsUpperCamal c.name.toString then warned := true IO.println s!"name: #{c.name}" if warned then throw <\| IO.userError s!"There are type former definitions not in upper camal style." pure 0	def	scripts	[ "import Batteries.Lean.HashSet", "import Lean" ]	scripts/type_former_lint.lean	main	/-- A rough definition of Upper Camal, checking that if a string starts with a latin letter then that letter is capital. -/
eulerLagrangeOp (L : Time → X → X → ℝ) (q : Time → X) : Time → X := fun t => gradient (L t · (∂ₜ q t)) (q t) - ∂ₜ (fun t' => gradient (L t' (q t') ·) (∂ₜ q t')) t	def	PhysLean	[ "import PhysLean.Mathematics.VariationalCalculus.HasVarGradient" ]	PhysLean/ClassicalMechanics/EulerLagrange.lean	eulerLagrangeOp	/-- The Euler Lagrange operator, for a trajectory `q : Time → X`, and a lagrangian `Time → X → X → ℝ`, the Euler-Lagrange operator is `∂L/∂q - dₜ(∂L/∂(dₜ q))`. -/
eulerLagrangeOp_eq (L : Time → X → X → ℝ) (q : Time → X) : eulerLagrangeOp L q = fun t => gradient (L t · (∂ₜ q t)) (q t) - ∂ₜ (fun t' => gradient (L t' (q t') ·) (∂ₜ q t')) t := by rfl	lemma	PhysLean	[ "import PhysLean.Mathematics.VariationalCalculus.HasVarGradient" ]	PhysLean/ClassicalMechanics/EulerLagrange.lean	eulerLagrangeOp_eq	/-- The Euler Lagrange operator, for a trajectory `q : Time → X`, and a lagrangian `Time → X → X → ℝ`, the Euler-Lagrange operator is `∂L/∂q - dₜ(∂L/∂(dₜ q))`. -/
eulerLagrangeOp_zero (q : Time → X) : eulerLagrangeOp (fun _ _ _ => 0) q = fun _ => 0 := by simp [eulerLagrangeOp_eq, Time.deriv_eq] /- The variational derivative of `L t (q' t) (deriv q' t))` for a lagrangian `L` is equal to the `eulerLagrangeOp`. -/	lemma	PhysLean	[ "import PhysLean.Mathematics.VariationalCalculus.HasVarGradient" ]	PhysLean/ClassicalMechanics/EulerLagrange.lean	eulerLagrangeOp_zero	null
euler_lagrange_varGradient (L : Time → X → X → ℝ) (q : Time → X) (hq : ContDiff ℝ ∞ q) (hL : ContDiff ℝ ∞ ↿L) : (δ (q':=q), ∫ t, L t (q' t) (fderiv ℝ q' t 1)) = eulerLagrangeOp L q := by rw [eulerLagrangeOp_eq] simp only [Time.deriv_eq] apply HasVarGradientAt.varGradient apply HasVarGradientAt.intro _ · apply HasVarAdjDerivAt.comp (F := fun (φ : Time → X × X) t => L t (φ t).fst (φ t).snd) (G := fun (φ : Time → X) t => (φ t, fderiv ℝ φ t 1)) · apply HasVarAdjDerivAt.fmap (f := fun t => ↿(L t)) · fun_prop · fun_prop intro x u apply DifferentiableAt.hasAdjFDerivAt apply Differentiable.differentiableAt apply ContDiff.differentiable fun_prop simp · apply HasVarAdjDerivAt.prod (F:=fun φ => φ) · apply HasVarAdjDerivAt.id _ hq · apply HasVarAdjDerivAt.fderiv · exact hq case hgrad => funext t simp (disch:=fun_prop) only simp[sub_eq_add_neg] congr rw [gradient_eq_adjFDeriv, adjFDeriv_uncurry] apply ContDiff.differentiable (n := ∞) (by fun_prop) ENat.LEInfty.out apply ContDiff.differentiable (n := ∞) (by fun_prop) ENat.LEInfty.out funext t rw [gradient_eq_adjFDeriv, adjFDeriv_uncurry] apply ContDiff.differentiable (n := ∞) (by fun_prop) ENat.LEInfty.out apply ContDiff.differentiable (n := ∞) (by fun_prop) ENat.LEInfty.out	theorem	PhysLean	[ "import PhysLean.Mathematics.VariationalCalculus.HasVarGradient" ]	PhysLean/ClassicalMechanics/EulerLagrange.lean	euler_lagrange_varGradient	null
hamiltonEqOp (H : Time → X → X → ℝ) (p : Time → X) (q : Time → X) : Time → X × X := fun t => (∂ₜ q t + -gradient (fun x => H t x (q t)) (p t), - ∂ₜ p t + -gradient (fun x => H t (p t) x) (q t))	def	PhysLean	[ "import PhysLean.Mathematics.VariationalCalculus.HasVarGradient" ]	PhysLean/ClassicalMechanics/HamiltonsEquations.lean	hamiltonEqOp	/-- Given a hamiltonian `H : Time → X → X → ℝ` the operator which when set to zero implies the Hamilton equations. -/
hamiltonEqOp_eq (H : Time → X → X → ℝ) (p : Time → X) (q : Time → X) : hamiltonEqOp H p q = fun t => (∂ₜ q t + -gradient (fun x => H t x (q t)) (p t), - ∂ₜ p t + -gradient (fun x => H t (p t) x) (q t)) := by rfl	lemma	PhysLean	[ "import PhysLean.Mathematics.VariationalCalculus.HasVarGradient" ]	PhysLean/ClassicalMechanics/HamiltonsEquations.lean	hamiltonEqOp_eq	/-- Given a hamiltonian `H : Time → X → X → ℝ` the operator which when set to zero implies the Hamilton equations. -/
hamiltonEqOp_eq_zero_iff_hamiltons_equations (H : Time → X → X → ℝ) (p : Time → X) (q : Time → X) : hamiltonEqOp H p q = 0 ↔ (∀ t, ∂ₜ q t = gradient (fun x => H t x (q t)) (p t)) ∧ (∀ t, ∂ₜ p t = -gradient (fun x => H t (p t) x) (q t)) := by simp [hamiltonEqOp_eq] simp_all only [Time.deriv_eq] rw [funext_iff] simp_all only [Pi.zero_apply, Prod.mk_eq_zero] apply Iff.intro · intro h1 apply And.intro · intro t conv_rhs => rw [← add_zero (gradient (fun x => H t x (q t)) (p t)), ← (h1 t).1] simp · intro t conv_lhs => rw [← add_zero (fderiv ℝ p t 1), ← (h1 t).2] simp · intro a x simp_all only [add_neg_cancel, neg_neg, and_self]	lemma	PhysLean	[ "import PhysLean.Mathematics.VariationalCalculus.HasVarGradient" ]	PhysLean/ClassicalMechanics/HamiltonsEquations.lean	hamiltonEqOp_eq_zero_iff_hamiltons_equations	null
hamiltons_equations_varGradient (H : Time → X → X → ℝ) (pq : Time → X × X) (hp : ContDiff ℝ ∞ pq) (hL : ContDiff ℝ ∞ ↿H) : (δ (pq':= pq), ∫ t, ⟪(pq' t).1, ∂ₜ (Prod.snd ∘ pq') t⟫_ℝ - H t (pq' t).1 (pq' t).2) = fun t => hamiltonEqOp H (fun t => (pq t).1) (fun t => (pq t).2) t := by apply HasVarGradientAt.varGradient apply HasVarGradientAt.intro _ · apply HasVarAdjDerivAt.add · let i := fun (t : Time) (x : X × X) => ⟪x.1, x.2⟫_ℝ apply HasVarAdjDerivAt.comp (F := fun (φ : Time → X × X) t => i t (φ t)) (G := fun (φ : Time → X × X) t => ((φ t).1, fderiv ℝ (Prod.snd ∘ φ) t 1)) · apply HasVarAdjDerivAt.fmap · fun_prop · fun_prop intro t x apply DifferentiableAt.hasAdjFDerivAt fun_prop · apply HasVarAdjDerivAt.prod · apply HasVarAdjDerivAt.fst apply HasVarAdjDerivAt.id fun_prop · apply HasVarAdjDerivAt.fderiv' (F := fun (φ : Time → X × X) t => (φ t).2) apply HasVarAdjDerivAt.fmap · fun_prop · fun_prop intro t x apply DifferentiableAt.hasAdjFDerivAt fun_prop · apply HasVarAdjDerivAt.neg let H' := fun t => ↿(H t) change HasVarAdjDerivAt (fun φ x => H' x (φ x)) _ pq apply HasVarAdjDerivAt.fmap · fun_prop · fun_prop intro x u apply DifferentiableAt.hasAdjFDerivAt apply Differentiable.differentiableAt apply ContDiff.differentiable fun_prop simp · simp only [adjFDeriv_prod_snd, Prod.mk_add_mk, add_zero, zero_add] funext x rw [adjFDeriv_uncurry] swap · apply ContDiff.differentiable fun_prop simp simp only [Prod.neg_mk, Prod.mk_add_mk] rw [adjFDeriv_inner] simp only [one_smul] conv_rhs => enter [2, 1, 1, 1, 2, x] rw [adjFDeriv_inner] simp rw [← gradient_eq_adjFDeriv, ← gradient_eq_adjFDeriv] rfl · apply ContDiff.differentiable fun_prop simp · apply ContDiff.differentiable fun_prop simp	theorem	PhysLean	[ "import PhysLean.Mathematics.VariationalCalculus.HasVarGradient" ]	PhysLean/ClassicalMechanics/HamiltonsEquations.lean	hamiltons_equations_varGradient	null
ElectricField (d : ℕ := 3) := Time → Space d → EuclideanSpace ℝ (Fin d) /-- The magnetic field is a map from `d+1` dimensional spacetime to the vector space `ℝ^d`. -/	abbrev	PhysLean	[ "import PhysLean.SpaceAndTime.SpaceTime.Basic" ]	PhysLean/Electromagnetism/Basic.lean	ElectricField	/-- The electric field is a map from `d`+1 dimensional spacetime to the vector space `ℝ^d`. -/
MagneticField (d : ℕ := 3) := Time → Space d → EuclideanSpace ℝ (Fin d) open IndexNotation open realLorentzTensor /-- The vector potential of an electromagnetic field-/	abbrev	PhysLean	[ "import PhysLean.SpaceAndTime.SpaceTime.Basic" ]	PhysLean/Electromagnetism/Basic.lean	MagneticField	/-- The magnetic field is a map from `d+1` dimensional spacetime to the vector space `ℝ^d`. -/
VectorPotential (d : ℕ := 3) := SpaceTime d → ℝT[d, .up] /-- The electric permittivity and the magnetic permeability of free space. -/	abbrev	PhysLean	[ "import PhysLean.SpaceAndTime.SpaceTime.Basic" ]	PhysLean/Electromagnetism/Basic.lean	VectorPotential	/-- The vector potential of an electromagnetic field-/
EMSystem where /-- The permittivity of free space. -/ ε₀ : ℝ /-- The permeability of free space. -/ μ₀ : ℝ TODO "6V2UZ" "Charge density and current density should be generalized to signed measures, in such a way that they are still easy to work with and can be integrated with with tensor notation. See here: https://leanprover.zulipchat.com/#narrow/channel/479953-PhysLean/topic/Maxwell's.20Equations" /-- The charge density. -/	structure	PhysLean	[ "import PhysLean.SpaceAndTime.SpaceTime.Basic" ]	PhysLean/Electromagnetism/Basic.lean	EMSystem	/-- The electric permittivity and the magnetic permeability of free space. -/
ChargeDensity := Time → Space → ℝ /-- Current density. -/	abbrev	PhysLean	[ "import PhysLean.SpaceAndTime.SpaceTime.Basic" ]	PhysLean/Electromagnetism/Basic.lean	ChargeDensity	/-- The charge density. -/
CurrentDensity := Time → Space → EuclideanSpace ℝ (Fin 3) namespace EMSystem variable (𝓔 : EMSystem) open SpaceTime /-- The speed of light. -/	abbrev	PhysLean	[ "import PhysLean.SpaceAndTime.SpaceTime.Basic" ]	PhysLean/Electromagnetism/Basic.lean	CurrentDensity	/-- Current density. -/
c : ℝ := 1/(√(𝓔.μ₀ * 𝓔.ε₀)) /-- Coulomb's constant. -/	def	PhysLean	[ "import PhysLean.SpaceAndTime.SpaceTime.Basic" ]	PhysLean/Electromagnetism/Basic.lean	c	/-- The speed of light. -/
coulombConstant : ℝ := 1/(4 * Real.pi * 𝓔.ε₀)	def	PhysLean	[ "import PhysLean.SpaceAndTime.SpaceTime.Basic" ]	PhysLean/Electromagnetism/Basic.lean	coulombConstant	/-- Coulomb's constant. -/
fderiv_uncurry (f : X → Y → Z) (xy dxy : X × Y) (hf : DifferentiableAt 𝕜 (↿f) xy) : fderiv 𝕜 ↿f xy dxy = fderiv 𝕜 (f · xy.2) xy.1 dxy.1 + fderiv 𝕜 (f xy.1 ·) xy.2 dxy.2 := by have hx : (f · xy.2) = ↿f ∘ (fun x' => (x',xy.2)) := by rfl have hy : (f xy.1 ·) = ↿f ∘ (fun y' => (xy.1,y')) := by rfl rw [hx,hy] repeat rw [fderiv_comp (hg := by fun_prop) (hf := by fun_prop)] dsimp rw [← ContinuousLinearMap.map_add] congr repeat rw [DifferentiableAt.fderiv_prodMk (hf₁ := by fun_prop) (hf₂ := by fun_prop)] simp	lemma	PhysLean	[ "import Mathlib.Analysis.Calculus.FDeriv.Symmetric" ]	PhysLean/Mathematics/FDerivCurry.lean	fderiv_uncurry	null
fderiv_curry_fst (f : X × Y → Z) (x : X) (y : Y) (h : DifferentiableAt 𝕜 f (x,y)) (dx : X) : fderiv 𝕜 (fun x' => Function.curry f x' y) x dx = fderiv 𝕜 f (x,y) (dx, 0) := by have h1 : f = ↿(Function.curry f) := by ext x rfl conv_rhs => rw [h1] rw [fderiv_uncurry] simp only [Function.curry_apply, map_zero, add_zero] exact h	lemma	PhysLean	[ "import Mathlib.Analysis.Calculus.FDeriv.Symmetric" ]	PhysLean/Mathematics/FDerivCurry.lean	fderiv_curry_fst	null
fderiv_curry_snd (f : X × Y → Z) (x : X) (y : Y) (h : DifferentiableAt 𝕜 f (x,y)) (dy : Y) : fderiv 𝕜 (Function.curry f x) y dy = fderiv 𝕜 (f) (x,y) (0, dy) := by have h1 : f = ↿(Function.curry f) := by ext x rfl conv_rhs => rw [h1] rw [fderiv_uncurry] simp rfl exact h	lemma	PhysLean	[ "import Mathlib.Analysis.Calculus.FDeriv.Symmetric" ]	PhysLean/Mathematics/FDerivCurry.lean	fderiv_curry_snd	null
fderiv_uncurry_clm_comp (f : X → Y → Z) (hf : Differentiable 𝕜 (↿f)) : fderiv 𝕜 ↿f = fun xy => (fderiv 𝕜 (f · xy.2) xy.1).comp (ContinuousLinearMap.fst 𝕜 X Y) + (fderiv 𝕜 (f xy.1 ·) xy.2).comp (ContinuousLinearMap.snd 𝕜 X Y) := by funext xy apply ContinuousLinearMap.ext intro dxy rw [fderiv_uncurry] simp only [ContinuousLinearMap.add_apply, ContinuousLinearMap.coe_comp', ContinuousLinearMap.coe_fst', Function.comp_apply, ContinuousLinearMap.coe_snd'] fun_prop	lemma	PhysLean	[ "import Mathlib.Analysis.Calculus.FDeriv.Symmetric" ]	PhysLean/Mathematics/FDerivCurry.lean	fderiv_uncurry_clm_comp	null
fderiv_wrt_prod {f : X × Y → Z} {xy} (hf : DifferentiableAt 𝕜 f xy) : fderiv 𝕜 f xy = (fderiv 𝕜 (fun x' => f (x',xy.2)) xy.1).comp (ContinuousLinearMap.fst 𝕜 X Y) + (fderiv 𝕜 (fun y' => f (xy.1,y')) xy.2).comp (ContinuousLinearMap.snd 𝕜 X Y) := by apply ContinuousLinearMap.ext; intro (dx,dy) apply fderiv_uncurry (fun x y => f (x,y)) _ _ hf	lemma	PhysLean	[ "import Mathlib.Analysis.Calculus.FDeriv.Symmetric" ]	PhysLean/Mathematics/FDerivCurry.lean	fderiv_wrt_prod	null
fderiv_wrt_prod_clm_comp (f : X × Y → Z) (hf : Differentiable 𝕜 f) : fderiv 𝕜 f = fun xy => (fderiv 𝕜 (fun x' => f (x',xy.2)) xy.1).comp (ContinuousLinearMap.fst 𝕜 X Y) + (fderiv 𝕜 (fun y' => f (xy.1,y')) xy.2).comp (ContinuousLinearMap.snd 𝕜 X Y) := fderiv_uncurry_clm_comp (fun x y => f (x,y)) hf	lemma	PhysLean	[ "import Mathlib.Analysis.Calculus.FDeriv.Symmetric" ]	PhysLean/Mathematics/FDerivCurry.lean	fderiv_wrt_prod_clm_comp	null
fderiv_curry_clm_apply (f : X → Y →L[𝕜] Z) (y : Y) (x dx : X) (h : Differentiable 𝕜 f) : fderiv 𝕜 f x dx y = fderiv 𝕜 (f · y) x dx := by rw [fderiv_clm_apply] <;> first \| simp \| fun_prop /- Helper rw lemmas for proving differentiability conditions. -/	lemma	PhysLean	[ "import Mathlib.Analysis.Calculus.FDeriv.Symmetric" ]	PhysLean/Mathematics/FDerivCurry.lean	fderiv_curry_clm_apply	null
fderiv_uncurry_comp_fst (f : X → Y → Z) (y : Y) (hf : Differentiable 𝕜 (↿f)) : fderiv 𝕜 (fun x' => (↿f) (x', y)) = fun x => (fderiv 𝕜 (↿f) ((·, y) x)).comp (fderiv 𝕜 (·, y) x) := by have hl (y : Y) : (fun x' => (↿f) (x', y)) = ↿f ∘ (·, y) := by rfl rw [hl] funext x rw [fderiv_comp] · fun_prop · fun_prop	lemma	PhysLean	[ "import Mathlib.Analysis.Calculus.FDeriv.Symmetric" ]	PhysLean/Mathematics/FDerivCurry.lean	fderiv_uncurry_comp_fst	null
fderiv_uncurry_comp_snd (f : X → Y → Z) (x : X) (hf : Differentiable 𝕜 (↿f)) : fderiv 𝕜 (fun y' => (↿f) (x, y')) = fun y => (fderiv 𝕜 (↿f) ((x, ·) y)).comp (fderiv 𝕜 (x, ·) y) := by have hl (x : X) : (fun y' => (↿f) (x, y')) = ↿f ∘ (x, ·) := by rfl rw [hl] funext y rw [fderiv_comp] · fun_prop · fun_prop	lemma	PhysLean	[ "import Mathlib.Analysis.Calculus.FDeriv.Symmetric" ]	PhysLean/Mathematics/FDerivCurry.lean	fderiv_uncurry_comp_snd	null
fderiv_curry_comp_fst (f : X → Y → Z) (x dx : X) (y : Y) (hf : Differentiable 𝕜 (↿f)) : (fderiv 𝕜 (fun x' => f x' y) x) dx = (fderiv 𝕜 (↿f) ((·, y) x)) ((fderiv 𝕜 (·, y) x) dx) := by have hl (y : Y) : (fun x' => f x' y) = ↿f ∘ (·, y) := by rfl rw [hl] rw [fderiv_comp] simp only [ContinuousLinearMap.coe_comp', Function.comp_apply] · fun_prop · fun_prop	lemma	PhysLean	[ "import Mathlib.Analysis.Calculus.FDeriv.Symmetric" ]	PhysLean/Mathematics/FDerivCurry.lean	fderiv_curry_comp_fst	null
fderiv_curry_comp_snd (f : X → Y → Z) (x : X) (y dy : Y) (hf : Differentiable 𝕜 (↿f)) : (fderiv 𝕜 (fun y' => f x y') y) dy = (fderiv 𝕜 (↿f) ((x, ·) y)) ((fderiv 𝕜 (x, ·) y) dy) := by have hl (x : X) : (fun y' => f x y') = ↿f ∘ (x, ·) := by rfl rw [hl] rw [fderiv_comp] simp only [ContinuousLinearMap.coe_comp', Function.comp_apply] · fun_prop · fun_prop	lemma	PhysLean	[ "import Mathlib.Analysis.Calculus.FDeriv.Symmetric" ]	PhysLean/Mathematics/FDerivCurry.lean	fderiv_curry_comp_snd	null
fderiv_inr_fst_clm (x : X) (y : Y) : (fderiv 𝕜 (x, ·) y) = ContinuousLinearMap.inr 𝕜 X Y := by rw [(hasFDerivAt_prodMk_right x y).fderiv]	lemma	PhysLean	[ "import Mathlib.Analysis.Calculus.FDeriv.Symmetric" ]	PhysLean/Mathematics/FDerivCurry.lean	fderiv_inr_fst_clm	null
fderiv_inl_snd_clm (x : X) (y : Y) : (fderiv 𝕜 (·, y) x) = ContinuousLinearMap.inl 𝕜 X Y := by rw [(hasFDerivAt_prodMk_left x y).fderiv] /- Differentiability conditions. -/	lemma	PhysLean	[ "import Mathlib.Analysis.Calculus.FDeriv.Symmetric" ]	PhysLean/Mathematics/FDerivCurry.lean	fderiv_inl_snd_clm	null
function_differentiableAt_fst (f : X → Y → Z) (x : X) (y : Y) (hf : Differentiable 𝕜 (↿f)) : DifferentiableAt 𝕜 (fun x' => f x' y) x := by have hl : (fun x' => f x' y) = ↿f ∘ (·, y) := by funext x' rfl rw [hl] apply Differentiable.differentiableAt apply Differentiable.comp · fun_prop · fun_prop	lemma	PhysLean	[ "import Mathlib.Analysis.Calculus.FDeriv.Symmetric" ]	PhysLean/Mathematics/FDerivCurry.lean	function_differentiableAt_fst	null
function_differentiableAt_snd (f : X → Y → Z) (x : X) (y : Y) (hf : Differentiable 𝕜 (↿f)) : DifferentiableAt 𝕜 (fun y' => f x y') y := by have hl : (fun y' => f x y') = ↿f ∘ (x, ·) := by funext y' rfl rw [hl] apply Differentiable.differentiableAt apply Differentiable.comp · fun_prop · fun_prop @[fun_prop]	lemma	PhysLean	[ "import Mathlib.Analysis.Calculus.FDeriv.Symmetric" ]	PhysLean/Mathematics/FDerivCurry.lean	function_differentiableAt_snd	null
fderiv_uncurry_differentiable_fst (f : X → Y → Z) (y : Y) (hf : ContDiff 𝕜 2 ↿f) : Differentiable 𝕜 (fderiv 𝕜 fun x' => (↿f) (x', y)) := by fun_prop @[fun_prop]	lemma	PhysLean	[ "import Mathlib.Analysis.Calculus.FDeriv.Symmetric" ]	PhysLean/Mathematics/FDerivCurry.lean	fderiv_uncurry_differentiable_fst	null
fderiv_uncurry_differentiable_snd (f : X → Y → Z) (x : X) (hf : ContDiff 𝕜 2 ↿f) : Differentiable 𝕜 (fderiv 𝕜 fun y' => (↿f) (x, y')) := by fun_prop @[fun_prop]	lemma	PhysLean	[ "import Mathlib.Analysis.Calculus.FDeriv.Symmetric" ]	PhysLean/Mathematics/FDerivCurry.lean	fderiv_uncurry_differentiable_snd	null
fderiv_uncurry_differentiable_fst_comp_snd (f : X → Y → Z) (x : X) (hf : ContDiff 𝕜 2 ↿f) : Differentiable 𝕜 (fun y' => fderiv 𝕜 (fun x' => (↿f) (x', y')) x) := by fun_prop @[fun_prop]	lemma	PhysLean	[ "import Mathlib.Analysis.Calculus.FDeriv.Symmetric" ]	PhysLean/Mathematics/FDerivCurry.lean	fderiv_uncurry_differentiable_fst_comp_snd	null
fderiv_uncurry_differentiable_fst_comp_snd_apply (f : X → Y → Z) (x δx : X) (hf : ContDiff 𝕜 2 ↿f) : Differentiable 𝕜 (fun y' => fderiv 𝕜 (fun x' => (↿f) (x', y')) x δx) := by fun_prop @[fun_prop]	lemma	PhysLean	[ "import Mathlib.Analysis.Calculus.FDeriv.Symmetric" ]	PhysLean/Mathematics/FDerivCurry.lean	fderiv_uncurry_differentiable_fst_comp_snd_apply	null
fderiv_uncurry_differentiable_snd_comp_fst (f : X → Y → Z) (y : Y) (hf : ContDiff 𝕜 2 ↿f) : Differentiable 𝕜 (fun x' => fderiv 𝕜 (fun y' => (↿f) (x', y')) y) := by fun_prop @[fun_prop]	lemma	PhysLean	[ "import Mathlib.Analysis.Calculus.FDeriv.Symmetric" ]	PhysLean/Mathematics/FDerivCurry.lean	fderiv_uncurry_differentiable_snd_comp_fst	null
fderiv_uncurry_differentiable_snd_comp_fst_apply (f : X → Y → Z) (y δy : Y) (hf : ContDiff 𝕜 2 ↿f) : Differentiable 𝕜 (fun x' => fderiv 𝕜 (fun y' => (↿f) (x', y')) y δy) := by fun_prop @[fun_prop]	lemma	PhysLean	[ "import Mathlib.Analysis.Calculus.FDeriv.Symmetric" ]	PhysLean/Mathematics/FDerivCurry.lean	fderiv_uncurry_differentiable_snd_comp_fst_apply	null
fderiv_curry_differentiableAt_fst_comp_snd (f : X → Y → Z) (x dx : X) (y : Y) (hf : ContDiff 𝕜 2 ↿f) : DifferentiableAt 𝕜 (fun y' => (fderiv 𝕜 (fun x' => f x' y') x) dx) y := by apply Differentiable.differentiableAt fun_prop	lemma	PhysLean	[ "import Mathlib.Analysis.Calculus.FDeriv.Symmetric" ]	PhysLean/Mathematics/FDerivCurry.lean	fderiv_curry_differentiableAt_fst_comp_snd	null
fderiv_curry_differentiableAt_snd_comp_fst (f : X → Y → Z) (x : X) (y dy : Y) (hf : ContDiff 𝕜 2 ↿f) : DifferentiableAt 𝕜 (fun x' => (fderiv 𝕜 (fun y' => f x' y') y) dy) x := by apply Differentiable.differentiableAt fun_prop /- fderiv commutes on X × Y. -/	lemma	PhysLean	[ "import Mathlib.Analysis.Calculus.FDeriv.Symmetric" ]	PhysLean/Mathematics/FDerivCurry.lean	fderiv_curry_differentiableAt_snd_comp_fst	null
fderiv_swap [IsRCLikeNormedField 𝕜] (f : X → Y → Z) (x dx : X) (y dy : Y) (hf : ContDiff 𝕜 2 ↿f) : fderiv 𝕜 (fun x' => fderiv 𝕜 (fun y' => f x' y') y dy) x dx = fderiv 𝕜 (fun y' => fderiv 𝕜 (fun x' => f x' y') x dx) y dy := by have hf' : IsSymmSndFDerivAt 𝕜 (↿f) (x,y) := by apply ContDiffAt.isSymmSndFDerivAt (n := 2) · exact ContDiff.contDiffAt hf · simp have h := IsSymmSndFDerivAt.eq hf' (dx,0) (0,dy) rw [fderiv_wrt_prod_clm_comp, fderiv_wrt_prod_clm_comp] at h simp only [ContinuousLinearMap.add_apply, ContinuousLinearMap.coe_comp', ContinuousLinearMap.coe_fst', Function.comp_apply, ContinuousLinearMap.coe_snd', map_zero, add_zero, zero_add] at h rw [fderiv_curry_clm_apply, fderiv_curry_clm_apply] at h simp only [ContinuousLinearMap.add_apply, ContinuousLinearMap.coe_comp', ContinuousLinearMap.coe_fst', Function.comp_apply, map_zero, ContinuousLinearMap.coe_snd', zero_add, add_zero] at h exact h /- Start of differentiability conditions. -/ · fun_prop · fun_prop · exact hf.differentiable (by simp) · fun_prop	lemma	PhysLean	[ "import Mathlib.Analysis.Calculus.FDeriv.Symmetric" ]	PhysLean/Mathematics/FDerivCurry.lean	fderiv_swap	null
predAboveI (i x : Fin n.succ.succ) : Fin n.succ := if h : x.val < i.val then ⟨x.val, by omega⟩ else ⟨x.val - 1, by by_cases hx : x = 0 · omega · omega⟩	def	PhysLean	[ "import Mathlib.Tactic.Polyrith", "import Mathlib.Tactic.Linarith", "import Mathlib.Logic.Equiv.Fin.Basic" ]	PhysLean/Mathematics/Fin.lean	predAboveI	/-- Given a `i` and `x` in `Fin n.succ.succ` returns an element of `Fin n.succ` subtracting 1 if `i.val ≤ x.val` else casting x. -/
predAboveI_self (i : Fin n.succ.succ) : predAboveI i i = ⟨i.val - 1, by omega⟩ := by simp [predAboveI] @[simp]	lemma	PhysLean	[ "import Mathlib.Tactic.Polyrith", "import Mathlib.Tactic.Linarith", "import Mathlib.Logic.Equiv.Fin.Basic" ]	PhysLean/Mathematics/Fin.lean	predAboveI_self	/-- Given a `i` and `x` in `Fin n.succ.succ` returns an element of `Fin n.succ` subtracting 1 if `i.val ≤ x.val` else casting x. -/
predAboveI_succAbove (i : Fin n.succ.succ) (x : Fin n.succ) : predAboveI i (Fin.succAbove i x) = x := by simp only [Nat.succ_eq_add_one, predAboveI, Fin.succAbove, Fin.val_fin_lt, Fin.ext_iff] split_ifs · rfl · rename_i h1 h2 simp only [Fin.lt_def, Fin.coe_castSucc, not_lt, Fin.val_succ] at h1 h2 omega · rfl	lemma	PhysLean	[ "import Mathlib.Tactic.Polyrith", "import Mathlib.Tactic.Linarith", "import Mathlib.Logic.Equiv.Fin.Basic" ]	PhysLean/Mathematics/Fin.lean	predAboveI_succAbove	/-- Given a `i` and `x` in `Fin n.succ.succ` returns an element of `Fin n.succ` subtracting 1 if `i.val ≤ x.val` else casting x. -/
succsAbove_predAboveI {i x : Fin n.succ.succ} (h : i ≠ x) : Fin.succAbove i (predAboveI i x) = x := by simp only [Fin.succAbove, predAboveI, Nat.succ_eq_add_one, Fin.val_fin_lt, Fin.ext_iff] split_ifs · rfl · rename_i h1 h2 rw [Fin.lt_def] at h1 h2 simp only [Fin.succ_mk, add_eq_left, one_ne_zero] simp only [Fin.castSucc_mk, Fin.eta, Fin.val_fin_lt, not_lt] at h2 rw [Fin.le_def] at h2 omega · rename_i h1 h2 simp only [not_lt] at h1 rw [Fin.le_def] at h1 rw [Fin.lt_def] at h2 simp only [Fin.castSucc_mk] at h2 omega · rename_i h1 h2 simp only [Fin.succ_mk] rw [not_lt, Fin.le_def] at h1 omega	lemma	PhysLean	[ "import Mathlib.Tactic.Polyrith", "import Mathlib.Tactic.Linarith", "import Mathlib.Logic.Equiv.Fin.Basic" ]	PhysLean/Mathematics/Fin.lean	succsAbove_predAboveI	null
predAboveI_eq_iff {i x : Fin n.succ.succ} (h : i ≠ x) (y : Fin n.succ) : y = predAboveI i x ↔ i.succAbove y = x := by apply Iff.intro <;> intro h · subst h rw [succsAbove_predAboveI h] · simp [← h]	lemma	PhysLean	[ "import Mathlib.Tactic.Polyrith", "import Mathlib.Tactic.Linarith", "import Mathlib.Logic.Equiv.Fin.Basic" ]	PhysLean/Mathematics/Fin.lean	predAboveI_eq_iff	null
predAboveI_lt {i x : Fin n.succ.succ} (h : x.val < i.val) : predAboveI i x = ⟨x.val, by omega⟩ := by simp [predAboveI, h]	lemma	PhysLean	[ "import Mathlib.Tactic.Polyrith", "import Mathlib.Tactic.Linarith", "import Mathlib.Logic.Equiv.Fin.Basic" ]	PhysLean/Mathematics/Fin.lean	predAboveI_lt	null
predAboveI_ge {i x : Fin n.succ.succ} (h : i.val < x.val) : predAboveI i x = ⟨x.val - 1, by omega⟩ := by simp only [Nat.succ_eq_add_one, predAboveI, Fin.val_fin_lt, dite_eq_right_iff, Fin.mk.injEq] omega	lemma	PhysLean	[ "import Mathlib.Tactic.Polyrith", "import Mathlib.Tactic.Linarith", "import Mathlib.Logic.Equiv.Fin.Basic" ]	PhysLean/Mathematics/Fin.lean	predAboveI_ge	null
succAbove_succAbove_predAboveI (i : Fin n.succ.succ) (j : Fin n.succ) (x : Fin n) : i.succAbove (j.succAbove x) = (i.succAbove j).succAbove ((predAboveI (i.succAbove j) i).succAbove x) := by by_cases h1 : j.castSucc < i · have hx := Fin.succAbove_of_castSucc_lt _ _ h1 rw [hx, predAboveI_ge h1] by_cases hx1 : x.castSucc < j · rw [Fin.succAbove_of_castSucc_lt _ _ hx1, Fin.succAbove_of_castSucc_lt] · nth_rewrite 2 [Fin.succAbove_of_castSucc_lt] · rw [Fin.succAbove_of_castSucc_lt] exact hx1 · rw [Fin.lt_def] at h1 hx1 ⊢ simp_all only [Nat.succ_eq_add_one, Fin.coe_castSucc] omega · exact Nat.lt_trans hx1 h1 · simp only [not_lt] at hx1 rw [Fin.le_def] at hx1 rw [Fin.lt_def] at h1 rw [Fin.succAbove_of_le_castSucc _ _ hx1] by_cases hx2 : x.succ.castSucc < i · rw [Fin.succAbove_of_castSucc_lt _ _ hx2] nth_rewrite 2 [Fin.succAbove_of_castSucc_lt] · rw [Fin.succAbove_of_le_castSucc] · rfl · assumption · rw [Fin.lt_def] at hx2 ⊢ simp_all only [Nat.succ_eq_add_one, Fin.coe_castSucc, Fin.val_succ] omega · simp only [not_lt] at hx2 rw [Fin.succAbove_of_le_castSucc _ _ hx2] nth_rewrite 2 [Fin.succAbove_of_le_castSucc] · rw [Fin.succAbove_of_le_castSucc] rw [Fin.le_def] exact Nat.le_succ_of_le hx1 · rw [Fin.le_def] at hx2 ⊢ simp_all · simp only [Nat.succ_eq_add_one, not_lt] at h1 have hx := Fin.succAbove_of_le_castSucc _ _ h1 rw [hx, predAboveI_lt (Nat.lt_add_one_of_le h1)] by_cases hx1 : j ≤ x.castSucc · rw [Fin.succAbove_of_le_castSucc _ _ hx1, Fin.succAbove_of_le_castSucc _ _] · nth_rewrite 2 [Fin.succAbove_of_le_castSucc _ _] · rw [Fin.succAbove_of_le_castSucc] rw [Fin.le_def] at hx1 ⊢ simp_all only [Nat.succ_eq_add_one, Fin.coe_castSucc, Fin.val_succ, add_le_add_iff_right] · rw [Fin.le_def] at h1 hx1 ⊢ simp_all only [Nat.succ_eq_add_one, Fin.coe_castSucc] omega · rw [Fin.le_def] at hx1 h1 ⊢ simp_all only [Nat.succ_eq_add_one, Fin.coe_castSucc, Fin.val_succ] omega · simp only [Nat.succ_eq_add_one, not_le] at hx1 rw [Fin.lt_def] at hx1 rw [Fin.le_def] at h1 rw [Fin.succAbove_of_castSucc_lt _ _ hx1] by_cases hx2 : x.castSucc.castSucc < i · rw [Fin.succAbove_of_castSucc_lt _ _ hx2] nth_rewrite 2 [Fin.succAbove_of_castSucc_lt] · rw [Fin.succAbove_of_castSucc_lt] rw [Fin.lt_def] at hx2 ⊢ simp_all only [Nat.succ_eq_add_one, Fin.coe_castSucc, Fin.val_succ] omega · rw [Fin.lt_def] at hx2 ⊢ simp_all · simp only [not_lt] at hx2 rw [Fin.succAbove_of_le_castSucc _ _ hx2] nth_rewrite 2 [Fin.succAbove_of_le_castSucc] · rw [Fin.succAbove_of_castSucc_lt] · rfl exact Fin.castSucc_lt_succ_iff.mpr hx1 · rw [Fin.le_def] at hx2 ⊢ simp_all /-- The equivalence between `Fin n.succ` and `Fin 1 ⊕ Fin n` extracting the `i`th component. -/	lemma	PhysLean	[ "import Mathlib.Tactic.Polyrith", "import Mathlib.Tactic.Linarith", "import Mathlib.Logic.Equiv.Fin.Basic" ]	PhysLean/Mathematics/Fin.lean	succAbove_succAbove_predAboveI	null
finExtractOne {n : ℕ} (i : Fin (n + 1)) : Fin (n + 1) ≃ Fin 1 ⊕ Fin n := (finCongr (by omega : n.succ = i + 1 + (n - i))).trans <\| finSumFinEquiv.symm.trans <\| (Equiv.sumCongr (finSumFinEquiv.symm.trans (Equiv.sumComm (Fin i) (Fin 1))) (Equiv.refl (Fin (n-i)))).trans <\| (Equiv.sumAssoc (Fin 1) (Fin i) (Fin (n - i))).trans <\| Equiv.sumCongr (Equiv.refl (Fin 1)) (finSumFinEquiv.trans (finCongr (by omega))) @[simp]	def	PhysLean	[ "import Mathlib.Tactic.Polyrith", "import Mathlib.Tactic.Linarith", "import Mathlib.Logic.Equiv.Fin.Basic" ]	PhysLean/Mathematics/Fin.lean	finExtractOne	/-- The equivalence between `Fin n.succ` and `Fin 1 ⊕ Fin n` extracting the `i`th component. -/
finExtractOne_apply_eq {n : ℕ} (i : Fin n.succ) : finExtractOne i i = Sum.inl 0 := by simp only [Nat.succ_eq_add_one, finExtractOne, Equiv.trans_apply, finCongr_apply, Equiv.sumCongr_apply, Equiv.coe_trans, Equiv.sumComm_apply, Equiv.coe_refl, Fin.isValue] rw [show Fin.cast _ i = Fin.castAdd ((n - ↑i)) ⟨i.1, lt_add_one i.1⟩ from rfl, finSumFinEquiv_symm_apply_castAdd] simp only [Nat.succ_eq_add_one, Sum.map_inl, Function.comp_apply, Fin.isValue] have h2 : @Fin.mk (↑i + 1) ↑i (lt_add_one i.1) = Fin.natAdd i.val 1 := rfl rw [h2, finSumFinEquiv_symm_apply_natAdd] rfl	lemma	PhysLean	[ "import Mathlib.Tactic.Polyrith", "import Mathlib.Tactic.Linarith", "import Mathlib.Logic.Equiv.Fin.Basic" ]	PhysLean/Mathematics/Fin.lean	finExtractOne_apply_eq	null
finExtractOne_symm_inr {n : ℕ} (i : Fin n.succ) : (finExtractOne i).symm ∘ Sum.inr = i.succAbove := by ext x simp only [Nat.succ_eq_add_one, finExtractOne, Function.comp_apply, Equiv.symm_trans_apply, finCongr_symm, Equiv.symm_symm, Equiv.sumCongr_symm, Equiv.refl_symm, Equiv.sumCongr_apply, Equiv.coe_refl, Sum.map_inr, finCongr_apply, Fin.coe_cast] change (finSumFinEquiv (Sum.map (⇑(finSumFinEquiv.symm.trans (Equiv.sumComm (Fin ↑i) (Fin 1))).symm) id ((Equiv.sumAssoc (Fin 1) (Fin ↑i) (Fin (n - i))).symm (Sum.inr (finSumFinEquiv.symm (Fin.cast _ x)))))).val = _ by_cases hi : x.1 < i.1 · generalize_proofs hp have h1 : (finSumFinEquiv.symm (Fin.cast hp x)) = Sum.inl ⟨x, hi⟩ := by rw [← finSumFinEquiv_symm_apply_castAdd] rfl rw [h1] simp only [Nat.succ_eq_add_one, Equiv.sumAssoc_symm_apply_inr_inl, Sum.map_inl, Equiv.symm_trans_apply, Equiv.symm_symm, Equiv.sumComm_symm, Equiv.sumComm_apply, Sum.swap_inr, finSumFinEquiv_apply_left, Fin.castAdd_mk] rw [Fin.succAbove] split · rfl rename_i hn simp_all only [Nat.succ_eq_add_one, not_lt, Fin.le_def, Fin.coe_castSucc, Fin.val_succ, left_eq_add, one_ne_zero] omega · generalize_proofs hp have h1 : (finSumFinEquiv.symm (Fin.cast hp x)) = Sum.inr ⟨x - i, by omega⟩ := by rw [← finSumFinEquiv_symm_apply_natAdd] apply congrArg ext simp only [Nat.succ_eq_add_one, Fin.coe_cast, Fin.natAdd_mk] omega rw [h1, Fin.succAbove] split · rename_i hn simp_all [Fin.lt_def] simp only [Nat.succ_eq_add_one, Equiv.sumAssoc_symm_apply_inr_inr, Sum.map_inr, id_eq, finSumFinEquiv_apply_right, Fin.natAdd_mk, Fin.val_succ] omega @[simp]	lemma	PhysLean	[ "import Mathlib.Tactic.Polyrith", "import Mathlib.Tactic.Linarith", "import Mathlib.Logic.Equiv.Fin.Basic" ]	PhysLean/Mathematics/Fin.lean	finExtractOne_symm_inr	null
finExtractOne_symm_inr_apply {n : ℕ} (i : Fin n.succ) (x : Fin n) : (finExtractOne i).symm (Sum.inr x) = i.succAbove x := calc _ = ((finExtractOne i).symm ∘ Sum.inr) x := rfl _ = i.succAbove x := by rw [finExtractOne_symm_inr] @[simp]	lemma	PhysLean	[ "import Mathlib.Tactic.Polyrith", "import Mathlib.Tactic.Linarith", "import Mathlib.Logic.Equiv.Fin.Basic" ]	PhysLean/Mathematics/Fin.lean	finExtractOne_symm_inr_apply	null
finExtractOne_symm_inl_apply {n : ℕ} (i : Fin n.succ) : (finExtractOne i).symm (Sum.inl 0) = i := by rfl	lemma	PhysLean	[ "import Mathlib.Tactic.Polyrith", "import Mathlib.Tactic.Linarith", "import Mathlib.Logic.Equiv.Fin.Basic" ]	PhysLean/Mathematics/Fin.lean	finExtractOne_symm_inl_apply	null
finExtractOne_apply_neq {n : ℕ} (i j : Fin (n + 1 + 1)) (hij : i ≠ j) : finExtractOne i j = Sum.inr (predAboveI i j) := by symm apply (Equiv.symm_apply_eq _).mp ?_ simp only [Nat.succ_eq_add_one, finExtractOne_symm_inr_apply] exact succsAbove_predAboveI hij /-- Given an equivalence `Fin n.succ.succ ≃ Fin n.succ.succ`, and an `i : Fin n.succ.succ`, the map `Fin n.succ → Fin n.succ` obtained by dropping `i` and it's image. -/	lemma	PhysLean	[ "import Mathlib.Tactic.Polyrith", "import Mathlib.Tactic.Linarith", "import Mathlib.Logic.Equiv.Fin.Basic" ]	PhysLean/Mathematics/Fin.lean	finExtractOne_apply_neq	null
finExtractOnPermHom {m : ℕ} (i : Fin n.succ.succ) (σ : Fin n.succ.succ ≃ Fin m.succ.succ) : Fin n.succ → Fin m.succ := fun x => predAboveI (σ i) (σ ((finExtractOne i).symm (Sum.inr x)))	def	PhysLean	[ "import Mathlib.Tactic.Polyrith", "import Mathlib.Tactic.Linarith", "import Mathlib.Logic.Equiv.Fin.Basic" ]	PhysLean/Mathematics/Fin.lean	finExtractOnPermHom	/-- Given an equivalence `Fin n.succ.succ ≃ Fin n.succ.succ`, and an `i : Fin n.succ.succ`, the map `Fin n.succ → Fin n.succ` obtained by dropping `i` and it's image. -/
finExtractOnPermHom_inv {m : ℕ} (i : Fin n.succ.succ) (σ : Fin n.succ.succ ≃ Fin m.succ.succ) : (finExtractOnPermHom (σ i) σ.symm) ∘ (finExtractOnPermHom i σ) = id := by funext x simp only [Nat.succ_eq_add_one, Function.comp_apply, finExtractOnPermHom, Equiv.symm_apply_apply, finExtractOne_symm_inr_apply, id_eq] by_cases h : σ (i.succAbove x) < σ i · rw [predAboveI_lt h, Fin.succAbove_of_castSucc_lt] · simp · simp_all have hσ : σ (i.succAbove x) ≠ σ i := by simp only [Nat.succ_eq_add_one, ne_eq, EmbeddingLike.apply_eq_iff_eq] exact Fin.succAbove_ne i x have hn : σ i < σ (i.succAbove x) := by omega rw [predAboveI_ge hn] rw [Fin.succAbove_of_le_castSucc] · simp only [Nat.succ_eq_add_one, Fin.succ_mk] trans predAboveI i (σ.symm (σ (i.succAbove x))) · congr exact Nat.sub_add_cancel (Fin.lt_of_le_of_lt (Fin.zero_le (σ i)) hn) simp rw [Fin.le_def] simp only [Nat.succ_eq_add_one, Fin.castSucc_mk] omega /-- Given an equivalence `Fin n.succ.succ ≃ Fin n.succ.succ`, and an `i : Fin n.succ.succ`, the equivalence `Fin n.succ ≃ Fin n.succ` obtained by dropping `i` and it's image. -/	lemma	PhysLean	[ "import Mathlib.Tactic.Polyrith", "import Mathlib.Tactic.Linarith", "import Mathlib.Logic.Equiv.Fin.Basic" ]	PhysLean/Mathematics/Fin.lean	finExtractOnPermHom_inv	/-- Given an equivalence `Fin n.succ.succ ≃ Fin n.succ.succ`, and an `i : Fin n.succ.succ`, the map `Fin n.succ → Fin n.succ` obtained by dropping `i` and it's image. -/
finExtractOnePerm {m : ℕ} (i : Fin n.succ.succ) (σ : Fin n.succ.succ ≃ Fin m.succ.succ) : Fin n.succ ≃ Fin m.succ where toFun x := finExtractOnPermHom i σ x invFun x := finExtractOnPermHom (σ i) σ.symm x left_inv x := by simpa using congrFun (finExtractOnPermHom_inv i σ) x right_inv x := by simpa using congrFun (finExtractOnPermHom_inv (σ i) σ.symm) x	def	PhysLean	[ "import Mathlib.Tactic.Polyrith", "import Mathlib.Tactic.Linarith", "import Mathlib.Logic.Equiv.Fin.Basic" ]	PhysLean/Mathematics/Fin.lean	finExtractOnePerm	/-- Given an equivalence `Fin n.succ.succ ≃ Fin n.succ.succ`, and an `i : Fin n.succ.succ`, the equivalence `Fin n.succ ≃ Fin n.succ` obtained by dropping `i` and it's image. -/
finExtractOnePerm_equiv {n m : ℕ} (e : Fin n.succ.succ ≃ Fin m.succ.succ) (i : Fin n.succ.succ) : e ∘ i.succAbove = (e i).succAbove ∘ finExtractOnePerm i e := by simp only [Nat.succ_eq_add_one, finExtractOnePerm, Equiv.coe_fn_mk] funext x simp only [Function.comp_apply, finExtractOnPermHom, Nat.succ_eq_add_one, finExtractOne_symm_inr_apply] rw [succsAbove_predAboveI] simp only [Nat.succ_eq_add_one, ne_eq, EmbeddingLike.apply_eq_iff_eq] exact Fin.ne_succAbove i x @[simp]	lemma	PhysLean	[ "import Mathlib.Tactic.Polyrith", "import Mathlib.Tactic.Linarith", "import Mathlib.Logic.Equiv.Fin.Basic" ]	PhysLean/Mathematics/Fin.lean	finExtractOnePerm_equiv	null
finExtractOnePerm_apply (i : Fin n.succ.succ) (σ : Fin n.succ.succ ≃ Fin n.succ.succ) (x : Fin n.succ) : finExtractOnePerm i σ x = predAboveI (σ i) (σ ((finExtractOne i).symm (Sum.inr x))) := rfl @[simp]	lemma	PhysLean	[ "import Mathlib.Tactic.Polyrith", "import Mathlib.Tactic.Linarith", "import Mathlib.Logic.Equiv.Fin.Basic" ]	PhysLean/Mathematics/Fin.lean	finExtractOnePerm_apply	null
finExtractOnePerm_symm_apply (i : Fin n.succ.succ) (σ : Fin n.succ.succ ≃ Fin n.succ.succ) (x : Fin n.succ) : (finExtractOnePerm i σ).symm x = predAboveI (σ.symm (σ i)) (σ.symm ((finExtractOne (σ i)).symm (Sum.inr x))) := rfl /-- The equivalence of types `Fin n.succ.succ ≃ (Fin 1 ⊕ Fin 1) ⊕ Fin n` extracting the `i` and `(i.succAbove j)`. -/	lemma	PhysLean	[ "import Mathlib.Tactic.Polyrith", "import Mathlib.Tactic.Linarith", "import Mathlib.Logic.Equiv.Fin.Basic" ]	PhysLean/Mathematics/Fin.lean	finExtractOnePerm_symm_apply	null
finExtractTwo {n : ℕ} (i : Fin n.succ.succ) (j : Fin n.succ) : Fin n.succ.succ ≃ (Fin 1 ⊕ Fin 1) ⊕ Fin n := (finExtractOne i).trans <\| (Equiv.sumCongr (Equiv.refl (Fin 1)) (finExtractOne j)).trans <\| (Equiv.sumAssoc (Fin 1) (Fin 1) (Fin n)).symm @[simp]	def	PhysLean	[ "import Mathlib.Tactic.Polyrith", "import Mathlib.Tactic.Linarith", "import Mathlib.Logic.Equiv.Fin.Basic" ]	PhysLean/Mathematics/Fin.lean	finExtractTwo	/-- The equivalence of types `Fin n.succ.succ ≃ (Fin 1 ⊕ Fin 1) ⊕ Fin n` extracting the `i` and `(i.succAbove j)`. -/
finExtractTwo_apply_fst {n : ℕ} (i : Fin n.succ.succ) (j : Fin n.succ) : finExtractTwo i j i = Sum.inl (Sum.inl 0) := by simp [finExtractTwo]	lemma	PhysLean	[ "import Mathlib.Tactic.Polyrith", "import Mathlib.Tactic.Linarith", "import Mathlib.Logic.Equiv.Fin.Basic" ]	PhysLean/Mathematics/Fin.lean	finExtractTwo_apply_fst	/-- The equivalence of types `Fin n.succ.succ ≃ (Fin 1 ⊕ Fin 1) ⊕ Fin n` extracting the `i` and `(i.succAbove j)`. -/
finExtractTwo_symm_inr {n : ℕ} (i : Fin n.succ.succ) (j : Fin n.succ) : (finExtractTwo i j).symm ∘ Sum.inr = i.succAbove ∘ j.succAbove := by rw [finExtractTwo] ext1 x simp @[simp]	lemma	PhysLean	[ "import Mathlib.Tactic.Polyrith", "import Mathlib.Tactic.Linarith", "import Mathlib.Logic.Equiv.Fin.Basic" ]	PhysLean/Mathematics/Fin.lean	finExtractTwo_symm_inr	null
finExtractTwo_symm_inr_apply {n : ℕ} (i : Fin n.succ.succ) (j : Fin n.succ) (x : Fin n) : (finExtractTwo i j).symm (Sum.inr x) = i.succAbove (j.succAbove x) := by simp [finExtractTwo] @[simp]	lemma	PhysLean	[ "import Mathlib.Tactic.Polyrith", "import Mathlib.Tactic.Linarith", "import Mathlib.Logic.Equiv.Fin.Basic" ]	PhysLean/Mathematics/Fin.lean	finExtractTwo_symm_inr_apply	null
finExtractTwo_symm_inl_inr_apply {n : ℕ} (i : Fin n.succ.succ) (j : Fin n.succ) : (finExtractTwo i j).symm (Sum.inl (Sum.inr 0)) = i.succAbove j := by simp [finExtractTwo] @[simp]	lemma	PhysLean	[ "import Mathlib.Tactic.Polyrith", "import Mathlib.Tactic.Linarith", "import Mathlib.Logic.Equiv.Fin.Basic" ]	PhysLean/Mathematics/Fin.lean	finExtractTwo_symm_inl_inr_apply	null
finExtractTwo_symm_inl_inl_apply {n : ℕ} (i : Fin n.succ.succ) (j : Fin n.succ) : (finExtractTwo i j).symm (Sum.inl (Sum.inl 0)) = i := by rfl @[simp]	lemma	PhysLean	[ "import Mathlib.Tactic.Polyrith", "import Mathlib.Tactic.Linarith", "import Mathlib.Logic.Equiv.Fin.Basic" ]	PhysLean/Mathematics/Fin.lean	finExtractTwo_symm_inl_inl_apply	null
finExtractTwo_apply_snd {n : ℕ} (i : Fin n.succ.succ) (j : Fin n.succ) : finExtractTwo i j (i.succAbove j) = Sum.inl (Sum.inr 0) := by simp [← Equiv.eq_symm_apply] /-- Takes two maps `Fin n → Fin n` and returns the equivalence they form. -/	lemma	PhysLean	[ "import Mathlib.Tactic.Polyrith", "import Mathlib.Tactic.Linarith", "import Mathlib.Logic.Equiv.Fin.Basic" ]	PhysLean/Mathematics/Fin.lean	finExtractTwo_apply_snd	null
finMapToEquiv (f1 : Fin n → Fin m) (f2 : Fin m → Fin n) (h : ∀ x, f1 (f2 x) = x := by decide) (h' : ∀ x, f2 (f1 x) = x := by decide) : Fin n ≃ Fin m where toFun := f1 invFun := f2 left_inv := h' right_inv := h @[simp]	def	PhysLean	[ "import Mathlib.Tactic.Polyrith", "import Mathlib.Tactic.Linarith", "import Mathlib.Logic.Equiv.Fin.Basic" ]	PhysLean/Mathematics/Fin.lean	finMapToEquiv	/-- Takes two maps `Fin n → Fin n` and returns the equivalence they form. -/
finMapToEquiv_apply {f1 : Fin n → Fin m} {f2 : Fin m → Fin n} {h : ∀ x, f1 (f2 x) = x} {h' : ∀ x, f2 (f1 x) = x} (x : Fin n) : finMapToEquiv f1 f2 h h' x = f1 x := rfl @[simp]	lemma	PhysLean	[ "import Mathlib.Tactic.Polyrith", "import Mathlib.Tactic.Linarith", "import Mathlib.Logic.Equiv.Fin.Basic" ]	PhysLean/Mathematics/Fin.lean	finMapToEquiv_apply	/-- Takes two maps `Fin n → Fin n` and returns the equivalence they form. -/
finMapToEquiv_symm_apply {f1 : Fin n → Fin m} {f2 : Fin m → Fin n} {h : ∀ x, f1 (f2 x) = x} {h' : ∀ x, f2 (f1 x) = x} (x : Fin m) : (finMapToEquiv f1 f2 h h').symm x = f2 x := rfl	lemma	PhysLean	[ "import Mathlib.Tactic.Polyrith", "import Mathlib.Tactic.Linarith", "import Mathlib.Logic.Equiv.Fin.Basic" ]	PhysLean/Mathematics/Fin.lean	finMapToEquiv_symm_apply	null
finMapToEquiv_symm_eq {f1 : Fin n → Fin m} {f2 : Fin m → Fin n} {h : ∀ x, f1 (f2 x) = x} {h' : ∀ x, f2 (f1 x) = x} : (finMapToEquiv f1 f2 h h').symm = finMapToEquiv f2 f1 h' h := rfl /-- Given an equivalence between `Fin n` and `Fin m`, the induced equivalence between `Fin n.succ` and `Fin m.succ` derived by `Fin.cons`. -/	lemma	PhysLean	[ "import Mathlib.Tactic.Polyrith", "import Mathlib.Tactic.Linarith", "import Mathlib.Logic.Equiv.Fin.Basic" ]	PhysLean/Mathematics/Fin.lean	finMapToEquiv_symm_eq	null

addModulesIn (recurse : Bool) (prev : Array Name) (root : Name := .anonymous) (path : FilePath) : IO (Array Name) := do let mut r := prev for entry in ← path.readDir do if ← entry.path.isDir then if recurse then r ← addModulesIn recurse r (root.mkStr entry.fileName) entry.path else let .some mod := FilePath.fileStem entry.fileName | continue r := r.push (root.mkStr mod) pure r /-- Compute imports expected by `PhysLean.lean` by looking at file structure. -/

def

scripts

[ "import Batteries.Lean.HashSet", "import Lean" ]

scripts/check_file_imports.lean

addModulesIn

/-- Recursively finds files in directory. -/

expectedPhysLeanImports : IO (Array Name) := do let mut needed := #[] for top in ← FilePath.readDir "PhysLean" do let nm := `PhysLean let rootname := FilePath.withExtension top.fileName "" let root := nm.mkStr rootname.toString if ← top.path.isDir then needed ← addModulesIn (recurse := true) needed (root := root) top.path else needed := needed.push root pure needed

def

scripts

[ "import Batteries.Lean.HashSet", "import Lean" ]

scripts/check_file_imports.lean

expectedPhysLeanImports

/-- Compute imports expected by `PhysLean.lean` by looking at file structure. -/

listDif : (a: List String) → (b : List String) → (List String × List String) | [], [] => ([], []) | a :: as, [] => (a :: as, []) | [], b :: bs => ([], b :: bs) | a :: as, b :: bs => if a = b then listDif as bs else (a :: (listDif as bs).1, b :: (listDif as bs).2) /-- Checks whether an array `imports` is sorted after `Init` is removed. -/

def

scripts

[ "import Batteries.Lean.HashSet", "import Lean" ]

scripts/check_file_imports.lean

listDif

null

arrayImportSorted (imports : Array Import) : IO Bool := do let X := (imports.map (fun x => x.module.toString)).filter (fun x => x != "Init") let mut warned := false if ! X = X.qsort (· < ·) then IO.print s!"Import file is not sorted. \n" let ldif := listDif X.toList (X.qsort (· < ·)).toList let lzip := List.zip ldif.1 ldif.2 let lstring := String.intercalate "\n" (lzip.map (fun x => s!"{x.1} > {x.2}")) println! lstring warned := true pure warned /-- Checks every file in `reqImports` is imported into `modData` return true if this is NOT the case. -/

def

scripts

[ "import Batteries.Lean.HashSet", "import Lean" ]

scripts/check_file_imports.lean

arrayImportSorted

/-- Checks whether an array `imports` is sorted after `Init` is removed. -/

checkMissingImports (modData : ModuleData) (reqImports : Array Name) : IO Bool := do let names : Std.HashSet Name := Std.HashSet.ofArray (modData.imports.map (·.module)) let mut warned := false let nameArray := reqImports.filterMap ( fun req => if !names.contains req then some req else none) if nameArray.size ≠ 0 then let nameArraySort := nameArray.qsort (·.toString < ·.toString) IO.print s!"Files are not imported add the following to the `PhysLean` file: \n" for name in nameArraySort do IO.print s!"import {name}\n" warned := true pure warned

def

scripts

[ "import Batteries.Lean.HashSet", "import Lean" ]

scripts/check_file_imports.lean

checkMissingImports

/-- Checks every file in `reqImports` is imported into `modData` return true if this is NOT the case. -/

main (_ : List String) : IO UInt32 := do initSearchPath (← findSysroot) let mods : Name := `PhysLean 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 ePhysLeanImports ← expectedPhysLeanImports let sortedWarned ← arrayImportSorted hepLeanMod.imports let warned ← checkMissingImports hepLeanMod ePhysLeanImports if (warned ∨ sortedWarned) then throw <| IO.userError s!"\x1b[31mThe PhysLean.lean file is not sorted, or has missing imports.\x1b[0m" else IO.println s!"\x1b[32mAll files are imported correctly into PhysLean.lean.\x1b[0m" pure 0

def

scripts

[ "import Batteries.Lean.HashSet", "import Lean" ]

scripts/check_file_imports.lean

main

null

PhysLeanTODOItem : Type := Array String → Array (String × ℕ) /-- Checks if a . -/

def

scripts

[ "import Lean", "import Batteries.Data.String.Matcher", "import Mathlib.Data.Nat.Notation" ]

scripts/find_TODOs.lean

PhysLeanTODOItem

/-- Given a list of lines, outputs an error message and a line number. -/

TODOFinder : PhysLeanTODOItem := fun lines ↦ Id.run do let enumLines := (lines.toList.enumFrom 1) let todos := enumLines.filterMap (fun (lno1, l1) ↦ if l1.startsWith "/-! TODO:" then some ((l1.replace "/-! TODO: " "").replace "-/" "", lno1) else none) todos.toArray

def

scripts

[ "import Lean", "import Batteries.Data.String.Matcher", "import Mathlib.Data.Nat.Notation" ]

scripts/find_TODOs.lean

TODOFinder

/-- Checks if a . -/

TODOContext where /-- The underlying `message`. -/ statement : String /-- The line number -/ lineNumber : ℕ /-- The file path -/ path : FilePath

structure

scripts

[ "import Lean", "import Batteries.Data.String.Matcher", "import Mathlib.Data.Nat.Notation" ]

scripts/find_TODOs.lean

TODOContext

/-- Checks if a . -/

printTODO (todos : Array TODOContext) : IO Unit := do for e in todos do IO.println (s!"{e.path}:{e.lineNumber}: {e.statement}")

def

scripts

[ "import Lean", "import Batteries.Data.String.Matcher", "import Mathlib.Data.Nat.Notation" ]

scripts/find_TODOs.lean

printTODO

/-- The file path -/

filePathToGitPath (S : FilePath) (n : ℕ) : String := "https://github.com/HEPLean/PhysLean/blob/master/"++ (S.toString.replace "." "/").replace "/lean" ".lean" ++ "#L" ++ toString n

def

scripts

[ "import Lean", "import Batteries.Data.String.Matcher", "import Mathlib.Data.Nat.Notation" ]

scripts/find_TODOs.lean

filePathToGitPath

/-- The file path -/

docTODO (todos : Array TODOContext) : IO String := do let mut out := "" for e in todos do out := out ++ (s!" - [{e.statement}]("++ filePathToGitPath e.path e.lineNumber ++ ")\n") return out

def

scripts

[ "import Lean", "import Batteries.Data.String.Matcher", "import Mathlib.Data.Nat.Notation" ]

scripts/find_TODOs.lean

docTODO

/-- The file path -/

hepLeanLintFile (path : FilePath) : IO String := do let lines ← IO.FS.lines path let allOutput := (Array.map (fun lint ↦ (Array.map (fun (e, n) ↦ TODOContext.mk e n path)) (lint lines))) #[TODOFinder] let errors := allOutput.flatten printTODO errors docTODO errors

def

scripts

[ "import Lean", "import Batteries.Data.String.Matcher", "import Mathlib.Data.Nat.Notation" ]

scripts/find_TODOs.lean

hepLeanLintFile

null

todoFileHeader : String := s!" # TODO List This is an automatically generated list of TODOs appearing as `/-! TODO:...` in PhysLean. Please feel free to contribute to the completion of these tasks. "

def

scripts

[ "import Lean", "import Batteries.Data.String.Matcher", "import Mathlib.Data.Nat.Notation" ]

scripts/find_TODOs.lean

todoFileHeader

null

main (args : List String) : IO UInt32 := do initSearchPath (← findSysroot) let mods : Name := `PhysLean 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 mut out : String := "" for imp in hepLeanMod.imports do if imp.module == `Init then continue let filePath := (mkFilePath (imp.module.toString.split (· == '.'))).addExtension "lean" let l ← hepLeanLintFile filePath if l != "" then out := out ++ "\n### " ++ imp.module.toString ++ "\n" out := out ++ l let fileOut : System.FilePath := {toString := "./docs/TODOList.md"} /- Below here is concerned with writing out to the docs. -/ if "mkFile" ∈ args then IO.println (s!"TODOList file made.") IO.FS.writeFile fileOut (todoFileHeader ++ out) return 0

def

scripts

[ "import Lean", "import Batteries.Data.String.Matcher", "import Mathlib.Data.Nat.Notation" ]

scripts/find_TODOs.lean

main

null

main (args : List String) : IO UInt32 := do println! "\x1b[36m(1/7) Style lint \x1b[0m" println! "\x1b[2mThis linter is not checked by GitHub but if you have time please fix these errors.\x1b[0m" let styleLint ← IO.Process.output {cmd := "lake", args := #["exe", "style_lint"]} println! styleLint.stdout println! "\x1b[36m(2/7) Building \x1b[0m" let build ← IO.Process.output {cmd := "lake", args := #["build"]} let s1 := "Build completed successfully" let s2 := build.stdout if ¬ (s2.splitOn s1).length = 2 then println! "\x1b[31mError: Build failed. Run `lake build` to see the errors.\x1b[0m\n" else println! "\x1b[32mBuild is successful.\x1b[0m\n" println! "\x1b[36m(3/7) File imports \x1b[0m" let importCheck ← IO.Process.output {cmd := "lake", args := #["exe", "check_file_imports"]} println! importCheck.stdout println! "\x1b[36m(4/7) TODO tag duplicates \x1b[0m" let todoCheck ← IO.Process.output {cmd := "lake", args := #["exe", "check_dup_tags"]} println! todoCheck.stdout println! "\x1b[36m(5/7) Sorry and pseudo attribute linter \x1b[0m" let sorryPseudoCheck ← IO.Process.output {cmd := "lake", args := #["exe", "sorry_lint"]} println! sorryPseudoCheck.stdout if ¬ "--fast" ∈ args then println! "\x1b[36m(6/7) Lean linter \x1b[0m" println! "\x1b[2mExpect this linter to take a while to run, it can be skipped with lake exe lint_all --fast" println! "You can manually perform this linter by placing `#lint` at the end of the files you have modified.\x1b[0m" let leanCheck ← IO.Process.output {cmd := "lake", args := #["exe", "runPhysLeanLinters", "PhysLean"]} println! leanCheck.stdout println! "\x1b[36m(7/7) Transitive imports \x1b[0m" println! "\x1b[2mExpect this linter to take a while to run, it can be skipped with lake exe lint_all --fast\x1b[0m" let redundentImports ← IO.Process.output {cmd := "lake", args := #["exe", "redundant_imports"]} println! redundentImports.stdout pure 0

def

scripts

[]

scripts/lint_all.lean

main

null

lintStyleCli (args : Cli.Parsed) : IO UInt32 := do let mode : OutputSetting := match (args.hasFlag "update", args.hasFlag "github") with | (true, _) => OutputSetting.update | (false, true) => OutputSetting.print ErrorFormat.github | (false, false) => OutputSetting.print ErrorFormat.humanReadable let mut allModules := #[] for s in ["PhysLean.lean"] do allModules := allModules.append ((← IO.FS.lines s).filter (!·.containsSubstr "Batteries") |>.map (·.stripPrefix "import ")) let numberErrorFiles ← lintModules allModules mode return min numberErrorFiles 125 /-- Setting up command line options and help text for `lake exe lint_style`. -/ -- so far, no help options or so: perhaps that is fine?

def

scripts

[ "import Mathlib.Tactic.Linter.TextBased", "import Cli.Basic" ]

scripts/mathlib_textLint_on_hepLean.lean

lintStyleCli

/-- Implementation of the `lint_style` command line program. -/

heplean_lint_style : Cmd := `[Cli| lint_style VIA lintStyleCli; ["0.0.1"] "Run text-based style linters on every Lean file in PhysLean (adapted from mathlib's lint_style). Print errors about any unexpected style errors to standard output." FLAGS: github; "Print errors in a format suitable for github problem matchers\n\ otherwise, produce human-readable output" update; "Print errors solely for the style exceptions file" ] /-- The entry point to the `lake exe mathlib_textLint_on_hepLean` command. -/

def

scripts

[ "import Mathlib.Tactic.Linter.TextBased", "import Cli.Basic" ]

scripts/mathlib_textLint_on_hepLean.lean

heplean_lint_style

/-- Setting up command line options and help text for `lake exe lint_style`. -/

main (args : List String) : IO UInt32 := do heplean_lint_style.validate args

def

scripts

[ "import Mathlib.Tactic.Linter.TextBased", "import Cli.Basic" ]

scripts/mathlib_textLint_on_hepLean.lean

main

/-- The entry point to the `lake exe mathlib_textLint_on_hepLean` command. -/

getDocString (constName : Array ConstantInfo) : MetaM String := do let env ← getEnv let mut docString := "" for c in constName do if ¬ Lean.Name.isInternalDetail c.name then let doc ← Lean.findDocString? env c.name match doc with | some x => docString := docString ++ "- " ++ x ++ "\n" | none => docString := docString return docString

def

scripts

[ "import Batteries.Lean.IO.Process", "import Lean", "import Lean.Parser", "import Lean.Data.Json", "import Mathlib.Lean.CoreM", "import LLM.GPT.Json", "import LLM.GPT.API" ]

scripts/openAI_doc_check.lean

getDocString

null

header : String := " Answer as if you an expert mathematician, physicist and software engineer. Below I have listed the doc strings of definitions and theorems in a Lean 4 file. Output a list of 1) spelling mistakes. 2) grammatical errors. 3) suggestions for improvement. Note that text within `...` should be treated as code and not spellchecked. Doc strings should be a complete sentence, or a noun phrase. "

def

scripts

[ "import Batteries.Lean.IO.Process", "import Lean", "import Lean.Parser", "import Lean.Data.Json", "import Mathlib.Lean.CoreM", "import LLM.GPT.Json", "import LLM.GPT.API" ]

scripts/openAI_doc_check.lean

header

null

main (args : List String) : IO UInt32 := do initSearchPath (← findSysroot) let firstArg := args.head? match firstArg with | some x => do let mut imp : Import := Import.mk x.toName false if x == "random" then let mods : Name := `PhysLean let imps : Import := {module := mods} let mFile ← findOLean imps.module unless (← mFile.pathExists) do throw <| IO.userError s!"object file '{mFile}' of module {imps.module} does not exist" let (hepLeanMod, _) ← readModuleData mFile let imports := hepLeanMod.imports let y ← IO.rand 0 (imports.size -1) imp := imports.get! y let mFile ← findOLean imp.module let filePath := (mkFilePath (imp.module.toString.split (· == '.'))).addExtension "lean" IO.println s!"Checking: {filePath}" let (modData, _) ← readModuleData mFile let cons := modData.constants let docString ← CoreM.withImportModules #[imp.module] (getDocString cons).run' let message : LLM.Message := {role := Role.user, content := header ++ docString} let request : GPT.Request := {messages := [message]} let response ← LLM.GPT.chat (toString <| ToJson.toJson request) let parsedRespone := GPT.parse response match parsedRespone with | .ok x => IO.println x | .error e => IO.println e | none => IO.println "No module provided." return 0

def

scripts

[ "import Batteries.Lean.IO.Process", "import Lean", "import Lean.Parser", "import Lean.Data.Json", "import Mathlib.Lean.CoreM", "import LLM.GPT.Json", "import LLM.GPT.API" ]

scripts/openAI_doc_check.lean

main

null

getStats : MetaM String := do let noDefsVal ← noDefs let noLemmasVal ← noLemmas let noImportsVal ← noImports let noDefsNoDocVal ← noDefsNoDocString let noLemmasNoDocVal ← noLemmasNoDocString let noLinesVal ← noLines let noInformalLemmasVal ← noInformalLemmas let s := s!" Number of Files 📄: {noImportsVal} Number of lines 💻: {noLinesVal} Number of Definitions (incl. instances): {noDefsVal - noInformalLemmasVal} - Of which {noDefsNoDocVal} do not have doc-strings Number of Lemmas: {noLemmasVal + noInformalLemmasVal} - Of which {noLemmasNoDocVal} do not have doc-strings" pure s

def

scripts

[ "import PhysLean.Meta.Informal.Post", "import Mathlib.Lean.CoreM" ]

scripts/stats.lean

getStats

null

Stats.toHtml : MetaM String := do let noDefsVal ← noDefs let noLemmasVal ← noLemmas let noImportsVal ← noImports let noDefsNoDocVal ← noDefsNoDocString let noLemmasNoDocVal ← noLemmasNoDocString let noLinesVal ← noLines let noInformalDefsVal ← noInformalDefs let noInformalLemmasVal ← noInformalLemmas let noTODOsVal ← noTODOs let noFilesWithTODOsVal ← noFilesWithTODOs let header := "--- layout: default --- <!DOCTYPE html> <html> <head> <title>Stats for PhysLean</title> <meta name=\"viewport\" content=\"width=device-width, initial-scale=1.0\"> <style> /* Style the progress bar to be wider and take up more space */ progress { width: 80%; /* Adjust to take up more horizontal space */ height: 30px; /* Increase height to make it wider */ appearance: none; /* Remove default browser styles */ } /* Change the color for WebKit browsers (Chrome, Safari, etc.) */ progress::-webkit-progress-bar { background-color: #f3f3f3; /* Background color */ border-radius: 5px; overflow: hidden; } progress::-webkit-progress-value { background-color: #157878; /* Change this to your desired color */ border-radius: 5px; } /* Change the color for Firefox */ progress::-moz-progress-bar { background-color: #157878; /* Change this to your desired color */ } </style> </head> <body>" let body := s!" <h1>Stats for PhysLean</h1> <h3>Number of Files 📄: {noImportsVal}</h3> <h3>Number of lines 💻: {noLinesVal}</h3> <h3>Number of Definitions (incl. instances): {noDefsVal - noInformalLemmasVal}</h3> <p>- Of which {noDefsVal - noDefsNoDocVal- noInformalLemmasVal} have doc-strings:</p> <progress value=\"{noDefsVal - noDefsNoDocVal- noInformalLemmasVal}\" max=\"{noDefsVal- noInformalLemmasVal}\"></progress> <p>- Of which {noDefsVal - noInformalLemmasVal - noInformalDefsVal} are not <a href=\"https://heplean.github.io/HepLean/InformalGraph.html\">informal definitions</a>:</p> <progress value=\"{noDefsVal - noInformalLemmasVal - noInformalDefsVal}\" max=\"{noDefsVal - noInformalLemmasVal}\"></progress> <h3>Number of Lemmas: {noLemmasVal + noInformalLemmasVal}</h3> <p>- Of which {noLemmasVal - noLemmasNoDocVal + noInformalLemmasVal} have doc-strings:</p> <progress value=\"{noLemmasVal - noLemmasNoDocVal + noInformalLemmasVal}\" max=\"{noLemmasVal + noInformalLemmasVal}\"></progress> <p>- Of which {noLemmasVal} are not <a href=\"https://heplean.github.io/HepLean/InformalGraph.html\">informal lemmas</a>:</p> <progress value=\"{noLemmasVal}\" max=\"{noLemmasVal + noInformalLemmasVal}\"></progress> <h3>Number of <a href=\"https://heplean.github.io/HepLean/TODOList\">TODOs</a>: {noTODOsVal}</h3> <p>- There are {noImportsVal - noFilesWithTODOsVal} (of {noImportsVal}) files which are TODO free:</p> <progress value=\"{noImportsVal - noFilesWithTODOsVal}\" max=\"{noImportsVal}\"></progress> " let footer := " </body> </html> " pure (header ++ "\n" ++ body ++ "\n" ++ footer)

def

scripts

[ "import PhysLean.Meta.Informal.Post", "import Mathlib.Lean.CoreM" ]

scripts/stats.lean

Stats.toHtml

null

main (args : List String) : IO UInt32 := do let _ ← noImports let statString ← CoreM.withImportModules #[`PhysLean] (getStats).run' println! statString if "mkHTML" ∈ args then let html ← CoreM.withImportModules #[`PhysLean] (Stats.toHtml).run' let htmlFile : System.FilePath := {toString := "./docs/Stats.html"} IO.FS.writeFile htmlFile html IO.println (s!"HTML file made.") pure 0

def

scripts

[ "import PhysLean.Meta.Informal.Post", "import Mathlib.Lean.CoreM" ]

scripts/stats.lean

main

null

baseHtmlGenerator (title : String) (site : Array Html) : BaseHtmlM Html := do let moduleConstant := if let some module := ← getCurrentName then #[<script>{.raw s!"const MODULE_NAME={String.quote module.toString};"}</script>] else #[] pure <html lang="en"> <head> [← baseHtmlHeadDeclarations] <title>{title}</title> <script defer="true" src={s!"{← getRoot}mathjax-config.js"}></script> <script defer="true" src="https://cdnjs.cloudflare.com/polyfill/v3/polyfill.min.js?features=es6"></script> <script defer="true" src="https://cdn.jsdelivr.net/npm/mathjax@3/es5/tex-mml-chtml.js"></script> <script>{.raw s!"const SITE_ROOT={String.quote (← getRoot)};"}</script> [moduleConstant] <script type="module" src={s!"{← getRoot}jump-src.js"}></script> <script type="module" src={s!"{← getRoot}search.js"}></script> <script type="module" src={s!"{← getRoot}expand-nav.js"}></script> <script type="module" src={s!"{← getRoot}how-about.js"}></script> <script type="module" src={s!"{← getRoot}instances.js"}></script> <script type="module" src={s!"{← getRoot}importedBy.js"}></script> </head> <body> <input id="nav_toggle" type="checkbox"/> <header style="background-color: #2C3E50; color: #fff;"> <h1><label for="nav_toggle"></label><span> <a href="heplean.com" style="color: #fff; text-decoration: none; font-family: serif"> PhysLean Documentation</a> </span></h1> <h2 style="color: #fff; font-family: serif">[breakWithin title]</h2> <form action="https://google.com/search" method="get" id="search_form" style="color: var(--text-color);"> <input type="hidden" name="sitesearch" value="https://leanprover-community.github.io/mathlib4_docs"/> <input type="text" name="q" autocomplete="off"/>{.raw " "} <button id="search_button" onclick={s!"javascript: form.action='{← getRoot}search.html';"}>Search</button> <button>Google site search</button> </form> </header> [site] <nav class="nav"> <iframe src={s!"{← getRoot}navbar.html"} class="navframe" frameBorder="0"></iframe> </nav> </body> </html> /-- A comfortability wrapper around `baseHtmlGenerator`. -/

def

scripts

[ "import DocGen4.Output.ToHtmlFormat", "import DocGen4.Output.Navbar" ]

scripts/Template.lean

baseHtmlGenerator

/-- The HTML template used for all pages. -/

baseHtml (title : String) (site : Html) : BaseHtmlM Html := baseHtmlGenerator title #[site]

def

scripts

[ "import DocGen4.Output.ToHtmlFormat", "import DocGen4.Output.Navbar" ]

scripts/Template.lean

baseHtml

/-- A comfortability wrapper around `baseHtmlGenerator`. -/

IsUpperCamal (s : String) : Bool := let parts := s.splitOn "." let lastPart := parts.get! (parts.length - 1) lastPart = "noConfusionType" ∨ (¬ (lastPart.get 0 ≥ 'A' ∧ lastPart.get 0 ≤ 'z')) ∨ (lastPart.get 0 ≥ 'A' ∧ lastPart.get 0 ≤ 'Z')

def

scripts

[ "import Batteries.Lean.HashSet", "import Lean" ]

scripts/type_former_lint.lean

IsUpperCamal

/-- A rough definition of Upper Camal, checking that if a string starts with a latin letter then that letter is capital. -/

main (_ : List String) : IO UInt32 := do initSearchPath (← findSysroot) let mods : Name := `PhysLean 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 mut warned := false for imp in hepLeanMod.imports do let mFile ← findOLean imp.module let (modData, _) ← readModuleData mFile let cons := modData.constants for c in cons do if c.hasValue ∧ ¬ Lean.Name.isInternal c.name ∧ Lean.Compiler.LCNF.isTypeFormerType c.type ∧ ¬ IsUpperCamal c.name.toString then warned := true IO.println s!"name: #{c.name}" if warned then throw <| IO.userError s!"There are type former definitions not in upper camal style." pure 0

def

scripts

[ "import Batteries.Lean.HashSet", "import Lean" ]

scripts/type_former_lint.lean

main

/-- A rough definition of Upper Camal, checking that if a string starts with a latin letter then that letter is capital. -/

eulerLagrangeOp (L : Time → X → X → ℝ) (q : Time → X) : Time → X := fun t => gradient (L t · (∂ₜ q t)) (q t) - ∂ₜ (fun t' => gradient (L t' (q t') ·) (∂ₜ q t')) t

def

PhysLean

[ "import PhysLean.Mathematics.VariationalCalculus.HasVarGradient" ]

PhysLean/ClassicalMechanics/EulerLagrange.lean

eulerLagrangeOp

/-- The Euler Lagrange operator, for a trajectory `q : Time → X`, and a lagrangian `Time → X → X → ℝ`, the Euler-Lagrange operator is `∂L/∂q - dₜ(∂L/∂(dₜ q))`. -/

eulerLagrangeOp_eq (L : Time → X → X → ℝ) (q : Time → X) : eulerLagrangeOp L q = fun t => gradient (L t · (∂ₜ q t)) (q t) - ∂ₜ (fun t' => gradient (L t' (q t') ·) (∂ₜ q t')) t := by rfl

lemma

PhysLean

[ "import PhysLean.Mathematics.VariationalCalculus.HasVarGradient" ]

PhysLean/ClassicalMechanics/EulerLagrange.lean

eulerLagrangeOp_eq

/-- The Euler Lagrange operator, for a trajectory `q : Time → X`, and a lagrangian `Time → X → X → ℝ`, the Euler-Lagrange operator is `∂L/∂q - dₜ(∂L/∂(dₜ q))`. -/

eulerLagrangeOp_zero (q : Time → X) : eulerLagrangeOp (fun _ _ _ => 0) q = fun _ => 0 := by simp [eulerLagrangeOp_eq, Time.deriv_eq] /- The variational derivative of `L t (q' t) (deriv q' t))` for a lagrangian `L` is equal to the `eulerLagrangeOp`. -/

lemma

PhysLean

[ "import PhysLean.Mathematics.VariationalCalculus.HasVarGradient" ]

PhysLean/ClassicalMechanics/EulerLagrange.lean

eulerLagrangeOp_zero

null

euler_lagrange_varGradient (L : Time → X → X → ℝ) (q : Time → X) (hq : ContDiff ℝ ∞ q) (hL : ContDiff ℝ ∞ ↿L) : (δ (q':=q), ∫ t, L t (q' t) (fderiv ℝ q' t 1)) = eulerLagrangeOp L q := by rw [eulerLagrangeOp_eq] simp only [Time.deriv_eq] apply HasVarGradientAt.varGradient apply HasVarGradientAt.intro _ · apply HasVarAdjDerivAt.comp (F := fun (φ : Time → X × X) t => L t (φ t).fst (φ t).snd) (G := fun (φ : Time → X) t => (φ t, fderiv ℝ φ t 1)) · apply HasVarAdjDerivAt.fmap (f := fun t => ↿(L t)) · fun_prop · fun_prop intro x u apply DifferentiableAt.hasAdjFDerivAt apply Differentiable.differentiableAt apply ContDiff.differentiable fun_prop simp · apply HasVarAdjDerivAt.prod (F:=fun φ => φ) · apply HasVarAdjDerivAt.id _ hq · apply HasVarAdjDerivAt.fderiv · exact hq case hgrad => funext t simp (disch:=fun_prop) only simp[sub_eq_add_neg] congr rw [gradient_eq_adjFDeriv, adjFDeriv_uncurry] apply ContDiff.differentiable (n := ∞) (by fun_prop) ENat.LEInfty.out apply ContDiff.differentiable (n := ∞) (by fun_prop) ENat.LEInfty.out funext t rw [gradient_eq_adjFDeriv, adjFDeriv_uncurry] apply ContDiff.differentiable (n := ∞) (by fun_prop) ENat.LEInfty.out apply ContDiff.differentiable (n := ∞) (by fun_prop) ENat.LEInfty.out

theorem

PhysLean

[ "import PhysLean.Mathematics.VariationalCalculus.HasVarGradient" ]

PhysLean/ClassicalMechanics/EulerLagrange.lean

euler_lagrange_varGradient

null

hamiltonEqOp (H : Time → X → X → ℝ) (p : Time → X) (q : Time → X) : Time → X × X := fun t => (∂ₜ q t + -gradient (fun x => H t x (q t)) (p t), - ∂ₜ p t + -gradient (fun x => H t (p t) x) (q t))

def

PhysLean

[ "import PhysLean.Mathematics.VariationalCalculus.HasVarGradient" ]

PhysLean/ClassicalMechanics/HamiltonsEquations.lean

hamiltonEqOp

/-- Given a hamiltonian `H : Time → X → X → ℝ` the operator which when set to zero implies the Hamilton equations. -/

hamiltonEqOp_eq (H : Time → X → X → ℝ) (p : Time → X) (q : Time → X) : hamiltonEqOp H p q = fun t => (∂ₜ q t + -gradient (fun x => H t x (q t)) (p t), - ∂ₜ p t + -gradient (fun x => H t (p t) x) (q t)) := by rfl

lemma

PhysLean

[ "import PhysLean.Mathematics.VariationalCalculus.HasVarGradient" ]

PhysLean/ClassicalMechanics/HamiltonsEquations.lean

hamiltonEqOp_eq

/-- Given a hamiltonian `H : Time → X → X → ℝ` the operator which when set to zero implies the Hamilton equations. -/

hamiltonEqOp_eq_zero_iff_hamiltons_equations (H : Time → X → X → ℝ) (p : Time → X) (q : Time → X) : hamiltonEqOp H p q = 0 ↔ (∀ t, ∂ₜ q t = gradient (fun x => H t x (q t)) (p t)) ∧ (∀ t, ∂ₜ p t = -gradient (fun x => H t (p t) x) (q t)) := by simp [hamiltonEqOp_eq] simp_all only [Time.deriv_eq] rw [funext_iff] simp_all only [Pi.zero_apply, Prod.mk_eq_zero] apply Iff.intro · intro h1 apply And.intro · intro t conv_rhs => rw [← add_zero (gradient (fun x => H t x (q t)) (p t)), ← (h1 t).1] simp · intro t conv_lhs => rw [← add_zero (fderiv ℝ p t 1), ← (h1 t).2] simp · intro a x simp_all only [add_neg_cancel, neg_neg, and_self]

lemma

PhysLean

[ "import PhysLean.Mathematics.VariationalCalculus.HasVarGradient" ]

PhysLean/ClassicalMechanics/HamiltonsEquations.lean

hamiltonEqOp_eq_zero_iff_hamiltons_equations

null

hamiltons_equations_varGradient (H : Time → X → X → ℝ) (pq : Time → X × X) (hp : ContDiff ℝ ∞ pq) (hL : ContDiff ℝ ∞ ↿H) : (δ (pq':= pq), ∫ t, ⟪(pq' t).1, ∂ₜ (Prod.snd ∘ pq') t⟫_ℝ - H t (pq' t).1 (pq' t).2) = fun t => hamiltonEqOp H (fun t => (pq t).1) (fun t => (pq t).2) t := by apply HasVarGradientAt.varGradient apply HasVarGradientAt.intro _ · apply HasVarAdjDerivAt.add · let i := fun (t : Time) (x : X × X) => ⟪x.1, x.2⟫_ℝ apply HasVarAdjDerivAt.comp (F := fun (φ : Time → X × X) t => i t (φ t)) (G := fun (φ : Time → X × X) t => ((φ t).1, fderiv ℝ (Prod.snd ∘ φ) t 1)) · apply HasVarAdjDerivAt.fmap · fun_prop · fun_prop intro t x apply DifferentiableAt.hasAdjFDerivAt fun_prop · apply HasVarAdjDerivAt.prod · apply HasVarAdjDerivAt.fst apply HasVarAdjDerivAt.id fun_prop · apply HasVarAdjDerivAt.fderiv' (F := fun (φ : Time → X × X) t => (φ t).2) apply HasVarAdjDerivAt.fmap · fun_prop · fun_prop intro t x apply DifferentiableAt.hasAdjFDerivAt fun_prop · apply HasVarAdjDerivAt.neg let H' := fun t => ↿(H t) change HasVarAdjDerivAt (fun φ x => H' x (φ x)) _ pq apply HasVarAdjDerivAt.fmap · fun_prop · fun_prop intro x u apply DifferentiableAt.hasAdjFDerivAt apply Differentiable.differentiableAt apply ContDiff.differentiable fun_prop simp · simp only [adjFDeriv_prod_snd, Prod.mk_add_mk, add_zero, zero_add] funext x rw [adjFDeriv_uncurry] swap · apply ContDiff.differentiable fun_prop simp simp only [Prod.neg_mk, Prod.mk_add_mk] rw [adjFDeriv_inner] simp only [one_smul] conv_rhs => enter [2, 1, 1, 1, 2, x] rw [adjFDeriv_inner] simp rw [← gradient_eq_adjFDeriv, ← gradient_eq_adjFDeriv] rfl · apply ContDiff.differentiable fun_prop simp · apply ContDiff.differentiable fun_prop simp

theorem

PhysLean

[ "import PhysLean.Mathematics.VariationalCalculus.HasVarGradient" ]

PhysLean/ClassicalMechanics/HamiltonsEquations.lean

hamiltons_equations_varGradient

null

ElectricField (d : ℕ := 3) := Time → Space d → EuclideanSpace ℝ (Fin d) /-- The magnetic field is a map from `d+1` dimensional spacetime to the vector space `ℝ^d`. -/

abbrev

PhysLean

[ "import PhysLean.SpaceAndTime.SpaceTime.Basic" ]

PhysLean/Electromagnetism/Basic.lean

ElectricField

/-- The electric field is a map from `d`+1 dimensional spacetime to the vector space `ℝ^d`. -/

MagneticField (d : ℕ := 3) := Time → Space d → EuclideanSpace ℝ (Fin d) open IndexNotation open realLorentzTensor /-- The vector potential of an electromagnetic field-/

abbrev

PhysLean

[ "import PhysLean.SpaceAndTime.SpaceTime.Basic" ]

PhysLean/Electromagnetism/Basic.lean

MagneticField

/-- The magnetic field is a map from `d+1` dimensional spacetime to the vector space `ℝ^d`. -/

VectorPotential (d : ℕ := 3) := SpaceTime d → ℝT[d, .up] /-- The electric permittivity and the magnetic permeability of free space. -/

abbrev

PhysLean

[ "import PhysLean.SpaceAndTime.SpaceTime.Basic" ]

PhysLean/Electromagnetism/Basic.lean

VectorPotential

/-- The vector potential of an electromagnetic field-/

EMSystem where /-- The permittivity of free space. -/ ε₀ : ℝ /-- The permeability of free space. -/ μ₀ : ℝ TODO "6V2UZ" "Charge density and current density should be generalized to signed measures, in such a way that they are still easy to work with and can be integrated with with tensor notation. See here: https://leanprover.zulipchat.com/#narrow/channel/479953-PhysLean/topic/Maxwell's.20Equations" /-- The charge density. -/

structure

PhysLean

[ "import PhysLean.SpaceAndTime.SpaceTime.Basic" ]

PhysLean/Electromagnetism/Basic.lean

EMSystem

/-- The electric permittivity and the magnetic permeability of free space. -/

ChargeDensity := Time → Space → ℝ /-- Current density. -/

abbrev

PhysLean

[ "import PhysLean.SpaceAndTime.SpaceTime.Basic" ]

PhysLean/Electromagnetism/Basic.lean

ChargeDensity

/-- The charge density. -/

CurrentDensity := Time → Space → EuclideanSpace ℝ (Fin 3) namespace EMSystem variable (𝓔 : EMSystem) open SpaceTime /-- The speed of light. -/

abbrev

PhysLean

[ "import PhysLean.SpaceAndTime.SpaceTime.Basic" ]

PhysLean/Electromagnetism/Basic.lean

CurrentDensity

/-- Current density. -/

c : ℝ := 1/(√(𝓔.μ₀ * 𝓔.ε₀)) /-- Coulomb's constant. -/

def

PhysLean

[ "import PhysLean.SpaceAndTime.SpaceTime.Basic" ]

PhysLean/Electromagnetism/Basic.lean

c

/-- The speed of light. -/

coulombConstant : ℝ := 1/(4 * Real.pi * 𝓔.ε₀)

def

PhysLean

[ "import PhysLean.SpaceAndTime.SpaceTime.Basic" ]

PhysLean/Electromagnetism/Basic.lean

coulombConstant

/-- Coulomb's constant. -/

fderiv_uncurry (f : X → Y → Z) (xy dxy : X × Y) (hf : DifferentiableAt 𝕜 (↿f) xy) : fderiv 𝕜 ↿f xy dxy = fderiv 𝕜 (f · xy.2) xy.1 dxy.1 + fderiv 𝕜 (f xy.1 ·) xy.2 dxy.2 := by have hx : (f · xy.2) = ↿f ∘ (fun x' => (x',xy.2)) := by rfl have hy : (f xy.1 ·) = ↿f ∘ (fun y' => (xy.1,y')) := by rfl rw [hx,hy] repeat rw [fderiv_comp (hg := by fun_prop) (hf := by fun_prop)] dsimp rw [← ContinuousLinearMap.map_add] congr repeat rw [DifferentiableAt.fderiv_prodMk (hf₁ := by fun_prop) (hf₂ := by fun_prop)] simp

lemma

PhysLean

[ "import Mathlib.Analysis.Calculus.FDeriv.Symmetric" ]

PhysLean/Mathematics/FDerivCurry.lean

fderiv_uncurry

null

fderiv_curry_fst (f : X × Y → Z) (x : X) (y : Y) (h : DifferentiableAt 𝕜 f (x,y)) (dx : X) : fderiv 𝕜 (fun x' => Function.curry f x' y) x dx = fderiv 𝕜 f (x,y) (dx, 0) := by have h1 : f = ↿(Function.curry f) := by ext x rfl conv_rhs => rw [h1] rw [fderiv_uncurry] simp only [Function.curry_apply, map_zero, add_zero] exact h

lemma

PhysLean

[ "import Mathlib.Analysis.Calculus.FDeriv.Symmetric" ]

PhysLean/Mathematics/FDerivCurry.lean

fderiv_curry_fst

null

fderiv_curry_snd (f : X × Y → Z) (x : X) (y : Y) (h : DifferentiableAt 𝕜 f (x,y)) (dy : Y) : fderiv 𝕜 (Function.curry f x) y dy = fderiv 𝕜 (f) (x,y) (0, dy) := by have h1 : f = ↿(Function.curry f) := by ext x rfl conv_rhs => rw [h1] rw [fderiv_uncurry] simp rfl exact h

lemma

PhysLean

[ "import Mathlib.Analysis.Calculus.FDeriv.Symmetric" ]

PhysLean/Mathematics/FDerivCurry.lean

fderiv_curry_snd

null

fderiv_uncurry_clm_comp (f : X → Y → Z) (hf : Differentiable 𝕜 (↿f)) : fderiv 𝕜 ↿f = fun xy => (fderiv 𝕜 (f · xy.2) xy.1).comp (ContinuousLinearMap.fst 𝕜 X Y) + (fderiv 𝕜 (f xy.1 ·) xy.2).comp (ContinuousLinearMap.snd 𝕜 X Y) := by funext xy apply ContinuousLinearMap.ext intro dxy rw [fderiv_uncurry] simp only [ContinuousLinearMap.add_apply, ContinuousLinearMap.coe_comp', ContinuousLinearMap.coe_fst', Function.comp_apply, ContinuousLinearMap.coe_snd'] fun_prop

lemma

PhysLean

[ "import Mathlib.Analysis.Calculus.FDeriv.Symmetric" ]

PhysLean/Mathematics/FDerivCurry.lean

fderiv_uncurry_clm_comp

null

fderiv_wrt_prod {f : X × Y → Z} {xy} (hf : DifferentiableAt 𝕜 f xy) : fderiv 𝕜 f xy = (fderiv 𝕜 (fun x' => f (x',xy.2)) xy.1).comp (ContinuousLinearMap.fst 𝕜 X Y) + (fderiv 𝕜 (fun y' => f (xy.1,y')) xy.2).comp (ContinuousLinearMap.snd 𝕜 X Y) := by apply ContinuousLinearMap.ext; intro (dx,dy) apply fderiv_uncurry (fun x y => f (x,y)) _ _ hf

lemma

PhysLean

[ "import Mathlib.Analysis.Calculus.FDeriv.Symmetric" ]

PhysLean/Mathematics/FDerivCurry.lean

fderiv_wrt_prod

null

fderiv_wrt_prod_clm_comp (f : X × Y → Z) (hf : Differentiable 𝕜 f) : fderiv 𝕜 f = fun xy => (fderiv 𝕜 (fun x' => f (x',xy.2)) xy.1).comp (ContinuousLinearMap.fst 𝕜 X Y) + (fderiv 𝕜 (fun y' => f (xy.1,y')) xy.2).comp (ContinuousLinearMap.snd 𝕜 X Y) := fderiv_uncurry_clm_comp (fun x y => f (x,y)) hf

lemma

PhysLean

[ "import Mathlib.Analysis.Calculus.FDeriv.Symmetric" ]

PhysLean/Mathematics/FDerivCurry.lean

fderiv_wrt_prod_clm_comp

null

fderiv_curry_clm_apply (f : X → Y →L[𝕜] Z) (y : Y) (x dx : X) (h : Differentiable 𝕜 f) : fderiv 𝕜 f x dx y = fderiv 𝕜 (f · y) x dx := by rw [fderiv_clm_apply] <;> first | simp | fun_prop /- Helper rw lemmas for proving differentiability conditions. -/

lemma

PhysLean

[ "import Mathlib.Analysis.Calculus.FDeriv.Symmetric" ]

PhysLean/Mathematics/FDerivCurry.lean

fderiv_curry_clm_apply

null

fderiv_uncurry_comp_fst (f : X → Y → Z) (y : Y) (hf : Differentiable 𝕜 (↿f)) : fderiv 𝕜 (fun x' => (↿f) (x', y)) = fun x => (fderiv 𝕜 (↿f) ((·, y) x)).comp (fderiv 𝕜 (·, y) x) := by have hl (y : Y) : (fun x' => (↿f) (x', y)) = ↿f ∘ (·, y) := by rfl rw [hl] funext x rw [fderiv_comp] · fun_prop · fun_prop

lemma

PhysLean

[ "import Mathlib.Analysis.Calculus.FDeriv.Symmetric" ]

PhysLean/Mathematics/FDerivCurry.lean

fderiv_uncurry_comp_fst

null

fderiv_uncurry_comp_snd (f : X → Y → Z) (x : X) (hf : Differentiable 𝕜 (↿f)) : fderiv 𝕜 (fun y' => (↿f) (x, y')) = fun y => (fderiv 𝕜 (↿f) ((x, ·) y)).comp (fderiv 𝕜 (x, ·) y) := by have hl (x : X) : (fun y' => (↿f) (x, y')) = ↿f ∘ (x, ·) := by rfl rw [hl] funext y rw [fderiv_comp] · fun_prop · fun_prop

lemma

PhysLean

[ "import Mathlib.Analysis.Calculus.FDeriv.Symmetric" ]

PhysLean/Mathematics/FDerivCurry.lean

fderiv_uncurry_comp_snd

null

fderiv_curry_comp_fst (f : X → Y → Z) (x dx : X) (y : Y) (hf : Differentiable 𝕜 (↿f)) : (fderiv 𝕜 (fun x' => f x' y) x) dx = (fderiv 𝕜 (↿f) ((·, y) x)) ((fderiv 𝕜 (·, y) x) dx) := by have hl (y : Y) : (fun x' => f x' y) = ↿f ∘ (·, y) := by rfl rw [hl] rw [fderiv_comp] simp only [ContinuousLinearMap.coe_comp', Function.comp_apply] · fun_prop · fun_prop

lemma

PhysLean

[ "import Mathlib.Analysis.Calculus.FDeriv.Symmetric" ]

PhysLean/Mathematics/FDerivCurry.lean

fderiv_curry_comp_fst

null

fderiv_curry_comp_snd (f : X → Y → Z) (x : X) (y dy : Y) (hf : Differentiable 𝕜 (↿f)) : (fderiv 𝕜 (fun y' => f x y') y) dy = (fderiv 𝕜 (↿f) ((x, ·) y)) ((fderiv 𝕜 (x, ·) y) dy) := by have hl (x : X) : (fun y' => f x y') = ↿f ∘ (x, ·) := by rfl rw [hl] rw [fderiv_comp] simp only [ContinuousLinearMap.coe_comp', Function.comp_apply] · fun_prop · fun_prop

lemma

PhysLean

[ "import Mathlib.Analysis.Calculus.FDeriv.Symmetric" ]

PhysLean/Mathematics/FDerivCurry.lean

fderiv_curry_comp_snd

null

fderiv_inr_fst_clm (x : X) (y : Y) : (fderiv 𝕜 (x, ·) y) = ContinuousLinearMap.inr 𝕜 X Y := by rw [(hasFDerivAt_prodMk_right x y).fderiv]

lemma

PhysLean

[ "import Mathlib.Analysis.Calculus.FDeriv.Symmetric" ]

PhysLean/Mathematics/FDerivCurry.lean

fderiv_inr_fst_clm

null

fderiv_inl_snd_clm (x : X) (y : Y) : (fderiv 𝕜 (·, y) x) = ContinuousLinearMap.inl 𝕜 X Y := by rw [(hasFDerivAt_prodMk_left x y).fderiv] /- Differentiability conditions. -/

lemma

PhysLean

[ "import Mathlib.Analysis.Calculus.FDeriv.Symmetric" ]

PhysLean/Mathematics/FDerivCurry.lean

fderiv_inl_snd_clm

null

function_differentiableAt_fst (f : X → Y → Z) (x : X) (y : Y) (hf : Differentiable 𝕜 (↿f)) : DifferentiableAt 𝕜 (fun x' => f x' y) x := by have hl : (fun x' => f x' y) = ↿f ∘ (·, y) := by funext x' rfl rw [hl] apply Differentiable.differentiableAt apply Differentiable.comp · fun_prop · fun_prop

lemma

PhysLean

[ "import Mathlib.Analysis.Calculus.FDeriv.Symmetric" ]

PhysLean/Mathematics/FDerivCurry.lean

function_differentiableAt_fst

null

function_differentiableAt_snd (f : X → Y → Z) (x : X) (y : Y) (hf : Differentiable 𝕜 (↿f)) : DifferentiableAt 𝕜 (fun y' => f x y') y := by have hl : (fun y' => f x y') = ↿f ∘ (x, ·) := by funext y' rfl rw [hl] apply Differentiable.differentiableAt apply Differentiable.comp · fun_prop · fun_prop @[fun_prop]

lemma

PhysLean

[ "import Mathlib.Analysis.Calculus.FDeriv.Symmetric" ]

PhysLean/Mathematics/FDerivCurry.lean

function_differentiableAt_snd

null

fderiv_uncurry_differentiable_fst (f : X → Y → Z) (y : Y) (hf : ContDiff 𝕜 2 ↿f) : Differentiable 𝕜 (fderiv 𝕜 fun x' => (↿f) (x', y)) := by fun_prop @[fun_prop]

lemma

PhysLean

[ "import Mathlib.Analysis.Calculus.FDeriv.Symmetric" ]

PhysLean/Mathematics/FDerivCurry.lean

fderiv_uncurry_differentiable_fst

null

fderiv_uncurry_differentiable_snd (f : X → Y → Z) (x : X) (hf : ContDiff 𝕜 2 ↿f) : Differentiable 𝕜 (fderiv 𝕜 fun y' => (↿f) (x, y')) := by fun_prop @[fun_prop]

lemma

PhysLean

[ "import Mathlib.Analysis.Calculus.FDeriv.Symmetric" ]

PhysLean/Mathematics/FDerivCurry.lean

fderiv_uncurry_differentiable_snd

null

fderiv_uncurry_differentiable_fst_comp_snd (f : X → Y → Z) (x : X) (hf : ContDiff 𝕜 2 ↿f) : Differentiable 𝕜 (fun y' => fderiv 𝕜 (fun x' => (↿f) (x', y')) x) := by fun_prop @[fun_prop]

lemma

PhysLean

[ "import Mathlib.Analysis.Calculus.FDeriv.Symmetric" ]

PhysLean/Mathematics/FDerivCurry.lean

fderiv_uncurry_differentiable_fst_comp_snd

null

fderiv_uncurry_differentiable_fst_comp_snd_apply (f : X → Y → Z) (x δx : X) (hf : ContDiff 𝕜 2 ↿f) : Differentiable 𝕜 (fun y' => fderiv 𝕜 (fun x' => (↿f) (x', y')) x δx) := by fun_prop @[fun_prop]

lemma

PhysLean

[ "import Mathlib.Analysis.Calculus.FDeriv.Symmetric" ]

PhysLean/Mathematics/FDerivCurry.lean

fderiv_uncurry_differentiable_fst_comp_snd_apply

null

fderiv_uncurry_differentiable_snd_comp_fst (f : X → Y → Z) (y : Y) (hf : ContDiff 𝕜 2 ↿f) : Differentiable 𝕜 (fun x' => fderiv 𝕜 (fun y' => (↿f) (x', y')) y) := by fun_prop @[fun_prop]

lemma

PhysLean

[ "import Mathlib.Analysis.Calculus.FDeriv.Symmetric" ]

PhysLean/Mathematics/FDerivCurry.lean

fderiv_uncurry_differentiable_snd_comp_fst

null

fderiv_uncurry_differentiable_snd_comp_fst_apply (f : X → Y → Z) (y δy : Y) (hf : ContDiff 𝕜 2 ↿f) : Differentiable 𝕜 (fun x' => fderiv 𝕜 (fun y' => (↿f) (x', y')) y δy) := by fun_prop @[fun_prop]

lemma

PhysLean

[ "import Mathlib.Analysis.Calculus.FDeriv.Symmetric" ]

PhysLean/Mathematics/FDerivCurry.lean

fderiv_uncurry_differentiable_snd_comp_fst_apply

null

fderiv_curry_differentiableAt_fst_comp_snd (f : X → Y → Z) (x dx : X) (y : Y) (hf : ContDiff 𝕜 2 ↿f) : DifferentiableAt 𝕜 (fun y' => (fderiv 𝕜 (fun x' => f x' y') x) dx) y := by apply Differentiable.differentiableAt fun_prop

lemma

PhysLean

[ "import Mathlib.Analysis.Calculus.FDeriv.Symmetric" ]

PhysLean/Mathematics/FDerivCurry.lean

fderiv_curry_differentiableAt_fst_comp_snd

null

fderiv_curry_differentiableAt_snd_comp_fst (f : X → Y → Z) (x : X) (y dy : Y) (hf : ContDiff 𝕜 2 ↿f) : DifferentiableAt 𝕜 (fun x' => (fderiv 𝕜 (fun y' => f x' y') y) dy) x := by apply Differentiable.differentiableAt fun_prop /- fderiv commutes on X × Y. -/

lemma

PhysLean

[ "import Mathlib.Analysis.Calculus.FDeriv.Symmetric" ]

PhysLean/Mathematics/FDerivCurry.lean

fderiv_curry_differentiableAt_snd_comp_fst

null

fderiv_swap [IsRCLikeNormedField 𝕜] (f : X → Y → Z) (x dx : X) (y dy : Y) (hf : ContDiff 𝕜 2 ↿f) : fderiv 𝕜 (fun x' => fderiv 𝕜 (fun y' => f x' y') y dy) x dx = fderiv 𝕜 (fun y' => fderiv 𝕜 (fun x' => f x' y') x dx) y dy := by have hf' : IsSymmSndFDerivAt 𝕜 (↿f) (x,y) := by apply ContDiffAt.isSymmSndFDerivAt (n := 2) · exact ContDiff.contDiffAt hf · simp have h := IsSymmSndFDerivAt.eq hf' (dx,0) (0,dy) rw [fderiv_wrt_prod_clm_comp, fderiv_wrt_prod_clm_comp] at h simp only [ContinuousLinearMap.add_apply, ContinuousLinearMap.coe_comp', ContinuousLinearMap.coe_fst', Function.comp_apply, ContinuousLinearMap.coe_snd', map_zero, add_zero, zero_add] at h rw [fderiv_curry_clm_apply, fderiv_curry_clm_apply] at h simp only [ContinuousLinearMap.add_apply, ContinuousLinearMap.coe_comp', ContinuousLinearMap.coe_fst', Function.comp_apply, map_zero, ContinuousLinearMap.coe_snd', zero_add, add_zero] at h exact h /- Start of differentiability conditions. -/ · fun_prop · fun_prop · exact hf.differentiable (by simp) · fun_prop

lemma

PhysLean

[ "import Mathlib.Analysis.Calculus.FDeriv.Symmetric" ]

PhysLean/Mathematics/FDerivCurry.lean

fderiv_swap

null

predAboveI (i x : Fin n.succ.succ) : Fin n.succ := if h : x.val < i.val then ⟨x.val, by omega⟩ else ⟨x.val - 1, by by_cases hx : x = 0 · omega · omega⟩

def

PhysLean

[ "import Mathlib.Tactic.Polyrith", "import Mathlib.Tactic.Linarith", "import Mathlib.Logic.Equiv.Fin.Basic" ]

PhysLean/Mathematics/Fin.lean

predAboveI

/-- Given a `i` and `x` in `Fin n.succ.succ` returns an element of `Fin n.succ` subtracting 1 if `i.val ≤ x.val` else casting x. -/

predAboveI_self (i : Fin n.succ.succ) : predAboveI i i = ⟨i.val - 1, by omega⟩ := by simp [predAboveI] @[simp]

lemma

PhysLean

[ "import Mathlib.Tactic.Polyrith", "import Mathlib.Tactic.Linarith", "import Mathlib.Logic.Equiv.Fin.Basic" ]

PhysLean/Mathematics/Fin.lean

predAboveI_self

/-- Given a `i` and `x` in `Fin n.succ.succ` returns an element of `Fin n.succ` subtracting 1 if `i.val ≤ x.val` else casting x. -/

predAboveI_succAbove (i : Fin n.succ.succ) (x : Fin n.succ) : predAboveI i (Fin.succAbove i x) = x := by simp only [Nat.succ_eq_add_one, predAboveI, Fin.succAbove, Fin.val_fin_lt, Fin.ext_iff] split_ifs · rfl · rename_i h1 h2 simp only [Fin.lt_def, Fin.coe_castSucc, not_lt, Fin.val_succ] at h1 h2 omega · rfl

lemma

PhysLean

[ "import Mathlib.Tactic.Polyrith", "import Mathlib.Tactic.Linarith", "import Mathlib.Logic.Equiv.Fin.Basic" ]

PhysLean/Mathematics/Fin.lean

predAboveI_succAbove

/-- Given a `i` and `x` in `Fin n.succ.succ` returns an element of `Fin n.succ` subtracting 1 if `i.val ≤ x.val` else casting x. -/

succsAbove_predAboveI {i x : Fin n.succ.succ} (h : i ≠ x) : Fin.succAbove i (predAboveI i x) = x := by simp only [Fin.succAbove, predAboveI, Nat.succ_eq_add_one, Fin.val_fin_lt, Fin.ext_iff] split_ifs · rfl · rename_i h1 h2 rw [Fin.lt_def] at h1 h2 simp only [Fin.succ_mk, add_eq_left, one_ne_zero] simp only [Fin.castSucc_mk, Fin.eta, Fin.val_fin_lt, not_lt] at h2 rw [Fin.le_def] at h2 omega · rename_i h1 h2 simp only [not_lt] at h1 rw [Fin.le_def] at h1 rw [Fin.lt_def] at h2 simp only [Fin.castSucc_mk] at h2 omega · rename_i h1 h2 simp only [Fin.succ_mk] rw [not_lt, Fin.le_def] at h1 omega

lemma

PhysLean

[ "import Mathlib.Tactic.Polyrith", "import Mathlib.Tactic.Linarith", "import Mathlib.Logic.Equiv.Fin.Basic" ]

PhysLean/Mathematics/Fin.lean

succsAbove_predAboveI

null

predAboveI_eq_iff {i x : Fin n.succ.succ} (h : i ≠ x) (y : Fin n.succ) : y = predAboveI i x ↔ i.succAbove y = x := by apply Iff.intro <;> intro h · subst h rw [succsAbove_predAboveI h] · simp [← h]

lemma

PhysLean

[ "import Mathlib.Tactic.Polyrith", "import Mathlib.Tactic.Linarith", "import Mathlib.Logic.Equiv.Fin.Basic" ]

PhysLean/Mathematics/Fin.lean

predAboveI_eq_iff

null

predAboveI_lt {i x : Fin n.succ.succ} (h : x.val < i.val) : predAboveI i x = ⟨x.val, by omega⟩ := by simp [predAboveI, h]

lemma

PhysLean

[ "import Mathlib.Tactic.Polyrith", "import Mathlib.Tactic.Linarith", "import Mathlib.Logic.Equiv.Fin.Basic" ]

PhysLean/Mathematics/Fin.lean

predAboveI_lt

null

predAboveI_ge {i x : Fin n.succ.succ} (h : i.val < x.val) : predAboveI i x = ⟨x.val - 1, by omega⟩ := by simp only [Nat.succ_eq_add_one, predAboveI, Fin.val_fin_lt, dite_eq_right_iff, Fin.mk.injEq] omega

lemma

PhysLean

[ "import Mathlib.Tactic.Polyrith", "import Mathlib.Tactic.Linarith", "import Mathlib.Logic.Equiv.Fin.Basic" ]

PhysLean/Mathematics/Fin.lean

predAboveI_ge

null

succAbove_succAbove_predAboveI (i : Fin n.succ.succ) (j : Fin n.succ) (x : Fin n) : i.succAbove (j.succAbove x) = (i.succAbove j).succAbove ((predAboveI (i.succAbove j) i).succAbove x) := by by_cases h1 : j.castSucc < i · have hx := Fin.succAbove_of_castSucc_lt _ _ h1 rw [hx, predAboveI_ge h1] by_cases hx1 : x.castSucc < j · rw [Fin.succAbove_of_castSucc_lt _ _ hx1, Fin.succAbove_of_castSucc_lt] · nth_rewrite 2 [Fin.succAbove_of_castSucc_lt] · rw [Fin.succAbove_of_castSucc_lt] exact hx1 · rw [Fin.lt_def] at h1 hx1 ⊢ simp_all only [Nat.succ_eq_add_one, Fin.coe_castSucc] omega · exact Nat.lt_trans hx1 h1 · simp only [not_lt] at hx1 rw [Fin.le_def] at hx1 rw [Fin.lt_def] at h1 rw [Fin.succAbove_of_le_castSucc _ _ hx1] by_cases hx2 : x.succ.castSucc < i · rw [Fin.succAbove_of_castSucc_lt _ _ hx2] nth_rewrite 2 [Fin.succAbove_of_castSucc_lt] · rw [Fin.succAbove_of_le_castSucc] · rfl · assumption · rw [Fin.lt_def] at hx2 ⊢ simp_all only [Nat.succ_eq_add_one, Fin.coe_castSucc, Fin.val_succ] omega · simp only [not_lt] at hx2 rw [Fin.succAbove_of_le_castSucc _ _ hx2] nth_rewrite 2 [Fin.succAbove_of_le_castSucc] · rw [Fin.succAbove_of_le_castSucc] rw [Fin.le_def] exact Nat.le_succ_of_le hx1 · rw [Fin.le_def] at hx2 ⊢ simp_all · simp only [Nat.succ_eq_add_one, not_lt] at h1 have hx := Fin.succAbove_of_le_castSucc _ _ h1 rw [hx, predAboveI_lt (Nat.lt_add_one_of_le h1)] by_cases hx1 : j ≤ x.castSucc · rw [Fin.succAbove_of_le_castSucc _ _ hx1, Fin.succAbove_of_le_castSucc _ _] · nth_rewrite 2 [Fin.succAbove_of_le_castSucc _ _] · rw [Fin.succAbove_of_le_castSucc] rw [Fin.le_def] at hx1 ⊢ simp_all only [Nat.succ_eq_add_one, Fin.coe_castSucc, Fin.val_succ, add_le_add_iff_right] · rw [Fin.le_def] at h1 hx1 ⊢ simp_all only [Nat.succ_eq_add_one, Fin.coe_castSucc] omega · rw [Fin.le_def] at hx1 h1 ⊢ simp_all only [Nat.succ_eq_add_one, Fin.coe_castSucc, Fin.val_succ] omega · simp only [Nat.succ_eq_add_one, not_le] at hx1 rw [Fin.lt_def] at hx1 rw [Fin.le_def] at h1 rw [Fin.succAbove_of_castSucc_lt _ _ hx1] by_cases hx2 : x.castSucc.castSucc < i · rw [Fin.succAbove_of_castSucc_lt _ _ hx2] nth_rewrite 2 [Fin.succAbove_of_castSucc_lt] · rw [Fin.succAbove_of_castSucc_lt] rw [Fin.lt_def] at hx2 ⊢ simp_all only [Nat.succ_eq_add_one, Fin.coe_castSucc, Fin.val_succ] omega · rw [Fin.lt_def] at hx2 ⊢ simp_all · simp only [not_lt] at hx2 rw [Fin.succAbove_of_le_castSucc _ _ hx2] nth_rewrite 2 [Fin.succAbove_of_le_castSucc] · rw [Fin.succAbove_of_castSucc_lt] · rfl exact Fin.castSucc_lt_succ_iff.mpr hx1 · rw [Fin.le_def] at hx2 ⊢ simp_all /-- The equivalence between `Fin n.succ` and `Fin 1 ⊕ Fin n` extracting the `i`th component. -/

lemma

PhysLean

[ "import Mathlib.Tactic.Polyrith", "import Mathlib.Tactic.Linarith", "import Mathlib.Logic.Equiv.Fin.Basic" ]

PhysLean/Mathematics/Fin.lean

succAbove_succAbove_predAboveI

null

finExtractOne {n : ℕ} (i : Fin (n + 1)) : Fin (n + 1) ≃ Fin 1 ⊕ Fin n := (finCongr (by omega : n.succ = i + 1 + (n - i))).trans <| finSumFinEquiv.symm.trans <| (Equiv.sumCongr (finSumFinEquiv.symm.trans (Equiv.sumComm (Fin i) (Fin 1))) (Equiv.refl (Fin (n-i)))).trans <| (Equiv.sumAssoc (Fin 1) (Fin i) (Fin (n - i))).trans <| Equiv.sumCongr (Equiv.refl (Fin 1)) (finSumFinEquiv.trans (finCongr (by omega))) @[simp]

def

PhysLean

[ "import Mathlib.Tactic.Polyrith", "import Mathlib.Tactic.Linarith", "import Mathlib.Logic.Equiv.Fin.Basic" ]

PhysLean/Mathematics/Fin.lean

finExtractOne

/-- The equivalence between `Fin n.succ` and `Fin 1 ⊕ Fin n` extracting the `i`th component. -/

finExtractOne_apply_eq {n : ℕ} (i : Fin n.succ) : finExtractOne i i = Sum.inl 0 := by simp only [Nat.succ_eq_add_one, finExtractOne, Equiv.trans_apply, finCongr_apply, Equiv.sumCongr_apply, Equiv.coe_trans, Equiv.sumComm_apply, Equiv.coe_refl, Fin.isValue] rw [show Fin.cast _ i = Fin.castAdd ((n - ↑i)) ⟨i.1, lt_add_one i.1⟩ from rfl, finSumFinEquiv_symm_apply_castAdd] simp only [Nat.succ_eq_add_one, Sum.map_inl, Function.comp_apply, Fin.isValue] have h2 : @Fin.mk (↑i + 1) ↑i (lt_add_one i.1) = Fin.natAdd i.val 1 := rfl rw [h2, finSumFinEquiv_symm_apply_natAdd] rfl

lemma

PhysLean

[ "import Mathlib.Tactic.Polyrith", "import Mathlib.Tactic.Linarith", "import Mathlib.Logic.Equiv.Fin.Basic" ]

PhysLean/Mathematics/Fin.lean

finExtractOne_apply_eq

null

finExtractOne_symm_inr {n : ℕ} (i : Fin n.succ) : (finExtractOne i).symm ∘ Sum.inr = i.succAbove := by ext x simp only [Nat.succ_eq_add_one, finExtractOne, Function.comp_apply, Equiv.symm_trans_apply, finCongr_symm, Equiv.symm_symm, Equiv.sumCongr_symm, Equiv.refl_symm, Equiv.sumCongr_apply, Equiv.coe_refl, Sum.map_inr, finCongr_apply, Fin.coe_cast] change (finSumFinEquiv (Sum.map (⇑(finSumFinEquiv.symm.trans (Equiv.sumComm (Fin ↑i) (Fin 1))).symm) id ((Equiv.sumAssoc (Fin 1) (Fin ↑i) (Fin (n - i))).symm (Sum.inr (finSumFinEquiv.symm (Fin.cast _ x)))))).val = _ by_cases hi : x.1 < i.1 · generalize_proofs hp have h1 : (finSumFinEquiv.symm (Fin.cast hp x)) = Sum.inl ⟨x, hi⟩ := by rw [← finSumFinEquiv_symm_apply_castAdd] rfl rw [h1] simp only [Nat.succ_eq_add_one, Equiv.sumAssoc_symm_apply_inr_inl, Sum.map_inl, Equiv.symm_trans_apply, Equiv.symm_symm, Equiv.sumComm_symm, Equiv.sumComm_apply, Sum.swap_inr, finSumFinEquiv_apply_left, Fin.castAdd_mk] rw [Fin.succAbove] split · rfl rename_i hn simp_all only [Nat.succ_eq_add_one, not_lt, Fin.le_def, Fin.coe_castSucc, Fin.val_succ, left_eq_add, one_ne_zero] omega · generalize_proofs hp have h1 : (finSumFinEquiv.symm (Fin.cast hp x)) = Sum.inr ⟨x - i, by omega⟩ := by rw [← finSumFinEquiv_symm_apply_natAdd] apply congrArg ext simp only [Nat.succ_eq_add_one, Fin.coe_cast, Fin.natAdd_mk] omega rw [h1, Fin.succAbove] split · rename_i hn simp_all [Fin.lt_def] simp only [Nat.succ_eq_add_one, Equiv.sumAssoc_symm_apply_inr_inr, Sum.map_inr, id_eq, finSumFinEquiv_apply_right, Fin.natAdd_mk, Fin.val_succ] omega @[simp]

lemma

PhysLean

[ "import Mathlib.Tactic.Polyrith", "import Mathlib.Tactic.Linarith", "import Mathlib.Logic.Equiv.Fin.Basic" ]

PhysLean/Mathematics/Fin.lean

finExtractOne_symm_inr

null

finExtractOne_symm_inr_apply {n : ℕ} (i : Fin n.succ) (x : Fin n) : (finExtractOne i).symm (Sum.inr x) = i.succAbove x := calc _ = ((finExtractOne i).symm ∘ Sum.inr) x := rfl _ = i.succAbove x := by rw [finExtractOne_symm_inr] @[simp]

lemma

PhysLean

[ "import Mathlib.Tactic.Polyrith", "import Mathlib.Tactic.Linarith", "import Mathlib.Logic.Equiv.Fin.Basic" ]

PhysLean/Mathematics/Fin.lean

finExtractOne_symm_inr_apply

null

finExtractOne_symm_inl_apply {n : ℕ} (i : Fin n.succ) : (finExtractOne i).symm (Sum.inl 0) = i := by rfl

lemma

PhysLean

[ "import Mathlib.Tactic.Polyrith", "import Mathlib.Tactic.Linarith", "import Mathlib.Logic.Equiv.Fin.Basic" ]

PhysLean/Mathematics/Fin.lean

finExtractOne_symm_inl_apply

null

finExtractOne_apply_neq {n : ℕ} (i j : Fin (n + 1 + 1)) (hij : i ≠ j) : finExtractOne i j = Sum.inr (predAboveI i j) := by symm apply (Equiv.symm_apply_eq _).mp ?_ simp only [Nat.succ_eq_add_one, finExtractOne_symm_inr_apply] exact succsAbove_predAboveI hij /-- Given an equivalence `Fin n.succ.succ ≃ Fin n.succ.succ`, and an `i : Fin n.succ.succ`, the map `Fin n.succ → Fin n.succ` obtained by dropping `i` and it's image. -/

lemma

PhysLean

[ "import Mathlib.Tactic.Polyrith", "import Mathlib.Tactic.Linarith", "import Mathlib.Logic.Equiv.Fin.Basic" ]

PhysLean/Mathematics/Fin.lean

finExtractOne_apply_neq

null

finExtractOnPermHom {m : ℕ} (i : Fin n.succ.succ) (σ : Fin n.succ.succ ≃ Fin m.succ.succ) : Fin n.succ → Fin m.succ := fun x => predAboveI (σ i) (σ ((finExtractOne i).symm (Sum.inr x)))

def

PhysLean

[ "import Mathlib.Tactic.Polyrith", "import Mathlib.Tactic.Linarith", "import Mathlib.Logic.Equiv.Fin.Basic" ]

PhysLean/Mathematics/Fin.lean

finExtractOnPermHom

/-- Given an equivalence `Fin n.succ.succ ≃ Fin n.succ.succ`, and an `i : Fin n.succ.succ`, the map `Fin n.succ → Fin n.succ` obtained by dropping `i` and it's image. -/

finExtractOnPermHom_inv {m : ℕ} (i : Fin n.succ.succ) (σ : Fin n.succ.succ ≃ Fin m.succ.succ) : (finExtractOnPermHom (σ i) σ.symm) ∘ (finExtractOnPermHom i σ) = id := by funext x simp only [Nat.succ_eq_add_one, Function.comp_apply, finExtractOnPermHom, Equiv.symm_apply_apply, finExtractOne_symm_inr_apply, id_eq] by_cases h : σ (i.succAbove x) < σ i · rw [predAboveI_lt h, Fin.succAbove_of_castSucc_lt] · simp · simp_all have hσ : σ (i.succAbove x) ≠ σ i := by simp only [Nat.succ_eq_add_one, ne_eq, EmbeddingLike.apply_eq_iff_eq] exact Fin.succAbove_ne i x have hn : σ i < σ (i.succAbove x) := by omega rw [predAboveI_ge hn] rw [Fin.succAbove_of_le_castSucc] · simp only [Nat.succ_eq_add_one, Fin.succ_mk] trans predAboveI i (σ.symm (σ (i.succAbove x))) · congr exact Nat.sub_add_cancel (Fin.lt_of_le_of_lt (Fin.zero_le (σ i)) hn) simp rw [Fin.le_def] simp only [Nat.succ_eq_add_one, Fin.castSucc_mk] omega /-- Given an equivalence `Fin n.succ.succ ≃ Fin n.succ.succ`, and an `i : Fin n.succ.succ`, the equivalence `Fin n.succ ≃ Fin n.succ` obtained by dropping `i` and it's image. -/

lemma

PhysLean

[ "import Mathlib.Tactic.Polyrith", "import Mathlib.Tactic.Linarith", "import Mathlib.Logic.Equiv.Fin.Basic" ]

PhysLean/Mathematics/Fin.lean

finExtractOnPermHom_inv

/-- Given an equivalence `Fin n.succ.succ ≃ Fin n.succ.succ`, and an `i : Fin n.succ.succ`, the map `Fin n.succ → Fin n.succ` obtained by dropping `i` and it's image. -/

finExtractOnePerm {m : ℕ} (i : Fin n.succ.succ) (σ : Fin n.succ.succ ≃ Fin m.succ.succ) : Fin n.succ ≃ Fin m.succ where toFun x := finExtractOnPermHom i σ x invFun x := finExtractOnPermHom (σ i) σ.symm x left_inv x := by simpa using congrFun (finExtractOnPermHom_inv i σ) x right_inv x := by simpa using congrFun (finExtractOnPermHom_inv (σ i) σ.symm) x

def

PhysLean

[ "import Mathlib.Tactic.Polyrith", "import Mathlib.Tactic.Linarith", "import Mathlib.Logic.Equiv.Fin.Basic" ]

PhysLean/Mathematics/Fin.lean

finExtractOnePerm

/-- Given an equivalence `Fin n.succ.succ ≃ Fin n.succ.succ`, and an `i : Fin n.succ.succ`, the equivalence `Fin n.succ ≃ Fin n.succ` obtained by dropping `i` and it's image. -/

finExtractOnePerm_equiv {n m : ℕ} (e : Fin n.succ.succ ≃ Fin m.succ.succ) (i : Fin n.succ.succ) : e ∘ i.succAbove = (e i).succAbove ∘ finExtractOnePerm i e := by simp only [Nat.succ_eq_add_one, finExtractOnePerm, Equiv.coe_fn_mk] funext x simp only [Function.comp_apply, finExtractOnPermHom, Nat.succ_eq_add_one, finExtractOne_symm_inr_apply] rw [succsAbove_predAboveI] simp only [Nat.succ_eq_add_one, ne_eq, EmbeddingLike.apply_eq_iff_eq] exact Fin.ne_succAbove i x @[simp]

lemma

PhysLean

[ "import Mathlib.Tactic.Polyrith", "import Mathlib.Tactic.Linarith", "import Mathlib.Logic.Equiv.Fin.Basic" ]

PhysLean/Mathematics/Fin.lean

finExtractOnePerm_equiv

null

finExtractOnePerm_apply (i : Fin n.succ.succ) (σ : Fin n.succ.succ ≃ Fin n.succ.succ) (x : Fin n.succ) : finExtractOnePerm i σ x = predAboveI (σ i) (σ ((finExtractOne i).symm (Sum.inr x))) := rfl @[simp]

lemma

PhysLean

[ "import Mathlib.Tactic.Polyrith", "import Mathlib.Tactic.Linarith", "import Mathlib.Logic.Equiv.Fin.Basic" ]

PhysLean/Mathematics/Fin.lean

finExtractOnePerm_apply

null

finExtractOnePerm_symm_apply (i : Fin n.succ.succ) (σ : Fin n.succ.succ ≃ Fin n.succ.succ) (x : Fin n.succ) : (finExtractOnePerm i σ).symm x = predAboveI (σ.symm (σ i)) (σ.symm ((finExtractOne (σ i)).symm (Sum.inr x))) := rfl /-- The equivalence of types `Fin n.succ.succ ≃ (Fin 1 ⊕ Fin 1) ⊕ Fin n` extracting the `i` and `(i.succAbove j)`. -/

lemma

PhysLean

[ "import Mathlib.Tactic.Polyrith", "import Mathlib.Tactic.Linarith", "import Mathlib.Logic.Equiv.Fin.Basic" ]

PhysLean/Mathematics/Fin.lean

finExtractOnePerm_symm_apply

null

finExtractTwo {n : ℕ} (i : Fin n.succ.succ) (j : Fin n.succ) : Fin n.succ.succ ≃ (Fin 1 ⊕ Fin 1) ⊕ Fin n := (finExtractOne i).trans <| (Equiv.sumCongr (Equiv.refl (Fin 1)) (finExtractOne j)).trans <| (Equiv.sumAssoc (Fin 1) (Fin 1) (Fin n)).symm @[simp]

def

PhysLean

[ "import Mathlib.Tactic.Polyrith", "import Mathlib.Tactic.Linarith", "import Mathlib.Logic.Equiv.Fin.Basic" ]

PhysLean/Mathematics/Fin.lean

finExtractTwo

/-- The equivalence of types `Fin n.succ.succ ≃ (Fin 1 ⊕ Fin 1) ⊕ Fin n` extracting the `i` and `(i.succAbove j)`. -/

finExtractTwo_apply_fst {n : ℕ} (i : Fin n.succ.succ) (j : Fin n.succ) : finExtractTwo i j i = Sum.inl (Sum.inl 0) := by simp [finExtractTwo]

lemma

PhysLean

[ "import Mathlib.Tactic.Polyrith", "import Mathlib.Tactic.Linarith", "import Mathlib.Logic.Equiv.Fin.Basic" ]

PhysLean/Mathematics/Fin.lean

finExtractTwo_apply_fst

/-- The equivalence of types `Fin n.succ.succ ≃ (Fin 1 ⊕ Fin 1) ⊕ Fin n` extracting the `i` and `(i.succAbove j)`. -/

finExtractTwo_symm_inr {n : ℕ} (i : Fin n.succ.succ) (j : Fin n.succ) : (finExtractTwo i j).symm ∘ Sum.inr = i.succAbove ∘ j.succAbove := by rw [finExtractTwo] ext1 x simp @[simp]

lemma

PhysLean

[ "import Mathlib.Tactic.Polyrith", "import Mathlib.Tactic.Linarith", "import Mathlib.Logic.Equiv.Fin.Basic" ]

PhysLean/Mathematics/Fin.lean

finExtractTwo_symm_inr

null

finExtractTwo_symm_inr_apply {n : ℕ} (i : Fin n.succ.succ) (j : Fin n.succ) (x : Fin n) : (finExtractTwo i j).symm (Sum.inr x) = i.succAbove (j.succAbove x) := by simp [finExtractTwo] @[simp]

lemma

PhysLean

[ "import Mathlib.Tactic.Polyrith", "import Mathlib.Tactic.Linarith", "import Mathlib.Logic.Equiv.Fin.Basic" ]

PhysLean/Mathematics/Fin.lean

finExtractTwo_symm_inr_apply

null

finExtractTwo_symm_inl_inr_apply {n : ℕ} (i : Fin n.succ.succ) (j : Fin n.succ) : (finExtractTwo i j).symm (Sum.inl (Sum.inr 0)) = i.succAbove j := by simp [finExtractTwo] @[simp]

lemma

PhysLean

[ "import Mathlib.Tactic.Polyrith", "import Mathlib.Tactic.Linarith", "import Mathlib.Logic.Equiv.Fin.Basic" ]

PhysLean/Mathematics/Fin.lean

finExtractTwo_symm_inl_inr_apply

null

finExtractTwo_symm_inl_inl_apply {n : ℕ} (i : Fin n.succ.succ) (j : Fin n.succ) : (finExtractTwo i j).symm (Sum.inl (Sum.inl 0)) = i := by rfl @[simp]

lemma

PhysLean

[ "import Mathlib.Tactic.Polyrith", "import Mathlib.Tactic.Linarith", "import Mathlib.Logic.Equiv.Fin.Basic" ]

PhysLean/Mathematics/Fin.lean

finExtractTwo_symm_inl_inl_apply

null

finExtractTwo_apply_snd {n : ℕ} (i : Fin n.succ.succ) (j : Fin n.succ) : finExtractTwo i j (i.succAbove j) = Sum.inl (Sum.inr 0) := by simp [← Equiv.eq_symm_apply] /-- Takes two maps `Fin n → Fin n` and returns the equivalence they form. -/

lemma

PhysLean

[ "import Mathlib.Tactic.Polyrith", "import Mathlib.Tactic.Linarith", "import Mathlib.Logic.Equiv.Fin.Basic" ]

PhysLean/Mathematics/Fin.lean

finExtractTwo_apply_snd

null

finMapToEquiv (f1 : Fin n → Fin m) (f2 : Fin m → Fin n) (h : ∀ x, f1 (f2 x) = x := by decide) (h' : ∀ x, f2 (f1 x) = x := by decide) : Fin n ≃ Fin m where toFun := f1 invFun := f2 left_inv := h' right_inv := h @[simp]

def

PhysLean

[ "import Mathlib.Tactic.Polyrith", "import Mathlib.Tactic.Linarith", "import Mathlib.Logic.Equiv.Fin.Basic" ]

PhysLean/Mathematics/Fin.lean

finMapToEquiv

/-- Takes two maps `Fin n → Fin n` and returns the equivalence they form. -/

finMapToEquiv_apply {f1 : Fin n → Fin m} {f2 : Fin m → Fin n} {h : ∀ x, f1 (f2 x) = x} {h' : ∀ x, f2 (f1 x) = x} (x : Fin n) : finMapToEquiv f1 f2 h h' x = f1 x := rfl @[simp]

lemma

PhysLean

[ "import Mathlib.Tactic.Polyrith", "import Mathlib.Tactic.Linarith", "import Mathlib.Logic.Equiv.Fin.Basic" ]

PhysLean/Mathematics/Fin.lean

finMapToEquiv_apply

/-- Takes two maps `Fin n → Fin n` and returns the equivalence they form. -/

finMapToEquiv_symm_apply {f1 : Fin n → Fin m} {f2 : Fin m → Fin n} {h : ∀ x, f1 (f2 x) = x} {h' : ∀ x, f2 (f1 x) = x} (x : Fin m) : (finMapToEquiv f1 f2 h h').symm x = f2 x := rfl

lemma

PhysLean

[ "import Mathlib.Tactic.Polyrith", "import Mathlib.Tactic.Linarith", "import Mathlib.Logic.Equiv.Fin.Basic" ]

PhysLean/Mathematics/Fin.lean

finMapToEquiv_symm_apply

null

finMapToEquiv_symm_eq {f1 : Fin n → Fin m} {f2 : Fin m → Fin n} {h : ∀ x, f1 (f2 x) = x} {h' : ∀ x, f2 (f1 x) = x} : (finMapToEquiv f1 f2 h h').symm = finMapToEquiv f2 f1 h' h := rfl /-- Given an equivalence between `Fin n` and `Fin m`, the induced equivalence between `Fin n.succ` and `Fin m.succ` derived by `Fin.cons`. -/

lemma

PhysLean

[ "import Mathlib.Tactic.Polyrith", "import Mathlib.Tactic.Linarith", "import Mathlib.Logic.Equiv.Fin.Basic" ]

PhysLean/Mathematics/Fin.lean

finMapToEquiv_symm_eq

null

Datasets:

phanerozoic
/

Lean4-PhysLean

Lean4-PhysLean

Applications

Source

Schema

Collection including phanerozoic/Lean4-PhysLean

Proof Assistant Projects

Column	Type	Description
fact	string	Declaration body
type	string	theorem, def, lemma, etc.
library	string	Source module
imports	list	Required imports
filename	string	Source file path
symbolic_name	string	Identifier
docstring	string	Documentation (if present)