ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- Set.biUnion_finsetSigma_univ'
lemma Set.biUnion_finsetSigma_univ' (s : Finset ι) (f : Π i, κ i → Set α) :
    ⋃ i ∈ s, ⋃ j, f i j = ⋃ ij ∈ s.sigma fun _ ↦ Finset.univ, f ij.1 ij.2 
Arguments: {ι : Type u_1} {α : Type u_2} {κ : ι → Type u_5} [(i : ι) → Fintype (κ i)] (s : Finset ι) (f : (i : ι) → κ i → Set α)
Goal: ⋃ i ∈ s, ⋃ j, f i j = ⋃ ij ∈ s.sigma fun x => Finset.univ, f ij.fst ij.snd
-- Set.biInter_finsetSigma_univ
lemma Set.biInter_finsetSigma_univ (s : Finset ι) (f : Sigma κ → Set α) :
    ⋂ ij ∈ s.sigma fun _ ↦ Finset.univ, f ij = ⋂ i ∈ s, ⋂ j, f ⟨i, j⟩ 
Arguments: {ι : Type u_1} {α : Type u_2} {κ : ι → Type u_5} [(i : ι) → Fintype (κ i)] (s : Finset ι) (f : Sigma κ → Set α)
Goal: ⋂ ij ∈ s.sigma fun x => Finset.univ, f ij = ⋂ i ∈ s, ⋂ j, f ⟨i, j⟩
-- Set.biInter_finsetSigma_univ'
lemma Set.biInter_finsetSigma_univ' (s : Finset ι) (f : Π i, κ i → Set α) :
    ⋂ i ∈ s, ⋂ j, f i j = ⋂ ij ∈ s.sigma fun _ ↦ Finset.univ, f ij.1 ij.2 
