name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
CliffordAlgebra.map_apply_ι | Mathlib.LinearAlgebra.CliffordAlgebra.Basic | ∀ {R : Type u_1} [inst : CommRing R] {M₁ : Type u_4} {M₂ : Type u_5} [inst_1 : AddCommGroup M₁]
[inst_2 : AddCommGroup M₂] [inst_3 : Module R M₁] [inst_4 : Module R M₂] {Q₁ : QuadraticForm R M₁}
{Q₂ : QuadraticForm R M₂} (f : Q₁ →qᵢ Q₂) (m : M₁),
(CliffordAlgebra.map f) ((CliffordAlgebra.ι Q₁) m) = (CliffordAlgeb... | null | true |
LieModule.Weight.instInvolutiveNegSubtypeMemLieSubalgebra._proof_2 | Mathlib.Algebra.Lie.Weights.Killing | ∀ {K : Type u_1} {L : Type u_2} [inst : LieRing L] [inst_1 : Field K] [inst_2 : LieAlgebra K L]
[inst_3 : FiniteDimensional K L] [inst_4 : LieAlgebra.IsKilling K L] {H : LieSubalgebra K L}
[inst_5 : H.IsCartanSubalgebra] [inst_6 : LieModule.IsTriangularizable K (↥H) L] (α : LieModule.Weight K (↥H) L),
{ toFun := ... | null | false |
List.forall₂_map_left_iff._f | Mathlib.Data.List.Forall2 | ∀ {α : Type u_1} {β : Type u_2} {γ : Type u_3} {R : α → β → Prop} {f : γ → α} (x : List γ)
(f_1 :
List.below (motive := fun x =>
∀ (x_1 : List β), List.Forall₂ R (List.map f x) x_1 ↔ List.Forall₂ (fun c b => R (f c) b) x x_1) x)
(x_1 : List β), List.Forall₂ R (List.map f x) x_1 ↔ List.Forall₂ (fun c b => ... | null | false |
Filter.Tendsto.curry | Mathlib.Order.Filter.Curry | ∀ {α : Type u_1} {β : Type u_2} {γ : Type u_3} {f : α → β → γ} {la : Filter α} {lb : Filter β} {lc : Filter γ},
(∀ᶠ (a : α) in la, Filter.Tendsto (fun b => f a b) lb lc) → Filter.Tendsto (↿f) (la.curry lb) lc | null | true |
MeasurableSpace.DynkinSystem.restrictOn | Mathlib.MeasureTheory.PiSystem | {α : Type u_3} → (d : MeasurableSpace.DynkinSystem α) → {s : Set α} → d.Has s → MeasurableSpace.DynkinSystem α | If `s` is in a Dynkin system `d`, we can form the new Dynkin system `{s ∩ t | t ∈ d}`. | true |
MulEquiv.op._proof_1 | Mathlib.Algebra.Group.Equiv.Opposite | ∀ {α : Type u_1} {β : Type u_2} [inst : Mul α] [inst_1 : Mul β] (f : αᵐᵒᵖ ≃* βᵐᵒᵖ) (x : α),
(MulOpposite.unop ∘ ⇑f.symm ∘ MulOpposite.op) ((MulOpposite.unop ∘ ⇑f ∘ MulOpposite.op) x) = x | null | false |
Valuation.map_sub_of_left_eq_zero | Mathlib.RingTheory.Valuation.Basic | ∀ {R : Type u_3} {Γ₀ : Type u_4} [inst : Ring R] [inst_1 : LinearOrderedCommMonoidWithZero Γ₀] (v : Valuation R Γ₀)
{x y : R}, v x = 0 → v (x - y) = v y | null | true |
Int.toNat_of_nonpos | Init.Data.Int.Lemmas | ∀ {z : ℤ}, z ≤ 0 → z.toNat = 0 | null | true |
Std.TreeSet.ofList_nil | Std.Data.TreeSet.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering}, Std.TreeSet.ofList [] cmp = ∅ | null | true |
SimpleGraph.reachable_iff_nonempty_univ | Mathlib.Combinatorics.SimpleGraph.Connectivity.Connected | ∀ {V : Type u} {G : SimpleGraph V} {u v : V}, G.Reachable u v ↔ Set.univ.Nonempty | null | true |
_private.Std.Do.Triple.SpecLemmas.0.Std.Do.Spec.forIn'_roi._simp_1 | Std.Do.Triple.SpecLemmas | ∀ {α : Type u} {r : Std.Roi α} [inst : LT α] [inst_1 : Std.PRange.UpwardEnumerable α]
[inst_2 : Std.PRange.LawfulUpwardEnumerable α] [inst_3 : Std.Rxi.IsAlwaysFinite α]
[Std.PRange.LawfulUpwardEnumerableLT α] {a : α}, (a ∈ r) = (a ∈ r.toList) | null | false |
Multiset.sub_filter_eq_filter_not | Mathlib.Data.Multiset.Filter | ∀ {α : Type u_1} [inst : DecidableEq α] (p : α → Prop) [inst_1 : DecidablePred p] (s : Multiset α),
s - Multiset.filter p s = Multiset.filter (fun a => ¬p a) s | null | true |
_private.Mathlib.Topology.ContinuousOn.0.continuousWithinAt_prod_of_discrete_right._simp_1_2 | Mathlib.Topology.ContinuousOn | ∀ {α : Type u_1} {β : Type u_2} {f : α → β} {s : Set β} {l : Filter α},
Filter.map f l ⊓ Filter.principal s = Filter.map f (l ⊓ Filter.principal (f ⁻¹' s)) | null | false |
CategoryTheory.CostructuredArrow.prodEquivalence_unitIso | Mathlib.CategoryTheory.Comma.StructuredArrow.Basic | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
{C' : Type u₃} [inst_2 : CategoryTheory.Category.{v₃, u₃} C'] {D' : Type u₄}
[inst_3 : CategoryTheory.Category.{v₄, u₄} D'] (S : CategoryTheory.Functor C D) (S' : CategoryTheory.Functor C' D')
(... | null | true |
DFinsupp.toFinsupp_support | Mathlib.Data.Finsupp.ToDFinsupp | ∀ {ι : Type u_1} {M : Type u_3} [inst : DecidableEq ι] [inst_1 : Zero M] [inst_2 : (m : M) → Decidable (m ≠ 0)]
(f : Π₀ (x : ι), M), f.toFinsupp.support = f.support | null | true |
Int.reduceAdd | Lean.Meta.Tactic.Simp.BuiltinSimprocs.Int | Lean.Meta.Simp.DSimproc | null | true |
_private.Aesop.RuleTac.Forward.0.Aesop.RuleTac.makeForwardHypProofs._proof_3 | Aesop.RuleTac.Forward | ∀ (immediateMVars : Array Lean.MVarId) (i : ℕ),
immediateMVars.size > 0 ∧ i < immediateMVars.size → ¬immediateMVars.size - 1 - i < immediateMVars.size → False | null | false |
CategoryTheory.FreeMonoidalCategory.Hom.l_hom.sizeOf_spec | Mathlib.CategoryTheory.Monoidal.Free.Basic | ∀ {C : Type u} [inst : SizeOf C] (X : CategoryTheory.FreeMonoidalCategory C),
sizeOf (CategoryTheory.FreeMonoidalCategory.Hom.l_hom X) = 1 + sizeOf X | null | true |
CategoryTheory.Equivalence.leftOp_inverse_obj | Mathlib.CategoryTheory.Opposites | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
(e : C ≌ Dᵒᵖ) (X : D), e.leftOp.inverse.obj X = Opposite.op (e.inverse.obj (Opposite.op X)) | null | true |
CategoryTheory.PreZeroHypercover.fromShrink | Mathlib.CategoryTheory.Sites.Hypercover.Zero | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] → {S : C} → (E : CategoryTheory.PreZeroHypercover S) → E.shrink.Hom E | The deduplication of `E` refines `E`. | true |
MaxTropical.instDivOfSub.eq_1 | Mathlib.Algebra.Tropical.Basic | ∀ {R : Type u} [inst : Sub R],
MaxTropical.instDivOfSub = { div := fun x y => MaxTropical.trop (MaxTropical.untrop x - MaxTropical.untrop y) } | null | true |
Lean.AsyncList.brecOn_3 | Lean.Server.AsyncList | {ε : Type u} →
{α : Type v} →
{motive_1 : Lean.AsyncList ε α → Sort u_1} →
{motive_2 : Lean.Server.ServerTask (Except ε (Lean.AsyncList ε α)) → Sort u_1} →
{motive_3 : Task (Except ε (Lean.AsyncList ε α)) → Sort u_1} →
{motive_4 : Except ε (Lean.AsyncList ε α) → Sort u_1} →
(t ... | null | false |
_private.Mathlib.Data.List.Basic.0.List.subset_singleton_iff._simp_1_3 | Mathlib.Data.List.Basic | ∀ {α : Type u_1} {a b : α}, (a ∈ [b]) = (a = b) | null | false |
Std.Http.Header.Expect | Std.Http.Data.Headers.Basic | Type | The `Expect` header.
Represents an expectation token.
The only standardized expectation is `100-continue`.
Reference: https://www.rfc-editor.org/rfc/rfc9110.html#name-expect
| true |
Matroid.RankFinite.mk._flat_ctor | Mathlib.Combinatorics.Matroid.Basic | ∀ {α : Type u_1} {M : Matroid α}, (∃ B, M.IsBase B ∧ B.Finite) → M.RankFinite | null | false |
_private.Mathlib.ModelTheory.Semantics.0.FirstOrder.Language.Sentence.realize_cardGe._simp_1_6 | Mathlib.ModelTheory.Semantics | ∀ {n : ℕ} (x : Fin n), (x ∈ List.finRange n) = True | null | false |
contMDiffWithinAt_iff_source_of_mem_maximalAtlas | Mathlib.Geometry.Manifold.ContMDiff.Defs | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {H : Type u_3} [inst_3 : TopologicalSpace H] {I : ModelWithCorners 𝕜 E H} {M : Type u_4}
[inst_4 : TopologicalSpace M] [inst_5 : ChartedSpace H M] {E' : Type u_5} [inst_6 : NormedAddComm... | null | true |
BitVec.cpopLayer._unary._proof_1 | Init.Data.BitVec.Bitblast | ∀ {len w : ℕ} (oldLayer : BitVec (len * w)) (iterNum : ℕ) (newLayer : BitVec (iterNum * w))
(hold : 2 * (iterNum - 1) < len) (hlen : ¬len - iterNum * 2 = 0) (hcast : w + iterNum * w = (iterNum + 1) * w),
InvImage (fun x1 x2 => x1 < x2)
(fun x => PSigma.casesOn x fun iterNum newLayer => PSigma.casesOn newLayer f... | null | false |
_private.Init.Data.List.Zip.0.List.map_fst_zip.match_1_1 | Init.Data.List.Zip | ∀ {α : Type u_1} {β : Type u_2} (motive : (x : List α) → (x_1 : List β) → x.length ≤ x_1.length → Prop) (x : List α)
(x_1 : List β) (x_2 : x.length ≤ x_1.length),
(∀ (x : List β) (x_3 : [].length ≤ x.length), motive [] x x_3) →
(∀ (head : α) (as : List α) (head_1 : β) (bs : List β) (h : (head :: as).length ≤ (h... | null | false |
instNoMaxOrderForallOfNonempty | Mathlib.Order.Max | ∀ {ι : Type u} {π : ι → Type u_3} [Nonempty ι] [inst : (i : ι) → Preorder (π i)] [∀ (i : ι), NoMaxOrder (π i)],
NoMaxOrder ((i : ι) → π i) | null | true |
Std.Time.Minute.Offset | Std.Time.Time.Unit.Minute | Type | `Offset` represents a duration offset in minutes.
| true |
SymbolicDynamics.FullShift.MulSubshift.mk._flat_ctor | Mathlib.Dynamics.SymbolicDynamics.Basic | {A : Type u_1} →
[inst : TopologicalSpace A] →
{G : Type u_2} →
[inst_1 : Monoid G] →
(carrier : Set (G → A)) →
IsClosed carrier →
(∀ (g : G), Set.MapsTo (SymbolicDynamics.FullShift.mulShift g) carrier carrier) →
SymbolicDynamics.FullShift.MulSubshift A G | null | false |
CategoryTheory.Adjunction.mkOfUnitCounit_counit | Mathlib.CategoryTheory.Adjunction.Basic | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
{F : CategoryTheory.Functor C D} {G : CategoryTheory.Functor D C}
(adj : CategoryTheory.Adjunction.CoreUnitCounit F G),
(CategoryTheory.Adjunction.mkOfUnitCounit adj).counit = adj.counit | null | true |
OpenPartialHomeomorph.EqOnSource.target_eq | Mathlib.Topology.OpenPartialHomeomorph.IsImage | ∀ {X : Type u_1} {Y : Type u_2} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y]
{e e' : OpenPartialHomeomorph X Y}, e ≈ e' → e.target = e'.target | Two equivalent open partial homeomorphisms have the same target. | true |
HomologicalComplex.restrictionCyclesIso | Mathlib.Algebra.Homology.Embedding.RestrictionHomology | {ι : Type u_1} →
{ι' : Type u_2} →
{c : ComplexShape ι} →
{c' : ComplexShape ι'} →
{C : Type u_3} →
[inst : CategoryTheory.Category.{v_1, u_3} C] →
[inst_1 : CategoryTheory.Limits.HasZeroMorphisms C] →
(K : HomologicalComplex C c') →
(e : c.Embeddi... | The isomorphism `(K.restriction e).cycles j ≅ K.cycles j'` when `e.f j = j'`
and the successors `k` and `k'` of `j` and `j'` satisfy `e.f k = k'`. | true |
Mathlib.Tactic.Ring.Common.evalPow₁._unsafe_rec | Mathlib.Tactic.Ring.Common | {u : Lean.Level} →
{α : Q(Type u)} →
{bt : Q(«$α») → Type} →
{sα : Q(CommSemiring «$α»)} →
Mathlib.Tactic.Ring.Common.RingCompute bt sα →
Mathlib.Tactic.Ring.Common.RingCompute Mathlib.Tactic.Ring.Common.btℕ Mathlib.Tactic.Ring.Common.sℕ →
{a : Q(«$α»)} →
{b : Q(ℕ... | null | false |
Ioo_mem_nhdsLT | Mathlib.Topology.Order.OrderClosed | ∀ {α : Type u} [inst : TopologicalSpace α] [inst_1 : LinearOrder α] [ClosedIicTopology α] {a b : α},
a < b → Set.Ioo a b ∈ nhdsWithin b (Set.Iio b) | null | true |
intervalIntegral.derivWithin_integral_right._auto_1 | Mathlib.MeasureTheory.Integral.IntervalIntegral.FundThmCalculus | Lean.Syntax | null | false |
DifferentiableAt.smul | Mathlib.Analysis.Calculus.FDeriv.Mul | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {F : Type u_3} [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace 𝕜 F] {f : E → F}
{x : E} {𝕜' : Type u_4} [inst_5 : NormedRing 𝕜'] [inst_6 : NormedAlgebra 𝕜 𝕜'] [inst_7 : Module ... | null | true |
HomologicalComplex.instSubHom | Mathlib.Algebra.Homology.Additive | {ι : Type u_1} →
{V : Type u} →
[inst : CategoryTheory.Category.{v, u} V] →
[inst_1 : CategoryTheory.Preadditive V] → {c : ComplexShape ι} → {C D : HomologicalComplex V c} → Sub (C ⟶ D) | null | true |
_private.Lean.Meta.Tactic.Repeat.0.Lean.Meta.repeat'Core.go.match_3.eq_1 | Lean.Meta.Tactic.Repeat | ∀ (motive : ℕ → Sort u_1) (h_1 : Unit → motive 0) (h_2 : (n : ℕ) → motive n.succ),
(match 0 with
| 0 => h_1 ()
| n.succ => h_2 n) =
h_1 () | null | true |
CategoryTheory.Join.costructuredArrowEquiv._proof_10 | Mathlib.CategoryTheory.Join.Final | ∀ (C : Type u_3) (D : Type u_4) [inst : CategoryTheory.Category.{u_1, u_3} C]
[inst_1 : CategoryTheory.Category.{u_2, u_4} D] (d : D)
(X : CategoryTheory.CostructuredArrow (CategoryTheory.Join.inclLeft C D) (CategoryTheory.Join.right d)),
CategoryTheory.CategoryStruct.comp
((CategoryTheory.CostructuredArrow... | null | false |
CategoryTheory.Limits.MultispanIndex.ofSigmaCoforkFunctor._proof_1 | Mathlib.CategoryTheory.Limits.Shapes.Multiequalizer | ∀ {C : Type u_4} [inst : CategoryTheory.Category.{u_3, u_4} C] {J : CategoryTheory.Limits.MultispanShape}
(I : CategoryTheory.Limits.MultispanIndex J C) {c : CategoryTheory.Limits.Cofan I.left}
(hc : CategoryTheory.Limits.IsColimit c) {d : CategoryTheory.Limits.Cofan I.right}
{K₁ K₂ : CategoryTheory.Limits.Cofork... | null | false |
AddChar.PrimitiveAddChar.recOn | Mathlib.NumberTheory.LegendreSymbol.AddCharacter | {R : Type u} →
[inst : CommRing R] →
{R' : Type v} →
[inst_1 : Field R'] →
{motive : AddChar.PrimitiveAddChar R R' → Sort u_1} →
(t : AddChar.PrimitiveAddChar R R') →
((n : ℕ+) →
(char : AddChar R (CyclotomicField (↑n) R')) →
(prim : char.IsPri... | null | false |
AffineIsometry.linear_eq_linearIsometry | Mathlib.Analysis.Normed.Affine.Isometry | ∀ {𝕜 : Type u_1} {V : Type u_2} {V₂ : Type u_4} {P : Type u_7} {P₂ : Type u_8} [inst : NormedField 𝕜]
[inst_1 : SeminormedAddCommGroup V] [inst_2 : NormedSpace 𝕜 V] [inst_3 : PseudoMetricSpace P]
[inst_4 : NormedAddTorsor V P] [inst_5 : SeminormedAddCommGroup V₂] [inst_6 : NormedSpace 𝕜 V₂]
[inst_7 : PseudoMe... | null | true |
_private.Std.Data.Internal.List.Associative.0.Std.Internal.List.getValueCast._proof_1 | Std.Data.Internal.List.Associative | ∀ {α : Type u_2} {β : α → Type u_1} [inst : BEq α] [inst_1 : LawfulBEq α] (a : α) (l : List ((a : α) × β a)),
Std.Internal.List.containsKey a l = true → (Std.Internal.List.getValueCast? a l).isSome = true | null | false |
_private.Mathlib.Tactic.ComputeAsymptotics.Multiseries.Monomial.Predicates.0.Tactic.ComputeAsymptotics.UnitMonomial.FirstNonzeroIsNeg.cons_iff._proof_1_5 | Mathlib.Tactic.ComputeAsymptotics.Multiseries.Monomial.Predicates | ∀ {hd : ℝ} {tl : Tactic.ComputeAsymptotics.UnitMonomial},
Tactic.ComputeAsymptotics.UnitMonomial.FirstNonzeroIsNeg (hd :: tl) ↔ hd < 0 ∨ hd = 0 ∧ tl.FirstNonzeroIsNeg | null | false |
norm_root_X_pow_sub_C | Mathlib.FieldTheory.KummerExtension | ∀ {K : Type u} [inst : Field K] {n : ℕ} {a : K},
n ≠ 0 → (Algebra.norm K) (AdjoinRoot.root (Polynomial.X ^ n - Polynomial.C a)) = (-1) ^ n * -a | null | true |
PreQuasiregular.equiv_apply_val | Mathlib.Algebra.Algebra.Spectrum.Quasispectrum | ∀ {R : Type u_1} (val : R), (PreQuasiregular.equiv val).val = val | null | true |
Lean.AttributeApplicationTime.ctorElim | Lean.Attributes | {motive : Lean.AttributeApplicationTime → Sort u} →
(ctorIdx : ℕ) →
(t : Lean.AttributeApplicationTime) →
ctorIdx = t.ctorIdx → Lean.AttributeApplicationTime.ctorElimType ctorIdx → motive t | null | false |
IsUltrametricDist.norm_prod_le_of_forall_le_of_nonneg | Mathlib.Analysis.Normed.Group.Ultra | ∀ {M : Type u_1} {ι : Type u_2} [inst : SeminormedCommGroup M] [IsUltrametricDist M] {s : Finset ι} {f : ι → M} {C : ℝ},
0 ≤ C → (∀ i ∈ s, ‖f i‖ ≤ C) → ‖∏ i ∈ s, f i‖ ≤ C | Generalised ultrametric triangle inequality for finite products in commutative groups with
an ultrametric norm.
| true |
_private.Init.Data.String.Lemmas.Pattern.TakeDrop.Basic.0.String.Slice.Pattern.Model.Pos.skip?_eq_none_iff._simp_1_2 | Init.Data.String.Lemmas.Pattern.TakeDrop.Basic | ∀ {ρ : Type} {pat : ρ} [inst : String.Slice.Pattern.Model.PatternModel pat] {s : String.Slice} {base : s.Pos}
{pos : (s.sliceFrom base).Pos},
String.Slice.Pattern.Model.MatchesAt pat pos =
String.Slice.Pattern.Model.MatchesAt pat (String.Slice.Pos.ofSliceFrom pos) | null | false |
IsLocalizedModule.liftOfLE | Mathlib.Algebra.Module.LocalizedModule.Basic | {R : Type u_1} →
[inst : CommSemiring R] →
{M : Type u_2} →
[inst_1 : AddCommMonoid M] →
[inst_2 : Module R M] →
{M₁ : Type u_6} →
{M₂ : Type u_7} →
[inst_3 : AddCommMonoid M₁] →
[inst_4 : AddCommMonoid M₂] →
[inst_5 : Module R M₁... | The natural map `Mₛ →ₗ[R] Mₜ` if `s ≤ t` (in `Submonoid R`). | true |
Std.DTreeMap.Internal.Impl.insertMax._unsafe_rec | Std.Data.DTreeMap.Internal.Operations | {α : Type u} →
{β : α → Type v} →
(k : α) → β k → (t : Std.DTreeMap.Internal.Impl α β) → t.Balanced → Std.DTreeMap.Internal.Impl.Tree α β (t.size + 1) | null | false |
RootPairing.PolarizationIn.eq_1 | Mathlib.LinearAlgebra.RootSystem.Finite.CanonicalBilinear | ∀ {ι : Type u_1} {R : Type u_2} {M : Type u_3} {N : Type u_4} [inst : CommRing R] [inst_1 : AddCommGroup M]
[inst_2 : Module R M] [inst_3 : AddCommGroup N] [inst_4 : Module R N] (P : RootPairing ι R M N) (S : Type u_5)
[inst_5 : CommRing S] [inst_6 : Algebra S R] [inst_7 : FaithfulSMul S R] [inst_8 : Module S M]
... | null | true |
FunLike.coe_vadd | Mathlib.Algebra.Group.IsApply | ∀ {M : Type u_1} {F : Type u_2} {α : Type u_4} {β : Type u_5} [inst : FunLike F α β] [inst_1 : VAdd M F]
[inst_2 : VAdd M β] [IsVAddApply M F α β] (n : M) (f : F), ⇑(n +ᵥ f) = n +ᵥ ⇑f | null | true |
countablyGenerated_of_standardBorel | Mathlib.MeasureTheory.Constructions.Polish.Basic | ∀ {α : Type u_1} [inst : MeasurableSpace α] [StandardBorelSpace α], MeasurableSpace.CountablyGenerated α | null | true |
exists_isLocalExtr_Ioo | Mathlib.Topology.Order.Rolle | ∀ {X : Type u_1} {Y : Type u_2} [inst : ConditionallyCompleteLinearOrder X] [DenselyOrdered X]
[inst_2 : TopologicalSpace X] [OrderTopology X] [inst_4 : LinearOrder Y] [inst_5 : TopologicalSpace Y]
[OrderTopology Y] {f : X → Y} {a b : X},
a < b → ContinuousOn f (Set.Icc a b) → f a = f b → ∃ c ∈ Set.Ioo a b, IsLoc... | A continuous function on a closed interval with `f a = f b`
has a local extremum at some point of the corresponding open interval. | true |
isOpen_iff_ultrafilter' | Mathlib.Topology.Separation.Hausdorff | ∀ {X : Type u_1} [inst : TopologicalSpace X] [T2Space X] [CompactSpace X] (U : Set X),
IsOpen U ↔ ∀ (F : Ultrafilter X), F.lim ∈ U → U ∈ ↑F | null | true |
Not.imp | Init.Core | ∀ {a b : Prop}, ¬b → (a → b) → ¬a | null | true |
Turing.PartrecToTM2.natEnd.eq_3 | Mathlib.Computability.TuringMachine.ToPartrec | ∀ (x : Turing.PartrecToTM2.Γ'),
(x = Turing.PartrecToTM2.Γ'.consₗ → False) →
(x = Turing.PartrecToTM2.Γ'.cons → False) → Turing.PartrecToTM2.natEnd x = false | null | true |
Matrix.instAddRightCancelSemigroup._proof_1 | Mathlib.LinearAlgebra.Matrix.Defs | ∀ {m : Type u_1} {n : Type u_2} {α : Type u_3} [inst : AddRightCancelSemigroup α], IsRightCancelAdd (Matrix m n α) | null | false |
Order.cof_eq | Mathlib.SetTheory.Cardinal.Cofinality.Basic | ∀ (α : Type u) [inst : Preorder α], ∃ s, IsCofinal s ∧ Cardinal.mk ↑s = Order.cof α | **Alias** of `Order.exists_cof_eq`.
---
Every well-order has a cofinal subset of cardinal `cof α`. | true |
Order.le_pred_iff | Mathlib.Order.SuccPred.Basic | ∀ {α : Type u_1} [inst : Preorder α] [inst_1 : PredOrder α] {a b : α} [NoMinOrder α], b ≤ Order.pred a ↔ b < a | null | true |
CategoryTheory.Adjunction.leftAdjointCompNatTrans.eq_1 | Mathlib.CategoryTheory.Adjunction.CompositionIso | ∀ {C₀ : Type u_1} {C₁ : Type u_2} {C₂ : Type u_3} [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} C₂]
{F₀₁ : CategoryTheory.Functor C₀ C₁} {F₁₂ : CategoryTheory.Functor C₁ C₂} {F₀₂ : CategoryTheory.Functor C₀ C₂}
{G₁₀ : C... | null | true |
_private.Init.Data.List.Sublist.0.List.Sublist.eq_of_length.match_1_1 | Init.Data.List.Sublist | ∀ (motive : False → Prop) (x : False), motive x | null | false |
_private.Std.Data.Iterators.Lemmas.Combinators.Zip.0.Std.IterM.step_intermediateZip.match_3.eq_2 | Std.Data.Iterators.Lemmas.Combinators.Zip | ∀ {α₁ β₁ : Type u_1} {m : Type u_1 → Type u_2} [inst : Std.Iterator α₁ m β₁]
(motive : Option { out // ∃ it, it.IsPlausibleOutput out } → Sort u_3)
(out₁ : { out // ∃ it, it.IsPlausibleOutput out }) (h_1 : Unit → motive none)
(h_2 : (out₁ : { out // ∃ it, it.IsPlausibleOutput out }) → motive (some out₁)),
(matc... | null | true |
_private.Mathlib.SetTheory.Cardinal.Subfield.0.Subfield.rangeOfWType._proof_2 | Mathlib.SetTheory.Cardinal.Subfield | ∀ {α : Type u_1} (s : Set α) [inst : DivisionRing α],
∃ y, WType.elim (↥(Subfield.closure s)) (Subfield.operate✝ s) y = 1 | null | false |
CategoryTheory.Limits.biprod.map_snd_assoc | Mathlib.CategoryTheory.Limits.Shapes.BinaryBiproducts | ∀ {C : Type uC} [inst : CategoryTheory.Category.{uC', uC} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
{W X Y Z : C} [inst_2 : CategoryTheory.Limits.HasBinaryBiproduct W X]
[inst_3 : CategoryTheory.Limits.HasBinaryBiproduct Y Z] (f : W ⟶ Y) (g : X ⟶ Z) {Z_1 : C} (h : Z ⟶ Z_1),
CategoryTheory.CategoryStr... | null | true |
InformationTheory.integral_llr_compProd_eq_add | Mathlib.InformationTheory.KullbackLeibler.ChainRule | ∀ {𝓧 : Type u_1} {𝓨 : Type u_2} {m𝓧 : MeasurableSpace 𝓧} {m𝓨 : MeasurableSpace 𝓨} {μ ν : MeasureTheory.Measure 𝓧}
{κ η : ProbabilityTheory.Kernel 𝓧 𝓨} [MeasureTheory.IsFiniteMeasure μ] [MeasureTheory.IsFiniteMeasure ν]
[ProbabilityTheory.IsMarkovKernel κ] [ProbabilityTheory.IsMarkovKernel η],
(μ.compProd... | Chain rule for the integral of the log-likelihood ratio, under absolute continuity and
integrability assumptions. | true |
Lean.Grind.CommRing.Poly.mulMon.go.eq_def | Init.Grind.Ring.CommSolver | ∀ (k : ℤ) (m : Lean.Grind.CommRing.Mon) (a : Lean.Grind.CommRing.Poly),
Lean.Grind.CommRing.Poly.mulMon.go k m a =
match a with
| Lean.Grind.CommRing.Poly.num k' =>
bif k' == 0 then Lean.Grind.CommRing.Poly.num 0
else Lean.Grind.CommRing.Poly.add (k * k') m (Lean.Grind.CommRing.Poly.num 0)
| L... | null | true |
WithBot.unbot_one | Mathlib.Algebra.Order.Monoid.Unbundled.WithTop | ∀ {α : Type u} [inst : One α], WithBot.unbot 1 ⋯ = 1 | null | true |
NormedRing.sub._inherited_default | Mathlib.Analysis.Normed.Ring.Basic | {α : Type u_5} →
(zero : α) →
(add : α → α → α) →
(∀ (a b c : α), a + b + c = a + (b + c)) →
(∀ (a : α), 0 + a = a) →
(∀ (a : α), a + 0 = a) →
(nsmul : ℕ → α → α) →
(∀ (x : α), 0 • x = 0) → (∀ (n : ℕ) (x : α), (n + 1) • x = n • x + x) → (α → α) → α → α → α | null | false |
_private.Lean.Meta.Tactic.Simp.Simproc.0.Lean.Meta.Simp.initFn._@.Lean.Meta.Tactic.Simp.Simproc.1207380286._hygCtx._hyg.2 | Lean.Meta.Tactic.Simp.Simproc | IO (IO.Ref Lean.Meta.Simprocs) | null | false |
add_neg_le_neg_add_iff | Mathlib.Algebra.Order.Group.Unbundled.Basic | ∀ {α : Type u} [inst : AddGroup α] [inst_1 : LE α] [AddLeftMono α] {a b c d : α} [AddRightMono α],
a + -b ≤ -d + c ↔ d + a ≤ c + b | null | true |
Lean.Compiler.LCNF.Simp.Config.mk | Lean.Compiler.LCNF.Simp.Config | Bool → Bool → Bool → Bool → Lean.Compiler.LCNF.Simp.Config | null | true |
CategoryTheory.MonoidalCategory.MonoidalRightAction.«term_⊙ᵣ_» | Mathlib.CategoryTheory.Monoidal.Action.Basic | Lean.TrailingParserDescr | Notation for `actionObj`, the action of `C` on `D`. | true |
ContDiffMapSupportedIn.instZero | Mathlib.Analysis.Distribution.ContDiffMapSupportedIn | {E : Type u_2} →
{F : Type u_3} →
[inst : NormedAddCommGroup E] →
[inst_1 : NormedSpace ℝ E] →
[inst_2 : NormedAddCommGroup F] →
[inst_3 : NormedSpace ℝ F] →
{n : ℕ∞} → {K : TopologicalSpace.Compacts E} → Zero (ContDiffMapSupportedIn E F n K) | null | true |
ClassGroup.fintypeOfAdmissibleOfFinite._proof_5 | Mathlib.NumberTheory.ClassNumber.Finite | ∀ {R : Type u_2} {S : Type u_3} (K : Type u_4) (L : Type u_1) [inst : EuclideanDomain R] [inst_1 : CommRing S]
[inst_2 : Field K] [inst_3 : Field L] [inst_4 : Algebra R K] [IsFractionRing R K] [inst_6 : Algebra K L]
[inst_7 : FiniteDimensional K L] [inst_8 : Algebra.IsSeparable K L] [algRL : Algebra R L] [IsScalarT... | null | false |
_private.Mathlib.Algebra.Homology.HomotopyCategory.HomComplexSingle.0.CochainComplex.HomComplex.Cocycle.toSingleMk._proof_1 | Mathlib.Algebra.Homology.HomotopyCategory.HomComplexSingle | ∀ {p q n : ℤ}, p + n = q → ∀ (p' : ℤ), p' + 1 = p → p' + (n + 1) = q | null | false |
Lean.Elab.ConfigEval.ConfigItem.shift | Lean.Elab.ConfigEval.Basic | Lean.Elab.ConfigEval.ConfigItem → Lean.Elab.ConfigEval.ConfigItem | Drops the first component of the `optionName`, returning the new config item.
The first component is stored at the front of `prevOptionComps`.
| true |
BitVec.signExtend_eq_setWidth_of_msb_false | Init.Data.BitVec.Lemmas | ∀ {w : ℕ} {x : BitVec w} {v : ℕ}, x.msb = false → BitVec.signExtend v x = BitVec.setWidth v x | The sign extension is the same as zero extending when `msb = false`. | true |
SimplexCategory.eq_σ_comp_of_not_injective' | Mathlib.AlgebraicTopology.SimplexCategory.Basic | ∀ {n : ℕ} {Δ' : SimplexCategory} (θ : { len := n + 1 } ⟶ Δ') (i : Fin (n + 1)),
(SimplexCategory.Hom.toOrderHom θ) i.castSucc = (SimplexCategory.Hom.toOrderHom θ) i.succ →
∃ θ', θ = CategoryTheory.CategoryStruct.comp (SimplexCategory.σ i) θ' | null | true |
Lean.Elab.WhereFinallyView.noConfusionType | Lean.Elab.WhereFinally | Sort u → Lean.Elab.WhereFinallyView → Lean.Elab.WhereFinallyView → Sort u | null | false |
measurable_findGreatest' | Mathlib.MeasureTheory.MeasurableSpace.Constructions | ∀ {α : Type u_1} {mα : MeasurableSpace α} {p : α → ℕ → Prop} [inst : (x : α) → DecidablePred (p x)] {N : ℕ},
(∀ k ≤ N, MeasurableSet {x | Nat.findGreatest (p x) N = k}) → Measurable fun x => Nat.findGreatest (p x) N | null | true |
SubAddAction.carrier | Mathlib.GroupTheory.GroupAction.SubMulAction | {R : Type u} → {M : Type v} → [inst : VAdd R M] → SubAddAction R M → Set M | The underlying set of a `SubAddAction`. | true |
CategoryTheory.whiskeringRightCompEvaluation_hom_app | Mathlib.CategoryTheory.Products.Basic | ∀ {A : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} A] {B : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} B]
{C : Type u₃} [inst_2 : CategoryTheory.Category.{v₃, u₃} C] (F : CategoryTheory.Functor B C) (a : A)
(X : CategoryTheory.Functor A B),
(CategoryTheory.whiskeringRightCompEvaluation F a).hom.app ... | null | true |
Algebra.lmul_injective | Mathlib.Algebra.Algebra.Bilinear | ∀ {R : Type u_1} {A : Type u_2} [inst : CommSemiring R] [inst_1 : Semiring A] [inst_2 : Algebra R A],
Function.Injective ⇑(Algebra.lmul R A) | null | true |
CategoryTheory.Adjunction.homEquiv_ofNatIsoRight_symm_apply._to_dual_1 | Mathlib.CategoryTheory.Adjunction.Basic | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
{F : CategoryTheory.Functor C D} {G H : CategoryTheory.Functor D C} (adj : G ⊣ F) (iso : G ≅ H) {X : C} {Y : D}
(f : H.obj Y ⟶ X),
((adj.ofNatIsoLeft iso).homEquiv' X Y).symm f =
(adj.homEqu... | null | false |
EisensteinSeries.eisSummand_extension_differentiableOn | Mathlib.NumberTheory.ModularForms.EisensteinSeries.MDifferentiable | ∀ (k : ℤ) (a : Fin 2 → ℤ),
DifferentiableOn ℂ (EisensteinSeries.eisSummand k a ∘ ↑UpperHalfPlane.ofComplex) {z | 0 < z.im} | Auxiliary lemma showing that for any `k : ℤ` and `(a : Fin 2 → ℤ)`
the extension of `eisSummand` is differentiable on `{z : ℂ | 0 < z.im}`. | true |
_private.Lean.Expr.0.Lean.Expr.getBoundedAppArgsAux._unsafe_rec | Lean.Expr | Lean.Expr → Array Lean.Expr → ℕ → Array Lean.Expr | null | false |
CategoryTheory.Functor.FullyFaithful.preimage_comp_assoc | Mathlib.CategoryTheory.Functor.FullyFaithful | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
{F : CategoryTheory.Functor C D} (hF : F.FullyFaithful) {X Y Z : C} (f : F.obj X ⟶ F.obj Y) (g : F.obj Y ⟶ F.obj Z)
{Z_1 : C} (h : Z ⟶ Z_1),
CategoryTheory.CategoryStruct.comp (hF.preimage (Cate... | null | true |
AddSubgroup.top_toAddSubmonoid | Mathlib.Algebra.Group.Subgroup.Lattice | ∀ {G : Type u_1} [inst : AddGroup G], ⊤.toAddSubmonoid = ⊤ | null | true |
Algebra.FormallyUnramified.inst | Mathlib.RingTheory.Unramified.Basic | ∀ {R : Type u} [inst : CommRing R], Algebra.FormallyUnramified R R | null | true |
_private.Mathlib.NumberTheory.NumberField.CanonicalEmbedding.Basic.0.NumberField.mixedEmbedding.stdBasis_repr_eq_matrixToStdBasis_mul._simp_1_6 | Mathlib.NumberTheory.NumberField.CanonicalEmbedding.Basic | ∀ {α : Type u_1} [inst : Fintype α] (x : α), (x ∈ Finset.univ) = True | null | false |
AddAction.instIsPretransitiveElemOrbit | Mathlib.GroupTheory.GroupAction.Basic | ∀ {G : Type u_1} {α : Type u_2} [inst : AddGroup G] [inst_1 : AddAction G α] (a : α),
AddAction.IsPretransitive G ↑(AddAction.orbit G a) | The action of an additive group on an orbit is transitive. | true |
MeasureTheory.Measure.prod_eq | Mathlib.MeasureTheory.Measure.Prod | ∀ {α : Type u_1} {β : Type u_2} [inst : MeasurableSpace α] [inst_1 : MeasurableSpace β] {μ : MeasureTheory.Measure α}
[MeasureTheory.SigmaFinite μ] {ν : MeasureTheory.Measure β} [MeasureTheory.SigmaFinite ν]
{μν : MeasureTheory.Measure (α × β)},
(∀ (s : Set α) (t : Set β), MeasurableSet s → MeasurableSet t → μν (... | A measure on a product space equals the product measure of sigma-finite measures if they are
equal on rectangles. | true |
Lean.Lsp.DocumentChange | Lean.Data.Lsp.Basic | Type | A change to a file resource.
[reference](https://microsoft.github.io/language-server-protocol/specifications/lsp/3.17/specification/#resourceChanges) | true |
Nat.exists_most_significant_bit | Mathlib.Data.Nat.Bitwise | ∀ {n : ℕ}, n ≠ 0 → ∃ i, n.testBit i = true ∧ ∀ (j : ℕ), i < j → n.testBit j = false | null | true |
_private.Mathlib.RingTheory.Polynomial.Resultant.Basic.0.Polynomial.resultant_succ_left_deg._proof_1_6 | Mathlib.RingTheory.Polynomial.Resultant.Basic | ∀ (m n : ℕ), m ≤ m + 1 + n ∧ m + 1 + n ≤ m + (n + 1) | null | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.