name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11.5k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
_private.Mathlib.Order.KrullDimension.0.Order.exists_series_of_le_height._proof_1_1 | Mathlib.Order.KrullDimension | ∀ {α : Type u_1} [inst : Preorder α] {n : ℕ} (m : ℕ) (p : LTSeries α), p.length = m → n < m → m - n < p.length + 1 | null | false |
MulAction.IsBlock.of_orbit | Mathlib.GroupTheory.GroupAction.Blocks | ∀ {G : Type u_1} [inst : Group G] {X : Type u_2} [inst_1 : MulAction G X] {H : Subgroup G} {a : X},
MulAction.stabilizer G a ≤ H → MulAction.IsBlock G (MulAction.orbit (↥H) a) | The orbit of `a` under a subgroup containing the stabilizer of `a` is a block | true |
SimpleGraph.Subgraph.instCompletelyDistribLattice._proof_2 | Mathlib.Combinatorics.SimpleGraph.Subgraph | ∀ {V : Type u_1} {G : SimpleGraph V} (s : Set G.Subgraph), IsGLB s (sInf s) | null | false |
mul_neg_geom_sum | Mathlib.Algebra.Ring.GeomSum | ∀ {R : Type u_1} [inst : Ring R] (x : R) (n : ℕ), (1 - x) * ∑ i ∈ Finset.range n, x ^ i = 1 - x ^ n | null | true |
Subalgebra.coe_pi | Mathlib.Algebra.Algebra.Subalgebra.Pi | ∀ {ι : Type u_1} {R : Type u_2} {S : ι → Type u_3} [inst : CommSemiring R] [inst_1 : (i : ι) → Semiring (S i)]
[inst_2 : (i : ι) → Algebra R (S i)] (s : Set ι) (t : (i : ι) → Subalgebra R (S i)),
↑(Subalgebra.pi s t) = (Submodule.pi s fun i => Subalgebra.toSubmodule (t i)).carrier | null | true |
CompletelyDistribLattice.mk._flat_ctor | Mathlib.Order.CompleteBooleanAlgebra | {α : Type u} →
(le lt : α → α → Prop) →
(le_refl : ∀ (a : α), le a a) →
(le_trans : ∀ (a b c : α), le a b → le b c → le a c) →
(lt_iff_le_not_ge : autoParam (∀ (a b : α), lt a b ↔ le a b ∧ ¬le b a) Preorder.lt_iff_le_not_ge._autoParam) →
(le_antisymm : ∀ (a b : α), le a b → le b a → a = b)... | null | false |
Lean.Meta.Grind.EMatch.State | Lean.Meta.Tactic.Grind.Types | Type | E-matching related fields for the `grind` goal. | true |
Configuration.HasLines.rec | Mathlib.Combinatorics.Configuration | {P : Type u_1} →
{L : Type u_2} →
[inst : Membership P L] →
{motive : Configuration.HasLines P L → Sort u} →
([toNondegenerate : Configuration.Nondegenerate P L] →
(mkLine : {p₁ p₂ : P} → p₁ ≠ p₂ → L) →
(mkLine_ax : ∀ {p₁ p₂ : P} (h : p₁ ≠ p₂), p₁ ∈ mkLine h ∧ p₂ ∈ mkLine h... | null | false |
Int.abs_modEq_two._simp_1 | Mathlib.Data.Int.ModEq | ∀ {a : ℤ}, (|a| ≡ a [ZMOD 2]) = True | null | false |
FinEnum.PSigma.finEnumPropProp._proof_3 | Mathlib.Data.FinEnum | ∀ {α : Prop} {β : α → Prop}, (∃ (a : α), β a) → α | null | false |
RealRMK.le_rieszMeasure_tsupport_subset | Mathlib.MeasureTheory.Integral.RieszMarkovKakutani.Real | ∀ {X : Type u_1} [inst : TopologicalSpace X] [inst_1 : T2Space X] [inst_2 : MeasurableSpace X] [inst_3 : BorelSpace X]
(Λ : CompactlySupportedContinuousMap X ℝ →ₚ[ℝ] ℝ) [inst_4 : LocallyCompactSpace X]
{f : CompactlySupportedContinuousMap X ℝ},
(∀ (x : X), 0 ≤ f x ∧ f x ≤ 1) → ∀ {V : Set X}, tsupport ⇑f ⊆ V → ENN... | If `f` assumes values between `0` and `1` and the support is contained in `V`, then
`Λ f ≤ rieszMeasure V`. | true |
intervalIntegral.continuousOn_primitive_interval_left | Mathlib.MeasureTheory.Integral.DominatedConvergence | ∀ {E : Type u_1} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E] {a b : ℝ} {μ : MeasureTheory.Measure ℝ}
{f : ℝ → E} [MeasureTheory.NoAtoms μ],
MeasureTheory.IntegrableOn f (Set.uIcc a b) μ → ContinuousOn (fun x => ∫ (t : ℝ) in x..b, f t ∂μ) (Set.uIcc a b) | null | true |
IsPrimitiveRoot.toInteger_sub_one_dvd_prime' | Mathlib.NumberTheory.NumberField.Cyclotomic.Basic | ∀ {p : ℕ} {K : Type u} [inst : Field K] {ζ : K} [hp : Fact (Nat.Prime p)] [inst_1 : CharZero K]
[hcycl : IsCyclotomicExtension {p} ℚ K] (hζ : IsPrimitiveRoot ζ p), hζ.toInteger - 1 ∣ ↑p | In a `p`-th cyclotomic extension of `ℚ`, we have that `ζ - 1` divides `p` in `𝓞 K`. | true |
MulEquiv.coprodAssoc_apply_inl_inl | Mathlib.GroupTheory.Coprod.Basic | ∀ {M : Type u_1} {N : Type u_2} {P : Type u_3} [inst : Monoid M] [inst_1 : Monoid N] [inst_2 : Monoid P] (x : M),
(MulEquiv.coprodAssoc M N P) (Monoid.Coprod.inl (Monoid.Coprod.inl x)) = Monoid.Coprod.inl x | null | true |
MeasureTheory.AEStronglyMeasurable.mono_set | Mathlib.MeasureTheory.Function.StronglyMeasurable.AEStronglyMeasurable | ∀ {α : Type u_1} {β : Type u_2} [inst : TopologicalSpace β] {m m₀ : MeasurableSpace α} {μ : MeasureTheory.Measure α}
{f : α → β} {s t : Set α},
s ⊆ t → MeasureTheory.AEStronglyMeasurable f (μ.restrict t) → MeasureTheory.AEStronglyMeasurable f (μ.restrict s) | null | true |
Matrix.discr_fin_two | Mathlib.LinearAlgebra.Matrix.Charpoly.Disc | ∀ {R : Type u_1} [inst : CommRing R] (A : Matrix (Fin 2) (Fin 2) R), A.discr = A.trace ^ 2 - 4 * A.det | null | true |
ModuleCat.projectiveResolution._proof_1 | Mathlib.Algebra.Category.ModuleCat.LeftResolution | ∀ (R : Type u_1) [inst : Ring R] (X : ModuleCat R),
CategoryTheory.isProjective (ModuleCat R) (((CategoryTheory.forget (ModuleCat R)).comp (ModuleCat.free R)).obj X) | null | false |
Seminorm.comp_smul | Mathlib.Analysis.Seminorm | ∀ {𝕜 : Type u_3} {𝕜₂ : Type u_4} {E : Type u_7} {E₂ : Type u_8} [inst : SeminormedRing 𝕜]
[inst_1 : SeminormedCommRing 𝕜₂] {σ₁₂ : 𝕜 →+* 𝕜₂} [inst_2 : RingHomIsometric σ₁₂] [inst_3 : AddCommGroup E]
[inst_4 : AddCommGroup E₂] [inst_5 : Module 𝕜 E] [inst_6 : Module 𝕜₂ E₂] (p : Seminorm 𝕜₂ E₂) (f : E →ₛₗ[σ₁₂]... | null | true |
Lean.Widget.RpcEncodablePacket.leanTags?._@.Lean.Widget.InteractiveDiagnostic.2989700264._hygCtx._hyg.2 | Lean.Widget.InteractiveDiagnostic | Lean.Widget.RpcEncodablePacket✝ → Option Lean.Json | null | false |
NumberField.mixedEmbedding.euclidean.instNontrivialMixedSpace | Mathlib.NumberTheory.NumberField.CanonicalEmbedding.Basic | ∀ (K : Type u_1) [inst : Field K] [NumberField K], Nontrivial (NumberField.mixedEmbedding.euclidean.mixedSpace K) | null | true |
Matrix.detp_smul_add_adjp | Mathlib.LinearAlgebra.Matrix.SemiringInverse | ∀ {n : Type u_1} {R : Type u_3} [inst : Fintype n] [inst_1 : DecidableEq n] [inst_2 : CommSemiring R]
{A B : Matrix n n R}, A * B = 1 → Matrix.detp 1 B • A + Matrix.adjp (-1) B = Matrix.detp (-1) B • A + Matrix.adjp 1 B | null | true |
AffineEquiv.ofBijective_apply | Mathlib.LinearAlgebra.AffineSpace.AffineEquiv | ∀ {k : Type u_1} {P₁ : Type u_2} {P₂ : Type u_3} {V₁ : Type u_6} {V₂ : Type u_7} [inst : Ring k]
[inst_1 : AddCommGroup V₁] [inst_2 : AddCommGroup V₂] [inst_3 : Module k V₁] [inst_4 : Module k V₂]
[inst_5 : AddTorsor V₁ P₁] [inst_6 : AddTorsor V₂ P₂] {φ : P₁ →ᵃ[k] P₂} (hφ : Function.Bijective ⇑φ) (a : P₁),
(Affin... | null | true |
Ordinal.preOmega_max | Mathlib.SetTheory.Cardinal.Aleph | ∀ (o₁ o₂ : Ordinal.{u_1}), Ordinal.preOmega (max o₁ o₂) = max (Ordinal.preOmega o₁) (Ordinal.preOmega o₂) | null | true |
Polynomial.powAddExpansion | Mathlib.Algebra.Polynomial.Identities | {R : Type u_1} →
[inst : CommSemiring R] → (x y : R) → (n : ℕ) → { k // (x + y) ^ n = x ^ n + ↑n * x ^ (n - 1) * y + k * y ^ 2 } | `(x + y)^n` can be expressed as `x^n + n*x^(n-1)*y + k * y^2` for some `k` in the ring.
| true |
FiberBundleCore.fiberBundle | Mathlib.Topology.FiberBundle.Basic | {ι : Type u_1} →
{B : Type u_2} →
{F : Type u_3} →
[inst : TopologicalSpace B] → [inst_1 : TopologicalSpace F] → (Z : FiberBundleCore ι B F) → FiberBundle F Z.Fiber | A fiber bundle constructed from core is indeed a fiber bundle. | true |
_private.Init.Data.List.TakeDrop.0.List.take_left.match_1_1 | Init.Data.List.TakeDrop | ∀ {α : Type u_1} (motive : List α → List α → Prop) (x x_1 : List α),
(∀ (x : List α), motive [] x) → (∀ (a : α) (tail x : List α), motive (a :: tail) x) → motive x x_1 | null | false |
Lean.Syntax.ident.elim | Init.Prelude | {motive_1 : Lean.Syntax → Sort u} →
(t : Lean.Syntax) →
t.ctorIdx = 3 →
((info : Lean.SourceInfo) →
(rawVal : Substring.Raw) →
(val : Lean.Name) →
(preresolved : List Lean.Syntax.Preresolved) → motive_1 (Lean.Syntax.ident info rawVal val preresolved)) →
motive_1 t | null | false |
Set.mulIndicator_le' | Mathlib.Algebra.Order.Group.Indicator | ∀ {α : Type u_2} {M : Type u_3} [inst : LE M] [inst_1 : One M] {s : Set α} {f g : α → M},
(∀ a ∈ s, f a ≤ g a) → (∀ a ∉ s, 1 ≤ g a) → s.mulIndicator f ≤ g | null | true |
LinearMap.domRestrict₁₂_apply | Mathlib.LinearAlgebra.BilinearMap | ∀ {R : Type u_1} {R₂ : Type u_2} {S : Type u_3} {S₂ : Type u_4} [inst : Semiring R] [inst_1 : Semiring R₂]
[inst_2 : Semiring S] [inst_3 : Semiring S₂] {M : Type u_5} {N : Type u_7} {P : Type u_9} [inst_4 : AddCommMonoid M]
[inst_5 : AddCommMonoid N] [inst_6 : AddCommMonoid P] [inst_7 : Module R M] [inst_8 : Module... | null | true |
_private.Mathlib.Dynamics.PeriodicPts.Defs.0.Function.periodicOrbit_eq_nil_iff_not_periodic_pt._simp_1_4 | Mathlib.Dynamics.PeriodicPts.Defs | ∀ {n : ℕ}, (List.range n = []) = (n = 0) | null | false |
_private.Mathlib.RepresentationTheory.Rep.Basic.0.Rep.mk.noConfusion | Mathlib.RepresentationTheory.Rep.Basic | {k : Type u} →
{G : Type v} →
{inst : Semiring k} →
{inst_1 : Monoid G} →
{P : Sort u_1} →
{V : Type w} →
{hV1 : AddCommGroup V} →
{hV2 : Module k V} →
{ρ : Representation k G V} →
{V' : Type w} →
{hV1' : AddCo... | null | false |
CategoryTheory.Functor.OneHypercoverDenseData.essSurj | Mathlib.CategoryTheory.Sites.DenseSubsite.OneHypercoverDense | ∀ {C₀ : Type u₀} {C : Type u} [inst : CategoryTheory.Category.{v₀, u₀} C₀] [inst_1 : CategoryTheory.Category.{v, u} C]
{F : CategoryTheory.Functor C₀ C} {J₀ : CategoryTheory.GrothendieckTopology C₀}
{J : CategoryTheory.GrothendieckTopology C} (A : Type u') [inst_2 : CategoryTheory.Category.{v', u'} A]
[inst_3 : C... | null | true |
Matrix.coeff_det_one_add_X_smul_eq_sum_minors | Mathlib.LinearAlgebra.Matrix.Charpoly.Coeff | ∀ {R : Type u} [inst : CommRing R] {n : Type v} [inst_1 : DecidableEq n] [inst_2 : Fintype n] (M : Matrix n n R)
(k : ℕ),
(1 + Polynomial.X • M.map ⇑Polynomial.C).det.coeff k =
∑ s ∈ Finset.powersetCard k Finset.univ, (M.submatrix Subtype.val Subtype.val).det | The k-th coefficient of `det (1 + X • M)` equals the sum of all k×k principal minors of M.
This generalizes `coeff_det_one_add_X_smul_one` (the k = 1 case, which gives the trace)
and `det_eq_sign_charpoly_coeff` (the k = n case, which gives the determinant). | true |
_private.Lean.Elab.Tactic.NormCast.0.Lean.Elab.Tactic.NormCast.evalNormCast0._regBuiltin.Lean.Elab.Tactic.NormCast.evalNormCast0_1 | Lean.Elab.Tactic.NormCast | IO Unit | null | false |
HahnEmbedding.Partial.sSup | Mathlib.Algebra.Order.Module.HahnEmbedding | {K : Type u_1} →
[inst : DivisionRing K] →
[inst_1 : LinearOrder K] →
[inst_2 : IsOrderedRing K] →
[inst_3 : Archimedean K] →
{M : Type u_2} →
[inst_4 : AddCommGroup M] →
[inst_5 : LinearOrder M] →
[inst_6 : IsOrderedAddMonoid M] →
... | Promote `HahnEmbedding.Partial.sSupFun` to a `HahnEmbedding.Partial`. | true |
IsSimpleOrder.eq_bot_or_eq_top | Mathlib.Order.Atoms | ∀ {α : Type u_4} {inst : LE α} {inst_1 : BoundedOrder α} [self : IsSimpleOrder α] (a : α), a = ⊥ ∨ a = ⊤ | Every element is either `⊥` or `⊤` | true |
_private.Mathlib.Algebra.Order.Field.Power.0.Mathlib.Meta.Positivity.evalZPow._proof_2 | Mathlib.Algebra.Order.Field.Power | ∀ {u : Lean.Level} {α : Q(Type u)} (pα : Q(PartialOrder «$α»)) (_a : Q(LinearOrder «$α»)),
«$pα» =Q instDistribLatticeOfLinearOrder.toSemilatticeInf.toPartialOrder | null | false |
List.takeD | Batteries.Data.List.Basic | {α : Type u_1} → ℕ → List α → α → List α | Take `n` elements from a list `l`. If `l` has less than `n` elements, append `n - length l`
elements `x`.
| true |
Lean.instNonemptyKeyedDeclsAttribute | Lean.KeyedDeclsAttribute | ∀ {γ : Type}, Nonempty (Lean.KeyedDeclsAttribute γ) | null | true |
_private.Mathlib.Topology.Order.Basic.0.exists_countable_generateFrom_Ioi_Iio._simp_1_2 | Mathlib.Topology.Order.Basic | ∀ {α : Sort u_1} {β : Sort u_2} {f : α → β} {p : α → Prop} {q : β → Prop},
(∃ b, (∃ a, p a ∧ f a = b) ∧ q b) = ∃ a, p a ∧ q (f a) | null | false |
UInt16.lt_add_one | Init.Data.UInt.Lemmas | ∀ {c : UInt16}, c ≠ -1 → c < c + 1 | null | true |
_private.Mathlib.Probability.Distributions.Poisson.Basic.0.ProbabilityTheory.map_cast_poissonMeasure_conv_real | Mathlib.Probability.Distributions.Poisson.Basic | ∀ (r₁ r₂ : NNReal),
(MeasureTheory.Measure.map Nat.cast (ProbabilityTheory.poissonMeasure r₁)).conv
(MeasureTheory.Measure.map Nat.cast (ProbabilityTheory.poissonMeasure r₂)) =
MeasureTheory.Measure.map Nat.cast (ProbabilityTheory.poissonMeasure (r₁ + r₂)) | null | true |
Subring.rec | Mathlib.Algebra.Ring.Subring.Defs | {R : Type u} →
[inst : NonAssocRing R] →
{motive : Subring R → Sort u_1} →
((toSubsemiring : Subsemiring R) →
(neg_mem' : ∀ {x : R}, x ∈ toSubsemiring.carrier → -x ∈ toSubsemiring.carrier) →
motive { toSubsemiring := toSubsemiring, neg_mem' := neg_mem' }) →
(t : Subring R) → mo... | null | false |
_private.Init.Data.Iterators.Lemmas.Combinators.FilterMap.0.Std.Iter.val_step_filterMap.match_1.eq_1 | Init.Data.Iterators.Lemmas.Combinators.FilterMap | ∀ {γ : Type u_1} (motive : Option γ → Sort u_2) (h_1 : Unit → motive none) (h_2 : (out' : γ) → motive (some out')),
(match none with
| none => h_1 ()
| some out' => h_2 out') =
h_1 () | null | true |
instLawfulMonadContOptionT | Mathlib.Control.Monad.Cont | ∀ {m : Type u → Type v} [inst : Monad m] [inst_1 : MonadCont m] [LawfulMonadCont m], LawfulMonadCont (OptionT m) | null | true |
UniformEquiv.piCongrLeft | Mathlib.Topology.UniformSpace.Equiv | {ι : Type u_4} →
{ι' : Type u_5} →
{β : ι' → Type u_6} →
[inst : (j : ι') → UniformSpace (β j)] → (e : ι ≃ ι') → ((i : ι) → β (e i)) ≃ᵤ ((j : ι') → β j) | `Equiv.piCongrLeft` as a uniform isomorphism: this is the natural isomorphism
`Π i, β (e i) ≃ᵤ Π j, β j` obtained from a bijection `ι ≃ ι'`. | true |
_private.Lean.Meta.Tactic.Grind.Order.StructId.0.Lean.Meta.Grind.Order.getInst? | Lean.Meta.Tactic.Grind.Order.StructId | Lean.Name → Lean.Level → Lean.Expr → Lean.Meta.Grind.GoalM (Option Lean.Expr) | null | true |
«term_ᵈᵃᵃ» | Mathlib.GroupTheory.GroupAction.DomAct.Basic | Lean.TrailingParserDescr | If `M` additively acts on `α`, then `DomAddAct M` acts on `α → β` as
well as some bundled maps from `α`. This is a type synonym for `AddOpposite M`, so this corresponds
to a right action of `M`. | true |
Std.DTreeMap.Internal.Impl.getEntryGE?ₘ'.eq_1 | Std.Data.DTreeMap.Internal.Model | ∀ {α : Type u} {β : α → Type v} [inst : Ord α] (k : α) (t : Std.DTreeMap.Internal.Impl α β),
Std.DTreeMap.Internal.Impl.getEntryGE?ₘ' k t =
Std.DTreeMap.Internal.Impl.explore (compare k) none
(fun x x_1 =>
match x, x_1 with
| x, Std.DTreeMap.Internal.Impl.ExplorationStep.lt k' a v a_1 => som... | null | true |
_private.Lean.Elab.PreDefinition.WF.Preprocess.0._regBuiltin.Lean.Elab.WF.paramProj.declare_26._@.Lean.Elab.PreDefinition.WF.Preprocess.184633683._hygCtx._hyg.12 | Lean.Elab.PreDefinition.WF.Preprocess | IO Unit | null | false |
_private.Mathlib.Order.Filter.ENNReal.0.NNReal.toReal_liminf._simp_1_6 | Mathlib.Order.Filter.ENNReal | ∀ {q : NNReal}, (0 ≤ ↑q) = True | null | false |
Lean.ExternEntry.adhoc.sizeOf_spec | Lean.Compiler.ExternAttr | ∀ (backend : Lean.Name), sizeOf (Lean.ExternEntry.adhoc backend) = 1 + sizeOf backend | null | true |
_private.Std.Data.DTreeMap.Internal.Lemmas.0.Std.DTreeMap.Internal.Impl.Const.get!_inter_of_contains_eq_false_left._simp_1_3 | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {β : α → Type v} {x : Ord α} {t : Std.DTreeMap.Internal.Impl α β} {k : α},
(k ∈ t) = (Std.DTreeMap.Internal.Impl.contains k t = true) | null | false |
LocallyConstant.mulIndicator_apply | Mathlib.Topology.LocallyConstant.Basic | ∀ {X : Type u_1} [inst : TopologicalSpace X] {R : Type u_5} [inst_1 : One R] {U : Set X} (f : LocallyConstant X R)
(hU : IsClopen U) (x : X), (f.mulIndicator hU) x = U.mulIndicator (⇑f) x | null | true |
_private.Mathlib.AlgebraicGeometry.EllipticCurve.Affine.AddSubMap.0.WeierstrassCurve.addSubMapCoeff._proof_11 | Mathlib.AlgebraicGeometry.EllipticCurve.Affine.AddSubMap | (63 + 1).AtLeastTwo | null | false |
MeasureTheory.FiniteMeasure.map_prod_map | Mathlib.MeasureTheory.Measure.FiniteMeasureProd | ∀ {α : Type u_1} [inst : MeasurableSpace α] {β : Type u_2} [inst_1 : MeasurableSpace β]
(μ : MeasureTheory.FiniteMeasure α) (ν : MeasureTheory.FiniteMeasure β) {α' : Type u_3} [inst_2 : MeasurableSpace α']
{β' : Type u_4} [inst_3 : MeasurableSpace β'] {f : α → α'} {g : β → β'},
Measurable f → Measurable g → (μ.ma... | null | true |
Lean.PersistentHashMap.isUnaryEntries | Lean.Data.PersistentHashMap | {α : Type u_1} →
{β : Type u_2} →
Array (Lean.PersistentHashMap.Entry α β (Lean.PersistentHashMap.Node α β)) → ℕ → Option (α × β) → Option (α × β) | null | true |
_private.Mathlib.Data.Fintype.Sets.0.Set.disjoint_toFinset._simp_1_1 | Mathlib.Data.Fintype.Sets | ∀ {α : Type u_2} {s t : Finset α}, Disjoint s t = Disjoint ↑s ↑t | null | false |
List.length_eraseIdx | Init.Data.List.Erase | ∀ {α : Type u_1} {l : List α} {i : ℕ}, (l.eraseIdx i).length = if i < l.length then l.length - 1 else l.length | null | true |
coe_setBasisOfLinearIndependentOfCardEqFinrank | Mathlib.LinearAlgebra.FiniteDimensional.Lemmas | ∀ {K : Type u} {V : Type v} [inst : DivisionRing K] [inst_1 : AddCommGroup V] [inst_2 : Module K V] {s : Set V}
[inst_3 : Nonempty ↑s] [inst_4 : Fintype ↑s] (lin_ind : LinearIndependent K Subtype.val)
(card_eq : s.toFinset.card = Module.finrank K V),
⇑(setBasisOfLinearIndependentOfCardEqFinrank lin_ind card_eq) =... | null | true |
_private.Mathlib.CategoryTheory.WithTerminal.Cone.0.CategoryTheory.WithInitial.liftFromUnderComp.match_1.eq_1 | Mathlib.CategoryTheory.WithTerminal.Cone | ∀ {J : Type u_1} (motive : CategoryTheory.WithInitial J → Sort u_2)
(h_1 : Unit → motive CategoryTheory.WithInitial.star) (h_2 : (a : J) → motive (CategoryTheory.WithInitial.of a)),
(match CategoryTheory.WithInitial.star with
| CategoryTheory.WithInitial.star => h_1 ()
| CategoryTheory.WithInitial.of a => h... | null | true |
Lean.PrettyPrinter.Delaborator.TopDownAnalyze.isTrivialBottomUp | Lean.PrettyPrinter.Delaborator.TopDownAnalyze | Lean.Expr → Lean.PrettyPrinter.Delaborator.TopDownAnalyze.AnalyzeM Bool | null | true |
RelUpperSet.isRelUpperSet' | Mathlib.Order.Defs.Unbundled | ∀ {α : Type u_1} [inst : LE α] {P : α → Prop} (self : RelUpperSet P), IsRelUpperSet self.carrier P | The carrier of a `RelUpperSet` is an upper set relative to `P`.
Do NOT use directly. Please use `RelUpperSet.isRelUpperSet` instead. | true |
BoxIntegral.BoxAdditiveMap.rec | Mathlib.Analysis.BoxIntegral.Partition.Additive | {ι : Type u_3} →
{M : Type u_4} →
[inst : AddCommMonoid M] →
{I : WithTop (BoxIntegral.Box ι)} →
{motive : BoxIntegral.BoxAdditiveMap ι M I → Sort u} →
((toFun : BoxIntegral.Box ι → M) →
(sum_partition_boxes' :
∀ (J : BoxIntegral.Box ι),
... | null | false |
Lean.Environment.containsOnBranch | Lean.Environment | Lean.Environment → Lean.Name → Bool | Checks whether the given declaration is known on the current branch, in which case `findAsync?` will
not block.
| true |
Std.DTreeMap.Internal.Impl.Balanced.one_le | Std.Data.DTreeMap.Internal.Balanced | ∀ {α : Type u} {β : α → Type v} {sz : ℕ} {k : α} {v : β k} {l r : Std.DTreeMap.Internal.Impl α β},
(Std.DTreeMap.Internal.Impl.inner sz k v l r).Balanced → 1 ≤ sz | null | true |
TwoSidedIdeal.orderIsoRingCon_apply | Mathlib.RingTheory.TwoSidedIdeal.Basic | ∀ {R : Type u_1} [inst : NonUnitalNonAssocRing R] (self : TwoSidedIdeal R),
TwoSidedIdeal.orderIsoRingCon self = self.ringCon | null | true |
CategoryTheory.Limits.HasCountableLimits.mk._flat_ctor | Mathlib.CategoryTheory.Limits.Shapes.Countable | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C],
autoParam
(∀ (J : Type) [inst_1 : CategoryTheory.SmallCategory J] [CategoryTheory.CountableCategory J],
CategoryTheory.Limits.HasLimitsOfShape J C)
CategoryTheory.Limits.HasCountableLimits.out._autoParam →
CategoryTheory.Limits.Ha... | null | false |
MeromorphicNFAt.meromorphicAt | Mathlib.Analysis.Meromorphic.NormalForm | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {f : 𝕜 → E} {x : 𝕜}, MeromorphicNFAt f x → MeromorphicAt f x | If a function is meromorphic in normal form at `x`, then it is meromorphic at `x`. | true |
_private.Std.Data.DTreeMap.Internal.Lemmas.0.Std.DTreeMap.Internal.Impl.Const.getD_map_of_getKey?_eq_some._simp_1_3 | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {β : α → Type v} {x : Ord α} {t : Std.DTreeMap.Internal.Impl α β} {k : α},
(k ∈ t) = (Std.DTreeMap.Internal.Impl.contains k t = true) | null | false |
_private.Init.Data.Int.DivMod.Bootstrap.0.Int.add_mul_ediv_right.match_1_3 | Init.Data.Int.DivMod.Bootstrap | ∀ (motive : (c : ℤ) → (∃ n, c = ↑n + 1) → ℤ → 0 < c → Prop) (c : ℤ) (x : ∃ n, c = ↑n + 1) (b : ℤ) (H : 0 < c),
(∀ (w a : ℕ) (H : 0 < ↑w + 1), motive (↑w + 1) ⋯ (Int.ofNat a) H) →
(∀ (k n : ℕ) (H : 0 < ↑k + 1), motive (↑k + 1) ⋯ (Int.negSucc n) H) → motive c x b H | null | false |
_private.Mathlib.Order.GaloisConnection.Basic.0.isLUB_image2_of_isLUB_isLUB._simp_1_3 | Mathlib.Order.GaloisConnection.Basic | ∀ {α : Type u_1} {β : Type u_3} {γ : Type u_5} {f : α → β → γ} {s : Set α} {t : Set β} {p : γ → Prop},
(∀ z ∈ Set.image2 f s t, p z) = ∀ x ∈ s, ∀ y ∈ t, p (f x y) | null | false |
Matrix.single_apply_of_ne | Mathlib.Data.Matrix.Basis | ∀ {m : Type u_2} {n : Type u_3} {α : Type u_7} [inst : DecidableEq m] [inst_1 : DecidableEq n] [inst_2 : Zero α] (i : m)
(j : n) (c : α) (i' : m) (j' : n), ¬(i = i' ∧ j = j') → Matrix.single i j c i' j' = 0 | null | true |
Nat.Linear.Expr.var.inj | Init.Data.Nat.Linear | ∀ {i i_1 : Nat.Linear.Var}, Nat.Linear.Expr.var i = Nat.Linear.Expr.var i_1 → i = i_1 | null | true |
Lean.Lsp.instFromJsonPrepareRenameParams | Lean.Data.Lsp.LanguageFeatures | Lean.FromJson Lean.Lsp.PrepareRenameParams | null | true |
Std.TreeMap.Raw.maxKey?_eq_none_iff._simp_1 | Std.Data.TreeMap.Raw.Lemmas | ∀ {α : Type u} {β : Type v} {cmp : α → α → Ordering} {t : Std.TreeMap.Raw α β cmp} [Std.TransCmp cmp],
t.WF → (t.maxKey? = none) = (t.isEmpty = true) | null | false |
AddMonoidHom.smul | Mathlib.Algebra.Module.Hom | {R : Type u_1} → {M : Type u_3} → [inst : Semiring R] → [inst_1 : AddCommMonoid M] → [Module R M] → R →+ M →+ M | Scalar multiplication as a biadditive monoid homomorphism. We need `M` to be commutative
to have addition on `M →+ M`. | true |
Finmap.sigma_keys_lookup | Mathlib.Data.Finmap | ∀ {α : Type u} {β : α → Type v} [inst : DecidableEq α] (s : Finmap β),
(s.keys.sigma fun i => (Finmap.lookup i s).toFinset) = { val := s.entries, nodup := ⋯ } | null | true |
Lean.Elab.Term.ElabElimInfo.ctorIdx | Lean.Elab.App | Lean.Elab.Term.ElabElimInfo → ℕ | null | false |
Filter.Tendsto.atBot_mul_eventuallyLE_one | Mathlib.Order.Filter.AtTopBot.Monoid | ∀ {α : Type u_1} {M : Type u_2} [inst : CommMonoid M] [inst_1 : Preorder M] [IsOrderedMonoid M] {l : Filter α}
{f g : α → M}, Filter.Tendsto f l Filter.atBot → g ≤ᶠ[l] 1 → Filter.Tendsto (fun x => f x * g x) l Filter.atBot | null | true |
Polynomial.isSplittingField_C | Mathlib.FieldTheory.SplittingField.IsSplittingField | ∀ {K : Type v} [inst : Field K] (a : K), Polynomial.IsSplittingField K K (Polynomial.C a) | null | true |
Std.DHashMap.size_inter_le_size_right | Std.Data.DHashMap.Lemmas | ∀ {α : Type u} {β : α → Type v} {x : BEq α} {x_1 : Hashable α} {m₁ m₂ : Std.DHashMap α β} [EquivBEq α]
[LawfulHashable α], (m₁ ∩ m₂).size ≤ m₂.size | null | true |
Monoid.PushoutI.NormalWord.Transversal.mk.noConfusion | Mathlib.GroupTheory.PushoutI | {ι : Type u_1} →
{G : ι → Type u_2} →
{H : Type u_3} →
{inst : (i : ι) → Group (G i)} →
{inst_1 : Group H} →
{φ : (i : ι) → H →* G i} →
{P : Sort u} →
{injective : ∀ (i : ι), Function.Injective ⇑(φ i)} →
{set : (i : ι) → Set (G i)} →
... | null | false |
_private.Mathlib.Algebra.Ring.CentroidHom.0.CentroidHom._aux_Mathlib_Algebra_Ring_CentroidHom___macroRules__private_Mathlib_Algebra_Ring_CentroidHom_0_CentroidHom_termL_1 | Mathlib.Algebra.Ring.CentroidHom | Lean.Macro | null | false |
doublyStochastic.congr_simp | Mathlib.Analysis.Convex.DoublyStochasticMatrix | ∀ (R : Type u_3) (n : Type u_4) [inst : Fintype n] [inst_1 : DecidableEq n] [inst_2 : Semiring R]
[inst_3 : PartialOrder R] [inst_4 : IsOrderedRing R], doublyStochastic R n = doublyStochastic R n | null | true |
_private.Mathlib.SetTheory.Cardinal.Cofinality.Club.0.IsClub.sInter._proof_1_4 | Mathlib.SetTheory.Cardinal.Cofinality.Club | ∀ {α : Type u_1} [inst : LinearOrder α] [inst_1 : WellFoundedLT α] (h : Nonempty α) (s : Set α),
¬BddBelow s → sInf s = sInf ∅ | null | false |
_private.Mathlib.Analysis.CStarAlgebra.CStarMatrix.0.CStarMatrix.instFinite._proof_1 | Mathlib.Analysis.CStarAlgebra.CStarMatrix | ∀ {n : Type u_2} {m : Type u_3} [Finite m] [Finite n] (α : Type u_1) [Finite α], Finite (CStarMatrix m n α) | null | false |
Submodule.exists_sub_one_mem_and_smul_eq_zero_of_fg_of_le_smul | Mathlib.RingTheory.Finiteness.Nakayama | ∀ {R : Type u_1} [inst : CommRing R] {M : Type u_2} [inst_1 : AddCommGroup M] [inst_2 : Module R M] (I : Ideal R)
(N : Submodule R M), N.FG → N ≤ I • N → ∃ r, r - 1 ∈ I ∧ ∀ n ∈ N, r • n = 0 | **Nakayama's Lemma**. Atiyah-Macdonald 2.5, Eisenbud 4.7, Matsumura 2.2. | true |
RingHom.liftOfRightInverse._proof_5 | Mathlib.RingTheory.Ideal.Maps | ∀ {A : Type u_3} {B : Type u_1} {C : Type u_2} [inst : Ring A] [inst_1 : Ring B] [inst_2 : Ring C] (f : A →+* B)
(f_inv : B → A) (hf : Function.RightInverse f_inv ⇑f) (φ : B →+* C),
(fun g => f.liftOfRightInverseAux f_inv hf ↑g ⋯) ((fun φ => ⟨φ.comp f, ⋯⟩) φ) = φ | null | false |
_private.Std.Data.Internal.List.Associative.0.Std.Internal.List.getValueCast_mem._simp_1_5 | Std.Data.Internal.List.Associative | ∀ {α : Type u} {β : α → Type v} {x y : Sigma β}, (x = y) = (x.fst = y.fst ∧ x.snd ≍ y.snd) | null | false |
Projectivization.Subspace.instCompleteLattice | Mathlib.LinearAlgebra.Projectivization.Subspace | {K : Type u_1} →
{V : Type u_2} →
[inst : DivisionRing K] →
[inst_1 : AddCommGroup V] → [inst_2 : Module K V] → CompleteLattice (Projectivization.Subspace K V) | The subspaces of a projective space form a complete lattice. | true |
_aux_Mathlib_Algebra_Module_LinearMap_Defs___unexpand_LinearMap_1 | Mathlib.Algebra.Module.LinearMap.Defs | Lean.PrettyPrinter.Unexpander | null | false |
Action.instIsIsoHomInv | Mathlib.CategoryTheory.Action.Basic | ∀ {V : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} V] {G : Type u_2} [inst_1 : Monoid G] {M N : Action V G}
(f : M ≅ N), CategoryTheory.IsIso f.inv.hom | null | true |
AlgebraicTopology.DoldKan.HigherFacesVanish.induction | Mathlib.AlgebraicTopology.DoldKan.Faces | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Preadditive C]
{X : CategoryTheory.SimplicialObject C} {Y : C} {n q : ℕ} {φ : Y ⟶ X.obj (Opposite.op { len := n + 1 })},
AlgebraicTopology.DoldKan.HigherFacesVanish q φ →
AlgebraicTopology.DoldKan.HigherFacesVanish (q + 1)
... | null | true |
Lean.Parser.Term.open.parenthesizer | Lean.Parser.Command | Lean.PrettyPrinter.Parenthesizer | null | true |
SpecialLinearGroup.centerEquivRootsOfUnity.eq_1 | Mathlib.LinearAlgebra.SpecialLinearGroup | ∀ {R : Type u_1} {V : Type u_2} [inst : CommRing R] [inst_1 : AddCommGroup V] [inst_2 : Module R V]
[inst_3 : Module.Free R V] [inst_4 : Module.Finite R V],
SpecialLinearGroup.centerEquivRootsOfUnity =
{
toFun := fun g =>
⋯.by_cases (fun x => 1) fun hR =>
⋯.by_cases (fun x => 1) fun hV =... | null | true |
LinearMap.mkContinuous_coe | Mathlib.Analysis.Normed.Operator.ContinuousLinearMap | ∀ {𝕜 : Type u_1} {𝕜₂ : Type u_2} {E : Type u_3} {F : Type u_4} [inst : Ring 𝕜] [inst_1 : Ring 𝕜₂]
[inst_2 : SeminormedAddCommGroup E] [inst_3 : SeminormedAddCommGroup F] [inst_4 : Module 𝕜 E] [inst_5 : Module 𝕜₂ F]
{σ : 𝕜 →+* 𝕜₂} (f : E →ₛₗ[σ] F) (C : ℝ) (h : ∀ (x : E), ‖f x‖ ≤ C * ‖x‖), ↑(f.mkContinuous C ... | null | true |
hnot_sup_self | Mathlib.Order.Heyting.Basic | ∀ {α : Type u_2} [inst : CoheytingAlgebra α] (a : α), ￢a ⊔ a = ⊤ | null | true |
Equiv.traverse.eq_1 | Mathlib.Control.Traversable.Equiv | ∀ {t t' : Type u → Type u} (eqv : (α : Type u) → t α ≃ t' α) [inst : Traversable t] {m : Type u → Type u}
[inst_1 : Applicative m] {α β : Type u} (f : α → m β) (x : t' α),
Equiv.traverse eqv f x = ⇑(eqv β) <$> traverse f ((eqv α).symm x) | null | true |
MvPolynomial.pderiv_X_of_ne | Mathlib.Algebra.MvPolynomial.PDeriv | ∀ {R : Type u} {σ : Type v} [inst : CommSemiring R] {i j : σ}, j ≠ i → (MvPolynomial.pderiv i) (MvPolynomial.X j) = 0 | null | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.