File: Mathlib/Analysis/BoxIntegral/Partition/Additive.lean

full_name: BoxIntegral.BoxAdditiveMap.sum_partition_boxes'
code: /-- A function on `Box ι` is called box additive if for every box `J` and a partition `π` of `J`
we have `f J = ∑ Ji ∈ π.boxes, f Ji`. A function is called box additive on subboxes of `I : Box ι`
if the same property holds for `J ≤ I`. We formalize these two notions in the same definition
using `I : WithBot (Box ι)`: the value `I = ⊤` corresponds to functions box additive on the whole
space. -/
structure BoxAdditiveMap (ι M : Type*) [AddCommMonoid M] (I : WithTop (Box ι)) where
  /-- The function underlying this additive map. -/
  toFun : Box ι → M
  sum_partition_boxes' : ∀ J : Box ι, ↑J ≤ I → ∀ π : Prepartition J, π.IsPartition →
    ∑ Ji ∈ π.boxes, toFun Ji = toFun J
goal: ↑J ≤ I → ∀ (π : BoxIntegral.Prepartition J), π.IsPartition → ∑ Ji ∈ π.boxes, self.toFun Ji = self.toFun J

full_name: BoxIntegral.BoxAdditiveMap
code: /-- A function on `Box ι` is called box additive if for every box `J` and a partition `π` of `J`
we have `f J = ∑ Ji ∈ π.boxes, f Ji`. A function is called box additive on subboxes of `I : Box ι`
if the same property holds for `J ≤ I`. We formalize these two notions in the same definition
using `I : WithBot (Box ι)`: the value `I = ⊤` corresponds to functions box additive on the whole
space. -/
structure BoxAdditiveMap (ι M : Type*) [AddCommMonoid M] (I : WithTop (Box ι)) where
  /-- The function underlying this additive map. -/
  toFun : Box ι → M
  sum_partition_boxes' : ∀ J : Box ι, ↑J ≤ I → ∀ π : Prepartition J, π.IsPartition →
    ∑ Ji ∈ π.boxes, toFun Ji = toFun J
goal: Type (max u_3 u_4)

full_name: BoxIntegral.BoxAdditiveMap.toFun
code: /-- A function on `Box ι` is called box additive if for every box `J` and a partition `π` of `J`
we have `f J = ∑ Ji ∈ π.boxes, f Ji`. A function is called box additive on subboxes of `I : Box ι`
if the same property holds for `J ≤ I`. We formalize these two notions in the same definition
using `I : WithBot (Box ι)`: the value `I = ⊤` corresponds to functions box additive on the whole
space. -/
structure BoxAdditiveMap (ι M : Type*) [AddCommMonoid M] (I : WithTop (Box ι)) where
  /-- The function underlying this additive map. -/
  toFun : Box ι → M
  sum_partition_boxes' : ∀ J : Box ι, ↑J ≤ I → ∀ π : Prepartition J, π.IsPartition →
    ∑ Ji ∈ π.boxes, toFun Ji = toFun J
goal: BoxIntegral.Box ι → M

full_name: BoxIntegral.«_aux_Mathlib_Analysis_BoxIntegral_Partition_Additive___macroRules_BoxIntegral_term_→ᵇᵃ__1»
code: /-- A function on `Box ι` is called box additive if for every box `J` and a partition `π` of `J`
we have `f J = ∑ Ji ∈ π.boxes, f Ji`. -/
scoped notation:25 ι " →ᵇᵃ " M => BoxIntegral.BoxAdditiveMap ι M ⊤
goal: Lean.Macro

full_name: BoxIntegral._aux_Mathlib_Analysis_BoxIntegral_Partition_Additive___unexpand_BoxIntegral_BoxAdditiveMap_1
code: /-- A function on `Box ι` is called box additive if for every box `J` and a partition `π` of `J`
we have `f J = ∑ Ji ∈ π.boxes, f Ji`. -/
scoped notation:25 ι " →ᵇᵃ " M => BoxIntegral.BoxAdditiveMap ι M ⊤
goal: Lean.PrettyPrinter.Unexpander

full_name: BoxIntegral._aux_Mathlib_Analysis_BoxIntegral_Partition_Additive___unexpand_BoxIntegral_BoxAdditiveMap_2
code: @[inherit_doc] scoped notation:25 ι " →ᵇᵃ[" I "] " M => BoxIntegral.BoxAdditiveMap ι M I
goal: Lean.PrettyPrinter.Unexpander

full_name: BoxIntegral.«_aux_Mathlib_Analysis_BoxIntegral_Partition_Additive___macroRules_BoxIntegral_term_→ᵇᵃ[_]__1»
code: @[inherit_doc] scoped notation:25 ι " →ᵇᵃ[" I "] " M => BoxIntegral.BoxAdditiveMap ι M I
goal: Lean.Macro

