name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
LinearOrderedAddCommGroup.negGen_eq_of_top | Mathlib.Algebra.Order.Group.Cyclic | ∀ (G : Type u_1) [inst : AddCommGroup G] [inst_1 : LinearOrder G] [inst_2 : IsOrderedAddMonoid G]
[inst_3 : Nontrivial G] [inst_4 : IsAddCyclic G],
LinearOrderedAddCommGroup.negGen G = LinearOrderedAddCommGroup.Subgroup.negGen ⊤ | null | true |
IsCompl.sup_eq_top | Mathlib.Order.Disjoint | ∀ {α : Type u_1} [inst : Lattice α] [inst_1 : BoundedOrder α] {x y : α}, IsCompl x y → x ⊔ y = ⊤ | null | true |
ENNReal.one_le_coe_iff._simp_1 | Mathlib.Basic.ENNReal.Basic | ∀ {r : NNReal}, (1 ≤ ↑r) = (1 ≤ r) | null | false |
MeasureTheory.crossing_eq_crossing_of_lowerCrossingTime_lt | Mathlib.Probability.Martingale.Upcrossing | ∀ {Ω : Type u_1} {a b : ℝ} {f : ℕ → Ω → ℝ} {N n : ℕ} {ω : Ω} {M : ℕ},
N ≤ M →
MeasureTheory.lowerCrossingTime a b f N n ω < N →
MeasureTheory.upperCrossingTime a b f M n ω = MeasureTheory.upperCrossingTime a b f N n ω ∧
MeasureTheory.lowerCrossingTime a b f M n ω = MeasureTheory.lowerCrossingTime a ... | null | true |
Std.Time.instHSubOffsetOffset_41 | Std.Time.Date.Basic | HSub Std.Time.Week.Offset Std.Time.Day.Offset Std.Time.Day.Offset | null | true |
CategoryTheory.Localization.Construction.WhiskeringLeftEquivalence.inverse._proof_6 | Mathlib.CategoryTheory.Localization.Construction | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] (W : CategoryTheory.MorphismProperty C) (D : Type u_4)
[inst_1 : CategoryTheory.Category.{u_3, u_4} D] (G : W.FunctorsInverting D),
CategoryTheory.Localization.Construction.natTransExtension
(CategoryTheory.CategoryStruct.comp (CategoryTheory.eqTo... | null | false |
Filter.HasBasis.forall_iff | Mathlib.Order.Filter.Bases.Basic | ∀ {α : Type u_1} {ι : Sort u_3} {l : Filter α} {p : ι → Prop} {s : ι → Set α},
l.HasBasis p s →
∀ {P : Set α → Prop}, (∀ ⦃s t : Set α⦄, s ⊆ t → P s → P t) → ((∀ s ∈ l, P s) ↔ ∀ (i : ι), p i → P (s i)) | null | true |
String.Pos.noConfusionType | Init.Data.String.Defs | Sort u → {s : String} → s.Pos → {s' : String} → s'.Pos → Sort u | null | false |
AddGroup.ofLeftAxioms._proof_3 | Mathlib.Algebra.Group.MinimalAxioms | ∀ {G : Type u_1} [inst : Add G] [inst_1 : Zero G] (assoc : ∀ (a b c : G), a + b + c = a + (b + c)) (n : ℕ) (x : G),
(n + 1) • x = n • x + x | null | false |
covariant_le_of_covariant_lt | Mathlib.Algebra.Order.Monoid.Unbundled.Defs | ∀ (M : Type u_1) (N : Type u_2) (μ : M → N → N) [inst : PartialOrder N],
(Covariant M N μ fun x1 x2 => x1 < x2) → Covariant M N μ fun x1 x2 => x1 ≤ x2 | null | true |
CategoryTheory.Functor.LaxBraided.mk | Mathlib.CategoryTheory.Monoidal.Braided.Basic | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
[inst_1 : CategoryTheory.MonoidalCategory C] →
[inst_2 : CategoryTheory.BraidedCategory C] →
{D : Type u₂} →
[inst_3 : CategoryTheory.Category.{v₂, u₂} D] →
[inst_4 : CategoryTheory.MonoidalCategory D] →
... | null | true |
Finite.of_addSubgroup_quotient | Mathlib.GroupTheory.QuotientGroup.Finite | ∀ {G : Type u_2} [inst : AddGroup G] (H : AddSubgroup G) [Finite ↥H] [Finite (G ⧸ H)], Finite G | null | true |
Lean.Elab.Term.Context.declName? | Lean.Elab.Term.TermElabM | Lean.Elab.Term.Context → Option Lean.Name | null | true |
_private.Mathlib.NumberTheory.LSeries.PrimesInAP.0.ArithmeticFunction.vonMangoldt.summable_residueClass_non_primes_div._simp_1_2 | Mathlib.NumberTheory.LSeries.PrimesInAP | ∀ {G₀ : Type u_3} [inst : GroupWithZero G₀] {a b : G₀}, (a / b = 0) = (a = 0 ∨ b = 0) | null | false |
AddSubsemigroup.centerCongr_apply_coe | Mathlib.GroupTheory.Submonoid.Center | ∀ {M : Type u_2} {N : Type u_1} [inst : Add M] [inst_1 : Add N] (e : M ≃+ N) (r : ↥(AddSubsemigroup.center M)),
↑((AddSubsemigroup.centerCongr e) r) = e ↑r | null | true |
Matrix.ofNat_mulVec | Mathlib.Data.Matrix.Mul | ∀ {m : Type u_2} {α : Type v} [inst : NonAssocSemiring α] [inst_1 : Fintype m] [inst_2 : DecidableEq m] (x : ℕ)
[inst_3 : x.AtLeastTwo] (v : m → α), (OfNat.ofNat x).mulVec v = OfNat.ofNat x • v | null | true |
SchwartzMap.fderivCLM._proof_5 | Mathlib.Analysis.Distribution.SchwartzSpace.Deriv | ∀ (𝕜 : Type u_1) (F : Type u_2) [inst : NormedAddCommGroup F] [inst_1 : RCLike 𝕜] [inst_2 : NormedSpace 𝕜 F],
ContinuousConstSMul 𝕜 F | null | false |
CategoryTheory.Bicategory.eqToHomTransIso._proof_1 | Mathlib.CategoryTheory.Bicategory.EqToHom | ∀ {B : Type u_1} {x y : B}, x = y → x = y | null | false |
Semiring.toOppositeModule._proof_3 | Mathlib.Algebra.Module.Opposite | ∀ {R : Type u_1} [inst : Semiring R] (x x_1 : Rᵐᵒᵖ) (x_2 : R),
x_2 * (MulOpposite.unop x + MulOpposite.unop x_1) = x_2 * MulOpposite.unop x + x_2 * MulOpposite.unop x_1 | null | false |
StarSubalgebra.one_mem_toNonUnitalStarSubalgebra | Mathlib.Algebra.Star.Subalgebra | ∀ {R : Type u_1} {A : Type u_2} [inst : CommSemiring R] [inst_1 : StarRing R] [inst_2 : Semiring A]
[inst_3 : StarRing A] [inst_4 : Algebra R A] [inst_5 : StarModule R A] (S : StarSubalgebra R A),
1 ∈ S.toNonUnitalStarSubalgebra | null | true |
Primrec.ite | Mathlib.Computability.Primrec.Basic | ∀ {α : Type u_1} {σ : Type u_3} [inst : Primcodable α] [inst_1 : Primcodable σ] {c : α → Prop}
[inst_2 : DecidablePred c] {f g : α → σ},
PrimrecPred c → Primrec f → Primrec g → Primrec fun a => if c a then f a else g a | null | true |
List.idxToSigmaCount._proof_2 | Batteries.Data.List.Count | ∀ {α : Type u_1} (xs : List α) (i : Fin xs.length), ↑i < xs.length | null | false |
GroupTopology.instCompleteLattice._proof_1 | Mathlib.Topology.Algebra.Group.GroupTopology | ∀ {α : Type u_1} [inst : Group α] (a b : GroupTopology α), a ≤ SemilatticeSup.sup a b | null | false |
CategoryTheory.Limits.CategoricalPullback.mkNatIso_eq._proof_3 | Mathlib.CategoryTheory.Limits.Shapes.Pullback.Categorical.Basic | ∀ {A : Type u_6} {B : Type u_3} {C : Type u_8} [inst : CategoryTheory.Category.{u_5, u_6} A]
[inst_1 : CategoryTheory.Category.{u_2, u_3} B] [inst_2 : CategoryTheory.Category.{u_7, u_8} C]
{F : CategoryTheory.Functor A B} {G : CategoryTheory.Functor C B} {X : Type u_1}
[inst_3 : CategoryTheory.Category.{u_4, u_1}... | null | false |
LieSubmodule.subsingleton_iff | Mathlib.Algebra.Lie.Submodule | ∀ (R : Type u) (L : Type v) (M : Type w) [inst : CommRing R] [inst_1 : LieRing L] [inst_2 : AddCommGroup M]
[inst_3 : Module R M] [inst_4 : LieRingModule L M], Subsingleton (LieSubmodule R L M) ↔ Subsingleton M | null | true |
_private.Std.Time.Format.Basic.0.Std.Time.formatDayPeriod.match_1 | Std.Time.Format.Basic | (motive : Std.Time.DayPeriod → Sort u_1) →
(period : Std.Time.DayPeriod) →
(Unit → motive Std.Time.DayPeriod.am) →
(Unit → motive Std.Time.DayPeriod.pm) →
(Unit → motive Std.Time.DayPeriod.noon) → (Unit → motive Std.Time.DayPeriod.midnight) → motive period | null | false |
Finsupp.instEMetricSpaceWithLpOfNNReal._proof_3 | Mathlib.Analysis.Normed.Lp.Finsupp | ∀ {ι : Type u_1} {X : Type u_2} [inst : Zero X] {p : NNReal} [inst_1 : Fact (1 ≤ p)] [inst_2 : EMetricSpace X]
{f g : WithLp (↑p) (ι →₀ X)}, edist f g = 0 → f = g | null | false |
Odd.exists_bit1 | Mathlib.Algebra.Ring.Parity | ∀ {α : Type u_2} [inst : Semiring α] {a : α}, Odd a → ∃ b, a = 2 * b + 1 | **Alias** of the forward direction of `odd_iff_exists_bit1`. | true |
Int32.toUInt32_le | Init.Data.SInt.Lemmas | ∀ {a b : Int32}, 0 ≤ a → a ≤ b → a.toUInt32 ≤ b.toUInt32 | null | true |
Int16.or_neg_one | Init.Data.SInt.Bitwise | ∀ {a : Int16}, a ||| -1 = -1 | null | true |
HomologicalComplex₂.shape_f | Mathlib.Algebra.Homology.HomologicalBicomplex | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
{I₁ : Type u_2} {I₂ : Type u_3} {c₁ : ComplexShape I₁} {c₂ : ComplexShape I₂} (K : HomologicalComplex₂ C c₁ c₂)
(i₁ i₁' : I₁), ¬c₁.Rel i₁ i₁' → ∀ (i₂ : I₂), (K.d i₁ i₁').f i₂ = 0 | null | true |
Cardinal.mul_eq_max_of_aleph0_le_right | Mathlib.SetTheory.Cardinal.Arithmetic | ∀ {a b : Cardinal.{u_1}}, a ≠ 0 → Cardinal.aleph0 ≤ b → a * b = max a b | null | true |
NNReal.measurableSpace._aux_1 | Mathlib.MeasureTheory.Constructions.BorelSpace.Basic | Set NNReal → Prop | null | false |
Prod.addAction._proof_2 | Mathlib.Algebra.Group.Action.Prod | ∀ {M : Type u_3} {α : Type u_1} {β : Type u_2} [inst : AddMonoid M] [inst_1 : AddAction M α] [inst_2 : AddAction M β]
(x : α × β), 0 +ᵥ x = x | null | false |
HasSubset.casesOn | Init.Core | {α : Type u} →
{motive : HasSubset α → Sort u_1} →
(t : HasSubset α) → ((Subset : α → α → Prop) → motive { Subset := Subset }) → motive t | null | false |
Std.DTreeMap.«term_~m_» | Std.Data.DTreeMap.Basic | Lean.TrailingParserDescr | Two tree maps are equivalent in the sense of Equiv iff all the keys and values are equal. | true |
SmoothBumpCovering.noConfusionType | Mathlib.Geometry.Manifold.PartitionOfUnity | Sort u →
{ι : Type uι} →
{E : Type uE} →
[inst : NormedAddCommGroup E] →
[inst_1 : NormedSpace ℝ E] →
{H : Type uH} →
[inst_2 : TopologicalSpace H] →
{I : ModelWithCorners ℝ E H} →
{M : Type uM} →
[inst_3 : TopologicalSpace M] →
... | null | false |
Filter.lift_iInf_of_directed | Mathlib.Order.Filter.Lift | ∀ {α : Type u_1} {β : Type u_2} {ι : Sort u_4} [Nonempty ι] {f : ι → Filter α} {g : Set α → Filter β},
Directed (fun x1 x2 => x1 ≥ x2) f → Monotone g → (iInf f).lift g = ⨅ i, (f i).lift g | null | true |
HomotopicalAlgebra.CofibrantObject.HoCat.resolutionCompToLocalizationNatTrans | Mathlib.AlgebraicTopology.ModelCategory.CofibrantObjectHomotopy | {C : Type u_1} →
[inst : CategoryTheory.Category.{v_1, u_1} C] →
[inst_1 : HomotopicalAlgebra.ModelCategory C] →
{D : Type u_2} →
[inst_2 : CategoryTheory.Category.{v_2, u_2} D] →
(L : CategoryTheory.Functor C D) →
[inst_3 : L.IsLocalization (HomotopicalAlgebra.weakEquivalences... | The natural isomorphism `HoCat.resolution ⋙ HoCat.toLocalization L ⟶ L` when
`L : C ⥤ D` is a localization functor. | true |
IsSquare.exists_sq | Mathlib.Algebra.Group.Even | ∀ {α : Type u_2} [inst : Monoid α] (a : α), IsSquare a → ∃ r, a = r ^ 2 | **Alias** of the forward direction of `isSquare_iff_exists_sq`. | true |
Aesop.Frontend.BuilderOption.index.noConfusion | Aesop.Frontend.RuleExpr | {P : Sort u} →
{imode imode' : Aesop.IndexingMode} →
Aesop.Frontend.BuilderOption.index imode = Aesop.Frontend.BuilderOption.index imode' → (imode = imode' → P) → P | null | false |
AlgCat.tensorAlgebra._proof_1 | Mathlib.Algebra.Category.AlgCat.TensorAlgebra | ∀ (R : Type u_1) [inst : CommRing R] (M : ModuleCat R), IsScalarTower R R ↑M | null | false |
MvPolynomial.mem_supported_vars | Mathlib.Algebra.MvPolynomial.Supported | ∀ {σ : Type u_1} {R : Type u} [inst : CommSemiring R] (p : MvPolynomial σ R), p ∈ MvPolynomial.supported R ↑p.vars | null | true |
self_mem_nhdsWithin | Mathlib.Topology.NhdsWithin | ∀ {α : Type u_1} [inst : TopologicalSpace α] {a : α} {s : Set α}, s ∈ nhdsWithin a s | null | true |
SimpleGraph.IsMaximumClique.congr_simp | Mathlib.Combinatorics.SimpleGraph.Clique | ∀ {α : Type u_3} [inst : Finite α] (G G_1 : SimpleGraph α),
G = G_1 → ∀ (s s_1 : Finset α), s = s_1 → G.IsMaximumClique s = G_1.IsMaximumClique s_1 | null | true |
Nonneg.unitsHomeomorphPos._proof_1 | Mathlib.Topology.Algebra.Field | ∀ (R : Type u_1) [inst : DivisionSemiring R] [inst_1 : PartialOrder R] [inst_2 : IsStrictOrderedRing R]
[inst_3 : PosMulReflectLT R] [inst_4 : TopologicalSpace R], Continuous (Nonneg.unitsEquivPos R).toFun | null | false |
IsSl2Triple.HasPrimitiveVectorWith.casesOn | Mathlib.Algebra.Lie.Sl2 | {R : Type u_1} →
{L : Type u_2} →
{M : Type u_3} →
[inst : CommRing R] →
[inst_1 : LieRing L] →
[inst_2 : AddCommGroup M] →
[inst_3 : Module R M] →
[inst_4 : LieRingModule L M] →
{h e f : L} →
{t : IsSl2Triple h e f} →
... | null | false |
SimpleGraph.Copy.isoSubgraphMap._simp_1 | Mathlib.Combinatorics.SimpleGraph.Copy | ∀ {α : Type u_1} {β : Type u_2} {γ : Type u_3} {δ : Type u_4} {r : α → β → Prop} {f : α → γ} {g : β → δ} {c : γ}
{d : δ}, Relation.Map r f g c d = ∃ a b, r a b ∧ f a = c ∧ g b = d | null | false |
Aesop.Rapp.setState | Aesop.Tree.Data | Aesop.NodeState → Aesop.Rapp → Aesop.Rapp | null | true |
Subrepresentation.instMax | Mathlib.RepresentationTheory.Subrepresentation | {A : Type u_1} →
{G : Type u_2} →
{W : Type u_3} →
[inst : Semiring A] →
[inst_1 : Monoid G] →
[inst_2 : AddCommMonoid W] → [inst_3 : Module A W] → {ρ : Representation A G W} → Max (Subrepresentation ρ) | null | true |
List.find?_pmap.match_1 | Init.Data.List.Find | {α : Type u_1} →
{xs : List α} →
(motive : { x // x ∈ xs } → Sort u_2) → (x : { x // x ∈ xs }) → ((a : α) → (m : a ∈ xs) → motive ⟨a, m⟩) → motive x | null | false |
TwoSidedIdeal.jacobson | Mathlib.RingTheory.Jacobson.Ideal | {R : Type u} → [inst : Ring R] → TwoSidedIdeal R → TwoSidedIdeal R | The Jacobson radical of `I` is the infimum of all maximal (left) ideals containing `I`. | true |
_private.Lean.Compiler.LCNF.ToLCNF.0.Lean.Compiler.LCNF.ToLCNF.toLCNF.visitCore.match_3 | Lean.Compiler.LCNF.ToLCNF | (motive : Lean.Expr → Sort u_1) →
(e : Lean.Expr) →
((fn arg : Lean.Expr) → motive (fn.app arg)) →
((declName : Lean.Name) → (us : List Lean.Level) → motive (Lean.Expr.const declName us)) →
((s : Lean.Name) → (i : ℕ) → (e : Lean.Expr) → motive (Lean.Expr.proj s i e)) →
((d : Lean.MData) → ... | null | false |
_private.Mathlib.RingTheory.WittVector.MulCoeff.0.WittVector._aux_Mathlib_RingTheory_WittVector_MulCoeff___unexpand_WittVector_1 | Mathlib.RingTheory.WittVector.MulCoeff | Lean.PrettyPrinter.Unexpander | null | false |
SchwartzMap.instLineDeriv._proof_1 | Mathlib.Analysis.Distribution.SchwartzSpace.Deriv | ∀ {E : Type u_2} {F : Type u_1} [inst : NormedAddCommGroup E] [inst_1 : NormedAddCommGroup F] [inst_2 : NormedSpace ℝ F]
[inst_3 : NormedSpace ℝ E], SMulCommClass ℝ ℝ (E →L[ℝ] F) | null | false |
Lean.Meta.repeat1' | Lean.Meta.Tactic.Repeat | {m : Type → Type} →
{ε : Type u_1} →
{s : Type} →
[Monad m] →
[Lean.MonadError m] →
[MonadExcept ε m] →
[Lean.MonadBacktrack s m] →
[Lean.MonadMCtx m] →
(Lean.MVarId → m (List Lean.MVarId)) → List Lean.MVarId → optParam ℕ 100000 → m (List Lean.MVar... | `repeat1' f` runs `f` on all of the goals to produce a new list of goals,
then runs `f` again on all of those goals, and repeats until `f` fails on all remaining goals,
or until `maxIters` total calls to `f` have occurred.
Fails if `f` does not succeed at least once.
| true |
ArithmeticFunction.carmichael._proof_3 | Mathlib.NumberTheory.ArithmeticFunction.Carmichael | (match 0 with
| 0 => 0
| n.succ => Nat.find ⋯) =
match 0 with
| 0 => 0
| n.succ => Nat.find ⋯ | null | false |
_private.Lean.Meta.Tactic.Grind.EMatchTheorem.0.Lean.Meta.Grind.Collector.Context.mk.injEq | Lean.Meta.Tactic.Grind.EMatchTheorem | ∀ (proof : Lean.Expr) (xs : Array Lean.Expr) (proof_1 : Lean.Expr) (xs_1 : Array Lean.Expr),
({ proof := proof, xs := xs } = { proof := proof_1, xs := xs_1 }) = (proof = proof_1 ∧ xs = xs_1) | null | true |
Aesop.Script.SScript.empty | Aesop.Script.SScript | Aesop.Script.SScript | null | true |
add_sub_assoc' | Mathlib.Algebra.Group.Basic | ∀ {G : Type u_3} [inst : SubNegMonoid G] (a b c : G), a + (b - c) = a + b - c | null | true |
RatFunc.toFractionRingAlgEquiv | Mathlib.FieldTheory.RatFunc.Basic | (K : Type u) →
[inst : CommRing K] →
[inst_1 : IsDomain K] →
(R : Type u_1) →
[inst_2 : CommSemiring R] → [inst_3 : Algebra R (Polynomial K)] → RatFunc K ≃ₐ[R] FractionRing (Polynomial K) | The equivalence between `K⟮X⟯` and the field of fractions of `K[X]`
| true |
Algebra.Extension.algebraMap_σ | Mathlib.RingTheory.Extension.Basic | ∀ {R : Type u} {S : Type v} [inst : CommRing R] [inst_1 : CommRing S] [inst_2 : Algebra R S]
(self : Algebra.Extension R S) (x : S), (algebraMap self.Ring S) (self.σ x) = x | null | true |
List.not_lt_minimum_of_mem | Mathlib.Data.List.MinMax | ∀ {α : Type u_1} [inst : Preorder α] [inst_1 : DecidableLT α] {l : List α} {a m : α}, a ∈ l → l.minimum = ↑m → ¬a < m | null | true |
CategoryTheory.Pseudofunctor.DescentData'.descentData | Mathlib.CategoryTheory.Sites.Descent.DescentDataPrime | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
{F : CategoryTheory.Pseudofunctor (CategoryTheory.LocallyDiscrete Cᵒᵖ) CategoryTheory.Cat} →
{ι : Type t} →
{S : C} →
{X : ι → C} →
{f : (i : ι) → X i ⟶ S} →
{sq : (i j : ι) → CategoryTheory.Limits.ChosenP... | The functor `toDescentDataFunctor : F.DescentData' sq sq₃ ⥤ F.DescentData f`, on objects. | true |
_private.Init.Data.List.Nat.Basic.0.List.length_filterMap_lt_length_iff_exists._proof_1_5 | Init.Data.List.Nat.Basic | ∀ {α : Type u_1} {β : Type u_2} {f : α → Option β} (xs : List α),
(List.filterMap f xs).length ≤ xs.length → ¬(List.filterMap f xs).length < xs.length + 1 → False | null | false |
Lean.Parser.Tactic.Conv.convLeft | Init.Conv | Lean.ParserDescr | `left` traverses into the left argument. Synonym for `lhs`. | true |
Ideal.map_sup | Mathlib.RingTheory.Ideal.Maps | ∀ {R : Type u} {S : Type v} {F : Type u_1} [inst : Semiring R] [inst_1 : Semiring S] [inst_2 : FunLike F R S] (f : F)
(I J : Ideal R) [RingHomClass F R S], Ideal.map f (I ⊔ J) = Ideal.map f I ⊔ Ideal.map f J | null | true |
FirstOrder.Language.LHom.substructureReduct._proof_2 | Mathlib.ModelTheory.Substructures | ∀ {L : FirstOrder.Language} {M : Type u_3} [inst : L.Structure M] {L' : FirstOrder.Language} [inst_1 : L'.Structure M]
(φ : L →ᴸ L') [inst_2 : φ.IsExpansionOn M] {x x_1 : L'.Substructure M},
{ toFun := fun S => { carrier := ↑S, fun_mem := ⋯ }, inj' := ⋯ } x ≤
{ toFun := fun S => { carrier := ↑S, fun_mem := ⋯ ... | null | false |
AlgebraicGeometry.LocallyRingedSpace.HasCoequalizer.imageBasicOpen | Mathlib.Geometry.RingedSpace.LocallyRingedSpace.HasColimits | {X Y : AlgebraicGeometry.LocallyRingedSpace} →
(f g : X ⟶ Y) →
(U :
TopologicalSpace.Opens
↑↑(CategoryTheory.Limits.coequalizer (AlgebraicGeometry.LocallyRingedSpace.Hom.toShHom f)
(AlgebraicGeometry.LocallyRingedSpace.Hom.toShHom g)).toPresheafedSpace) →
↑((CategoryTheor... | (Implementation). The basic open set of the section `π꙳ s`. | true |
unitarySubgroupUnitsEquiv._proof_7 | Mathlib.Algebra.Star.Unitary | ∀ {M : Type u_1} [inst : Monoid M] [inst_1 : StarMul M] (x : ↥(unitarySubgroup Mˣ)),
star { val := ↑⟨↑↑x, ⋯⟩, inv := star ↑⟨↑↑x, ⋯⟩, val_inv := ⋯, inv_val := ⋯ } *
{ val := ↑⟨↑↑x, ⋯⟩, inv := star ↑⟨↑↑x, ⋯⟩, val_inv := ⋯, inv_val := ⋯ } =
1 ∧
{ val := ↑⟨↑↑x, ⋯⟩, inv := star ↑⟨↑↑x, ⋯⟩, val_inv := ⋯, i... | null | false |
NumberField.mixedEmbedding.instIsZLatticeRealMixedSpaceIntegerLattice | Mathlib.NumberTheory.NumberField.CanonicalEmbedding.Basic | ∀ (K : Type u_1) [inst : Field K] [inst_1 : NumberField K], IsZLattice ℝ (NumberField.mixedEmbedding.integerLattice K) | null | true |
Std.TreeMap.min?_keys | Std.Data.TreeMap.Lemmas | ∀ {α : Type u} {β : Type v} {cmp : α → α → Ordering} {t : Std.TreeMap α β cmp} [Std.TransCmp cmp] [inst : Min α]
[inst_1 : LE α] [Std.LawfulOrderCmp cmp] [Std.LawfulOrderMin α] [Std.LawfulOrderLeftLeaningMin α]
[Std.LawfulEqCmp cmp], t.keys.min? = t.minKey? | null | true |
LocalizedModule.instRing._proof_2 | Mathlib.Algebra.Module.LocalizedModule.Basic | ∀ {R : Type u_1} [inst : CommSemiring R] {A : Type u_2} [inst_1 : Ring A] [inst_2 : Algebra R A] {S : Submonoid R}
(n : ℕ), (Int.negSucc n).castDef = -↑(n + 1) | null | false |
BialgCat.Hom.mk.sizeOf_spec | Mathlib.Algebra.Category.BialgCat.Basic | ∀ {R : Type u} [inst : CommRing R] {V W : BialgCat R} [inst_1 : SizeOf R] (toBialgHom' : V.carrier →ₐc[R] W.carrier),
sizeOf { toBialgHom' := toBialgHom' } = 1 + sizeOf toBialgHom' | null | true |
Mathlib.Meta.NormNum.Result'.isNat.injEq | Mathlib.Tactic.NormNum.Result | ∀ (inst lit proof inst_1 lit_1 proof_1 : Lean.Expr),
(Mathlib.Meta.NormNum.Result'.isNat inst lit proof = Mathlib.Meta.NormNum.Result'.isNat inst_1 lit_1 proof_1) =
(inst = inst_1 ∧ lit = lit_1 ∧ proof = proof_1) | null | true |
CategoryTheory.Limits.HasWeakKernels.mk._flat_ctor | Mathlib.CategoryTheory.Limits.WeakLimits.WeakKernels | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C],
autoParam (∀ {X Y : C} (f : X ⟶ Y), CategoryTheory.Limits.HasWeakKernel f)
CategoryTheory.Limits.HasWeakKernels.hasWeakLimit._autoParam →
CategoryTheory.Limits.HasWeakKernels C | null | false |
Set.iInter₂_add_subset | Mathlib.Algebra.Group.Pointwise.Set.Lattice | ∀ {α : Type u_1} {ι : Sort u_3} {κ : ι → Sort u_4} [inst : Add α] (s : (i : ι) → κ i → Set α) (t : Set α),
(⋂ i, ⋂ j, s i j) + t ⊆ ⋂ i, ⋂ j, s i j + t | null | true |
ciSup_or' | Mathlib.Order.ConditionallyCompleteLattice.Indexed | ∀ {α : Type u_1} [inst : ConditionallyCompleteLinearOrderBot α] (p q : Prop) (f : p ∨ q → α),
⨆ (h : p ∨ q), f h = max (⨆ (h : p), f ⋯) (⨆ (h : q), f ⋯) | **Alias** of `ciSup_or`. | true |
Fin2.cases'.match_1 | Mathlib.Data.Fin.Fin2 | {n : ℕ} →
(motive : Fin2 n.succ → Sort u_1) →
(x : Fin2 n.succ) → (Unit → motive Fin2.fz) → ((n_1 : Fin2 n) → motive n_1.fs) → motive x | null | false |
FreeAddMonoid.ofList_nil | Mathlib.Algebra.FreeMonoid.Basic | ∀ {α : Type u_1}, FreeAddMonoid.ofList [] = 0 | null | true |
UInt8.ofInt_add | Init.Data.UInt.Lemmas | ∀ (x y : ℤ), UInt8.ofInt (x + y) = UInt8.ofInt x + UInt8.ofInt y | null | true |
isMeagre_iff_eq_countable_union_isNowhereDense | Mathlib.Topology.GDelta.Basic | ∀ {X : Type u_1} [inst : TopologicalSpace X] {s : Set X},
IsMeagre s ↔ ∃ S, (∀ t ∈ S, IsNowhereDense t) ∧ S.Countable ∧ s = ⋃₀ S | A set is meagre iff it is a countable union of nowhere dense sets. | true |
Lean.Parser.Command.declModifiersF.formatter | Lean.Parser.Command | Lean.PrettyPrinter.Formatter | null | true |
ComplexShape.instTotalComplexShapeSymmetryIntUp._proof_2 | Mathlib.Algebra.Homology.ComplexShapeSigns | ∀ (i₁ : ℤ) {i₂ i₂' : ℤ},
(ComplexShape.up ℤ).Rel i₂ i₂' →
(i₁ * i₂).negOnePow * (ComplexShape.up ℤ).ε₂ (ComplexShape.up ℤ) (ComplexShape.up ℤ) (i₁, i₂) =
(ComplexShape.up ℤ).ε₁ (ComplexShape.up ℤ) (ComplexShape.up ℤ) (i₂, i₁) * (i₁ * i₂').negOnePow | null | false |
_private.Std.Http.Protocol.H1.Redirect.0.Std.Http.Protocol.H1.decideRedirect._sparseCasesOn_1 | Std.Http.Protocol.H1.Redirect | {motive : Std.Http.Status → Sort u} →
(t : Std.Http.Status) →
motive Std.Http.Status.movedPermanently →
motive Std.Http.Status.found →
motive Std.Http.Status.temporaryRedirect →
motive Std.Http.Status.permanentRedirect → (Nat.hasNotBit 6389760 t.ctorIdx → motive t) → motive t | null | false |
_private.Mathlib.Tactic.Ring.Common.0.Mathlib.Tactic.Ring.Common.evalPowProd.match_5 | Mathlib.Tactic.Ring.Common | {u : Lean.Level} →
{α : Q(Type u)} →
{bt : Q(«$α») → Type} →
{sα : Q(CommSemiring «$α»)} →
{b : Q(ℕ)} →
(a : Q(«$α»)) →
(motive : Mathlib.Tactic.Ring.Common.Result bt q(«$a» ^ «$b») → Sort u_1) →
(x : Mathlib.Tactic.Ring.Common.Result bt q(«$a» ^ «$b»)) →
... | null | false |
_private.Mathlib.Algebra.Lie.Subalgebra.0.LieSubalgebra.toSubmodule_eq_top._simp_1_1 | Mathlib.Algebra.Lie.Subalgebra | ∀ {R : Type u} {L : Type v} [inst : CommRing R] [inst_1 : LieRing L] [inst_2 : LieAlgebra R L]
(L₁' L₂' : LieSubalgebra R L), (L₁' = L₂') = (L₁'.toSubmodule = L₂'.toSubmodule) | null | false |
Nat.ne_of_beq_eq_false._f | Init.Prelude | ∀ (x : ℕ) (f : Nat.below (motive := fun x => ∀ (x_1 : ℕ), x.beq x_1 = false → x = x_1 → False) x) (x_1 : ℕ),
x.beq x_1 = false → x = x_1 → False | null | false |
Algebra.TensorProduct.productLeftAlgHom | Mathlib.RingTheory.TensorProduct.Maps | {R : Type uR} →
{S : Type uS} →
{A : Type uA} →
{B : Type uB} →
{C : Type uC} →
[inst : CommSemiring R] →
[inst_1 : CommSemiring S] →
[inst_2 : Algebra R S] →
[inst_3 : Semiring A] →
[inst_4 : Algebra R A] →
[i... | If `A`, `B`, `C` are `R`-algebras, `A` and `C` are also `S`-algebras (forming a tower as
`·/S/R`), then the product map of `f : A →ₐ[S] C` and `g : B →ₐ[R] C` is an `S`-algebra
homomorphism.
This is just a special case of `Algebra.TensorProduct.lift` for when `C` is commutative. | true |
Nat.add_div_eq_of_le_mod_add_mod | Mathlib.Data.Nat.ModEq | ∀ {a b c : ℕ}, c ≤ a % c + b % c → 0 < c → (a + b) / c = a / c + b / c + 1 | null | true |
CommRingCat.Colimits.instCommRingColimitType._proof_16 | Mathlib.Algebra.Category.Ring.Colimits | ∀ {J : Type u_1} [inst : CategoryTheory.SmallCategory J] (F : CategoryTheory.Functor J CommRingCat), ↑0 = 0 | null | false |
SimpleGraph.map_adj | Mathlib.Combinatorics.SimpleGraph.Maps | ∀ {V : Type u_1} {W : Type u_2} (f : V ↪ W) (G : SimpleGraph V) (u v : W),
(SimpleGraph.map (⇑f) G).Adj u v ↔ ∃ u' v', G.Adj u' v' ∧ f u' = u ∧ f v' = v | null | true |
CategoryTheory.Triangulated.TStructure.IsGE.mk._flat_ctor | Mathlib.CategoryTheory.Triangulated.TStructure.Basic | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Preadditive C]
[inst_2 : CategoryTheory.Limits.HasZeroObject C] [inst_3 : CategoryTheory.HasShift C ℤ]
[inst_4 : ∀ (n : ℤ), (CategoryTheory.shiftFunctor C n).Additive] [inst_5 : CategoryTheory.Pretriangulated C]
{t : CategoryT... | null | false |
ProbabilityTheory.Kernel.iIndepFun.indepFun_sum_range_succ | Mathlib.Probability.Independence.Kernel.IndepFun | ∀ {α : Type u_1} {Ω : Type u_2} {mα : MeasurableSpace α} {mΩ : MeasurableSpace Ω} {κ : ProbabilityTheory.Kernel α Ω}
{μ : MeasureTheory.Measure α} {β : Type u_8} {m : MeasurableSpace β} [inst : AddCommMonoid β] [MeasurableAdd₂ β]
{f : ℕ → Ω → β},
ProbabilityTheory.Kernel.iIndepFun f κ μ →
(∀ (i : ℕ), Measurab... | null | true |
List.toFinsupp | Mathlib.Data.List.ToFinsupp | {M : Type u_1} → [inst : Zero M] → (l : List M) → [DecidablePred fun x => l.getD x 0 ≠ 0] → ℕ →₀ M | Indexing into a `l : List M`, as a finitely-supported function,
where the support are all the indices within the length of the list
that index to a non-zero value. Indices beyond the end of the list are sent to 0.
This is a computable version of the `Finsupp.onFinset` construction.
| true |
CategoryTheory.Equivalence.sheafCongr.functor_obj_obj_obj | Mathlib.CategoryTheory.Sites.Equivalence | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] (J : CategoryTheory.GrothendieckTopology C) {D : Type u₂}
[inst_1 : CategoryTheory.Category.{v₂, u₂} D] (K : CategoryTheory.GrothendieckTopology D) (e : C ≌ D) (A : Type u₃)
[inst_2 : CategoryTheory.Category.{v₃, u₃} A] [inst_3 : CategoryTheory.Functor.IsD... | null | true |
Filter.tendsto_mul_const_iff | Mathlib.Topology.Algebra.Group.Basic | ∀ {G : Type u_1} {α : Type u_3} [inst : TopologicalSpace G] [inst_1 : Group G] [SeparatelyContinuousMul G] (b : G)
{c : G} {f : α → G} {l : Filter α}, Filter.Tendsto (fun x => f x * b) l (nhds (c * b)) ↔ Filter.Tendsto f l (nhds c) | null | true |
smul_nonpos_iff_pos_imp_nonpos | Mathlib.Algebra.Order.Module.Defs | ∀ {α : Type u_1} {β : Type u_2} [inst : Ring α] [inst_1 : LinearOrder α] [IsStrictOrderedRing α]
[inst_3 : AddCommGroup β] [inst_4 : LinearOrder β] [IsOrderedAddMonoid β] [inst_6 : Module α β]
[PosSMulStrictMono α β] {a : α} {b : β}, a • b ≤ 0 ↔ (0 < a → b ≤ 0) ∧ (b < 0 → 0 ≤ a) | null | true |
CategoryTheory.Pseudofunctor.mapComp'₀₁₃_hom_assoc | Mathlib.CategoryTheory.Bicategory.Strict.Pseudofunctor | ∀ {B : Type u₁} {C : Type u₂} [inst : CategoryTheory.Bicategory B] [inst_1 : CategoryTheory.Bicategory.Strict B]
[inst_2 : CategoryTheory.Bicategory C] (F : CategoryTheory.Pseudofunctor B C) {b₀ b₁ b₂ b₃ : B} (f₀₁ : b₀ ⟶ b₁)
(f₁₂ : b₁ ⟶ b₂) (f₂₃ : b₂ ⟶ b₃) (f₀₂ : b₀ ⟶ b₂) (f₁₃ : b₁ ⟶ b₃) (f : b₀ ⟶ b₃)
(h₀₂ : Cate... | null | true |
Std.Time.PlainDate.format | Std.Time.Format | Std.Time.PlainDate → String → optParam Std.Time.DateFormat Std.Time.DateFormat.enUS → String | Formats a `PlainDate` using a specific format and locale.
| true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.