ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- AlgebraicGeometry.ProjectiveSpectrum.Proj.mk_mem_toSpec_base_apply
lemma mk_mem_toSpec_base_apply {f} (x : Proj| pbo f)
    (z : NumDenSameDeg 𝒜 (.powers f)) :
    HomogeneousLocalization.mk z ∈ ((toSpec 𝒜 f).1.base x).asIdeal ↔
      z.num.1 ∈ x.1.asHomogeneousIdeal 
Arguments: {R : Type u_1} {A : Type u_2} [CommRing R] [CommRing A] [Algebra R A] (𝒜 : ℕ → Submodule R A) [GradedAlgebra 𝒜] {f : A} (x : ↑((AlgebraicGeometry.Proj.toLocallyRingedSpace 𝒜).restrict ⋯).toTopCat) (z : HomogeneousLocalization.NumDenSameDeg 𝒜 (Submonoid.powers f))
Goal: HomogeneousLocalization.mk z ∈ ((AlgebraicGeometry.ProjectiveSpectrum.Proj.toSpec 𝒜 f).val.base x).asIdeal ↔
  ↑z.num ∈ (↑x).asHomogeneousIdeal
-- AlgebraicGeometry.ProjectiveSpectrum.Proj.toSpec_preimage_basicOpen
lemma toSpec_preimage_basicOpen {f}
    (t : NumDenSameDeg 𝒜 (.powers f)) :
    (Opens.map (toSpec 𝒜 f).1.base).obj (sbo (.mk t)) =
      Opens.comap ⟨_, continuous_subtype_val⟩ (pbo t.num.1) 
Arguments: {R : Type u_1} {A : Type u_2} [CommRing R] [CommRing A] [Algebra R A] (𝒜 : ℕ → Submodule R A) [GradedAlgebra 𝒜] {f : A} (t : HomogeneousLocalization.NumDenSameDeg 𝒜 (Submonoid.powers f))
Goal: (TopologicalSpace.Opens.map (AlgebraicGeometry.ProjectiveSpectrum.Proj.toSpec 𝒜 f).val.base).obj
    (PrimeSpectrum.basicOpen (HomogeneousLocalization.mk t)) =
  (TopologicalSpace.Opens.comap { toFun := Subtype.val, continuous_toFun := ⋯ }) (ProjectiveSpectrum.basicOpen 𝒜 ↑t.num)
-- AlgebraicGeometry.ProjectiveSpectrum.Proj.toOpen_toSpec_val_c_app
@[reassoc]
lemma toOpen_toSpec_val_c_app (f) (U) :
    StructureSheaf.toOpen (A⁰_ f) U.unop ≫ (toSpec 𝒜 f).val.c.app U =
      awayToΓ 𝒜 f ≫ (Proj| pbo f).presheaf.map (homOfLE le_top).op 
Arguments: {R : Type u_1} {A : Type u_2} [CommRing R] [CommRing A] [Algebra R A] (𝒜 : ℕ → Submodule R A) [GradedAlgebra 𝒜] (f : A) (U :
  (TopologicalSpace.Opens
      ↑↑(AlgebraicGeometry.Spec.locallyRingedSpaceObj
              (CommRingCat.of (HomogeneousLocalization.Away 𝒜 f))).toPresheafedSpace)ᵒᵖ)
Goal: CategoryTheory.CategoryStruct.comp
    (AlgebraicGeometry.StructureSheaf.toOpen (HomogeneousLocalization.Away 𝒜 f) (Opposite.unop U))
    ((AlgebraicGeometry.ProjectiveSpectrum.Proj.toSpec 𝒜 f).val.c.app U) =
  CategoryTheory.CategoryStruct.comp (AlgebraicGeometry.ProjectiveSpectrum.Proj.awayToΓ 𝒜 f)
    (((AlgebraicGeometry.Proj.toLocallyRingedSpace 𝒜).restrict ⋯).presheaf.map (CategoryTheory.homOfLE ⋯).op)
-- AlgebraicGeometry.ProjectiveSpectrum.Proj.toStalk_stalkMap_toSpec
@[reassoc]
lemma toStalk_stalkMap_toSpec (f) (x) :
    StructureSheaf.toStalk _ _ ≫ (toSpec 𝒜 f).stalkMap x =
      awayToΓ 𝒜 f ≫ (Proj| pbo f).presheaf.Γgerm x 
