l3lab/ntp-mathlib huggingface dataset:
theorem supp_eq_of_isUniform (h : q.IsUniform) {α : TypeVec n} (a : q.P.A) (f : q.P.B a ⟹ α) :
    ∀ i, supp (abs ⟨a, f⟩) i = f i '' univ := by
  intro; ext u; rw [mem_supp]; constructor
  · 

Proof state:
case h.mp
n : ℕ
F : TypeVec.{u} n → Type u_1
inst✝ : MvFunctor F
q : MvQPF F
h : IsUniform
α : TypeVec.{u} n
a : (P F).A
f : MvPFunctor.B (P F) a ⟹ α
i✝ : Fin2 n
u : α i✝
⊢ (∀ (a_1 : (P F).A) (f_1 : MvPFunctor.B (P F) a_1 ⟹ α),
      abs { fst := a_1, snd := f_1 } = abs { fst := a, snd := f } → u ∈ f_1 i✝ '' univ) →
    u ∈ f i✝ '' univ

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

Proof state:
case h.mp
n : ℕ
F : TypeVec.{u} n → Type u_1
inst✝ : MvFunctor F
q : MvQPF F
h : IsUniform
α : TypeVec.{u} n
a : (P F).A
f : MvPFunctor.B (P F) a ⟹ α
i✝ : Fin2 n
u : α i✝
h' :
  ∀ (a_1 : (P F).A) (f_1 : MvPFunctor.B (P F) a_1 ⟹ α),
    abs { fst := a_1, snd := f_1 } = abs { fst := a, snd := f } → u ∈ f_1 i✝ '' univ
⊢ u ∈ f i✝ '' univ

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

Proof state:
case h.mpr
n : ℕ
F : TypeVec.{u} n → Type u_1
inst✝ : MvFunctor F
q : MvQPF F
h : IsUniform
α : TypeVec.{u} n
a : (P F).A
f : MvPFunctor.B (P F) a ⟹ α
i✝ : Fin2 n
u : α i✝
⊢ u ∈ f i✝ '' univ →
    ∀ (a_2 : (P F).A) (f_1 : MvPFunctor.B (P F) a_2 ⟹ α),
      abs { fst := a_2, snd := f_1 } = abs { fst := a, snd := f } → u ∈ f_1 i✝ '' univ

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

Proof state:
case h.mpr
n : ℕ
F : TypeVec.{u} n → Type u_1
inst✝ : MvFunctor F
q : MvQPF F
h : IsUniform
α : TypeVec.{u} n
a : (P F).A
f : MvPFunctor.B (P F) a ⟹ α
i✝ : Fin2 n
u : α i✝
h' : u ∈ f i✝ '' univ
a' : (P F).A
f' : MvPFunctor.B (P F) a' ⟹ α
e : abs { fst := a', snd := f' } = abs { fst := a, snd := f }
⊢ u ∈ f' i✝ '' univ

Next tactic:
rw [← h _ _ _ _ e.symm]
theorem supp_eq_of_isUniform (h : q.IsUniform) {α : TypeVec n} (a : q.P.A) (f : q.P.B a ⟹ α) :
    ∀ i, supp (abs ⟨a, f⟩) i = f i '' univ := by
  intro; 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
n : ℕ
F : TypeVec.{u} n → Type u_1
inst✝ : MvFunctor F
q : MvQPF F
h : IsUniform
α : TypeVec.{u} n
a : (P F).A
f : MvPFunctor.B (P F) a ⟹ α
i✝ : Fin2 n
u : α i✝
h' : u ∈ f i✝ '' univ
a' : (P F).A
f' : MvPFunctor.B (P F) a' ⟹ α
e : abs { fst := a', snd := f' } = abs { fst := a, snd := f }
⊢ u ∈ f i✝ '' univ

Next tactic:
apply h'
theorem liftP_iff_of_isUniform (h : q.IsUniform) {α : TypeVec n} (x : F α) (p : ∀ i, α i → Prop) :
    LiftP p x ↔ ∀ (i), ∀ u ∈ supp x i, p i u := by
  

Proof state:
n : ℕ
F : TypeVec.{u} n → Type u_1
inst✝ : MvFunctor F
q : MvQPF F
h : IsUniform
α : TypeVec.{u} n
x : F α
p : (i : Fin2 n) → α i → Prop
⊢ LiftP p x ↔ ∀ (i : Fin2 n), ∀ u ∈ supp x i, p i u

