ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- Finset.addDysonETransform_fst
@[to_additive (attr := simps) "The **Dyson e-transform**.
Turns `(s, t)` into `(s ∪ e +ᵥ t, t ∩ -e +ᵥ s)`. This reduces the sum of the two sets."]
def mulDysonETransform : Finset α × Finset α 
Arguments: {α : Type u_1} [DecidableEq α] [AddCommGroup α] (e : α) (x : Finset α × Finset α)
Goal: (Finset.addDysonETransform e x).1 = x.1 ∪ (e +ᵥ x.2)
-- Finset.mulDysonETransform_snd
@[to_additive (attr := simps) "The **Dyson e-transform**.
Turns `(s, t)` into `(s ∪ e +ᵥ t, t ∩ -e +ᵥ s)`. This reduces the sum of the two sets."]
def mulDysonETransform : Finset α × Finset α 
Arguments: {α : Type u_1} [DecidableEq α] [CommGroup α] (e : α) (x : Finset α × Finset α)
Goal: (Finset.mulDysonETransform e x).2 = x.2 ∩ e⁻¹ • x.1
-- Finset.mulDysonETransform.subset
@[to_additive]
theorem mulDysonETransform.subset :
    (mulDysonETransform e x).1 * (mulDysonETransform e x).2 ⊆ x.1 * x.2 
Arguments: {α : Type u_1} [DecidableEq α] [CommGroup α] (e : α) (x : Finset α × Finset α)
Goal: (Finset.mulDysonETransform e x).1 * (Finset.mulDysonETransform e x).2 ⊆ x.1 * x.2
-- Finset.addDysonETransform.subset
@[to_additive]
theorem mulDysonETransform.subset :
    (mulDysonETransform e x).1 * (mulDysonETransform e x).2 ⊆ x.1 * x.2 
Arguments: {α : Type u_1} [DecidableEq α] [AddCommGroup α] (e : α) (x : Finset α × Finset α)
Goal: (Finset.addDysonETransform e x).1 + (Finset.addDysonETransform e x).2 ⊆ x.1 + x.2
-- Finset.mulDysonETransform.card
@[to_additive]
theorem mulDysonETransform.card :
    (mulDysonETransform e x).1.card + (mulDysonETransform e x).2.card = x.1.card + x.2.card 
Arguments: {α : Type u_1} [DecidableEq α] [CommGroup α] (e : α) (x : Finset α × Finset α)
Goal: (Finset.mulDysonETransform e x).1.card + (Finset.mulDysonETransform e x).2.card = x.1.card + x.2.card
-- Finset.addDysonETransform.card
@[to_additive]
theorem mulDysonETransform.card :
    (mulDysonETransform e x).1.card + (mulDysonETransform e x).2.card = x.1.card + x.2.card 
Arguments: {α : Type u_1} [DecidableEq α] [AddCommGroup α] (e : α) (x : Finset α × Finset α)
Goal: (Finset.addDysonETransform e x).1.card + (Finset.addDysonETransform e x).2.card = x.1.card + x.2.card
-- Finset.addDysonETransform_idem
@[to_additive (attr := simp)]
theorem mulDysonETransform_idem :
    mulDysonETransform e (mulDysonETransform e x) = mulDysonETransform e x 
Arguments: {α : Type u_1} [DecidableEq α] [AddCommGroup α] (e : α) (x : Finset α × Finset α)
Goal: Finset.addDysonETransform e (Finset.addDysonETransform e x) = Finset.addDysonETransform e x
-- Finset.mulDysonETransform_idem
@[to_additive (attr := simp)]
theorem mulDysonETransform_idem :
    mulDysonETransform e (mulDysonETransform e x) = mulDysonETransform e x 
Arguments: {α : Type u_1} [DecidableEq α] [CommGroup α] (e : α) (x : Finset α × Finset α)
Goal: Finset.mulDysonETransform e (Finset.mulDysonETransform e x) = Finset.mulDysonETransform e x
-- Finset.mulDysonETransform.smul_finset_snd_subset_fst
@[to_additive]
theorem mulDysonETransform.smul_finset_snd_subset_fst :
    e • (mulDysonETransform e x).2 ⊆ (mulDysonETransform e x).1 
Arguments: {α : Type u_1} [DecidableEq α] [CommGroup α] {e : α} {x : Finset α × Finset α}
Goal: e • (Finset.mulDysonETransform e x).2 ⊆ (Finset.mulDysonETransform e x).1
-- Finset.addDysonETransform.vadd_finset_snd_subset_fst
@[to_additive]
theorem mulDysonETransform.smul_finset_snd_subset_fst :
    e • (mulDysonETransform e x).2 ⊆ (mulDysonETransform e x).1 
Arguments: {α : Type u_1} [DecidableEq α] [AddCommGroup α] {e : α} {x : Finset α × Finset α}
Goal: e +ᵥ (Finset.addDysonETransform e x).2 ⊆ (Finset.addDysonETransform e x).1
-- Finset.addETransformLeft_fst
@[to_additive (attr := simps) "An **e-transform**.
Turns `(s, t)` into `(s ∩ s +ᵥ e, t ∪ -e +ᵥ t)`. This reduces the sum of the two sets."]
def mulETransformLeft : Finset α × Finset α 
Arguments: {α : Type u_1} [DecidableEq α] [AddGroup α] (e : α) (x : Finset α × Finset α)
Goal: (Finset.addETransformLeft e x).1 = x.1 ∩ (AddOpposite.op e +ᵥ x.1)
-- Finset.mulETransformLeft_fst
@[to_additive (attr := simps) "An **e-transform**.
Turns `(s, t)` into `(s ∩ s +ᵥ e, t ∪ -e +ᵥ t)`. This reduces the sum of the two sets."]
def mulETransformLeft : Finset α × Finset α 
Arguments: {α : Type u_1} [DecidableEq α] [Group α] (e : α) (x : Finset α × Finset α)
Goal: (Finset.mulETransformLeft e x).1 = x.1 ∩ MulOpposite.op e • x.1
-- Finset.addETransformLeft_snd
@[to_additive (attr := simps) "An **e-transform**.
Turns `(s, t)` into `(s ∩ s +ᵥ e, t ∪ -e +ᵥ t)`. This reduces the sum of the two sets."]
def mulETransformLeft : Finset α × Finset α 
Arguments: {α : Type u_1} [DecidableEq α] [AddGroup α] (e : α) (x : Finset α × Finset α)
Goal: (Finset.addETransformLeft e x).2 = x.2 ∪ (-e +ᵥ x.2)
-- Finset.mulETransformLeft_snd
@[to_additive (attr := simps) "An **e-transform**.
Turns `(s, t)` into `(s ∩ s +ᵥ e, t ∪ -e +ᵥ t)`. This reduces the sum of the two sets."]
def mulETransformLeft : Finset α × Finset α 
Arguments: {α : Type u_1} [DecidableEq α] [Group α] (e : α) (x : Finset α × Finset α)
Goal: (Finset.mulETransformLeft e x).2 = x.2 ∪ e⁻¹ • x.2
-- Finset.mulETransformRight_fst
@[to_additive (attr := simps) "An **e-transform**.
Turns `(s, t)` into `(s ∪ s +ᵥ e, t ∩ -e +ᵥ t)`. This reduces the sum of the two sets."]
def mulETransformRight : Finset α × Finset α 
Arguments: {α : Type u_1} [DecidableEq α] [Group α] (e : α) (x : Finset α × Finset α)
Goal: (Finset.mulETransformRight e x).1 = x.1 ∪ MulOpposite.op e • x.1
-- Finset.mulETransformRight_snd
@[to_additive (attr := simps) "An **e-transform**.
Turns `(s, t)` into `(s ∪ s +ᵥ e, t ∩ -e +ᵥ t)`. This reduces the sum of the two sets."]
def mulETransformRight : Finset α × Finset α 
Arguments: {α : Type u_1} [DecidableEq α] [Group α] (e : α) (x : Finset α × Finset α)
Goal: (Finset.mulETransformRight e x).2 = x.2 ∩ e⁻¹ • x.2
-- Finset.addETransformRight_snd
@[to_additive (attr := simps) "An **e-transform**.
Turns `(s, t)` into `(s ∪ s +ᵥ e, t ∩ -e +ᵥ t)`. This reduces the sum of the two sets."]
def mulETransformRight : Finset α × Finset α 
Arguments: {α : Type u_1} [DecidableEq α] [AddGroup α] (e : α) (x : Finset α × Finset α)
Goal: (Finset.addETransformRight e x).2 = x.2 ∩ (-e +ᵥ x.2)
-- Finset.addETransformRight_fst
@[to_additive (attr := simps) "An **e-transform**.
Turns `(s, t)` into `(s ∪ s +ᵥ e, t ∩ -e +ᵥ t)`. This reduces the sum of the two sets."]
def mulETransformRight : Finset α × Finset α 
Arguments: {α : Type u_1} [DecidableEq α] [AddGroup α] (e : α) (x : Finset α × Finset α)
Goal: (Finset.addETransformRight e x).1 = x.1 ∪ (AddOpposite.op e +ᵥ x.1)
-- Finset.mulETransformLeft_one
@[to_additive (attr := simp)]
theorem mulETransformLeft_one : mulETransformLeft 1 x = x 
Arguments: {α : Type u_1} [DecidableEq α] [Group α] (x : Finset α × Finset α)
Goal: Finset.mulETransformLeft 1 x = x
-- Finset.addETransformLeft_zero
@[to_additive (attr := simp)]
theorem mulETransformLeft_one : mulETransformLeft 1 x = x 
Arguments: {α : Type u_1} [DecidableEq α] [AddGroup α] (x : Finset α × Finset α)
Goal: Finset.addETransformLeft 0 x = x
-- Finset.mulETransformRight_one
@[to_additive (attr := simp)]
theorem mulETransformRight_one : mulETransformRight 1 x = x 
Arguments: {α : Type u_1} [DecidableEq α] [Group α] (x : Finset α × Finset α)
Goal: Finset.mulETransformRight 1 x = x
-- Finset.addETransformRight_zero
@[to_additive (attr := simp)]
theorem mulETransformRight_one : mulETransformRight 1 x = x 
Arguments: {α : Type u_1} [DecidableEq α] [AddGroup α] (x : Finset α × Finset α)
Goal: Finset.addETransformRight 0 x = x
-- Finset.mulETransformLeft.fst_mul_snd_subset
@[to_additive]
theorem mulETransformLeft.fst_mul_snd_subset :
    (mulETransformLeft e x).1 * (mulETransformLeft e x).2 ⊆ x.1 * x.2 
Arguments: {α : Type u_1} [DecidableEq α] [Group α] (e : α) (x : Finset α × Finset α)
Goal: (Finset.mulETransformLeft e x).1 * (Finset.mulETransformLeft e x).2 ⊆ x.1 * x.2
-- Finset.addETransformLeft.fst_add_snd_subset
@[to_additive]
theorem mulETransformLeft.fst_mul_snd_subset :
    (mulETransformLeft e x).1 * (mulETransformLeft e x).2 ⊆ x.1 * x.2 
Arguments: {α : Type u_1} [DecidableEq α] [AddGroup α] (e : α) (x : Finset α × Finset α)
Goal: (Finset.addETransformLeft e x).1 + (Finset.addETransformLeft e x).2 ⊆ x.1 + x.2
-- Finset.mulETransformRight.fst_mul_snd_subset
@[to_additive]
theorem mulETransformRight.fst_mul_snd_subset :
    (mulETransformRight e x).1 * (mulETransformRight e x).2 ⊆ x.1 * x.2 
Arguments: {α : Type u_1} [DecidableEq α] [Group α] (e : α) (x : Finset α × Finset α)
Goal: (Finset.mulETransformRight e x).1 * (Finset.mulETransformRight e x).2 ⊆ x.1 * x.2
-- Finset.addETransformRight.fst_add_snd_subset
@[to_additive]
theorem mulETransformRight.fst_mul_snd_subset :
    (mulETransformRight e x).1 * (mulETransformRight e x).2 ⊆ x.1 * x.2 
Arguments: {α : Type u_1} [DecidableEq α] [AddGroup α] (e : α) (x : Finset α × Finset α)
Goal: (Finset.addETransformRight e x).1 + (Finset.addETransformRight e x).2 ⊆ x.1 + x.2
-- Finset.addETransformLeft.card
@[to_additive]
theorem mulETransformLeft.card :
    (mulETransformLeft e x).1.card + (mulETransformRight e x).1.card = 2 * x.1.card 
Arguments: {α : Type u_1} [DecidableEq α] [AddGroup α] (e : α) (x : Finset α × Finset α)
Goal: (Finset.addETransformLeft e x).1.card + (Finset.addETransformRight e x).1.card = 2 * x.1.card
-- Finset.mulETransformLeft.card
@[to_additive]
theorem mulETransformLeft.card :
    (mulETransformLeft e x).1.card + (mulETransformRight e x).1.card = 2 * x.1.card 
Arguments: {α : Type u_1} [DecidableEq α] [Group α] (e : α) (x : Finset α × Finset α)
Goal: (Finset.mulETransformLeft e x).1.card + (Finset.mulETransformRight e x).1.card = 2 * x.1.card
-- Finset.mulETransformRight.card
@[to_additive]
theorem mulETransformRight.card :
    (mulETransformLeft e x).2.card + (mulETransformRight e x).2.card = 2 * x.2.card 
Arguments: {α : Type u_1} [DecidableEq α] [Group α] (e : α) (x : Finset α × Finset α)
Goal: (Finset.mulETransformLeft e x).2.card + (Finset.mulETransformRight e x).2.card = 2 * x.2.card
-- Finset.addETransformRight.card
@[to_additive]
theorem mulETransformRight.card :
    (mulETransformLeft e x).2.card + (mulETransformRight e x).2.card = 2 * x.2.card 
Arguments: {α : Type u_1} [DecidableEq α] [AddGroup α] (e : α) (x : Finset α × Finset α)
Goal: (Finset.addETransformLeft e x).2.card + (Finset.addETransformRight e x).2.card = 2 * x.2.card
-- Finset.AddETransform.card
@[to_additive AddETransform.card "This statement is meant to be combined with
`le_or_lt_of_add_le_add` and similar lemmas."]
protected theorem MulETransform.card :
    (mulETransformLeft e x).1.card + (mulETransformLeft e x).2.card +
        ((mulETransformRight e x).1.card + (mulETransformRight e x).2.card) =
      x.1.card + x.2.card + (x.1.card + x.2.card) 
Arguments: {α : Type u_1} [DecidableEq α] [AddGroup α] (e : α) (x : Finset α × Finset α)
Goal: (Finset.addETransformLeft e x).1.card + (Finset.addETransformLeft e x).2.card +
    ((Finset.addETransformRight e x).1.card + (Finset.addETransformRight e x).2.card) =
  x.1.card + x.2.card + (x.1.card + x.2.card)
-- Finset.MulETransform.card
@[to_additive AddETransform.card "This statement is meant to be combined with
`le_or_lt_of_add_le_add` and similar lemmas."]
protected theorem MulETransform.card :
    (mulETransformLeft e x).1.card + (mulETransformLeft e x).2.card +
        ((mulETransformRight e x).1.card + (mulETransformRight e x).2.card) =
      x.1.card + x.2.card + (x.1.card + x.2.card) 
Arguments: {α : Type u_1} [DecidableEq α] [Group α] (e : α) (x : Finset α × Finset α)
Goal: (Finset.mulETransformLeft e x).1.card + (Finset.mulETransformLeft e x).2.card +
    ((Finset.mulETransformRight e x).1.card + (Finset.mulETransformRight e x).2.card) =
  x.1.card + x.2.card + (x.1.card + x.2.card)
-- Finset.addETransformLeft_neg
@[to_additive (attr := simp)]
theorem mulETransformLeft_inv : mulETransformLeft e⁻¹ x = (mulETransformRight e x.swap).swap 
Arguments: {α : Type u_1} [DecidableEq α] [AddCommGroup α] (e : α) (x : Finset α × Finset α)
Goal: Finset.addETransformLeft (-e) x = (Finset.addETransformRight e x.swap).swap
-- Finset.mulETransformLeft_inv
@[to_additive (attr := simp)]
theorem mulETransformLeft_inv : mulETransformLeft e⁻¹ x = (mulETransformRight e x.swap).swap 
Arguments: {α : Type u_1} [DecidableEq α] [CommGroup α] (e : α) (x : Finset α × Finset α)
Goal: Finset.mulETransformLeft e⁻¹ x = (Finset.mulETransformRight e x.swap).swap
-- Finset.mulETransformRight_inv
@[to_additive (attr := simp)]
theorem mulETransformRight_inv : mulETransformRight e⁻¹ x = (mulETransformLeft e x.swap).swap 
Arguments: {α : Type u_1} [DecidableEq α] [CommGroup α] (e : α) (x : Finset α × Finset α)
Goal: Finset.mulETransformRight e⁻¹ x = (Finset.mulETransformLeft e x.swap).swap
-- Finset.addETransformRight_neg
@[to_additive (attr := simp)]
theorem mulETransformRight_inv : mulETransformRight e⁻¹ x = (mulETransformLeft e x.swap).swap 
Arguments: {α : Type u_1} [DecidableEq α] [AddCommGroup α] (e : α) (x : Finset α × Finset α)
Goal: Finset.addETransformRight (-e) x = (Finset.addETransformLeft e x.swap).swap
-- hallMatchingsOn.nonempty
theorem hallMatchingsOn.nonempty {ι : Type u} {α : Type v} [DecidableEq α] (t : ι → Finset α)
    (h : ∀ s : Finset ι, s.card ≤ (s.biUnion t).card) (ι' : Finset ι) :
    Nonempty (hallMatchingsOn t ι') 
Arguments: {ι : Type u} {α : Type v} [DecidableEq α] (t : ι → Finset α) (h : ∀ (s : Finset ι), s.card ≤ (s.biUnion t).card) (ι' : Finset ι)
Goal: Nonempty ↑(hallMatchingsOn t ι')
-- Finset.all_card_le_biUnion_card_iff_exists_injective
theorem Finset.all_card_le_biUnion_card_iff_exists_injective {ι : Type u} {α : Type v}
    [DecidableEq α] (t : ι → Finset α) :
    (∀ s : Finset ι, s.card ≤ (s.biUnion t).card) ↔
      ∃ f : ι → α, Function.Injective f ∧ ∀ x, f x ∈ t x 
Arguments: {ι : Type u} {α : Type v} [DecidableEq α] (t : ι → Finset α)
Goal: (∀ (s : Finset ι), s.card ≤ (s.biUnion t).card) ↔ ∃ f, Function.Injective f ∧ ∀ (x : ι), f x ∈ t x
-- Fintype.all_card_le_rel_image_card_iff_exists_injective
theorem Fintype.all_card_le_rel_image_card_iff_exists_injective {α : Type u} {β : Type v}
    [DecidableEq β] (r : α → β → Prop) [∀ a : α, Fintype (Rel.image r {a})] :
    (∀ A : Finset α, A.card ≤ Fintype.card (Rel.image r A)) ↔
      ∃ f : α → β, Function.Injective f ∧ ∀ x, r x (f x) 
Arguments: {α : Type u} {β : Type v} [DecidableEq β] (r : α → β → Prop) [(a : α) → Fintype ↑(Rel.image r {a})]
Goal: (∀ (A : Finset α), A.card ≤ Fintype.card ↑(Rel.image r ↑A)) ↔ ∃ f, Function.Injective f ∧ ∀ (x : α), r x (f x)
-- Fintype.all_card_le_filter_rel_iff_exists_injective
theorem Fintype.all_card_le_filter_rel_iff_exists_injective {α : Type u} {β : Type v} [Fintype β]
    (r : α → β → Prop) [∀ a, DecidablePred (r a)] :
    (∀ A : Finset α, A.card ≤ (univ.filter fun b : β => ∃ a ∈ A, r a b).card) ↔
      ∃ f : α → β, Function.Injective f ∧ ∀ x, r x (f x) 
Arguments: {α : Type u} {β : Type v} [Fintype β] (r : α → β → Prop) [(a : α) → DecidablePred (r a)]
Goal: (∀ (A : Finset α), A.card ≤ (Finset.filter (fun b => ∃ a ∈ A, r a b) Finset.univ).card) ↔
  ∃ f, Function.Injective f ∧ ∀ (x : α), r x (f x)
-- IsCorner.add_eq_add
@[mk_iff]
structure IsCorner (A : Set (G × G)) (x₁ y₁ x₂ y₂ : G) : Prop where
  fst_fst_mem : (x₁, y₁) ∈ A
  fst_snd_mem : (x₁, y₂) ∈ A
  snd_fst_mem : (x₂, y₁) ∈ A
  add_eq_add : x₁ + y₂ = x₂ + y₁
Arguments: {G : Type u_1} [AddCommMonoid G] {A : Set (G × G)} {x₁ y₁ x₂ y₂ : G} (self : IsCorner A x₁ y₁ x₂ y₂)
Goal: x₁ + y₂ = x₂ + y₁
-- isCorner_iff
@[mk_iff]
structure IsCorner (A : Set (G × G)) (x₁ y₁ x₂ y₂ : G) : Prop where
  fst_fst_mem : (x₁, y₁) ∈ A
  fst_snd_mem : (x₁, y₂) ∈ A
  snd_fst_mem : (x₂, y₁) ∈ A
  add_eq_add : x₁ + y₂ = x₂ + y₁
Arguments: {G : Type u_1} [AddCommMonoid G] (A : Set (G × G)) (x₁ y₁ x₂ y₂ : G)
Goal: IsCorner A x₁ y₁ x₂ y₂ ↔ (x₁, y₁) ∈ A ∧ (x₁, y₂) ∈ A ∧ (x₂, y₁) ∈ A ∧ x₁ + y₂ = x₂ + y₁
-- IsCorner.snd_fst_mem
@[mk_iff]
structure IsCorner (A : Set (G × G)) (x₁ y₁ x₂ y₂ : G) : Prop where
  fst_fst_mem : (x₁, y₁) ∈ A
  fst_snd_mem : (x₁, y₂) ∈ A
  snd_fst_mem : (x₂, y₁) ∈ A
  add_eq_add : x₁ + y₂ = x₂ + y₁
Arguments: {G : Type u_1} [AddCommMonoid G] {A : Set (G × G)} {x₁ y₁ x₂ y₂ : G} (self : IsCorner A x₁ y₁ x₂ y₂)
Goal: (x₂, y₁) ∈ A
-- IsCorner.fst_snd_mem
@[mk_iff]
structure IsCorner (A : Set (G × G)) (x₁ y₁ x₂ y₂ : G) : Prop where
  fst_fst_mem : (x₁, y₁) ∈ A
  fst_snd_mem : (x₁, y₂) ∈ A
  snd_fst_mem : (x₂, y₁) ∈ A
  add_eq_add : x₁ + y₂ = x₂ + y₁
Arguments: {G : Type u_1} [AddCommMonoid G] {A : Set (G × G)} {x₁ y₁ x₂ y₂ : G} (self : IsCorner A x₁ y₁ x₂ y₂)
Goal: (x₁, y₂) ∈ A
-- IsCorner.fst_fst_mem
@[mk_iff]
structure IsCorner (A : Set (G × G)) (x₁ y₁ x₂ y₂ : G) : Prop where
  fst_fst_mem : (x₁, y₁) ∈ A
  fst_snd_mem : (x₁, y₂) ∈ A
  snd_fst_mem : (x₂, y₁) ∈ A
  add_eq_add : x₁ + y₂ = x₂ + y₁
Arguments: {G : Type u_1} [AddCommMonoid G] {A : Set (G × G)} {x₁ y₁ x₂ y₂ : G} (self : IsCorner A x₁ y₁ x₂ y₂)
Goal: (x₁, y₁) ∈ A
-- isCornerFree_iff
lemma isCornerFree_iff (hAs : A ⊆ s ×ˢ s) :
    IsCornerFree A ↔ ∀ ⦃x₁⦄, x₁ ∈ s → ∀ ⦃y₁⦄, y₁ ∈ s → ∀ ⦃x₂⦄, x₂ ∈ s → ∀ ⦃y₂⦄, y₂ ∈ s →
      IsCorner A x₁ y₁ x₂ y₂ → x₁ = x₂ 
Arguments: {G : Type u_1} [AddCommMonoid G] {A : Set (G × G)} {s : Set G} (hAs : A ⊆ s ×ˢ s)
Goal: IsCornerFree A ↔
  ∀ ⦃x₁ : G⦄, x₁ ∈ s → ∀ ⦃y₁ : G⦄, y₁ ∈ s → ∀ ⦃x₂ : G⦄, x₂ ∈ s → ∀ ⦃y₂ : G⦄, y₂ ∈ s → IsCorner A x₁ y₁ x₂ y₂ → x₁ = x₂
-- IsCorner.mono
lemma IsCorner.mono (hAB : A ⊆ B) (hA : IsCorner A x₁ y₁ x₂ y₂) : IsCorner B x₁ y₁ x₂ y₂ 
Arguments: {G : Type u_1} [AddCommMonoid G] {A B : Set (G × G)} {x₁ y₁ x₂ y₂ : G} (hAB : A ⊆ B) (hA : IsCorner A x₁ y₁ x₂ y₂)
Goal: IsCorner B x₁ y₁ x₂ y₂
-- IsCornerFree.mono
lemma IsCornerFree.mono (hAB : A ⊆ B) (hB : IsCornerFree B) : IsCornerFree A 
Arguments: {G : Type u_1} [AddCommMonoid G] {A B : Set (G × G)} (hAB : A ⊆ B) (hB : IsCornerFree B)
Goal: IsCornerFree A
-- not_isCorner_empty
@[simp] lemma not_isCorner_empty : ¬ IsCorner ∅ x₁ y₁ x₂ y₂ 
Arguments: {G : Type u_1} [AddCommMonoid G] {x₁ y₁ x₂ y₂ : G}
Goal: ¬IsCorner ∅ x₁ y₁ x₂ y₂
-- Set.Subsingleton.isCornerFree
@[simp] lemma Set.Subsingleton.isCornerFree (hA : A.Subsingleton) : IsCornerFree A 
Arguments: {G : Type u_1} [AddCommMonoid G] {A : Set (G × G)} (hA : A.Subsingleton)
Goal: IsCornerFree A
-- isCornerFree_empty
lemma isCornerFree_empty : IsCornerFree (∅ : Set (G × G)) 
Arguments: {G : Type u_1} [AddCommMonoid G]
Goal: IsCornerFree ∅
-- isCornerFree_singleton
lemma isCornerFree_singleton (x : G × G) : IsCornerFree {x} 
Arguments: {G : Type u_1} [AddCommMonoid G] (x : G × G)
Goal: IsCornerFree {x}
-- IsCorner.image
lemma IsCorner.image (hf : IsAddFreimanHom 2 s t f) (hAs : (A : Set (G × G)) ⊆ s ×ˢ s)
    (hA : IsCorner A x₁ y₁ x₂ y₂) : IsCorner (Prod.map f f '' A) (f x₁) (f y₁) (f x₂) (f y₂) 
Arguments: {G : Type u_1} {H : Type u_2} [AddCommMonoid G] [AddCommMonoid H] {A : Set (G × G)} {s : Set G} {t : Set H} {f : G → H} {x₁ y₁ x₂ y₂ : G} (hf : IsAddFreimanHom 2 s t f) (hAs : A ⊆ s ×ˢ s) (hA : IsCorner A x₁ y₁ x₂ y₂)
Goal: IsCorner (Prod.map f f '' A) (f x₁) (f y₁) (f x₂) (f y₂)
-- IsCornerFree.of_image
lemma IsCornerFree.of_image (hf : IsAddFreimanHom 2 s t f) (hf' : s.InjOn f)
    (hAs : (A : Set (G × G)) ⊆ s ×ˢ s) (hA : IsCornerFree (Prod.map f f '' A)) : IsCornerFree A 
Arguments: {G : Type u_1} {H : Type u_2} [AddCommMonoid G] [AddCommMonoid H] {A : Set (G × G)} {s : Set G} {t : Set H} {f : G → H} (hf : IsAddFreimanHom 2 s t f) (hf' : Set.InjOn f s) (hAs : A ⊆ s ×ˢ s) (hA : IsCornerFree (Prod.map f f '' A))
Goal: IsCornerFree A
-- isCorner_image
lemma isCorner_image (hf : IsAddFreimanIso 2 s t f) (hAs : A ⊆ s ×ˢ s)
    (hx₁ : x₁ ∈ s) (hy₁ : y₁ ∈ s) (hx₂ : x₂ ∈ s) (hy₂ : y₂ ∈ s) :
    IsCorner (Prod.map f f '' A) (f x₁) (f y₁) (f x₂) (f y₂) ↔ IsCorner A x₁ y₁ x₂ y₂ 
Arguments: {G : Type u_1} {H : Type u_2} [AddCommMonoid G] [AddCommMonoid H] {A : Set (G × G)} {s : Set G} {t : Set H} {f : G → H} {x₁ y₁ x₂ y₂ : G} (hf : IsAddFreimanIso 2 s t f) (hAs : A ⊆ s ×ˢ s) (hx₁ : x₁ ∈ s) (hy₁ : y₁ ∈ s) (hx₂ : x₂ ∈ s) (hy₂ : y₂ ∈ s)
Goal: IsCorner (Prod.map f f '' A) (f x₁) (f y₁) (f x₂) (f y₂) ↔ IsCorner A x₁ y₁ x₂ y₂
-- isCornerFree_image
lemma isCornerFree_image (hf : IsAddFreimanIso 2 s t f) (hAs : A ⊆ s ×ˢ s) :
    IsCornerFree (Prod.map f f '' A) ↔ IsCornerFree A 
Arguments: {G : Type u_1} {H : Type u_2} [AddCommMonoid G] [AddCommMonoid H] {A : Set (G × G)} {s : Set G} {t : Set H} {f : G → H} (hf : IsAddFreimanIso 2 s t f) (hAs : A ⊆ s ×ˢ s)
Goal: IsCornerFree (Prod.map f f '' A) ↔ IsCornerFree A
-- ONote.zero_def
@[simp]
theorem zero_def : zero = 0 
Goal: ONote.zero = 0
-- ONote.lt_def
theorem lt_def {x y : ONote} : x < y ↔ repr x < repr y 
Arguments: {x y : ONote}
Goal: x < y ↔ x.repr < y.repr
-- ONote.le_def
theorem le_def {x y : ONote} : x ≤ y ↔ repr x ≤ repr y 
Arguments: {x y : ONote}
Goal: x ≤ y ↔ x.repr ≤ y.repr
-- ONote.ofNat_zero
@[simp] theorem ofNat_zero : ofNat 0 = 0 
Goal: ↑0 = 0
-- ONote.ofNat_succ
@[simp] theorem ofNat_succ (n) : ofNat (Nat.succ n) = oadd 0 n.succPNat 0 
Arguments: (n : ℕ)
Goal: ↑n.succ = ONote.oadd 0 n.succPNat 0
-- ONote.ofNat_one
@[simp 1200]
theorem ofNat_one : ofNat 1 = 1 
Goal: ↑1 = 1
-- ONote.repr_ofNat
@[simp]
theorem repr_ofNat (n : ℕ) : repr (ofNat n) = n 
Arguments: (n : ℕ)
Goal: (↑n).repr = ↑n
-- ONote.repr_one
theorem repr_one : repr (ofNat 1) = (1 : ℕ) 
Goal: (↑1).repr = ↑1
-- ONote.omega_le_oadd
theorem omega_le_oadd (e n a) : ω ^ repr e ≤ repr (oadd e n a) 
Arguments: (e : ONote) (n : ℕ+) (a : ONote)
Goal: ω ^ e.repr ≤ (e.oadd n a).repr
-- ONote.oadd_pos
theorem oadd_pos (e n a) : 0 < oadd e n a 
Arguments: (e : ONote) (n : ℕ+) (a : ONote)
Goal: 0 < e.oadd n a
-- ONote.eq_of_cmp_eq
theorem eq_of_cmp_eq : ∀ {o₁ o₂}, cmp o₁ o₂ = Ordering.eq → o₁ = o₂
  
Arguments: {o₁ o₂ : ONote}
Goal: o₁.cmp o₂ = Ordering.eq → o₁ = o₂
-- ONote.zero_lt_one
protected theorem zero_lt_one : (0 : ONote) < 1 
Goal: 0 < 1
-- ONote.NF.out
class NF (o : ONote) : Prop where
  out : Exists (NFBelow o)
Arguments: {o : ONote} [self : o.NF]
Goal: Exists o.NFBelow
-- ONote.NFBelow.oadd
theorem NFBelow.oadd {e n a b} : NF e → NFBelow a (repr e) → repr e < b → NFBelow (oadd e n a) b
  
Arguments: {e : ONote} {n : ℕ+} {a : ONote} {b : Ordinal.{0}}
Goal: e.NF → a.NFBelow e.repr → e.repr < b → (e.oadd n a).NFBelow b
-- ONote.NFBelow.fst
theorem NFBelow.fst {e n a b} (h : NFBelow (ONote.oadd e n a) b) : NF e 
Arguments: {e : ONote} {n : ℕ+} {a : ONote} {b : Ordinal.{0}} (h : (e.oadd n a).NFBelow b)
Goal: e.NF
-- ONote.NF.fst
theorem NF.fst {e n a} : NF (oadd e n a) → NF e
  
Arguments: {e : ONote} {n : ℕ+} {a : ONote}
Goal: (e.oadd n a).NF → e.NF
-- ONote.NFBelow.snd
theorem NFBelow.snd {e n a b} (h : NFBelow (ONote.oadd e n a) b) : NFBelow a (repr e) 
Arguments: {e : ONote} {n : ℕ+} {a : ONote} {b : Ordinal.{0}} (h : (e.oadd n a).NFBelow b)
Goal: a.NFBelow e.repr
-- ONote.NF.snd'
theorem NF.snd' {e n a} : NF (oadd e n a) → NFBelow a (repr e)
  
Arguments: {e : ONote} {n : ℕ+} {a : ONote}
Goal: (e.oadd n a).NF → a.NFBelow e.repr
-- ONote.NF.snd
theorem NF.snd {e n a} (h : NF (oadd e n a)) : NF a 
Arguments: {e : ONote} {n : ℕ+} {a : ONote} (h : (e.oadd n a).NF)
Goal: a.NF
-- ONote.NF.oadd
theorem NF.oadd {e a} (h₁ : NF e) (n) (h₂ : NFBelow a (repr e)) : NF (oadd e n a) 
Arguments: {e a : ONote} (h₁ : e.NF) (n : ℕ+) (h₂ : a.NFBelow e.repr)
Goal: (e.oadd n a).NF
-- ONote.NFBelow.lt
theorem NFBelow.lt {e n a b} (h : NFBelow (ONote.oadd e n a) b) : repr e < b 
Arguments: {e : ONote} {n : ℕ+} {a : ONote} {b : Ordinal.{0}} (h : (e.oadd n a).NFBelow b)
Goal: e.repr < b
-- ONote.NFBelow_zero
theorem NFBelow_zero : ∀ {o}, NFBelow o 0 ↔ o = 0
  
Arguments: {o : ONote}
Goal: o.NFBelow 0 ↔ o = 0
-- ONote.NF.zero_of_zero
theorem NF.zero_of_zero {e n a} (h : NF (ONote.oadd e n a)) (e0 : e = 0) : a = 0 
Arguments: {e : ONote} {n : ℕ+} {a : ONote} (h : (e.oadd n a).NF) (e0 : e = 0)
Goal: a = 0
-- ONote.NFBelow.repr_lt
theorem NFBelow.repr_lt {o b} (h : NFBelow o b) : repr o < ω ^ b 
Arguments: {o : ONote} {b : Ordinal.{0}} (h : o.NFBelow b)
Goal: o.repr < ω ^ b
-- ONote.NFBelow.mono
theorem NFBelow.mono {o b₁ b₂} (bb : b₁ ≤ b₂) (h : NFBelow o b₁) : NFBelow o b₂ 
Arguments: {o : ONote} {b₁ b₂ : Ordinal.{0}} (bb : b₁ ≤ b₂) (h : o.NFBelow b₁)
Goal: o.NFBelow b₂