Arguments: {ι : Type u_1} {α : Type u_2} {κ : ι → Type u_5} [(i : ι) → Fintype (κ i)] (s : Finset ι) (f : (i : ι) → κ i → Set α)
Goal: ⋂ i ∈ s, ⋂ j, f i j = ⋂ ij ∈ s.sigma fun x => Finset.univ, f ij.fst ij.snd
-- Finset.univ_sigma_univ
@[simp] lemma Finset.univ_sigma_univ : univ.sigma (fun _ ↦ univ) = (univ : Finset (Σ i, κ i)) 
Arguments: {ι : Type u_1} {κ : ι → Type u_5} [(i : ι) → Fintype (κ i)] [Fintype ι]
Goal: (Finset.univ.sigma fun x => Finset.univ) = Finset.univ
-- PNat.Icc_eq_finset_subtype
theorem Icc_eq_finset_subtype : Icc a b = (Icc (a : ℕ) b).subtype fun n : ℕ => 0 < n 
Arguments: (a b : ℕ+)
Goal: Finset.Icc a b = Finset.subtype (fun n => 0 < n) (Finset.Icc ↑a ↑b)
-- PNat.Ico_eq_finset_subtype
theorem Ico_eq_finset_subtype : Ico a b = (Ico (a : ℕ) b).subtype fun n : ℕ => 0 < n 
Arguments: (a b : ℕ+)
Goal: Finset.Ico a b = Finset.subtype (fun n => 0 < n) (Finset.Ico ↑a ↑b)
-- PNat.Ioc_eq_finset_subtype
theorem Ioc_eq_finset_subtype : Ioc a b = (Ioc (a : ℕ) b).subtype fun n : ℕ => 0 < n 
Arguments: (a b : ℕ+)
Goal: Finset.Ioc a b = Finset.subtype (fun n => 0 < n) (Finset.Ioc ↑a ↑b)
-- PNat.Ioo_eq_finset_subtype
theorem Ioo_eq_finset_subtype : Ioo a b = (Ioo (a : ℕ) b).subtype fun n : ℕ => 0 < n 
Arguments: (a b : ℕ+)
Goal: Finset.Ioo a b = Finset.subtype (fun n => 0 < n) (Finset.Ioo ↑a ↑b)
-- PNat.uIcc_eq_finset_subtype
theorem uIcc_eq_finset_subtype : uIcc a b = (uIcc (a : ℕ) b).subtype fun n : ℕ => 0 < n 
Arguments: (a b : ℕ+)
Goal: Finset.uIcc a b = Finset.subtype (fun n => 0 < n) (Finset.uIcc ↑a ↑b)
-- PNat.map_subtype_embedding_Icc
theorem map_subtype_embedding_Icc : (Icc a b).map (Embedding.subtype _) = Icc ↑a ↑b 
Arguments: (a b : ℕ+)
Goal: Finset.map (Function.Embedding.subtype fun n => 0 < n) (Finset.Icc a b) = Finset.Icc ↑a ↑b
-- PNat.map_subtype_embedding_Ico
theorem map_subtype_embedding_Ico : (Ico a b).map (Embedding.subtype _) = Ico ↑a ↑b 
Arguments: (a b : ℕ+)
Goal: Finset.map (Function.Embedding.subtype fun n => 0 < n) (Finset.Ico a b) = Finset.Ico ↑a ↑b
-- PNat.map_subtype_embedding_Ioc
theorem map_subtype_embedding_Ioc : (Ioc a b).map (Embedding.subtype _) = Ioc ↑a ↑b 
Arguments: (a b : ℕ+)
Goal: Finset.map (Function.Embedding.subtype fun n => 0 < n) (Finset.Ioc a b) = Finset.Ioc ↑a ↑b
-- PNat.map_subtype_embedding_Ioo
theorem map_subtype_embedding_Ioo : (Ioo a b).map (Embedding.subtype _) = Ioo ↑a ↑b 
Arguments: (a b : ℕ+)
Goal: Finset.map (Function.Embedding.subtype fun n => 0 < n) (Finset.Ioo a b) = Finset.Ioo ↑a ↑b
-- PNat.map_subtype_embedding_uIcc
theorem map_subtype_embedding_uIcc : (uIcc a b).map (Embedding.subtype _) = uIcc ↑a ↑b 
Arguments: (a b : ℕ+)
Goal: Finset.map (Function.Embedding.subtype fun n => 0 < n) (Finset.uIcc a b) = Finset.uIcc ↑a ↑b
-- PNat.card_Icc
@[simp]
theorem card_Icc : (Icc a b).card = b + 1 - a 
Arguments: (a b : ℕ+)
Goal: (Finset.Icc a b).card = ↑b + 1 - ↑a
-- PNat.card_Ico
@[simp]
theorem card_Ico : (Ico a b).card = b - a 
Arguments: (a b : ℕ+)
Goal: (Finset.Ico a b).card = ↑b - ↑a
-- PNat.card_Ioc
@[simp]
theorem card_Ioc : (Ioc a b).card = b - a 
Arguments: (a b : ℕ+)
Goal: (Finset.Ioc a b).card = ↑b - ↑a
-- PNat.card_Ioo
@[simp]
theorem card_Ioo : (Ioo a b).card = b - a - 1 
Arguments: (a b : ℕ+)
Goal: (Finset.Ioo a b).card = ↑b - ↑a - 1
-- PNat.card_uIcc
@[simp]
theorem card_uIcc : (uIcc a b).card = (b - a : ℤ).natAbs + 1 
Arguments: (a b : ℕ+)
Goal: (Finset.uIcc a b).card = (↑↑b - ↑↑a).natAbs + 1
-- PNat.card_fintype_Icc
theorem card_fintype_Icc : Fintype.card (Set.Icc a b) = b + 1 - a 
Arguments: (a b : ℕ+)
Goal: Fintype.card ↑(Set.Icc a b) = ↑b + 1 - ↑a
-- PNat.card_fintype_Ico
theorem card_fintype_Ico : Fintype.card (Set.Ico a b) = b - a 
Arguments: (a b : ℕ+)
Goal: Fintype.card ↑(Set.Ico a b) = ↑b - ↑a
-- PNat.card_fintype_Ioc
theorem card_fintype_Ioc : Fintype.card (Set.Ioc a b) = b - a 
Arguments: (a b : ℕ+)
Goal: Fintype.card ↑(Set.Ioc a b) = ↑b - ↑a
-- PNat.card_fintype_Ioo
theorem card_fintype_Ioo : Fintype.card (Set.Ioo a b) = b - a - 1 
Arguments: (a b : ℕ+)
Goal: Fintype.card ↑(Set.Ioo a b) = ↑b - ↑a - 1
-- PNat.card_fintype_uIcc
theorem card_fintype_uIcc : Fintype.card (Set.uIcc a b) = (b - a : ℤ).natAbs + 1 
Arguments: (a b : ℕ+)
Goal: Fintype.card ↑(Set.uIcc a b) = (↑↑b - ↑↑a).natAbs + 1
-- Fin.succ_eq
@[simp]
theorem succ_eq {n : ℕ} : SuccOrder.succ = fun a => if a < Fin.last n then a + 1 else a 
Arguments: {n : ℕ}
Goal: SuccOrder.succ = fun a => if a < Fin.last n then a + 1 else a
-- Fin.succ_apply
@[simp]
theorem succ_apply {n : ℕ} (a) : SuccOrder.succ a = if a < Fin.last n then a + 1 else a 
Arguments: {n : ℕ} (a : Fin (n + 1))
Goal: SuccOrder.succ a = if a < Fin.last n then a + 1 else a
-- Fin.pred_eq
@[simp]
theorem pred_eq {n} : PredOrder.pred = fun a : Fin (n + 1) => if a = 0 then 0 else a - 1 
Arguments: {n : ℕ}
Goal: PredOrder.pred = fun a => if a = 0 then 0 else a - 1
-- Fin.pred_apply
@[simp]
theorem pred_apply {n : ℕ} (a : Fin (n + 1)) : PredOrder.pred a = if a = 0 then 0 else a - 1 
Arguments: {n : ℕ} (a : Fin (n + 1))
Goal: PredOrder.pred a = if a = 0 then 0 else a - 1
-- PNat.mk_coe
@[simp]
theorem mk_coe (n h) : (PNat.val (⟨n, h⟩ : ℕ+) : ℕ) = n 
Arguments: (n : ℕ) (h : 0 < n)
Goal: ↑⟨n, h⟩ = n
-- PNat.natPred_eq_pred
@[simp]
theorem natPred_eq_pred {n : ℕ} (h : 0 < n) : natPred (⟨n, h⟩ : ℕ+) = n.pred 
Arguments: {n : ℕ} (h : 0 < n)
Goal: PNat.natPred ⟨n, h⟩ = n.pred
-- Nat.succPNat_coe
@[simp]
theorem succPNat_coe (n : ℕ) : (succPNat n : ℕ) = succ n 
Arguments: (n : ℕ)
Goal: ↑n.succPNat = n.succ
-- Nat.natPred_succPNat
@[simp]
theorem natPred_succPNat (n : ℕ) : n.succPNat.natPred = n 
Arguments: (n : ℕ)
Goal: n.succPNat.natPred = n
-- PNat.succPNat_natPred
@[simp]
theorem _root_.PNat.succPNat_natPred (n : ℕ+) : n.natPred.succPNat = n 
Arguments: (n : ℕ+)
Goal: n.natPred.succPNat = n
-- Nat.toPNat'_zero
@[simp]
theorem toPNat'_zero : Nat.toPNat' 0 = 1 
Goal: Nat.toPNat' 0 = 1
-- Nat.toPNat'_coe
@[simp]
theorem toPNat'_coe : ∀ n : ℕ, (toPNat' n : ℕ) = ite (0 < n) n 1
  
