Loogle!
Result
Found 90 declarations mentioning Sum, Equiv, and Prod.
- Equiv.boolProdEquivSum 📋 Mathlib.Logic.Equiv.Prod
(α : Type u_9) : Bool × α ≃ α ⊕ α - optionProdEquiv 📋 Mathlib.Logic.Equiv.Prod
{α : Type u_9} {β : Type u_10} : Option α × β ≃ β ⊕ α × β - Equiv.sumArrowEquivProdArrow 📋 Mathlib.Logic.Equiv.Prod
(α : Type u_9) (β : Type u_10) (γ : Type u_11) : (α ⊕ β → γ) ≃ (α → γ) × (β → γ) - Equiv.sumProdDistrib 📋 Mathlib.Logic.Equiv.Prod
(α : Type u_9) (β : Type u_10) (γ : Type u_11) : (α ⊕ β) × γ ≃ α × γ ⊕ β × γ - Equiv.prodPiEquivSumPi 📋 Mathlib.Logic.Equiv.Prod
{ι : Type u_9} {ι' : Type u_10} (π : ι → Type u) (π' : ι' → Type u) : ((i : ι) → π i) × ((i' : ι') → π' i') ≃ ((i : ι ⊕ ι') → Sum.elim π π' i) - Equiv.sumPiEquivProdPi 📋 Mathlib.Logic.Equiv.Prod
{ι : Type u_10} {ι' : Type u_11} (π : ι ⊕ ι' → Type u_9) : ((i : ι ⊕ ι') → π i) ≃ ((i : ι) → π (Sum.inl i)) × ((i' : ι') → π (Sum.inr i')) - Equiv.boolProdEquivSum_symm_apply 📋 Mathlib.Logic.Equiv.Prod
(α : Type u_9) (a✝ : α ⊕ α) : (Equiv.boolProdEquivSum α).symm a✝ = Sum.elim (Prod.mk false) (Prod.mk true) a✝ - optionProdEquiv_mk_none 📋 Mathlib.Logic.Equiv.Prod
{α : Type u_9} {β : Type u_10} (b : β) : optionProdEquiv (none, b) = Sum.inl b - Equiv.boolProdEquivSum_apply 📋 Mathlib.Logic.Equiv.Prod
(α : Type u_9) (p : Bool × α) : (Equiv.boolProdEquivSum α) p = if p.1 = true then Sum.inr p.2 else Sum.inl p.2 - Equiv.sumArrowEquivProdArrow_apply_fst 📋 Mathlib.Logic.Equiv.Prod
{α : Type u_9} {β : Type u_10} {γ : Type u_11} (f : α ⊕ β → γ) (a : α) : ((Equiv.sumArrowEquivProdArrow α β γ) f).1 a = f (Sum.inl a) - Equiv.sumArrowEquivProdArrow_apply_snd 📋 Mathlib.Logic.Equiv.Prod
{α : Type u_9} {β : Type u_10} {γ : Type u_11} (f : α ⊕ β → γ) (b : β) : ((Equiv.sumArrowEquivProdArrow α β γ) f).2 b = f (Sum.inr b) - optionProdEquiv_mk_some 📋 Mathlib.Logic.Equiv.Prod
{α : Type u_9} {β : Type u_10} (a : α) (b : β) : optionProdEquiv (some a, b) = Sum.inr (a, b) - optionProdEquiv_symm_inl 📋 Mathlib.Logic.Equiv.Prod
{α : Type u_9} {β : Type u_10} (b : β) : optionProdEquiv.symm (Sum.inl b) = (none, b) - Equiv.sumArrowEquivProdArrow_symm_apply_inl 📋 Mathlib.Logic.Equiv.Prod
{α : Type u_9} {β : Type u_10} {γ : Type u_11} (f : α → γ) (g : β → γ) (a : α) : (Equiv.sumArrowEquivProdArrow α β γ).symm (f, g) (Sum.inl a) = f a - Equiv.sumArrowEquivProdArrow_symm_apply_inr 📋 Mathlib.Logic.Equiv.Prod
{α : Type u_9} {β : Type u_10} {γ : Type u_11} (f : α → γ) (g : β → γ) (b : β) : (Equiv.sumArrowEquivProdArrow α β γ).symm (f, g) (Sum.inr b) = g b - optionProdEquiv_symm_inr 📋 Mathlib.Logic.Equiv.Prod
{α : Type u_9} {β : Type u_10} (p : α × β) : optionProdEquiv.symm (Sum.inr p) = Prod.map some id p - Equiv.sumProdDistrib_apply_left 📋 Mathlib.Logic.Equiv.Prod
{α : Type u_9} {β : Type u_10} {γ : Type u_11} (a : α) (c : γ) : (Equiv.sumProdDistrib α β γ) (Sum.inl a, c) = Sum.inl (a, c) - Equiv.sumProdDistrib_apply_right 📋 Mathlib.Logic.Equiv.Prod
{α : Type u_9} {β : Type u_10} {γ : Type u_11} (b : β) (c : γ) : (Equiv.sumProdDistrib α β γ) (Sum.inr b, c) = Sum.inr (b, c) - Equiv.sumProdDistrib_symm_apply_left 📋 Mathlib.Logic.Equiv.Prod
{α : Type u_9} {β : Type u_10} {γ : Type u_11} (a : α × γ) : (Equiv.sumProdDistrib α β γ).symm (Sum.inl a) = (Sum.inl a.1, a.2) - Equiv.sumProdDistrib_symm_apply_right 📋 Mathlib.Logic.Equiv.Prod
{α : Type u_9} {β : Type u_10} {γ : Type u_11} (b : β × γ) : (Equiv.sumProdDistrib α β γ).symm (Sum.inr b) = (Sum.inr b.1, b.2) - Equiv.sumPiEquivProdPi_apply 📋 Mathlib.Logic.Equiv.Prod
{ι : Type u_10} {ι' : Type u_11} (π : ι ⊕ ι' → Type u_9) (f : (i : ι ⊕ ι') → π i) : (Equiv.sumPiEquivProdPi π) f = (fun i => f (Sum.inl i), fun i' => f (Sum.inr i')) - Equiv.sumPiEquivProdPi_symm_apply 📋 Mathlib.Logic.Equiv.Prod
{ι : Type u_10} {ι' : Type u_11} (π : ι ⊕ ι' → Type u_9) (g : ((i : ι) → π (Sum.inl i)) × ((i' : ι') → π (Sum.inr i'))) (t : ι ⊕ ι') : (Equiv.sumPiEquivProdPi π).symm g t = Sum.rec g.1 g.2 t - Equiv.prodPiEquivSumPi_symm_apply 📋 Mathlib.Logic.Equiv.Prod
{ι : Type u_9} {ι' : Type u_10} (π : ι → Type u) (π' : ι' → Type u) (a✝ : (i : ι ⊕ ι') → Sum.elim π π' i) : (Equiv.prodPiEquivSumPi π π').symm a✝ = (Equiv.sumPiEquivProdPi (Sum.elim π π')) a✝ - Equiv.prodPiEquivSumPi_apply 📋 Mathlib.Logic.Equiv.Prod
{ι : Type u_9} {ι' : Type u_10} (π : ι → Type u) (π' : ι' → Type u) (a✝ : ((i : ι) → Sum.elim π π' (Sum.inl i)) × ((i' : ι') → Sum.elim π π' (Sum.inr i'))) (i : ι ⊕ ι') : (Equiv.prodPiEquivSumPi π π') a✝ i = (Equiv.sumPiEquivProdPi (Sum.elim π π')).symm a✝ i - Equiv.prodSumDistrib 📋 Mathlib.Logic.Equiv.Sum
(α : Type u_9) (β : Type u_10) (γ : Type u_11) : α × (β ⊕ γ) ≃ α × β ⊕ α × γ - Equiv.prodSumDistrib_apply_left 📋 Mathlib.Logic.Equiv.Sum
{α : Type u_9} {β : Type u_10} {γ : Type u_11} (a : α) (b : β) : (Equiv.prodSumDistrib α β γ) (a, Sum.inl b) = Sum.inl (a, b) - Equiv.prodSumDistrib_apply_right 📋 Mathlib.Logic.Equiv.Sum
{α : Type u_9} {β : Type u_10} {γ : Type u_11} (a : α) (c : γ) : (Equiv.prodSumDistrib α β γ) (a, Sum.inr c) = Sum.inr (a, c) - Equiv.prodSumDistrib_symm_apply_left 📋 Mathlib.Logic.Equiv.Sum
{α : Type u_9} {β : Type u_10} {γ : Type u_11} (a : α × β) : (Equiv.prodSumDistrib α β γ).symm (Sum.inl a) = (a.1, Sum.inl a.2) - Equiv.prodSumDistrib_symm_apply_right 📋 Mathlib.Logic.Equiv.Sum
{α : Type u_9} {β : Type u_10} {γ : Type u_11} (a : α × γ) : (Equiv.prodSumDistrib α β γ).symm (Sum.inr a) = (a.1, Sum.inr a.2) - Equiv.piCongrLeft_sumInl 📋 Mathlib.Logic.Equiv.Basic
{ι : Type u_10} {ι' : Type u_11} {ι'' : Sort u_12} (π : ι'' → Type u_9) (e : ι ⊕ ι' ≃ ι'') (f : (i : ι) → π (e (Sum.inl i))) (g : (i : ι') → π (e (Sum.inr i))) (i : ι) : (Equiv.piCongrLeft π e) ((Equiv.sumPiEquivProdPi fun x => π (e x)).symm (f, g)) (e (Sum.inl i)) = f i - Equiv.piCongrLeft_sumInr 📋 Mathlib.Logic.Equiv.Basic
{ι : Type u_10} {ι' : Type u_11} {ι'' : Sort u_12} (π : ι'' → Type u_9) (e : ι ⊕ ι' ≃ ι'') (f : (i : ι) → π (e (Sum.inl i))) (g : (i : ι') → π (e (Sum.inr i))) (j : ι') : (Equiv.piCongrLeft π e) ((Equiv.sumPiEquivProdPi fun x => π (e x)).symm (f, g)) (e (Sum.inr j)) = g j - Equiv.sumPiEquivProdPi_symm_preimage_univ_pi 📋 Mathlib.Data.Set.Prod
{ι : Type u_1} {ι' : Type u_2} (π : ι ⊕ ι' → Type u_4) (t : (i : ι ⊕ ι') → Set (π i)) : ⇑(Equiv.sumPiEquivProdPi π).symm ⁻¹' Set.univ.pi t = (Set.univ.pi fun i => t (Sum.inl i)) ×ˢ Set.univ.pi fun i => t (Sum.inr i) - Equiv.Perm.sumCongrHom_apply 📋 Mathlib.Algebra.Group.End
(α : Type u_7) (β : Type u_8) (a : Equiv.Perm α × Equiv.Perm β) : (Equiv.Perm.sumCongrHom α β) a = a.1.sumCongr a.2 - Equiv.sumPiEquivProdPi.eq_1 📋 Mathlib.Data.Finset.Basic
{ι : Type u_10} {ι' : Type u_11} (π : ι ⊕ ι' → Type u_9) : Equiv.sumPiEquivProdPi π = { toFun := fun f => (fun i => f (Sum.inl i), fun i' => f (Sum.inr i')), invFun := fun g t => Sum.rec g.1 g.2 t, left_inv := ⋯, right_inv := ⋯ } - Equiv.piFinsetUnion.eq_1 📋 Mathlib.Data.Finset.Basic
{ι : Type u_5} [DecidableEq ι] (α : ι → Type u_4) {s t : Finset ι} (h : Disjoint s t) : Equiv.piFinsetUnion α h = (Equiv.sumPiEquivProdPi fun b => α ↑((Equiv.Finset.union s t h) b)).symm.trans (Equiv.piCongrLeft (fun i => α ↑i) (Equiv.Finset.union s t h)) - RingEquiv.sumArrowEquivProdArrow_apply 📋 Mathlib.Algebra.Ring.Equiv
{α : Type u_2} {β : Type u_3} {R : Type u_4} [NonAssocSemiring R] (x : α ⊕ β → R) : (RingEquiv.sumArrowEquivProdArrow α β R) x = (Equiv.sumArrowEquivProdArrow α β R) x - RingEquiv.sumArrowEquivProdArrow_symm_apply 📋 Mathlib.Algebra.Ring.Equiv
{α : Type u_2} {β : Type u_3} {R : Type u_4} [NonAssocSemiring R] (x : (α → R) × (β → R)) : (RingEquiv.sumArrowEquivProdArrow α β R).symm x = (Equiv.sumArrowEquivProdArrow α β R).symm x - Prod.Lex.sumLexProdLexDistrib_apply 📋 Mathlib.Order.Hom.Lex
(α : Type u_4) (β : Type u_5) (γ : Type u_6) [Preorder α] [Preorder β] [Preorder γ] (a✝ : Lex (Lex (α ⊕ β) × γ)) : (Prod.Lex.sumLexProdLexDistrib α β γ) a✝ = toLex (Sum.map (⇑toLex) (⇑toLex) ((Equiv.sumProdDistrib α β γ) (Prod.map (⇑ofLex) id (ofLex a✝)))) - Prod.Lex.sumLexProdLexDistrib_symm_apply 📋 Mathlib.Order.Hom.Lex
(α : Type u_4) (β : Type u_5) (γ : Type u_6) [Preorder α] [Preorder β] [Preorder γ] (a✝ : Lex (Lex (α × γ) ⊕ Lex (β × γ))) : (RelIso.symm (Prod.Lex.sumLexProdLexDistrib α β γ)) a✝ = toLex (Prod.map (⇑toLex) id ((Equiv.sumProdDistrib α β γ).symm (Sum.map (⇑ofLex) (⇑ofLex) (ofLex a✝)))) - LinearEquiv.sumPiEquivProdPi_apply 📋 Mathlib.Algebra.Module.Equiv.Basic
(R : Type u_9) [Semiring R] (S : Type u_10) (T : Type u_11) (A : S ⊕ T → Type u_12) [(st : S ⊕ T) → AddCommMonoid (A st)] [(st : S ⊕ T) → Module R (A st)] : ⇑(LinearEquiv.sumPiEquivProdPi R S T A) = ⇑(Equiv.sumPiEquivProdPi A) - LinearEquiv.sumPiEquivProdPi_symm_apply 📋 Mathlib.Algebra.Module.Equiv.Basic
(R : Type u_9) [Semiring R] (S : Type u_10) (T : Type u_11) (A : S ⊕ T → Type u_12) [(st : S ⊕ T) → AddCommMonoid (A st)] [(st : S ⊕ T) → Module R (A st)] : ⇑(LinearEquiv.sumPiEquivProdPi R S T A).symm = ⇑(Equiv.sumPiEquivProdPi A).symm - Finsupp.sumFinsuppEquivProdFinsupp 📋 Mathlib.Data.Finsupp.Basic
{α : Type u_12} {β : Type u_13} {γ : Type u_14} [Zero γ] : (α ⊕ β →₀ γ) ≃ (α →₀ γ) × (β →₀ γ) - Finsupp.fst_sumFinsuppEquivProdFinsupp 📋 Mathlib.Data.Finsupp.Basic
{α : Type u_12} {β : Type u_13} {γ : Type u_14} [Zero γ] (f : α ⊕ β →₀ γ) (x : α) : (Finsupp.sumFinsuppEquivProdFinsupp f).1 x = f (Sum.inl x) - Finsupp.snd_sumFinsuppEquivProdFinsupp 📋 Mathlib.Data.Finsupp.Basic
{α : Type u_12} {β : Type u_13} {γ : Type u_14} [Zero γ] (f : α ⊕ β →₀ γ) (y : β) : (Finsupp.sumFinsuppEquivProdFinsupp f).2 y = f (Sum.inr y) - Finsupp.sumFinsuppEquivProdFinsupp_apply 📋 Mathlib.Data.Finsupp.Basic
{α : Type u_12} {β : Type u_13} {γ : Type u_14} [Zero γ] (f : α ⊕ β →₀ γ) : Finsupp.sumFinsuppEquivProdFinsupp f = (Finsupp.comapDomain Sum.inl f ⋯, Finsupp.comapDomain Sum.inr f ⋯) - Finsupp.sumFinsuppEquivProdFinsupp_symm_apply 📋 Mathlib.Data.Finsupp.Basic
{α : Type u_12} {β : Type u_13} {γ : Type u_14} [Zero γ] (fg : (α →₀ γ) × (β →₀ γ)) : Finsupp.sumFinsuppEquivProdFinsupp.symm fg = fg.1.sumElim fg.2 - Finsupp.sumFinsuppEquivProdFinsupp_symm_inl 📋 Mathlib.Data.Finsupp.Basic
{α : Type u_12} {β : Type u_13} {γ : Type u_14} [Zero γ] (fg : (α →₀ γ) × (β →₀ γ)) (x : α) : (Finsupp.sumFinsuppEquivProdFinsupp.symm fg) (Sum.inl x) = fg.1 x - Finsupp.sumFinsuppEquivProdFinsupp_symm_inr 📋 Mathlib.Data.Finsupp.Basic
{α : Type u_12} {β : Type u_13} {γ : Type u_14} [Zero γ] (fg : (α →₀ γ) × (β →₀ γ)) (y : β) : (Finsupp.sumFinsuppEquivProdFinsupp.symm fg) (Sum.inr y) = fg.2 y - AlgEquiv.sumArrowEquivProdArrow_apply 📋 Mathlib.Algebra.Algebra.Pi
{α : Type u_1} {β : Type u_2} {R : Type u_3} [CommSemiring R] (S : Type u_8) [Semiring S] [Algebra R S] (x : α ⊕ β → S) : (AlgEquiv.sumArrowEquivProdArrow α β R S) x = (Equiv.sumArrowEquivProdArrow α β S) x - AlgEquiv.sumArrowEquivProdArrow_symm_apply_inr 📋 Mathlib.Algebra.Algebra.Pi
{α : Type u_1} {β : Type u_2} {R : Type u_3} [CommSemiring R] (S : Type u_8) [Semiring S] [Algebra R S] (x : (α → S) × (β → S)) : (AlgEquiv.sumArrowEquivProdArrow α β R S).symm x = (Equiv.sumArrowEquivProdArrow α β S).symm x - Homeomorph.sumProdDistrib_apply 📋 Mathlib.Topology.Constructions.SumProd
{X : Type u} {Y : Type v} {Z : Type u_2} [TopologicalSpace X] [TopologicalSpace Y] [TopologicalSpace Z] (a✝ : (X ⊕ Y) × Z) : Homeomorph.sumProdDistrib a✝ = (Equiv.sumProdDistrib X Y Z) a✝ - Homeomorph.sumProdDistrib_symm_apply 📋 Mathlib.Topology.Constructions.SumProd
{X : Type u} {Y : Type v} {Z : Type u_2} [TopologicalSpace X] [TopologicalSpace Y] [TopologicalSpace Z] (a✝ : X × Z ⊕ Y × Z) : Homeomorph.sumProdDistrib.symm a✝ = (Equiv.sumProdDistrib X Y Z).symm a✝ - Matrix.fromBlocksZero₁₂InvertibleEquiv 📋 Mathlib.LinearAlgebra.Matrix.SchurComplement
{m : Type u_2} {n : Type u_3} {α : Type u_4} [Fintype m] [Fintype n] [DecidableEq m] [DecidableEq n] [CommRing α] (A : Matrix m m α) (C : Matrix n m α) (D : Matrix n n α) : Invertible (Matrix.fromBlocks A 0 C D) ≃ Invertible A × Invertible D - Matrix.fromBlocksZero₂₁InvertibleEquiv 📋 Mathlib.LinearAlgebra.Matrix.SchurComplement
{m : Type u_2} {n : Type u_3} {α : Type u_4} [Fintype m] [Fintype n] [DecidableEq m] [DecidableEq n] [CommRing α] (A : Matrix m m α) (B : Matrix m n α) (D : Matrix n n α) : Invertible (Matrix.fromBlocks A B 0 D) ≃ Invertible A × Invertible D - PrimeSpectrum.primeSpectrumProd 📋 Mathlib.RingTheory.Spectrum.Prime.Basic
(R : Type u) (S : Type v) [CommSemiring R] [CommSemiring S] : PrimeSpectrum (R × S) ≃ PrimeSpectrum R ⊕ PrimeSpectrum S - PrimeSpectrum.primeSpectrumProd_symm_inl_asIdeal 📋 Mathlib.RingTheory.Spectrum.Prime.Basic
{R : Type u} {S : Type v} [CommSemiring R] [CommSemiring S] (x : PrimeSpectrum R) : ((PrimeSpectrum.primeSpectrumProd R S).symm (Sum.inl x)).asIdeal = x.asIdeal.prod ⊤ - PrimeSpectrum.primeSpectrumProd_symm_inr_asIdeal 📋 Mathlib.RingTheory.Spectrum.Prime.Basic
{R : Type u} {S : Type v} [CommSemiring R] [CommSemiring S] (x : PrimeSpectrum S) : ((PrimeSpectrum.primeSpectrumProd R S).symm (Sum.inr x)).asIdeal = ⊤.prod x.asIdeal - PrimeSpectrum.primeSpectrumProd_symm_inl 📋 Mathlib.RingTheory.Spectrum.Prime.Topology
{R : Type u} {S : Type v} [CommSemiring R] [CommSemiring S] (x : PrimeSpectrum R) : (PrimeSpectrum.primeSpectrumProd R S).symm (Sum.inl x) = PrimeSpectrum.comap (RingHom.fst R S) x - PrimeSpectrum.primeSpectrumProd_symm_inr 📋 Mathlib.RingTheory.Spectrum.Prime.Topology
{R : Type u} {S : Type v} [CommSemiring R] [CommSemiring S] (x : PrimeSpectrum S) : (PrimeSpectrum.primeSpectrumProd R S).symm (Sum.inr x) = PrimeSpectrum.comap (RingHom.snd R S) x - Finsupp.sumFinsuppEquivProdFinsupp.eq_1 📋 Mathlib.RingTheory.Extension.Generators
{α : Type u_12} {β : Type u_13} {γ : Type u_14} [Zero γ] : Finsupp.sumFinsuppEquivProdFinsupp = { toFun := fun f => (Finsupp.comapDomain Sum.inl f ⋯, Finsupp.comapDomain Sum.inr f ⋯), invFun := fun fg => fg.1.sumElim fg.2, left_inv := ⋯, right_inv := ⋯ } - MeasurableEquiv.coe_sumPiEquivProdPi 📋 Mathlib.MeasureTheory.MeasurableSpace.Embedding
{δ : Type u_4} {δ' : Type u_5} (α : δ ⊕ δ' → Type u_8) [(i : δ ⊕ δ') → MeasurableSpace (α i)] : ⇑(MeasurableEquiv.sumPiEquivProdPi α) = ⇑(Equiv.sumPiEquivProdPi α) - MeasurableEquiv.coe_sumPiEquivProdPi_symm 📋 Mathlib.MeasureTheory.MeasurableSpace.Embedding
{δ : Type u_4} {δ' : Type u_5} (α : δ ⊕ δ' → Type u_8) [(i : δ ⊕ δ') → MeasurableSpace (α i)] : ⇑(MeasurableEquiv.sumPiEquivProdPi α).symm = ⇑(Equiv.sumPiEquivProdPi α).symm - Equiv.sumEmbeddingEquivProdEmbeddingDisjoint 📋 Mathlib.Logic.Equiv.Embedding
{α : Type u_1} {β : Type u_2} {γ : Type u_3} : (α ⊕ β ↪ γ) ≃ { f // Disjoint (Set.range ⇑f.1) (Set.range ⇑f.2) } - Polynomial.toMatrix_sylvesterMap 📋 Mathlib.RingTheory.Polynomial.Resultant.Basic
{m n : ℕ} {R : Type u_1} [CommRing R] (f g : Polynomial R) (hf : f.natDegree ≤ m) (hg : g.natDegree ≤ n) : (LinearMap.toMatrix ((Polynomial.degreeLT.basis R m).prod (Polynomial.degreeLT.basis R n)) (Polynomial.degreeLT.basis R (m + n))) (f.sylvesterMap g hf hg) = (Matrix.reindex (Equiv.refl (Fin (m + n))) finSumFinEquiv.symm) (f.sylvester g m n) - AlgebraicGeometry.coprodSpec_coprodMk 📋 Mathlib.AlgebraicGeometry.Limits
(R S : Type u) [CommRing R] [CommRing S] (x : ↥(AlgebraicGeometry.Spec { carrier := R, commRing := inst✝ }) ⊕ ↥(AlgebraicGeometry.Spec { carrier := S, commRing := inst✝¹ })) : (AlgebraicGeometry.coprodSpec R S) ((AlgebraicGeometry.coprodMk (AlgebraicGeometry.Spec { carrier := R, commRing := inst✝ }) (AlgebraicGeometry.Spec { carrier := S, commRing := inst✝¹ })) x) = (PrimeSpectrum.primeSpectrumProd R S).symm x - AlgebraicGeometry.coprodSpec_apply 📋 Mathlib.AlgebraicGeometry.Limits
(R S : Type u) [CommRing R] [CommRing S] (x : ↥(AlgebraicGeometry.Spec { carrier := R, commRing := inst✝ } ⨿ AlgebraicGeometry.Spec { carrier := S, commRing := inst✝¹ })) : (AlgebraicGeometry.coprodSpec R S) x = (PrimeSpectrum.primeSpectrumProd R S).symm ((AlgebraicGeometry.coprodMk (AlgebraicGeometry.Spec { carrier := R, commRing := inst✝ }) (AlgebraicGeometry.Spec { carrier := S, commRing := inst✝¹ })).symm x) - Algebra.Generators.cotangentCompLocalizationAwayEquiv.eq_1 📋 Mathlib.RingTheory.Extension.Cotangent.LocalizationAway
{R : Type u_1} {S : Type u_2} {T : Type u_3} {ι : Type u_4} [CommRing R] [CommRing S] [Algebra R S] [CommRing T] [Algebra R T] [Algebra S T] [IsScalarTower R S T] (g : S) [IsLocalization.Away g T] (P : Algebra.Generators R S ι) {x : ((Algebra.Generators.localizationAway T g).comp P).toExtension.Cotangent} (hx : (Algebra.Extension.Cotangent.map ((Algebra.Generators.localizationAway T g).ofComp P).toExtensionHom) x = Algebra.Generators.cMulXSubOneCotangent T g) : Algebra.Generators.cotangentCompLocalizationAwayEquiv g P hx = ↑((⋯.splitSurjectiveEquiv ⋯) ⟨Algebra.Generators.cotangentCompAwaySec g P x, ⋯⟩) - Polynomial.UniversalCoprimeFactorizationRing.homEquiv 📋 Mathlib.RingTheory.Polynomial.UniversalFactorizationRing
{R : Type u_1} (S : Type u_2) [CommRing R] [CommRing S] [Algebra R S] {n : ℕ} (m k : ℕ) (hn : n = m + k) (p : Polynomial.MonicDegreeEq R n) : (Polynomial.UniversalCoprimeFactorizationRing m k hn p →ₐ[R] S) ≃ { q // ↑q.1 * ↑q.2 = Polynomial.map (algebraMap R S) ↑p ∧ IsCoprime ↑q.1 ↑q.2 } - Polynomial.UniversalCoprimeFactorizationRing.homEquiv.eq_1 📋 Mathlib.RingTheory.Polynomial.UniversalFactorizationRing
{R : Type u_1} (S : Type u_2) [CommRing R] [CommRing S] [Algebra R S] {n : ℕ} (m k : ℕ) (hn : n = m + k) (p : Polynomial.MonicDegreeEq R n) : Polynomial.UniversalCoprimeFactorizationRing.homEquiv S m k hn p = { toFun := fun f => ⟨↑((Polynomial.UniversalFactorizationRing.homEquiv S m k hn p) (f.comp (IsScalarTower.toAlgHom R (Polynomial.UniversalFactorizationRing m k hn p) (Polynomial.UniversalCoprimeFactorizationRing m k hn p)))), ⋯⟩, invFun := fun q => IsLocalization.liftAlgHom ⋯, left_inv := ⋯, right_inv := ⋯ } - Polynomial.UniversalCoprimeFactorizationRing.homEquiv_comp_fst 📋 Mathlib.RingTheory.Polynomial.UniversalFactorizationRing
{R : Type u_1} (S : Type u_2) [CommRing R] [CommRing S] [Algebra R S] {n : ℕ} (m k : ℕ) (hn : n = m + k) (p : Polynomial.MonicDegreeEq R n) {T : Type u_4} [CommRing T] [Algebra R T] (f : Polynomial.UniversalCoprimeFactorizationRing m k hn p →ₐ[R] S) (g : S →ₐ[R] T) : (↑((Polynomial.UniversalCoprimeFactorizationRing.homEquiv T m k hn p) (g.comp f))).1 = (↑((Polynomial.UniversalCoprimeFactorizationRing.homEquiv S m k hn p) f)).1.map ↑g - Polynomial.UniversalCoprimeFactorizationRing.homEquiv_comp_snd 📋 Mathlib.RingTheory.Polynomial.UniversalFactorizationRing
{R : Type u_1} (S : Type u_2) [CommRing R] [CommRing S] [Algebra R S] {n : ℕ} (m k : ℕ) (hn : n = m + k) (p : Polynomial.MonicDegreeEq R n) {T : Type u_4} [CommRing T] [Algebra R T] (f : Polynomial.UniversalCoprimeFactorizationRing m k hn p →ₐ[R] S) (g : S →ₐ[R] T) : (↑((Polynomial.UniversalCoprimeFactorizationRing.homEquiv T m k hn p) (g.comp f))).2 = (↑((Polynomial.UniversalCoprimeFactorizationRing.homEquiv S m k hn p) f)).2.map ↑g - SimpleGraph.Coloring.sumEquiv 📋 Mathlib.Combinatorics.SimpleGraph.Sum
{V : Type u_1} {W : Type u_2} {γ : Type u_4} {G : SimpleGraph V} {H : SimpleGraph W} : (G ⊕g H).Coloring γ ≃ G.Coloring γ × H.Coloring γ - SimpleGraph.Iso.boxProdSumDistrib_toEquiv 📋 Mathlib.Combinatorics.SimpleGraph.Prod
{V : Type u_4} {W₁ : Type u_8} {W₂ : Type u_9} (G : SimpleGraph V) (H₁ : SimpleGraph W₁) (H₂ : SimpleGraph W₂) : (SimpleGraph.Iso.boxProdSumDistrib G H₁ H₂).toEquiv = Equiv.prodSumDistrib V W₁ W₂ - SimpleGraph.Iso.sumBoxProdDistrib_toEquiv 📋 Mathlib.Combinatorics.SimpleGraph.Prod
{V₁ : Type u_5} {V₂ : Type u_6} {W : Type u_7} (G₁ : SimpleGraph V₁) (G₂ : SimpleGraph V₂) (H : SimpleGraph W) : (SimpleGraph.Iso.sumBoxProdDistrib G₁ G₂ H).toEquiv = Equiv.sumProdDistrib V₁ V₂ W - SimpleGraph.Iso.boxProdSumDistrib_apply 📋 Mathlib.Combinatorics.SimpleGraph.Prod
{V : Type u_4} {W₁ : Type u_8} {W₂ : Type u_9} (G : SimpleGraph V) (H₁ : SimpleGraph W₁) (H₂ : SimpleGraph W₂) (a✝ : V × (W₁ ⊕ W₂)) : (SimpleGraph.Iso.boxProdSumDistrib G H₁ H₂) a✝ = Sum.map Prod.swap Prod.swap ((Equiv.sumProdDistrib W₁ W₂ V) a✝.swap) - SimpleGraph.Iso.boxProdSumDistrib_symm_apply 📋 Mathlib.Combinatorics.SimpleGraph.Prod
{V : Type u_4} {W₁ : Type u_8} {W₂ : Type u_9} (G : SimpleGraph V) (H₁ : SimpleGraph W₁) (H₂ : SimpleGraph W₂) (a✝ : V × W₁ ⊕ V × W₂) : (RelIso.symm (SimpleGraph.Iso.boxProdSumDistrib G H₁ H₂)) a✝ = ((Equiv.sumProdDistrib W₁ W₂ V).symm (Sum.map Prod.swap Prod.swap a✝)).swap - FirstOrder.genericPolyMapSurjOnOfInjOn.eq_1 📋 Mathlib.FieldTheory.AxGrothendieck
{ι : Type u_1} {α : Type u_2} [Finite α] [Finite ι] (φ : FirstOrder.Language.ring.Formula (α ⊕ ι)) (mons : ι → Finset (ι →₀ ℕ)) : FirstOrder.genericPolyMapSurjOnOfInjOn φ mons = FirstOrder.Language.Formula.iAlls (α ⊕ (i : ι) × ↥(mons i)) (FirstOrder.Language.Formula.relabel Sum.inr ((FirstOrder.Language.Formula.iAlls ι ((FirstOrder.Language.Formula.relabel (Sum.map Sum.inl id) φ).imp (FirstOrder.Language.BoundedFormula.subst φ (Sum.elim (fun a => FirstOrder.Language.var (Sum.inl (Sum.inl a))) fun i => FirstOrder.Language.Term.relabel (fun i => (Equiv.sumAssoc α ((i : ι) × ↥(mons i)) ι).symm (Sum.inr i)) (FirstOrder.Ring.termOfFreeCommRing (FirstOrder.Ring.genericPolyMap mons i)))))).imp ((FirstOrder.Language.Formula.iAlls (Fin 2 × ι) (FirstOrder.Language.BoundedFormula.imp (FirstOrder.Language.Formula.relabel (Sum.map Sum.inl fun i => (0, i)) φ) (FirstOrder.Language.BoundedFormula.imp (FirstOrder.Language.Formula.relabel (Sum.map Sum.inl fun i => (1, i)) φ) (FirstOrder.Language.Formula.relabel (fun x => (Equiv.sumAssoc α ((i : ι) × ↥(mons i)) (Fin 2 × ι)).symm (Sum.inr x)) (FirstOrder.Language.Formula.imp (FirstOrder.Language.BoundedFormula.iInf fun i => (FirstOrder.Language.Term.relabel (Sum.inl ∘ Sum.map id fun i => (0, i)) (FirstOrder.Ring.termOfFreeCommRing (FirstOrder.Ring.genericPolyMap mons i))).bdEqual (FirstOrder.Language.Term.relabel (Sum.inl ∘ Sum.map id fun i => (1, i)) (FirstOrder.Ring.termOfFreeCommRing (FirstOrder.Ring.genericPolyMap mons i)))) (FirstOrder.Language.BoundedFormula.iInf fun i => (FirstOrder.Language.var (Sum.inl (Sum.inr (0, i)))).bdEqual (FirstOrder.Language.var (Sum.inl (Sum.inr (1, i)))))))))).imp (FirstOrder.Language.Formula.iAlls ι ((FirstOrder.Language.Formula.relabel (Sum.map Sum.inl id) φ).imp (FirstOrder.Language.Formula.iExs ι (FirstOrder.Language.Formula.relabel (fun i => have this := Sum.elim (Sum.inl ∘ Sum.inl) (fun i => if i.1 = 0 then Sum.inr i.2 else Sum.inl (Sum.inr i.2)) i; this) (FirstOrder.Language.Formula.relabel (Sum.map Sum.inl fun i => (0, i)) φ ⊓ FirstOrder.Language.Formula.relabel (fun x => (Equiv.sumAssoc α ((i : ι) × ↥(mons i)) (Fin 2 × ι)).symm (Sum.inr x)) (FirstOrder.Language.BoundedFormula.iInf fun i => (FirstOrder.Language.Term.relabel (Sum.inl ∘ Sum.map id fun i => (0, i)) (FirstOrder.Ring.termOfFreeCommRing (FirstOrder.Ring.genericPolyMap mons i))).bdEqual (FirstOrder.Language.var (Sum.inl (Sum.inr (1, i))))))))))))) - DihedralGroup.oddCommuteEquiv 📋 Mathlib.GroupTheory.SpecificGroups.Dihedral
{n : ℕ} (hn : Odd n) : { p // Commute p.1 p.2 } ≃ ZMod n ⊕ ZMod n ⊕ ZMod n ⊕ ZMod n × ZMod n - DihedralGroup.oddCommuteEquiv_apply 📋 Mathlib.GroupTheory.SpecificGroups.Dihedral
{n : ℕ} (hn : Odd n) (x✝ : { p // Commute p.1 p.2 }) : (DihedralGroup.oddCommuteEquiv hn) x✝ = match x✝ with | ⟨(DihedralGroup.sr i, DihedralGroup.r a), property⟩ => Sum.inl i | ⟨(DihedralGroup.r a, DihedralGroup.sr j), property⟩ => Sum.inr (Sum.inl j) | ⟨(DihedralGroup.sr i, DihedralGroup.sr j), property⟩ => Sum.inr (Sum.inr (Sum.inl (i + j))) | ⟨(DihedralGroup.r i, DihedralGroup.r j), property⟩ => Sum.inr (Sum.inr (Sum.inr (i, j))) - DihedralGroup.oddCommuteEquiv_symm_apply 📋 Mathlib.GroupTheory.SpecificGroups.Dihedral
{n : ℕ} (hn : Odd n) (x✝ : ZMod n ⊕ ZMod n ⊕ ZMod n ⊕ ZMod n × ZMod n) : (DihedralGroup.oddCommuteEquiv hn).symm x✝ = match x✝ with | Sum.inl i => ⟨(DihedralGroup.sr i, DihedralGroup.r 0), ⋯⟩ | Sum.inr (Sum.inl j) => ⟨(DihedralGroup.r 0, DihedralGroup.sr j), ⋯⟩ | Sum.inr (Sum.inr (Sum.inl k)) => ⟨(DihedralGroup.sr (↑(ZMod.unitOfCoprime 2 ⋯)⁻¹ * k), DihedralGroup.sr (↑(ZMod.unitOfCoprime 2 ⋯)⁻¹ * k)), ⋯⟩ | Sum.inr (Sum.inr (Sum.inr (i, j))) => ⟨(DihedralGroup.r i, DihedralGroup.r j), ⋯⟩ - SetTheory.PGame.toLeftMovesMul 📋 Mathlib.SetTheory.Game.Basic
{x y : SetTheory.PGame} : x.LeftMoves × y.LeftMoves ⊕ x.RightMoves × y.RightMoves ≃ (x * y).LeftMoves - SetTheory.PGame.toRightMovesMul 📋 Mathlib.SetTheory.Game.Basic
{x y : SetTheory.PGame} : x.LeftMoves × y.RightMoves ⊕ x.RightMoves × y.LeftMoves ≃ (x * y).RightMoves - SetTheory.PGame.mul_moveLeft_inl 📋 Mathlib.SetTheory.Game.Basic
{x y : SetTheory.PGame} {i : x.LeftMoves} {j : y.LeftMoves} : (x * y).moveLeft (SetTheory.PGame.toLeftMovesMul (Sum.inl (i, j))) = x.moveLeft i * y + x * y.moveLeft j - x.moveLeft i * y.moveLeft j - SetTheory.PGame.mul_moveLeft_inr 📋 Mathlib.SetTheory.Game.Basic
{x y : SetTheory.PGame} {i : x.RightMoves} {j : y.RightMoves} : (x * y).moveLeft (SetTheory.PGame.toLeftMovesMul (Sum.inr (i, j))) = x.moveRight i * y + x * y.moveRight j - x.moveRight i * y.moveRight j - SetTheory.PGame.mul_moveRight_inl 📋 Mathlib.SetTheory.Game.Basic
{x y : SetTheory.PGame} {i : x.LeftMoves} {j : y.RightMoves} : (x * y).moveRight (SetTheory.PGame.toRightMovesMul (Sum.inl (i, j))) = x.moveLeft i * y + x * y.moveRight j - x.moveLeft i * y.moveRight j - SetTheory.PGame.mul_moveRight_inr 📋 Mathlib.SetTheory.Game.Basic
{x y : SetTheory.PGame} {i : x.RightMoves} {j : y.LeftMoves} : (x * y).moveRight (SetTheory.PGame.toRightMovesMul (Sum.inr (i, j))) = x.moveRight i * y + x * y.moveLeft j - x.moveRight i * y.moveLeft j - SetTheory.PGame.leftMoves_mul_cases 📋 Mathlib.SetTheory.Game.Basic
{x y : SetTheory.PGame} (k : (x * y).LeftMoves) {P : (x * y).LeftMoves → Prop} (hl : ∀ (ix : x.LeftMoves) (iy : y.LeftMoves), P (SetTheory.PGame.toLeftMovesMul (Sum.inl (ix, iy)))) (hr : ∀ (jx : x.RightMoves) (jy : y.RightMoves), P (SetTheory.PGame.toLeftMovesMul (Sum.inr (jx, jy)))) : P k - SetTheory.PGame.rightMoves_mul_cases 📋 Mathlib.SetTheory.Game.Basic
{x y : SetTheory.PGame} (k : (x * y).RightMoves) {P : (x * y).RightMoves → Prop} (hl : ∀ (ix : x.LeftMoves) (jy : y.RightMoves), P (SetTheory.PGame.toRightMovesMul (Sum.inl (ix, jy)))) (hr : ∀ (jx : x.RightMoves) (iy : y.LeftMoves), P (SetTheory.PGame.toRightMovesMul (Sum.inr (jx, iy)))) : P k - SetTheory.PGame.mulCommRelabelling.eq_def 📋 Mathlib.SetTheory.Game.Basic
(x y : SetTheory.PGame) : x.mulCommRelabelling y = match x, y with | SetTheory.PGame.mk xl xr xL xR, SetTheory.PGame.mk yl yr yL yR => SetTheory.PGame.Relabelling.mk ((Equiv.prodComm xl yl).sumCongr (Equiv.prodComm xr yr)) ((Equiv.sumComm (xl × yr) (xr × yl)).trans ((Equiv.prodComm xr yl).sumCongr (Equiv.prodComm xl yr))) (fun i => Sum.casesOn i (fun val => Prod.casesOn val fun i j => id ((((xL i * SetTheory.PGame.mk yl yr yL yR).addCommRelabelling (SetTheory.PGame.mk xl xr xL xR * yL j)).trans (((SetTheory.PGame.mk xl xr xL xR).mulCommRelabelling (yL j)).addCongr ((xL i).mulCommRelabelling (SetTheory.PGame.mk yl yr yL yR)))).subCongr ((xL i).mulCommRelabelling (yL j)))) fun val => Prod.casesOn val fun i j => id ((((xR i * SetTheory.PGame.mk yl yr yL yR).addCommRelabelling (SetTheory.PGame.mk xl xr xL xR * yR j)).trans (((SetTheory.PGame.mk xl xr xL xR).mulCommRelabelling (yR j)).addCongr ((xR i).mulCommRelabelling (SetTheory.PGame.mk yl yr yL yR)))).subCongr ((xR i).mulCommRelabelling (yR j)))) fun j => Sum.casesOn j (fun val => Prod.casesOn val fun i j => id ((((xL i * SetTheory.PGame.mk yl yr yL yR).addCommRelabelling (SetTheory.PGame.mk xl xr xL xR * yR j)).trans (((SetTheory.PGame.mk xl xr xL xR).mulCommRelabelling (yR j)).addCongr ((xL i).mulCommRelabelling (SetTheory.PGame.mk yl yr yL yR)))).subCongr ((xL i).mulCommRelabelling (yR j)))) fun val => Prod.casesOn val fun i j => id ((((xR i * SetTheory.PGame.mk yl yr yL yR).addCommRelabelling (SetTheory.PGame.mk xl xr xL xR * yL j)).trans (((SetTheory.PGame.mk xl xr xL xR).mulCommRelabelling (yL j)).addCongr ((xR i).mulCommRelabelling (SetTheory.PGame.mk yl yr yL yR)))).subCongr ((xR i).mulCommRelabelling (yL j))) - SetTheory.PGame.negMulRelabelling.eq_def 📋 Mathlib.SetTheory.Game.Basic
(x y : SetTheory.PGame) : x.negMulRelabelling y = match x, y with | ⋯, ⋯ => SetTheory.PGame.Relabelling.mk (Equiv.sumComm (xr × yl) (xl × yr)) (Equiv.sumComm (xr × yr) (xl × yl)) (fun i => Sum.casesOn i (fun val => Prod.casesOn val fun i j => id ((((fun a => SetTheory.PGame.rec (motive := fun x => SetTheory.PGame → SetTheory.PGame) (fun xl xr a a_1 IHxl IHxr y => SetTheory.PGame.rec (fun yl yr yL yR IHyl IHyr => have y := SetTheory.PGame.mk yl yr yL yR; SetTheory.PGame.mk (xl × yl ⊕ xr × yr) (xl × yr ⊕ xr × yl) (fun a => Sum.casesOn a (fun val => Prod.casesOn val fun i j => IHxl i y + IHyl j - IHxl i (yL j)) fun val => Prod.casesOn val fun i j => IHxr i y + IHyr j - IHxr i (yR j)) fun a => Sum.casesOn a (fun val => Prod.casesOn val fun i j => IHxl i y + IHyr j - IHxl i (yR j)) fun val => Prod.casesOn val fun i j => IHxr i y + IHyl j - IHxr i (yL j)) y) (xR a)) i (SetTheory.PGame.mk yl yr yL yR) + (fun a => SetTheory.PGame.rec (fun yl yr yL yR IHyl IHyr => have y := SetTheory.PGame.mk yl yr yL yR; SetTheory.PGame.mk (xl × yl ⊕ xr × yr) (xl × yr ⊕ xr × yl) (fun a => Sum.casesOn a (fun val => Prod.casesOn val fun i j => (fun a => SetTheory.PGame.rec (motive := fun x => SetTheory.PGame → SetTheory.PGame) (fun xl xr a a_1 IHxl IHxr y => SetTheory.PGame.rec (fun yl yr yL yR IHyl IHyr => have y := SetTheory.PGame.mk yl yr yL yR; SetTheory.PGame.mk (xl × yl ⊕ xr × yr) (xl × yr ⊕ xr × yl) (fun a => Sum.casesOn a (fun val => Prod.casesOn val fun i j => IHxl i y + IHyl j - IHxl i (yL j)) fun val => Prod.casesOn val fun i j => IHxr i y + IHyr j - IHxr i (yR j)) fun a => Sum.casesOn a (fun val => Prod.casesOn val fun i j => IHxl i y + IHyr j - IHxl i (yR j)) fun val => Prod.casesOn val fun i j => IHxr i y + IHyl j - IHxr i (yL j)) y) (xL a)) i y + IHyl j - (fun a => SetTheory.PGame.rec (motive := fun x => SetTheory.PGame → SetTheory.PGame) (fun xl xr a a_1 IHxl IHxr y => SetTheory.PGame.rec (fun yl yr yL yR IHyl IHyr => have y := SetTheory.PGame.mk yl yr yL yR; SetTheory.PGame.mk (xl × yl ⊕ xr × yr) (xl × yr ⊕ xr × yl) (fun a => Sum.casesOn a (fun val => Prod.casesOn val fun i j => IHxl i y + IHyl j - IHxl i (yL j)) fun val => Prod.casesOn val fun i j => IHxr i y + IHyr j - IHxr i (yR j)) fun a => Sum.casesOn a (fun val => Prod.casesOn val fun i j => IHxl i y + IHyr j - IHxl i (yR j)) fun val => Prod.casesOn val fun i j => IHxr i y + IHyl j - IHxr i (yL j)) y) (xL a)) i (yL j)) fun val => Prod.casesOn val fun i j => (fun a => SetTheory.PGame.rec (motive := fun x => SetTheory.PGame → SetTheory.PGame) (fun xl xr a a_1 IHxl IHxr y => SetTheory.PGame.rec (fun yl yr yL yR IHyl IHyr => have y := SetTheory.PGame.mk yl yr yL yR; SetTheory.PGame.mk (xl × yl ⊕ xr × yr) (xl × yr ⊕ xr × yl) (fun a => Sum.casesOn a (fun val => Prod.casesOn val fun i j => IHxl i y + IHyl j - IHxl i (yL j)) fun val => Prod.casesOn val fun i j => IHxr i y + IHyr j - IHxr i (yR j)) fun a => Sum.casesOn a (fun val => Prod.casesOn val fun i j => IHxl i y + IHyr j - IHxl i (yR j)) fun val => Prod.casesOn val fun i j => IHxr i y + IHyl j - IHxr i (yL j)) y) (xR a)) i y + IHyr j - (fun a => SetTheory.PGame.rec (motive := fun x => SetTheory.PGame → SetTheory.PGame) (fun xl xr a a_1 IHxl IHxr y => SetTheory.PGame.rec (fun yl yr yL yR IHyl IHyr => have y := SetTheory.PGame.mk yl yr yL yR; SetTheory.PGame.mk (xl × yl ⊕ xr × yr) (xl × yr ⊕ xr × yl) (fun a => Sum.casesOn a (fun val => Prod.casesOn val fun i j => IHxl i y + IHyl j - IHxl i (yL j)) fun val => Prod.casesOn val fun i j => IHxr i y + IHyr j - IHxr i (yR j)) fun a => Sum.casesOn a (fun val => Prod.casesOn val fun i j => IHxl i y + IHyr j - IHxl i (yR j)) fun val => Prod.casesOn val fun i j => IHxr i y + IHyl j - IHxr i (yL j)) y) (xR a)) i (yR j)) fun a => Sum.casesOn a (fun val => Prod.casesOn val fun i j => (fun a => SetTheory.PGame.rec (motive := fun x => SetTheory.PGame → SetTheory.PGame) (fun xl xr a a_1 IHxl IHxr y => SetTheory.PGame.rec (fun yl yr yL yR IHyl IHyr => have y := SetTheory.PGame.mk yl yr yL yR; SetTheory.PGame.mk (xl × yl ⊕ xr × yr) (xl × yr ⊕ xr × yl) (fun a => Sum.casesOn a (fun val => Prod.casesOn val fun i j => IHxl i y + IHyl j - IHxl i (yL j)) fun val => Prod.casesOn val fun i j => IHxr i y + IHyr j - IHxr i (yR j)) fun a => Sum.casesOn a (fun val => Prod.casesOn val fun i j => IHxl i y + IHyr j - IHxl i (yR j)) fun val => Prod.casesOn val fun i j => IHxr i y + IHyl j - IHxr i (yL j)) y) (xL a)) i y + IHyr j - (fun a => SetTheory.PGame.rec (motive := fun x => SetTheory.PGame → SetTheory.PGame) (fun xl xr a a_1 IHxl IHxr y => SetTheory.PGame.rec (fun yl yr yL yR IHyl IHyr => have y := SetTheory.PGame.mk yl yr yL yR; SetTheory.PGame.mk (xl × yl ⊕ xr × yr) (xl × yr ⊕ xr × yl) (fun a => Sum.casesOn a (fun val => Prod.casesOn val fun i j => IHxl i y + IHyl j - IHxl i (yL j)) fun val => Prod.casesOn val fun i j => IHxr i y + IHyr j - IHxr i (yR j)) fun a => Sum.casesOn a (fun val => Prod.casesOn val fun i j => IHxl i y + IHyr j - IHxl i (yR j)) fun val => Prod.casesOn val fun i j => IHxr i y + IHyl j - IHxr i (yL j)) y) (xL a)) i (yR j)) fun val => Prod.casesOn val fun i j => (fun a => SetTheory.PGame.rec (motive := fun x => SetTheory.PGame → SetTheory.PGame) (fun xl xr a a_1 IHxl IHxr y => SetTheory.PGame.rec (fun yl yr yL yR IHyl IHyr => have y := SetTheory.PGame.mk yl yr yL yR; SetTheory.PGame.mk (xl × yl ⊕ xr × yr) (xl × yr ⊕ xr × yl) (fun a => Sum.casesOn a (fun val => Prod.casesOn val fun i j => IHxl i y + IHyl j - IHxl i (yL j)) fun val => Prod.casesOn val fun i j => IHxr i y + IHyr j - IHxr i (yR j)) fun a => Sum.casesOn a (fun val => Prod.casesOn val fun i j => IHxl i y + IHyr j - IHxl i (yR j)) fun val => Prod.casesOn val fun i j => IHxr i y + IHyl j - IHxr i (yL j)) y) (xR a)) i y + IHyl j - (fun a => SetTheory.PGame.rec (motive := fun x => SetTheory.PGame → SetTheory.PGame) (fun xl xr a a_1 IHxl IHxr y => SetTheory.PGame.rec (fun yl yr yL yR IHyl IHyr => have y := SetTheory.PGame.mk yl yr yL yR; SetTheory.PGame.mk (xl × yl ⊕ xr × yr) (xl × yr ⊕ xr × yl) (fun a => Sum.casesOn a (fun val => Prod.casesOn val fun i j => IHxl i y + IHyl j - IHxl i (yL j)) fun val => Prod.casesOn val fun i j => IHxr i y + IHyr j - IHxr i (yR j)) fun a => Sum.casesOn a (fun val => Prod.casesOn val fun i j => IHxl i y + IHyr j - IHxl i (yR j)) fun val => Prod.casesOn val fun i j => IHxr i y + IHyl j - IHxr i (yL j)) y) (xR a)) i (yL j)) (yL a)) j).negAddRelabelling (-(fun a => SetTheory.PGame.rec (motive := fun x => SetTheory.PGame → SetTheory.PGame) (fun xl xr a a_1 IHxl IHxr y => SetTheory.PGame.rec (fun yl yr yL yR IHyl IHyr => have y := SetTheory.PGame.mk yl yr yL yR; SetTheory.PGame.mk (xl × yl ⊕ xr × yr) (xl × yr ⊕ xr × yl) (fun a => Sum.casesOn a (fun val => Prod.casesOn val fun i j => IHxl i y + IHyl j - IHxl i (yL j)) fun val => Prod.casesOn val fun i j => IHxr i y + IHyr j - IHxr i (yR j)) fun a => Sum.casesOn a (fun val => Prod.casesOn val fun i j => IHxl i y + IHyr j - IHxl i (yR j)) fun val => Prod.casesOn val fun i j => IHxr i y + IHyl j - IHxr i (yL j)) y) (xR a)) i (yL j))).trans (((((fun a => SetTheory.PGame.rec (motive := fun x => SetTheory.PGame → SetTheory.PGame) (fun xl xr a a_1 IHxl IHxr y => SetTheory.PGame.rec (fun yl yr yL yR IHyl IHyr => have y := SetTheory.PGame.mk yl yr yL yR; SetTheory.PGame.mk (xl × yl ⊕ xr × yr) (xl × yr ⊕ xr × yl) (fun a => Sum.casesOn a (fun val => Prod.casesOn val fun i j => IHxl i y + IHyl j - IHxl i (yL j)) fun val => Prod.casesOn val fun i j => IHxr i y + IHyr j - IHxr i (yR j)) fun a => Sum.casesOn a (fun val => Prod.casesOn val fun i j => IHxl i y + IHyr j - IHxl i (yR j)) fun val => Prod.casesOn val fun i j => IHxr i y + IHyl j - IHxr i (yL j)) y) (xR a)) i (SetTheory.PGame.mk yl yr yL yR)).negAddRelabelling ((fun a => SetTheory.PGame.rec (fun yl yr yL yR IHyl IHyr => have y := SetTheory.PGame.mk yl yr yL yR; SetTheory.PGame.mk (xl × yl ⊕ xr × yr) (xl × yr ⊕ xr × yl) (fun a => Sum.casesOn a (fun val => Prod.casesOn val fun i j => (fun a => SetTheory.PGame.rec (motive := fun x => SetTheory.PGame → SetTheory.PGame) (fun xl xr a a_1 IHxl IHxr y => SetTheory.PGame.rec (fun yl yr yL yR IHyl IHyr => have y := SetTheory.PGame.mk yl yr yL yR; SetTheory.PGame.mk (xl × yl ⊕ xr × yr) (xl × yr ⊕ xr × yl) (fun a => Sum.casesOn a (fun val => Prod.casesOn val fun i j => IHxl i y + IHyl j - IHxl i (yL j)) fun val => Prod.casesOn val fun i j => IHxr i y + IHyr j - IHxr i (yR j)) fun a => Sum.casesOn a (fun val => Prod.casesOn val fun i j => IHxl i y + IHyr j - IHxl i (yR j)) fun val => Prod.casesOn val fun i j => IHxr i y + IHyl j - IHxr i (yL j)) y) (xL a)) i y + IHyl j - (fun a => SetTheory.PGame.rec (motive := fun x => SetTheory.PGame → SetTheory.PGame) (fun xl xr a a_1 IHxl IHxr y => SetTheory.PGame.rec (fun yl yr yL yR IHyl IHyr => have y := SetTheory.PGame.mk yl yr yL yR; SetTheory.PGame.mk (xl × yl ⊕ xr × yr) (xl × yr ⊕ xr × yl) (fun a => Sum.casesOn a (fun val => Prod.casesOn val fun i j => IHxl i y + IHyl j - IHxl i (yL j)) fun val => Prod.casesOn val fun i j => IHxr i y + IHyr j - IHxr i (yR j)) fun a => Sum.casesOn a (fun val => Prod.casesOn val fun i j => IHxl i y + IHyr j - IHxl i (yR j)) fun val => Prod.casesOn val fun i j => IHxr i y + IHyl j - IHxr i (yL j)) y) (xL a)) i (yL j)) fun val => Prod.casesOn val fun i j => (fun a => SetTheory.PGame.rec (motive := fun x => SetTheory.PGame → SetTheory.PGame) (fun xl xr a a_1 IHxl IHxr y => SetTheory.PGame.rec (fun yl yr yL yR IHyl IHyr => have y := SetTheory.PGame.mk yl yr yL yR; SetTheory.PGame.mk (xl × yl ⊕ xr × yr) (xl × yr ⊕ xr × yl) (fun a => Sum.casesOn a (fun val => Prod.casesOn val fun i j => IHxl i y + IHyl j - IHxl i (yL j)) fun val => Prod.casesOn val fun i j => IHxr i y + IHyr j - IHxr i (yR j)) fun a => Sum.casesOn a (fun val => Prod.casesOn val fun i j => IHxl i y + IHyr j - IHxl i (yR j)) fun val => Prod.casesOn val fun i j => IHxr i y + IHyl j - IHxr i (yL j)) y) (xR a)) i y + IHyr j - (fun a => SetTheory.PGame.rec (motive := fun x => SetTheory.PGame → SetTheory.PGame) (fun xl xr a a_1 IHxl IHxr y => SetTheory.PGame.rec (fun yl yr yL yR IHyl IHyr => have y := SetTheory.PGame.mk yl yr yL yR; SetTheory.PGame.mk (xl × yl ⊕ xr × yr) (xl × yr ⊕ xr × yl) (fun a => Sum.casesOn a (fun val => Prod.casesOn val fun i j => IHxl i y + IHyl j - IHxl i (yL j)) fun val => Prod.casesOn val fun i j => IHxr i y + IHyr j - IHxr i (yR j)) fun a => Sum.casesOn a (fun val => Prod.casesOn val fun i j => IHxl i y + IHyr j - IHxl i (yR j)) fun val => Prod.casesOn val fun i j => IHxr i y + IHyl j - IHxr i (yL j)) y) (xR a)) i (yR j)) fun a => Sum.casesOn a (fun val => Prod.casesOn val fun i j => (fun a => SetTheory.PGame.rec (motive := fun x => SetTheory.PGame → SetTheory.PGame) (fun xl xr a a_1 IHxl IHxr y => SetTheory.PGame.rec (fun yl yr yL yR IHyl IHyr => have y := SetTheory.PGame.mk yl yr yL yR; SetTheory.PGame.mk (xl × yl ⊕ xr × yr) (xl × yr ⊕ xr × yl) (fun a => Sum.casesOn a (fun val => Prod.casesOn val fun i j => IHxl i y + IHyl j - IHxl i (yL j)) fun val => Prod.casesOn val fun i j => IHxr i y + IHyr j - IHxr i (yR j)) fun a => Sum.casesOn a (fun val => Prod.casesOn val fun i j => IHxl i y + IHyr j - IHxl i (yR j)) fun val => Prod.casesOn val fun i j => IHxr i y + IHyl j - IHxr i (yL j)) y) (xL a)) i y + IHyr j - (fun a => SetTheory.PGame.rec (motive := fun x => SetTheory.PGame → SetTheory.PGame) (fun xl xr a a_1 IHxl IHxr y => SetTheory.PGame.rec (fun yl yr yL yR IHyl IHyr => have y := SetTheory.PGame.mk yl yr yL yR; SetTheory.PGame.mk (xl × yl ⊕ xr × yr) (xl × yr ⊕ xr × yl) (fun a => Sum.casesOn a (fun val => Prod.casesOn val fun i j => IHxl i y + IHyl j - IHxl i (yL j)) fun val => Prod.casesOn val fun i j => IHxr i y + IHyr j - IHxr i (yR j)) fun a => Sum.casesOn a (fun val => Prod.casesOn val fun i j => IHxl i y + IHyr j - IHxl i (yR j)) fun val => Prod.casesOn val fun i j => IHxr i y + IHyl j - IHxr i (yL j)) y) (xL a)) i (yR j)) fun val => Prod.casesOn val fun i j => (fun a => SetTheory.PGame.rec (motive := fun x => SetTheory.PGame → SetTheory.PGame) (fun xl xr a a_1 IHxl IHxr y => SetTheory.PGame.rec (fun yl yr yL yR IHyl IHyr => have y := SetTheory.PGame.mk yl yr yL yR; SetTheory.PGame.mk (xl × yl ⊕ xr × yr) (xl × yr ⊕ xr × yl) (fun a => Sum.casesOn a (fun val => Prod.casesOn val fun i j => IHxl i y + IHyl j - IHxl i (yL j)) fun val => Prod.casesOn val fun i j => IHxr i y + IHyr j - IHxr i (yR j)) fun a => Sum.casesOn a (fun val => Prod.casesOn val fun i j => IHxl i y + IHyr j - IHxl i (yR j)) fun val => Prod.casesOn val fun i j => IHxr i y + IHyl j - IHxr i (yL j)) y) (xR a)) i y + IHyl j - (fun a => SetTheory.PGame.rec (motive := fun x => SetTheory.PGame → SetTheory.PGame) (fun xl xr a a_1 IHxl IHxr y => SetTheory.PGame.rec (fun yl yr yL yR IHyl IHyr => have y := SetTheory.PGame.mk yl yr yL yR; SetTheory.PGame.mk (xl × yl ⊕ xr × yr) (xl × yr ⊕ xr × yl) (fun a => Sum.casesOn a (fun val => Prod.casesOn val fun i j => IHxl i y + IHyl j - IHxl i (yL j)) fun val => Prod.casesOn val fun i j => IHxr i y + IHyr j - IHxr i (yR j)) fun a => Sum.casesOn a (fun val => Prod.casesOn val fun i j => IHxl i y + IHyr j - IHxl i (yR j)) fun val => Prod.casesOn val fun i j => IHxr i y + IHyl j - IHxr i (yL j)) y) (xR a)) i (yL j)) (yL a)) j)).trans (((xR i).negMulRelabelling (SetTheory.PGame.mk yl yr yL yR)).symm.addCongr (id ((SetTheory.PGame.mk xl xr xL xR).negMulRelabelling (yL j)).symm))).subCongr ((xR i).negMulRelabelling (yL j)).symm)).symm) fun val => Prod.casesOn val fun i j => id ((((fun a => SetTheory.PGame.rec (motive := fun x => SetTheory.PGame → SetTheory.PGame) (fun xl xr a a_1 IHxl IHxr y => SetTheory.PGame.rec (fun yl yr yL yR IHyl IHyr => have y := SetTheory.PGame.mk yl yr yL yR; SetTheory.PGame.mk (xl × yl ⊕ xr × yr) (xl × yr ⊕ xr × yl) (fun a => Sum.casesOn a (fun val => Prod.casesOn val fun i j => IHxl i y + IHyl j - IHxl i (yL j)) fun val => Prod.casesOn val fun i j => IHxr i y + IHyr j - IHxr i (yR j)) fun a => Sum.casesOn a (fun val => Prod.casesOn val fun i j => IHxl i y + IHyr j - IHxl i (yR j)) fun val => Prod.casesOn val fun i j => IHxr i y + IHyl j - IHxr i (yL j)) y) (xL a)) i (SetTheory.PGame.mk yl yr yL yR) + (fun a => SetTheory.PGame.rec (fun yl yr yL yR IHyl IHyr => have y := SetTheory.PGame.mk yl yr yL yR; SetTheory.PGame.mk (xl × yl ⊕ xr × yr) (xl × yr ⊕ xr × yl) (fun a => Sum.casesOn a (fun val => Prod.casesOn val fun i j => (fun a => SetTheory.PGame.rec (motive := fun x => SetTheory.PGame → SetTheory.PGame) (fun xl xr a a_1 IHxl IHxr y => SetTheory.PGame.rec (fun yl yr yL yR IHyl IHyr => have y := SetTheory.PGame.mk yl yr yL yR; SetTheory.PGame.mk (xl × yl ⊕ xr × yr) (xl × yr ⊕ xr × yl) (fun a => Sum.casesOn a (fun val => Prod.casesOn val fun i j => IHxl i y + IHyl j - IHxl i (yL j)) fun val => Prod.casesOn val fun i j => IHxr i y + IHyr j - IHxr i (yR j)) fun a => Sum.casesOn a (fun val => Prod.casesOn val fun i j => IHxl i y + IHyr j - IHxl i (yR j)) fun val => Prod.casesOn val fun i j => IHxr i y + IHyl j - IHxr i (yL j)) y) (xL a)) i y + IHyl j - (fun a => SetTheory.PGame.rec (motive := fun x => SetTheory.PGame → SetTheory.PGame) (fun xl xr a a_1 IHxl IHxr y => SetTheory.PGame.rec (fun yl yr yL yR IHyl IHyr => have y := SetTheory.PGame.mk yl yr yL yR; SetTheory.PGame.mk (xl × yl ⊕ xr × yr) (xl × yr ⊕ xr × yl) (fun a => Sum.casesOn a (fun val => Prod.casesOn val fun i j => IHxl i y + IHyl j - IHxl i (yL j)) fun val => Prod.casesOn val fun i j => IHxr i y + IHyr j - IHxr i (yR j)) fun a => Sum.casesOn a (fun val => Prod.casesOn val fun i j => IHxl i y + IHyr j - IHxl i (yR j)) fun val => Prod.casesOn val fun i j => IHxr i y + IHyl j - IHxr i (yL j)) y) (xL a)) i (yL j)) fun val => Prod.casesOn val fun i j => (fun a => SetTheory.PGame.rec (motive := fun x => SetTheory.PGame → SetTheory.PGame) (fun xl xr a a_1 IHxl IHxr y => SetTheory.PGame.rec (fun yl yr yL yR IHyl IHyr => have y := SetTheory.PGame.mk yl yr yL yR; SetTheory.PGame.mk (xl × yl ⊕ xr × yr) (xl × yr ⊕ xr × yl) (fun a => Sum.casesOn a (fun val => Prod.casesOn val fun i j => IHxl i y + IHyl j - IHxl i (yL j)) fun val => Prod.casesOn val fun i j => IHxr i y + IHyr j - IHxr i (yR j)) fun a => Sum.casesOn a (fun val => Prod.casesOn val fun i j => IHxl i y + IHyr j - IHxl i (yR j)) fun val => Prod.casesOn val fun i j => IHxr i y + IHyl j - IHxr i (yL j)) y) (xR a)) i y + IHyr j - (fun a => SetTheory.PGame.rec (motive := fun x => SetTheory.PGame → SetTheory.PGame) (fun xl xr a a_1 IHxl IHxr y => SetTheory.PGame.rec (fun yl yr yL yR IHyl IHyr => have y := SetTheory.PGame.mk yl yr yL yR; SetTheory.PGame.mk (xl × yl ⊕ xr × yr) (xl × yr ⊕ xr × yl) (fun a => Sum.casesOn a (fun val => Prod.casesOn val fun i j => IHxl i y + IHyl j - IHxl i (yL j)) fun val => Prod.casesOn val fun i j => IHxr i y + IHyr j - IHxr i (yR j)) fun a => Sum.casesOn a (fun val => Prod.casesOn val fun i j => IHxl i y + IHyr j - IHxl i (yR j)) fun val => Prod.casesOn val fun i j => IHxr i y + IHyl j - IHxr i (yL j)) y) (xR a)) i (yR j)) fun a => Sum.casesOn a (fun val => Prod.casesOn val fun i j => (fun a => SetTheory.PGame.rec (motive := fun x => SetTheory.PGame → SetTheory.PGame) (fun xl xr a a_1 IHxl IHxr y => SetTheory.PGame.rec (fun yl yr yL yR IHyl IHyr => have y := SetTheory.PGame.mk yl yr yL yR; SetTheory.PGame.mk (xl × yl ⊕ xr × yr) (xl × yr ⊕ xr × yl) (fun a => Sum.casesOn a (fun val => Prod.casesOn val fun i j => IHxl i y + IHyl j - IHxl i (yL j)) fun val => Prod.casesOn val fun i j => IHxr i y + IHyr j - IHxr i (yR j)) fun a => Sum.casesOn a (fun val => Prod.casesOn val fun i j => IHxl i y + IHyr j - IHxl i (yR j)) fun val => Prod.casesOn val fun i j => IHxr i y + IHyl j - IHxr i (yL j)) y) (xL a)) i y + IHyr j - (fun a => SetTheory.PGame.rec (motive := fun x => SetTheory.PGame → SetTheory.PGame) (fun xl xr a a_1 IHxl IHxr y => SetTheory.PGame.rec (fun yl yr yL yR IHyl IHyr => have y := SetTheory.PGame.mk yl yr yL yR; SetTheory.PGame.mk (xl × yl ⊕ xr × yr) (xl × yr ⊕ xr × yl) (fun a => Sum.casesOn a (fun val => Prod.casesOn val fun i j => IHxl i y + IHyl j - IHxl i (yL j)) fun val => Prod.casesOn val fun i j => IHxr i y + IHyr j - IHxr i (yR j)) fun a => Sum.casesOn a (fun val => Prod.casesOn val fun i j => IHxl i y + IHyr j - IHxl i (yR j)) fun val => Prod.casesOn val fun i j => IHxr i y + IHyl j - IHxr i (yL j)) y) (xL a)) i (yR j)) fun val => Prod.casesOn val fun i j => (fun a => SetTheory.PGame.rec (motive := fun x => SetTheory.PGame → SetTheory.PGame) (fun xl xr a a_1 IHxl IHxr y => SetTheory.PGame.rec (fun yl yr yL yR IHyl IHyr => have y := SetTheory.PGame.mk yl yr yL yR; SetTheory.PGame.mk (xl × yl ⊕ xr × yr) (xl × yr ⊕ xr × yl) (fun a => Sum.casesOn a (fun val => Prod.casesOn val fun i j => IHxl i y + IHyl j - IHxl i (yL j)) fun val => Prod.casesOn val fun i j => IHxr i y + IHyr j - IHxr i (yR j)) fun a => Sum.casesOn a (fun val => Prod.casesOn val fun i j => IHxl i y + IHyr j - IHxl i (yR j)) fun val => Prod.casesOn val fun i j => IHxr i y + IHyl j - IHxr i (yL j)) y) (xR a)) i y + IHyl j - (fun a => SetTheory.PGame.rec (motive := fun x => SetTheory.PGame → SetTheory.PGame) (fun xl xr a a_1 IHxl IHxr y => SetTheory.PGame.rec (fun yl yr yL yR IHyl IHyr => have y := SetTheory.PGame.mk yl yr yL yR; SetTheory.PGame.mk (xl × yl ⊕ xr × yr) (xl × yr ⊕ xr × yl) (fun a => Sum.casesOn a (fun val => Prod.casesOn val fun i j => IHxl i y + IHyl j - IHxl i (yL j)) fun val => Prod.casesOn val fun i j => IHxr i y + IHyr j - IHxr i (yR j)) fun a => Sum.casesOn a (fun val => Prod.casesOn val fun i j => IHxl i y + IHyr j - IHxl i (yR j)) fun val => Prod.casesOn val fun i j => IHxr i y + IHyl j - IHxr i (yL j)) y) (xR a)) i (yL j)) (yR a)) j).negAddRelabelling (-(fun a => SetTheory.PGame.rec (motive := fun x => SetTheory.PGame → SetTheory.PGame) (fun xl xr a a_1 IHxl IHxr y => SetTheory.PGame.rec (fun yl yr yL yR IHyl IHyr => have y := SetTheory.PGame.mk yl yr yL yR; SetTheory.PGame.mk (xl × yl ⊕ xr × yr) (xl × yr ⊕ xr × yl) (fun a => Sum.casesOn a (fun val => Prod.casesOn val fun i j => IHxl i y + IHyl j - IHxl i (yL j)) fun val => Prod.casesOn val fun i j => IHxr i y + IHyr j - IHxr i (yR j)) fun a => Sum.casesOn a (fun val => Prod.casesOn val fun i j => IHxl i y + IHyr j - IHxl i (yR j)) fun val => Prod.casesOn val fun i j => IHxr i y + IHyl j - IHxr i (yL j)) y) (xL a)) i (yR j))).trans (((((fun a => SetTheory.PGame.rec (motive := fun x => SetTheory.PGame → SetTheory.PGame) (fun xl xr a a_1 IHxl IHxr y => SetTheory.PGame.rec (fun yl yr yL yR IHyl IHyr => have y := SetTheory.PGame.mk yl yr yL yR; SetTheory.PGame.mk (xl × yl ⊕ xr × yr) (xl × yr ⊕ xr × yl) (fun a => Sum.casesOn a (fun val => Prod.casesOn val fun i j => IHxl i y + IHyl j - IHxl i (yL j)) fun val => Prod.casesOn val fun i j => IHxr i y + IHyr j - IHxr i (yR j)) fun a => Sum.casesOn a (fun val => Prod.casesOn val fun i j => IHxl i y + IHyr j - IHxl i (yR j)) fun val => Prod.casesOn val fun i j => IHxr i y + IHyl j - IHxr i (yL j)) y) (xL a)) i (SetTheory.PGame.mk yl yr yL yR)).negAddRelabelling ((fun a => SetTheory.PGame.rec (fun yl yr yL yR IHyl IHyr => have y := SetTheory.PGame.mk yl yr yL yR; SetTheory.PGame.mk (xl × yl ⊕ xr × yr) (xl × yr ⊕ xr × yl) (fun a => Sum.casesOn a (fun val => Prod.casesOn val fun i j => (fun a => SetTheory.PGame.rec (motive := fun x => SetTheory.PGame → SetTheory.PGame) (fun xl xr a a_1 IHxl IHxr y => SetTheory.PGame.rec (fun yl yr yL yR IHyl IHyr => have y := SetTheory.PGame.mk yl yr yL yR; SetTheory.PGame.mk (xl × yl ⊕ xr × yr) (xl × yr ⊕ xr × yl) (fun a => Sum.casesOn a (fun val => Prod.casesOn val fun i j => IHxl i y + IHyl j - IHxl i (yL j)) fun val => Prod.casesOn val fun i j => IHxr i y + IHyr j - IHxr i (yR j)) fun a => Sum.casesOn a (fun val => Prod.casesOn val fun i j => IHxl i y + IHyr j - IHxl i (yR j)) fun val => Prod.casesOn val fun i j => IHxr i y + IHyl j - IHxr i (yL j)) y) (xL a)) i y + IHyl j - (fun a => SetTheory.PGame.rec (motive := fun x => SetTheory.PGame → SetTheory.PGame) (fun xl xr a a_1 IHxl IHxr y => SetTheory.PGame.rec (fun yl yr yL yR IHyl IHyr => have y := SetTheory.PGame.mk yl yr yL yR; SetTheory.PGame.mk (xl × yl ⊕ xr × yr) (xl × yr ⊕ xr × yl) (fun a => Sum.casesOn a (fun val => Prod.casesOn val fun i j => IHxl i y + IHyl j - IHxl i (yL j)) fun val => Prod.casesOn val fun i j => IHxr i y + IHyr j - IHxr i (yR j)) fun a => Sum.casesOn a (fun val => Prod.casesOn val fun i j => IHxl i y + IHyr j - IHxl i (yR j)) fun val => Prod.casesOn val fun i j => IHxr i y + IHyl j - IHxr i (yL j)) y) (xL a)) i (yL j)) fun val => Prod.casesOn val fun i j => (fun a => SetTheory.PGame.rec (motive := fun x => SetTheory.PGame → SetTheory.PGame) (fun xl xr a a_1 IHxl IHxr y => SetTheory.PGame.rec (fun yl yr yL yR IHyl IHyr => have y := SetTheory.PGame.mk yl yr yL yR; SetTheory.PGame.mk (xl × yl ⊕ xr × yr) (xl × yr ⊕ xr × yl) (fun a => Sum.casesOn a (fun val => Prod.casesOn val fun i j => IHxl i y + IHyl j - IHxl i (yL j)) fun val => Prod.casesOn val fun i j => IHxr i y + IHyr j - IHxr i (yR j)) fun a => Sum.casesOn a (fun val => Prod.casesOn val fun i j => IHxl i y + IHyr j - IHxl i (yR j)) fun val => Prod.casesOn val fun i j => IHxr i y + IHyl j - IHxr i (yL j)) y) (xR a)) i y + IHyr j - (fun a => SetTheory.PGame.rec (motive := fun x => SetTheory.PGame → SetTheory.PGame) (fun xl xr a a_1 IHxl IHxr y => SetTheory.PGame.rec (fun yl yr yL yR IHyl IHyr => have y := SetTheory.PGame.mk yl yr yL yR; SetTheory.PGame.mk (xl × yl ⊕ xr × yr) (xl × yr ⊕ xr × yl) (fun a => Sum.casesOn a (fun val => Prod.casesOn val fun i j => IHxl i y + IHyl j - IHxl i (yL j)) fun val => Prod.casesOn val fun i j => IHxr i y + IHyr j - IHxr i (yR j)) fun a => Sum.casesOn a (fun val => Prod.casesOn val fun i j => IHxl i y + IHyr j - IHxl i (yR j)) fun val => Prod.casesOn val fun i j => IHxr i y + IHyl j - IHxr i (yL j)) y) (xR a)) i (yR j)) fun a => Sum.casesOn a (fun val => Prod.casesOn val fun i j => (fun a => SetTheory.PGame.rec (motive := fun x => SetTheory.PGame → SetTheory.PGame) (fun xl xr a a_1 IHxl IHxr y => SetTheory.PGame.rec (fun yl yr yL yR IHyl IHyr => have y := SetTheory.PGame.mk yl yr yL yR; SetTheory.PGame.mk (xl × yl ⊕ xr × yr) (xl × yr ⊕ xr × yl) (fun a => Sum.casesOn a (fun val => Prod.casesOn val fun i j => IHxl i y + IHyl j - IHxl i (yL j)) fun val => Prod.casesOn val fun i j => IHxr i y + IHyr j - IHxr i (yR j)) fun a => Sum.casesOn a (fun val => Prod.casesOn val fun i j => IHxl i y + IHyr j - IHxl i (yR j)) fun val => Prod.casesOn val fun i j => IHxr i y + IHyl j - IHxr i (yL j)) y) (xL a)) i y + IHyr j - (fun a => SetTheory.PGame.rec (motive := fun x => SetTheory.PGame → SetTheory.PGame) (fun xl xr a a_1 IHxl IHxr y => SetTheory.PGame.rec (fun yl yr yL yR IHyl IHyr => have y := SetTheory.PGame.mk yl yr yL yR; SetTheory.PGame.mk (xl × yl ⊕ xr × yr) (xl × yr ⊕ xr × yl) (fun a => Sum.casesOn a (fun val => Prod.casesOn val fun i j => IHxl i y + IHyl j - IHxl i (yL j)) fun val => Prod.casesOn val fun i j => IHxr i y + IHyr j - IHxr i (yR j)) fun a => Sum.casesOn a (fun val => Prod.casesOn val fun i j => IHxl i y + IHyr j - IHxl i (yR j)) fun val => Prod.casesOn val fun i j => IHxr i y + IHyl j - IHxr i (yL j)) y) (xL a)) i (yR j)) fun val => Prod.casesOn val fun i j => (fun a => SetTheory.PGame.rec (motive := fun x => SetTheory.PGame → SetTheory.PGame) (fun xl xr a a_1 IHxl IHxr y => SetTheory.PGame.rec (fun yl yr yL yR IHyl IHyr => have y := SetTheory.PGame.mk yl yr yL yR; SetTheory.PGame.mk (xl × yl ⊕ xr × yr) (xl × yr ⊕ xr × yl) (fun a => Sum.casesOn a (fun val => Prod.casesOn val fun i j => IHxl i y + IHyl j - IHxl i (yL j)) fun val => Prod.casesOn val fun i j => IHxr i y + IHyr j - IHxr i (yR j)) fun a => Sum.casesOn a (fun val => Prod.casesOn val fun i j => IHxl i y + IHyr j - IHxl i (yR j)) fun val => Prod.casesOn val fun i j => IHxr i y + IHyl j - IHxr i (yL j)) y) (xR a)) i y + IHyl j - (fun a => SetTheory.PGame.rec (motive := fun x => SetTheory.PGame → SetTheory.PGame) (fun xl xr a a_1 IHxl IHxr y => SetTheory.PGame.rec (fun yl yr yL yR IHyl IHyr => have y := SetTheory.PGame.mk yl yr yL yR; SetTheory.PGame.mk (xl × yl ⊕ xr × yr) (xl × yr ⊕ xr × yl) (fun a => Sum.casesOn a (fun val => Prod.casesOn val fun i j => IHxl i y + IHyl j - IHxl i (yL j)) fun val => Prod.casesOn val fun i j => IHxr i y + IHyr j - IHxr i (yR j)) fun a => Sum.casesOn a (fun val => Prod.casesOn val fun i j => IHxl i y + IHyr j - IHxl i (yR j)) fun val => Prod.casesOn val fun i j => IHxr i y + IHyl j - IHxr i (yL j)) y) (xR a)) i (yL j)) (yR a)) j)).trans (((xL i).negMulRelabelling (SetTheory.PGame.mk yl yr yL yR)).symm.addCongr (id ((SetTheory.PGame.mk xl xr xL xR).negMulRelabelling (yR j)).symm))).subCongr ((xL i).negMulRelabelling (yR j)).symm)).symm) fun j => Sum.casesOn j (fun val => Prod.casesOn val fun i j => id ((((fun a => SetTheory.PGame.rec (motive := fun x => SetTheory.PGame → SetTheory.PGame) ⋯ ⋯) ⋯ ⋯ + ⋯).negAddRelabelling ⋯).trans ⋯).symm) ⋯
About
Loogle searches Lean and Mathlib definitions and theorems.
You can use Loogle from within the Lean4 VSCode language extension
using (by default) Ctrl-K Ctrl-S. You can also try the
#loogle command from LeanSearchClient,
the CLI version, the Loogle
VS Code extension, the lean.nvim
integration or the Zulip bot.
Usage
Loogle finds definitions and lemmas in various ways:
By constant:
🔍Real.sin
finds all lemmas whose statement somehow mentions the sine function.By lemma name substring:
🔍"differ"
finds all lemmas that have"differ"somewhere in their lemma name.By subexpression:
🔍_ * (_ ^ _)
finds all lemmas whose statements somewhere include a product where the second argument is raised to some power.The pattern can also be non-linear, as in
🔍Real.sqrt ?a * Real.sqrt ?aIf the pattern has parameters, they are matched in any order. Both of these will find
List.map:
🔍(?a -> ?b) -> List ?a -> List ?b
🔍List ?a -> (?a -> ?b) -> List ?bBy main conclusion:
🔍|- tsum _ = _ * tsum _
finds all lemmas where the conclusion (the subexpression to the right of all→and∀) has the given shape.As before, if the pattern has parameters, they are matched against the hypotheses of the lemma in any order; for example,
🔍|- _ < _ → tsum _ < tsum _
will findtsum_lt_tsumeven though the hypothesisf i < g iis not the last.
If you pass more than one such search filter, separated by commas
Loogle will return lemmas which match all of them. The
search
🔍 Real.sin, "two", tsum, _ * _, _ ^ _, |- _ < _ → _
would find all lemmas which mention the constants Real.sin
and tsum, have "two" as a substring of the
lemma name, include a product and a power somewhere in the type,
and have a hypothesis of the form _ < _ (if
there were any such lemmas). Metavariables (?a) are
assigned independently in each filter.
The #lucky button will directly send you to the
documentation of the first hit.
Source code
You can find the source code for this service at https://github.com/nomeata/loogle. The https://loogle.lean-lang.org/ service is provided by the Lean FRO.
This is Loogle revision 36960b0 serving mathlib revision 9a4cf1d