| import Mathlib.Combinatorics.SimpleGraph.Walk.Operations |
| import Mathlib.Algebra.Order.Archimedean.Real.Basic |
| import Mathlib.Tactic.Linarith |
| import Mathlib.Tactic.Ring |
|
|
| namespace OAI |
|
|
| namespace CompanionFPP |
|
|
| variable {V : Type*} {G : SimpleGraph V} |
|
|
| abbrev Weights (G : SimpleGraph V) := G.edgeSet → ℝ |
|
|
| def edgeCost (w : Weights G) {x y : V} (h : G.Adj x y) : ℝ := |
| w ⟨s(x, y), h⟩ |
|
|
| @[simp] theorem edgeCost_symm (w : Weights G) {x y : V} (h : G.Adj x y) : |
| edgeCost w h.symm = edgeCost w h := by |
| simp only [edgeCost, Sym2.eq_swap] |
|
|
| def pathCost (w : Weights G) {x y : V} : G.Walk x y → ℝ |
| | .nil => 0 |
| | .cons h p => edgeCost w h + pathCost w p |
|
|
| @[simp] theorem pathCost_nil (w : Weights G) (x : V) : |
| pathCost w (SimpleGraph.Walk.nil : G.Walk x x) = 0 := rfl |
|
|
| @[simp] theorem pathCost_cons (w : Weights G) {x y z : V} |
| (h : G.Adj x y) (p : G.Walk y z) : |
| pathCost w (.cons h p) = edgeCost w h + pathCost w p := rfl |
|
|
| @[simp] theorem pathCost_append (w : Weights G) {x y z : V} |
| (p : G.Walk x y) (q : G.Walk y z) : |
| pathCost w (p.append q) = pathCost w p + pathCost w q := by |
| induction p with |
| | nil => simp |
| | cons h p ih => simp [ih, add_assoc] |
|
|
| theorem pathCost_nonneg (w : Weights G) (hw : ∀ e, 0 ≤ w e) |
| {x y : V} (p : G.Walk x y) : 0 ≤ pathCost w p := by |
| induction p with |
| | nil => exact le_refl 0 |
| | cons h p ih => exact add_nonneg (hw _) ih |
|
|
| noncomputable def passageTime (w : Weights G) (x y : V) : ℝ := |
| sInf (Set.range (fun p : G.Walk x y => pathCost w p)) |
|
|
| theorem passageTime_le_pathCost (w : Weights G) (hw : ∀ e, 0 ≤ w e) |
| {x y : V} (p : G.Walk x y) : passageTime w x y ≤ pathCost w p := by |
| apply csInf_le |
| · exact ⟨0, by rintro _ ⟨q, rfl⟩; exact pathCost_nonneg w hw q⟩ |
| · exact ⟨p, rfl⟩ |
|
|
| @[simp] theorem pathCost_reverse (w : Weights G) {x y : V} (p : G.Walk x y) : |
| pathCost w p.reverse = pathCost w p := by |
| induction p with |
| | nil => simp |
| | cons h p ih => |
| simp [SimpleGraph.Walk.reverse_cons, ih, edgeCost, Sym2.eq_swap, add_comm] |
|
|
| theorem passageTime_nonneg (w : Weights G) (hw : ∀ e, 0 ≤ w e) |
| {x y : V} (hp : Nonempty (G.Walk x y)) : 0 ≤ passageTime w x y := by |
| obtain ⟨p⟩ := hp |
| apply le_csInf (s := Set.range (fun p : G.Walk x y => pathCost w p)) ⟨_, ⟨p, rfl⟩⟩ |
| rintro _ ⟨q, rfl⟩ |
| exact pathCost_nonneg w hw q |
|
|
| @[simp] theorem passageTime_self (w : Weights G) (hw : ∀ e, 0 ≤ w e) (x : V) : |
| passageTime w x x = 0 := by |
| apply le_antisymm |
| · simpa using passageTime_le_pathCost w hw (SimpleGraph.Walk.nil : G.Walk x x) |
| · exact passageTime_nonneg w hw ⟨.nil⟩ |
|
|
| theorem passageTime_symm (w : Weights G) (x y : V) : |
| passageTime w x y = passageTime w y x := by |
| unfold passageTime |
| congr 1 |
| ext t |
| constructor <;> rintro ⟨p, rfl⟩ <;> exact ⟨p.reverse, pathCost_reverse w p⟩ |
|
|
| theorem passageTime_triangle (w : Weights G) (hw : ∀ e, 0 ≤ w e) |
| {x y z : V} (hxy : Nonempty (G.Walk x y)) (hyz : Nonempty (G.Walk y z)) : |
| passageTime w x z ≤ passageTime w x y + passageTime w y z := by |
| obtain ⟨p₀⟩ := hxy |
| obtain ⟨q₀⟩ := hyz |
| suffices h : passageTime w x z - passageTime w x y ≤ passageTime w y z by linarith |
| apply le_csInf (s := Set.range (fun q : G.Walk y z => pathCost w q)) ⟨_, ⟨q₀, rfl⟩⟩ |
| rintro _ ⟨q, rfl⟩ |
| suffices h : passageTime w x z - pathCost w q ≤ passageTime w x y by linarith |
| apply le_csInf (s := Set.range (fun p : G.Walk x y => pathCost w p)) ⟨_, ⟨p₀, rfl⟩⟩ |
| rintro _ ⟨p, rfl⟩ |
| have h := passageTime_le_pathCost w hw (p.append q) |
| rw [pathCost_append] at h |
| linarith |
|
|
| structure Calibration (w : Weights G) where |
| B : V → V → ℝ |
| additive : ∀ x y z, B x z = B x y + B y z |
| edge_le : ∀ {x y}, (h : G.Adj x y) → B x y ≤ edgeCost w h |
|
|
| namespace Calibration |
| variable {w : Weights G} (b : Calibration w) |
|
|
| @[simp] theorem self (x : V) : b.B x x = 0 := by |
| have h := b.additive x x x |
| linarith |
|
|
| @[simp] theorem reverse (x y : V) : b.B y x = -b.B x y := by |
| have h := b.additive x y x |
| rw [b.self] at h |
| linarith |
|
|
| theorem le_pathCost {x y : V} (p : G.Walk x y) : b.B x y ≤ pathCost w p := by |
| induction p with |
| | nil => simp |
| | @cons x y z h p ih => |
| rw [pathCost_cons, b.additive x y z] |
| exact add_le_add (b.edge_le h) ih |
|
|
| def defect {x y : V} (p : G.Walk x y) := pathCost w p - b.B x y |
|
|
| theorem defect_nonneg {x y : V} (p : G.Walk x y) : 0 ≤ b.defect p := |
| sub_nonneg.mpr (b.le_pathCost p) |
|
|
| theorem defect_append {x y z : V} (p : G.Walk x y) (q : G.Walk y z) : |
| b.defect (p.append q) = b.defect p + b.defect q := by |
| simp only [defect, pathCost_append, b.additive x y z] |
| ring |
|
|
| theorem defect_subpath_le {a x y z : V} (p : G.Walk a x) |
| (q : G.Walk x y) (r : G.Walk y z) : |
| b.defect q ≤ b.defect ((p.append q).append r) := by |
| rw [b.defect_append, b.defect_append] |
| have := b.defect_nonneg p |
| have := b.defect_nonneg r |
| linarith |
|
|
| theorem defect_eq_centered (o : V) (h : V → ℝ) {x y : V} (p : G.Walk x y) : |
| b.defect p = (pathCost w p - (h y - h x)) - |
| (b.B o y - h y) + (b.B o x - h x) := by |
| have := b.additive o x y |
| unfold defect |
| linarith |
|
|
| end Calibration |
|
|
| end CompanionFPP |
|
|
| end OAI |
|
|
