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

tactic: constructor
state_before: F : Type u → Type u
q : QPF F
α : Type u
r : α → α → Prop
x y : F α
⊢ Liftr r x y ↔ ∃ a f₀ f₁, x = abs ⟨a, f₀⟩ ∧ y = abs ⟨a, f₁⟩ ∧ ∀ (i : (P F).B a), r (f₀ i) (f₁ i)
state_after: case mp
F : Type u → Type u
q : QPF F
α : Type u
r : α → α → Prop
x y : F α
⊢ Liftr r x y → ∃ a f₀ f₁, x = abs ⟨a, f₀⟩ ∧ y = abs ⟨a, f₁⟩ ∧ ∀ (i : (P F).B a), r (f₀ i) (f₁ i)

case mpr
F : Type u → Type u
q : QPF F
α : Type u
r : α → α → Prop
x y : F α
⊢ (∃ a f₀ f₁, x = abs ⟨a, f₀⟩ ∧ y = abs ⟨a, f₁⟩ ∧ ∀ (i : (P F).B a), r (f₀ i) (f₁ i)) → Liftr r x y

tactic: rintro ⟨a, f₀, f₁, xeq, yeq, h⟩
state_before: case mpr
F : Type u → Type u
q : QPF F
α : Type u
r : α → α → Prop
x y : F α
⊢ (∃ a f₀ f₁, x = abs ⟨a, f₀⟩ ∧ y = abs ⟨a, f₁⟩ ∧ ∀ (i : (P F).B a), r (f₀ i) (f₁ i)) → Liftr r x y
state_after: case mpr.intro.intro.intro.intro.intro
F : Type u → Type u
q : QPF F
α : Type u
r : α → α → 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 : (P F).B a), r (f₀ i) (f₁ i)
⊢ Liftr r x y

tactic: use abs ⟨a, fun i => ⟨(f₀ i, f₁ i), h i⟩⟩
state_before: case mpr.intro.intro.intro.intro.intro
F : Type u → Type u
q : QPF F
α : Type u
r : α → α → 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 : (P F).B a), r (f₀ i) (f₁ i)
⊢ Liftr r x y
state_after: case h
F : Type u → Type u
q : QPF F
α : Type u
r : α → α → 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 : (P F).B a), r (f₀ i) (f₁ i)
⊢ (fun t => (↑t).1) <$> abs ⟨a, fun i => ⟨(f₀ i, f₁ i), ⋯⟩⟩ = x ∧
    (fun t => (↑t).2) <$> abs ⟨a, fun i => ⟨(f₀ i, f₁ i), ⋯⟩⟩ = y

tactic: constructor
state_before: case h
F : Type u → Type u
q : QPF F
α : Type u
r : α → α → 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 : (P F).B a), r (f₀ i) (f₁ i)
⊢ (fun t => (↑t).1) <$> abs ⟨a, fun i => ⟨(f₀ i, f₁ i), ⋯⟩⟩ = x ∧
    (fun t => (↑t).2) <$> abs ⟨a, fun i => ⟨(f₀ i, f₁ i), ⋯⟩⟩ = y
state_after: case h.left
F : Type u → Type u
q : QPF F
α : Type u
r : α → α → 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 : (P F).B a), r (f₀ i) (f₁ i)
⊢ (fun t => (↑t).1) <$> abs ⟨a, fun i => ⟨(f₀ i, f₁ i), ⋯⟩⟩ = x

case h.right
F : Type u → Type u
q : QPF F
α : Type u
r : α → α → 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 : (P F).B a), r (f₀ i) (f₁ i)
⊢ (fun t => (↑t).2) <$> abs ⟨a, fun i => ⟨(f₀ i, f₁ i), ⋯⟩⟩ = y

tactic: rw [yeq, ← abs_map]
state_before: case h.right
F : Type u → Type u
q : QPF F
α : Type u
r : α → α → 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 : (P F).B a), r (f₀ i) (f₁ i)
⊢ (fun t => (↑t).2) <$> abs ⟨a, fun i => ⟨(f₀ i, f₁ i), ⋯⟩⟩ = y
state_after: case h.right
F : Type u → Type u
q : QPF F
α : Type u
r : α → α → 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 : (P F).B a), r (f₀ i) (f₁ i)
⊢ abs ((P F).map (fun t => (↑t).2) ⟨a, fun i => ⟨(f₀ i, f₁ i), ⋯⟩⟩) = abs ⟨a, f₁⟩