Next tactic:
rw [liftP_iff, ← abs_repr x]
theorem liftP_iff_of_isUniform (h : q.IsUniform) {α : TypeVec n} (x : F α) (p : ∀ i, α i → Prop) :
    LiftP p x ↔ ∀ (i), ∀ u ∈ supp x i, p i u := by
  rw [liftP_iff, ← abs_repr x]
  

Proof state:
n : ℕ
F : TypeVec.{u} n → Type u_1
inst✝ : MvFunctor F
q : MvQPF F
h : IsUniform
α : TypeVec.{u} n
x : F α
p : (i : Fin2 n) → α i → Prop
⊢ (∃ a f, abs (repr x) = abs { fst := a, snd := f } ∧ ∀ (i : Fin2 n) (j : MvPFunctor.B (P F) a i), p i (f i j)) ↔
    ∀ (i : Fin2 n), ∀ u ∈ supp (abs (repr x)) i, p i u

Next tactic:
cases' repr x with a f
theorem liftP_iff_of_isUniform (h : q.IsUniform) {α : TypeVec n} (x : F α) (p : ∀ i, α i → Prop) :
    LiftP p x ↔ ∀ (i), ∀ u ∈ supp x i, p i u := by
  rw [liftP_iff, ← abs_repr x]
  cases' repr x with a f; 

Proof state:
case mk
n : ℕ
F : TypeVec.{u} n → Type u_1
inst✝ : MvFunctor F
q : MvQPF F
h : IsUniform
α : TypeVec.{u} n
x : F α
p : (i : Fin2 n) → α i → Prop
a : (P F).A
f : MvPFunctor.B (P F) a ⟹ α
⊢ (∃ a_1 f_1,
      abs { fst := a, snd := f } = abs { fst := a_1, snd := f_1 } ∧
        ∀ (i : Fin2 n) (j : MvPFunctor.B (P F) a_1 i), p i (f_1 i j)) ↔
    ∀ (i : Fin2 n), ∀ u ∈ supp (abs { fst := a, snd := f }) i, p i u

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

Proof state:
case mk.mp
n : ℕ
F : TypeVec.{u} n → Type u_1
inst✝ : MvFunctor F
q : MvQPF F
h : IsUniform
α : TypeVec.{u} n
x : F α
p : (i : Fin2 n) → α i → Prop
a : (P F).A
f : MvPFunctor.B (P F) a ⟹ α
⊢ (∃ a_1 f_1,
      abs { fst := a, snd := f } = abs { fst := a_1, snd := f_1 } ∧
        ∀ (i : Fin2 n) (j : MvPFunctor.B (P F) a_1 i), p i (f_1 i j)) →
    ∀ (i : Fin2 n), ∀ u ∈ supp (abs { fst := a, snd := f }) i, p i u

Next tactic:
rintro ⟨a', f', abseq, hf⟩ u
theorem liftP_iff_of_isUniform (h : q.IsUniform) {α : TypeVec n} (x : F α) (p : ∀ i, α i → Prop) :
    LiftP p x ↔ ∀ (i), ∀ u ∈ supp x i, p i 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
n : ℕ
F : TypeVec.{u} n → Type u_1
inst✝ : MvFunctor F
q : MvQPF F
h : IsUniform
α : TypeVec.{u} n
x : F α
p : (i : Fin2 n) → α i → Prop
a : (P F).A
f : MvPFunctor.B (P F) a ⟹ α
a' : (P F).A
f' : MvPFunctor.B (P F) a' ⟹ fun i => α i
abseq : abs { fst := a, snd := f } = abs { fst := a', snd := f' }
hf : ∀ (i : Fin2 n) (j : MvPFunctor.B (P F) a' i), p i (f' i j)
u : Fin2 n
⊢ ∀ u_1 ∈ supp (abs { fst := a, snd := f }) u, p u u_1

Next tactic:
rw [supp_eq_of_isUniform h, h _ _ _ _ abseq]
theorem liftP_iff_of_isUniform (h : q.IsUniform) {α : TypeVec n} (x : F α) (p : ∀ i, α i → Prop) :
    LiftP p x ↔ ∀ (i), ∀ u ∈ supp x i, p i 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
