name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
HomotopicalAlgebra.PathObject.ofFactorizationData_p₁ | Mathlib.AlgebraicTopology.ModelCategory.PathObject | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : HomotopicalAlgebra.ModelCategory C] {A : C}
(h :
(HomotopicalAlgebra.trivialCofibrations C).MapFactorizationData (HomotopicalAlgebra.fibrations C)
(CategoryTheory.Limits.diag A)),
(HomotopicalAlgebra.PathObject.ofFactorizationData h).p₁ =
... | null | true |
NoncompactSpace.mk | Mathlib.Topology.Defs.Filter | ∀ {X : Type u_1} [inst : TopologicalSpace X], ¬IsCompact Set.univ → NoncompactSpace X | null | true |
Ideal.equivFinTwo._proof_2 | Mathlib.RingTheory.Ideal.Basic | ∀ (K : Type u_1) [inst : DivisionSemiring K] (i : Fin 2), (fun I => if I = ⊥ then 0 else 1) (![⊥, ⊤] i) = i | null | false |
_private.Mathlib.AlgebraicTopology.SimplicialObject.II.0.SimplexCategory.II.map'_succAboveOrderEmb._simp_1_5 | Mathlib.AlgebraicTopology.SimplicialObject.II | ∀ {n : ℕ} {i : Fin (n + 1)} {j : Fin n}, (i ≤ j.castSucc) = (i < j.succ) | null | false |
HahnSeries.toMvPowerSeries_symm_apply_coeff | Mathlib.RingTheory.HahnSeries.PowerSeries | ∀ {R : Type u_2} [inst : Semiring R] {σ : Type u_3} [inst_1 : Finite σ] (f : MvPowerSeries σ R),
(HahnSeries.toMvPowerSeries.symm f).coeff = f | null | true |
AlgebraicGeometry.HasRingHomProperty.descendsAlong | Mathlib.AlgebraicGeometry.Morphisms.Descent | ∀ (P P' : CategoryTheory.MorphismProperty AlgebraicGeometry.Scheme)
(Q Q' : {R S : Type u} → [inst : CommRing R] → [inst_1 : CommRing S] → (R →+* S) → Prop) [P'.IsStableUnderBaseChange]
[P'.IsStableUnderComposition] [P.IsStableUnderBaseChange],
@AlgebraicGeometry.IsLocalIso ⊓ @AlgebraicGeometry.Surjective ≤ P' →
... | Let `P` be the morphism property associated to the ring hom property `Q`. Suppose
- `P'` implies `Q'` on global sections for affine schemes,
- `P'` is satisfied for all surjective, local isomorphisms, and
- `Q` codescend along `Q'`.
Then `P` descends along quasi-compact morphisms satisfying `P'`.
Note: The second co... | true |
TopologicalSpace.OpenNhds.coe_id | Mathlib.Topology.Category.TopCat.OpenNhds | ∀ {X : TopCat} {x : ↑X} {U : TopologicalSpace.OpenNhds x} (f : U ⟶ U), ⇑f = id | null | true |
Finite.instSigma | Mathlib.Basic.Finite.Sigma | ∀ {α : Type u_1} {β : α → Type u_2} [Finite α] [∀ (a : α), Finite (β a)], Finite ((a : α) × β a) | null | true |
_private.Lean.Meta.Sym.Pattern.0.Lean.Meta.Sym.UnifyM.State.iPending._default | Lean.Meta.Sym.Pattern | Array (Lean.Expr × Lean.Expr) | null | false |
UpperSet.compl_sup | Mathlib.Order.UpperLower.CompleteLattice | ∀ {α : Type u_1} [inst : LE α] (s t : UpperSet α), (s ⊔ t).compl = s.compl ⊔ t.compl | null | true |
Submonoid.LocalizationMap.recOn | Mathlib.GroupTheory.MonoidLocalization.Basic | {M : Type u_1} →
[inst : CommMonoid M] →
{S : Submonoid M} →
{N : Type u_2} →
[inst_1 : CommMonoid N] →
{motive : S.LocalizationMap N → Sort u} →
(t : S.LocalizationMap N) →
((toMulHom : M →ₙ* N) →
(isLocalizationMap : S.IsLocalizationMap toMulHo... | null | false |
abs_zero | Mathlib.Algebra.Order.Group.Unbundled.Abs | ∀ {α : Type u_1} [inst : Lattice α] [inst_1 : AddGroup α] [AddLeftMono α], |0| = 0 | null | true |
Polynomial.valuation_eq_valuation_X_pow_natDegree_of_one_lt_valuation_X | Mathlib.FieldTheory.RatFunc.AsPolynomial | ∀ (K : Type u_1) [inst : Field K] {Γ : Type u_2} [inst_1 : LinearOrderedCommGroupWithZero Γ]
{v : Valuation (RatFunc K) Γ} [hv : Valuation.IsTrivialOn K v],
1 < v RatFunc.X → ∀ {p : Polynomial K}, p ≠ 0 → v ↑p = v RatFunc.X ^ p.natDegree | If a valuation `v` is trivial on constants and `1 < v RatFunc.X` then for every polynomial `p`,
`v p = v RatFunc.X ^ p.natDegree`.
Note: The condition `1 < v RatFunc.X` is typically satisfied by the valuation at infinity. | true |
Std.ExtDTreeMap.getKey!_inter_of_mem_right | Std.Data.ExtDTreeMap.Lemmas | ∀ {α : Type u} {β : α → Type v} {cmp : α → α → Ordering} {t₁ t₂ : Std.ExtDTreeMap α β cmp} [inst : Inhabited α]
[inst_1 : Std.TransCmp cmp] {k : α}, k ∈ t₂ → (t₁ ∩ t₂).getKey! k = t₁.getKey! k | null | true |
closure_subset_mul_right_of_mem_nhds_one_of_inv | Mathlib.Topology.Algebra.Group.Pointwise | ∀ {G : Type w} [inst : TopologicalSpace G] [inst_1 : Group G] [SeparatelyContinuousMul G] (s : Set G) {s' : Set G},
s' ∈ nhds 1 → (∀ x ∈ s', x⁻¹ ∈ s') → closure s ⊆ s * s' | null | true |
LinearMap.piApply._proof_5 | Mathlib.Algebra.Module.Equiv.Basic | ∀ {R : Type u_1} {M : Type u_3} {V : M → Type u_2} [inst : CommSemiring R] [inst_1 : (x : M) → AddCommMonoid (V x)]
[inst_2 : (x : M) → Module R (V x)] (x y : (x : M) → V x →ₗ[R] R),
{ toFun := fun s x_1 => ((x + y) x_1) (s x_1), map_add' := ⋯, map_smul' := ⋯ } =
{ toFun := fun s x_1 => (x x_1) (s x_1), map_add... | null | false |
MulHomClass.mk._flat_ctor | Mathlib.Algebra.Group.Hom.Defs | ∀ {F : Type u_10} {M : outParam (Type u_11)} {N : outParam (Type u_12)} [inst : Mul M] [inst_1 : Mul N]
[inst_2 : FunLike F M N], (∀ (f : F) (x y : M), f (x * y) = f x * f y) → MulHomClass F M N | null | false |
Mathlib.Tactic.Ring.ExBase.cast._sunfold | Mathlib.Tactic.Ring.Basic | {u : Lean.Level} →
{α : Q(Type u)} →
(sα : Q(CommSemiring «$α»)) →
{v : Lean.Level} →
{β : Q(Type v)} →
{sβ : Q(CommSemiring «$β»)} →
{a : Q(«$α»)} → Mathlib.Tactic.Ring.ExBase sα a → (a : Q(«$β»)) × Mathlib.Tactic.Ring.ExBase sβ a | null | false |
RingCon.instCommRingQuotient | Mathlib.RingTheory.Congruence.Defs | {R : Type u_1} → [inst : CommRing R] → (c : RingCon R) → CommRing c.Quotient | null | true |
SheafOfModules.QuasicoherentData.localGeneratorsData_I | Mathlib.Algebra.Category.ModuleCat.Sheaf.Quasicoherent | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {J : CategoryTheory.GrothendieckTopology C}
{R : CategoryTheory.Sheaf J RingCat} [inst_1 : ∀ (X : C), CategoryTheory.HasWeakSheafify (J.over X) AddCommGrpCat]
[inst_2 : ∀ (X : C), (J.over X).WEqualsLocallyBijective AddCommGrpCat] {M : SheafOfModules R}
(... | null | true |
_private.Mathlib.Combinatorics.SimpleGraph.Paths.0.SimpleGraph.Walk.support_cycleBypass_sublist_support.match_1_1 | Mathlib.Combinatorics.SimpleGraph.Paths | ∀ {V : Type u_1} {G : SimpleGraph V} {v : V} (motive : G.Walk v v → Prop) (x : G.Walk v v),
(∀ (_ : Unit), motive SimpleGraph.Walk.nil) →
(∀ (v_1 : V) (h : G.Adj v v_1) (w : G.Walk v_1 v), motive (SimpleGraph.Walk.cons h w)) → motive x | null | false |
_private.Mathlib.AlgebraicGeometry.EllipticCurve.Projective.Basic.0.WeierstrassCurve.Projective.equation_smul._simp_1_3 | Mathlib.AlgebraicGeometry.EllipticCurve.Projective.Basic | ∀ {R : Type r} [inst : CommRing R] (P : Fin 3 → R) (u : R), (u • P) 2 = u * P 2 | null | false |
le_mabs' | Mathlib.Algebra.Order.Group.Abs | ∀ {G : Type u_1} [inst : CommGroup G] [inst_1 : LinearOrder G] [IsOrderedMonoid G] {a b : G}, a ≤ |b|ₘ ↔ b ≤ a⁻¹ ∨ a ≤ b | null | true |
NumberField.mixedEmbedding.integerLattice._proof_1 | Mathlib.NumberTheory.NumberField.CanonicalEmbedding.Basic | RingHomSurjective (RingHom.id ℤ) | null | false |
UpperHalfPlane.toSL2R_smul_I | Mathlib.Analysis.Complex.UpperHalfPlane.MoebiusAction | ∀ (z : UpperHalfPlane), z.toSL2R • UpperHalfPlane.I = z | null | true |
AffineSubspace.finDim_map_le_finDim | Mathlib.LinearAlgebra.AffineSpace.Dimension | ∀ {R : Type u} {V : Type v} {V' : Type v'} {A : Type a} {A' : Type a'} [inst : AddCommGroup V] [inst_1 : AddTorsor V A]
[inst_2 : AddCommGroup V'] [inst_3 : AddTorsor V' A'] [inst_4 : Ring R] [inst_5 : Module R V] [inst_6 : Module R V']
[StrongRankCondition R] (f : A →ᵃ[R] A') (s : AffineSubspace R A) [Module.Finit... | null | true |
InfTopHom.copy | Mathlib.Order.Hom.BoundedLattice | {α : Type u_2} →
{β : Type u_3} →
[inst : Min α] →
[inst_1 : Top α] →
[inst_2 : Min β] → [inst_3 : Top β] → (f : InfTopHom α β) → (f' : α → β) → f' = ⇑f → InfTopHom α β | Copy of an `InfTopHom` with a new `toFun` equal to the old one. Useful to fix definitional
equalities. | true |
CategoryTheory.Localization.StrictUniversalPropertyFixedTarget.comp._proof_3 | Mathlib.CategoryTheory.Localization.Composition | ∀ {C₁ : Type u_1} {C₂ : Type u_8} {C₃ : Type u_6} {E : Type u_2} [inst : CategoryTheory.Category.{u_3, u_1} C₁]
[inst_1 : CategoryTheory.Category.{u_7, u_8} C₂] [inst_2 : CategoryTheory.Category.{u_5, u_6} C₃]
[inst_3 : CategoryTheory.Category.{u_4, u_2} E] {L₁ : CategoryTheory.Functor C₁ C₂}
{L₂ : CategoryTheory... | null | false |
_private.Mathlib.Algebra.Homology.HomotopyCategory.KInjective.0.CochainComplex.isKInjective_of_injective_aux._proof_1_12 | Mathlib.Algebra.Homology.HomotopyCategory.KInjective | ∀ (n : ℤ), n + 1 + 0 = n + 1 | null | false |
_private.Mathlib.NumberTheory.Cyclotomic.Gal.0.IsCyclotomicExtension.autEquivPow._simp_7 | Mathlib.NumberTheory.Cyclotomic.Gal | ∀ {R : Type u_4} {k : ℕ} [inst : CommMonoid R] (ζ : ↥(rootsOfUnity k R)) (m : ℕ), ↑↑ζ ^ m = ↑↑(ζ ^ m) | null | false |
AlgebraicGeometry.germ_stalkClosedPointIso_hom_assoc | Mathlib.AlgebraicGeometry.Stalk | ∀ (R : CommRingCat) [inst : IsLocalRing ↑R] {Z : CommRingCat} (h : R ⟶ Z),
CategoryTheory.CategoryStruct.comp ((AlgebraicGeometry.Spec R).presheaf.germ ⊤ (IsLocalRing.closedPoint ↑R) trivial)
(CategoryTheory.CategoryStruct.comp (AlgebraicGeometry.stalkClosedPointIso R).hom h) =
CategoryTheory.CategoryStruct... | null | true |
MeasureTheory.SignedMeasure.eq_singularPart | Mathlib.MeasureTheory.VectorMeasure.Decomposition.Lebesgue | ∀ {α : Type u_1} {m : MeasurableSpace α} {μ : MeasureTheory.Measure α} {s : MeasureTheory.SignedMeasure α}
(t : MeasureTheory.SignedMeasure α) (f : α → ℝ),
MeasureTheory.VectorMeasure.MutuallySingular t μ.toENNRealVectorMeasure →
s = t + μ.withDensityᵥ f → t = s.singularPart μ | Given a measure `μ`, signed measures `s` and `t`, and a function `f` such that `t` is
mutually singular with respect to `μ` and `s = t + μ.withDensityᵥ f`, we have
`t = singularPart s μ`, i.e. `t` is the singular part of the Lebesgue decomposition between
`s` and `μ`. | true |
Lean.Syntax.antiquotKind? | Lean.Syntax | Lean.Syntax → Option (Lean.SyntaxNodeKind × Bool) | Return kind of parser expected at this antiquotation, and whether it is a "pseudo" kind (see `mkAntiquot`). | true |
ProbabilityTheory.Kernel.lintegral_map | Mathlib.Probability.Kernel.Composition.MapComap | ∀ {α : Type u_1} {β : Type u_2} {mα : MeasurableSpace α} {mβ : MeasurableSpace β} {γ : Type u_4}
{mγ : MeasurableSpace γ} {f : β → γ} (κ : ProbabilityTheory.Kernel α β),
Measurable f → ∀ (a : α) {g' : γ → ENNReal}, Measurable g' → ∫⁻ (b : γ), g' b ∂(κ.map f) a = ∫⁻ (a : β), g' (f a) ∂κ a | null | true |
PredOrder.nhdsLE | Mathlib.Topology.Order.OrderClosed | ∀ {α : Type u} [inst : TopologicalSpace α] [inst_1 : LinearOrder α] [ClosedIicTopology α] {b : α} [PredOrder α],
nhdsWithin b (Set.Iic b) = pure b | null | true |
_private.Lean.Meta.ArgsPacker.0.Lean.Meta.ArgsPacker.Unary.curryType.go._f | Lean.Meta.ArgsPacker | Lean.Expr →
Lean.Expr →
(a : List Lean.Name) →
List.below (motive := fun a => Lean.Expr → Array Lean.Expr → Lean.MetaM Lean.Expr) a →
Lean.Expr → Array Lean.Expr → Lean.MetaM Lean.Expr | null | false |
MaxTropical.trop_coe_ne_zero | Mathlib.Algebra.Tropical.Basic | ∀ {R : Type u} (x : R), MaxTropical.trop ↑x ≠ 0 | null | true |
AdicCompletion.instModuleQuotientIdealHSMulTopSubmodule | Mathlib.RingTheory.AdicCompletion.Algebra | {R : Type u_1} →
[inst : CommRing R] →
(I : Ideal R) → {M : Type u_3} → [inst_1 : AddCommGroup M] → [inst_2 : Module R M] → Module (R ⧸ I • ⊤) (M ⧸ I • ⊤) | null | true |
Std.PRange.UpwardEnumerable.Map.PreservesRxiSize.rec | Init.Data.Range.Polymorphic.Map | {α : Type u_1} →
{β : Type u_2} →
[inst : Std.PRange.UpwardEnumerable α] →
[inst_1 : Std.PRange.UpwardEnumerable β] →
[inst_2 : Std.Rxi.HasSize α] →
[inst_3 : Std.Rxi.HasSize β] →
{f : Std.PRange.UpwardEnumerable.Map α β} →
{motive : f.PreservesRxiSize → Sort u} →... | null | false |
IsStarProjection.le_one | Mathlib.Algebra.Order.Star.Basic | ∀ {R : Type u_1} [inst : Ring R] [inst_1 : PartialOrder R] [inst_2 : StarRing R] [StarOrderedRing R] {p : R},
IsStarProjection p → p ≤ 1 | null | true |
_private.Mathlib.Algebra.Lie.Weights.RootSystem.0.LieAlgebra.IsKilling.eq_neg_one_or_eq_zero_or_eq_one_of_eq_smul._simp_1_6 | Mathlib.Algebra.Lie.Weights.RootSystem | ∀ {α : Type u_1} {a b : α}, (b ∈ {a}) = (b = a) | null | false |
String.Slice.pos!.eq_1 | Init.Data.String.Lemmas.Basic | ∀ (s : String.Slice) (off : String.Pos.Raw),
s.pos! off =
if h : String.Pos.Raw.isValidForSlice s off = true then s.pos off ⋯
else
panicWithPosWithDecl "Init.Data.String.Basic" "String.Slice.pos!" 1661 4
"Offset is not at a valid UTF-8 character boundary" | null | true |
FirstOrder.Language.Embedding.age_subset_age | Mathlib.ModelTheory.Fraisse | ∀ {L : FirstOrder.Language} {M : Type w} [inst : L.Structure M] {N : Type w} [inst_1 : L.Structure N]
(MN : L.Embedding M N), L.age M ⊆ L.age N | null | true |
MonoidWithZeroHom.valueMonoid.eq_1 | Mathlib.Algebra.GroupWithZero.Range | ∀ {A : Type u_1} {B : Type u_2} [inst : MonoidWithZero A] [inst_1 : MonoidWithZero B] (f : A →*₀ B),
f.valueMonoid = { carrier := Units.val ⁻¹' Set.range ⇑f, mul_mem' := ⋯, one_mem' := ⋯ } | null | true |
Std.Http.URI.Builder.scheme._default | Std.Http.Data.URI.Basic | Option Std.Http.URI.Scheme | null | false |
Set.compl_iUnion | Mathlib.Data.Set.Lattice.Indexed | ∀ {β : Type u_2} {ι : Sort u_4} (s : ι → Set β), (⋃ i, s i)ᶜ = ⋂ i, (s i)ᶜ | null | true |
_private.Lean.Parser.Command.0.Lean.Parser.Command.check_failure._regBuiltin.Lean.Parser.Command.check_failure.parenthesizer_11 | Lean.Parser.Command | IO Unit | null | false |
IsGreatest.norm_cfcₙ | Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.Isometric | ∀ {𝕜 : Type u_1} {A : Type u_2} {p : outParam (A → Prop)} [inst : RCLike 𝕜] [inst_1 : NonUnitalNormedRing A]
[inst_2 : StarRing A] [inst_3 : NormedSpace 𝕜 A] [inst_4 : IsScalarTower 𝕜 A A] [inst_5 : SMulCommClass 𝕜 A A]
[inst_6 : NonUnitalIsometricContinuousFunctionalCalculus 𝕜 A p] (f : 𝕜 → 𝕜) (a : A),
a... | null | true |
Subgroup.unop_toSubmonoid | Mathlib.Algebra.Group.Subgroup.MulOpposite | ∀ {G : Type u_1} [inst : Group G] (H : Subgroup Gᵐᵒᵖ), H.unop.toSubmonoid = H.unop | null | true |
BddLat.instLargeCategory._proof_2 | Mathlib.Order.Category.BddLat | ∀ {X Y : BddLat} (f : X.Hom Y), { hom' := { hom' := BoundedLatticeHom.id ↑Y.toLat }.hom'.comp f.hom' } = f | null | false |
Max.max | Init.Prelude | {α : Type u} → [self : Max α] → α → α → α | Returns the greater of its two arguments.
Conventions for notations in identifiers:
* The recommended spelling of `max` in identifiers is `max`.
* The recommended spelling of `⊔` in identifiers is `sup` (`⊔` is the preferred notation for `max` when the type is not linearly ordered.). | true |
CategoryTheory.Mod.instCategory._proof_6 | Mathlib.CategoryTheory.Monoidal.Mod | ∀ {C : Type u_3} [inst : CategoryTheory.Category.{u_1, u_3} C] [inst_1 : CategoryTheory.MonoidalCategory C]
{D : Type u_4} [inst_2 : CategoryTheory.Category.{u_2, u_4} D]
[inst_3 : CategoryTheory.MonoidalCategory.MonoidalLeftAction C D] {A : C} [inst_4 : CategoryTheory.MonObj A]
{W X Y Z : CategoryTheory.Mod D A}... | null | false |
Padic.complete | Mathlib.NumberTheory.Padics.PadicNumbers | ∀ {p : ℕ} [hp : Fact (Nat.Prime p)], CauSeq.IsComplete ℚ_[p] norm | null | true |
MulEquiv.ofLeftInverse._proof_2 | Mathlib.Algebra.Group.Subsemigroup.Operations | ∀ {M : Type u_2} {N : Type u_1} [inst : Mul M] [inst_1 : Mul N] (f : M →ₙ* N) (x y : M),
f.srangeRestrict.toFun (x * y) = f.srangeRestrict.toFun x * f.srangeRestrict.toFun y | null | false |
Profinite.NobelingProof.πJ.eq_1 | Mathlib.Topology.Category.Profinite.Nobeling.Span | ∀ {I : Type u} (C : Set (I → Bool)) [inst : LinearOrder I] (s : Finset I),
Profinite.NobelingProof.πJ C s =
LocallyConstant.comapₗ ℤ { toFun := Profinite.NobelingProof.ProjRestrict C fun x => x ∈ s, continuous_toFun := ⋯ } | null | true |
_private.Mathlib.Analysis.InnerProductSpace.Subspace.0.OrthogonalFamily.inner_right_dfinsupp._simp_1_1 | Mathlib.Analysis.InnerProductSpace.Subspace | ∀ {ι : Type u} {β : ι → Type v} [inst : DecidableEq ι] [inst_1 : (i : ι) → Zero (β i)]
[inst_2 : (i : ι) → (x : β i) → Decidable (x ≠ 0)] (f : Π₀ (i : ι), β i) (i : ι), (i ∈ f.support) = (f i ≠ 0) | null | false |
Group.ofLeftAxioms | Mathlib.Algebra.Group.MinimalAxioms | {G : Type u} →
[inst : Mul G] →
[inst_1 : Inv G] →
[inst_2 : One G] →
(∀ (a b c : G), a * b * c = a * (b * c)) → (∀ (a : G), 1 * a = a) → (∀ (a : G), a⁻¹ * a = 1) → Group G | Define a `Group` structure on a Type by proving `∀ a, 1 * a = a` and
`∀ a, a⁻¹ * a = 1`.
Note that this uses the default definitions for `npow`, `zpow` and `div`.
See note [reducible non-instances]. | true |
_private.Mathlib.LinearAlgebra.RootSystem.Defs.0.RootPairing.pairing_smul_coroot_eq._simp_1_2 | Mathlib.LinearAlgebra.RootSystem.Defs | ∀ {G : Type u_3} [inst : AddGroup G] {a b c : G}, (a - b = a - c) = (b = c) | null | false |
_private.Lean.Elab.BuiltinNotation.0.Lean.Elab.Term.initFn._@.Lean.Elab.BuiltinNotation.3712712094._hygCtx._hyg.4 | Lean.Elab.BuiltinNotation | IO (Lean.Option Bool) | null | false |
QuotientGroup.leftRel_eq | Mathlib.GroupTheory.Coset.Defs | ∀ {α : Type u_1} [inst : Group α] (s : Subgroup α), ⇑(QuotientGroup.leftRel s) = fun x y => x⁻¹ * y ∈ s | null | true |
Int64.toUInt64_ofBitVec | Init.Data.SInt.Lemmas | ∀ (b : BitVec 64), (Int64.ofBitVec b).toUInt64 = { toBitVec := b } | null | true |
Filter.tendsto_atTop_mul_const_right | Mathlib.Order.Filter.AtTopBot.Group | ∀ {α : Type u_1} {G : Type u_2} [inst : CommGroup G] [inst_1 : PartialOrder G] [IsOrderedMonoid G] (l : Filter α)
{f : α → G} (C : G), Filter.Tendsto f l Filter.atTop → Filter.Tendsto (fun x => f x * C) l Filter.atTop | null | true |
CategoryTheory.Functor.OplaxLeftLinear.δₗ_associativity._autoParam | Mathlib.CategoryTheory.Monoidal.Action.LinearFunctor | Lean.Syntax | null | false |
_private.Mathlib.LinearAlgebra.Matrix.Determinant.Basic.0.Matrix.det_fromBlocks_zero₂₁._simp_1_6 | Mathlib.LinearAlgebra.Matrix.Determinant.Basic | ∀ {α : Type u_1} [inst : Fintype α] (x : α), (x ∈ Finset.univ) = True | null | false |
Lean.Lsp.LeanILeanHeaderSetupInfoParams.mk.injEq | Lean.Data.Lsp.Internal | ∀ (version : ℕ) (isSetupFailure : Bool) (directImports : Array Lean.Lsp.ImportInfo) (version_1 : ℕ)
(isSetupFailure_1 : Bool) (directImports_1 : Array Lean.Lsp.ImportInfo),
({ version := version, isSetupFailure := isSetupFailure, directImports := directImports } =
{ version := version_1, isSetupFailure := isS... | null | true |
CategoryTheory.Limits.BinaryBicone.isLimitSndKernelFork | Mathlib.CategoryTheory.Limits.Shapes.BinaryBiproducts | {C : Type uC} →
[inst : CategoryTheory.Category.{uC', uC} C] →
[inst_1 : CategoryTheory.Limits.HasZeroMorphisms C] →
{X Y : C} →
{c : CategoryTheory.Limits.BinaryBicone X Y} →
CategoryTheory.Limits.IsLimit c.toCone → CategoryTheory.Limits.IsLimit c.sndKernelFork | The fork defined in `BinaryBicone.sndKernelFork` is indeed a kernel. | true |
Lattice.mk'._proof_8 | Mathlib.Order.Lattice | ∀ {α : Type u_1} [inst : Max α] [inst_1 : Min α],
(∀ (a b : α), a ⊔ a ⊓ b = a) → (∀ (a b : α), a ⊓ (a ⊔ b) = a) → ∀ (b : α), b ⊔ b = b | null | false |
ContinuousMap.tendsto_concat | Mathlib.Topology.ContinuousMap.Interval | ∀ {α : Type u_1} [inst : LinearOrder α] [inst_1 : TopologicalSpace α] [inst_2 : OrderTopology α] {a b c : α}
[inst_3 : Fact (a ≤ b)] [inst_4 : Fact (b ≤ c)] {E : Type u_2} [inst_5 : TopologicalSpace E]
{f : C(↑(Set.Icc a b), E)} {g : C(↑(Set.Icc b c), E)} {ι : Type u_3} {p : Filter ι} {F : ι → C(↑(Set.Icc a b), E)}... | null | true |
Batteries.Tactic.GeneralizeProofs.AContext.fvars | Batteries.Tactic.GeneralizeProofs | Batteries.Tactic.GeneralizeProofs.AContext → Array Lean.Expr | The local fvars corresponding to bound variables.
Abstraction needs to be sure that these variables do not appear in abstracted terms. | true |
_private.Init.Data.Fin.Lemmas.0.Fin.coe_sub_iff_lt._proof_1_1 | Init.Data.Fin.Lemmas | ∀ {n : ℕ} {a b : Fin n}, n ≤ n - ↑b + ↑a → ¬(n - ↑b + ↑a - n = n + ↑a - ↑b ↔ ↑a < ↑b) → False | null | false |
hyperoperation_ge_three_one | Mathlib.Data.Nat.Hyperoperation | ∀ (n k : ℕ), hyperoperation (n + 3) 1 k = 1 | null | true |
NumberField.FiniteAdeleRing.unitEmbedding_norm_apply | Mathlib.NumberTheory.NumberField.FiniteAdeleRing | ∀ {K : Type u_2} [inst : Field K] [inst_1 : NumberField K] (x : Kˣ),
‖↑((IsDedekindDomain.FiniteAdeleRing.unitEmbedding (NumberField.RingOfIntegers K) K) x)‖ =
∏ᶠ (v : IsDedekindDomain.HeightOneSpectrum (NumberField.RingOfIntegers K)), (NumberField.FinitePlace.mk v) ↑x | null | true |
AddGroupNorm.ext | Mathlib.Analysis.Normed.Group.Seminorm | ∀ {E : Type u_3} [inst : AddGroup E] {p q : AddGroupNorm E}, (∀ (x : E), p x = q x) → p = q | null | true |
ProfiniteGrp.isIso_toLimit | Mathlib.Topology.Algebra.Category.ProfiniteGrp.Limits | ∀ (P : ProfiniteGrp.{u}), CategoryTheory.IsIso P.toLimit | null | true |
MonoidAlgebra.bialgEquivOfSubsingleton | Mathlib.RingTheory.Bialgebra.MonoidAlgebra | {R : Type u_1} →
(M : Type u_8) → [inst : CommSemiring R] → [inst_1 : Monoid M] → [Subsingleton M] → MonoidAlgebra R M ≃ₐc[R] R | The trivial monoid algebra is isomorphic to the base ring. | true |
GenLoop.toLoop_apply_coe | Mathlib.Topology.Homotopy.HomotopyGroup | ∀ {N : Type u_1} {X : Type u_2} [inst : TopologicalSpace X] {x : X} [inst_1 : DecidableEq N] (i : N)
(p : ↑(GenLoop N X x)) (t : ↑unitInterval), ↑((GenLoop.toLoop i p) t) = ((↑p).comp ↑(Cube.insertAt i)).curry t | null | true |
CategoryTheory.Equivalence.congrRightFunctor._proof_1 | Mathlib.CategoryTheory.Equivalence | ∀ {C : Type u_3} [inst : CategoryTheory.Category.{u_1, u_3} C] {D : Type u_4}
[inst_1 : CategoryTheory.Category.{u_2, u_4} D] (E : Type u_5) [inst_2 : CategoryTheory.Category.{u_6, u_5} E]
(X : C ≌ D),
CategoryTheory.Equivalence.mkHom
((CategoryTheory.Functor.whiskeringRight E C D).map
(CategoryTheo... | null | false |
LieAlgebra.Basis.base._proof_5 | Mathlib.Algebra.Lie.Basis.Base | ∀ {K : Type u_1} {L : Type u_2} [inst : Field K] [inst_1 : CharZero K] [inst_2 : LieRing L] [inst_3 : LieAlgebra K L]
[inst_4 : FiniteDimensional K L] {H : LieSubalgebra K L} {ι : Type u_3} [inst_5 : Fintype ι]
(b : LieAlgebra.Basis ι H) [inst_6 : LieModule.IsTriangularizable K (↥H) L] [inst_7 : LieAlgebra.IsKillin... | null | false |
Submodule.isComplEquivProj._proof_9 | Mathlib.LinearAlgebra.Projection | ∀ {R : Type u_2} [inst : Ring R] {E : Type u_1} [inst_1 : AddCommGroup E] [inst_2 : Module R E] (p : Submodule R E)
(x : { f // ∀ (x : ↥p), f ↑x = x }), ⟨p.projectionOnto ↑⟨(↑x).ker, ⋯⟩ ⋯, ⋯⟩ = x | null | false |
Lean.PrettyPrinter.Delaborator.TopDownAnalyze.State.mk.sizeOf_spec | Lean.PrettyPrinter.Delaborator.TopDownAnalyze | ∀ (annotations : Lean.PrettyPrinter.Delaborator.OptionsPerPos) (postponed : Array (Lean.Expr × Lean.Expr)),
sizeOf { annotations := annotations, postponed := postponed } = 1 + sizeOf annotations + sizeOf postponed | null | true |
AlgebraicGeometry.basicOpen_eq_bot_iff._simp_1 | Mathlib.AlgebraicGeometry.Properties | ∀ {X : AlgebraicGeometry.Scheme} [AlgebraicGeometry.IsReduced X] {U : X.Opens} (s : ↑(X.presheaf.obj (Opposite.op U))),
(X.basicOpen s = ⊥) = (s = 0) | null | false |
AlgebraicGeometry.Scheme.Modules.pseudofunctor_mapComp_hom_τr | Mathlib.AlgebraicGeometry.Modules.Sheaf | ∀ {a b c : CategoryTheory.LocallyDiscrete AlgebraicGeometry.Schemeᵒᵖ} (x : a ⟶ b) (x_1 : b ⟶ c),
(AlgebraicGeometry.Scheme.Modules.pseudofunctor.mapComp x x_1).hom.τr =
CategoryTheory.NatTrans.toCatHom₂ (AlgebraicGeometry.Scheme.Modules.pushforwardComp x_1.as.unop x.as.unop).hom | null | true |
_private.Mathlib.MeasureTheory.Integral.Regular.0.IsCompact.measure_eq_biInf_integral_hasCompactSupport._simp_1_3 | Mathlib.MeasureTheory.Integral.Regular | ∀ {b a : Prop}, (∃ (_ : a), b) = (a ∧ b) | null | false |
AddEquiv.ulift._proof_1 | Mathlib.Algebra.Group.ULift | ∀ {α : Type u_2} [inst : Add α] (x x_1 : ULift.{u_1, u_2} α), Equiv.ulift.toFun (x + x_1) = Equiv.ulift.toFun (x + x_1) | null | false |
CategoryTheory.FilteredObject.instCategory | Mathlib.CategoryTheory.Filtration.Basic | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
{I : Type u_1} →
[inst_1 : CategoryTheory.Category.{u_2, u_1} I] →
CategoryTheory.Category.{max u_1 v, max (max (max u_2 u_1) u) v} (CategoryTheory.FilteredObject C I) | The category structure on filtered objects. | true |
Std.DTreeMap.Internal.Impl.WF.filter | Std.Data.DTreeMap.Internal.WF.Defs | ∀ {α : Type u} [inst : Ord α] {x : α → Type v} {t : Std.DTreeMap.Internal.Impl α x} {h : t.Balanced}
{f : (a : α) → x a → Bool}, t.WF → (Std.DTreeMap.Internal.Impl.filter f t h).impl.WF | `filter` preserves well-formedness. Later shown to be subsumed by `.wf`. | true |
_private.Mathlib.Tactic.Explode.0.Mathlib.Explode.explodeCore.consDep | Mathlib.Tactic.Explode | Bool → Option Mathlib.Explode.Entry → List (Option ℕ) → List (Option ℕ) | Prepend the `line` of the `Entry` to `deps` if it's not `none`, but if the entry isn't marked
with `useAsDep` then it's not added to the list at all. | true |
RingTheory.Sequence.isWeaklyRegular_append_iff | Mathlib.RingTheory.Regular.RegularSequence | ∀ {R : Type u_1} (M : Type u_3) [inst : CommRing R] [inst_1 : AddCommGroup M] [inst_2 : Module R M] (rs₁ rs₂ : List R),
RingTheory.Sequence.IsWeaklyRegular M (rs₁ ++ rs₂) ↔
RingTheory.Sequence.IsWeaklyRegular M rs₁ ∧ RingTheory.Sequence.IsWeaklyRegular (M ⧸ Ideal.ofList rs₁ • ⊤) rs₂ | null | true |
_private.Mathlib.Topology.MetricSpace.Bounded.0.Metric.comap_dist_right_atTop._simp_1_2 | Mathlib.Topology.MetricSpace.Bounded | ∀ {α : Type u_1} [inst : LinearOrder α] {a b : α}, (¬a < b) = (b ≤ a) | null | false |
_private.Mathlib.Tactic.DefEqAbuse.0.Lean.MessageData.VisitStep._sizeOf_1 | Mathlib.Tactic.DefEqAbuse | {α : Type u_1} → [SizeOf α] → Lean.MessageData.VisitStep✝ α → ℕ | null | false |
List.exists_of_modifyTailIdx | Init.Data.List.Nat.Modify | ∀ {α : Type u_1} (f : List α → List α) {i : ℕ} {l : List α},
i ≤ l.length → ∃ l₁ l₂, l = l₁ ++ l₂ ∧ l₁.length = i ∧ l.modifyTailIdx i f = l₁ ++ f l₂ | null | true |
RestrictedProduct.instDFunLike | Mathlib.Topology.Algebra.RestrictedProduct.Basic | {ι : Type u_1} →
(R : ι → Type u_2) →
(A : (i : ι) → Set (R i)) → {𝓕 : Filter ι} → DFunLike (RestrictedProduct (fun i => R i) (fun i => A i) 𝓕) ι R | null | true |
AkraBazziRecurrence.eventually_one_sub_smoothingFn_nonneg | Mathlib.Computability.AkraBazzi.SumTransform | ∀ᶠ (n : ℕ) in Filter.atTop, 0 ≤ 1 - AkraBazziRecurrence.smoothingFn ↑n | null | true |
Std.ExtHashSet.getD_eq_of_contains | Std.Data.ExtHashSet.Lemmas | ∀ {α : Type u} {x : BEq α} {x_1 : Hashable α} {m : Std.ExtHashSet α} [inst : LawfulBEq α] {k fallback : α},
m.contains k = true → m.getD k fallback = k | null | true |
_private.Lean.Parser.Do.0.Lean.Parser.Term.doReassign._regBuiltin.Lean.Parser.Term.doReassign.parenthesizer_15 | Lean.Parser.Do | IO Unit | null | false |
eulerFunction | Mathlib.Combinatorics.Enumerative.Pentagonal.EulerFunction | {R : Type u_1} → [NormedCommRing R] → R → R | The Euler function $\phi(x) = \sum_{k=-\infty}^{\infty}(-1)^k x^{k (3k - 1) / 2}$, defined
as a power series with the same coefficients as `PowerSeries.pentagonalSeries`. See
`eulerFunction_eq_tsum_pentagonal` for the expression using pentagonal numbers. | true |
_private.Mathlib.RingTheory.Smooth.NoetherianDescent.0.Algebra.Smooth.DescentAux | Mathlib.RingTheory.Smooth.NoetherianDescent | (A : Type u) → (B : Type u_2) → [inst : CommRing A] → [inst_1 : CommRing B] → [Algebra A B] → Type (max (max 1 u) u_2) | (Implementation detail): If `S` is an `R`-algebra with presentation `P`
and section `σ` of the projection `R[Xᵢ] ⧸ I^2 → S`, then a
`DescentAux` structure contains the data necessary to reconstruct `σ`. | true |
_private.Lean.Compiler.LCNF.Simp.ConstantFold.0.Lean.Compiler.LCNF.Simp.ConstantFold.applyFolders.match_1 | Lean.Compiler.LCNF.Simp.ConstantFold | (motive :
Option (Lean.Compiler.LCNF.LetValue Lean.Compiler.LCNF.Purity.pure) ×
Array (Lean.Compiler.LCNF.CodeDecl Lean.Compiler.LCNF.Purity.pure) →
Sort u_1) →
(__do_lift :
Option (Lean.Compiler.LCNF.LetValue Lean.Compiler.LCNF.Purity.pure) ×
Array (Lean.Compiler.LCNF.CodeDecl Lean.Co... | null | false |
Matrix.transposeAlgEquiv_symm_apply | Mathlib.Data.Matrix.Basic | ∀ (m : Type u_2) (R : Type u_4) (α : Type u_8) [inst : CommSemiring R] [inst_1 : CommSemiring α] [inst_2 : Fintype m]
[inst_3 : DecidableEq m] [inst_4 : Algebra R α] (a : (Matrix m m α)ᵐᵒᵖ),
(Matrix.transposeAlgEquiv m R α).symm a = (MulOpposite.unop a).transpose | null | true |
Lean.Meta.Grind.Arith.Cutsat.LeCnstrProof.commRingNorm.elim | Lean.Meta.Tactic.Grind.Arith.Cutsat.Types | {motive_9 : Lean.Meta.Grind.Arith.Cutsat.LeCnstrProof → Sort u} →
(t : Lean.Meta.Grind.Arith.Cutsat.LeCnstrProof) →
t.ctorIdx = 17 →
((c : Lean.Meta.Grind.Arith.Cutsat.LeCnstr) →
(e : Lean.Meta.Grind.Arith.CommRing.RingExpr) →
(p : Lean.Grind.CommRing.Poly) → motive_9 (Lean.Meta.Grind.... | null | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.