Theorem: MvQPF.liftR_iff
File: Mathlib/Data/QPF/Multivariate/Basic.lean

tactic: constructor
state_before: n : ℕ
F : TypeVec n → Type u_1
inst✝ : MvFunctor F
q : MvQPF F
α : TypeVec n
r : {i : Fin2 n} → α i → α i → Prop
x y : F α
⊢ LiftR (fun {i} => r) x y ↔
    ∃ a f₀ f₁,
      x = abs { fst := a, snd := f₀ } ∧
        y = abs { fst := a, snd := f₁ } ∧ ∀ (i : Fin2 n) (j : MvPFunctor.B (P F) a i), r (f₀ i j) (f₁ i j)

tactic: rintro ⟨a, f₀, f₁, xeq, yeq, h⟩
state_before: case mpr
n : ℕ
F : TypeVec n → Type u_1
inst✝ : MvFunctor F
q : MvQPF F
α : TypeVec n
r : {i : Fin2 n} → α i → α i → Prop
x y : F α
⊢ (∃ a f₀ f₁,
      x = abs { fst := a, snd := f₀ } ∧
        y = abs { fst := a, snd := f₁ } ∧ ∀ (i : Fin2 n) (j : MvPFunctor.B (P F) a i), r (f₀ i j) (f₁ i j)) →
    LiftR (fun {i} => r) x y

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

tactic: dsimp
state_before: case mpr.intro.intro.intro.intro.intro
n : ℕ
F : TypeVec n → Type u_1
inst✝ : MvFunctor F
q : MvQPF F
α : TypeVec n
r : {i : Fin2 n} → α i → α i → Prop
x y : F α
a : (P F).A
f₀ f₁ : MvPFunctor.B (P F) a ⟹ α
xeq : x = abs { fst := a, snd := f₀ }
yeq : y = abs { fst := a, snd := f₁ }
h : ∀ (i : Fin2 n) (j : MvPFunctor.B (P F) a i), r (f₀ i j) (f₁ i j)
⊢ (fun i t => (↑t).fst) <$$>
        abs { fst := a, snd := fun i j => { val := (f₀ i j, f₁ i j), property := (_ : r (f₀ i j) (f₁ i j)) } } =
      x ∧
    (fun i t => (↑t).snd) <$$>
        abs { fst := a, snd := fun i j => { val := (f₀ i j, f₁ i j), property := (_ : r (f₀ i j) (f₁ i j)) } } =
      y

tactic: constructor
state_before: case mpr.intro.intro.intro.intro.intro
n : ℕ
F : TypeVec n → Type u_1
inst✝ : MvFunctor F
q : MvQPF F
α : TypeVec n
r : {i : Fin2 n} → α i → α i → Prop
x y : F α
a : (P F).A
f₀ f₁ : MvPFunctor.B (P F) a ⟹ α
xeq : x = abs { fst := a, snd := f₀ }
yeq : y = abs { fst := a, snd := f₁ }
h : ∀ (i : Fin2 n) (j : MvPFunctor.B (P F) a i), r (f₀ i j) (f₁ i j)
⊢ (fun i t => (↑t).fst) <$$>
        abs { fst := a, snd := fun i j => { val := (f₀ i j, f₁ i j), property := (_ : r (f₀ i j) (f₁ i j)) } } =
      x ∧
    (fun i t => (↑t).snd) <$$>
        abs { fst := a, snd := fun i j => { val := (f₀ i j, f₁ i j), property := (_ : r (f₀ i j) (f₁ i j)) } } =
      y

tactic: rw [yeq, ← abs_map]
state_before: case mpr.intro.intro.intro.intro.intro.right
n : ℕ
F : TypeVec n → Type u_1
inst✝ : MvFunctor F
q : MvQPF F
α : TypeVec n
r : {i : Fin2 n} → α i → α i → Prop
x y : F α
a : (P F).A
f₀ f₁ : MvPFunctor.B (P F) a ⟹ α
xeq : x = abs { fst := a, snd := f₀ }
yeq : y = abs { fst := a, snd := f₁ }
h : ∀ (i : Fin2 n) (j : MvPFunctor.B (P F) a i), r (f₀ i j) (f₁ i j)
⊢ (fun i t => (↑t).snd) <$$>
      abs { fst := a, snd := fun i j => { val := (f₀ i j, f₁ i j), property := (_ : r (f₀ i j) (f₁ i j)) } } =
    y

