Theorem: QPF.liftp_iff'
File: Mathlib/Data/QPF/Univariate/Basic.lean

tactic: constructor
state_before: F : Type u → Type u
q : QPF F
α : Type u
p : α → Prop
x : F α
⊢ Liftp p x ↔ ∃ u, abs u = x ∧ ∀ (i : (P F).B u.fst), p (u.snd i)
state_after: case mp
F : Type u → Type u
q : QPF F
α : Type u
p : α → Prop
x : F α
⊢ Liftp p x → ∃ u, abs u = x ∧ ∀ (i : (P F).B u.fst), p (u.snd i)

case mpr
F : Type u → Type u
q : QPF F
α : Type u
p : α → Prop
x : F α
⊢ (∃ u, abs u = x ∧ ∀ (i : (P F).B u.fst), p (u.snd i)) → Liftp p x

tactic: rintro ⟨⟨a, f⟩, h₀, h₁⟩
state_before: case mpr
F : Type u → Type u
q : QPF F
α : Type u
p : α → Prop
x : F α
⊢ (∃ u, abs u = x ∧ ∀ (i : (P F).B u.fst), p (u.snd i)) → Liftp p x
state_after: case mpr.intro.mk.intro
F : Type u → Type u
q : QPF F
α : Type u
p : α → Prop
x : F α
a : (P F).A
f : (P F).B a → α
h₀ : abs ⟨a, f⟩ = x
h₁ : ∀ (i : (P F).B ⟨a, f⟩.fst), p (⟨a, f⟩.snd i)
⊢ Liftp p x

tactic: dsimp at *
state_before: case mpr.intro.mk.intro
F : Type u → Type u
q : QPF F
α : Type u
p : α → Prop
x : F α
a : (P F).A
f : (P F).B a → α
h₀ : abs ⟨a, f⟩ = x
h₁ : ∀ (i : (P F).B ⟨a, f⟩.fst), p (⟨a, f⟩.snd i)
⊢ Liftp p x
state_after: case mpr.intro.mk.intro
F : Type u → Type u
q : QPF F
α : Type u
p : α → Prop
x : F α
a : (P F).A
f : (P F).B a → α
h₀ : abs ⟨a, f⟩ = x
h₁ : ∀ (i : (P F).B a), p (f i)
⊢ Liftp p x

tactic: use abs ⟨a, fun i => ⟨f i, h₁ i⟩⟩
state_before: case mpr.intro.mk.intro
F : Type u → Type u
q : QPF F
α : Type u
p : α → Prop
x : F α
a : (P F).A
f : (P F).B a → α
h₀ : abs ⟨a, f⟩ = x
h₁ : ∀ (i : (P F).B a), p (f i)
⊢ Liftp p x
state_after: case h
F : Type u → Type u
q : QPF F
α : Type u
p : α → Prop
x : F α
a : (P F).A
f : (P F).B a → α
h₀ : abs ⟨a, f⟩ = x
h₁ : ∀ (i : (P F).B a), p (f i)
⊢ Subtype.val <$> abs ⟨a, fun i => ⟨f i, ⋯⟩⟩ = x

tactic: rw [← abs_map, ← h₀]
state_before: case h
F : Type u → Type u
q : QPF F
α : Type u
p : α → Prop
x : F α
a : (P F).A
f : (P F).B a → α
h₀ : abs ⟨a, f⟩ = x
h₁ : ∀ (i : (P F).B a), p (f i)
⊢ Subtype.val <$> abs ⟨a, fun i => ⟨f i, ⋯⟩⟩ = x
state_after: case h
F : Type u → Type u
q : QPF F
α : Type u
p : α → Prop
x : F α
a : (P F).A
f : (P F).B a → α
h₀ : abs ⟨a, f⟩ = x
h₁ : ∀ (i : (P F).B a), p (f i)
⊢ abs ((P F).map Subtype.val ⟨a, fun i => ⟨f i, ⋯⟩⟩) = abs ⟨a, f⟩

tactic: rfl
state_before: case h
F : Type u → Type u
q : QPF F
α : Type u
p : α → Prop
x : F α
a : (P F).A
f : (P F).B a → α
h₀ : abs ⟨a, f⟩ = x
h₁ : ∀ (i : (P F).B a), p (f i)
⊢ abs ((P F).map Subtype.val ⟨a, fun i => ⟨f i, ⋯⟩⟩) = abs ⟨a, f⟩
state_after: no goals

tactic: rintro ⟨y, hy⟩
state_before: case mp
F : Type u → Type u
q : QPF F
α : Type u
p : α → Prop
x : F α
⊢ Liftp p x → ∃ u, abs u = x ∧ ∀ (i : (P F).B u.fst), p (u.snd i)
state_after: case mp.intro
F : Type u → Type u
q : QPF F
α : Type u
p : α → Prop
x : F α
y : F (Subtype p)
hy : Subtype.val <$> y = x
⊢ ∃ u, abs u = x ∧ ∀ (i : (P F).B u.fst), p (u.snd i)

tactic: cases' h : repr y with a f
state_before: case mp.intro
F : Type u → Type u
q : QPF F
α : Type u
p : α → Prop
x : F α
y : F (Subtype p)
hy : Subtype.val <$> y = x
⊢ ∃ u, abs u = x ∧ ∀ (i : (P F).B u.fst), p (u.snd i)
state_after: case mp.intro.mk
F : Type u → Type u
q : QPF F
α : Type u
p : α → Prop
x : F α
y : F (Subtype p)
hy : Subtype.val <$> y = x
a : (P F).A
f : (P F).B a → Subtype p
h : repr y = ⟨a, f⟩
⊢ ∃ u, abs u = x ∧ ∀ (i : (P F).B u.fst), p (u.snd i)