Arguments: (n : ℕ)
Goal: ↑n.toPNat' = if 0 < n then n else 1
-- PNat.mk_le_mk
-- Porting note: no `simp`  because simp can prove it
theorem mk_le_mk (n k : ℕ) (hn : 0 < n) (hk : 0 < k) : (⟨n, hn⟩ : ℕ+) ≤ ⟨k, hk⟩ ↔ n ≤ k 
Arguments: (n k : ℕ) (hn : 0 < n) (hk : 0 < k)
Goal: ⟨n, hn⟩ ≤ ⟨k, hk⟩ ↔ n ≤ k
-- PNat.mk_lt_mk
theorem mk_lt_mk (n k : ℕ) (hn : 0 < n) (hk : 0 < k) : (⟨n, hn⟩ : ℕ+) < ⟨k, hk⟩ ↔ n < k 
Arguments: (n k : ℕ) (hn : 0 < n) (hk : 0 < k)
Goal: ⟨n, hn⟩ < ⟨k, hk⟩ ↔ n < k
-- PNat.coe_le_coe
@[simp, norm_cast]
theorem coe_le_coe (n k : ℕ+) : (n : ℕ) ≤ k ↔ n ≤ k 
Arguments: (n k : ℕ+)
Goal: ↑n ≤ ↑k ↔ n ≤ k
-- PNat.coe_lt_coe
@[simp, norm_cast]
theorem coe_lt_coe (n k : ℕ+) : (n : ℕ) < k ↔ n < k 
Arguments: (n k : ℕ+)
Goal: ↑n < ↑k ↔ n < k
-- PNat.pos
@[simp]
theorem pos (n : ℕ+) : 0 < (n : ℕ) 
Arguments: (n : ℕ+)
Goal: 0 < ↑n
-- PNat.eq
theorem eq {m n : ℕ+} : (m : ℕ) = n → m = n 
Arguments: {m n : ℕ+}
Goal: ↑m = ↑n → m = n
-- PNat.coe_injective
theorem coe_injective : Function.Injective (fun (a : ℕ+) => (a : ℕ)) 
Goal: Function.Injective fun a => ↑a
-- PNat.ne_zero
@[simp]
theorem ne_zero (n : ℕ+) : (n : ℕ) ≠ 0 
Arguments: (n : ℕ+)
Goal: ↑n ≠ 0
-- PNat.toPNat'_coe
theorem toPNat'_coe {n : ℕ} : 0 < n → (n.toPNat' : ℕ) = n 
Arguments: {n : ℕ}
Goal: 0 < n → ↑n.toPNat' = n
-- PNat.coe_toPNat'
@[simp]
theorem coe_toPNat' (n : ℕ+) : (n : ℕ).toPNat' = n 
Arguments: (n : ℕ+)
Goal: (↑n).toPNat' = n
-- PNat.one_le
@[simp]
theorem one_le (n : ℕ+) : (1 : ℕ+) ≤ n 
Arguments: (n : ℕ+)
Goal: 1 ≤ n
-- PNat.not_lt_one
@[simp]
theorem not_lt_one (n : ℕ+) : ¬n < 1 
Arguments: (n : ℕ+)
Goal: ¬n < 1
-- PNat.mk_one
@[simp]
theorem mk_one {h} : (⟨1, h⟩ : ℕ+) = (1 : ℕ+) 
Arguments: {h : 0 < 1}
Goal: ⟨1, h⟩ = 1
-- PNat.one_coe
@[norm_cast]
theorem one_coe : ((1 : ℕ+) : ℕ) = 1 
Goal: ↑1 = 1
-- PNat.coe_eq_one_iff
@[simp, norm_cast]
theorem coe_eq_one_iff {m : ℕ+} : (m : ℕ) = 1 ↔ m = 1 
Arguments: {m : ℕ+}
Goal: ↑m = 1 ↔ m = 1
-- PNat.mod_coe
theorem mod_coe (m k : ℕ+) :
    (mod m k : ℕ) = ite ((m : ℕ) % (k : ℕ) = 0) (k : ℕ) ((m : ℕ) % (k : ℕ)) 