tactic: rfl
state_before: case mpr.intro.intro.intro.intro.intro.right
n : ℕ
F : TypeVec n → Type u_1
inst✝ : MvFunctor F
q : MvQPF F
α : TypeVec n
r : {i : Fin2 n} → α i → α i → Prop
x y : F α
a : (P F).A
f₀ f₁ : MvPFunctor.B (P F) a ⟹ α
xeq : x = abs { fst := a, snd := f₀ }
yeq : y = abs { fst := a, snd := f₁ }
h : ∀ (i : Fin2 n) (j : MvPFunctor.B (P F) a i), r (f₀ i j) (f₁ i j)
⊢ abs
      ((fun i t => (↑t).snd) <$$>
        { fst := a, snd := fun i j => { val := (f₀ i j, f₁ i j), property := (_ : r (f₀ i j) (f₁ i j)) } }) =
    abs { fst := a, snd := f₁ }

tactic: rintro ⟨u, xeq, yeq⟩
state_before: case mp
n : ℕ
F : TypeVec n → Type u_1
inst✝ : MvFunctor F
q : MvQPF F
α : TypeVec n
r : {i : Fin2 n} → α i → α i → Prop
x y : F α
⊢ LiftR (fun {i} => r) x y →
    ∃ a f₀ f₁,
      x = abs { fst := a, snd := f₀ } ∧
        y = abs { fst := a, snd := f₁ } ∧ ∀ (i : Fin2 n) (j : MvPFunctor.B (P F) a i), r (f₀ i j) (f₁ i j)

