ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- UniqueMul.iff_card_le_one
@[to_additive]
theorem iff_card_le_one [DecidableEq G] (ha0 : a0 ∈ A) (hb0 : b0 ∈ B) :
    UniqueMul A B a0 b0 ↔ ((A ×ˢ B).filter (fun p ↦ p.1 * p.2 = a0 * b0)).card ≤ 1 
Arguments: {G : Type u_1} [Mul G] {A B : Finset G} {a0 b0 : G} [DecidableEq G] (ha0 : a0 ∈ A) (hb0 : b0 ∈ B)
Goal: UniqueMul A B a0 b0 ↔ (Finset.filter (fun p => p.1 * p.2 = a0 * b0) (A ×ˢ B)).card ≤ 1
-- UniqueMul.exists_iff_exists_existsUnique
@[to_additive]
theorem exists_iff_exists_existsUnique :
    (∃ a0 b0 : G, a0 ∈ A ∧ b0 ∈ B ∧ UniqueMul A B a0 b0) ↔
      ∃ g : G, ∃! ab, ab ∈ A ×ˢ B ∧ ab.1 * ab.2 = g 
Arguments: {G : Type u_1} [Mul G] {A B : Finset G}
Goal: (∃ a0 b0, a0 ∈ A ∧ b0 ∈ B ∧ UniqueMul A B a0 b0) ↔ ∃ g, ∃! ab, ab ∈ A ×ˢ B ∧ ab.1 * ab.2 = g
-- UniqueAdd.exists_iff_exists_existsUnique
@[to_additive]
theorem exists_iff_exists_existsUnique :
    (∃ a0 b0 : G, a0 ∈ A ∧ b0 ∈ B ∧ UniqueMul A B a0 b0) ↔
      ∃ g : G, ∃! ab, ab ∈ A ×ˢ B ∧ ab.1 * ab.2 = g 
Arguments: {G : Type u_1} [Add G] {A B : Finset G}
Goal: (∃ a0 b0, a0 ∈ A ∧ b0 ∈ B ∧ UniqueAdd A B a0 b0) ↔ ∃ g, ∃! ab, ab ∈ A ×ˢ B ∧ ab.1 + ab.2 = g
-- UniqueAdd.addHom_preimage
@[to_additive "`UniqueAdd` is preserved by inverse images under injective, additive maps."]
theorem mulHom_preimage (f : G →ₙ* H) (hf : Function.Injective f) (a0 b0 : G) {A B : Finset H}
    (u : UniqueMul A B (f a0) (f b0)) :
    UniqueMul (A.preimage f hf.injOn) (B.preimage f hf.injOn) a0 b0 
Arguments: {G : Type u_1} {H : Type u_2} [Add G] [Add H] (f : AddHom G H) (hf : Function.Injective ⇑f) (a0 b0 : G) {A B : Finset H} (u : UniqueAdd A B (f a0) (f b0))
Goal: UniqueAdd (A.preimage ⇑f ⋯) (B.preimage ⇑f ⋯) a0 b0
-- UniqueMul.mulHom_preimage
@[to_additive "`UniqueAdd` is preserved by inverse images under injective, additive maps."]
theorem mulHom_preimage (f : G →ₙ* H) (hf : Function.Injective f) (a0 b0 : G) {A B : Finset H}
    (u : UniqueMul A B (f a0) (f b0)) :
    UniqueMul (A.preimage f hf.injOn) (B.preimage f hf.injOn) a0 b0 
Arguments: {G : Type u_1} {H : Type u_2} [Mul G] [Mul H] (f : G →ₙ* H) (hf : Function.Injective ⇑f) (a0 b0 : G) {A B : Finset H} (u : UniqueMul A B (f a0) (f b0))
Goal: UniqueMul (A.preimage ⇑f ⋯) (B.preimage ⇑f ⋯) a0 b0
-- UniqueMul.of_mulHom_image
@[to_additive] theorem of_mulHom_image [DecidableEq H] (f : G →ₙ* H)
    (hf : ∀ ⦃a b c d : G⦄, a * b = c * d → f a = f c ∧ f b = f d → a = c ∧ b = d)
    (h : UniqueMul (A.image f) (B.image f) (f a0) (f b0)) : UniqueMul A B a0 b0 
Arguments: {G : Type u_1} {H : Type u_2} [Mul G] [Mul H] {A B : Finset G} {a0 b0 : G} [DecidableEq H] (f : G →ₙ* H) (hf : ∀ ⦃a b c d : G⦄, a * b = c * d → f a = f c ∧ f b = f d → a = c ∧ b = d) (h : UniqueMul (Finset.image (⇑f) A) (Finset.image (⇑f) B) (f a0) (f b0))
Goal: UniqueMul A B a0 b0
-- UniqueAdd.of_addHom_image
@[to_additive] theorem of_mulHom_image [DecidableEq H] (f : G →ₙ* H)
    (hf : ∀ ⦃a b c d : G⦄, a * b = c * d → f a = f c ∧ f b = f d → a = c ∧ b = d)
    (h : UniqueMul (A.image f) (B.image f) (f a0) (f b0)) : UniqueMul A B a0 b0 