Arguments: (m k : ℕ+)
Goal: ↑(m.mod k) = if ↑m % ↑k = 0 then ↑k else ↑m % ↑k
-- PNat.div_coe
theorem div_coe (m k : ℕ+) :
    (div m k : ℕ) = ite ((m : ℕ) % (k : ℕ) = 0) ((m : ℕ) / (k : ℕ)).pred ((m : ℕ) / (k : ℕ)) 
Arguments: (m k : ℕ+)
Goal: m.div k = if ↑m % ↑k = 0 then (↑m / ↑k).pred else ↑m / ↑k
-- PNat.find_spec
protected theorem find_spec : p (PNat.find h) 
Arguments: {p : ℕ+ → Prop} [DecidablePred p] (h : ∃ n, p n)
Goal: p (PNat.find h)
-- PNat.find_min
protected theorem find_min : ∀ {m : ℕ+}, m < PNat.find h → ¬p m 
Arguments: {p : ℕ+ → Prop} [DecidablePred p] (h : ∃ n, p n) {m : ℕ+}
Goal: m < PNat.find h → ¬p m
-- PNat.find_min'
protected theorem find_min' {m : ℕ+} (hm : p m) : PNat.find h ≤ m 
Arguments: {p : ℕ+ → Prop} [DecidablePred p] (h : ∃ n, p n) {m : ℕ+} (hm : p m)
Goal: PNat.find h ≤ m
-- PNat.find_eq_iff
theorem find_eq_iff : PNat.find h = m ↔ p m ∧ ∀ n < m, ¬p n 
Arguments: {p : ℕ+ → Prop} [DecidablePred p] (h : ∃ n, p n) {m : ℕ+}
Goal: PNat.find h = m ↔ p m ∧ ∀ n < m, ¬p n
-- PNat.find_lt_iff
@[simp]
theorem find_lt_iff (n : ℕ+) : PNat.find h < n ↔ ∃ m < n, p m 
Arguments: {p : ℕ+ → Prop} [DecidablePred p] (h : ∃ n, p n) (n : ℕ+)
Goal: PNat.find h < n ↔ ∃ m < n, p m
-- PNat.find_le_iff
@[simp]
theorem find_le_iff (n : ℕ+) : PNat.find h ≤ n ↔ ∃ m ≤ n, p m 
Arguments: {p : ℕ+ → Prop} [DecidablePred p] (h : ∃ n, p n) (n : ℕ+)
Goal: PNat.find h ≤ n ↔ ∃ m ≤ n, p m
-- PNat.le_find_iff
@[simp]
theorem le_find_iff (n : ℕ+) : n ≤ PNat.find h ↔ ∀ m < n, ¬p m 
Arguments: {p : ℕ+ → Prop} [DecidablePred p] (h : ∃ n, p n) (n : ℕ+)
Goal: n ≤ PNat.find h ↔ ∀ m < n, ¬p m
-- PNat.lt_find_iff
@[simp]
theorem lt_find_iff (n : ℕ+) : n < PNat.find h ↔ ∀ m ≤ n, ¬p m 
Arguments: {p : ℕ+ → Prop} [DecidablePred p] (h : ∃ n, p n) (n : ℕ+)
Goal: n < PNat.find h ↔ ∀ m ≤ n, ¬p m
-- PNat.find_eq_one
@[simp]
theorem find_eq_one : PNat.find h = 1 ↔ p 1 
Arguments: {p : ℕ+ → Prop} [DecidablePred p] (h : ∃ n, p n)
Goal: PNat.find h = 1 ↔ p 1
-- PNat.one_le_find
theorem one_le_find : 1 < PNat.find h ↔ ¬p 1 
Arguments: {p : ℕ+ → Prop} [DecidablePred p] (h : ∃ n, p n)
Goal: 1 < PNat.find h ↔ ¬p 1
-- PNat.find_mono
theorem find_mono (h : ∀ n, q n → p n) {hp : ∃ n, p n} {hq : ∃ n, q n} :
    PNat.find hp ≤ PNat.find hq 
Arguments: {p q : ℕ+ → Prop} [DecidablePred p] [DecidablePred q] (h : ∀ (n : ℕ+), q n → p n) {hp : ∃ n, p n} {hq : ∃ n, q n}
Goal: PNat.find hp ≤ PNat.find hq
-- PNat.find_le
theorem find_le {h : ∃ n, p n} (hn : p n) : PNat.find h ≤ n 
Arguments: {p : ℕ+ → Prop} [DecidablePred p] {n : ℕ+} {h : ∃ n, p n} (hn : p n)
Goal: PNat.find h ≤ n
-- PNat.find_comp_succ
theorem find_comp_succ (h : ∃ n, p n) (h₂ : ∃ n, p (n + 1)) (h1 : ¬p 1) :
    PNat.find h = PNat.find h₂ + 1 
