formal
stringlengths 41
427k
| informal
stringclasses 1
value |
|---|---|
Turing.PartrecToTM2.copy_ok ** q : Λ' s : Option Γ' a b c d : List Γ' ⊢ Reaches₁ (TM2.step tr) { l := some (Λ'.copy q), var := s, stk := elim a b c d } { l := some q, var := none, stk := elim (List.reverseAux b a) [] c (List.reverseAux b d) } ** induction' b with x b IH generalizing a d s ** case cons q : Λ' s✝ : Option Γ' a✝ c d✝ : List Γ' x : Γ' b : List Γ' IH : ∀ (s : Option Γ') (a d : List Γ'), Reaches₁ (TM2.step tr) { l := some (Λ'.copy q), var := s, stk := elim a b c d } { l := some q, var := none, stk := elim (List.reverseAux b a) [] c (List.reverseAux b d) } s : Option Γ' a d : List Γ' ⊢ Reaches₁ (TM2.step tr) { l := some (Λ'.copy q), var := s, stk := elim a (x :: b) c d } { l := some q, var := none, stk := elim (List.reverseAux (x :: b) a) [] c (List.reverseAux (x :: b) d) } ** refine' TransGen.head rfl _ ** case cons q : Λ' s✝ : Option Γ' a✝ c d✝ : List Γ' x : Γ' b : List Γ' IH : ∀ (s : Option Γ') (a d : List Γ'), Reaches₁ (TM2.step tr) { l := some (Λ'.copy q), var := s, stk := elim a b c d } { l := some q, var := none, stk := elim (List.reverseAux b a) [] c (List.reverseAux b d) } s : Option Γ' a d : List Γ' ⊢ TransGen (fun a b => b ∈ TM2.step tr a) (TM2.stepAux (tr (Λ'.copy q)) s (elim a (x :: b) c d)) { l := some q, var := none, stk := elim (List.reverseAux (x :: b) a) [] c (List.reverseAux (x :: b) d) } ** simp only [TM2.step, Option.mem_def, TM2.stepAux, elim_rev, List.head?_cons, Option.isSome_some,
List.tail_cons, elim_update_rev, ne_eq, Function.update_noteq, elim_main, elim_update_main,
elim_stack, elim_update_stack, cond_true, List.reverseAux_cons] ** case cons q : Λ' s✝ : Option Γ' a✝ c d✝ : List Γ' x : Γ' b : List Γ' IH : ∀ (s : Option Γ') (a d : List Γ'), Reaches₁ (TM2.step tr) { l := some (Λ'.copy q), var := s, stk := elim a b c d } { l := some q, var := none, stk := elim (List.reverseAux b a) [] c (List.reverseAux b d) } s : Option Γ' a d : List Γ' ⊢ TransGen (fun a b => (match a with | { l := none, var := var, stk := stk } => none | { l := some l, var := v, stk := S } => some (TM2.stepAux (tr l) v S)) = some b) { l := some (Λ'.copy q), var := some x, stk := elim (Option.iget (some x) :: a) b c (Option.iget (some x) :: d) } { l := some q, var := none, stk := elim (List.reverseAux b (x :: a)) [] c (List.reverseAux b (x :: d)) } ** exact IH _ _ _ ** case nil q : Λ' s✝ : Option Γ' a✝ c d✝ : List Γ' s : Option Γ' a d : List Γ' ⊢ Reaches₁ (TM2.step tr) { l := some (Λ'.copy q), var := s, stk := elim a [] c d } { l := some q, var := none, stk := elim (List.reverseAux [] a) [] c (List.reverseAux [] d) } ** refine' TransGen.single _ ** case nil q : Λ' s✝ : Option Γ' a✝ c d✝ : List Γ' s : Option Γ' a d : List Γ' ⊢ { l := some q, var := none, stk := elim (List.reverseAux [] a) [] c (List.reverseAux [] d) } ∈ TM2.step tr { l := some (Λ'.copy q), var := s, stk := elim a [] c d } ** simp ** Qed
| |
Turing.PartrecToTM2.trList_ne_consₗ ** a : ℕ l : List ℕ x : Γ' h : x ∈ trList (a :: l) ⊢ x ≠ Γ'.consₗ ** simp [trList] at h ** a : ℕ l : List ℕ x : Γ' h : x ∈ trNat a ∨ x = Γ'.cons ∨ x ∈ trList l ⊢ x ≠ Γ'.consₗ ** obtain h | rfl | h := h ** case inl a : ℕ l : List ℕ x : Γ' h : x ∈ trNat a ⊢ x ≠ Γ'.consₗ ** rintro rfl ** case inl a : ℕ l : List ℕ h : Γ'.consₗ ∈ trNat a ⊢ False ** cases trNat_natEnd _ _ h ** case inr.inl a : ℕ l : List ℕ ⊢ Γ'.cons ≠ Γ'.consₗ ** rintro ⟨⟩ ** case inr.inr a : ℕ l : List ℕ x : Γ' h : x ∈ trList l ⊢ x ≠ Γ'.consₗ ** exact trList_ne_consₗ l _ h ** Qed
| |
Turing.PartrecToTM2.head_main_ok ** q : Λ' s : Option Γ' L : List ℕ c d : List Γ' ⊢ Reaches₁ (TM2.step tr) { l := some (head main q), var := s, stk := elim (trList L) [] c d } { l := some q, var := none, stk := elim (trList [List.headI L]) [] c d } ** let o : Option Γ' := List.casesOn L none fun _ _ => some Γ'.cons ** q : Λ' s : Option Γ' L : List ℕ c d : List Γ' o : Option Γ' := List.casesOn L none fun x x => some Γ'.cons ⊢ Reaches₁ (TM2.step tr) { l := some (head main q), var := s, stk := elim (trList L) [] c d } { l := some q, var := none, stk := elim (trList [List.headI L]) [] c d } ** refine'
(move_ok (by decide)
(splitAtPred_eq _ _ (trNat L.headI) o (trList L.tail) (trNat_natEnd _) _)).trans
(TransGen.head rfl (TransGen.head rfl _)) ** case refine'_2 q : Λ' s : Option Γ' L : List ℕ c d : List Γ' o : Option Γ' := List.casesOn L none fun x x => some Γ'.cons ⊢ TransGen (fun a b => b ∈ TM2.step tr a) (TM2.stepAux (tr ((fun x => Λ'.read fun s => ite (s = some Γ'.consₗ) id (Λ'.clear (fun x => decide (x = Γ'.consₗ)) main) (unrev q)) o)) o (update (update (update (elim (trList L) [] c d) main (trList (List.tail L))) rev (List.reverseAux (trNat (List.headI L)) (elim (trList L) [] c d rev))) rev ((fun s => Option.iget ((fun x => some Γ'.cons) s)) o :: update (update (elim (trList L) [] c d) main (trList (List.tail L))) rev (List.reverseAux (trNat (List.headI L)) (elim (trList L) [] c d rev)) rev))) { l := some q, var := none, stk := elim (trList [List.headI L]) [] c d } ** simp only [TM2.step, Option.mem_def, TM2.stepAux, elim_update_main, elim_rev, elim_update_rev,
Function.update_same, trList] ** case refine'_2 q : Λ' s : Option Γ' L : List ℕ c d : List Γ' o : Option Γ' := List.casesOn L none fun x x => some Γ'.cons ⊢ TransGen (fun a b => (match a with | { l := none, var := var, stk := stk } => none | { l := some l, var := v, stk := S } => some (TM2.stepAux (tr l) v S)) = some b) { l := some (ite (List.rec none (fun head tail tail_ih => some Γ'.cons) L = some Γ'.consₗ) id (Λ'.clear (fun x => decide (x = Γ'.consₗ)) main) (unrev q)), var := List.rec none (fun head tail tail_ih => some Γ'.cons) L, stk := elim (trList (List.tail L)) (Option.iget (some Γ'.cons) :: List.reverseAux (trNat (List.headI L)) []) c d } { l := some q, var := none, stk := elim (trNat (List.headI L) ++ [Γ'.cons]) [] c d } ** rw [if_neg (show o ≠ some Γ'.consₗ by cases L <;> simp)] ** case refine'_2 q : Λ' s : Option Γ' L : List ℕ c d : List Γ' o : Option Γ' := List.casesOn L none fun x x => some Γ'.cons ⊢ TransGen (fun a b => (match a with | { l := none, var := var, stk := stk } => none | { l := some l, var := v, stk := S } => some (TM2.stepAux (tr l) v S)) = some b) { l := some (Λ'.clear (fun x => decide (x = Γ'.consₗ)) main (unrev q)), var := List.rec none (fun head tail tail_ih => some Γ'.cons) L, stk := elim (trList (List.tail L)) (Option.iget (some Γ'.cons) :: List.reverseAux (trNat (List.headI L)) []) c d } { l := some q, var := none, stk := elim (trNat (List.headI L) ++ [Γ'.cons]) [] c d } ** refine' (clear_ok (splitAtPred_eq _ _ _ none [] _ ⟨rfl, rfl⟩)).trans _ ** case refine'_2.refine'_2 q : Λ' s : Option Γ' L : List ℕ c d : List Γ' o : Option Γ' := List.casesOn L none fun x x => some Γ'.cons ⊢ TransGen (fun a b => b ∈ TM2.step tr a) { l := some (unrev q), var := none, stk := update (elim (trList (List.tail L)) (Option.iget (some Γ'.cons) :: List.reverseAux (trNat (List.headI L)) []) c d) main [] } { l := some q, var := none, stk := elim (trNat (List.headI L) ++ [Γ'.cons]) [] c d } ** convert unrev_ok using 2 ** case h.e'_2.h.e'_7 q : Λ' s : Option Γ' L : List ℕ c d : List Γ' o : Option Γ' := List.casesOn L none fun x x => some Γ'.cons ⊢ elim (trNat (List.headI L) ++ [Γ'.cons]) [] c d = update (update (update (elim (trList (List.tail L)) (Option.iget (some Γ'.cons) :: List.reverseAux (trNat (List.headI L)) []) c d) main []) rev []) main (List.reverseAux (update (elim (trList (List.tail L)) (Option.iget (some Γ'.cons) :: List.reverseAux (trNat (List.headI L)) []) c d) main [] rev) (update (elim (trList (List.tail L)) (Option.iget (some Γ'.cons) :: List.reverseAux (trNat (List.headI L)) []) c d) main [] main)) ** simp [List.reverseAux_eq] ** q : Λ' s : Option Γ' L : List ℕ c d : List Γ' o : Option Γ' := List.casesOn L none fun x x => some Γ'.cons ⊢ main ≠ rev ** decide ** case refine'_1 q : Λ' s : Option Γ' L : List ℕ c d : List Γ' o : Option Γ' := List.casesOn L none fun x x => some Γ'.cons ⊢ Option.elim' (elim (trList L) [] c d main = trNat (List.headI L) ∧ trList (List.tail L) = []) (fun a => natEnd a = true ∧ elim (trList L) [] c d main = trNat (List.headI L) ++ a :: trList (List.tail L)) o ** cases L <;> simp ** q : Λ' s : Option Γ' L : List ℕ c d : List Γ' o : Option Γ' := List.casesOn L none fun x x => some Γ'.cons ⊢ o ≠ some Γ'.consₗ ** cases L <;> simp ** case refine'_2.refine'_1 q : Λ' s : Option Γ' L : List ℕ c d : List Γ' o : Option Γ' := List.casesOn L none fun x x => some Γ'.cons ⊢ ∀ (x : Γ'), x ∈ elim (trList (List.tail L)) (Option.iget (some Γ'.cons) :: List.reverseAux (trNat (List.headI L)) []) c d main → decide (x = Γ'.consₗ) = false ** exact fun x h => Bool.decide_false (trList_ne_consₗ _ _ h) ** Qed
| |
Turing.PartrecToTM2.succ_ok ** q : Λ' s : Option Γ' n : ℕ c d : List Γ' ⊢ Reaches₁ (TM2.step tr) { l := some (Λ'.succ q), var := s, stk := elim (trList [n]) [] c d } { l := some q, var := none, stk := elim (trList [Nat.succ n]) [] c d } ** simp only [TM2.step, trList, trNat._eq_1, Nat.cast_succ, Num.add_one] ** q : Λ' s : Option Γ' n : ℕ c d : List Γ' ⊢ Reaches₁ (fun x => match x with | { l := none, var := var, stk := stk } => none | { l := some l, var := v, stk := S } => some (TM2.stepAux (tr l) v S)) { l := some (Λ'.succ q), var := s, stk := elim (trNum ↑n ++ [Γ'.cons]) [] c d } { l := some q, var := none, stk := elim (trNum (Num.succ ↑n) ++ [Γ'.cons]) [] c d } ** cases' (n : Num) with a ** case pos q : Λ' s : Option Γ' n : ℕ c d : List Γ' a : PosNum ⊢ Reaches₁ (fun x => match x with | { l := none, var := var, stk := stk } => none | { l := some l, var := v, stk := S } => some (TM2.stepAux (tr l) v S)) { l := some (Λ'.succ q), var := s, stk := elim (trNum (Num.pos a) ++ [Γ'.cons]) [] c d } { l := some q, var := none, stk := elim (trNum (Num.succ (Num.pos a)) ++ [Γ'.cons]) [] c d } ** simp only [trNum, Num.succ, Num.succ'] ** case pos q : Λ' s : Option Γ' n : ℕ c d : List Γ' a : PosNum ⊢ Reaches₁ (fun x => match x with | { l := none, var := var, stk := stk } => none | { l := some l, var := v, stk := S } => some (TM2.stepAux (tr l) v S)) { l := some (Λ'.succ q), var := s, stk := elim (trPosNum a ++ [Γ'.cons]) [] c d } { l := some q, var := none, stk := elim (trPosNum (PosNum.succ a) ++ [Γ'.cons]) [] c d } ** suffices ∀ l₁, ∃ l₁' l₂' s',
List.reverseAux l₁ (trPosNum a.succ) = List.reverseAux l₁' l₂' ∧
Reaches₁ (TM2.step tr) ⟨some q.succ, s, K'.elim (trPosNum a ++ [Γ'.cons]) l₁ c d⟩
⟨some (unrev q), s', K'.elim (l₂' ++ [Γ'.cons]) l₁' c d⟩ by
obtain ⟨l₁', l₂', s', e, h⟩ := this []
simp [List.reverseAux] at e
refine' h.trans _
convert unrev_ok using 2
simp [e, List.reverseAux_eq] ** case pos q : Λ' s : Option Γ' n : ℕ c d : List Γ' a : PosNum ⊢ ∀ (l₁ : List Γ'), ∃ l₁' l₂' s', List.reverseAux l₁ (trPosNum (PosNum.succ a)) = List.reverseAux l₁' l₂' ∧ Reaches₁ (TM2.step tr) { l := some (Λ'.succ q), var := s, stk := elim (trPosNum a ++ [Γ'.cons]) l₁ c d } { l := some (unrev q), var := s', stk := elim (l₂' ++ [Γ'.cons]) l₁' c d } ** induction' a with m IH m _ generalizing s <;> intro l₁ ** case zero q : Λ' s : Option Γ' n : ℕ c d : List Γ' ⊢ Reaches₁ (fun x => match x with | { l := none, var := var, stk := stk } => none | { l := some l, var := v, stk := S } => some (TM2.stepAux (tr l) v S)) { l := some (Λ'.succ q), var := s, stk := elim (trNum Num.zero ++ [Γ'.cons]) [] c d } { l := some q, var := none, stk := elim (trNum (Num.succ Num.zero) ++ [Γ'.cons]) [] c d } ** refine' TransGen.head rfl _ ** case zero q : Λ' s : Option Γ' n : ℕ c d : List Γ' ⊢ TransGen (fun a b => b ∈ (fun x => match x with | { l := none, var := var, stk := stk } => none | { l := some l, var := v, stk := S } => some (TM2.stepAux (tr l) v S)) a) (TM2.stepAux (tr (Λ'.succ q)) s (elim (trNum Num.zero ++ [Γ'.cons]) [] c d)) { l := some q, var := none, stk := elim (trNum (Num.succ Num.zero) ++ [Γ'.cons]) [] c d } ** simp only [Option.mem_def, TM2.stepAux, elim_main, decide_False, elim_update_main, ne_eq,
Function.update_noteq, elim_rev, elim_update_rev, decide_True, Function.update_same,
cond_true, cond_false] ** case zero q : Λ' s : Option Γ' n : ℕ c d : List Γ' ⊢ TransGen (fun a b => (match a with | { l := none, var := var, stk := stk } => none | { l := some l, var := v, stk := S } => some (TM2.stepAux (tr l) v S)) = some b) { l := some (unrev q), var := List.head? (trNum Num.zero ++ [Γ'.cons]), stk := elim (Γ'.bit1 :: Γ'.cons :: List.tail (trNum Num.zero ++ [Γ'.cons])) [] c d } { l := some q, var := none, stk := elim (trNum (Num.succ Num.zero) ++ [Γ'.cons]) [] c d } ** convert unrev_ok using 2 ** case h.e'_2.h.e'_7 q : Λ' s : Option Γ' n : ℕ c d : List Γ' ⊢ elim (trNum (Num.succ Num.zero) ++ [Γ'.cons]) [] c d = update (update (elim (Γ'.bit1 :: Γ'.cons :: List.tail (trNum Num.zero ++ [Γ'.cons])) [] c d) rev []) main (List.reverseAux (elim (Γ'.bit1 :: Γ'.cons :: List.tail (trNum Num.zero ++ [Γ'.cons])) [] c d rev) (elim (Γ'.bit1 :: Γ'.cons :: List.tail (trNum Num.zero ++ [Γ'.cons])) [] c d main)) ** simp only [elim_update_rev, elim_rev, elim_main, List.reverseAux_nil, elim_update_main] ** case h.e'_2.h.e'_7 q : Λ' s : Option Γ' n : ℕ c d : List Γ' ⊢ elim (trNum (Num.succ Num.zero) ++ [Γ'.cons]) [] c d = elim (Γ'.bit1 :: Γ'.cons :: List.tail (trNum Num.zero ++ [Γ'.cons])) [] c d ** rfl ** q : Λ' s : Option Γ' n : ℕ c d : List Γ' a : PosNum this : ∀ (l₁ : List Γ'), ∃ l₁' l₂' s', List.reverseAux l₁ (trPosNum (PosNum.succ a)) = List.reverseAux l₁' l₂' ∧ Reaches₁ (TM2.step tr) { l := some (Λ'.succ q), var := s, stk := elim (trPosNum a ++ [Γ'.cons]) l₁ c d } { l := some (unrev q), var := s', stk := elim (l₂' ++ [Γ'.cons]) l₁' c d } ⊢ Reaches₁ (fun x => match x with | { l := none, var := var, stk := stk } => none | { l := some l, var := v, stk := S } => some (TM2.stepAux (tr l) v S)) { l := some (Λ'.succ q), var := s, stk := elim (trPosNum a ++ [Γ'.cons]) [] c d } { l := some q, var := none, stk := elim (trPosNum (PosNum.succ a) ++ [Γ'.cons]) [] c d } ** obtain ⟨l₁', l₂', s', e, h⟩ := this [] ** case intro.intro.intro.intro q : Λ' s : Option Γ' n : ℕ c d : List Γ' a : PosNum this : ∀ (l₁ : List Γ'), ∃ l₁' l₂' s', List.reverseAux l₁ (trPosNum (PosNum.succ a)) = List.reverseAux l₁' l₂' ∧ Reaches₁ (TM2.step tr) { l := some (Λ'.succ q), var := s, stk := elim (trPosNum a ++ [Γ'.cons]) l₁ c d } { l := some (unrev q), var := s', stk := elim (l₂' ++ [Γ'.cons]) l₁' c d } l₁' l₂' : List Γ' s' : Option Γ' e : List.reverseAux [] (trPosNum (PosNum.succ a)) = List.reverseAux l₁' l₂' h : Reaches₁ (TM2.step tr) { l := some (Λ'.succ q), var := s, stk := elim (trPosNum a ++ [Γ'.cons]) [] c d } { l := some (unrev q), var := s', stk := elim (l₂' ++ [Γ'.cons]) l₁' c d } ⊢ Reaches₁ (fun x => match x with | { l := none, var := var, stk := stk } => none | { l := some l, var := v, stk := S } => some (TM2.stepAux (tr l) v S)) { l := some (Λ'.succ q), var := s, stk := elim (trPosNum a ++ [Γ'.cons]) [] c d } { l := some q, var := none, stk := elim (trPosNum (PosNum.succ a) ++ [Γ'.cons]) [] c d } ** simp [List.reverseAux] at e ** case intro.intro.intro.intro q : Λ' s : Option Γ' n : ℕ c d : List Γ' a : PosNum this : ∀ (l₁ : List Γ'), ∃ l₁' l₂' s', List.reverseAux l₁ (trPosNum (PosNum.succ a)) = List.reverseAux l₁' l₂' ∧ Reaches₁ (TM2.step tr) { l := some (Λ'.succ q), var := s, stk := elim (trPosNum a ++ [Γ'.cons]) l₁ c d } { l := some (unrev q), var := s', stk := elim (l₂' ++ [Γ'.cons]) l₁' c d } l₁' l₂' : List Γ' s' : Option Γ' e : trPosNum (PosNum.succ a) = List.reverseAux l₁' l₂' h : Reaches₁ (TM2.step tr) { l := some (Λ'.succ q), var := s, stk := elim (trPosNum a ++ [Γ'.cons]) [] c d } { l := some (unrev q), var := s', stk := elim (l₂' ++ [Γ'.cons]) l₁' c d } ⊢ Reaches₁ (fun x => match x with | { l := none, var := var, stk := stk } => none | { l := some l, var := v, stk := S } => some (TM2.stepAux (tr l) v S)) { l := some (Λ'.succ q), var := s, stk := elim (trPosNum a ++ [Γ'.cons]) [] c d } { l := some q, var := none, stk := elim (trPosNum (PosNum.succ a) ++ [Γ'.cons]) [] c d } ** refine' h.trans _ ** case intro.intro.intro.intro q : Λ' s : Option Γ' n : ℕ c d : List Γ' a : PosNum this : ∀ (l₁ : List Γ'), ∃ l₁' l₂' s', List.reverseAux l₁ (trPosNum (PosNum.succ a)) = List.reverseAux l₁' l₂' ∧ Reaches₁ (TM2.step tr) { l := some (Λ'.succ q), var := s, stk := elim (trPosNum a ++ [Γ'.cons]) l₁ c d } { l := some (unrev q), var := s', stk := elim (l₂' ++ [Γ'.cons]) l₁' c d } l₁' l₂' : List Γ' s' : Option Γ' e : trPosNum (PosNum.succ a) = List.reverseAux l₁' l₂' h : Reaches₁ (TM2.step tr) { l := some (Λ'.succ q), var := s, stk := elim (trPosNum a ++ [Γ'.cons]) [] c d } { l := some (unrev q), var := s', stk := elim (l₂' ++ [Γ'.cons]) l₁' c d } ⊢ TransGen (fun a b => b ∈ TM2.step tr a) { l := some (unrev q), var := s', stk := elim (l₂' ++ [Γ'.cons]) l₁' c d } { l := some q, var := none, stk := elim (trPosNum (PosNum.succ a) ++ [Γ'.cons]) [] c d } ** convert unrev_ok using 2 ** case h.e'_2.h.e'_7 q : Λ' s : Option Γ' n : ℕ c d : List Γ' a : PosNum this : ∀ (l₁ : List Γ'), ∃ l₁' l₂' s', List.reverseAux l₁ (trPosNum (PosNum.succ a)) = List.reverseAux l₁' l₂' ∧ Reaches₁ (TM2.step tr) { l := some (Λ'.succ q), var := s, stk := elim (trPosNum a ++ [Γ'.cons]) l₁ c d } { l := some (unrev q), var := s', stk := elim (l₂' ++ [Γ'.cons]) l₁' c d } l₁' l₂' : List Γ' s' : Option Γ' e : trPosNum (PosNum.succ a) = List.reverseAux l₁' l₂' h : Reaches₁ (TM2.step tr) { l := some (Λ'.succ q), var := s, stk := elim (trPosNum a ++ [Γ'.cons]) [] c d } { l := some (unrev q), var := s', stk := elim (l₂' ++ [Γ'.cons]) l₁' c d } ⊢ elim (trPosNum (PosNum.succ a) ++ [Γ'.cons]) [] c d = update (update (elim (l₂' ++ [Γ'.cons]) l₁' c d) rev []) main (List.reverseAux (elim (l₂' ++ [Γ'.cons]) l₁' c d rev) (elim (l₂' ++ [Γ'.cons]) l₁' c d main)) ** simp [e, List.reverseAux_eq] ** case pos.one q : Λ' s✝ : Option Γ' n : ℕ c d : List Γ' s : Option Γ' l₁ : List Γ' ⊢ ∃ l₁' l₂' s', List.reverseAux l₁ (trPosNum (PosNum.succ PosNum.one)) = List.reverseAux l₁' l₂' ∧ Reaches₁ (TM2.step tr) { l := some (Λ'.succ q), var := s, stk := elim (trPosNum PosNum.one ++ [Γ'.cons]) l₁ c d } { l := some (unrev q), var := s', stk := elim (l₂' ++ [Γ'.cons]) l₁' c d } ** refine' ⟨Γ'.bit0 :: l₁, [Γ'.bit1], some Γ'.cons, rfl, TransGen.head rfl (TransGen.single _)⟩ ** case pos.one q : Λ' s✝ : Option Γ' n : ℕ c d : List Γ' s : Option Γ' l₁ : List Γ' ⊢ { l := some (unrev q), var := some Γ'.cons, stk := elim ([Γ'.bit1] ++ [Γ'.cons]) (Γ'.bit0 :: l₁) c d } ∈ TM2.step tr (TM2.stepAux (tr (Λ'.succ q)) s (elim (trPosNum PosNum.one ++ [Γ'.cons]) l₁ c d)) ** simp [trPosNum] ** case pos.bit1 q : Λ' s✝ : Option Γ' n : ℕ c d : List Γ' m : PosNum IH : ∀ {s : Option Γ'} (l₁ : List Γ'), ∃ l₁' l₂' s', List.reverseAux l₁ (trPosNum (PosNum.succ m)) = List.reverseAux l₁' l₂' ∧ Reaches₁ (TM2.step tr) { l := some (Λ'.succ q), var := s, stk := elim (trPosNum m ++ [Γ'.cons]) l₁ c d } { l := some (unrev q), var := s', stk := elim (l₂' ++ [Γ'.cons]) l₁' c d } s : Option Γ' l₁ : List Γ' ⊢ ∃ l₁' l₂' s', List.reverseAux l₁ (trPosNum (PosNum.succ (PosNum.bit1 m))) = List.reverseAux l₁' l₂' ∧ Reaches₁ (TM2.step tr) { l := some (Λ'.succ q), var := s, stk := elim (trPosNum (PosNum.bit1 m) ++ [Γ'.cons]) l₁ c d } { l := some (unrev q), var := s', stk := elim (l₂' ++ [Γ'.cons]) l₁' c d } ** obtain ⟨l₁', l₂', s', e, h⟩ := IH (Γ'.bit0 :: l₁) ** case pos.bit1.intro.intro.intro.intro q : Λ' s✝ : Option Γ' n : ℕ c d : List Γ' m : PosNum IH : ∀ {s : Option Γ'} (l₁ : List Γ'), ∃ l₁' l₂' s', List.reverseAux l₁ (trPosNum (PosNum.succ m)) = List.reverseAux l₁' l₂' ∧ Reaches₁ (TM2.step tr) { l := some (Λ'.succ q), var := s, stk := elim (trPosNum m ++ [Γ'.cons]) l₁ c d } { l := some (unrev q), var := s', stk := elim (l₂' ++ [Γ'.cons]) l₁' c d } s : Option Γ' l₁ l₁' l₂' : List Γ' s' : Option Γ' e : List.reverseAux (Γ'.bit0 :: l₁) (trPosNum (PosNum.succ m)) = List.reverseAux l₁' l₂' h : Reaches₁ (TM2.step tr) { l := some (Λ'.succ q), var := ?m.497624, stk := elim (trPosNum m ++ [Γ'.cons]) (Γ'.bit0 :: l₁) c d } { l := some (unrev q), var := s', stk := elim (l₂' ++ [Γ'.cons]) l₁' c d } ⊢ ∃ l₁' l₂' s', List.reverseAux l₁ (trPosNum (PosNum.succ (PosNum.bit1 m))) = List.reverseAux l₁' l₂' ∧ Reaches₁ (TM2.step tr) { l := some (Λ'.succ q), var := s, stk := elim (trPosNum (PosNum.bit1 m) ++ [Γ'.cons]) l₁ c d } { l := some (unrev q), var := s', stk := elim (l₂' ++ [Γ'.cons]) l₁' c d } ** refine' ⟨l₁', l₂', s', e, TransGen.head _ h⟩ ** case pos.bit1.intro.intro.intro.intro q : Λ' s✝ : Option Γ' n : ℕ c d : List Γ' m : PosNum IH : ∀ {s : Option Γ'} (l₁ : List Γ'), ∃ l₁' l₂' s', List.reverseAux l₁ (trPosNum (PosNum.succ m)) = List.reverseAux l₁' l₂' ∧ Reaches₁ (TM2.step tr) { l := some (Λ'.succ q), var := s, stk := elim (trPosNum m ++ [Γ'.cons]) l₁ c d } { l := some (unrev q), var := s', stk := elim (l₂' ++ [Γ'.cons]) l₁' c d } s : Option Γ' l₁ l₁' l₂' : List Γ' s' : Option Γ' e : List.reverseAux (Γ'.bit0 :: l₁) (trPosNum (PosNum.succ m)) = List.reverseAux l₁' l₂' h : Reaches₁ (TM2.step tr) { l := some (Λ'.succ q), var := ?m.497624, stk := elim (trPosNum m ++ [Γ'.cons]) (Γ'.bit0 :: l₁) c d } { l := some (unrev q), var := s', stk := elim (l₂' ++ [Γ'.cons]) l₁' c d } ⊢ { l := some (Λ'.succ q), var := ?m.497624, stk := elim (trPosNum m ++ [Γ'.cons]) (Γ'.bit0 :: l₁) c d } ∈ TM2.step tr { l := some (Λ'.succ q), var := s, stk := elim (trPosNum (PosNum.bit1 m) ++ [Γ'.cons]) l₁ c d } ** simp [PosNum.succ, trPosNum] ** case pos.bit1.intro.intro.intro.intro q : Λ' s✝ : Option Γ' n : ℕ c d : List Γ' m : PosNum IH : ∀ {s : Option Γ'} (l₁ : List Γ'), ∃ l₁' l₂' s', List.reverseAux l₁ (trPosNum (PosNum.succ m)) = List.reverseAux l₁' l₂' ∧ Reaches₁ (TM2.step tr) { l := some (Λ'.succ q), var := s, stk := elim (trPosNum m ++ [Γ'.cons]) l₁ c d } { l := some (unrev q), var := s', stk := elim (l₂' ++ [Γ'.cons]) l₁' c d } s : Option Γ' l₁ l₁' l₂' : List Γ' s' : Option Γ' e : List.reverseAux (Γ'.bit0 :: l₁) (trPosNum (PosNum.succ m)) = List.reverseAux l₁' l₂' h : Reaches₁ (TM2.step tr) { l := some (Λ'.succ q), var := ?m.497624, stk := elim (trPosNum m ++ [Γ'.cons]) (Γ'.bit0 :: l₁) c d } { l := some (unrev q), var := s', stk := elim (l₂' ++ [Γ'.cons]) l₁' c d } ⊢ some Γ'.bit1 = ?m.497624 ** rfl ** case pos.bit0 q : Λ' s✝ : Option Γ' n : ℕ c d : List Γ' m : PosNum a_ih✝ : ∀ {s : Option Γ'} (l₁ : List Γ'), ∃ l₁' l₂' s', List.reverseAux l₁ (trPosNum (PosNum.succ m)) = List.reverseAux l₁' l₂' ∧ Reaches₁ (TM2.step tr) { l := some (Λ'.succ q), var := s, stk := elim (trPosNum m ++ [Γ'.cons]) l₁ c d } { l := some (unrev q), var := s', stk := elim (l₂' ++ [Γ'.cons]) l₁' c d } s : Option Γ' l₁ : List Γ' ⊢ ∃ l₁' l₂' s', List.reverseAux l₁ (trPosNum (PosNum.succ (PosNum.bit0 m))) = List.reverseAux l₁' l₂' ∧ Reaches₁ (TM2.step tr) { l := some (Λ'.succ q), var := s, stk := elim (trPosNum (PosNum.bit0 m) ++ [Γ'.cons]) l₁ c d } { l := some (unrev q), var := s', stk := elim (l₂' ++ [Γ'.cons]) l₁' c d } ** refine' ⟨l₁, _, some Γ'.bit0, rfl, TransGen.single _⟩ ** case pos.bit0 q : Λ' s✝ : Option Γ' n : ℕ c d : List Γ' m : PosNum a_ih✝ : ∀ {s : Option Γ'} (l₁ : List Γ'), ∃ l₁' l₂' s', List.reverseAux l₁ (trPosNum (PosNum.succ m)) = List.reverseAux l₁' l₂' ∧ Reaches₁ (TM2.step tr) { l := some (Λ'.succ q), var := s, stk := elim (trPosNum m ++ [Γ'.cons]) l₁ c d } { l := some (unrev q), var := s', stk := elim (l₂' ++ [Γ'.cons]) l₁' c d } s : Option Γ' l₁ : List Γ' ⊢ { l := some (unrev q), var := some Γ'.bit0, stk := elim (trPosNum (PosNum.succ (PosNum.bit0 m)) ++ [Γ'.cons]) l₁ c d } ∈ TM2.step tr { l := some (Λ'.succ q), var := s, stk := elim (trPosNum (PosNum.bit0 m) ++ [Γ'.cons]) l₁ c d } ** simp only [TM2.step, TM2.stepAux, elim_main, elim_update_main, ne_eq, Function.update_noteq,
elim_rev, elim_update_rev, Function.update_same, Option.mem_def, Option.some.injEq] ** case pos.bit0 q : Λ' s✝ : Option Γ' n : ℕ c d : List Γ' m : PosNum a_ih✝ : ∀ {s : Option Γ'} (l₁ : List Γ'), ∃ l₁' l₂' s', List.reverseAux l₁ (trPosNum (PosNum.succ m)) = List.reverseAux l₁' l₂' ∧ Reaches₁ (TM2.step tr) { l := some (Λ'.succ q), var := s, stk := elim (trPosNum m ++ [Γ'.cons]) l₁ c d } { l := some (unrev q), var := s', stk := elim (l₂' ++ [Γ'.cons]) l₁' c d } s : Option Γ' l₁ : List Γ' ⊢ (bif decide (List.head? (trPosNum (PosNum.bit0 m) ++ [Γ'.cons]) = some Γ'.bit1) then { l := some (Λ'.succ q), var := List.head? (trPosNum (PosNum.bit0 m) ++ [Γ'.cons]), stk := elim (List.tail (trPosNum (PosNum.bit0 m) ++ [Γ'.cons])) (Γ'.bit0 :: l₁) c d } else bif decide (List.head? (trPosNum (PosNum.bit0 m) ++ [Γ'.cons]) = some Γ'.cons) then { l := some (unrev q), var := List.head? (trPosNum (PosNum.bit0 m) ++ [Γ'.cons]), stk := elim (Γ'.bit1 :: Γ'.cons :: List.tail (trPosNum (PosNum.bit0 m) ++ [Γ'.cons])) l₁ c d } else { l := some (unrev q), var := List.head? (trPosNum (PosNum.bit0 m) ++ [Γ'.cons]), stk := elim (Γ'.bit1 :: List.tail (trPosNum (PosNum.bit0 m) ++ [Γ'.cons])) l₁ c d }) = { l := some (unrev q), var := some Γ'.bit0, stk := elim (trPosNum (PosNum.succ (PosNum.bit0 m)) ++ [Γ'.cons]) l₁ c d } ** rfl ** Qed
| |
Turing.PartrecToTM2.pred_ok ** q₁ q₂ : Λ' s : Option Γ' v : List ℕ c d : List Γ' ⊢ ∃ s', Reaches₁ (TM2.step tr) { l := some (Λ'.pred q₁ q₂), var := s, stk := elim (trList v) [] c d } (Nat.rec { l := some q₁, var := s', stk := elim (trList (List.tail v)) [] c d } (fun n x => { l := some q₂, var := s', stk := elim (trList (n :: List.tail v)) [] c d }) (List.headI v)) ** rcases v with (_ | ⟨_ | n, v⟩) ** case cons.succ q₁ q₂ : Λ' s : Option Γ' c d : List Γ' v : List ℕ n : ℕ ⊢ ∃ s', Reaches₁ (TM2.step tr) { l := some (Λ'.pred q₁ q₂), var := s, stk := elim (trList (Nat.succ n :: v)) [] c d } (Nat.rec { l := some q₁, var := s', stk := elim (trList (List.tail (Nat.succ n :: v))) [] c d } (fun n_1 x => { l := some q₂, var := s', stk := elim (trList (n_1 :: List.tail (Nat.succ n :: v))) [] c d }) (List.headI (Nat.succ n :: v))) ** refine' ⟨none, _⟩ ** case cons.succ q₁ q₂ : Λ' s : Option Γ' c d : List Γ' v : List ℕ n : ℕ ⊢ Reaches₁ (TM2.step tr) { l := some (Λ'.pred q₁ q₂), var := s, stk := elim (trList (Nat.succ n :: v)) [] c d } (Nat.rec { l := some q₁, var := none, stk := elim (trList (List.tail (Nat.succ n :: v))) [] c d } (fun n_1 x => { l := some q₂, var := none, stk := elim (trList (n_1 :: List.tail (Nat.succ n :: v))) [] c d }) (List.headI (Nat.succ n :: v))) ** simp only [TM2.step, trList, trNat._eq_1, trNum, Nat.cast_succ, Num.add_one, Num.succ,
List.tail_cons, List.headI_cons] ** case cons.succ q₁ q₂ : Λ' s : Option Γ' c d : List Γ' v : List ℕ n : ℕ ⊢ Reaches₁ (fun x => match x with | { l := none, var := var, stk := stk } => none | { l := some l, var := v, stk := S } => some (TM2.stepAux (tr l) v S)) { l := some (Λ'.pred q₁ q₂), var := s, stk := elim (trPosNum (Num.succ' ↑n) ++ Γ'.cons :: trList v) [] c d } { l := some q₂, var := none, stk := elim ((match ↑n with | Num.zero => [] | Num.pos n => trPosNum n) ++ Γ'.cons :: trList v) [] c d } ** cases' (n : Num) with a ** case cons.succ.pos q₁ q₂ : Λ' s : Option Γ' c d : List Γ' v : List ℕ n : ℕ a : PosNum ⊢ Reaches₁ (fun x => match x with | { l := none, var := var, stk := stk } => none | { l := some l, var := v, stk := S } => some (TM2.stepAux (tr l) v S)) { l := some (Λ'.pred q₁ q₂), var := s, stk := elim (trPosNum (Num.succ' (Num.pos a)) ++ Γ'.cons :: trList v) [] c d } { l := some q₂, var := none, stk := elim ((match Num.pos a with | Num.zero => [] | Num.pos n => trPosNum n) ++ Γ'.cons :: trList v) [] c d } ** simp only [Num.succ'] ** case cons.succ.pos q₁ q₂ : Λ' s : Option Γ' c d : List Γ' v : List ℕ n : ℕ a : PosNum ⊢ Reaches₁ (fun x => match x with | { l := none, var := var, stk := stk } => none | { l := some l, var := v, stk := S } => some (TM2.stepAux (tr l) v S)) { l := some (Λ'.pred q₁ q₂), var := s, stk := elim (trPosNum (PosNum.succ a) ++ Γ'.cons :: trList v) [] c d } { l := some q₂, var := none, stk := elim (trPosNum a ++ Γ'.cons :: trList v) [] c d } ** suffices ∀ l₁, ∃ l₁' l₂' s',
List.reverseAux l₁ (trPosNum a) = List.reverseAux l₁' l₂' ∧
Reaches₁ (TM2.step tr)
⟨some (q₁.pred q₂), s, K'.elim (trPosNum a.succ ++ Γ'.cons :: trList v) l₁ c d⟩
⟨some (unrev q₂), s', K'.elim (l₂' ++ Γ'.cons :: trList v) l₁' c d⟩ by
obtain ⟨l₁', l₂', s', e, h⟩ := this []
simp [List.reverseAux] at e
refine' h.trans _
convert unrev_ok using 2
simp [e, List.reverseAux_eq] ** case cons.succ.pos q₁ q₂ : Λ' s : Option Γ' c d : List Γ' v : List ℕ n : ℕ a : PosNum ⊢ ∀ (l₁ : List Γ'), ∃ l₁' l₂' s', List.reverseAux l₁ (trPosNum a) = List.reverseAux l₁' l₂' ∧ Reaches₁ (TM2.step tr) { l := some (Λ'.pred q₁ q₂), var := s, stk := elim (trPosNum (PosNum.succ a) ++ Γ'.cons :: trList v) l₁ c d } { l := some (unrev q₂), var := s', stk := elim (l₂' ++ Γ'.cons :: trList v) l₁' c d } ** induction' a with m IH m IH generalizing s <;> intro l₁ ** case nil q₁ q₂ : Λ' s : Option Γ' c d : List Γ' ⊢ ∃ s', Reaches₁ (TM2.step tr) { l := some (Λ'.pred q₁ q₂), var := s, stk := elim (trList []) [] c d } (Nat.rec { l := some q₁, var := s', stk := elim (trList (List.tail [])) [] c d } (fun n x => { l := some q₂, var := s', stk := elim (trList (n :: List.tail [])) [] c d }) (List.headI [])) ** refine' ⟨none, TransGen.single _⟩ ** case nil q₁ q₂ : Λ' s : Option Γ' c d : List Γ' ⊢ Nat.rec { l := some q₁, var := none, stk := elim (trList (List.tail [])) [] c d } (fun n x => { l := some q₂, var := none, stk := elim (trList (n :: List.tail [])) [] c d }) (List.headI []) ∈ TM2.step tr { l := some (Λ'.pred q₁ q₂), var := s, stk := elim (trList []) [] c d } ** simp ** case nil q₁ q₂ : Λ' s : Option Γ' c d : List Γ' ⊢ { l := some q₁, var := none, stk := elim [] [] c d } = Nat.rec { l := some q₁, var := none, stk := elim [] [] c d } (fun n x => { l := some q₂, var := none, stk := elim (trNat n ++ [Γ'.cons]) [] c d }) default ** rfl ** case cons.zero q₁ q₂ : Λ' s : Option Γ' c d : List Γ' v : List ℕ ⊢ ∃ s', Reaches₁ (TM2.step tr) { l := some (Λ'.pred q₁ q₂), var := s, stk := elim (trList (Nat.zero :: v)) [] c d } (Nat.rec { l := some q₁, var := s', stk := elim (trList (List.tail (Nat.zero :: v))) [] c d } (fun n x => { l := some q₂, var := s', stk := elim (trList (n :: List.tail (Nat.zero :: v))) [] c d }) (List.headI (Nat.zero :: v))) ** refine' ⟨some Γ'.cons, TransGen.single _⟩ ** case cons.zero q₁ q₂ : Λ' s : Option Γ' c d : List Γ' v : List ℕ ⊢ Nat.rec { l := some q₁, var := some Γ'.cons, stk := elim (trList (List.tail (Nat.zero :: v))) [] c d } (fun n x => { l := some q₂, var := some Γ'.cons, stk := elim (trList (n :: List.tail (Nat.zero :: v))) [] c d }) (List.headI (Nat.zero :: v)) ∈ TM2.step tr { l := some (Λ'.pred q₁ q₂), var := s, stk := elim (trList (Nat.zero :: v)) [] c d } ** simp ** case cons.succ.zero q₁ q₂ : Λ' s : Option Γ' c d : List Γ' v : List ℕ n : ℕ ⊢ Reaches₁ (fun x => match x with | { l := none, var := var, stk := stk } => none | { l := some l, var := v, stk := S } => some (TM2.stepAux (tr l) v S)) { l := some (Λ'.pred q₁ q₂), var := s, stk := elim (trPosNum (Num.succ' Num.zero) ++ Γ'.cons :: trList v) [] c d } { l := some q₂, var := none, stk := elim ((match Num.zero with | Num.zero => [] | Num.pos n => trPosNum n) ++ Γ'.cons :: trList v) [] c d } ** simp [trPosNum, trNum, show Num.zero.succ' = PosNum.one from rfl] ** case cons.succ.zero q₁ q₂ : Λ' s : Option Γ' c d : List Γ' v : List ℕ n : ℕ ⊢ Reaches₁ (fun x => match x with | { l := none, var := var, stk := stk } => none | { l := some l, var := v, stk := S } => some (TM2.stepAux (tr l) v S)) { l := some (Λ'.pred q₁ q₂), var := s, stk := elim (Γ'.bit1 :: Γ'.cons :: trList v) [] c d } { l := some q₂, var := none, stk := elim (Γ'.cons :: trList v) [] c d } ** refine' TransGen.head rfl _ ** case cons.succ.zero q₁ q₂ : Λ' s : Option Γ' c d : List Γ' v : List ℕ n : ℕ ⊢ TransGen (fun a b => b ∈ (fun x => match x with | { l := none, var := var, stk := stk } => none | { l := some l, var := v, stk := S } => some (TM2.stepAux (tr l) v S)) a) (TM2.stepAux (tr (Λ'.pred q₁ q₂)) s (elim (Γ'.bit1 :: Γ'.cons :: trList v) [] c d)) { l := some q₂, var := none, stk := elim (Γ'.cons :: trList v) [] c d } ** simp only [Option.mem_def, TM2.stepAux, elim_main, List.head?_cons, Option.some.injEq,
decide_False, List.tail_cons, elim_update_main, ne_eq, Function.update_noteq, elim_rev,
elim_update_rev, natEnd, Function.update_same, cond_true, cond_false] ** case cons.succ.zero q₁ q₂ : Λ' s : Option Γ' c d : List Γ' v : List ℕ n : ℕ ⊢ TransGen (fun a b => (match a with | { l := none, var := var, stk := stk } => none | { l := some l, var := v, stk := S } => some (TM2.stepAux (tr l) v S)) = some b) { l := some (unrev q₂), var := some Γ'.cons, stk := elim (Γ'.cons :: trList v) [] c d } { l := some q₂, var := none, stk := elim (Γ'.cons :: trList v) [] c d } ** convert unrev_ok using 2 ** case h.e'_2.h.e'_7 q₁ q₂ : Λ' s : Option Γ' c d : List Γ' v : List ℕ n : ℕ ⊢ elim (Γ'.cons :: trList v) [] c d = update (update (elim (Γ'.cons :: trList v) [] c d) rev []) main (List.reverseAux (elim (Γ'.cons :: trList v) [] c d rev) (elim (Γ'.cons :: trList v) [] c d main)) ** simp ** q₁ q₂ : Λ' s : Option Γ' c d : List Γ' v : List ℕ n : ℕ a : PosNum this : ∀ (l₁ : List Γ'), ∃ l₁' l₂' s', List.reverseAux l₁ (trPosNum a) = List.reverseAux l₁' l₂' ∧ Reaches₁ (TM2.step tr) { l := some (Λ'.pred q₁ q₂), var := s, stk := elim (trPosNum (PosNum.succ a) ++ Γ'.cons :: trList v) l₁ c d } { l := some (unrev q₂), var := s', stk := elim (l₂' ++ Γ'.cons :: trList v) l₁' c d } ⊢ Reaches₁ (fun x => match x with | { l := none, var := var, stk := stk } => none | { l := some l, var := v, stk := S } => some (TM2.stepAux (tr l) v S)) { l := some (Λ'.pred q₁ q₂), var := s, stk := elim (trPosNum (PosNum.succ a) ++ Γ'.cons :: trList v) [] c d } { l := some q₂, var := none, stk := elim (trPosNum a ++ Γ'.cons :: trList v) [] c d } ** obtain ⟨l₁', l₂', s', e, h⟩ := this [] ** case intro.intro.intro.intro q₁ q₂ : Λ' s : Option Γ' c d : List Γ' v : List ℕ n : ℕ a : PosNum this : ∀ (l₁ : List Γ'), ∃ l₁' l₂' s', List.reverseAux l₁ (trPosNum a) = List.reverseAux l₁' l₂' ∧ Reaches₁ (TM2.step tr) { l := some (Λ'.pred q₁ q₂), var := s, stk := elim (trPosNum (PosNum.succ a) ++ Γ'.cons :: trList v) l₁ c d } { l := some (unrev q₂), var := s', stk := elim (l₂' ++ Γ'.cons :: trList v) l₁' c d } l₁' l₂' : List Γ' s' : Option Γ' e : List.reverseAux [] (trPosNum a) = List.reverseAux l₁' l₂' h : Reaches₁ (TM2.step tr) { l := some (Λ'.pred q₁ q₂), var := s, stk := elim (trPosNum (PosNum.succ a) ++ Γ'.cons :: trList v) [] c d } { l := some (unrev q₂), var := s', stk := elim (l₂' ++ Γ'.cons :: trList v) l₁' c d } ⊢ Reaches₁ (fun x => match x with | { l := none, var := var, stk := stk } => none | { l := some l, var := v, stk := S } => some (TM2.stepAux (tr l) v S)) { l := some (Λ'.pred q₁ q₂), var := s, stk := elim (trPosNum (PosNum.succ a) ++ Γ'.cons :: trList v) [] c d } { l := some q₂, var := none, stk := elim (trPosNum a ++ Γ'.cons :: trList v) [] c d } ** simp [List.reverseAux] at e ** case intro.intro.intro.intro q₁ q₂ : Λ' s : Option Γ' c d : List Γ' v : List ℕ n : ℕ a : PosNum this : ∀ (l₁ : List Γ'), ∃ l₁' l₂' s', List.reverseAux l₁ (trPosNum a) = List.reverseAux l₁' l₂' ∧ Reaches₁ (TM2.step tr) { l := some (Λ'.pred q₁ q₂), var := s, stk := elim (trPosNum (PosNum.succ a) ++ Γ'.cons :: trList v) l₁ c d } { l := some (unrev q₂), var := s', stk := elim (l₂' ++ Γ'.cons :: trList v) l₁' c d } l₁' l₂' : List Γ' s' : Option Γ' e : trPosNum a = List.reverseAux l₁' l₂' h : Reaches₁ (TM2.step tr) { l := some (Λ'.pred q₁ q₂), var := s, stk := elim (trPosNum (PosNum.succ a) ++ Γ'.cons :: trList v) [] c d } { l := some (unrev q₂), var := s', stk := elim (l₂' ++ Γ'.cons :: trList v) l₁' c d } ⊢ Reaches₁ (fun x => match x with | { l := none, var := var, stk := stk } => none | { l := some l, var := v, stk := S } => some (TM2.stepAux (tr l) v S)) { l := some (Λ'.pred q₁ q₂), var := s, stk := elim (trPosNum (PosNum.succ a) ++ Γ'.cons :: trList v) [] c d } { l := some q₂, var := none, stk := elim (trPosNum a ++ Γ'.cons :: trList v) [] c d } ** refine' h.trans _ ** case intro.intro.intro.intro q₁ q₂ : Λ' s : Option Γ' c d : List Γ' v : List ℕ n : ℕ a : PosNum this : ∀ (l₁ : List Γ'), ∃ l₁' l₂' s', List.reverseAux l₁ (trPosNum a) = List.reverseAux l₁' l₂' ∧ Reaches₁ (TM2.step tr) { l := some (Λ'.pred q₁ q₂), var := s, stk := elim (trPosNum (PosNum.succ a) ++ Γ'.cons :: trList v) l₁ c d } { l := some (unrev q₂), var := s', stk := elim (l₂' ++ Γ'.cons :: trList v) l₁' c d } l₁' l₂' : List Γ' s' : Option Γ' e : trPosNum a = List.reverseAux l₁' l₂' h : Reaches₁ (TM2.step tr) { l := some (Λ'.pred q₁ q₂), var := s, stk := elim (trPosNum (PosNum.succ a) ++ Γ'.cons :: trList v) [] c d } { l := some (unrev q₂), var := s', stk := elim (l₂' ++ Γ'.cons :: trList v) l₁' c d } ⊢ TransGen (fun a b => b ∈ TM2.step tr a) { l := some (unrev q₂), var := s', stk := elim (l₂' ++ Γ'.cons :: trList v) l₁' c d } { l := some q₂, var := none, stk := elim (trPosNum a ++ Γ'.cons :: trList v) [] c d } ** convert unrev_ok using 2 ** case h.e'_2.h.e'_7 q₁ q₂ : Λ' s : Option Γ' c d : List Γ' v : List ℕ n : ℕ a : PosNum this : ∀ (l₁ : List Γ'), ∃ l₁' l₂' s', List.reverseAux l₁ (trPosNum a) = List.reverseAux l₁' l₂' ∧ Reaches₁ (TM2.step tr) { l := some (Λ'.pred q₁ q₂), var := s, stk := elim (trPosNum (PosNum.succ a) ++ Γ'.cons :: trList v) l₁ c d } { l := some (unrev q₂), var := s', stk := elim (l₂' ++ Γ'.cons :: trList v) l₁' c d } l₁' l₂' : List Γ' s' : Option Γ' e : trPosNum a = List.reverseAux l₁' l₂' h : Reaches₁ (TM2.step tr) { l := some (Λ'.pred q₁ q₂), var := s, stk := elim (trPosNum (PosNum.succ a) ++ Γ'.cons :: trList v) [] c d } { l := some (unrev q₂), var := s', stk := elim (l₂' ++ Γ'.cons :: trList v) l₁' c d } ⊢ elim (trPosNum a ++ Γ'.cons :: trList v) [] c d = update (update (elim (l₂' ++ Γ'.cons :: trList v) l₁' c d) rev []) main (List.reverseAux (elim (l₂' ++ Γ'.cons :: trList v) l₁' c d rev) (elim (l₂' ++ Γ'.cons :: trList v) l₁' c d main)) ** simp [e, List.reverseAux_eq] ** case cons.succ.pos.one q₁ q₂ : Λ' s✝ : Option Γ' c d : List Γ' v : List ℕ n : ℕ s : Option Γ' l₁ : List Γ' ⊢ ∃ l₁' l₂' s', List.reverseAux l₁ (trPosNum PosNum.one) = List.reverseAux l₁' l₂' ∧ Reaches₁ (TM2.step tr) { l := some (Λ'.pred q₁ q₂), var := s, stk := elim (trPosNum (PosNum.succ PosNum.one) ++ Γ'.cons :: trList v) l₁ c d } { l := some (unrev q₂), var := s', stk := elim (l₂' ++ Γ'.cons :: trList v) l₁' c d } ** refine' ⟨Γ'.bit1::l₁, [], some Γ'.cons, rfl, TransGen.head rfl (TransGen.single _)⟩ ** case cons.succ.pos.one q₁ q₂ : Λ' s✝ : Option Γ' c d : List Γ' v : List ℕ n : ℕ s : Option Γ' l₁ : List Γ' ⊢ { l := some (unrev q₂), var := some Γ'.cons, stk := elim ([] ++ Γ'.cons :: trList v) (Γ'.bit1 :: l₁) c d } ∈ TM2.step tr (TM2.stepAux (tr (Λ'.pred q₁ q₂)) s (elim (trPosNum (PosNum.succ PosNum.one) ++ Γ'.cons :: trList v) l₁ c d)) ** simp [trPosNum, show PosNum.one.succ = PosNum.one.bit0 from rfl] ** case cons.succ.pos.bit1 q₁ q₂ : Λ' s✝ : Option Γ' c d : List Γ' v : List ℕ n : ℕ m : PosNum IH : ∀ (s : Option Γ') (l₁ : List Γ'), ∃ l₁' l₂' s', List.reverseAux l₁ (trPosNum m) = List.reverseAux l₁' l₂' ∧ Reaches₁ (TM2.step tr) { l := some (Λ'.pred q₁ q₂), var := s, stk := elim (trPosNum (PosNum.succ m) ++ Γ'.cons :: trList v) l₁ c d } { l := some (unrev q₂), var := s', stk := elim (l₂' ++ Γ'.cons :: trList v) l₁' c d } s : Option Γ' l₁ : List Γ' ⊢ ∃ l₁' l₂' s', List.reverseAux l₁ (trPosNum (PosNum.bit1 m)) = List.reverseAux l₁' l₂' ∧ Reaches₁ (TM2.step tr) { l := some (Λ'.pred q₁ q₂), var := s, stk := elim (trPosNum (PosNum.succ (PosNum.bit1 m)) ++ Γ'.cons :: trList v) l₁ c d } { l := some (unrev q₂), var := s', stk := elim (l₂' ++ Γ'.cons :: trList v) l₁' c d } ** obtain ⟨l₁', l₂', s', e, h⟩ := IH (some Γ'.bit0) (Γ'.bit1 :: l₁) ** case cons.succ.pos.bit1.intro.intro.intro.intro q₁ q₂ : Λ' s✝ : Option Γ' c d : List Γ' v : List ℕ n : ℕ m : PosNum IH : ∀ (s : Option Γ') (l₁ : List Γ'), ∃ l₁' l₂' s', List.reverseAux l₁ (trPosNum m) = List.reverseAux l₁' l₂' ∧ Reaches₁ (TM2.step tr) { l := some (Λ'.pred q₁ q₂), var := s, stk := elim (trPosNum (PosNum.succ m) ++ Γ'.cons :: trList v) l₁ c d } { l := some (unrev q₂), var := s', stk := elim (l₂' ++ Γ'.cons :: trList v) l₁' c d } s : Option Γ' l₁ l₁' l₂' : List Γ' s' : Option Γ' e : List.reverseAux (Γ'.bit1 :: l₁) (trPosNum m) = List.reverseAux l₁' l₂' h : Reaches₁ (TM2.step tr) { l := some (Λ'.pred q₁ q₂), var := some Γ'.bit0, stk := elim (trPosNum (PosNum.succ m) ++ Γ'.cons :: trList v) (Γ'.bit1 :: l₁) c d } { l := some (unrev q₂), var := s', stk := elim (l₂' ++ Γ'.cons :: trList v) l₁' c d } ⊢ ∃ l₁' l₂' s', List.reverseAux l₁ (trPosNum (PosNum.bit1 m)) = List.reverseAux l₁' l₂' ∧ Reaches₁ (TM2.step tr) { l := some (Λ'.pred q₁ q₂), var := s, stk := elim (trPosNum (PosNum.succ (PosNum.bit1 m)) ++ Γ'.cons :: trList v) l₁ c d } { l := some (unrev q₂), var := s', stk := elim (l₂' ++ Γ'.cons :: trList v) l₁' c d } ** refine' ⟨l₁', l₂', s', e, TransGen.head _ h⟩ ** case cons.succ.pos.bit1.intro.intro.intro.intro q₁ q₂ : Λ' s✝ : Option Γ' c d : List Γ' v : List ℕ n : ℕ m : PosNum IH : ∀ (s : Option Γ') (l₁ : List Γ'), ∃ l₁' l₂' s', List.reverseAux l₁ (trPosNum m) = List.reverseAux l₁' l₂' ∧ Reaches₁ (TM2.step tr) { l := some (Λ'.pred q₁ q₂), var := s, stk := elim (trPosNum (PosNum.succ m) ++ Γ'.cons :: trList v) l₁ c d } { l := some (unrev q₂), var := s', stk := elim (l₂' ++ Γ'.cons :: trList v) l₁' c d } s : Option Γ' l₁ l₁' l₂' : List Γ' s' : Option Γ' e : List.reverseAux (Γ'.bit1 :: l₁) (trPosNum m) = List.reverseAux l₁' l₂' h : Reaches₁ (TM2.step tr) { l := some (Λ'.pred q₁ q₂), var := some Γ'.bit0, stk := elim (trPosNum (PosNum.succ m) ++ Γ'.cons :: trList v) (Γ'.bit1 :: l₁) c d } { l := some (unrev q₂), var := s', stk := elim (l₂' ++ Γ'.cons :: trList v) l₁' c d } ⊢ { l := some (Λ'.pred q₁ q₂), var := some Γ'.bit0, stk := elim (trPosNum (PosNum.succ m) ++ Γ'.cons :: trList v) (Γ'.bit1 :: l₁) c d } ∈ TM2.step tr { l := some (Λ'.pred q₁ q₂), var := s, stk := elim (trPosNum (PosNum.succ (PosNum.bit1 m)) ++ Γ'.cons :: trList v) l₁ c d } ** simp ** case cons.succ.pos.bit1.intro.intro.intro.intro q₁ q₂ : Λ' s✝ : Option Γ' c d : List Γ' v : List ℕ n : ℕ m : PosNum IH : ∀ (s : Option Γ') (l₁ : List Γ'), ∃ l₁' l₂' s', List.reverseAux l₁ (trPosNum m) = List.reverseAux l₁' l₂' ∧ Reaches₁ (TM2.step tr) { l := some (Λ'.pred q₁ q₂), var := s, stk := elim (trPosNum (PosNum.succ m) ++ Γ'.cons :: trList v) l₁ c d } { l := some (unrev q₂), var := s', stk := elim (l₂' ++ Γ'.cons :: trList v) l₁' c d } s : Option Γ' l₁ l₁' l₂' : List Γ' s' : Option Γ' e : List.reverseAux (Γ'.bit1 :: l₁) (trPosNum m) = List.reverseAux l₁' l₂' h : Reaches₁ (TM2.step tr) { l := some (Λ'.pred q₁ q₂), var := some Γ'.bit0, stk := elim (trPosNum (PosNum.succ m) ++ Γ'.cons :: trList v) (Γ'.bit1 :: l₁) c d } { l := some (unrev q₂), var := s', stk := elim (l₂' ++ Γ'.cons :: trList v) l₁' c d } ⊢ (bif decide (List.head? (trPosNum (PosNum.succ (PosNum.bit1 m)) ++ Γ'.cons :: trList v) = some Γ'.bit0) then { l := some (Λ'.pred q₁ q₂), var := List.head? (trPosNum (PosNum.succ (PosNum.bit1 m)) ++ Γ'.cons :: trList v), stk := elim (List.tail (trPosNum (PosNum.succ (PosNum.bit1 m)) ++ Γ'.cons :: trList v)) (Γ'.bit1 :: l₁) c d } else bif match Option.iget (List.head? (trPosNum (PosNum.succ (PosNum.bit1 m)) ++ Γ'.cons :: trList v)) with | Γ'.consₗ => true | Γ'.cons => true | x => false then { l := some q₁, var := List.head? (trPosNum (PosNum.succ (PosNum.bit1 m)) ++ Γ'.cons :: trList v), stk := elim (List.tail (trPosNum (PosNum.succ (PosNum.bit1 m)) ++ Γ'.cons :: trList v)) l₁ c d } else bif match Option.iget (List.head? (List.tail (trPosNum (PosNum.succ (PosNum.bit1 m)) ++ Γ'.cons :: trList v))) with | Γ'.consₗ => true | Γ'.cons => true | x => false then { l := some (unrev q₂), var := List.head? (List.tail (trPosNum (PosNum.succ (PosNum.bit1 m)) ++ Γ'.cons :: trList v)), stk := elim (List.tail (trPosNum (PosNum.succ (PosNum.bit1 m)) ++ Γ'.cons :: trList v)) l₁ c d } else { l := some (unrev q₂), var := List.head? (List.tail (trPosNum (PosNum.succ (PosNum.bit1 m)) ++ Γ'.cons :: trList v)), stk := elim (List.tail (trPosNum (PosNum.succ (PosNum.bit1 m)) ++ Γ'.cons :: trList v)) (Γ'.bit0 :: l₁) c d }) = { l := some (Λ'.pred q₁ q₂), var := some Γ'.bit0, stk := elim (trPosNum (PosNum.succ m) ++ Γ'.cons :: trList v) (Γ'.bit1 :: l₁) c d } ** rfl ** case cons.succ.pos.bit0 q₁ q₂ : Λ' s✝ : Option Γ' c d : List Γ' v : List ℕ n : ℕ m : PosNum IH : ∀ (s : Option Γ') (l₁ : List Γ'), ∃ l₁' l₂' s', List.reverseAux l₁ (trPosNum m) = List.reverseAux l₁' l₂' ∧ Reaches₁ (TM2.step tr) { l := some (Λ'.pred q₁ q₂), var := s, stk := elim (trPosNum (PosNum.succ m) ++ Γ'.cons :: trList v) l₁ c d } { l := some (unrev q₂), var := s', stk := elim (l₂' ++ Γ'.cons :: trList v) l₁' c d } s : Option Γ' l₁ : List Γ' ⊢ ∃ l₁' l₂' s', List.reverseAux l₁ (trPosNum (PosNum.bit0 m)) = List.reverseAux l₁' l₂' ∧ Reaches₁ (TM2.step tr) { l := some (Λ'.pred q₁ q₂), var := s, stk := elim (trPosNum (PosNum.succ (PosNum.bit0 m)) ++ Γ'.cons :: trList v) l₁ c d } { l := some (unrev q₂), var := s', stk := elim (l₂' ++ Γ'.cons :: trList v) l₁' c d } ** obtain ⟨a, l, e, h⟩ : ∃ a l, (trPosNum m = a::l) ∧ natEnd a = false := by
cases m <;> refine' ⟨_, _, rfl, rfl⟩ ** case cons.succ.pos.bit0.intro.intro.intro q₁ q₂ : Λ' s✝ : Option Γ' c d : List Γ' v : List ℕ n : ℕ m : PosNum IH : ∀ (s : Option Γ') (l₁ : List Γ'), ∃ l₁' l₂' s', List.reverseAux l₁ (trPosNum m) = List.reverseAux l₁' l₂' ∧ Reaches₁ (TM2.step tr) { l := some (Λ'.pred q₁ q₂), var := s, stk := elim (trPosNum (PosNum.succ m) ++ Γ'.cons :: trList v) l₁ c d } { l := some (unrev q₂), var := s', stk := elim (l₂' ++ Γ'.cons :: trList v) l₁' c d } s : Option Γ' l₁ : List Γ' a : Γ' l : List Γ' e : trPosNum m = a :: l h : natEnd a = false ⊢ ∃ l₁' l₂' s', List.reverseAux l₁ (trPosNum (PosNum.bit0 m)) = List.reverseAux l₁' l₂' ∧ Reaches₁ (TM2.step tr) { l := some (Λ'.pred q₁ q₂), var := s, stk := elim (trPosNum (PosNum.succ (PosNum.bit0 m)) ++ Γ'.cons :: trList v) l₁ c d } { l := some (unrev q₂), var := s', stk := elim (l₂' ++ Γ'.cons :: trList v) l₁' c d } ** refine' ⟨Γ'.bit0 :: l₁, _, some a, rfl, TransGen.single _⟩ ** case cons.succ.pos.bit0.intro.intro.intro q₁ q₂ : Λ' s✝ : Option Γ' c d : List Γ' v : List ℕ n : ℕ m : PosNum IH : ∀ (s : Option Γ') (l₁ : List Γ'), ∃ l₁' l₂' s', List.reverseAux l₁ (trPosNum m) = List.reverseAux l₁' l₂' ∧ Reaches₁ (TM2.step tr) { l := some (Λ'.pred q₁ q₂), var := s, stk := elim (trPosNum (PosNum.succ m) ++ Γ'.cons :: trList v) l₁ c d } { l := some (unrev q₂), var := s', stk := elim (l₂' ++ Γ'.cons :: trList v) l₁' c d } s : Option Γ' l₁ : List Γ' a : Γ' l : List Γ' e : trPosNum m = a :: l h : natEnd a = false ⊢ { l := some (unrev q₂), var := some a, stk := elim (trPosNum m ++ Γ'.cons :: trList v) (Γ'.bit0 :: l₁) c d } ∈ TM2.step tr { l := some (Λ'.pred q₁ q₂), var := s, stk := elim (trPosNum (PosNum.succ (PosNum.bit0 m)) ++ Γ'.cons :: trList v) l₁ c d } ** simp [trPosNum, PosNum.succ, e, h, show some Γ'.bit1 ≠ some Γ'.bit0 by decide,
Option.iget, -natEnd] ** case cons.succ.pos.bit0.intro.intro.intro q₁ q₂ : Λ' s✝ : Option Γ' c d : List Γ' v : List ℕ n : ℕ m : PosNum IH : ∀ (s : Option Γ') (l₁ : List Γ'), ∃ l₁' l₂' s', List.reverseAux l₁ (trPosNum m) = List.reverseAux l₁' l₂' ∧ Reaches₁ (TM2.step tr) { l := some (Λ'.pred q₁ q₂), var := s, stk := elim (trPosNum (PosNum.succ m) ++ Γ'.cons :: trList v) l₁ c d } { l := some (unrev q₂), var := s', stk := elim (l₂' ++ Γ'.cons :: trList v) l₁' c d } s : Option Γ' l₁ : List Γ' a : Γ' l : List Γ' e : trPosNum m = a :: l h : natEnd a = false ⊢ (bif natEnd Γ'.bit1 then { l := some q₁, var := some Γ'.bit1, stk := elim (a :: (l ++ Γ'.cons :: trList v)) l₁ c d } else { l := some (unrev q₂), var := some a, stk := elim (a :: (l ++ Γ'.cons :: trList v)) (Γ'.bit0 :: l₁) c d }) = { l := some (unrev q₂), var := some a, stk := elim (a :: (l ++ Γ'.cons :: trList v)) (Γ'.bit0 :: l₁) c d } ** rfl ** q₁ q₂ : Λ' s✝ : Option Γ' c d : List Γ' v : List ℕ n : ℕ m : PosNum IH : ∀ (s : Option Γ') (l₁ : List Γ'), ∃ l₁' l₂' s', List.reverseAux l₁ (trPosNum m) = List.reverseAux l₁' l₂' ∧ Reaches₁ (TM2.step tr) { l := some (Λ'.pred q₁ q₂), var := s, stk := elim (trPosNum (PosNum.succ m) ++ Γ'.cons :: trList v) l₁ c d } { l := some (unrev q₂), var := s', stk := elim (l₂' ++ Γ'.cons :: trList v) l₁' c d } s : Option Γ' l₁ : List Γ' ⊢ ∃ a l, trPosNum m = a :: l ∧ natEnd a = false ** cases m <;> refine' ⟨_, _, rfl, rfl⟩ ** q₁ q₂ : Λ' s✝ : Option Γ' c d : List Γ' v : List ℕ n : ℕ m : PosNum IH : ∀ (s : Option Γ') (l₁ : List Γ'), ∃ l₁' l₂' s', List.reverseAux l₁ (trPosNum m) = List.reverseAux l₁' l₂' ∧ Reaches₁ (TM2.step tr) { l := some (Λ'.pred q₁ q₂), var := s, stk := elim (trPosNum (PosNum.succ m) ++ Γ'.cons :: trList v) l₁ c d } { l := some (unrev q₂), var := s', stk := elim (l₂' ++ Γ'.cons :: trList v) l₁' c d } s : Option Γ' l₁ : List Γ' a : Γ' l : List Γ' e : trPosNum m = a :: l h : natEnd a = false ⊢ some Γ'.bit1 ≠ some Γ'.bit0 ** decide ** Qed
| |
Turing.PartrecToTM2.trStmts₁_trans ** q q' : Λ' ⊢ q' ∈ trStmts₁ q → trStmts₁ q' ⊆ trStmts₁ q ** induction' q with _ _ _ q q_ih _ _ q q_ih q q_ih _ _ q q_ih q q_ih q q_ih q₁ q₂ q₁_ih q₂_ih _ <;>
simp (config := { contextual := true }) only [trStmts₁, Finset.mem_insert, Finset.mem_union,
or_imp, Finset.mem_singleton, Finset.Subset.refl, imp_true_iff, true_and_iff] ** case move q' : Λ' p✝ : Γ' → Bool k₁✝ k₂✝ : K' q : Λ' q_ih : q' ∈ trStmts₁ q → trStmts₁ q' ⊆ trStmts₁ q ⊢ q' ∈ trStmts₁ q → trStmts₁ q' ⊆ insert (Λ'.move p✝ k₁✝ k₂✝ q) (trStmts₁ q) case clear q' : Λ' p✝ : Γ' → Bool k✝ : K' q : Λ' q_ih : q' ∈ trStmts₁ q → trStmts₁ q' ⊆ trStmts₁ q ⊢ q' ∈ trStmts₁ q → trStmts₁ q' ⊆ insert (Λ'.clear p✝ k✝ q) (trStmts₁ q) case copy q' q : Λ' q_ih : q' ∈ trStmts₁ q → trStmts₁ q' ⊆ trStmts₁ q ⊢ q' ∈ trStmts₁ q → trStmts₁ q' ⊆ insert (Λ'.copy q) (trStmts₁ q) case push q' : Λ' k✝ : K' s✝ : Option Γ' → Option Γ' q : Λ' q_ih : q' ∈ trStmts₁ q → trStmts₁ q' ⊆ trStmts₁ q ⊢ q' ∈ trStmts₁ q → trStmts₁ q' ⊆ insert (Λ'.push k✝ s✝ q) (trStmts₁ q) case read q' : Λ' q : Option Γ' → Λ' q_ih : ∀ (a : Option Γ'), q' ∈ trStmts₁ (q a) → trStmts₁ q' ⊆ trStmts₁ (q a) ⊢ (q' ∈ Finset.biUnion Finset.univ fun s => trStmts₁ (q s)) → trStmts₁ q' ⊆ insert (Λ'.read q) (Finset.biUnion Finset.univ fun s => trStmts₁ (q s)) case succ q' q : Λ' q_ih : q' ∈ trStmts₁ q → trStmts₁ q' ⊆ trStmts₁ q ⊢ (q' = unrev q → insert (Λ'.move (fun x => false) rev main q) (trStmts₁ q) ⊆ insert (Λ'.succ q) (insert (unrev q) (trStmts₁ q))) ∧ (q' ∈ trStmts₁ q → trStmts₁ q' ⊆ insert (Λ'.succ q) (insert (unrev q) (trStmts₁ q))) case pred q' q₁ q₂ : Λ' q₁_ih : q' ∈ trStmts₁ q₁ → trStmts₁ q' ⊆ trStmts₁ q₁ q₂_ih : q' ∈ trStmts₁ q₂ → trStmts₁ q' ⊆ trStmts₁ q₂ ⊢ (q' ∈ trStmts₁ q₁ → trStmts₁ q' ⊆ insert (Λ'.pred q₁ q₂) (trStmts₁ q₁ ∪ insert (unrev q₂) (trStmts₁ q₂))) ∧ (q' = unrev q₂ → insert (Λ'.move (fun x => false) rev main q₂) (trStmts₁ q₂) ⊆ insert (Λ'.pred q₁ q₂) (trStmts₁ q₁ ∪ insert (unrev q₂) (trStmts₁ q₂))) ∧ (q' ∈ trStmts₁ q₂ → trStmts₁ q' ⊆ insert (Λ'.pred q₁ q₂) (trStmts₁ q₁ ∪ insert (unrev q₂) (trStmts₁ q₂))) ** iterate 4 exact fun h => Finset.Subset.trans (q_ih h) (Finset.subset_insert _ _) ** case push q' : Λ' k✝ : K' s✝ : Option Γ' → Option Γ' q : Λ' q_ih : q' ∈ trStmts₁ q → trStmts₁ q' ⊆ trStmts₁ q ⊢ q' ∈ trStmts₁ q → trStmts₁ q' ⊆ insert (Λ'.push k✝ s✝ q) (trStmts₁ q) case read q' : Λ' q : Option Γ' → Λ' q_ih : ∀ (a : Option Γ'), q' ∈ trStmts₁ (q a) → trStmts₁ q' ⊆ trStmts₁ (q a) ⊢ (q' ∈ Finset.biUnion Finset.univ fun s => trStmts₁ (q s)) → trStmts₁ q' ⊆ insert (Λ'.read q) (Finset.biUnion Finset.univ fun s => trStmts₁ (q s)) case succ q' q : Λ' q_ih : q' ∈ trStmts₁ q → trStmts₁ q' ⊆ trStmts₁ q ⊢ (q' = unrev q → insert (Λ'.move (fun x => false) rev main q) (trStmts₁ q) ⊆ insert (Λ'.succ q) (insert (unrev q) (trStmts₁ q))) ∧ (q' ∈ trStmts₁ q → trStmts₁ q' ⊆ insert (Λ'.succ q) (insert (unrev q) (trStmts₁ q))) case pred q' q₁ q₂ : Λ' q₁_ih : q' ∈ trStmts₁ q₁ → trStmts₁ q' ⊆ trStmts₁ q₁ q₂_ih : q' ∈ trStmts₁ q₂ → trStmts₁ q' ⊆ trStmts₁ q₂ ⊢ (q' ∈ trStmts₁ q₁ → trStmts₁ q' ⊆ insert (Λ'.pred q₁ q₂) (trStmts₁ q₁ ∪ insert (unrev q₂) (trStmts₁ q₂))) ∧ (q' = unrev q₂ → insert (Λ'.move (fun x => false) rev main q₂) (trStmts₁ q₂) ⊆ insert (Λ'.pred q₁ q₂) (trStmts₁ q₁ ∪ insert (unrev q₂) (trStmts₁ q₂))) ∧ (q' ∈ trStmts₁ q₂ → trStmts₁ q' ⊆ insert (Λ'.pred q₁ q₂) (trStmts₁ q₁ ∪ insert (unrev q₂) (trStmts₁ q₂))) ** exact fun h => Finset.Subset.trans (q_ih h) (Finset.subset_insert _ _) ** case read q' : Λ' q : Option Γ' → Λ' q_ih : ∀ (a : Option Γ'), q' ∈ trStmts₁ (q a) → trStmts₁ q' ⊆ trStmts₁ (q a) ⊢ (q' ∈ Finset.biUnion Finset.univ fun s => trStmts₁ (q s)) → trStmts₁ q' ⊆ insert (Λ'.read q) (Finset.biUnion Finset.univ fun s => trStmts₁ (q s)) ** simp ** case read q' : Λ' q : Option Γ' → Λ' q_ih : ∀ (a : Option Γ'), q' ∈ trStmts₁ (q a) → trStmts₁ q' ⊆ trStmts₁ (q a) ⊢ ∀ (x : Option Γ'), q' ∈ trStmts₁ (q x) → trStmts₁ q' ⊆ insert (Λ'.read q) (Finset.biUnion Finset.univ fun s => trStmts₁ (q s)) ** intro s h x h' ** case read q' : Λ' q : Option Γ' → Λ' q_ih : ∀ (a : Option Γ'), q' ∈ trStmts₁ (q a) → trStmts₁ q' ⊆ trStmts₁ (q a) s : Option Γ' h : q' ∈ trStmts₁ (q s) x : Λ' h' : x ∈ trStmts₁ q' ⊢ x ∈ insert (Λ'.read q) (Finset.biUnion Finset.univ fun s => trStmts₁ (q s)) ** simp only [Finset.mem_biUnion, Finset.mem_univ, true_and, Finset.mem_insert] ** case read q' : Λ' q : Option Γ' → Λ' q_ih : ∀ (a : Option Γ'), q' ∈ trStmts₁ (q a) → trStmts₁ q' ⊆ trStmts₁ (q a) s : Option Γ' h : q' ∈ trStmts₁ (q s) x : Λ' h' : x ∈ trStmts₁ q' ⊢ x = Λ'.read q ∨ ∃ a, x ∈ trStmts₁ (q a) ** exact Or.inr ⟨_, q_ih s h h'⟩ ** case succ q' q : Λ' q_ih : q' ∈ trStmts₁ q → trStmts₁ q' ⊆ trStmts₁ q ⊢ (q' = unrev q → insert (Λ'.move (fun x => false) rev main q) (trStmts₁ q) ⊆ insert (Λ'.succ q) (insert (unrev q) (trStmts₁ q))) ∧ (q' ∈ trStmts₁ q → trStmts₁ q' ⊆ insert (Λ'.succ q) (insert (unrev q) (trStmts₁ q))) ** constructor ** case succ.left q' q : Λ' q_ih : q' ∈ trStmts₁ q → trStmts₁ q' ⊆ trStmts₁ q ⊢ q' = unrev q → insert (Λ'.move (fun x => false) rev main q) (trStmts₁ q) ⊆ insert (Λ'.succ q) (insert (unrev q) (trStmts₁ q)) ** rintro rfl ** case succ.left q : Λ' q_ih : unrev q ∈ trStmts₁ q → trStmts₁ (unrev q) ⊆ trStmts₁ q ⊢ insert (Λ'.move (fun x => false) rev main q) (trStmts₁ q) ⊆ insert (Λ'.succ q) (insert (unrev q) (trStmts₁ q)) ** apply Finset.subset_insert ** case succ.right q' q : Λ' q_ih : q' ∈ trStmts₁ q → trStmts₁ q' ⊆ trStmts₁ q ⊢ q' ∈ trStmts₁ q → trStmts₁ q' ⊆ insert (Λ'.succ q) (insert (unrev q) (trStmts₁ q)) ** intro h x h' ** case succ.right q' q : Λ' q_ih : q' ∈ trStmts₁ q → trStmts₁ q' ⊆ trStmts₁ q h : q' ∈ trStmts₁ q x : Λ' h' : x ∈ trStmts₁ q' ⊢ x ∈ insert (Λ'.succ q) (insert (unrev q) (trStmts₁ q)) ** simp only [Finset.mem_insert] ** case succ.right q' q : Λ' q_ih : q' ∈ trStmts₁ q → trStmts₁ q' ⊆ trStmts₁ q h : q' ∈ trStmts₁ q x : Λ' h' : x ∈ trStmts₁ q' ⊢ x = Λ'.succ q ∨ x = unrev q ∨ x ∈ trStmts₁ q ** exact Or.inr (Or.inr <| q_ih h h') ** case pred q' q₁ q₂ : Λ' q₁_ih : q' ∈ trStmts₁ q₁ → trStmts₁ q' ⊆ trStmts₁ q₁ q₂_ih : q' ∈ trStmts₁ q₂ → trStmts₁ q' ⊆ trStmts₁ q₂ ⊢ (q' ∈ trStmts₁ q₁ → trStmts₁ q' ⊆ insert (Λ'.pred q₁ q₂) (trStmts₁ q₁ ∪ insert (unrev q₂) (trStmts₁ q₂))) ∧ (q' = unrev q₂ → insert (Λ'.move (fun x => false) rev main q₂) (trStmts₁ q₂) ⊆ insert (Λ'.pred q₁ q₂) (trStmts₁ q₁ ∪ insert (unrev q₂) (trStmts₁ q₂))) ∧ (q' ∈ trStmts₁ q₂ → trStmts₁ q' ⊆ insert (Λ'.pred q₁ q₂) (trStmts₁ q₁ ∪ insert (unrev q₂) (trStmts₁ q₂))) ** refine' ⟨fun h x h' => _, fun _ x h' => _, fun h x h' => _⟩ <;> simp ** case pred.refine'_1 q' q₁ q₂ : Λ' q₁_ih : q' ∈ trStmts₁ q₁ → trStmts₁ q' ⊆ trStmts₁ q₁ q₂_ih : q' ∈ trStmts₁ q₂ → trStmts₁ q' ⊆ trStmts₁ q₂ h : q' ∈ trStmts₁ q₁ x : Λ' h' : x ∈ trStmts₁ q' ⊢ x = Λ'.pred q₁ q₂ ∨ x = unrev q₂ ∨ x ∈ trStmts₁ q₁ ∨ x ∈ trStmts₁ q₂ ** exact Or.inr (Or.inr <| Or.inl <| q₁_ih h h') ** case pred.refine'_2 q' q₁ q₂ : Λ' q₁_ih : q' ∈ trStmts₁ q₁ → trStmts₁ q' ⊆ trStmts₁ q₁ q₂_ih : q' ∈ trStmts₁ q₂ → trStmts₁ q' ⊆ trStmts₁ q₂ x✝ : q' = unrev q₂ x : Λ' h' : x ∈ insert (Λ'.move (fun x => false) rev main q₂) (trStmts₁ q₂) ⊢ x = Λ'.pred q₁ q₂ ∨ x = unrev q₂ ∨ x ∈ trStmts₁ q₁ ∨ x ∈ trStmts₁ q₂ ** cases' Finset.mem_insert.1 h' with h' h' <;> simp [h', unrev] ** case pred.refine'_3 q' q₁ q₂ : Λ' q₁_ih : q' ∈ trStmts₁ q₁ → trStmts₁ q' ⊆ trStmts₁ q₁ q₂_ih : q' ∈ trStmts₁ q₂ → trStmts₁ q' ⊆ trStmts₁ q₂ h : q' ∈ trStmts₁ q₂ x : Λ' h' : x ∈ trStmts₁ q' ⊢ x = Λ'.pred q₁ q₂ ∨ x = unrev q₂ ∨ x ∈ trStmts₁ q₁ ∨ x ∈ trStmts₁ q₂ ** exact Or.inr (Or.inr <| Or.inr <| q₂_ih h h') ** Qed
| |
Turing.PartrecToTM2.trStmts₁_self ** case ret k✝ : Cont' ⊢ Λ'.ret k✝ ∈ trStmts₁ (Λ'.ret k✝) ** first |apply Finset.mem_singleton_self|apply Finset.mem_insert_self ** case ret k✝ : Cont' ⊢ Λ'.ret k✝ ∈ trStmts₁ (Λ'.ret k✝) ** apply Finset.mem_singleton_self ** case pred q₁✝ q₂✝ : Λ' q₁_ih✝ : q₁✝ ∈ trStmts₁ q₁✝ q₂_ih✝ : q₂✝ ∈ trStmts₁ q₂✝ ⊢ Λ'.pred q₁✝ q₂✝ ∈ trStmts₁ (Λ'.pred q₁✝ q₂✝) ** apply Finset.mem_insert_self ** Qed
| |
Turing.PartrecToTM2.codeSupp'_self ** c : Code k : Cont' ⊢ trStmts₁ (trNormal c k) ⊆ codeSupp' c k ** cases c <;> first |rfl|exact Finset.subset_union_left _ _ ** case tail k : Cont' ⊢ trStmts₁ (trNormal Code.tail k) ⊆ codeSupp' Code.tail k ** rfl ** case fix k : Cont' a✝ : Code ⊢ trStmts₁ (trNormal (Code.fix a✝) k) ⊆ codeSupp' (Code.fix a✝) k ** exact Finset.subset_union_left _ _ ** Qed
| |
Turing.PartrecToTM2.codeSupp_cons ** f fs : Code k : Cont' ⊢ codeSupp (Code.cons f fs) k = trStmts₁ (trNormal (Code.cons f fs) k) ∪ codeSupp f (Cont'.cons₁ fs k) ** simp [codeSupp, codeSupp', contSupp, Finset.union_assoc] ** Qed
| |
Turing.PartrecToTM2.codeSupp_comp ** f g : Code k : Cont' ⊢ codeSupp (Code.comp f g) k = trStmts₁ (trNormal (Code.comp f g) k) ∪ codeSupp g (Cont'.comp f k) ** simp only [codeSupp, codeSupp', trNormal, Finset.union_assoc, contSupp] ** f g : Code k : Cont' ⊢ trStmts₁ (trNormal g (Cont'.comp f k)) ∪ (codeSupp' g (Cont'.comp f k) ∪ (trStmts₁ (trNormal f k) ∪ (codeSupp' f k ∪ contSupp k))) = trStmts₁ (trNormal g (Cont'.comp f k)) ∪ (codeSupp' g (Cont'.comp f k) ∪ (codeSupp' f k ∪ contSupp k)) ** rw [← Finset.union_assoc _ _ (contSupp k),
Finset.union_eq_right.2 (codeSupp'_self _ _)] ** Qed
| |
Turing.PartrecToTM2.codeSupp_case ** f g : Code k : Cont' ⊢ codeSupp (Code.case f g) k = trStmts₁ (trNormal (Code.case f g) k) ∪ (codeSupp f k ∪ codeSupp g k) ** simp [codeSupp, codeSupp', contSupp, Finset.union_assoc, Finset.union_left_comm] ** Qed
| |
Turing.PartrecToTM2.contSupp_cons₁ ** fs : Code k : Cont' ⊢ contSupp (Cont'.cons₁ fs k) = trStmts₁ (move₂ (fun x => false) main aux (move₂ (fun s => decide (s = Γ'.consₗ)) stack main (move₂ (fun x => false) aux stack (trNormal fs (Cont'.cons₂ k))))) ∪ codeSupp fs (Cont'.cons₂ k) ** simp [codeSupp, codeSupp', contSupp, Finset.union_assoc] ** Qed
| |
Turing.PartrecToTM2.contSupp_fix ** f : Code k : Cont' ⊢ contSupp (Cont'.fix f k) = codeSupp f (Cont'.fix f k) ** simp (config := { contextual := true }) [codeSupp, codeSupp', contSupp, Finset.union_assoc,
Finset.subset_iff] ** Qed
| |
Turing.PartrecToTM2.supports_insert ** K S : Finset Λ' q : Λ' ⊢ Supports (insert q K) S ↔ TM2.SupportsStmt S (tr q) ∧ Supports K S ** simp [Supports] ** Qed
| |
Turing.PartrecToTM2.supports_singleton ** S : Finset Λ' q : Λ' ⊢ Supports {q} S ↔ TM2.SupportsStmt S (tr q) ** simp [Supports] ** Qed
| |
Turing.PartrecToTM2.supports_union ** K₁ K₂ S : Finset Λ' ⊢ Supports (K₁ ∪ K₂) S ↔ Supports K₁ S ∧ Supports K₂ S ** simp [Supports, or_imp, forall_and] ** Qed
| |
Turing.PartrecToTM2.supports_biUnion ** K : Option Γ' → Finset Λ' S : Finset Λ' ⊢ Supports (Finset.biUnion Finset.univ K) S ↔ ∀ (a : Option Γ'), Supports (K a) S ** simp [Supports] ** K : Option Γ' → Finset Λ' S : Finset Λ' ⊢ (∀ (q : Λ') (x : Option Γ'), q ∈ K x → TM2.SupportsStmt S (tr q)) ↔ ∀ (a : Option Γ') (q : Λ'), q ∈ K a → TM2.SupportsStmt S (tr q) ** apply forall_swap ** Qed
| |
Turing.PartrecToTM2.head_supports ** S : Finset Λ' k : K' q : Λ' H : Λ'.Supports S q x✝ : Option Γ' ⊢ Λ'.Supports S ((fun s => ite (s = some Γ'.consₗ) id (Λ'.clear (fun x => decide (x = Γ'.consₗ)) k) (unrev q)) x✝) ** dsimp only ** S : Finset Λ' k : K' q : Λ' H : Λ'.Supports S q x✝ : Option Γ' ⊢ Λ'.Supports S (ite (x✝ = some Γ'.consₗ) id (Λ'.clear (fun x => decide (x = Γ'.consₗ)) k) (unrev q)) ** split_ifs <;> exact H ** Qed
| |
Turing.PartrecToTM2.trStmts₁_supports' ** S : Finset Λ' q : Λ' K : Finset Λ' H₁ : Λ'.Supports S q H₂ : trStmts₁ q ∪ K ⊆ S H₃ : K ⊆ S → Supports K S ⊢ Supports (trStmts₁ q ∪ K) S ** simp [Finset.union_subset_iff] at H₂ ** S : Finset Λ' q : Λ' K : Finset Λ' H₁ : Λ'.Supports S q H₃ : K ⊆ S → Supports K S H₂ : trStmts₁ q ⊆ S ∧ K ⊆ S ⊢ Supports (trStmts₁ q ∪ K) S ** exact supports_union.2 ⟨trStmts₁_supports H₁ H₂.1, H₃ H₂.2⟩ ** Qed
| |
Turing.PartrecToTM2.trNormal_supports ** S : Finset Λ' c : Code k : Cont' Hk : codeSupp c k ⊆ S ⊢ Λ'.Supports S (trNormal c k) ** induction c generalizing k <;> simp [Λ'.Supports, head] ** case zero' S : Finset Λ' k : Cont' Hk : codeSupp Code.zero' k ⊆ S ⊢ contSupp k ⊆ S case succ S : Finset Λ' k : Cont' Hk : codeSupp Code.succ k ⊆ S ⊢ ∀ (s : Option Γ'), Λ'.Supports S (ite (s = some Γ'.consₗ) id (Λ'.clear (fun x => decide (x = Γ'.consₗ)) main) (unrev (Λ'.succ (Λ'.ret k)))) case tail S : Finset Λ' k : Cont' Hk : codeSupp Code.tail k ⊆ S ⊢ contSupp k ⊆ S case cons S : Finset Λ' a✝¹ a✝ : Code a_ih✝¹ : ∀ {k : Cont'}, codeSupp a✝¹ k ⊆ S → Λ'.Supports S (trNormal a✝¹ k) a_ih✝ : ∀ {k : Cont'}, codeSupp a✝ k ⊆ S → Λ'.Supports S (trNormal a✝ k) k : Cont' Hk : codeSupp (Code.cons a✝¹ a✝) k ⊆ S ⊢ Λ'.Supports S (trNormal a✝¹ (Cont'.cons₁ a✝ k)) case comp S : Finset Λ' a✝¹ a✝ : Code a_ih✝¹ : ∀ {k : Cont'}, codeSupp a✝¹ k ⊆ S → Λ'.Supports S (trNormal a✝¹ k) a_ih✝ : ∀ {k : Cont'}, codeSupp a✝ k ⊆ S → Λ'.Supports S (trNormal a✝ k) k : Cont' Hk : codeSupp (Code.comp a✝¹ a✝) k ⊆ S ⊢ Λ'.Supports S (trNormal a✝ (Cont'.comp a✝¹ k)) case case S : Finset Λ' a✝¹ a✝ : Code a_ih✝¹ : ∀ {k : Cont'}, codeSupp a✝¹ k ⊆ S → Λ'.Supports S (trNormal a✝¹ k) a_ih✝ : ∀ {k : Cont'}, codeSupp a✝ k ⊆ S → Λ'.Supports S (trNormal a✝ k) k : Cont' Hk : codeSupp (Code.case a✝¹ a✝) k ⊆ S ⊢ Λ'.Supports S (trNormal a✝¹ k) ∧ Λ'.Supports S (trNormal a✝ k) case fix S : Finset Λ' a✝ : Code a_ih✝ : ∀ {k : Cont'}, codeSupp a✝ k ⊆ S → Λ'.Supports S (trNormal a✝ k) k : Cont' Hk : codeSupp (Code.fix a✝) k ⊆ S ⊢ Λ'.Supports S (trNormal a✝ (Cont'.fix a✝ k)) ** case zero' => exact Finset.union_subset_right Hk ** case succ S : Finset Λ' k : Cont' Hk : codeSupp Code.succ k ⊆ S ⊢ ∀ (s : Option Γ'), Λ'.Supports S (ite (s = some Γ'.consₗ) id (Λ'.clear (fun x => decide (x = Γ'.consₗ)) main) (unrev (Λ'.succ (Λ'.ret k)))) case tail S : Finset Λ' k : Cont' Hk : codeSupp Code.tail k ⊆ S ⊢ contSupp k ⊆ S case cons S : Finset Λ' a✝¹ a✝ : Code a_ih✝¹ : ∀ {k : Cont'}, codeSupp a✝¹ k ⊆ S → Λ'.Supports S (trNormal a✝¹ k) a_ih✝ : ∀ {k : Cont'}, codeSupp a✝ k ⊆ S → Λ'.Supports S (trNormal a✝ k) k : Cont' Hk : codeSupp (Code.cons a✝¹ a✝) k ⊆ S ⊢ Λ'.Supports S (trNormal a✝¹ (Cont'.cons₁ a✝ k)) case comp S : Finset Λ' a✝¹ a✝ : Code a_ih✝¹ : ∀ {k : Cont'}, codeSupp a✝¹ k ⊆ S → Λ'.Supports S (trNormal a✝¹ k) a_ih✝ : ∀ {k : Cont'}, codeSupp a✝ k ⊆ S → Λ'.Supports S (trNormal a✝ k) k : Cont' Hk : codeSupp (Code.comp a✝¹ a✝) k ⊆ S ⊢ Λ'.Supports S (trNormal a✝ (Cont'.comp a✝¹ k)) case case S : Finset Λ' a✝¹ a✝ : Code a_ih✝¹ : ∀ {k : Cont'}, codeSupp a✝¹ k ⊆ S → Λ'.Supports S (trNormal a✝¹ k) a_ih✝ : ∀ {k : Cont'}, codeSupp a✝ k ⊆ S → Λ'.Supports S (trNormal a✝ k) k : Cont' Hk : codeSupp (Code.case a✝¹ a✝) k ⊆ S ⊢ Λ'.Supports S (trNormal a✝¹ k) ∧ Λ'.Supports S (trNormal a✝ k) case fix S : Finset Λ' a✝ : Code a_ih✝ : ∀ {k : Cont'}, codeSupp a✝ k ⊆ S → Λ'.Supports S (trNormal a✝ k) k : Cont' Hk : codeSupp (Code.fix a✝) k ⊆ S ⊢ Λ'.Supports S (trNormal a✝ (Cont'.fix a✝ k)) ** case succ => intro; split_ifs <;> exact Finset.union_subset_right Hk ** case tail S : Finset Λ' k : Cont' Hk : codeSupp Code.tail k ⊆ S ⊢ contSupp k ⊆ S case cons S : Finset Λ' a✝¹ a✝ : Code a_ih✝¹ : ∀ {k : Cont'}, codeSupp a✝¹ k ⊆ S → Λ'.Supports S (trNormal a✝¹ k) a_ih✝ : ∀ {k : Cont'}, codeSupp a✝ k ⊆ S → Λ'.Supports S (trNormal a✝ k) k : Cont' Hk : codeSupp (Code.cons a✝¹ a✝) k ⊆ S ⊢ Λ'.Supports S (trNormal a✝¹ (Cont'.cons₁ a✝ k)) case comp S : Finset Λ' a✝¹ a✝ : Code a_ih✝¹ : ∀ {k : Cont'}, codeSupp a✝¹ k ⊆ S → Λ'.Supports S (trNormal a✝¹ k) a_ih✝ : ∀ {k : Cont'}, codeSupp a✝ k ⊆ S → Λ'.Supports S (trNormal a✝ k) k : Cont' Hk : codeSupp (Code.comp a✝¹ a✝) k ⊆ S ⊢ Λ'.Supports S (trNormal a✝ (Cont'.comp a✝¹ k)) case case S : Finset Λ' a✝¹ a✝ : Code a_ih✝¹ : ∀ {k : Cont'}, codeSupp a✝¹ k ⊆ S → Λ'.Supports S (trNormal a✝¹ k) a_ih✝ : ∀ {k : Cont'}, codeSupp a✝ k ⊆ S → Λ'.Supports S (trNormal a✝ k) k : Cont' Hk : codeSupp (Code.case a✝¹ a✝) k ⊆ S ⊢ Λ'.Supports S (trNormal a✝¹ k) ∧ Λ'.Supports S (trNormal a✝ k) case fix S : Finset Λ' a✝ : Code a_ih✝ : ∀ {k : Cont'}, codeSupp a✝ k ⊆ S → Λ'.Supports S (trNormal a✝ k) k : Cont' Hk : codeSupp (Code.fix a✝) k ⊆ S ⊢ Λ'.Supports S (trNormal a✝ (Cont'.fix a✝ k)) ** case tail => exact Finset.union_subset_right Hk ** case cons S : Finset Λ' a✝¹ a✝ : Code a_ih✝¹ : ∀ {k : Cont'}, codeSupp a✝¹ k ⊆ S → Λ'.Supports S (trNormal a✝¹ k) a_ih✝ : ∀ {k : Cont'}, codeSupp a✝ k ⊆ S → Λ'.Supports S (trNormal a✝ k) k : Cont' Hk : codeSupp (Code.cons a✝¹ a✝) k ⊆ S ⊢ Λ'.Supports S (trNormal a✝¹ (Cont'.cons₁ a✝ k)) case comp S : Finset Λ' a✝¹ a✝ : Code a_ih✝¹ : ∀ {k : Cont'}, codeSupp a✝¹ k ⊆ S → Λ'.Supports S (trNormal a✝¹ k) a_ih✝ : ∀ {k : Cont'}, codeSupp a✝ k ⊆ S → Λ'.Supports S (trNormal a✝ k) k : Cont' Hk : codeSupp (Code.comp a✝¹ a✝) k ⊆ S ⊢ Λ'.Supports S (trNormal a✝ (Cont'.comp a✝¹ k)) case case S : Finset Λ' a✝¹ a✝ : Code a_ih✝¹ : ∀ {k : Cont'}, codeSupp a✝¹ k ⊆ S → Λ'.Supports S (trNormal a✝¹ k) a_ih✝ : ∀ {k : Cont'}, codeSupp a✝ k ⊆ S → Λ'.Supports S (trNormal a✝ k) k : Cont' Hk : codeSupp (Code.case a✝¹ a✝) k ⊆ S ⊢ Λ'.Supports S (trNormal a✝¹ k) ∧ Λ'.Supports S (trNormal a✝ k) case fix S : Finset Λ' a✝ : Code a_ih✝ : ∀ {k : Cont'}, codeSupp a✝ k ⊆ S → Λ'.Supports S (trNormal a✝ k) k : Cont' Hk : codeSupp (Code.fix a✝) k ⊆ S ⊢ Λ'.Supports S (trNormal a✝ (Cont'.fix a✝ k)) ** case cons f fs IHf _ =>
apply IHf
rw [codeSupp_cons] at Hk
exact Finset.union_subset_right Hk ** case comp S : Finset Λ' a✝¹ a✝ : Code a_ih✝¹ : ∀ {k : Cont'}, codeSupp a✝¹ k ⊆ S → Λ'.Supports S (trNormal a✝¹ k) a_ih✝ : ∀ {k : Cont'}, codeSupp a✝ k ⊆ S → Λ'.Supports S (trNormal a✝ k) k : Cont' Hk : codeSupp (Code.comp a✝¹ a✝) k ⊆ S ⊢ Λ'.Supports S (trNormal a✝ (Cont'.comp a✝¹ k)) case case S : Finset Λ' a✝¹ a✝ : Code a_ih✝¹ : ∀ {k : Cont'}, codeSupp a✝¹ k ⊆ S → Λ'.Supports S (trNormal a✝¹ k) a_ih✝ : ∀ {k : Cont'}, codeSupp a✝ k ⊆ S → Λ'.Supports S (trNormal a✝ k) k : Cont' Hk : codeSupp (Code.case a✝¹ a✝) k ⊆ S ⊢ Λ'.Supports S (trNormal a✝¹ k) ∧ Λ'.Supports S (trNormal a✝ k) case fix S : Finset Λ' a✝ : Code a_ih✝ : ∀ {k : Cont'}, codeSupp a✝ k ⊆ S → Λ'.Supports S (trNormal a✝ k) k : Cont' Hk : codeSupp (Code.fix a✝) k ⊆ S ⊢ Λ'.Supports S (trNormal a✝ (Cont'.fix a✝ k)) ** case comp f g _ IHg => apply IHg; rw [codeSupp_comp] at Hk; exact Finset.union_subset_right Hk ** case case S : Finset Λ' a✝¹ a✝ : Code a_ih✝¹ : ∀ {k : Cont'}, codeSupp a✝¹ k ⊆ S → Λ'.Supports S (trNormal a✝¹ k) a_ih✝ : ∀ {k : Cont'}, codeSupp a✝ k ⊆ S → Λ'.Supports S (trNormal a✝ k) k : Cont' Hk : codeSupp (Code.case a✝¹ a✝) k ⊆ S ⊢ Λ'.Supports S (trNormal a✝¹ k) ∧ Λ'.Supports S (trNormal a✝ k) case fix S : Finset Λ' a✝ : Code a_ih✝ : ∀ {k : Cont'}, codeSupp a✝ k ⊆ S → Λ'.Supports S (trNormal a✝ k) k : Cont' Hk : codeSupp (Code.fix a✝) k ⊆ S ⊢ Λ'.Supports S (trNormal a✝ (Cont'.fix a✝ k)) ** case
case f g IHf IHg =>
simp only [codeSupp_case, Finset.union_subset_iff] at Hk
exact ⟨IHf Hk.2.1, IHg Hk.2.2⟩ ** case fix S : Finset Λ' a✝ : Code a_ih✝ : ∀ {k : Cont'}, codeSupp a✝ k ⊆ S → Λ'.Supports S (trNormal a✝ k) k : Cont' Hk : codeSupp (Code.fix a✝) k ⊆ S ⊢ Λ'.Supports S (trNormal a✝ (Cont'.fix a✝ k)) ** case fix f IHf => apply IHf; rw [codeSupp_fix] at Hk; exact Finset.union_subset_right Hk ** S : Finset Λ' k : Cont' Hk : codeSupp Code.zero' k ⊆ S ⊢ contSupp k ⊆ S ** exact Finset.union_subset_right Hk ** S : Finset Λ' k : Cont' Hk : codeSupp Code.succ k ⊆ S ⊢ ∀ (s : Option Γ'), Λ'.Supports S (ite (s = some Γ'.consₗ) id (Λ'.clear (fun x => decide (x = Γ'.consₗ)) main) (unrev (Λ'.succ (Λ'.ret k)))) ** intro ** S : Finset Λ' k : Cont' Hk : codeSupp Code.succ k ⊆ S s✝ : Option Γ' ⊢ Λ'.Supports S (ite (s✝ = some Γ'.consₗ) id (Λ'.clear (fun x => decide (x = Γ'.consₗ)) main) (unrev (Λ'.succ (Λ'.ret k)))) ** split_ifs <;> exact Finset.union_subset_right Hk ** S : Finset Λ' k : Cont' Hk : codeSupp Code.tail k ⊆ S ⊢ contSupp k ⊆ S ** exact Finset.union_subset_right Hk ** S : Finset Λ' f fs : Code IHf : ∀ {k : Cont'}, codeSupp f k ⊆ S → Λ'.Supports S (trNormal f k) a_ih✝ : ∀ {k : Cont'}, codeSupp fs k ⊆ S → Λ'.Supports S (trNormal fs k) k : Cont' Hk : codeSupp (Code.cons f fs) k ⊆ S ⊢ Λ'.Supports S (trNormal f (Cont'.cons₁ fs k)) ** apply IHf ** case Hk S : Finset Λ' f fs : Code IHf : ∀ {k : Cont'}, codeSupp f k ⊆ S → Λ'.Supports S (trNormal f k) a_ih✝ : ∀ {k : Cont'}, codeSupp fs k ⊆ S → Λ'.Supports S (trNormal fs k) k : Cont' Hk : codeSupp (Code.cons f fs) k ⊆ S ⊢ codeSupp f (Cont'.cons₁ fs k) ⊆ S ** rw [codeSupp_cons] at Hk ** case Hk S : Finset Λ' f fs : Code IHf : ∀ {k : Cont'}, codeSupp f k ⊆ S → Λ'.Supports S (trNormal f k) a_ih✝ : ∀ {k : Cont'}, codeSupp fs k ⊆ S → Λ'.Supports S (trNormal fs k) k : Cont' Hk : trStmts₁ (trNormal (Code.cons f fs) k) ∪ codeSupp f (Cont'.cons₁ fs k) ⊆ S ⊢ codeSupp f (Cont'.cons₁ fs k) ⊆ S ** exact Finset.union_subset_right Hk ** S : Finset Λ' f g : Code a_ih✝ : ∀ {k : Cont'}, codeSupp f k ⊆ S → Λ'.Supports S (trNormal f k) IHg : ∀ {k : Cont'}, codeSupp g k ⊆ S → Λ'.Supports S (trNormal g k) k : Cont' Hk : codeSupp (Code.comp f g) k ⊆ S ⊢ Λ'.Supports S (trNormal g (Cont'.comp f k)) ** apply IHg ** case Hk S : Finset Λ' f g : Code a_ih✝ : ∀ {k : Cont'}, codeSupp f k ⊆ S → Λ'.Supports S (trNormal f k) IHg : ∀ {k : Cont'}, codeSupp g k ⊆ S → Λ'.Supports S (trNormal g k) k : Cont' Hk : codeSupp (Code.comp f g) k ⊆ S ⊢ codeSupp g (Cont'.comp f k) ⊆ S ** rw [codeSupp_comp] at Hk ** case Hk S : Finset Λ' f g : Code a_ih✝ : ∀ {k : Cont'}, codeSupp f k ⊆ S → Λ'.Supports S (trNormal f k) IHg : ∀ {k : Cont'}, codeSupp g k ⊆ S → Λ'.Supports S (trNormal g k) k : Cont' Hk : trStmts₁ (trNormal (Code.comp f g) k) ∪ codeSupp g (Cont'.comp f k) ⊆ S ⊢ codeSupp g (Cont'.comp f k) ⊆ S ** exact Finset.union_subset_right Hk ** S : Finset Λ' f g : Code IHf : ∀ {k : Cont'}, codeSupp f k ⊆ S → Λ'.Supports S (trNormal f k) IHg : ∀ {k : Cont'}, codeSupp g k ⊆ S → Λ'.Supports S (trNormal g k) k : Cont' Hk : codeSupp (Code.case f g) k ⊆ S ⊢ Λ'.Supports S (trNormal f k) ∧ Λ'.Supports S (trNormal g k) ** simp only [codeSupp_case, Finset.union_subset_iff] at Hk ** S : Finset Λ' f g : Code IHf : ∀ {k : Cont'}, codeSupp f k ⊆ S → Λ'.Supports S (trNormal f k) IHg : ∀ {k : Cont'}, codeSupp g k ⊆ S → Λ'.Supports S (trNormal g k) k : Cont' Hk : trStmts₁ (trNormal (Code.case f g) k) ⊆ S ∧ codeSupp f k ⊆ S ∧ codeSupp g k ⊆ S ⊢ Λ'.Supports S (trNormal f k) ∧ Λ'.Supports S (trNormal g k) ** exact ⟨IHf Hk.2.1, IHg Hk.2.2⟩ ** S : Finset Λ' f : Code IHf : ∀ {k : Cont'}, codeSupp f k ⊆ S → Λ'.Supports S (trNormal f k) k : Cont' Hk : codeSupp (Code.fix f) k ⊆ S ⊢ Λ'.Supports S (trNormal f (Cont'.fix f k)) ** apply IHf ** case Hk S : Finset Λ' f : Code IHf : ∀ {k : Cont'}, codeSupp f k ⊆ S → Λ'.Supports S (trNormal f k) k : Cont' Hk : codeSupp (Code.fix f) k ⊆ S ⊢ codeSupp f (Cont'.fix f k) ⊆ S ** rw [codeSupp_fix] at Hk ** case Hk S : Finset Λ' f : Code IHf : ∀ {k : Cont'}, codeSupp f k ⊆ S → Λ'.Supports S (trNormal f k) k : Cont' Hk : trStmts₁ (trNormal (Code.fix f) k) ∪ codeSupp f (Cont'.fix f k) ⊆ S ⊢ codeSupp f (Cont'.fix f k) ⊆ S ** exact Finset.union_subset_right Hk ** Qed
| |
Turing.PartrecToTM2.codeSupp'_supports ** S : Finset Λ' c : Code k : Cont' H : codeSupp c k ⊆ S ⊢ Supports (codeSupp' c k) S ** induction c generalizing k ** case zero' S : Finset Λ' k : Cont' H : codeSupp Code.zero' k ⊆ S ⊢ Supports (codeSupp' Code.zero' k) S case succ S : Finset Λ' k : Cont' H : codeSupp Code.succ k ⊆ S ⊢ Supports (codeSupp' Code.succ k) S case tail S : Finset Λ' k : Cont' H : codeSupp Code.tail k ⊆ S ⊢ Supports (codeSupp' Code.tail k) S case cons S : Finset Λ' a✝¹ a✝ : Code a_ih✝¹ : ∀ {k : Cont'}, codeSupp a✝¹ k ⊆ S → Supports (codeSupp' a✝¹ k) S a_ih✝ : ∀ {k : Cont'}, codeSupp a✝ k ⊆ S → Supports (codeSupp' a✝ k) S k : Cont' H : codeSupp (Code.cons a✝¹ a✝) k ⊆ S ⊢ Supports (codeSupp' (Code.cons a✝¹ a✝) k) S case comp S : Finset Λ' a✝¹ a✝ : Code a_ih✝¹ : ∀ {k : Cont'}, codeSupp a✝¹ k ⊆ S → Supports (codeSupp' a✝¹ k) S a_ih✝ : ∀ {k : Cont'}, codeSupp a✝ k ⊆ S → Supports (codeSupp' a✝ k) S k : Cont' H : codeSupp (Code.comp a✝¹ a✝) k ⊆ S ⊢ Supports (codeSupp' (Code.comp a✝¹ a✝) k) S case case S : Finset Λ' a✝¹ a✝ : Code a_ih✝¹ : ∀ {k : Cont'}, codeSupp a✝¹ k ⊆ S → Supports (codeSupp' a✝¹ k) S a_ih✝ : ∀ {k : Cont'}, codeSupp a✝ k ⊆ S → Supports (codeSupp' a✝ k) S k : Cont' H : codeSupp (Code.case a✝¹ a✝) k ⊆ S ⊢ Supports (codeSupp' (Code.case a✝¹ a✝) k) S case fix S : Finset Λ' a✝ : Code a_ih✝ : ∀ {k : Cont'}, codeSupp a✝ k ⊆ S → Supports (codeSupp' a✝ k) S k : Cont' H : codeSupp (Code.fix a✝) k ⊆ S ⊢ Supports (codeSupp' (Code.fix a✝) k) S ** iterate 3
exact trStmts₁_supports (trNormal_supports H) (Finset.Subset.trans (codeSupp_self _ _) H) ** case case S : Finset Λ' a✝¹ a✝ : Code a_ih✝¹ : ∀ {k : Cont'}, codeSupp a✝¹ k ⊆ S → Supports (codeSupp' a✝¹ k) S a_ih✝ : ∀ {k : Cont'}, codeSupp a✝ k ⊆ S → Supports (codeSupp' a✝ k) S k : Cont' H : codeSupp (Code.case a✝¹ a✝) k ⊆ S ⊢ Supports (codeSupp' (Code.case a✝¹ a✝) k) S case fix S : Finset Λ' a✝ : Code a_ih✝ : ∀ {k : Cont'}, codeSupp a✝ k ⊆ S → Supports (codeSupp' a✝ k) S k : Cont' H : codeSupp (Code.fix a✝) k ⊆ S ⊢ Supports (codeSupp' (Code.fix a✝) k) S ** case case f g IHf IHg =>
have H' := H; simp only [codeSupp_case, Finset.union_subset_iff] at H'
refine' trStmts₁_supports' (trNormal_supports H) (Finset.union_subset_left H) fun _ => _
exact supports_union.2 ⟨IHf H'.2.1, IHg H'.2.2⟩ ** case tail S : Finset Λ' k : Cont' H : codeSupp Code.tail k ⊆ S ⊢ Supports (codeSupp' Code.tail k) S case cons S : Finset Λ' a✝¹ a✝ : Code a_ih✝¹ : ∀ {k : Cont'}, codeSupp a✝¹ k ⊆ S → Supports (codeSupp' a✝¹ k) S a_ih✝ : ∀ {k : Cont'}, codeSupp a✝ k ⊆ S → Supports (codeSupp' a✝ k) S k : Cont' H : codeSupp (Code.cons a✝¹ a✝) k ⊆ S ⊢ Supports (codeSupp' (Code.cons a✝¹ a✝) k) S case comp S : Finset Λ' a✝¹ a✝ : Code a_ih✝¹ : ∀ {k : Cont'}, codeSupp a✝¹ k ⊆ S → Supports (codeSupp' a✝¹ k) S a_ih✝ : ∀ {k : Cont'}, codeSupp a✝ k ⊆ S → Supports (codeSupp' a✝ k) S k : Cont' H : codeSupp (Code.comp a✝¹ a✝) k ⊆ S ⊢ Supports (codeSupp' (Code.comp a✝¹ a✝) k) S case case S : Finset Λ' a✝¹ a✝ : Code a_ih✝¹ : ∀ {k : Cont'}, codeSupp a✝¹ k ⊆ S → Supports (codeSupp' a✝¹ k) S a_ih✝ : ∀ {k : Cont'}, codeSupp a✝ k ⊆ S → Supports (codeSupp' a✝ k) S k : Cont' H : codeSupp (Code.case a✝¹ a✝) k ⊆ S ⊢ Supports (codeSupp' (Code.case a✝¹ a✝) k) S case fix S : Finset Λ' a✝ : Code a_ih✝ : ∀ {k : Cont'}, codeSupp a✝ k ⊆ S → Supports (codeSupp' a✝ k) S k : Cont' H : codeSupp (Code.fix a✝) k ⊆ S ⊢ Supports (codeSupp' (Code.fix a✝) k) S ** exact trStmts₁_supports (trNormal_supports H) (Finset.Subset.trans (codeSupp_self _ _) H) ** S : Finset Λ' f fs : Code IHf : ∀ {k : Cont'}, codeSupp f k ⊆ S → Supports (codeSupp' f k) S IHfs : ∀ {k : Cont'}, codeSupp fs k ⊆ S → Supports (codeSupp' fs k) S k : Cont' H : codeSupp (Code.cons f fs) k ⊆ S ⊢ Supports (codeSupp' (Code.cons f fs) k) S ** have H' := H ** S : Finset Λ' f fs : Code IHf : ∀ {k : Cont'}, codeSupp f k ⊆ S → Supports (codeSupp' f k) S IHfs : ∀ {k : Cont'}, codeSupp fs k ⊆ S → Supports (codeSupp' fs k) S k : Cont' H H' : codeSupp (Code.cons f fs) k ⊆ S ⊢ Supports (codeSupp' (Code.cons f fs) k) S ** simp only [codeSupp_cons, Finset.union_subset_iff] at H' ** S : Finset Λ' f fs : Code IHf : ∀ {k : Cont'}, codeSupp f k ⊆ S → Supports (codeSupp' f k) S IHfs : ∀ {k : Cont'}, codeSupp fs k ⊆ S → Supports (codeSupp' fs k) S k : Cont' H : codeSupp (Code.cons f fs) k ⊆ S H' : trStmts₁ (trNormal (Code.cons f fs) k) ⊆ S ∧ codeSupp f (Cont'.cons₁ fs k) ⊆ S ⊢ Supports (codeSupp' (Code.cons f fs) k) S ** refine' trStmts₁_supports' (trNormal_supports H) (Finset.union_subset_left H) fun h => _ ** S : Finset Λ' f fs : Code IHf : ∀ {k : Cont'}, codeSupp f k ⊆ S → Supports (codeSupp' f k) S IHfs : ∀ {k : Cont'}, codeSupp fs k ⊆ S → Supports (codeSupp' fs k) S k : Cont' H : codeSupp (Code.cons f fs) k ⊆ S H' : trStmts₁ (trNormal (Code.cons f fs) k) ⊆ S ∧ codeSupp f (Cont'.cons₁ fs k) ⊆ S h : codeSupp' f (Cont'.cons₁ fs k) ∪ (trStmts₁ (move₂ (fun x => false) main aux (move₂ (fun s => decide (s = Γ'.consₗ)) stack main (move₂ (fun x => false) aux stack (trNormal fs (Cont'.cons₂ k))))) ∪ (codeSupp' fs (Cont'.cons₂ k) ∪ trStmts₁ (head stack (Λ'.ret k)))) ⊆ S ⊢ Supports (codeSupp' f (Cont'.cons₁ fs k) ∪ (trStmts₁ (move₂ (fun x => false) main aux (move₂ (fun s => decide (s = Γ'.consₗ)) stack main (move₂ (fun x => false) aux stack (trNormal fs (Cont'.cons₂ k))))) ∪ (codeSupp' fs (Cont'.cons₂ k) ∪ trStmts₁ (head stack (Λ'.ret k))))) S ** refine' supports_union.2 ⟨IHf H'.2, _⟩ ** S : Finset Λ' f fs : Code IHf : ∀ {k : Cont'}, codeSupp f k ⊆ S → Supports (codeSupp' f k) S IHfs : ∀ {k : Cont'}, codeSupp fs k ⊆ S → Supports (codeSupp' fs k) S k : Cont' H : codeSupp (Code.cons f fs) k ⊆ S H' : trStmts₁ (trNormal (Code.cons f fs) k) ⊆ S ∧ codeSupp f (Cont'.cons₁ fs k) ⊆ S h : codeSupp' f (Cont'.cons₁ fs k) ∪ (trStmts₁ (move₂ (fun x => false) main aux (move₂ (fun s => decide (s = Γ'.consₗ)) stack main (move₂ (fun x => false) aux stack (trNormal fs (Cont'.cons₂ k))))) ∪ (codeSupp' fs (Cont'.cons₂ k) ∪ trStmts₁ (head stack (Λ'.ret k)))) ⊆ S ⊢ Supports (trStmts₁ (move₂ (fun x => false) main aux (move₂ (fun s => decide (s = Γ'.consₗ)) stack main (move₂ (fun x => false) aux stack (trNormal fs (Cont'.cons₂ k))))) ∪ (codeSupp' fs (Cont'.cons₂ k) ∪ trStmts₁ (head stack (Λ'.ret k)))) S ** refine' trStmts₁_supports' (trNormal_supports _) (Finset.union_subset_right h) fun h => _ ** case refine'_2 S : Finset Λ' f fs : Code IHf : ∀ {k : Cont'}, codeSupp f k ⊆ S → Supports (codeSupp' f k) S IHfs : ∀ {k : Cont'}, codeSupp fs k ⊆ S → Supports (codeSupp' fs k) S k : Cont' H : codeSupp (Code.cons f fs) k ⊆ S H' : trStmts₁ (trNormal (Code.cons f fs) k) ⊆ S ∧ codeSupp f (Cont'.cons₁ fs k) ⊆ S h✝ : codeSupp' f (Cont'.cons₁ fs k) ∪ (trStmts₁ (move₂ (fun x => false) main aux (move₂ (fun s => decide (s = Γ'.consₗ)) stack main (move₂ (fun x => false) aux stack (trNormal fs (Cont'.cons₂ k))))) ∪ (codeSupp' fs (Cont'.cons₂ k) ∪ trStmts₁ (head stack (Λ'.ret k)))) ⊆ S h : codeSupp' fs (Cont'.cons₂ k) ∪ trStmts₁ (head stack (Λ'.ret k)) ⊆ S ⊢ Supports (codeSupp' fs (Cont'.cons₂ k) ∪ trStmts₁ (head stack (Λ'.ret k))) S ** refine' supports_union.2 ⟨IHfs _, _⟩ ** case refine'_2.refine'_2 S : Finset Λ' f fs : Code IHf : ∀ {k : Cont'}, codeSupp f k ⊆ S → Supports (codeSupp' f k) S IHfs : ∀ {k : Cont'}, codeSupp fs k ⊆ S → Supports (codeSupp' fs k) S k : Cont' H : codeSupp (Code.cons f fs) k ⊆ S H' : trStmts₁ (trNormal (Code.cons f fs) k) ⊆ S ∧ codeSupp f (Cont'.cons₁ fs k) ⊆ S h✝ : codeSupp' f (Cont'.cons₁ fs k) ∪ (trStmts₁ (move₂ (fun x => false) main aux (move₂ (fun s => decide (s = Γ'.consₗ)) stack main (move₂ (fun x => false) aux stack (trNormal fs (Cont'.cons₂ k))))) ∪ (codeSupp' fs (Cont'.cons₂ k) ∪ trStmts₁ (head stack (Λ'.ret k)))) ⊆ S h : codeSupp' fs (Cont'.cons₂ k) ∪ trStmts₁ (head stack (Λ'.ret k)) ⊆ S ⊢ Supports (trStmts₁ (head stack (Λ'.ret k))) S ** exact
trStmts₁_supports (head_supports <| Finset.union_subset_right H)
(Finset.union_subset_right h) ** case refine'_1 S : Finset Λ' f fs : Code IHf : ∀ {k : Cont'}, codeSupp f k ⊆ S → Supports (codeSupp' f k) S IHfs : ∀ {k : Cont'}, codeSupp fs k ⊆ S → Supports (codeSupp' fs k) S k : Cont' H : codeSupp (Code.cons f fs) k ⊆ S H' : trStmts₁ (trNormal (Code.cons f fs) k) ⊆ S ∧ codeSupp f (Cont'.cons₁ fs k) ⊆ S h : codeSupp' f (Cont'.cons₁ fs k) ∪ (trStmts₁ (move₂ (fun x => false) main aux (move₂ (fun s => decide (s = Γ'.consₗ)) stack main (move₂ (fun x => false) aux stack (trNormal fs (Cont'.cons₂ k))))) ∪ (codeSupp' fs (Cont'.cons₂ k) ∪ trStmts₁ (head stack (Λ'.ret k)))) ⊆ S ⊢ codeSupp fs (Cont'.cons₂ k) ⊆ S ** simp only [codeSupp, Finset.union_subset_iff, contSupp] at h H ⊢ ** case refine'_1 S : Finset Λ' f fs : Code IHf : ∀ {k : Cont'}, codeSupp f k ⊆ S → Supports (codeSupp' f k) S IHfs : ∀ {k : Cont'}, codeSupp fs k ⊆ S → Supports (codeSupp' fs k) S k : Cont' H' : trStmts₁ (trNormal (Code.cons f fs) k) ⊆ S ∧ codeSupp f (Cont'.cons₁ fs k) ⊆ S h : codeSupp' f (Cont'.cons₁ fs k) ⊆ S ∧ trStmts₁ (move₂ (fun x => false) main aux (move₂ (fun s => decide (s = Γ'.consₗ)) stack main (move₂ (fun x => false) aux stack (trNormal fs (Cont'.cons₂ k))))) ⊆ S ∧ codeSupp' fs (Cont'.cons₂ k) ⊆ S ∧ trStmts₁ (head stack (Λ'.ret k)) ⊆ S H : codeSupp' (Code.cons f fs) k ⊆ S ∧ contSupp k ⊆ S ⊢ codeSupp' fs (Cont'.cons₂ k) ⊆ S ∧ trStmts₁ (head stack (Λ'.ret k)) ⊆ S ∧ contSupp k ⊆ S ** exact ⟨h.2.2.1, h.2.2.2, H.2⟩ ** case refine'_2.refine'_1 S : Finset Λ' f fs : Code IHf : ∀ {k : Cont'}, codeSupp f k ⊆ S → Supports (codeSupp' f k) S IHfs : ∀ {k : Cont'}, codeSupp fs k ⊆ S → Supports (codeSupp' fs k) S k : Cont' H : codeSupp (Code.cons f fs) k ⊆ S H' : trStmts₁ (trNormal (Code.cons f fs) k) ⊆ S ∧ codeSupp f (Cont'.cons₁ fs k) ⊆ S h✝ : codeSupp' f (Cont'.cons₁ fs k) ∪ (trStmts₁ (move₂ (fun x => false) main aux (move₂ (fun s => decide (s = Γ'.consₗ)) stack main (move₂ (fun x => false) aux stack (trNormal fs (Cont'.cons₂ k))))) ∪ (codeSupp' fs (Cont'.cons₂ k) ∪ trStmts₁ (head stack (Λ'.ret k)))) ⊆ S h : codeSupp' fs (Cont'.cons₂ k) ∪ trStmts₁ (head stack (Λ'.ret k)) ⊆ S ⊢ codeSupp fs (Cont'.cons₂ k) ⊆ S ** rw [codeSupp, contSupp_cons₁] at H' ** case refine'_2.refine'_1 S : Finset Λ' f fs : Code IHf : ∀ {k : Cont'}, codeSupp f k ⊆ S → Supports (codeSupp' f k) S IHfs : ∀ {k : Cont'}, codeSupp fs k ⊆ S → Supports (codeSupp' fs k) S k : Cont' H : codeSupp (Code.cons f fs) k ⊆ S H' : trStmts₁ (trNormal (Code.cons f fs) k) ⊆ S ∧ codeSupp' f (Cont'.cons₁ fs k) ∪ (trStmts₁ (move₂ (fun x => false) main aux (move₂ (fun s => decide (s = Γ'.consₗ)) stack main (move₂ (fun x => false) aux stack (trNormal fs (Cont'.cons₂ k))))) ∪ codeSupp fs (Cont'.cons₂ k)) ⊆ S h✝ : codeSupp' f (Cont'.cons₁ fs k) ∪ (trStmts₁ (move₂ (fun x => false) main aux (move₂ (fun s => decide (s = Γ'.consₗ)) stack main (move₂ (fun x => false) aux stack (trNormal fs (Cont'.cons₂ k))))) ∪ (codeSupp' fs (Cont'.cons₂ k) ∪ trStmts₁ (head stack (Λ'.ret k)))) ⊆ S h : codeSupp' fs (Cont'.cons₂ k) ∪ trStmts₁ (head stack (Λ'.ret k)) ⊆ S ⊢ codeSupp fs (Cont'.cons₂ k) ⊆ S ** exact Finset.union_subset_right (Finset.union_subset_right H'.2) ** S : Finset Λ' f g : Code IHf : ∀ {k : Cont'}, codeSupp f k ⊆ S → Supports (codeSupp' f k) S IHg : ∀ {k : Cont'}, codeSupp g k ⊆ S → Supports (codeSupp' g k) S k : Cont' H : codeSupp (Code.comp f g) k ⊆ S ⊢ Supports (codeSupp' (Code.comp f g) k) S ** have H' := H ** S : Finset Λ' f g : Code IHf : ∀ {k : Cont'}, codeSupp f k ⊆ S → Supports (codeSupp' f k) S IHg : ∀ {k : Cont'}, codeSupp g k ⊆ S → Supports (codeSupp' g k) S k : Cont' H H' : codeSupp (Code.comp f g) k ⊆ S ⊢ Supports (codeSupp' (Code.comp f g) k) S ** rw [codeSupp_comp] at H' ** S : Finset Λ' f g : Code IHf : ∀ {k : Cont'}, codeSupp f k ⊆ S → Supports (codeSupp' f k) S IHg : ∀ {k : Cont'}, codeSupp g k ⊆ S → Supports (codeSupp' g k) S k : Cont' H : codeSupp (Code.comp f g) k ⊆ S H' : trStmts₁ (trNormal (Code.comp f g) k) ∪ codeSupp g (Cont'.comp f k) ⊆ S ⊢ Supports (codeSupp' (Code.comp f g) k) S ** have H' := Finset.union_subset_right H' ** S : Finset Λ' f g : Code IHf : ∀ {k : Cont'}, codeSupp f k ⊆ S → Supports (codeSupp' f k) S IHg : ∀ {k : Cont'}, codeSupp g k ⊆ S → Supports (codeSupp' g k) S k : Cont' H : codeSupp (Code.comp f g) k ⊆ S H'✝ : trStmts₁ (trNormal (Code.comp f g) k) ∪ codeSupp g (Cont'.comp f k) ⊆ S H' : codeSupp g (Cont'.comp f k) ⊆ S ⊢ Supports (codeSupp' (Code.comp f g) k) S ** refine' trStmts₁_supports' (trNormal_supports H) (Finset.union_subset_left H) fun h => _ ** S : Finset Λ' f g : Code IHf : ∀ {k : Cont'}, codeSupp f k ⊆ S → Supports (codeSupp' f k) S IHg : ∀ {k : Cont'}, codeSupp g k ⊆ S → Supports (codeSupp' g k) S k : Cont' H : codeSupp (Code.comp f g) k ⊆ S H'✝ : trStmts₁ (trNormal (Code.comp f g) k) ∪ codeSupp g (Cont'.comp f k) ⊆ S H' : codeSupp g (Cont'.comp f k) ⊆ S h : codeSupp' g (Cont'.comp f k) ∪ (trStmts₁ (trNormal f k) ∪ codeSupp' f k) ⊆ S ⊢ Supports (codeSupp' g (Cont'.comp f k) ∪ (trStmts₁ (trNormal f k) ∪ codeSupp' f k)) S ** refine' supports_union.2 ⟨IHg H', _⟩ ** S : Finset Λ' f g : Code IHf : ∀ {k : Cont'}, codeSupp f k ⊆ S → Supports (codeSupp' f k) S IHg : ∀ {k : Cont'}, codeSupp g k ⊆ S → Supports (codeSupp' g k) S k : Cont' H : codeSupp (Code.comp f g) k ⊆ S H'✝ : trStmts₁ (trNormal (Code.comp f g) k) ∪ codeSupp g (Cont'.comp f k) ⊆ S H' : codeSupp g (Cont'.comp f k) ⊆ S h : codeSupp' g (Cont'.comp f k) ∪ (trStmts₁ (trNormal f k) ∪ codeSupp' f k) ⊆ S ⊢ Supports (trStmts₁ (trNormal f k) ∪ codeSupp' f k) S ** refine' trStmts₁_supports' (trNormal_supports _) (Finset.union_subset_right h) fun _ => _ ** case refine'_2 S : Finset Λ' f g : Code IHf : ∀ {k : Cont'}, codeSupp f k ⊆ S → Supports (codeSupp' f k) S IHg : ∀ {k : Cont'}, codeSupp g k ⊆ S → Supports (codeSupp' g k) S k : Cont' H : codeSupp (Code.comp f g) k ⊆ S H'✝ : trStmts₁ (trNormal (Code.comp f g) k) ∪ codeSupp g (Cont'.comp f k) ⊆ S H' : codeSupp g (Cont'.comp f k) ⊆ S h : codeSupp' g (Cont'.comp f k) ∪ (trStmts₁ (trNormal f k) ∪ codeSupp' f k) ⊆ S x✝ : codeSupp' f k ⊆ S ⊢ Supports (codeSupp' f k) S ** exact IHf (Finset.union_subset_right H') ** case refine'_1 S : Finset Λ' f g : Code IHf : ∀ {k : Cont'}, codeSupp f k ⊆ S → Supports (codeSupp' f k) S IHg : ∀ {k : Cont'}, codeSupp g k ⊆ S → Supports (codeSupp' g k) S k : Cont' H : codeSupp (Code.comp f g) k ⊆ S H'✝ : trStmts₁ (trNormal (Code.comp f g) k) ∪ codeSupp g (Cont'.comp f k) ⊆ S H' : codeSupp g (Cont'.comp f k) ⊆ S h : codeSupp' g (Cont'.comp f k) ∪ (trStmts₁ (trNormal f k) ∪ codeSupp' f k) ⊆ S ⊢ codeSupp f k ⊆ S ** simp only [codeSupp', codeSupp, Finset.union_subset_iff, contSupp] at h H ⊢ ** case refine'_1 S : Finset Λ' f g : Code IHf : ∀ {k : Cont'}, codeSupp f k ⊆ S → Supports (codeSupp' f k) S IHg : ∀ {k : Cont'}, codeSupp g k ⊆ S → Supports (codeSupp' g k) S k : Cont' H'✝ : trStmts₁ (trNormal (Code.comp f g) k) ∪ codeSupp g (Cont'.comp f k) ⊆ S H' : codeSupp g (Cont'.comp f k) ⊆ S h : codeSupp' g (Cont'.comp f k) ⊆ S ∧ trStmts₁ (trNormal f k) ⊆ S ∧ codeSupp' f k ⊆ S H : (trStmts₁ (trNormal (Code.comp f g) k) ⊆ S ∧ codeSupp' g (Cont'.comp f k) ⊆ S ∧ trStmts₁ (trNormal f k) ⊆ S ∧ codeSupp' f k ⊆ S) ∧ contSupp k ⊆ S ⊢ codeSupp' f k ⊆ S ∧ contSupp k ⊆ S ** exact ⟨h.2.2, H.2⟩ ** S : Finset Λ' f g : Code IHf : ∀ {k : Cont'}, codeSupp f k ⊆ S → Supports (codeSupp' f k) S IHg : ∀ {k : Cont'}, codeSupp g k ⊆ S → Supports (codeSupp' g k) S k : Cont' H : codeSupp (Code.case f g) k ⊆ S ⊢ Supports (codeSupp' (Code.case f g) k) S ** have H' := H ** S : Finset Λ' f g : Code IHf : ∀ {k : Cont'}, codeSupp f k ⊆ S → Supports (codeSupp' f k) S IHg : ∀ {k : Cont'}, codeSupp g k ⊆ S → Supports (codeSupp' g k) S k : Cont' H H' : codeSupp (Code.case f g) k ⊆ S ⊢ Supports (codeSupp' (Code.case f g) k) S ** simp only [codeSupp_case, Finset.union_subset_iff] at H' ** S : Finset Λ' f g : Code IHf : ∀ {k : Cont'}, codeSupp f k ⊆ S → Supports (codeSupp' f k) S IHg : ∀ {k : Cont'}, codeSupp g k ⊆ S → Supports (codeSupp' g k) S k : Cont' H : codeSupp (Code.case f g) k ⊆ S H' : trStmts₁ (trNormal (Code.case f g) k) ⊆ S ∧ codeSupp f k ⊆ S ∧ codeSupp g k ⊆ S ⊢ Supports (codeSupp' (Code.case f g) k) S ** refine' trStmts₁_supports' (trNormal_supports H) (Finset.union_subset_left H) fun _ => _ ** S : Finset Λ' f g : Code IHf : ∀ {k : Cont'}, codeSupp f k ⊆ S → Supports (codeSupp' f k) S IHg : ∀ {k : Cont'}, codeSupp g k ⊆ S → Supports (codeSupp' g k) S k : Cont' H : codeSupp (Code.case f g) k ⊆ S H' : trStmts₁ (trNormal (Code.case f g) k) ⊆ S ∧ codeSupp f k ⊆ S ∧ codeSupp g k ⊆ S x✝ : codeSupp' f k ∪ codeSupp' g k ⊆ S ⊢ Supports (codeSupp' f k ∪ codeSupp' g k) S ** exact supports_union.2 ⟨IHf H'.2.1, IHg H'.2.2⟩ ** S : Finset Λ' f : Code IHf : ∀ {k : Cont'}, codeSupp f k ⊆ S → Supports (codeSupp' f k) S k : Cont' H : codeSupp (Code.fix f) k ⊆ S ⊢ Supports (codeSupp' (Code.fix f) k) S ** have H' := H ** S : Finset Λ' f : Code IHf : ∀ {k : Cont'}, codeSupp f k ⊆ S → Supports (codeSupp' f k) S k : Cont' H H' : codeSupp (Code.fix f) k ⊆ S ⊢ Supports (codeSupp' (Code.fix f) k) S ** simp only [codeSupp_fix, Finset.union_subset_iff] at H' ** S : Finset Λ' f : Code IHf : ∀ {k : Cont'}, codeSupp f k ⊆ S → Supports (codeSupp' f k) S k : Cont' H : codeSupp (Code.fix f) k ⊆ S H' : trStmts₁ (trNormal (Code.fix f) k) ⊆ S ∧ codeSupp f (Cont'.fix f k) ⊆ S ⊢ Supports (codeSupp' (Code.fix f) k) S ** refine' trStmts₁_supports' (trNormal_supports H) (Finset.union_subset_left H) fun h => _ ** S : Finset Λ' f : Code IHf : ∀ {k : Cont'}, codeSupp f k ⊆ S → Supports (codeSupp' f k) S k : Cont' H : codeSupp (Code.fix f) k ⊆ S H' : trStmts₁ (trNormal (Code.fix f) k) ⊆ S ∧ codeSupp f (Cont'.fix f k) ⊆ S h : codeSupp' f (Cont'.fix f k) ∪ (trStmts₁ (Λ'.clear natEnd main (trNormal f (Cont'.fix f k))) ∪ {Λ'.ret k}) ⊆ S ⊢ Supports (codeSupp' f (Cont'.fix f k) ∪ (trStmts₁ (Λ'.clear natEnd main (trNormal f (Cont'.fix f k))) ∪ {Λ'.ret k})) S ** refine' supports_union.2 ⟨IHf H'.2, _⟩ ** S : Finset Λ' f : Code IHf : ∀ {k : Cont'}, codeSupp f k ⊆ S → Supports (codeSupp' f k) S k : Cont' H : codeSupp (Code.fix f) k ⊆ S H' : trStmts₁ (trNormal (Code.fix f) k) ⊆ S ∧ codeSupp f (Cont'.fix f k) ⊆ S h : codeSupp' f (Cont'.fix f k) ∪ (trStmts₁ (Λ'.clear natEnd main (trNormal f (Cont'.fix f k))) ∪ {Λ'.ret k}) ⊆ S ⊢ Supports (trStmts₁ (Λ'.clear natEnd main (trNormal f (Cont'.fix f k))) ∪ {Λ'.ret k}) S ** refine' trStmts₁_supports' (trNormal_supports _) (Finset.union_subset_right h) fun _ => _ ** case refine'_2 S : Finset Λ' f : Code IHf : ∀ {k : Cont'}, codeSupp f k ⊆ S → Supports (codeSupp' f k) S k : Cont' H : codeSupp (Code.fix f) k ⊆ S H' : trStmts₁ (trNormal (Code.fix f) k) ⊆ S ∧ codeSupp f (Cont'.fix f k) ⊆ S h : codeSupp' f (Cont'.fix f k) ∪ (trStmts₁ (Λ'.clear natEnd main (trNormal f (Cont'.fix f k))) ∪ {Λ'.ret k}) ⊆ S x✝ : {Λ'.ret k} ⊆ S ⊢ Supports {Λ'.ret k} S ** exact supports_singleton.2 (ret_supports <| Finset.union_subset_right H) ** case refine'_1 S : Finset Λ' f : Code IHf : ∀ {k : Cont'}, codeSupp f k ⊆ S → Supports (codeSupp' f k) S k : Cont' H : codeSupp (Code.fix f) k ⊆ S H' : trStmts₁ (trNormal (Code.fix f) k) ⊆ S ∧ codeSupp f (Cont'.fix f k) ⊆ S h : codeSupp' f (Cont'.fix f k) ∪ (trStmts₁ (Λ'.clear natEnd main (trNormal f (Cont'.fix f k))) ∪ {Λ'.ret k}) ⊆ S ⊢ codeSupp f (Cont'.fix f k) ⊆ S ** simp only [codeSupp', codeSupp, Finset.union_subset_iff, contSupp, trStmts₁,
Finset.insert_subset_iff] at h H ⊢ ** case refine'_1 S : Finset Λ' f : Code IHf : ∀ {k : Cont'}, codeSupp f k ⊆ S → Supports (codeSupp' f k) S k : Cont' H' : trStmts₁ (trNormal (Code.fix f) k) ⊆ S ∧ codeSupp f (Cont'.fix f k) ⊆ S h : codeSupp' f (Cont'.fix f k) ⊆ S ∧ (Λ'.clear natEnd main (trNormal f (Cont'.fix f k)) ∈ S ∧ trStmts₁ (trNormal f (Cont'.fix f k)) ⊆ S) ∧ {Λ'.ret k} ⊆ S H : (trStmts₁ (trNormal (Code.fix f) k) ⊆ S ∧ codeSupp' f (Cont'.fix f k) ⊆ S ∧ (Λ'.clear natEnd main (trNormal f (Cont'.fix f k)) ∈ S ∧ trStmts₁ (trNormal f (Cont'.fix f k)) ⊆ S) ∧ {Λ'.ret k} ⊆ S) ∧ contSupp k ⊆ S ⊢ codeSupp' f (Cont'.fix f k) ⊆ S ∧ (trStmts₁ (trNormal (Code.fix f) k) ⊆ S ∧ codeSupp' f (Cont'.fix f k) ⊆ S ∧ (Λ'.clear natEnd main (trNormal f (Cont'.fix f k)) ∈ S ∧ trStmts₁ (trNormal f (Cont'.fix f k)) ⊆ S) ∧ {Λ'.ret k} ⊆ S) ∧ contSupp k ⊆ S ** exact ⟨h.1, ⟨H.1.1, h⟩, H.2⟩ ** Qed
| |
MeasureTheory.Content.mono ** G : Type w inst✝ : TopologicalSpace G μ : Content G K₁ K₂ : Compacts G h : ↑K₁ ⊆ ↑K₂ ⊢ (fun s => ↑(toFun μ s)) K₁ ≤ (fun s => ↑(toFun μ s)) K₂ ** simp [apply_eq_coe_toFun, μ.mono' _ _ h] ** Qed
| |
MeasureTheory.Content.sup_disjoint ** G : Type w inst✝ : TopologicalSpace G μ : Content G K₁ K₂ : Compacts G h : Disjoint ↑K₁ ↑K₂ ⊢ (fun s => ↑(toFun μ s)) (K₁ ⊔ K₂) = (fun s => ↑(toFun μ s)) K₁ + (fun s => ↑(toFun μ s)) K₂ ** simp [apply_eq_coe_toFun, μ.sup_disjoint' _ _ h] ** Qed
| |
MeasureTheory.Content.sup_le ** G : Type w inst✝ : TopologicalSpace G μ : Content G K₁ K₂ : Compacts G ⊢ (fun s => ↑(toFun μ s)) (K₁ ⊔ K₂) ≤ (fun s => ↑(toFun μ s)) K₁ + (fun s => ↑(toFun μ s)) K₂ ** simp only [apply_eq_coe_toFun] ** G : Type w inst✝ : TopologicalSpace G μ : Content G K₁ K₂ : Compacts G ⊢ ↑(toFun μ (K₁ ⊔ K₂)) ≤ ↑(toFun μ K₁) + ↑(toFun μ K₂) ** norm_cast ** G : Type w inst✝ : TopologicalSpace G μ : Content G K₁ K₂ : Compacts G ⊢ toFun μ (K₁ ⊔ K₂) ≤ toFun μ K₁ + toFun μ K₂ ** exact μ.sup_le' _ _ ** Qed
| |
MeasureTheory.Content.empty ** G : Type w inst✝ : TopologicalSpace G μ : Content G ⊢ (fun s => ↑(toFun μ s)) ⊥ = 0 ** have := μ.sup_disjoint' ⊥ ⊥ ** G : Type w inst✝ : TopologicalSpace G μ : Content G this : Disjoint ↑⊥ ↑⊥ → toFun μ (⊥ ⊔ ⊥) = toFun μ ⊥ + toFun μ ⊥ ⊢ (fun s => ↑(toFun μ s)) ⊥ = 0 ** simpa [apply_eq_coe_toFun] using this ** Qed
| |
MeasureTheory.Content.innerContent_bot ** G : Type w inst✝ : TopologicalSpace G μ : Content G ⊢ innerContent μ ⊥ = 0 ** refine' le_antisymm _ (zero_le _) ** G : Type w inst✝ : TopologicalSpace G μ : Content G ⊢ innerContent μ ⊥ ≤ 0 ** rw [← μ.empty] ** G : Type w inst✝ : TopologicalSpace G μ : Content G ⊢ innerContent μ ⊥ ≤ (fun s => ↑(toFun μ s)) ⊥ ** refine' iSup₂_le fun K hK => _ ** G : Type w inst✝ : TopologicalSpace G μ : Content G K : Compacts G hK : ↑K ⊆ ↑⊥ ⊢ (fun s => ↑(toFun μ s)) K ≤ (fun s => ↑(toFun μ s)) ⊥ ** have : K = ⊥ := by
ext1
rw [subset_empty_iff.mp hK, Compacts.coe_bot] ** G : Type w inst✝ : TopologicalSpace G μ : Content G K : Compacts G hK : ↑K ⊆ ↑⊥ this : K = ⊥ ⊢ (fun s => ↑(toFun μ s)) K ≤ (fun s => ↑(toFun μ s)) ⊥ ** rw [this] ** G : Type w inst✝ : TopologicalSpace G μ : Content G K : Compacts G hK : ↑K ⊆ ↑⊥ ⊢ K = ⊥ ** ext1 ** case h G : Type w inst✝ : TopologicalSpace G μ : Content G K : Compacts G hK : ↑K ⊆ ↑⊥ ⊢ ↑K = ↑⊥ ** rw [subset_empty_iff.mp hK, Compacts.coe_bot] ** Qed
| |
MeasureTheory.Content.innerContent_exists_compact ** G : Type w inst✝ : TopologicalSpace G μ : Content G U : Opens G hU : innerContent μ U ≠ ⊤ ε : ℝ≥0 hε : ε ≠ 0 ⊢ ∃ K, ↑K ⊆ ↑U ∧ innerContent μ U ≤ (fun s => ↑(toFun μ s)) K + ↑ε ** have h'ε := ENNReal.coe_ne_zero.2 hε ** G : Type w inst✝ : TopologicalSpace G μ : Content G U : Opens G hU : innerContent μ U ≠ ⊤ ε : ℝ≥0 hε : ε ≠ 0 h'ε : ↑ε ≠ 0 ⊢ ∃ K, ↑K ⊆ ↑U ∧ innerContent μ U ≤ (fun s => ↑(toFun μ s)) K + ↑ε ** cases' le_or_lt (μ.innerContent U) ε with h h ** case inr G : Type w inst✝ : TopologicalSpace G μ : Content G U : Opens G hU : innerContent μ U ≠ ⊤ ε : ℝ≥0 hε : ε ≠ 0 h'ε : ↑ε ≠ 0 h : ↑ε < innerContent μ U ⊢ ∃ K, ↑K ⊆ ↑U ∧ innerContent μ U ≤ (fun s => ↑(toFun μ s)) K + ↑ε ** have h₂ := ENNReal.sub_lt_self hU h.ne_bot h'ε ** case inr G : Type w inst✝ : TopologicalSpace G μ : Content G U : Opens G hU : innerContent μ U ≠ ⊤ ε : ℝ≥0 hε : ε ≠ 0 h'ε : ↑ε ≠ 0 h : ↑ε < innerContent μ U h₂ : innerContent μ U - ↑ε < innerContent μ U ⊢ ∃ K, ↑K ⊆ ↑U ∧ innerContent μ U ≤ (fun s => ↑(toFun μ s)) K + ↑ε ** conv at h₂ => rhs; rw [innerContent] ** case inr G : Type w inst✝ : TopologicalSpace G μ : Content G U : Opens G hU : innerContent μ U ≠ ⊤ ε : ℝ≥0 hε : ε ≠ 0 h'ε : ↑ε ≠ 0 h : ↑ε < innerContent μ U h₂ : innerContent μ U - ↑ε < ⨆ K, ⨆ (_ : ↑K ⊆ ↑U), (fun s => ↑(toFun μ s)) K ⊢ ∃ K, ↑K ⊆ ↑U ∧ innerContent μ U ≤ (fun s => ↑(toFun μ s)) K + ↑ε ** simp only [lt_iSup_iff] at h₂ ** case inr G : Type w inst✝ : TopologicalSpace G μ : Content G U : Opens G hU : innerContent μ U ≠ ⊤ ε : ℝ≥0 hε : ε ≠ 0 h'ε : ↑ε ≠ 0 h : ↑ε < innerContent μ U h₂ : ∃ i i_1, innerContent μ U - ↑ε < ↑(toFun μ i) ⊢ ∃ K, ↑K ⊆ ↑U ∧ innerContent μ U ≤ (fun s => ↑(toFun μ s)) K + ↑ε ** rcases h₂ with ⟨U, h1U, h2U⟩ ** case inr.intro.intro G : Type w inst✝ : TopologicalSpace G μ : Content G U✝ : Opens G hU : innerContent μ U✝ ≠ ⊤ ε : ℝ≥0 hε : ε ≠ 0 h'ε : ↑ε ≠ 0 h : ↑ε < innerContent μ U✝ U : Compacts G h1U : ↑U ⊆ ↑U✝ h2U : innerContent μ U✝ - ↑ε < ↑(toFun μ U) ⊢ ∃ K, ↑K ⊆ ↑U✝ ∧ innerContent μ U✝ ≤ (fun s => ↑(toFun μ s)) K + ↑ε ** refine' ⟨U, h1U, _⟩ ** case inr.intro.intro G : Type w inst✝ : TopologicalSpace G μ : Content G U✝ : Opens G hU : innerContent μ U✝ ≠ ⊤ ε : ℝ≥0 hε : ε ≠ 0 h'ε : ↑ε ≠ 0 h : ↑ε < innerContent μ U✝ U : Compacts G h1U : ↑U ⊆ ↑U✝ h2U : innerContent μ U✝ - ↑ε < ↑(toFun μ U) ⊢ innerContent μ U✝ ≤ (fun s => ↑(toFun μ s)) U + ↑ε ** rw [← tsub_le_iff_right] ** case inr.intro.intro G : Type w inst✝ : TopologicalSpace G μ : Content G U✝ : Opens G hU : innerContent μ U✝ ≠ ⊤ ε : ℝ≥0 hε : ε ≠ 0 h'ε : ↑ε ≠ 0 h : ↑ε < innerContent μ U✝ U : Compacts G h1U : ↑U ⊆ ↑U✝ h2U : innerContent μ U✝ - ↑ε < ↑(toFun μ U) ⊢ innerContent μ U✝ - ↑ε ≤ (fun s => ↑(toFun μ s)) U ** exact le_of_lt h2U ** case inl G : Type w inst✝ : TopologicalSpace G μ : Content G U : Opens G hU : innerContent μ U ≠ ⊤ ε : ℝ≥0 hε : ε ≠ 0 h'ε : ↑ε ≠ 0 h : innerContent μ U ≤ ↑ε ⊢ ∃ K, ↑K ⊆ ↑U ∧ innerContent μ U ≤ (fun s => ↑(toFun μ s)) K + ↑ε ** exact ⟨⊥, empty_subset _, le_add_left h⟩ ** Qed
| |
MeasureTheory.Content.innerContent_iUnion_nat ** G : Type w inst✝¹ : TopologicalSpace G μ : Content G inst✝ : T2Space G U : ℕ → Set G hU : ∀ (i : ℕ), IsOpen (U i) ⊢ innerContent μ { carrier := ⋃ i, U i, is_open' := (_ : IsOpen (⋃ i, U i)) } ≤ ∑' (i : ℕ), innerContent μ { carrier := U i, is_open' := (_ : IsOpen (U i)) } ** have := μ.innerContent_iSup_nat fun i => ⟨U i, hU i⟩ ** G : Type w inst✝¹ : TopologicalSpace G μ : Content G inst✝ : T2Space G U : ℕ → Set G hU : ∀ (i : ℕ), IsOpen (U i) this : innerContent μ (⨆ i, { carrier := U i, is_open' := (_ : IsOpen (U i)) }) ≤ ∑' (i : ℕ), innerContent μ { carrier := U i, is_open' := (_ : IsOpen (U i)) } ⊢ innerContent μ { carrier := ⋃ i, U i, is_open' := (_ : IsOpen (⋃ i, U i)) } ≤ ∑' (i : ℕ), innerContent μ { carrier := U i, is_open' := (_ : IsOpen (U i)) } ** rwa [Opens.iSup_def] at this ** Qed
| |
MeasureTheory.Content.innerContent_comap ** G : Type w inst✝ : TopologicalSpace G μ : Content G f : G ≃ₜ G h : ∀ ⦃K : Compacts G⦄, (fun s => ↑(toFun μ s)) (Compacts.map ↑f (_ : Continuous ↑f) K) = (fun s => ↑(toFun μ s)) K U : Opens G ⊢ innerContent μ (↑(Opens.comap (Homeomorph.toContinuousMap f)) U) = innerContent μ U ** refine' (Compacts.equiv f).surjective.iSup_congr _ fun K => iSup_congr_Prop image_subset_iff _ ** G : Type w inst✝ : TopologicalSpace G μ : Content G f : G ≃ₜ G h : ∀ ⦃K : Compacts G⦄, (fun s => ↑(toFun μ s)) (Compacts.map ↑f (_ : Continuous ↑f) K) = (fun s => ↑(toFun μ s)) K U : Opens G K : Compacts G ⊢ ↑K ⊆ ↑(↑(Opens.comap (Homeomorph.toContinuousMap f)) U) → (fun s => ↑(toFun μ s)) (↑(Compacts.equiv f) K) = (fun s => ↑(toFun μ s)) K ** intro hK ** G : Type w inst✝ : TopologicalSpace G μ : Content G f : G ≃ₜ G h : ∀ ⦃K : Compacts G⦄, (fun s => ↑(toFun μ s)) (Compacts.map ↑f (_ : Continuous ↑f) K) = (fun s => ↑(toFun μ s)) K U : Opens G K : Compacts G hK : ↑K ⊆ ↑(↑(Opens.comap (Homeomorph.toContinuousMap f)) U) ⊢ (fun s => ↑(toFun μ s)) (↑(Compacts.equiv f) K) = (fun s => ↑(toFun μ s)) K ** simp only [Equiv.coe_fn_mk, Subtype.mk_eq_mk, Compacts.equiv] ** G : Type w inst✝ : TopologicalSpace G μ : Content G f : G ≃ₜ G h : ∀ ⦃K : Compacts G⦄, (fun s => ↑(toFun μ s)) (Compacts.map ↑f (_ : Continuous ↑f) K) = (fun s => ↑(toFun μ s)) K U : Opens G K : Compacts G hK : ↑K ⊆ ↑(↑(Opens.comap (Homeomorph.toContinuousMap f)) U) ⊢ ↑(toFun μ (Compacts.map ↑f (_ : Continuous ↑f) K)) = ↑(toFun μ K) ** apply h ** Qed
| |
MeasureTheory.Content.is_mul_left_invariant_innerContent ** G : Type w inst✝² : TopologicalSpace G μ : Content G inst✝¹ : Group G inst✝ : TopologicalGroup G h : ∀ (g : G) {K : Compacts G}, (fun s => ↑(toFun μ s)) (Compacts.map (fun b => g * b) (_ : Continuous fun b => g * b) K) = (fun s => ↑(toFun μ s)) K g : G U : Opens G ⊢ innerContent μ (↑(Opens.comap (Homeomorph.toContinuousMap (Homeomorph.mulLeft g))) U) = innerContent μ U ** convert μ.innerContent_comap (Homeomorph.mulLeft g) (fun K => h g) U ** Qed
| |
MeasureTheory.Content.le_outerMeasure_compacts ** G : Type w inst✝¹ : TopologicalSpace G μ : Content G inst✝ : T2Space G K : Compacts G ⊢ (fun s => ↑(toFun μ s)) K ≤ ↑(Content.outerMeasure μ) ↑K ** rw [Content.outerMeasure, inducedOuterMeasure_eq_iInf] ** G : Type w inst✝¹ : TopologicalSpace G μ : Content G inst✝ : T2Space G K : Compacts G ⊢ (fun s => ↑(toFun μ s)) K ≤ ⨅ t, ⨅ (ht : IsOpen t), ⨅ (_ : ↑K ⊆ t), innerContent μ { carrier := t, is_open' := ht } ** exact le_iInf fun U => le_iInf fun hU => le_iInf <| μ.le_innerContent K ⟨U, hU⟩ ** case PU G : Type w inst✝¹ : TopologicalSpace G μ : Content G inst✝ : T2Space G K : Compacts G ⊢ ∀ ⦃f : ℕ → Set G⦄, (∀ (i : ℕ), IsOpen (f i)) → IsOpen (⋃ i, f i) ** exact fun U hU => isOpen_iUnion hU ** case msU G : Type w inst✝¹ : TopologicalSpace G μ : Content G inst✝ : T2Space G K : Compacts G ⊢ ∀ ⦃f : ℕ → Set G⦄ (hm : ∀ (i : ℕ), IsOpen (f i)), innerContent μ { carrier := ⋃ i, f i, is_open' := (_ : IsOpen (⋃ i, (fun i => f i) i)) } ≤ ∑' (i : ℕ), innerContent μ { carrier := f i, is_open' := (_ : IsOpen (f i)) } ** exact μ.innerContent_iUnion_nat ** case m_mono G : Type w inst✝¹ : TopologicalSpace G μ : Content G inst✝ : T2Space G K : Compacts G ⊢ ∀ ⦃s₁ s₂ : Set G⦄ (hs₁ : IsOpen s₁) (hs₂ : IsOpen s₂), s₁ ⊆ s₂ → innerContent μ { carrier := s₁, is_open' := hs₁ } ≤ innerContent μ { carrier := s₂, is_open' := hs₂ } ** exact μ.innerContent_mono ** Qed
| |
MeasureTheory.Content.outerMeasure_exists_compact ** G : Type w inst✝¹ : TopologicalSpace G μ : Content G inst✝ : T2Space G U : Opens G hU : ↑(Content.outerMeasure μ) ↑U ≠ ⊤ ε : ℝ≥0 hε : ε ≠ 0 ⊢ ∃ K, ↑K ⊆ ↑U ∧ ↑(Content.outerMeasure μ) ↑U ≤ ↑(Content.outerMeasure μ) ↑K + ↑ε ** rw [μ.outerMeasure_opens] at hU ⊢ ** G : Type w inst✝¹ : TopologicalSpace G μ : Content G inst✝ : T2Space G U : Opens G hU : innerContent μ U ≠ ⊤ ε : ℝ≥0 hε : ε ≠ 0 ⊢ ∃ K, ↑K ⊆ ↑U ∧ innerContent μ U ≤ ↑(Content.outerMeasure μ) ↑K + ↑ε ** rcases μ.innerContent_exists_compact hU hε with ⟨K, h1K, h2K⟩ ** case intro.intro G : Type w inst✝¹ : TopologicalSpace G μ : Content G inst✝ : T2Space G U : Opens G hU : innerContent μ U ≠ ⊤ ε : ℝ≥0 hε : ε ≠ 0 K : Compacts G h1K : ↑K ⊆ ↑U h2K : innerContent μ U ≤ (fun s => ↑(toFun μ s)) K + ↑ε ⊢ ∃ K, ↑K ⊆ ↑U ∧ innerContent μ U ≤ ↑(Content.outerMeasure μ) ↑K + ↑ε ** exact ⟨K, h1K, le_trans h2K <| add_le_add_right (μ.le_outerMeasure_compacts K) _⟩ ** Qed
| |
MeasureTheory.Content.outerMeasure_lt_top_of_isCompact ** G : Type w inst✝² : TopologicalSpace G μ : Content G inst✝¹ : T2Space G inst✝ : WeaklyLocallyCompactSpace G K : Set G hK : IsCompact K ⊢ ↑(Content.outerMeasure μ) K < ⊤ ** rcases exists_compact_superset hK with ⟨F, h1F, h2F⟩ ** case intro.intro G : Type w inst✝² : TopologicalSpace G μ : Content G inst✝¹ : T2Space G inst✝ : WeaklyLocallyCompactSpace G K : Set G hK : IsCompact K F : Set G h1F : IsCompact F h2F : K ⊆ interior F ⊢ ↑(Content.outerMeasure μ) K < ⊤ ** calc
μ.outerMeasure K ≤ μ.outerMeasure (interior F) := OuterMeasure.mono' _ h2F
_ ≤ μ ⟨F, h1F⟩ := by
apply μ.outerMeasure_le ⟨interior F, isOpen_interior⟩ ⟨F, h1F⟩ interior_subset
_ < ⊤ := μ.lt_top _ ** G : Type w inst✝² : TopologicalSpace G μ : Content G inst✝¹ : T2Space G inst✝ : WeaklyLocallyCompactSpace G K : Set G hK : IsCompact K F : Set G h1F : IsCompact F h2F : K ⊆ interior F ⊢ ↑(Content.outerMeasure μ) (interior F) ≤ (fun s => ↑(toFun μ s)) { carrier := F, isCompact' := h1F } ** apply μ.outerMeasure_le ⟨interior F, isOpen_interior⟩ ⟨F, h1F⟩ interior_subset ** Qed
| |
MeasureTheory.Content.is_mul_left_invariant_outerMeasure ** G : Type w inst✝³ : TopologicalSpace G μ : Content G inst✝² : T2Space G inst✝¹ : Group G inst✝ : TopologicalGroup G h : ∀ (g : G) {K : Compacts G}, (fun s => ↑(toFun μ s)) (Compacts.map (fun b => g * b) (_ : Continuous fun b => g * b) K) = (fun s => ↑(toFun μ s)) K g : G A : Set G ⊢ ↑(Content.outerMeasure μ) ((fun x => g * x) ⁻¹' A) = ↑(Content.outerMeasure μ) A ** convert μ.outerMeasure_preimage (Homeomorph.mulLeft g) (fun K => h g) A ** Qed
| |
MeasureTheory.Content.outerMeasure_pos_of_is_mul_left_invariant ** G : Type w inst✝³ : TopologicalSpace G μ : Content G inst✝² : T2Space G inst✝¹ : Group G inst✝ : TopologicalGroup G h3 : ∀ (g : G) {K : Compacts G}, (fun s => ↑(toFun μ s)) (Compacts.map (fun b => g * b) (_ : Continuous fun b => g * b) K) = (fun s => ↑(toFun μ s)) K K : Compacts G hK : (fun s => ↑(toFun μ s)) K ≠ 0 U : Set G h1U : IsOpen U h2U : Set.Nonempty U ⊢ 0 < ↑(Content.outerMeasure μ) U ** convert μ.innerContent_pos_of_is_mul_left_invariant h3 K hK ⟨U, h1U⟩ h2U ** case h.e'_4 G : Type w inst✝³ : TopologicalSpace G μ : Content G inst✝² : T2Space G inst✝¹ : Group G inst✝ : TopologicalGroup G h3 : ∀ (g : G) {K : Compacts G}, (fun s => ↑(toFun μ s)) (Compacts.map (fun b => g * b) (_ : Continuous fun b => g * b) K) = (fun s => ↑(toFun μ s)) K K : Compacts G hK : (fun s => ↑(toFun μ s)) K ≠ 0 U : Set G h1U : IsOpen U h2U : Set.Nonempty U ⊢ ↑(Content.outerMeasure μ) U = innerContent μ { carrier := U, is_open' := h1U } ** exact μ.outerMeasure_opens ⟨U, h1U⟩ ** Qed
| |
MeasureTheory.Content.borel_le_caratheodory ** G : Type w inst✝² : TopologicalSpace G μ : Content G inst✝¹ : T2Space G S : MeasurableSpace G inst✝ : BorelSpace G ⊢ S ≤ OuterMeasure.caratheodory (Content.outerMeasure μ) ** rw [@BorelSpace.measurable_eq G _ _] ** G : Type w inst✝² : TopologicalSpace G μ : Content G inst✝¹ : T2Space G S : MeasurableSpace G inst✝ : BorelSpace G ⊢ borel G ≤ OuterMeasure.caratheodory (Content.outerMeasure μ) ** refine' MeasurableSpace.generateFrom_le _ ** G : Type w inst✝² : TopologicalSpace G μ : Content G inst✝¹ : T2Space G S : MeasurableSpace G inst✝ : BorelSpace G ⊢ ∀ (t : Set G), t ∈ {s | IsOpen s} → MeasurableSet t ** intro U hU ** G : Type w inst✝² : TopologicalSpace G μ : Content G inst✝¹ : T2Space G S : MeasurableSpace G inst✝ : BorelSpace G U : Set G hU : U ∈ {s | IsOpen s} ⊢ MeasurableSet U ** rw [μ.outerMeasure_caratheodory] ** G : Type w inst✝² : TopologicalSpace G μ : Content G inst✝¹ : T2Space G S : MeasurableSpace G inst✝ : BorelSpace G U : Set G hU : U ∈ {s | IsOpen s} ⊢ ∀ (U_1 : Opens G), ↑(Content.outerMeasure μ) (↑U_1 ∩ U) + ↑(Content.outerMeasure μ) (↑U_1 \ U) ≤ ↑(Content.outerMeasure μ) ↑U_1 ** intro U' ** G : Type w inst✝² : TopologicalSpace G μ : Content G inst✝¹ : T2Space G S : MeasurableSpace G inst✝ : BorelSpace G U : Set G hU : U ∈ {s | IsOpen s} U' : Opens G ⊢ ↑(Content.outerMeasure μ) (↑U' ∩ U) + ↑(Content.outerMeasure μ) (↑U' \ U) ≤ ↑(Content.outerMeasure μ) ↑U' ** rw [μ.outerMeasure_of_isOpen ((U' : Set G) ∩ U) (U'.isOpen.inter hU)] ** G : Type w inst✝² : TopologicalSpace G μ : Content G inst✝¹ : T2Space G S : MeasurableSpace G inst✝ : BorelSpace G U : Set G hU : U ∈ {s | IsOpen s} U' : Opens G ⊢ innerContent μ { carrier := ↑U' ∩ U, is_open' := (_ : IsOpen (↑U' ∩ U)) } + ↑(Content.outerMeasure μ) (↑U' \ U) ≤ ↑(Content.outerMeasure μ) ↑U' ** simp only [innerContent, iSup_subtype'] ** G : Type w inst✝² : TopologicalSpace G μ : Content G inst✝¹ : T2Space G S : MeasurableSpace G inst✝ : BorelSpace G U : Set G hU : U ∈ {s | IsOpen s} U' : Opens G ⊢ (⨆ x, ↑(toFun μ ↑x)) + ↑(Content.outerMeasure μ) (↑U' \ U) ≤ ↑(Content.outerMeasure μ) ↑U' ** haveI : Nonempty { L : Compacts G // (L : Set G) ⊆ U' ∩ U } := ⟨⟨⊥, empty_subset _⟩⟩ ** G : Type w inst✝² : TopologicalSpace G μ : Content G inst✝¹ : T2Space G S : MeasurableSpace G inst✝ : BorelSpace G U : Set G hU : U ∈ {s | IsOpen s} U' : Opens G this : Nonempty { L // ↑L ⊆ ↑U' ∩ U } ⊢ (⨆ x, ↑(toFun μ ↑x)) + ↑(Content.outerMeasure μ) (↑U' \ U) ≤ ↑(Content.outerMeasure μ) ↑U' ** rw [ENNReal.iSup_add] ** G : Type w inst✝² : TopologicalSpace G μ : Content G inst✝¹ : T2Space G S : MeasurableSpace G inst✝ : BorelSpace G U : Set G hU : U ∈ {s | IsOpen s} U' : Opens G this : Nonempty { L // ↑L ⊆ ↑U' ∩ U } ⊢ ⨆ b, ↑(toFun μ ↑b) + ↑(Content.outerMeasure μ) (↑U' \ U) ≤ ↑(Content.outerMeasure μ) ↑U' ** refine' iSup_le _ ** G : Type w inst✝² : TopologicalSpace G μ : Content G inst✝¹ : T2Space G S : MeasurableSpace G inst✝ : BorelSpace G U : Set G hU : U ∈ {s | IsOpen s} U' : Opens G this : Nonempty { L // ↑L ⊆ ↑U' ∩ U } ⊢ ∀ (i : { i // ↑i ⊆ ↑U' ∩ U }), ↑(toFun μ ↑i) + ↑(Content.outerMeasure μ) (↑U' \ U) ≤ ↑(Content.outerMeasure μ) ↑U' ** rintro ⟨L, hL⟩ ** case mk G : Type w inst✝² : TopologicalSpace G μ : Content G inst✝¹ : T2Space G S : MeasurableSpace G inst✝ : BorelSpace G U : Set G hU : U ∈ {s | IsOpen s} U' : Opens G this : Nonempty { L // ↑L ⊆ ↑U' ∩ U } L : Compacts G hL : ↑L ⊆ ↑U' ∩ U ⊢ ↑(toFun μ ↑{ val := L, property := hL }) + ↑(Content.outerMeasure μ) (↑U' \ U) ≤ ↑(Content.outerMeasure μ) ↑U' ** simp only [subset_inter_iff] at hL ** case mk G : Type w inst✝² : TopologicalSpace G μ : Content G inst✝¹ : T2Space G S : MeasurableSpace G inst✝ : BorelSpace G U : Set G hU : U ∈ {s | IsOpen s} U' : Opens G this : Nonempty { L // ↑L ⊆ ↑U' ∩ U } L : Compacts G hL✝ : ↑L ⊆ ↑U' ∩ U hL : ↑L ⊆ ↑U' ∧ ↑L ⊆ U ⊢ ↑(toFun μ ↑{ val := L, property := hL✝ }) + ↑(Content.outerMeasure μ) (↑U' \ U) ≤ ↑(Content.outerMeasure μ) ↑U' ** have : ↑U' \ U ⊆ U' \ L := diff_subset_diff_right hL.2 ** case mk G : Type w inst✝² : TopologicalSpace G μ : Content G inst✝¹ : T2Space G S : MeasurableSpace G inst✝ : BorelSpace G U : Set G hU : U ∈ {s | IsOpen s} U' : Opens G this✝ : Nonempty { L // ↑L ⊆ ↑U' ∩ U } L : Compacts G hL✝ : ↑L ⊆ ↑U' ∩ U hL : ↑L ⊆ ↑U' ∧ ↑L ⊆ U this : ↑U' \ U ⊆ ↑U' \ ↑L ⊢ ↑(toFun μ ↑{ val := L, property := hL✝ }) + ↑(Content.outerMeasure μ) (↑U' \ U) ≤ ↑(Content.outerMeasure μ) ↑U' ** refine' le_trans (add_le_add_left (μ.outerMeasure.mono' this) _) _ ** case mk G : Type w inst✝² : TopologicalSpace G μ : Content G inst✝¹ : T2Space G S : MeasurableSpace G inst✝ : BorelSpace G U : Set G hU : U ∈ {s | IsOpen s} U' : Opens G this✝ : Nonempty { L // ↑L ⊆ ↑U' ∩ U } L : Compacts G hL✝ : ↑L ⊆ ↑U' ∩ U hL : ↑L ⊆ ↑U' ∧ ↑L ⊆ U this : ↑U' \ U ⊆ ↑U' \ ↑L ⊢ ↑(toFun μ ↑{ val := L, property := hL✝ }) + ↑(Content.outerMeasure μ) (↑U' \ ↑L) ≤ ↑(Content.outerMeasure μ) ↑U' ** rw [μ.outerMeasure_of_isOpen (↑U' \ L) (IsOpen.sdiff U'.2 L.2.isClosed)] ** case mk G : Type w inst✝² : TopologicalSpace G μ : Content G inst✝¹ : T2Space G S : MeasurableSpace G inst✝ : BorelSpace G U : Set G hU : U ∈ {s | IsOpen s} U' : Opens G this✝ : Nonempty { L // ↑L ⊆ ↑U' ∩ U } L : Compacts G hL✝ : ↑L ⊆ ↑U' ∩ U hL : ↑L ⊆ ↑U' ∧ ↑L ⊆ U this : ↑U' \ U ⊆ ↑U' \ ↑L ⊢ ↑(toFun μ ↑{ val := L, property := hL✝ }) + innerContent μ { carrier := ↑U' \ ↑L, is_open' := (_ : IsOpen (↑U' \ ↑L)) } ≤ ↑(Content.outerMeasure μ) ↑U' ** simp only [innerContent, iSup_subtype'] ** case mk G : Type w inst✝² : TopologicalSpace G μ : Content G inst✝¹ : T2Space G S : MeasurableSpace G inst✝ : BorelSpace G U : Set G hU : U ∈ {s | IsOpen s} U' : Opens G this✝ : Nonempty { L // ↑L ⊆ ↑U' ∩ U } L : Compacts G hL✝ : ↑L ⊆ ↑U' ∩ U hL : ↑L ⊆ ↑U' ∧ ↑L ⊆ U this : ↑U' \ U ⊆ ↑U' \ ↑L ⊢ ↑(toFun μ L) + ⨆ x, ↑(toFun μ ↑x) ≤ ↑(Content.outerMeasure μ) ↑U' ** haveI : Nonempty { M : Compacts G // (M : Set G) ⊆ ↑U' \ L } := ⟨⟨⊥, empty_subset _⟩⟩ ** case mk G : Type w inst✝² : TopologicalSpace G μ : Content G inst✝¹ : T2Space G S : MeasurableSpace G inst✝ : BorelSpace G U : Set G hU : U ∈ {s | IsOpen s} U' : Opens G this✝¹ : Nonempty { L // ↑L ⊆ ↑U' ∩ U } L : Compacts G hL✝ : ↑L ⊆ ↑U' ∩ U hL : ↑L ⊆ ↑U' ∧ ↑L ⊆ U this✝ : ↑U' \ U ⊆ ↑U' \ ↑L this : Nonempty { M // ↑M ⊆ ↑U' \ ↑L } ⊢ ↑(toFun μ L) + ⨆ x, ↑(toFun μ ↑x) ≤ ↑(Content.outerMeasure μ) ↑U' ** rw [ENNReal.add_iSup] ** case mk G : Type w inst✝² : TopologicalSpace G μ : Content G inst✝¹ : T2Space G S : MeasurableSpace G inst✝ : BorelSpace G U : Set G hU : U ∈ {s | IsOpen s} U' : Opens G this✝¹ : Nonempty { L // ↑L ⊆ ↑U' ∩ U } L : Compacts G hL✝ : ↑L ⊆ ↑U' ∩ U hL : ↑L ⊆ ↑U' ∧ ↑L ⊆ U this✝ : ↑U' \ U ⊆ ↑U' \ ↑L this : Nonempty { M // ↑M ⊆ ↑U' \ ↑L } ⊢ ⨆ b, ↑(toFun μ L) + ↑(toFun μ ↑b) ≤ ↑(Content.outerMeasure μ) ↑U' ** refine' iSup_le _ ** case mk G : Type w inst✝² : TopologicalSpace G μ : Content G inst✝¹ : T2Space G S : MeasurableSpace G inst✝ : BorelSpace G U : Set G hU : U ∈ {s | IsOpen s} U' : Opens G this✝¹ : Nonempty { L // ↑L ⊆ ↑U' ∩ U } L : Compacts G hL✝ : ↑L ⊆ ↑U' ∩ U hL : ↑L ⊆ ↑U' ∧ ↑L ⊆ U this✝ : ↑U' \ U ⊆ ↑U' \ ↑L this : Nonempty { M // ↑M ⊆ ↑U' \ ↑L } ⊢ ∀ (i : { i // ↑i ⊆ ↑U' \ ↑L }), ↑(toFun μ L) + ↑(toFun μ ↑i) ≤ ↑(Content.outerMeasure μ) ↑U' ** rintro ⟨M, hM⟩ ** case mk.mk G : Type w inst✝² : TopologicalSpace G μ : Content G inst✝¹ : T2Space G S : MeasurableSpace G inst✝ : BorelSpace G U : Set G hU : U ∈ {s | IsOpen s} U' : Opens G this✝¹ : Nonempty { L // ↑L ⊆ ↑U' ∩ U } L : Compacts G hL✝ : ↑L ⊆ ↑U' ∩ U hL : ↑L ⊆ ↑U' ∧ ↑L ⊆ U this✝ : ↑U' \ U ⊆ ↑U' \ ↑L this : Nonempty { M // ↑M ⊆ ↑U' \ ↑L } M : Compacts G hM : ↑M ⊆ ↑U' \ ↑L ⊢ ↑(toFun μ L) + ↑(toFun μ ↑{ val := M, property := hM }) ≤ ↑(Content.outerMeasure μ) ↑U' ** simp only [subset_diff] at hM ** case mk.mk G : Type w inst✝² : TopologicalSpace G μ : Content G inst✝¹ : T2Space G S : MeasurableSpace G inst✝ : BorelSpace G U : Set G hU : U ∈ {s | IsOpen s} U' : Opens G this✝¹ : Nonempty { L // ↑L ⊆ ↑U' ∩ U } L : Compacts G hL✝ : ↑L ⊆ ↑U' ∩ U hL : ↑L ⊆ ↑U' ∧ ↑L ⊆ U this✝ : ↑U' \ U ⊆ ↑U' \ ↑L this : Nonempty { M // ↑M ⊆ ↑U' \ ↑L } M : Compacts G hM✝ : ↑M ⊆ ↑U' \ ↑L hM : ↑M ⊆ ↑U' ∧ Disjoint ↑M ↑L ⊢ ↑(toFun μ L) + ↑(toFun μ ↑{ val := M, property := hM✝ }) ≤ ↑(Content.outerMeasure μ) ↑U' ** have : (↑(L ⊔ M) : Set G) ⊆ U' := by
simp only [union_subset_iff, Compacts.coe_sup, hM, hL, and_self_iff] ** case mk.mk G : Type w inst✝² : TopologicalSpace G μ : Content G inst✝¹ : T2Space G S : MeasurableSpace G inst✝ : BorelSpace G U : Set G hU : U ∈ {s | IsOpen s} U' : Opens G this✝² : Nonempty { L // ↑L ⊆ ↑U' ∩ U } L : Compacts G hL✝ : ↑L ⊆ ↑U' ∩ U hL : ↑L ⊆ ↑U' ∧ ↑L ⊆ U this✝¹ : ↑U' \ U ⊆ ↑U' \ ↑L this✝ : Nonempty { M // ↑M ⊆ ↑U' \ ↑L } M : Compacts G hM✝ : ↑M ⊆ ↑U' \ ↑L hM : ↑M ⊆ ↑U' ∧ Disjoint ↑M ↑L this : ↑(L ⊔ M) ⊆ ↑U' ⊢ ↑(toFun μ L) + ↑(toFun μ ↑{ val := M, property := hM✝ }) ≤ ↑(Content.outerMeasure μ) ↑U' ** rw [μ.outerMeasure_of_isOpen (↑U') U'.2] ** case mk.mk G : Type w inst✝² : TopologicalSpace G μ : Content G inst✝¹ : T2Space G S : MeasurableSpace G inst✝ : BorelSpace G U : Set G hU : U ∈ {s | IsOpen s} U' : Opens G this✝² : Nonempty { L // ↑L ⊆ ↑U' ∩ U } L : Compacts G hL✝ : ↑L ⊆ ↑U' ∩ U hL : ↑L ⊆ ↑U' ∧ ↑L ⊆ U this✝¹ : ↑U' \ U ⊆ ↑U' \ ↑L this✝ : Nonempty { M // ↑M ⊆ ↑U' \ ↑L } M : Compacts G hM✝ : ↑M ⊆ ↑U' \ ↑L hM : ↑M ⊆ ↑U' ∧ Disjoint ↑M ↑L this : ↑(L ⊔ M) ⊆ ↑U' ⊢ ↑(toFun μ L) + ↑(toFun μ ↑{ val := M, property := hM✝ }) ≤ innerContent μ { carrier := ↑U', is_open' := (_ : IsOpen U'.carrier) } ** refine' le_trans (ge_of_eq _) (μ.le_innerContent _ _ this) ** case mk.mk G : Type w inst✝² : TopologicalSpace G μ : Content G inst✝¹ : T2Space G S : MeasurableSpace G inst✝ : BorelSpace G U : Set G hU : U ∈ {s | IsOpen s} U' : Opens G this✝² : Nonempty { L // ↑L ⊆ ↑U' ∩ U } L : Compacts G hL✝ : ↑L ⊆ ↑U' ∩ U hL : ↑L ⊆ ↑U' ∧ ↑L ⊆ U this✝¹ : ↑U' \ U ⊆ ↑U' \ ↑L this✝ : Nonempty { M // ↑M ⊆ ↑U' \ ↑L } M : Compacts G hM✝ : ↑M ⊆ ↑U' \ ↑L hM : ↑M ⊆ ↑U' ∧ Disjoint ↑M ↑L this : ↑(L ⊔ M) ⊆ ↑U' ⊢ (fun s => ↑(toFun μ s)) (L ⊔ M) = ↑(toFun μ L) + ↑(toFun μ ↑{ val := M, property := hM✝ }) ** exact μ.sup_disjoint _ _ hM.2.symm ** G : Type w inst✝² : TopologicalSpace G μ : Content G inst✝¹ : T2Space G S : MeasurableSpace G inst✝ : BorelSpace G U : Set G hU : U ∈ {s | IsOpen s} U' : Opens G this✝¹ : Nonempty { L // ↑L ⊆ ↑U' ∩ U } L : Compacts G hL✝ : ↑L ⊆ ↑U' ∩ U hL : ↑L ⊆ ↑U' ∧ ↑L ⊆ U this✝ : ↑U' \ U ⊆ ↑U' \ ↑L this : Nonempty { M // ↑M ⊆ ↑U' \ ↑L } M : Compacts G hM✝ : ↑M ⊆ ↑U' \ ↑L hM : ↑M ⊆ ↑U' ∧ Disjoint ↑M ↑L ⊢ ↑(L ⊔ M) ⊆ ↑U' ** simp only [union_subset_iff, Compacts.coe_sup, hM, hL, and_self_iff] ** Qed
| |
MeasureTheory.OuterMeasure.iUnion_null ** α : Type u_1 β : Type u_2 R : Type u_3 R' : Type u_4 ms : Set (OuterMeasure α) m✝ : OuterMeasure α inst✝ : Countable β m : OuterMeasure α s : β → Set α h : ∀ (i : β), ↑m (s i) = 0 ⊢ ↑m (⋃ i, s i) = 0 ** simpa [h] using m.iUnion s ** Qed
| |
MeasureTheory.OuterMeasure.sUnion_null_iff ** α : Type u_1 β : Type u_2 R : Type u_3 R' : Type u_4 ms : Set (OuterMeasure α) m✝ m : OuterMeasure α S : Set (Set α) hS : Set.Countable S ⊢ ↑m (⋃₀ S) = 0 ↔ ∀ (s : Set α), s ∈ S → ↑m s = 0 ** rw [sUnion_eq_biUnion, m.biUnion_null_iff hS] ** Qed
| |
MeasureTheory.OuterMeasure.null_of_locally_null ** α : Type u_1 β : Type u_2 R : Type u_3 R' : Type u_4 ms : Set (OuterMeasure α) m✝ : OuterMeasure α inst✝¹ : TopologicalSpace α inst✝ : SecondCountableTopology α m : OuterMeasure α s : Set α hs : ∀ (x : α), x ∈ s → ∃ u, u ∈ 𝓝[s] x ∧ ↑m u = 0 ⊢ ↑m s = 0 ** choose! u hxu hu₀ using hs ** α : Type u_1 β : Type u_2 R : Type u_3 R' : Type u_4 ms : Set (OuterMeasure α) m✝ : OuterMeasure α inst✝¹ : TopologicalSpace α inst✝ : SecondCountableTopology α m : OuterMeasure α s : Set α u : α → Set α hxu : ∀ (x : α), x ∈ s → u x ∈ 𝓝[s] x hu₀ : ∀ (x : α), x ∈ s → ↑m (u x) = 0 ⊢ ↑m s = 0 ** choose t ht using TopologicalSpace.countable_cover_nhdsWithin hxu ** α : Type u_1 β : Type u_2 R : Type u_3 R' : Type u_4 ms : Set (OuterMeasure α) m✝ : OuterMeasure α inst✝¹ : TopologicalSpace α inst✝ : SecondCountableTopology α m : OuterMeasure α s : Set α u : α → Set α hxu : ∀ (x : α), x ∈ s → u x ∈ 𝓝[s] x hu₀ : ∀ (x : α), x ∈ s → ↑m (u x) = 0 t : Set α ht : t ⊆ s ∧ Set.Countable t ∧ s ⊆ ⋃ x ∈ t, u x ⊢ ↑m s = 0 ** rcases ht with ⟨ts, t_count, ht⟩ ** case intro.intro α : Type u_1 β : Type u_2 R : Type u_3 R' : Type u_4 ms : Set (OuterMeasure α) m✝ : OuterMeasure α inst✝¹ : TopologicalSpace α inst✝ : SecondCountableTopology α m : OuterMeasure α s : Set α u : α → Set α hxu : ∀ (x : α), x ∈ s → u x ∈ 𝓝[s] x hu₀ : ∀ (x : α), x ∈ s → ↑m (u x) = 0 t : Set α ts : t ⊆ s t_count : Set.Countable t ht : s ⊆ ⋃ x ∈ t, u x ⊢ ↑m s = 0 ** apply m.mono_null ht ** case intro.intro α : Type u_1 β : Type u_2 R : Type u_3 R' : Type u_4 ms : Set (OuterMeasure α) m✝ : OuterMeasure α inst✝¹ : TopologicalSpace α inst✝ : SecondCountableTopology α m : OuterMeasure α s : Set α u : α → Set α hxu : ∀ (x : α), x ∈ s → u x ∈ 𝓝[s] x hu₀ : ∀ (x : α), x ∈ s → ↑m (u x) = 0 t : Set α ts : t ⊆ s t_count : Set.Countable t ht : s ⊆ ⋃ x ∈ t, u x ⊢ ↑m (⋃ x ∈ t, u x) = 0 ** exact (m.biUnion_null_iff t_count).2 fun x hx => hu₀ x (ts hx) ** Qed
| |
MeasureTheory.OuterMeasure.exists_mem_forall_mem_nhds_within_pos ** α : Type u_1 β : Type u_2 R : Type u_3 R' : Type u_4 ms : Set (OuterMeasure α) m✝ : OuterMeasure α inst✝¹ : TopologicalSpace α inst✝ : SecondCountableTopology α m : OuterMeasure α s : Set α hs : ↑m s ≠ 0 ⊢ ∃ x, x ∈ s ∧ ∀ (t : Set α), t ∈ 𝓝[s] x → 0 < ↑m t ** contrapose! hs ** α : Type u_1 β : Type u_2 R : Type u_3 R' : Type u_4 ms : Set (OuterMeasure α) m✝ : OuterMeasure α inst✝¹ : TopologicalSpace α inst✝ : SecondCountableTopology α m : OuterMeasure α s : Set α hs : ∀ (x : α), x ∈ s → ∃ t, t ∈ 𝓝[s] x ∧ ↑m t ≤ 0 ⊢ ↑m s = 0 ** simp only [nonpos_iff_eq_zero] at hs ** α : Type u_1 β : Type u_2 R : Type u_3 R' : Type u_4 ms : Set (OuterMeasure α) m✝ : OuterMeasure α inst✝¹ : TopologicalSpace α inst✝ : SecondCountableTopology α m : OuterMeasure α s : Set α hs : ∀ (x : α), x ∈ s → ∃ t, t ∈ 𝓝[s] x ∧ ↑m t = 0 ⊢ ↑m s = 0 ** exact m.null_of_locally_null s hs ** Qed
| |
MeasureTheory.OuterMeasure.iUnion_of_tendsto_zero ** α : Type u_1 β : Type u_2 R : Type u_3 R' : Type u_4 ms : Set (OuterMeasure α) m✝ : OuterMeasure α ι : Type u_5 m : OuterMeasure α s : ι → Set α l : Filter ι inst✝ : NeBot l h0 : Tendsto (fun k => ↑m ((⋃ n, s n) \ s k)) l (𝓝 0) ⊢ ↑m (⋃ n, s n) = ⨆ n, ↑m (s n) ** set S := ⋃ n, s n ** α : Type u_1 β : Type u_2 R : Type u_3 R' : Type u_4 ms : Set (OuterMeasure α) m✝ : OuterMeasure α ι : Type u_5 m : OuterMeasure α s : ι → Set α l : Filter ι inst✝ : NeBot l S : Set α := ⋃ n, s n h0 : Tendsto (fun k => ↑m (S \ s k)) l (𝓝 0) ⊢ ↑m S = ⨆ n, ↑m (s n) ** set M := ⨆ n, m (s n) ** α : Type u_1 β : Type u_2 R : Type u_3 R' : Type u_4 ms : Set (OuterMeasure α) m✝ : OuterMeasure α ι : Type u_5 m : OuterMeasure α s : ι → Set α l : Filter ι inst✝ : NeBot l S : Set α := ⋃ n, s n h0 : Tendsto (fun k => ↑m (S \ s k)) l (𝓝 0) M : ℝ≥0∞ := ⨆ n, ↑m (s n) ⊢ ↑m S = M ** have hsS : ∀ {k}, s k ⊆ S := fun {k} => subset_iUnion _ _ ** α : Type u_1 β : Type u_2 R : Type u_3 R' : Type u_4 ms : Set (OuterMeasure α) m✝ : OuterMeasure α ι : Type u_5 m : OuterMeasure α s : ι → Set α l : Filter ι inst✝ : NeBot l S : Set α := ⋃ n, s n h0 : Tendsto (fun k => ↑m (S \ s k)) l (𝓝 0) M : ℝ≥0∞ := ⨆ n, ↑m (s n) hsS : ∀ {k : ι}, s k ⊆ S ⊢ ↑m S = M ** refine' le_antisymm _ (iSup_le fun n => m.mono hsS) ** α : Type u_1 β : Type u_2 R : Type u_3 R' : Type u_4 ms : Set (OuterMeasure α) m✝ : OuterMeasure α ι : Type u_5 m : OuterMeasure α s : ι → Set α l : Filter ι inst✝ : NeBot l S : Set α := ⋃ n, s n h0 : Tendsto (fun k => ↑m (S \ s k)) l (𝓝 0) M : ℝ≥0∞ := ⨆ n, ↑m (s n) hsS : ∀ {k : ι}, s k ⊆ S ⊢ ↑m S ≤ M ** have A : ∀ k, m S ≤ M + m (S \ s k) := fun k =>
calc
m S = m (s k ∪ S \ s k) := by rw [union_diff_self, union_eq_self_of_subset_left hsS]
_ ≤ m (s k) + m (S \ s k) := (m.union _ _)
_ ≤ M + m (S \ s k) := add_le_add_right (le_iSup (m.measureOf ∘ s) k) _ ** α : Type u_1 β : Type u_2 R : Type u_3 R' : Type u_4 ms : Set (OuterMeasure α) m✝ : OuterMeasure α ι : Type u_5 m : OuterMeasure α s : ι → Set α l : Filter ι inst✝ : NeBot l S : Set α := ⋃ n, s n h0 : Tendsto (fun k => ↑m (S \ s k)) l (𝓝 0) M : ℝ≥0∞ := ⨆ n, ↑m (s n) hsS : ∀ {k : ι}, s k ⊆ S A : ∀ (k : ι), ↑m S ≤ M + ↑m (S \ s k) ⊢ ↑m S ≤ M ** have B : Tendsto (fun k => M + m (S \ s k)) l (𝓝 (M + 0)) := tendsto_const_nhds.add h0 ** α : Type u_1 β : Type u_2 R : Type u_3 R' : Type u_4 ms : Set (OuterMeasure α) m✝ : OuterMeasure α ι : Type u_5 m : OuterMeasure α s : ι → Set α l : Filter ι inst✝ : NeBot l S : Set α := ⋃ n, s n h0 : Tendsto (fun k => ↑m (S \ s k)) l (𝓝 0) M : ℝ≥0∞ := ⨆ n, ↑m (s n) hsS : ∀ {k : ι}, s k ⊆ S A : ∀ (k : ι), ↑m S ≤ M + ↑m (S \ s k) B : Tendsto (fun k => M + ↑m (S \ s k)) l (𝓝 (M + 0)) ⊢ ↑m S ≤ M ** rw [add_zero] at B ** α : Type u_1 β : Type u_2 R : Type u_3 R' : Type u_4 ms : Set (OuterMeasure α) m✝ : OuterMeasure α ι : Type u_5 m : OuterMeasure α s : ι → Set α l : Filter ι inst✝ : NeBot l S : Set α := ⋃ n, s n h0 : Tendsto (fun k => ↑m (S \ s k)) l (𝓝 0) M : ℝ≥0∞ := ⨆ n, ↑m (s n) hsS : ∀ {k : ι}, s k ⊆ S A : ∀ (k : ι), ↑m S ≤ M + ↑m (S \ s k) B : Tendsto (fun k => M + ↑m (S \ s k)) l (𝓝 M) ⊢ ↑m S ≤ M ** exact ge_of_tendsto' B A ** α : Type u_1 β : Type u_2 R : Type u_3 R' : Type u_4 ms : Set (OuterMeasure α) m✝ : OuterMeasure α ι : Type u_5 m : OuterMeasure α s : ι → Set α l : Filter ι inst✝ : NeBot l S : Set α := ⋃ n, s n h0 : Tendsto (fun k => ↑m (S \ s k)) l (𝓝 0) M : ℝ≥0∞ := ⨆ n, ↑m (s n) hsS : ∀ {k : ι}, s k ⊆ S k : ι ⊢ ↑m S = ↑m (s k ∪ S \ s k) ** rw [union_diff_self, union_eq_self_of_subset_left hsS] ** Qed
| |
MeasureTheory.OuterMeasure.le_inter_add_diff ** α : Type u_1 β : Type u_2 R : Type u_3 R' : Type u_4 ms : Set (OuterMeasure α) m✝ m : OuterMeasure α t s : Set α ⊢ ↑m t ≤ ↑m (t ∩ s) + ↑m (t \ s) ** convert m.union _ _ ** case h.e'_3.h.e'_3 α : Type u_1 β : Type u_2 R : Type u_3 R' : Type u_4 ms : Set (OuterMeasure α) m✝ m : OuterMeasure α t s : Set α ⊢ t = t ∩ s ∪ t \ s ** rw [inter_union_diff t s] ** Qed
| |
MeasureTheory.OuterMeasure.diff_null ** α : Type u_1 β : Type u_2 R : Type u_3 R' : Type u_4 ms : Set (OuterMeasure α) m✝ m : OuterMeasure α s t : Set α ht : ↑m t = 0 ⊢ ↑m (s \ t) = ↑m s ** refine' le_antisymm (m.mono <| diff_subset _ _) _ ** α : Type u_1 β : Type u_2 R : Type u_3 R' : Type u_4 ms : Set (OuterMeasure α) m✝ m : OuterMeasure α s t : Set α ht : ↑m t = 0 ⊢ ↑m s ≤ ↑m (s \ t) ** calc
m s ≤ m (s ∩ t) + m (s \ t) := le_inter_add_diff _
_ ≤ m t + m (s \ t) := (add_le_add_right (m.mono <| inter_subset_right _ _) _)
_ = m (s \ t) := by rw [ht, zero_add] ** α : Type u_1 β : Type u_2 R : Type u_3 R' : Type u_4 ms : Set (OuterMeasure α) m✝ m : OuterMeasure α s t : Set α ht : ↑m t = 0 ⊢ ↑m t + ↑m (s \ t) = ↑m (s \ t) ** rw [ht, zero_add] ** Qed
| |
MeasureTheory.OuterMeasure.union_null ** α : Type u_1 β : Type u_2 R : Type u_3 R' : Type u_4 ms : Set (OuterMeasure α) m✝ m : OuterMeasure α s₁ s₂ : Set α h₁ : ↑m s₁ = 0 h₂ : ↑m s₂ = 0 ⊢ ↑m (s₁ ∪ s₂) = 0 ** simpa [h₁, h₂] using m.union s₁ s₂ ** Qed
| |
MeasureTheory.OuterMeasure.coe_fn_injective ** α : Type u_1 β : Type u_2 R : Type u_3 R' : Type u_4 ms : Set (OuterMeasure α) m μ₁ μ₂ : OuterMeasure α h : (fun μ s => ↑μ s) μ₁ = (fun μ s => ↑μ s) μ₂ ⊢ μ₁ = μ₂ ** cases μ₁ ** case mk α : Type u_1 β : Type u_2 R : Type u_3 R' : Type u_4 ms : Set (OuterMeasure α) m μ₂ : OuterMeasure α measureOf✝ : Set α → ℝ≥0∞ empty✝ : measureOf✝ ∅ = 0 mono✝ : ∀ {s₁ s₂ : Set α}, s₁ ⊆ s₂ → measureOf✝ s₁ ≤ measureOf✝ s₂ iUnion_nat✝ : ∀ (s : ℕ → Set α), measureOf✝ (⋃ i, s i) ≤ ∑' (i : ℕ), measureOf✝ (s i) h : (fun μ s => ↑μ s) { measureOf := measureOf✝, empty := empty✝, mono := mono✝, iUnion_nat := iUnion_nat✝ } = (fun μ s => ↑μ s) μ₂ ⊢ { measureOf := measureOf✝, empty := empty✝, mono := mono✝, iUnion_nat := iUnion_nat✝ } = μ₂ ** cases μ₂ ** case mk.mk α : Type u_1 β : Type u_2 R : Type u_3 R' : Type u_4 ms : Set (OuterMeasure α) m : OuterMeasure α measureOf✝¹ : Set α → ℝ≥0∞ empty✝¹ : measureOf✝¹ ∅ = 0 mono✝¹ : ∀ {s₁ s₂ : Set α}, s₁ ⊆ s₂ → measureOf✝¹ s₁ ≤ measureOf✝¹ s₂ iUnion_nat✝¹ : ∀ (s : ℕ → Set α), measureOf✝¹ (⋃ i, s i) ≤ ∑' (i : ℕ), measureOf✝¹ (s i) measureOf✝ : Set α → ℝ≥0∞ empty✝ : measureOf✝ ∅ = 0 mono✝ : ∀ {s₁ s₂ : Set α}, s₁ ⊆ s₂ → measureOf✝ s₁ ≤ measureOf✝ s₂ iUnion_nat✝ : ∀ (s : ℕ → Set α), measureOf✝ (⋃ i, s i) ≤ ∑' (i : ℕ), measureOf✝ (s i) h : (fun μ s => ↑μ s) { measureOf := measureOf✝¹, empty := empty✝¹, mono := mono✝¹, iUnion_nat := iUnion_nat✝¹ } = (fun μ s => ↑μ s) { measureOf := measureOf✝, empty := empty✝, mono := mono✝, iUnion_nat := iUnion_nat✝ } ⊢ { measureOf := measureOf✝¹, empty := empty✝¹, mono := mono✝¹, iUnion_nat := iUnion_nat✝¹ } = { measureOf := measureOf✝, empty := empty✝, mono := mono✝, iUnion_nat := iUnion_nat✝ } ** congr ** Qed
| |
MeasureTheory.OuterMeasure.ext_nonempty ** α : Type u_1 β : Type u_2 R : Type u_3 R' : Type u_4 ms : Set (OuterMeasure α) m μ₁ μ₂ : OuterMeasure α h : ∀ (s : Set α), Set.Nonempty s → ↑μ₁ s = ↑μ₂ s s : Set α he : s = ∅ ⊢ ↑μ₁ s = ↑μ₂ s ** rw [he, empty', empty'] ** Qed
| |
MeasureTheory.OuterMeasure.coe_iSup ** α : Type u_1 β : Type u_2 R : Type u_3 R' : Type u_4 ms : Set (OuterMeasure α) m : OuterMeasure α ι : Sort u_5 f : ι → OuterMeasure α s : Set α ⊢ ↑(⨆ i, f i) s = iSup (fun i => ↑(f i)) s ** simp ** Qed
| |
MeasureTheory.OuterMeasure.sup_apply ** α : Type u_1 β : Type u_2 R : Type u_3 R' : Type u_4 ms : Set (OuterMeasure α) m m₁ m₂ : OuterMeasure α s : Set α ⊢ ↑(m₁ ⊔ m₂) s = ↑m₁ s ⊔ ↑m₂ s ** have := iSup_apply (fun b => cond b m₁ m₂) s ** α : Type u_1 β : Type u_2 R : Type u_3 R' : Type u_4 ms : Set (OuterMeasure α) m m₁ m₂ : OuterMeasure α s : Set α this : ↑(⨆ i, bif i then m₁ else m₂) s = ⨆ i, ↑(bif i then m₁ else m₂) s ⊢ ↑(m₁ ⊔ m₂) s = ↑m₁ s ⊔ ↑m₂ s ** rwa [iSup_bool_eq, iSup_bool_eq] at this ** Qed
| |
MeasureTheory.OuterMeasure.smul_iSup ** α : Type u_1 β : Type u_2 R : Type u_3 R' : Type u_4 ms : Set (OuterMeasure α) m : OuterMeasure α inst✝¹ : SMul R ℝ≥0∞ inst✝ : IsScalarTower R ℝ≥0∞ ℝ≥0∞ ι : Sort u_5 f : ι → OuterMeasure α c : R s : Set α ⊢ ↑(c • ⨆ i, f i) s = ↑(⨆ i, c • f i) s ** simp only [smul_apply, iSup_apply, ENNReal.smul_iSup] ** Qed
| |
MeasureTheory.OuterMeasure.map_sup ** α : Type u_1 β✝ : Type u_2 R : Type u_3 R' : Type u_4 ms : Set (OuterMeasure α) m✝ : OuterMeasure α β : Type u_5 f : α → β m m' : OuterMeasure α s : Set β ⊢ ↑(↑(map f) (m ⊔ m')) s = ↑(↑(map f) m ⊔ ↑(map f) m') s ** simp only [map_apply, sup_apply] ** Qed
| |
MeasureTheory.OuterMeasure.map_iSup ** α : Type u_1 β✝ : Type u_2 R : Type u_3 R' : Type u_4 ms : Set (OuterMeasure α) m✝ : OuterMeasure α β : Type u_5 ι : Sort u_6 f : α → β m : ι → OuterMeasure α s : Set β ⊢ ↑(↑(map f) (⨆ i, m i)) s = ↑(⨆ i, ↑(map f) (m i)) s ** simp only [map_apply, iSup_apply] ** Qed
| |
MeasureTheory.OuterMeasure.smul_dirac_apply ** α : Type u_1 β : Type u_2 R : Type u_3 R' : Type u_4 ms : Set (OuterMeasure α) m : OuterMeasure α a : ℝ≥0∞ b : α s : Set α ⊢ ↑(a • dirac b) s = indicator s (fun x => a) b ** simp only [smul_apply, smul_eq_mul, dirac_apply, ← indicator_mul_right _ fun _ => a, mul_one] ** Qed
| |
MeasureTheory.OuterMeasure.comap_iSup ** α : Type u_1 β✝ : Type u_2 R : Type u_3 R' : Type u_4 ms : Set (OuterMeasure α) m✝ : OuterMeasure α β : Type u_5 ι : Sort u_6 f : α → β m : ι → OuterMeasure β s : Set α ⊢ ↑(↑(comap f) (⨆ i, m i)) s = ↑(⨆ i, ↑(comap f) (m i)) s ** simp only [comap_apply, iSup_apply] ** Qed
| |
MeasureTheory.OuterMeasure.restrict_apply ** α : Type u_1 β : Type u_2 R : Type u_3 R' : Type u_4 ms : Set (OuterMeasure α) m✝ : OuterMeasure α s t : Set α m : OuterMeasure α ⊢ ↑(↑(restrict s) m) t = ↑m (t ∩ s) ** simp [restrict] ** Qed
| |
MeasureTheory.OuterMeasure.restrict_mono ** α : Type u_1 β : Type u_2 R : Type u_3 R' : Type u_4 ms : Set (OuterMeasure α) m✝ : OuterMeasure α s t : Set α h : s ⊆ t m m' : OuterMeasure α hm : m ≤ m' u : Set α ⊢ ↑(↑(restrict s) m) u ≤ ↑(↑(restrict t) m') u ** simp only [restrict_apply] ** α : Type u_1 β : Type u_2 R : Type u_3 R' : Type u_4 ms : Set (OuterMeasure α) m✝ : OuterMeasure α s t : Set α h : s ⊆ t m m' : OuterMeasure α hm : m ≤ m' u : Set α ⊢ ↑m (u ∩ s) ≤ ↑m' (u ∩ t) ** exact (hm _).trans (m'.mono <| inter_subset_inter_right _ h) ** Qed
| |
MeasureTheory.OuterMeasure.restrict_univ ** α : Type u_1 β : Type u_2 R : Type u_3 R' : Type u_4 ms : Set (OuterMeasure α) m✝ m : OuterMeasure α s : Set α ⊢ ↑(↑(restrict univ) m) s = ↑m s ** simp ** Qed
| |
MeasureTheory.OuterMeasure.restrict_empty ** α : Type u_1 β : Type u_2 R : Type u_3 R' : Type u_4 ms : Set (OuterMeasure α) m✝ m : OuterMeasure α s : Set α ⊢ ↑(↑(restrict ∅) m) s = ↑0 s ** simp ** Qed
| |
MeasureTheory.OuterMeasure.restrict_iSup ** α : Type u_1 β : Type u_2 R : Type u_3 R' : Type u_4 ms : Set (OuterMeasure α) m✝ : OuterMeasure α ι : Sort u_5 s : Set α m : ι → OuterMeasure α ⊢ ↑(restrict s) (⨆ i, m i) = ⨆ i, ↑(restrict s) (m i) ** simp [restrict] ** Qed
| |
MeasureTheory.OuterMeasure.map_comap ** α : Type u_1 β✝ : Type u_2 R : Type u_3 R' : Type u_4 ms : Set (OuterMeasure α) m✝ : OuterMeasure α β : Type u_5 f : α → β m : OuterMeasure β s : Set β ⊢ f '' (f ⁻¹' s) = Subtype.val '' (Subtype.val ⁻¹' s) ** simp only [image_preimage_eq_inter_range, Subtype.range_coe] ** Qed
| |
MeasureTheory.OuterMeasure.map_comap_of_surjective ** α : Type u_1 β✝ : Type u_2 R : Type u_3 R' : Type u_4 ms : Set (OuterMeasure α) m✝ : OuterMeasure α β : Type u_5 f : α → β hf : Surjective f m : OuterMeasure β s : Set β ⊢ ↑(↑(map f) (↑(comap f) m)) s = ↑m s ** rw [map_apply, comap_apply, hf.image_preimage] ** Qed
| |
MeasureTheory.OuterMeasure.comap_map ** α : Type u_1 β✝ : Type u_2 R : Type u_3 R' : Type u_4 ms : Set (OuterMeasure α) m✝ : OuterMeasure α β : Type u_5 f : α → β hf : Injective f m : OuterMeasure α s : Set α ⊢ ↑(↑(comap f) (↑(map f) m)) s = ↑m s ** rw [comap_apply, map_apply, hf.preimage_image] ** Qed
| |
MeasureTheory.OuterMeasure.top_apply ** α : Type u_1 β : Type u_2 R : Type u_3 R' : Type u_4 ms : Set (OuterMeasure α) m : OuterMeasure α s : Set α h : Set.Nonempty s a : α as : a ∈ s ⊢ ⊤ ≤ ↑(⊤ • dirac a) s ** simp [smul_dirac_apply, as] ** Qed
| |
MeasureTheory.OuterMeasure.top_apply' ** α : Type u_1 β : Type u_2 R : Type u_3 R' : Type u_4 ms : Set (OuterMeasure α) m : OuterMeasure α s : Set α h : s = ∅ ⊢ ↑⊤ s = ⨅ (_ : s = ∅), 0 ** simp [h] ** α : Type u_1 β : Type u_2 R : Type u_3 R' : Type u_4 ms : Set (OuterMeasure α) m : OuterMeasure α s : Set α h : Set.Nonempty s ⊢ ↑⊤ s = ⨅ (_ : s = ∅), 0 ** simp [h, h.ne_empty] ** Qed
| |
MeasureTheory.OuterMeasure.comap_top ** α : Type u_1 β : Type u_2 R : Type u_3 R' : Type u_4 ms : Set (OuterMeasure α) m : OuterMeasure α f : α → β s : Set α hs : Set.Nonempty s ⊢ ↑(↑(comap f) ⊤) s = ↑⊤ s ** rw [comap_apply, top_apply hs, top_apply (hs.image _)] ** Qed
| |
MeasureTheory.OuterMeasure.map_top ** α : Type u_1 β : Type u_2 R : Type u_3 R' : Type u_4 ms : Set (OuterMeasure α) m : OuterMeasure α f : α → β s : Set β ⊢ ↑(↑(map f) ⊤) s = ↑(↑(restrict (range f)) ⊤) s ** rw [map_apply, restrict_apply, ← image_preimage_eq_inter_range, top_apply', top_apply',
Set.image_eq_empty] ** Qed
| |
MeasureTheory.OuterMeasure.ofFunction_le ** α : Type u_1 m : Set α → ℝ≥0∞ m_empty : m ∅ = 0 s : Set α f : ℕ → Set α := fun i => Nat.casesOn i s fun x => ∅ ⊢ ∀ (b' : ℕ), b' ≠ 0 → m (f b') = 0 ** rintro (_ | i) ** case zero α : Type u_1 m : Set α → ℝ≥0∞ m_empty : m ∅ = 0 s : Set α f : ℕ → Set α := fun i => Nat.casesOn i s fun x => ∅ ⊢ Nat.zero ≠ 0 → m (f Nat.zero) = 0 case succ α : Type u_1 m : Set α → ℝ≥0∞ m_empty : m ∅ = 0 s : Set α f : ℕ → Set α := fun i => Nat.casesOn i s fun x => ∅ i : ℕ ⊢ Nat.succ i ≠ 0 → m (f (Nat.succ i)) = 0 ** simp ** case succ α : Type u_1 m : Set α → ℝ≥0∞ m_empty : m ∅ = 0 s : Set α f : ℕ → Set α := fun i => Nat.casesOn i s fun x => ∅ i : ℕ ⊢ Nat.succ i ≠ 0 → m (f (Nat.succ i)) = 0 ** simp [m_empty] ** Qed
| |
MeasureTheory.OuterMeasure.comap_ofFunction ** α : Type u_1 m : Set α → ℝ≥0∞ m_empty : m ∅ = 0 β : Type ?u.147531 f : β → α h : Monotone m ∨ Surjective f ⊢ (fun s => m (f '' s)) ∅ = 0 ** simp ** α : Type u_1 m : Set α → ℝ≥0∞ m_empty : m ∅ = 0 β : Type ?u.147531 f : β → α h : Monotone m ∨ Surjective f ⊢ m ∅ = 0 ** simp [m_empty] ** α : Type u_1 m : Set α → ℝ≥0∞ m_empty : m ∅ = 0 β : Type u_2 f : β → α h : Monotone m ∨ Surjective f ⊢ ↑(comap f) (OuterMeasure.ofFunction m m_empty) = OuterMeasure.ofFunction (fun s => m (f '' s)) (_ : (fun s => m (f '' s)) ∅ = 0) ** refine' le_antisymm (le_ofFunction.2 fun s => _) fun s => _ ** case refine'_1 α : Type u_1 m : Set α → ℝ≥0∞ m_empty : m ∅ = 0 β : Type u_2 f : β → α h : Monotone m ∨ Surjective f s : Set β ⊢ ↑(↑(comap f) (OuterMeasure.ofFunction m m_empty)) s ≤ m (f '' s) ** rw [comap_apply] ** case refine'_1 α : Type u_1 m : Set α → ℝ≥0∞ m_empty : m ∅ = 0 β : Type u_2 f : β → α h : Monotone m ∨ Surjective f s : Set β ⊢ ↑(OuterMeasure.ofFunction m m_empty) (f '' s) ≤ m (f '' s) ** apply ofFunction_le ** case refine'_2 α : Type u_1 m : Set α → ℝ≥0∞ m_empty : m ∅ = 0 β : Type u_2 f : β → α h : Monotone m ∨ Surjective f s : Set β ⊢ ↑(OuterMeasure.ofFunction (fun s => m (f '' s)) (_ : (fun s => m (f '' s)) ∅ = 0)) s ≤ ↑(↑(comap f) (OuterMeasure.ofFunction m m_empty)) s ** rw [comap_apply, ofFunction_apply, ofFunction_apply] ** case refine'_2 α : Type u_1 m : Set α → ℝ≥0∞ m_empty : m ∅ = 0 β : Type u_2 f : β → α h : Monotone m ∨ Surjective f s : Set β ⊢ ⨅ t, ⨅ (_ : s ⊆ iUnion t), ∑' (n : ℕ), m (f '' t n) ≤ ⨅ t, ⨅ (_ : f '' s ⊆ iUnion t), ∑' (n : ℕ), m (t n) ** refine' iInf_mono' fun t => ⟨fun k => f ⁻¹' t k, _⟩ ** case refine'_2 α : Type u_1 m : Set α → ℝ≥0∞ m_empty : m ∅ = 0 β : Type u_2 f : β → α h : Monotone m ∨ Surjective f s : Set β t : ℕ → Set α ⊢ ⨅ (_ : s ⊆ ⋃ k, f ⁻¹' t k), ∑' (n : ℕ), m (f '' (fun k => f ⁻¹' t k) n) ≤ ⨅ (_ : f '' s ⊆ iUnion t), ∑' (n : ℕ), m (t n) ** refine' iInf_mono' fun ht => _ ** case refine'_2 α : Type u_1 m : Set α → ℝ≥0∞ m_empty : m ∅ = 0 β : Type u_2 f : β → α h : Monotone m ∨ Surjective f s : Set β t : ℕ → Set α ht : f '' s ⊆ iUnion t ⊢ ∃ i, ∑' (n : ℕ), m (f '' (fun k => f ⁻¹' t k) n) ≤ ∑' (n : ℕ), m (t n) ** rw [Set.image_subset_iff, preimage_iUnion] at ht ** case refine'_2 α : Type u_1 m : Set α → ℝ≥0∞ m_empty : m ∅ = 0 β : Type u_2 f : β → α h : Monotone m ∨ Surjective f s : Set β t : ℕ → Set α ht : s ⊆ ⋃ i, f ⁻¹' t i ⊢ ∃ i, ∑' (n : ℕ), m (f '' (fun k => f ⁻¹' t k) n) ≤ ∑' (n : ℕ), m (t n) ** refine' ⟨ht, ENNReal.tsum_le_tsum fun n => _⟩ ** case refine'_2 α : Type u_1 m : Set α → ℝ≥0∞ m_empty : m ∅ = 0 β : Type u_2 f : β → α h : Monotone m ∨ Surjective f s : Set β t : ℕ → Set α ht : s ⊆ ⋃ i, f ⁻¹' t i n : ℕ ⊢ m (f '' (fun k => f ⁻¹' t k) n) ≤ m (t n) ** cases' h with hl hr ** case refine'_2.inl α : Type u_1 m : Set α → ℝ≥0∞ m_empty : m ∅ = 0 β : Type u_2 f : β → α s : Set β t : ℕ → Set α ht : s ⊆ ⋃ i, f ⁻¹' t i n : ℕ hl : Monotone m ⊢ m (f '' (fun k => f ⁻¹' t k) n) ≤ m (t n) case refine'_2.inr α : Type u_1 m : Set α → ℝ≥0∞ m_empty : m ∅ = 0 β : Type u_2 f : β → α s : Set β t : ℕ → Set α ht : s ⊆ ⋃ i, f ⁻¹' t i n : ℕ hr : Surjective f ⊢ m (f '' (fun k => f ⁻¹' t k) n) ≤ m (t n) ** exacts [hl (image_preimage_subset _ _), (congr_arg m (hr.image_preimage (t n))).le] ** Qed
| |
MeasureTheory.OuterMeasure.map_ofFunction_le ** α : Type u_1 m : Set α → ℝ≥0∞ m_empty : m ∅ = 0 β : Type u_2 f : α → β s : Set β ⊢ ↑(↑(map f) (OuterMeasure.ofFunction m m_empty)) s ≤ m (f ⁻¹' s) ** rw [map_apply] ** α : Type u_1 m : Set α → ℝ≥0∞ m_empty : m ∅ = 0 β : Type u_2 f : α → β s : Set β ⊢ ↑(OuterMeasure.ofFunction m m_empty) (f ⁻¹' s) ≤ m (f ⁻¹' s) ** apply ofFunction_le ** Qed
| |
MeasureTheory.OuterMeasure.boundedBy_eq_ofFunction ** α : Type u_1 m : Set α → ℝ≥0∞ m_empty : m ∅ = 0 s : Set α ⊢ ↑(boundedBy m) s = ↑(OuterMeasure.ofFunction m m_empty) s ** have : (fun s : Set α => ⨆ _ : s.Nonempty, m s) = m := by
ext1 t
cases' t.eq_empty_or_nonempty with h h <;> simp [h, Set.not_nonempty_empty, m_empty] ** α : Type u_1 m : Set α → ℝ≥0∞ m_empty : m ∅ = 0 s : Set α this : (fun s => ⨆ (_ : Set.Nonempty s), m s) = m ⊢ ↑(boundedBy m) s = ↑(OuterMeasure.ofFunction m m_empty) s ** simp [boundedBy, this] ** α : Type u_1 m : Set α → ℝ≥0∞ m_empty : m ∅ = 0 s : Set α ⊢ (fun s => ⨆ (_ : Set.Nonempty s), m s) = m ** ext1 t ** case h α : Type u_1 m : Set α → ℝ≥0∞ m_empty : m ∅ = 0 s t : Set α ⊢ ⨆ (_ : Set.Nonempty t), m t = m t ** cases' t.eq_empty_or_nonempty with h h <;> simp [h, Set.not_nonempty_empty, m_empty] ** Qed
| |
MeasureTheory.OuterMeasure.boundedBy_apply ** α : Type u_1 m : Set α → ℝ≥0∞ s : Set α ⊢ ↑(boundedBy m) s = ⨅ t, ⨅ (_ : s ⊆ iUnion t), ∑' (n : ℕ), ⨆ (_ : Set.Nonempty (t n)), m (t n) ** simp [boundedBy, ofFunction_apply] ** Qed
| |
MeasureTheory.OuterMeasure.le_boundedBy ** α : Type u_1 m : Set α → ℝ≥0∞ μ : OuterMeasure α ⊢ μ ≤ boundedBy m ↔ ∀ (s : Set α), ↑μ s ≤ m s ** rw [boundedBy , le_ofFunction, forall_congr'] ** α : Type u_1 m : Set α → ℝ≥0∞ μ : OuterMeasure α ⊢ ∀ (a : Set α), ↑μ a ≤ ⨆ (_ : Set.Nonempty a), m a ↔ ↑μ a ≤ m a ** intro s ** α : Type u_1 m : Set α → ℝ≥0∞ μ : OuterMeasure α s : Set α ⊢ ↑μ s ≤ ⨆ (_ : Set.Nonempty s), m s ↔ ↑μ s ≤ m s ** cases' s.eq_empty_or_nonempty with h h <;> simp [h, Set.not_nonempty_empty] ** Qed
| |
MeasureTheory.OuterMeasure.le_boundedBy' ** α : Type u_1 m : Set α → ℝ≥0∞ μ : OuterMeasure α ⊢ μ ≤ boundedBy m ↔ ∀ (s : Set α), Set.Nonempty s → ↑μ s ≤ m s ** rw [le_boundedBy, forall_congr'] ** α : Type u_1 m : Set α → ℝ≥0∞ μ : OuterMeasure α ⊢ ∀ (a : Set α), ↑μ a ≤ m a ↔ Set.Nonempty a → ↑μ a ≤ m a ** intro s ** α : Type u_1 m : Set α → ℝ≥0∞ μ : OuterMeasure α s : Set α ⊢ ↑μ s ≤ m s ↔ Set.Nonempty s → ↑μ s ≤ m s ** cases' s.eq_empty_or_nonempty with h h <;> simp [h] ** Qed
| |
MeasureTheory.OuterMeasure.boundedBy_top ** α : Type u_1 m : Set α → ℝ≥0∞ ⊢ boundedBy ⊤ = ⊤ ** rw [eq_top_iff, le_boundedBy'] ** α : Type u_1 m : Set α → ℝ≥0∞ ⊢ ∀ (s : Set α), Set.Nonempty s → ↑⊤ s ≤ ⊤ s ** intro s hs ** α : Type u_1 m : Set α → ℝ≥0∞ s : Set α hs : Set.Nonempty s ⊢ ↑⊤ s ≤ ⊤ s ** rw [top_apply hs] ** α : Type u_1 m : Set α → ℝ≥0∞ s : Set α hs : Set.Nonempty s ⊢ ⊤ ≤ ⊤ s ** exact le_rfl ** Qed
| |
MeasureTheory.OuterMeasure.comap_boundedBy ** α : Type u_1 m : Set α → ℝ≥0∞ β : Type u_2 f : β → α h : (Monotone fun s => m ↑s) ∨ Surjective f ⊢ ↑(comap f) (boundedBy m) = boundedBy fun s => m (f '' s) ** refine' (comap_ofFunction _ _).trans _ ** case refine'_1 α : Type u_1 m : Set α → ℝ≥0∞ β : Type u_2 f : β → α h : (Monotone fun s => m ↑s) ∨ Surjective f ⊢ (Monotone fun s => ⨆ (_ : Set.Nonempty s), m s) ∨ Surjective f ** refine' h.imp (fun H s t hst => iSup_le fun hs => _) id ** case refine'_1 α : Type u_1 m : Set α → ℝ≥0∞ β : Type u_2 f : β → α h : (Monotone fun s => m ↑s) ∨ Surjective f H : Monotone fun s => m ↑s s t : Set α hst : s ≤ t hs : Set.Nonempty s ⊢ m s ≤ (fun s => ⨆ (_ : Set.Nonempty s), m s) t ** have ht : t.Nonempty := hs.mono hst ** case refine'_1 α : Type u_1 m : Set α → ℝ≥0∞ β : Type u_2 f : β → α h : (Monotone fun s => m ↑s) ∨ Surjective f H : Monotone fun s => m ↑s s t : Set α hst : s ≤ t hs : Set.Nonempty s ht : Set.Nonempty t ⊢ m s ≤ (fun s => ⨆ (_ : Set.Nonempty s), m s) t ** exact (@H ⟨s, hs⟩ ⟨t, ht⟩ hst).trans (le_iSup (fun _ : t.Nonempty => m t) ht) ** case refine'_2 α : Type u_1 m : Set α → ℝ≥0∞ β : Type u_2 f : β → α h : (Monotone fun s => m ↑s) ∨ Surjective f ⊢ OuterMeasure.ofFunction (fun s => ⨆ (_ : Set.Nonempty (f '' s)), m (f '' s)) (_ : (fun s => ⨆ (_ : Set.Nonempty (f '' s)), m (f '' s)) ∅ = 0) = boundedBy fun s => m (f '' s) ** dsimp only [boundedBy] ** case refine'_2 α : Type u_1 m : Set α → ℝ≥0∞ β : Type u_2 f : β → α h : (Monotone fun s => m ↑s) ∨ Surjective f ⊢ OuterMeasure.ofFunction (fun s => ⨆ (_ : Set.Nonempty (f '' s)), m (f '' s)) (_ : ⨆ (_ : Set.Nonempty (f '' ∅)), m (f '' ∅) = 0) = OuterMeasure.ofFunction (fun s => ⨆ (_ : Set.Nonempty s), m (f '' s)) (_ : ⨆ (_ : Set.Nonempty ∅), m (f '' ∅) = 0) ** congr with s : 1 ** case refine'_2.e_m.h α : Type u_1 m : Set α → ℝ≥0∞ β : Type u_2 f : β → α h : (Monotone fun s => m ↑s) ∨ Surjective f s : Set β ⊢ ⨆ (_ : Set.Nonempty (f '' s)), m (f '' s) = ⨆ (_ : Set.Nonempty s), m (f '' s) ** rw [nonempty_image_iff] ** Qed
| |
MeasureTheory.OuterMeasure.isCaratheodory_empty ** α : Type u m : OuterMeasure α s s₁ s₂ : Set α ⊢ IsCaratheodory m ∅ ** simp [IsCaratheodory, m.empty, diff_empty] ** Qed
| |
MeasureTheory.OuterMeasure.isCaratheodory_compl ** α : Type u m : OuterMeasure α s s₁ s₂ : Set α ⊢ IsCaratheodory m s₁ → IsCaratheodory m s₁ᶜ ** simp [IsCaratheodory, diff_eq, add_comm] ** Qed
| |
MeasureTheory.OuterMeasure.isCaratheodory_compl_iff ** α : Type u m : OuterMeasure α s s₁ s₂ : Set α h : IsCaratheodory m sᶜ ⊢ IsCaratheodory m s ** simpa using isCaratheodory_compl m h ** Qed
| |
MeasureTheory.OuterMeasure.isCaratheodory_union ** α : Type u m : OuterMeasure α s s₁ s₂ : Set α h₁ : IsCaratheodory m s₁ h₂ : IsCaratheodory m s₂ t : Set α ⊢ ↑m t = ↑m (t ∩ (s₁ ∪ s₂)) + ↑m (t \ (s₁ ∪ s₂)) ** rw [h₁ t, h₂ (t ∩ s₁), h₂ (t \ s₁), h₁ (t ∩ (s₁ ∪ s₂)), inter_diff_assoc _ _ s₁,
Set.inter_assoc _ _ s₁, inter_eq_self_of_subset_right (Set.subset_union_left _ _),
union_diff_left, h₂ (t ∩ s₁)] ** α : Type u m : OuterMeasure α s s₁ s₂ : Set α h₁ : IsCaratheodory m s₁ h₂ : IsCaratheodory m s₂ t : Set α ⊢ ↑m (t ∩ s₁ ∩ s₂) + ↑m ((t ∩ s₁) \ s₂) + (↑m (t \ s₁ ∩ s₂) + ↑m ((t \ s₁) \ s₂)) = ↑m (t ∩ s₁ ∩ s₂) + ↑m ((t ∩ s₁) \ s₂) + ↑m (t ∩ (s₂ \ s₁)) + ↑m (t \ (s₁ ∪ s₂)) ** simp [diff_eq, add_assoc] ** Qed
| |
MeasureTheory.OuterMeasure.measure_inter_union ** α : Type u m : OuterMeasure α s s₁ s₂ : Set α h : s₁ ∩ s₂ ⊆ ∅ h₁ : IsCaratheodory m s₁ t : Set α ⊢ ↑m (t ∩ (s₁ ∪ s₂)) = ↑m (t ∩ s₁) + ↑m (t ∩ s₂) ** rw [h₁, Set.inter_assoc, Set.union_inter_cancel_left, inter_diff_assoc, union_diff_cancel_left h] ** Qed
| |
MeasureTheory.OuterMeasure.isCaratheodory_iUnion_lt ** α : Type u m : OuterMeasure α s✝ s₁ s₂ : Set α s : ℕ → Set α x✝ : ∀ (i : ℕ), i < 0 → IsCaratheodory m (s i) ⊢ IsCaratheodory m (⋃ i, ⋃ (_ : i < 0), s i) ** simp [Nat.not_lt_zero] ** α : Type u m : OuterMeasure α s✝ s₁ s₂ : Set α s : ℕ → Set α n : ℕ h : ∀ (i : ℕ), i < n + 1 → IsCaratheodory m (s i) ⊢ IsCaratheodory m (⋃ i, ⋃ (_ : i < n + 1), s i) ** rw [biUnion_lt_succ] ** α : Type u m : OuterMeasure α s✝ s₁ s₂ : Set α s : ℕ → Set α n : ℕ h : ∀ (i : ℕ), i < n + 1 → IsCaratheodory m (s i) ⊢ IsCaratheodory m ((⋃ k, ⋃ (_ : k < n), s k) ∪ s n) ** exact isCaratheodory_union m
(isCaratheodory_iUnion_lt fun i hi => h i <| lt_of_lt_of_le hi <| Nat.le_succ _)
(h n (le_refl (n + 1))) ** Qed
| |
MeasureTheory.OuterMeasure.isCaratheodory_sum ** α : Type u m : OuterMeasure α s✝ s₁ s₂ : Set α s : ℕ → Set α h : ∀ (i : ℕ), IsCaratheodory m (s i) hd : Pairwise (Disjoint on s) t : Set α ⊢ ∑ i in Finset.range 0, ↑m (t ∩ s i) = ↑m (t ∩ ⋃ i, ⋃ (_ : i < 0), s i) ** simp [Nat.not_lt_zero, m.empty] ** α : Type u m : OuterMeasure α s✝ s₁ s₂ : Set α s : ℕ → Set α h : ∀ (i : ℕ), IsCaratheodory m (s i) hd : Pairwise (Disjoint on s) t : Set α n : ℕ ⊢ ∑ i in Finset.range (Nat.succ n), ↑m (t ∩ s i) = ↑m (t ∩ ⋃ i, ⋃ (_ : i < Nat.succ n), s i) ** rw [biUnion_lt_succ, Finset.sum_range_succ, Set.union_comm, isCaratheodory_sum h hd,
m.measure_inter_union _ (h n), add_comm] ** α : Type u m : OuterMeasure α s✝ s₁ s₂ : Set α s : ℕ → Set α h : ∀ (i : ℕ), IsCaratheodory m (s i) hd : Pairwise (Disjoint on s) t : Set α n : ℕ ⊢ s n ∩ ⋃ k, ⋃ (_ : k < n), s k ⊆ ∅ ** intro a ** α : Type u m : OuterMeasure α s✝ s₁ s₂ : Set α s : ℕ → Set α h : ∀ (i : ℕ), IsCaratheodory m (s i) hd : Pairwise (Disjoint on s) t : Set α n : ℕ a : α ⊢ a ∈ s n ∩ ⋃ k, ⋃ (_ : k < n), s k → a ∈ ∅ ** simpa using fun (h₁ : a ∈ s n) i (hi : i < n) h₂ => (hd (ne_of_gt hi)).le_bot ⟨h₁, h₂⟩ ** Qed
| |
MeasureTheory.OuterMeasure.f_iUnion ** α : Type u m : OuterMeasure α s✝ s₁ s₂ : Set α s : ℕ → Set α h : ∀ (i : ℕ), IsCaratheodory m (s i) hd : Pairwise (Disjoint on s) ⊢ ↑m (⋃ i, s i) = ∑' (i : ℕ), ↑m (s i) ** refine' le_antisymm (m.iUnion_nat s) _ ** α : Type u m : OuterMeasure α s✝ s₁ s₂ : Set α s : ℕ → Set α h : ∀ (i : ℕ), IsCaratheodory m (s i) hd : Pairwise (Disjoint on s) ⊢ ∑' (i : ℕ), ↑m (s i) ≤ ↑m (⋃ i, s i) ** rw [ENNReal.tsum_eq_iSup_nat] ** α : Type u m : OuterMeasure α s✝ s₁ s₂ : Set α s : ℕ → Set α h : ∀ (i : ℕ), IsCaratheodory m (s i) hd : Pairwise (Disjoint on s) ⊢ ⨆ i, ∑ a in Finset.range i, ↑m (s a) ≤ ↑m (⋃ i, s i) ** refine' iSup_le fun n => _ ** α : Type u m : OuterMeasure α s✝ s₁ s₂ : Set α s : ℕ → Set α h : ∀ (i : ℕ), IsCaratheodory m (s i) hd : Pairwise (Disjoint on s) n : ℕ ⊢ ∑ a in Finset.range n, ↑m (s a) ≤ ↑m (⋃ i, s i) ** have := @isCaratheodory_sum _ m _ h hd univ n ** α : Type u m : OuterMeasure α s✝ s₁ s₂ : Set α s : ℕ → Set α h : ∀ (i : ℕ), IsCaratheodory m (s i) hd : Pairwise (Disjoint on s) n : ℕ this : ∑ i in Finset.range n, ↑m (univ ∩ s i) = ↑m (univ ∩ ⋃ i, ⋃ (_ : i < n), s i) ⊢ ∑ a in Finset.range n, ↑m (s a) ≤ ↑m (⋃ i, s i) ** simp at this ** α : Type u m : OuterMeasure α s✝ s₁ s₂ : Set α s : ℕ → Set α h : ∀ (i : ℕ), IsCaratheodory m (s i) hd : Pairwise (Disjoint on s) n : ℕ this : ∑ x in Finset.range n, ↑m (s x) = ↑m (⋃ i, ⋃ (_ : i < n), s i) ⊢ ∑ a in Finset.range n, ↑m (s a) ≤ ↑m (⋃ i, s i) ** simp [this] ** α : Type u m : OuterMeasure α s✝ s₁ s₂ : Set α s : ℕ → Set α h : ∀ (i : ℕ), IsCaratheodory m (s i) hd : Pairwise (Disjoint on s) n : ℕ this : ∑ x in Finset.range n, ↑m (s x) = ↑m (⋃ i, ⋃ (_ : i < n), s i) ⊢ ↑m (⋃ i, ⋃ (_ : i < n), s i) ≤ ↑m (⋃ i, s i) ** exact m.mono (iUnion₂_subset fun i _ => subset_iUnion _ i) ** Qed
| |
MeasureTheory.OuterMeasure.boundedBy_caratheodory ** α : Type u_1 m : Set α → ℝ≥0∞ s : Set α hs : ∀ (t : Set α), m (t ∩ s) + m (t \ s) ≤ m t ⊢ MeasurableSet s ** apply ofFunction_caratheodory ** case hs α : Type u_1 m : Set α → ℝ≥0∞ s : Set α hs : ∀ (t : Set α), m (t ∩ s) + m (t \ s) ≤ m t ⊢ ∀ (t : Set α), (⨆ (_ : Set.Nonempty (t ∩ s)), m (t ∩ s)) + ⨆ (_ : Set.Nonempty (t \ s)), m (t \ s) ≤ ⨆ (_ : Set.Nonempty t), m t ** intro t ** case hs α : Type u_1 m : Set α → ℝ≥0∞ s : Set α hs : ∀ (t : Set α), m (t ∩ s) + m (t \ s) ≤ m t t : Set α ⊢ (⨆ (_ : Set.Nonempty (t ∩ s)), m (t ∩ s)) + ⨆ (_ : Set.Nonempty (t \ s)), m (t \ s) ≤ ⨆ (_ : Set.Nonempty t), m t ** cases' t.eq_empty_or_nonempty with h h ** case hs.inl α : Type u_1 m : Set α → ℝ≥0∞ s : Set α hs : ∀ (t : Set α), m (t ∩ s) + m (t \ s) ≤ m t t : Set α h : t = ∅ ⊢ (⨆ (_ : Set.Nonempty (t ∩ s)), m (t ∩ s)) + ⨆ (_ : Set.Nonempty (t \ s)), m (t \ s) ≤ ⨆ (_ : Set.Nonempty t), m t ** simp [h, Set.not_nonempty_empty] ** case hs.inr α : Type u_1 m : Set α → ℝ≥0∞ s : Set α hs : ∀ (t : Set α), m (t ∩ s) + m (t \ s) ≤ m t t : Set α h : Set.Nonempty t ⊢ (⨆ (_ : Set.Nonempty (t ∩ s)), m (t ∩ s)) + ⨆ (_ : Set.Nonempty (t \ s)), m (t \ s) ≤ ⨆ (_ : Set.Nonempty t), m t ** convert le_trans _ (hs t) ** case hs.inr.convert_2 α : Type u_1 m : Set α → ℝ≥0∞ s : Set α hs : ∀ (t : Set α), m (t ∩ s) + m (t \ s) ≤ m t t : Set α h : Set.Nonempty t ⊢ (⨆ (_ : Set.Nonempty (t ∩ s)), m (t ∩ s)) + ⨆ (_ : Set.Nonempty (t \ s)), m (t \ s) ≤ m (t ∩ s) + m (t \ s) ** exact add_le_add iSup_const_le iSup_const_le ** case h.e'_4 α : Type u_1 m : Set α → ℝ≥0∞ s : Set α hs : ∀ (t : Set α), m (t ∩ s) + m (t \ s) ≤ m t t : Set α h : Set.Nonempty t ⊢ ⨆ (_ : Set.Nonempty t), m t = m t ** simp [h] ** Qed
| |
MeasureTheory.OuterMeasure.top_caratheodory ** α : Type u_1 s : Set α x✝ : MeasurableSet s t : Set α ht : t = ∅ ⊢ ↑⊤ (t ∩ s) + ↑⊤ (t \ s) ≤ ↑⊤ t ** simp [ht] ** α : Type u_1 s : Set α x✝ : MeasurableSet s t : Set α ht : Set.Nonempty t ⊢ ↑⊤ (t ∩ s) + ↑⊤ (t \ s) ≤ ↑⊤ t ** simp only [ht, top_apply, le_top] ** Qed
| |
MeasureTheory.OuterMeasure.le_add_caratheodory ** α : Type u_1 m₁ m₂ : OuterMeasure α s : Set α x✝ : MeasurableSet s t : Set α hs₁ : s ∈ (fun m => {t | MeasurableSet t}) (OuterMeasure.caratheodory m₁) hs₂ : s ∈ (fun m => {t | MeasurableSet t}) (OuterMeasure.caratheodory m₂) ⊢ ↑(m₁ + m₂) t = ↑(m₁ + m₂) (t ∩ s) + ↑(m₁ + m₂) (t \ s) ** simp [hs₁ t, hs₂ t, add_left_comm, add_assoc] ** Qed
| |
MeasureTheory.OuterMeasure.dirac_caratheodory ** α : Type u_1 a : α s : Set α x✝ : MeasurableSet s t : Set α ⊢ ↑(dirac a) t = ↑(dirac a) (t ∩ s) + ↑(dirac a) (t \ s) ** by_cases ht : a ∈ t ** case pos α : Type u_1 a : α s : Set α x✝ : MeasurableSet s t : Set α ht : a ∈ t ⊢ ↑(dirac a) t = ↑(dirac a) (t ∩ s) + ↑(dirac a) (t \ s) case neg α : Type u_1 a : α s : Set α x✝ : MeasurableSet s t : Set α ht : ¬a ∈ t ⊢ ↑(dirac a) t = ↑(dirac a) (t ∩ s) + ↑(dirac a) (t \ s) ** swap ** case pos α : Type u_1 a : α s : Set α x✝ : MeasurableSet s t : Set α ht : a ∈ t ⊢ ↑(dirac a) t = ↑(dirac a) (t ∩ s) + ↑(dirac a) (t \ s) ** by_cases hs : a ∈ s <;> simp [*] ** case neg α : Type u_1 a : α s : Set α x✝ : MeasurableSet s t : Set α ht : ¬a ∈ t ⊢ ↑(dirac a) t = ↑(dirac a) (t ∩ s) + ↑(dirac a) (t \ s) ** simp [ht] ** Qed
| |
MeasureTheory.OuterMeasure.sInf_eq_boundedBy_sInfGen ** α : Type u_1 m : Set (OuterMeasure α) ⊢ sInf m = boundedBy (sInfGen m) ** refine' le_antisymm _ _ ** case refine'_1 α : Type u_1 m : Set (OuterMeasure α) ⊢ sInf m ≤ boundedBy (sInfGen m) ** refine' le_boundedBy.2 fun s => le_iInf₂ fun μ hμ => _ ** case refine'_1 α : Type u_1 m : Set (OuterMeasure α) s : Set α μ : OuterMeasure α hμ : μ ∈ m ⊢ ↑(sInf m) s ≤ ↑μ s ** apply sInf_le hμ ** case refine'_2 α : Type u_1 m : Set (OuterMeasure α) ⊢ boundedBy (sInfGen m) ≤ sInf m ** refine' le_sInf _ ** case refine'_2 α : Type u_1 m : Set (OuterMeasure α) ⊢ ∀ (b : OuterMeasure α), b ∈ m → boundedBy (sInfGen m) ≤ b ** intro μ hμ t ** case refine'_2 α : Type u_1 m : Set (OuterMeasure α) μ : OuterMeasure α hμ : μ ∈ m t : Set α ⊢ ↑(boundedBy (sInfGen m)) t ≤ ↑μ t ** refine' le_trans (boundedBy_le t) (iInf₂_le μ hμ) ** Qed
| |
MeasureTheory.OuterMeasure.iSup_sInfGen_nonempty ** α : Type u_1 m : Set (OuterMeasure α) h : Set.Nonempty m t : Set α ⊢ ⨆ (_ : Set.Nonempty t), sInfGen m t = ⨅ μ ∈ m, ↑μ t ** rcases t.eq_empty_or_nonempty with (rfl | ht) ** case inl α : Type u_1 m : Set (OuterMeasure α) h : Set.Nonempty m ⊢ ⨆ (_ : Set.Nonempty ∅), sInfGen m ∅ = ⨅ μ ∈ m, ↑μ ∅ ** rcases h with ⟨μ, hμ⟩ ** case inl.intro α : Type u_1 m : Set (OuterMeasure α) μ : OuterMeasure α hμ : μ ∈ m ⊢ ⨆ (_ : Set.Nonempty ∅), sInfGen m ∅ = ⨅ μ ∈ m, ↑μ ∅ ** rw [eq_false Set.not_nonempty_empty, iSup_false, eq_comm] ** case inl.intro α : Type u_1 m : Set (OuterMeasure α) μ : OuterMeasure α hμ : μ ∈ m ⊢ ⨅ μ ∈ m, ↑μ ∅ = ⊥ ** simp_rw [empty'] ** case inl.intro α : Type u_1 m : Set (OuterMeasure α) μ : OuterMeasure α hμ : μ ∈ m ⊢ ⨅ μ ∈ m, 0 = ⊥ ** apply bot_unique ** case inl.intro.h α : Type u_1 m : Set (OuterMeasure α) μ : OuterMeasure α hμ : μ ∈ m ⊢ ⨅ μ ∈ m, 0 ≤ ⊥ ** refine' iInf_le_of_le μ (iInf_le _ hμ) ** case inr α : Type u_1 m : Set (OuterMeasure α) h : Set.Nonempty m t : Set α ht : Set.Nonempty t ⊢ ⨆ (_ : Set.Nonempty t), sInfGen m t = ⨅ μ ∈ m, ↑μ t ** simp [ht, sInfGen_def] ** Qed
| |
MeasureTheory.OuterMeasure.sInf_apply' ** α : Type u_1 m : Set (OuterMeasure α) s : Set α h : Set.Nonempty s hm : m = ∅ ⊢ ↑(sInf m) s = ⨅ t, ⨅ (_ : s ⊆ iUnion t), ∑' (n : ℕ), ⨅ μ ∈ m, ↑μ (t n) ** simp [hm, h] ** Qed
| |
MeasureTheory.OuterMeasure.iInf_apply ** α : Type u_1 ι : Sort u_2 inst✝ : Nonempty ι m : ι → OuterMeasure α s : Set α ⊢ ↑(⨅ i, m i) s = ⨅ t, ⨅ (_ : s ⊆ iUnion t), ∑' (n : ℕ), ⨅ i, ↑(m i) (t n) ** rw [iInf, sInf_apply (range_nonempty m)] ** α : Type u_1 ι : Sort u_2 inst✝ : Nonempty ι m : ι → OuterMeasure α s : Set α ⊢ ⨅ t, ⨅ (_ : s ⊆ iUnion t), ∑' (n : ℕ), ⨅ μ ∈ range m, ↑μ (t n) = ⨅ t, ⨅ (_ : s ⊆ iUnion t), ∑' (n : ℕ), ⨅ i, ↑(m i) (t n) ** simp only [iInf_range] ** Qed
| |
MeasureTheory.OuterMeasure.biInf_apply ** α : Type u_1 ι : Type u_2 I : Set ι hI : Set.Nonempty I m : ι → OuterMeasure α s : Set α ⊢ ↑(⨅ i ∈ I, m i) s = ⨅ t, ⨅ (_ : s ⊆ iUnion t), ∑' (n : ℕ), ⨅ i ∈ I, ↑(m i) (t n) ** haveI := hI.to_subtype ** α : Type u_1 ι : Type u_2 I : Set ι hI : Set.Nonempty I m : ι → OuterMeasure α s : Set α this : Nonempty ↑I ⊢ ↑(⨅ i ∈ I, m i) s = ⨅ t, ⨅ (_ : s ⊆ iUnion t), ∑' (n : ℕ), ⨅ i ∈ I, ↑(m i) (t n) ** simp only [← iInf_subtype'', iInf_apply] ** Qed
| |
MeasureTheory.OuterMeasure.biInf_apply' ** α : Type u_1 ι : Type u_2 I : Set ι m : ι → OuterMeasure α s : Set α hs : Set.Nonempty s ⊢ ↑(⨅ i ∈ I, m i) s = ⨅ t, ⨅ (_ : s ⊆ iUnion t), ∑' (n : ℕ), ⨅ i ∈ I, ↑(m i) (t n) ** simp only [← iInf_subtype'', iInf_apply' _ hs] ** Qed
| |
MeasureTheory.OuterMeasure.map_biInf_comap ** α : Type u_1 ι : Type u_2 β : Type u_3 I : Set ι hI : Set.Nonempty I f : α → β m : ι → OuterMeasure β ⊢ ↑(map f) (⨅ i ∈ I, ↑(comap f) (m i)) = ⨅ i ∈ I, ↑(map f) (↑(comap f) (m i)) ** haveI := hI.to_subtype ** α : Type u_1 ι : Type u_2 β : Type u_3 I : Set ι hI : Set.Nonempty I f : α → β m : ι → OuterMeasure β this : Nonempty ↑I ⊢ ↑(map f) (⨅ i ∈ I, ↑(comap f) (m i)) = ⨅ i ∈ I, ↑(map f) (↑(comap f) (m i)) ** rw [← iInf_subtype'', ← iInf_subtype''] ** α : Type u_1 ι : Type u_2 β : Type u_3 I : Set ι hI : Set.Nonempty I f : α → β m : ι → OuterMeasure β this : Nonempty ↑I ⊢ ↑(map f) (⨅ i, ↑(comap f) (m ↑i)) = ⨅ i, ↑(map f) (↑(comap f) (m ↑i)) ** exact map_iInf_comap _ ** Qed
| |
MeasureTheory.extend_eq ** α : Type u_1 P : α → Prop m : (s : α) → P s → ℝ≥0∞ s : α h : P s ⊢ extend m s = m s h ** simp [extend, h] ** Qed
| |
MeasureTheory.extend_eq_top ** α : Type u_1 P : α → Prop m : (s : α) → P s → ℝ≥0∞ s : α h : ¬P s ⊢ extend m s = ⊤ ** simp [extend, h] ** Qed
| |
MeasureTheory.le_extend ** α : Type u_1 P : α → Prop m : (s : α) → P s → ℝ≥0∞ s : α h : P s ⊢ m s h ≤ extend m s ** simp only [extend, le_iInf_iff] ** α : Type u_1 P : α → Prop m : (s : α) → P s → ℝ≥0∞ s : α h : P s ⊢ ∀ (i : P s), m s h ≤ m s i ** intro ** α : Type u_1 P : α → Prop m : (s : α) → P s → ℝ≥0∞ s : α h i✝ : P s ⊢ m s h ≤ m s i✝ ** rfl ** Qed
| |
MeasureTheory.extend_iUnion_nat ** α : Type u_1 P : Set α → Prop m : (s : Set α) → P s → ℝ≥0∞ P0 : P ∅ m0 : m ∅ P0 = 0 PU : ∀ ⦃f : ℕ → Set α⦄, (∀ (i : ℕ), P (f i)) → P (⋃ i, f i) mU✝ : ∀ ⦃f : ℕ → Set α⦄ (hm : ∀ (i : ℕ), P (f i)), Pairwise (Disjoint on f) → m (⋃ i, f i) (_ : P (⋃ i, f i)) = ∑' (i : ℕ), m (f i) (_ : P (f i)) msU : ∀ ⦃f : ℕ → Set α⦄ (hm : ∀ (i : ℕ), P (f i)), m (⋃ i, f i) (_ : P (⋃ i, f i)) ≤ ∑' (i : ℕ), m (f i) (_ : P (f i)) m_mono : ∀ ⦃s₁ s₂ : Set α⦄ (hs₁ : P s₁) (hs₂ : P s₂), s₁ ⊆ s₂ → m s₁ hs₁ ≤ m s₂ hs₂ f : ℕ → Set α hm : ∀ (i : ℕ), P (f i) mU : m (⋃ i, f i) (_ : P (⋃ i, f i)) = ∑' (i : ℕ), m (f i) (_ : P (f i)) ⊢ ∑' (i : ℕ), m (f i) (_ : P (f i)) = ∑' (i : ℕ), extend m (f i) ** congr with i ** case e_f.h α : Type u_1 P : Set α → Prop m : (s : Set α) → P s → ℝ≥0∞ P0 : P ∅ m0 : m ∅ P0 = 0 PU : ∀ ⦃f : ℕ → Set α⦄, (∀ (i : ℕ), P (f i)) → P (⋃ i, f i) mU✝ : ∀ ⦃f : ℕ → Set α⦄ (hm : ∀ (i : ℕ), P (f i)), Pairwise (Disjoint on f) → m (⋃ i, f i) (_ : P (⋃ i, f i)) = ∑' (i : ℕ), m (f i) (_ : P (f i)) msU : ∀ ⦃f : ℕ → Set α⦄ (hm : ∀ (i : ℕ), P (f i)), m (⋃ i, f i) (_ : P (⋃ i, f i)) ≤ ∑' (i : ℕ), m (f i) (_ : P (f i)) m_mono : ∀ ⦃s₁ s₂ : Set α⦄ (hs₁ : P s₁) (hs₂ : P s₂), s₁ ⊆ s₂ → m s₁ hs₁ ≤ m s₂ hs₂ f : ℕ → Set α hm : ∀ (i : ℕ), P (f i) mU : m (⋃ i, f i) (_ : P (⋃ i, f i)) = ∑' (i : ℕ), m (f i) (_ : P (f i)) i : ℕ ⊢ m (f i) (_ : P (f i)) = extend m (f i) ** rw [extend_eq] ** Qed
| |
MeasureTheory.extend_iUnion_le_tsum_nat' ** α : Type u_1 P : Set α → Prop m : (s : Set α) → P s → ℝ≥0∞ P0 : P ∅ m0 : m ∅ P0 = 0 PU : ∀ ⦃f : ℕ → Set α⦄, (∀ (i : ℕ), P (f i)) → P (⋃ i, f i) mU : ∀ ⦃f : ℕ → Set α⦄ (hm : ∀ (i : ℕ), P (f i)), Pairwise (Disjoint on f) → m (⋃ i, f i) (_ : P (⋃ i, f i)) = ∑' (i : ℕ), m (f i) (_ : P (f i)) msU : ∀ ⦃f : ℕ → Set α⦄ (hm : ∀ (i : ℕ), P (f i)), m (⋃ i, f i) (_ : P (⋃ i, f i)) ≤ ∑' (i : ℕ), m (f i) (_ : P (f i)) m_mono : ∀ ⦃s₁ s₂ : Set α⦄ (hs₁ : P s₁) (hs₂ : P s₂), s₁ ⊆ s₂ → m s₁ hs₁ ≤ m s₂ hs₂ s : ℕ → Set α ⊢ extend m (⋃ i, s i) ≤ ∑' (i : ℕ), extend m (s i) ** by_cases h : ∀ i, P (s i) ** case pos α : Type u_1 P : Set α → Prop m : (s : Set α) → P s → ℝ≥0∞ P0 : P ∅ m0 : m ∅ P0 = 0 PU : ∀ ⦃f : ℕ → Set α⦄, (∀ (i : ℕ), P (f i)) → P (⋃ i, f i) mU : ∀ ⦃f : ℕ → Set α⦄ (hm : ∀ (i : ℕ), P (f i)), Pairwise (Disjoint on f) → m (⋃ i, f i) (_ : P (⋃ i, f i)) = ∑' (i : ℕ), m (f i) (_ : P (f i)) msU : ∀ ⦃f : ℕ → Set α⦄ (hm : ∀ (i : ℕ), P (f i)), m (⋃ i, f i) (_ : P (⋃ i, f i)) ≤ ∑' (i : ℕ), m (f i) (_ : P (f i)) m_mono : ∀ ⦃s₁ s₂ : Set α⦄ (hs₁ : P s₁) (hs₂ : P s₂), s₁ ⊆ s₂ → m s₁ hs₁ ≤ m s₂ hs₂ s : ℕ → Set α h : ∀ (i : ℕ), P (s i) ⊢ extend m (⋃ i, s i) ≤ ∑' (i : ℕ), extend m (s i) ** rw [extend_eq _ (PU h), congr_arg tsum _] ** α : Type u_1 P : Set α → Prop m : (s : Set α) → P s → ℝ≥0∞ P0 : P ∅ m0 : m ∅ P0 = 0 PU : ∀ ⦃f : ℕ → Set α⦄, (∀ (i : ℕ), P (f i)) → P (⋃ i, f i) mU : ∀ ⦃f : ℕ → Set α⦄ (hm : ∀ (i : ℕ), P (f i)), Pairwise (Disjoint on f) → m (⋃ i, f i) (_ : P (⋃ i, f i)) = ∑' (i : ℕ), m (f i) (_ : P (f i)) msU : ∀ ⦃f : ℕ → Set α⦄ (hm : ∀ (i : ℕ), P (f i)), m (⋃ i, f i) (_ : P (⋃ i, f i)) ≤ ∑' (i : ℕ), m (f i) (_ : P (f i)) m_mono : ∀ ⦃s₁ s₂ : Set α⦄ (hs₁ : P s₁) (hs₂ : P s₂), s₁ ⊆ s₂ → m s₁ hs₁ ≤ m s₂ hs₂ s : ℕ → Set α h : ∀ (i : ℕ), P (s i) ⊢ (fun i => extend m (s i)) = fun i => m (s i) (_ : P (s i)) ** funext i ** case h α : Type u_1 P : Set α → Prop m : (s : Set α) → P s → ℝ≥0∞ P0 : P ∅ m0 : m ∅ P0 = 0 PU : ∀ ⦃f : ℕ → Set α⦄, (∀ (i : ℕ), P (f i)) → P (⋃ i, f i) mU : ∀ ⦃f : ℕ → Set α⦄ (hm : ∀ (i : ℕ), P (f i)), Pairwise (Disjoint on f) → m (⋃ i, f i) (_ : P (⋃ i, f i)) = ∑' (i : ℕ), m (f i) (_ : P (f i)) msU : ∀ ⦃f : ℕ → Set α⦄ (hm : ∀ (i : ℕ), P (f i)), m (⋃ i, f i) (_ : P (⋃ i, f i)) ≤ ∑' (i : ℕ), m (f i) (_ : P (f i)) m_mono : ∀ ⦃s₁ s₂ : Set α⦄ (hs₁ : P s₁) (hs₂ : P s₂), s₁ ⊆ s₂ → m s₁ hs₁ ≤ m s₂ hs₂ s : ℕ → Set α h : ∀ (i : ℕ), P (s i) i : ℕ ⊢ extend m (s i) = m (s i) (_ : P (s i)) ** apply extend_eq _ (h i) ** case pos α : Type u_1 P : Set α → Prop m : (s : Set α) → P s → ℝ≥0∞ P0 : P ∅ m0 : m ∅ P0 = 0 PU : ∀ ⦃f : ℕ → Set α⦄, (∀ (i : ℕ), P (f i)) → P (⋃ i, f i) mU : ∀ ⦃f : ℕ → Set α⦄ (hm : ∀ (i : ℕ), P (f i)), Pairwise (Disjoint on f) → m (⋃ i, f i) (_ : P (⋃ i, f i)) = ∑' (i : ℕ), m (f i) (_ : P (f i)) msU : ∀ ⦃f : ℕ → Set α⦄ (hm : ∀ (i : ℕ), P (f i)), m (⋃ i, f i) (_ : P (⋃ i, f i)) ≤ ∑' (i : ℕ), m (f i) (_ : P (f i)) m_mono : ∀ ⦃s₁ s₂ : Set α⦄ (hs₁ : P s₁) (hs₂ : P s₂), s₁ ⊆ s₂ → m s₁ hs₁ ≤ m s₂ hs₂ s : ℕ → Set α h : ∀ (i : ℕ), P (s i) ⊢ m (⋃ i, s i) (_ : P (⋃ i, s i)) ≤ tsum ?m.284093 ** apply msU h ** case neg α : Type u_1 P : Set α → Prop m : (s : Set α) → P s → ℝ≥0∞ P0 : P ∅ m0 : m ∅ P0 = 0 PU : ∀ ⦃f : ℕ → Set α⦄, (∀ (i : ℕ), P (f i)) → P (⋃ i, f i) mU : ∀ ⦃f : ℕ → Set α⦄ (hm : ∀ (i : ℕ), P (f i)), Pairwise (Disjoint on f) → m (⋃ i, f i) (_ : P (⋃ i, f i)) = ∑' (i : ℕ), m (f i) (_ : P (f i)) msU : ∀ ⦃f : ℕ → Set α⦄ (hm : ∀ (i : ℕ), P (f i)), m (⋃ i, f i) (_ : P (⋃ i, f i)) ≤ ∑' (i : ℕ), m (f i) (_ : P (f i)) m_mono : ∀ ⦃s₁ s₂ : Set α⦄ (hs₁ : P s₁) (hs₂ : P s₂), s₁ ⊆ s₂ → m s₁ hs₁ ≤ m s₂ hs₂ s : ℕ → Set α h : ¬∀ (i : ℕ), P (s i) ⊢ extend m (⋃ i, s i) ≤ ∑' (i : ℕ), extend m (s i) ** cases' not_forall.1 h with i hi ** case neg.intro α : Type u_1 P : Set α → Prop m : (s : Set α) → P s → ℝ≥0∞ P0 : P ∅ m0 : m ∅ P0 = 0 PU : ∀ ⦃f : ℕ → Set α⦄, (∀ (i : ℕ), P (f i)) → P (⋃ i, f i) mU : ∀ ⦃f : ℕ → Set α⦄ (hm : ∀ (i : ℕ), P (f i)), Pairwise (Disjoint on f) → m (⋃ i, f i) (_ : P (⋃ i, f i)) = ∑' (i : ℕ), m (f i) (_ : P (f i)) msU : ∀ ⦃f : ℕ → Set α⦄ (hm : ∀ (i : ℕ), P (f i)), m (⋃ i, f i) (_ : P (⋃ i, f i)) ≤ ∑' (i : ℕ), m (f i) (_ : P (f i)) m_mono : ∀ ⦃s₁ s₂ : Set α⦄ (hs₁ : P s₁) (hs₂ : P s₂), s₁ ⊆ s₂ → m s₁ hs₁ ≤ m s₂ hs₂ s : ℕ → Set α h : ¬∀ (i : ℕ), P (s i) i : ℕ hi : ¬P (s i) ⊢ extend m (⋃ i, s i) ≤ ∑' (i : ℕ), extend m (s i) ** exact le_trans (le_iInf fun h => hi.elim h) (ENNReal.le_tsum i) ** Qed
| |
MeasureTheory.extend_mono' ** α : Type u_1 P : Set α → Prop m : (s : Set α) → P s → ℝ≥0∞ P0 : P ∅ m0 : m ∅ P0 = 0 PU : ∀ ⦃f : ℕ → Set α⦄, (∀ (i : ℕ), P (f i)) → P (⋃ i, f i) mU : ∀ ⦃f : ℕ → Set α⦄ (hm : ∀ (i : ℕ), P (f i)), Pairwise (Disjoint on f) → m (⋃ i, f i) (_ : P (⋃ i, f i)) = ∑' (i : ℕ), m (f i) (_ : P (f i)) msU : ∀ ⦃f : ℕ → Set α⦄ (hm : ∀ (i : ℕ), P (f i)), m (⋃ i, f i) (_ : P (⋃ i, f i)) ≤ ∑' (i : ℕ), m (f i) (_ : P (f i)) m_mono : ∀ ⦃s₁ s₂ : Set α⦄ (hs₁ : P s₁) (hs₂ : P s₂), s₁ ⊆ s₂ → m s₁ hs₁ ≤ m s₂ hs₂ s₁ s₂ : Set α h₁ : P s₁ hs : s₁ ⊆ s₂ ⊢ extend m s₁ ≤ extend m s₂ ** refine' le_iInf _ ** α : Type u_1 P : Set α → Prop m : (s : Set α) → P s → ℝ≥0∞ P0 : P ∅ m0 : m ∅ P0 = 0 PU : ∀ ⦃f : ℕ → Set α⦄, (∀ (i : ℕ), P (f i)) → P (⋃ i, f i) mU : ∀ ⦃f : ℕ → Set α⦄ (hm : ∀ (i : ℕ), P (f i)), Pairwise (Disjoint on f) → m (⋃ i, f i) (_ : P (⋃ i, f i)) = ∑' (i : ℕ), m (f i) (_ : P (f i)) msU : ∀ ⦃f : ℕ → Set α⦄ (hm : ∀ (i : ℕ), P (f i)), m (⋃ i, f i) (_ : P (⋃ i, f i)) ≤ ∑' (i : ℕ), m (f i) (_ : P (f i)) m_mono : ∀ ⦃s₁ s₂ : Set α⦄ (hs₁ : P s₁) (hs₂ : P s₂), s₁ ⊆ s₂ → m s₁ hs₁ ≤ m s₂ hs₂ s₁ s₂ : Set α h₁ : P s₁ hs : s₁ ⊆ s₂ ⊢ ∀ (i : (fun s => P s) s₂), extend m s₁ ≤ m s₂ i ** intro h₂ ** α : Type u_1 P : Set α → Prop m : (s : Set α) → P s → ℝ≥0∞ P0 : P ∅ m0 : m ∅ P0 = 0 PU : ∀ ⦃f : ℕ → Set α⦄, (∀ (i : ℕ), P (f i)) → P (⋃ i, f i) mU : ∀ ⦃f : ℕ → Set α⦄ (hm : ∀ (i : ℕ), P (f i)), Pairwise (Disjoint on f) → m (⋃ i, f i) (_ : P (⋃ i, f i)) = ∑' (i : ℕ), m (f i) (_ : P (f i)) msU : ∀ ⦃f : ℕ → Set α⦄ (hm : ∀ (i : ℕ), P (f i)), m (⋃ i, f i) (_ : P (⋃ i, f i)) ≤ ∑' (i : ℕ), m (f i) (_ : P (f i)) m_mono : ∀ ⦃s₁ s₂ : Set α⦄ (hs₁ : P s₁) (hs₂ : P s₂), s₁ ⊆ s₂ → m s₁ hs₁ ≤ m s₂ hs₂ s₁ s₂ : Set α h₁ : P s₁ hs : s₁ ⊆ s₂ h₂ : (fun s => P s) s₂ ⊢ extend m s₁ ≤ m s₂ h₂ ** rw [extend_eq m h₁] ** α : Type u_1 P : Set α → Prop m : (s : Set α) → P s → ℝ≥0∞ P0 : P ∅ m0 : m ∅ P0 = 0 PU : ∀ ⦃f : ℕ → Set α⦄, (∀ (i : ℕ), P (f i)) → P (⋃ i, f i) mU : ∀ ⦃f : ℕ → Set α⦄ (hm : ∀ (i : ℕ), P (f i)), Pairwise (Disjoint on f) → m (⋃ i, f i) (_ : P (⋃ i, f i)) = ∑' (i : ℕ), m (f i) (_ : P (f i)) msU : ∀ ⦃f : ℕ → Set α⦄ (hm : ∀ (i : ℕ), P (f i)), m (⋃ i, f i) (_ : P (⋃ i, f i)) ≤ ∑' (i : ℕ), m (f i) (_ : P (f i)) m_mono : ∀ ⦃s₁ s₂ : Set α⦄ (hs₁ : P s₁) (hs₂ : P s₂), s₁ ⊆ s₂ → m s₁ hs₁ ≤ m s₂ hs₂ s₁ s₂ : Set α h₁ : P s₁ hs : s₁ ⊆ s₂ h₂ : (fun s => P s) s₂ ⊢ m s₁ h₁ ≤ m s₂ h₂ ** exact m_mono h₁ h₂ hs ** Qed
| |
MeasureTheory.extend_union ** α : Type u_1 P : Set α → Prop m : (s : Set α) → P s → ℝ≥0∞ P0 : P ∅ m0 : m ∅ P0 = 0 PU : ∀ ⦃f : ℕ → Set α⦄, (∀ (i : ℕ), P (f i)) → P (⋃ i, f i) mU : ∀ ⦃f : ℕ → Set α⦄ (hm : ∀ (i : ℕ), P (f i)), Pairwise (Disjoint on f) → m (⋃ i, f i) (_ : P (⋃ i, f i)) = ∑' (i : ℕ), m (f i) (_ : P (f i)) msU : ∀ ⦃f : ℕ → Set α⦄ (hm : ∀ (i : ℕ), P (f i)), m (⋃ i, f i) (_ : P (⋃ i, f i)) ≤ ∑' (i : ℕ), m (f i) (_ : P (f i)) m_mono : ∀ ⦃s₁ s₂ : Set α⦄ (hs₁ : P s₁) (hs₂ : P s₂), s₁ ⊆ s₂ → m s₁ hs₁ ≤ m s₂ hs₂ s₁ s₂ : Set α hd : Disjoint s₁ s₂ h₁ : P s₁ h₂ : P s₂ ⊢ extend m (s₁ ∪ s₂) = extend m s₁ + extend m s₂ ** rw [union_eq_iUnion,
extend_iUnion P0 m0 PU mU (pairwise_disjoint_on_bool.2 hd) (Bool.forall_bool.2 ⟨h₂, h₁⟩),
tsum_fintype] ** α : Type u_1 P : Set α → Prop m : (s : Set α) → P s → ℝ≥0∞ P0 : P ∅ m0 : m ∅ P0 = 0 PU : ∀ ⦃f : ℕ → Set α⦄, (∀ (i : ℕ), P (f i)) → P (⋃ i, f i) mU : ∀ ⦃f : ℕ → Set α⦄ (hm : ∀ (i : ℕ), P (f i)), Pairwise (Disjoint on f) → m (⋃ i, f i) (_ : P (⋃ i, f i)) = ∑' (i : ℕ), m (f i) (_ : P (f i)) msU : ∀ ⦃f : ℕ → Set α⦄ (hm : ∀ (i : ℕ), P (f i)), m (⋃ i, f i) (_ : P (⋃ i, f i)) ≤ ∑' (i : ℕ), m (f i) (_ : P (f i)) m_mono : ∀ ⦃s₁ s₂ : Set α⦄ (hs₁ : P s₁) (hs₂ : P s₂), s₁ ⊆ s₂ → m s₁ hs₁ ≤ m s₂ hs₂ s₁ s₂ : Set α hd : Disjoint s₁ s₂ h₁ : P s₁ h₂ : P s₂ ⊢ ∑ b : Bool, extend m (bif b then s₁ else s₂) = extend m s₁ + extend m s₂ ** simp ** Qed
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.