Arguments: {R : Type u_1} {A : Type u_2} [CommRing R] [CommRing A] [Algebra R A] (𝒜 : ℕ → Submodule R A) [GradedAlgebra 𝒜] (f : A) (x : ↑((AlgebraicGeometry.Proj.toLocallyRingedSpace 𝒜).restrict ⋯).toTopCat)
Goal: CategoryTheory.CategoryStruct.comp
    (AlgebraicGeometry.StructureSheaf.toStalk (↑(CommRingCat.of (HomogeneousLocalization.Away 𝒜 f)))
      ((AlgebraicGeometry.ProjectiveSpectrum.Proj.toSpec 𝒜 f).val.base x))
    (AlgebraicGeometry.LocallyRingedSpace.Hom.stalkMap (AlgebraicGeometry.ProjectiveSpectrum.Proj.toSpec 𝒜 f) x) =
  CategoryTheory.CategoryStruct.comp (AlgebraicGeometry.ProjectiveSpectrum.Proj.awayToΓ 𝒜 f)
    (((AlgebraicGeometry.Proj.toLocallyRingedSpace 𝒜).restrict ⋯).presheaf.Γgerm x)
-- AlgebraicGeometry.ProjectiveSpectrum.Proj.isLocalization_atPrime
lemma isLocalization_atPrime (f) (x : pbo f) {m} (f_deg : f ∈ 𝒜 m) (hm : 0 < m) :
    @IsLocalization (Away 𝒜 f) _ ((toSpec 𝒜 f).1.base x).asIdeal.primeCompl
      (AtPrime 𝒜 x.1.asHomogeneousIdeal.toIdeal) _
      (mapId 𝒜 (Submonoid.powers_le.mpr x.2)).toAlgebra 
Arguments: {R : Type u_1} {A : Type u_2} [CommRing R] [CommRing A] [Algebra R A] (𝒜 : ℕ → Submodule R A) [GradedAlgebra 𝒜] (f : A) (x : ↥(ProjectiveSpectrum.basicOpen 𝒜 f)) {m : ℕ} (f_deg : f ∈ 𝒜 m) (hm : 0 < m)
Goal: IsLocalization ((AlgebraicGeometry.ProjectiveSpectrum.Proj.toSpec 𝒜 f).val.base x).asIdeal.primeCompl
  (HomogeneousLocalization.AtPrime 𝒜 (↑x).asHomogeneousIdeal.toIdeal)
-- AlgebraicGeometry.ProjectiveSpectrum.Proj.toStalk_specStalkEquiv
lemma toStalk_specStalkEquiv (f) (x : pbo f) {m} (f_deg : f ∈ 𝒜 m) (hm : 0 < m) :
    StructureSheaf.toStalk (A⁰_ f) ((toSpec 𝒜 f).1.base x) ≫ (specStalkEquiv 𝒜 f x f_deg hm).hom =
      (mapId _ <| Submonoid.powers_le.mpr x.2 : (A⁰_ f) →+* AtPrime 𝒜 x.1.1.toIdeal) 
Arguments: {R : Type u_1} {A : Type u_2} [CommRing R] [CommRing A] [Algebra R A] (𝒜 : ℕ → Submodule R A) [GradedAlgebra 𝒜] (f : A) (x : ↥(ProjectiveSpectrum.basicOpen 𝒜 f)) {m : ℕ} (f_deg : f ∈ 𝒜 m) (hm : 0 < m)
Goal: CategoryTheory.CategoryStruct.comp
    (AlgebraicGeometry.StructureSheaf.toStalk (HomogeneousLocalization.Away 𝒜 f)
      ((AlgebraicGeometry.ProjectiveSpectrum.Proj.toSpec 𝒜 f).val.base x))
    (AlgebraicGeometry.ProjectiveSpectrum.Proj.specStalkEquiv 𝒜 f x f_deg hm).hom =
  HomogeneousLocalization.mapId 𝒜 ⋯