Arguments: {p : ℕ+ → Prop} [DecidablePred p] (h : ∃ n, p n) (h₂ : ∃ n, p (n + 1)) (h1 : ¬p 1)
Goal: PNat.find h = PNat.find h₂ + 1
-- QPF.abs_map
class QPF (F : Type u → Type u) extends Functor F where
  P : PFunctor.{u}
  abs : ∀ {α}, P α → F α
  repr : ∀ {α}, F α → P α
  abs_repr : ∀ {α} (x : F α), abs (repr x) = x
  abs_map : ∀ {α β} (f : α → β) (p : P α), abs (P.map f p) = f <$> abs p
Arguments: {F : Type u → Type u} [self : QPF F] {α β : Type u} (f : α → β) (p : ↑(QPF.P F) α)
Goal: QPF.abs ((QPF.P F).map f p) = f <$> QPF.abs p
-- QPF.abs_repr
class QPF (F : Type u → Type u) extends Functor F where
  P : PFunctor.{u}
  abs : ∀ {α}, P α → F α
  repr : ∀ {α}, F α → P α
  abs_repr : ∀ {α} (x : F α), abs (repr x) = x
  abs_map : ∀ {α β} (f : α → β) (p : P α), abs (P.map f p) = f <$> abs p
Arguments: {F : Type u → Type u} [self : QPF F] {α : Type u} (x : F α)
Goal: QPF.abs (QPF.repr x) = x
-- QPF.id_map
theorem id_map {α : Type _} (x : F α) : id <$> x = x 
Arguments: {F : Type u → Type u} [q : QPF F] {α : Type u} (x : F α)
Goal: id <$> x = x
-- QPF.comp_map
theorem comp_map {α β γ : Type _} (f : α → β) (g : β → γ) (x : F α) :
    (g ∘ f) <$> x = g <$> f <$> x 
Arguments: {F : Type u → Type u} [q : QPF F] {α β γ : Type u} (f : α → β) (g : β → γ) (x : F α)
Goal: (g ∘ f) <$> x = g <$> f <$> x
-- QPF.lawfulFunctor
theorem lawfulFunctor
    (h : ∀ α β : Type u, @Functor.mapConst F _ α _ = Functor.map ∘ Function.const β) :
    LawfulFunctor F 
Arguments: {F : Type u → Type u} [q : QPF F] (h : ∀ (α β : Type u), Functor.mapConst = Functor.map ∘ Function.const β)
Goal: LawfulFunctor F
-- QPF.liftp_iff
theorem liftp_iff {α : Type u} (p : α → Prop) (x : F α) :
    Liftp p x ↔ ∃ a f, x = abs ⟨a, f⟩ ∧ ∀ i, p (f i) 
Arguments: {F : Type u → Type u} [q : QPF F] {α : Type u} (p : α → Prop) (x : F α)
Goal: Functor.Liftp p x ↔ ∃ a f, x = QPF.abs ⟨a, f⟩ ∧ ∀ (i : (QPF.P F).B a), p (f i)
-- QPF.liftp_iff'
theorem liftp_iff' {α : Type u} (p : α → Prop) (x : F α) :
    Liftp p x ↔ ∃ u : q.P α, abs u = x ∧ ∀ i, p (u.snd i) 
Arguments: {F : Type u → Type u} [q : QPF F] {α : Type u} (p : α → Prop) (x : F α)
Goal: Functor.Liftp p x ↔ ∃ u, QPF.abs u = x ∧ ∀ (i : (QPF.P F).B u.fst), p (u.snd i)
-- QPF.liftr_iff
theorem liftr_iff {α : Type u} (r : α → α → Prop) (x y : F α) :
    Liftr r x y ↔ ∃ a f₀ f₁, x = abs ⟨a, f₀⟩ ∧ y = abs ⟨a, f₁⟩ ∧ ∀ i, r (f₀ i) (f₁ i) 
Arguments: {F : Type u → Type u} [q : QPF F] {α : Type u} (r : α → α → Prop) (x y : F α)
Goal: Functor.Liftr r x y ↔ ∃ a f₀ f₁, x = QPF.abs ⟨a, f₀⟩ ∧ y = QPF.abs ⟨a, f₁⟩ ∧ ∀ (i : (QPF.P F).B a), r (f₀ i) (f₁ i)
-- QPF.recF_eq
theorem recF_eq {α : Type _} (g : F α → α) (x : q.P.W) :
    recF g x = g (abs (q.P.map (recF g) x.dest)) 
Arguments: {F : Type u → Type u} [q : QPF F] {α : Type u} (g : F α → α) (x : (QPF.P F).W)
Goal: QPF.recF g x = g (QPF.abs ((QPF.P F).map (QPF.recF g) x.dest))
-- QPF.recF_eq'
theorem recF_eq' {α : Type _} (g : F α → α) (a : q.P.A) (f : q.P.B a → q.P.W) :
    recF g ⟨a, f⟩ = g (abs (q.P.map (recF g) ⟨a, f⟩)) 
Arguments: {F : Type u → Type u} [q : QPF F] {α : Type u} (g : F α → α) (a : (QPF.P F).A) (f : (QPF.P F).B a → (QPF.P F).W)
Goal: QPF.recF g (WType.mk a f) = g (QPF.abs ((QPF.P F).map (QPF.recF g) ⟨a, f⟩))
-- QPF.recF_eq_of_Wequiv
theorem recF_eq_of_Wequiv {α : Type u} (u : F α → α) (x y : q.P.W) :
    Wequiv x y → recF u x = recF u y 
