ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- Cardinal.nfpFamily_lt_ord_of_isRegular
theorem nfpFamily_lt_ord_of_isRegular {ι} {f : ι → Ordinal → Ordinal} {c} (hc : IsRegular c)
    (hι : #ι < c) (hc' : c ≠ ℵ₀) {a} (hf : ∀ (i), ∀ b < c.ord, f i b < c.ord) :
    a < c.ord → nfpFamily.{u, u} f a < c.ord 
Arguments: {ι : Type u} {f : ι → Ordinal.{u} → Ordinal.{u}} {c : Cardinal.{u}} (hc : c.IsRegular) (hι : #ι < c) (hc' : c ≠ ℵ₀) {a : Ordinal.{u}} (hf : ∀ (i : ι), ∀ b < c.ord, f i b < c.ord)
Goal: a < c.ord → Ordinal.nfpFamily f a < c.ord
-- Cardinal.nfpBFamily_lt_ord_lift_of_isRegular
theorem nfpBFamily_lt_ord_lift_of_isRegular {o : Ordinal} {f : ∀ a < o, Ordinal → Ordinal} {c}
    (hc : IsRegular c) (ho : Cardinal.lift.{v, u} o.card < c) (hc' : c ≠ ℵ₀)
    (hf : ∀ (i hi), ∀ b < c.ord, f i hi b < c.ord) {a} :
    a < c.ord → nfpBFamily.{u, v} o f a < c.ord 
Arguments: {o : Ordinal.{u}} {f : (a : Ordinal.{u}) → a < o → Ordinal.{max u v} → Ordinal.{max u v}} {c : Cardinal.{max u v}} (hc : c.IsRegular) (ho : Cardinal.lift.{v, u} o.card < c) (hc' : c ≠ ℵ₀) (hf : ∀ (i : Ordinal.{u}) (hi : i < o), ∀ b < c.ord, f i hi b < c.ord) {a : Ordinal.{max u v}}
Goal: a < c.ord → o.nfpBFamily f a < c.ord
-- Cardinal.nfpBFamily_lt_ord_of_isRegular
theorem nfpBFamily_lt_ord_of_isRegular {o : Ordinal} {f : ∀ a < o, Ordinal → Ordinal} {c}
    (hc : IsRegular c) (ho : o.card < c) (hc' : c ≠ ℵ₀)
    (hf : ∀ (i hi), ∀ b < c.ord, f i hi b < c.ord) {a} :
    a < c.ord → nfpBFamily.{u, u} o f a < c.ord 
Arguments: {o : Ordinal.{u}} {f : (a : Ordinal.{u}) → a < o → Ordinal.{u} → Ordinal.{u}} {c : Cardinal.{u}} (hc : c.IsRegular) (ho : o.card < c) (hc' : c ≠ ℵ₀) (hf : ∀ (i : Ordinal.{u}) (hi : i < o), ∀ b < c.ord, f i hi b < c.ord) {a : Ordinal.{u}}
Goal: a < c.ord → o.nfpBFamily f a < c.ord
-- Cardinal.nfp_lt_ord_of_isRegular
theorem nfp_lt_ord_of_isRegular {f : Ordinal → Ordinal} {c} (hc : IsRegular c) (hc' : c ≠ ℵ₀)
    (hf : ∀ i < c.ord, f i < c.ord) {a} : a < c.ord → nfp f a < c.ord 
Arguments: {f : Ordinal.{u_2} → Ordinal.{u_2}} {c : Cardinal.{u_2}} (hc : c.IsRegular) (hc' : c ≠ ℵ₀) (hf : ∀ i < c.ord, f i < c.ord) {a : Ordinal.{u_2}}
Goal: a < c.ord → Ordinal.nfp f a < c.ord
-- Cardinal.derivFamily_lt_ord_lift
theorem derivFamily_lt_ord_lift {ι} {f : ι → Ordinal → Ordinal} {c} (hc : IsRegular c)
    (hι : Cardinal.lift.{v, u} #ι < c) (hc' : c ≠ ℵ₀)
    (hf : ∀ (i), ∀ b < c.ord, f i b < c.ord) {a} :
    a < c.ord → derivFamily.{u, v} f a < c.ord 
Arguments: {ι : Type u} {f : ι → Ordinal.{max u v} → Ordinal.{max u v}} {c : Cardinal.{max u v}} (hc : c.IsRegular) (hι : Cardinal.lift.{v, u} #ι < c) (hc' : c ≠ ℵ₀) (hf : ∀ (i : ι), ∀ b < c.ord, f i b < c.ord) {a : Ordinal.{max u v}}
Goal: a < c.ord → Ordinal.derivFamily f a < c.ord
-- Cardinal.derivFamily_lt_ord
theorem derivFamily_lt_ord {ι} {f : ι → Ordinal → Ordinal} {c} (hc : IsRegular c) (hι : #ι < c)
    (hc' : c ≠ ℵ₀) (hf : ∀ (i), ∀ b < c.ord, f i b < c.ord) {a} :
    a < c.ord → derivFamily.{u, u} f a < c.ord 
Arguments: {ι : Type u} {f : ι → Ordinal.{u} → Ordinal.{u}} {c : Cardinal.{u}} (hc : c.IsRegular) (hι : #ι < c) (hc' : c ≠ ℵ₀) (hf : ∀ (i : ι), ∀ b < c.ord, f i b < c.ord) {a : Ordinal.{u}}
Goal: a < c.ord → Ordinal.derivFamily f a < c.ord
-- Cardinal.derivBFamily_lt_ord_lift
theorem derivBFamily_lt_ord_lift {o : Ordinal} {f : ∀ a < o, Ordinal → Ordinal} {c}
    (hc : IsRegular c) (hι : Cardinal.lift.{v, u} o.card < c) (hc' : c ≠ ℵ₀)
    (hf : ∀ (i hi), ∀ b < c.ord, f i hi b < c.ord) {a} :
    a < c.ord → derivBFamily.{u, v} o f a < c.ord 
Arguments: {o : Ordinal.{u}} {f : (a : Ordinal.{u}) → a < o → Ordinal.{max u v} → Ordinal.{max u v}} {c : Cardinal.{max u v}} (hc : c.IsRegular) (hι : Cardinal.lift.{v, u} o.card < c) (hc' : c ≠ ℵ₀) (hf : ∀ (i : Ordinal.{u}) (hi : i < o), ∀ b < c.ord, f i hi b < c.ord) {a : Ordinal.{max u v}}
Goal: a < c.ord → o.derivBFamily f a < c.ord
-- Cardinal.derivBFamily_lt_ord
theorem derivBFamily_lt_ord {o : Ordinal} {f : ∀ a < o, Ordinal → Ordinal} {c} (hc : IsRegular c)
    (hι : o.card < c) (hc' : c ≠ ℵ₀) (hf : ∀ (i hi), ∀ b < c.ord, f i hi b < c.ord) {a} :
    a < c.ord → derivBFamily.{u, u} o f a < c.ord 
Arguments: {o : Ordinal.{u}} {f : (a : Ordinal.{u}) → a < o → Ordinal.{u} → Ordinal.{u}} {c : Cardinal.{u}} (hc : c.IsRegular) (hι : o.card < c) (hc' : c ≠ ℵ₀) (hf : ∀ (i : Ordinal.{u}) (hi : i < o), ∀ b < c.ord, f i hi b < c.ord) {a : Ordinal.{u}}
Goal: a < c.ord → o.derivBFamily f a < c.ord
-- Cardinal.deriv_lt_ord
theorem deriv_lt_ord {f : Ordinal.{u} → Ordinal} {c} (hc : IsRegular c) (hc' : c ≠ ℵ₀)
    (hf : ∀ i < c.ord, f i < c.ord) {a} : a < c.ord → deriv f a < c.ord 
Arguments: {f : Ordinal.{u} → Ordinal.{u}} {c : Cardinal.{u}} (hc : c.IsRegular) (hc' : c ≠ ℵ₀) (hf : ∀ i < c.ord, f i < c.ord) {a : Ordinal.{u}}
Goal: a < c.ord → Ordinal.deriv f a < c.ord
-- Cardinal.IsInaccessible.mk
theorem IsInaccessible.mk {c} (h₁ : ℵ₀ < c) (h₂ : c ≤ c.ord.cof) (h₃ : ∀ x < c, (2^x) < c) :
    IsInaccessible c 
Arguments: {c : Cardinal.{u_2}} (h₁ : ℵ₀ < c) (h₂ : c ≤ c.ord.cof) (h₃ : ∀ x < c, 2 ^ x < c)
Goal: c.IsInaccessible
-- Cardinal.univ_inaccessible
theorem univ_inaccessible : IsInaccessible univ.{u, v} 
Goal: Cardinal.univ.{u, v}.IsInaccessible
-- Cardinal.lt_power_cof
theorem lt_power_cof {c : Cardinal.{u}} : ℵ₀ ≤ c → c < (c^cof c.ord) 
Arguments: {c : Cardinal.{u}}
Goal: ℵ₀ ≤ c → c < c ^ c.ord.cof
-- Cardinal.lt_cof_power
theorem lt_cof_power {a b : Cardinal} (ha : ℵ₀ ≤ a) (b1 : 1 < b) : a < cof (b^a).ord 
Arguments: {a b : Cardinal.{u_2}} (ha : ℵ₀ ≤ a) (b1 : 1 < b)
Goal: a < (b ^ a).ord.cof
-- Ordinal.sup_sequence_lt_omega1
lemma sup_sequence_lt_omega1 {α} [Countable α] (o : α → Ordinal) (ho : ∀ n, o n < ω₁) :
    sup o < ω₁ 
Arguments: {α : Type u_2} [Countable α] (o : α → Ordinal.{max u_3 u_2}) (ho : ∀ (n : α), o n < (Cardinal.aleph 1).ord)
Goal: Ordinal.sup o < (Cardinal.aleph 1).ord
-- Finset.shadow_empty
@[simp]
theorem shadow_empty : ∂ (∅ : Finset (Finset α)) = ∅ 
Arguments: {α : Type u_1} [DecidableEq α]
Goal: ∅.shadow = ∅
-- Finset.shadow_iterate_empty
@[simp] lemma shadow_iterate_empty (k : ℕ) : ∂^[k] (∅ : Finset (Finset α)) = ∅ 
Arguments: {α : Type u_1} [DecidableEq α] (k : ℕ)
Goal: Finset.shadow^[k] ∅ = ∅
-- Finset.shadow_singleton_empty
@[simp]
theorem shadow_singleton_empty : ∂ ({∅} : Finset (Finset α)) = ∅ 
Arguments: {α : Type u_1} [DecidableEq α]
Goal: {∅}.shadow = ∅
-- Finset.shadow_monotone
@[mono]
theorem shadow_monotone : Monotone (shadow : Finset (Finset α) → Finset (Finset α)) 
Arguments: {α : Type u_1} [DecidableEq α]
Goal: Monotone Finset.shadow
-- Finset.mem_shadow_iff
lemma mem_shadow_iff : t ∈ ∂ 𝒜 ↔ ∃ s ∈ 𝒜, ∃ a ∈ s, erase s a = t 
Arguments: {α : Type u_1} [DecidableEq α] {𝒜 : Finset (Finset α)} {t : Finset α}
Goal: t ∈ 𝒜.shadow ↔ ∃ s ∈ 𝒜, ∃ a ∈ s, s.erase a = t
-- Finset.erase_mem_shadow
theorem erase_mem_shadow (hs : s ∈ 𝒜) (ha : a ∈ s) : erase s a ∈ ∂ 𝒜 
Arguments: {α : Type u_1} [DecidableEq α] {𝒜 : Finset (Finset α)} {s : Finset α} {a : α} (hs : s ∈ 𝒜) (ha : a ∈ s)
Goal: s.erase a ∈ 𝒜.shadow
-- Finset.mem_shadow_iff_exists_sdiff
lemma mem_shadow_iff_exists_sdiff : t ∈ ∂ 𝒜 ↔ ∃ s ∈ 𝒜, t ⊆ s ∧ (s \ t).card = 1 
Arguments: {α : Type u_1} [DecidableEq α] {𝒜 : Finset (Finset α)} {t : Finset α}
Goal: t ∈ 𝒜.shadow ↔ ∃ s ∈ 𝒜, t ⊆ s ∧ (s \ t).card = 1
-- Finset.mem_shadow_iff_insert_mem
lemma mem_shadow_iff_insert_mem : t ∈ ∂ 𝒜 ↔ ∃ a ∉ t, insert a t ∈ 𝒜 
Arguments: {α : Type u_1} [DecidableEq α] {𝒜 : Finset (Finset α)} {t : Finset α}
Goal: t ∈ 𝒜.shadow ↔ ∃ a ∉ t, insert a t ∈ 𝒜
-- Finset.mem_shadow_iff_exists_mem_card_add_one
lemma mem_shadow_iff_exists_mem_card_add_one :
    t ∈ ∂ 𝒜 ↔ ∃ s ∈ 𝒜, t ⊆ s ∧ s.card = t.card + 1 
Arguments: {α : Type u_1} [DecidableEq α] {𝒜 : Finset (Finset α)} {t : Finset α}
Goal: t ∈ 𝒜.shadow ↔ ∃ s ∈ 𝒜, t ⊆ s ∧ s.card = t.card + 1
-- Finset.mem_shadow_iterate_iff_exists_card
lemma mem_shadow_iterate_iff_exists_card :
    t ∈ ∂^[k] 𝒜 ↔ ∃ u : Finset α, u.card = k ∧ Disjoint t u ∧ t ∪ u ∈ 𝒜 
Arguments: {α : Type u_1} [DecidableEq α] {𝒜 : Finset (Finset α)} {t : Finset α} {k : ℕ}
Goal: t ∈ Finset.shadow^[k] 𝒜 ↔ ∃ u, u.card = k ∧ Disjoint t u ∧ t ∪ u ∈ 𝒜
-- Finset.mem_shadow_iterate_iff_exists_sdiff
lemma mem_shadow_iterate_iff_exists_sdiff : t ∈ ∂^[k] 𝒜 ↔ ∃ s ∈ 𝒜, t ⊆ s ∧ (s \ t).card = k 
Arguments: {α : Type u_1} [DecidableEq α] {𝒜 : Finset (Finset α)} {t : Finset α} {k : ℕ}
Goal: t ∈ Finset.shadow^[k] 𝒜 ↔ ∃ s ∈ 𝒜, t ⊆ s ∧ (s \ t).card = k
-- Finset.mem_shadow_iterate_iff_exists_mem_card_add
lemma mem_shadow_iterate_iff_exists_mem_card_add :
    t ∈ ∂^[k] 𝒜 ↔ ∃ s ∈ 𝒜, t ⊆ s ∧ s.card = t.card + k 
Arguments: {α : Type u_1} [DecidableEq α] {𝒜 : Finset (Finset α)} {t : Finset α} {k : ℕ}
Goal: t ∈ Finset.shadow^[k] 𝒜 ↔ ∃ s ∈ 𝒜, t ⊆ s ∧ s.card = t.card + k
-- Set.Sized.shadow
protected theorem _root_.Set.Sized.shadow (h𝒜 : (𝒜 : Set (Finset α)).Sized r) :
    (∂ 𝒜 : Set (Finset α)).Sized (r - 1) 
Arguments: {α : Type u_1} [DecidableEq α] {𝒜 : Finset (Finset α)} {r : ℕ} (h𝒜 : Set.Sized r ↑𝒜)
Goal: Set.Sized (r - 1) ↑𝒜.shadow
-- Set.Sized.shadow_iterate
lemma _root_.Set.Sized.shadow_iterate (h𝒜 : (𝒜 : Set (Finset α)).Sized r) :
    (∂^[k] 𝒜 : Set (Finset α)).Sized (r - k) 
Arguments: {α : Type u_1} [DecidableEq α] {𝒜 : Finset (Finset α)} {k r : ℕ} (h𝒜 : Set.Sized r ↑𝒜)
Goal: Set.Sized (r - k) ↑(Finset.shadow^[k] 𝒜)
-- Finset.sized_shadow_iff
theorem sized_shadow_iff (h : ∅ ∉ 𝒜) :
    (∂ 𝒜 : Set (Finset α)).Sized r ↔ (𝒜 : Set (Finset α)).Sized (r + 1) 
Arguments: {α : Type u_1} [DecidableEq α] {𝒜 : Finset (Finset α)} {r : ℕ} (h : ∅ ∉ 𝒜)
Goal: Set.Sized r ↑𝒜.shadow ↔ Set.Sized (r + 1) ↑𝒜
-- Finset.exists_subset_of_mem_shadow
lemma exists_subset_of_mem_shadow (hs : t ∈ ∂ 𝒜) : ∃ s ∈ 𝒜, t ⊆ s 
Arguments: {α : Type u_1} [DecidableEq α] {𝒜 : Finset (Finset α)} {t : Finset α} (hs : t ∈ 𝒜.shadow)
Goal: ∃ s ∈ 𝒜, t ⊆ s
-- Finset.upShadow_empty
@[simp]
theorem upShadow_empty : ∂⁺ (∅ : Finset (Finset α)) = ∅ 
Arguments: {α : Type u_1} [DecidableEq α] [Fintype α]
Goal: ∅.upShadow = ∅
-- Finset.upShadow_monotone
@[mono]
theorem upShadow_monotone : Monotone (upShadow : Finset (Finset α) → Finset (Finset α)) 
Arguments: {α : Type u_1} [DecidableEq α] [Fintype α]
Goal: Monotone Finset.upShadow
-- Finset.mem_upShadow_iff
lemma mem_upShadow_iff : t ∈ ∂⁺ 𝒜 ↔ ∃ s ∈ 𝒜, ∃ a ∉ s, insert a s = t 
Arguments: {α : Type u_1} [DecidableEq α] [Fintype α] {𝒜 : Finset (Finset α)} {t : Finset α}
Goal: t ∈ 𝒜.upShadow ↔ ∃ s ∈ 𝒜, ∃ a ∉ s, insert a s = t
-- Finset.insert_mem_upShadow
theorem insert_mem_upShadow (hs : s ∈ 𝒜) (ha : a ∉ s) : insert a s ∈ ∂⁺ 𝒜 
Arguments: {α : Type u_1} [DecidableEq α] [Fintype α] {𝒜 : Finset (Finset α)} {s : Finset α} {a : α} (hs : s ∈ 𝒜) (ha : a ∉ s)
Goal: insert a s ∈ 𝒜.upShadow
-- Finset.mem_upShadow_iff_exists_sdiff
lemma mem_upShadow_iff_exists_sdiff : t ∈ ∂⁺ 𝒜 ↔ ∃ s ∈ 𝒜, s ⊆ t ∧ (t \ s).card = 1 
Arguments: {α : Type u_1} [DecidableEq α] [Fintype α] {𝒜 : Finset (Finset α)} {t : Finset α}
Goal: t ∈ 𝒜.upShadow ↔ ∃ s ∈ 𝒜, s ⊆ t ∧ (t \ s).card = 1
-- Finset.mem_upShadow_iff_erase_mem
lemma mem_upShadow_iff_erase_mem : t ∈ ∂⁺ 𝒜 ↔ ∃ a, a ∈ t ∧ erase t a ∈ 𝒜 
Arguments: {α : Type u_1} [DecidableEq α] [Fintype α] {𝒜 : Finset (Finset α)} {t : Finset α}
Goal: t ∈ 𝒜.upShadow ↔ ∃ a ∈ t, t.erase a ∈ 𝒜
-- Finset.mem_upShadow_iff_exists_mem_card_add_one
lemma mem_upShadow_iff_exists_mem_card_add_one :
    t ∈ ∂⁺ 𝒜 ↔ ∃ s ∈ 𝒜, s ⊆ t ∧ t.card = s.card + 1 
Arguments: {α : Type u_1} [DecidableEq α] [Fintype α] {𝒜 : Finset (Finset α)} {t : Finset α}
Goal: t ∈ 𝒜.upShadow ↔ ∃ s ∈ 𝒜, s ⊆ t ∧ t.card = s.card + 1
-- Finset.mem_upShadow_iterate_iff_exists_card
lemma mem_upShadow_iterate_iff_exists_card :
    t ∈ ∂⁺^[k] 𝒜 ↔ ∃ u : Finset α, u.card = k ∧ u ⊆ t ∧ t \ u ∈ 𝒜 
Arguments: {α : Type u_1} [DecidableEq α] [Fintype α] {𝒜 : Finset (Finset α)} {t : Finset α} {k : ℕ}
Goal: t ∈ Finset.upShadow^[k] 𝒜 ↔ ∃ u, u.card = k ∧ u ⊆ t ∧ t \ u ∈ 𝒜
-- Finset.mem_upShadow_iterate_iff_exists_sdiff
lemma mem_upShadow_iterate_iff_exists_sdiff :
    t ∈ ∂⁺^[k] 𝒜 ↔ ∃ s ∈ 𝒜, s ⊆ t ∧ (t \ s).card = k 
Arguments: {α : Type u_1} [DecidableEq α] [Fintype α] {𝒜 : Finset (Finset α)} {t : Finset α} {k : ℕ}
Goal: t ∈ Finset.upShadow^[k] 𝒜 ↔ ∃ s ∈ 𝒜, s ⊆ t ∧ (t \ s).card = k
-- Finset.mem_upShadow_iterate_iff_exists_mem_card_add
lemma mem_upShadow_iterate_iff_exists_mem_card_add :
    t ∈ ∂⁺^[k] 𝒜 ↔ ∃ s ∈ 𝒜, s ⊆ t ∧ t.card = s.card + k 
Arguments: {α : Type u_1} [DecidableEq α] [Fintype α] {𝒜 : Finset (Finset α)} {t : Finset α} {k : ℕ}
Goal: t ∈ Finset.upShadow^[k] 𝒜 ↔ ∃ s ∈ 𝒜, s ⊆ t ∧ t.card = s.card + k
-- Set.Sized.upShadow
protected lemma _root_.Set.Sized.upShadow (h𝒜 : (𝒜 : Set (Finset α)).Sized r) :
    (∂⁺ 𝒜 : Set (Finset α)).Sized (r + 1) 
Arguments: {α : Type u_1} [DecidableEq α] [Fintype α] {𝒜 : Finset (Finset α)} {r : ℕ} (h𝒜 : Set.Sized r ↑𝒜)
Goal: Set.Sized (r + 1) ↑𝒜.upShadow
-- Finset.exists_subset_of_mem_upShadow
theorem exists_subset_of_mem_upShadow (hs : s ∈ ∂⁺ 𝒜) : ∃ t ∈ 𝒜, t ⊆ s 
Arguments: {α : Type u_1} [DecidableEq α] [Fintype α] {𝒜 : Finset (Finset α)} {s : Finset α} (hs : s ∈ 𝒜.upShadow)
Goal: ∃ t ∈ 𝒜, t ⊆ s
-- Finset.mem_upShadow_iff_exists_mem_card_add
theorem mem_upShadow_iff_exists_mem_card_add :
    s ∈ ∂⁺ ^[k] 𝒜 ↔ ∃ t ∈ 𝒜, t ⊆ s ∧ t.card + k = s.card 
Arguments: {α : Type u_1} [DecidableEq α] [Fintype α] {𝒜 : Finset (Finset α)} {s : Finset α} {k : ℕ}
Goal: s ∈ Finset.upShadow^[k] 𝒜 ↔ ∃ t ∈ 𝒜, t ⊆ s ∧ t.card + k = s.card
-- Finset.shadow_compls
@[simp] lemma shadow_compls : ∂ 𝒜ᶜˢ = (∂⁺ 𝒜)ᶜˢ 
Arguments: {α : Type u_1} [DecidableEq α] [Fintype α] {𝒜 : Finset (Finset α)}
Goal: 𝒜.compls.shadow = 𝒜.upShadow.compls
-- Finset.upShadow_compls
@[simp] lemma upShadow_compls : ∂⁺ 𝒜ᶜˢ = (∂ 𝒜)ᶜˢ 
Arguments: {α : Type u_1} [DecidableEq α] [Fintype α] {𝒜 : Finset (Finset α)}
Goal: 𝒜.compls.upShadow = 𝒜.shadow.compls
-- SimpleGraph.incMatrix_apply
theorem incMatrix_apply [Zero R] [One R] {a : α} {e : Sym2 α} :
    G.incMatrix R a e = (G.incidenceSet a).indicator 1 e 
Arguments: {R : Type u_1} {α : Type u_2} (G : SimpleGraph α) [Zero R] [One R] {a : α} {e : Sym2 α}
Goal: SimpleGraph.incMatrix R G a e = (G.incidenceSet a).indicator 1 e
-- SimpleGraph.incMatrix_apply'
theorem incMatrix_apply' [Zero R] [One R] [DecidableEq α] [DecidableRel G.Adj] {a : α}
    {e : Sym2 α} : G.incMatrix R a e = if e ∈ G.incidenceSet a then 1 else 0 
Arguments: {R : Type u_1} {α : Type u_2} (G : SimpleGraph α) [Zero R] [One R] [DecidableEq α] [DecidableRel G.Adj] {a : α} {e : Sym2 α}
Goal: SimpleGraph.incMatrix R G a e = if e ∈ G.incidenceSet a then 1 else 0
-- SimpleGraph.incMatrix_apply_mul_incMatrix_apply
theorem incMatrix_apply_mul_incMatrix_apply : G.incMatrix R a e * G.incMatrix R b e =
    (G.incidenceSet a ∩ G.incidenceSet b).indicator 1 e 
Arguments: {R : Type u_1} {α : Type u_2} (G : SimpleGraph α) [MulZeroOneClass R] {a b : α} {e : Sym2 α}
Goal: SimpleGraph.incMatrix R G a e * SimpleGraph.incMatrix R G b e = (G.incidenceSet a ∩ G.incidenceSet b).indicator 1 e
-- SimpleGraph.incMatrix_apply_mul_incMatrix_apply_of_not_adj
theorem incMatrix_apply_mul_incMatrix_apply_of_not_adj (hab : a ≠ b) (h : ¬G.Adj a b) :
    G.incMatrix R a e * G.incMatrix R b e = 0 
Arguments: {R : Type u_1} {α : Type u_2} (G : SimpleGraph α) [MulZeroOneClass R] {a b : α} {e : Sym2 α} (hab : a ≠ b) (h : ¬G.Adj a b)
Goal: SimpleGraph.incMatrix R G a e * SimpleGraph.incMatrix R G b e = 0
-- SimpleGraph.incMatrix_of_not_mem_incidenceSet
theorem incMatrix_of_not_mem_incidenceSet (h : e ∉ G.incidenceSet a) : G.incMatrix R a e = 0 
Arguments: {R : Type u_1} {α : Type u_2} (G : SimpleGraph α) [MulZeroOneClass R] {a : α} {e : Sym2 α} (h : e ∉ G.incidenceSet a)
Goal: SimpleGraph.incMatrix R G a e = 0
-- SimpleGraph.incMatrix_of_mem_incidenceSet
theorem incMatrix_of_mem_incidenceSet (h : e ∈ G.incidenceSet a) : G.incMatrix R a e = 1 
Arguments: {R : Type u_1} {α : Type u_2} (G : SimpleGraph α) [MulZeroOneClass R] {a : α} {e : Sym2 α} (h : e ∈ G.incidenceSet a)
Goal: SimpleGraph.incMatrix R G a e = 1
-- SimpleGraph.incMatrix_apply_eq_zero_iff
theorem incMatrix_apply_eq_zero_iff : G.incMatrix R a e = 0 ↔ e ∉ G.incidenceSet a 
Arguments: {R : Type u_1} {α : Type u_2} (G : SimpleGraph α) [MulZeroOneClass R] {a : α} {e : Sym2 α} [Nontrivial R]
Goal: SimpleGraph.incMatrix R G a e = 0 ↔ e ∉ G.incidenceSet a
-- SimpleGraph.incMatrix_apply_eq_one_iff
theorem incMatrix_apply_eq_one_iff : G.incMatrix R a e = 1 ↔ e ∈ G.incidenceSet a 
Arguments: {R : Type u_1} {α : Type u_2} (G : SimpleGraph α) [MulZeroOneClass R] {a : α} {e : Sym2 α} [Nontrivial R]
Goal: SimpleGraph.incMatrix R G a e = 1 ↔ e ∈ G.incidenceSet a
-- SimpleGraph.sum_incMatrix_apply
theorem sum_incMatrix_apply [Fintype (neighborSet G a)] :
    ∑ e, G.incMatrix R a e = G.degree a 
Arguments: {R : Type u_1} {α : Type u_2} (G : SimpleGraph α) [Fintype (Sym2 α)] [NonAssocSemiring R] {a : α} [Fintype ↑(G.neighborSet a)]
Goal: ∑ e : Sym2 α, SimpleGraph.incMatrix R G a e = ↑(G.degree a)
-- SimpleGraph.incMatrix_mul_transpose_diag
theorem incMatrix_mul_transpose_diag [Fintype (neighborSet G a)] :
    (G.incMatrix R * (G.incMatrix R)ᵀ) a a = G.degree a 
Arguments: {R : Type u_1} {α : Type u_2} (G : SimpleGraph α) [Fintype (Sym2 α)] [NonAssocSemiring R] {a : α} [Fintype ↑(G.neighborSet a)]
Goal: (SimpleGraph.incMatrix R G * (SimpleGraph.incMatrix R G)ᵀ) a a = ↑(G.degree a)
-- SimpleGraph.sum_incMatrix_apply_of_mem_edgeSet
theorem sum_incMatrix_apply_of_mem_edgeSet [Fintype α] :
    e ∈ G.edgeSet → ∑ a, G.incMatrix R a e = 2 
Arguments: {R : Type u_1} {α : Type u_2} (G : SimpleGraph α) [NonAssocSemiring R] {e : Sym2 α} [Fintype α]
Goal: e ∈ G.edgeSet → ∑ a : α, SimpleGraph.incMatrix R G a e = 2
-- SimpleGraph.sum_incMatrix_apply_of_not_mem_edgeSet
theorem sum_incMatrix_apply_of_not_mem_edgeSet [Fintype α] (h : e ∉ G.edgeSet) :
    ∑ a, G.incMatrix R a e = 0 
Arguments: {R : Type u_1} {α : Type u_2} (G : SimpleGraph α) [NonAssocSemiring R] {e : Sym2 α} [Fintype α] (h : e ∉ G.edgeSet)
Goal: ∑ a : α, SimpleGraph.incMatrix R G a e = 0
-- SimpleGraph.incMatrix_transpose_mul_diag
theorem incMatrix_transpose_mul_diag [Fintype α] [Decidable (e ∈ G.edgeSet)] :
    ((G.incMatrix R)ᵀ * G.incMatrix R) e e = if e ∈ G.edgeSet then 2 else 0 
Arguments: {R : Type u_1} {α : Type u_2} (G : SimpleGraph α) [NonAssocSemiring R] {e : Sym2 α} [Fintype α] [Decidable (e ∈ G.edgeSet)]
Goal: ((SimpleGraph.incMatrix R G)ᵀ * SimpleGraph.incMatrix R G) e e = if e ∈ G.edgeSet then 2 else 0
-- SimpleGraph.incMatrix_mul_transpose_apply_of_adj
theorem incMatrix_mul_transpose_apply_of_adj (h : G.Adj a b) :
    (G.incMatrix R * (G.incMatrix R)ᵀ) a b = (1 : R) 
Arguments: {R : Type u_1} {α : Type u_2} (G : SimpleGraph α) [Fintype (Sym2 α)] [Semiring R] {a b : α} (h : G.Adj a b)
Goal: (SimpleGraph.incMatrix R G * (SimpleGraph.incMatrix R G)ᵀ) a b = 1
-- SimpleGraph.incMatrix_mul_transpose
theorem incMatrix_mul_transpose
    [∀ a, Fintype (neighborSet G a)] [DecidableEq α] [DecidableRel G.Adj] :
    G.incMatrix R * (G.incMatrix R)ᵀ = fun a b =>
      if a = b then (G.degree a : R) else if G.Adj a b then 1 else 0 
Arguments: {R : Type u_1} {α : Type u_2} (G : SimpleGraph α) [Fintype (Sym2 α)] [Semiring R] [(a : α) → Fintype ↑(G.neighborSet a)] [DecidableEq α] [DecidableRel G.Adj]
Goal: SimpleGraph.incMatrix R G * (SimpleGraph.incMatrix R G)ᵀ = fun a b =>
  if a = b then ↑(G.degree a) else if G.Adj a b then 1 else 0
-- SetTheory.PGame.leftMoves_mk
@[simp]
theorem leftMoves_mk {xl xr xL xR} : (⟨xl, xr, xL, xR⟩ : PGame).LeftMoves = xl 
Arguments: {xl xr : Type u_1} {xL : xl → SetTheory.PGame} {xR : xr → SetTheory.PGame}
Goal: (SetTheory.PGame.mk xl xr xL xR).LeftMoves = xl
-- SetTheory.PGame.moveLeft_mk
@[simp]
theorem moveLeft_mk {xl xr xL xR} : (⟨xl, xr, xL, xR⟩ : PGame).moveLeft = xL 
Arguments: {xl xr : Type u_1} {xL : xl → SetTheory.PGame} {xR : xr → SetTheory.PGame}
Goal: (SetTheory.PGame.mk xl xr xL xR).moveLeft = xL
-- SetTheory.PGame.rightMoves_mk
@[simp]
theorem rightMoves_mk {xl xr xL xR} : (⟨xl, xr, xL, xR⟩ : PGame).RightMoves = xr 
Arguments: {xl xr : Type u_1} {xL : xl → SetTheory.PGame} {xR : xr → SetTheory.PGame}
Goal: (SetTheory.PGame.mk xl xr xL xR).RightMoves = xr
-- SetTheory.PGame.moveRight_mk
@[simp]
theorem moveRight_mk {xl xr xL xR} : (⟨xl, xr, xL, xR⟩ : PGame).moveRight = xR 
Arguments: {xl xr : Type u_1} {xL : xl → SetTheory.PGame} {xR : xr → SetTheory.PGame}
Goal: (SetTheory.PGame.mk xl xr xL xR).moveRight = xR
-- SetTheory.PGame.leftMoves_ofLists
theorem leftMoves_ofLists (L R : List PGame) : (ofLists L R).LeftMoves = ULift (Fin L.length) 
Arguments: (L R : List SetTheory.PGame)
Goal: (SetTheory.PGame.ofLists L R).LeftMoves = ULift.{u_1, 0} (Fin L.length)
-- SetTheory.PGame.rightMoves_ofLists
theorem rightMoves_ofLists (L R : List PGame) : (ofLists L R).RightMoves = ULift (Fin R.length) 
Arguments: (L R : List SetTheory.PGame)
Goal: (SetTheory.PGame.ofLists L R).RightMoves = ULift.{u_1, 0} (Fin R.length)
-- SetTheory.PGame.ofLists_moveLeft
theorem ofLists_moveLeft {L R : List PGame} (i : Fin L.length) :
    (ofLists L R).moveLeft (toOfListsLeftMoves i) = L.get i 
Arguments: {L R : List SetTheory.PGame} (i : Fin L.length)
Goal: (SetTheory.PGame.ofLists L R).moveLeft (SetTheory.PGame.toOfListsLeftMoves i) = L.get i
-- SetTheory.PGame.ofLists_moveLeft'
@[simp]
theorem ofLists_moveLeft' {L R : List PGame} (i : (ofLists L R).LeftMoves) :
    (ofLists L R).moveLeft i = L.get (toOfListsLeftMoves.symm i) 
Arguments: {L R : List SetTheory.PGame} (i : (SetTheory.PGame.ofLists L R).LeftMoves)
Goal: (SetTheory.PGame.ofLists L R).moveLeft i = L.get (SetTheory.PGame.toOfListsLeftMoves.symm i)
-- SetTheory.PGame.ofLists_moveRight
theorem ofLists_moveRight {L R : List PGame} (i : Fin R.length) :
    (ofLists L R).moveRight (toOfListsRightMoves i) = R.get i 
Arguments: {L R : List SetTheory.PGame} (i : Fin R.length)
Goal: (SetTheory.PGame.ofLists L R).moveRight (SetTheory.PGame.toOfListsRightMoves i) = R.get i
-- SetTheory.PGame.ofLists_moveRight'
@[simp]
theorem ofLists_moveRight' {L R : List PGame} (i : (ofLists L R).RightMoves) :
    (ofLists L R).moveRight i = R.get (toOfListsRightMoves.symm i) 
Arguments: {L R : List SetTheory.PGame} (i : (SetTheory.PGame.ofLists L R).RightMoves)
Goal: (SetTheory.PGame.ofLists L R).moveRight i = R.get (SetTheory.PGame.toOfListsRightMoves.symm i)
-- SetTheory.PGame.isOption_iff
@[mk_iff]
inductive IsOption : PGame → PGame → Prop
  | moveLeft {x : PGame} (i : x.LeftMoves) : IsOption (x.moveLeft i) x
  | moveRight {x : PGame} (i : x.RightMoves) : IsOption (x.moveRight i) x
Goal: ∀ (a a_1 : SetTheory.PGame), a.IsOption a_1 ↔ (∃ i, a = a_1.moveLeft i) ∨ ∃ i, a = a_1.moveRight i
-- SetTheory.PGame.IsOption.mk_left
theorem IsOption.mk_left {xl xr : Type u} (xL : xl → PGame) (xR : xr → PGame) (i : xl) :
    (xL i).IsOption (mk xl xr xL xR) 
Arguments: {xl xr : Type u} (xL : xl → SetTheory.PGame) (xR : xr → SetTheory.PGame) (i : xl)
Goal: (xL i).IsOption (SetTheory.PGame.mk xl xr xL xR)
-- SetTheory.PGame.IsOption.mk_right
theorem IsOption.mk_right {xl xr : Type u} (xL : xl → PGame) (xR : xr → PGame) (i : xr) :
    (xR i).IsOption (mk xl xr xL xR) 
Arguments: {xl xr : Type u} (xL : xl → SetTheory.PGame) (xR : xr → SetTheory.PGame) (i : xr)
Goal: (xR i).IsOption (SetTheory.PGame.mk xl xr xL xR)
-- SetTheory.PGame.wf_isOption
theorem wf_isOption : WellFounded IsOption 
Goal: WellFounded SetTheory.PGame.IsOption
-- SetTheory.PGame.Subsequent.trans
@[trans]
theorem Subsequent.trans {x y z} : Subsequent x y → Subsequent y z → Subsequent x z 
Arguments: {x y z : SetTheory.PGame}
Goal: x.Subsequent y → y.Subsequent z → x.Subsequent z
-- SetTheory.PGame.wf_subsequent
theorem wf_subsequent : WellFounded Subsequent 
Goal: WellFounded SetTheory.PGame.Subsequent
-- SetTheory.PGame.Subsequent.moveLeft
@[simp]
theorem Subsequent.moveLeft {x : PGame} (i : x.LeftMoves) : Subsequent (x.moveLeft i) x 
Arguments: {x : SetTheory.PGame} (i : x.LeftMoves)
Goal: (x.moveLeft i).Subsequent x
-- SetTheory.PGame.Subsequent.moveRight
@[simp]
theorem Subsequent.moveRight {x : PGame} (j : x.RightMoves) : Subsequent (x.moveRight j) x 
Arguments: {x : SetTheory.PGame} (j : x.RightMoves)
Goal: (x.moveRight j).Subsequent x
-- SetTheory.PGame.Subsequent.mk_left
@[simp]
theorem Subsequent.mk_left {xl xr} (xL : xl → PGame) (xR : xr → PGame) (i : xl) :
    Subsequent (xL i) (mk xl xr xL xR) 
Arguments: {xl xr : Type u_1} (xL : xl → SetTheory.PGame) (xR : xr → SetTheory.PGame) (i : xl)
Goal: (xL i).Subsequent (SetTheory.PGame.mk xl xr xL xR)