Theorem: MvPFunctor.liftR_iff
File: Mathlib/Data/PFunctor/Multivariate/Basic.lean

tactic: constructor
state_before: n m : ℕ
P : MvPFunctor.{u} n
Q : Fin2 n → MvPFunctor.{u} m
α✝ β : TypeVec.{u} m
α : TypeVec.{u} n
r : ⦃i : Fin2 n⦄ → α i → α i → Prop
x y : ↑P α
⊢ LiftR r x y ↔ ∃ a f₀ f₁, x = ⟨a, f₀⟩ ∧ y = ⟨a, f₁⟩ ∧ ∀ (i : Fin2 n) (j : P.B a i), r (f₀ i j) (f₁ i j)
state_after: case mp
n m : ℕ
P : MvPFunctor.{u} n
Q : Fin2 n → MvPFunctor.{u} m
α✝ β : TypeVec.{u} m
α : TypeVec.{u} n
r : ⦃i : Fin2 n⦄ → α i → α i → Prop
x y : ↑P α
⊢ LiftR r x y → ∃ a f₀ f₁, x = ⟨a, f₀⟩ ∧ y = ⟨a, f₁⟩ ∧ ∀ (i : Fin2 n) (j : P.B a i), r (f₀ i j) (f₁ i j)

case mpr
n m : ℕ
P : MvPFunctor.{u} n
Q : Fin2 n → MvPFunctor.{u} m
α✝ β : TypeVec.{u} m
α : TypeVec.{u} n
r : ⦃i : Fin2 n⦄ → α i → α i → Prop
x y : ↑P α
⊢ (∃ a f₀ f₁, x = ⟨a, f₀⟩ ∧ y = ⟨a, f₁⟩ ∧ ∀ (i : Fin2 n) (j : P.B a i), r (f₀ i j) (f₁ i j)) → LiftR r x y

tactic: rintro ⟨a, f₀, f₁, xeq, yeq, h⟩
state_before: case mpr
n m : ℕ
P : MvPFunctor.{u} n
Q : Fin2 n → MvPFunctor.{u} m
α✝ β : TypeVec.{u} m
α : TypeVec.{u} n
r : ⦃i : Fin2 n⦄ → α i → α i → Prop
x y : ↑P α
⊢ (∃ a f₀ f₁, x = ⟨a, f₀⟩ ∧ y = ⟨a, f₁⟩ ∧ ∀ (i : Fin2 n) (j : P.B a i), r (f₀ i j) (f₁ i j)) → LiftR r x y
state_after: case mpr.intro.intro.intro.intro.intro
n m : ℕ
P : MvPFunctor.{u} n
Q : Fin2 n → MvPFunctor.{u} m
α✝ β : TypeVec.{u} m
α : TypeVec.{u} n
r : ⦃i : Fin2 n⦄ → α i → α i → Prop
x y : ↑P α
a : P.A
f₀ f₁ : P.B a ⟹ α
xeq : x = ⟨a, f₀⟩
yeq : y = ⟨a, f₁⟩
h : ∀ (i : Fin2 n) (j : P.B a i), r (f₀ i j) (f₁ i j)
⊢ LiftR r x y

tactic: use ⟨a, fun i j => ⟨(f₀ i j, f₁ i j), h i j⟩⟩
state_before: case mpr.intro.intro.intro.intro.intro
n m : ℕ
P : MvPFunctor.{u} n
Q : Fin2 n → MvPFunctor.{u} m
α✝ β : TypeVec.{u} m
α : TypeVec.{u} n
r : ⦃i : Fin2 n⦄ → α i → α i → Prop
x y : ↑P α
a : P.A
f₀ f₁ : P.B a ⟹ α
xeq : x = ⟨a, f₀⟩
yeq : y = ⟨a, f₁⟩
h : ∀ (i : Fin2 n) (j : P.B a i), r (f₀ i j) (f₁ i j)
⊢ LiftR r x y
state_after: case h
n m : ℕ
P : MvPFunctor.{u} n
Q : Fin2 n → MvPFunctor.{u} m
α✝ β : TypeVec.{u} m
α : TypeVec.{u} n
r : ⦃i : Fin2 n⦄ → α i → α i → Prop
x y : ↑P α
a : P.A
f₀ f₁ : P.B a ⟹ α
xeq : x = ⟨a, f₀⟩
yeq : y = ⟨a, f₁⟩
h : ∀ (i : Fin2 n) (j : P.B a i), r (f₀ i j) (f₁ i j)
⊢ (fun i t => (↑t).1) <$$> ⟨a, fun i j => ⟨(f₀ i j, f₁ i j), ⋯⟩⟩ = x ∧
    (fun i t => (↑t).2) <$$> ⟨a, fun i j => ⟨(f₀ i j, f₁ i j), ⋯⟩⟩ = y