Arguments: {F : Type u → Type u} [q : QPF F] {α : Type u} (u : F α → α) (x y : (QPF.P F).W)
Goal: QPF.Wequiv x y → QPF.recF u x = QPF.recF u y
-- QPF.Wequiv.abs'
theorem Wequiv.abs' (x y : q.P.W) (h : QPF.abs x.dest = QPF.abs y.dest) : Wequiv x y 
Arguments: {F : Type u → Type u} [q : QPF F] (x y : (QPF.P F).W) (h : QPF.abs x.dest = QPF.abs y.dest)
Goal: QPF.Wequiv x y
-- QPF.Wequiv.refl
theorem Wequiv.refl (x : q.P.W) : Wequiv x x 
Arguments: {F : Type u → Type u} [q : QPF F] (x : (QPF.P F).W)
Goal: QPF.Wequiv x x
-- QPF.Wequiv.symm
theorem Wequiv.symm (x y : q.P.W) : Wequiv x y → Wequiv y x 
Arguments: {F : Type u → Type u} [q : QPF F] (x y : (QPF.P F).W)
Goal: QPF.Wequiv x y → QPF.Wequiv y x
-- QPF.Wrepr_equiv
theorem Wrepr_equiv (x : q.P.W) : Wequiv (Wrepr x) x 
Arguments: {F : Type u → Type u} [q : QPF F] (x : (QPF.P F).W)
Goal: QPF.Wequiv (QPF.Wrepr x) x
-- QPF.Fix.rec_eq
theorem Fix.rec_eq {α : Type _} (g : F α → α) (x : F (Fix F)) :
    Fix.rec g (Fix.mk x) = g (Fix.rec g <$> x) 
Arguments: {F : Type u → Type u} [q : QPF F] {α : Type u} (g : F α → α) (x : F (QPF.Fix F))
Goal: QPF.Fix.rec g (QPF.Fix.mk x) = g (QPF.Fix.rec g <$> x)
-- QPF.Fix.ind_aux
theorem Fix.ind_aux (a : q.P.A) (f : q.P.B a → q.P.W) :
    Fix.mk (abs ⟨a, fun x => ⟦f x⟧⟩) = ⟦⟨a, f⟩⟧ 
Arguments: {F : Type u → Type u} [q : QPF F] (a : (QPF.P F).A) (f : (QPF.P F).B a → (QPF.P F).W)
Goal: QPF.Fix.mk (QPF.abs ⟨a, fun x => ⟦f x⟧⟩) = ⟦WType.mk a f⟧
-- QPF.Fix.ind_rec
theorem Fix.ind_rec {α : Type u} (g₁ g₂ : Fix F → α)
    (h : ∀ x : F (Fix F), g₁ <$> x = g₂ <$> x → g₁ (Fix.mk x) = g₂ (Fix.mk x)) :
    ∀ x, g₁ x = g₂ x 
Arguments: {F : Type u → Type u} [q : QPF F] {α : Type u} (g₁ g₂ : QPF.Fix F → α) (h : ∀ (x : F (QPF.Fix F)), g₁ <$> x = g₂ <$> x → g₁ (QPF.Fix.mk x) = g₂ (QPF.Fix.mk x)) (x : QPF.Fix F)
Goal: g₁ x = g₂ x
-- QPF.Fix.rec_unique
theorem Fix.rec_unique {α : Type u} (g : F α → α) (h : Fix F → α)
    (hyp : ∀ x, h (Fix.mk x) = g (h <$> x)) : Fix.rec g = h 
Arguments: {F : Type u → Type u} [q : QPF F] {α : Type u} (g : F α → α) (h : QPF.Fix F → α) (hyp : ∀ (x : F (QPF.Fix F)), h (QPF.Fix.mk x) = g (h <$> x))
Goal: QPF.Fix.rec g = h
-- QPF.Fix.mk_dest
theorem Fix.mk_dest (x : Fix F) : Fix.mk (Fix.dest x) = x 
Arguments: {F : Type u → Type u} [q : QPF F] (x : QPF.Fix F)
Goal: QPF.Fix.mk x.dest = x
-- QPF.Fix.dest_mk
theorem Fix.dest_mk (x : F (Fix F)) : Fix.dest (Fix.mk x) = x 
Arguments: {F : Type u → Type u} [q : QPF F] (x : F (QPF.Fix F))
Goal: (QPF.Fix.mk x).dest = x
-- QPF.Fix.ind
theorem Fix.ind (p : Fix F → Prop) (h : ∀ x : F (Fix F), Liftp p x → p (Fix.mk x)) : ∀ x, p x 
Arguments: {F : Type u → Type u} [q : QPF F] (p : QPF.Fix F → Prop) (h : ∀ (x : F (QPF.Fix F)), Functor.Liftp p x → p (QPF.Fix.mk x)) (x : QPF.Fix F)
Goal: p x
-- QPF.corecF_eq
theorem corecF_eq {α : Type _} (g : α → F α) (x : α) :
    PFunctor.M.dest (corecF g x) = q.P.map (corecF g) (repr (g x)) 
