name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
_private.Mathlib.Analysis.Normed.Field.Basic.0.NormedField.denselyOrdered_range_norm.match_1 | Mathlib.Analysis.Normed.Field.Basic | ∀ (α : Type u_1) [inst : DenselyNormedField α] (x y : α) (motive : (∃ x_1, ‖x‖ < ‖x_1‖ ∧ ‖x_1‖ < ↑⟨‖y‖, ⋯⟩) → Prop)
(x_1 : ∃ x_1, ‖x‖ < ‖x_1‖ ∧ ‖x_1‖ < ↑⟨‖y‖, ⋯⟩), (∀ (z : α) (h : ‖x‖ < ‖z‖ ∧ ‖z‖ < ↑⟨‖y‖, ⋯⟩), motive ⋯) → motive x_1 | null | false |
ConvexCone.coe_add._simp_1 | Mathlib.Geometry.Convex.Cone.Basic | ∀ {R : Type u_2} {M : Type u_4} [inst : Semiring R] [inst_1 : PartialOrder R] [inst_2 : AddCommMonoid M]
[inst_3 : Module R M] (C₁ C₂ : ConvexCone R M), ↑C₁ + ↑C₂ = ↑(C₁ + C₂) | null | false |
LinearMap.BilinMap.toQuadraticMap._proof_3 | Mathlib.LinearAlgebra.QuadraticForm.Basic | ∀ {R : Type u_3} {M : Type u_1} {N : Type u_2} [inst : CommSemiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M]
[inst_3 : AddCommMonoid N] [inst_4 : Module R N] (B : LinearMap.BilinMap R M N),
∃ B_1, ∀ (x y : M), (B (x + y)) (x + y) = (B x) x + (B y) y + (B_1 x) y | null | false |
Matrix.PosSemidef.ofNat | Mathlib.LinearAlgebra.Matrix.PosDef | ∀ {n : Type u_2} {R : Type u_3} [inst : Ring R] [inst_1 : PartialOrder R] [inst_2 : StarRing R] [StarOrderedRing R]
[inst_4 : DecidableEq n] (d : ℕ) [inst_5 : d.AtLeastTwo], (OfNat.ofNat d).PosSemidef | null | true |
List.takeI_left' | Mathlib.Data.List.TakeDrop | ∀ {α : Type u} [inst : Inhabited α] {l₁ l₂ : List α} {n : ℕ}, l₁.length = n → List.takeI n (l₁ ++ l₂) = l₁ | null | true |
OrderHom.nextFixed._proof_1 | Mathlib.Order.FixedPoints | ∀ {α : Type u_1} [inst : CompleteLattice α] (f : α →o α) (x : α) (hx : x ≤ f x),
↑((OrderHom.dual f).prevFixed x hx) ∈ Function.fixedPoints ⇑(OrderHom.dual f) | null | false |
Std.DHashMap.getKey_eq_getKeyD | Std.Data.DHashMap.Lemmas | ∀ {α : Type u} {β : α → Type v} {x : BEq α} {x_1 : Hashable α} {m : Std.DHashMap α β} [EquivBEq α] [LawfulHashable α]
{a fallback : α} {h : a ∈ m}, m.getKey a h = m.getKeyD a fallback | null | true |
ConcaveOn.continuousOn_interior | Mathlib.Analysis.Convex.Continuous | ∀ {E : Type u_1} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E] {C : Set E} {f : E → ℝ}
[FiniteDimensional ℝ E], ConcaveOn ℝ C f → ContinuousOn f (interior C) | null | true |
Lean.Doc.MarkdownM.InlineCtx.inEmph._default | Lean.DocString.Markdown | Bool | null | false |
ENNReal.zpow_add | Mathlib.Basic.ENNReal.Inv | ∀ {x : ENNReal}, x ≠ 0 → x ≠ ⊤ → ∀ (m n : ℤ), x ^ (m + n) = x ^ m * x ^ n | null | true |
CondensedMod.epi_iff_locallySurjective_on_compHaus | Mathlib.Condensed.Epi | ∀ (R : Type (u + 1)) [inst : Ring R] {X Y : CondensedMod R} (f : X ⟶ Y),
CategoryTheory.Epi f ↔
∀ (S : CompHaus) (y : ↑(Y.obj.obj (Opposite.op S))),
∃ S' φ,
∃ (_ : Function.Surjective ⇑(CategoryTheory.ConcreteCategory.hom φ)),
∃ x,
(CategoryTheory.ConcreteCategory.hom (f.hom.ap... | null | true |
_private.Init.Data.Iterators.Lemmas.Consumers.Access.0.Std.Iter.atIdxSlow?_eq_match.match_3.splitter | Init.Data.Iterators.Lemmas.Consumers.Access | {α β : Type u_1} →
(motive : Std.IterStep (Std.Iter β) β → Sort u_2) →
(x : Std.IterStep (Std.Iter β) β) →
((it' : Std.Iter β) → (out : β) → motive (Std.IterStep.yield it' out)) →
((it' : Std.Iter β) → motive (Std.IterStep.skip it')) → (Unit → motive Std.IterStep.done) → motive x | null | true |
OreLocalization.instDivisionRingNonZeroDivisors | Mathlib.RingTheory.OreLocalization.Ring | {R : Type u_1} →
[inst : Ring R] →
[Nontrivial R] →
[NoZeroDivisors R] →
[inst_3 : OreLocalization.OreSet (nonZeroDivisors R)] → DivisionRing (OreLocalization (nonZeroDivisors R) R) | null | true |
MoritaEquivalence.ofAlgEquiv._proof_1 | Mathlib.RingTheory.Morita.Basic | ∀ {R : Type u_1} [inst : CommSemiring R] {A : Type u_2} {B : Type u_3} [inst_1 : Ring A] [inst_2 : Algebra R A]
[inst_3 : Ring B] [inst_4 : Algebra R B] (f : A ≃ₐ[R] B),
CategoryTheory.Functor.Linear R (ModuleCat.restrictScalarsEquivalenceOfRingEquiv f.symm.toRingEquiv).functor | null | false |
_private.Mathlib.Analysis.RCLike.Sqrt.0.RCLike.sqrt_neg_I._proof_1_3 | Mathlib.Analysis.RCLike.Sqrt | ∀ {𝕜 : Type u_1} [inst : RCLike 𝕜],
¬RCLike.im RCLike.I = 1 →
(algebraMap ℝ 𝕜) √(RCLike.re (-RCLike.I)) = (algebraMap ℝ 𝕜) √2⁻¹ * (1 + RCLike.I) * -RCLike.I | null | false |
FunctionField.inftyValuation.X_zpow | Mathlib.NumberTheory.FunctionField | ∀ (F : Type u_1) [inst : Field F] [inst_1 : DecidableEq (RatFunc F)] (m : ℤ),
(RatFunc.inftyValuation F) (RatFunc.X ^ m) = WithZero.exp m | **Alias** of `RatFunc.inftyValuation.X_zpow`. | true |
LinearMap.iterateFrobenius | Mathlib.Algebra.CharP.Frobenius | (R : Type u_1) →
[inst : CommSemiring R] →
(S : Type u_2) →
[inst_1 : CommSemiring S] →
(p n : ℕ) → [inst_2 : ExpChar R p] → [ExpChar S p] → [inst_4 : Algebra R S] → S →ₛₗ[iterateFrobenius R p n] S | The iterated Frobenius map of an algebra as an iterated-Frobenius-semilinear map. | true |
inner_gradientWithin_right | Mathlib.Analysis.Calculus.Gradient.Basic | ∀ {𝕜 : Type u_1} {F : Type u_2} [inst : RCLike 𝕜] [inst_1 : NormedAddCommGroup F] [inst_2 : InnerProductSpace 𝕜 F]
[inst_3 : CompleteSpace F] {f : F → 𝕜} {x y : F} {s : Set F},
inner 𝕜 x (gradientWithin f s y) = (starRingEnd 𝕜) ((fderivWithin 𝕜 f s y) x) | null | true |
Field.Emb.Cardinal.embEquivPi._proof_6 | Mathlib.FieldTheory.CardinalEmb | ∀ {F : Type u_2} {E : Type u_1} [inst : Field F] [inst_1 : Field E] [inst_2 : Algebra F E],
Function.Injective WithTop.some | null | false |
RingCon.quotientKerEquivRangeₐ_comp_mkₐ | Mathlib.RingTheory.Congruence.Hom | ∀ {M : Type u_1} {N : Type u_2} {R : Type u_4} [inst : CommSemiring R] [inst_1 : Semiring M] [inst_2 : Algebra R M]
[inst_3 : Semiring N] [inst_4 : Algebra R N] (φ : M →ₐ[R] N),
(↑(RingCon.quotientKerEquivRangeₐ φ)).comp (RingCon.mkₐ R (RingCon.ker ↑φ)) = φ.rangeRestrict | null | true |
NonUnitalStarRingHom.mk.sizeOf_spec | Mathlib.Algebra.Star.StarRingHom | ∀ {A : Type u_1} {B : Type u_2} [inst : NonUnitalNonAssocSemiring A] [inst_1 : Star A]
[inst_2 : NonUnitalNonAssocSemiring B] [inst_3 : Star B] [inst_4 : SizeOf A] [inst_5 : SizeOf B]
(toNonUnitalRingHom : A →ₙ+* B)
(map_star' : ∀ (a : A), toNonUnitalRingHom.toFun (star a) = star (toNonUnitalRingHom.toFun a)),
... | null | true |
CompHausLike.instPreservesLimitWalkingCospanCospanToCompHausLike | Mathlib.Topology.Category.CompHausLike.Limits | ∀ {P : TopCat → Prop} {X Y B : CompHausLike P} (f : X ⟶ B) (g : Y ⟶ B) [CompHausLike.HasExplicitPullback f g]
{P' : TopCat → Prop} (h : ∀ (X : CompHausLike P), P X.toTop → P' X.toTop),
CategoryTheory.Limits.PreservesLimit (CategoryTheory.Limits.cospan f g) (CompHausLike.toCompHausLike h) | The functor to another `CompHausLike` preserves pullbacks. | true |
CategoryTheory.Limits.ChosenPullback.p₁ | Mathlib.CategoryTheory.Limits.Shapes.Pullback.ChosenPullback | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
{X₁ X₂ S : C} →
{f₁ : X₁ ⟶ S} → {f₂ : X₂ ⟶ S} → (self : CategoryTheory.Limits.ChosenPullback f₁ f₂) → self.pullback ⟶ X₁ | the first projection | true |
groupHomology.indIso._proof_3 | Mathlib.RepresentationTheory.Homological.GroupHomology.Shapiro | ∀ {k G : Type u_1} [inst : CommRing k] [inst_1 : Group G] (S : Subgroup G),
CategoryTheory.Limits.HasZeroObject (Rep.{u_1, u_1, u_1} k ↥S) | null | false |
PolishSpace.measurableEquivNatBoolOfNotCountable._proof_2 | Mathlib.MeasureTheory.Constructions.Polish.Basic | ∀ {α : Type u_1} [inst : MeasurableSpace α] [StandardBorelSpace α], ¬Countable α → Nonempty (α ≃ᵐ (ℕ → Bool)) | null | false |
CategoryTheory.ShortComplex.fFunctor_map | Mathlib.Algebra.Homology.ShortComplex.Basic | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
{S T : CategoryTheory.ShortComplex C} (f : S ⟶ T),
CategoryTheory.ShortComplex.fFunctor.map f = CategoryTheory.Arrow.homMk f.τ₁ f.τ₂ ⋯ | null | true |
differentialIdeal_le_fractionalIdeal_iff | Mathlib.RingTheory.DedekindDomain.Different | ∀ {A : Type u_1} {K : Type u_2} {L : Type u} {B : Type u_3} [inst : CommRing A] [inst_1 : Field K] [inst_2 : CommRing B]
[inst_3 : Field L] [inst_4 : Algebra A K] [inst_5 : Algebra B L] [inst_6 : Algebra A B] [inst_7 : Algebra K L]
[inst_8 : Algebra A L] [inst_9 : IsScalarTower A K L] [inst_10 : IsScalarTower A B L... | null | true |
MeasureTheory.weightedSMul._proof_1 | Mathlib.MeasureTheory.Integral.Bochner.L1 | ∀ {F : Type u_1} [inst : NormedAddCommGroup F] [inst_1 : NormedSpace ℝ F], SMulCommClass ℝ ℝ F | null | false |
_private.Mathlib.CategoryTheory.Bicategory.Modification.Oplax.0.CategoryTheory.Oplax.LaxTrans.Modification.ext.match_1 | Mathlib.CategoryTheory.Bicategory.Modification.Oplax | ∀ {B : Type u_5} {inst : CategoryTheory.Bicategory B} {C : Type u_6} {inst_1 : CategoryTheory.Bicategory C}
{F G : CategoryTheory.OplaxFunctor B C} {η θ : F ⟶ G} (motive : CategoryTheory.Oplax.LaxTrans.Modification η θ → Prop)
(h : CategoryTheory.Oplax.LaxTrans.Modification η θ),
(∀ (app : (a : B) → η.app a ⟶ θ.a... | null | false |
Filter.map_mapsTo_Iic_iff_mapsTo | Mathlib.Order.Filter.Tendsto | ∀ {α : Type u_1} {β : Type u_2} {s : Set α} {t : Set β} {m : α → β},
Set.MapsTo (Filter.map m) (Set.Iic (Filter.principal s)) (Set.Iic (Filter.principal t)) ↔ Set.MapsTo m s t | null | true |
CategoryTheory.WithTerminal.opEquiv_counitIso_hom_app | Mathlib.CategoryTheory.WithTerminal.Basic | ∀ (C : Type u) [inst : CategoryTheory.Category.{v, u} C] (X : CategoryTheory.WithInitial Cᵒᵖ),
(CategoryTheory.WithTerminal.opEquiv C).counitIso.hom.app X =
(match X with
| CategoryTheory.WithInitial.of x => CategoryTheory.Iso.refl (CategoryTheory.WithInitial.of x)
| CategoryTheory.WithInitial.star =>... | null | true |
Int.ediv_mul | Init.Data.Int.DivMod.Lemmas | ∀ {x y z : ℤ}, x / (y * z) = x / y / z + if y < 0 ∧ ¬z ∣ x / y then z.sign else 0 | null | true |
_private.Mathlib.Algebra.Ring.Int.Parity.0.Int.natAbs_even._proof_1_1 | Mathlib.Algebra.Ring.Int.Parity | ∀ {n : ℤ}, Even n.natAbs ↔ Even n | null | false |
ModularForm.restrict_injective | Mathlib.NumberTheory.ModularForms.NormTrace | ∀ {𝒢 ℋ : Subgroup (GL (Fin 2) ℝ)} {k : ℤ} (hGH : 𝒢 ≤ ℋ), Function.Injective (ModularForm.restrict hGH) | null | true |
_private.Mathlib.RingTheory.Etale.QuasiFinite.0.Localization.exists_finite_awayMapₐ_of_surjective_awayMapₐ._simp_1_11 | Mathlib.RingTheory.Etale.QuasiFinite | ∀ {M : Type u_2} [inst : Monoid M] (a : M) (m n : ℕ), (a ^ m) ^ n = a ^ (m * n) | null | false |
TwoSidedIdeal.instNegSubtypeMem._proof_1 | Mathlib.RingTheory.TwoSidedIdeal.Basic | ∀ {R : Type u_1} [inst : NonUnitalNonAssocRing R] (I : TwoSidedIdeal R) (x : ↥I), -↑x ∈ I | null | false |
Lean.Lsp.InitializeResult.noConfusion | Lean.Data.Lsp.InitShutdown | {P : Sort u} → {t t' : Lean.Lsp.InitializeResult} → t = t' → Lean.Lsp.InitializeResult.noConfusionType P t t' | null | false |
FreeLieAlgebra.instZero | Mathlib.Algebra.Lie.Free | (R : Type u) → (X : Type v) → [inst : CommRing R] → Zero (FreeLieAlgebra R X) | null | true |
totallyBounded_interUnionBalls | Mathlib.Topology.UniformSpace.Cauchy | ∀ {α : Type u} [uniformSpace : UniformSpace α] {p : ℕ → Prop} {U : ℕ → SetRel α α},
(uniformity α).HasBasis p U → ∀ (xs : ℕ → α) (u : ℕ → ℕ), TotallyBounded (interUnionBalls xs u U) | null | true |
CategoryTheory.Limits.coker._proof_1 | Mathlib.CategoryTheory.Limits.Shapes.Kernels | ∀ (C : Type u_2) [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
[inst_2 : CategoryTheory.Limits.HasCokernels C] {f g : CategoryTheory.Arrow C} (u : f ⟶ g),
CategoryTheory.CategoryStruct.comp f.hom
(CategoryTheory.CategoryStruct.comp (CategoryTheory.Arrow.Hom.... | null | false |
Bool.bne_self_right | Init.Data.Bool | ∀ (a b : Bool), ((a != b) != b) = a | null | true |
CategoryTheory.Functor.ranCompLimIso_hom_app | Mathlib.CategoryTheory.Functor.KanExtension.Adjunction | ∀ {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] {H : Type u_3} [inst_2 : CategoryTheory.Category.{v_3, u_3} H]
(L : CategoryTheory.Functor C D) [inst_3 : ∀ (G : CategoryTheory.Functor C H), L.HasRightKanExtension G]
[inst_4 : CategoryTh... | null | true |
CategoryTheory.ShortComplex.RightHomologyData.canonical | Mathlib.Algebra.Homology.ShortComplex.Homology | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
[inst_1 : CategoryTheory.Limits.HasZeroMorphisms C] →
(S : CategoryTheory.ShortComplex C) → [S.HasHomology] → S.RightHomologyData | Given a short complex `S` such that `S.HasHomology`, this is the canonical
right homology data for `S` whose `Q` and `H` fields are
respectively `S.opcycles` and `S.homology`. | true |
String.toByteArray | Init.Prelude | String → ByteArray | The bytes of the UTF-8 encoding of the string. Since strings have a special representation in
the runtime, this function actually takes linear time and space at runtime. For efficient access
to the string's bytes, use `String.utf8ByteSize` and `String.getUTF8Byte`. | true |
VectorBundle.finrank_eq | Mathlib.Topology.VectorBundle.FiniteDimensional | ∀ (R : Type u_1) {B : Type u_2} (F : Type u_3) (E : B → Type u_4) [inst : NontriviallyNormedField R]
[inst_1 : TopologicalSpace B] [inst_2 : TopologicalSpace (Bundle.TotalSpace F E)] [inst_3 : NormedAddCommGroup F]
[inst_4 : NormedSpace R F] [inst_5 : (x : B) → TopologicalSpace (E x)] [inst_6 : FiberBundle F E]
[... | null | true |
_private.Lean.Meta.Tactic.Simp.BuiltinSimprocs.Fin.0.Fin.Value.mk.inj | Lean.Meta.Tactic.Simp.BuiltinSimprocs.Fin | ∀ {n : ℕ} {value : Fin n} {n_1 : ℕ} {value_1 : Fin n_1},
{ n := n, value := value } = { n := n_1, value := value_1 } → n = n_1 ∧ value ≍ value_1 | null | true |
stableUnderSpecialization_iUnion | Mathlib.Topology.Inseparable | ∀ {X : Type u_1} [inst : TopologicalSpace X] {ι : Sort u_7} (S : ι → Set X),
(∀ (i : ι), StableUnderSpecialization (S i)) → StableUnderSpecialization (⋃ i, S i) | null | true |
Lean.Elab.Tactic.RCases.RCasesPatt.clear.noConfusion | Lean.Elab.Tactic.RCases | {P : Sort u} →
{ref ref' : Lean.Syntax} →
Lean.Elab.Tactic.RCases.RCasesPatt.clear ref = Lean.Elab.Tactic.RCases.RCasesPatt.clear ref' → (ref = ref' → P) → P | null | false |
Equiv.funSplitAt | Mathlib.Logic.Equiv.Prod | {α : Type u_9} → [DecidableEq α] → (i : α) → (β : Type u_10) → (α → β) ≃ β × ({ j // j ≠ i } → β) | A product of copies of a type can be split as the binary product of one copy and the product
of all the remaining copies. | true |
Array.foldrM | Init.Data.Array.Basic | {α : Type u} →
{β : Type v} →
{m : Type v → Type w} → [Monad m] → (α → β → m β) → β → (as : Array α) → optParam ℕ as.size → optParam ℕ 0 → m β | Folds a monadic function over an array from the right, accumulating a value starting with `init`.
The accumulated value is combined with the each element of the list in reverse order, using `f`.
The optional parameters `start` and `stop` control the region of the array to be folded. Folding
proceeds from `start` (excl... | true |
Std.Tactic.BVDecide.LRAT.Internal.AssignValue.false | Std.Tactic.BVDecide.LRAT.Internal.Assignment | Std.Tactic.BVDecide.LRAT.Internal.AssignValue | null | true |
_private.Mathlib.Algebra.Polynomial.Roots.0.Polynomial.eq_zero_of_natDegree_lt_card_of_eval_eq_zero._simp_1_1 | Mathlib.Algebra.Polynomial.Roots | ∀ {α : Type u_1} {β : Type u_2} [inst : DecidableEq β] {f : α → β} {s : Finset α} {b : β},
(b ∈ Finset.image f s) = ∃ a ∈ s, f a = b | null | false |
_private.Mathlib.Data.Set.Finite.Basic.0.Set.infinite_union._simp_1_2 | Mathlib.Data.Set.Finite.Basic | ∀ {a b : Prop}, (¬(a ∧ b)) = (¬a ∨ ¬b) | null | false |
CategoryTheory.ShortComplex.leftHomologyπ_naturality'_assoc | Mathlib.Algebra.Homology.ShortComplex.LeftHomology | ∀ {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₁.LeftHomologyData) (h₂ : S₂.LeftHomologyData) {Z : C}
(h : h₂.H ⟶ Z),
CategoryTheory.CategoryStruct.comp h₁.π
(CategoryTheory.Categ... | null | true |
MeasureTheory.AEEqFun.ext | Mathlib.MeasureTheory.Function.AEEqFun | ∀ {α : Type u_1} {β : Type u_2} [inst : MeasurableSpace α] {μ : MeasureTheory.Measure α} [inst_1 : TopologicalSpace β]
{f g : α →ₘ[μ] β}, ↑f =ᵐ[μ] ↑g → f = g | null | true |
Subsemiring.copy_toSubmonoid | Mathlib.Algebra.Ring.Subsemiring.Defs | ∀ {R : Type u} [inst : NonAssocSemiring R] (S : Subsemiring R) (s : Set R) (hs : s = ↑S),
(S.copy s hs).toSubmonoid = { carrier := s, mul_mem' := ⋯, one_mem' := ⋯ } | null | true |
Std.Http.URI.Host.rec | Std.Http.Data.URI.Basic | {motive : Std.Http.URI.Host → Sort u} →
((name : Std.Http.URI.DomainName) → motive (Std.Http.URI.Host.name name)) →
((ipv4 : Std.Net.IPv4Addr) → motive (Std.Http.URI.Host.ipv4 ipv4)) →
((ipv6 : Std.Net.IPv6Addr) → motive (Std.Http.URI.Host.ipv6 ipv6)) → (t : Std.Http.URI.Host) → motive t | null | false |
Commute.conj_iff._simp_2 | Mathlib.Algebra.Group.Commute.Basic | ∀ {G : Type u_1} [inst : Group G] {a b : G} (h : G), Commute (h * a * h⁻¹) (h * b * h⁻¹) = Commute a b | null | false |
CategoryTheory.ObjectProperty.instSmallOppositeOp_1 | Mathlib.CategoryTheory.ObjectProperty.Small | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] (P : CategoryTheory.ObjectProperty C)
[CategoryTheory.ObjectProperty.Small.{w, v, u} P], CategoryTheory.ObjectProperty.Small.{w, v, u} P.op | null | true |
AEMeasurable.union | Mathlib.MeasureTheory.Measure.AEMeasurable | ∀ {α : Type u_2} {m0 : MeasurableSpace α} {μ : MeasureTheory.Measure α} {β : Type u_7} {f g : α → Set β},
AEMeasurable f μ → AEMeasurable g μ → AEMeasurable (fun a => f a ∪ g a) μ | null | true |
ContinuousMap.instSeminormedCommRing._proof_1 | Mathlib.Topology.ContinuousMap.Compact | ∀ {R : Type u_1} [inst : SeminormedCommRing R], IsTopologicalRing R | null | false |
CategoryTheory.sum.associativity._proof_1 | Mathlib.CategoryTheory.Sums.Associator | ∀ (C : Type u_2) [inst : CategoryTheory.Category.{u_4, u_2} C] (D : Type u_1)
[inst_1 : CategoryTheory.Category.{u_5, u_1} D] (E : Type u_3) [inst_2 : CategoryTheory.Category.{u_6, u_3} E]
(x : (C ⊕ D) ⊕ E),
CategoryTheory.CategoryStruct.comp
((CategoryTheory.sum.associator C D E).map
((CategoryTheo... | null | false |
Hypergraph.mk.inj | Mathlib.Combinatorics.Hypergraph.Basic | ∀ {α : Type u_4} {vertexSet : Set α} {edgeSet : Set (Set α)}
{subset_vertexSet_of_mem_edgeSet' : ∀ ⦃e : Set α⦄, e ∈ edgeSet → e ⊆ vertexSet} {vertexSet_1 : Set α}
{edgeSet_1 : Set (Set α)} {subset_vertexSet_of_mem_edgeSet'_1 : ∀ ⦃e : Set α⦄, e ∈ edgeSet_1 → e ⊆ vertexSet_1},
{ vertexSet := vertexSet, edgeSet := e... | null | true |
Lean.Compiler.LCNF.Check.Pure.Context.mk._flat_ctor | Lean.Compiler.LCNF.Check | Lean.FVarIdSet → Lean.FVarIdSet → Lean.Compiler.LCNF.Check.Pure.Context | null | false |
_private.Std.Tactic.BVDecide.LRAT.Internal.Rup.0.Std.Tactic.BVDecide.LRAT.Internal.State.propagateHints.match_5 | Std.Tactic.BVDecide.LRAT.Internal.Rup | (motive : Option Bool → Sort u_1) →
(x : Option Bool) → ((value : Bool) → motive (some value)) → (Unit → motive none) → motive x | null | false |
Module.AEval.instAddCommGroup._proof_11 | Mathlib.Algebra.Polynomial.Module.AEval | ∀ {R : Type u_1} {A : Type u_3} {M : Type u_2} [inst : CommSemiring R] [inst_1 : Semiring A] (a : A)
[inst_2 : Algebra R A] [inst_3 : AddCommGroup M] [inst_4 : Module A M] [inst_5 : Module R M]
[inst_6 : IsScalarTower R A M] (a_1 : Module.AEval R M a), -a_1 + a_1 = 0 | null | false |
_private.Mathlib.ModelTheory.Algebra.Field.CharP.0.FirstOrder.Field.charP_iff_model_fieldOfChar._simp_1_5 | Mathlib.ModelTheory.Algebra.Field.CharP | ∀ {L : FirstOrder.Language} {M : Type w} [inst : L.Structure M] {α : Type u'} {v : α → M}, ⊥.Realize v = False | null | false |
Lean.Doc.MathMode.recOn | Lean.DocString.Types | {motive : Lean.Doc.MathMode → Sort u} →
(t : Lean.Doc.MathMode) → motive Lean.Doc.MathMode.inline → motive Lean.Doc.MathMode.display → motive t | null | false |
ContinuousNeg.continuous_neg | Mathlib.Topology.Algebra.Group.Defs | ∀ {G : Type u} {inst : TopologicalSpace G} {inst_1 : Neg G} [self : ContinuousNeg G], Continuous fun a => -a | null | true |
CategoryTheory.ComposableArrows.mk₀ | Mathlib.CategoryTheory.ComposableArrows.Basic | {C : Type u_1} → [inst : CategoryTheory.Category.{v_1, u_1} C] → C → CategoryTheory.ComposableArrows C 0 | Constructor for `ComposableArrows C 0`. | true |
ProbabilityTheory.setBernoulli_real_singleton | Mathlib.Probability.Distributions.SetBernoulli | ∀ {ι : Type u_1} {s u : Set ι} [Countable ι] (p : ↑unitInterval),
s ⊆ u → u.Finite → (ProbabilityTheory.setBernoulli u p).real {s} = ↑p ^ s.ncard * (1 - ↑p) ^ (u \ s).ncard | null | true |
linearIndependent_le_basis | Mathlib.LinearAlgebra.Dimension.StrongRankCondition | ∀ {R : Type u} {M : Type v} [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M] [StrongRankCondition R]
{ι : Type w} (b : Module.Basis ι R M) {κ : Type w} (v : κ → M), LinearIndependent R v → Cardinal.mk κ ≤ Cardinal.mk ι | Over any ring `R` satisfying the strong rank condition,
if `b` is a basis for a module `M`,
and `s` is a linearly independent set,
then the cardinality of `s` is bounded by the cardinality of `b`.
| true |
MeasureTheory.diracProbaHomeomorph | Mathlib.MeasureTheory.Measure.DiracProba | {X : Type u_1} →
[inst : MeasurableSpace X] →
[inst_1 : TopologicalSpace X] →
[inst_2 : OpensMeasurableSpace X] →
[T0Space X] → [CompletelyRegularSpace X] → X ≃ₜ ↑(Set.range MeasureTheory.diracProba) | In a completely regular T0 topological space `X`, `diracProbaEquiv` is a homeomorphism to
its image in `ProbabilityMeasure X`. | true |
_private.Mathlib.Topology.UniformSpace.UniformConvergence.0.tendstoUniformlyOn_iff_tendsto._simp_1_1 | Mathlib.Topology.UniformSpace.UniformConvergence | ∀ {α : Type u_1} {β : Type u_2} {ι : Type u_4} [inst : UniformSpace β] {F : ι → α → β} {f : α → β} {s : Set α}
{p : Filter ι}, TendstoUniformlyOn F f p s = TendstoUniformlyOnFilter F f p (Filter.principal s) | null | false |
List.mapIdxMAux'.match_1 | Mathlib.Data.List.Defs | {α : Type u_1} →
(motive : ℕ → List α → Sort u_2) →
(x : ℕ) →
(x_1 : List α) → ((x : ℕ) → motive x []) → ((i : ℕ) → (a : α) → (as : List α) → motive i (a :: as)) → motive x x_1 | null | false |
CocompactMap.mk | Mathlib.Topology.ContinuousMap.CocompactMap | {α : Type u} →
{β : Type v} →
[inst : TopologicalSpace α] →
[inst_1 : TopologicalSpace β] →
(toContinuousMap : C(α, β)) →
Filter.Tendsto toContinuousMap.toFun (Filter.cocompact α) (Filter.cocompact β) → CocompactMap α β | null | true |
Shrink.instNSMul.eq_1 | Mathlib.Algebra.Group.Shrink | ∀ {M : Type u_1} {α : Type u_2} [inst : Small.{v, u_2} α] [inst_1 : SMul M α],
Shrink.instNSMul = Equiv.smul M (equivShrink α).symm | null | true |
Set.smul_set_inter | Mathlib.Algebra.Group.Action.Pointwise.Set.Basic | ∀ {α : Type u_2} {β : Type u_3} [inst : SMul α β] [IsLeftCancelSMul α β] {s t : Set β} {a : α},
a • (s ∩ t) = a • s ∩ a • t | null | true |
_private.Mathlib.AlgebraicGeometry.Morphisms.Separated.0.AlgebraicGeometry.Scheme.Pullback.diagonalCoverDiagonalRange_eq_top_of_injective._simp_1_5 | Mathlib.AlgebraicGeometry.Morphisms.Separated | ∀ {α : Type u_1} {β : α → Type u_4} {p : (a : α) × β a → Prop}, (∃ x, p x) = ∃ a b, p ⟨a, b⟩ | null | false |
NonUnitalSubalgebra.ext | Mathlib.Algebra.Algebra.NonUnitalSubalgebra | ∀ {R : Type u} {A : Type v} [inst : CommSemiring R] [inst_1 : NonUnitalNonAssocSemiring A] [inst_2 : Module R A]
{S T : NonUnitalSubalgebra R A}, (∀ (x : A), x ∈ S ↔ x ∈ T) → S = T | null | true |
Module.Dual.extendRCLikeₗ._proof_3 | Mathlib.Analysis.RCLike.Extend | ∀ {𝕜 : Type u_2} [inst : RCLike 𝕜] {F : Type u_1} [inst_1 : AddCommGroup F] [inst_2 : Module ℝ F] [inst_3 : Module 𝕜 F]
[inst_4 : IsScalarTower ℝ 𝕜 F] (m : ℝ) (x : Module.Dual ℝ F), (m • x).extendRCLike = (RingHom.id ℝ) m • x.extendRCLike | null | false |
CategoryTheory.Limits.reflectsLimit_of_unop | Mathlib.CategoryTheory.Limits.Preserves.Opposites | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
{J : Type w} [inst_2 : CategoryTheory.Category.{w', w} J] (K : CategoryTheory.Functor J Cᵒᵖ)
(F : CategoryTheory.Functor Cᵒᵖ Dᵒᵖ) [CategoryTheory.Limits.ReflectsColimit K.leftOp F.unop],
Categor... | If `F.unop : C ⥤ D` reflects colimits of `K.leftOp : Jᵒᵖ ⥤ C`, then `F : Cᵒᵖ ⥤ Dᵒᵖ` reflects
limits of `K : J ⥤ Cᵒᵖ`. | true |
BesselPotentialSpace._aux_Mathlib_Analysis_FunctionalSpaces_BesselPotentialSpace___unexpand_BesselPotentialSpace_3 | Mathlib.Analysis.FunctionalSpaces.BesselPotentialSpace | Lean.PrettyPrinter.Unexpander | null | false |
CategoryTheory.tensorRightHomEquiv_symm_coevaluation_comp_whiskerLeft | Mathlib.CategoryTheory.Monoidal.Rigid.Basic | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] [inst_1 : CategoryTheory.MonoidalCategory C] {X Y : C}
[inst_2 : CategoryTheory.HasLeftDual X] [inst_3 : CategoryTheory.HasLeftDual Y] (f : X ⟶ Y),
(CategoryTheory.tensorRightHomEquiv (CategoryTheory.MonoidalCategoryStruct.tensorUnit C) (ᘁY) Y ᘁX).symm
... | null | true |
Matrix.charpoly_fromBlocks_zero₂₁ | Mathlib.LinearAlgebra.Matrix.Charpoly.Basic | ∀ {R : Type u_1} [inst : CommRing R] {m : Type u_3} {n : Type u_4} [inst_1 : DecidableEq m] [inst_2 : DecidableEq n]
[inst_3 : Fintype m] [inst_4 : Fintype n] (M₁₁ : Matrix m m R) (M₁₂ : Matrix m n R) (M₂₂ : Matrix n n R),
(Matrix.fromBlocks M₁₁ M₁₂ 0 M₂₂).charpoly = M₁₁.charpoly * M₂₂.charpoly | null | true |
List.foldl | Init.Prelude | {α : Type u} → {β : Type v} → (α → β → α) → α → List β → α | Folds a function over a list from the left, accumulating a value starting with `init`. The
accumulated value is combined with the each element of the list in order, using `f`.
Examples:
* `[a, b, c].foldl f z = f (f (f z a) b) c`
* `[1, 2, 3].foldl (· ++ toString ·) "" = "123"`
* `[1, 2, 3].foldl (s!"({·} {·})") "... | true |
CategoryTheory.PreZeroHypercover.HasPullbacks | Mathlib.CategoryTheory.Sites.Hypercover.Zero | {C : Type u} → [inst : CategoryTheory.Category.{v, u} C] → {S : C} → CategoryTheory.PreZeroHypercover S → Prop | The assumption that the pullback of `X i₁` and `X i₂` over `S` exists
for any `i₁` and `i₂`. | true |
CommRingCat.Colimits.instCommRingColimitType._proof_25 | Mathlib.Algebra.Category.Ring.Colimits | ∀ {J : Type u_1} [inst : CategoryTheory.SmallCategory J] (F : CategoryTheory.Functor J CommRingCat)
(x y : CommRingCat.Colimits.ColimitType F), x * y = y * x | null | false |
PointedCone.maxTensorProduct_map_le | Mathlib.Geometry.Convex.Cone.TensorProduct | ∀ {R : Type u_1} [inst : CommRing R] [inst_1 : LinearOrder R] [inst_2 : IsStrictOrderedRing R] {G : Type u_2}
[inst_3 : AddCommGroup G] [inst_4 : Module R G] {H : Type u_3} [inst_5 : AddCommGroup H] [inst_6 : Module R H]
{G' : Type u_4} {H' : Type u_5} [inst_7 : AddCommGroup G'] [inst_8 : Module R G'] [inst_9 : Add... | `maxTensorProduct` is functorial: the image of a maximal tensor product under
`TensorProduct.map f g` is contained in the maximal tensor product of the images. | true |
Colex.instMonoid.eq_1 | Mathlib.Algebra.Order.Group.Synonym | ∀ {α : Type u_1} [inst : Monoid α],
Colex.instMonoid =
{ toOne := Colex.instOne, toMul := Colex.instMul, mul_assoc := ⋯, one_mul := ⋯, mul_one := ⋯, toNPow := NPow.ofPow,
npow_zero := ⋯, npow_succ := ⋯ } | null | true |
OrderHom.noConfusion | Mathlib.Order.Hom.Basic | {P : Sort u} →
{α : Type u_6} →
{β : Type u_7} →
{inst : Preorder α} →
{inst_1 : Preorder β} →
{t : α →o β} →
{α' : Type u_6} →
{β' : Type u_7} →
{inst' : Preorder α'} →
{inst'_1 : Preorder β'} →
{t' : α' →o β'... | null | false |
_private.Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.ShiftRight.0.Std.Tactic.BVDecide.BVExpr.bitblast.blastShiftRightConst.go_denote_eq._proof_1_1 | Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.ShiftRight | ∀ {w : ℕ} (distance curr idx : ℕ), curr = idx → ¬idx < curr + 1 → False | null | false |
Std.Tactic.BVDecide.Normalize.BitVec.mul_ones | Std.Tactic.BVDecide.Normalize.BitVec | ∀ {w : ℕ} (a : BitVec w), a * -1#w = -a | null | true |
HomotopicalAlgebra.ModelCategory.categoryWithFibrations._autoParam | Mathlib.AlgebraicTopology.ModelCategory.Basic | Lean.Syntax | null | false |
AffineBasis.linear_eq_sumCoords | Mathlib.LinearAlgebra.AffineSpace.Basis | ∀ {ι : Type u_1} {k : Type u_5} {V : Type u_6} {P : Type u_7} [inst : AddCommGroup V] [inst_1 : AddTorsor V P]
[inst_2 : Ring k] [inst_3 : Module k V] (b : AffineBasis ι k P) (i : ι), (b.coord i).linear = -(b.basisOf i).sumCoords | null | true |
TensorProduct.finsuppLeft._proof_4 | Mathlib.LinearAlgebra.DirectSum.Finsupp | ∀ (R : Type u_1) (S : Type u_2) [inst : CommSemiring R] [inst_1 : Semiring S] [inst_2 : Algebra R S] (M : Type u_3)
[inst_3 : AddCommMonoid M] [inst_4 : Module R M] [inst_5 : Module S M] [IsScalarTower R S M] (ι : Type u_4),
IsScalarTower R S (ι →₀ M) | null | false |
HomologicalComplex.mapBifunctorMapHomotopy.hom₁.eq_1 | Mathlib.Algebra.Homology.BifunctorHomotopy | ∀ {C₁ : Type u_1} {C₂ : Type u_2} {D : Type u_3} {I₁ : Type u_4} {I₂ : Type u_5} {J : Type u_6}
[inst : CategoryTheory.Category.{v_1, u_1} C₁] [inst_1 : CategoryTheory.Category.{v_2, u_2} C₂]
[inst_2 : CategoryTheory.Category.{v_3, u_3} D] [inst_3 : CategoryTheory.Preadditive C₁]
[inst_4 : CategoryTheory.Preaddit... | null | true |
List.flatMapM_subtype | Init.Data.List.Monadic | ∀ {m : Type u_1 → Type u_2} {α : Type u_3} {β : Type u_1} [inst : Monad m] [LawfulMonad m] {p : α → Prop}
{l : List { x // p x }} {f : { x // p x } → m (List β)} {g : α → m (List β)},
(∀ (x : α) (h : p x), f ⟨x, h⟩ = g x) → List.flatMapM f l = List.flatMapM g l.unattach | null | true |
CategoryTheory.AddMod.Hom.mk.inj | Mathlib.CategoryTheory.Monoidal.Mod | ∀ {C : Type u₁} {inst : CategoryTheory.Category.{v₁, u₁} C} {inst_1 : CategoryTheory.MonoidalCategory C} {D : Type u₂}
{inst_2 : CategoryTheory.Category.{v₂, u₂} D} {inst_3 : CategoryTheory.MonoidalCategory.MonoidalLeftAction C D}
{A : C} {inst_4 : CategoryTheory.AddMonObj A} {M N : CategoryTheory.AddMod D A} {hom ... | null | true |
CompHausLike.HasExplicitPullbacks.hasProp | Mathlib.Topology.Category.CompHausLike.Limits | ∀ {P : TopCat → Prop} [self : CompHausLike.HasExplicitPullbacks P] {X Y B : CompHausLike P} (f : X ⟶ B) (g : Y ⟶ B),
CompHausLike.HasExplicitPullback f g | null | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.