-- AlgebraicGeometry.ProjectiveSpectrum.Proj.stalkMap_toSpec
lemma stalkMap_toSpec (f) (x : pbo f) {m} (f_deg : f ∈ 𝒜 m) (hm : 0 < m) :
    (toSpec 𝒜 f).stalkMap x =
      (specStalkEquiv 𝒜 f x f_deg hm).hom ≫ (Proj.stalkIso' 𝒜 x.1).toCommRingCatIso.inv ≫
      ((Proj.toLocallyRingedSpace 𝒜).restrictStalkIso (Opens.openEmbedding _) x).inv 
Arguments: {R : Type u_1} {A : Type u_2} [CommRing R] [CommRing A] [Algebra R A] (𝒜 : ℕ → Submodule R A) [GradedAlgebra 𝒜] (f : A) (x : ↥(ProjectiveSpectrum.basicOpen 𝒜 f)) {m : ℕ} (f_deg : f ∈ 𝒜 m) (hm : 0 < m)
Goal: AlgebraicGeometry.LocallyRingedSpace.Hom.stalkMap (AlgebraicGeometry.ProjectiveSpectrum.Proj.toSpec 𝒜 f) x =
  CategoryTheory.CategoryStruct.comp (AlgebraicGeometry.ProjectiveSpectrum.Proj.specStalkEquiv 𝒜 f x f_deg hm).hom
    (CategoryTheory.CategoryStruct.comp (AlgebraicGeometry.Proj.stalkIso' 𝒜 ↑x).toCommRingCatIso.inv
      ((AlgebraicGeometry.Proj.toLocallyRingedSpace 𝒜).restrictStalkIso ⋯ x).inv)
-- AlgebraicGeometry.ProjectiveSpectrum.Proj.isIso_toSpec
lemma isIso_toSpec (f) {m} (f_deg : f ∈ 𝒜 m) (hm : 0 < m) :
    IsIso (toSpec 𝒜 f) 
Arguments: {R : Type u_1} {A : Type u_2} [CommRing R] [CommRing A] [Algebra R A] (𝒜 : ℕ → Submodule R A) [GradedAlgebra 𝒜] (f : A) {m : ℕ} (f_deg : f ∈ 𝒜 m) (hm : 0 < m)
Goal: CategoryTheory.IsIso (AlgebraicGeometry.ProjectiveSpectrum.Proj.toSpec 𝒜 f)
-- Finset.dens_eq_card_div_card
lemma dens_eq_card_div_card (s : Finset α) : dens s = s.card / Fintype.card α 
Arguments: {α : Type u_2} [Fintype α] (s : Finset α)
Goal: s.dens = ↑s.card / ↑(Fintype.card α)
-- Finset.dens_empty
@[simp] lemma dens_empty : dens (∅ : Finset α) = 0 
Arguments: {α : Type u_2} [Fintype α]
Goal: ∅.dens = 0
-- Finset.dens_singleton
@[simp] lemma dens_singleton (a : α) : dens ({a} : Finset α) = (Fintype.card α : ℚ≥0)⁻¹ 
Arguments: {α : Type u_2} [Fintype α] (a : α)
Goal: {a}.dens = (↑(Fintype.card α))⁻¹
-- Finset.dens_cons
@[simp] lemma dens_cons (h : a ∉ s) : (s.cons a h).dens = dens s + (Fintype.card α : ℚ≥0)⁻¹ 
Arguments: {α : Type u_2} [Fintype α] {s : Finset α} {a : α} (h : a ∉ s)
Goal: (Finset.cons a s h).dens = s.dens + (↑(Fintype.card α))⁻¹
-- Finset.dens_disjUnion
@[simp] lemma dens_disjUnion (s t : Finset α) (h) : dens (s.disjUnion t h) = dens s + dens t 
Arguments: {α : Type u_2} [Fintype α] (s t : Finset α) (h : Disjoint s t)
Goal: (s.disjUnion t h).dens = s.dens + t.dens
-- Finset.dens_eq_zero
@[simp] lemma dens_eq_zero : dens s = 0 ↔ s = ∅ 
Arguments: {α : Type u_2} [Fintype α] {s : Finset α}
Goal: s.dens = 0 ↔ s = ∅
-- Finset.dens_ne_zero
lemma dens_ne_zero : dens s ≠ 0 ↔ s.Nonempty 
Arguments: {α : Type u_2} [Fintype α] {s : Finset α}
Goal: s.dens ≠ 0 ↔ s.Nonempty
-- Finset.dens_pos
@[simp] lemma dens_pos : 0 < dens s ↔ s.Nonempty 
Arguments: {α : Type u_2} [Fintype α] {s : Finset α}
Goal: 0 < s.dens ↔ s.Nonempty
-- Finset.dens_le_dens
lemma dens_le_dens (h : s ⊆ t) : dens s ≤ dens t 
Arguments: {α : Type u_2} [Fintype α] {s t : Finset α} (h : s ⊆ t)
Goal: s.dens ≤ t.dens
-- Finset.dens_lt_dens
lemma dens_lt_dens (h : s ⊂ t) : dens s < dens t 
Arguments: {α : Type u_2} [Fintype α] {s t : Finset α} (h : s ⊂ t)
Goal: s.dens < t.dens
-- Finset.dens_mono
@[mono] lemma dens_mono : Monotone (dens : Finset α → ℚ≥0) 
Arguments: {α : Type u_2} [Fintype α]
Goal: Monotone Finset.dens
-- Finset.dens_strictMono
@[mono] lemma dens_strictMono : StrictMono (dens : Finset α → ℚ≥0) 
Arguments: {α : Type u_2} [Fintype α]
Goal: StrictMono Finset.dens
-- Finset.dens_map_le
lemma dens_map_le [Fintype β] (f : α ↪ β) : dens (s.map f) ≤ dens s 
Arguments: {α : Type u_2} {β : Type u_3} [Fintype α] {s : Finset α} [Fintype β] (f : α ↪ β)
Goal: (Finset.map f s).dens ≤ s.dens
-- Finset.dens_univ
@[simp] lemma dens_univ : dens (univ : Finset α) = 1 
Arguments: {α : Type u_2} [Fintype α] [Nonempty α]
Goal: Finset.univ.dens = 1
-- Finset.dens_eq_one
@[simp] lemma dens_eq_one : dens s = 1 ↔ s = univ 
Arguments: {α : Type u_2} [Fintype α] {s : Finset α} [Nonempty α]
Goal: s.dens = 1 ↔ s = Finset.univ
-- Finset.dens_ne_one
lemma dens_ne_one : dens s ≠ 1 ↔ s ≠ univ 
Arguments: {α : Type u_2} [Fintype α] {s : Finset α} [Nonempty α]
Goal: s.dens ≠ 1 ↔ s ≠ Finset.univ
-- Finset.dens_union_add_dens_inter
lemma dens_union_add_dens_inter (s t : Finset α) :
    dens (s ∪ t) + dens (s ∩ t) = dens s + dens t 
Arguments: {α : Type u_2} [Fintype α] [DecidableEq α] (s t : Finset α)
Goal: (s ∪ t).dens + (s ∩ t).dens = s.dens + t.dens
-- Finset.dens_inter_add_dens_union
lemma dens_inter_add_dens_union (s t : Finset α) :
    dens (s ∩ t) + dens (s ∪ t) = dens s + dens t 
Arguments: {α : Type u_2} [Fintype α] [DecidableEq α] (s t : Finset α)
Goal: (s ∩ t).dens + (s ∪ t).dens = s.dens + t.dens
-- Finset.dens_union_of_disjoint
@[simp] lemma dens_union_of_disjoint (h : Disjoint s t) : dens (s ∪ t) = dens s + dens t 
Arguments: {α : Type u_2} [Fintype α] {s t : Finset α} [DecidableEq α] (h : Disjoint s t)
Goal: (s ∪ t).dens = s.dens + t.dens
-- Finset.dens_sdiff_add_dens_eq_dens
lemma dens_sdiff_add_dens_eq_dens (h : s ⊆ t) : dens (t \ s) + dens s = dens t 
Arguments: {α : Type u_2} [Fintype α] {s t : Finset α} [DecidableEq α] (h : s ⊆ t)
Goal: (t \ s).dens + s.dens = t.dens
-- Finset.dens_sdiff_add_dens
lemma dens_sdiff_add_dens (s t : Finset α) : dens (s \ t) + dens t = (s ∪ t).dens 
Arguments: {α : Type u_2} [Fintype α] [DecidableEq α] (s t : Finset α)
Goal: (s \ t).dens + t.dens = (s ∪ t).dens
-- Finset.dens_sdiff_comm
lemma dens_sdiff_comm (h : card s = card t) : dens (s \ t) = dens (t \ s) 
Arguments: {α : Type u_2} [Fintype α] {s t : Finset α} [DecidableEq α] (h : s.card = t.card)
Goal: (s \ t).dens = (t \ s).dens
-- Finset.dens_sdiff_add_dens_inter
@[simp]
lemma dens_sdiff_add_dens_inter (s t : Finset α) : dens (s \ t) + dens (s ∩ t) = dens s 
Arguments: {α : Type u_2} [Fintype α] [DecidableEq α] (s t : Finset α)
Goal: (s \ t).dens + (s ∩ t).dens = s.dens
-- Finset.dens_inter_add_dens_sdiff
@[simp]
lemma dens_inter_add_dens_sdiff (s t : Finset α) : dens (s ∩ t) + dens (s \ t) = dens s 
Arguments: {α : Type u_2} [Fintype α] [DecidableEq α] (s t : Finset α)
Goal: (s ∩ t).dens + (s \ t).dens = s.dens
-- Finset.dens_filter_add_dens_filter_not_eq_dens
lemma dens_filter_add_dens_filter_not_eq_dens
    (p : α → Prop) [DecidablePred p] [∀ x, Decidable (¬p x)] :
    dens (s.filter p) + dens (s.filter fun a ↦ ¬ p a) = dens s 
Arguments: {α : Type u_2} [Fintype α] {s : Finset α} [DecidableEq α] (p : α → Prop) [DecidablePred p] [(x : α) → Decidable ¬p x]
Goal: (Finset.filter p s).dens + (Finset.filter (fun a => ¬p a) s).dens = s.dens
-- Finset.dens_union_le
lemma dens_union_le (s t : Finset α) : dens (s ∪ t) ≤ dens s + dens t 
Arguments: {α : Type u_2} [Fintype α] [DecidableEq α] (s t : Finset α)
Goal: (s ∪ t).dens ≤ s.dens + t.dens
-- Finset.dens_le_dens_sdiff_add_dens
lemma dens_le_dens_sdiff_add_dens : dens s ≤ dens (s \ t) + dens t 
Arguments: {α : Type u_2} [Fintype α] {s t : Finset α} [DecidableEq α]
Goal: s.dens ≤ (s \ t).dens + t.dens
-- Finset.dens_sdiff
lemma dens_sdiff (h : s ⊆ t) : dens (t \ s) = dens t - dens s 
Arguments: {α : Type u_2} [Fintype α] {s t : Finset α} [DecidableEq α] (h : s ⊆ t)
Goal: (t \ s).dens = t.dens - s.dens
-- Finset.le_dens_sdiff
lemma le_dens_sdiff (s t : Finset α) : dens t - dens s ≤ dens (t \ s) 
Arguments: {α : Type u_2} [Fintype α] [DecidableEq α] (s t : Finset α)
Goal: t.dens - s.dens ≤ (t \ s).dens
-- Finset.sort_sorted
@[simp]
theorem sort_sorted (s : Finset α) : List.Sorted r (sort r s) 
Arguments: {α : Type u_1} (r : α → α → Prop) [DecidableRel r] [IsTrans α r] [IsAntisymm α r] [IsTotal α r] (s : Finset α)
Goal: List.Sorted r (Finset.sort r s)
-- Finset.sort_eq
@[simp]
theorem sort_eq (s : Finset α) : ↑(sort r s) = s.1 
Arguments: {α : Type u_1} (r : α → α → Prop) [DecidableRel r] [IsTrans α r] [IsAntisymm α r] [IsTotal α r] (s : Finset α)
Goal: ↑(Finset.sort r s) = s.val
-- Finset.sort_nodup
@[simp]
theorem sort_nodup (s : Finset α) : (sort r s).Nodup 
Arguments: {α : Type u_1} (r : α → α → Prop) [DecidableRel r] [IsTrans α r] [IsAntisymm α r] [IsTotal α r] (s : Finset α)
Goal: (Finset.sort r s).Nodup
-- Finset.sort_toFinset
@[simp]
theorem sort_toFinset [DecidableEq α] (s : Finset α) : (sort r s).toFinset = s 
Arguments: {α : Type u_1} (r : α → α → Prop) [DecidableRel r] [IsTrans α r] [IsAntisymm α r] [IsTotal α r] [DecidableEq α] (s : Finset α)
Goal: (Finset.sort r s).toFinset = s
-- Finset.mem_sort
@[simp]
theorem mem_sort {s : Finset α} {a : α} : a ∈ sort r s ↔ a ∈ s 
Arguments: {α : Type u_1} (r : α → α → Prop) [DecidableRel r] [IsTrans α r] [IsAntisymm α r] [IsTotal α r] {s : Finset α} {a : α}
Goal: a ∈ Finset.sort r s ↔ a ∈ s
-- Finset.length_sort
@[simp]
theorem length_sort {s : Finset α} : (sort r s).length = s.card 
Arguments: {α : Type u_1} (r : α → α → Prop) [DecidableRel r] [IsTrans α r] [IsAntisymm α r] [IsTotal α r] {s : Finset α}
Goal: (Finset.sort r s).length = s.card
-- Finset.sort_empty
@[simp]
theorem sort_empty : sort r ∅ = [] 
Arguments: {α : Type u_1} (r : α → α → Prop) [DecidableRel r] [IsTrans α r] [IsAntisymm α r] [IsTotal α r]
Goal: Finset.sort r ∅ = []
-- Finset.sort_singleton
@[simp]
theorem sort_singleton (a : α) : sort r {a} = [a] 
Arguments: {α : Type u_1} (r : α → α → Prop) [DecidableRel r] [IsTrans α r] [IsAntisymm α r] [IsTotal α r] (a : α)
Goal: Finset.sort r {a} = [a]
-- Finset.sort_perm_toList
theorem sort_perm_toList (s : Finset α) : sort r s ~ s.toList 
Arguments: {α : Type u_1} (r : α → α → Prop) [DecidableRel r] [IsTrans α r] [IsAntisymm α r] [IsTotal α r] (s : Finset α)
Goal: (Finset.sort r s).Perm s.toList
-- Finset.sort_sorted_lt
theorem sort_sorted_lt (s : Finset α) : List.Sorted (· < ·) (sort (· ≤ ·) s) 
Arguments: {α : Type u_1} [LinearOrder α] (s : Finset α)
Goal: List.Sorted (fun x x_1 => x < x_1) (Finset.sort (fun x x_1 => x ≤ x_1) s)
-- Finset.sort_sorted_gt
theorem sort_sorted_gt (s : Finset α) : List.Sorted (· > ·) (sort (· ≥ ·) s) 
Arguments: {α : Type u_1} [LinearOrder α] (s : Finset α)
Goal: List.Sorted (fun x x_1 => x > x_1) (Finset.sort (fun x x_1 => x ≥ x_1) s)
-- Finset.sorted_zero_eq_min'_aux
theorem sorted_zero_eq_min'_aux (s : Finset α) (h : 0 < (s.sort (· ≤ ·)).length) (H : s.Nonempty) :
    (s.sort (· ≤ ·)).get ⟨0, h⟩ = s.min' H 
Arguments: {α : Type u_1} [LinearOrder α] (s : Finset α) (h : 0 < (Finset.sort (fun x x_1 => x ≤ x_1) s).length) (H : s.Nonempty)
Goal: (Finset.sort (fun x x_1 => x ≤ x_1) s).get ⟨0, h⟩ = s.min' H
-- Finset.sorted_zero_eq_min'
theorem sorted_zero_eq_min' {s : Finset α} {h : 0 < (s.sort (· ≤ ·)).length} :
    (s.sort (· ≤ ·)).get ⟨0, h⟩ = s.min' (card_pos.1 <| by rwa [length_sort] at h) 
Arguments: {α : Type u_1} [LinearOrder α] {s : Finset α} {h : 0 < (Finset.sort (fun x x_1 => x ≤ x_1) s).length}
Goal: (Finset.sort (fun x x_1 => x ≤ x_1) s).get ⟨0, h⟩ = s.min' ⋯
-- Finset.min'_eq_sorted_zero
theorem min'_eq_sorted_zero {s : Finset α} {h : s.Nonempty} :
    s.min' h = (s.sort (· ≤ ·)).get ⟨0, (by rw [length_sort]; exact card_pos.2 h)⟩ 
Arguments: {α : Type u_1} [LinearOrder α] {s : Finset α} {h : s.Nonempty}
Goal: s.min' h = (Finset.sort (fun x x_1 => x ≤ x_1) s).get ⟨0, ⋯⟩
-- Finset.sorted_last_eq_max'_aux
theorem sorted_last_eq_max'_aux (s : Finset α)
    (h : (s.sort (· ≤ ·)).length - 1 < (s.sort (· ≤ ·)).length) (H : s.Nonempty) :
    (s.sort (· ≤ ·)).get ⟨(s.sort (· ≤ ·)).length - 1, h⟩ = s.max' H 
Arguments: {α : Type u_1} [LinearOrder α] (s : Finset α) (h : (Finset.sort (fun x x_1 => x ≤ x_1) s).length - 1 < (Finset.sort (fun x x_1 => x ≤ x_1) s).length) (H : s.Nonempty)
Goal: (Finset.sort (fun x x_1 => x ≤ x_1) s).get ⟨(Finset.sort (fun x x_1 => x ≤ x_1) s).length - 1, h⟩ = s.max' H
-- Finset.sorted_last_eq_max'
theorem sorted_last_eq_max' {s : Finset α}
    {h : (s.sort (· ≤ ·)).length - 1 < (s.sort (· ≤ ·)).length} :
    (s.sort (· ≤ ·)).get ⟨(s.sort (· ≤ ·)).length - 1, h⟩ =
      s.max' (by rw [length_sort] at h; exact card_pos.1 (lt_of_le_of_lt bot_le h)) 
Arguments: {α : Type u_1} [LinearOrder α] {s : Finset α} {h : (Finset.sort (fun x x_1 => x ≤ x_1) s).length - 1 < (Finset.sort (fun x x_1 => x ≤ x_1) s).length}
Goal: (Finset.sort (fun x x_1 => x ≤ x_1) s).get ⟨(Finset.sort (fun x x_1 => x ≤ x_1) s).length - 1, h⟩ = s.max' ⋯
-- Finset.max'_eq_sorted_last
theorem max'_eq_sorted_last {s : Finset α} {h : s.Nonempty} :
    s.max' h =
      (s.sort (· ≤ ·)).get ⟨(s.sort (· ≤ ·)).length - 1,
        by simpa using Nat.sub_lt (card_pos.mpr h) Nat.zero_lt_one⟩ 
Arguments: {α : Type u_1} [LinearOrder α] {s : Finset α} {h : s.Nonempty}
Goal: s.max' h = (Finset.sort (fun x x_1 => x ≤ x_1) s).get ⟨(Finset.sort (fun x x_1 => x ≤ x_1) s).length - 1, ⋯⟩
-- Finset.coe_orderIsoOfFin_apply
@[simp]
theorem coe_orderIsoOfFin_apply (s : Finset α) {k : ℕ} (h : s.card = k) (i : Fin k) :
    ↑(orderIsoOfFin s h i) = orderEmbOfFin s h i 
Arguments: {α : Type u_1} [LinearOrder α] (s : Finset α) {k : ℕ} (h : s.card = k) (i : Fin k)
Goal: ↑((s.orderIsoOfFin h) i) = (s.orderEmbOfFin h) i
-- Finset.orderIsoOfFin_symm_apply
theorem orderIsoOfFin_symm_apply (s : Finset α) {k : ℕ} (h : s.card = k) (x : s) :
    ↑((s.orderIsoOfFin h).symm x) = (s.sort (· ≤ ·)).indexOf ↑x 
Arguments: {α : Type u_1} [LinearOrder α] (s : Finset α) {k : ℕ} (h : s.card = k) (x : { x // x ∈ s })
Goal: ↑((s.orderIsoOfFin h).symm x) = List.indexOf (↑x) (Finset.sort (fun x x_1 => x ≤ x_1) s)
-- Finset.orderEmbOfFin_apply
theorem orderEmbOfFin_apply (s : Finset α) {k : ℕ} (h : s.card = k) (i : Fin k) :
    s.orderEmbOfFin h i =
      (s.sort (· ≤ ·)).get ⟨i, by rw [length_sort, h]; exact i.2⟩ 
Arguments: {α : Type u_1} [LinearOrder α] (s : Finset α) {k : ℕ} (h : s.card = k) (i : Fin k)
Goal: (s.orderEmbOfFin h) i = (Finset.sort (fun x x_1 => x ≤ x_1) s).get ⟨↑i, ⋯⟩
-- Finset.orderEmbOfFin_mem
@[simp]
theorem orderEmbOfFin_mem (s : Finset α) {k : ℕ} (h : s.card = k) (i : Fin k) :
    s.orderEmbOfFin h i ∈ s 
Arguments: {α : Type u_1} [LinearOrder α] (s : Finset α) {k : ℕ} (h : s.card = k) (i : Fin k)
Goal: (s.orderEmbOfFin h) i ∈ s
-- Finset.range_orderEmbOfFin
@[simp]
theorem range_orderEmbOfFin (s : Finset α) {k : ℕ} (h : s.card = k) :
    Set.range (s.orderEmbOfFin h) = s 
Arguments: {α : Type u_1} [LinearOrder α] (s : Finset α) {k : ℕ} (h : s.card = k)
Goal: Set.range ⇑(s.orderEmbOfFin h) = ↑s
-- Finset.orderEmbOfFin_zero
theorem orderEmbOfFin_zero {s : Finset α} {k : ℕ} (h : s.card = k) (hz : 0 < k) :
    orderEmbOfFin s h ⟨0, hz⟩ = s.min' (card_pos.mp (h.symm ▸ hz)) 
Arguments: {α : Type u_1} [LinearOrder α] {s : Finset α} {k : ℕ} (h : s.card = k) (hz : 0 < k)
Goal: (s.orderEmbOfFin h) ⟨0, hz⟩ = s.min' ⋯
-- Finset.orderEmbOfFin_last
theorem orderEmbOfFin_last {s : Finset α} {k : ℕ} (h : s.card = k) (hz : 0 < k) :
    orderEmbOfFin s h ⟨k - 1, Nat.sub_lt hz (Nat.succ_pos 0)⟩ =
      s.max' (card_pos.mp (h.symm ▸ hz)) 
Arguments: {α : Type u_1} [LinearOrder α] {s : Finset α} {k : ℕ} (h : s.card = k) (hz : 0 < k)
Goal: (s.orderEmbOfFin h) ⟨k - 1, ⋯⟩ = s.max' ⋯
-- Finset.orderEmbOfFin_singleton
@[simp]
theorem orderEmbOfFin_singleton (a : α) (i : Fin 1) :
    orderEmbOfFin {a} (card_singleton a) i = a 
Arguments: {α : Type u_1} [LinearOrder α] (a : α) (i : Fin 1)
Goal: ({a}.orderEmbOfFin ⋯) i = a
-- Finset.orderEmbOfFin_unique
theorem orderEmbOfFin_unique {s : Finset α} {k : ℕ} (h : s.card = k) {f : Fin k → α}
    (hfs : ∀ x, f x ∈ s) (hmono : StrictMono f) : f = s.orderEmbOfFin h 
Arguments: {α : Type u_1} [LinearOrder α] {s : Finset α} {k : ℕ} (h : s.card = k) {f : Fin k → α} (hfs : ∀ (x : Fin k), f x ∈ s) (hmono : StrictMono f)
Goal: f = ⇑(s.orderEmbOfFin h)
-- Finset.orderEmbOfFin_unique'
theorem orderEmbOfFin_unique' {s : Finset α} {k : ℕ} (h : s.card = k) {f : Fin k ↪o α}
    (hfs : ∀ x, f x ∈ s) : f = s.orderEmbOfFin h 
Arguments: {α : Type u_1} [LinearOrder α] {s : Finset α} {k : ℕ} (h : s.card = k) {f : Fin k ↪o α} (hfs : ∀ (x : Fin k), f x ∈ s)
Goal: f = s.orderEmbOfFin h
-- Finset.orderEmbOfFin_eq_orderEmbOfFin_iff
@[simp]
theorem orderEmbOfFin_eq_orderEmbOfFin_iff {k l : ℕ} {s : Finset α} {i : Fin k} {j : Fin l}
    {h : s.card = k} {h' : s.card = l} :
    s.orderEmbOfFin h i = s.orderEmbOfFin h' j ↔ (i : ℕ) = (j : ℕ) 
Arguments: {α : Type u_1} [LinearOrder α] {k l : ℕ} {s : Finset α} {i : Fin k} {j : Fin l} {h : s.card = k} {h' : s.card = l}
Goal: (s.orderEmbOfFin h) i = (s.orderEmbOfFin h') j ↔ ↑i = ↑j
-- Finset.orderEmbOfCardLe_mem
theorem orderEmbOfCardLe_mem (s : Finset α) {k : ℕ} (h : k ≤ s.card) (a) :
    orderEmbOfCardLe s h a ∈ s 
Arguments: {α : Type u_1} [LinearOrder α] (s : Finset α) {k : ℕ} (h : k ≤ s.card) (a : Fin k)
Goal: (s.orderEmbOfCardLe h) a ∈ s
-- Fin.sort_univ
theorem sort_univ (n : ℕ) : Finset.univ.sort (fun x y : Fin n => x ≤ y) = List.finRange n 
Arguments: (n : ℕ)
Goal: Finset.sort (fun x y => x ≤ y) Finset.univ = List.finRange n
-- Finset.mem_powerset
@[simp]
theorem mem_powerset {s t : Finset α} : s ∈ powerset t ↔ s ⊆ t 
Arguments: {α : Type u_1} {s t : Finset α}
Goal: s ∈ t.powerset ↔ s ⊆ t
-- Finset.coe_powerset
@[simp, norm_cast]
theorem coe_powerset (s : Finset α) :
    (s.powerset : Set (Finset α)) = ((↑) : Finset α → Set α) ⁻¹' (s : Set α).powerset 
Arguments: {α : Type u_1} (s : Finset α)
Goal: ↑s.powerset = Finset.toSet ⁻¹' 𝒫↑s
-- Finset.empty_mem_powerset
theorem empty_mem_powerset (s : Finset α) : ∅ ∈ powerset s 
Arguments: {α : Type u_1} (s : Finset α)
Goal: ∅ ∈ s.powerset
-- Finset.mem_powerset_self
theorem mem_powerset_self (s : Finset α) : s ∈ powerset s 
Arguments: {α : Type u_1} (s : Finset α)
Goal: s ∈ s.powerset
-- Finset.powerset_nonempty
@[aesop safe apply (rule_sets := [finsetNonempty])]
theorem powerset_nonempty (s : Finset α) : s.powerset.Nonempty 
Arguments: {α : Type u_1} (s : Finset α)
Goal: s.powerset.Nonempty
-- Finset.powerset_mono
@[simp]
theorem powerset_mono {s t : Finset α} : powerset s ⊆ powerset t ↔ s ⊆ t 
Arguments: {α : Type u_1} {s t : Finset α}
Goal: s.powerset ⊆ t.powerset ↔ s ⊆ t
-- Finset.powerset_injective
theorem powerset_injective : Injective (powerset : Finset α → Finset (Finset α)) 
Arguments: {α : Type u_1}
Goal: Function.Injective Finset.powerset
-- Finset.powerset_inj
@[simp]
theorem powerset_inj : powerset s = powerset t ↔ s = t 
Arguments: {α : Type u_1} {s t : Finset α}
Goal: s.powerset = t.powerset ↔ s = t
-- Finset.powerset_empty
@[simp]
theorem powerset_empty : (∅ : Finset α).powerset = {∅} 
Arguments: {α : Type u_1}
Goal: ∅.powerset = {∅}
-- Finset.powerset_eq_singleton_empty
@[simp]
theorem powerset_eq_singleton_empty : s.powerset = {∅} ↔ s = ∅ 
Arguments: {α : Type u_1} {s : Finset α}
Goal: s.powerset = {∅} ↔ s = ∅
-- Finset.card_powerset
@[simp]
theorem card_powerset (s : Finset α) : card (powerset s) = 2 ^ card s 
Arguments: {α : Type u_1} (s : Finset α)
Goal: s.powerset.card = 2 ^ s.card
-- Finset.not_mem_of_mem_powerset_of_not_mem
theorem not_mem_of_mem_powerset_of_not_mem {s t : Finset α} {a : α} (ht : t ∈ s.powerset)
    (h : a ∉ s) : a ∉ t 
Arguments: {α : Type u_1} {s t : Finset α} {a : α} (ht : t ∈ s.powerset) (h : a ∉ s)
Goal: a ∉ t
-- Finset.powerset_insert
theorem powerset_insert [DecidableEq α] (s : Finset α) (a : α) :
    powerset (insert a s) = s.powerset ∪ s.powerset.image (insert a) 
Arguments: {α : Type u_1} [DecidableEq α] (s : Finset α) (a : α)
Goal: (insert a s).powerset = s.powerset ∪ Finset.image (insert a) s.powerset