ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- Profinite.NobelingProof.Products.eval_πs
theorem eval_πs {l : Products I} {o : Ordinal} (hlt : ∀ i ∈ l.val, ord I i < o) :
    πs C o (l.eval (π C (ord I · < o))) = l.eval C 
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}} (hlt : ∀ i ∈ ↑l, Profinite.NobelingProof.ord I i < o)
Goal: (Profinite.NobelingProof.πs C o)
    (Profinite.NobelingProof.Products.eval (Profinite.NobelingProof.π C fun x => Profinite.NobelingProof.ord I x < o)
      l) =
  Profinite.NobelingProof.Products.eval C l
-- Profinite.NobelingProof.Products.eval_πs'
theorem eval_πs' {l : Products I} {o₁ o₂ : Ordinal} (h : o₁ ≤ o₂)
    (hlt : ∀ i ∈ l.val, ord I i < o₁) :
    πs' C h (l.eval (π C (ord I · < o₁))) = l.eval (π C (ord 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₁ o₂ : Ordinal.{u}} (h : o₁ ≤ o₂) (hlt : ∀ i ∈ ↑l, Profinite.NobelingProof.ord I i < o₁)
Goal: (Profinite.NobelingProof.πs' C h)
    (Profinite.NobelingProof.Products.eval (Profinite.NobelingProof.π C fun x => Profinite.NobelingProof.ord I x < o₁)
      l) =
  Profinite.NobelingProof.Products.eval (Profinite.NobelingProof.π C fun x => Profinite.NobelingProof.ord I x < o₂) l
-- Profinite.NobelingProof.Products.eval_πs_image
theorem eval_πs_image {l : Products I} {o : Ordinal}
    (hl : ∀ i ∈ l.val, ord I i < o) : eval C '' { m | m < l } =
    (πs C o) '' (eval (π C (ord I · < o)) '' { m | m < l }) 
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}} (hl : ∀ i ∈ ↑l, Profinite.NobelingProof.ord I i < o)
Goal: Profinite.NobelingProof.Products.eval C '' {m | m < l} =
  ⇑(Profinite.NobelingProof.πs C o) ''
    (Profinite.NobelingProof.Products.eval (Profinite.NobelingProof.π C fun x => Profinite.NobelingProof.ord I x < o) ''
      {m | m < l})