tactic: rfl
state_before: case h.right
F : Type u → Type u
q : QPF F
α : Type u
r : α → α → 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 : (P F).B a), r (f₀ i) (f₁ i)
⊢ abs ((P F).map (fun t => (↑t).2) ⟨a, fun i => ⟨(f₀ i, f₁ i), ⋯⟩⟩) = abs ⟨a, f₁⟩
state_after: no goals

tactic: rintro ⟨u, xeq, yeq⟩
state_before: case mp
F : Type u → Type u
q : QPF F
α : Type u
r : α → α → Prop
x y : F α
⊢ Liftr r x y → ∃ a f₀ f₁, x = abs ⟨a, f₀⟩ ∧ y = abs ⟨a, f₁⟩ ∧ ∀ (i : (P F).B a), r (f₀ i) (f₁ i)
state_after: case mp.intro.intro
F : Type u → Type u
q : QPF F
α : Type u
r : α → α → Prop
x y : F α
u : F { p // r p.1 p.2 }
xeq : (fun t => (↑t).1) <$> u = x
yeq : (fun t => (↑t).2) <$> u = y
⊢ ∃ a f₀ f₁, x = abs ⟨a, f₀⟩ ∧ y = abs ⟨a, f₁⟩ ∧ ∀ (i : (P F).B a), r (f₀ i) (f₁ i)

tactic: cases' h : repr u with a f
state_before: case mp.intro.intro
F : Type u → Type u
q : QPF F
α : Type u
r : α → α → Prop
x y : F α
u : F { p // r p.1 p.2 }
xeq : (fun t => (↑t).1) <$> u = x
yeq : (fun t => (↑t).2) <$> u = y
⊢ ∃ a f₀ f₁, x = abs ⟨a, f₀⟩ ∧ y = abs ⟨a, f₁⟩ ∧ ∀ (i : (P F).B a), r (f₀ i) (f₁ i)
state_after: case mp.intro.intro.mk
F : Type u → Type u
q : QPF F
α : Type u
r : α → α → Prop
x y : F α
u : F { p // r p.1 p.2 }
xeq : (fun t => (↑t).1) <$> u = x
yeq : (fun t => (↑t).2) <$> u = y
a : (P F).A
f : (P F).B a → { p // r p.1 p.2 }
h : repr u = ⟨a, f⟩
⊢ ∃ a f₀ f₁, x = abs ⟨a, f₀⟩ ∧ y = abs ⟨a, f₁⟩ ∧ ∀ (i : (P F).B 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
F : Type u → Type u
q : QPF F
α : Type u
r : α → α → Prop
x y : F α
u : F { p // r p.1 p.2 }
xeq : (fun t => (↑t).1) <$> u = x
yeq : (fun t => (↑t).2) <$> u = y
a : (P F).A
f : (P F).B a → { p // r p.1 p.2 }
h : repr u = ⟨a, f⟩
⊢ ∃ a f₀ f₁, x = abs ⟨a, f₀⟩ ∧ y = abs ⟨a, f₁⟩ ∧ ∀ (i : (P F).B a), r (f₀ i) (f₁ i)
state_after: case h
F : Type u → Type u
q : QPF F
α : Type u
r : α → α → Prop
x y : F α
u : F { p // r p.1 p.2 }
xeq : (fun t => (↑t).1) <$> u = x
yeq : (fun t => (↑t).2) <$> u = y
a : (P F).A
f : (P F).B a → { p // r p.1 p.2 }
h : repr u = ⟨a, f⟩
⊢ x = abs ⟨a, fun i => (↑(f i)).1⟩ ∧ y = abs ⟨a, fun i => (↑(f i)).2⟩ ∧ ∀ (i : (P F).B a), r (↑(f i)).1 (↑(f i)).2

tactic: constructor
state_before: case h
F : Type u → Type u
q : QPF F
α : Type u
r : α → α → Prop
x y : F α
u : F { p // r p.1 p.2 }
xeq : (fun t => (↑t).1) <$> u = x
yeq : (fun t => (↑t).2) <$> u = y
a : (P F).A
f : (P F).B a → { p // r p.1 p.2 }
h : repr u = ⟨a, f⟩
⊢ x = abs ⟨a, fun i => (↑(f i)).1⟩ ∧ y = abs ⟨a, fun i => (↑(f i)).2⟩ ∧ ∀ (i : (P F).B a), r (↑(f i)).1 (↑(f i)).2
state_after: case h.left
F : Type u → Type u
q : QPF F
α : Type u
r : α → α → Prop
x y : F α
u : F { p // r p.1 p.2 }
xeq : (fun t => (↑t).1) <$> u = x
yeq : (fun t => (↑t).2) <$> u = y
a : (P F).A
f : (P F).B a → { p // r p.1 p.2 }
h : repr u = ⟨a, f⟩
⊢ x = abs ⟨a, fun i => (↑(f i)).1⟩

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

tactic: constructor
state_before: case h.right
F : Type u → Type u
q : QPF F
α : Type u
r : α → α → Prop
x y : F α
u : F { p // r p.1 p.2 }
xeq : (fun t => (↑t).1) <$> u = x
yeq : (fun t => (↑t).2) <$> u = y
a : (P F).A
f : (P F).B a → { p // r p.1 p.2 }
h : repr u = ⟨a, f⟩
⊢ y = abs ⟨a, fun i => (↑(f i)).2⟩ ∧ ∀ (i : (P F).B a), r (↑(f i)).1 (↑(f i)).2
state_after: case h.right.left
F : Type u → Type u
q : QPF F
α : Type u
r : α → α → Prop
x y : F α
u : F { p // r p.1 p.2 }
xeq : (fun t => (↑t).1) <$> u = x
yeq : (fun t => (↑t).2) <$> u = y
a : (P F).A
f : (P F).B a → { p // r p.1 p.2 }
h : repr u = ⟨a, f⟩
⊢ y = abs ⟨a, fun i => (↑(f i)).2⟩

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

tactic: intro i
state_before: case h.right.right
F : Type u → Type u
q : QPF F
α : Type u
r : α → α → Prop
x y : F α
u : F { p // r p.1 p.2 }
xeq : (fun t => (↑t).1) <$> u = x
yeq : (fun t => (↑t).2) <$> u = y
a : (P F).A
f : (P F).B a → { p // r p.1 p.2 }
h : repr u = ⟨a, f⟩
⊢ ∀ (i : (P F).B a), r (↑(f i)).1 (↑(f i)).2
state_after: case h.right.right
F : Type u → Type u
q : QPF F
α : Type u
r : α → α → Prop
x y : F α
u : F { p // r p.1 p.2 }
xeq : (fun t => (↑t).1) <$> u = x
yeq : (fun t => (↑t).2) <$> u = y
a : (P F).A
f : (P F).B a → { p // r p.1 p.2 }
h : repr u = ⟨a, f⟩
i : (P F).B a
⊢ r (↑(f i)).1 (↑(f i)).2

tactic: exact (f i).property
state_before: case h.right.right
F : Type u → Type u
q : QPF F
α : Type u
r : α → α → Prop
x y : F α
u : F { p // r p.1 p.2 }
xeq : (fun t => (↑t).1) <$> u = x
yeq : (fun t => (↑t).2) <$> u = y
a : (P F).A
f : (P F).B a → { p // r p.1 p.2 }
h : repr u = ⟨a, f⟩
i : (P F).B a
⊢ r (↑(f i)).1 (↑(f i)).2
state_after: no goals

tactic: rw [← xeq, ← abs_repr u, h, ← abs_map]
state_before: case h.left
F : Type u → Type u
q : QPF F
α : Type u
r : α → α → Prop
x y : F α
u : F { p // r p.1 p.2 }
xeq : (fun t => (↑t).1) <$> u = x
yeq : (fun t => (↑t).2) <$> u = y
a : (P F).A
f : (P F).B a → { p // r p.1 p.2 }
h : repr u = ⟨a, f⟩
⊢ x = abs ⟨a, fun i => (↑(f i)).1⟩
state_after: case h.left
F : Type u → Type u
q : QPF F
α : Type u
r : α → α → Prop
x y : F α
u : F { p // r p.1 p.2 }
xeq : (fun t => (↑t).1) <$> u = x
yeq : (fun t => (↑t).2) <$> u = y
a : (P F).A
f : (P F).B a → { p // r p.1 p.2 }
h : repr u = ⟨a, f⟩
⊢ abs ((P F).map (fun t => (↑t).1) ⟨a, f⟩) = abs ⟨a, fun i => (↑(f i)).1⟩

tactic: rfl
state_before: case h.left
F : Type u → Type u
q : QPF F
α : Type u
r : α → α → Prop
x y : F α
u : F { p // r p.1 p.2 }
xeq : (fun t => (↑t).1) <$> u = x
yeq : (fun t => (↑t).2) <$> u = y
a : (P F).A
f : (P F).B a → { p // r p.1 p.2 }
h : repr u = ⟨a, f⟩
⊢ abs ((P F).map (fun t => (↑t).1) ⟨a, f⟩) = abs ⟨a, fun i => (↑(f i)).1⟩
state_after: no goals

tactic: rw [← yeq, ← abs_repr u, h, ← abs_map]
state_before: case h.right.left
F : Type u → Type u
q : QPF F
α : Type u
r : α → α → Prop
x y : F α
u : F { p // r p.1 p.2 }
xeq : (fun t => (↑t).1) <$> u = x
yeq : (fun t => (↑t).2) <$> u = y
a : (P F).A
f : (P F).B a → { p // r p.1 p.2 }
h : repr u = ⟨a, f⟩
⊢ y = abs ⟨a, fun i => (↑(f i)).2⟩
state_after: case h.right.left
F : Type u → Type u
q : QPF F
α : Type u
r : α → α → Prop
x y : F α
u : F { p // r p.1 p.2 }
xeq : (fun t => (↑t).1) <$> u = x
yeq : (fun t => (↑t).2) <$> u = y
a : (P F).A
f : (P F).B a → { p // r p.1 p.2 }
h : repr u = ⟨a, f⟩
⊢ abs ((P F).map (fun t => (↑t).2) ⟨a, f⟩) = abs ⟨a, fun i => (↑(f i)).2⟩

tactic: rfl
state_before: case h.right.left
F : Type u → Type u
q : QPF F
α : Type u
r : α → α → Prop
x y : F α
u : F { p // r p.1 p.2 }
xeq : (fun t => (↑t).1) <$> u = x
yeq : (fun t => (↑t).2) <$> u = y
a : (P F).A
f : (P F).B a → { p // r p.1 p.2 }
h : repr u = ⟨a, f⟩
⊢ abs ((P F).map (fun t => (↑t).2) ⟨a, f⟩) = abs ⟨a, fun i => (↑(f i)).2⟩
state_after: no goals

tactic: rw [xeq, ← abs_map]
state_before: case h.left
F : Type u → Type u
q : QPF F
α : Type u
r : α → α → 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 : (P F).B a), r (f₀ i) (f₁ i)
⊢ (fun t => (↑t).1) <$> abs ⟨a, fun i => ⟨(f₀ i, f₁ i), ⋯⟩⟩ = x
state_after: case h.left
F : Type u → Type u
q : QPF F
α : Type u
r : α → α → 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 : (P F).B a), r (f₀ i) (f₁ i)
⊢ abs ((P F).map (fun t => (↑t).1) ⟨a, fun i => ⟨(f₀ i, f₁ i), ⋯⟩⟩) = abs ⟨a, f₀⟩

tactic: rfl
state_before: case h.left
F : Type u → Type u
q : QPF F
α : Type u
r : α → α → 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 : (P F).B a), r (f₀ i) (f₁ i)
⊢ abs ((P F).map (fun t => (↑t).1) ⟨a, fun i => ⟨(f₀ i, f₁ i), ⋯⟩⟩) = abs ⟨a, f₀⟩
state_after: no goals