tactic: use ⟨a, fun i => (f i).val⟩
state_before: case mp.intro.mk
F : Type u → Type u
q : QPF F
α : Type u
p : α → Prop
x : F α
y : F (Subtype p)
hy : Subtype.val <$> y = x
a : (P F).A
f : (P F).B a → Subtype p
h : repr y = ⟨a, f⟩
⊢ ∃ u, abs u = x ∧ ∀ (i : (P F).B u.fst), p (u.snd i)
state_after: case h
F : Type u → Type u
q : QPF F
α : Type u
p : α → Prop
x : F α
y : F (Subtype p)
hy : Subtype.val <$> y = x
a : (P F).A
f : (P F).B a → Subtype p
h : repr y = ⟨a, f⟩
⊢ abs ⟨a, fun i => ↑(f i)⟩ = x ∧ ∀ (i : (P F).B ⟨a, fun i => ↑(f i)⟩.fst), p (⟨a, fun i => ↑(f i)⟩.snd i)

tactic: dsimp
state_before: case h
F : Type u → Type u
q : QPF F
α : Type u
p : α → Prop
x : F α
y : F (Subtype p)
hy : Subtype.val <$> y = x
a : (P F).A
f : (P F).B a → Subtype p
h : repr y = ⟨a, f⟩
⊢ abs ⟨a, fun i => ↑(f i)⟩ = x ∧ ∀ (i : (P F).B ⟨a, fun i => ↑(f i)⟩.fst), p (⟨a, fun i => ↑(f i)⟩.snd i)
state_after: case h
F : Type u → Type u
q : QPF F
α : Type u
p : α → Prop
x : F α
y : F (Subtype p)
hy : Subtype.val <$> y = x
a : (P F).A
f : (P F).B a → Subtype p
h : repr y = ⟨a, f⟩
⊢ abs ⟨a, fun i => ↑(f i)⟩ = x ∧ ∀ (i : (P F).B a), p ↑(f i)

tactic: constructor
state_before: case h
F : Type u → Type u
q : QPF F
α : Type u
p : α → Prop
x : F α
y : F (Subtype p)
hy : Subtype.val <$> y = x
a : (P F).A
f : (P F).B a → Subtype p
h : repr y = ⟨a, f⟩
⊢ abs ⟨a, fun i => ↑(f i)⟩ = x ∧ ∀ (i : (P F).B a), p ↑(f i)
state_after: case h.left
F : Type u → Type u
q : QPF F
α : Type u
p : α → Prop
x : F α
y : F (Subtype p)
hy : Subtype.val <$> y = x
a : (P F).A
f : (P F).B a → Subtype p
h : repr y = ⟨a, f⟩
⊢ abs ⟨a, fun i => ↑(f i)⟩ = x

case h.right
F : Type u → Type u
q : QPF F
α : Type u
p : α → Prop
x : F α
y : F (Subtype p)
hy : Subtype.val <$> y = x
a : (P F).A
f : (P F).B a → Subtype p
h : repr y = ⟨a, f⟩
⊢ ∀ (i : (P F).B a), p ↑(f i)

tactic: intro i
state_before: case h.right
F : Type u → Type u
q : QPF F
α : Type u
p : α → Prop
x : F α
y : F (Subtype p)
hy : Subtype.val <$> y = x
a : (P F).A
f : (P F).B a → Subtype p
h : repr y = ⟨a, f⟩
⊢ ∀ (i : (P F).B a), p ↑(f i)
state_after: case h.right
F : Type u → Type u
q : QPF F
α : Type u
p : α → Prop
x : F α
y : F (Subtype p)
hy : Subtype.val <$> y = x
a : (P F).A
f : (P F).B a → Subtype p
h : repr y = ⟨a, f⟩
i : (P F).B a
⊢ p ↑(f i)

tactic: apply (f i).property
state_before: case h.right
F : Type u → Type u
q : QPF F
α : Type u
p : α → Prop
x : F α
y : F (Subtype p)
hy : Subtype.val <$> y = x
a : (P F).A
f : (P F).B a → Subtype p
h : repr y = ⟨a, f⟩
i : (P F).B a
⊢ p ↑(f i)
state_after: no goals

tactic: rw [← hy, ← abs_repr y, h, ← abs_map]
state_before: case h.left
F : Type u → Type u
q : QPF F
α : Type u
p : α → Prop
x : F α
y : F (Subtype p)
hy : Subtype.val <$> y = x
a : (P F).A
f : (P F).B a → Subtype p
h : repr y = ⟨a, f⟩
⊢ abs ⟨a, fun i => ↑(f i)⟩ = x
state_after: case h.left
F : Type u → Type u
q : QPF F
α : Type u
p : α → Prop
x : F α
y : F (Subtype p)
hy : Subtype.val <$> y = x
a : (P F).A
f : (P F).B a → Subtype p
h : repr y = ⟨a, f⟩
⊢ abs ⟨a, fun i => ↑(f i)⟩ = abs ((P F).map Subtype.val ⟨a, f⟩)

tactic: rfl
state_before: case h.left
F : Type u → Type u
q : QPF F
α : Type u
p : α → Prop
x : F α
y : F (Subtype p)
hy : Subtype.val <$> y = x
a : (P F).A
f : (P F).B a → Subtype p
h : repr y = ⟨a, f⟩
⊢ abs ⟨a, fun i => ↑(f i)⟩ = abs ((P F).map Subtype.val ⟨a, f⟩)
state_after: no goals