n : ℕ
F : TypeVec.{u} n → Type u_1
inst✝ : MvFunctor F
q : MvQPF F
h : IsUniform
α : TypeVec.{u} n
x : F α
p : (i : Fin2 n) → α i → Prop
a : (P F).A
f : MvPFunctor.B (P F) a ⟹ α
a' : (P F).A
f' : MvPFunctor.B (P F) a' ⟹ fun i => α i
abseq : abs { fst := a, snd := f } = abs { fst := a', snd := f' }
hf : ∀ (i : Fin2 n) (j : MvPFunctor.B (P F) a' i), p i (f' i j)
u : Fin2 n
⊢ ∀ u_1 ∈ f' u '' univ, p u u_1

Next tactic:
rintro b ⟨i, _, hi⟩
theorem liftP_iff_of_isUniform (h : q.IsUniform) {α : TypeVec n} (x : F α) (p : ∀ i, α i → Prop) :
    LiftP p x ↔ ∀ (i), ∀ u ∈ supp x i, p i 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 b ⟨i, _, hi⟩
    

Proof state:
case mk.mp.intro.intro.intro.intro.intro
n : ℕ
F : TypeVec.{u} n → Type u_1
inst✝ : MvFunctor F
q : MvQPF F
h : IsUniform
α : TypeVec.{u} n
x : F α
p : (i : Fin2 n) → α i → Prop
a : (P F).A
f : MvPFunctor.B (P F) a ⟹ α
a' : (P F).A
f' : MvPFunctor.B (P F) a' ⟹ fun i => α i
abseq : abs { fst := a, snd := f } = abs { fst := a', snd := f' }
hf : ∀ (i : Fin2 n) (j : MvPFunctor.B (P F) a' i), p i (f' i j)
u : Fin2 n
b : α u
i : MvPFunctor.B (P F) a' u
left✝ : i ∈ univ
hi : f' u i = b
⊢ p u b

Next tactic:
rw [← hi]
theorem liftP_iff_of_isUniform (h : q.IsUniform) {α : TypeVec n} (x : F α) (p : ∀ i, α i → Prop) :
    LiftP p x ↔ ∀ (i), ∀ u ∈ supp x i, p i 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 b ⟨i, _, hi⟩
    rw [← hi]
    