-- Profinite.NobelingProof.Products.eval_πs_image'
theorem eval_πs_image' {l : Products I} {o₁ o₂ : Ordinal} (h : o₁ ≤ o₂)
    (hl : ∀ i ∈ l.val, ord I i < o₁) : eval (π C (ord I · < o₂)) '' { m | m < l } =
    (πs' C h) '' (eval (π C (ord I · < o₁)) '' { m | m < l }) 
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₁ o₂ : Ordinal.{u}} (h : o₁ ≤ o₂) (hl : ∀ i ∈ ↑l, Profinite.NobelingProof.ord I i < o₁)
Goal: Profinite.NobelingProof.Products.eval (Profinite.NobelingProof.π C fun x => Profinite.NobelingProof.ord I x < o₂) ''
    {m | m < l} =
  ⇑(Profinite.NobelingProof.πs' C h) ''
    (Profinite.NobelingProof.Products.eval
        (Profinite.NobelingProof.π C fun x => Profinite.NobelingProof.ord I x < o₁) ''
      {m | m < l})
-- Profinite.NobelingProof.Products.head_lt_ord_of_isGood
theorem head_lt_ord_of_isGood [Inhabited I] {l : Products I} {o : Ordinal}
    (h : l.isGood (π C (ord I · < o))) (hn : l.val ≠ []) : ord I (l.val.head!) < o 
Arguments: {I : Type u} [LinearOrder I] [IsWellOrder I fun x x_1 => x < x_1] (C : Set (I → Bool)) [Inhabited I] {l : Profinite.NobelingProof.Products I} {o : Ordinal.{u}} (h :
  Profinite.NobelingProof.Products.isGood (Profinite.NobelingProof.π C fun x => Profinite.NobelingProof.ord I x < o) l) (hn : ↑l ≠ [])
Goal: Profinite.NobelingProof.ord I (↑l).head! < o
-- Profinite.NobelingProof.Products.isGood_mono
theorem isGood_mono {l : Products I} {o₁ o₂ : Ordinal} (h : o₁ ≤ o₂)
    (hl : l.isGood (π C (ord I · < o₁))) : l.isGood (π C (ord 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₁ o₂ : Ordinal.{u}} (h : o₁ ≤ o₂) (hl :
  Profinite.NobelingProof.Products.isGood (Profinite.NobelingProof.π C fun x => Profinite.NobelingProof.ord I x < o₁) l)
Goal: Profinite.NobelingProof.Products.isGood (Profinite.NobelingProof.π C fun x => Profinite.NobelingProof.ord I x < o₂) l
-- Profinite.NobelingProof.GoodProducts.range_equiv_smaller_toFun_bijective
theorem range_equiv_smaller_toFun_bijective (o : Ordinal) :
    Function.Bijective (range_equiv_smaller_toFun 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.Bijective (Profinite.NobelingProof.GoodProducts.range_equiv_smaller_toFun C o)
-- Profinite.NobelingProof.GoodProducts.smaller_factorization
theorem smaller_factorization (o : Ordinal) :
    (fun (p : smaller C o) ↦ p.1) ∘ (range_equiv_smaller C o).toFun =
    (πs C o) ∘ (fun (p : range (π C (ord I · < o))) ↦ p.1) 
Arguments: {I : Type u} [LinearOrder I] [IsWellOrder I fun x x_1 => x < x_1] (C : Set (I → Bool)) (o : Ordinal.{u})
Goal: (fun p => ↑p) ∘ (Profinite.NobelingProof.GoodProducts.range_equiv_smaller C o).toFun =
  ⇑(Profinite.NobelingProof.πs C o) ∘ fun p => ↑p
-- Profinite.NobelingProof.GoodProducts.linearIndependent_iff_smaller
theorem linearIndependent_iff_smaller (o : Ordinal) :
    LinearIndependent ℤ (GoodProducts.eval (π C (ord I · < o))) ↔
    LinearIndependent ℤ (fun (p : smaller C o) ↦ p.1) 
Arguments: {I : Type u} [LinearOrder I] [IsWellOrder I fun x x_1 => x < x_1] (C : Set (I → Bool)) (o : Ordinal.{u})
Goal: LinearIndependent ℤ
    (Profinite.NobelingProof.GoodProducts.eval
      (Profinite.NobelingProof.π C fun x => Profinite.NobelingProof.ord I x < o)) ↔
  LinearIndependent ℤ fun (p : ↑(Profinite.NobelingProof.GoodProducts.smaller C o)) => ↑p
-- Profinite.NobelingProof.GoodProducts.smaller_mono
theorem smaller_mono {o₁ o₂ : Ordinal} (h : o₁ ≤ o₂) : smaller C o₁ ⊆ smaller C 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₂)
Goal: Profinite.NobelingProof.GoodProducts.smaller C o₁ ⊆ Profinite.NobelingProof.GoodProducts.smaller C o₂
-- Profinite.NobelingProof.Products.limitOrdinal
theorem Products.limitOrdinal (l : Products I) : l.isGood (π C (ord I · < o)) ↔
    ∃ (o' : Ordinal), o' < o ∧ l.isGood (π 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}} (ho : o.IsLimit) (l : Profinite.NobelingProof.Products I)
Goal: Profinite.NobelingProof.Products.isGood (Profinite.NobelingProof.π C fun x => Profinite.NobelingProof.ord I x < o) l ↔
  ∃ o' < o,
    Profinite.NobelingProof.Products.isGood (Profinite.NobelingProof.π C fun x => Profinite.NobelingProof.ord I x < o')
      l
-- Profinite.NobelingProof.GoodProducts.union
theorem GoodProducts.union : range C = ⋃ (e : {o' // o' < o}), (smaller C e.val) 
Arguments: {I : Type u} [LinearOrder I] [IsWellOrder I fun x x_1 => x < x_1] (C : Set (I → Bool)) {o : Ordinal.{u}} (ho : o.IsLimit) (hsC : Profinite.NobelingProof.contained C o)
Goal: Profinite.NobelingProof.GoodProducts.range C = ⋃ e, Profinite.NobelingProof.GoodProducts.smaller C ↑e
-- Profinite.NobelingProof.GoodProducts.range_equiv_factorization
theorem GoodProducts.range_equiv_factorization :
    (fun (p : ⋃ (e : {o' // o' < o}), (smaller C e.val)) ↦ p.1) ∘ (range_equiv C ho hsC).toFun =
    (fun (p : range C) ↦ (p.1 : LocallyConstant C ℤ)) 
Arguments: {I : Type u} [LinearOrder I] [IsWellOrder I fun x x_1 => x < x_1] (C : Set (I → Bool)) {o : Ordinal.{u}} (ho : o.IsLimit) (hsC : Profinite.NobelingProof.contained C o)
Goal: (fun p => ↑p) ∘ (Profinite.NobelingProof.GoodProducts.range_equiv C ho hsC).toFun = fun p => ↑p
-- Profinite.NobelingProof.GoodProducts.linearIndependent_iff_union_smaller
theorem GoodProducts.linearIndependent_iff_union_smaller {o : Ordinal} (ho : o.IsLimit)
    (hsC : contained C o) : LinearIndependent ℤ (GoodProducts.eval C) ↔
    LinearIndependent ℤ (fun (p : ⋃ (e : {o' // o' < o}), (smaller C e.val)) ↦ p.1) 
Arguments: {I : Type u} [LinearOrder I] [IsWellOrder I fun x x_1 => x < x_1] (C : Set (I → Bool)) {o : Ordinal.{u}} (ho : o.IsLimit) (hsC : Profinite.NobelingProof.contained C o)
Goal: LinearIndependent ℤ (Profinite.NobelingProof.GoodProducts.eval C) ↔
  LinearIndependent ℤ fun (p : ↑(⋃ e, Profinite.NobelingProof.GoodProducts.smaller C ↑e)) => ↑p
-- Profinite.NobelingProof.isClosed_C0
theorem isClosed_C0 : IsClosed (C0 C ho) 
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) (ho : o < Ordinal.type fun x x_1 => x < x_1)
Goal: IsClosed (Profinite.NobelingProof.C0 C ho)
-- Profinite.NobelingProof.isClosed_C1
theorem isClosed_C1 : IsClosed (C1 C ho) 
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) (ho : o < Ordinal.type fun x x_1 => x < x_1)
Goal: IsClosed (Profinite.NobelingProof.C1 C ho)
-- Profinite.NobelingProof.contained_C1
theorem contained_C1 : contained (π (C1 C ho) (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}} (ho : o < Ordinal.type fun x x_1 => x < x_1)
Goal: Profinite.NobelingProof.contained
  (Profinite.NobelingProof.π (Profinite.NobelingProof.C1 C ho) fun x => Profinite.NobelingProof.ord I x < o) o
-- Profinite.NobelingProof.union_C0C1_eq
theorem union_C0C1_eq : (C0 C ho) ∪ (C1 C ho) = C 
Arguments: {I : Type u} [LinearOrder I] [IsWellOrder I fun x x_1 => x < x_1] (C : Set (I → Bool)) {o : Ordinal.{u}} (ho : o < Ordinal.type fun x x_1 => x < x_1)
Goal: Profinite.NobelingProof.C0 C ho ∪ Profinite.NobelingProof.C1 C ho = C
-- Profinite.NobelingProof.isClosed_C'
theorem isClosed_C' : IsClosed (C' C ho) 
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) (ho : o < Ordinal.type fun x x_1 => x < x_1)
Goal: IsClosed (Profinite.NobelingProof.C' C ho)
-- Profinite.NobelingProof.contained_C'
theorem contained_C' : contained (C' C ho) o 
Arguments: {I : Type u} [LinearOrder I] [IsWellOrder I fun x x_1 => x < x_1] (C : Set (I → Bool)) {o : Ordinal.{u}} (ho : o < Ordinal.type fun x x_1 => x < x_1)
Goal: Profinite.NobelingProof.contained (Profinite.NobelingProof.C' C ho) o
-- Profinite.NobelingProof.continuous_swapTrue
theorem continuous_swapTrue  :
    Continuous (SwapTrue o : (I → Bool) → I → Bool) 
Arguments: {I : Type u} [LinearOrder I] [IsWellOrder I fun x x_1 => x < x_1] (o : Ordinal.{u})
Goal: Continuous (Profinite.NobelingProof.SwapTrue o)
-- Profinite.NobelingProof.swapTrue_mem_C1
theorem swapTrue_mem_C1 (f : π (C1 C ho) (ord I · < o)) :
    SwapTrue o f.val ∈ C1 C ho 
Arguments: {I : Type u} [LinearOrder I] [IsWellOrder I fun x x_1 => x < x_1] (C : Set (I → Bool)) {o : Ordinal.{u}} (hsC : Profinite.NobelingProof.contained C (Order.succ o)) (ho : o < Ordinal.type fun x x_1 => x < x_1) (f : ↑(Profinite.NobelingProof.π (Profinite.NobelingProof.C1 C ho) fun x => Profinite.NobelingProof.ord I x < o))
Goal: Profinite.NobelingProof.SwapTrue o ↑f ∈ Profinite.NobelingProof.C1 C ho
-- Profinite.NobelingProof.continuous_CC'₀
theorem continuous_CC'₀ : Continuous (CC'₀ C ho) 
Arguments: {I : Type u} [LinearOrder I] [IsWellOrder I fun x x_1 => x < x_1] (C : Set (I → Bool)) {o : Ordinal.{u}} (ho : o < Ordinal.type fun x x_1 => x < x_1)
Goal: Continuous (Profinite.NobelingProof.CC'₀ C ho)
-- Profinite.NobelingProof.continuous_CC'₁
theorem continuous_CC'₁ : Continuous (CC'₁ C hsC ho) 
Arguments: {I : Type u} [LinearOrder I] [IsWellOrder I fun x x_1 => x < x_1] (C : Set (I → Bool)) {o : Ordinal.{u}} (hsC : Profinite.NobelingProof.contained C (Order.succ o)) (ho : o < Ordinal.type fun x x_1 => x < x_1)
Goal: Continuous (Profinite.NobelingProof.CC'₁ C hsC ho)
-- Profinite.NobelingProof.CC_comp_zero
theorem CC_comp_zero : ∀ y, (Linear_CC' C hsC ho) ((πs C o) y) = 0 
Arguments: {I : Type u} [LinearOrder I] [IsWellOrder I fun x x_1 => x < x_1] (C : Set (I → Bool)) {o : Ordinal.{u}} (hsC : Profinite.NobelingProof.contained C (Order.succ o)) (ho : o < Ordinal.type fun x x_1 => x < x_1) (y : LocallyConstant ↑(Profinite.NobelingProof.π C fun x => Profinite.NobelingProof.ord I x < o) ℤ)
Goal: (Profinite.NobelingProof.Linear_CC' C hsC ho) ((Profinite.NobelingProof.πs C o) y) = 0
-- Profinite.NobelingProof.C0_projOrd
theorem C0_projOrd {x : I → Bool} (hx : x ∈ C0 C ho) : Proj (ord I · < o) x = x 
Arguments: {I : Type u} [LinearOrder I] [IsWellOrder I fun x x_1 => x < x_1] (C : Set (I → Bool)) {o : Ordinal.{u}} (hsC : Profinite.NobelingProof.contained C (Order.succ o)) (ho : o < Ordinal.type fun x x_1 => x < x_1) {x : I → Bool} (hx : x ∈ Profinite.NobelingProof.C0 C ho)
Goal: Profinite.NobelingProof.Proj (fun x => Profinite.NobelingProof.ord I x < o) x = x
-- Profinite.NobelingProof.C1_projOrd
theorem C1_projOrd {x : I → Bool} (hx : x ∈ C1 C ho) : SwapTrue o (Proj (ord I · < o) x) = x 
Arguments: {I : Type u} [LinearOrder I] [IsWellOrder I fun x x_1 => x < x_1] (C : Set (I → Bool)) {o : Ordinal.{u}} (hsC : Profinite.NobelingProof.contained C (Order.succ o)) (ho : o < Ordinal.type fun x x_1 => x < x_1) {x : I → Bool} (hx : x ∈ Profinite.NobelingProof.C1 C ho)
Goal: Profinite.NobelingProof.SwapTrue o (Profinite.NobelingProof.Proj (fun x => Profinite.NobelingProof.ord I x < o) x) = x
-- Profinite.NobelingProof.CC_exact
theorem CC_exact {f : LocallyConstant C ℤ} (hf : Linear_CC' C hsC ho f = 0) :
    ∃ y, πs C o y = f 
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) (hsC : Profinite.NobelingProof.contained C (Order.succ o)) (ho : o < Ordinal.type fun x x_1 => x < x_1) {f : LocallyConstant ↑C ℤ} (hf : (Profinite.NobelingProof.Linear_CC' C hsC ho) f = 0)
Goal: ∃ y, (Profinite.NobelingProof.πs C o) y = f
-- Profinite.NobelingProof.succ_mono
theorem succ_mono : CategoryTheory.Mono (ModuleCat.ofHom (π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: CategoryTheory.Mono (ModuleCat.ofHom (Profinite.NobelingProof.πs C o))
-- Profinite.NobelingProof.succ_exact
theorem succ_exact :
    (ShortComplex.mk (ModuleCat.ofHom (πs C o)) (ModuleCat.ofHom (Linear_CC' C hsC ho))
    (by ext; apply CC_comp_zero)).Exact 
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) (hsC : Profinite.NobelingProof.contained C (Order.succ o)) (ho : o < Ordinal.type fun x x_1 => x < x_1)
Goal: (CategoryTheory.ShortComplex.mk (ModuleCat.ofHom (Profinite.NobelingProof.πs C o))
    (ModuleCat.ofHom (Profinite.NobelingProof.Linear_CC' C hsC ho)) ⋯).Exact
-- Profinite.NobelingProof.GoodProducts.union_succ
theorem union_succ : GoodProducts C = GoodProducts (π C (ord I · < o)) ∪ MaxProducts C ho 
Arguments: {I : Type u} [LinearOrder I] [IsWellOrder I fun x x_1 => x < x_1] (C : Set (I → Bool)) {o : Ordinal.{u}} (hsC : Profinite.NobelingProof.contained C (Order.succ o)) (ho : o < Ordinal.type fun x x_1 => x < x_1)
Goal: Profinite.NobelingProof.GoodProducts C =
  Profinite.NobelingProof.GoodProducts (Profinite.NobelingProof.π C fun x => Profinite.NobelingProof.ord I x < o) ∪
    Profinite.NobelingProof.GoodProducts.MaxProducts C ho
-- Profinite.NobelingProof.GoodProducts.injective_sum_to
theorem injective_sum_to : Function.Injective (sum_to C ho) 
Arguments: {I : Type u} [LinearOrder I] [IsWellOrder I fun x x_1 => x < x_1] (C : Set (I → Bool)) {o : Ordinal.{u}} (ho : o < Ordinal.type fun x x_1 => x < x_1)
Goal: Function.Injective (Profinite.NobelingProof.GoodProducts.sum_to C ho)
-- Profinite.NobelingProof.GoodProducts.sum_to_range
theorem sum_to_range :
    Set.range (sum_to C ho) = GoodProducts (π C (ord I · < o)) ∪ MaxProducts C ho 
Arguments: {I : Type u} [LinearOrder I] [IsWellOrder I fun x x_1 => x < x_1] (C : Set (I → Bool)) {o : Ordinal.{u}} (ho : o < Ordinal.type fun x x_1 => x < x_1)
Goal: Set.range (Profinite.NobelingProof.GoodProducts.sum_to C ho) =
  Profinite.NobelingProof.GoodProducts (Profinite.NobelingProof.π C fun x => Profinite.NobelingProof.ord I x < o) ∪
    Profinite.NobelingProof.GoodProducts.MaxProducts C ho
-- Profinite.NobelingProof.GoodProducts.sum_equiv_comp_eval_eq_elim
theorem sum_equiv_comp_eval_eq_elim : eval C ∘ (sum_equiv C hsC ho).toFun =
    (Sum.elim (fun (l : GoodProducts (π C (ord I · < o))) ↦ Products.eval C l.1)
    (fun (l : MaxProducts C ho) ↦ Products.eval C l.1)) 
Arguments: {I : Type u} [LinearOrder I] [IsWellOrder I fun x x_1 => x < x_1] (C : Set (I → Bool)) {o : Ordinal.{u}} (hsC : Profinite.NobelingProof.contained C (Order.succ o)) (ho : o < Ordinal.type fun x x_1 => x < x_1)
Goal: Profinite.NobelingProof.GoodProducts.eval C ∘ (Profinite.NobelingProof.GoodProducts.sum_equiv C hsC ho).toFun =
  Sum.elim (fun l => Profinite.NobelingProof.Products.eval C ↑l) fun l => Profinite.NobelingProof.Products.eval C ↑l
-- Profinite.NobelingProof.GoodProducts.linearIndependent_iff_sum
theorem linearIndependent_iff_sum :
    LinearIndependent ℤ (eval C) ↔ LinearIndependent ℤ (SumEval C ho) 
Arguments: {I : Type u} [LinearOrder I] [IsWellOrder I fun x x_1 => x < x_1] (C : Set (I → Bool)) {o : Ordinal.{u}} (hsC : Profinite.NobelingProof.contained C (Order.succ o)) (ho : o < Ordinal.type fun x x_1 => x < x_1)
Goal: LinearIndependent ℤ (Profinite.NobelingProof.GoodProducts.eval C) ↔
  LinearIndependent ℤ (Profinite.NobelingProof.GoodProducts.SumEval C ho)
-- Profinite.NobelingProof.GoodProducts.span_sum
theorem span_sum : Set.range (eval C) = Set.range (Sum.elim
    (fun (l : GoodProducts (π C (ord I · < o))) ↦ Products.eval C l.1)
    (fun (l : MaxProducts C ho) ↦ Products.eval C l.1)) 
Arguments: {I : Type u} [LinearOrder I] [IsWellOrder I fun x x_1 => x < x_1] (C : Set (I → Bool)) {o : Ordinal.{u}} (hsC : Profinite.NobelingProof.contained C (Order.succ o)) (ho : o < Ordinal.type fun x x_1 => x < x_1)
Goal: Set.range (Profinite.NobelingProof.GoodProducts.eval C) =
  Set.range
    (Sum.elim (fun l => Profinite.NobelingProof.Products.eval C ↑l) fun l => Profinite.NobelingProof.Products.eval C ↑l)
-- Profinite.NobelingProof.GoodProducts.square_commutes
theorem square_commutes : SumEval C ho ∘ Sum.inl =
    ModuleCat.ofHom (πs C o) ∘ eval (π 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}} (ho : o < Ordinal.type fun x x_1 => x < x_1)
Goal: Profinite.NobelingProof.GoodProducts.SumEval C ho ∘ Sum.inl =
  ⇑(ModuleCat.ofHom (Profinite.NobelingProof.πs C o)) ∘
    Profinite.NobelingProof.GoodProducts.eval (Profinite.NobelingProof.π C fun x => Profinite.NobelingProof.ord I x < o)
-- Profinite.NobelingProof.swapTrue_eq_true
theorem swapTrue_eq_true (x : I → Bool) : SwapTrue o x (term I ho) = true 
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) (x : I → Bool)
Goal: Profinite.NobelingProof.SwapTrue o x (Profinite.NobelingProof.term I ho) = true
-- Profinite.NobelingProof.mem_C'_eq_false
theorem mem_C'_eq_false : ∀ x, x ∈ C' C ho → x (term I ho) = false 
Arguments: {I : Type u} [LinearOrder I] [IsWellOrder I fun x x_1 => x < x_1] (C : Set (I → Bool)) {o : Ordinal.{u}} (ho : o < Ordinal.type fun x x_1 => x < x_1) (x : I → Bool)
Goal: x ∈ Profinite.NobelingProof.C' C ho → x (Profinite.NobelingProof.term I ho) = false
-- Profinite.NobelingProof.Products.max_eq_o_cons_tail
theorem Products.max_eq_o_cons_tail [Inhabited I] (l : Products I) (hl : l.val ≠ [])
    (hlh : l.val.head! = term I ho) : l.val = term I ho :: l.Tail.val 
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) [Inhabited I] (l : Profinite.NobelingProof.Products I) (hl : ↑l ≠ []) (hlh : (↑l).head! = Profinite.NobelingProof.term I ho)
Goal: ↑l = Profinite.NobelingProof.term I ho :: ↑l.Tail
-- Profinite.NobelingProof.Products.max_eq_o_cons_tail'
theorem Products.max_eq_o_cons_tail' [Inhabited I] (l : Products I) (hl : l.val ≠ [])
    (hlh : l.val.head! = term I ho) (hlc : List.Chain' (·>·) (term I ho :: l.Tail.val)) :
    l = ⟨term I ho :: l.Tail.val, hlc⟩ 
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) [Inhabited I] (l : Profinite.NobelingProof.Products I) (hl : ↑l ≠ []) (hlh : (↑l).head! = Profinite.NobelingProof.term I ho) (hlc : List.Chain' (fun x x_1 => x > x_1) (Profinite.NobelingProof.term I ho :: ↑l.Tail))
Goal: l = ⟨Profinite.NobelingProof.term I ho :: ↑l.Tail, hlc⟩
-- Profinite.NobelingProof.GoodProducts.head!_eq_o_of_maxProducts
theorem GoodProducts.head!_eq_o_of_maxProducts [Inhabited I] (l : ↑(MaxProducts C ho)) :
    l.val.val.head! = term I ho 
Arguments: {I : Type u} [LinearOrder I] [IsWellOrder I fun x x_1 => x < x_1] (C : Set (I → Bool)) {o : Ordinal.{u}} (hsC : Profinite.NobelingProof.contained C (Order.succ o)) (ho : o < Ordinal.type fun x x_1 => x < x_1) [Inhabited I] (l : ↑(Profinite.NobelingProof.GoodProducts.MaxProducts C ho))
Goal: (↑↑l).head! = Profinite.NobelingProof.term I ho
-- Profinite.NobelingProof.GoodProducts.max_eq_o_cons_tail
theorem GoodProducts.max_eq_o_cons_tail (l : MaxProducts C ho) :
    l.val.val = (term I ho) :: l.val.Tail.val 
Arguments: {I : Type u} [LinearOrder I] [IsWellOrder I fun x x_1 => x < x_1] (C : Set (I → Bool)) {o : Ordinal.{u}} (hsC : Profinite.NobelingProof.contained C (Order.succ o)) (ho : o < Ordinal.type fun x x_1 => x < x_1) (l : ↑(Profinite.NobelingProof.GoodProducts.MaxProducts C ho))
Goal: ↑↑l = Profinite.NobelingProof.term I ho :: ↑(↑l).Tail
-- Profinite.NobelingProof.Products.evalCons
theorem Products.evalCons {l : List I} {a : I}
    (hla : (a::l).Chain' (·>·)) : Products.eval C ⟨a::l,hla⟩ =
    (e C a) * Products.eval C ⟨l,List.Chain'.sublist hla (List.tail_sublist (a::l))⟩ 
Arguments: {I : Type u} [LinearOrder I] (C : Set (I → Bool)) {l : List I} {a : I} (hla : List.Chain' (fun x x_1 => x > x_1) (a :: l))
Goal: Profinite.NobelingProof.Products.eval C ⟨a :: l, hla⟩ =
  Profinite.NobelingProof.e C a * Profinite.NobelingProof.Products.eval C ⟨l, ⋯⟩
-- Profinite.NobelingProof.Products.max_eq_eval
theorem Products.max_eq_eval [Inhabited I] (l : Products I) (hl : l.val ≠ [])
    (hlh : l.val.head! = term I ho) :
    Linear_CC' C hsC ho (l.eval C) = l.Tail.eval (C' C ho) 
Arguments: {I : Type u} [LinearOrder I] [IsWellOrder I fun x x_1 => x < x_1] (C : Set (I → Bool)) {o : Ordinal.{u}} (hsC : Profinite.NobelingProof.contained C (Order.succ o)) (ho : o < Ordinal.type fun x x_1 => x < x_1) [Inhabited I] (l : Profinite.NobelingProof.Products I) (hl : ↑l ≠ []) (hlh : (↑l).head! = Profinite.NobelingProof.term I ho)
Goal: (Profinite.NobelingProof.Linear_CC' C hsC ho) (Profinite.NobelingProof.Products.eval C l) =
  Profinite.NobelingProof.Products.eval (Profinite.NobelingProof.C' C ho) l.Tail
-- Profinite.NobelingProof.GoodProducts.max_eq_eval
theorem max_eq_eval (l : MaxProducts C ho) :
    Linear_CC' C hsC ho (l.val.eval C) = l.val.Tail.eval (C' C ho) 
Arguments: {I : Type u} [LinearOrder I] [IsWellOrder I fun x x_1 => x < x_1] (C : Set (I → Bool)) {o : Ordinal.{u}} (hsC : Profinite.NobelingProof.contained C (Order.succ o)) (ho : o < Ordinal.type fun x x_1 => x < x_1) (l : ↑(Profinite.NobelingProof.GoodProducts.MaxProducts C ho))
Goal: (Profinite.NobelingProof.Linear_CC' C hsC ho) (Profinite.NobelingProof.Products.eval C ↑l) =
  Profinite.NobelingProof.Products.eval (Profinite.NobelingProof.C' C ho) (↑l).Tail
-- Profinite.NobelingProof.GoodProducts.max_eq_eval_unapply
theorem max_eq_eval_unapply :
    (Linear_CC' C hsC ho) ∘ (fun (l : MaxProducts C ho) ↦ Products.eval C l.val) =
    (fun l ↦ l.val.Tail.eval (C' C ho)) 
Arguments: {I : Type u} [LinearOrder I] [IsWellOrder I fun x x_1 => x < x_1] (C : Set (I → Bool)) {o : Ordinal.{u}} (hsC : Profinite.NobelingProof.contained C (Order.succ o)) (ho : o < Ordinal.type fun x x_1 => x < x_1)
Goal: (⇑(Profinite.NobelingProof.Linear_CC' C hsC ho) ∘ fun l => Profinite.NobelingProof.Products.eval C ↑l) = fun l =>
  Profinite.NobelingProof.Products.eval (Profinite.NobelingProof.C' C ho) (↑l).Tail