name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
_private.Std.Time.Format.Basic.0.Std.Time.GenericFormat.DateBuilder.G._default | Std.Time.Format.Basic | Option Std.Time.Year.Era | null | false |
Matroid.restrict_empty | Mathlib.Combinatorics.Matroid.Constructions | ∀ {α : Type u_1} (M : Matroid α), M.restrict ∅ = Matroid.emptyOn α | null | true |
instFromJsonRpcEncodablePacket.fromJson._@.Mathlib.Tactic.Widget.Calc.3238076937._hygCtx._hyg.20 | Mathlib.Tactic.Widget.Calc | Lean.Json → Except String RpcEncodablePacket✝ | null | false |
CategoryTheory.Equivalence.sheafCongrPrecoherent | Mathlib.CategoryTheory.Sites.Coherent.Equivalence | {C : Type u_1} →
[inst : CategoryTheory.Category.{v_1, u_1} C] →
{D : Type u_2} →
[inst_1 : CategoryTheory.Category.{v_2, u_2} D] →
[inst_2 : CategoryTheory.Precoherent C] →
(A : Type u_3) →
[inst_3 : CategoryTheory.Category.{v_3, u_3} A] →
(e : C ≌ D) →
... | Equivalent precoherent categories give equivalent coherent toposes.
| true |
IsPathConnected.subset_pathComponent | Mathlib.Topology.Connected.PathConnected | ∀ {X : Type u_1} [inst : TopologicalSpace X] {x : X} {F : Set X}, IsPathConnected F → x ∈ F → F ⊆ pathComponent x | null | true |
Perfection.lift._proof_13 | Mathlib.RingTheory.Perfection | ∀ (p : ℕ) [hp : Fact (Nat.Prime p)] (R : Type u_2) [inst : CommSemiring R] [inst_1 : CharP R p]
[inst_2 : PerfectRing R p] (S : Type u_1) [inst_3 : CommSemiring S] [inst_4 : CharP S p] (f : R →+* S) (x x_1 : R),
⟨fun n => f ((⇑↑(frobeniusEquiv R p).symm)^[n] (x + x_1)), ⋯⟩ =
⟨fun n => f ((⇑↑(frobeniusEquiv R p)... | null | false |
_private.Init.Data.BitVec.Bitblast.0.BitVec.getElem_sdiv.match_1.eq_3 | Init.Data.BitVec.Bitblast | ∀ (motive : Bool → Bool → Sort u_1) (h_1 : Unit → motive false false) (h_2 : Unit → motive false true)
(h_3 : Unit → motive true false) (h_4 : Unit → motive true true),
(match true, false with
| false, false => h_1 ()
| false, true => h_2 ()
| true, false => h_3 ()
| true, true => h_4 ()) =
h_3 ... | null | true |
Preperfect.eq_1 | Mathlib.Topology.Perfect | ∀ {α : Type u_1} [inst : TopologicalSpace α] (C : Set α), Preperfect C = ∀ x ∈ C, AccPt x (Filter.principal C) | null | true |
Submonoid.LocalizationMap.lift_spec | Mathlib.GroupTheory.MonoidLocalization.Maps | ∀ {M : Type u_1} [inst : CommMonoid M] {S : Submonoid M} {N : Type u_2} [inst_1 : CommMonoid N] {P : Type u_3}
[inst_2 : CommMonoid P] (f : S.LocalizationMap N) {g : M →* P} (hg : ∀ (y : ↥S), IsUnit (g ↑y)) (z : N) (v : P),
(f.lift hg) z = v ↔ g (f.sec z).1 = g ↑(f.sec z).2 * v | Given a Localization map `f : M →* N` for a Submonoid `S ⊆ M`, if a `CommMonoid` map
`g : M →* P` induces a map `f.lift hg : N →* P` then for all `z : N, v : P`, we have
`f.lift hg z = v ↔ g x = g y * v`, where `x : M, y ∈ S` are such that `z * f y = f x`. | true |
_private.Lean.Elab.MutualInductive.0.Lean.Elab.Command.elabHeadersAux._unsafe_rec | Lean.Elab.MutualInductive | Array Lean.Elab.Command.InductiveView →
ℕ → Array Lean.Elab.Command.PreElabHeaderResult → Lean.Elab.TermElabM (Array Lean.Elab.Command.PreElabHeaderResult) | null | false |
SchwartzMap.norm_toBoundedContinuousFunction_le | Mathlib.Analysis.Distribution.SchwartzSpace.Basic | ∀ {E : Type u_5} {F : Type u_6} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E] [inst_2 : NormedAddCommGroup F]
[inst_3 : NormedSpace ℝ F] (f : SchwartzMap E F), ‖f.toBoundedContinuousFunction‖ ≤ (SchwartzMap.seminorm ℝ 0 0) f | null | true |
WithTop.toDualBotEquiv._proof_1 | Mathlib.Order.Hom.WithTopBot | ∀ {α : Type u_1} (a : WithTop αᵒᵈ),
(fun a => WithBot.recBotCoe ⊤ (fun a => ↑(OrderDual.toDual a)) (OrderDual.ofDual a))
((fun a => OrderDual.toDual (WithTop.recTopCoe ⊥ (fun a => ↑(OrderDual.ofDual a)) a)) a) =
a | null | false |
Std.Tactic.BVDecide.BVExpr.bitblast.blastArithShiftRight | Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.ShiftRight | {α : Type} →
[inst : Hashable α] →
[inst_1 : DecidableEq α] →
{w : ℕ} → (aig : Std.Sat.AIG α) → aig.ArbitraryShiftTarget w → Std.Sat.AIG.RefVecEntry α w | null | true |
Std.Tactic.BVDecide.BVExpr.bitblast.ExtractAndExtendBitTarget.rec | Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Cpop | {α : Type} →
[inst : Hashable α] →
[inst_1 : DecidableEq α] →
{aig : Std.Sat.AIG α} →
{w : ℕ} →
{motive : Std.Tactic.BVDecide.BVExpr.bitblast.ExtractAndExtendBitTarget aig w → Sort u} →
((start : ℕ) → (x : aig.RefVec w) → motive { start := start, x := x }) →
(t : ... | null | false |
AlgebraicGeometry.morphismRestrictStalkMap | Mathlib.AlgebraicGeometry.Restrict | {X Y : AlgebraicGeometry.Scheme} →
(f : X ⟶ Y) →
(U : Y.Opens) →
(x : ↥↑((TopologicalSpace.Opens.map f.base).obj U)) →
CategoryTheory.Arrow.mk (AlgebraicGeometry.Scheme.Hom.stalkMap (f ∣_ U) x) ≅
CategoryTheory.Arrow.mk (AlgebraicGeometry.Scheme.Hom.stalkMap f ↑x) | The stalk map of a restriction of a morphism is isomorphic to the stalk map of the original map.
| true |
_private.Init.Grind.Ring.Basic.0.Lean.Grind.IsCharP.mk'_aux._proof_1_2 | Init.Grind.Ring.Basic | ∀ {x y : ℕ} (p : ℕ), ¬p = 0 → ¬0 < p → False | null | false |
TopologicalSpace.NonemptyCompacts.toCloseds | Mathlib.Topology.Sets.Compacts | {α : Type u_1} →
[inst : TopologicalSpace α] → [T2Space α] → TopologicalSpace.NonemptyCompacts α → TopologicalSpace.Closeds α | Reinterpret a nonempty compact as a closed set. | true |
Aesop.Nanos.noConfusion | Aesop.Nanos | {P : Sort u} → {t t' : Aesop.Nanos} → t = t' → Aesop.Nanos.noConfusionType P t t' | null | false |
ProofWidgets.RefreshComponent.RefreshState.noConfusionType | ProofWidgets.Component.RefreshComponent | Sort u → ProofWidgets.RefreshComponent.RefreshState → ProofWidgets.RefreshComponent.RefreshState → Sort u | null | false |
_private.Mathlib.Combinatorics.SimpleGraph.Triangle.Counting.0.SimpleGraph.good_vertices_triangle_card._simp_1_1 | Mathlib.Combinatorics.SimpleGraph.Triangle.Counting | ∀ {α : Type u_1} [inst : DecidableEq α] {s t : Finset α} {a : α}, (a ∈ s \ t) = (a ∈ s ∧ a ∉ t) | null | false |
Part.mem_some_iff | Mathlib.Data.Part | ∀ {α : Type u_1} {a b : α}, b ∈ Part.some a ↔ b = a | null | true |
Lean.Grind.CommRing.Expr.toPoly.eq_def | Init.Grind.Ring.CommSolver | ∀ (x : Lean.Grind.CommRing.Expr),
x.toPoly =
match x with
| Lean.Grind.CommRing.Expr.num k => Lean.Grind.CommRing.Poly.num k
| Lean.Grind.CommRing.Expr.intCast k => Lean.Grind.CommRing.Poly.num k
| Lean.Grind.CommRing.Expr.natCast k => Lean.Grind.CommRing.Poly.num ↑k
| Lean.Grind.CommRing.Expr.var... | null | true |
ProfiniteAddGrp.Hom._mkInternal.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 | false |
MaximalFor.le_of_le | Mathlib.Order.Defs.Unbundled | ∀ {ι : Sort u_1} {α : Type u_2} [inst : LE α] {P : ι → Prop} {f : ι → α} {i j : ι},
MaximalFor P f i → P j → f i ≤ f j → f j ≤ f i | null | true |
Lean.Kernel.Exception.appTypeMismatch.elim | Lean.Environment | {motive : Lean.Kernel.Exception → Sort u} →
(t : Lean.Kernel.Exception) →
t.ctorIdx = 9 →
((env : Lean.Kernel.Environment) →
(lctx : Lean.LocalContext) →
(app funType argType : Lean.Expr) →
motive (Lean.Kernel.Exception.appTypeMismatch env lctx app funType argType)) →
... | null | false |
Std.Time.instDecidableEqPlainDate | Std.Time.Date.PlainDate | DecidableEq Std.Time.PlainDate | null | true |
padicValNat.pow | Mathlib.NumberTheory.Padics.PadicVal.Basic | ∀ {p : ℕ} [hp : Fact (Nat.Prime p)] (a n : ℕ), padicValNat p (a ^ n) = n * padicValNat p a | A version of `padicValRat.pow` for `padicValNat`. | true |
Lean.Lsp.CompletionItemKind.rec | Lean.Data.Lsp.LanguageFeatures | {motive : Lean.Lsp.CompletionItemKind → Sort u} →
motive Lean.Lsp.CompletionItemKind.text →
motive Lean.Lsp.CompletionItemKind.method →
motive Lean.Lsp.CompletionItemKind.function →
motive Lean.Lsp.CompletionItemKind.constructor →
motive Lean.Lsp.CompletionItemKind.field →
moti... | null | false |
AlgebraicGeometry.Spec.germ_stalkMapIso_hom_assoc | Mathlib.AlgebraicGeometry.AffineScheme | ∀ {R : CommRingCat} (x : PrimeSpectrum ↑R) {Z : CommRingCat} (h : ↧(Localization.AtPrime x.asIdeal) ⟶ Z),
CategoryTheory.CategoryStruct.comp ((AlgebraicGeometry.Spec R).presheaf.germ ⊤ x trivial)
(CategoryTheory.CategoryStruct.comp (AlgebraicGeometry.Spec.stalkIso R x).hom h) =
CategoryTheory.CategoryStruct... | null | true |
SeparationQuotient.instMulAction.eq_1 | Mathlib.Topology.Algebra.SeparationQuotient.Basic | ∀ {M : Type u_1} {X : Type u_2} [inst : Monoid M] [inst_1 : MulAction M X] [inst_2 : TopologicalSpace X]
[inst_3 : ContinuousConstSMul M X],
SeparationQuotient.instMulAction = Function.Surjective.mulAction SeparationQuotient.mk ⋯ ⋯ | null | true |
ωCPO.of.noConfusion | Mathlib.Order.Category.OmegaCompletePartialOrder | {P : Sort u_1} →
{carrier : Type u} →
{str : OmegaCompletePartialOrder carrier} →
{carrier' : Type u} →
{str' : OmegaCompletePartialOrder carrier'} → ↧carrier = ↧carrier' → (carrier = carrier' → str ≍ str' → P) → P | null | false |
CategoryTheory.CosimplicialObject.δ_comp_σ_of_le_assoc | Mathlib.AlgebraicTopology.SimplicialObject.Basic | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] (X : CategoryTheory.CosimplicialObject C) {n : ℕ}
{i : Fin (n + 2)} {j : Fin (n + 1)},
i ≤ j.castSucc →
∀ {Z : C} (h : X.obj { len := n + 1 } ⟶ Z),
CategoryTheory.CategoryStruct.comp (X.δ i.castSucc) (CategoryTheory.CategoryStruct.comp (X.σ j.succ) ... | The second cosimplicial identity | true |
isClopen_sInter | Mathlib.Topology.AlexandrovDiscrete | ∀ {α : Type u_3} [inst : TopologicalSpace α] [AlexandrovDiscrete α] {S : Set (Set α)},
(∀ s ∈ S, IsClopen s) → IsClopen (⋂₀ S) | null | true |
Lean.Syntax.brecOn_2 | Init.Prelude | {motive_1 : Lean.Syntax → Sort u} →
{motive_2 : Array Lean.Syntax → Sort u} →
{motive_3 : List Lean.Syntax → Sort u} →
(t : List Lean.Syntax) →
((t : Lean.Syntax) → t.below → motive_1 t) →
((t : Array Lean.Syntax) → Lean.Syntax.below_1 t → motive_2 t) →
((t : List Lean.Syntax) ... | null | false |
iSup_comm | Mathlib.Order.CompleteLattice.Basic | ∀ {α : Type u_1} {ι : Sort u_4} {ι' : Sort u_5} [inst : CompleteLattice α] {f : ι → ι' → α},
⨆ i, ⨆ j, f i j = ⨆ j, ⨆ i, f i j | null | true |
EReal.mul_eq_bot | Mathlib.Data.EReal.Operations | ∀ (a b : EReal), a * b = ⊥ ↔ a = ⊥ ∧ 0 < b ∨ 0 < a ∧ b = ⊥ ∨ a = ⊤ ∧ b < 0 ∨ a < 0 ∧ b = ⊤ | null | true |
MulOpposite.instSubNegMonoid._proof_3 | Mathlib.Algebra.Group.Opposite | ∀ {α : Type u_1} [inst : SubNegMonoid α] (x : αᵐᵒᵖ), MulOpposite.unop (-x) = MulOpposite.unop (-x) | null | false |
CategoryTheory.Functor.OplaxMonoidal.δ_comp_tensorHom_η_assoc | Mathlib.CategoryTheory.Monoidal.Functor | ∀ {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 D]
(F : CategoryTheory.Functor C D) [inst_4 : F.OplaxMonoidal] {X : C} {Y : D} (f : F.obj X ⟶ Y) {Z : D}
(h... | null | true |
Monoid.CoprodI.NeWord.below | Mathlib.GroupTheory.CoprodI | {ι : Type u_1} →
{M : ι → Type u_2} →
[inst : (i : ι) → Monoid (M i)] →
{motive : (a a_1 : ι) → Monoid.CoprodI.NeWord M a a_1 → Sort u} →
{a a_1 : ι} → Monoid.CoprodI.NeWord M a a_1 → Sort (max ((max u_1 u_2) + 1) u) | null | false |
Lean.Order.ImplicationOrder.instOrder | Init.Internal.Order.Basic | Lean.Order.PartialOrder Lean.Order.ImplicationOrder | null | true |
MeasureTheory.SimpleFunc.const_lintegral_restrict | Mathlib.MeasureTheory.Function.SimpleFunc | ∀ {α : Type u_1} {m : MeasurableSpace α} {μ : MeasureTheory.Measure α} (c : ENNReal) (s : Set α),
(MeasureTheory.SimpleFunc.const α c).lintegral (μ.restrict s) = c * μ s | null | true |
_private.Mathlib.Probability.Martingale.Upcrossing.0.MeasureTheory.upperCrossingTime.match_1.eq_2 | Mathlib.Probability.Martingale.Upcrossing | ∀ (motive : ℕ → Sort u_1) (n : ℕ) (h_1 : Unit → motive 0) (h_2 : (n : ℕ) → motive n.succ),
(match n.succ with
| 0 => h_1 ()
| n.succ => h_2 n) =
h_2 n | null | true |
CategoryTheory.Limits.preservesFiniteColimits_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]
(F : CategoryTheory.Functor Cᵒᵖ Dᵒᵖ) [CategoryTheory.Limits.PreservesFiniteLimits F.unop],
CategoryTheory.Limits.PreservesFiniteColimits F | If `F.unop : C ⥤ D` preserves finite limits, then `F : Cᵒᵖ ⥤ Dᵒᵖ` preserves finite colimits. | true |
Std.Http.URI.Host.recOn | Std.Http.Data.URI.Basic | {motive : Std.Http.URI.Host → Sort u} →
(t : Std.Http.URI.Host) →
((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)) → motive t | null | false |
_private.Init.Data.Nat.Gcd.0.Nat.dvdProdDvdOfDvdProd._proof_1 | Init.Data.Nat.Gcd | ∀ {k m : ℕ}, k.gcd m = 0 → 0 ∣ m | null | false |
Differentiable.div | Mathlib.Analysis.Calculus.Deriv.Inv | ∀ {𝕜 : Type u} [inst : NontriviallyNormedField 𝕜] {𝕜' : Type u_1} [inst_1 : NontriviallyNormedField 𝕜']
[inst_2 : NormedAlgebra 𝕜 𝕜'] {c d : 𝕜 → 𝕜'},
Differentiable 𝕜 c → Differentiable 𝕜 d → (∀ (x : 𝕜), d x ≠ 0) → Differentiable 𝕜 (c / d) | null | true |
_private.Mathlib.RingTheory.Extension.Cotangent.BaseChange.0.Algebra.tensorH1CotangentOfFlat._proof_5 | Mathlib.RingTheory.Extension.Cotangent.BaseChange | ∀ (R : Type u_3) (S : Type u_1) [inst : CommRing R] [inst_1 : CommRing S] [inst_2 : Algebra R S] (T : Type u_2)
[inst_3 : CommRing T] [inst_4 : Algebra R T],
IsScalarTower (TensorProduct R T S) (TensorProduct R T S)
(Algebra.Generators.self R S).toExtension.baseChange.Cotangent | null | false |
CompHausLike.LocallyConstant.functorToPresheavesIso._proof_2 | Mathlib.Condensed.Discrete.LocallyConstant | ∀ (P : TopCat → Prop) [CompHausLike.HasExplicitFiniteCoproducts P] [CompHausLike.HasExplicitPullbacks P],
(∀ ⦃X Y : CompHausLike P⦄ (f : X ⟶ Y),
CategoryTheory.EffectiveEpi f → Function.Surjective ⇑(CategoryTheory.ConcreteCategory.hom f)) →
CategoryTheory.Precoherent (CompHausLike P) | null | false |
Lean.QuotVal._sizeOf_inst | Lean.Declaration | SizeOf Lean.QuotVal | null | false |
AddLocalization.recOnSubsingleton₂ | Mathlib.GroupTheory.MonoidLocalization.Basic | {M : Type u_1} →
[inst : AddCommMonoid M] →
{S : AddSubmonoid M} →
{r : AddLocalization S → AddLocalization S → Sort u} →
[h : ∀ (a c : M) (b d : ↥S), Subsingleton (r (AddLocalization.mk a b) (AddLocalization.mk c d))] →
(x y : AddLocalization S) →
((a c : M) → (b d : ↥S) → r (... | Copy of `Quotient.recOnSubsingleton₂` for `AddLocalization` | true |
pinGroup.instStarMulSubtypeCliffordAlgebraMemSubmonoid._proof_2 | Mathlib.LinearAlgebra.CliffordAlgebra.SpinGroup | ∀ {R : Type u_1} [inst : CommRing R] {M : Type u_2} [inst_1 : AddCommGroup M] [inst_2 : Module R M]
{Q : QuadraticForm R M} (x x_1 : ↥(pinGroup Q)), star (x * x_1) = star x_1 * star x | null | false |
Lean.Lsp.CodeActionParams.partialResultToken?._inherited_default | Lean.Data.Lsp.CodeActions | Option Lean.Lsp.ProgressToken | null | false |
RestrictedProduct.continuousSMul | Mathlib.Topology.Algebra.RestrictedProduct.TopologicalSpace | ∀ {ι : Type u_1} (R : ι → Type u_2) {S : ι → Type u_3} [inst : (i : ι) → SetLike (S i) (R i)] {B : (i : ι) → S i}
[inst_1 : (i : ι) → TopologicalSpace (R i)] [hBopen : Fact (∀ (i : ι), IsOpen ↑(B i))] {G : Type u_4}
[inst_2 : TopologicalSpace G] [inst_3 : (i : ι) → SMul G (R i)] [inst_4 : ∀ (i : ι), SMulMemClass (S... | null | true |
WithTop.instSemigroupWithZero.eq_1 | Mathlib.Algebra.Order.Ring.WithTop | ∀ {α : Type u_1} [inst : DecidableEq α] [inst_1 : SemigroupWithZero α] [inst_2 : NoZeroDivisors α],
WithTop.instSemigroupWithZero =
{ toMul := WithTop.instMulZeroClass.toMul, mul_assoc := ⋯, toZero := WithTop.instMulZeroClass.toZero, zero_mul := ⋯,
mul_zero := ⋯ } | null | true |
Lean.Grind.ToInt | Init.Grind.ToInt | Type u → Type | TODO: delete this class (and this file) after the next `update-stage0`. The current
stage0 binary's `getToIntId?` still resolves the constant `Lean.Grind.ToInt` by name
while building the stage1 library; the class only needs to exist, no instances.
| true |
ProofWidgets.LayoutKind.block.elim | ProofWidgets.Data.Html | {motive : ProofWidgets.LayoutKind → Sort u} →
(t : ProofWidgets.LayoutKind) → t.ctorIdx = 0 → motive ProofWidgets.LayoutKind.block → motive t | null | false |
Fin.reduceFinMk | Lean.Meta.Tactic.Simp.BuiltinSimprocs.Fin | Lean.Meta.Simp.DSimproc | null | true |
_private.Mathlib.Tactic.CategoryTheory.Coherence.Normalize.0.Mathlib.Tactic.BicategoryLike.WhiskerRight.e.match_1 | Mathlib.Tactic.CategoryTheory.Coherence.Normalize | (motive : Mathlib.Tactic.BicategoryLike.WhiskerRight → Sort u_1) →
(x : Mathlib.Tactic.BicategoryLike.WhiskerRight) →
((η : Mathlib.Tactic.BicategoryLike.Atom) → motive (Mathlib.Tactic.BicategoryLike.WhiskerRight.of η)) →
((e : Mathlib.Tactic.BicategoryLike.Mor₂) →
(η : Mathlib.Tactic.BicategoryLi... | null | false |
Lean.Elab.Do.MutVar.ident | Lean.Elab.Do.Basic | Lean.Elab.Do.MutVar → Lean.Ident | The identifier of the `let mut` or `erased mut` declaration. | true |
Ideal.quotientRangePowQuotSuccInclusionEquiv._proof_2 | Mathlib.NumberTheory.RamificationInertia.Basic | ∀ {S : Type u_1} [inst : CommRing S] (P : Ideal S) {i : ℕ} (a : S),
a ∈ (fun x => P ^ x) i ∧ a ∉ (fun x => P ^ x) i.succ → a ∈ P ^ i | null | false |
Lean.Environment.setExporting | Lean.Environment | Lean.Environment → Bool → Lean.Environment | Updates `env.isExporting`. Ignored if `env.header.isModule` is false. | true |
CategoryTheory.InjectiveResolution.extMk._proof_5 | Mathlib.CategoryTheory.Abelian.Injective.Ext | IsRightCancelAdd ℕ | null | false |
implicitFunctionOfBivariate_def | Mathlib.Analysis.Calculus.ImplicitFunction.Bivariate | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] [inst_1 : IsRCLikeNormedField 𝕜] {E₁ : Type u_2}
[inst_2 : NormedAddCommGroup E₁] [inst_3 : NormedSpace 𝕜 E₁] [inst_4 : CompleteSpace E₁] {E₂ : Type u_3}
[inst_5 : NormedAddCommGroup E₂] [inst_6 : NormedSpace 𝕜 E₂] [inst_7 : CompleteSpace E₂] {F : Type u_4}
... | null | true |
CategoryTheory.Limits.ChosenPullback₃.pullback | Mathlib.CategoryTheory.Limits.Shapes.Pullback.ChosenPullback | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
{X₁ X₂ X₃ S : C} →
{f₁ : X₁ ⟶ S} →
{f₂ : X₂ ⟶ S} →
{f₃ : X₃ ⟶ S} →
{h₁₂ : CategoryTheory.Limits.ChosenPullback f₁ f₂} →
{h₂₃ : CategoryTheory.Limits.ChosenPullback f₂ f₃} →
{h₁₃ : CategoryT... | The chosen wide pullback of `(f₁, f₂, f₃)`. | true |
FirstOrder.Language.ElementaryEmbedding.rec | Mathlib.ModelTheory.ElementaryMaps | {L : FirstOrder.Language} →
{M : Type u_1} →
{N : Type u_2} →
[inst : L.Structure M] →
[inst_1 : L.Structure N] →
{motive : L.ElementaryEmbedding M N → Sort u} →
((toFun : M → N) →
(map_formula' :
∀ ⦃n : ℕ⦄ (φ : L.Formula (Fin n)) (x : Fin n ... | null | false |
_private.Mathlib.CategoryTheory.SmallObject.Iteration.Basic.0.CategoryTheory.SmallObject.SuccStruct.Iteration.ext.match_1 | Mathlib.CategoryTheory.SmallObject.Iteration.Basic | ∀ {C : Type u_3} {inst : CategoryTheory.Category.{u_2, u_3} C} {J : Type u_1}
{Φ : CategoryTheory.SmallObject.SuccStruct C} {inst_1 : LinearOrder J} {inst_2 : SuccOrder J} {inst_3 : OrderBot J}
{inst_4 : CategoryTheory.Limits.HasIterationOfShape J C} {inst_5 : WellFoundedLT J} {j : J}
(motive : Φ.Iteration j → Pr... | null | false |
isLeftRegular_unop | Mathlib.Algebra.Regular.Opposite | ∀ {R : Type u_1} [inst : Mul R] {a : Rᵐᵒᵖ}, IsLeftRegular (MulOpposite.unop a) ↔ IsRightRegular a | null | true |
IsLocalFrameOn.casesOn | Mathlib.Geometry.Manifold.VectorBundle.LocalFrame | {𝕜 : 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} →
... | null | false |
QuasispectrumRestricts.cfc | Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.Restrict | ∀ {R : Type u_1} {S : Type u_2} {A : Type u_3} {p q : A → Prop} [inst : Semifield R] [inst_1 : StarRing R]
[inst_2 : MetricSpace R] [inst_3 : IsTopologicalSemiring R] [inst_4 : ContinuousStar R] [inst_5 : Field S]
[inst_6 : StarRing S] [inst_7 : MetricSpace S] [inst_8 : IsTopologicalRing S] [inst_9 : ContinuousStar... | Given a `NonUnitalContinuousFunctionalCalculus S A q`. If we form the predicate `p` for `a : A`
characterized by: `q a` and the quasispectrum of `a` restricts to the scalar subring `R` via
`f : C(S, R)`, then we can get a restricted functional calculus
`NonUnitalContinuousFunctionalCalculus R A p`. | true |
CategoryTheory.Functor.mapCommpGrp_id_mul | Mathlib.CategoryTheory.Monoidal.CommGrp_ | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] [inst_1 : CategoryTheory.CartesianMonoidalCategory C]
[inst_2 : CategoryTheory.BraidedCategory C] (A : CategoryTheory.CommGrp C),
CategoryTheory.MonObj.mul =
CategoryTheory.CategoryStruct.comp
(CategoryTheory.CategoryStruct.id (CategoryTheory.Mon... | **Alias** of `CategoryTheory.Functor.mapCommGrp_id_mul`. | true |
Profinite.NobelingProof.mem_C'_eq_false | Mathlib.Topology.Category.Profinite.Nobeling.Successor | ∀ {I : Type u} (C : Set (I → Bool)) [inst : LinearOrder I] [inst_1 : WellFoundedLT I] {o : Ordinal.{u}}
(ho : o < Ordinal.type fun x1 x2 => x1 < x2),
∀ x ∈ Profinite.NobelingProof.C' C ho, x (Profinite.NobelingProof.term I ho) = false | null | true |
isMaxOn_Iic_of_deriv | Mathlib.Analysis.Calculus.DerivativeTest | ∀ {f : ℝ → ℝ} {b c : ℝ},
ContinuousAt f b →
ContinuousAt f c →
DifferentiableOn ℝ f (Set.Iio b) →
DifferentiableOn ℝ f (Set.Ioo b c) →
(∀ x ∈ Set.Iio b, 0 ≤ deriv f x) → (∀ x ∈ Set.Ioo b c, deriv f x ≤ 0) → IsMaxOn f (Set.Iic c) b | Suppose `f : ℝ → ℝ` is continuous at `b` and `c`, the derivative `f'` is nonnegative on
`Iio b` and nonpositive on `Ioo b c`. Then `f` attains its maximum on `Iic c` at `b`. | true |
_private.Mathlib.Topology.Algebra.Group.Neighborhood.0.continuous_of_continuousAt_zero₂.match_1_1 | Mathlib.Topology.Algebra.Group.Neighborhood | ∀ {G : Type u_1} {H : Type u_2} (motive : G × H → Prop) (x : G × H), (∀ (x : G) (y : H), motive (x, y)) → motive x | null | false |
BEx.elim | Mathlib.Basic.Logic.Basic | ∀ {α : Sort u_1} {p : α → Prop} {P : (x : α) → p x → Prop} {b : Prop},
(∃ x, ∃ (h : p x), P x h) → (∀ (a : α) (h : p a), P a h → b) → b | null | true |
CategoryTheory.Functor.IsEquivalence.essSurj | Mathlib.CategoryTheory.Equivalence | ∀ {C : Type u₁} {inst : CategoryTheory.Category.{v₁, u₁} C} {D : Type u₂} {inst_1 : CategoryTheory.Category.{v₂, u₂} D}
{F : CategoryTheory.Functor C D} [self : F.IsEquivalence], F.EssSurj | null | true |
_private.Mathlib.CategoryTheory.Limits.Preserves.Shapes.Pullbacks.0.CategoryTheory.Limits.PreservesPullback.iso_inv_snd._simp_1_2 | Mathlib.CategoryTheory.Limits.Preserves.Shapes.Pullbacks | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {X Y Z : C} (α : X ≅ Y) {f : X ⟶ Z} {g : Y ⟶ Z},
(CategoryTheory.CategoryStruct.comp α.inv f = g) = (f = CategoryTheory.CategoryStruct.comp α.hom g) | null | false |
Lean.Parser.Sym.DSimp.none | Init.Sym.DSimp.DSimprocDSL | Lean.ParserDescr | Do nothing | true |
_private.Std.Data.DTreeMap.Internal.Lemmas.0.Std.DTreeMap.Internal.Impl.Const.getKey!_filter._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 |
Lean.Meta.Grind.AC.DiseqCnstrProof.casesOn | Lean.Meta.Tactic.Grind.AC.Types | {motive_2 : Lean.Meta.Grind.AC.DiseqCnstrProof → Sort u} →
(t : Lean.Meta.Grind.AC.DiseqCnstrProof) →
((a b : Lean.Expr) → (ea eb : Lean.Grind.AC.Expr) → motive_2 (Lean.Meta.Grind.AC.DiseqCnstrProof.core a b ea eb)) →
((c : Lean.Meta.Grind.AC.DiseqCnstr) → motive_2 (Lean.Meta.Grind.AC.DiseqCnstrProof.erase_... | null | false |
CategoryTheory.ShortComplex.isoCyclesOfIsLimit_inv_ι | Mathlib.Algebra.Homology.ShortComplex.LeftHomology | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
(S : CategoryTheory.ShortComplex C) [inst_2 : S.HasLeftHomology] {kf : CategoryTheory.Limits.KernelFork S.g}
(hkf : CategoryTheory.Limits.IsLimit kf),
CategoryTheory.CategoryStruct.comp (S.isoCyclesO... | null | true |
_private.Mathlib.Topology.UniformSpace.Basic.0.UniformContinuousOn.comp._simp_1_5 | Mathlib.Topology.UniformSpace.Basic | ∀ {α : Type u_1} {β : Type u_2} {p : α × β → Prop}, (∀ (x : α × β), p x) = ∀ (a : α) (b : β), p (a, b) | null | false |
Differentiable.fun_sum | Mathlib.Analysis.Calculus.FDeriv.Add | ∀ {𝕜 : 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] {ι : Type u_4}
{u : Finset ι} {A : ι → E → F}, (∀ i ∈ u, Differentiable 𝕜 (A i)) → Differentiable 𝕜 fun a => ∑... | Eta-expanded form of `Differentiable.sum` | true |
Fin.encodePi._sunfold | Batteries.Data.Fin.Coding | {n : ℕ} → (f : Fin n → ℕ) → ((i : Fin n) → Fin (f i)) → Fin (Fin.prod f) | null | false |
_private.Mathlib.Data.List.Interleave.0.List.interleaves_ofFn_odd._proof_1_5 | Mathlib.Data.List.Interleave | ∀ {n : ℕ} (i : Fin n), ↑i < n + 1 | null | false |
SeparationQuotient.map_unique | Mathlib.Topology.UniformSpace.Separation | ∀ {α : Type u} {β : Type v} [inst : UniformSpace α] [inst_1 : UniformSpace β] {f : α → β},
UniformContinuous f →
∀ {g : SeparationQuotient α → SeparationQuotient β},
SeparationQuotient.mk ∘ f = g ∘ SeparationQuotient.mk → SeparationQuotient.map f = g | null | true |
inf_inf_sdiff | Mathlib.Order.BooleanAlgebra.Basic | ∀ {α : Type u} [inst : GeneralizedBooleanAlgebra α] (x y : α), x ⊓ y ⊓ x \ y = ⊥ | null | true |
Function.IsPeriodicPt.apply | Mathlib.Dynamics.PeriodicPts.Defs | ∀ {α : Type u_1} {f : α → α} {x : α} {n : ℕ}, Function.IsPeriodicPt f n x → Function.IsPeriodicPt f n (f x) | null | true |
Std.Tactic.BVDecide.BVExpr.bitblast.AppendTarget.h | Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Append | ∀ {α : Type} [inst : Hashable α] [inst_1 : DecidableEq α] {aig : Std.Sat.AIG α} {combined : ℕ}
(self : Std.Tactic.BVDecide.BVExpr.bitblast.AppendTarget aig combined), combined = self.rw + self.lw | null | true |
_private.Mathlib.Probability.Distributions.Exponential.0.ProbabilityTheory.cdf_expMeasure_eq._simp_1_2 | Mathlib.Probability.Distributions.Exponential | ∀ {x : ℝ}, (Real.exp x ≤ 1) = (x ≤ 0) | null | false |
ContinuousMultilinearMap.toFormalMultilinearSeries.congr_simp | Mathlib.Analysis.Calculus.FDeriv.Analytic | ∀ {𝕜 : Type u} {F : Type w} [inst : Semiring 𝕜] [inst_1 : AddCommMonoid F] [inst_2 : Module 𝕜 F]
[inst_3 : TopologicalSpace F] [inst_4 : ContinuousAdd F] [inst_5 : ContinuousConstSMul 𝕜 F] {ι : Type u_1}
{E : ι → Type u_2} [inst_6 : (i : ι) → AddCommGroup (E i)] [inst_7 : (i : ι) → Module 𝕜 (E i)]
[inst_8 : ... | null | true |
Option.forIn'_toArray._proof_1 | Init.Data.Option.Array | ∀ {α : Type u_1} (o : Option α), ∀ a ∈ o, a ∈ o.toArray | null | false |
MeasureTheory.integral_eq_of_hasDerivAt_off_countable_of_le | Mathlib.MeasureTheory.Integral.DivergenceTheorem | ∀ {E : Type u} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E] [CompleteSpace E] (f f' : ℝ → E) {a b : ℝ},
a ≤ b →
∀ {s : Set ℝ},
s.Countable →
ContinuousOn f (Set.Icc a b) →
(∀ x ∈ Set.Ioo a b \ s, HasDerivAt f (f' x) x) →
IntervalIntegrable f' MeasureTheory.volume a ... | **Fundamental theorem of calculus, part 2**. This version assumes that `f` is continuous on the
interval and is differentiable off a countable set `s`.
See also
* `intervalIntegral.integral_eq_sub_of_hasDeriv_right_of_le` for a version that only assumes right
differentiability of `f`;
* `MeasureTheory.integral_eq_o... | true |
_private.Mathlib.GroupTheory.OrderOfElement.0.IsOfFinAddOrder.mem_multiples_iff_mem_zmultiples.match_1_1 | Mathlib.GroupTheory.OrderOfElement | ∀ {G : Type u_1} [inst : AddGroup G] {x y : G} (motive : y ∈ AddSubmonoid.multiples x → Prop)
(x_1 : y ∈ AddSubmonoid.multiples x), (∀ (n : ℕ) (hn : (fun x_2 => x_2 • x) n = y), motive ⋯) → motive x_1 | null | false |
AlgebraicGeometry.ProjIsoSpecTopComponent.FromSpec.mem_carrier_iff_of_mem | Mathlib.AlgebraicGeometry.ProjectiveSpectrum.Scheme | ∀ {A : Type u_1} {σ : Type u_2} [inst : CommRing A] [inst_1 : SetLike σ A] [inst_2 : AddSubgroupClass σ A] {𝒜 : ℕ → σ}
[inst_3 : GradedRing 𝒜] {f : A} {m : ℕ} (f_deg : f ∈ 𝒜 m),
0 < m →
∀ (q : ↑↑(AlgebraicGeometry.Spec.locallyRingedSpaceObj ↧(HomogeneousLocalization.Away 𝒜 f)).toPresheafedSpace)
(a : ... | null | true |
Filter.Tendsto.eventually_intervalIntegrable | Mathlib.MeasureTheory.Integral.IntervalIntegral.Basic | ∀ {ι : Type u_1} {E : Type u_5} [inst : NormedAddCommGroup E] {f : ℝ → E} {μ : MeasureTheory.Measure ℝ}
{l l' : Filter ℝ},
StronglyMeasurableAtFilter f l' μ →
∀ [Filter.TendstoIxxClass Set.Ioc l l'] [l'.IsMeasurablyGenerated],
μ.FiniteAtFilter l' →
∀ {c : E},
Filter.Tendsto f l' (nhds c)... | Let `l'` be a measurably generated filter; let `l` be a of filter such that each `s ∈ l'`
eventually includes `Ioc u v` as both `u` and `v` tend to `l`. Let `μ` be a measure finite at `l'`.
Suppose that `f : ℝ → E` has a finite limit at `l`. Then `f` is interval integrable on `u..v`
provided that both `u` and `v` tend... | true |
_private.Std.Time.Notation.0.Std.Time.convertOffsetZ | Std.Time.Notation | Std.Time.OffsetZ → Lean.MacroM (Lean.TSyntax `term) | null | true |
Units.le_of_one_le_inv | Mathlib.Algebra.Order.Monoid.Unbundled.Units | ∀ {M : Type u_1} [inst : Monoid M] [inst_1 : LE M] [MulLeftMono M] (u : Mˣ), 1 ≤ ↑u⁻¹ → ↑u ≤ 1 | **Alias** of the forward direction of `Units.one_le_inv`. | true |
_private.Mathlib.RingTheory.Smooth.NoetherianDescent.0.Algebra.Smooth.exists_subalgebra_fg._simp_1_3 | Mathlib.RingTheory.Smooth.NoetherianDescent | ∀ {G : Type u_3} [inst : AddGroup G] {a b : G}, (a - b = 0) = (a = b) | null | false |
Std.DTreeMap.Internal.Impl.brecOn | Std.Data.DTreeMap.Internal.Def | {α : Type u} →
{β : α → Type v} →
{motive : Std.DTreeMap.Internal.Impl α β → Sort u_1} →
(t : Std.DTreeMap.Internal.Impl α β) →
((t : Std.DTreeMap.Internal.Impl α β) → Std.DTreeMap.Internal.Impl.below t → motive t) → motive t | null | false |
Sym2.other_invol' | Mathlib.Data.Sym.Sym2 | ∀ {α : Type u_1} [inst : DecidableEq α] {a : α} {z : Sym2 α} (ha : a ∈ z) (hb : Sym2.Mem.other' ha ∈ z),
Sym2.Mem.other' hb = a | null | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.