Proof state:
case mk.mp.intro.intro.intro.intro.intro
n : ℕ
F : TypeVec.{u} n → Type u_1
inst✝ : MvFunctor F
q : MvQPF F
h : IsUniform
α : TypeVec.{u} n
x : F α
p : (i : Fin2 n) → α i → Prop
a : (P F).A
f : MvPFunctor.B (P F) a ⟹ α
a' : (P F).A
f' : MvPFunctor.B (P F) a' ⟹ fun i => α i
abseq : abs { fst := a, snd := f } = abs { fst := a', snd := f' }
hf : ∀ (i : Fin2 n) (j : MvPFunctor.B (P F) a' i), p i (f' i j)
u : Fin2 n
b : α u
i : MvPFunctor.B (P F) a' u
left✝ : i ∈ univ
hi : f' u i = b
⊢ p u (f' u i)

Next tactic:
apply hf
theorem liftP_iff_of_isUniform (h : q.IsUniform) {α : TypeVec n} (x : F α) (p : ∀ i, α i → Prop) :
    LiftP p x ↔ ∀ (i), ∀ u ∈ supp x i, p i 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 b ⟨i, _, hi⟩
    rw [← hi]
    apply hf
  

Proof state:
case mk.mpr
n : ℕ
F : TypeVec.{u} n → Type u_1
inst✝ : MvFunctor F
q : MvQPF F
h : IsUniform
α : TypeVec.{u} n
x : F α
p : (i : Fin2 n) → α i → Prop
a : (P F).A
f : MvPFunctor.B (P F) a ⟹ α
⊢ (∀ (i : Fin2 n), ∀ u ∈ supp (abs { fst := a, snd := f }) i, p i u) →
    ∃ a_2 f_1,
      abs { fst := a, snd := f } = abs { fst := a_2, snd := f_1 } ∧
        ∀ (i : Fin2 n) (j : MvPFunctor.B (P F) a_2 i), p i (f_1 i j)

Next tactic:
intro h'
theorem liftP_iff_of_isUniform (h : q.IsUniform) {α : TypeVec n} (x : F α) (p : ∀ i, α i → Prop) :
    LiftP p x ↔ ∀ (i), ∀ u ∈ supp x i, p i 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 b ⟨i, _, hi⟩
    rw [← hi]
    apply hf
  intro h'
  

Proof state:
case mk.mpr
n : ℕ
F : TypeVec.{u} n → Type u_1
inst✝ : MvFunctor F
q : MvQPF F
h : IsUniform
α : TypeVec.{u} n
x : F α
p : (i : Fin2 n) → α i → Prop
a : (P F).A
f : MvPFunctor.B (P F) a ⟹ α
h' : ∀ (i : Fin2 n), ∀ u ∈ supp (abs { fst := a, snd := f }) i, p i u
⊢ ∃ a_1 f_1,
    abs { fst := a, snd := f } = abs { fst := a_1, snd := f_1 } ∧
      ∀ (i : Fin2 n) (j : MvPFunctor.B (P F) a_1 i), p i (f_1 i j)

Next tactic:
refine' ⟨a, f, rfl, fun _ i => h' _ _ _⟩
theorem liftP_iff_of_isUniform (h : q.IsUniform) {α : TypeVec n} (x : F α) (p : ∀ i, α i → Prop) :
    LiftP p x ↔ ∀ (i), ∀ u ∈ supp x i, p i 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 b ⟨i, _, hi⟩
    rw [← hi]
    apply hf
  intro h'
  refine' ⟨a, f, rfl, fun _ i => h' _ _ _⟩
  

Proof state:
case mk.mpr
n : ℕ
F : TypeVec.{u} n → Type u_1
inst✝ : MvFunctor F
q : MvQPF F
h : IsUniform
α : TypeVec.{u} n
x : F α
p : (i : Fin2 n) → α i → Prop
a : (P F).A
f : MvPFunctor.B (P F) a ⟹ α
h' : ∀ (i : Fin2 n), ∀ u ∈ supp (abs { fst := a, snd := f }) i, p i u
x✝ : Fin2 n
i : MvPFunctor.B (P F) a x✝
⊢ f x✝ i ∈ supp (abs { fst := a, snd := f }) x✝

Next tactic:
rw [supp_eq_of_isUniform h]
theorem liftP_iff_of_isUniform (h : q.IsUniform) {α : TypeVec n} (x : F α) (p : ∀ i, α i → Prop) :
    LiftP p x ↔ ∀ (i), ∀ u ∈ supp x i, p i 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 b ⟨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
n : ℕ
F : TypeVec.{u} n → Type u_1
inst✝ : MvFunctor F
q : MvQPF F
h : IsUniform
α : TypeVec.{u} n
x : F α
p : (i : Fin2 n) → α i → Prop
a : (P F).A
f : MvPFunctor.B (P F) a ⟹ α
h' : ∀ (i : Fin2 n), ∀ u ∈ supp (abs { fst := a, snd := f }) i, p i u
x✝ : Fin2 n
i : MvPFunctor.B (P F) a x✝
⊢ f x✝ i ∈ f x✝ '' univ

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

Proof state:
n : ℕ
F : TypeVec.{u} n → Type u_1
inst✝ : MvFunctor F
q : MvQPF F
h : IsUniform
α β : TypeVec.{u} n
g : α ⟹ β
x : F α
i : Fin2 n
⊢ supp (g <$$> x) i = g i '' supp x i

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

Proof state:
n : ℕ
F : TypeVec.{u} n → Type u_1
inst✝ : MvFunctor F
q : MvQPF F
h : IsUniform
α β : TypeVec.{u} n
g : α ⟹ β
x : F α
i : Fin2 n
⊢ supp (g <$$> abs (repr x)) i = g i '' supp (abs (repr x)) i

Next tactic:
cases' repr x with a f
theorem supp_map (h : q.IsUniform) {α β : TypeVec n} (g : α ⟹ β) (x : F α) (i) :
    supp (g <$$> x) i = g i '' supp x i := by
  rw [← abs_repr x]; cases' repr x with a f; 

Proof state:
case mk
n : ℕ
F : TypeVec.{u} n → Type u_1
inst✝ : MvFunctor F
q : MvQPF F
h : IsUniform
α β : TypeVec.{u} n
g : α ⟹ β
x : F α
i : Fin2 n
a : (P F).A
f : MvPFunctor.B (P F) a ⟹ α
⊢ supp (g <$$> abs { fst := a, snd := f }) i = g i '' supp (abs { fst := a, snd := f }) i

Next tactic:
rw [← abs_map, MvPFunctor.map_eq]
theorem supp_map (h : q.IsUniform) {α β : TypeVec n} (g : α ⟹ β) (x : F α) (i) :
    supp (g <$$> x) i = g i '' supp x i := by
  rw [← abs_repr x]; cases' repr x with a f; rw [← abs_map, MvPFunctor.map_eq]
  

Proof state:
case mk
n : ℕ
F : TypeVec.{u} n → Type u_1
inst✝ : MvFunctor F
q : MvQPF F
h : IsUniform
α β : TypeVec.{u} n
g : α ⟹ β
x : F α
i : Fin2 n
a : (P F).A
f : MvPFunctor.B (P F) a ⟹ α
⊢ supp (abs { fst := a, snd := g ⊚ f }) i = g i '' supp (abs { fst := a, snd := f }) i

Next tactic:
rw [supp_eq_of_isUniform h, supp_eq_of_isUniform h, ← image_comp]
theorem supp_map (h : q.IsUniform) {α β : TypeVec n} (g : α ⟹ β) (x : F α) (i) :
    supp (g <$$> x) i = g i '' supp x i := by
  rw [← abs_repr x]; cases' repr x with a f; rw [← abs_map, MvPFunctor.map_eq]
  rw [supp_eq_of_isUniform h, supp_eq_of_isUniform h, ← image_comp]
  

Proof state:
case mk
n : ℕ
F : TypeVec.{u} n → Type u_1
inst✝ : MvFunctor F
q : MvQPF F
h : IsUniform
α β : TypeVec.{u} n
g : α ⟹ β
x : F α
i : Fin2 n
a : (P F).A
f : MvPFunctor.B (P F) a ⟹ α
⊢ (g ⊚ f) i '' univ = g i ∘ f i '' univ

Next tactic:
rfl
theorem suppPreservation_iff_isUniform : q.SuppPreservation ↔ q.IsUniform := by
  

Proof state:
n : ℕ
F : TypeVec.{u} n → Type u_1
inst✝ : MvFunctor F
q : MvQPF F
⊢ SuppPreservation ↔ IsUniform

Next tactic:
constructor
theorem suppPreservation_iff_isUniform : q.SuppPreservation ↔ q.IsUniform := by
  constructor
  · 

Proof state:
case mp
n : ℕ
F : TypeVec.{u} n → Type u_1
inst✝ : MvFunctor F
q : MvQPF F
⊢ SuppPreservation → IsUniform

Next tactic:
intro h α a a' f f' h' i
theorem suppPreservation_iff_isUniform : q.SuppPreservation ↔ q.IsUniform := by
  constructor
  · intro h α a a' f f' h' i
    

Proof state:
case mp
n : ℕ
F : TypeVec.{u} n → Type u_1
inst✝ : MvFunctor F
q : MvQPF F
h : SuppPreservation
α : TypeVec.{u} n
a a' : (P F).A
f : MvPFunctor.B (P F) a ⟹ α
f' : MvPFunctor.B (P F) a' ⟹ α
h' : abs { fst := a, snd := f } = abs { fst := a', snd := f' }
i : Fin2 n
⊢ f i '' univ = f' i '' univ

Next tactic:
rw [← MvPFunctor.supp_eq, ← MvPFunctor.supp_eq, ← h, h', h]
theorem suppPreservation_iff_isUniform : q.SuppPreservation ↔ q.IsUniform := by
  constructor
  · intro h α a a' f f' h' i
    rw [← MvPFunctor.supp_eq, ← MvPFunctor.supp_eq, ← h, h', h]
  · 

Proof state:
case mpr
n : ℕ
F : TypeVec.{u} n → Type u_1
inst✝ : MvFunctor F
q : MvQPF F
⊢ IsUniform → SuppPreservation

Next tactic:
rintro h α ⟨a, f⟩
theorem suppPreservation_iff_isUniform : q.SuppPreservation ↔ q.IsUniform := by
  constructor
  · intro h α a a' f f' h' i
    rw [← MvPFunctor.supp_eq, ← MvPFunctor.supp_eq, ← h, h', h]
  · rintro h α ⟨a, f⟩
    

Proof state:
case mpr.mk
n : ℕ
F : TypeVec.{u} n → Type u_1
inst✝ : MvFunctor F
q : MvQPF F
h : IsUniform
α : TypeVec.{u} n
a : (P F).A
f : MvPFunctor.B (P F) a ⟹ α
⊢ supp (abs { fst := a, snd := f }) = supp { fst := a, snd := f }

Next tactic:
ext
theorem suppPreservation_iff_isUniform : q.SuppPreservation ↔ q.IsUniform := by
  constructor
  · intro h α a a' f f' h' i
    rw [← MvPFunctor.supp_eq, ← MvPFunctor.supp_eq, ← h, h', h]
  · rintro h α ⟨a, f⟩
    ext
    

Proof state:
case mpr.mk.h.h
n : ℕ
F : TypeVec.{u} n → Type u_1
inst✝ : MvFunctor F
q : MvQPF F
h : IsUniform
α : TypeVec.{u} n
a : (P F).A
f : MvPFunctor.B (P F) a ⟹ α
x✝¹ : Fin2 n
x✝ : α x✝¹
⊢ x✝ ∈ supp (abs { fst := a, snd := f }) x✝¹ ↔ x✝ ∈ supp { fst := a, snd := f } x✝¹

Next tactic:
rwa [supp_eq_of_isUniform, MvPFunctor.supp_eq]
theorem suppPreservation_iff_liftpPreservation : q.SuppPreservation ↔ q.LiftPPreservation := by
  

Proof state:
n : ℕ
F : TypeVec.{u} n → Type u_1
inst✝ : MvFunctor F
q : MvQPF F
⊢ SuppPreservation ↔ LiftPPreservation

Next tactic:
constructor
theorem suppPreservation_iff_liftpPreservation : q.SuppPreservation ↔ q.LiftPPreservation := by
  constructor <;> 

Proof state:
case mp
n : ℕ
F : TypeVec.{u} n → Type u_1
inst✝ : MvFunctor F
q : MvQPF F
⊢ SuppPreservation → LiftPPreservation

Next tactic:
intro h
theorem suppPreservation_iff_liftpPreservation : q.SuppPreservation ↔ q.LiftPPreservation := by
  constructor <;> 

Proof state:
case mpr
n : ℕ
F : TypeVec.{u} n → Type u_1
inst✝ : MvFunctor F
q : MvQPF F
⊢ LiftPPreservation → SuppPreservation

Next tactic:
intro h
theorem suppPreservation_iff_liftpPreservation : q.SuppPreservation ↔ q.LiftPPreservation := by
  constructor <;> intro h
  · 

Proof state:
case mp
n : ℕ
F : TypeVec.{u} n → Type u_1
inst✝ : MvFunctor F
q : MvQPF F
h : SuppPreservation
⊢ LiftPPreservation

Next tactic:
rintro α p ⟨a, f⟩
theorem suppPreservation_iff_liftpPreservation : q.SuppPreservation ↔ q.LiftPPreservation := by
  constructor <;> intro h
  · rintro α p ⟨a, f⟩
    

Proof state:
case mp.mk
n : ℕ
F : TypeVec.{u} n → Type u_1
inst✝ : MvFunctor F
q : MvQPF F
h : SuppPreservation
α : TypeVec.{u} n
p : ⦃i : Fin2 n⦄ → α i → Prop
a : (P F).A
f : MvPFunctor.B (P F) a ⟹ α
⊢ LiftP p (abs { fst := a, snd := f }) ↔ LiftP p { fst := a, snd := f }

Next tactic:
have h' := h
theorem suppPreservation_iff_liftpPreservation : q.SuppPreservation ↔ q.LiftPPreservation := by
  constructor <;> intro h
  · rintro α p ⟨a, f⟩
    have h' := h
    

Proof state:
case mp.mk
n : ℕ
F : TypeVec.{u} n → Type u_1
inst✝ : MvFunctor F
q : MvQPF F
h : SuppPreservation
α : TypeVec.{u} n
p : ⦃i : Fin2 n⦄ → α i → Prop
a : (P F).A
f : MvPFunctor.B (P F) a ⟹ α
h' : SuppPreservation
⊢ LiftP p (abs { fst := a, snd := f }) ↔ LiftP p { fst := a, snd := f }

Next tactic:
rw [suppPreservation_iff_isUniform] at h'
theorem suppPreservation_iff_liftpPreservation : q.SuppPreservation ↔ q.LiftPPreservation := by
  constructor <;> intro h
  · rintro α p ⟨a, f⟩
    have h' := h
    rw [suppPreservation_iff_isUniform] at h'
    

Proof state:
case mp.mk
n : ℕ
F : TypeVec.{u} n → Type u_1
inst✝ : MvFunctor F
q : MvQPF F
h : SuppPreservation
α : TypeVec.{u} n
p : ⦃i : Fin2 n⦄ → α i → Prop
a : (P F).A
f : MvPFunctor.B (P F) a ⟹ α
h' : IsUniform
⊢ LiftP p (abs { fst := a, snd := f }) ↔ LiftP p { fst := a, snd := f }

Next tactic:
dsimp only [SuppPreservation, supp] at h
theorem suppPreservation_iff_liftpPreservation : q.SuppPreservation ↔ q.LiftPPreservation := by
  constructor <;> intro h
  · rintro α p ⟨a, f⟩
    have h' := h
    rw [suppPreservation_iff_isUniform] at h'
    dsimp only [SuppPreservation, supp] at h
    

Proof state:
case mp.mk
n : ℕ
F : TypeVec.{u} n → Type u_1
inst✝ : MvFunctor F
q : MvQPF F
h : ∀ ⦃α : TypeVec.{u} n⦄ (x : ↑(P F) α), supp (abs x) = supp x
α : TypeVec.{u} n
p : ⦃i : Fin2 n⦄ → α i → Prop
a : (P F).A
f : MvPFunctor.B (P F) a ⟹ α
h' : IsUniform
⊢ LiftP p (abs { fst := a, snd := f }) ↔ LiftP p { fst := a, snd := f }

Next tactic:
simp only [liftP_iff_of_isUniform, supp_eq_of_isUniform, MvPFunctor.liftP_iff', h',
      image_univ, mem_range, exists_imp]
theorem suppPreservation_iff_liftpPreservation : q.SuppPreservation ↔ q.LiftPPreservation := by
  constructor <;> intro h
  · rintro α p ⟨a, f⟩
    have h' := h
    rw [suppPreservation_iff_isUniform] at h'
    dsimp only [SuppPreservation, supp] at h
    simp only [liftP_iff_of_isUniform, supp_eq_of_isUniform, MvPFunctor.liftP_iff', h',
      image_univ, mem_range, exists_imp]
    

Proof state:
case mp.mk
n : ℕ
F : TypeVec.{u} n → Type u_1
inst✝ : MvFunctor F
q : MvQPF F
h : ∀ ⦃α : TypeVec.{u} n⦄ (x : ↑(P F) α), supp (abs x) = supp x
α : TypeVec.{u} n
p : ⦃i : Fin2 n⦄ → α i → Prop
a : (P F).A
f : MvPFunctor.B (P F) a ⟹ α
h' : IsUniform
⊢ (∀ (i : Fin2 n) (u : α i) (x : MvPFunctor.B (P F) a i), f i x = u → p u) ↔
    ∀ (i : Fin2 n) (x : MvPFunctor.B (P F) a i), p (f i x)

Next tactic:
constructor
theorem suppPreservation_iff_liftpPreservation : q.SuppPreservation ↔ q.LiftPPreservation := by
  constructor <;> intro h
  · rintro α p ⟨a, f⟩
    have h' := h
    rw [suppPreservation_iff_isUniform] at h'
    dsimp only [SuppPreservation, supp] at h
    simp only [liftP_iff_of_isUniform, supp_eq_of_isUniform, MvPFunctor.liftP_iff', h',
      image_univ, mem_range, exists_imp]
    constructor <;> 

Proof state:
case mp.mk.mp
n : ℕ
F : TypeVec.{u} n → Type u_1
inst✝ : MvFunctor F
q : MvQPF F
h : ∀ ⦃α : TypeVec.{u} n⦄ (x : ↑(P F) α), supp (abs x) = supp x
α : TypeVec.{u} n
p : ⦃i : Fin2 n⦄ → α i → Prop
a : (P F).A
f : MvPFunctor.B (P F) a ⟹ α
h' : IsUniform
⊢ (∀ (i : Fin2 n) (u : α i) (x : MvPFunctor.B (P F) a i), f i x = u → p u) →
    ∀ (i : Fin2 n) (x : MvPFunctor.B (P F) a i), p (f i x)

Next tactic:
intros
theorem suppPreservation_iff_liftpPreservation : q.SuppPreservation ↔ q.LiftPPreservation := by
  constructor <;> intro h
  · rintro α p ⟨a, f⟩
    have h' := h
    rw [suppPreservation_iff_isUniform] at h'
    dsimp only [SuppPreservation, supp] at h
    simp only [liftP_iff_of_isUniform, supp_eq_of_isUniform, MvPFunctor.liftP_iff', h',
      image_univ, mem_range, exists_imp]
    constructor <;> 

Proof state:
case mp.mk.mpr
n : ℕ
F : TypeVec.{u} n → Type u_1
inst✝ : MvFunctor F
q : MvQPF F
h : ∀ ⦃α : TypeVec.{u} n⦄ (x : ↑(P F) α), supp (abs x) = supp x
α : TypeVec.{u} n
p : ⦃i : Fin2 n⦄ → α i → Prop
a : (P F).A
f : MvPFunctor.B (P F) a ⟹ α
h' : IsUniform
⊢ (∀ (i : Fin2 n) (x : MvPFunctor.B (P F) a i), p (f i x)) →
    ∀ (i : Fin2 n) (u : α i) (x : MvPFunctor.B (P F) a i), f i x = u → p u

Next tactic:
intros
theorem suppPreservation_iff_liftpPreservation : q.SuppPreservation ↔ q.LiftPPreservation := by
  constructor <;> intro h
  · rintro α p ⟨a, f⟩
    have h' := h
    rw [suppPreservation_iff_isUniform] at h'
    dsimp only [SuppPreservation, supp] at h
    simp only [liftP_iff_of_isUniform, supp_eq_of_isUniform, MvPFunctor.liftP_iff', h',
      image_univ, mem_range, exists_imp]
    constructor <;> intros <;> 

Proof state:
case mp.mk.mp
n : ℕ
F : TypeVec.{u} n → Type u_1
inst✝ : MvFunctor F
q : MvQPF F
h : ∀ ⦃α : TypeVec.{u} n⦄ (x : ↑(P F) α), supp (abs x) = supp x
α : TypeVec.{u} n
p : ⦃i : Fin2 n⦄ → α i → Prop
a : (P F).A
f : MvPFunctor.B (P F) a ⟹ α
h' : IsUniform
a✝ : ∀ (i : Fin2 n) (u : α i) (x : MvPFunctor.B (P F) a i), f i x = u → p u
i✝ : Fin2 n
x✝ : MvPFunctor.B (P F) a i✝
⊢ p (f i✝ x✝)

Next tactic:
subst_vars
theorem suppPreservation_iff_liftpPreservation : q.SuppPreservation ↔ q.LiftPPreservation := by
  constructor <;> intro h
  · rintro α p ⟨a, f⟩
    have h' := h
    rw [suppPreservation_iff_isUniform] at h'
    dsimp only [SuppPreservation, supp] at h
    simp only [liftP_iff_of_isUniform, supp_eq_of_isUniform, MvPFunctor.liftP_iff', h',
      image_univ, mem_range, exists_imp]
    constructor <;> intros <;> 

Proof state:
case mp.mk.mpr
n : ℕ
F : TypeVec.{u} n → Type u_1
inst✝ : MvFunctor F
q : MvQPF F
h : ∀ ⦃α : TypeVec.{u} n⦄ (x : ↑(P F) α), supp (abs x) = supp x
α : TypeVec.{u} n
p : ⦃i : Fin2 n⦄ → α i → Prop
a : (P F).A
f : MvPFunctor.B (P F) a ⟹ α
h' : IsUniform
a✝¹ : ∀ (i : Fin2 n) (x : MvPFunctor.B (P F) a i), p (f i x)
i✝ : Fin2 n
u✝ : α i✝
x✝ : MvPFunctor.B (P F) a i✝
a✝ : f i✝ x✝ = u✝
⊢ p u✝

Next tactic:
subst_vars