Loogle!
Result
Found 75 declarations mentioning Sum, Equiv and Prod.
- Equiv.boolProdEquivSum 📋 Mathlib.Logic.Equiv.Prod
(α : Type u_9) : Bool × α ≃ α ⊕ α - 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✝ - Equiv.boolProdEquivSum_apply 📋 Mathlib.Logic.Equiv.Prod
(α : Type u_9) (p : Bool × α) : (Equiv.boolProdEquivSum α) p = Bool.casesOn p.1 (Sum.inl p.2) (Sum.inr 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) - 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 - 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.piCongrLeft_sum_inl 📋 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_sum_inr 📋 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_6) (β : Type u_7) (a : Equiv.Perm α × Equiv.Perm β) : (Equiv.Perm.sumCongrHom α β) a = a.1.sumCongr a.2 - 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_13} {β : Type u_14} {γ : Type u_15} [Zero γ] : (α ⊕ β →₀ γ) ≃ (α →₀ γ) × (β →₀ γ) - Finsupp.fst_sumFinsuppEquivProdFinsupp 📋 Mathlib.Data.Finsupp.Basic
{α : Type u_13} {β : Type u_14} {γ : Type u_15} [Zero γ] (f : α ⊕ β →₀ γ) (x : α) : (Finsupp.sumFinsuppEquivProdFinsupp f).1 x = f (Sum.inl x) - Finsupp.snd_sumFinsuppEquivProdFinsupp 📋 Mathlib.Data.Finsupp.Basic
{α : Type u_13} {β : Type u_14} {γ : Type u_15} [Zero γ] (f : α ⊕ β →₀ γ) (y : β) : (Finsupp.sumFinsuppEquivProdFinsupp f).2 y = f (Sum.inr y) - Finsupp.sumFinsuppEquivProdFinsupp_apply 📋 Mathlib.Data.Finsupp.Basic
{α : Type u_13} {β : Type u_14} {γ : Type u_15} [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_13} {β : Type u_14} {γ : Type u_15} [Zero γ] (fg : (α →₀ γ) × (β →₀ γ)) : Finsupp.sumFinsuppEquivProdFinsupp.symm fg = fg.1.sumElim fg.2 - Finsupp.sumFinsuppEquivProdFinsupp_symm_inl 📋 Mathlib.Data.Finsupp.Basic
{α : Type u_13} {β : Type u_14} {γ : Type u_15} [Zero γ] (fg : (α →₀ γ) × (β →₀ γ)) (x : α) : (Finsupp.sumFinsuppEquivProdFinsupp.symm fg) (Sum.inl x) = fg.1 x - Finsupp.sumFinsuppEquivProdFinsupp_symm_inr 📋 Mathlib.Data.Finsupp.Basic
{α : Type u_13} {β : Type u_14} {γ : Type u_15} [Zero γ] (fg : (α →₀ γ) × (β →₀ γ)) (y : β) : (Finsupp.sumFinsuppEquivProdFinsupp.symm fg) (Sum.inr y) = fg.2 y - 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✝ - Equiv.sumArrowEquivProdArrow.eq_1 📋 Mathlib.Topology.Homeomorph.Lemmas
(α : Type u_9) (β : Type u_10) (γ : Type u_11) : Equiv.sumArrowEquivProdArrow α β γ = { toFun := fun f => (f ∘ Sum.inl, f ∘ Sum.inr), invFun := fun p => Sum.elim p.1 p.2, left_inv := ⋯, right_inv := ⋯ } - 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.Generators
{α : Type u_13} {β : Type u_14} {γ : Type u_15} [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) } - PiLp.sumPiLpEquivProdLpPiLp_apply 📋 Mathlib.Analysis.Normed.Lp.PiLp
{𝕜 : Type u_1} [Semiring 𝕜] {ι : Type u_5} {κ : Type u_6} (p : ENNReal) (α : ι ⊕ κ → Type u_7) [Fintype ι] [Fintype κ] [Fact (1 ≤ p)] [(i : ι ⊕ κ) → SeminormedAddCommGroup (α i)] [(i : ι ⊕ κ) → Module 𝕜 (α i)] (a✝ : WithLp p ((i : ι ⊕ κ) → α i)) : (PiLp.sumPiLpEquivProdLpPiLp p α) a✝ = (WithLp.equiv p (WithLp p ((s : ι) → α (Sum.inl s)) × WithLp p ((t : κ) → α (Sum.inr t)))).symm ((WithLp.equiv p ((s : ι) → α (Sum.inl s))).symm fun i => a✝ (Sum.inl i), (WithLp.equiv p ((t : κ) → α (Sum.inr t))).symm fun i' => a✝ (Sum.inr i')) - PiLp.sumPiLpEquivProdLpPiLp_symm_apply 📋 Mathlib.Analysis.Normed.Lp.PiLp
{𝕜 : Type u_1} [Semiring 𝕜] {ι : Type u_5} {κ : Type u_6} (p : ENNReal) (α : ι ⊕ κ → Type u_7) [Fintype ι] [Fintype κ] [Fact (1 ≤ p)] [(i : ι ⊕ κ) → SeminormedAddCommGroup (α i)] [(i : ι ⊕ κ) → Module 𝕜 (α i)] (a✝ : WithLp p (WithLp p ((i : ι) → α (Sum.inl i)) × WithLp p ((i : κ) → α (Sum.inr i)))) : (PiLp.sumPiLpEquivProdLpPiLp p α).symm a✝ = (WithLp.equiv p ((i : ι ⊕ κ) → α i)).symm ((Equiv.sumPiEquivProdPi α).symm (((WithLp.linearEquiv p 𝕜 ((s : ι) → α (Sum.inl s))).symm.prodCongr (WithLp.linearEquiv p 𝕜 ((t : κ) → α (Sum.inr t))).symm).symm ((WithLp.equiv p (WithLp p ((s : ι) → α (Sum.inl s)) × WithLp p ((t : κ) → α (Sum.inr t)))) a✝))) - AlgebraicGeometry.coprodSpec_coprodMk 📋 Mathlib.AlgebraicGeometry.Limits
(R S : Type u) [CommRing R] [CommRing S] (x : ↑↑(AlgebraicGeometry.Spec (CommRingCat.of R)).toPresheafedSpace ⊕ ↑↑(AlgebraicGeometry.Spec (CommRingCat.of S)).toPresheafedSpace) : (CategoryTheory.ConcreteCategory.hom (AlgebraicGeometry.coprodSpec R S).base) ((AlgebraicGeometry.coprodMk (AlgebraicGeometry.Spec (CommRingCat.of R)) (AlgebraicGeometry.Spec (CommRingCat.of S))) x) = (PrimeSpectrum.primeSpectrumProd R S).symm x - AlgebraicGeometry.coprodSpec_apply 📋 Mathlib.AlgebraicGeometry.Limits
(R S : Type u) [CommRing R] [CommRing S] (x : ↑↑(AlgebraicGeometry.Spec (CommRingCat.of R) ⨿ AlgebraicGeometry.Spec (CommRingCat.of S)).toPresheafedSpace) : (CategoryTheory.ConcreteCategory.hom (AlgebraicGeometry.coprodSpec R S).base) x = (PrimeSpectrum.primeSpectrumProd R S).symm ((AlgebraicGeometry.coprodMk (AlgebraicGeometry.Spec (CommRingCat.of R)) (AlgebraicGeometry.Spec (CommRingCat.of S))).symm x) - SimpleGraph.Coloring.sumEquiv 📋 Mathlib.Combinatorics.SimpleGraph.Sum
{α : Type u_1} {β : Type u_2} {γ : Type u_3} {G : SimpleGraph α} {H : SimpleGraph β} : (G ⊕g H).Coloring γ ≃ G.Coloring γ × H.Coloring γ - 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 : ι) × { x // x ∈ 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 : ι) × { x // x ∈ 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 : ι) × { x // x ∈ 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 => let_fun 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 : ι) × { x // x ∈ 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 📋 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_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), ⋯⟩ - 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), ⋯⟩ - 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 - 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 IHxl IHxr y => SetTheory.PGame.rec (fun yl yr yL yR IHyl IHyr => let_fun 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 => let_fun 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 IHxl IHxr y => SetTheory.PGame.rec (fun yl yr yL yR IHyl IHyr => let_fun y := SetTheory.PGame.mk yl yr yL yR; ⋯) y) (xL a)) i y + IHyl j - (fun a => SetTheory.PGame.rec (motive := fun x => SetTheory.PGame → SetTheory.PGame) (fun xl xr a a IHxl IHxr y => SetTheory.PGame.rec (fun yl yr yL yR IHyl IHyr => let_fun y := SetTheory.PGame.mk yl yr yL yR; SetTheory.PGame.mk (xl × yl ⊕ xr × yr) (xl × yr ⊕ xr × yl) ⋯ ⋯) 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 IHxl IHxr y => SetTheory.PGame.rec (fun yl yr yL yR IHyl IHyr => let_fun y := SetTheory.PGame.mk yl yr yL yR; ⋯) y) (xR a)) i y + IHyr j - (fun a => SetTheory.PGame.rec (motive := fun x => SetTheory.PGame → SetTheory.PGame) (fun xl xr a a IHxl IHxr y => SetTheory.PGame.rec (fun yl yr yL yR IHyl IHyr => let_fun y := SetTheory.PGame.mk yl yr yL yR; SetTheory.PGame.mk (xl × yl ⊕ xr × yr) (xl × yr ⊕ xr × yl) ⋯ ⋯) 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 IHxl IHxr y => SetTheory.PGame.rec (fun yl yr yL yR IHyl IHyr => let_fun y := SetTheory.PGame.mk yl yr yL yR; ⋯) y) (xL a)) i y + IHyr j - (fun a => SetTheory.PGame.rec (motive := fun x => SetTheory.PGame → SetTheory.PGame) (fun xl xr a a IHxl IHxr y => SetTheory.PGame.rec (fun yl yr yL yR IHyl IHyr => let_fun y := SetTheory.PGame.mk yl yr yL yR; SetTheory.PGame.mk (xl × yl ⊕ xr × yr) (xl × yr ⊕ xr × yl) ⋯ ⋯) 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 IHxl IHxr y => SetTheory.PGame.rec (fun yl yr yL yR IHyl IHyr => let_fun y := SetTheory.PGame.mk yl yr yL yR; ⋯) y) (xR a)) i y + IHyl j - (fun a => SetTheory.PGame.rec (motive := fun x => SetTheory.PGame → SetTheory.PGame) (fun xl xr a a IHxl IHxr y => SetTheory.PGame.rec (fun yl yr yL yR IHyl IHyr => let_fun y := SetTheory.PGame.mk yl yr yL yR; SetTheory.PGame.mk (xl × yl ⊕ xr × yr) (xl × yr ⊕ xr × yl) ⋯ ⋯) 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 IHxl IHxr y => SetTheory.PGame.rec (fun yl yr yL yR IHyl IHyr => let_fun 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 IHxl IHxr y => SetTheory.PGame.rec (fun yl yr yL yR IHyl IHyr => let_fun 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 => let_fun 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 IHxl IHxr y => SetTheory.PGame.rec (fun yl yr yL yR IHyl IHyr => ⋯) y) (xL a)) i y + IHyl j - (fun a => SetTheory.PGame.rec (motive := fun x => SetTheory.PGame → SetTheory.PGame) (fun xl xr a a IHxl IHxr y => SetTheory.PGame.rec (fun yl yr yL yR IHyl IHyr => let_fun y := SetTheory.PGame.mk yl yr yL yR; ⋯) 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 IHxl IHxr y => SetTheory.PGame.rec (fun yl yr yL yR IHyl IHyr => ⋯) y) (xR a)) i y + IHyr j - (fun a => SetTheory.PGame.rec (motive := fun x => SetTheory.PGame → SetTheory.PGame) (fun xl xr a a IHxl IHxr y => SetTheory.PGame.rec (fun yl yr yL yR IHyl IHyr => let_fun y := SetTheory.PGame.mk yl yr yL yR; ⋯) 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 IHxl IHxr y => SetTheory.PGame.rec (fun yl yr yL yR IHyl IHyr => ⋯) y) (xL a)) i y + IHyr j - (fun a => SetTheory.PGame.rec (motive := fun x => SetTheory.PGame → SetTheory.PGame) (fun xl xr a a IHxl IHxr y => SetTheory.PGame.rec (fun yl yr yL yR IHyl IHyr => let_fun y := SetTheory.PGame.mk yl yr yL yR; ⋯) 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 IHxl IHxr y => SetTheory.PGame.rec (fun yl yr yL yR IHyl IHyr => ⋯) y) (xR a)) i y + IHyl j - (fun a => SetTheory.PGame.rec (motive := fun x => SetTheory.PGame → SetTheory.PGame) (fun xl xr a a IHxl IHxr y => SetTheory.PGame.rec (fun yl yr yL yR IHyl IHyr => let_fun y := SetTheory.PGame.mk yl yr yL yR; ⋯) 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 IHxl IHxr y => SetTheory.PGame.rec (fun yl yr yL yR IHyl IHyr => let_fun 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 => let_fun 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 IHxl IHxr y => SetTheory.PGame.rec (fun yl yr yL yR IHyl IHyr => let_fun y := SetTheory.PGame.mk yl yr yL yR; ⋯) y) (xL a)) i y + IHyl j - (fun a => SetTheory.PGame.rec (motive := fun x => SetTheory.PGame → SetTheory.PGame) (fun xl xr a a IHxl IHxr y => SetTheory.PGame.rec (fun yl yr yL yR IHyl IHyr => let_fun y := SetTheory.PGame.mk yl yr yL yR; SetTheory.PGame.mk (xl × yl ⊕ xr × yr) (xl × yr ⊕ xr × yl) ⋯ ⋯) 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 IHxl IHxr y => SetTheory.PGame.rec (fun yl yr yL yR IHyl IHyr => let_fun y := SetTheory.PGame.mk yl yr yL yR; ⋯) y) (xR a)) i y + IHyr j - (fun a => SetTheory.PGame.rec (motive := fun x => SetTheory.PGame → SetTheory.PGame) (fun xl xr a a IHxl IHxr y => SetTheory.PGame.rec (fun yl yr yL yR IHyl IHyr => let_fun y := SetTheory.PGame.mk yl yr yL yR; SetTheory.PGame.mk (xl × yl ⊕ xr × yr) (xl × yr ⊕ xr × yl) ⋯ ⋯) 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 IHxl IHxr y => SetTheory.PGame.rec (fun yl yr yL yR IHyl IHyr => let_fun y := SetTheory.PGame.mk yl yr yL yR; ⋯) y) (xL a)) i y + IHyr j - (fun a => SetTheory.PGame.rec (motive := fun x => SetTheory.PGame → SetTheory.PGame) (fun xl xr a a IHxl IHxr y => SetTheory.PGame.rec (fun yl yr yL yR IHyl IHyr => let_fun y := SetTheory.PGame.mk yl yr yL yR; SetTheory.PGame.mk (xl × yl ⊕ xr × yr) (xl × yr ⊕ xr × yl) ⋯ ⋯) 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 IHxl IHxr y => SetTheory.PGame.rec (fun yl yr yL yR IHyl IHyr => let_fun y := SetTheory.PGame.mk yl yr yL yR; ⋯) y) (xR a)) i y + IHyl j - (fun a => SetTheory.PGame.rec (motive := fun x => SetTheory.PGame → SetTheory.PGame) (fun xl xr a a IHxl IHxr y => SetTheory.PGame.rec (fun yl yr yL yR IHyl IHyr => let_fun y := SetTheory.PGame.mk yl yr yL yR; SetTheory.PGame.mk (xl × yl ⊕ xr × yr) (xl × yr ⊕ xr × yl) ⋯ ⋯) 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 IHxl IHxr y => SetTheory.PGame.rec (fun yl yr yL yR IHyl IHyr => let_fun 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 IHxl IHxr y => SetTheory.PGame.rec (fun yl yr yL yR IHyl IHyr => let_fun 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 => let_fun 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 IHxl IHxr y => SetTheory.PGame.rec (fun yl yr yL yR IHyl IHyr => ⋯) y) (xL a)) i y + IHyl j - (fun a => SetTheory.PGame.rec (motive := fun x => SetTheory.PGame → SetTheory.PGame) (fun xl xr a a IHxl IHxr y => SetTheory.PGame.rec (fun yl yr yL yR IHyl IHyr => let_fun y := SetTheory.PGame.mk yl yr yL yR; ⋯) 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 IHxl IHxr y => SetTheory.PGame.rec (fun yl yr yL yR IHyl IHyr => ⋯) y) (xR a)) i y + IHyr j - (fun a => SetTheory.PGame.rec (motive := fun x => SetTheory.PGame → SetTheory.PGame) (fun xl xr a a IHxl IHxr y => SetTheory.PGame.rec (fun yl yr yL yR IHyl IHyr => let_fun y := SetTheory.PGame.mk yl yr yL yR; ⋯) 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 IHxl IHxr y => SetTheory.PGame.rec (fun yl yr yL yR IHyl IHyr => ⋯) y) (xL a)) i y + IHyr j - (fun a => SetTheory.PGame.rec (motive := fun x => SetTheory.PGame → SetTheory.PGame) (fun xl xr a a IHxl IHxr y => SetTheory.PGame.rec (fun yl yr yL yR IHyl IHyr => let_fun y := SetTheory.PGame.mk yl yr yL yR; ⋯) 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 IHxl IHxr y => SetTheory.PGame.rec (fun yl yr yL yR IHyl IHyr => ⋯) y) (xR a)) i y + IHyl j - (fun a => SetTheory.PGame.rec (motive := fun x => SetTheory.PGame → SetTheory.PGame) (fun xl xr a a IHxl IHxr y => SetTheory.PGame.rec (fun yl yr yL yR IHyl IHyr => let_fun y := SetTheory.PGame.mk yl yr yL yR; ⋯) 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) (fun xl xr a a IHxl IHxr y => SetTheory.PGame.rec (fun yl yr yL yR IHyl IHyr => let_fun 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 => let_fun 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 IHxl IHxr y => SetTheory.PGame.rec (fun yl yr yL yR IHyl IHyr => let_fun y := SetTheory.PGame.mk yl yr yL yR; ⋯) y) (xL a)) i y + IHyl j - (fun a => SetTheory.PGame.rec (motive := fun x => SetTheory.PGame → SetTheory.PGame) (fun xl xr a a IHxl IHxr y => SetTheory.PGame.rec (fun yl yr yL yR IHyl IHyr => let_fun y := SetTheory.PGame.mk yl yr yL yR; SetTheory.PGame.mk (xl × yl ⊕ xr × yr) (xl × yr ⊕ xr × yl) ⋯ ⋯) 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 IHxl IHxr y => SetTheory.PGame.rec (fun yl yr yL yR IHyl IHyr => let_fun y := SetTheory.PGame.mk yl yr yL yR; ⋯) y) (xR a)) i y + IHyr j - (fun a => SetTheory.PGame.rec (motive := fun x => SetTheory.PGame → SetTheory.PGame) (fun xl xr a a IHxl IHxr y => SetTheory.PGame.rec (fun yl yr yL yR IHyl IHyr => let_fun y := SetTheory.PGame.mk yl yr yL yR; SetTheory.PGame.mk (xl × yl ⊕ xr × yr) (xl × yr ⊕ xr × yl) ⋯ ⋯) 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 IHxl IHxr y => SetTheory.PGame.rec (fun yl yr yL yR IHyl IHyr => let_fun y := SetTheory.PGame.mk yl yr yL yR; ⋯) y) (xL a)) i y + IHyr j - (fun a => SetTheory.PGame.rec (motive := fun x => SetTheory.PGame → SetTheory.PGame) (fun xl xr a a IHxl IHxr y => SetTheory.PGame.rec (fun yl yr yL yR IHyl IHyr => let_fun y := SetTheory.PGame.mk yl yr yL yR; SetTheory.PGame.mk (xl × yl ⊕ xr × yr) (xl × yr ⊕ xr × yl) ⋯ ⋯) y) (xL a)) i (yR j)) fun val => Prod.casesOn ⋯ ⋯) ⋯) ⋯).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 ?a
If 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 ?b
By 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_tsum
even though the hypothesisf i < g i
is 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 19971e9
serving mathlib revision bce1d65