name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11.5k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
_private.Mathlib.Algebra.Module.ZLattice.Covolume.0._auto_40 | Mathlib.Algebra.Module.ZLattice.Covolume | Lean.Syntax | null | false |
Besicovitch.BallPackage.ctorIdx | Mathlib.MeasureTheory.Covering.Besicovitch | {β : Type u_1} → {α : Type u_2} → Besicovitch.BallPackage β α → ℕ | null | false |
QuasispectrumRestricts.nonUnitalStarAlgHom._proof_17 | Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.Restrict | ∀ {R : Type u_3} {S : Type u_1} {A : Type u_2} [inst : Semifield R] [inst_1 : TopologicalSpace R] [inst_2 : Field S]
[inst_3 : TopologicalSpace S] [inst_4 : NonUnitalRing A] [inst_5 : Algebra R S] [inst_6 : Module R A]
[inst_7 : Module S A] [IsScalarTower S A A] [SMulCommClass S A A] [IsScalarTower R S A] {a : A} {... | null | false |
isClosed_le_of_isClosed_nonneg | Mathlib.Analysis.Normed.Order.Lattice | ∀ {G : Type u_2} [inst : AddCommGroup G] [inst_1 : PartialOrder G] [IsOrderedAddMonoid G] [inst_3 : TopologicalSpace G]
[ContinuousSub G], IsClosed {x | 0 ≤ x} → IsClosed {p | p.1 ≤ p.2} | null | true |
MeasureTheory.Lp.edist_toLp_zero | Mathlib.MeasureTheory.Function.LpSpace.Basic | ∀ {α : Type u_1} {E : Type u_4} {m : MeasurableSpace α} {p : ENNReal} {μ : MeasureTheory.Measure α}
[inst : NormedAddCommGroup E] (f : α → E) (hf : MeasureTheory.MemLp f p μ),
edist (MeasureTheory.MemLp.toLp f hf) 0 = MeasureTheory.eLpNorm f p μ | null | true |
CategoryTheory.WideSubcategory.obj | Mathlib.CategoryTheory.Widesubcategory | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
{_P : CategoryTheory.MorphismProperty C} → [inst_1 : _P.IsMultiplicative] → CategoryTheory.WideSubcategory _P → C | The category of which this is a wide subcategory | true |
_private.BatteriesRecycling.MonadSatisfying.Basic.0.SatisfiesM.bind.match_1_1 | BatteriesRecycling.MonadSatisfying.Basic | ∀ {m : Type u_1 → Type u_2} {α : Type u_1} {p : α → Prop} [inst : Monad m] (motive : (x : m α) → SatisfiesM p x → Prop)
(x : m α) (hx : SatisfiesM p x), (∀ (x : m { a // p a }), motive (Subtype.val <$> x) ⋯) → motive x hx | null | false |
nhdsSet_le_iff._simp_1 | Mathlib.Topology.Separation.Basic | ∀ {X : Type u_1} [inst : TopologicalSpace X] [T1Space X] {s t : Set X}, (nhdsSet s ≤ nhdsSet t) = (s ⊆ t) | null | false |
Lean.Server.StatefulRequestHandler.casesOn | Lean.Server.Requests | {motive : Lean.Server.StatefulRequestHandler → Sort u} →
(t : Lean.Server.StatefulRequestHandler) →
((fileSource : Lean.Json → Except Lean.Server.RequestError Lean.Lsp.DocumentUri) →
(pureHandle : Lean.Json → Dynamic → Lean.Server.RequestM (Lean.Server.SerializedLspResponse × Dynamic)) →
(handle... | null | false |
Sublattice.mem_mk._simp_1 | Mathlib.Order.Sublattice | ∀ {α : Type u_2} [inst : Lattice α] {s : Set α} {a : α} (h_sup : SupClosed s) (h_inf : InfClosed s),
(a ∈ { carrier := s, supClosed' := h_sup, infClosed' := h_inf }) = (a ∈ s) | null | false |
Lean.Lsp.ResolveSupport | Lean.Data.Lsp.Basic | Type | null | true |
intervalIntegral.integral_derivWithin_Icc_of_contDiffOn_Icc | Mathlib.MeasureTheory.Integral.IntervalIntegral.ContDiff | ∀ {E : Type u_3} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E] {f : ℝ → E} {a b : ℝ} [CompleteSpace E],
ContDiffOn ℝ 1 f (Set.Icc a b) → a ≤ b → ∫ (x : ℝ) in a..b, derivWithin f (Set.Icc a b) x = f b - f a | Fundamental theorem of calculus-2: If `f : ℝ → E` is `C^1` on `[a, b]`,
then `∫ y in a..b, derivWithin f (Icc a b) y` equals `f b - f a`. | true |
GroupExtension.Equiv.trans_apply | Mathlib.GroupTheory.GroupExtension.Defs | ∀ {N : Type u_1} {E : Type u_2} {G : Type u_3} [inst : Group N] [inst_1 : Group E] [inst_2 : Group G]
{S : GroupExtension N E G} {E' : Type u_4} [inst_3 : Group E'] {S' : GroupExtension N E' G} (equiv : S.Equiv S')
{E'' : Type u_5} [inst_4 : Group E''] {S'' : GroupExtension N E'' G} (equiv' : S'.Equiv S'') (a : E),... | null | true |
Lean.Meta.Simp.Arith.Nat.ToLinear.State.vars | Lean.Meta.Tactic.Simp.Arith.Nat.Basic | Lean.Meta.Simp.Arith.Nat.ToLinear.State → Array Lean.Expr | null | true |
Part.elim_toOption | Mathlib.Data.Part | ∀ {α : Type u_4} {β : Type u_5} (a : Part α) [inst : Decidable a.Dom] (b : β) (f : α → β),
a.toOption.elim b f = if h : a.Dom then f (a.get h) else b | null | true |
SeminormFamily.basisSets_univ_mem | Mathlib.Analysis.LocallyConvex.WithSeminorms | ∀ {R : Type u_1} {E : Type u_6} {ι : Type u_9} [inst : SeminormedRing R] [inst_1 : AddCommGroup E] [inst_2 : Module R E]
(p : SeminormFamily R E ι), Set.univ ∈ p.basisSets | null | true |
EuclideanSpace.nnnorm_single | Mathlib.Analysis.InnerProductSpace.PiL2 | ∀ {ι : Type u_1} {𝕜 : Type u_3} [inst : RCLike 𝕜] [inst_1 : DecidableEq ι] [inst_2 : Fintype ι] (i : ι) (a : 𝕜),
‖EuclideanSpace.single i a‖₊ = ‖a‖₊ | null | true |
Std.DTreeMap.Internal.Impl.insertMany_eq_foldl_impl | Std.Data.DTreeMap.Internal.WF.Lemmas | ∀ {α : Type u} {β : α → Type v} {x : Ord α} {t₁ : Std.DTreeMap.Internal.Impl α β} (h₁ : t₁.Balanced)
{t₂ : Std.DTreeMap.Internal.Impl α β},
↑(t₁.insertMany t₂ h₁) =
Std.DTreeMap.Internal.Impl.foldl (fun acc k v => Std.DTreeMap.Internal.Impl.insert! k v acc) t₁ t₂ | null | true |
_private.Mathlib.Computability.Reduce.0.ManyOneEquiv.trans.match_1_1 | Mathlib.Computability.Reduce | ∀ {α : Type u_1} {β : Type u_2} {γ : Type u_3} [inst : Primcodable α] [inst_1 : Primcodable β] [inst_2 : Primcodable γ]
{p : α → Prop} {q : β → Prop} {r : γ → Prop} (motive : ManyOneEquiv p q → ManyOneEquiv q r → Prop)
(x : ManyOneEquiv p q) (x_1 : ManyOneEquiv q r),
(∀ (pq : p ≤₀ q) (qp : q ≤₀ p) (qr : q ≤₀ r) (... | null | false |
LowerSet.instSProd | Mathlib.Order.UpperLower.Prod | {α : Type u_1} →
{β : Type u_2} → [inst : Preorder α] → [inst_1 : Preorder β] → SProd (LowerSet α) (LowerSet β) (LowerSet (α × β)) | null | true |
Std.ExtHashMap.getKeyD_alter_self | Std.Data.ExtHashMap.Lemmas | ∀ {α : Type u} {β : Type v} {x : BEq α} {x_1 : Hashable α} {m : Std.ExtHashMap α β} [inst : EquivBEq α]
[inst_1 : LawfulHashable α] [Inhabited α] {k fallback : α} {f : Option β → Option β},
(m.alter k f).getKeyD k fallback = if (f m[k]?).isSome = true then k else fallback | null | true |
SemiNormedGrp.hom_id | Mathlib.Analysis.Normed.Group.SemiNormedGrp | ∀ {M : SemiNormedGrp}, SemiNormedGrp.Hom.hom (CategoryTheory.CategoryStruct.id M) = NormedAddGroupHom.id M.carrier | null | true |
MeasureTheory.Measure.IsAddLeftInvariant.comap | Mathlib.MeasureTheory.Group.Measure | ∀ {G : Type u_1} [inst : MeasurableSpace G] [inst_1 : AddGroup G] [MeasurableAdd G] {H : Type u_3} [inst_3 : AddGroup H]
{mH : MeasurableSpace H} [MeasurableAdd H] (μ : MeasureTheory.Measure H) [μ.IsAddLeftInvariant] {f : G →+ H},
MeasurableEmbedding ⇑f → (MeasureTheory.Measure.comap (⇑f) μ).IsAddLeftInvariant | null | true |
Matrix.SpecialLinearGroup.instCoeInt | Mathlib.LinearAlgebra.Matrix.SpecialLinearGroup | {n : Type u} →
[inst : DecidableEq n] →
[inst_1 : Fintype n] →
{R : Type v} → [inst_2 : CommRing R] → Coe (Matrix.SpecialLinearGroup n ℤ) (Matrix.SpecialLinearGroup n R) | Coercion of SL `n` `ℤ` to SL `n` `R` for a commutative ring `R`. | true |
List.getLast?_replicate | Init.Data.List.Lemmas | ∀ {α : Type u_1} {a : α} {n : ℕ}, (List.replicate n a).getLast? = if n = 0 then none else some a | null | true |
neg_one_pow_eq_neg_one_iff_odd | Mathlib.Algebra.Ring.Parity | ∀ {R : Type u_4} [inst : Monoid R] [inst_1 : HasDistribNeg R] {n : ℕ}, -1 ≠ 1 → ((-1) ^ n = -1 ↔ Odd n) | null | true |
_private.Lean.Meta.MkIffOfInductiveProp.0.Lean.Meta.nCasesProd.match_5 | Lean.Meta.MkIffOfInductiveProp | (motive : Array Lean.Meta.CasesSubgoal → Sort u_1) →
(__x : Array Lean.Meta.CasesSubgoal) →
((sg : Lean.Meta.CasesSubgoal) → motive #[sg]) → ((x : Array Lean.Meta.CasesSubgoal) → motive x) → motive __x | null | false |
unitsCentralizerEquiv._proof_8 | Mathlib.GroupTheory.GroupAction.ConjAct | ∀ (M : Type u_1) [inst : Monoid M] (x : Mˣ) (x_1 x_2 : ↥(MulAction.stabilizer (ConjAct Mˣ) x)),
⟨↑(ConjAct.ofConjAct ↑(x_1 * x_2)), ⋯⟩ = ⟨↑(ConjAct.ofConjAct ↑(x_1 * x_2)), ⋯⟩ | null | false |
_private.Mathlib.Combinatorics.Schnirelmann.0.add_eq_univ_of_one_le_schirelmannDensity_add_schnirelmannDensity.match_1_1.splitter | Mathlib.Combinatorics.Schnirelmann | (motive : ℕ ⊕ ℕ → Sort u_1) → (x : ℕ ⊕ ℕ) → ((x : ℕ) → motive (Sum.inl x)) → ((y : ℕ) → motive (Sum.inr y)) → motive x | null | true |
_private.Mathlib.Topology.Algebra.Category.ProfiniteGrp.Basic.0.ProfiniteAddGrp.Hom.mk.inj | Mathlib.Topology.Algebra.Category.ProfiniteGrp.Basic | ∀ {A B : ProfiniteAddGrp.{u}} {hom' hom'_1 : ↑A.toProfinite.toTop →ₜ+ ↑B.toProfinite.toTop},
{ hom' := hom' } = { hom' := hom'_1 } → hom' = hom'_1 | null | true |
PeriodPair.derivWeierstrassP | Mathlib.Analysis.SpecialFunctions.Elliptic.Weierstrass | PeriodPair → ℂ → ℂ | The derivative of Weierstrass `℘` function.
This has the notation `℘'[L]` in the namespace `PeriodPairs`. | true |
TensorProduct.finsuppRight_symm_apply_single | 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] [inst_6 : IsScalarTower R S M] {N : Type u_4}
[inst_7 : AddCommMonoid N] [inst_8 : Module R N] {ι : Type u_5} [inst_9 : Decidable... | null | true |
MonoidAlgebra.addCommMonoid._proof_2 | Mathlib.Algebra.MonoidAlgebra.Defs | ∀ {R : Type u_1} {M : Type u_2} [inst : Semiring R] (a : MonoidAlgebra R M), 0 + a = a | null | false |
Array.get!Internal | Init.Prelude | {α : Type u} → [Inhabited α] → Array α → ℕ → α | Use the indexing notation `a[i]!` instead.
Access an element from an array, or panic if the index is out of bounds.
| true |
Lean.SourceInfo.ctorIdx | Init.Prelude | Lean.SourceInfo → ℕ | null | false |
instLinearOrderedAddCommGroupWithTopAdditiveOrderDual._proof_7 | Mathlib.Algebra.Order.GroupWithZero.Canonical | ∀ {α : Type u_1} [inst : LinearOrderedCommGroupWithZero α] (n : ℕ) (a : Additive αᵒᵈ),
SubNegMonoid.zsmul (↑n.succ) a = SubNegMonoid.zsmul (↑n) a + a | null | false |
SMulCon.noConfusion | Mathlib.Algebra.Module.Congruence.Defs | {P : Sort u} →
{S : Type u_2} →
{M : Type u_3} →
{inst : SMul S M} →
{t : SMulCon S M} →
{S' : Type u_2} →
{M' : Type u_3} →
{inst' : SMul S' M'} →
{t' : SMulCon S' M'} → S = S' → M = M' → inst ≍ inst' → t ≍ t' → SMulCon.noConfusionType P t t' | null | false |
Aesop.Frontend.RuleExpr.elab | Aesop.Frontend.RuleExpr | Lean.Syntax → Aesop.ElabM Aesop.Frontend.RuleExpr | null | true |
EuclideanDomain.lcm | Mathlib.Algebra.EuclideanDomain.Defs | {R : Type u} → [EuclideanDomain R] → [DecidableEq R] → R → R → R | `lcm a b` is a (non-unique) element such that `a ∣ lcm a b` `b ∣ lcm a b`, and for
any element `c` such that `a ∣ c` and `b ∣ c`, then `lcm a b ∣ c` | true |
NumberField.IsCMField.starRing | Mathlib.NumberTheory.NumberField.CMField | (K : Type u_1) →
[inst : Field K] → [inst_1 : CharZero K] → [NumberField.IsCMField K] → [Algebra.IsIntegral ℚ K] → StarRing K | null | true |
CategoryTheory.PreOneHypercover.inv_hom_h₁ | Mathlib.CategoryTheory.Sites.Hypercover.One | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {S : C} {E F : CategoryTheory.PreOneHypercover S} (e : E ≅ F)
{i j : F.I₀} (k : F.I₁ i j),
CategoryTheory.CategoryStruct.comp (e.inv.h₁ k) (e.hom.h₁ (e.inv.s₁ k)) =
CategoryTheory.CategoryStruct.comp (CategoryTheory.PreOneHypercover.congrIndexOneOfEqIso ⋯... | null | true |
Real.iteratedDerivWithin_cos_Ioo | Mathlib.Analysis.SpecialFunctions.Trigonometric.Deriv | ∀ (n : ℕ) {a b x : ℝ}, x ∈ Set.Ioo a b → iteratedDerivWithin n Real.cos (Set.Ioo a b) x = iteratedDeriv n Real.cos x | null | true |
ModularGroup.eq_smul_self_of_mem_fdo_mem_fdo | Mathlib.NumberTheory.Modular | ∀ {g : Matrix.SpecialLinearGroup (Fin 2) ℤ} {z : UpperHalfPlane},
z ∈ ModularGroup.fdo → g • z ∈ ModularGroup.fdo → z = g • z | Second Fundamental Domain Lemma: if both `z` and `g • z` are in the open domain `𝒟ᵒ`,
where `z : ℍ` and `g : SL(2, ℤ)`, then `z = g • z`. | true |
_private.Init.Data.String.Lemmas.Splits.0.String.Slice.Pos.Splits.le_iff_exists_eq_append._simp_1_3 | Init.Data.String.Lemmas.Splits | ∀ {s : String.Slice} {l r : s.Pos}, (l ≤ r) = (l.offset ≤ r.offset) | null | false |
MulEquiv.mk.inj | Mathlib.Algebra.Group.Equiv.Defs | ∀ {M : Type u_9} {N : Type u_10} {inst : Mul M} {inst_1 : Mul N} {toEquiv : M ≃ N}
{map_mul' : ∀ (x y : M), toEquiv.toFun (x * y) = toEquiv.toFun x * toEquiv.toFun y} {toEquiv_1 : M ≃ N}
{map_mul'_1 : ∀ (x y : M), toEquiv_1.toFun (x * y) = toEquiv_1.toFun x * toEquiv_1.toFun y},
{ toEquiv := toEquiv, map_mul' := ... | null | true |
_private.Lean.Meta.FunInfo.0.Lean.Meta.FunInfoEnvCacheKey.c | Lean.Meta.FunInfo | Lean.Meta.FunInfoEnvCacheKey✝ → Lean.Name | null | true |
_private.Mathlib.Algebra.Category.CommHopfAlgCat.0.CommHopfAlgCat.Hom.ext.match_1 | Mathlib.Algebra.Category.CommHopfAlgCat | ∀ {R : Type u_2} {inst : CommRing R} {A B : CommHopfAlgCat R} (motive : A.Hom B → Prop) (h : A.Hom B),
(∀ (hom' : ↑A →ₐc[R] ↑B), motive { hom' := hom' }) → motive h | null | false |
ValuationRing.instLEValueGroup._proof_1 | Mathlib.RingTheory.Valuation.ValuationRing | ∀ (A : Type u_2) [inst : CommRing A] (K : Type u_1) [inst_1 : Field K] [inst_2 : Algebra A K] (a₁ a₂ b₁ b₂ : K),
(MulAction.orbitRel Aˣ K) a₁ b₁ → (MulAction.orbitRel Aˣ K) a₂ b₂ → (∃ c, c • a₂ = a₁) = ∃ c, c • b₂ = b₁ | null | false |
_private.Mathlib.Data.Int.Interval.0.Int.instLocallyFiniteOrder._proof_14 | Mathlib.Data.Int.Interval | ∀ (a b x : ℤ), a < x ∧ x < b → (x - (a + 1)).toNat < (b - a - 1).toNat ∧ a + 1 + ↑(x - (a + 1)).toNat = x | null | false |
TopCommRingCat._sizeOf_inst | Mathlib.Topology.Category.TopCommRingCat | SizeOf TopCommRingCat | null | false |
CategoryTheory.Limits.coneUnopOfCocone_pt | Mathlib.CategoryTheory.Limits.Cones | ∀ {J : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} J] {C : Type u₃} [inst_1 : CategoryTheory.Category.{v₃, u₃} C]
{F : CategoryTheory.Functor Jᵒᵖ Cᵒᵖ} (c : CategoryTheory.Limits.Cocone F),
(CategoryTheory.Limits.coneUnopOfCocone c).pt = Opposite.unop c.pt | null | true |
_private.Mathlib.Analysis.InnerProductSpace.Projection.Minimal.0.termAbsR | Mathlib.Analysis.InnerProductSpace.Projection.Minimal | Lean.ParserDescr | null | true |
CategoryTheory.FintypeCat.Action.isConnected_iff_transitive | Mathlib.CategoryTheory.Galois.Examples | ∀ (G : Type u) [inst : Group G] (X : Action FintypeCat G) [Nonempty X.V.obj],
CategoryTheory.PreGaloisCategory.IsConnected X ↔ MulAction.IsPretransitive G X.V.obj | A nonempty finite `G`-set is connected if and only if the `G`-action is transitive. | true |
_private.Lean.Meta.Tactic.Grind.Parser.0.Lean.Parser.Command.grindPattern._regBuiltin.Lean.Parser.Command.grindPattern_1 | Lean.Meta.Tactic.Grind.Parser | IO Unit | null | false |
Set.exists_min_image | Mathlib.Data.Set.Finite.Lemmas | ∀ {α : Type u} {β : Type v} [inst : LinearOrder β] (s : Set α) (f : α → β),
s.Finite → s.Nonempty → ∃ a ∈ s, ∀ b ∈ s, f a ≤ f b | null | true |
isLocalMax_of_deriv' | Mathlib.Analysis.Calculus.DerivativeTest | ∀ {f : ℝ → ℝ} {b : ℝ},
ContinuousAt f b →
(∀ᶠ (x : ℝ) in nhdsWithin b (Set.Iio b), DifferentiableAt ℝ f x) →
(∀ᶠ (x : ℝ) in nhdsWithin b (Set.Ioi b), DifferentiableAt ℝ f x) →
(∀ᶠ (x : ℝ) in nhdsWithin b (Set.Iio b), 0 ≤ deriv f x) →
(∀ᶠ (x : ℝ) in nhdsWithin b (Set.Ioi b), deriv f x ≤ 0) ... | The First-Derivative Test from calculus, maxima version,
expressed in terms of left and right filters. | true |
OrthogonalFamily.independent | Mathlib.Analysis.InnerProductSpace.Subspace | ∀ {𝕜 : Type u_1} {E : Type u_2} [inst : RCLike 𝕜] [inst_1 : NormedAddCommGroup E] [inst_2 : InnerProductSpace 𝕜 E]
{ι : Type u_4} {V : ι → Submodule 𝕜 E}, (OrthogonalFamily 𝕜 (fun i => ↥(V i)) fun i => (V i).subtypeₗᵢ) → iSupIndep V | An orthogonal family forms an independent family of subspaces; that is, any collection of
elements each from a different subspace in the family is linearly independent. In particular, the
pairwise intersections of elements of the family are 0. | true |
MulHom.prod_comp_prodMap | Mathlib.Algebra.Group.Prod | ∀ {M : Type u_3} {N : Type u_4} {P : Type u_5} {M' : Type u_6} {N' : Type u_7} [inst : Mul M] [inst_1 : Mul N]
[inst_2 : Mul M'] [inst_3 : Mul N'] [inst_4 : Mul P] (f : P →ₙ* M) (g : P →ₙ* N) (f' : M →ₙ* M') (g' : N →ₙ* N'),
(f'.prodMap g').comp (f.prod g) = (f'.comp f).prod (g'.comp g) | null | true |
NonUnitalSubsemiring.mem_prod | Mathlib.RingTheory.NonUnitalSubsemiring.Basic | ∀ {R : Type u} {S : Type v} [inst : NonUnitalNonAssocSemiring R] [inst_1 : NonUnitalNonAssocSemiring S]
{s : NonUnitalSubsemiring R} {t : NonUnitalSubsemiring S} {p : R × S}, p ∈ s.prod t ↔ p.1 ∈ s ∧ p.2 ∈ t | null | true |
BitVec.not_sub_one_eq_not_add_one | Init.Data.BitVec.Bitblast | ∀ {w : ℕ} {x : BitVec w}, ~~~(x - 1#w) = ~~~x + 1#w | null | true |
Diffeomorph.coe_toHomeomorph | Mathlib.Geometry.Manifold.Diffeomorph | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {F : Type u_4} [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace 𝕜 F] {H : Type u_5}
[inst_5 : TopologicalSpace H] {G : Type u_7} [inst_6 : TopologicalSpace G] {I : ModelWithCorners ... | null | true |
_private.Std.Time.Format.Basic.0.Std.Time.GenericFormat.DateBuilder.H | Std.Time.Format.Basic | Std.Time.GenericFormat.DateBuilder✝ → Option Std.Time.Hour.Ordinal | null | true |
ONote.opowAux2.match_1 | Mathlib.SetTheory.Ordinal.Notation | (motive : ONote × ℕ → Sort u_1) →
(x : ONote × ℕ) → ((b : ONote) → motive (b, 0)) → ((b : ONote) → (k : ℕ) → motive (b, k.succ)) → motive x | null | false |
MeasureTheory.eLpNorm'_mono_ae | Mathlib.MeasureTheory.Function.LpSeminorm.Basic | ∀ {α : Type u_1} {F : Type u_5} {G : Type u_6} {m0 : MeasurableSpace α} {q : ℝ} {μ : MeasureTheory.Measure α}
[inst : NormedAddCommGroup F] [inst_1 : NormedAddCommGroup G] {f : α → F} {g : α → G},
0 ≤ q → (∀ᵐ (x : α) ∂μ, ‖f x‖ ≤ ‖g x‖) → MeasureTheory.eLpNorm' f q μ ≤ MeasureTheory.eLpNorm' g q μ | null | true |
Filter.eventually_mem_set._simp_1 | Mathlib.Order.Filter.Basic | ∀ {α : Type u} {s : Set α} {l : Filter α}, (∀ᶠ (x : α) in l, x ∈ s) = (s ∈ l) | null | false |
MvPolynomial.uniqueAlgEquiv_apply | Mathlib.Algebra.MvPolynomial.Equiv | ∀ (R : Type u) [inst : CommSemiring R] (σ : Type u_2) [inst_1 : Unique σ] (p : MvPolynomial σ R),
(MvPolynomial.uniqueAlgEquiv R σ) p = MvPolynomial.eval₂ Polynomial.C (fun x => Polynomial.X) p | null | true |
Module.Basis.adjustToOrientation.congr_simp | Mathlib.LinearAlgebra.Orientation | ∀ {R : Type u_1} [inst : CommRing R] [inst_1 : LinearOrder R] [inst_2 : IsStrictOrderedRing R] {M : Type u_2}
[inst_3 : AddCommGroup M] [inst_4 : Module R M] {ι : Type u_3} [inst_5 : Fintype ι] [inst_6 : DecidableEq ι]
[inst_7 : Nonempty ι] (e e_1 : Module.Basis ι R M),
e = e_1 → ∀ (x x_1 : Orientation R M ι), x ... | null | true |
AddSubgroup.normalCore._proof_2 | Mathlib.Algebra.Group.Subgroup.Basic | ∀ {G : Type u_1} [inst : AddGroup G] (H : AddSubgroup G) {x x_1 : G},
x ∈ {a | ∀ (b : G), b + a + -b ∈ H} → x_1 ∈ {a | ∀ (b : G), b + a + -b ∈ H} → ∀ (c : G), c + (x + x_1) + -c ∈ H | null | false |
SetSemiring.instCompleteBooleanAlgebra._proof_20 | Mathlib.Data.Set.Semiring | ∀ {α : Type u_1} (x y z : SetSemiring α), (x ⊔ y) ⊓ (x ⊔ z) ≤ x ⊔ y ⊓ z | null | false |
MeasureTheory.IsFundamentalDomain.measure_zero_of_invariant | Mathlib.MeasureTheory.Group.FundamentalDomain | ∀ {G : Type u_1} {α : Type u_3} [inst : Group G] [inst_1 : MulAction G α] [inst_2 : MeasurableSpace α] {s : Set α}
{μ : MeasureTheory.Measure α} [MeasurableConstSMul G α] [MeasureTheory.SMulInvariantMeasure G α μ] [Countable G],
MeasureTheory.IsFundamentalDomain G s μ → ∀ (t : Set α), (∀ (g : G), g • t = t) → μ (t ... | null | true |
differentiable_neg | Mathlib.Analysis.Calculus.Deriv.Add | ∀ {𝕜 : Type u} [inst : NontriviallyNormedField 𝕜], Differentiable 𝕜 Neg.neg | null | true |
isFullyInvariant_iff_sSup_isotypicComponents | Mathlib.RingTheory.SimpleModule.Isotypic | ∀ {R : Type u_2} {M : Type u} [inst : Ring R] [inst_1 : AddCommGroup M] [inst_2 : Module R M] [IsSemisimpleModule R M]
{m : Submodule R M}, m.IsFullyInvariant ↔ ∃ s ⊆ isotypicComponents R M, m = sSup s | null | true |
PointedCone.IsSimplicial.hull | Mathlib.Geometry.Convex.Cone.Simplicial | ∀ {R : Type u_1} {M : Type u_2} [inst : Semiring R] [inst_1 : PartialOrder R] [inst_2 : IsOrderedRing R]
[inst_3 : AddCommMonoid M] [inst_4 : Module R M] {s : Set M},
s.Finite → LinearIndepOn R id s → (PointedCone.hull R s).IsSimplicial | The conic hull of a finite linearly independent set is simplicial. | true |
_private.Mathlib.Geometry.Manifold.VectorBundle.Tangent.0.termTM | Mathlib.Geometry.Manifold.VectorBundle.Tangent | Lean.ParserDescr | null | true |
CategoryTheory.Functor.Final.rec | Mathlib.CategoryTheory.Limits.Final | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
{D : Type u₂} →
[inst_1 : CategoryTheory.Category.{v₂, u₂} D] →
{F : CategoryTheory.Functor C D} →
{motive : F.Final → Sort u} →
((out : ∀ (d : D), CategoryTheory.IsConnected (CategoryTheory.StructuredArrow d F)) → m... | null | false |
Units.val | Mathlib.Algebra.Group.Units.Defs | {α : Type u} → [inst : Monoid α] → αˣ → α | The underlying value in the base `Monoid`. | true |
List.alternatingSum_nil | Mathlib.Algebra.BigOperators.Group.List.Basic | ∀ {G : Type u_7} [inst : Zero G] [inst_1 : Add G] [inst_2 : Neg G], [].alternatingSum = 0 | null | true |
_private.Init.Data.List.Find.0.List.find?_replicate_eq_none_iff._simp_1_1 | Init.Data.List.Find | ∀ {a b : Prop}, (a ∨ b) = (¬a → b) | null | false |
Lean.Meta.Grind.mkEqHEqProof | Lean.Meta.Tactic.Grind.Types | Lean.Expr → Lean.Expr → Lean.Meta.Grind.GoalM Lean.Expr | Returns a proof that `a = b` if they have the same type. Otherwise, returns a proof of `a ≍ b`.
It assumes `a` and `b` are in the same equivalence class.
| true |
CategoryTheory.PreZeroHypercover.pullbackIso | Mathlib.CategoryTheory.Sites.Hypercover.Zero | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
{S T : C} →
(f : S ⟶ T) →
(E : CategoryTheory.PreZeroHypercover T) →
[inst_1 : ∀ (i : E.I₀), CategoryTheory.Limits.HasPullback f (E.f i)] →
[inst_2 : ∀ (i : E.I₀), CategoryTheory.Limits.HasPullback (E.f i) f] →
... | Pullback symmetry isomorphism. | true |
Set.iUnion_iUnion_eq_right | Mathlib.Data.Set.Lattice | ∀ {α : Type u_1} {β : Type u_2} {b : β} {s : (x : β) → b = x → Set α}, ⋃ x, ⋃ (h : b = x), s x h = s b ⋯ | null | true |
Std.DHashMap.Internal.Raw.Const.get_eq | Std.Data.DHashMap.Internal.Raw | ∀ {α : Type u} {β : Type v} [inst : BEq α] [inst_1 : Hashable α] {m : Std.DHashMap.Raw α fun x => β} {a : α}
{h : a ∈ m}, Std.DHashMap.Raw.Const.get m a h = Std.DHashMap.Internal.Raw₀.Const.get ⟨m, ⋯⟩ a ⋯ | null | true |
toLexLinearEquiv | Mathlib.Algebra.Order.Module.Equiv | (α : Type u_1) →
(β : Type u_2) → [inst : Semiring α] → [inst_1 : AddCommMonoid β] → [inst_2 : Module α β] → β ≃ₗ[α] Lex β | `toLex` as a linear equivalence | true |
SupHom.recOn | Mathlib.Order.Hom.Lattice | {α : Type u_6} →
{β : Type u_7} →
[inst : Max α] →
[inst_1 : Max β] →
{motive : SupHom α β → Sort u} →
(t : SupHom α β) →
((toFun : α → β) →
(map_sup' : ∀ (a b : α), toFun (a ⊔ b) = toFun a ⊔ toFun b) →
motive { toFun := toFun, map_sup' := map_... | null | false |
_private.Init.Data.Vector.Lemmas.0.Vector.mem_flatten._simp_1_1 | Init.Data.Vector.Lemmas | ∀ {α : Type u_1} {a : α} {xss : Array (Array α)}, (a ∈ xss.flatten) = ∃ xs ∈ xss, a ∈ xs | null | false |
_private.Init.Data.Array.Basic.0.Array.findSomeRevM?.find.match_1 | Init.Data.Array.Basic | {β : Type u_1} →
(motive : Option β → Sort u_2) → (r : Option β) → ((val : β) → motive (some val)) → (Unit → motive none) → motive r | null | false |
WithLp._sizeOf_inst | Mathlib.Analysis.Normed.Lp.WithLp | (p : ENNReal) → (V : Type u_1) → [SizeOf V] → SizeOf (WithLp p V) | null | false |
continuous_clm_apply | Mathlib.Analysis.Normed.Module.FiniteDimension | ∀ {𝕜 : Type u} [inst : NontriviallyNormedField 𝕜] {E : Type v} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {F : Type w} [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace 𝕜 F] [CompleteSpace 𝕜]
{X : Type u_1} [inst_6 : TopologicalSpace X] [FiniteDimensional 𝕜 E] {f : X → E →L[𝕜] F},
Conti... | null | true |
_private.Lean.Meta.Sym.Arith.Poly.0.Lean.Grind.CommRing.Mon.sharesVar._unary.eq_def | Lean.Meta.Sym.Arith.Poly | ∀ (_x : (_ : Lean.Grind.CommRing.Mon) ×' Lean.Grind.CommRing.Mon),
Lean.Grind.CommRing.Mon.sharesVar._unary _x =
PSigma.casesOn _x fun a a_1 =>
match a, a_1 with
| Lean.Grind.CommRing.Mon.unit, x => false
| x, Lean.Grind.CommRing.Mon.unit => false
| Lean.Grind.CommRing.Mon.mult pw₁ m₁, Lea... | null | false |
normalize_eq_one | Mathlib.Algebra.GCDMonoid.Basic | ∀ {α : Type u_1} [inst : CommMonoidWithZero α] [inst_1 : NormalizationMonoid α] {x : α}, normalize x = 1 ↔ IsUnit x | null | true |
SSet.Subcomplex.Pairing.RankFunction.Cell.ι_t_app_assoc | Mathlib.AlgebraicTopology.SimplicialSet.AnodyneExtensions.RelativeCellComplex | ∀ {X : SSet} {A : X.Subcomplex} {P : A.Pairing} {ι : Type v} [inst : LinearOrder ι] {f : P.RankFunction ι}
[inst_1 : P.IsProper] {j : ι} (c : f.Cell j) (x : SimplexCategoryᵒᵖ) {Z : Type u}
(h : (f.filtration j).toSSet.obj x ⟶ Z),
CategoryTheory.CategoryStruct.comp (c.ιSigmaHorn.app x) (CategoryTheory.CategoryStru... | null | true |
_private.Mathlib.MeasureTheory.Integral.Bochner.Basic.0.Mathlib.Meta.Positivity.evalIntegral._proof_2 | Mathlib.MeasureTheory.Integral.Bochner.Basic | ∀ (α : Q(Type)) (pα : Q(PartialOrder «$α»)) (__defeqres : PLift («$pα» =Q Real.partialOrder)),
«$pα» =Q Real.partialOrder | null | false |
CategoryTheory.Monoidal.functorCategoryMonoidal._proof_13 | Mathlib.CategoryTheory.Monoidal.FunctorCategory | ∀ {C : Type u_3} [inst : CategoryTheory.Category.{u_1, u_3} C] {D : Type u_4}
[inst_1 : CategoryTheory.Category.{u_2, u_4} D] [inst_2 : CategoryTheory.MonoidalCategory D]
{X Y : CategoryTheory.Functor C D} (f : X ⟶ Y),
CategoryTheory.CategoryStruct.comp
(CategoryTheory.MonoidalCategoryStruct.whiskerLeft
... | null | false |
Matrix.Semiring.smulCommClass | Mathlib.Data.Matrix.Mul | ∀ {n : Type u_3} {R : Type u_7} {α : Type v} [inst : NonUnitalNonAssocSemiring α] [inst_1 : Fintype n]
[inst_2 : Monoid R] [inst_3 : DistribMulAction R α] [SMulCommClass R α α],
SMulCommClass R (Matrix n n α) (Matrix n n α) | This instance enables use with `mul_smul_comm`. | true |
Std.Time.Day.instDecidableLtOffset._aux_1 | Std.Time.Date.Unit.Day | {x y : Std.Time.Day.Offset} → Decidable (x < y) | null | false |
Std.TreeSet.min!_insert_le_self | Std.Data.TreeSet.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} {t : Std.TreeSet α cmp} [Std.TransCmp cmp] [inst : Inhabited α] {k : α},
(cmp (t.insert k).min! k).isLE = true | null | true |
CFC.norm_mul_mul_star_self_of_nonneg | Mathlib.Analysis.SpecialFunctions.ContinuousFunctionalCalculus.Rpow.Isometric | ∀ {A : Type u_1} [inst : PartialOrder A] [inst_1 : NonUnitalNormedRing A] [inst_2 : StarRing A] [CStarRing A]
[inst_4 : NormedSpace ℝ A] [inst_5 : SMulCommClass ℝ A A] [inst_6 : IsScalarTower ℝ A A] [inst_7 : StarOrderedRing A]
[inst_8 : NonUnitalContinuousFunctionalCalculus ℝ A IsSelfAdjoint] [inst_9 : NonnegSpect... | null | true |
_private.Mathlib.Analysis.InnerProductSpace.Basic.0.inner_eq_norm_mul_iff_div._simp_1_6 | Mathlib.Analysis.InnerProductSpace.Basic | ∀ {G₀ : Type u_3} [inst : GroupWithZero G₀] {a : G₀} (n : ℤ), a ≠ 0 → (a ^ n = 0) = False | null | false |
Std.DTreeMap.Internal.Impl.Const.toListModel_insertManyIfNewUnit!_list | Std.Data.DTreeMap.Internal.WF.Lemmas | ∀ {α : Type u} {x : Ord α} [Std.TransOrd α] [inst : BEq α] [Std.LawfulBEqOrd α] {l : List α}
{t : Std.DTreeMap.Internal.Impl α fun x => Unit},
t.WF →
(↑(Std.DTreeMap.Internal.Impl.Const.insertManyIfNewUnit! t l)).toListModel.Perm
(Std.Internal.List.insertListIfNewUnit t.toListModel l) | null | true |
BitVec.sub_add_comm | Init.Data.BitVec.Bitblast | ∀ {w : ℕ} {z x y : BitVec w}, x - y + z = x + z - y | null | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.