name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
AddGroupSeminorm.instLattice._proof_1 | Mathlib.Analysis.Normed.Group.Seminorm | ∀ {E : Type u_1} [inst : AddCommGroup E] (p q : AddGroupSeminorm E) (x : E), p x + q (x - x) ≤ p x | null | false |
USize.ne_iff_toBitVec64_ne._simp_1 | Init.Data.UInt.IntToBitVec | ∀ {a b : USize} (h : System.Platform.numBits = 64), (a ≠ b) = (a.toBitVec64 h ≠ b.toBitVec64 h) | null | false |
Module.Relations.instQuotient._proof_7 | Mathlib.Algebra.Module.Presentation.Basic | ∀ {A : Type u_3} [inst : Ring A] (relations : Module.Relations A) (r s : A) (x : relations.Quotient),
(r + s) • x = r • x + s • x | null | false |
Lean.Compiler.LCNF.getParamTypes | Lean.Compiler.LCNF.MonoTypes | Lean.Expr → Array Lean.Expr | null | true |
coe_smul_fixedPoints_of_normal | Mathlib.GroupTheory.GroupAction.SubMulAction | ∀ {G : Type u_1} [inst : Group G] {α : Type u_2} [inst_1 : MulAction G α] {H : Subgroup G} [hH : H.Normal] (g : G)
(a : ↑(MulAction.fixedPoints (↥H) α)), ↑(g • a) = g • ↑a | null | true |
Batteries.BinomialHeap.Imp.Heap.WF.of_le | Batteries.Data.BinomialHeap.Basic | ∀ {n n' : ℕ} {α : Type u_1} {le : α → α → Bool} {s : Batteries.BinomialHeap.Imp.Heap α},
n ≤ n' → Batteries.BinomialHeap.Imp.Heap.WF le n' s → Batteries.BinomialHeap.Imp.Heap.WF le n s | null | true |
Inclusion.instToSetIntervalBoolProp | Mathlib.Tactic.Inclusion.Core.ToSet | Inclusion.ToSet Inclusion.IntervalBool Prop | null | true |
SimpleGraph.Iso.lineGraph | Mathlib.Combinatorics.SimpleGraph.LineGraph | {V : Type u_1} → {V' : Type u_2} → {G : SimpleGraph V} → {G' : SimpleGraph V'} → G ≃g G' → G.lineGraph ≃g G'.lineGraph | Lift an isomorphism between graphs to an isomorphism between their line graphs | true |
CategoryTheory.instFinalStructuredArrowCompPreOfRepresentablyFlat | Mathlib.CategoryTheory.Functor.Flat | ∀ {C : Type u_1} {D : Type u_2} {E : Type u_3} [inst : CategoryTheory.Category.{v_1, u_1} C]
[inst_1 : CategoryTheory.Category.{v_2, u_2} D] [inst_2 : CategoryTheory.Category.{v_3, u_3} E]
(F : CategoryTheory.Functor C D) (G : CategoryTheory.Functor D E) (X : E) [CategoryTheory.RepresentablyFlat F],
(CategoryTheo... | null | true |
_private.Lean.Compiler.LCNF.Simp.SimpM.0.Lean.Compiler.LCNF.Simp.isOnceOrMustInline.match_1 | Lean.Compiler.LCNF.Simp.SimpM | (motive : Option Lean.Compiler.LCNF.Simp.FunDeclInfo → Sort u_1) →
(x : Option Lean.Compiler.LCNF.Simp.FunDeclInfo) →
(Unit → motive (some Lean.Compiler.LCNF.Simp.FunDeclInfo.once)) →
(Unit → motive (some Lean.Compiler.LCNF.Simp.FunDeclInfo.mustInline)) →
((x : Option Lean.Compiler.LCNF.Simp.FunDecl... | null | false |
LinearMap.split_surjective_of_localization_maximal | Mathlib.RingTheory.LocalProperties.Projective | ∀ {R : Type u_1} {N : Type u_2} {M : Type uM} [inst : CommRing R] [inst_1 : AddCommGroup M] [inst_2 : Module R M]
[inst_3 : AddCommGroup N] [inst_4 : Module R N] (f : M →ₗ[R] N) [Module.FinitePresentation R N],
(∀ (I : Ideal R) (x : I.IsMaximal), ∃ g, (LocalizedModule.map I.primeCompl) f ∘ₗ g = LinearMap.id) →
... | null | true |
BitVec.ofNat_lt_ofNat | Init.Data.BitVec.Lemmas | ∀ {n x y : ℕ}, BitVec.ofNat n x < BitVec.ofNat n y ↔ x % 2 ^ n < y % 2 ^ n | null | true |
_private.Mathlib.Topology.Algebra.Valued.ValuationTopology.0.Valuation.map_eq_one_of_forall_lt._simp_1_2 | Mathlib.Topology.Algebra.Valued.ValuationTopology | ∀ {G : Type u_7} {H : Type u_8} {F : Type u_9} [inst : FunLike F G H] [inst_1 : Monoid G] [inst_2 : Monoid H]
[MonoidHomClass F G H] (f : F) (a : G) (n : ℕ), f a ^ n = f (a ^ n) | null | false |
Stream'.Seq.dropn_add._f | Mathlib.Data.Seq.Basic | ∀ {α : Type u} (s : Stream'.Seq α) (m x : ℕ) (f : Nat.below x), s.drop (m + x) = (s.drop m).drop x | null | false |
_private.Batteries.Data.String.Lemmas.0.String.Legacy.contains.eq_1 | Batteries.Data.String.Lemmas | ∀ (s : String) (c : Char), String.Legacy.contains s c = String.Legacy.any s fun a => a == c | null | true |
_private.Mathlib.RingTheory.Flat.Basic.0.Module.Flat.iff_lTensor_preserves_injective_linearMap'._simp_1_2 | Mathlib.RingTheory.Flat.Basic | ∀ {R : Type u_1} [inst : CommSemiring R] (M : Type u_4) {N : Type u_5} {P : Type u_6} [inst_1 : AddCommMonoid M]
[inst_2 : AddCommMonoid N] [inst_3 : AddCommMonoid P] [inst_4 : Module R M] [inst_5 : Module R N]
[inst_6 : Module R P] (f : N →ₗ[R] P),
Function.Injective ⇑(LinearMap.lTensor M f) = Function.Injective... | null | false |
CategoryTheory.LocalizerMorphism.mk.inj | Mathlib.CategoryTheory.Localization.LocalizerMorphism | ∀ {C₁ : Type u₁} {C₂ : Type u₂} {inst : CategoryTheory.Category.{v₁, u₁} C₁}
{inst_1 : CategoryTheory.Category.{v₂, u₂} C₂} {W₁ : CategoryTheory.MorphismProperty C₁}
{W₂ : CategoryTheory.MorphismProperty C₂} {functor : CategoryTheory.Functor C₁ C₂}
{map : W₁ ≤ W₂.inverseImage functor} {functor_1 : CategoryTheory.... | null | true |
LinearMap.frobenius._proof_2 | Mathlib.Algebra.CharP.Frobenius | ∀ (R : Type u_2) [inst : CommSemiring R] (S : Type u_1) [inst_1 : CommSemiring S] (p : ℕ) [inst_2 : ExpChar R p]
[inst_3 : ExpChar S p] [inst_4 : Algebra R S] (r : R) (s : S),
(frobenius S p) (r • s) = (frobenius R p) r • (↑↑(frobenius S p)).toFun s | null | false |
UniformFun.ofFun_pow | Mathlib.Topology.Algebra.UniformConvergence | ∀ {α : Type u_1} {β : Type u_2} {M : Type u_4} [inst : Pow β M] (c : M) (f : α → β),
UniformFun.ofFun (f ^ c) = UniformFun.ofFun f ^ c | null | true |
_private.Mathlib.Computability.TuringMachine.PostTuringMachine.0.Turing.TM1to0.tr_supports._simp_1_4 | Mathlib.Computability.TuringMachine.PostTuringMachine | ∀ {α : Type u_1} {a b : α}, (some a = some b) = (a = b) | null | false |
lTensor.inverse_of_rightInverse._proof_3 | Mathlib.LinearAlgebra.TensorProduct.RightExactness | ∀ {R : Type u_3} {M : Type u_4} {N : Type u_1} {P : Type u_5} [inst : CommRing R] [inst_1 : AddCommGroup M]
[inst_2 : AddCommGroup N] [inst_3 : AddCommGroup P] [inst_4 : Module R M] [inst_5 : Module R N] [inst_6 : Module R P]
{f : M →ₗ[R] N} {g : N →ₗ[R] P} (Q : Type u_2) [inst_7 : AddCommGroup Q] [inst_8 : Module ... | null | false |
Dynamics.netEntropyInfEntourage | Mathlib.Dynamics.TopologicalEntropy.NetEntropy | {X : Type u_1} → (X → X) → Set X → SetRel X X → EReal | The entropy of an entourage `U`, defined as the exponential rate of growth of the size of the
largest `(U, n)`-dynamical net of `F`. Takes values in the space of extended real numbers
`[-∞,+∞]`. This version uses a `liminf`, and is an alternative definition. | true |
_private.Mathlib.Topology.EMetricSpace.Defs.0.uniformity_basis_edist_le'.match_1_1 | Mathlib.Topology.EMetricSpace.Defs | ∀ (ε' : ENNReal) (motive : (∃ a, 0 < a ∧ a < ε') → Prop) (x : ∃ a, 0 < a ∧ a < ε'),
(∀ (δ : ENNReal) (hδ : 0 < δ ∧ δ < ε'), motive ⋯) → motive x | null | false |
Lean.Syntax.eqWithInfoAndTraceReuse | Lean.Syntax | Lean.Options → Lean.Syntax → Lean.Syntax → Bool | Like `eqWithInfo` but prints trace on failure if `trace.Elab.reuse` is activated. | true |
CategoryTheory.NonemptyParallelPairPresentationAux.ι₂ | Mathlib.CategoryTheory.Limits.Indization.ParallelPair | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
{A B : CategoryTheory.Functor Cᵒᵖ (Type v₁)} →
(f g : A ⟶ B) →
(P₁ : CategoryTheory.Limits.IndObjectPresentation A) →
(P₂ : CategoryTheory.Limits.IndObjectPresentation B) →
(CategoryTheory.NonemptyParallelPairPresent... | Implementation; see `nonempty_indParallelPairPresentation`. | true |
«term_!=_» | Init.Core | Lean.TrailingParserDescr | `x != y` is boolean not-equal. It is the negation of `x == y` which is supplied by
the `BEq` typeclass.
Unlike `x ≠ y` (which is notation for `Ne x y`), this is `Bool` valued instead of
`Prop` valued. It is mainly intended for programming applications.
Conventions for notations in identifiers:
* The recommended sp... | true |
ValueDistribution.characteristic_zero | Mathlib.Analysis.Complex.ValueDistribution.CharacteristicFunction | ValueDistribution.characteristic 0 ⊤ = fun x => 0 | The characteristic function of the zero function for the value `⊤` vanishes identically. | true |
commBialgCatEquivComonCommAlgCat._proof_7 | Mathlib.Algebra.Category.CommBialgCat | ∀ (R : Type u_1) [inst : CommRing R] (X : (CategoryTheory.Mon (CommAlgCat R)ᵒᵖ)ᵒᵖ),
CommBialgCat.ofHom (BialgHom.ofAlgHom (CommAlgCat.Hom.hom (CategoryTheory.CategoryStruct.id X).unop.hom.unop) ⋯ ⋯) =
CategoryTheory.CategoryStruct.id ↧↑(Opposite.unop (Opposite.unop X).X) | null | false |
_private.Mathlib.Analysis.LocallyConvex.WithSeminorms.0.WithSeminorms.toLocallyConvexSpace._simp_1_2 | Mathlib.Analysis.LocallyConvex.WithSeminorms | ∀ {α : Type u_1} {a b : α}, (a ∈ {b}) = (a = b) | null | false |
ISize.toInt16_ofNat | Init.Data.SInt.Lemmas | ∀ {n : ℕ}, (OfNat.ofNat n).toInt16 = OfNat.ofNat n | null | true |
CategoryTheory.Functor.IsDenseSubsite.sheafEquiv_inverse | Mathlib.CategoryTheory.Sites.DenseSubsite.Basic | ∀ {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] (J : CategoryTheory.GrothendieckTopology C)
(K : CategoryTheory.GrothendieckTopology D) (G : CategoryTheory.Functor C D) (A : Type u_3)
[inst_2 : CategoryTheory.Category.{v_3, u_3} A] [ins... | null | true |
ContinuousMap.HomotopyRel.prod_apply | Mathlib.Topology.Homotopy.Product | ∀ {α : Type u_1} {β : Type u_2} [inst : TopologicalSpace α] [inst_1 : TopologicalSpace β] {A : Type u_3}
[inst_2 : TopologicalSpace A] {f₀ f₁ : C(A, α)} {g₀ g₁ : C(A, β)} {S : Set A} (F : f₀.HomotopyRel f₁ S)
(G : g₀.HomotopyRel g₁ S) (t : ↑unitInterval × A), (F.prod G) t = (F t, G t) | null | true |
Ordinal.omega0_opow_epsilon | Mathlib.SetTheory.Ordinal.Veblen | ∀ (o : Ordinal.{u_1}), Ordinal.omega0 ^ o.epsilon = o.epsilon | null | true |
_private.Mathlib.AlgebraicGeometry.Cover.Directed.0.AlgebraicGeometry.Scheme.Cover.locallyDirectedPullbackCover._simp_9 | Mathlib.AlgebraicGeometry.Cover.Directed | ∀ {α : Type u} {ι : Sort u_1} {f : ι → α} {x : α}, (x ∈ Set.range f) = ∃ y, f y = x | null | false |
IsFractionRing.toField._proof_2 | Mathlib.RingTheory.Localization.FractionRing | ∀ (A : Type u_2) [inst : CommRing A] {K : Type u_1} [inst_1 : CommRing K] [inst_2 : Algebra A K]
[inst_3 : IsFractionRing A K] [inst_4 : IsDomain A] (a : K), a ^ 0 = 1 | null | false |
Std.Iterators.Types.Zip.rel₃_of_memoizedLeft | Std.Data.Iterators.Combinators.Monadic.Zip | ∀ {m : Type w → Type w'} {α₁ β₁ : Type w} [inst : Std.Iterator α₁ m β₁] {α₂ β₂ : Type w} [inst_1 : Std.Iterator α₂ m β₂]
[inst_2 : Std.Iterators.Productive α₁ m] [inst_3 : Std.Iterators.Productive α₂ m] {it' it : Std.IterM m (β₁ × β₂)},
Option.SomeLtNone.lt emptyRelation it'.internalState.memoizedLeft it.internalSt... | null | true |
CategoryTheory.MorphismProperty.LeftFraction.map_compatibility | Mathlib.CategoryTheory.Localization.CalculusOfFractions | ∀ {C : Type u_1} {D : Type u_2} [inst : CategoryTheory.Category.{v_1, u_1} C]
[inst_1 : CategoryTheory.Category.{v_2, u_2} D] {W : CategoryTheory.MorphismProperty C} {X Y : C}
(φ : W.LeftFraction X Y) {E : Type u_3} [inst_2 : CategoryTheory.Category.{v_3, u_3} E]
(L₁ : CategoryTheory.Functor C D) (L₂ : CategoryTh... | null | true |
Lean.Lsp.CancelParams.mk.inj | Lean.Data.Lsp.CancelParams | ∀ {id id_1 : Lean.JsonRpc.RequestID}, { id := id } = { id := id_1 } → id = id_1 | null | true |
CategoryTheory.Iso.isoFunctorOfIsoInverse | Mathlib.CategoryTheory.Equivalence | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
{D : Type u₂} →
[inst_1 : CategoryTheory.Category.{v₂, u₂} D] →
{G G' : C ≌ D} → (G.inverse ≅ G'.inverse) → (G.functor ≅ G'.functor) | As a special case, given two equivalences `G` and `G'` between the same categories,
construct an isomorphism `G.functor ≅ G.functor` from an isomorphism `G.inverse ≅ G.inverse`. | true |
_private.Mathlib.Analysis.SpecialFunctions.OrdinaryHypergeometric.0.ordinaryHypergeometricSeries_radius_eq_one._simp_1_4 | Mathlib.Analysis.SpecialFunctions.OrdinaryHypergeometric | ∀ {α : Type u_2} [inst : Zero α] [inst_1 : OfNat α 3] [NeZero 3], (3 = 0) = False | null | false |
Batteries.BinomialHeap.Imp.HeapNode.node.sizeOf_spec | Batteries.Data.BinomialHeap.Basic | ∀ {α : Type u} [inst : SizeOf α] (a : α) (child sibling : Batteries.BinomialHeap.Imp.HeapNode α),
sizeOf (Batteries.BinomialHeap.Imp.HeapNode.node a child sibling) = 1 + sizeOf a + sizeOf child + sizeOf sibling | null | true |
Submodule.bot_toAddSubmonoid | Mathlib.Algebra.Module.Submodule.Lattice | ∀ {R : Type u_1} {M : Type u_3} [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M],
⊥.toAddSubmonoid = ⊥ | null | true |
_private.Mathlib.Combinatorics.Nullstellensatz.0.MvPolynomial.Alon.of_mem_P_support | Mathlib.Combinatorics.Nullstellensatz | ∀ {R : Type u_1} [inst : CommRing R] {ι : Type u_3} (i : ι) (S : Finset R),
∀ m ∈ (MvPolynomial.Alon.P✝ S i).support, ∃ e ≤ S.card, m = fun₀ | i => e | The support of `Alon.P S i` is the set of exponents of the form `single i e`,
for `e ≤ #S`. | true |
MulOpposite.instAddRightCancelSemigroup | Mathlib.Algebra.Group.Opposite | {α : Type u_1} → [AddRightCancelSemigroup α] → AddRightCancelSemigroup αᵐᵒᵖ | null | true |
Float.recOn | Init.Data.Float.Float | {motive : Float → Sort u} → (t : Float) → ((toModel : Float.Model) → motive { toModel := toModel }) → motive t | null | false |
Finset.image_eq_preimage_of_leftInvOn_injOn | Mathlib.Data.Finset.Preimage | ∀ {α : Type u_1} {β : Type u_2} [inst : DecidableEq β] {f : α → β} {g : β → α} {s : Finset α},
Set.LeftInvOn g f ↑s → ∀ (ginj : Set.InjOn g (g ⁻¹' ↑s)), Finset.image f s = s.preimage g ginj | null | true |
DirectSum.smul_apply | Mathlib.Algebra.DirectSum.Module | ∀ {R : Type u} [inst : Semiring R] {ι : Type v} {M : ι → Type w} [inst_1 : (i : ι) → AddCommMonoid (M i)]
[inst_2 : (i : ι) → Module R (M i)] (b : R) (v : DirectSum ι fun i => M i) (i : ι), (b • v) i = b • v i | null | true |
hasDerivAt_exp_smul_const_of_mem_ball | Mathlib.Analysis.SpecialFunctions.Exponential | ∀ {𝕂 : Type u_1} {𝔸 : Type u_3} [inst : NontriviallyNormedField 𝕂] [CharZero 𝕂] [inst_2 : NormedRing 𝔸]
[inst_3 : NormedAlgebra 𝕂 𝔸] [CompleteSpace 𝔸] (x : 𝔸) (t : 𝕂),
t • x ∈ Metric.eball 0 (NormedSpace.expSeries 𝕂 𝔸).radius →
HasDerivAt (fun u => NormedSpace.exp (u • x)) (NormedSpace.exp (t • x) *... | null | true |
SemiRingCat.limitSemiring._proof_31 | Mathlib.Algebra.Category.Ring.Limits | ∀ {J : Type u_3} [inst : CategoryTheory.Category.{u_2, u_3} J] (F : CategoryTheory.Functor J SemiRingCat)
[inst_1 : Small.{u_1, max u_1 u_3} ↑(F.comp (CategoryTheory.forget SemiRingCat)).sections],
autoParam (∀ (n : ℕ), ↑(n + 1) = ↑n + 1) AddMonoidWithOne.natCast_succ._autoParam | null | false |
CategoryTheory.Functor.RepresentableBy.homEquiv_comp | Mathlib.CategoryTheory.Yoneda | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {F : CategoryTheory.Functor Cᵒᵖ (Type v)} {Y : C}
(self : F.RepresentableBy Y) {X X' : C} (f : X ⟶ X') (g : X' ⟶ Y),
self.homEquiv (CategoryTheory.CategoryStruct.comp f g) =
(CategoryTheory.ConcreteCategory.hom (F.map f.op)) (self.homEquiv g) | null | true |
Mathlib.Tactic.RingNF.Config.mode._default | Mathlib.Tactic.Ring.RingNF | Mathlib.Tactic.RingNF.RingMode | null | false |
AddCommGrpCat.kernelIsLimit._proof_2 | Mathlib.Algebra.Category.Grp.Kernels | ∀ {G : AddCommGrpCat}, AddSubmonoidClass (AddSubgroup ↑G) ↑G | null | false |
AddCommute.neg_right_iff | Mathlib.Algebra.Group.Commute.Basic | ∀ {G : Type u_1} [inst : AddGroup G] {a b : G}, AddCommute a (-b) ↔ AddCommute a b | null | true |
Vector.le_total | Init.Data.Vector.Lex | ∀ {α : Type u_1} {n : ℕ} [inst : LT α] [i : Std.Asymm fun x1 x2 => x1 < x2] (xs ys : Vector α n), xs ≤ ys ∨ ys ≤ xs | null | true |
Int64.toUInt64_and | Init.Data.SInt.Bitwise | ∀ (a b : Int64), (a &&& b).toUInt64 = a.toUInt64 &&& b.toUInt64 | null | true |
Lean.Linter.CodeQuality.Source.module.elim | Lean.Linter.CodeQuality.Basic | {motive : Lean.Linter.CodeQuality.Source → Sort u} →
(t : Lean.Linter.CodeQuality.Source) →
t.ctorIdx = 0 → ((name : Lean.Name) → motive (Lean.Linter.CodeQuality.Source.module name)) → motive t | null | false |
norm_zsmul_le | Mathlib.Analysis.Normed.Group.Int | ∀ {α : Type u_1} [inst : SeminormedAddCommGroup α] (n : ℤ) (a : α), ‖n • a‖ ≤ ‖n‖ * ‖a‖ | null | true |
ModularGroup.T.eq_1 | Mathlib.NumberTheory.ModularForms.Cusps | ModularGroup.T = ⟨!![1, 1; 0, 1], ModularGroup.T._proof_1⟩ | null | true |
Std.ExtTreeSet.size_ofList_le | Std.Data.ExtTreeSet.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} [Std.TransCmp cmp] {l : List α}, (Std.ExtTreeSet.ofList l cmp).size ≤ l.length | null | true |
Lean.Elab.Term.Quotation.HeadInfo.mk.sizeOf_spec | Lean.Elab.Quotation | ∀ (check : Lean.Elab.Term.Quotation.HeadCheck)
(onMatch : Lean.Elab.Term.Quotation.HeadCheck → Lean.Elab.Term.Quotation.MatchResult)
(doMatch :
(List Lean.Term → Lean.Elab.TermElabM Lean.Term) → Lean.Elab.TermElabM Lean.Term → Lean.Elab.TermElabM Lean.Term),
sizeOf { check := check, onMatch := onMatch, doMatc... | null | true |
ContDiffAt.add | Mathlib.Analysis.Calculus.ContDiff.Operations | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type uE} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {F : Type uF} [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace 𝕜 F] {x : E}
{n : WithTop ℕ∞} {f g : E → F}, ContDiffAt 𝕜 n f x → ContDiffAt 𝕜 n g x → ContDiffAt 𝕜 n (fun x => f x ... | The sum of two `C^n` functions at a point is `C^n` at this point. | true |
ChartedSpaceCore.openPartialHomeomorph._proof_6 | Mathlib.Geometry.Manifold.ChartedSpace | ∀ {H : Type u_2} {M : Type u_1} [inst : TopologicalSpace H] (c : ChartedSpaceCore H M), ∀ e ∈ c.atlas, IsOpen e.source | null | false |
Pi.instOrderTopLexForallOfWellFoundedLT._proof_1 | Mathlib.Order.PiLex | ∀ {ι : Type u_1} {β : ι → Type u_2} [inst : LinearOrder ι] [WellFoundedLT ι] [inst_2 : (a : ι) → PartialOrder (β a)]
[inst_3 : (a : ι) → OrderTop (β a)] (x : Lex ((a : ι) → β a)), toLex x ≤ toLex ⊤ | null | false |
Lean.Doc.Inline.brecOn_2.go | Lean.DocString.Types | {i : Type u} →
{motive_1 : Lean.Doc.Inline i → Sort u_1} →
{motive_2 : Array (Lean.Doc.Inline i) → Sort u_1} →
{motive_3 : List (Lean.Doc.Inline i) → Sort u_1} →
(t : List (Lean.Doc.Inline i)) →
((t : Lean.Doc.Inline i) → t.below → motive_1 t) →
((t : Array (Lean.Doc.Inline i))... | null | true |
CategoryTheory.Limits.binaryFanZeroLeftIsLimit._proof_4 | Mathlib.CategoryTheory.Limits.Constructions.ZeroObjects | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.Limits.HasZeroObject C] (X : C)
(s : CategoryTheory.Limits.BinaryFan 0 X) (m : s.pt ⟶ X),
CategoryTheory.CategoryStruct.comp m (CategoryTheory.CategoryStruct.id X) = s.snd → m = s.snd | null | false |
Nat.shiftRight_bitwise_distrib._auto_5 | Init.Data.Nat.Bitwise.Lemmas | Lean.Syntax | null | false |
GroupSeminorm.instZeroGroupSeminorm | Mathlib.Analysis.Normed.Group.Seminorm | {E : Type u_3} → [inst : Group E] → Zero (GroupSeminorm E) | null | true |
_private.Lean.Compiler.ExternAttr.0.PSigma.casesOn._arg_pusher | Lean.Compiler.ExternAttr | ∀ {α : Sort u} {β : α → Sort v} {motive : PSigma β → Sort u_1} (α_1 : Sort u✝) (β_1 : α_1 → Sort v✝)
(f : (x : α_1) → β_1 x) (rel : PSigma β → α_1 → Prop) (t : PSigma β)
(mk : (fst : α) → (snd : β fst) → ((y : α_1) → rel ⟨fst, snd⟩ y → β_1 y) → motive ⟨fst, snd⟩),
(PSigma.casesOn (motive := fun t => ((y : α_1) → ... | null | false |
Differentiable.differentiableOn | Mathlib.Analysis.Calculus.FDeriv.Basic | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : AddCommGroup E] [inst_2 : Module 𝕜 E]
[inst_3 : TopologicalSpace E] {F : Type u_3} [inst_4 : AddCommGroup F] [inst_5 : Module 𝕜 F]
[inst_6 : TopologicalSpace F] {f : E → F} {s : Set E}, Differentiable 𝕜 f → DifferentiableOn 𝕜 f s | null | true |
Prod.seminormedRing._proof_13 | Mathlib.Analysis.Normed.Ring.Basic | ∀ {α : Type u_1} {β : Type u_2} [inst : SeminormedRing α] [inst_1 : SeminormedRing β] (a b : α × β), a - b = a + -b | null | false |
fwdDiff_aux.coe_fwdDiffₗ_pow | Mathlib.Algebra.Group.ForwardDiff | ∀ {M : Type u_1} {G : Type u_2} [inst : AddCommMonoid M] [inst_1 : AddCommGroup G] (h : M) (n : ℕ),
⇑(fwdDiff_aux.fwdDiffₗ M G h ^ n) = (fwdDiff h)^[n] | null | true |
_private.Lean.Meta.MkIffOfInductiveProp.0.Lean.Meta.nCasesSum._f | Lean.Meta.MkIffOfInductiveProp | (n : ℕ) →
Nat.below (motive := fun n => Lean.MVarId → Lean.FVarId → Lean.MetaM (List (Lean.FVarId × Lean.MVarId))) n →
Lean.MVarId → Lean.FVarId → Lean.MetaM (List (Lean.FVarId × Lean.MVarId)) | null | false |
_private.Mathlib.RingTheory.RootsOfUnity.PrimitiveRoots.0.IsPrimitiveRoot.injOn_pow_mul._simp_1_1 | Mathlib.RingTheory.RootsOfUnity.PrimitiveRoots | ∀ {M₀ : Type u_1} [inst : MulZeroClass M₀] [IsRightCancelMulZero M₀] {a b c : M₀}, (a * c = b * c) = (a = b ∨ c = 0) | null | false |
AlgebraicGeometry.Scheme.Pullback.p_comm | Mathlib.AlgebraicGeometry.Pullbacks | ∀ {X Y Z : AlgebraicGeometry.Scheme} (𝒰 : X.OpenCover) (f : X ⟶ Z) (g : Y ⟶ Z)
[inst : ∀ (i : 𝒰.I₀), CategoryTheory.Limits.HasPullback (CategoryTheory.CategoryStruct.comp (𝒰.f i) f) g],
CategoryTheory.CategoryStruct.comp (AlgebraicGeometry.Scheme.Pullback.p1 𝒰 f g) f =
CategoryTheory.CategoryStruct.comp (Al... | null | true |
RingHom.inverse._proof_2 | Mathlib.Algebra.Ring.Equiv | ∀ {R : Type u_1} {S : Type u_2} [inst : NonAssocSemiring R] [inst_1 : NonAssocSemiring S], MulHomClass (R →+* S) R S | null | false |
_private.Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Udiv.0.Std.Tactic.BVDecide.BVExpr.bitblast.blastUdiv.blastDivSubtractShift._proof_2 | Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Udiv | ∀ {α : Type} [inst : Hashable α] [inst_1 : DecidableEq α] {w : ℕ} (aig : Std.Sat.AIG α) (n : aig.RefVec w) (wn : ℕ)
(q r : aig.RefVec w)
(this :
aig.decls.size ≤
(Std.Tactic.BVDecide.BVExpr.bitblast.blastUdiv.blastShiftConcat aig
{ lhs := r, bit := n.getD (wn - 1) (aig.mkConstCached false) }... | null | false |
CategoryTheory.Limits.Types.isCoprodOfMono._proof_1 | Mathlib.CategoryTheory.Limits.Types.Coproducts | ∀ {X Y : Type u_1} (f : X ⟶ Y) [CategoryTheory.Mono f],
Nonempty (CategoryTheory.Limits.IsColimit (CategoryTheory.Limits.BinaryCofan.mk f (TypeCat.ofHom Subtype.val))) | null | false |
_private.Init.Data.Iterators.Lemmas.Combinators.FilterMap.0.Std.Iter.step_filterM.match_1.splitter | Init.Data.Iterators.Lemmas.Combinators.FilterMap | {β : Type u_1} →
{n : Type u_1 → Type u_2} →
{f : β → n (ULift.{u_1, 0} Bool)} →
[inst : MonadAttach n] →
(out : β) →
(motive : Subtype (MonadAttach.CanReturn (f out)) → Sort u_3) →
(__do_lift : Subtype (MonadAttach.CanReturn (f out))) →
((hf : MonadAttach.CanRetu... | null | true |
String.Slice.Subslice.startInclusive | Init.Data.String.Subslice | {s : String.Slice} → s.Subslice → s.Pos | The byte position of the start of the subslice. | true |
CategoryTheory.SmallCategoryOfSet.instSmallCategoryElemObj | Mathlib.CategoryTheory.SmallRepresentatives | (Ω : Type w) → (S : CategoryTheory.SmallCategoryOfSet Ω) → CategoryTheory.SmallCategory ↑S.obj | null | true |
MulChar.restrictHom_surjective | Mathlib.NumberTheory.MulChar.Duality | ∀ (M : Type u_1) (R : Type u_2) [inst : CommMonoid M] [inst_1 : CommRing R] [Finite M]
[HasEnoughRootsOfUnity R (Monoid.exponent Mˣ)] (N : Submonoid M), Function.Surjective ⇑(MulChar.domRestrictHom N R) | **Alias** of `MulChar.domRestrictHom_surjective`.
---
Let `N` be a submonoid of `M` group and let `R` be a ring with enough roots of unity.
Then any `R`-value multiplicative character of `N` can be extended to a multiplicative
character of `M`.
| true |
Asymptotics._aux_Mathlib_Analysis_Asymptotics_TVS___unexpand_Asymptotics_IsThetaTVS_1 | Mathlib.Analysis.Asymptotics.TVS | Lean.PrettyPrinter.Unexpander | null | false |
_private.Lean.Elab.Tactic.Try.0.Lean.Elab.Tactic.Try.toSuggestion | Lean.Elab.Tactic.Try | Lean.TSyntax `tactic → Lean.Meta.Tactic.TryThis.Suggestion | null | true |
AlgebraicGeometry.GeometricallyConnected.rec | Mathlib.AlgebraicGeometry.Geometrically.Connected | {X Y : AlgebraicGeometry.Scheme} →
{f : X ⟶ Y} →
{motive : AlgebraicGeometry.GeometricallyConnected f → Sort u} →
((geometrically_connectedSpace : AlgebraicGeometry.geometrically (fun x => ConnectedSpace ↥x) f) → motive ⋯) →
(t : AlgebraicGeometry.GeometricallyConnected f) → motive t | null | false |
Choose.primeFactors_gcd_choose_of_isPrimePow | Mathlib.Data.Nat.Choose.Lucas | ∀ {n : ℕ}, IsPrimePow n → ((Finset.Icc 1 (n - 1)).gcd n.choose).primeFactors = {n.minFac} | null | true |
_private.Mathlib.Topology.Order.IntermediateValue.0.setOfPred_isPreconnected_eq_of_ordered._simp_1_6 | Mathlib.Topology.Order.IntermediateValue | ∀ {α : Sort u_1} {p : α → Prop} {a' : α}, (∀ (a : α), a = a' → p a) = p a' | null | false |
_private.Mathlib.RingTheory.TwoSidedIdeal.Lattice.0.TwoSidedIdeal.mem_iInf._simp_1_1 | Mathlib.RingTheory.TwoSidedIdeal.Lattice | ∀ {R : Type u_1} [inst : NonUnitalNonAssocRing R] (I : TwoSidedIdeal R) (x : R), (x ∈ I) = I.ringCon x 0 | null | false |
Plausible.Testable.unusedVarTestable | Plausible.Testable | {var : String} →
{α : Sort u_1} →
{β : Prop} → [Nonempty α] → [Plausible.Testable β] → Plausible.Testable (Plausible.NamedBinder var (∀ (a : α), β)) | null | true |
Complex.I_smul_mem_skewAdjoint_iff_isSelfAdjoint | Mathlib.LinearAlgebra.Complex.Module | ∀ {A : Type u_1} [inst : AddCommGroup A] [inst_1 : Module ℂ A] [inst_2 : StarAddMonoid A] [StarModule ℂ A] {a : A},
Complex.I • a ∈ skewAdjoint A ↔ IsSelfAdjoint a | null | true |
ENormedAddCommMonoid.ctorIdx | Mathlib.Analysis.Normed.Group.Defs | {E : Type u_4} → {inst : TopologicalSpace E} → ENormedAddCommMonoid E → ℕ | null | false |
ArchimedeanClass.map_mk_le | Mathlib.Algebra.Order.Archimedean.Class | ∀ {M : Type u_1} [inst : AddCommGroup M] [inst_1 : LinearOrder M] [inst_2 : IsOrderedAddMonoid M] {a b : M}
{N : Type u_2} [inst_3 : AddCommGroup N] [inst_4 : LinearOrder N] [inst_5 : IsOrderedAddMonoid N] (f : M →+o N),
ArchimedeanClass.mk a ≤ ArchimedeanClass.mk b → ArchimedeanClass.mk (f a) ≤ ArchimedeanClass.mk... | null | true |
WittVector.exists_frobenius_solution_fractionRing_aux | Mathlib.RingTheory.WittVector.FrobeniusFractionField | ∀ (p : ℕ) [hp : Fact (Nat.Prime p)] {k : Type u_1} [inst : Field k] [inst_1 : CharP k p] [inst_2 : IsAlgClosed k]
(m n : ℕ) (r' q' : WittVector p k) (hr' : r'.coeff 0 ≠ 0) (hq' : q'.coeff 0 ≠ 0)
(hq : ↑p ^ n * q' ∈ nonZeroDivisors (WittVector p k)),
have b := WittVector.frobeniusRotation p hr' hq';
(IsFractionR... | null | true |
Real.Angle.toReal_eq_zero_iff | Mathlib.Analysis.SpecialFunctions.Trigonometric.Angle | ∀ {θ : Real.Angle}, θ.toReal = 0 ↔ θ = 0 | null | true |
PNat.natPred_lt_natPred | Mathlib.Data.PNat.Basic | ∀ {m n : ℕ+}, m.natPred < n.natPred ↔ m < n | null | true |
_private.Aesop.Util.UnorderedArraySet.0.Aesop.UnorderedArraySet.mk.injEq | Aesop.Util.UnorderedArraySet | ∀ {α : Type u_1} [inst : BEq α] (rep rep_1 : Array α), ({ rep := rep } = { rep := rep_1 }) = (rep = rep_1) | null | true |
FirstOrder.Field.ACF_zero_realize_iff_finite_ACF_prime_not_realize | Mathlib.ModelTheory.Algebra.Field.IsAlgClosed | ∀ {φ : FirstOrder.Language.ring.Sentence},
FirstOrder.Language.Theory.ACF 0 ⊨ᵇ φ ↔ {p | FirstOrder.Language.Theory.ACF ↑p ⊨ᵇ φ}ᶜ.Finite | Another statement of the **Lefschetz principle**. A first-order sentence is modeled by the
theory of algebraically closed fields of characteristic zero if and only if it is modeled by the
theory of algebraically closed fields of characteristic `p` for all but finitely many primes `p`.
| true |
Lean.Parser.Term.ensureTypeOf.parenthesizer | Lean.Parser.Term | Lean.PrettyPrinter.Parenthesizer | null | true |
Lean.MessageData.instCoeMVarId | Lean.Message | Coe Lean.MVarId Lean.MessageData | null | true |
Matroid.exists_isBase | Mathlib.Combinatorics.Matroid.Basic | ∀ {α : Type u_1} (self : Matroid α), ∃ B, self.IsBase B | There is at least one `Base`. | true |
CategoryTheory.Over.associator_hom_left_snd_snd_assoc | Mathlib.CategoryTheory.Monoidal.Cartesian.Over | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Limits.HasPullbacks C] {X : C}
(R S T : CategoryTheory.Over X) {Z : C} (h : T.left ⟶ Z),
CategoryTheory.CategoryStruct.comp
(CategoryTheory.Over.Hom.left (CategoryTheory.MonoidalCategoryStruct.associator R S T).hom)
... | null | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.