tactic: constructor
state_before: case h
n m : ℕ
P : MvPFunctor.{u} n
Q : Fin2 n → MvPFunctor.{u} m
α✝ β : TypeVec.{u} m
α : TypeVec.{u} n
r : ⦃i : Fin2 n⦄ → α i → α i → Prop
x y : ↑P α
a : P.A
f₀ f₁ : P.B a ⟹ α
xeq : x = ⟨a, f₀⟩
yeq : y = ⟨a, f₁⟩
h : ∀ (i : Fin2 n) (j : P.B a i), r (f₀ i j) (f₁ i j)
⊢ (fun i t => (↑t).1) <$$> ⟨a, fun i j => ⟨(f₀ i j, f₁ i j), ⋯⟩⟩ = x ∧
    (fun i t => (↑t).2) <$$> ⟨a, fun i j => ⟨(f₀ i j, f₁ i j), ⋯⟩⟩ = y
state_after: case h.left
n m : ℕ
P : MvPFunctor.{u} n
Q : Fin2 n → MvPFunctor.{u} m
α✝ β : TypeVec.{u} m
α : TypeVec.{u} n
r : ⦃i : Fin2 n⦄ → α i → α i → Prop
x y : ↑P α
a : P.A
f₀ f₁ : P.B a ⟹ α
xeq : x = ⟨a, f₀⟩
yeq : y = ⟨a, f₁⟩
h : ∀ (i : Fin2 n) (j : P.B a i), r (f₀ i j) (f₁ i j)
⊢ (fun i t => (↑t).1) <$$> ⟨a, fun i j => ⟨(f₀ i j, f₁ i j), ⋯⟩⟩ = x

case h.right
n m : ℕ
P : MvPFunctor.{u} n
Q : Fin2 n → MvPFunctor.{u} m
α✝ β : TypeVec.{u} m
α : TypeVec.{u} n
r : ⦃i : Fin2 n⦄ → α i → α i → Prop
x y : ↑P α
a : P.A
f₀ f₁ : P.B a ⟹ α
xeq : x = ⟨a, f₀⟩
yeq : y = ⟨a, f₁⟩
h : ∀ (i : Fin2 n) (j : P.B a i), r (f₀ i j) (f₁ i j)
⊢ (fun i t => (↑t).2) <$$> ⟨a, fun i j => ⟨(f₀ i j, f₁ i j), ⋯⟩⟩ = y

tactic: rw [yeq]
state_before: case h.right
n m : ℕ
P : MvPFunctor.{u} n
Q : Fin2 n → MvPFunctor.{u} m
α✝ β : TypeVec.{u} m
α : TypeVec.{u} n
r : ⦃i : Fin2 n⦄ → α i → α i → Prop
x y : ↑P α
a : P.A
f₀ f₁ : P.B a ⟹ α
xeq : x = ⟨a, f₀⟩
yeq : y = ⟨a, f₁⟩
h : ∀ (i : Fin2 n) (j : P.B a i), r (f₀ i j) (f₁ i j)
⊢ (fun i t => (↑t).2) <$$> ⟨a, fun i j => ⟨(f₀ i j, f₁ i j), ⋯⟩⟩ = y
state_after: case h.right
n m : ℕ
P : MvPFunctor.{u} n
Q : Fin2 n → MvPFunctor.{u} m
α✝ β : TypeVec.{u} m
α : TypeVec.{u} n
r : ⦃i : Fin2 n⦄ → α i → α i → Prop
x y : ↑P α
a : P.A
f₀ f₁ : P.B a ⟹ α
xeq : x = ⟨a, f₀⟩
yeq : y = ⟨a, f₁⟩
h : ∀ (i : Fin2 n) (j : P.B a i), r (f₀ i j) (f₁ i j)
⊢ (fun i t => (↑t).2) <$$> ⟨a, fun i j => ⟨(f₀ i j, f₁ i j), ⋯⟩⟩ = ⟨a, f₁⟩

