-- Mathlib/Data/QPF/Multivariate/Basic.lean
theorem liftR_iff {α : TypeVec n} (r : ∀ /- ⦃i⦄ -/ {i}, α i → α i → Prop) (x y : F α) :
    LiftR r x y ↔ ∃ a f₀ f₁, x = abs ⟨a, f₀⟩ ∧ y = abs ⟨a, f₁⟩ ∧ ∀ i j, r (f₀ i j) (f₁ i j)

Proof state:
case mp.intro.intro.mk
n : ℕ
F : TypeVec.{u} n → Type u_1
q : MvQPF F
α : TypeVec.{u} n
r : {i : Fin2 n} → α i → α i → Prop
x y : F α
u : F fun i => { p // (fun {i} => r) p.1 p.2 }
xeq : (fun i t => (↑t).1) <$$> u = x
yeq : (fun i t => (↑t).2) <$$> u = y
a : (P F).A
f : (P F).B a ⟹ fun i => { p // (fun {i} => r) p.1 p.2 }
h : repr u = ⟨a, f⟩
⊢ ∃ a f₀ f₁, x = abs ⟨a, f₀⟩ ∧ y = abs ⟨a, f₁⟩ ∧ ∀ (i : Fin2 n) (j : (P F).B a i), r (f₀ i j) (f₁ i j)

Tactic:
use a, fun i j => (f i j).val.fst, fun i j => (f i j).val.snd

Result:
case h
n : ℕ
F : TypeVec.{u} n → Type u_1
q : MvQPF F
α : TypeVec.{u} n
r : {i : Fin2 n} → α i → α i → Prop
x y : F α
u : F fun i => { p // (fun {i} => r) p.1 p.2 }
xeq : (fun i t => (↑t).1) <$$> u = x
yeq : (fun i t => (↑t).2) <$$> u = y
a : (P F).A
f : (P F).B a ⟹ fun i => { p // (fun {i} => r) p.1 p.2 }
h : repr u = ⟨a, f⟩
⊢ x = abs ⟨a, fun i j => (↑(f i j)).1⟩ ∧
    y = abs ⟨a, fun i j => (↑(f i j)).2⟩ ∧
      ∀ (i : Fin2 n) (j : (P F).B a i), r (↑(f i j)).1 ((fun i j => (↑(f i j)).2) i j)

Proof state:
case h
n : ℕ
F : TypeVec.{u} n → Type u_1
q : MvQPF F
α : TypeVec.{u} n
r : {i : Fin2 n} → α i → α i → Prop
x y : F α
u : F fun i => { p // (fun {i} => r) p.1 p.2 }
xeq : (fun i t => (↑t).1) <$$> u = x
yeq : (fun i t => (↑t).2) <$$> u = y
a : (P F).A
f : (P F).B a ⟹ fun i => { p // (fun {i} => r) p.1 p.2 }
h : repr u = ⟨a, f⟩
⊢ x = abs ⟨a, fun i j => (↑(f i j)).1⟩ ∧
    y = abs ⟨a, fun i j => (↑(f i j)).2⟩ ∧
      ∀ (i : Fin2 n) (j : (P F).B a i), r (↑(f i j)).1 ((fun i j => (↑(f i j)).2) i j)

Tactic:
constructor

Result:
case h.left
n : ℕ
F : TypeVec.{u} n → Type u_1
q : MvQPF F
α : TypeVec.{u} n
r : {i : Fin2 n} → α i → α i → Prop
x y : F α
u : F fun i => { p // (fun {i} => r) p.1 p.2 }
xeq : (fun i t => (↑t).1) <$$> u = x
yeq : (fun i t => (↑t).2) <$$> u = y
a : (P F).A
f : (P F).B a ⟹ fun i => { p // (fun {i} => r) p.1 p.2 }
h : repr u = ⟨a, f⟩
⊢ x = abs ⟨a, fun i j => (↑(f i j)).1⟩

case h.right
n : ℕ
F : TypeVec.{u} n → Type u_1
q : MvQPF F
α : TypeVec.{u} n
r : {i : Fin2 n} → α i → α i → Prop
x y : F α
u : F fun i => { p // (fun {i} => r) p.1 p.2 }
xeq : (fun i t => (↑t).1) <$$> u = x
yeq : (fun i t => (↑t).2) <$$> u = y
a : (P F).A
f : (P F).B a ⟹ fun i => { p // (fun {i} => r) p.1 p.2 }
h : repr u = ⟨a, f⟩
⊢ y = abs ⟨a, fun i j => (↑(f i j)).2⟩ ∧ ∀ (i : Fin2 n) (j : (P F).B a i), r (↑(f i j)).1 (↑(f i j)).2

Proof state:
case h.left
n : ℕ
F : TypeVec.{u} n → Type u_1
q : MvQPF F
α : TypeVec.{u} n
r : {i : Fin2 n} → α i → α i → Prop
x y : F α
u : F fun i => { p // (fun {i} => r) p.1 p.2 }
xeq : (fun i t => (↑t).1) <$$> u = x
yeq : (fun i t => (↑t).2) <$$> u = y
a : (P F).A
f : (P F).B a ⟹ fun i => { p // (fun {i} => r) p.1 p.2 }
h : repr u = ⟨a, f⟩
⊢ x = abs ⟨a, fun i j => (↑(f i j)).1⟩

Tactic:
rw [← xeq, ← abs_repr u, h, ← abs_map]

Result:
case h.left
n : ℕ
F : TypeVec.{u} n → Type u_1
q : MvQPF F
α : TypeVec.{u} n
r : {i : Fin2 n} → α i → α i → Prop
x y : F α
u : F fun i => { p // (fun {i} => r) p.1 p.2 }
xeq : (fun i t => (↑t).1) <$$> u = x
yeq : (fun i t => (↑t).2) <$$> u = y
a : (P F).A
f : (P F).B a ⟹ fun i => { p // (fun {i} => r) p.1 p.2 }
h : repr u = ⟨a, f⟩
⊢ abs ((fun i t => (↑t).1) <$$> ⟨a, f⟩) = abs ⟨a, fun i j => (↑(f i j)).1⟩

Proof state:
case mp.intro.intro
n : ℕ
F : TypeVec.{u} n → Type u_1
q : MvQPF F
α : TypeVec.{u} n
r : {i : Fin2 n} → α i → α i → Prop
x y : F α
u : F fun i => { p // (fun {i} => r) p.1 p.2 }
xeq : (fun i t => (↑t).1) <$$> u = x
yeq : (fun i t => (↑t).2) <$$> u = y
⊢ ∃ a f₀ f₁, x = abs ⟨a, f₀⟩ ∧ y = abs ⟨a, f₁⟩ ∧ ∀ (i : Fin2 n) (j : (P F).B a i), r (f₀ i j) (f₁ i j)

Tactic:
rcases h : repr u with ⟨a, f⟩

Result:
case mp.intro.intro.mk
n : ℕ
F : TypeVec.{u} n → Type u_1
q : MvQPF F
α : TypeVec.{u} n
r : {i : Fin2 n} → α i → α i → Prop
x y : F α
u : F fun i => { p // (fun {i} => r) p.1 p.2 }
xeq : (fun i t => (↑t).1) <$$> u = x
yeq : (fun i t => (↑t).2) <$$> u = y
a : (P F).A
f : (P F).B a ⟹ fun i => { p // (fun {i} => r) p.1 p.2 }
h : repr u = ⟨a, f⟩
⊢ ∃ a f₀ f₁, x = abs ⟨a, f₀⟩ ∧ y = abs ⟨a, f₁⟩ ∧ ∀ (i : Fin2 n) (j : (P F).B a i), r (f₀ i j) (f₁ i j)

Proof state:
case h.right
n : ℕ
F : TypeVec.{u} n → Type u_1
q : MvQPF F
α : TypeVec.{u} n
r : {i : Fin2 n} → α i → α i → Prop
x y : F α
a : (P F).A
f₀ f₁ : (P F).B a ⟹ α
xeq : x = abs ⟨a, f₀⟩
yeq : y = abs ⟨a, f₁⟩
h : ∀ (i : Fin2 n) (j : (P F).B a i), r (f₀ i j) (f₁ i j)
⊢ (fun i t => (↑t).2) <$$> abs ⟨a, fun i j => ⟨(f₀ i j, f₁ i j), ⋯⟩⟩ = y

Tactic:
rw [yeq, ← abs_map]

Result:
case h.right
n : ℕ
F : TypeVec.{u} n → Type u_1
q : MvQPF F
α : TypeVec.{u} n
r : {i : Fin2 n} → α i → α i → Prop
x y : F α
a : (P F).A
f₀ f₁ : (P F).B a ⟹ α
xeq : x = abs ⟨a, f₀⟩
yeq : y = abs ⟨a, f₁⟩
h : ∀ (i : Fin2 n) (j : (P F).B a i), r (f₀ i j) (f₁ i j)
⊢ abs ((fun i t => (↑t).2) <$$> ⟨a, fun i j => ⟨(f₀ i j, f₁ i j), ⋯⟩⟩) = abs ⟨a, f₁⟩

Proof state:
case h
n : ℕ
F : TypeVec.{u} n → Type u_1
q : MvQPF F
α : TypeVec.{u} n
r : {i : Fin2 n} → α i → α i → Prop
x y : F α
a : (P F).A
f₀ f₁ : (P F).B a ⟹ α
xeq : x = abs ⟨a, f₀⟩
yeq : y = abs ⟨a, f₁⟩
h : ∀ (i : Fin2 n) (j : (P F).B a i), r (f₀ i j) (f₁ i j)
⊢ (fun i t => (↑t).1) <$$> abs ⟨a, fun i j => ⟨(f₀ i j, f₁ i j), ⋯⟩⟩ = x ∧
    (fun i t => (↑t).2) <$$> abs ⟨a, fun i j => ⟨(f₀ i j, f₁ i j), ⋯⟩⟩ = y

Tactic:
constructor

Result:
case h.left
n : ℕ
F : TypeVec.{u} n → Type u_1
q : MvQPF F
α : TypeVec.{u} n
r : {i : Fin2 n} → α i → α i → Prop
x y : F α
a : (P F).A
f₀ f₁ : (P F).B a ⟹ α
xeq : x = abs ⟨a, f₀⟩
yeq : y = abs ⟨a, f₁⟩
h : ∀ (i : Fin2 n) (j : (P F).B a i), r (f₀ i j) (f₁ i j)
⊢ (fun i t => (↑t).1) <$$> abs ⟨a, fun i j => ⟨(f₀ i j, f₁ i j), ⋯⟩⟩ = x

case h.right
n : ℕ
F : TypeVec.{u} n → Type u_1
q : MvQPF F
α : TypeVec.{u} n
r : {i : Fin2 n} → α i → α i → Prop
x y : F α
a : (P F).A
f₀ f₁ : (P F).B a ⟹ α
xeq : x = abs ⟨a, f₀⟩
yeq : y = abs ⟨a, f₁⟩
h : ∀ (i : Fin2 n) (j : (P F).B a i), r (f₀ i j) (f₁ i j)
⊢ (fun i t => (↑t).2) <$$> abs ⟨a, fun i j => ⟨(f₀ i j, f₁ i j), ⋯⟩⟩ = y

Proof state:
case h.right.left
n : ℕ
F : TypeVec.{u} n → Type u_1
q : MvQPF F
α : TypeVec.{u} n
r : {i : Fin2 n} → α i → α i → Prop
x y : F α
u : F fun i => { p // (fun {i} => r) p.1 p.2 }
xeq : (fun i t => (↑t).1) <$$> u = x
yeq : (fun i t => (↑t).2) <$$> u = y
a : (P F).A
f : (P F).B a ⟹ fun i => { p // (fun {i} => r) p.1 p.2 }
h : repr u = ⟨a, f⟩
⊢ y = abs ⟨a, fun i j => (↑(f i j)).2⟩

Tactic:
rw [← yeq, ← abs_repr u, h, ← abs_map]

Result:
case h.right.left
n : ℕ
F : TypeVec.{u} n → Type u_1
q : MvQPF F
α : TypeVec.{u} n
r : {i : Fin2 n} → α i → α i → Prop
x y : F α
u : F fun i => { p // (fun {i} => r) p.1 p.2 }
xeq : (fun i t => (↑t).1) <$$> u = x
yeq : (fun i t => (↑t).2) <$$> u = y
a : (P F).A
f : (P F).B a ⟹ fun i => { p // (fun {i} => r) p.1 p.2 }
h : repr u = ⟨a, f⟩
⊢ abs ((fun i t => (↑t).2) <$$> ⟨a, f⟩) = abs ⟨a, fun i j => (↑(f i j)).2⟩

Proof state:
case mpr
n : ℕ
F : TypeVec.{u} n → Type u_1
q : MvQPF F
α : TypeVec.{u} n
r : {i : Fin2 n} → α i → α i → Prop
x y : F α
⊢ (∃ a f₀ f₁, x = abs ⟨a, f₀⟩ ∧ y = abs ⟨a, f₁⟩ ∧ ∀ (i : Fin2 n) (j : (P F).B a i), r (f₀ i j) (f₁ i j)) →
    LiftR (fun {i} => r) x y

Tactic:
rintro ⟨a, f₀, f₁, xeq, yeq, h⟩

Result:
case mpr.intro.intro.intro.intro.intro
n : ℕ
F : TypeVec.{u} n → Type u_1
q : MvQPF F
α : TypeVec.{u} n
r : {i : Fin2 n} → α i → α i → Prop
x y : F α
a : (P F).A
f₀ f₁ : (P F).B a ⟹ α
xeq : x = abs ⟨a, f₀⟩
yeq : y = abs ⟨a, f₁⟩
h : ∀ (i : Fin2 n) (j : (P F).B a i), r (f₀ i j) (f₁ i j)
⊢ LiftR (fun {i} => r) x y