l3lab/ntp-mathlib huggingface dataset:
theorem has_good_supp_iff {α : Type u} (x : F α) :
    (∀ p, Liftp p x ↔ ∀ u ∈ supp x, p u) ↔
      ∃ a f, abs ⟨a, f⟩ = x ∧ ∀ a' f', abs ⟨a', f'⟩ = x → f '' univ ⊆ f' '' univ := by
  constructor
  · intro h
    have : Liftp (supp x) x := by rw [h]; intro u; exact id
    rw [liftp_iff] at this
    rcases this with ⟨a, f, xeq, h'⟩
    refine' ⟨a, f, xeq.symm, _⟩
    intro a' f' h''
    rintro u ⟨i, _, hfi⟩
    have : u ∈ supp x := by rw [← hfi]; apply h'
    exact (mem_supp x u).mp this _ _ h''
  rintro ⟨a, f, xeq, h⟩ p; rw [liftp_iff]; constructor
  · rintro ⟨a', f', xeq', h'⟩ u usuppx
    rcases (mem_supp x u).mp usuppx a' f' xeq'.symm with ⟨i, _, f'ieq⟩
    

Proof state:
case mpr.intro.intro.intro.mp.intro.intro.intro.intro.intro
F : Type u → Type u
inst✝ : Functor F
q : QPF F
α : Type u
x : F α
a : (P F).A
f : PFunctor.B (P F) a → α
xeq : abs { fst := a, snd := f } = x
h : ∀ (a' : (P F).A) (f' : PFunctor.B (P F) a' → α), abs { fst := a', snd := f' } = x → f '' univ ⊆ f' '' univ
p : α → Prop
a' : (P F).A
f' : PFunctor.B (P F) a' → α
xeq' : x = abs { fst := a', snd := f' }
h' : ∀ (i : PFunctor.B (P F) a'), p (f' i)
u : α
usuppx : u ∈ supp x
i : PFunctor.B (P F) a'
left✝ : i ∈ univ
f'ieq : f' i = u
⊢ p u

Next tactic:
rw [← f'ieq]
theorem has_good_supp_iff {α : Type u} (x : F α) :
    (∀ p, Liftp p x ↔ ∀ u ∈ supp x, p u) ↔
      ∃ a f, abs ⟨a, f⟩ = x ∧ ∀ a' f', abs ⟨a', f'⟩ = x → f '' univ ⊆ f' '' univ := by
  constructor
  · intro h
    have : Liftp (supp x) x := by rw [h]; intro u; exact id
    rw [liftp_iff] at this
    rcases this with ⟨a, f, xeq, h'⟩
    refine' ⟨a, f, xeq.symm, _⟩
    intro a' f' h''
    rintro u ⟨i, _, hfi⟩
    have : u ∈ supp x := by rw [← hfi]; apply h'
    exact (mem_supp x u).mp this _ _ h''
  rintro ⟨a, f, xeq, h⟩ p; rw [liftp_iff]; constructor
  · rintro ⟨a', f', xeq', h'⟩ u usuppx
    rcases (mem_supp x u).mp usuppx a' f' xeq'.symm with ⟨i, _, f'ieq⟩
    rw [← f'ieq]
    

Proof state:
case mpr.intro.intro.intro.mp.intro.intro.intro.intro.intro
F : Type u → Type u
inst✝ : Functor F
q : QPF F
α : Type u
x : F α
a : (P F).A
f : PFunctor.B (P F) a → α
xeq : abs { fst := a, snd := f } = x
h : ∀ (a' : (P F).A) (f' : PFunctor.B (P F) a' → α), abs { fst := a', snd := f' } = x → f '' univ ⊆ f' '' univ
p : α → Prop
a' : (P F).A
f' : PFunctor.B (P F) a' → α
xeq' : x = abs { fst := a', snd := f' }
h' : ∀ (i : PFunctor.B (P F) a'), p (f' i)
u : α
usuppx : u ∈ supp x
i : PFunctor.B (P F) a'
left✝ : i ∈ univ
f'ieq : f' i = u
⊢ p (f' i)

Next tactic:
apply h'
theorem has_good_supp_iff {α : Type u} (x : F α) :
    (∀ p, Liftp p x ↔ ∀ u ∈ supp x, p u) ↔
      ∃ a f, abs ⟨a, f⟩ = x ∧ ∀ a' f', abs ⟨a', f'⟩ = x → f '' univ ⊆ f' '' univ := by
  constructor
  · intro h
    have : Liftp (supp x) x := by rw [h]; intro u; exact id
    rw [liftp_iff] at this
    rcases this with ⟨a, f, xeq, h'⟩
    refine' ⟨a, f, xeq.symm, _⟩
    intro a' f' h''
    rintro u ⟨i, _, hfi⟩
    have : u ∈ supp x := by rw [← hfi]; apply h'
    exact (mem_supp x u).mp this _ _ h''
  rintro ⟨a, f, xeq, h⟩ p; rw [liftp_iff]; constructor
  · rintro ⟨a', f', xeq', h'⟩ u usuppx
    rcases (mem_supp x u).mp usuppx a' f' xeq'.symm with ⟨i, _, f'ieq⟩
    rw [← f'ieq]
    apply h'
  

Proof state:
case mpr.intro.intro.intro.mpr
F : Type u → Type u
inst✝ : Functor F
q : QPF F
α : Type u
x : F α
a : (P F).A
f : PFunctor.B (P F) a → α
xeq : abs { fst := a, snd := f } = x
h : ∀ (a' : (P F).A) (f' : PFunctor.B (P F) a' → α), abs { fst := a', snd := f' } = x → f '' univ ⊆ f' '' univ
p : α → Prop
⊢ (∀ u ∈ supp x, p u) → ∃ a f, x = abs { fst := a, snd := f } ∧ ∀ (i : PFunctor.B (P F) a), p (f i)

Next tactic:
intro h'
theorem has_good_supp_iff {α : Type u} (x : F α) :
    (∀ p, Liftp p x ↔ ∀ u ∈ supp x, p u) ↔
      ∃ a f, abs ⟨a, f⟩ = x ∧ ∀ a' f', abs ⟨a', f'⟩ = x → f '' univ ⊆ f' '' univ := by
  constructor
  · intro h
    have : Liftp (supp x) x := by rw [h]; intro u; exact id
    rw [liftp_iff] at this
    rcases this with ⟨a, f, xeq, h'⟩
    refine' ⟨a, f, xeq.symm, _⟩
    intro a' f' h''
    rintro u ⟨i, _, hfi⟩
    have : u ∈ supp x := by rw [← hfi]; apply h'
    exact (mem_supp x u).mp this _ _ h''
  rintro ⟨a, f, xeq, h⟩ p; rw [liftp_iff]; constructor
  · rintro ⟨a', f', xeq', h'⟩ u usuppx
    rcases (mem_supp x u).mp usuppx a' f' xeq'.symm with ⟨i, _, f'ieq⟩
    rw [← f'ieq]
    apply h'
  intro h'
  

Proof state:
case mpr.intro.intro.intro.mpr
F : Type u → Type u
inst✝ : Functor F
q : QPF F
α : Type u
x : F α
a : (P F).A
f : PFunctor.B (P F) a → α
xeq : abs { fst := a, snd := f } = x
h : ∀ (a' : (P F).A) (f' : PFunctor.B (P F) a' → α), abs { fst := a', snd := f' } = x → f '' univ ⊆ f' '' univ
p : α → Prop
h' : ∀ u ∈ supp x, p u
⊢ ∃ a f, x = abs { fst := a, snd := f } ∧ ∀ (i : PFunctor.B (P F) a), p (f i)

Next tactic:
refine' ⟨a, f, xeq.symm, _⟩
theorem has_good_supp_iff {α : Type u} (x : F α) :
    (∀ p, Liftp p x ↔ ∀ u ∈ supp x, p u) ↔
      ∃ a f, abs ⟨a, f⟩ = x ∧ ∀ a' f', abs ⟨a', f'⟩ = x → f '' univ ⊆ f' '' univ := by
  constructor
  · intro h
    have : Liftp (supp x) x := by rw [h]; intro u; exact id
    rw [liftp_iff] at this
    rcases this with ⟨a, f, xeq, h'⟩
    refine' ⟨a, f, xeq.symm, _⟩
    intro a' f' h''
    rintro u ⟨i, _, hfi⟩
    have : u ∈ supp x := by rw [← hfi]; apply h'
    exact (mem_supp x u).mp this _ _ h''
  rintro ⟨a, f, xeq, h⟩ p; rw [liftp_iff]; constructor
  · rintro ⟨a', f', xeq', h'⟩ u usuppx
    rcases (mem_supp x u).mp usuppx a' f' xeq'.symm with ⟨i, _, f'ieq⟩
    rw [← f'ieq]
    apply h'
  intro h'
  refine' ⟨a, f, xeq.symm, _⟩; 

Proof state:
case mpr.intro.intro.intro.mpr
F : Type u → Type u
inst✝ : Functor F
q : QPF F
α : Type u
x : F α
a : (P F).A
f : PFunctor.B (P F) a → α
xeq : abs { fst := a, snd := f } = x
h : ∀ (a' : (P F).A) (f' : PFunctor.B (P F) a' → α), abs { fst := a', snd := f' } = x → f '' univ ⊆ f' '' univ
p : α → Prop
h' : ∀ u ∈ supp x, p u
⊢ ∀ (i : PFunctor.B (P F) a), p (f i)

Next tactic:
intro i
theorem has_good_supp_iff {α : Type u} (x : F α) :
    (∀ p, Liftp p x ↔ ∀ u ∈ supp x, p u) ↔
      ∃ a f, abs ⟨a, f⟩ = x ∧ ∀ a' f', abs ⟨a', f'⟩ = x → f '' univ ⊆ f' '' univ := by
  constructor
  · intro h
    have : Liftp (supp x) x := by rw [h]; intro u; exact id
    rw [liftp_iff] at this
    rcases this with ⟨a, f, xeq, h'⟩
    refine' ⟨a, f, xeq.symm, _⟩
    intro a' f' h''
    rintro u ⟨i, _, hfi⟩
    have : u ∈ supp x := by rw [← hfi]; apply h'
    exact (mem_supp x u).mp this _ _ h''
  rintro ⟨a, f, xeq, h⟩ p; rw [liftp_iff]; constructor
  · rintro ⟨a', f', xeq', h'⟩ u usuppx
    rcases (mem_supp x u).mp usuppx a' f' xeq'.symm with ⟨i, _, f'ieq⟩
    rw [← f'ieq]
    apply h'
  intro h'
  refine' ⟨a, f, xeq.symm, _⟩; intro i
  

Proof state:
case mpr.intro.intro.intro.mpr
F : Type u → Type u
inst✝ : Functor F
q : QPF F
α : Type u
x : F α
a : (P F).A
f : PFunctor.B (P F) a → α
xeq : abs { fst := a, snd := f } = x
h : ∀ (a' : (P F).A) (f' : PFunctor.B (P F) a' → α), abs { fst := a', snd := f' } = x → f '' univ ⊆ f' '' univ
p : α → Prop
h' : ∀ u ∈ supp x, p u
i : PFunctor.B (P F) a
⊢ p (f i)

Next tactic:
apply h'
theorem has_good_supp_iff {α : Type u} (x : F α) :
    (∀ p, Liftp p x ↔ ∀ u ∈ supp x, p u) ↔
      ∃ a f, abs ⟨a, f⟩ = x ∧ ∀ a' f', abs ⟨a', f'⟩ = x → f '' univ ⊆ f' '' univ := by
  constructor
  · intro h
    have : Liftp (supp x) x := by rw [h]; intro u; exact id
    rw [liftp_iff] at this
    rcases this with ⟨a, f, xeq, h'⟩
    refine' ⟨a, f, xeq.symm, _⟩
    intro a' f' h''
    rintro u ⟨i, _, hfi⟩
    have : u ∈ supp x := by rw [← hfi]; apply h'
    exact (mem_supp x u).mp this _ _ h''
  rintro ⟨a, f, xeq, h⟩ p; rw [liftp_iff]; constructor
  · rintro ⟨a', f', xeq', h'⟩ u usuppx
    rcases (mem_supp x u).mp usuppx a' f' xeq'.symm with ⟨i, _, f'ieq⟩
    rw [← f'ieq]
    apply h'
  intro h'
  refine' ⟨a, f, xeq.symm, _⟩; intro i
  apply h'; 

Proof state:
case mpr.intro.intro.intro.mpr.a
F : Type u → Type u
inst✝ : Functor F
q : QPF F
α : Type u
x : F α
a : (P F).A
f : PFunctor.B (P F) a → α
xeq : abs { fst := a, snd := f } = x
h : ∀ (a' : (P F).A) (f' : PFunctor.B (P F) a' → α), abs { fst := a', snd := f' } = x → f '' univ ⊆ f' '' univ
p : α → Prop
h' : ∀ u ∈ supp x, p u
i : PFunctor.B (P F) a
⊢ f i ∈ supp x

Next tactic:
rw [mem_supp]
theorem has_good_supp_iff {α : Type u} (x : F α) :
    (∀ p, Liftp p x ↔ ∀ u ∈ supp x, p u) ↔
      ∃ a f, abs ⟨a, f⟩ = x ∧ ∀ a' f', abs ⟨a', f'⟩ = x → f '' univ ⊆ f' '' univ := by
  constructor
  · intro h
    have : Liftp (supp x) x := by rw [h]; intro u; exact id
    rw [liftp_iff] at this
    rcases this with ⟨a, f, xeq, h'⟩
    refine' ⟨a, f, xeq.symm, _⟩
    intro a' f' h''
    rintro u ⟨i, _, hfi⟩
    have : u ∈ supp x := by rw [← hfi]; apply h'
    exact (mem_supp x u).mp this _ _ h''
  rintro ⟨a, f, xeq, h⟩ p; rw [liftp_iff]; constructor
  · rintro ⟨a', f', xeq', h'⟩ u usuppx
    rcases (mem_supp x u).mp usuppx a' f' xeq'.symm with ⟨i, _, f'ieq⟩
    rw [← f'ieq]
    apply h'
  intro h'
  refine' ⟨a, f, xeq.symm, _⟩; intro i
  apply h'; rw [mem_supp]
  

Proof state:
case mpr.intro.intro.intro.mpr.a
F : Type u → Type u
inst✝ : Functor F
q : QPF F
α : Type u
x : F α
a : (P F).A
f : PFunctor.B (P F) a → α
xeq : abs { fst := a, snd := f } = x
h : ∀ (a' : (P F).A) (f' : PFunctor.B (P F) a' → α), abs { fst := a', snd := f' } = x → f '' univ ⊆ f' '' univ
p : α → Prop
h' : ∀ u ∈ supp x, p u
i : PFunctor.B (P F) a
⊢ ∀ (a : (P F).A) (f_1 : PFunctor.B (P F) a → α), abs { fst := a, snd := f_1 } = x → f i ∈ f_1 '' univ

Next tactic:
intro a' f' xeq'
theorem has_good_supp_iff {α : Type u} (x : F α) :
    (∀ p, Liftp p x ↔ ∀ u ∈ supp x, p u) ↔
      ∃ a f, abs ⟨a, f⟩ = x ∧ ∀ a' f', abs ⟨a', f'⟩ = x → f '' univ ⊆ f' '' univ := by
  constructor
  · intro h
    have : Liftp (supp x) x := by rw [h]; intro u; exact id
    rw [liftp_iff] at this
    rcases this with ⟨a, f, xeq, h'⟩
    refine' ⟨a, f, xeq.symm, _⟩
    intro a' f' h''
    rintro u ⟨i, _, hfi⟩
    have : u ∈ supp x := by rw [← hfi]; apply h'
    exact (mem_supp x u).mp this _ _ h''
  rintro ⟨a, f, xeq, h⟩ p; rw [liftp_iff]; constructor
  · rintro ⟨a', f', xeq', h'⟩ u usuppx
    rcases (mem_supp x u).mp usuppx a' f' xeq'.symm with ⟨i, _, f'ieq⟩
    rw [← f'ieq]
    apply h'
  intro h'
  refine' ⟨a, f, xeq.symm, _⟩; intro i
  apply h'; rw [mem_supp]
  intro a' f' xeq'
  

Proof state:
case mpr.intro.intro.intro.mpr.a
F : Type u → Type u
inst✝ : Functor F
q : QPF F
α : Type u
x : F α
a : (P F).A
f : PFunctor.B (P F) a → α
xeq : abs { fst := a, snd := f } = x
h : ∀ (a' : (P F).A) (f' : PFunctor.B (P F) a' → α), abs { fst := a', snd := f' } = x → f '' univ ⊆ f' '' univ
p : α → Prop
h' : ∀ u ∈ supp x, p u
i : PFunctor.B (P F) a
a' : (P F).A
f' : PFunctor.B (P F) a' → α
xeq' : abs { fst := a', snd := f' } = x
⊢ f i ∈ f' '' univ

Next tactic:
apply h a' f' xeq'
theorem has_good_supp_iff {α : Type u} (x : F α) :
    (∀ p, Liftp p x ↔ ∀ u ∈ supp x, p u) ↔
      ∃ a f, abs ⟨a, f⟩ = x ∧ ∀ a' f', abs ⟨a', f'⟩ = x → f '' univ ⊆ f' '' univ := by
  constructor
  · intro h
    have : Liftp (supp x) x := by rw [h]; intro u; exact id
    rw [liftp_iff] at this
    rcases this with ⟨a, f, xeq, h'⟩
    refine' ⟨a, f, xeq.symm, _⟩
    intro a' f' h''
    rintro u ⟨i, _, hfi⟩
    have : u ∈ supp x := by rw [← hfi]; apply h'
    exact (mem_supp x u).mp this _ _ h''
  rintro ⟨a, f, xeq, h⟩ p; rw [liftp_iff]; constructor
  · rintro ⟨a', f', xeq', h'⟩ u usuppx
    rcases (mem_supp x u).mp usuppx a' f' xeq'.symm with ⟨i, _, f'ieq⟩
    rw [← f'ieq]
    apply h'
  intro h'
  refine' ⟨a, f, xeq.symm, _⟩; intro i
  apply h'; rw [mem_supp]
  intro a' f' xeq'
  apply h a' f' xeq'
  

Proof state:
case mpr.intro.intro.intro.mpr.a.a
F : Type u → Type u
inst✝ : Functor F
q : QPF F
α : Type u
x : F α
a : (P F).A
f : PFunctor.B (P F) a → α
xeq : abs { fst := a, snd := f } = x
h : ∀ (a' : (P F).A) (f' : PFunctor.B (P F) a' → α), abs { fst := a', snd := f' } = x → f '' univ ⊆ f' '' univ
p : α → Prop
h' : ∀ u ∈ supp x, p u
i : PFunctor.B (P F) a
a' : (P F).A
f' : PFunctor.B (P F) a' → α
xeq' : abs { fst := a', snd := f' } = x
⊢ f i ∈ f '' univ

Next tactic:
apply mem_image_of_mem _ (mem_univ _)
theorem supp_eq_of_isUniform (h : q.IsUniform) {α : Type u} (a : q.P.A) (f : q.P.B a → α) :
    supp (abs ⟨a, f⟩) = f '' univ := by
  

Proof state:
F : Type u → Type u
inst✝ : Functor F
q : QPF F
h : IsUniform
α : Type u
a : (P F).A
f : PFunctor.B (P F) a → α
⊢ supp (abs { fst := a, snd := f }) = f '' univ

Next tactic:
ext u
theorem supp_eq_of_isUniform (h : q.IsUniform) {α : Type u} (a : q.P.A) (f : q.P.B a → α) :
    supp (abs ⟨a, f⟩) = f '' univ := by
  ext u; 

Proof state:
case h
F : Type u → Type u
inst✝ : Functor F
q : QPF F
h : IsUniform
α : Type u
a : (P F).A
f : PFunctor.B (P F) a → α
u : α
⊢ u ∈ supp (abs { fst := a, snd := f }) ↔ u ∈ f '' univ

Next tactic:
rw [mem_supp]
theorem supp_eq_of_isUniform (h : q.IsUniform) {α : Type u} (a : q.P.A) (f : q.P.B a → α) :
    supp (abs ⟨a, f⟩) = f '' univ := by
  ext u; rw [mem_supp]; 

Proof state:
case h
F : Type u → Type u
inst✝ : Functor F
q : QPF F
h : IsUniform
α : Type u
a : (P F).A
f : PFunctor.B (P F) a → α
u : α
⊢ (∀ (a_1 : (P F).A) (f_1 : PFunctor.B (P F) a_1 → α),
      abs { fst := a_1, snd := f_1 } = abs { fst := a, snd := f } → u ∈ f_1 '' univ) ↔
    u ∈ f '' univ

Next tactic:
constructor
theorem supp_eq_of_isUniform (h : q.IsUniform) {α : Type u} (a : q.P.A) (f : q.P.B a → α) :
    supp (abs ⟨a, f⟩) = f '' univ := by
  ext u; rw [mem_supp]; constructor
  · 

Proof state:
case h.mp
F : Type u → Type u
inst✝ : Functor F
q : QPF F
h : IsUniform
α : Type u
a : (P F).A
f : PFunctor.B (P F) a → α
u : α
⊢ (∀ (a_1 : (P F).A) (f_1 : PFunctor.B (P F) a_1 → α),
      abs { fst := a_1, snd := f_1 } = abs { fst := a, snd := f } → u ∈ f_1 '' univ) →
    u ∈ f '' univ

Next tactic:
intro h'
theorem supp_eq_of_isUniform (h : q.IsUniform) {α : Type u} (a : q.P.A) (f : q.P.B a → α) :
    supp (abs ⟨a, f⟩) = f '' univ := by
  ext u; rw [mem_supp]; constructor
  · intro h'
    

Proof state:
case h.mp
F : Type u → Type u
inst✝ : Functor F
q : QPF F
h : IsUniform
α : Type u
a : (P F).A
f : PFunctor.B (P F) a → α
u : α
h' :
  ∀ (a_1 : (P F).A) (f_1 : PFunctor.B (P F) a_1 → α),
    abs { fst := a_1, snd := f_1 } = abs { fst := a, snd := f } → u ∈ f_1 '' univ
⊢ u ∈ f '' univ

Next tactic:
apply h' _ _ rfl
theorem supp_eq_of_isUniform (h : q.IsUniform) {α : Type u} (a : q.P.A) (f : q.P.B a → α) :
    supp (abs ⟨a, f⟩) = f '' univ := by
  ext u; rw [mem_supp]; constructor
  · intro h'
    apply h' _ _ rfl
  

Proof state:
case h.mpr
F : Type u → Type u
inst✝ : Functor F
q : QPF F
h : IsUniform
α : Type u
a : (P F).A
f : PFunctor.B (P F) a → α
u : α
⊢ u ∈ f '' univ →
    ∀ (a_2 : (P F).A) (f_1 : PFunctor.B (P F) a_2 → α),
      abs { fst := a_2, snd := f_1 } = abs { fst := a, snd := f } → u ∈ f_1 '' univ

Next tactic:
intro h' a' f' e
theorem supp_eq_of_isUniform (h : q.IsUniform) {α : Type u} (a : q.P.A) (f : q.P.B a → α) :
    supp (abs ⟨a, f⟩) = f '' univ := by
  ext u; rw [mem_supp]; constructor
  · intro h'
    apply h' _ _ rfl
  intro h' a' f' e
  

Proof state:
case h.mpr
F : Type u → Type u
inst✝ : Functor F
q : QPF F
h : IsUniform
α : Type u
a : (P F).A
f : PFunctor.B (P F) a → α
u : α
h' : u ∈ f '' univ
a' : (P F).A
f' : PFunctor.B (P F) a' → α
e : abs { fst := a', snd := f' } = abs { fst := a, snd := f }
⊢ u ∈ f' '' univ

Next tactic:
rw [← h _ _ _ _ e.symm]
theorem supp_eq_of_isUniform (h : q.IsUniform) {α : Type u} (a : q.P.A) (f : q.P.B a → α) :
    supp (abs ⟨a, f⟩) = f '' univ := by
  ext u; rw [mem_supp]; constructor
  · intro h'
    apply h' _ _ rfl
  intro h' a' f' e
  rw [← h _ _ _ _ e.symm]; 

Proof state:
case h.mpr
F : Type u → Type u
inst✝ : Functor F
q : QPF F
h : IsUniform
α : Type u
a : (P F).A
f : PFunctor.B (P F) a → α
u : α
h' : u ∈ f '' univ
a' : (P F).A
f' : PFunctor.B (P F) a' → α
e : abs { fst := a', snd := f' } = abs { fst := a, snd := f }
⊢ u ∈ f '' univ

Next tactic:
apply h'
theorem liftp_iff_of_isUniform (h : q.IsUniform) {α : Type u} (x : F α) (p : α → Prop) :
    Liftp p x ↔ ∀ u ∈ supp x, p u := by
  

Proof state:
F : Type u → Type u
inst✝ : Functor F
q : QPF F
h : IsUniform
α : Type u
x : F α
p : α → Prop
⊢ Liftp p x ↔ ∀ u ∈ supp x, p u

Next tactic:
rw [liftp_iff, ← abs_repr x]
theorem liftp_iff_of_isUniform (h : q.IsUniform) {α : Type u} (x : F α) (p : α → Prop) :
    Liftp p x ↔ ∀ u ∈ supp x, p u := by
  rw [liftp_iff, ← abs_repr x]
  

Proof state:
F : Type u → Type u
inst✝ : Functor F
q : QPF F
h : IsUniform
α : Type u
x : F α
p : α → Prop
⊢ (∃ a f, abs (repr x) = abs { fst := a, snd := f } ∧ ∀ (i : PFunctor.B (P F) a), p (f i)) ↔
    ∀ u ∈ supp (abs (repr x)), p u

Next tactic:
cases' repr x with a f
theorem liftp_iff_of_isUniform (h : q.IsUniform) {α : Type u} (x : F α) (p : α → Prop) :
    Liftp p x ↔ ∀ u ∈ supp x, p u := by
  rw [liftp_iff, ← abs_repr x]
  cases' repr x with a f; 

Proof state:
case mk
F : Type u → Type u
inst✝ : Functor F
q : QPF F
h : IsUniform
α : Type u
x : F α
p : α → Prop
a : (P F).A
f : PFunctor.B (P F) a → α
⊢ (∃ a_1 f_1, abs { fst := a, snd := f } = abs { fst := a_1, snd := f_1 } ∧ ∀ (i : PFunctor.B (P F) a_1), p (f_1 i)) ↔
    ∀ u ∈ supp (abs { fst := a, snd := f }), p u

Next tactic:
constructor
theorem liftp_iff_of_isUniform (h : q.IsUniform) {α : Type u} (x : F α) (p : α → Prop) :
    Liftp p x ↔ ∀ u ∈ supp x, p u := by
  rw [liftp_iff, ← abs_repr x]
  cases' repr x with a f; constructor
  · 

Proof state:
case mk.mp
F : Type u → Type u
inst✝ : Functor F
q : QPF F
h : IsUniform
α : Type u
x : F α
p : α → Prop
a : (P F).A
f : PFunctor.B (P F) a → α
⊢ (∃ a_1 f_1, abs { fst := a, snd := f } = abs { fst := a_1, snd := f_1 } ∧ ∀ (i : PFunctor.B (P F) a_1), p (f_1 i)) →
    ∀ u ∈ supp (abs { fst := a, snd := f }), p u

Next tactic:
rintro ⟨a', f', abseq, hf⟩ u
theorem liftp_iff_of_isUniform (h : q.IsUniform) {α : Type u} (x : F α) (p : α → Prop) :
    Liftp p x ↔ ∀ u ∈ supp x, p u := by
  rw [liftp_iff, ← abs_repr x]
  cases' repr x with a f; constructor
  · rintro ⟨a', f', abseq, hf⟩ u
    

Proof state:
case mk.mp.intro.intro.intro
F : Type u → Type u
inst✝ : Functor F
q : QPF F
h : IsUniform
α : Type u
x : F α
p : α → Prop
a : (P F).A
f : PFunctor.B (P F) a → α
a' : (P F).A
f' : PFunctor.B (P F) a' → α
abseq : abs { fst := a, snd := f } = abs { fst := a', snd := f' }
hf : ∀ (i : PFunctor.B (P F) a'), p (f' i)
u : α
⊢ u ∈ supp (abs { fst := a, snd := f }) → p u

Next tactic:
rw [supp_eq_of_isUniform h, h _ _ _ _ abseq]
theorem liftp_iff_of_isUniform (h : q.IsUniform) {α : Type u} (x : F α) (p : α → Prop) :
    Liftp p x ↔ ∀ u ∈ supp x, p u := by
  rw [liftp_iff, ← abs_repr x]
  cases' repr x with a f; constructor
  · rintro ⟨a', f', abseq, hf⟩ u
    rw [supp_eq_of_isUniform h, h _ _ _ _ abseq]
    

Proof state:
case mk.mp.intro.intro.intro
F : Type u → Type u
inst✝ : Functor F
q : QPF F
h : IsUniform
α : Type u
x : F α
p : α → Prop
a : (P F).A
f : PFunctor.B (P F) a → α
a' : (P F).A
f' : PFunctor.B (P F) a' → α
abseq : abs { fst := a, snd := f } = abs { fst := a', snd := f' }
hf : ∀ (i : PFunctor.B (P F) a'), p (f' i)
u : α
⊢ u ∈ f' '' univ → p u

Next tactic:
rintro ⟨i, _, hi⟩
theorem liftp_iff_of_isUniform (h : q.IsUniform) {α : Type u} (x : F α) (p : α → Prop) :
    Liftp p x ↔ ∀ u ∈ supp x, p u := by
  rw [liftp_iff, ← abs_repr x]
  cases' repr x with a f; constructor
  · rintro ⟨a', f', abseq, hf⟩ u
    rw [supp_eq_of_isUniform h, h _ _ _ _ abseq]
    rintro ⟨i, _, hi⟩
    

Proof state:
case mk.mp.intro.intro.intro.intro.intro
F : Type u → Type u
inst✝ : Functor F
q : QPF F
h : IsUniform
α : Type u
x : F α
p : α → Prop
a : (P F).A
f : PFunctor.B (P F) a → α
a' : (P F).A
f' : PFunctor.B (P F) a' → α
abseq : abs { fst := a, snd := f } = abs { fst := a', snd := f' }
hf : ∀ (i : PFunctor.B (P F) a'), p (f' i)
u : α
i : PFunctor.B (P F) a'
left✝ : i ∈ univ
hi : f' i = u
⊢ p u

Next tactic:
rw [← hi]
theorem liftp_iff_of_isUniform (h : q.IsUniform) {α : Type u} (x : F α) (p : α → Prop) :
    Liftp p x ↔ ∀ u ∈ supp x, p u := by
  rw [liftp_iff, ← abs_repr x]
  cases' repr x with a f; constructor
  · rintro ⟨a', f', abseq, hf⟩ u
    rw [supp_eq_of_isUniform h, h _ _ _ _ abseq]
    rintro ⟨i, _, hi⟩
    rw [← hi]
    

Proof state:
case mk.mp.intro.intro.intro.intro.intro
F : Type u → Type u
inst✝ : Functor F
q : QPF F
h : IsUniform
α : Type u
x : F α
p : α → Prop
a : (P F).A
f : PFunctor.B (P F) a → α
a' : (P F).A
f' : PFunctor.B (P F) a' → α
abseq : abs { fst := a, snd := f } = abs { fst := a', snd := f' }
hf : ∀ (i : PFunctor.B (P F) a'), p (f' i)
u : α
i : PFunctor.B (P F) a'
left✝ : i ∈ univ
hi : f' i = u
⊢ p (f' i)

Next tactic:
apply hf
theorem liftp_iff_of_isUniform (h : q.IsUniform) {α : Type u} (x : F α) (p : α → Prop) :
    Liftp p x ↔ ∀ u ∈ supp x, p u := by
  rw [liftp_iff, ← abs_repr x]
  cases' repr x with a f; constructor
  · rintro ⟨a', f', abseq, hf⟩ u
    rw [supp_eq_of_isUniform h, h _ _ _ _ abseq]
    rintro ⟨i, _, hi⟩
    rw [← hi]
    apply hf
  

Proof state:
case mk.mpr
F : Type u → Type u
inst✝ : Functor F
q : QPF F
h : IsUniform
α : Type u
x : F α
p : α → Prop
a : (P F).A
f : PFunctor.B (P F) a → α
⊢ (∀ u ∈ supp (abs { fst := a, snd := f }), p u) →
    ∃ a_2 f_1, abs { fst := a, snd := f } = abs { fst := a_2, snd := f_1 } ∧ ∀ (i : PFunctor.B (P F) a_2), p (f_1 i)

Next tactic:
intro h'
theorem liftp_iff_of_isUniform (h : q.IsUniform) {α : Type u} (x : F α) (p : α → Prop) :
    Liftp p x ↔ ∀ u ∈ supp x, p u := by
  rw [liftp_iff, ← abs_repr x]
  cases' repr x with a f; constructor
  · rintro ⟨a', f', abseq, hf⟩ u
    rw [supp_eq_of_isUniform h, h _ _ _ _ abseq]
    rintro ⟨i, _, hi⟩
    rw [← hi]
    apply hf
  intro h'
  

Proof state:
case mk.mpr
F : Type u → Type u
inst✝ : Functor F
q : QPF F
h : IsUniform
α : Type u
x : F α
p : α → Prop
a : (P F).A
f : PFunctor.B (P F) a → α
h' : ∀ u ∈ supp (abs { fst := a, snd := f }), p u
⊢ ∃ a_1 f_1, abs { fst := a, snd := f } = abs { fst := a_1, snd := f_1 } ∧ ∀ (i : PFunctor.B (P F) a_1), p (f_1 i)

Next tactic:
refine' ⟨a, f, rfl, fun i => h' _ _⟩
theorem liftp_iff_of_isUniform (h : q.IsUniform) {α : Type u} (x : F α) (p : α → Prop) :
    Liftp p x ↔ ∀ u ∈ supp x, p u := by
  rw [liftp_iff, ← abs_repr x]
  cases' repr x with a f; constructor
  · rintro ⟨a', f', abseq, hf⟩ u
    rw [supp_eq_of_isUniform h, h _ _ _ _ abseq]
    rintro ⟨i, _, hi⟩
    rw [← hi]
    apply hf
  intro h'
  refine' ⟨a, f, rfl, fun i => h' _ _⟩
  

Proof state:
case mk.mpr
F : Type u → Type u
inst✝ : Functor F
q : QPF F
h : IsUniform
α : Type u
x : F α
p : α → Prop
a : (P F).A
f : PFunctor.B (P F) a → α
h' : ∀ u ∈ supp (abs { fst := a, snd := f }), p u
i : PFunctor.B (P F) a
⊢ f i ∈ supp (abs { fst := a, snd := f })

Next tactic:
rw [supp_eq_of_isUniform h]
theorem liftp_iff_of_isUniform (h : q.IsUniform) {α : Type u} (x : F α) (p : α → Prop) :
    Liftp p x ↔ ∀ u ∈ supp x, p u := by
  rw [liftp_iff, ← abs_repr x]
  cases' repr x with a f; constructor
  · rintro ⟨a', f', abseq, hf⟩ u
    rw [supp_eq_of_isUniform h, h _ _ _ _ abseq]
    rintro ⟨i, _, hi⟩
    rw [← hi]
    apply hf
  intro h'
  refine' ⟨a, f, rfl, fun i => h' _ _⟩
  rw [supp_eq_of_isUniform h]
  

Proof state:
case mk.mpr
F : Type u → Type u
inst✝ : Functor F
q : QPF F
h : IsUniform
α : Type u
x : F α
p : α → Prop
a : (P F).A
f : PFunctor.B (P F) a → α
h' : ∀ u ∈ supp (abs { fst := a, snd := f }), p u
i : PFunctor.B (P F) a
⊢ f i ∈ f '' univ

Next tactic:
exact ⟨i, mem_univ i, rfl⟩
theorem supp_map (h : q.IsUniform) {α β : Type u} (g : α → β) (x : F α) :
    supp (g <$> x) = g '' supp x := by
  

Proof state:
F : Type u → Type u
inst✝ : Functor F
q : QPF F
h : IsUniform
α β : Type u
g : α → β
x : F α
⊢ supp (g <$> x) = g '' supp x

Next tactic:
rw [← abs_repr x]
theorem supp_map (h : q.IsUniform) {α β : Type u} (g : α → β) (x : F α) :
    supp (g <$> x) = g '' supp x := by
  rw [← abs_repr x]; 

Proof state:
F : Type u → Type u
inst✝ : Functor F
q : QPF F
h : IsUniform
α β : Type u
g : α → β
x : F α
⊢ supp (g <$> abs (repr x)) = g '' supp (abs (repr x))

Next tactic:
cases' repr x with a f