tactic: cases' h : repr u with a f
state_before: case mp.intro.intro
n : ℕ
F : TypeVec n → Type u_1
inst✝ : MvFunctor F
q : MvQPF F
α : TypeVec n
r : {i : Fin2 n} → α i → α i → Prop
x y : F α
u : F fun i => { p // (fun {i} => r) p.fst p.snd }
xeq : (fun i t => (↑t).fst) <$$> u = x
yeq : (fun i t => (↑t).snd) <$$> u = y
⊢ ∃ a f₀ f₁,
    x = abs { fst := a, snd := f₀ } ∧
      y = abs { fst := a, snd := f₁ } ∧ ∀ (i : Fin2 n) (j : MvPFunctor.B (P F) 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
state_before: case mp.intro.intro.mk
n : ℕ
F : TypeVec n → Type u_1
inst✝ : MvFunctor F
q : MvQPF F
α : TypeVec n
r : {i : Fin2 n} → α i → α i → Prop
x y : F α
u : F fun i => { p // (fun {i} => r) p.fst p.snd }
xeq : (fun i t => (↑t).fst) <$$> u = x
yeq : (fun i t => (↑t).snd) <$$> u = y
a : (P F).A
f : MvPFunctor.B (P F) a ⟹ fun i => { p // (fun {i} => r) p.fst p.snd }
h : repr u = { fst := a, snd := f }
⊢ ∃ a f₀ f₁,
    x = abs { fst := a, snd := f₀ } ∧
      y = abs { fst := a, snd := f₁ } ∧ ∀ (i : Fin2 n) (j : MvPFunctor.B (P F) a i), r (f₀ i j) (f₁ i j)

tactic: constructor
state_before: case mp.intro.intro.mk
n : ℕ
F : TypeVec n → Type u_1
inst✝ : MvFunctor F
q : MvQPF F
α : TypeVec n
r : {i : Fin2 n} → α i → α i → Prop
x y : F α
u : F fun i => { p // (fun {i} => r) p.fst p.snd }
xeq : (fun i t => (↑t).fst) <$$> u = x
yeq : (fun i t => (↑t).snd) <$$> u = y
a : (P F).A
f : MvPFunctor.B (P F) a ⟹ fun i => { p // (fun {i} => r) p.fst p.snd }
h : repr u = { fst := a, snd := f }
⊢ x = abs { fst := a, snd := fun i j => (↑(f i j)).fst } ∧
    y = abs { fst := a, snd := fun i j => (↑(f i j)).snd } ∧
      ∀ (i : Fin2 n) (j : MvPFunctor.B (P F) a i), r ((fun i j => (↑(f i j)).fst) i j) ((fun i j => (↑(f i j)).snd) i j)

tactic: constructor
state_before: case mp.intro.intro.mk.right
n : ℕ
F : TypeVec n → Type u_1
inst✝ : MvFunctor F
q : MvQPF F
α : TypeVec n
r : {i : Fin2 n} → α i → α i → Prop
x y : F α
u : F fun i => { p // (fun {i} => r) p.fst p.snd }
xeq : (fun i t => (↑t).fst) <$$> u = x
yeq : (fun i t => (↑t).snd) <$$> u = y
a : (P F).A
f : MvPFunctor.B (P F) a ⟹ fun i => { p // (fun {i} => r) p.fst p.snd }
h : repr u = { fst := a, snd := f }
⊢ y = abs { fst := a, snd := fun i j => (↑(f i j)).snd } ∧
    ∀ (i : Fin2 n) (j : MvPFunctor.B (P F) a i), r ((fun i j => (↑(f i j)).fst) i j) ((fun i j => (↑(f i j)).snd) i j)

tactic: intro i j
state_before: case mp.intro.intro.mk.right.right
n : ℕ
F : TypeVec n → Type u_1
inst✝ : MvFunctor F
q : MvQPF F
α : TypeVec n
r : {i : Fin2 n} → α i → α i → Prop
x y : F α
u : F fun i => { p // (fun {i} => r) p.fst p.snd }
xeq : (fun i t => (↑t).fst) <$$> u = x
yeq : (fun i t => (↑t).snd) <$$> u = y
a : (P F).A
f : MvPFunctor.B (P F) a ⟹ fun i => { p // (fun {i} => r) p.fst p.snd }
h : repr u = { fst := a, snd := f }
⊢ ∀ (i : Fin2 n) (j : MvPFunctor.B (P F) a i), r ((fun i j => (↑(f i j)).fst) i j) ((fun i j => (↑(f i j)).snd) i j)

tactic: exact (f i j).property
state_before: case mp.intro.intro.mk.right.right
n : ℕ
F : TypeVec n → Type u_1
inst✝ : MvFunctor F
q : MvQPF F
α : TypeVec n
r : {i : Fin2 n} → α i → α i → Prop
x y : F α
u : F fun i => { p // (fun {i} => r) p.fst p.snd }
xeq : (fun i t => (↑t).fst) <$$> u = x
yeq : (fun i t => (↑t).snd) <$$> u = y
a : (P F).A
f : MvPFunctor.B (P F) a ⟹ fun i => { p // (fun {i} => r) p.fst p.snd }
h : repr u = { fst := a, snd := f }
i : Fin2 n
j : MvPFunctor.B (P F) a i
⊢ r ((fun i j => (↑(f i j)).fst) i j) ((fun i j => (↑(f i j)).snd) i j)

tactic: rw [← xeq, ← abs_repr u, h, ← abs_map]
state_before: case mp.intro.intro.mk.left
n : ℕ
F : TypeVec n → Type u_1
inst✝ : MvFunctor F
q : MvQPF F
α : TypeVec n
r : {i : Fin2 n} → α i → α i → Prop
x y : F α
u : F fun i => { p // (fun {i} => r) p.fst p.snd }
xeq : (fun i t => (↑t).fst) <$$> u = x
yeq : (fun i t => (↑t).snd) <$$> u = y
a : (P F).A
f : MvPFunctor.B (P F) a ⟹ fun i => { p // (fun {i} => r) p.fst p.snd }
h : repr u = { fst := a, snd := f }
⊢ x = abs { fst := a, snd := fun i j => (↑(f i j)).fst }

tactic: rfl
state_before: case mp.intro.intro.mk.left
n : ℕ
F : TypeVec n → Type u_1
inst✝ : MvFunctor F
q : MvQPF F
α : TypeVec n
r : {i : Fin2 n} → α i → α i → Prop
x y : F α
u : F fun i => { p // (fun {i} => r) p.fst p.snd }
xeq : (fun i t => (↑t).fst) <$$> u = x
yeq : (fun i t => (↑t).snd) <$$> u = y
a : (P F).A
f : MvPFunctor.B (P F) a ⟹ fun i => { p // (fun {i} => r) p.fst p.snd }
h : repr u = { fst := a, snd := f }
⊢ abs ((fun i t => (↑t).fst) <$$> { fst := a, snd := f }) = abs { fst := a, snd := fun i j => (↑(f i j)).fst }

tactic: rw [← yeq, ← abs_repr u, h, ← abs_map]
state_before: case mp.intro.intro.mk.right.left
n : ℕ
F : TypeVec n → Type u_1
inst✝ : MvFunctor F
q : MvQPF F
α : TypeVec n
r : {i : Fin2 n} → α i → α i → Prop
x y : F α
u : F fun i => { p // (fun {i} => r) p.fst p.snd }
xeq : (fun i t => (↑t).fst) <$$> u = x
yeq : (fun i t => (↑t).snd) <$$> u = y
a : (P F).A
f : MvPFunctor.B (P F) a ⟹ fun i => { p // (fun {i} => r) p.fst p.snd }
h : repr u = { fst := a, snd := f }
⊢ y = abs { fst := a, snd := fun i j => (↑(f i j)).snd }

tactic: rfl
state_before: case mp.intro.intro.mk.right.left
n : ℕ
F : TypeVec n → Type u_1
inst✝ : MvFunctor F
q : MvQPF F
α : TypeVec n
r : {i : Fin2 n} → α i → α i → Prop
x y : F α
u : F fun i => { p // (fun {i} => r) p.fst p.snd }
xeq : (fun i t => (↑t).fst) <$$> u = x
yeq : (fun i t => (↑t).snd) <$$> u = y
a : (P F).A
f : MvPFunctor.B (P F) a ⟹ fun i => { p // (fun {i} => r) p.fst p.snd }
h : repr u = { fst := a, snd := f }
⊢ abs ((fun i t => (↑t).snd) <$$> { fst := a, snd := f }) = abs { fst := a, snd := fun i j => (↑(f i j)).snd }

tactic: rw [xeq, ← abs_map]
state_before: case mpr.intro.intro.intro.intro.intro.left
n : ℕ
F : TypeVec n → Type u_1
inst✝ : MvFunctor F
q : MvQPF F
α : TypeVec n
r : {i : Fin2 n} → α i → α i → Prop
x y : F α
a : (P F).A
f₀ f₁ : MvPFunctor.B (P F) a ⟹ α
xeq : x = abs { fst := a, snd := f₀ }
yeq : y = abs { fst := a, snd := f₁ }
h : ∀ (i : Fin2 n) (j : MvPFunctor.B (P F) a i), r (f₀ i j) (f₁ i j)
⊢ (fun i t => (↑t).fst) <$$>
      abs { fst := a, snd := fun i j => { val := (f₀ i j, f₁ i j), property := (_ : r (f₀ i j) (f₁ i j)) } } =
    x

tactic: rfl
state_before: case mpr.intro.intro.intro.intro.intro.left
n : ℕ
F : TypeVec n → Type u_1
inst✝ : MvFunctor F
q : MvQPF F
α : TypeVec n
r : {i : Fin2 n} → α i → α i → Prop
x y : F α
a : (P F).A
f₀ f₁ : MvPFunctor.B (P F) a ⟹ α
xeq : x = abs { fst := a, snd := f₀ }
yeq : y = abs { fst := a, snd := f₁ }
h : ∀ (i : Fin2 n) (j : MvPFunctor.B (P F) a i), r (f₀ i j) (f₁ i j)
⊢ abs
      ((fun i t => (↑t).fst) <$$>
        { fst := a, snd := fun i j => { val := (f₀ i j, f₁ i j), property := (_ : r (f₀ i j) (f₁ i j)) } }) =
    abs { fst := a, snd := f₀ }