full_name: BoxIntegral.BoxAdditiveMap.instFunLikeBox
code: instance : FunLike (ι →ᵇᵃ[I₀] M) (Box ι) M 
goal: FunLike (BoxIntegral.BoxAdditiveMap ι M I₀) (BoxIntegral.Box ι) M

full_name: BoxIntegral.BoxAdditiveMap.coe_mk
code: @[simp]
theorem coe_mk (f h) : ⇑(mk f h : ι →ᵇᵃ[I₀] M) = f 
goal: ⇑{ toFun := f, sum_partition_boxes' := h } = f

full_name: BoxIntegral.BoxAdditiveMap.coe_injective
code: theorem coe_injective : Injective fun (f : ι →ᵇᵃ[I₀] M) x => f x 
goal: Function.Injective fun f x => f x

full_name: BoxIntegral.BoxAdditiveMap.coe_inj
code: theorem coe_inj {f g : ι →ᵇᵃ[I₀] M} : (f : Box ι → M) = g ↔ f = g 
goal: ⇑f = ⇑g ↔ f = g

full_name: BoxIntegral.BoxAdditiveMap.sum_partition_boxes
code: theorem sum_partition_boxes (f : ι →ᵇᵃ[I₀] M) (hI : ↑I ≤ I₀) {π : Prepartition I}
    (h : π.IsPartition) : ∑ J ∈ π.boxes, f J = f I 
goal: ∑ J ∈ π.boxes, f J = f I

full_name: BoxIntegral.BoxAdditiveMap.instZero
code: @[simps (config := .asFn)]
instance : Zero (ι →ᵇᵃ[I₀] M) 
goal: Zero (BoxIntegral.BoxAdditiveMap ι M I₀)

full_name: BoxIntegral.BoxAdditiveMap.instZero_zero_apply
code: @[simps (config := .asFn)]
instance : Zero (ι →ᵇᵃ[I₀] M) 
goal: ⇑0 = 0

full_name: BoxIntegral.BoxAdditiveMap.instInhabited
code: instance : Inhabited (ι →ᵇᵃ[I₀] M) 
goal: Inhabited (BoxIntegral.BoxAdditiveMap ι M I₀)

full_name: BoxIntegral.BoxAdditiveMap.instAdd
code: instance : Add (ι →ᵇᵃ[I₀] M) 
goal: Add (BoxIntegral.BoxAdditiveMap ι M I₀)

full_name: BoxIntegral.BoxAdditiveMap.instSMulOfDistribMulAction
code: instance {R} [Monoid R] [DistribMulAction R M] : SMul R (ι →ᵇᵃ[I₀] M) 
goal: SMul R (BoxIntegral.BoxAdditiveMap ι M I₀)

full_name: BoxIntegral.BoxAdditiveMap.instAddCommMonoid
code: instance : AddCommMonoid (ι →ᵇᵃ[I₀] M) 
goal: AddCommMonoid (BoxIntegral.BoxAdditiveMap ι M I₀)

full_name: BoxIntegral.BoxAdditiveMap.map_split_add
code: @[simp]
theorem map_split_add (f : ι →ᵇᵃ[I₀] M) (hI : ↑I ≤ I₀) (i : ι) (x : ℝ) :
    (I.splitLower i x).elim' 0 f + (I.splitUpper i x).elim' 0 f = f I 
goal: Option.elim' 0 (⇑f) (I.splitLower i x) + Option.elim' 0 (⇑f) (I.splitUpper i x) = f I

full_name: BoxIntegral.BoxAdditiveMap.restrict
code: /-- If `f` is box-additive on subboxes of `I₀`, then it is box-additive on subboxes of any
`I ≤ I₀`. -/
@[simps]
def restrict (f : ι →ᵇᵃ[I₀] M) (I : WithTop (Box ι)) (hI : I ≤ I₀) : ι →ᵇᵃ[I] M 
goal: BoxIntegral.BoxAdditiveMap ι M I

full_name: BoxIntegral.BoxAdditiveMap.restrict_apply
code: /-- If `f` is box-additive on subboxes of `I₀`, then it is box-additive on subboxes of any
`I ≤ I₀`. -/
@[simps]
def restrict (f : ι →ᵇᵃ[I₀] M) (I : WithTop (Box ι)) (hI : I ≤ I₀) : ι →ᵇᵃ[I] M 
goal: (f.restrict I hI) a = f a

full_name: BoxIntegral.BoxAdditiveMap.ofMapSplitAdd
code: /-- If `f : Box ι → M` is box additive on partitions of the form `split I i x`, then it is box
additive. -/
def ofMapSplitAdd [Finite ι] (f : Box ι → M) (I₀ : WithTop (Box ι))
    (hf : ∀ I : Box ι, ↑I ≤ I₀ → ∀ {i x}, x ∈ Ioo (I.lower i) (I.upper i) →
      (I.splitLower i x).elim' 0 f + (I.splitUpper i x).elim' 0 f = f I) :
    ι →ᵇᵃ[I₀] M 
goal: BoxIntegral.BoxAdditiveMap ι M I₀

full_name: BoxIntegral.BoxAdditiveMap.map_apply
code: /-- If `g : M → N` is an additive map and `f` is a box additive map, then `g ∘ f` is a box additive
map. -/
@[simps (config := .asFn)]
def map (f : ι →ᵇᵃ[I₀] M) (g : M →+ N) : ι →ᵇᵃ[I₀] N 
goal: ⇑(f.map g) = ⇑g ∘ ⇑f

full_name: BoxIntegral.BoxAdditiveMap.map
code: /-- If `g : M → N` is an additive map and `f` is a box additive map, then `g ∘ f` is a box additive
map. -/
@[simps (config := .asFn)]
def map (f : ι →ᵇᵃ[I₀] M) (g : M →+ N) : ι →ᵇᵃ[I₀] N 
goal: BoxIntegral.BoxAdditiveMap ι N I₀

full_name: BoxIntegral.BoxAdditiveMap.sum_boxes_congr
code: /-- If `f` is a box additive function on subboxes of `I` and `π₁`, `π₂` are two prepartitions of
`I` that cover the same part of `I`, then `∑ J ∈ π₁.boxes, f J = ∑ J ∈ π₂.boxes, f J`. -/
theorem sum_boxes_congr [Finite ι] (f : ι →ᵇᵃ[I₀] M) (hI : ↑I ≤ I₀) {π₁ π₂ : Prepartition I}
    (h : π₁.iUnion = π₂.iUnion) : ∑ J ∈ π₁.boxes, f J = ∑ J ∈ π₂.boxes, f J 
goal: ∑ J ∈ π₁.boxes, f J = ∑ J ∈ π₂.boxes, f J

full_name: BoxIntegral.BoxAdditiveMap.toSMul
code: /-- If `f` is a box-additive map, then so is the map sending `I` to the scalar multiplication
by `f I` as a continuous linear map from `E` to itself. -/
def toSMul (f : ι →ᵇᵃ[I₀] ℝ) : ι →ᵇᵃ[I₀] E →L[ℝ] E 
goal: BoxIntegral.BoxAdditiveMap ι (E →L[ℝ] E) I₀

full_name: BoxIntegral.BoxAdditiveMap.toSMul_apply
code: @[simp]
theorem toSMul_apply (f : ι →ᵇᵃ[I₀] ℝ) (I : Box ι) (x : E) : f.toSMul I x = f I • x 
goal: (f.toSMul I) x = f I • x

full_name: BoxIntegral.BoxAdditiveMap.upperSubLower_apply
code: /-- Given a box `I₀` in `ℝⁿ⁺¹`, `f x : Box (Fin n) → G` is a family of functions indexed by a real
`x` and for `x ∈ [I₀.lower i, I₀.upper i]`, `f x` is box-additive on subboxes of the `i`-th face of
`I₀`, then `fun J ↦ f (J.upper i) (J.face i) - f (J.lower i) (J.face i)` is box-additive on subboxes
of `I₀`. -/
@[simps!]
def upperSubLower.{u} {G : Type u} [AddCommGroup G] (I₀ : Box (Fin (n + 1))) (i : Fin (n + 1))
    (f : ℝ → Box (Fin n) → G) (fb : Icc (I₀.lower i) (I₀.upper i) → Fin n →ᵇᵃ[I₀.face i] G)
    (hf : ∀ (x) (hx : x ∈ Icc (I₀.lower i) (I₀.upper i)) (J), f x J = fb ⟨x, hx⟩ J) :
    Fin (n + 1) →ᵇᵃ[I₀] G 
goal: (BoxIntegral.BoxAdditiveMap.upperSubLower I₀ i f fb hf) J = f (J.upper i) (J.face i) - f (J.lower i) (J.face i)

full_name: BoxIntegral.BoxAdditiveMap.upperSubLower
code: /-- Given a box `I₀` in `ℝⁿ⁺¹`, `f x : Box (Fin n) → G` is a family of functions indexed by a real
`x` and for `x ∈ [I₀.lower i, I₀.upper i]`, `f x` is box-additive on subboxes of the `i`-th face of
`I₀`, then `fun J ↦ f (J.upper i) (J.face i) - f (J.lower i) (J.face i)` is box-additive on subboxes
of `I₀`. -/
@[simps!]
def upperSubLower.{u} {G : Type u} [AddCommGroup G] (I₀ : Box (Fin (n + 1))) (i : Fin (n + 1))
    (f : ℝ → Box (Fin n) → G) (fb : Icc (I₀.lower i) (I₀.upper i) → Fin n →ᵇᵃ[I₀.face i] G)
    (hf : ∀ (x) (hx : x ∈ Icc (I₀.lower i) (I₀.upper i)) (J), f x J = fb ⟨x, hx⟩ J) :
    Fin (n + 1) →ᵇᵃ[I₀] G 
goal: BoxIntegral.BoxAdditiveMap (Fin (n + 1)) G ↑I₀