ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- AddSubgroup.isOpen_of_openAddSubgroup
@[to_additive]
theorem isOpen_of_openSubgroup [ContinuousMul G] (H: Subgroup G) {U : OpenSubgroup G} (h : ↑U ≤ H) :
    IsOpen (H : Set G) 
Arguments: {G : Type u_1} [AddGroup G] [TopologicalSpace G] [ContinuousAdd G] (H : AddSubgroup G) {U : OpenAddSubgroup G} (h : ↑U ≤ H)
Goal: IsOpen ↑H
-- AddSubgroup.isOpen_of_zero_mem_interior
@[to_additive "If a subgroup of an additive topological group has `0` in its interior, then it is
open."]
theorem isOpen_of_one_mem_interior [ContinuousMul G] (H: Subgroup G)
    (h_1_int : (1 : G) ∈ interior (H : Set G)) : IsOpen (H : Set G) 
Arguments: {G : Type u_1} [AddGroup G] [TopologicalSpace G] [ContinuousAdd G] (H : AddSubgroup G) (h_1_int : 0 ∈ interior ↑H)
Goal: IsOpen ↑H
-- Subgroup.isOpen_of_one_mem_interior
@[to_additive "If a subgroup of an additive topological group has `0` in its interior, then it is
open."]
theorem isOpen_of_one_mem_interior [ContinuousMul G] (H: Subgroup G)
    (h_1_int : (1 : G) ∈ interior (H : Set G)) : IsOpen (H : Set G) 
Arguments: {G : Type u_1} [Group G] [TopologicalSpace G] [ContinuousMul G] (H : Subgroup G) (h_1_int : 1 ∈ interior ↑H)
Goal: IsOpen ↑H
-- OpenAddSubgroup.toAddSubgroup_sup
@[to_additive (attr := simp, norm_cast)]
theorem toSubgroup_sup (U V : OpenSubgroup G) : (↑(U ⊔ V) : Subgroup G) = ↑U ⊔ ↑V 
Arguments: {G : Type u_1} [AddGroup G] [TopologicalSpace G] [ContinuousAdd G] (U V : OpenAddSubgroup G)
Goal: ↑(U ⊔ V) = ↑U ⊔ ↑V
-- OpenSubgroup.toSubgroup_sup
@[to_additive (attr := simp, norm_cast)]
theorem toSubgroup_sup (U V : OpenSubgroup G) : (↑(U ⊔ V) : Subgroup G) = ↑U ⊔ ↑V 
Arguments: {G : Type u_1} [Group G] [TopologicalSpace G] [ContinuousMul G] (U V : OpenSubgroup G)
Goal: ↑(U ⊔ V) = ↑U ⊔ ↑V
-- Submodule.isOpen_mono
theorem isOpen_mono {U P : Submodule R M} (h : U ≤ P) (hU : IsOpen (U : Set M)) :
    IsOpen (P : Set M) 
Arguments: {R : Type u_1} {M : Type u_2} [CommRing R] [AddCommGroup M] [TopologicalSpace M] [TopologicalAddGroup M] [Module R M] {U P : Submodule R M} (h : U ≤ P) (hU : IsOpen ↑U)
Goal: IsOpen ↑P
-- Ideal.isOpen_of_isOpen_subideal
theorem isOpen_of_isOpen_subideal {U I : Ideal R} (h : U ≤ I) (hU : IsOpen (U : Set R)) :
    IsOpen (I : Set R) 
Arguments: {R : Type u_1} [CommRing R] [TopologicalSpace R] [TopologicalRing R] {U I : Ideal R} (h : U ≤ I) (hU : IsOpen ↑U)
Goal: IsOpen ↑I
-- Profinite.NobelingProof.continuous_proj
@[simp]
theorem continuous_proj :
    Continuous (Proj J : (I → Bool) → (I → Bool)) 
Arguments: {I : Type u} (J : I → Prop) [(i : I) → Decidable (J i)]
Goal: Continuous (Profinite.NobelingProof.Proj J)
-- Profinite.NobelingProof.ProjRestrict_coe
@[simps!]
def ProjRestrict : C → π C J 
Arguments: {I : Type u} (C : Set (I → Bool)) (J : I → Prop) [(i : I) → Decidable (J i)]
Goal: ∀ (a : ↑C) (a_1 : I), ↑(Profinite.NobelingProof.ProjRestrict C J a) a_1 = Profinite.NobelingProof.Proj J (↑a) a_1
-- Profinite.NobelingProof.continuous_projRestrict
@[simp]
theorem continuous_projRestrict : Continuous (ProjRestrict C J) 
Arguments: {I : Type u} (C : Set (I → Bool)) (J : I → Prop) [(i : I) → Decidable (J i)]
Goal: Continuous (Profinite.NobelingProof.ProjRestrict C J)
-- Profinite.NobelingProof.proj_eq_self
theorem proj_eq_self {x : I → Bool} (h : ∀ i, x i ≠ false → J i) : Proj J x = x 
Arguments: {I : Type u} (J : I → Prop) [(i : I) → Decidable (J i)] {x : I → Bool} (h : ∀ (i : I), x i ≠ false → J i)
Goal: Profinite.NobelingProof.Proj J x = x
-- Profinite.NobelingProof.proj_prop_eq_self
theorem proj_prop_eq_self (hh : ∀ i x, x ∈ C → x i ≠ false → J i) : π C J = C 
Arguments: {I : Type u} (C : Set (I → Bool)) (J : I → Prop) [(i : I) → Decidable (J i)] (hh : ∀ (i : I), ∀ x ∈ C, x i ≠ false → J i)
Goal: Profinite.NobelingProof.π C J = C
-- Profinite.NobelingProof.proj_comp_of_subset
theorem proj_comp_of_subset (h : ∀ i, J i → K i) : (Proj J ∘ Proj K) =
    (Proj J : (I → Bool) → (I → Bool)) 
Arguments: {I : Type u} (J K : I → Prop) [(i : I) → Decidable (J i)] [(i : I) → Decidable (K i)] (h : ∀ (i : I), J i → K i)
Goal: Profinite.NobelingProof.Proj J ∘ Profinite.NobelingProof.Proj K = Profinite.NobelingProof.Proj J
-- Profinite.NobelingProof.proj_eq_of_subset
theorem proj_eq_of_subset (h : ∀ i, J i → K i) : π (π C K) J = π C J 
Arguments: {I : Type u} (C : Set (I → Bool)) (J K : I → Prop) [(i : I) → Decidable (J i)] [(i : I) → Decidable (K i)] (h : ∀ (i : I), J i → K i)
Goal: Profinite.NobelingProof.π (Profinite.NobelingProof.π C K) J = Profinite.NobelingProof.π C J
-- Profinite.NobelingProof.ProjRestricts_coe
@[simps!]
def ProjRestricts (h : ∀ i, J i → K i) : π C K → π C J 
Arguments: {I : Type u} (C : Set (I → Bool)) {J K : I → Prop} [(i : I) → Decidable (J i)] [(i : I) → Decidable (K i)] (h : ∀ (i : I), J i → K i)
Goal: ∀ (a : ↑(Profinite.NobelingProof.π C K)) (a_1 : I),
  ↑(Profinite.NobelingProof.ProjRestricts C h a) a_1 = Profinite.NobelingProof.Proj J (↑a) a_1
-- Profinite.NobelingProof.continuous_projRestricts
@[simp]
theorem continuous_projRestricts (h : ∀ i, J i → K i) : Continuous (ProjRestricts C h) 
Arguments: {I : Type u} (C : Set (I → Bool)) {J K : I → Prop} [(i : I) → Decidable (J i)] [(i : I) → Decidable (K i)] (h : ∀ (i : I), J i → K i)
Goal: Continuous (Profinite.NobelingProof.ProjRestricts C h)
-- Profinite.NobelingProof.surjective_projRestricts
theorem surjective_projRestricts (h : ∀ i, J i → K i) : Function.Surjective (ProjRestricts C h) 
Arguments: {I : Type u} (C : Set (I → Bool)) {J K : I → Prop} [(i : I) → Decidable (J i)] [(i : I) → Decidable (K i)] (h : ∀ (i : I), J i → K i)
Goal: Function.Surjective (Profinite.NobelingProof.ProjRestricts C h)
-- Profinite.NobelingProof.projRestricts_eq_id
theorem projRestricts_eq_id : ProjRestricts C (fun i (h : J i) ↦ h) = id 
Arguments: {I : Type u} (C : Set (I → Bool)) (J : I → Prop) [(i : I) → Decidable (J i)]
Goal: Profinite.NobelingProof.ProjRestricts C ⋯ = id
-- Profinite.NobelingProof.projRestricts_eq_comp
theorem projRestricts_eq_comp (hJK : ∀ i, J i → K i) (hKL : ∀ i, K i → L i) :
    ProjRestricts C hJK ∘ ProjRestricts C hKL = ProjRestricts C (fun i ↦ hKL i ∘ hJK i) 
Arguments: {I : Type u} (C : Set (I → Bool)) {J K L : I → Prop} [(i : I) → Decidable (J i)] [(i : I) → Decidable (K i)] [(i : I) → Decidable (L i)] (hJK : ∀ (i : I), J i → K i) (hKL : ∀ (i : I), K i → L i)
Goal: Profinite.NobelingProof.ProjRestricts C hJK ∘ Profinite.NobelingProof.ProjRestricts C hKL =
  Profinite.NobelingProof.ProjRestricts C ⋯
-- Profinite.NobelingProof.projRestricts_comp_projRestrict
theorem projRestricts_comp_projRestrict (h : ∀ i, J i → K i) :
    ProjRestricts C h ∘ ProjRestrict C K = ProjRestrict C J 
Arguments: {I : Type u} (C : Set (I → Bool)) {J K : I → Prop} [(i : I) → Decidable (J i)] [(i : I) → Decidable (K i)] (h : ∀ (i : I), J i → K i)
Goal: Profinite.NobelingProof.ProjRestricts C h ∘ Profinite.NobelingProof.ProjRestrict C K =
  Profinite.NobelingProof.ProjRestrict C J
-- Profinite.NobelingProof.iso_map_bijective
lemma iso_map_bijective : Function.Bijective (iso_map C J) 
Arguments: {I : Type u} (C : Set (I → Bool)) (J : I → Prop) [(i : I) → Decidable (J i)]
Goal: Function.Bijective ⇑(Profinite.NobelingProof.iso_map C J)
-- Profinite.NobelingProof.Products.lt_iff_lex_lt
@[simp]
theorem lt_iff_lex_lt (l m : Products I) : l < m ↔ List.Lex (·<·) l.val m.val 
Arguments: {I : Type u} [LinearOrder I] (l m : Profinite.NobelingProof.Products I)
Goal: l < m ↔ List.Lex (fun x x_1 => x < x_1) ↑l ↑m
-- Profinite.NobelingProof.Products.rel_head!_of_mem
theorem rel_head!_of_mem [Inhabited I] {i : I} {l : Products I} (hi : i ∈ l.val) :
    i ≤ l.val.head! 
Arguments: {I : Type u} [LinearOrder I] [Inhabited I] {i : I} {l : Profinite.NobelingProof.Products I} (hi : i ∈ ↑l)
Goal: i ≤ (↑l).head!
-- Profinite.NobelingProof.Products.head!_le_of_lt
theorem head!_le_of_lt [Inhabited I] {q l : Products I} (h : q < l) (hq : q.val ≠ []) :
    q.val.head! ≤ l.val.head! 
Arguments: {I : Type u} [LinearOrder I] [Inhabited I] {q l : Profinite.NobelingProof.Products I} (h : q < l) (hq : ↑q ≠ [])
Goal: (↑q).head! ≤ (↑l).head!
-- Profinite.NobelingProof.GoodProducts.injective
theorem injective : Function.Injective (eval C) 
Arguments: {I : Type u} [LinearOrder I] (C : Set (I → Bool))
Goal: Function.Injective (Profinite.NobelingProof.GoodProducts.eval C)
-- Profinite.NobelingProof.GoodProducts.equiv_toFun_eq_eval
theorem equiv_toFun_eq_eval : (equiv_range C).toFun = Set.rangeFactorization (eval C) 
Arguments: {I : Type u} [LinearOrder I] (C : Set (I → Bool))
Goal: (Profinite.NobelingProof.GoodProducts.equiv_range C).toFun =
  Set.rangeFactorization (Profinite.NobelingProof.GoodProducts.eval C)
-- Profinite.NobelingProof.GoodProducts.linearIndependent_iff_range
theorem linearIndependent_iff_range : LinearIndependent ℤ (GoodProducts.eval C) ↔
    LinearIndependent ℤ (fun (p : range C) ↦ p.1) 
Arguments: {I : Type u} [LinearOrder I] (C : Set (I → Bool))
Goal: LinearIndependent ℤ (Profinite.NobelingProof.GoodProducts.eval C) ↔
  LinearIndependent ℤ fun (p : ↑(Profinite.NobelingProof.GoodProducts.range C)) => ↑p
-- Profinite.NobelingProof.Products.eval_eq
theorem eval_eq (l : Products I) (x : C) :
    l.eval C x = if ∀ i, i ∈ l.val → (x.val i = true) then 1 else 0 
Arguments: {I : Type u} [LinearOrder I] (C : Set (I → Bool)) (l : Profinite.NobelingProof.Products I) (x : ↑C)
Goal: (Profinite.NobelingProof.Products.eval C l) x = if ∀ i ∈ ↑l, ↑x i = true then 1 else 0
-- Profinite.NobelingProof.Products.evalFacProp
theorem evalFacProp {l : Products I} (J : I → Prop)
    (h : ∀ a, a ∈ l.val → J a) [∀ j, Decidable (J j)] :
    l.eval (π C J) ∘ ProjRestrict C J = l.eval C 
Arguments: {I : Type u} [LinearOrder I] (C : Set (I → Bool)) {l : Profinite.NobelingProof.Products I} (J : I → Prop) (h : ∀ a ∈ ↑l, J a) [(j : I) → Decidable (J j)]
Goal: ⇑(Profinite.NobelingProof.Products.eval (Profinite.NobelingProof.π C J) l) ∘ Profinite.NobelingProof.ProjRestrict C J =
  ⇑(Profinite.NobelingProof.Products.eval C l)
-- Profinite.NobelingProof.Products.evalFacProps
theorem evalFacProps {l : Products I} (J K : I → Prop)
    (h : ∀ a, a ∈ l.val → J a) [∀ j, Decidable (J j)] [∀ j, Decidable (K j)]
    (hJK : ∀ i, J i → K i) :
    l.eval (π C J) ∘ ProjRestricts C hJK = l.eval (π C K) 
Arguments: {I : Type u} [LinearOrder I] (C : Set (I → Bool)) {l : Profinite.NobelingProof.Products I} (J K : I → Prop) (h : ∀ a ∈ ↑l, J a) [(j : I) → Decidable (J j)] [(j : I) → Decidable (K j)] (hJK : ∀ (i : I), J i → K i)
Goal: ⇑(Profinite.NobelingProof.Products.eval (Profinite.NobelingProof.π C J) l) ∘
    Profinite.NobelingProof.ProjRestricts C hJK =
  ⇑(Profinite.NobelingProof.Products.eval (Profinite.NobelingProof.π C K) l)
-- Profinite.NobelingProof.Products.prop_of_isGood
theorem prop_of_isGood  {l : Products I} (J : I → Prop) [∀ j, Decidable (J j)]
    (h : l.isGood (π C J)) : ∀ a, a ∈ l.val → J a 
Arguments: {I : Type u} [LinearOrder I] (C : Set (I → Bool)) {l : Profinite.NobelingProof.Products I} (J : I → Prop) [(j : I) → Decidable (J j)] (h : Profinite.NobelingProof.Products.isGood (Profinite.NobelingProof.π C J) l) (a : I)
Goal: a ∈ ↑l → J a
-- Profinite.NobelingProof.GoodProducts.span_iff_products
theorem GoodProducts.span_iff_products : ⊤ ≤ span ℤ (Set.range (eval C)) ↔
    ⊤ ≤ span ℤ (Set.range (Products.eval C)) 
Arguments: {I : Type u} [LinearOrder I] [IsWellOrder I fun x x_1 => x < x_1] (C : Set (I → Bool))
Goal: ⊤ ≤ Submodule.span ℤ (Set.range (Profinite.NobelingProof.GoodProducts.eval C)) ↔
  ⊤ ≤ Submodule.span ℤ (Set.range (Profinite.NobelingProof.Products.eval C))
-- Profinite.NobelingProof.eval_eq_πJ
theorem eval_eq_πJ (l : Products I) (hl : l.isGood (π C (· ∈ s))) :
    l.eval C = πJ C s (l.eval (π C (· ∈ s))) 
Arguments: {I : Type u} [LinearOrder I] (C : Set (I → Bool)) (s : Finset I) (l : Profinite.NobelingProof.Products I) (hl : Profinite.NobelingProof.Products.isGood (Profinite.NobelingProof.π C fun x => x ∈ s) l)
Goal: Profinite.NobelingProof.Products.eval C l =
  (Profinite.NobelingProof.πJ C s)
    (Profinite.NobelingProof.Products.eval (Profinite.NobelingProof.π C fun x => x ∈ s) l)
-- Profinite.NobelingProof.spanFinBasis.span
theorem spanFinBasis.span : ⊤ ≤ Submodule.span ℤ (Set.range (spanFinBasis C s)) 
Arguments: {I : Type u} [LinearOrder I] (C : Set (I → Bool)) (s : Finset I)
Goal: ⊤ ≤ Submodule.span ℤ (Set.range (Profinite.NobelingProof.spanFinBasis C s))
-- Profinite.NobelingProof.list_prod_apply
theorem list_prod_apply (x : C) (l : List (LocallyConstant C ℤ)) :
    l.prod x = (l.map (LocallyConstant.evalMonoidHom x)).prod 
Arguments: {I : Type u} (C : Set (I → Bool)) (x : ↑C) (l : List (LocallyConstant ↑C ℤ))
Goal: l.prod x = (List.map (⇑(LocallyConstant.evalMonoidHom x)) l).prod
-- Profinite.NobelingProof.factors_prod_eq_basis_of_eq
theorem factors_prod_eq_basis_of_eq {x y : (π C fun x ↦ x ∈ s)} (h : y = x) :
    (factors C s x).prod y = 1 
Arguments: {I : Type u} [LinearOrder I] (C : Set (I → Bool)) (s : Finset I) {x y : ↑(Profinite.NobelingProof.π C fun x => x ∈ s)} (h : y = x)
Goal: (Profinite.NobelingProof.factors C s x).prod y = 1
-- Profinite.NobelingProof.e_mem_of_eq_true
theorem e_mem_of_eq_true {x : (π C (· ∈ s))} {a : I} (hx : x.val a = true) :
    e (π C (· ∈ s)) a ∈ factors C s x 
Arguments: {I : Type u} [LinearOrder I] (C : Set (I → Bool)) (s : Finset I) {x : ↑(Profinite.NobelingProof.π C fun x => x ∈ s)} {a : I} (hx : ↑x a = true)
Goal: Profinite.NobelingProof.e (Profinite.NobelingProof.π C fun x => x ∈ s) a ∈ Profinite.NobelingProof.factors C s x
-- Profinite.NobelingProof.one_sub_e_mem_of_false
theorem one_sub_e_mem_of_false {x y : (π C (· ∈ s))} {a : I} (ha : y.val a = true)
    (hx : x.val a = false) : 1 - e (π C (· ∈ s)) a ∈ factors C s x 
Arguments: {I : Type u} [LinearOrder I] (C : Set (I → Bool)) (s : Finset I) {x y : ↑(Profinite.NobelingProof.π C fun x => x ∈ s)} {a : I} (ha : ↑y a = true) (hx : ↑x a = false)
Goal: 1 - Profinite.NobelingProof.e (Profinite.NobelingProof.π C fun x => x ∈ s) a ∈ Profinite.NobelingProof.factors C s x
-- Profinite.NobelingProof.factors_prod_eq_basis_of_ne
theorem factors_prod_eq_basis_of_ne {x y : (π C (· ∈ s))} (h : y ≠ x) :
    (factors C s x).prod y = 0 
Arguments: {I : Type u} [LinearOrder I] (C : Set (I → Bool)) (s : Finset I) {x y : ↑(Profinite.NobelingProof.π C fun x => x ∈ s)} (h : y ≠ x)
Goal: (Profinite.NobelingProof.factors C s x).prod y = 0
-- Profinite.NobelingProof.factors_prod_eq_basis
theorem factors_prod_eq_basis (x : π C (· ∈ s)) :
    (factors C s x).prod = spanFinBasis C s x 
Arguments: {I : Type u} [LinearOrder I] (C : Set (I → Bool)) (s : Finset I) (x : ↑(Profinite.NobelingProof.π C fun x => x ∈ s))
Goal: (Profinite.NobelingProof.factors C s x).prod = Profinite.NobelingProof.spanFinBasis C s x
-- Profinite.NobelingProof.GoodProducts.finsupp_sum_mem_span_eval
theorem GoodProducts.finsupp_sum_mem_span_eval {a : I} {as : List I}
    (ha : List.Chain' (· > ·) (a :: as)) {c : Products I →₀ ℤ}
    (hc : (c.support : Set (Products I)) ⊆ {m | m.val ≤ as}) :
    (Finsupp.sum c fun a_1 b ↦ e (π C (· ∈ s)) a * b • Products.eval (π C (· ∈ s)) a_1) ∈
      Submodule.span ℤ (Products.eval (π C (· ∈ s)) '' {m | m.val ≤ a :: as}) 
Arguments: {I : Type u} [LinearOrder I] (C : Set (I → Bool)) (s : Finset I) {a : I} {as : List I} (ha : List.Chain' (fun x x_1 => x > x_1) (a :: as)) {c : Profinite.NobelingProof.Products I →₀ ℤ} (hc : ↑c.support ⊆ {m | ↑m ≤ as})
Goal: (c.sum fun a_1 b =>
    Profinite.NobelingProof.e (Profinite.NobelingProof.π C fun x => x ∈ s) a *
      b • Profinite.NobelingProof.Products.eval (Profinite.NobelingProof.π C fun x => x ∈ s) a_1) ∈
  Submodule.span ℤ
    (Profinite.NobelingProof.Products.eval (Profinite.NobelingProof.π C fun x => x ∈ s) '' {m | ↑m ≤ a :: as})
-- Profinite.NobelingProof.GoodProducts.spanFin
theorem GoodProducts.spanFin : ⊤ ≤ Submodule.span ℤ (Set.range (eval (π C (· ∈ s)))) 
Arguments: {I : Type u} [LinearOrder I] [IsWellOrder I fun x x_1 => x < x_1] (C : Set (I → Bool)) (s : Finset I)
Goal: ⊤ ≤
  Submodule.span ℤ (Set.range (Profinite.NobelingProof.GoodProducts.eval (Profinite.NobelingProof.π C fun x => x ∈ s)))
-- Profinite.NobelingProof.fin_comap_jointlySurjective
theorem fin_comap_jointlySurjective
    (hC : IsClosed C)
    (f : LocallyConstant C ℤ) : ∃ (s : Finset I)
    (g : LocallyConstant (π C (· ∈ s)) ℤ), f = g.comap ⟨(ProjRestrict C (· ∈ s)),
      continuous_projRestrict _ _⟩ 
Arguments: {I : Type u} [LinearOrder I] (C : Set (I → Bool)) (hC : IsClosed C) (f : LocallyConstant ↑C ℤ)
Goal: ∃ s g,
  f = LocallyConstant.comap { toFun := Profinite.NobelingProof.ProjRestrict C fun x => x ∈ s, continuous_toFun := ⋯ } g
-- Profinite.NobelingProof.GoodProducts.span
theorem GoodProducts.span (hC : IsClosed C) :
    ⊤ ≤ Submodule.span ℤ (Set.range (eval C)) 
Arguments: {I : Type u} [LinearOrder I] [IsWellOrder I fun x x_1 => x < x_1] (C : Set (I → Bool)) (hC : IsClosed C)
Goal: ⊤ ≤ Submodule.span ℤ (Set.range (Profinite.NobelingProof.GoodProducts.eval C))
-- Profinite.NobelingProof.term_ord_aux
theorem term_ord_aux {i : I} (ho : ord I i < Ordinal.type ((·<·) : I → I → Prop)) :
    term I ho = i 
Arguments: {I : Type u} [LinearOrder I] [IsWellOrder I fun x x_1 => x < x_1] {i : I} (ho : Profinite.NobelingProof.ord I i < Ordinal.type fun x x_1 => x < x_1)
Goal: Profinite.NobelingProof.term I ho = i
-- Profinite.NobelingProof.ord_term_aux
@[simp]
theorem ord_term_aux {o : Ordinal} (ho : o < Ordinal.type ((·<·) : I → I → Prop)) :
    ord I (term I ho) = o 
Arguments: {I : Type u} [LinearOrder I] [IsWellOrder I fun x x_1 => x < x_1] {o : Ordinal.{u}} (ho : o < Ordinal.type fun x x_1 => x < x_1)
Goal: Profinite.NobelingProof.ord I (Profinite.NobelingProof.term I ho) = o
-- Profinite.NobelingProof.ord_term
theorem ord_term {o : Ordinal} (ho : o < Ordinal.type ((·<·) : I → I → Prop)) (i : I) :
    ord I i = o ↔ term I ho = i 
Arguments: {I : Type u} [LinearOrder I] [IsWellOrder I fun x x_1 => x < x_1] {o : Ordinal.{u}} (ho : o < Ordinal.type fun x x_1 => x < x_1) (i : I)
Goal: Profinite.NobelingProof.ord I i = o ↔ Profinite.NobelingProof.term I ho = i
-- Profinite.NobelingProof.Products.prop_of_isGood_of_contained
theorem Products.prop_of_isGood_of_contained  {l : Products I} (o : Ordinal) (h : l.isGood C)
    (hsC : contained C o) (i : I) (hi : i ∈ l.val) : ord I i < o 
Arguments: {I : Type u} [LinearOrder I] [IsWellOrder I fun x x_1 => x < x_1] (C : Set (I → Bool)) {l : Profinite.NobelingProof.Products I} (o : Ordinal.{u}) (h : Profinite.NobelingProof.Products.isGood C l) (hsC : Profinite.NobelingProof.contained C o) (i : I) (hi : i ∈ ↑l)
Goal: Profinite.NobelingProof.ord I i < o
-- Profinite.NobelingProof.GoodProducts.linearIndependentEmpty
theorem GoodProducts.linearIndependentEmpty :
    LinearIndependent ℤ (eval (∅ : Set (I → Bool))) 
Arguments: {I : Type u} [LinearOrder I]
Goal: LinearIndependent ℤ (Profinite.NobelingProof.GoodProducts.eval ∅)
-- Profinite.NobelingProof.Products.lt_nil_empty
theorem Products.lt_nil_empty : { m : Products I | m < Products.nil } = ∅ 
Arguments: {I : Type u} [LinearOrder I]
Goal: {m | m < Profinite.NobelingProof.Products.nil} = ∅
-- Profinite.NobelingProof.Products.isGood_nil
theorem Products.isGood_nil : Products.isGood ({fun _ ↦ false} : Set (I → Bool)) Products.nil 
Arguments: {I : Type u} [LinearOrder I]
Goal: Profinite.NobelingProof.Products.isGood {fun x => false} Profinite.NobelingProof.Products.nil
-- Profinite.NobelingProof.Products.span_nil_eq_top
theorem Products.span_nil_eq_top :
    Submodule.span ℤ (eval ({fun _ ↦ false} : Set (I → Bool)) '' {nil}) = ⊤ 
Arguments: {I : Type u} [LinearOrder I]
Goal: Submodule.span ℤ (Profinite.NobelingProof.Products.eval {fun x => false} '' {Profinite.NobelingProof.Products.nil}) = ⊤
-- Profinite.NobelingProof.GoodProducts.linearIndependentSingleton
theorem GoodProducts.linearIndependentSingleton :
    LinearIndependent ℤ (eval ({fun _ ↦ false} : Set (I → Bool))) 
Arguments: {I : Type u} [LinearOrder I]
Goal: LinearIndependent ℤ (Profinite.NobelingProof.GoodProducts.eval {fun x => false})
-- Profinite.NobelingProof.contained_eq_proj
theorem contained_eq_proj (o : Ordinal) (h : contained C o) :
    C = π C (ord I · < o) 
Arguments: {I : Type u} [LinearOrder I] [IsWellOrder I fun x x_1 => x < x_1] (C : Set (I → Bool)) (o : Ordinal.{u}) (h : Profinite.NobelingProof.contained C o)
Goal: C = Profinite.NobelingProof.π C fun x => Profinite.NobelingProof.ord I x < o
-- Profinite.NobelingProof.isClosed_proj
theorem isClosed_proj (o : Ordinal) (hC : IsClosed C) : IsClosed (π C (ord I · < o)) 
Arguments: {I : Type u} [LinearOrder I] [IsWellOrder I fun x x_1 => x < x_1] (C : Set (I → Bool)) (o : Ordinal.{u}) (hC : IsClosed C)
Goal: IsClosed (Profinite.NobelingProof.π C fun x => Profinite.NobelingProof.ord I x < o)
-- Profinite.NobelingProof.contained_proj
theorem contained_proj (o : Ordinal) : contained (π C (ord I · < o)) o 
Arguments: {I : Type u} [LinearOrder I] [IsWellOrder I fun x x_1 => x < x_1] (C : Set (I → Bool)) (o : Ordinal.{u})
Goal: Profinite.NobelingProof.contained (Profinite.NobelingProof.π C fun x => Profinite.NobelingProof.ord I x < o) o
-- Profinite.NobelingProof.πs_apply_apply
@[simps!]
noncomputable
def πs (o : Ordinal) : LocallyConstant (π C (ord I · < o)) ℤ →ₗ[ℤ] LocallyConstant C ℤ 
Arguments: {I : Type u} [LinearOrder I] [IsWellOrder I fun x x_1 => x < x_1] (C : Set (I → Bool)) (o : Ordinal.{u}) (g : LocallyConstant ↑(Profinite.NobelingProof.π C fun x => Profinite.NobelingProof.ord I x < o) ℤ)
Goal: ∀ (a : ↑C),
  ((Profinite.NobelingProof.πs C o) g) a =
    g (Profinite.NobelingProof.ProjRestrict C (fun x => Profinite.NobelingProof.ord I x < o) a)
-- Profinite.NobelingProof.coe_πs
theorem coe_πs (o : Ordinal) (f : LocallyConstant (π C (ord I · < o)) ℤ) :
    πs C o f = f ∘ ProjRestrict C (ord I · < o) 
Arguments: {I : Type u} [LinearOrder I] [IsWellOrder I fun x x_1 => x < x_1] (C : Set (I → Bool)) (o : Ordinal.{u}) (f : LocallyConstant ↑(Profinite.NobelingProof.π C fun x => Profinite.NobelingProof.ord I x < o) ℤ)
Goal: ⇑((Profinite.NobelingProof.πs C o) f) =
  ⇑f ∘ Profinite.NobelingProof.ProjRestrict C fun x => Profinite.NobelingProof.ord I x < o
-- Profinite.NobelingProof.injective_πs
theorem injective_πs (o : Ordinal) : Function.Injective (πs C o) 
Arguments: {I : Type u} [LinearOrder I] [IsWellOrder I fun x x_1 => x < x_1] (C : Set (I → Bool)) (o : Ordinal.{u})
Goal: Function.Injective ⇑(Profinite.NobelingProof.πs C o)
-- Profinite.NobelingProof.πs'_apply_apply
@[simps!]
noncomputable
def πs' {o₁ o₂ : Ordinal} (h : o₁ ≤ o₂) :
    LocallyConstant (π C (ord I · < o₁)) ℤ →ₗ[ℤ] LocallyConstant (π C (ord I · < o₂)) ℤ 
Arguments: {I : Type u} [LinearOrder I] [IsWellOrder I fun x x_1 => x < x_1] (C : Set (I → Bool)) {o₁ o₂ : Ordinal.{u}} (h : o₁ ≤ o₂) (g : LocallyConstant ↑(Profinite.NobelingProof.π C fun x => Profinite.NobelingProof.ord I x < o₁) ℤ)
Goal: ∀ (a : ↑(Profinite.NobelingProof.π C fun x => Profinite.NobelingProof.ord I x < o₂)),
  ((Profinite.NobelingProof.πs' C h) g) a = g (Profinite.NobelingProof.ProjRestricts C ⋯ a)
-- Profinite.NobelingProof.coe_πs'
theorem coe_πs' {o₁ o₂ : Ordinal} (h : o₁ ≤ o₂) (f : LocallyConstant (π C (ord I · < o₁)) ℤ) :
    (πs' C h f).toFun = f.toFun ∘ (ProjRestricts C (fun _ hh ↦ lt_of_lt_of_le hh h)) 
Arguments: {I : Type u} [LinearOrder I] [IsWellOrder I fun x x_1 => x < x_1] (C : Set (I → Bool)) {o₁ o₂ : Ordinal.{u}} (h : o₁ ≤ o₂) (f : LocallyConstant ↑(Profinite.NobelingProof.π C fun x => Profinite.NobelingProof.ord I x < o₁) ℤ)
Goal: ((Profinite.NobelingProof.πs' C h) f).toFun = f.toFun ∘ Profinite.NobelingProof.ProjRestricts C ⋯
-- Profinite.NobelingProof.injective_πs'
theorem injective_πs' {o₁ o₂ : Ordinal} (h : o₁ ≤ o₂) : Function.Injective (πs' C h) 
Arguments: {I : Type u} [LinearOrder I] [IsWellOrder I fun x x_1 => x < x_1] (C : Set (I → Bool)) {o₁ o₂ : Ordinal.{u}} (h : o₁ ≤ o₂)
Goal: Function.Injective ⇑(Profinite.NobelingProof.πs' C h)
-- Profinite.NobelingProof.Products.lt_ord_of_lt
theorem lt_ord_of_lt {l m : Products I} {o : Ordinal} (h₁ : m < l)
    (h₂ : ∀ i ∈ l.val, ord I i < o) : ∀ i ∈ m.val, ord I i < o 
Arguments: {I : Type u} [LinearOrder I] [IsWellOrder I fun x x_1 => x < x_1] {l m : Profinite.NobelingProof.Products I} {o : Ordinal.{u}} (h₁ : m < l) (h₂ : ∀ i ∈ ↑l, Profinite.NobelingProof.ord I i < o) (i : I)
Goal: i ∈ ↑m → Profinite.NobelingProof.ord I i < o