tactic: rfl
state_before: case h.right
n m : ℕ
P : MvPFunctor.{u} n
Q : Fin2 n → MvPFunctor.{u} m
α✝ β : TypeVec.{u} m
α : TypeVec.{u} n
r : ⦃i : Fin2 n⦄ → α i → α i → Prop
x y : ↑P α
a : P.A
f₀ f₁ : P.B a ⟹ α
xeq : x = ⟨a, f₀⟩
yeq : y = ⟨a, f₁⟩
h : ∀ (i : Fin2 n) (j : P.B a i), r (f₀ i j) (f₁ i j)
⊢ (fun i t => (↑t).2) <$$> ⟨a, fun i j => ⟨(f₀ i j, f₁ i j), ⋯⟩⟩ = ⟨a, f₁⟩
state_after: no goals

tactic: rintro ⟨u, xeq, yeq⟩
state_before: case mp
n m : ℕ
P : MvPFunctor.{u} n
Q : Fin2 n → MvPFunctor.{u} m
α✝ β : TypeVec.{u} m
α : TypeVec.{u} n
r : ⦃i : Fin2 n⦄ → α i → α i → Prop
x y : ↑P α
⊢ LiftR r x y → ∃ a f₀ f₁, x = ⟨a, f₀⟩ ∧ y = ⟨a, f₁⟩ ∧ ∀ (i : Fin2 n) (j : P.B a i), r (f₀ i j) (f₁ i j)
state_after: case mp.intro.intro
n m : ℕ
P : MvPFunctor.{u} n
Q : Fin2 n → MvPFunctor.{u} m
α✝ β : TypeVec.{u} m
α : TypeVec.{u} n
r : ⦃i : Fin2 n⦄ → α i → α i → Prop
x y : ↑P α
u : ↑P fun i => { p // 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 = ⟨a, f₀⟩ ∧ y = ⟨a, f₁⟩ ∧ ∀ (i : Fin2 n) (j : P.B a i), r (f₀ i j) (f₁ i j)

tactic: cases' h : u with a f
state_before: case mp.intro.intro
n m : ℕ
P : MvPFunctor.{u} n
Q : Fin2 n → MvPFunctor.{u} m
α✝ β : TypeVec.{u} m
α : TypeVec.{u} n
r : ⦃i : Fin2 n⦄ → α i → α i → Prop
x y : ↑P α
u : ↑P fun i => { p // 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 = ⟨a, f₀⟩ ∧ y = ⟨a, f₁⟩ ∧ ∀ (i : Fin2 n) (j : P.B a i), r (f₀ i j) (f₁ i j)
state_after: case mp.intro.intro.mk
n m : ℕ
P : MvPFunctor.{u} n
Q : Fin2 n → MvPFunctor.{u} m
α✝ β : TypeVec.{u} m
α : TypeVec.{u} n
r : ⦃i : Fin2 n⦄ → α i → α i → Prop
x y : ↑P α
u : ↑P fun i => { p // r p.1 p.2 }
xeq : (fun i t => (↑t).1) <$$> u = x
yeq : (fun i t => (↑t).2) <$$> u = y
a : P.A
f : P.B a ⟹ fun i => { p // r p.1 p.2 }
h : u = ⟨a, f⟩
⊢ ∃ a f₀ f₁, x = ⟨a, f₀⟩ ∧ y = ⟨a, f₁⟩ ∧ ∀ (i : Fin2 n) (j : P.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
state_before: case mp.intro.intro.mk
n m : ℕ
P : MvPFunctor.{u} n
Q : Fin2 n → MvPFunctor.{u} m
α✝ β : TypeVec.{u} m
α : TypeVec.{u} n
r : ⦃i : Fin2 n⦄ → α i → α i → Prop
x y : ↑P α
u : ↑P fun i => { p // r p.1 p.2 }
xeq : (fun i t => (↑t).1) <$$> u = x
yeq : (fun i t => (↑t).2) <$$> u = y
a : P.A
f : P.B a ⟹ fun i => { p // r p.1 p.2 }
h : u = ⟨a, f⟩
⊢ ∃ a f₀ f₁, x = ⟨a, f₀⟩ ∧ y = ⟨a, f₁⟩ ∧ ∀ (i : Fin2 n) (j : P.B a i), r (f₀ i j) (f₁ i j)
state_after: case h
n m : ℕ
P : MvPFunctor.{u} n
Q : Fin2 n → MvPFunctor.{u} m
α✝ β : TypeVec.{u} m
α : TypeVec.{u} n
r : ⦃i : Fin2 n⦄ → α i → α i → Prop
x y : ↑P α
u : ↑P fun i => { p // r p.1 p.2 }
xeq : (fun i t => (↑t).1) <$$> u = x
yeq : (fun i t => (↑t).2) <$$> u = y
a : P.A
f : P.B a ⟹ fun i => { p // r p.1 p.2 }
h : u = ⟨a, f⟩
⊢ x = ⟨a, fun i j => (↑(f i j)).1⟩ ∧
    y = ⟨a, fun i j => (↑(f i j)).2⟩ ∧ ∀ (i : Fin2 n) (j : P.B a i), r (↑(f i j)).1 (↑(f i j)).2

tactic: constructor
state_before: case h
n m : ℕ
P : MvPFunctor.{u} n
Q : Fin2 n → MvPFunctor.{u} m
α✝ β : TypeVec.{u} m
α : TypeVec.{u} n
r : ⦃i : Fin2 n⦄ → α i → α i → Prop
x y : ↑P α
u : ↑P fun i => { p // r p.1 p.2 }
xeq : (fun i t => (↑t).1) <$$> u = x
yeq : (fun i t => (↑t).2) <$$> u = y
a : P.A
f : P.B a ⟹ fun i => { p // r p.1 p.2 }
h : u = ⟨a, f⟩
⊢ x = ⟨a, fun i j => (↑(f i j)).1⟩ ∧
    y = ⟨a, fun i j => (↑(f i j)).2⟩ ∧ ∀ (i : Fin2 n) (j : P.B a i), r (↑(f i j)).1 (↑(f i j)).2
state_after: case h.left
n m : ℕ
P : MvPFunctor.{u} n
Q : Fin2 n → MvPFunctor.{u} m
α✝ β : TypeVec.{u} m
α : TypeVec.{u} n
r : ⦃i : Fin2 n⦄ → α i → α i → Prop
x y : ↑P α
u : ↑P fun i => { p // r p.1 p.2 }
xeq : (fun i t => (↑t).1) <$$> u = x
yeq : (fun i t => (↑t).2) <$$> u = y
a : P.A
f : P.B a ⟹ fun i => { p // r p.1 p.2 }
h : u = ⟨a, f⟩
⊢ x = ⟨a, fun i j => (↑(f i j)).1⟩

case h.right
n m : ℕ
P : MvPFunctor.{u} n
Q : Fin2 n → MvPFunctor.{u} m
α✝ β : TypeVec.{u} m
α : TypeVec.{u} n
r : ⦃i : Fin2 n⦄ → α i → α i → Prop
x y : ↑P α
u : ↑P fun i => { p // r p.1 p.2 }
xeq : (fun i t => (↑t).1) <$$> u = x
yeq : (fun i t => (↑t).2) <$$> u = y
a : P.A
f : P.B a ⟹ fun i => { p // r p.1 p.2 }
h : u = ⟨a, f⟩
⊢ y = ⟨a, fun i j => (↑(f i j)).2⟩ ∧ ∀ (i : Fin2 n) (j : P.B a i), r (↑(f i j)).1 (↑(f i j)).2

tactic: constructor
state_before: case h.right
n m : ℕ
P : MvPFunctor.{u} n
Q : Fin2 n → MvPFunctor.{u} m
α✝ β : TypeVec.{u} m
α : TypeVec.{u} n
r : ⦃i : Fin2 n⦄ → α i → α i → Prop
x y : ↑P α
u : ↑P fun i => { p // r p.1 p.2 }
xeq : (fun i t => (↑t).1) <$$> u = x
yeq : (fun i t => (↑t).2) <$$> u = y
a : P.A
f : P.B a ⟹ fun i => { p // r p.1 p.2 }
h : u = ⟨a, f⟩
⊢ y = ⟨a, fun i j => (↑(f i j)).2⟩ ∧ ∀ (i : Fin2 n) (j : P.B a i), r (↑(f i j)).1 (↑(f i j)).2
state_after: case h.right.left
n m : ℕ
P : MvPFunctor.{u} n
Q : Fin2 n → MvPFunctor.{u} m
α✝ β : TypeVec.{u} m
α : TypeVec.{u} n
r : ⦃i : Fin2 n⦄ → α i → α i → Prop
x y : ↑P α
u : ↑P fun i => { p // r p.1 p.2 }
xeq : (fun i t => (↑t).1) <$$> u = x
yeq : (fun i t => (↑t).2) <$$> u = y
a : P.A
f : P.B a ⟹ fun i => { p // r p.1 p.2 }
h : u = ⟨a, f⟩
⊢ y = ⟨a, fun i j => (↑(f i j)).2⟩

case h.right.right
n m : ℕ
P : MvPFunctor.{u} n
Q : Fin2 n → MvPFunctor.{u} m
α✝ β : TypeVec.{u} m
α : TypeVec.{u} n
r : ⦃i : Fin2 n⦄ → α i → α i → Prop
x y : ↑P α
u : ↑P fun i => { p // r p.1 p.2 }
xeq : (fun i t => (↑t).1) <$$> u = x
yeq : (fun i t => (↑t).2) <$$> u = y
a : P.A
f : P.B a ⟹ fun i => { p // r p.1 p.2 }
h : u = ⟨a, f⟩
⊢ ∀ (i : Fin2 n) (j : P.B a i), r (↑(f i j)).1 (↑(f i j)).2

tactic: intro i j
state_before: case h.right.right
n m : ℕ
P : MvPFunctor.{u} n
Q : Fin2 n → MvPFunctor.{u} m
α✝ β : TypeVec.{u} m
α : TypeVec.{u} n
r : ⦃i : Fin2 n⦄ → α i → α i → Prop
x y : ↑P α
u : ↑P fun i => { p // r p.1 p.2 }
xeq : (fun i t => (↑t).1) <$$> u = x
yeq : (fun i t => (↑t).2) <$$> u = y
a : P.A
f : P.B a ⟹ fun i => { p // r p.1 p.2 }
h : u = ⟨a, f⟩
⊢ ∀ (i : Fin2 n) (j : P.B a i), r (↑(f i j)).1 (↑(f i j)).2
state_after: case h.right.right
n m : ℕ
P : MvPFunctor.{u} n
Q : Fin2 n → MvPFunctor.{u} m
α✝ β : TypeVec.{u} m
α : TypeVec.{u} n
r : ⦃i : Fin2 n⦄ → α i → α i → Prop
x y : ↑P α
u : ↑P fun i => { p // r p.1 p.2 }
xeq : (fun i t => (↑t).1) <$$> u = x
yeq : (fun i t => (↑t).2) <$$> u = y
a : P.A
f : P.B a ⟹ fun i => { p // r p.1 p.2 }
h : u = ⟨a, f⟩
i : Fin2 n
j : P.B a i
⊢ r (↑(f i j)).1 (↑(f i j)).2

tactic: exact (f i j).property
state_before: case h.right.right
n m : ℕ
P : MvPFunctor.{u} n
Q : Fin2 n → MvPFunctor.{u} m
α✝ β : TypeVec.{u} m
α : TypeVec.{u} n
r : ⦃i : Fin2 n⦄ → α i → α i → Prop
x y : ↑P α
u : ↑P fun i => { p // r p.1 p.2 }
xeq : (fun i t => (↑t).1) <$$> u = x
yeq : (fun i t => (↑t).2) <$$> u = y
a : P.A
f : P.B a ⟹ fun i => { p // r p.1 p.2 }
h : u = ⟨a, f⟩
i : Fin2 n
j : P.B a i
⊢ r (↑(f i j)).1 (↑(f i j)).2
state_after: no goals

tactic: rw [← xeq, h]
state_before: case h.left
n m : ℕ
P : MvPFunctor.{u} n
Q : Fin2 n → MvPFunctor.{u} m
α✝ β : TypeVec.{u} m
α : TypeVec.{u} n
r : ⦃i : Fin2 n⦄ → α i → α i → Prop
x y : ↑P α
u : ↑P fun i => { p // r p.1 p.2 }
xeq : (fun i t => (↑t).1) <$$> u = x
yeq : (fun i t => (↑t).2) <$$> u = y
a : P.A
f : P.B a ⟹ fun i => { p // r p.1 p.2 }
h : u = ⟨a, f⟩
⊢ x = ⟨a, fun i j => (↑(f i j)).1⟩
state_after: case h.left
n m : ℕ
P : MvPFunctor.{u} n
Q : Fin2 n → MvPFunctor.{u} m
α✝ β : TypeVec.{u} m
α : TypeVec.{u} n
r : ⦃i : Fin2 n⦄ → α i → α i → Prop
x y : ↑P α
u : ↑P fun i => { p // r p.1 p.2 }
xeq : (fun i t => (↑t).1) <$$> u = x
yeq : (fun i t => (↑t).2) <$$> u = y
a : P.A
f : P.B a ⟹ fun i => { p // r p.1 p.2 }
h : u = ⟨a, f⟩
⊢ (fun i t => (↑t).1) <$$> ⟨a, f⟩ = ⟨a, fun i j => (↑(f i j)).1⟩

tactic: rfl
state_before: case h.left
n m : ℕ
P : MvPFunctor.{u} n
Q : Fin2 n → MvPFunctor.{u} m
α✝ β : TypeVec.{u} m
α : TypeVec.{u} n
r : ⦃i : Fin2 n⦄ → α i → α i → Prop
x y : ↑P α
u : ↑P fun i => { p // r p.1 p.2 }
xeq : (fun i t => (↑t).1) <$$> u = x
yeq : (fun i t => (↑t).2) <$$> u = y
a : P.A
f : P.B a ⟹ fun i => { p // r p.1 p.2 }
h : u = ⟨a, f⟩
⊢ (fun i t => (↑t).1) <$$> ⟨a, f⟩ = ⟨a, fun i j => (↑(f i j)).1⟩
state_after: no goals

tactic: rw [← yeq, h]
state_before: case h.right.left
n m : ℕ
P : MvPFunctor.{u} n
Q : Fin2 n → MvPFunctor.{u} m
α✝ β : TypeVec.{u} m
α : TypeVec.{u} n
r : ⦃i : Fin2 n⦄ → α i → α i → Prop
x y : ↑P α
u : ↑P fun i => { p // r p.1 p.2 }
xeq : (fun i t => (↑t).1) <$$> u = x
yeq : (fun i t => (↑t).2) <$$> u = y
a : P.A
f : P.B a ⟹ fun i => { p // r p.1 p.2 }
h : u = ⟨a, f⟩
⊢ y = ⟨a, fun i j => (↑(f i j)).2⟩
state_after: case h.right.left
n m : ℕ
P : MvPFunctor.{u} n
Q : Fin2 n → MvPFunctor.{u} m
α✝ β : TypeVec.{u} m
α : TypeVec.{u} n
r : ⦃i : Fin2 n⦄ → α i → α i → Prop
x y : ↑P α
u : ↑P fun i => { p // r p.1 p.2 }
xeq : (fun i t => (↑t).1) <$$> u = x
yeq : (fun i t => (↑t).2) <$$> u = y
a : P.A
f : P.B a ⟹ fun i => { p // r p.1 p.2 }
h : u = ⟨a, f⟩
⊢ (fun i t => (↑t).2) <$$> ⟨a, f⟩ = ⟨a, fun i j => (↑(f i j)).2⟩

tactic: rfl
state_before: case h.right.left
n m : ℕ
P : MvPFunctor.{u} n
Q : Fin2 n → MvPFunctor.{u} m
α✝ β : TypeVec.{u} m
α : TypeVec.{u} n
r : ⦃i : Fin2 n⦄ → α i → α i → Prop
x y : ↑P α
u : ↑P fun i => { p // r p.1 p.2 }
xeq : (fun i t => (↑t).1) <$$> u = x
yeq : (fun i t => (↑t).2) <$$> u = y
a : P.A
f : P.B a ⟹ fun i => { p // r p.1 p.2 }
h : u = ⟨a, f⟩
⊢ (fun i t => (↑t).2) <$$> ⟨a, f⟩ = ⟨a, fun i j => (↑(f i j)).2⟩
state_after: no goals

tactic: rw [xeq]
state_before: case h.left
n m : ℕ
P : MvPFunctor.{u} n
Q : Fin2 n → MvPFunctor.{u} m
α✝ β : TypeVec.{u} m
α : TypeVec.{u} n
r : ⦃i : Fin2 n⦄ → α i → α i → Prop
x y : ↑P α
a : P.A
f₀ f₁ : P.B a ⟹ α
xeq : x = ⟨a, f₀⟩
yeq : y = ⟨a, f₁⟩
h : ∀ (i : Fin2 n) (j : P.B a i), r (f₀ i j) (f₁ i j)
⊢ (fun i t => (↑t).1) <$$> ⟨a, fun i j => ⟨(f₀ i j, f₁ i j), ⋯⟩⟩ = x
state_after: case h.left
n m : ℕ
P : MvPFunctor.{u} n
Q : Fin2 n → MvPFunctor.{u} m
α✝ β : TypeVec.{u} m
α : TypeVec.{u} n
r : ⦃i : Fin2 n⦄ → α i → α i → Prop
x y : ↑P α
a : P.A
f₀ f₁ : P.B a ⟹ α
xeq : x = ⟨a, f₀⟩
yeq : y = ⟨a, f₁⟩
h : ∀ (i : Fin2 n) (j : P.B a i), r (f₀ i j) (f₁ i j)
⊢ (fun i t => (↑t).1) <$$> ⟨a, fun i j => ⟨(f₀ i j, f₁ i j), ⋯⟩⟩ = ⟨a, f₀⟩

tactic: rfl
state_before: case h.left
n m : ℕ
P : MvPFunctor.{u} n
Q : Fin2 n → MvPFunctor.{u} m
α✝ β : TypeVec.{u} m
α : TypeVec.{u} n
r : ⦃i : Fin2 n⦄ → α i → α i → Prop
x y : ↑P α
a : P.A
f₀ f₁ : P.B a ⟹ α
xeq : x = ⟨a, f₀⟩
yeq : y = ⟨a, f₁⟩
h : ∀ (i : Fin2 n) (j : P.B a i), r (f₀ i j) (f₁ i j)
⊢ (fun i t => (↑t).1) <$$> ⟨a, fun i j => ⟨(f₀ i j, f₁ i j), ⋯⟩⟩ = ⟨a, f₀⟩
state_after: no goals