Arguments: {G : Type u_1} {H : Type u_2} [Add G] [Add H] {A B : Finset G} {a0 b0 : G} [DecidableEq H] (f : AddHom G H) (hf : ∀ ⦃a b c d : G⦄, a + b = c + d → f a = f c ∧ f b = f d → a = c ∧ b = d) (h : UniqueAdd (Finset.image (⇑f) A) (Finset.image (⇑f) B) (f a0) (f b0))
Goal: UniqueAdd A B a0 b0
-- UniqueMul.mulHom_image_iff
@[to_additive
      "`UniqueAdd` is preserved under additive maps that are injective.

See `UniqueAdd.addHom_map_iff` for a version with swapped bundling."]
theorem mulHom_image_iff [DecidableEq H] (f : G →ₙ* H) (hf : Function.Injective f) :
    UniqueMul (A.image f) (B.image f) (f a0) (f b0) ↔ UniqueMul A B a0 b0 
Arguments: {G : Type u_1} {H : Type u_2} [Mul G] [Mul H] {A B : Finset G} {a0 b0 : G} [DecidableEq H] (f : G →ₙ* H) (hf : Function.Injective ⇑f)
Goal: UniqueMul (Finset.image (⇑f) A) (Finset.image (⇑f) B) (f a0) (f b0) ↔ UniqueMul A B a0 b0
-- UniqueAdd.addHom_image_iff
@[to_additive
      "`UniqueAdd` is preserved under additive maps that are injective.

See `UniqueAdd.addHom_map_iff` for a version with swapped bundling."]
theorem mulHom_image_iff [DecidableEq H] (f : G →ₙ* H) (hf : Function.Injective f) :
    UniqueMul (A.image f) (B.image f) (f a0) (f b0) ↔ UniqueMul A B a0 b0 
Arguments: {G : Type u_1} {H : Type u_2} [Add G] [Add H] {A B : Finset G} {a0 b0 : G} [DecidableEq H] (f : AddHom G H) (hf : Function.Injective ⇑f)
Goal: UniqueAdd (Finset.image (⇑f) A) (Finset.image (⇑f) B) (f a0) (f b0) ↔ UniqueAdd A B a0 b0
-- UniqueAdd.addHom_map_iff
@[to_additive
      "`UniqueAdd` is preserved under embeddings that are additive.

See `UniqueAdd.addHom_image_iff` for a version with swapped bundling."]
theorem mulHom_map_iff (f : G ↪ H) (mul : ∀ x y, f (x * y) = f x * f y) :
    UniqueMul (A.map f) (B.map f) (f a0) (f b0) ↔ UniqueMul A B a0 b0 
Arguments: {G : Type u_1} {H : Type u_2} [Add G] [Add H] {A B : Finset G} {a0 b0 : G} (f : G ↪ H) (mul : ∀ (x y : G), f (x + y) = f x + f y)
Goal: UniqueAdd (Finset.map f A) (Finset.map f B) (f a0) (f b0) ↔ UniqueAdd A B a0 b0
-- UniqueMul.mulHom_map_iff
@[to_additive
      "`UniqueAdd` is preserved under embeddings that are additive.

See `UniqueAdd.addHom_image_iff` for a version with swapped bundling."]
theorem mulHom_map_iff (f : G ↪ H) (mul : ∀ x y, f (x * y) = f x * f y) :
    UniqueMul (A.map f) (B.map f) (f a0) (f b0) ↔ UniqueMul A B a0 b0 
Arguments: {G : Type u_1} {H : Type u_2} [Mul G] [Mul H] {A B : Finset G} {a0 b0 : G} (f : G ↪ H) (mul : ∀ (x y : G), f (x * y) = f x * f y)
Goal: UniqueMul (Finset.map f A) (Finset.map f B) (f a0) (f b0) ↔ UniqueMul A B a0 b0
-- UniqueMul.of_mulOpposite
@[to_additive]
theorem of_mulOpposite
    (h : UniqueMul (B.map ⟨_, op_injective⟩) (A.map ⟨_, op_injective⟩) (op b0) (op a0)) :
    UniqueMul A B a0 b0 
Arguments: {G : Type u_1} [Mul G] {A B : Finset G} {a0 b0 : G} (h :
  UniqueMul (Finset.map { toFun := MulOpposite.op, inj' := ⋯ } B) (Finset.map { toFun := MulOpposite.op, inj' := ⋯ } A)
    (MulOpposite.op b0) (MulOpposite.op a0))
Goal: UniqueMul A B a0 b0
-- UniqueAdd.of_addOpposite
@[to_additive]
theorem of_mulOpposite
    (h : UniqueMul (B.map ⟨_, op_injective⟩) (A.map ⟨_, op_injective⟩) (op b0) (op a0)) :
    UniqueMul A B a0 b0 
Arguments: {G : Type u_1} [Add G] {A B : Finset G} {a0 b0 : G} (h :
  UniqueAdd (Finset.map { toFun := AddOpposite.op, inj' := ⋯ } B) (Finset.map { toFun := AddOpposite.op, inj' := ⋯ } A)
    (AddOpposite.op b0) (AddOpposite.op a0))
Goal: UniqueAdd A B a0 b0
-- UniqueAdd.to_addOpposite
@[to_additive]
theorem to_mulOpposite (h : UniqueMul A B a0 b0) :
    UniqueMul (B.map ⟨_, op_injective⟩) (A.map ⟨_, op_injective⟩) (op b0) (op a0) 
Arguments: {G : Type u_1} [Add G] {A B : Finset G} {a0 b0 : G} (h : UniqueAdd A B a0 b0)
Goal: UniqueAdd (Finset.map { toFun := AddOpposite.op, inj' := ⋯ } B) (Finset.map { toFun := AddOpposite.op, inj' := ⋯ } A)
  (AddOpposite.op b0) (AddOpposite.op a0)
-- UniqueMul.to_mulOpposite
@[to_additive]
theorem to_mulOpposite (h : UniqueMul A B a0 b0) :
    UniqueMul (B.map ⟨_, op_injective⟩) (A.map ⟨_, op_injective⟩) (op b0) (op a0) 
Arguments: {G : Type u_1} [Mul G] {A B : Finset G} {a0 b0 : G} (h : UniqueMul A B a0 b0)
Goal: UniqueMul (Finset.map { toFun := MulOpposite.op, inj' := ⋯ } B) (Finset.map { toFun := MulOpposite.op, inj' := ⋯ } A)
  (MulOpposite.op b0) (MulOpposite.op a0)
-- UniqueMul.iff_mulOpposite
@[to_additive]
theorem iff_mulOpposite :
    UniqueMul (B.map ⟨_, op_injective⟩) (A.map ⟨_, op_injective⟩) (op b0) (op a0) ↔
      UniqueMul A B a0 b0 
Arguments: {G : Type u_1} [Mul G] {A B : Finset G} {a0 b0 : G}
Goal: UniqueMul (Finset.map { toFun := MulOpposite.op, inj' := ⋯ } B) (Finset.map { toFun := MulOpposite.op, inj' := ⋯ } A)
    (MulOpposite.op b0) (MulOpposite.op a0) ↔
  UniqueMul A B a0 b0
-- UniqueAdd.iff_addOpposite
@[to_additive]
theorem iff_mulOpposite :
    UniqueMul (B.map ⟨_, op_injective⟩) (A.map ⟨_, op_injective⟩) (op b0) (op a0) ↔
      UniqueMul A B a0 b0 
Arguments: {G : Type u_1} [Add G] {A B : Finset G} {a0 b0 : G}
Goal: UniqueAdd (Finset.map { toFun := AddOpposite.op, inj' := ⋯ } B) (Finset.map { toFun := AddOpposite.op, inj' := ⋯ } A)
    (AddOpposite.op b0) (AddOpposite.op a0) ↔
  UniqueAdd A B a0 b0
-- UniqueAdd.of_image_filter
@[to_additive]
theorem of_image_filter [DecidableEq H]
    (f : G →ₙ* H) {A B : Finset G} {aG bG : G} {aH bH : H} (hae : f aG = aH) (hbe : f bG = bH)
    (huH : UniqueMul (A.image f) (B.image f) aH bH)
    (huG : UniqueMul (A.filter (f · = aH)) (B.filter (f · = bH)) aG bG) :
    UniqueMul A B aG bG 
Arguments: {G : Type u_1} {H : Type u_2} [Add G] [Add H] [DecidableEq H] (f : AddHom G H) {A B : Finset G} {aG bG : G} {aH bH : H} (hae : f aG = aH) (hbe : f bG = bH) (huH : UniqueAdd (Finset.image (⇑f) A) (Finset.image (⇑f) B) aH bH) (huG : UniqueAdd (Finset.filter (fun x => f x = aH) A) (Finset.filter (fun x => f x = bH) B) aG bG)
Goal: UniqueAdd A B aG bG
-- UniqueMul.of_image_filter
@[to_additive]
theorem of_image_filter [DecidableEq H]
    (f : G →ₙ* H) {A B : Finset G} {aG bG : G} {aH bH : H} (hae : f aG = aH) (hbe : f bG = bH)
    (huH : UniqueMul (A.image f) (B.image f) aH bH)
    (huG : UniqueMul (A.filter (f · = aH)) (B.filter (f · = bH)) aG bG) :
    UniqueMul A B aG bG 
Arguments: {G : Type u_1} {H : Type u_2} [Mul G] [Mul H] [DecidableEq H] (f : G →ₙ* H) {A B : Finset G} {aG bG : G} {aH bH : H} (hae : f aG = aH) (hbe : f bG = bH) (huH : UniqueMul (Finset.image (⇑f) A) (Finset.image (⇑f) B) aH bH) (huG : UniqueMul (Finset.filter (fun x => f x = aH) A) (Finset.filter (fun x => f x = bH) B) aG bG)
Goal: UniqueMul A B aG bG
-- UniqueSums.uniqueAdd_of_nonempty
class UniqueSums (G) [Add G] : Prop where
  uniqueAdd_of_nonempty :
    ∀ {A B : Finset G}, A.Nonempty → B.Nonempty → ∃ a0 ∈ A, ∃ b0 ∈ B, UniqueAdd A B a0 b0
Arguments: {G : Type u_1} [Add G] [self : UniqueSums G] {A B : Finset G}
Goal: A.Nonempty → B.Nonempty → ∃ a0 ∈ A, ∃ b0 ∈ B, UniqueAdd A B a0 b0
-- UniqueProds.uniqueMul_of_nonempty
class UniqueProds (G) [Mul G] : Prop where
  uniqueMul_of_nonempty :
    ∀ {A B : Finset G}, A.Nonempty → B.Nonempty → ∃ a0 ∈ A, ∃ b0 ∈ B, UniqueMul A B a0 b0
Arguments: {G : Type u_1} [Mul G] [self : UniqueProds G] {A B : Finset G}
Goal: A.Nonempty → B.Nonempty → ∃ a0 ∈ A, ∃ b0 ∈ B, UniqueMul A B a0 b0
-- TwoUniqueSums.uniqueAdd_of_one_lt_card
class TwoUniqueSums (G) [Add G] : Prop where
  uniqueAdd_of_one_lt_card : ∀ {A B : Finset G}, 1 < A.card * B.card →
    ∃ p1 ∈ A ×ˢ B, ∃ p2 ∈ A ×ˢ B, p1 ≠ p2 ∧ UniqueAdd A B p1.1 p1.2 ∧ UniqueAdd A B p2.1 p2.2
Arguments: {G : Type u_1} [Add G] [self : TwoUniqueSums G] {A B : Finset G}
Goal: 1 < A.card * B.card → ∃ p1 ∈ A ×ˢ B, ∃ p2 ∈ A ×ˢ B, p1 ≠ p2 ∧ UniqueAdd A B p1.1 p1.2 ∧ UniqueAdd A B p2.1 p2.2
-- TwoUniqueProds.uniqueMul_of_one_lt_card
class TwoUniqueProds (G) [Mul G] : Prop where
  uniqueMul_of_one_lt_card : ∀ {A B : Finset G}, 1 < A.card * B.card →
    ∃ p1 ∈ A ×ˢ B, ∃ p2 ∈ A ×ˢ B, p1 ≠ p2 ∧ UniqueMul A B p1.1 p1.2 ∧ UniqueMul A B p2.1 p2.2
Arguments: {G : Type u_1} [Mul G] [self : TwoUniqueProds G] {A B : Finset G}
Goal: 1 < A.card * B.card → ∃ p1 ∈ A ×ˢ B, ∃ p2 ∈ A ×ˢ B, p1 ≠ p2 ∧ UniqueMul A B p1.1 p1.2 ∧ UniqueMul A B p2.1 p2.2
-- uniqueMul_of_twoUniqueMul
@[to_additive]
lemma uniqueMul_of_twoUniqueMul {G} [Mul G] {A B : Finset G} (h : 1 < A.card * B.card →
    ∃ p1 ∈ A ×ˢ B, ∃ p2 ∈ A ×ˢ B, p1 ≠ p2 ∧ UniqueMul A B p1.1 p1.2 ∧ UniqueMul A B p2.1 p2.2)
    (hA : A.Nonempty) (hB : B.Nonempty) : ∃ a ∈ A, ∃ b ∈ B, UniqueMul A B a b 
Arguments: {G : Type u_1} [Mul G] {A B : Finset G} (h : 1 < A.card * B.card → ∃ p1 ∈ A ×ˢ B, ∃ p2 ∈ A ×ˢ B, p1 ≠ p2 ∧ UniqueMul A B p1.1 p1.2 ∧ UniqueMul A B p2.1 p2.2) (hA : A.Nonempty) (hB : B.Nonempty)
Goal: ∃ a ∈ A, ∃ b ∈ B, UniqueMul A B a b
-- uniqueAdd_of_twoUniqueAdd
@[to_additive]
lemma uniqueMul_of_twoUniqueMul {G} [Mul G] {A B : Finset G} (h : 1 < A.card * B.card →
    ∃ p1 ∈ A ×ˢ B, ∃ p2 ∈ A ×ˢ B, p1 ≠ p2 ∧ UniqueMul A B p1.1 p1.2 ∧ UniqueMul A B p2.1 p2.2)
    (hA : A.Nonempty) (hB : B.Nonempty) : ∃ a ∈ A, ∃ b ∈ B, UniqueMul A B a b 
Arguments: {G : Type u_1} [Add G] {A B : Finset G} (h : 1 < A.card * B.card → ∃ p1 ∈ A ×ˢ B, ∃ p2 ∈ A ×ˢ B, p1 ≠ p2 ∧ UniqueAdd A B p1.1 p1.2 ∧ UniqueAdd A B p2.1 p2.2) (hA : A.Nonempty) (hB : B.Nonempty)
Goal: ∃ a ∈ A, ∃ b ∈ B, UniqueAdd A B a b
-- UniqueSums.of_addHom
@[to_additive] theorem of_mulHom (f : H →ₙ* G)
    (hf : ∀ ⦃a b c d : H⦄, a * b = c * d → f a = f c ∧ f b = f d → a = c ∧ b = d)
    [UniqueProds G] : UniqueProds H 
Arguments: {G : Type u} {H : Type v} [Add G] [Add H] (f : AddHom H G) (hf : ∀ ⦃a b c d : H⦄, a + b = c + d → f a = f c ∧ f b = f d → a = c ∧ b = d) [UniqueSums G]
Goal: UniqueSums H
-- UniqueProds.of_mulHom
@[to_additive] theorem of_mulHom (f : H →ₙ* G)
    (hf : ∀ ⦃a b c d : H⦄, a * b = c * d → f a = f c ∧ f b = f d → a = c ∧ b = d)
    [UniqueProds G] : UniqueProds H 
Arguments: {G : Type u} {H : Type v} [Mul G] [Mul H] (f : H →ₙ* G) (hf : ∀ ⦃a b c d : H⦄, a * b = c * d → f a = f c ∧ f b = f d → a = c ∧ b = d) [UniqueProds G]
Goal: UniqueProds H
-- UniqueSums.of_injective_addHom
@[to_additive]
theorem of_injective_mulHom (f : H →ₙ* G) (hf : Function.Injective f) (_ : UniqueProds G) :
    UniqueProds H 
Arguments: {G : Type u} {H : Type v} [Add G] [Add H] (f : AddHom H G) (hf : Function.Injective ⇑f)
Goal: UniqueSums G → UniqueSums H
-- UniqueProds.of_injective_mulHom
@[to_additive]
theorem of_injective_mulHom (f : H →ₙ* G) (hf : Function.Injective f) (_ : UniqueProds G) :
    UniqueProds H 
Arguments: {G : Type u} {H : Type v} [Mul G] [Mul H] (f : H →ₙ* G) (hf : Function.Injective ⇑f)
Goal: UniqueProds G → UniqueProds H
-- AddEquiv.uniqueSums_iff
@[to_additive "`UniqueSums` is preserved under additive equivalences."]
theorem _root_.MulEquiv.uniqueProds_iff (f : G ≃* H) : UniqueProds G ↔ UniqueProds H 
Arguments: {G : Type u} {H : Type v} [Add G] [Add H] (f : G ≃+ H)
Goal: UniqueSums G ↔ UniqueSums H
-- MulEquiv.uniqueProds_iff
@[to_additive "`UniqueSums` is preserved under additive equivalences."]
theorem _root_.MulEquiv.uniqueProds_iff (f : G ≃* H) : UniqueProds G ↔ UniqueProds H 
Arguments: {G : Type u} {H : Type v} [Mul G] [Mul H] (f : G ≃* H)
Goal: UniqueProds G ↔ UniqueProds H
-- UniqueProds.of_mulOpposite
@[to_additive]
theorem of_mulOpposite (h : UniqueProds Gᵐᵒᵖ) : UniqueProds G 
Arguments: {G : Type u} [Mul G] (h : UniqueProds Gᵐᵒᵖ)
Goal: UniqueProds G
-- UniqueSums.of_addOpposite
@[to_additive]
theorem of_mulOpposite (h : UniqueProds Gᵐᵒᵖ) : UniqueProds G 
Arguments: {G : Type u} [Add G] (h : UniqueSums Gᵃᵒᵖ)
Goal: UniqueSums G
-- _private.Mathlib.Algebra.Group.UniqueProds.0.UniqueProds.toIsAddLeftCancel
@[to_additive] private theorem toIsLeftCancelMul [UniqueProds G] : IsLeftCancelMul G 
Arguments: {G : Type u} [Add G] [UniqueSums G]
Goal: IsLeftCancelAdd G
-- _private.Mathlib.Algebra.Group.UniqueProds.0.UniqueProds.toIsLeftCancelMul
@[to_additive] private theorem toIsLeftCancelMul [UniqueProds G] : IsLeftCancelMul G 
Arguments: {G : Type u} [Mul G] [UniqueProds G]
Goal: IsLeftCancelMul G
-- UniqueSums.toIsAddCancel
@[to_additive] theorem toIsCancelMul [UniqueProds G] : IsCancelMul G 
Arguments: {G : Type u} [Add G] [UniqueSums G]
Goal: IsCancelAdd G
-- UniqueProds.toIsCancelMul
@[to_additive] theorem toIsCancelMul [UniqueProds G] : IsCancelMul G 
Arguments: {G : Type u} [Mul G] [UniqueProds G]
Goal: IsCancelMul G
-- UniqueSums.of_same
@[to_additive] theorem of_same {G} [Semigroup G] [IsCancelMul G]
    (h : ∀ {A : Finset G}, A.Nonempty → ∃ a1 ∈ A, ∃ a2 ∈ A, UniqueMul A A a1 a2) :
    UniqueProds G 
Arguments: {G : Type u_1} [AddSemigroup G] [IsCancelAdd G] (h : ∀ {A : Finset G}, A.Nonempty → ∃ a1 ∈ A, ∃ a2 ∈ A, UniqueAdd A A a1 a2)
Goal: UniqueSums G
-- UniqueProds.of_same
@[to_additive] theorem of_same {G} [Semigroup G] [IsCancelMul G]
    (h : ∀ {A : Finset G}, A.Nonempty → ∃ a1 ∈ A, ∃ a2 ∈ A, UniqueMul A A a1 a2) :
    UniqueProds G 
Arguments: {G : Type u_1} [Semigroup G] [IsCancelMul G] (h : ∀ {A : Finset G}, A.Nonempty → ∃ a1 ∈ A, ∃ a2 ∈ A, UniqueMul A A a1 a2)
Goal: UniqueProds G
-- UniqueSums.toTwoUniqueSums_of_addGroup
@[to_additive] theorem toTwoUniqueProds_of_group {G}
    [Group G] [UniqueProds G] : TwoUniqueProds G 
Arguments: {G : Type u_1} [AddGroup G] [UniqueSums G]
Goal: TwoUniqueSums G
-- UniqueProds.toTwoUniqueProds_of_group
@[to_additive] theorem toTwoUniqueProds_of_group {G}
    [Group G] [UniqueProds G] : TwoUniqueProds G 
Arguments: {G : Type u_1} [Group G] [UniqueProds G]
Goal: TwoUniqueProds G
-- TwoUniqueProds.of_mulHom
@[to_additive] theorem of_mulHom (f : H →ₙ* G)
    (hf : ∀ ⦃a b c d : H⦄, a * b = c * d → f a = f c ∧ f b = f d → a = c ∧ b = d)
    [TwoUniqueProds G] : TwoUniqueProds H 
Arguments: {G : Type u} {H : Type v} [Mul G] [Mul H] (f : H →ₙ* G) (hf : ∀ ⦃a b c d : H⦄, a * b = c * d → f a = f c ∧ f b = f d → a = c ∧ b = d) [TwoUniqueProds G]
Goal: TwoUniqueProds H
-- TwoUniqueSums.of_addHom
@[to_additive] theorem of_mulHom (f : H →ₙ* G)
    (hf : ∀ ⦃a b c d : H⦄, a * b = c * d → f a = f c ∧ f b = f d → a = c ∧ b = d)
    [TwoUniqueProds G] : TwoUniqueProds H 
Arguments: {G : Type u} {H : Type v} [Add G] [Add H] (f : AddHom H G) (hf : ∀ ⦃a b c d : H⦄, a + b = c + d → f a = f c ∧ f b = f d → a = c ∧ b = d) [TwoUniqueSums G]
Goal: TwoUniqueSums H
-- TwoUniqueSums.of_injective_addHom
@[to_additive]
theorem of_injective_mulHom (f : H →ₙ* G) (hf : Function.Injective f)
    (_ : TwoUniqueProds G) : TwoUniqueProds H 
Arguments: {G : Type u} {H : Type v} [Add G] [Add H] (f : AddHom H G) (hf : Function.Injective ⇑f)
Goal: TwoUniqueSums G → TwoUniqueSums H
-- TwoUniqueProds.of_injective_mulHom
@[to_additive]
theorem of_injective_mulHom (f : H →ₙ* G) (hf : Function.Injective f)
    (_ : TwoUniqueProds G) : TwoUniqueProds H 
Arguments: {G : Type u} {H : Type v} [Mul G] [Mul H] (f : H →ₙ* G) (hf : Function.Injective ⇑f)
Goal: TwoUniqueProds G → TwoUniqueProds H
-- AddEquiv.twoUniqueSums_iff
@[to_additive "`TwoUniqueSums` is preserved under additive equivalences."]
theorem _root_.MulEquiv.twoUniqueProds_iff (f : G ≃* H) : TwoUniqueProds G ↔ TwoUniqueProds H 
Arguments: {G : Type u} {H : Type v} [Add G] [Add H] (f : G ≃+ H)
Goal: TwoUniqueSums G ↔ TwoUniqueSums H
-- MulEquiv.twoUniqueProds_iff
@[to_additive "`TwoUniqueSums` is preserved under additive equivalences."]
theorem _root_.MulEquiv.twoUniqueProds_iff (f : G ≃* H) : TwoUniqueProds G ↔ TwoUniqueProds H 
Arguments: {G : Type u} {H : Type v} [Mul G] [Mul H] (f : G ≃* H)
Goal: TwoUniqueProds G ↔ TwoUniqueProds H
-- TwoUniqueSums.of_addOpposite
@[to_additive]
theorem of_mulOpposite (h : TwoUniqueProds Gᵐᵒᵖ) : TwoUniqueProds G 
Arguments: {G : Type u} [Add G] (h : TwoUniqueSums Gᵃᵒᵖ)
Goal: TwoUniqueSums G
-- TwoUniqueProds.of_mulOpposite
@[to_additive]
theorem of_mulOpposite (h : TwoUniqueProds Gᵐᵒᵖ) : TwoUniqueProds G 
Arguments: {G : Type u} [Mul G] (h : TwoUniqueProds Gᵐᵒᵖ)
Goal: TwoUniqueProds G
-- RingHomId.eq_id
-- This at first seems not very useful. However we need this when considering
-- modules over some diagram in the category of rings,
-- e.g. when defining presheaves over a presheaf of rings.
-- See `Mathlib.Algebra.Category.ModuleCat.Presheaf`.
class RingHomId {R : Type*} [Semiring R] (σ : R →+* R) : Prop where
  eq_id : σ = RingHom.id R
Arguments: {R : Type u_4} [Semiring R] {σ : R →+* R} [self : RingHomId σ]
Goal: σ = RingHom.id R
-- RingHomCompTriple.comp_eq
class RingHomCompTriple (σ₁₂ : R₁ →+* R₂) (σ₂₃ : R₂ →+* R₃) (σ₁₃ : outParam (R₁ →+* R₃)) :
  Prop where
    comp_eq : σ₂₃.comp σ₁₂ = σ₁₃
Arguments: {R₁ : Type u_1} {R₂ : Type u_2} {R₃ : Type u_3} [Semiring R₁] [Semiring R₂] [Semiring R₃] {σ₁₂ : R₁ →+* R₂} {σ₂₃ : R₂ →+* R₃} {σ₁₃ : outParam (R₁ →+* R₃)} [self : RingHomCompTriple σ₁₂ σ₂₃ σ₁₃]
Goal: σ₂₃.comp σ₁₂ = σ₁₃
-- RingHomCompTriple.comp_apply
@[simp]
theorem comp_apply [RingHomCompTriple σ₁₂ σ₂₃ σ₁₃] {x : R₁} : σ₂₃ (σ₁₂ x) = σ₁₃ x 
Arguments: {R₁ : Type u_1} {R₂ : Type u_2} {R₃ : Type u_3} [Semiring R₁] [Semiring R₂] [Semiring R₃] {σ₁₂ : R₁ →+* R₂} {σ₂₃ : R₂ →+* R₃} {σ₁₃ : R₁ →+* R₃} [RingHomCompTriple σ₁₂ σ₂₃ σ₁₃] {x : R₁}
Goal: σ₂₃ (σ₁₂ x) = σ₁₃ x
-- RingHomInvPair.comp_eq₂
class RingHomInvPair (σ : R₁ →+* R₂) (σ' : outParam (R₂ →+* R₁)) : Prop where
    comp_eq : σ'.comp σ = RingHom.id R₁
    comp_eq₂ : σ.comp σ' = RingHom.id R₂
Arguments: {R₁ : Type u_1} {R₂ : Type u_2} [Semiring R₁] [Semiring R₂] {σ : R₁ →+* R₂} {σ' : outParam (R₂ →+* R₁)} [self : RingHomInvPair σ σ']
Goal: σ.comp σ' = RingHom.id R₂
-- RingHomInvPair.comp_eq
class RingHomInvPair (σ : R₁ →+* R₂) (σ' : outParam (R₂ →+* R₁)) : Prop where
    comp_eq : σ'.comp σ = RingHom.id R₁
    comp_eq₂ : σ.comp σ' = RingHom.id R₂
Arguments: {R₁ : Type u_1} {R₂ : Type u_2} [Semiring R₁] [Semiring R₂] {σ : R₁ →+* R₂} {σ' : outParam (R₂ →+* R₁)} [self : RingHomInvPair σ σ']
Goal: RingHom.comp σ' σ = RingHom.id R₁
-- RingHomInvPair.comp_apply_eq
theorem comp_apply_eq {x : R₁} : σ' (σ x) = x 
Arguments: {R₁ : Type u_1} {R₂ : Type u_2} [Semiring R₁] [Semiring R₂] {σ : R₁ →+* R₂} {σ' : R₂ →+* R₁} [RingHomInvPair σ σ'] {x : R₁}
Goal: σ' (σ x) = x
-- RingHomInvPair.comp_apply_eq₂
theorem comp_apply_eq₂ {x : R₂} : σ (σ' x) = x 
Arguments: {R₁ : Type u_1} {R₂ : Type u_2} [Semiring R₁] [Semiring R₂] {σ : R₁ →+* R₂} {σ' : R₂ →+* R₁} [RingHomInvPair σ σ'] {x : R₂}
Goal: σ (σ' x) = x
-- RingHomInvPair.of_ringEquiv
theorem of_ringEquiv (e : R₁ ≃+* R₂) : RingHomInvPair (↑e : R₁ →+* R₂) ↑e.symm 
Arguments: {R₁ : Type u_1} {R₂ : Type u_2} [Semiring R₁] [Semiring R₂] (e : R₁ ≃+* R₂)
Goal: RingHomInvPair ↑e ↑e.symm
-- RingHomInvPair.symm
theorem symm (σ₁₂ : R₁ →+* R₂) (σ₂₁ : R₂ →+* R₁) [RingHomInvPair σ₁₂ σ₂₁] :
    RingHomInvPair σ₂₁ σ₁₂ 
Arguments: {R₁ : Type u_1} {R₂ : Type u_2} [Semiring R₁] [Semiring R₂] (σ₁₂ : R₁ →+* R₂) (σ₂₁ : R₂ →+* R₁) [RingHomInvPair σ₁₂ σ₂₁]
Goal: RingHomInvPair σ₂₁ σ₁₂
-- RingHomSurjective.is_surjective
class RingHomSurjective (σ : R₁ →+* R₂) : Prop where
    is_surjective : Function.Surjective σ
Arguments: {R₁ : Type u_1} {R₂ : Type u_2} [Semiring R₁] [Semiring R₂] {σ : R₁ →+* R₂} [self : RingHomSurjective σ]
Goal: Function.Surjective ⇑σ
-- RingHom.surjective
theorem RingHom.surjective (σ : R₁ →+* R₂) [t : RingHomSurjective σ] : Function.Surjective σ 
Arguments: {R₁ : Type u_1} {R₂ : Type u_2} [Semiring R₁] [Semiring R₂] (σ : R₁ →+* R₂) [t : RingHomSurjective σ]
Goal: Function.Surjective ⇑σ
-- RingHomSurjective.comp
theorem comp [RingHomCompTriple σ₁₂ σ₂₃ σ₁₃] [RingHomSurjective σ₁₂] [RingHomSurjective σ₂₃] :
    RingHomSurjective σ₁₃ 
Arguments: {R₁ : Type u_1} {R₂ : Type u_2} {R₃ : Type u_3} [Semiring R₁] [Semiring R₂] [Semiring R₃] {σ₁₂ : R₁ →+* R₂} {σ₂₃ : R₂ →+* R₃} {σ₁₃ : R₁ →+* R₃} [RingHomCompTriple σ₁₂ σ₂₃ σ₁₃] [RingHomSurjective σ₁₂] [RingHomSurjective σ₂₃]
Goal: RingHomSurjective σ₁₃
-- Function.Injective.leftDistribClass
theorem leftDistribClass [Mul α] [Add α] [LeftDistribClass α] (add : ∀ x y, f (x + y) = f x + f y)
    (mul : ∀ x y, f (x * y) = f x * f y) : LeftDistribClass β 
Arguments: {α : Type u_1} {β : Type u_2} [Add β] [Mul β] (f : β → α) (hf : Function.Injective f) [Mul α] [Add α] [LeftDistribClass α] (add : ∀ (x y : β), f (x + y) = f x + f y) (mul : ∀ (x y : β), f (x * y) = f x * f y)
Goal: LeftDistribClass β
-- Function.Injective.rightDistribClass
theorem rightDistribClass [Mul α] [Add α] [RightDistribClass α] (add : ∀ x y, f (x + y) = f x + f y)
    (mul : ∀ x y, f (x * y) = f x * f y) : RightDistribClass β 
Arguments: {α : Type u_1} {β : Type u_2} [Add β] [Mul β] (f : β → α) (hf : Function.Injective f) [Mul α] [Add α] [RightDistribClass α] (add : ∀ (x y : β), f (x + y) = f x + f y) (mul : ∀ (x y : β), f (x * y) = f x * f y)
Goal: RightDistribClass β
-- Function.Surjective.leftDistribClass
theorem leftDistribClass [Mul α] [Add α] [LeftDistribClass α] (add : ∀ x y, f (x + y) = f x + f y)
    (mul : ∀ x y, f (x * y) = f x * f y) : LeftDistribClass β 
Arguments: {α : Type u_1} {β : Type u_2} [Add β] [Mul β] (f : α → β) (hf : Function.Surjective f) [Mul α] [Add α] [LeftDistribClass α] (add : ∀ (x y : α), f (x + y) = f x + f y) (mul : ∀ (x y : α), f (x * y) = f x * f y)
Goal: LeftDistribClass β