Download data/lean/ComparatorChallenges/CylinderCovering.lean from introvoyz045/math: direct link, hf CLI and curl.
- Browser
- Download file 19.3 kB
-
https://huggingface.co/datasets/introvoyz045/math/resolve/main/data/lean/ComparatorChallenges/CylinderCovering.lean
- Command line
-
hf download hf://datasets/introvoyz045/math/data/lean/ComparatorChallenges/CylinderCovering.lean
-
curl -L -o CylinderCovering.lean https://huggingface.co/datasets/introvoyz045/math/resolve/main/data/lean/ComparatorChallenges/CylinderCovering.lean
19.3 kB
| import Mathlib | |
| namespace OAI | |
| section | |
| open Set MeasureTheory | |
| open scoped InnerProductSpace BigOperators Interval | |
| noncomputable section | |
| namespace TriangularCovering | |
| abbrev Space := EuclideanSpace โ (Fin 3) | |
| def H : โ := Real.sqrt 2 | |
| def point (x y t : โ) : Space := !โ[x, y, H * t] | |
| def K : Set Space := | |
| {z | โ x y t : โ, 0 โค t โง t โค 1 โง |x| โค 1 - t โง |y| โค t โง z = point x y t} | |
| def projection (u z : Space) : Space := z - (inner โ u z) โข u | |
| def area (B : Set Space) : โ := (Measure.euclideanHausdorffMeasure 2 B).toReal | |
| def shadowArea (u : Space) : โ := area (projection u '' K) | |
| def A_min : โ := sInf {a : โ | โ u : Space, โuโ = 1 โง a = shadowArea u} | |
| structure TriCylinder where | |
| axis : Space | |
| base : Set Space | |
| unit_axis : โaxisโ = 1 | |
| perpendicular : โ z โ base, inner โ axis z = 0 | |
| triangular : โ v : Fin 3 โ Space, AffineIndependent โ v โง | |
| base = convexHull โ (Set.range v) | |
| compact : IsCompact base | |
| convex : Convex โ base | |
| measurable : MeasurableSet base | |
| finite_area : Measure.euclideanHausdorffMeasure 2 base โ โค | |
| def TriCylinder.carrier (c : TriCylinder) : Set Space := | |
| {z | โ b โ c.base, โ r : โ, z = b + r โข c.axis} | |
| def Covers {m : โ} (c : Fin m โ TriCylinder) : Prop := | |
| โ z โ K, โ i : Fin m, z โ (c i).carrier | |
| def totalArea {m : โ} (c : Fin m โ TriCylinder) : โ := | |
| โ i : Fin m, area (c i).base | |
| def relativeCost {m : โ} (c : Fin m โ TriCylinder) : โ := | |
| โ i : Fin m, area (c i).base / shadowArea (c i).axis | |
| def n (ฮต : โ) : โ := โ2 / ฮต ^ 2โโ | |
| end TriangularCovering | |
| end | |
| end | |
| run_cmd Lean.modifyEnv fun env => Lean.Meta.auxLemmasExt.setState env {} | |
| section | |
| open Set MeasureTheory | |
| open scoped InnerProductSpace BigOperators Interval | |
| noncomputable section | |
| namespace TriangularCovering | |
| def ฮท : โ := 1 / 1000 | |
| def alpha (a b : โ) : โ := (1 + a * b) / 4 | |
| def beta (a b : โ) : โ := (a + b) / 4 | |
| def d (q : โ) : โ := q ^ 2 * (1 + q ^ 2) / 16 | |
| def cutoffCoeff (a b : โ) : โ := ฮท + max (d a) (d b) | |
| def step (N : โ) : โ := 2 / N | |
| def mesh (N i : โ) : โ := -1 + i * step N | |
| def cutoff (ฮต a b : โ) : โ := 1 / 2 + ฮต ^ 2 * cutoffCoeff a b | |
| def speedSq (a b : โ) : โ := (alpha a b)^2 + 2*(beta a b)^2 | |
| def normalizedTerm (ฮต a b : โ) : โ := | |
| (b-a) * (cutoff ฮต a b)^2 / Real.sqrt (1+ฮต^2*speedSq a b) | |
| end TriangularCovering | |
| end | |
| end | |
| run_cmd Lean.modifyEnv fun env => Lean.Meta.auxLemmasExt.setState env {} | |
| section | |
| open Set MeasureTheory | |
| open scoped InnerProductSpace BigOperators Interval | |
| noncomputable section | |
| namespace TriangularCovering | |
| def unit (v : Space) : Space := โvโโปยน โข v | |
| end TriangularCovering | |
| end | |
| end | |
| run_cmd Lean.modifyEnv fun env => Lean.Meta.auxLemmasExt.setState env {} | |
| section | |
| open Set MeasureTheory | |
| open scoped InnerProductSpace BigOperators Interval | |
| noncomputable section | |
| namespace TriangularCovering | |
| def tiltV (ฮต A B : โ) : Space := !โ[1, ฮต*A, H*ฮต*B] | |
| def tiltW (ฮต A B : โ) : Space := !โ[-ฮต*A, 1, H*ฮต*B] | |
| def lowerVertices (a b T : โ) : Fin 3 โ Space := | |
| ![point 0 0 0, point 0 (a*T) T, point 0 (b*T) T] | |
| def upperVertices (a b T : โ) : Fin 3 โ Space := | |
| ![point 0 0 1, point (a*T) 0 (1-T), point (b*T) 0 (1-T)] | |
| end TriangularCovering | |
| end | |
| end | |
| run_cmd Lean.modifyEnv fun env => Lean.Meta.auxLemmasExt.setState env {} | |
| section | |
| open Set MeasureTheory | |
| open scoped InnerProductSpace BigOperators Interval | |
| noncomputable section | |
| namespace TriangularCovering.Planar | |
| abbrev Coord := Fin 2 โ โ | |
| def standard : Set Coord := {x | 0 โค x 0 โง 0 โค x 1 โง x 0 + x 1 โค 1} | |
| def vertices : Fin 3 โ Coord := ![0, ![1, 0], ![0, 1] ] | |
| end TriangularCovering.Planar | |
| namespace TriangularCovering | |
| section Triangles | |
| variable {E F : Type*} [AddCommGroup E] [Module โ E] [AddCommGroup F] [Module โ F] | |
| def triangle (a b c : E) : Set E := convexHull โ (range (![a, b, c] : Fin 3 โ E)) | |
| end Triangles | |
| end TriangularCovering | |
| end | |
| end | |
| run_cmd Lean.modifyEnv fun env => Lean.Meta.auxLemmasExt.setState env {} | |
| section | |
| open Set MeasureTheory | |
| open scoped InnerProductSpace | |
| noncomputable section | |
| namespace TriangularCovering | |
| def lowerAngularIndex {N : โ} (j : Fin N) : Fin (2*N) := | |
| Fin.cast (two_mul N).symm (Fin.castAdd N j) | |
| def upperAngularIndex {N : โ} (j : Fin N) : Fin (2*N) := | |
| Fin.cast (two_mul N).symm (Fin.natAdd N j) | |
| def lowerAngularAxis (ฮต : โ) (j : โ) : Space := | |
| let a := mesh (n ฮต) j | |
| let b := mesh (n ฮต) (j+1) | |
| unit (tiltV ฮต (alpha a b) (beta a b)) | |
| def upperAngularAxis (ฮต : โ) (j : โ) : Space := | |
| let a := mesh (n ฮต) j | |
| let b := mesh (n ฮต) (j+1) | |
| unit (tiltW ฮต (alpha a b) (beta a b)) | |
| def lowerAngularBase (ฮต : โ) (j : โ) : Set Space := | |
| let a := mesh (n ฮต) j | |
| let b := mesh (n ฮต) (j+1) | |
| let v := lowerVertices a b (cutoff ฮต a b) | |
| projection (lowerAngularAxis ฮต j) '' triangle (v 0) (v 1) (v 2) | |
| def upperAngularBase (ฮต : โ) (j : โ) : Set Space := | |
| let a := mesh (n ฮต) j | |
| let b := mesh (n ฮต) (j+1) | |
| let v := upperVertices a b (cutoff ฮต a b) | |
| projection (upperAngularAxis ฮต j) '' triangle (v 0) (v 1) (v 2) | |
| def ExplicitAngularFamily (ฮต : โ) (c : Fin (2*n ฮต) โ TriCylinder) : Prop := | |
| โ j : Fin (n ฮต), | |
| (c (lowerAngularIndex j)).axis = lowerAngularAxis ฮต j โง | |
| (c (lowerAngularIndex j)).base = lowerAngularBase ฮต j โง | |
| (c (upperAngularIndex j)).axis = upperAngularAxis ฮต j โง | |
| (c (upperAngularIndex j)).base = upperAngularBase ฮต j | |
| def AngularAreaStatement : Prop := | |
| โ ฮต : โ, 0 < ฮต โ ฮต โค 1 โ | |
| โ c : Fin (2*n ฮต) โ TriCylinder, | |
| ExplicitAngularFamily ฮต c โง | |
| totalArea c/H = โ j : Fin (n ฮต), | |
| normalizedTerm ฮต (mesh (n ฮต) j) (mesh (n ฮต) (j+1)) โง | |
| |totalArea c/H - (1/2-(13/6000:โ)*ฮต^2)| โค 2*ฮต^4 | |
| def ExplicitAngularStatement : Prop := | |
| A_min = H โง | |
| โ ฮต : โ, 0 < ฮต โ ฮต โค 1/2000 โ | |
| โ c : Fin (2*n ฮต) โ TriCylinder, | |
| ExplicitAngularFamily ฮต c โง Covers c โง | |
| |totalArea c/H - (1/2-(13/6000:โ)*ฮต^2)| โค 2*ฮต^4 โง | |
| totalArea c < A_min/2 โง relativeCost c < 1/2 | |
| end TriangularCovering | |
| end | |
| end | |
| run_cmd Lean.modifyEnv fun env => Lean.Meta.auxLemmasExt.setState env {} | |
| section | |
| noncomputable section | |
| open Set MeasureTheory Filter Metric | |
| open scoped Topology ContDiff Pointwise | |
| namespace RuledApproximation | |
| abbrev Plane := EuclideanSpace โ (Fin 2) | |
| abbrev Space := EuclideanSpace โ (Fin 3) | |
| def vec2 (x y : โ) : Plane := WithLp.toLp 2 ![x, y] | |
| def vec3 (x y z : โ) : Space := WithLp.toLp 2 ![x, y, z] | |
| def axial (s : โ) (p : Plane) : Space := vec3 s (p 0) (p 1) | |
| def IsParallelogram {E : Type*} [AddCommGroup E] [Module โ E] (P : Set E) : Prop := | |
| โ c u v : E, LinearIndependent โ ![u, v] โง | |
| P = {x | โ s โ Icc (0 : โ) 1, โ t โ Icc (0 : โ) 1, | |
| x = c + s โข u + t โข v} | |
| structure Cylinder where | |
| axis : Space | |
| unit_axis : โaxisโ = 1 | |
| base : Set ((Submodule.span โ ({axis} : Set Space))แฎ) | |
| namespace Cylinder | |
| def carrier (C : Cylinder) : Set Space := | |
| {x | โ b โ C.base, โ t : โ, x = (b : Space) + t โข C.axis} | |
| def area (C : Cylinder) : โ := volume.real C.base | |
| def parallelogram (C : Cylinder) : Prop := IsParallelogram C.base | |
| def openBounded (C : Cylinder) : Prop := | |
| IsOpen C.base โง Bornology.IsBounded C.base โง MeasurableSet C.base | |
| end Cylinder | |
| def familySet {n : โ} (C : Fin n โ Cylinder) : Set Space := โ i, (C i).carrier | |
| def familyArea {n : โ} (C : Fin n โ Cylinder) : โ := โ i, (C i).area | |
| def HasFiniteCover (shape : Cylinder โ Prop) (S : Set Space) (A : โ) : Prop := | |
| โ n : โ, โ C : Fin n โ Cylinder, | |
| (โ i, shape (C i)) โง S โ familySet C โง familyArea C โค A | |
| def SmoothNear (n : WithTop โโ) (D : Set Plane) (v : Plane โ Plane) : Prop := | |
| โ U : Set Plane, IsOpen U โง D โ U โง ContDiffOn โ n v U | |
| def HyperbolicAt (L : โ) (v : Plane โ Plane) (p : Plane) : Prop := | |
| โ lam : โ, 0 < L * lam โง L * lam < 1 โง | |
| Module.End.HasEigenvalue (fderiv โ v p).toLinearMap lam โง | |
| Module.End.HasEigenvalue (fderiv โ v p).toLinearMap (-lam) | |
| def weight (v : Plane) : โ := 1 / Real.sqrt (1 + โvโ ^ 2) | |
| def physicalWeight (h : โ) (w : Plane) : โ := | |
| 1 / Real.sqrt (1 + w 0 ^ 2 + h ^ 2 * w 1 ^ 2) | |
| def ruled (D : Set Plane) (v : Plane โ Plane) (L : โ) : Set Space := | |
| {z | โ p โ D, โ r : โ, |r| โค L โง | |
| z = vec3 (p 0 + r * v p 0) (p 1 + r * v p 1) r} | |
| def physicalRuled (h : โ) (D : Set Plane) (v : Plane โ Plane) (L : โ) : Set Space := | |
| {z | โ p โ D, โ s : โ, |s| โค L โง | |
| z = vec3 s (p 0 + s * v p 0) (h * (p 1 + s * v p 1))} | |
| def HyperbolicStatement : Prop := | |
| โ (D : Set Plane) (v : Plane โ Plane) (L : โ), | |
| IsCompact D โ SmoothNear 1 D v โ 0 < L โ | |
| (โ p โ D, HyperbolicAt L v p) โ | |
| โ e : โ, 0 < e โ HasFiniteCover Cylinder.parallelogram (ruled D v L) | |
| ((โซ p in D, weight (v p)) + e) | |
| def unitSquare : Set Plane := {x | โ i, |x i| โค (1 : โ) / 2} | |
| def IsSquareTile (T : Set Plane) : Prop := | |
| โ c : Plane, โ R : Plane โโแตข[โ] Plane, โ a : โ, 0 < a โง | |
| T = (fun x => c + a โข R x) '' unitSquare | |
| def auxiliaryCylinder (T : Set Plane) (g : Plane) : Set Space := | |
| {z | โ s : โ, โ b โ T, z = axial s (b + s โข g)} | |
| def firstPhysicalMap (h : โ) (z : Space) : Space := vec3 (z 0) (z 1) (h * z 2) | |
| def secondPhysicalMap (h a : โ) (z : Space) : Space := | |
| vec3 (z 1) (z 0) (h * (a - z 2)) | |
| end RuledApproximation | |
| end | |
| end | |
| run_cmd Lean.modifyEnv fun env => Lean.Meta.auxLemmasExt.setState env {} | |
| section | |
| noncomputable section | |
| open Set MeasureTheory | |
| open scoped InnerProductSpace | |
| namespace CylinderCovering | |
| abbrev Space := EuclideanSpace โ (Fin 3) | |
| def IsRegularTetrahedron (K : Set Space) : Prop := | |
| โ v : Fin 4 โ Space, AffineIndependent โ v โง | |
| โ edge : โ, 0 < edge โง | |
| (โ i j : Fin 4, i โ j โ dist (v i) (v j) = edge) โง | |
| K = convexHull โ (range v) | |
| def shadowArea (K : Set Space) (u : Space) : โ := | |
| TriangularCovering.area (TriangularCovering.projection u '' K) | |
| def minimumShadowArea (K : Set Space) : โ := | |
| sInf {a : โ | โ u : Space, โuโ = 1 โง a = shadowArea K u} | |
| def triangularCovers {n : โ} (K : Set Space) | |
| (C : Fin n โ TriangularCovering.TriCylinder) : Prop := | |
| โ x โ K, โ i : Fin n, x โ (C i).carrier | |
| def triangularRelativeCost {n : โ} (K : Set Space) | |
| (C : Fin n โ TriangularCovering.TriCylinder) : โ := | |
| โ i, TriangularCovering.area (C i).base / shadowArea K (C i).axis | |
| def relativeCost {n : โ} (K : Set Space) | |
| (C : Fin n โ RuledApproximation.Cylinder) : โ := | |
| โ i, (C i).area / shadowArea K (C i).axis | |
| def AngularExplicitStatement : Prop := | |
| TriangularCovering.AngularAreaStatement โง TriangularCovering.ExplicitAngularStatement | |
| def RegularTriangularCounterexampleStatement : Prop := | |
| โ K : Set Space, IsRegularTetrahedron K โ | |
| โ n : โ, โ C : Fin n โ TriangularCovering.TriCylinder, | |
| triangularCovers K C โง | |
| TriangularCovering.totalArea C < minimumShadowArea K / 2 โง | |
| triangularRelativeCost K C < 1 / 2 | |
| def RegularParallelogramCounterexampleStatement : Prop := | |
| โ K : Set Space, IsRegularTetrahedron K โ | |
| โ n : โ, โ C : Fin n โ RuledApproximation.Cylinder, | |
| (โ i, (C i).parallelogram) โง | |
| K โ RuledApproximation.familySet C โง | |
| RuledApproximation.familyArea C < minimumShadowArea K / 2 โง | |
| relativeCost K C < 1 / 2 | |
| def RegularOpenCounterexampleStatement : Prop := | |
| โ K : Set Space, IsRegularTetrahedron K โ | |
| โ n : โ, โ C : Fin n โ RuledApproximation.Cylinder, | |
| (โ i, (C i).openBounded) โง | |
| K โ RuledApproximation.familySet C โง | |
| RuledApproximation.familyArea C < minimumShadowArea K / 2 โง | |
| relativeCost K C < 1 / 2 | |
| end CylinderCovering | |
| end | |
| end | |
| run_cmd Lean.modifyEnv fun env => Lean.Meta.auxLemmasExt.setState env {} | |
| section | |
| noncomputable section | |
| open Set MeasureTheory Filter | |
| open scoped Topology ContDiff | |
| namespace RuledApproximation | |
| def NilpotentC1Statement : Prop := | |
| โ (D : Set Plane) (G : Plane โ Plane), IsCompact D โ SmoothNear 1 D G โ | |
| (โ b โ D, (fderiv โ G b).comp (fderiv โ G b) = 0) โ | |
| โ h eps : โ, 0 < h โ 0 < eps โ | |
| โ n : โ, โ T : Fin n โ Set Plane, โ g : Fin n โ Plane, | |
| (โ i, IsSquareTile (T i)) โง | |
| physicalRuled 1 D G 1 โ โ i, auxiliaryCylinder (T i) (g i) โง | |
| (โ i, volume.real (T i) * physicalWeight h (g i)) โค | |
| (โซ b in D, physicalWeight h (G b)) + eps โง | |
| โ a : โ, โ Cโ Cโ : Fin n โ Cylinder, | |
| (โ i, (Cโ i).parallelogram โง (Cโ i).parallelogram โง | |
| (Cโ i).carrier = firstPhysicalMap h '' auxiliaryCylinder (T i) (g i) โง | |
| (Cโ i).carrier = secondPhysicalMap h a '' auxiliaryCylinder (T i) (g i) โง | |
| (Cโ i).area = h * volume.real (T i) * physicalWeight h (g i) โง | |
| (Cโ i).area = h * volume.real (T i) * physicalWeight h (g i)) | |
| end RuledApproximation | |
| end | |
| end | |
| run_cmd Lean.modifyEnv fun env => Lean.Meta.auxLemmasExt.setState env {} | |
| section | |
| noncomputable section | |
| namespace CylinderCovering.RadialRiemann | |
| open Set | |
| def step (a b : โ) (N : โ) : โ := (b - a) / N | |
| def point (a b : โ) (N i : โ) : โ := a + i * step a b N | |
| def cell (a b : โ) (N : โ) (i : Fin N) : Set โ := | |
| Icc (point a b N i) (point a b N (i + 1)) | |
| def IsTagged (a b : โ) (N : โ) (tag : Fin N โ โ) : Prop := | |
| โ i, tag i โ cell a b N i | |
| def capMax (R : โ โ โ) (a b : โ) (N : โ) (i : Fin N) : โ := | |
| sSup (R '' cell a b N i) | |
| end CylinderCovering.RadialRiemann | |
| end | |
| end | |
| run_cmd Lean.modifyEnv fun env => Lean.Meta.auxLemmasExt.setState env {} | |
| section | |
| open Set MeasureTheory Filter | |
| open scoped InnerProductSpace Topology | |
| noncomputable section | |
| namespace CylinderCovering.RadialSweep | |
| abbrev Space := TriangularCovering.Space | |
| structure Data where | |
| e : Space | |
| a : Space | |
| b : Space | |
| pโ : Space | |
| ฮฑ : โ | |
| ฮฒ : โ | |
| L : โ | |
| R : โ โ โ | |
| lam : โ โ โ | |
| w : โ โ Space | |
| interval_nonempty : ฮฑ < ฮฒ | |
| length_pos : 0 < L | |
| normal_unit : โeโ = 1 | |
| a_perp : inner โ e a = 0 | |
| b_perp : inner โ e b = 0 | |
| origin_perp : inner โ e pโ = 0 | |
| independent : LinearIndependent โ ![a, b] | |
| cap_continuous : ContinuousOn R (Icc ฮฑ ฮฒ) | |
| cap_nonneg : โ t โ Icc ฮฑ ฮฒ, 0 โค R t | |
| scalar_continuous : ContinuousOn lam (Icc ฮฑ ฮฒ) | |
| velocity_continuous : ContinuousOn w (Icc ฮฑ ฮฒ) | |
| velocity_perp : โ t โ Icc ฮฑ ฮฒ, inner โ e (w t) = 0 | |
| aligned : โ t โ Icc ฮฑ ฮฒ, | |
| HasDerivWithinAt w (lam t โข (a + t โข b)) (Icc ฮฑ ฮฒ) t | |
| def sweep (D : Data) : Set Space := | |
| {z | โ t โ Icc D.ฮฑ D.ฮฒ, โ ฯ โ Icc (0 : โ) (D.R t), | |
| โ s : โ, |s| โค D.L โง | |
| z = D.pโ + ฯ โข (D.a + t โข D.b) + s โข (D.e + D.w t)} | |
| def kappa (D : Data) : โ := | |
| Real.sqrt (inner โ D.a D.a * inner โ D.b D.b - (inner โ D.a D.b) ^ 2) | |
| def direction (D : Data) (t : โ) : Space := | |
| โD.e + D.w tโโปยน โข (D.e + D.w t) | |
| def weightedArea (D : Data) : โ := | |
| kappa D * โซ t in D.ฮฑ..D.ฮฒ, | |
| D.R t ^ 2 / (2 * Real.sqrt (1 + โD.w tโ ^ 2)) | |
| def scalarBound (D : Data) : โ := sSup ((fun t => |D.lam t|) '' Icc D.ฮฑ D.ฮฒ) | |
| def radialError (D : Data) : โ := D.L * scalarBound D | |
| def collar (D : Data) : โ := 3 * radialError D + 1 | |
| def midpoint (D : Data) (N : โ) (i : Fin N) : โ := | |
| (RadialRiemann.point D.ฮฑ D.ฮฒ N i + RadialRiemann.point D.ฮฑ D.ฮฒ N (i + 1)) / 2 | |
| def leftTip (D : Data) (N : โ) : โ := -collar D * RadialRiemann.step D.ฮฑ D.ฮฒ N | |
| def rightEdge (D : Data) (N : โ) (i : Fin N) : โ := | |
| RadialRiemann.capMax D.R D.ฮฑ D.ฮฒ N i + radialError D * RadialRiemann.step D.ฮฑ D.ฮฒ N | |
| def coordinateMap (D : Data) (p : โ ร โ) : Space := D.pโ + p.1 โข D.a + p.2 โข D.b | |
| def frozenVertices (D : Data) (N : โ) (i : Fin N) : Fin 3 โ Space := | |
| let l := leftTip D N | |
| let r := rightEdge D N i | |
| let m := midpoint D N i | |
| let d := RadialRiemann.step D.ฮฑ D.ฮฒ N | |
| ![coordinateMap D (l, m * l), | |
| coordinateMap D (r, m * r - d / 2 * (r - l)), | |
| coordinateMap D (r, m * r + d / 2 * (r - l))] | |
| def frozenTriangle (D : Data) (N : โ) (i : Fin N) : Set Space := | |
| convexHull โ (Set.range (frozenVertices D N i)) | |
| def frozenBase (D : Data) (N : โ) (tag : Fin N โ โ) (i : Fin N) : Set Space := | |
| TriangularCovering.projection (direction D (tag i)) '' frozenTriangle D N i | |
| def frozenArea (D : Data) (N : โ) (tag : Fin N โ โ) (i : Fin N) : โ := | |
| kappa D * RadialRiemann.step D.ฮฑ D.ฮฒ N * | |
| (RadialRiemann.capMax D.R D.ฮฑ D.ฮฒ N i + | |
| (radialError D + collar D) * RadialRiemann.step D.ฮฑ D.ฮฒ N) ^ 2 / | |
| (2 * Real.sqrt (1 + โD.w (tag i)โ ^ 2)) | |
| def localSweep (D : Data) (N : โ) (i : Fin N) : Set Space := | |
| {z | โ t โ RadialRiemann.cell D.ฮฑ D.ฮฒ N i, | |
| โ ฯ โ Icc (0 : โ) (D.R t), โ s : โ, |s| โค D.L โง | |
| z = D.pโ + ฯ โข (D.a + t โข D.b) + s โข (D.e + D.w t)} | |
| def actualBase (D : Data) (N : โ) (tag : Fin N โ โ) (i : Fin N) : Set Space := | |
| TriangularCovering.projection (direction D (tag i)) '' localSweep D N i | |
| def cylinder (u : Space) (B : Set Space) : Set Space := | |
| {z | โ b โ B, โ s : โ, z = b + s โข u} | |
| def actualCost (D : Data) (N : โ) (tag : Fin N โ โ) : โ := | |
| โ i : Fin N, TriangularCovering.area (actualBase D N tag i) | |
| def AlignedStatement : Prop := | |
| โ D : Data, โ tag : (N : โ) โ Fin N โ โ, | |
| (โ N, RadialRiemann.IsTagged D.ฮฑ D.ฮฒ N (tag N)) โ | |
| โ C : (N : โ) โ Fin N โ TriangularCovering.TriCylinder, | |
| (โ N, 0 < N โ | |
| (โ i, (C N i).axis = direction D (tag N i) โง | |
| (C N i).base = frozenBase D N (tag N) i โง | |
| TriangularCovering.area (C N i).base = frozenArea D N (tag N) i) โง | |
| (โ z โ sweep D, โ i : Fin N, z โ (C N i).carrier)) โง | |
| Tendsto (fun N => TriangularCovering.totalArea (C N)) atTop (๐ (weightedArea D)) | |
| def ActualSweepStatement : Prop := | |
| โ D : Data, โ tag : (N : โ) โ Fin N โ โ, | |
| (โ N, RadialRiemann.IsTagged D.ฮฑ D.ฮฒ N (tag N)) โ | |
| (โ N, 0 < N โ | |
| (โ i : Fin N, โdirection D (tag N i)โ = 1 โง | |
| IsCompact (actualBase D N (tag N) i) โง | |
| MeasurableSet (actualBase D N (tag N) i) โง | |
| Measure.euclideanHausdorffMeasure 2 (actualBase D N (tag N) i) โ โค โง | |
| (โ z โ actualBase D N (tag N) i, inner โ (direction D (tag N i)) z = 0) โง | |
| actualBase D N (tag N) i โ frozenBase D N (tag N) i) โง | |
| (โ z โ sweep D, โ i : Fin N, | |
| z โ cylinder (direction D (tag N i)) (actualBase D N (tag N) i))) โง | |
| (โ ฮต : โ, 0 < ฮต โ โแถ N in atTop, actualCost D N (tag N) โค weightedArea D + ฮต) โง | |
| Filter.limsup (fun N => actualCost D N (tag N)) atTop โค weightedArea D | |
| end CylinderCovering.RadialSweep | |
| end | |
| end | |
| namespace CylinderCovering | |
| theorem fourPaperMain : | |
| AngularExplicitStatement โง | |
| RuledApproximation.HyperbolicStatement โง | |
| RuledApproximation.NilpotentC1Statement โง | |
| RegularParallelogramCounterexampleStatement โง | |
| RegularOpenCounterexampleStatement โง | |
| RadialSweep.AlignedStatement โง | |
| RadialSweep.ActualSweepStatement := by | |
| sorry | |
| end CylinderCovering | |
| end OAI | |