Theorem: PFunctor.liftr_iff
File: Mathlib/Data/PFunctor/Univariate/Basic.lean

tactic: constructor
state_before: P : PFunctor
α : Type u
r : α → α → Prop
x y : Obj P α
⊢ Liftr r x y ↔ ∃ a f₀ f₁, x = { fst := a, snd := f₀ } ∧ y = { fst := a, snd := f₁ } ∧ ∀ (i : B P a), r (f₀ i) (f₁ i)

tactic: rintro ⟨a, f₀, f₁, xeq, yeq, h⟩
state_before: case mpr
P : PFunctor
α : Type u
r : α → α → Prop
x y : Obj P α
⊢ (∃ a f₀ f₁, x = { fst := a, snd := f₀ } ∧ y = { fst := a, snd := f₁ } ∧ ∀ (i : B P a), r (f₀ i) (f₁ i)) → Liftr r x y

tactic: use ⟨a, fun i => ⟨(f₀ i, f₁ i), h i⟩⟩
state_before: case mpr.intro.intro.intro.intro.intro
P : PFunctor
α : Type u
r : α → α → Prop
x y : Obj P α
a : P.A
f₀ f₁ : B P a → α
xeq : x = { fst := a, snd := f₀ }
yeq : y = { fst := a, snd := f₁ }
h : ∀ (i : B P a), r (f₀ i) (f₁ i)
⊢ Liftr r x y

tactic: constructor
state_before: case mpr.intro.intro.intro.intro.intro
P : PFunctor
α : Type u
r : α → α → Prop
x y : Obj P α
a : P.A
f₀ f₁ : B P a → α
xeq : x = { fst := a, snd := f₀ }
yeq : y = { fst := a, snd := f₁ }
h : ∀ (i : B P a), r (f₀ i) (f₁ i)
⊢ (fun t => (↑t).fst) <$> { fst := a, snd := fun i => { val := (f₀ i, f₁ i), property := (_ : r (f₀ i) (f₁ i)) } } = x ∧
    (fun t => (↑t).snd) <$> { fst := a, snd := fun i => { val := (f₀ i, f₁ i), property := (_ : r (f₀ i) (f₁ i)) } } = y

tactic: rw [yeq]
state_before: case mpr.intro.intro.intro.intro.intro.right
P : PFunctor
α : Type u
r : α → α → Prop
x y : Obj P α
a : P.A
f₀ f₁ : B P a → α
xeq : x = { fst := a, snd := f₀ }
yeq : y = { fst := a, snd := f₁ }
h : ∀ (i : B P a), r (f₀ i) (f₁ i)
⊢ (fun t => (↑t).snd) <$> { fst := a, snd := fun i => { val := (f₀ i, f₁ i), property := (_ : r (f₀ i) (f₁ i)) } } = y

tactic: rfl
state_before: case mpr.intro.intro.intro.intro.intro.right
P : PFunctor
α : Type u
r : α → α → Prop
x y : Obj P α
a : P.A
f₀ f₁ : B P a → α
xeq : x = { fst := a, snd := f₀ }
yeq : y = { fst := a, snd := f₁ }
h : ∀ (i : B P a), r (f₀ i) (f₁ i)
⊢ (fun t => (↑t).snd) <$> { fst := a, snd := fun i => { val := (f₀ i, f₁ i), property := (_ : r (f₀ i) (f₁ i)) } } =
    { fst := a, snd := f₁ }

tactic: rintro ⟨u, xeq, yeq⟩
state_before: case mp
P : PFunctor
α : Type u
r : α → α → Prop
x y : Obj P α
⊢ Liftr r x y → ∃ a f₀ f₁, x = { fst := a, snd := f₀ } ∧ y = { fst := a, snd := f₁ } ∧ ∀ (i : B P a), r (f₀ i) (f₁ i)

