File size: 3,240 Bytes
4a56cd6
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
import OAI.Geometry.TriangularCovering.Basic
import OAI.Geometry.CylinderCovering.Radial.RiemannDefinitions

namespace OAI

noncomputable section
namespace CylinderCovering.UnitEdgeFootprints

abbrev Space := TriangularCovering.Space

def height : ℝ := 1 / Real.sqrt 2

def intercept (u v : ℝ) : Space := !β‚‚[0, v, height * u]

def rawDirection (Ξ· m : ℝ) : Space :=
  !β‚‚[1, Ξ· * (1 / 4 + m ^ 2), 2 * height * Ξ· * m]

def axis (Ξ· m : ℝ) : Space := β€–rawDirection Ξ· m‖⁻¹ β€’ rawDirection Ξ· m

def vertices (Ξ· d M m : ℝ) : Fin 3 β†’ Space :=
  ![intercept (-Ξ· * d) (m * (-Ξ· * d)),
    intercept (M + Ξ· * d) (m * (M + Ξ· * d) - d / 2 * (M + 2 * Ξ· * d)),
    intercept (M + Ξ· * d) (m * (M + Ξ· * d) + d / 2 * (M + 2 * Ξ· * d))]

def foot (Ξ· d M m : ℝ) : Set Space := convexHull ℝ (Set.range (vertices Ξ· d M m))

def base (Ξ· d M m : ℝ) : Set Space :=
  TriangularCovering.projection (axis Ξ· m) '' foot Ξ· d M m

def representedPoint (Ξ· s ρ x : ℝ) : Space :=
  !β‚‚[x, s * ρ + Ξ· * x * (1 / 4 + s ^ 2), height * (ρ + 2 * Ξ· * x * s)]

def areaFormula (Ξ· d M m : ℝ) : ℝ :=
  height * d * (M + 2 * Ξ· * d) ^ 2 /
    (2 * Real.sqrt (1 + Ξ· ^ 2 * ((1 / 4 + m ^ 2) ^ 2 + 2 * m ^ 2)))

def LocalRealizationStatement : Prop :=
  βˆ€ Ξ· d M m : ℝ, 0 < Ξ· β†’ 0 < d β†’ 0 ≀ M β†’
    βˆƒ C : TriangularCovering.TriCylinder,
      C.axis = axis η m ∧ C.base = base η d M m ∧
      TriangularCovering.area C.base = areaFormula η d M m ∧
      βˆ€ s ρ x : ℝ, |s - m| ≀ d / 2 β†’ 0 ≀ ρ β†’ ρ ≀ M β†’ |x| ≀ 1 / 2 β†’
        representedPoint η s ρ x ∈ C.carrier

def sourceCap (Ξ· s : ℝ) : ℝ :=
  Real.sqrt (1 / 4 + Ξ· ^ 2 * (s ^ 2 / 4 + s ^ 4 + 1 / 960))

def sweep (Ξ· : ℝ) (R : ℝ β†’ ℝ) : Set Space :=
  {z | βˆƒ s ∈ Set.Icc (-1 / 2 : ℝ) (1 / 2), βˆƒ ρ ∈ Set.Icc (0 : ℝ) (R s),
    βˆƒ x : ℝ, |x| ≀ 1 / 2 ∧ z = representedPoint Ξ· s ρ x}

def mesh (N : β„•) : ℝ := RadialRiemann.step (-1 / 2) (1 / 2) N

def midpoint (N : β„•) (i : Fin N) : ℝ :=
  (RadialRiemann.point (-1 / 2) (1 / 2) N i +
    RadialRiemann.point (-1 / 2) (1 / 2) N (i + 1)) / 2

def maximumCap (R : ℝ β†’ ℝ) (N : β„•) (i : Fin N) : ℝ :=
  RadialRiemann.capMax R (-1 / 2) (1 / 2) N i

def limitingArea (Ξ· : ℝ) (R : ℝ β†’ ℝ) : ℝ :=
  height * ∫ s in (-1 / 2 : ℝ)..(1 / 2),
    R s ^ 2 / (2 * Real.sqrt (1 + Ξ· ^ 2 * ((1 / 4 + s ^ 2) ^ 2 + 2 * s ^ 2)))

def FamilyRealizationStatement : Prop :=
  βˆ€ Ξ· : ℝ, 0 < Ξ· β†’ βˆ€ R : ℝ β†’ ℝ,
    ContinuousOn R (Set.Icc (-1 / 2 : ℝ) (1 / 2)) β†’
    (βˆ€ s ∈ Set.Icc (-1 / 2 : ℝ) (1 / 2), 0 ≀ R s) β†’
    βˆƒ C : (N : β„•) β†’ Fin N β†’ TriangularCovering.TriCylinder,
      (βˆ€ N (i : Fin N),
        (C N i).axis = axis η (midpoint N i) ∧
        (C N i).base = base η (mesh N) (maximumCap R N i) (midpoint N i) ∧
        TriangularCovering.area (C N i).base =
          areaFormula η (mesh N) (maximumCap R N i) (midpoint N i)) ∧
      (βˆ€ N, 0 < N β†’ βˆ€ z ∈ sweep Ξ· R, βˆƒ i : Fin N, z ∈ (C N i).carrier) ∧
      Filter.Tendsto (fun N => TriangularCovering.totalArea (C N)) Filter.atTop
        (nhds (limitingArea Ξ· R))

end CylinderCovering.UnitEdgeFootprints

end

end OAI