ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- Fintype.prod_pi_mulSingle
@[to_additive "See also `Finset.sum_pi_single`."]
lemma prod_pi_mulSingle {α : ι → Type*} [∀ i, CommMonoid (α i)] (i : ι) (f : ∀ i, α i) :
    ∏ j, Pi.mulSingle j (f j) i = f i 
Arguments: {ι : Type u_6} [Fintype ι] [DecidableEq ι] {α : ι → Type u_9} [(i : ι) → CommMonoid (α i)] (i : ι) (f : (i : ι) → α i)
Goal: ∏ j : ι, Pi.mulSingle j (f j) i = f i
-- Fintype.sum_pi_single
@[to_additive "See also `Finset.sum_pi_single`."]
lemma prod_pi_mulSingle {α : ι → Type*} [∀ i, CommMonoid (α i)] (i : ι) (f : ∀ i, α i) :
    ∏ j, Pi.mulSingle j (f j) i = f i 
Arguments: {ι : Type u_6} [Fintype ι] [DecidableEq ι] {α : ι → Type u_9} [(i : ι) → AddCommMonoid (α i)] (i : ι) (f : (i : ι) → α i)
Goal: ∑ j : ι, Pi.single j (f j) i = f i
-- Fintype.sum_pi_single'
@[to_additive "See also `Finset.sum_pi_single'`."]
lemma prod_pi_mulSingle' (i : ι) (a : α) : ∏ j, Pi.mulSingle i a j = a 
Arguments: {ι : Type u_6} {α : Type u_8} [Fintype ι] [AddCommMonoid α] [DecidableEq ι] (i : ι) (a : α)
Goal: ∑ j : ι, Pi.single i a j = a
-- Fintype.prod_pi_mulSingle'
@[to_additive "See also `Finset.sum_pi_single'`."]
lemma prod_pi_mulSingle' (i : ι) (a : α) : ∏ j, Pi.mulSingle i a j = a 
Arguments: {ι : Type u_6} {α : Type u_8} [Fintype ι] [CommMonoid α] [DecidableEq ι] (i : ι) (a : α)
Goal: ∏ j : ι, Pi.mulSingle i a j = a
-- Finset.prod_attach_univ
@[to_additive (attr := simp)]
lemma prod_attach_univ [Fintype ι] (f : {i // i ∈ @univ ι _} → α) :
    ∏ i ∈ univ.attach, f i = ∏ i, f ⟨i, mem_univ _⟩ 
Arguments: {ι : Type u_1} {α : Type u_3} [CommMonoid α] [Fintype ι] (f : { i // i ∈ Finset.univ } → α)
Goal: ∏ i ∈ Finset.univ.attach, f i = ∏ i : ι, f ⟨i, ⋯⟩
-- Finset.sum_attach_univ
@[to_additive (attr := simp)]
lemma prod_attach_univ [Fintype ι] (f : {i // i ∈ @univ ι _} → α) :
    ∏ i ∈ univ.attach, f i = ∏ i, f ⟨i, mem_univ _⟩ 
Arguments: {ι : Type u_1} {α : Type u_3} [AddCommMonoid α] [Fintype ι] (f : { i // i ∈ Finset.univ } → α)
Goal: ∑ i ∈ Finset.univ.attach, f i = ∑ i : ι, f ⟨i, ⋯⟩
-- Finset.prod_erase_attach
@[to_additive]
theorem prod_erase_attach [DecidableEq ι] {s : Finset ι} (f : ι → α) (i : ↑s) :
    ∏ j ∈ s.attach.erase i, f ↑j = ∏ j ∈ s.erase ↑i, f j 
Arguments: {ι : Type u_1} {α : Type u_3} [CommMonoid α] [DecidableEq ι] {s : Finset ι} (f : ι → α) (i : { x // x ∈ s })
Goal: ∏ j ∈ s.attach.erase i, f ↑j = ∏ j ∈ s.erase ↑i, f j
-- Finset.sum_erase_attach
@[to_additive]
theorem prod_erase_attach [DecidableEq ι] {s : Finset ι} (f : ι → α) (i : ↑s) :
    ∏ j ∈ s.attach.erase i, f ↑j = ∏ j ∈ s.erase ↑i, f j 
Arguments: {ι : Type u_1} {α : Type u_3} [AddCommMonoid α] [DecidableEq ι] {s : Finset ι} (f : ι → α) (i : { x // x ∈ s })
Goal: ∑ j ∈ s.attach.erase i, f ↑j = ∑ j ∈ s.erase ↑i, f j
-- List.sum_toFinset
@[to_additive]
theorem prod_toFinset {M : Type*} [DecidableEq α] [CommMonoid M] (f : α → M) :
    ∀ {l : List α} (_hl : l.Nodup), l.toFinset.prod f = (l.map f).prod
  
Arguments: {α : Type u_3} {M : Type u_6} [DecidableEq α] [AddCommMonoid M] (f : α → M) {l : List α} (_hl : l.Nodup)
Goal: l.toFinset.sum f = (List.map f l).sum
-- List.prod_toFinset
@[to_additive]
theorem prod_toFinset {M : Type*} [DecidableEq α] [CommMonoid M] (f : α → M) :
    ∀ {l : List α} (_hl : l.Nodup), l.toFinset.prod f = (l.map f).prod
  
Arguments: {α : Type u_3} {M : Type u_6} [DecidableEq α] [CommMonoid M] (f : α → M) {l : List α} (_hl : l.Nodup)
Goal: l.toFinset.prod f = (List.map f l).prod
-- List.sum_toFinset_count_eq_length
@[simp]
theorem sum_toFinset_count_eq_length [DecidableEq α] (l : List α) :
    ∑ a in l.toFinset, l.count a = l.length 
Arguments: {α : Type u_3} [DecidableEq α] (l : List α)
Goal: ∑ a ∈ l.toFinset, List.count a l = l.length
-- Multiset.disjoint_list_sum_left
theorem disjoint_list_sum_left {a : Multiset α} {l : List (Multiset α)} :
    Multiset.Disjoint l.sum a ↔ ∀ b ∈ l, Multiset.Disjoint b a 
Arguments: {α : Type u_3} {a : Multiset α} {l : List (Multiset α)}
Goal: l.sum.Disjoint a ↔ ∀ b ∈ l, b.Disjoint a
-- Multiset.disjoint_list_sum_right
theorem disjoint_list_sum_right {a : Multiset α} {l : List (Multiset α)} :
    Multiset.Disjoint a l.sum ↔ ∀ b ∈ l, Multiset.Disjoint a b 
Arguments: {α : Type u_3} {a : Multiset α} {l : List (Multiset α)}
Goal: a.Disjoint l.sum ↔ ∀ b ∈ l, a.Disjoint b
-- Multiset.disjoint_sum_left
theorem disjoint_sum_left {a : Multiset α} {i : Multiset (Multiset α)} :
    Multiset.Disjoint i.sum a ↔ ∀ b ∈ i, Multiset.Disjoint b a 
Arguments: {α : Type u_3} {a : Multiset α} {i : Multiset (Multiset α)}
Goal: i.sum.Disjoint a ↔ ∀ b ∈ i, b.Disjoint a
-- Multiset.disjoint_sum_right
theorem disjoint_sum_right {a : Multiset α} {i : Multiset (Multiset α)} :
    Multiset.Disjoint a i.sum ↔ ∀ b ∈ i, Multiset.Disjoint a b 
Arguments: {α : Type u_3} {a : Multiset α} {i : Multiset (Multiset α)}
Goal: a.Disjoint i.sum ↔ ∀ b ∈ i, a.Disjoint b
-- Multiset.disjoint_finset_sum_left
theorem disjoint_finset_sum_left {β : Type*} {i : Finset β} {f : β → Multiset α} {a : Multiset α} :
    Multiset.Disjoint (i.sum f) a ↔ ∀ b ∈ i, Multiset.Disjoint (f b) a 
Arguments: {α : Type u_3} {β : Type u_6} {i : Finset β} {f : β → Multiset α} {a : Multiset α}
Goal: (i.sum f).Disjoint a ↔ ∀ b ∈ i, (f b).Disjoint a
-- Multiset.disjoint_finset_sum_right
theorem disjoint_finset_sum_right {β : Type*} {i : Finset β} {f : β → Multiset α}
    {a : Multiset α} : Multiset.Disjoint a (i.sum f) ↔ ∀ b ∈ i, Multiset.Disjoint a (f b) 
Arguments: {α : Type u_3} {β : Type u_6} {i : Finset β} {f : β → Multiset α} {a : Multiset α}
Goal: a.Disjoint (i.sum f) ↔ ∀ b ∈ i, a.Disjoint (f b)
-- Multiset.mem_sum
@[simp]
lemma mem_sum {s : Finset ι} {m : ι → Multiset α} : a ∈ ∑ i ∈ s, m i ↔ ∃ i ∈ s, a ∈ m i 
Arguments: {ι : Type u_1} {α : Type u_3} {a : α} {s : Finset ι} {m : ι → Multiset α}
Goal: a ∈ ∑ i ∈ s, m i ↔ ∃ i ∈ s, a ∈ m i
-- Multiset.toFinset_sum_count_eq
theorem toFinset_sum_count_eq (s : Multiset α) : ∑ a in s.toFinset, s.count a = card s 
Arguments: {α : Type u_3} [DecidableEq α] (s : Multiset α)
Goal: ∑ a ∈ s.toFinset, Multiset.count a s = Multiset.card s
-- Multiset.sum_count_eq_card
@[simp] lemma sum_count_eq_card {s : Finset α} {m : Multiset α} (hms : ∀ a ∈ m, a ∈ s) :
    ∑ a ∈ s, m.count a = card m 
Arguments: {α : Type u_3} [DecidableEq α] {s : Finset α} {m : Multiset α} (hms : ∀ a ∈ m, a ∈ s)
Goal: ∑ a ∈ s, Multiset.count a m = Multiset.card m
-- Multiset.sum_count_eq
@[deprecated sum_count_eq_card (since := "2024-07-21")]
theorem sum_count_eq [Fintype α] (s : Multiset α) : ∑ a, s.count a = Multiset.card s 
Arguments: {α : Type u_3} [DecidableEq α] [Fintype α] (s : Multiset α)
Goal: ∑ a : α, Multiset.count a s = Multiset.card s
-- Multiset.count_sum'
theorem count_sum' {s : Finset β} {a : α} {f : β → Multiset α} :
    count a (∑ x ∈ s, f x) = ∑ x ∈ s, count a (f x) 
Arguments: {α : Type u_3} {β : Type u_4} [DecidableEq α] {s : Finset β} {a : α} {f : β → Multiset α}
Goal: Multiset.count a (∑ x ∈ s, f x) = ∑ x ∈ s, Multiset.count a (f x)
-- Multiset.toFinset_sum_count_nsmul_eq
@[simp]
theorem toFinset_sum_count_nsmul_eq (s : Multiset α) :
    ∑ a ∈ s.toFinset, s.count a • {a} = s 
Arguments: {α : Type u_3} [DecidableEq α] (s : Multiset α)
Goal: ∑ a ∈ s.toFinset, Multiset.count a s • {a} = s
-- Multiset.exists_smul_of_dvd_count
theorem exists_smul_of_dvd_count (s : Multiset α) {k : ℕ}
    (h : ∀ a : α, a ∈ s → k ∣ Multiset.count a s) : ∃ u : Multiset α, s = k • u 
Arguments: {α : Type u_3} [DecidableEq α] (s : Multiset α) {k : ℕ} (h : ∀ a ∈ s, k ∣ Multiset.count a s)
Goal: ∃ u, s = k • u
-- Multiset.toFinset_prod_dvd_prod
theorem toFinset_prod_dvd_prod [CommMonoid α] (S : Multiset α) : S.toFinset.prod id ∣ S.prod 
Arguments: {α : Type u_3} [DecidableEq α] [CommMonoid α] (S : Multiset α)
Goal: S.toFinset.prod id ∣ S.prod
-- Multiset.prod_sum
@[to_additive]
theorem prod_sum {α : Type*} {ι : Type*} [CommMonoid α] (f : ι → Multiset α) (s : Finset ι) :
    (∑ x ∈ s, f x).prod = ∏ x ∈ s, (f x).prod 
Arguments: {α : Type u_6} {ι : Type u_7} [CommMonoid α] (f : ι → Multiset α) (s : Finset ι)
Goal: (∑ x ∈ s, f x).prod = ∏ x ∈ s, (f x).prod
-- Multiset.sum_sum
@[to_additive]
theorem prod_sum {α : Type*} {ι : Type*} [CommMonoid α] (f : ι → Multiset α) (s : Finset ι) :
    (∑ x ∈ s, f x).prod = ∏ x ∈ s, (f x).prod 
Arguments: {α : Type u_6} {ι : Type u_7} [AddCommMonoid α] (f : ι → Multiset α) (s : Finset ι)
Goal: (∑ x ∈ s, f x).sum = ∑ x ∈ s, (f x).sum
-- Units.coe_prod
@[simp, norm_cast]
theorem Units.coe_prod {M : Type*} [CommMonoid M] (f : α → Mˣ) (s : Finset α) :
    (↑(∏ i ∈ s, f i) : M) = ∏ i ∈ s, (f i : M) 
Arguments: {α : Type u_3} {M : Type u_6} [CommMonoid M] (f : α → Mˣ) (s : Finset α)
Goal: ↑(∏ i ∈ s, f i) = ∏ i ∈ s, ↑(f i)
-- nat_abs_sum_le
theorem nat_abs_sum_le {ι : Type*} (s : Finset ι) (f : ι → ℤ) :
    (∑ i ∈ s, f i).natAbs ≤ ∑ i ∈ s, (f i).natAbs 
Arguments: {ι : Type u_6} (s : Finset ι) (f : ι → ℤ)
Goal: (∑ i ∈ s, f i).natAbs ≤ ∑ i ∈ s, (f i).natAbs
-- ofMul_list_prod
@[simp]
theorem ofMul_list_prod (s : List α) : ofMul s.prod = (s.map ofMul).sum 
Arguments: {α : Type u_3} [Monoid α] (s : List α)
Goal: Additive.ofMul s.prod = (List.map (⇑Additive.ofMul) s).sum
-- toMul_list_sum
@[simp]
theorem toMul_list_sum (s : List (Additive α)) : toMul s.sum = (s.map toMul).prod 
Arguments: {α : Type u_3} [Monoid α] (s : List (Additive α))
Goal: Additive.toMul s.sum = (List.map (⇑Additive.toMul) s).prod
-- ofAdd_list_prod
@[simp]
theorem ofAdd_list_prod (s : List α) : ofAdd s.sum = (s.map ofAdd).prod 
Arguments: {α : Type u_3} [AddMonoid α] (s : List α)
Goal: Multiplicative.ofAdd s.sum = (List.map (⇑Multiplicative.ofAdd) s).prod
-- toAdd_list_sum
@[simp]
theorem toAdd_list_sum (s : List (Multiplicative α)) : toAdd s.prod = (s.map toAdd).sum 
Arguments: {α : Type u_3} [AddMonoid α] (s : List (Multiplicative α))
Goal: Multiplicative.toAdd s.prod = (List.map (⇑Multiplicative.toAdd) s).sum
-- ofMul_multiset_prod
@[simp]
theorem ofMul_multiset_prod (s : Multiset α) : ofMul s.prod = (s.map ofMul).sum 
Arguments: {α : Type u_3} [CommMonoid α] (s : Multiset α)
Goal: Additive.ofMul s.prod = (Multiset.map (⇑Additive.ofMul) s).sum
-- toMul_multiset_sum
@[simp]
theorem toMul_multiset_sum (s : Multiset (Additive α)) : toMul s.sum = (s.map toMul).prod 
Arguments: {α : Type u_3} [CommMonoid α] (s : Multiset (Additive α))
Goal: Additive.toMul s.sum = (Multiset.map (⇑Additive.toMul) s).prod
-- ofMul_prod
@[simp]
theorem ofMul_prod (s : Finset ι) (f : ι → α) : ofMul (∏ i ∈ s, f i) = ∑ i ∈ s, ofMul (f i) 
Arguments: {ι : Type u_1} {α : Type u_3} [CommMonoid α] (s : Finset ι) (f : ι → α)
Goal: Additive.ofMul (∏ i ∈ s, f i) = ∑ i ∈ s, Additive.ofMul (f i)
-- toMul_sum
@[simp]
theorem toMul_sum (s : Finset ι) (f : ι → Additive α) :
    toMul (∑ i ∈ s, f i) = ∏ i ∈ s, toMul (f i) 
Arguments: {ι : Type u_1} {α : Type u_3} [CommMonoid α] (s : Finset ι) (f : ι → Additive α)
Goal: Additive.toMul (∑ i ∈ s, f i) = ∏ i ∈ s, Additive.toMul (f i)
-- ofAdd_multiset_prod
@[simp]
theorem ofAdd_multiset_prod (s : Multiset α) : ofAdd s.sum = (s.map ofAdd).prod 
Arguments: {α : Type u_3} [AddCommMonoid α] (s : Multiset α)
Goal: Multiplicative.ofAdd s.sum = (Multiset.map (⇑Multiplicative.ofAdd) s).prod
-- toAdd_multiset_sum
@[simp]
theorem toAdd_multiset_sum (s : Multiset (Multiplicative α)) :
    toAdd s.prod = (s.map toAdd).sum 
Arguments: {α : Type u_3} [AddCommMonoid α] (s : Multiset (Multiplicative α))
Goal: Multiplicative.toAdd s.prod = (Multiset.map (⇑Multiplicative.toAdd) s).sum
-- ofAdd_sum
@[simp]
theorem ofAdd_sum (s : Finset ι) (f : ι → α) : ofAdd (∑ i ∈ s, f i) = ∏ i ∈ s, ofAdd (f i) 
Arguments: {ι : Type u_1} {α : Type u_3} [AddCommMonoid α] (s : Finset ι) (f : ι → α)
Goal: Multiplicative.ofAdd (∑ i ∈ s, f i) = ∏ i ∈ s, Multiplicative.ofAdd (f i)
-- toAdd_prod
@[simp]
theorem toAdd_prod (s : Finset ι) (f : ι → Multiplicative α) :
    toAdd (∏ i ∈ s, f i) = ∑ i ∈ s, toAdd (f i) 
Arguments: {ι : Type u_1} {α : Type u_3} [AddCommMonoid α] (s : Finset ι) (f : ι → Multiplicative α)
Goal: Multiplicative.toAdd (∏ i ∈ s, f i) = ∑ i ∈ s, Multiplicative.toAdd (f i)
-- Finset.sum_sym2_filter_not_isDiag
theorem Finset.sum_sym2_filter_not_isDiag {ι α} [LinearOrder ι] [AddCommMonoid α]
    (s : Finset ι) (p : Sym2 ι → α) :
    ∑ i in s.sym2.filter (¬ ·.IsDiag), p i =
      ∑ i in s.offDiag.filter (fun i => i.1 < i.2), p s(i.1, i.2) 
Arguments: {ι : Type u_6} {α : Type u_7} [LinearOrder ι] [AddCommMonoid α] (s : Finset ι) (p : Sym2 ι → α)
Goal: ∑ i ∈ Finset.filter (fun x => ¬x.IsDiag) s.sym2, p i = ∑ i ∈ Finset.filter (fun i => i.1 < i.2) s.offDiag, p s(i.1, i.2)
-- AlgebraicGeometry.IsOpenImmersion.isOpen_range
theorem IsOpenImmersion.isOpen_range {X Y : Scheme.{u}} (f : X ⟶ Y) [H : IsOpenImmersion f] :
    IsOpen (Set.range f.1.base) 
Arguments: {X Y : AlgebraicGeometry.Scheme} (f : X ⟶ Y) [H : AlgebraicGeometry.IsOpenImmersion f]
Goal: IsOpen (Set.range ⇑f.val.base)
-- AlgebraicGeometry.Scheme.Hom.openEmbedding
theorem openEmbedding : OpenEmbedding f.1.base 
Arguments: {X Y : AlgebraicGeometry.Scheme} (f : X.Hom Y) [H : AlgebraicGeometry.IsOpenImmersion f]
Goal: OpenEmbedding ⇑f.val.base
-- AlgebraicGeometry.Scheme.Hom.opensRange_coe
@[simps]
def opensRange : Y.Opens 
Arguments: {X Y : AlgebraicGeometry.Scheme} (f : X.Hom Y) [H : AlgebraicGeometry.IsOpenImmersion f]
Goal: ↑f.opensRange = Set.range ⇑f.val.base
-- AlgebraicGeometry.Scheme.Hom.image_le_image_of_le
lemma image_le_image_of_le {U V : X.Opens} (e : U ≤ V) : f ''ᵁ U ≤ f ''ᵁ V 
Arguments: {X Y : AlgebraicGeometry.Scheme} (f : X.Hom Y) [H : AlgebraicGeometry.IsOpenImmersion f] {U V : X.Opens} (e : U ≤ V)
Goal: f.opensFunctor.obj U ≤ f.opensFunctor.obj V
-- AlgebraicGeometry.Scheme.Hom.opensFunctor_map_homOfLE
@[simp]
lemma opensFunctor_map_homOfLE {U V : X.Opens} (e : U ≤ V) :
    (Scheme.Hom.opensFunctor f).map (homOfLE e) = homOfLE (f.image_le_image_of_le e) 
Arguments: {X Y : AlgebraicGeometry.Scheme} (f : X.Hom Y) [H : AlgebraicGeometry.IsOpenImmersion f] {U V : X.Opens} (e : U ≤ V)
Goal: f.opensFunctor.map (CategoryTheory.homOfLE e) = CategoryTheory.homOfLE ⋯
-- AlgebraicGeometry.Scheme.Hom.image_top_eq_opensRange
@[simp]
lemma image_top_eq_opensRange : f ''ᵁ ⊤ = f.opensRange 
Arguments: {X Y : AlgebraicGeometry.Scheme} (f : X.Hom Y) [H : AlgebraicGeometry.IsOpenImmersion f]
Goal: f.opensFunctor.obj ⊤ = f.opensRange
-- AlgebraicGeometry.Scheme.Hom.preimage_image_eq
@[simp]
lemma preimage_image_eq (U : X.Opens) : f ⁻¹ᵁ f ''ᵁ U = U 
Arguments: {X Y : AlgebraicGeometry.Scheme} (f : X.Hom Y) [H : AlgebraicGeometry.IsOpenImmersion f] (U : X.Opens)
Goal: (TopologicalSpace.Opens.map f.val.base).obj (f.opensFunctor.obj U) = U
-- AlgebraicGeometry.Scheme.Hom.image_preimage_eq_opensRange_inter
lemma image_preimage_eq_opensRange_inter (U : Y.Opens) : f ''ᵁ f ⁻¹ᵁ U = f.opensRange ⊓ U 
Arguments: {X Y : AlgebraicGeometry.Scheme} (f : X.Hom Y) [H : AlgebraicGeometry.IsOpenImmersion f] (U : Y.Opens)
Goal: f.opensFunctor.obj ((TopologicalSpace.Opens.map f.val.base).obj U) = f.opensRange ⊓ U
-- AlgebraicGeometry.Scheme.Hom.appIso_inv_naturality
@[reassoc (attr := simp)]
theorem appIso_inv_naturality {U V : X.Opens} (i : op U ⟶ op V) :
    X.presheaf.map i ≫ (f.appIso V).inv =
      (f.appIso U).inv ≫ Y.presheaf.map (f.opensFunctor.op.map i) 
Arguments: {X Y : AlgebraicGeometry.Scheme} (f : X.Hom Y) [H : AlgebraicGeometry.IsOpenImmersion f] {U V : X.Opens} (i : Opposite.op U ⟶ Opposite.op V)
Goal: X.presheaf.map i ≫ (f.appIso V).inv = (f.appIso U).inv ≫ Y.presheaf.map (f.opensFunctor.op.map i)
-- AlgebraicGeometry.Scheme.Hom.appIso_hom
theorem appIso_hom (U) :
    (f.appIso U).hom = f.app (f ''ᵁ U) ≫ X.presheaf.map
      (eqToHom (preimage_image_eq f U).symm).op 
Arguments: {X Y : AlgebraicGeometry.Scheme} (f : X.Hom Y) [H : AlgebraicGeometry.IsOpenImmersion f] (U : X.Opens)
Goal: (f.appIso U).hom = f.app (f.opensFunctor.obj U) ≫ X.presheaf.map (CategoryTheory.eqToHom ⋯).op
-- AlgebraicGeometry.Scheme.Hom.appIso_hom'
theorem appIso_hom' (U) :
    (f.appIso U).hom = f.appLE (f ''ᵁ U) U (preimage_image_eq f U).ge 
Arguments: {X Y : AlgebraicGeometry.Scheme} (f : X.Hom Y) [H : AlgebraicGeometry.IsOpenImmersion f] (U : X.Opens)
Goal: (f.appIso U).hom = f.appLE (f.opensFunctor.obj U) U ⋯
-- AlgebraicGeometry.Scheme.Hom.app_appIso_inv
@[reassoc (attr := simp)]
theorem app_appIso_inv (U) :
    f.app U ≫ (f.appIso (f ⁻¹ᵁ U)).inv =
      Y.presheaf.map (homOfLE (Set.image_preimage_subset f.1.base U.1)).op 
Arguments: {X Y : AlgebraicGeometry.Scheme} (f : X.Hom Y) [H : AlgebraicGeometry.IsOpenImmersion f] (U : Y.Opens)
Goal: f.app U ≫ (f.appIso ((TopologicalSpace.Opens.map f.val.base).obj U)).inv = Y.presheaf.map (CategoryTheory.homOfLE ⋯).op
-- AlgebraicGeometry.Scheme.Hom.app_invApp'
@[reassoc]
theorem app_invApp' (U) (hU : U ≤ f.opensRange) :
    f.app U ≫ (f.appIso (f ⁻¹ᵁ U)).inv =
      Y.presheaf.map (eqToHom (Opens.ext <| by simpa [Set.image_preimage_eq_inter_range])).op 
Arguments: {X Y : AlgebraicGeometry.Scheme} (f : X.Hom Y) [H : AlgebraicGeometry.IsOpenImmersion f] (U : Y.Opens) (hU : U ≤ f.opensRange)
Goal: f.app U ≫ (f.appIso ((TopologicalSpace.Opens.map f.val.base).obj U)).inv = Y.presheaf.map (CategoryTheory.eqToHom ⋯).op
-- AlgebraicGeometry.Scheme.Hom.appIso_inv_app
@[reassoc (attr := simp), elementwise (attr := simp)]
theorem appIso_inv_app (U) :
    (f.appIso U).inv ≫ f.app (f ''ᵁ U) = X.presheaf.map (eqToHom (preimage_image_eq f U)).op 
Arguments: {X Y : AlgebraicGeometry.Scheme} (f : X.Hom Y) [H : AlgebraicGeometry.IsOpenImmersion f] (U : X.Opens)
Goal: (f.appIso U).inv ≫ f.app (f.opensFunctor.obj U) = X.presheaf.map (CategoryTheory.eqToHom ⋯).op
-- AlgebraicGeometry.Scheme.Hom.appLE_appIso_inv
@[reassoc (attr := simp), elementwise]
lemma appLE_appIso_inv {X Y : Scheme.{u}} (f : X ⟶ Y) [IsOpenImmersion f] {U : Y.Opens}
    {V : X.Opens} (e : V ≤ f ⁻¹ᵁ U) :
    f.appLE U V e ≫ (f.appIso V).inv =
        Y.presheaf.map (homOfLE <| (f.image_le_image_of_le e).trans
          (f.image_preimage_eq_opensRange_inter U ▸ inf_le_right)).op 
Arguments: {X Y : AlgebraicGeometry.Scheme} (f : X ⟶ Y) [AlgebraicGeometry.IsOpenImmersion f] {U : Y.Opens} {V : X.Opens} (e : V ≤ (TopologicalSpace.Opens.map f.val.base).obj U)
Goal: AlgebraicGeometry.Scheme.Hom.appLE f U V e ≫ (AlgebraicGeometry.Scheme.Hom.appIso f V).inv =
  Y.presheaf.map (CategoryTheory.homOfLE ⋯).op
-- AlgebraicGeometry.Scheme.Hom.appIso_inv_appLE
@[reassoc (attr := simp)]
lemma appIso_inv_appLE {X Y : Scheme.{u}} (f : X ⟶ Y) [IsOpenImmersion f] {U V : X.Opens}
    (e : V ≤ f ⁻¹ᵁ f ''ᵁ U) :
    (f.appIso U).inv ≫ f.appLE (f ''ᵁ U) V e =
        X.presheaf.map (homOfLE (by rwa [preimage_image_eq] at e)).op 
Arguments: {X Y : AlgebraicGeometry.Scheme} (f : X ⟶ Y) [AlgebraicGeometry.IsOpenImmersion f] {U V : X.Opens} (e : V ≤ (TopologicalSpace.Opens.map f.val.base).obj ((AlgebraicGeometry.Scheme.Hom.opensFunctor f).obj U))
Goal: (AlgebraicGeometry.Scheme.Hom.appIso f U).inv ≫
    AlgebraicGeometry.Scheme.Hom.appLE f ((AlgebraicGeometry.Scheme.Hom.opensFunctor f).obj U) V e =
  X.presheaf.map (CategoryTheory.homOfLE ⋯).op
-- AlgebraicGeometry.IsOpenImmersion.opensEquiv_symm_apply
@[simps]
def IsOpenImmersion.opensEquiv {X Y : Scheme.{u}} (f : X ⟶ Y) [IsOpenImmersion f] :
    X.Opens ≃ { U : Y.Opens // U ≤ f.opensRange } 
Arguments: {X Y : AlgebraicGeometry.Scheme} (f : X ⟶ Y) [AlgebraicGeometry.IsOpenImmersion f] (U : { U // U ≤ AlgebraicGeometry.Scheme.Hom.opensRange f })
Goal: (AlgebraicGeometry.IsOpenImmersion.opensEquiv f).symm U = (TopologicalSpace.Opens.map f.val.base).obj ↑U
-- AlgebraicGeometry.IsOpenImmersion.opensEquiv_apply_coe
@[simps]
def IsOpenImmersion.opensEquiv {X Y : Scheme.{u}} (f : X ⟶ Y) [IsOpenImmersion f] :
    X.Opens ≃ { U : Y.Opens // U ≤ f.opensRange } 
Arguments: {X Y : AlgebraicGeometry.Scheme} (f : X ⟶ Y) [AlgebraicGeometry.IsOpenImmersion f] (U : X.Opens)
Goal: ↑((AlgebraicGeometry.IsOpenImmersion.opensEquiv f) U) = (AlgebraicGeometry.Scheme.Hom.opensFunctor f).obj U
-- AlgebraicGeometry.Scheme.IsOpenImmersion.of_isLocalization
lemma IsOpenImmersion.of_isLocalization {R S} [CommRing R] [CommRing S]
    [Algebra R S] (f : R) [IsLocalization.Away f S] :
    IsOpenImmersion (Spec.map (CommRingCat.ofHom (algebraMap R S))) 
Arguments: {R S : Type u_1} [CommRing R] [CommRing S] [Algebra R S] (f : R) [IsLocalization.Away f S]
Goal: AlgebraicGeometry.IsOpenImmersion (AlgebraicGeometry.Spec.map (CommRingCat.ofHom (algebraMap R S)))
-- AlgebraicGeometry.Scheme.exists_affine_mem_range_and_range_subset
theorem exists_affine_mem_range_and_range_subset
    {X : Scheme.{u}} {x : X} {U : X.Opens} (hxU : x ∈ U) :
    ∃ (R : CommRingCat) (f : Spec R ⟶ X),
      IsOpenImmersion f ∧ x ∈ Set.range f.1.base ∧ Set.range f.1.base ⊆ U 
Arguments: {X : AlgebraicGeometry.Scheme} {x : ↑↑X.toPresheafedSpace} {U : X.Opens} (hxU : x ∈ U)
Goal: ∃ R f, AlgebraicGeometry.IsOpenImmersion f ∧ x ∈ Set.range ⇑f.val.base ∧ Set.range ⇑f.val.base ⊆ ↑U
-- AlgebraicGeometry.PresheafedSpace.IsOpenImmersion.toScheme_toLocallyRingedSpace
@[simp]
theorem toScheme_toLocallyRingedSpace :
    (toScheme Y f).toLocallyRingedSpace = toLocallyRingedSpace Y.1 f 
Arguments: {X : AlgebraicGeometry.PresheafedSpace CommRingCat} (Y : AlgebraicGeometry.Scheme) (f : X ⟶ Y.toPresheafedSpace) [H : AlgebraicGeometry.PresheafedSpace.IsOpenImmersion f]
Goal: (AlgebraicGeometry.PresheafedSpace.IsOpenImmersion.toScheme Y f).toLocallyRingedSpace =
  AlgebraicGeometry.PresheafedSpace.IsOpenImmersion.toLocallyRingedSpace Y.toLocallyRingedSpace f
-- AlgebraicGeometry.PresheafedSpace.IsOpenImmersion.toSchemeHom_val
@[simp]
theorem toSchemeHom_val : (toSchemeHom Y f).val = f 
Arguments: {X : AlgebraicGeometry.PresheafedSpace CommRingCat} (Y : AlgebraicGeometry.Scheme) (f : X ⟶ Y.toPresheafedSpace) [H : AlgebraicGeometry.PresheafedSpace.IsOpenImmersion f]
Goal: (AlgebraicGeometry.PresheafedSpace.IsOpenImmersion.toSchemeHom Y f).val = f
-- AlgebraicGeometry.PresheafedSpace.IsOpenImmersion.scheme_eq_of_locallyRingedSpace_eq
theorem scheme_eq_of_locallyRingedSpace_eq {X Y : Scheme.{u}}
    (H : X.toLocallyRingedSpace = Y.toLocallyRingedSpace) : X = Y 
Arguments: {X Y : AlgebraicGeometry.Scheme} (H : X.toLocallyRingedSpace = Y.toLocallyRingedSpace)
Goal: X = Y
-- AlgebraicGeometry.PresheafedSpace.IsOpenImmersion.scheme_toScheme
theorem scheme_toScheme {X Y : Scheme.{u}} (f : X ⟶ Y) [AlgebraicGeometry.IsOpenImmersion f] :
    toScheme Y f.1 = X 
Arguments: {X Y : AlgebraicGeometry.Scheme} (f : X ⟶ Y) [AlgebraicGeometry.IsOpenImmersion f]
Goal: AlgebraicGeometry.PresheafedSpace.IsOpenImmersion.toScheme Y f.val = X
-- AlgebraicGeometry.Scheme.restrict_presheaf_obj
@[simps! (config := .lemmasOnly) carrier, simps! presheaf_obj]
def Scheme.restrict : Scheme 
Arguments: {U : TopCat} (X : AlgebraicGeometry.Scheme) {f : U ⟶ TopCat.of ↑↑X.toPresheafedSpace} (h : OpenEmbedding ⇑f)
Goal: ∀ (X_1 : (TopologicalSpace.Opens ↑U)ᵒᵖ),
  (X.restrict h).presheaf.obj X_1 = X.presheaf.obj (Opposite.op (⋯.functor.obj (Opposite.unop X_1)))
-- AlgebraicGeometry.Scheme.restrict_carrier
@[simps! (config := .lemmasOnly) carrier, simps! presheaf_obj]
def Scheme.restrict : Scheme 
Arguments: {U : TopCat} (X : AlgebraicGeometry.Scheme) {f : U ⟶ TopCat.of ↑↑X.toPresheafedSpace} (h : OpenEmbedding ⇑f)
Goal: ↑(X.restrict h).toPresheafedSpace = U
-- AlgebraicGeometry.Scheme.restrict_toPresheafedSpace
lemma Scheme.restrict_toPresheafedSpace :
    (X.restrict h).toPresheafedSpace = X.toPresheafedSpace.restrict h 
Arguments: {U : TopCat} (X : AlgebraicGeometry.Scheme) {f : U ⟶ TopCat.of ↑↑X.toPresheafedSpace} (h : OpenEmbedding ⇑f)
Goal: (X.restrict h).toPresheafedSpace = X.restrict h
-- AlgebraicGeometry.Scheme.ofRestrict_val_base
@[simps! val_base, simps! (config := .lemmasOnly) val_c_app]
def Scheme.ofRestrict : X.restrict h ⟶ X 
Arguments: {U : TopCat} (X : AlgebraicGeometry.Scheme) {f : U ⟶ TopCat.of ↑↑X.toPresheafedSpace} (h : OpenEmbedding ⇑f)
Goal: (X.ofRestrict h).val.base = f
-- AlgebraicGeometry.Scheme.ofRestrict_val_c_app
@[simps! val_base, simps! (config := .lemmasOnly) val_c_app]
def Scheme.ofRestrict : X.restrict h ⟶ X 
Arguments: {U : TopCat} (X : AlgebraicGeometry.Scheme) {f : U ⟶ TopCat.of ↑↑X.toPresheafedSpace} (h : OpenEmbedding ⇑f) (V : (TopologicalSpace.Opens ↑↑X.toPresheafedSpace)ᵒᵖ)
Goal: (X.ofRestrict h).val.c.app V = X.presheaf.map (⋯.adjunction.counit.app (Opposite.unop V)).op