name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M |
|---|---|---|
_private.Mathlib.CategoryTheory.Triangulated.TStructure.TruncLEGT.0.CategoryTheory.Triangulated.TStructure.isLE_truncLE_obj._proof_1_1 | Mathlib.CategoryTheory.Triangulated.TStructure.TruncLEGT | ∀ (a b : ℤ), a ≤ b → a + 1 ≤ b + 1 |
Set.self_mem_Iic | Mathlib.Order.Interval.Set.Basic | ∀ {α : Type u_1} [inst : Preorder α] {a : α}, a ∈ Set.Iic a |
Submonoid.center.commMonoid'.eq_1 | Mathlib.GroupTheory.Submonoid.Center | ∀ {M : Type u_1} [inst : MulOneClass M],
Submonoid.center.commMonoid' =
{ toMul := (Submonoid.center M).toMulOneClass.toMul, mul_assoc := ⋯,
toOne := (Submonoid.center M).toMulOneClass.toOne, one_mul := ⋯, mul_one := ⋯, npow := npowRecAuto,
npow_zero := ⋯, npow_succ := ⋯, mul_comm := ⋯ } |
SimpleGraph.IsFiveWheelLike.card_right | Mathlib.Combinatorics.SimpleGraph.FiveWheelLike | ∀ {α : Type u_1} {s : Finset α} {G : SimpleGraph α} {r k : ℕ} [inst : DecidableEq α] {v w₁ w₂ : α} {t : Finset α},
G.IsFiveWheelLike r k v w₁ w₂ s t → t.card = r |
Lean.Elab.Term.instToStringArg.match_1 | Lean.Elab.App | (motive : Lean.Elab.Term.Arg → Sort u_1) →
(x : Lean.Elab.Term.Arg) →
((val : Lean.Syntax) → motive (Lean.Elab.Term.Arg.stx val)) →
((val : Lean.Expr) → motive (Lean.Elab.Term.Arg.expr val)) → motive x |
_private.Mathlib.GroupTheory.FreeGroup.Orbit.0.FreeGroup.startsWith_mk_mul._proof_1_10 | Mathlib.GroupTheory.FreeGroup.Orbit | ∀ {α : Type u_1} [inst : DecidableEq α] (g : FreeGroup α), 2 ≤ g.toWord.length → 1 < g.toWord.length |
_private.Mathlib.Tactic.Explode.Pretty.0.Mathlib.Explode.rowToMessageData.match_1 | Mathlib.Tactic.Explode.Pretty | (motive : Mathlib.Explode.Status → Sort u_1) →
(x : Mathlib.Explode.Status) →
(Unit → motive Mathlib.Explode.Status.sintro) →
(Unit → motive Mathlib.Explode.Status.intro) →
(Unit → motive Mathlib.Explode.Status.cintro) →
(Unit → motive Mathlib.Explode.Status.lam) → (Unit → motive Mathlib.Explode.Status.reg) → motive x |
AlgebraicGeometry.Scheme.Cover.fromGlued_isOpenEmbedding | Mathlib.AlgebraicGeometry.Gluing | ∀ {X : AlgebraicGeometry.Scheme} (𝒰 : X.OpenCover),
Topology.IsOpenEmbedding ⇑(AlgebraicGeometry.Scheme.Cover.fromGlued 𝒰) |
WithBot.ofDual_le_iff | Mathlib.Order.WithBot | ∀ {α : Type u_1} [inst : LE α] {x : WithBot αᵒᵈ} {y : WithTop α}, WithBot.ofDual x ≤ y ↔ WithTop.toDual y ≤ x |
AlgebraicGeometry.Scheme.instIsOpenImmersionMapOfHomAwayAlgebraMap | Mathlib.AlgebraicGeometry.OpenImmersion | ∀ {R : Type u_1} [inst : CommRing R] (f : R),
AlgebraicGeometry.IsOpenImmersion
(AlgebraicGeometry.Spec.map (CommRingCat.ofHom (algebraMap R (Localization.Away f)))) |
Matrix.adjugate_conjTranspose | Mathlib.LinearAlgebra.Matrix.Adjugate | ∀ {n : Type v} {α : Type w} [inst : DecidableEq n] [inst_1 : Fintype n] [inst_2 : CommRing α] [inst_3 : StarRing α]
(A : Matrix n n α), A.adjugate.conjTranspose = A.conjTranspose.adjugate |
CategoryTheory.GradedNatTrans.naturality_assoc | Mathlib.CategoryTheory.Enriched.Basic | ∀ {V : Type v} [inst : CategoryTheory.Category.{w, v} V] [inst_1 : CategoryTheory.MonoidalCategory V] {C : Type u₁}
[inst_2 : CategoryTheory.EnrichedCategory V C] {D : Type u₂} [inst_3 : CategoryTheory.EnrichedCategory V D]
{A : CategoryTheory.Center V} {F G : CategoryTheory.EnrichedFunctor V C D}
(self : CategoryTheory.GradedNatTrans A F G) (X Y : C) {Z : V} (h : (F.obj X ⟶[V] G.obj Y) ⟶ Z),
CategoryTheory.CategoryStruct.comp (A.snd.β (X ⟶[V] Y)).hom
(CategoryTheory.CategoryStruct.comp (CategoryTheory.MonoidalCategoryStruct.tensorHom (F.map X Y) (self.app Y))
(CategoryTheory.CategoryStruct.comp (CategoryTheory.eComp V (F.obj X) (F.obj Y) (G.obj Y)) h)) =
CategoryTheory.CategoryStruct.comp (CategoryTheory.MonoidalCategoryStruct.tensorHom (self.app X) (G.map X Y))
(CategoryTheory.CategoryStruct.comp (CategoryTheory.eComp V (F.obj X) (G.obj X) (G.obj Y)) h) |
Submodule.smithNormalFormOfLE._proof_7 | Mathlib.LinearAlgebra.FreeModule.PID | ∀ {R : Type u_1} [inst : CommRing R] {M : Type u_2} [inst_1 : AddCommGroup M] [inst_2 : Module R M]
(N O : Submodule R M) (n : ℕ)
(x : ∃ o, ∃ (hno : n ≤ o), ∃ bO bN a, ∀ (i : Fin n), ↑(bN i) = a i • ↑(bO (Fin.castLE hno i))),
∃ (hno : n ≤ Classical.choose x), ∃ bO bN a, ∀ (i : Fin n), ↑(bN i) = a i • ↑(bO (Fin.castLE hno i)) |
DyckWord.le_add_self | Mathlib.Combinatorics.Enumerative.DyckWord | ∀ (p q : DyckWord), q ≤ p + q |
CategoryTheory.Bicategory.Adj.Bicategory.associator_hom_τl | Mathlib.CategoryTheory.Bicategory.Adjunction.Adj | ∀ {B : Type u} [inst : CategoryTheory.Bicategory B] {a b c d : CategoryTheory.Bicategory.Adj B} (α : a ⟶ b) (β : b ⟶ c)
(γ : c ⟶ d),
(CategoryTheory.Bicategory.Adj.Bicategory.associator α β γ).hom.τl =
(CategoryTheory.Bicategory.associator α.l β.l γ.l).hom |
NonAssocRing.mk._flat_ctor | Mathlib.Algebra.Ring.Defs | {α : Type u_1} →
(add : α → α → α) →
(∀ (a b c : α), a + b + c = a + (b + c)) →
(zero : α) →
(∀ (a : α), 0 + a = a) →
(∀ (a : α), a + 0 = a) →
(nsmul : ℕ → α → α) →
autoParam (∀ (x : α), nsmul 0 x = 0) AddMonoid.nsmul_zero._autoParam →
autoParam (∀ (n : ℕ) (x : α), nsmul (n + 1) x = nsmul n x + x) AddMonoid.nsmul_succ._autoParam →
(neg : α → α) →
(sub : α → α → α) →
autoParam (∀ (a b : α), a - b = a + neg b) SubNegMonoid.sub_eq_add_neg._autoParam →
(zsmul : ℤ → α → α) →
autoParam (∀ (a : α), zsmul 0 a = 0) SubNegMonoid.zsmul_zero'._autoParam →
autoParam (∀ (n : ℕ) (a : α), zsmul (↑n.succ) a = zsmul (↑n) a + a)
SubNegMonoid.zsmul_succ'._autoParam →
autoParam (∀ (n : ℕ) (a : α), zsmul (Int.negSucc n) a = neg (zsmul (↑n.succ) a))
SubNegMonoid.zsmul_neg'._autoParam →
(∀ (a : α), neg a + a = 0) →
(∀ (a b : α), a + b = b + a) →
(mul : α → α → α) →
(∀ (a b c : α), a * (b + c) = a * b + a * c) →
(∀ (a b c : α), (a + b) * c = a * c + b * c) →
(∀ (a : α), 0 * a = 0) →
(∀ (a : α), a * 0 = 0) →
(one : α) →
(∀ (a : α), 1 * a = a) →
(∀ (a : α), a * 1 = a) →
(natCast : ℕ → α) →
autoParam (natCast 0 = 0)
AddMonoidWithOne.natCast_zero._autoParam →
autoParam (∀ (n : ℕ), natCast (n + 1) = natCast n + 1)
AddMonoidWithOne.natCast_succ._autoParam →
(intCast : ℤ → α) →
autoParam (∀ (n : ℕ), intCast ↑n = ↑n)
AddGroupWithOne.intCast_ofNat._autoParam →
autoParam
(∀ (n : ℕ), intCast (Int.negSucc n) = neg ↑(n + 1))
AddGroupWithOne.intCast_negSucc._autoParam →
NonAssocRing α |
upperSemicontinuousOn_iff_restrict._simp_1 | Mathlib.Topology.Semicontinuity.Defs | ∀ {α : Type u_1} {β : Type u_2} [inst : TopologicalSpace α] [inst_1 : Preorder β] {f : α → β} {s : Set α},
UpperSemicontinuous (s.restrict f) = UpperSemicontinuousOn f s |
Lean.Parser.Command.grindPattern._regBuiltin.Lean.Parser.Command.GrindCnstr.guard.parenthesizer_105 | Lean.Meta.Tactic.Grind.Parser | IO Unit |
_private.Init.Core.0.if_neg.match_1_1 | Init.Core | ∀ {c : Prop} (motive : Decidable c → Prop) (h : Decidable c),
(∀ (hc : c), motive (isTrue hc)) → (∀ (h : ¬c), motive (isFalse h)) → motive h |
NonUnitalStarSubalgebra.ofClass._proof_2 | Mathlib.Algebra.Star.NonUnitalSubalgebra | ∀ {S : Type u_2} {A : Type u_1} [inst : NonUnitalNonAssocSemiring A] [inst_1 : SetLike S A]
[NonUnitalSubsemiringClass S A] (s : S), 0 ∈ s |
_private.Mathlib.Order.KrullDimension.0.Order.height_eq_krullDim_Iic._simp_1_3 | Mathlib.Order.KrullDimension | ∀ {α : Type u_1} [inst : LE α] {x y : α}, (x ≥ y) = (y ≤ x) |
Subgroup.commutator_le_focalSubgroupOf | Mathlib.GroupTheory.Focal | ∀ {G : Type u_1} [inst : Group G] (H : Subgroup G), commutator ↥H ≤ H.focalSubgroupOf |
instDecidableEqNzsNum | Mathlib.Data.Num.Bitwise | DecidableEq NzsNum |
_private.Mathlib.Analysis.SpecialFunctions.Pow.Real.0.Mathlib.Meta.NormNum.evalRPow.match_1 | Mathlib.Analysis.SpecialFunctions.Pow.Real | (motive :
(u : Lean.Level) →
{αR : Q(Type u)} →
(e : Q(«$αR»)) →
Lean.MetaM (Mathlib.Meta.NormNum.Result e) → Lean.MetaM (Mathlib.Meta.NormNum.Result e) → Sort u_1) →
(u : Lean.Level) →
{αR : Q(Type u)} →
(e : Q(«$αR»)) →
(__alt __alt_1 : Lean.MetaM (Mathlib.Meta.NormNum.Result e)) →
((αR : Q(Type)) →
(e : Q(«$αR»)) →
(__alt __alt_2 : Lean.MetaM (Mathlib.Meta.NormNum.Result e)) → motive Lean.Level.zero e __alt __alt_2) →
((x : Lean.Level) →
(αR : Q(Type x)) →
(e : Q(«$αR»)) →
(__alt __alt_2 : Lean.MetaM (Mathlib.Meta.NormNum.Result e)) → motive x e __alt __alt_2) →
motive u e __alt __alt_1 |
tendsto_mul | Mathlib.Topology.Algebra.Monoid | ∀ {M : Type u_3} [inst : TopologicalSpace M] [inst_1 : Mul M] [ContinuousMul M] {a b : M},
Filter.Tendsto (fun p => p.1 * p.2) (nhds (a, b)) (nhds (a * b)) |
Lean.Compiler.LCNF.LambdaLifting.State.recOn | Lean.Compiler.LCNF.LambdaLifting | {motive : Lean.Compiler.LCNF.LambdaLifting.State → Sort u} →
(t : Lean.Compiler.LCNF.LambdaLifting.State) →
((decls : Array (Lean.Compiler.LCNF.Decl Lean.Compiler.LCNF.Purity.pure)) →
(nextIdx : ℕ) → motive { decls := decls, nextIdx := nextIdx }) →
motive t |
CategoryTheory.Abelian.mono_inr_of_isColimit | Mathlib.CategoryTheory.Abelian.Basic | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [CategoryTheory.Abelian C]
[CategoryTheory.Limits.HasPushouts C] {X Y Z : C} (f : X ⟶ Y) (g : X ⟶ Z) [CategoryTheory.Mono f]
{s : CategoryTheory.Limits.PushoutCocone f g} (hs : CategoryTheory.Limits.IsColimit s), CategoryTheory.Mono s.inr |
HomotopicalAlgebra.FibrantObject.HoCat.localizerMorphismResolution | Mathlib.AlgebraicTopology.ModelCategory.FibrantObjectHomotopy | (C : Type u_1) →
[inst : CategoryTheory.Category.{v_1, u_1} C] →
[inst_1 : HomotopicalAlgebra.ModelCategory C] →
CategoryTheory.LocalizerMorphism (HomotopicalAlgebra.weakEquivalences C)
(HomotopicalAlgebra.weakEquivalences (HomotopicalAlgebra.FibrantObject.HoCat C)) |
Aesop.popGoal? | Aesop.Search.SearchM | {Q : Type} → [inst : Aesop.Queue Q] → Aesop.SearchM Q (Option Aesop.GoalRef) |
Algebra.SubmersivePresentation.ofHasCoeffs | Mathlib.RingTheory.Extension.Presentation.Core | {R : Type u_1} →
{S : Type u_2} →
{ι : Type u_3} →
{σ : Type u_4} →
[inst : CommRing R] →
[inst_1 : CommRing S] →
[inst_2 : Algebra R S] →
[inst_3 : Finite σ] →
(P : Algebra.SubmersivePresentation R S ι σ) →
(R₀ : Type u_5) →
[inst_4 : CommRing R₀] →
[inst_5 : Algebra R₀ R] →
[inst_6 : Algebra R₀ S] →
[inst_7 : IsScalarTower R₀ R S] →
[inst_8 : P.HasCoeffs R₀] →
[FaithfulSMul R₀ R] →
Algebra.SubmersivePresentation R₀ (Algebra.Presentation.ModelOfHasCoeffs R₀) ι σ |
Valuation.ltSubmodule_monotone | Mathlib.RingTheory.Valuation.Integers | ∀ {R : Type u} {Γ₀ : Type v} [inst : Ring R] [inst_1 : LinearOrderedCommGroupWithZero Γ₀] (v : Valuation R Γ₀),
Monotone v.ltSubmodule |
OrthonormalBasis.coe_equiv_euclideanSpace | Mathlib.Analysis.InnerProductSpace.PiL2 | ∀ {ι : Type u_1} {𝕜 : Type u_3} [inst : RCLike 𝕜] {E : Type u_4} [inst_1 : NormedAddCommGroup E]
[inst_2 : InnerProductSpace 𝕜 E] [inst_3 : Fintype ι] (b : OrthonormalBasis ι 𝕜 E),
⇑((EuclideanSpace.basisFun ι 𝕜).equiv b (Equiv.refl ι)) = fun x => ∑ i, x.ofLp i • b i |
SModEq.symm | Mathlib.LinearAlgebra.SModEq.Basic | ∀ {R : Type u_1} [inst : Ring R] {M : Type u_4} [inst_1 : AddCommGroup M] [inst_2 : Module R M] {U : Submodule R M}
{x y : M}, x ≡ y [SMOD U] → y ≡ x [SMOD U] |
_private.Mathlib.MeasureTheory.VectorMeasure.Basic.0.MeasureTheory.Measure.zero_le_toSignedMeasure._simp_1_1 | Mathlib.MeasureTheory.VectorMeasure.Basic | ∀ {α : Type u_1} {x : MeasurableSpace α} {μ : MeasureTheory.Measure α} {s : Set α}, (0 ≤ μ.real s) = True |
Units.add._proof_1 | Mathlib.Analysis.Normed.Ring.Units | ∀ {R : Type u_1} [inst : NormedRing R] [inst_1 : HasSummableGeomSeries R] (x : Rˣ) (t : R) (h : ‖t‖ < ‖↑x⁻¹‖⁻¹),
↑(x * Units.oneSub (-(↑x⁻¹ * t)) ⋯)⁻¹ = ↑(x * Units.oneSub (-(↑x⁻¹ * t)) ⋯)⁻¹ |
CategoryTheory.Localization.StrictUniversalPropertyFixedTarget.mk.injEq | Mathlib.CategoryTheory.Localization.Predicate | ∀ {C : Type u_1} {D : Type u_2} [inst : CategoryTheory.Category.{v_1, u_1} C]
[inst_1 : CategoryTheory.Category.{v_2, u_2} D] {L : CategoryTheory.Functor C D}
{W : CategoryTheory.MorphismProperty C} {E : Type u_3} [inst_2 : CategoryTheory.Category.{v_3, u_3} E]
(inverts : W.IsInvertedBy L) (lift : (F : CategoryTheory.Functor C E) → W.IsInvertedBy F → CategoryTheory.Functor D E)
(fac : ∀ (F : CategoryTheory.Functor C E) (hF : W.IsInvertedBy F), L.comp (lift F hF) = F)
(uniq : ∀ (F₁ F₂ : CategoryTheory.Functor D E), L.comp F₁ = L.comp F₂ → F₁ = F₂) (inverts_1 : W.IsInvertedBy L)
(lift_1 : (F : CategoryTheory.Functor C E) → W.IsInvertedBy F → CategoryTheory.Functor D E)
(fac_1 : ∀ (F : CategoryTheory.Functor C E) (hF : W.IsInvertedBy F), L.comp (lift_1 F hF) = F)
(uniq_1 : ∀ (F₁ F₂ : CategoryTheory.Functor D E), L.comp F₁ = L.comp F₂ → F₁ = F₂),
({ inverts := inverts, lift := lift, fac := fac, uniq := uniq } =
{ inverts := inverts_1, lift := lift_1, fac := fac_1, uniq := uniq_1 }) =
(lift = lift_1) |
Bifunctor.snd | Mathlib.Control.Bifunctor | {F : Type u₀ → Type u₁ → Type u₂} → [Bifunctor F] → {α : Type u₀} → {β β' : Type u₁} → (β → β') → F α β → F α β' |
Lean.mkAppRange | Lean.Expr | Lean.Expr → ℕ → ℕ → Array Lean.Expr → Lean.Expr |
Lean.Parser.Term.fun._regBuiltin.Lean.Parser.Term.fun_1 | Lean.Parser.Term | IO Unit |
MeasureTheory.UniformIntegrable.memLp_of_ae_tendsto | Mathlib.MeasureTheory.Function.UniformIntegrable | ∀ {α : Type u_1} {β : Type u_2} {m : MeasurableSpace α} {μ : MeasureTheory.Measure α} [inst : NormedAddCommGroup β]
{p : ENNReal} {κ : Type u_4} {u : Filter κ} [u.NeBot] [u.IsCountablyGenerated] {f : κ → α → β} {g : α → β},
MeasureTheory.UniformIntegrable f p μ →
(∀ᵐ (x : α) ∂μ, Filter.Tendsto (fun n => f n x) u (nhds (g x))) → MeasureTheory.MemLp g p μ |
_private.Aesop.Builder.Forward.0.Aesop.RuleBuilder.getImmediatePremises._sparseCasesOn_1 | Aesop.Builder.Forward | {motive : Lean.BinderInfo → Sort u} →
(t : Lean.BinderInfo) → motive Lean.BinderInfo.instImplicit → (Nat.hasNotBit 8 t.ctorIdx → motive t) → motive t |
Set.infinite_of_injective_forall_mem | Mathlib.Data.Set.Finite.Basic | ∀ {α : Type u} {β : Type v} [Infinite α] {s : Set β} {f : α → β},
Function.Injective f → (∀ (x : α), f x ∈ s) → s.Infinite |
IntCast.rec | Init.Data.Int.Basic | {R : Type u} →
{motive : IntCast R → Sort u_1} → ((intCast : ℤ → R) → motive { intCast := intCast }) → (t : IntCast R) → motive t |
_private.Mathlib.Topology.Separation.Hausdorff.0.t2_iff_isClosed_diagonal._simp_1_4 | Mathlib.Topology.Separation.Hausdorff | ∀ {α : Type u_1} {β : Type u_2} {p : α × β → Prop}, (∀ (x : α × β), p x) = ∀ (a : α) (b : β), p (a, b) |
QuadraticForm.radical_weightedSumSquares | Mathlib.LinearAlgebra.QuadraticForm.Radical | ∀ {𝕜 : Type u_1} {ι : Type u_2} [inst : Field 𝕜] [NeZero 2] [inst_2 : Fintype ι] {w : ι → 𝕜},
(QuadraticMap.weightedSumSquares 𝕜 w).radical = Pi.spanSubset 𝕜 {i | w i = 0} |
Std.Rxi.HasSize.rec | Init.Data.Range.Polymorphic.Basic | {α : Type u} →
{motive : Std.Rxi.HasSize α → Sort u_1} →
((size : α → ℕ) → motive { size := size }) → (t : Std.Rxi.HasSize α) → motive t |
CategoryTheory.ShortComplex.RightHomologyMapData.mk | Mathlib.Algebra.Homology.ShortComplex.RightHomology | {C : Type u_1} →
[inst : CategoryTheory.Category.{v_1, u_1} C] →
[inst_1 : CategoryTheory.Limits.HasZeroMorphisms C] →
{S₁ S₂ : CategoryTheory.ShortComplex C} →
{φ : S₁ ⟶ S₂} →
{h₁ : S₁.RightHomologyData} →
{h₂ : S₂.RightHomologyData} →
(φQ : h₁.Q ⟶ h₂.Q) →
(φH : h₁.H ⟶ h₂.H) →
autoParam (CategoryTheory.CategoryStruct.comp h₁.p φQ = CategoryTheory.CategoryStruct.comp φ.τ₂ h₂.p)
CategoryTheory.ShortComplex.RightHomologyMapData.commp._autoParam →
autoParam
(CategoryTheory.CategoryStruct.comp φQ h₂.g' = CategoryTheory.CategoryStruct.comp h₁.g' φ.τ₃)
CategoryTheory.ShortComplex.RightHomologyMapData.commg'._autoParam →
autoParam
(CategoryTheory.CategoryStruct.comp φH h₂.ι = CategoryTheory.CategoryStruct.comp h₁.ι φQ)
CategoryTheory.ShortComplex.RightHomologyMapData.commι._autoParam →
CategoryTheory.ShortComplex.RightHomologyMapData φ h₁ h₂ |
AlgebraicGeometry.Scheme.affineOpenCoverOfSpanRangeEqTop._proof_3 | Mathlib.AlgebraicGeometry.Cover.Open | ∀ {R : CommRingCat} {ι : Type u_1} (s : ι → ↑R),
Ideal.span (Set.range s) = ⊤ → ∀ (x : ↥(AlgebraicGeometry.Spec R)), ∃ i, s i ∉ x.asIdeal |
_private.Lean.Elab.Extra.0.Lean.Elab.Term.Op.Tree.term | Lean.Elab.Extra | Lean.Syntax → Lean.PersistentArray Lean.Elab.InfoTree → Lean.Expr → Lean.Elab.Term.Op.Tree✝ |
Submodule.starProjection_inj | Mathlib.Analysis.InnerProductSpace.Positive | ∀ {𝕜 : Type u_1} {E : Type u_2} [inst : RCLike 𝕜] [inst_1 : NormedAddCommGroup E] [inst_2 : InnerProductSpace 𝕜 E]
{U V : Submodule 𝕜 E} [inst_3 : U.HasOrthogonalProjection] [inst_4 : V.HasOrthogonalProjection],
U.starProjection = V.starProjection ↔ U = V |
BiheytingHom.id_comp | Mathlib.Order.Heyting.Hom | ∀ {α : Type u_2} {β : Type u_3} [inst : BiheytingAlgebra α] [inst_1 : BiheytingAlgebra β] (f : BiheytingHom α β),
(BiheytingHom.id β).comp f = f |
_private.Batteries.Data.String.Lemmas.0.String.foldlAux_of_valid.match_1_1 | Batteries.Data.String.Lemmas | ∀ {α : Type u_1} (motive : List Char → List Char → List Char → α → Prop) (x x_1 x_2 : List Char) (x_3 : α),
(∀ (l r : List Char) (a : α), motive l [] r a) →
(∀ (l : List Char) (c : Char) (m r : List Char) (a : α), motive l (c :: m) r a) → motive x x_1 x_2 x_3 |
BoundedLatticeHom.toInfTopHom | Mathlib.Order.Hom.BoundedLattice | {α : Type u_2} →
{β : Type u_3} →
[inst : Lattice α] →
[inst_1 : Lattice β] →
[inst_2 : BoundedOrder α] → [inst_3 : BoundedOrder β] → BoundedLatticeHom α β → InfTopHom α β |
SSet.Edge.map_id | Mathlib.AlgebraicTopology.SimplicialSet.CompStruct | ∀ {X Y : SSet} (x₀ : X.obj (Opposite.op (SimplexCategory.mk 0))) (f : X ⟶ Y),
(SSet.Edge.id x₀).map f = SSet.Edge.id (f.app (Opposite.op (SimplexCategory.mk 0)) x₀) |
GroupExtension.Equiv.ofMonoidHom._proof_6 | Mathlib.GroupTheory.GroupExtension.Basic | ∀ {N : Type u_4} {G : Type u_2} [inst : Group N] [inst_1 : Group G] {E : Type u_1} [inst_2 : Group E]
{S : GroupExtension N E G} {E' : Type u_3} [inst_3 : Group E'] {S' : GroupExtension N E' G} (f : E →* E'),
S'.rightHom.comp f = S.rightHom → ⇑(S'.rightHom.comp f) = ⇑S.rightHom |
EisensteinSeries.r1.eq_1 | Mathlib.NumberTheory.ModularForms.EisensteinSeries.Summable | ∀ (z : UpperHalfPlane), EisensteinSeries.r1 z = z.im ^ 2 / (z.re ^ 2 + z.im ^ 2) |
CategoryTheory.Limits.Cofork.IsColimit.homIso_natural | Mathlib.CategoryTheory.Limits.Shapes.Equalizers | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {X Y : C} {f g : X ⟶ Y} {t : CategoryTheory.Limits.Cofork f g}
{Z Z' : C} (q : Z ⟶ Z') (ht : CategoryTheory.Limits.IsColimit t) (k : t.pt ⟶ Z),
↑((CategoryTheory.Limits.Cofork.IsColimit.homIso ht Z') (CategoryTheory.CategoryStruct.comp k q)) =
CategoryTheory.CategoryStruct.comp (↑((CategoryTheory.Limits.Cofork.IsColimit.homIso ht Z) k)) q |
continuousWithinAt_iff_continuous_left'_right'._to_dual_1 | Mathlib.Topology.Order.LeftRight | ∀ {α : Type u_1} {β : Type u_2} [inst : TopologicalSpace α] [inst_1 : LinearOrder α] [inst_2 : TopologicalSpace β]
{s : Set α} {a : α} {f : α → β},
ContinuousWithinAt f s a ↔ ContinuousWithinAt f (s ∩ Set.Ioi a) a ∧ ContinuousWithinAt f (s ∩ Set.Iio a) a |
_private.Mathlib.Tactic.Lift.0.Mathlib.Tactic.Lift.main.match_3 | Mathlib.Tactic.Lift | (motive : Option (Lean.TSyntax `ident) → Sort u_1) →
(newVarName : Option (Lean.TSyntax `ident)) →
((v : Lean.TSyntax `ident) → motive (some v)) → (Unit → motive none) → motive newVarName |
_private.Mathlib.Probability.Moments.SubGaussian.0.ProbabilityTheory.Kernel.HasSubgaussianMGF.measure_pos_eq_zero_of_hasSubGaussianMGF_zero._simp_1_2 | Mathlib.Probability.Moments.SubGaussian | ∀ {α : Sort u} {p : α → Prop} {q : { a // p a } → Prop}, (∃ x, q x) = ∃ a, ∃ (b : p a), q ⟨a, b⟩ |
Std.Roc.Sliceable.rec | Init.Data.Slice.Notation | {α : Type u} →
{β : Type v} →
{γ : Type w} →
{motive : Std.Roc.Sliceable α β γ → Sort u_1} →
((mkSlice : α → Std.Roc β → γ) → motive { mkSlice := mkSlice }) → (t : Std.Roc.Sliceable α β γ) → motive t |
HomotopicalAlgebra.AttachCells.ofArrowIso._proof_1 | Mathlib.AlgebraicTopology.RelativeCellComplex.AttachCells | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] {α : Type u_4} {A B : α → C} {g : (a : α) → A a ⟶ B a}
{X₁ X₂ : C} {f : X₁ ⟶ X₂} (c : HomotopicalAlgebra.AttachCells g f) {Y₁ Y₂ : C} {f' : Y₁ ⟶ Y₂}
(e : CategoryTheory.Arrow.mk f ≅ CategoryTheory.Arrow.mk f'),
CategoryTheory.IsPushout (CategoryTheory.CategoryStruct.comp c.g₁ (CategoryTheory.Arrow.leftFunc.map e.hom)) c.m f'
(CategoryTheory.CategoryStruct.comp c.g₂ (CategoryTheory.Arrow.rightFunc.map e.hom)) |
WithTop.add_right_inj | Mathlib.Algebra.Order.Monoid.Unbundled.WithTop | ∀ {α : Type u} [inst : Add α] {x y z : WithTop α} [IsRightCancelAdd α], z ≠ ⊤ → (x + z = y + z ↔ x = y) |
CategoryTheory.Comonad.comparison._proof_3 | Mathlib.CategoryTheory.Monad.Adjunction | ∀ {C : Type u_4} [inst : CategoryTheory.Category.{u_3, u_4} C] {D : Type u_2}
[inst_1 : CategoryTheory.Category.{u_1, u_2} D] {L : CategoryTheory.Functor C D} {R : CategoryTheory.Functor D C}
(h : L ⊣ R) (X : C),
CategoryTheory.CategoryStruct.comp (L.map (h.unit.app X)) (h.toComonad.δ.app (L.obj X)) =
CategoryTheory.CategoryStruct.comp (L.map (h.unit.app X)) (h.toComonad.map (L.map (h.unit.app X))) |
RatFunc.intDegree_add_le | Mathlib.FieldTheory.RatFunc.Degree | ∀ {K : Type u} [inst : Field K] {x y : RatFunc K}, y ≠ 0 → x + y ≠ 0 → (x + y).intDegree ≤ max x.intDegree y.intDegree |
SimpleGraph.TripartiteFromTriangles.toTriangle.match_1 | Mathlib.Combinatorics.SimpleGraph.Triangle.Tripartite | ∀ {α : Type u_1} {β : Type u_3} {γ : Type u_2} (motive : α × β × γ → Prop) (x : α × β × γ),
(∀ (a' : α) (b' : β) (c' : γ), motive (a', b', c')) → motive x |
LiouvilleWith.mul_rat_iff | Mathlib.NumberTheory.Transcendental.Liouville.LiouvilleWith | ∀ {p x : ℝ} {r : ℚ}, r ≠ 0 → (LiouvilleWith p (x * ↑r) ↔ LiouvilleWith p x) |
Module.IsTorsionFree.of_faithfulSMul | Mathlib.Algebra.Algebra.Basic | ∀ (R : Type u_1) (S : Type u_2) (A : Type u_3) [inst : CommSemiring R] [inst_1 : Semiring A] [inst_2 : Algebra R A]
[FaithfulSMul R A] [inst_4 : Semiring S] [inst_5 : Module S R] [inst_6 : Module S A] [IsScalarTower S R A]
[Module.IsTorsionFree S A], Module.IsTorsionFree S R |
AddOpposite.opUniformEquivRight._proof_1 | Mathlib.Topology.Algebra.IsUniformGroup.Basic | ∀ (G : Type u_1) [inst : AddGroup G] [inst_1 : TopologicalSpace G] [inst_2 : IsTopologicalAddGroup G],
UniformContinuous AddOpposite.op |
CategoryTheory.Triangulated.TStructure.triangleLEGEIsoTriangleLTGE._proof_2 | Mathlib.CategoryTheory.Triangulated.TStructure.TruncLEGT | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{u_2, u_1} C] [inst_1 : CategoryTheory.Preadditive C]
[inst_2 : CategoryTheory.Limits.HasZeroObject C] [inst_3 : CategoryTheory.HasShift C ℤ]
[inst_4 : ∀ (n : ℤ), (CategoryTheory.shiftFunctor C n).Additive] [inst_5 : CategoryTheory.Pretriangulated C]
(t : CategoryTheory.Triangulated.TStructure C) (a b : ℤ) (h : a + 1 = b),
CategoryTheory.CategoryStruct.comp ((t.triangleLEGE a b h).whiskerLeft CategoryTheory.Pretriangulated.Triangle.π₂Toπ₃)
(CategoryTheory.Iso.refl ((t.triangleLEGE a b h).comp CategoryTheory.Pretriangulated.Triangle.π₃)).hom =
CategoryTheory.CategoryStruct.comp
(CategoryTheory.Iso.refl ((t.triangleLEGE a b h).comp CategoryTheory.Pretriangulated.Triangle.π₂)).hom
((t.triangleLTGE b).whiskerLeft CategoryTheory.Pretriangulated.Triangle.π₂Toπ₃) |
Int.tdiv_left_inj | Init.Data.Int.DivMod.Lemmas | ∀ {a b d : ℤ}, d ∣ a → d ∣ b → (a.tdiv d = b.tdiv d ↔ a = b) |
Module.eqIdeal._proof_3 | Mathlib.RingTheory.Ideal.Defs | ∀ (R : Type u_1) {M : Type u_2} [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M] (m m' : M),
0 ∈ {r | r • m = r • m'} |
measurableSet_generateFrom_of_mem_supClosure | Mathlib.MeasureTheory.MeasurableSpace.Basic | ∀ {α : Type u_1} {s : Set (Set α)} {t : Set α}, t ∈ supClosure s → MeasurableSet t |
Std.TreeSet.Raw.isEmpty_insert | Std.Data.TreeSet.Raw.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} {t : Std.TreeSet.Raw α cmp} [Std.TransCmp cmp],
t.WF → ∀ {k : α}, (t.insert k).isEmpty = false |
_private.Mathlib.MeasureTheory.Covering.Besicovitch.0.Besicovitch.exist_finset_disjoint_balls_large_measure._simp_1_20 | Mathlib.MeasureTheory.Covering.Besicovitch | ∀ {α : Type u_1} {a : α} {s : Finset α}, (a ∈ ↑s) = (a ∈ s) |
Std.DTreeMap.Internal.Unit.RooSliceData | Std.Data.DTreeMap.Internal.Zipper | (α : Type u) → [Ord α] → Type u |
MeasureTheory.projectiveFamilyContent_eq | Mathlib.MeasureTheory.Constructions.ProjectiveFamilyContent | ∀ {ι : Type u_1} {α : ι → Type u_2} {mα : (i : ι) → MeasurableSpace (α i)}
{P : (J : Finset ι) → MeasureTheory.Measure ((j : ↥J) → α ↑j)} {s : Set ((i : ι) → α i)}
(hP : MeasureTheory.IsProjectiveMeasureFamily P),
(MeasureTheory.projectiveFamilyContent hP) s = MeasureTheory.projectiveFamilyFun P s |
norm_add₄_le | Mathlib.Analysis.Normed.Group.Basic | ∀ {E : Type u_5} [inst : SeminormedAddGroup E] {a b c d : E}, ‖a + b + c + d‖ ≤ ‖a‖ + ‖b‖ + ‖c‖ + ‖d‖ |
_private.Mathlib.AlgebraicGeometry.Scheme.0.AlgebraicGeometry.basicOpen_eq_of_affine._simp_1_1 | Mathlib.AlgebraicGeometry.Scheme | ∀ {A : Type u_1} {B : Type u_2} [i : SetLike A B] {p : A} {x : B}, (x ∈ ↑p) = (x ∈ p) |
CategoryTheory.Functor.whiskerRight_id | Mathlib.CategoryTheory.Whiskering | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
{E : Type u₃} [inst_2 : CategoryTheory.Category.{v₃, u₃} E] {G : CategoryTheory.Functor C D}
(F : CategoryTheory.Functor D E),
CategoryTheory.Functor.whiskerRight (CategoryTheory.NatTrans.id G) F = CategoryTheory.NatTrans.id (G.comp F) |
DirectSum.SetLike.IsHomogeneous | Mathlib.Algebra.DirectSum.Decomposition | {ι : Type u_1} →
{M : Type u_3} →
{σ : Type u_4} →
[inst : DecidableEq ι] →
[inst_1 : AddCommMonoid M] →
[inst_2 : SetLike σ M] →
[inst_3 : AddSubmonoidClass σ M] →
(ℳ : ι → σ) → [DirectSum.Decomposition ℳ] → {P : Type u_5} → [SetLike P M] → P → Prop |
MulOpposite.instNonUnitalNormedRing._proof_3 | Mathlib.Analysis.Normed.Ring.Basic | ∀ {α : Type u_1} [inst : NonUnitalNormedRing α] (a b : αᵐᵒᵖ), ‖a * b‖ ≤ ‖a‖ * ‖b‖ |
Graded.subtypeMap | Mathlib.Data.FunLike.Graded | {F : Type u_1} →
{A : Type u_2} →
{B : Type u_3} →
{σ : Type u_4} →
{τ : Type u_5} →
{ι : Type u_6} →
[inst : SetLike σ A] →
[inst_1 : SetLike τ B] →
{𝒜 : ι → σ} →
{ℬ : ι → τ} → [inst_2 : FunLike F A B] → [GradedFunLike F 𝒜 ℬ] → F → (i : ι) → ↥(𝒜 i) → ↥(ℬ i) |
smoothSheafCommGroup.compLeft | Mathlib.Geometry.Manifold.Sheaf.Smooth | {𝕜 : Type u_1} →
[inst : NontriviallyNormedField 𝕜] →
{EM : Type u_2} →
[inst_1 : NormedAddCommGroup EM] →
[inst_2 : NormedSpace 𝕜 EM] →
{HM : Type u_3} →
[inst_3 : TopologicalSpace HM] →
(IM : ModelWithCorners 𝕜 EM HM) →
{E : Type u_4} →
[inst_4 : NormedAddCommGroup E] →
[inst_5 : NormedSpace 𝕜 E] →
{H : Type u_5} →
[inst_6 : TopologicalSpace H] →
(I : ModelWithCorners 𝕜 E H) →
{H' : Type u_6} →
[inst_7 : TopologicalSpace H'] →
(I' : ModelWithCorners 𝕜 E H') →
(M : Type u) →
[inst_8 : TopologicalSpace M] →
[inst_9 : ChartedSpace HM M] →
(A A' : Type u) →
[inst_10 : TopologicalSpace A] →
[inst_11 : ChartedSpace H A] →
[inst_12 : TopologicalSpace A'] →
[inst_13 : ChartedSpace H' A'] →
[inst_14 : CommGroup A] →
[inst_15 : CommGroup A'] →
[inst_16 : LieGroup I (↑⊤) A] →
[inst_17 : LieGroup I' (↑⊤) A'] →
(φ : A →* A') →
ContMDiff I I' ↑⊤ ⇑φ →
(smoothSheafCommGroup IM I M A ⟶
smoothSheafCommGroup IM I' M A') |
Representation.mapSubmodule._proof_15 | Mathlib.RepresentationTheory.Submodule | ∀ {k : Type u_3} {G : Type u_2} {V : Type u_1} [inst : CommSemiring k] [inst_1 : Monoid G] [inst_2 : AddCommMonoid V]
[inst_3 : Module k V] (ρ : Representation k G V) (q : Submodule (MonoidAlgebra k G) ρ.asModule),
(fun p =>
let __AddSubmonoid := AddSubmonoid.map ρ.asModuleEquiv.symm (↑p).toAddSubmonoid;
{ toAddSubmonoid := __AddSubmonoid, smul_mem' := ⋯ })
((fun q => ⟨(Submodule.orderIsoMapComap ρ.asModuleEquiv.symm).symm (Submodule.restrictScalars k q), ⋯⟩) q) =
q |
LieDerivation.coe_sub_linearMap | Mathlib.Algebra.Lie.Derivation.Basic | ∀ {R : Type u_1} {L : Type u_2} {M : Type u_3} [inst : CommRing R] [inst_1 : LieRing L] [inst_2 : LieAlgebra R L]
[inst_3 : AddCommGroup M] [inst_4 : Module R M] [inst_5 : LieRingModule L M] [inst_6 : LieModule R L M]
(D1 D2 : LieDerivation R L M), ↑(D1 - D2) = ↑D1 - ↑D2 |
LLVM.instNonemptyBasicBlock | Lean.Compiler.IR.LLVMBindings | ∀ {Context : Sort u_1} {ctx : Context}, Nonempty (LLVM.BasicBlock ctx) |
Std.ExtHashMap.getKey?_inter | Std.Data.ExtHashMap.Lemmas | ∀ {α : Type u} {β : Type v} {x : BEq α} {x_1 : Hashable α} {m₁ m₂ : Std.ExtHashMap α β} [inst : EquivBEq α]
[inst_1 : LawfulHashable α] {k : α}, (m₁ ∩ m₂).getKey? k = if k ∈ m₂ then m₁.getKey? k else none |
Lean.Lsp.SemanticTokenType.decorator.sizeOf_spec | Lean.Data.Lsp.LanguageFeatures | sizeOf Lean.Lsp.SemanticTokenType.decorator = 1 |
_private.Lean.Meta.Tactic.Simp.BuiltinSimprocs.BitVec.0._regBuiltin.BitVec.reduceXOr.declare_73._@.Lean.Meta.Tactic.Simp.BuiltinSimprocs.BitVec.370586403._hygCtx._hyg.20 | Lean.Meta.Tactic.Simp.BuiltinSimprocs.BitVec | IO Unit |
List.takeWhile_cons_of_pos | Init.Data.List.TakeDrop | ∀ {α : Type u_1} {p : α → Bool} {a : α} {l : List α}, p a = true → List.takeWhile p (a :: l) = a :: List.takeWhile p l |
Lean.Expr.const.injEq | Lean.Expr | ∀ (declName : Lean.Name) (us : List Lean.Level) (declName_1 : Lean.Name) (us_1 : List Lean.Level),
(Lean.Expr.const declName us = Lean.Expr.const declName_1 us_1) = (declName = declName_1 ∧ us = us_1) |
Array.getElem_setIfInBounds | Init.Data.Array.Lemmas | ∀ {α : Type u_1} {xs : Array α} {i : ℕ} {a : α} {j : ℕ} (hj : j < xs.size),
(xs.setIfInBounds i a)[j] = if i = j then a else xs[j] |
_private.Mathlib.Algebra.Category.Grp.Basic.0.CommGrpCat.Hom.mk._flat_ctor | Mathlib.Algebra.Category.Grp.Basic | {A B : CommGrpCat} → (↑A →* ↑B) → A.Hom B |
Prod.instExistsAddOfLE | Mathlib.Algebra.Order.Monoid.Prod | ∀ {α : Type u_1} {β : Type u_2} [inst : LE α] [inst_1 : LE β] [inst_2 : Add α] [inst_3 : Add β] [ExistsAddOfLE α]
[ExistsAddOfLE β], ExistsAddOfLE (α × β) |
Std.Internal.Small.mk._flat_ctor | Std.Data.Iterators.Lemmas.Equivalence.HetT | ∀ {α : Type v}, Nonempty (Std.Internal.ComputableSmall α) → Std.Internal.Small α |
Finset.nonempty_product | Mathlib.Data.Finset.Prod | ∀ {α : Type u_1} {β : Type u_2} {s : Finset α} {t : Finset β}, (s ×ˢ t).Nonempty ↔ s.Nonempty ∧ t.Nonempty |
MonoidAlgebra.mapDomainNonUnitalRingHom_comp | Mathlib.Algebra.MonoidAlgebra.MapDomain | ∀ {R : Type u_2} {M : Type u_5} {N : Type u_6} {O : Type u_7} [inst : Semiring R] [inst_1 : Mul M] [inst_2 : Mul N]
[inst_3 : Mul O] (f : N →ₙ* O) (g : M →ₙ* N),
MonoidAlgebra.mapDomainNonUnitalRingHom R (f.comp g) =
(MonoidAlgebra.mapDomainNonUnitalRingHom R f).comp (MonoidAlgebra.mapDomainNonUnitalRingHom R g) |
OrderMonoidHom.copy._proof_2 | Mathlib.Algebra.Order.Hom.Monoid | ∀ {α : Type u_2} {β : Type u_1} [inst : Preorder α] [inst_1 : Preorder β] [inst_2 : MulOneClass α]
[inst_3 : MulOneClass β] (f : α →*o β) (f' : α → β) (h : f' = ⇑f) (x y : α),
(↑(f.copy f' h)).toFun (x * y) = (↑(f.copy f' h)).toFun x * (↑(f.copy f' h)).toFun y |
Lean.Elab.Term.MatchAltView.mk.inj | Lean.Elab.MatchAltView | ∀ {k : Lean.SyntaxNodeKinds} {ref : Lean.Syntax} {patterns : Array Lean.Syntax} {lhs : Lean.Syntax}
{rhs : Lean.TSyntax k} {ref_1 : Lean.Syntax} {patterns_1 : Array Lean.Syntax} {lhs_1 : Lean.Syntax}
{rhs_1 : Lean.TSyntax k},
{ ref := ref, patterns := patterns, lhs := lhs, rhs := rhs } =
{ ref := ref_1, patterns := patterns_1, lhs := lhs_1, rhs := rhs_1 } →
ref = ref_1 ∧ patterns = patterns_1 ∧ lhs = lhs_1 ∧ rhs = rhs_1 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.