Arguments: {F : Type u → Type u} [q : QPF F] {α : Type u} (g : α → F α) (x : α)
Goal: (QPF.corecF g x).dest = (QPF.P F).map (QPF.corecF g) (QPF.repr (g x))
-- QPF.Cofix.dest_corec
theorem Cofix.dest_corec {α : Type u} (g : α → F α) (x : α) :
    Cofix.dest (Cofix.corec g x) = Cofix.corec g <$> g x 
Arguments: {F : Type u → Type u} [q : QPF F] {α : Type u} (g : α → F α) (x : α)
Goal: (QPF.Cofix.corec g x).dest = QPF.Cofix.corec g <$> g x
-- _private.Mathlib.Data.QPF.Univariate.Basic.0.QPF.Cofix.bisim_aux
private theorem Cofix.bisim_aux (r : Cofix F → Cofix F → Prop) (h' : ∀ x, r x x)
    (h : ∀ x y, r x y → Quot.mk r <$> Cofix.dest x = Quot.mk r <$> Cofix.dest y) :
    ∀ x y, r x y → x = y 
Arguments: {F : Type u → Type u} [q : QPF F] (r : QPF.Cofix F → QPF.Cofix F → Prop) (h' : ∀ (x : QPF.Cofix F), r x x) (h : ∀ (x y : QPF.Cofix F), r x y → Quot.mk r <$> x.dest = Quot.mk r <$> y.dest) (x y : QPF.Cofix F)
Goal: r x y → x = y
-- QPF.Cofix.bisim_rel
theorem Cofix.bisim_rel (r : Cofix F → Cofix F → Prop)
    (h : ∀ x y, r x y → Quot.mk r <$> Cofix.dest x = Quot.mk r <$> Cofix.dest y) :
    ∀ x y, r x y → x = y 
Arguments: {F : Type u → Type u} [q : QPF F] (r : QPF.Cofix F → QPF.Cofix F → Prop) (h : ∀ (x y : QPF.Cofix F), r x y → Quot.mk r <$> x.dest = Quot.mk r <$> y.dest) (x y : QPF.Cofix F)
Goal: r x y → x = y
-- QPF.Cofix.bisim
theorem Cofix.bisim (r : Cofix F → Cofix F → Prop)
    (h : ∀ x y, r x y → Liftr r (Cofix.dest x) (Cofix.dest y)) : ∀ x y, r x y → x = y 
Arguments: {F : Type u → Type u} [q : QPF F] (r : QPF.Cofix F → QPF.Cofix F → Prop) (h : ∀ (x y : QPF.Cofix F), r x y → Functor.Liftr r x.dest y.dest) (x y : QPF.Cofix F)
Goal: r x y → x = y
-- QPF.Cofix.bisim'
theorem Cofix.bisim' {α : Type*} (Q : α → Prop) (u v : α → Cofix F)
    (h : ∀ x, Q x → ∃ a f f', Cofix.dest (u x) = abs ⟨a, f⟩ ∧ Cofix.dest (v x) = abs ⟨a, f'⟩ ∧
      ∀ i, ∃ x', Q x' ∧ f i = u x' ∧ f' i = v x') :
    ∀ x, Q x → u x = v x 
Arguments: {F : Type u → Type u} [q : QPF F] {α : Type u_1} (Q : α → Prop) (u v : α → QPF.Cofix F) (h :
  ∀ (x : α),
    Q x →
      ∃ a f f',
        (u x).dest = QPF.abs ⟨a, f⟩ ∧
          (v x).dest = QPF.abs ⟨a, f'⟩ ∧ ∀ (i : (QPF.P F).B a), ∃ x', Q x' ∧ f i = u x' ∧ f' i = v x') (x : α)
Goal: Q x → u x = v x
-- QPF.mem_supp
theorem mem_supp {α : Type u} (x : F α) (u : α) :
    u ∈ supp x ↔ ∀ a f, abs ⟨a, f⟩ = x → u ∈ f '' univ 
Arguments: {F : Type u → Type u} [q : QPF F] {α : Type u} (x : F α) (u : α)
Goal: u ∈ Functor.supp x ↔ ∀ (a : (QPF.P F).A) (f : (QPF.P F).B a → α), QPF.abs ⟨a, f⟩ = x → u ∈ f '' Set.univ
-- QPF.supp_eq
theorem supp_eq {α : Type u} (x : F α) :
    supp x = { u | ∀ a f, abs ⟨a, f⟩ = x → u ∈ f '' univ } 
Arguments: {F : Type u → Type u} [q : QPF F] {α : Type u} (x : F α)
Goal: Functor.supp x = {u | ∀ (a : (QPF.P F).A) (f : (QPF.P F).B a → α), QPF.abs ⟨a, f⟩ = x → u ∈ f '' Set.univ}
-- QPF.has_good_supp_iff
theorem has_good_supp_iff {α : Type u} (x : F α) :
    (∀ p, Liftp p x ↔ ∀ u ∈ supp x, p u) ↔
      ∃ a f, abs ⟨a, f⟩ = x ∧ ∀ a' f', abs ⟨a', f'⟩ = x → f '' univ ⊆ f' '' univ 
Arguments: {F : Type u → Type u} [q : QPF F] {α : Type u} (x : F α)
Goal: (∀ (p : α → Prop), Functor.Liftp p x ↔ ∀ u ∈ Functor.supp x, p u) ↔
  ∃ a f,
    QPF.abs ⟨a, f⟩ = x ∧
      ∀ (a' : (QPF.P F).A) (f' : (QPF.P F).B a' → α), QPF.abs ⟨a', f'⟩ = x → f '' Set.univ ⊆ f' '' Set.univ
-- QPF.supp_eq_of_isUniform
theorem supp_eq_of_isUniform (h : q.IsUniform) {α : Type u} (a : q.P.A) (f : q.P.B a → α) :
    supp (abs ⟨a, f⟩) = f '' univ 
Arguments: {F : Type u → Type u} [q : QPF F] (h : QPF.IsUniform) {α : Type u} (a : (QPF.P F).A) (f : (QPF.P F).B a → α)
Goal: Functor.supp (QPF.abs ⟨a, f⟩) = f '' Set.univ
-- QPF.liftp_iff_of_isUniform
theorem liftp_iff_of_isUniform (h : q.IsUniform) {α : Type u} (x : F α) (p : α → Prop) :
    Liftp p x ↔ ∀ u ∈ supp x, p u 
Arguments: {F : Type u → Type u} [q : QPF F] (h : QPF.IsUniform) {α : Type u} (x : F α) (p : α → Prop)
Goal: Functor.Liftp p x ↔ ∀ u ∈ Functor.supp x, p u
-- QPF.supp_map
theorem supp_map (h : q.IsUniform) {α β : Type u} (g : α → β) (x : F α) :
    supp (g <$> x) = g '' supp x 
Arguments: {F : Type u → Type u} [q : QPF F] (h : QPF.IsUniform) {α β : Type u} (g : α → β) (x : F α)
Goal: Functor.supp (g <$> x) = g '' Functor.supp x
-- QPF.suppPreservation_iff_uniform
theorem suppPreservation_iff_uniform : q.SuppPreservation ↔ q.IsUniform 
Arguments: {F : Type u → Type u} [q : QPF F]
Goal: QPF.SuppPreservation ↔ QPF.IsUniform
-- QPF.suppPreservation_iff_liftpPreservation
theorem suppPreservation_iff_liftpPreservation : q.SuppPreservation ↔ q.LiftpPreservation 
Arguments: {F : Type u → Type u} [q : QPF F]
Goal: QPF.SuppPreservation ↔ QPF.LiftpPreservation
-- QPF.liftpPreservation_iff_uniform
theorem liftpPreservation_iff_uniform : q.LiftpPreservation ↔ q.IsUniform 
Arguments: {F : Type u → Type u} [q : QPF F]
Goal: QPF.LiftpPreservation ↔ QPF.IsUniform
-- IsMaxChain.range_fin_of_covBy
theorem IsMaxChain.range_fin_of_covBy (h0 : f 0 = ⊥) (hlast : f (.last n) = ⊤)
    (hcovBy : ∀ k : Fin n, f k.castSucc ⩿ f k.succ) :
    IsMaxChain (· ≤ ·) (range f) 
Arguments: {α : Type u_1} [PartialOrder α] [BoundedOrder α] {n : ℕ} {f : Fin (n + 1) → α} (h0 : f 0 = ⊥) (hlast : f (Fin.last n) = ⊤) (hcovBy : ∀ (k : Fin n), f k.castSucc ⩿ f k.succ)
Goal: IsMaxChain (fun x x_1 => x ≤ x_1) (Set.range f)
-- Flag.rangeFin_carrier
@[simps]
def Flag.rangeFin (f : Fin (n + 1) → α) (h0 : f 0 = ⊥) (hlast : f (.last n) = ⊤)
    (hcovBy : ∀ k : Fin n, f k.castSucc ⩿ f k.succ) : Flag α 
Arguments: {α : Type u_1} [PartialOrder α] [BoundedOrder α] {n : ℕ} (f : Fin (n + 1) → α) (h0 : f 0 = ⊥) (hlast : f (Fin.last n) = ⊤) (hcovBy : ∀ (k : Fin n), f k.castSucc ⩿ f k.succ)
Goal: ↑(Flag.rangeFin f h0 hlast hcovBy) = Set.range f
-- Flag.mem_rangeFin
@[simp] theorem Flag.mem_rangeFin {x h0 hlast hcovBy} :
    x ∈ rangeFin f h0 hlast hcovBy ↔ ∃ k, f k = x 
Arguments: {α : Type u_1} [PartialOrder α] [BoundedOrder α] {n : ℕ} {f : Fin (n + 1) → α} {x : α} {h0 : f 0 = ⊥} {hlast : f (Fin.last n) = ⊤} {hcovBy : ∀ (k : Fin n), f k.castSucc ⩿ f k.succ}
Goal: x ∈ Flag.rangeFin f h0 hlast hcovBy ↔ ∃ k, f k = x
-- Nat.Primes.coe_pnat_nat
@[norm_cast]
theorem coe_pnat_nat (p : Nat.Primes) : ((p : ℕ+) : ℕ) = p 
Arguments: (p : Nat.Primes)
Goal: ↑↑p = ↑p
-- Nat.Primes.coe_pnat_injective
theorem coe_pnat_injective : Function.Injective ((↑) : Nat.Primes → ℕ+) 
Goal: Function.Injective Nat.Primes.toPNat