tactic: cases' h : u with a f
state_before: case mp.intro.intro
P : PFunctor
α : Type u
r : α → α → Prop
x y : Obj P α
u : Obj P { p // r p.fst p.snd }
xeq : (fun t => (↑t).fst) <$> u = x
yeq : (fun t => (↑t).snd) <$> u = y
⊢ ∃ a f₀ f₁, x = { fst := a, snd := f₀ } ∧ y = { fst := a, snd := f₁ } ∧ ∀ (i : B P a), r (f₀ i) (f₁ i)

tactic: use a, fun i => (f i).val.fst, fun i => (f i).val.snd
state_before: case mp.intro.intro.mk
P : PFunctor
α : Type u
r : α → α → Prop
x y : Obj P α
u : Obj P { p // r p.fst p.snd }
xeq : (fun t => (↑t).fst) <$> u = x
yeq : (fun t => (↑t).snd) <$> u = y
a : P.A
f : B P a → { p // r p.fst p.snd }
h : u = { fst := a, snd := f }
⊢ ∃ a f₀ f₁, x = { fst := a, snd := f₀ } ∧ y = { fst := a, snd := f₁ } ∧ ∀ (i : B P a), r (f₀ i) (f₁ i)

tactic: constructor
state_before: case mp.intro.intro.mk
P : PFunctor
α : Type u
r : α → α → Prop
x y : Obj P α
u : Obj P { p // r p.fst p.snd }
xeq : (fun t => (↑t).fst) <$> u = x
yeq : (fun t => (↑t).snd) <$> u = y
a : P.A
f : B P a → { p // r p.fst p.snd }
h : u = { fst := a, snd := f }
⊢ x = { fst := a, snd := fun i => (↑(f i)).fst } ∧
    y = { fst := a, snd := fun i => (↑(f i)).snd } ∧
      ∀ (i : B P a), r ((fun i => (↑(f i)).fst) i) ((fun i => (↑(f i)).snd) i)

tactic: constructor
state_before: case mp.intro.intro.mk.right
P : PFunctor
α : Type u
r : α → α → Prop
x y : Obj P α
u : Obj P { p // r p.fst p.snd }
xeq : (fun t => (↑t).fst) <$> u = x
yeq : (fun t => (↑t).snd) <$> u = y
a : P.A
f : B P a → { p // r p.fst p.snd }
h : u = { fst := a, snd := f }
⊢ y = { fst := a, snd := fun i => (↑(f i)).snd } ∧
    ∀ (i : B P a), r ((fun i => (↑(f i)).fst) i) ((fun i => (↑(f i)).snd) i)

tactic: intro i
state_before: case mp.intro.intro.mk.right.right
P : PFunctor
α : Type u
r : α → α → Prop
x y : Obj P α
u : Obj P { p // r p.fst p.snd }
xeq : (fun t => (↑t).fst) <$> u = x
yeq : (fun t => (↑t).snd) <$> u = y
a : P.A
f : B P a → { p // r p.fst p.snd }
h : u = { fst := a, snd := f }
⊢ ∀ (i : B P a), r ((fun i => (↑(f i)).fst) i) ((fun i => (↑(f i)).snd) i)

tactic: exact (f i).property
state_before: case mp.intro.intro.mk.right.right
P : PFunctor
α : Type u
r : α → α → Prop
x y : Obj P α
u : Obj P { p // r p.fst p.snd }
xeq : (fun t => (↑t).fst) <$> u = x
yeq : (fun t => (↑t).snd) <$> u = y
a : P.A
f : B P a → { p // r p.fst p.snd }
h : u = { fst := a, snd := f }
i : B P a
⊢ r ((fun i => (↑(f i)).fst) i) ((fun i => (↑(f i)).snd) i)

tactic: rw [← xeq, h]
state_before: case mp.intro.intro.mk.left
P : PFunctor
α : Type u
r : α → α → Prop
x y : Obj P α
u : Obj P { p // r p.fst p.snd }
xeq : (fun t => (↑t).fst) <$> u = x
yeq : (fun t => (↑t).snd) <$> u = y
a : P.A
f : B P a → { p // r p.fst p.snd }
h : u = { fst := a, snd := f }
⊢ x = { fst := a, snd := fun i => (↑(f i)).fst }

tactic: rfl
state_before: case mp.intro.intro.mk.left
P : PFunctor
α : Type u
r : α → α → Prop
x y : Obj P α
u : Obj P { p // r p.fst p.snd }
xeq : (fun t => (↑t).fst) <$> u = x
yeq : (fun t => (↑t).snd) <$> u = y
a : P.A
f : B P a → { p // r p.fst p.snd }
h : u = { fst := a, snd := f }
⊢ (fun t => (↑t).fst) <$> { fst := a, snd := f } = { fst := a, snd := fun i => (↑(f i)).fst }

tactic: rw [← yeq, h]
state_before: case mp.intro.intro.mk.right.left
P : PFunctor
α : Type u
r : α → α → Prop
x y : Obj P α
u : Obj P { p // r p.fst p.snd }
xeq : (fun t => (↑t).fst) <$> u = x
yeq : (fun t => (↑t).snd) <$> u = y
a : P.A
f : B P a → { p // r p.fst p.snd }
h : u = { fst := a, snd := f }
⊢ y = { fst := a, snd := fun i => (↑(f i)).snd }

tactic: rfl
state_before: case mp.intro.intro.mk.right.left
P : PFunctor
α : Type u
r : α → α → Prop
x y : Obj P α
u : Obj P { p // r p.fst p.snd }
xeq : (fun t => (↑t).fst) <$> u = x
yeq : (fun t => (↑t).snd) <$> u = y
a : P.A
f : B P a → { p // r p.fst p.snd }
h : u = { fst := a, snd := f }
⊢ (fun t => (↑t).snd) <$> { fst := a, snd := f } = { fst := a, snd := fun i => (↑(f i)).snd }

tactic: rw [xeq]
state_before: case mpr.intro.intro.intro.intro.intro.left
P : PFunctor
α : Type u
r : α → α → Prop
x y : Obj P α
a : P.A
f₀ f₁ : B P a → α
xeq : x = { fst := a, snd := f₀ }
yeq : y = { fst := a, snd := f₁ }
h : ∀ (i : B P a), r (f₀ i) (f₁ i)
⊢ (fun t => (↑t).fst) <$> { fst := a, snd := fun i => { val := (f₀ i, f₁ i), property := (_ : r (f₀ i) (f₁ i)) } } = x

tactic: rfl
state_before: case mpr.intro.intro.intro.intro.intro.left
P : PFunctor
α : Type u
r : α → α → Prop
x y : Obj P α
a : P.A
f₀ f₁ : B P a → α
xeq : x = { fst := a, snd := f₀ }
yeq : y = { fst := a, snd := f₁ }
h : ∀ (i : B P a), r (f₀ i) (f₁ i)
⊢ (fun t => (↑t).fst) <$> { fst := a, snd := fun i => { val := (f₀ i, f₁ i), property := (_ : r (f₀ i) (f₁ i)) } } =
    { fst := a, snd := f₀ }