name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
AddCommGrpCat.instCreatesColimitsOfSizeUliftFunctor | Mathlib.Algebra.Category.Grp.Ulift | CategoryTheory.CreatesColimitsOfSize.{w, u, u, max u v, u + 1, max (u + 1) (v + 1)} AddCommGrpCat.uliftFunctor | The functor `uliftFunctor : AddCommGrpCat.{u} ⥤ AddCommGrpCat.{max u v}` creates `u`-small colimits.
| true |
FloorRing.ofFloor._proof_1 | Mathlib.Algebra.Order.Floor.Defs | ∀ (α : Type u_1) [inst : Ring α] [inst_1 : LinearOrder α] [IsOrderedAddMonoid α] (floor : α → ℤ),
GaloisConnection Int.cast floor → ∀ (a : α) (z : ℤ), (fun a => -floor (-a)) a ≤ z ↔ a ≤ ↑z | null | false |
Units.coe_smul | Mathlib.Algebra.Group.Action.Units | ∀ {M : Type u_6} {N : Type u_7} [inst : Monoid M] [inst_1 : Monoid N] [inst_2 : MulDistribMulAction M N] (m : M)
(u : Nˣ), ↑(m • u) = m • ↑u | null | true |
UpperHalfPlane.measurableEmbedding_coe | Mathlib.Analysis.Complex.UpperHalfPlane.Measure | MeasurableEmbedding UpperHalfPlane.coe | null | true |
Nat.lt_sum_ge | Batteries.Data.Nat.Lemmas | (a b : ℕ) → a < b ⊕' b ≤ a | Strong case analysis on `a < b ∨ b ≤ a` | true |
CategoryTheory.ShortComplex.SnakeInput.functorL₃_obj | Mathlib.Algebra.Homology.ShortComplex.SnakeLemma | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Abelian C]
(S : CategoryTheory.ShortComplex.SnakeInput C), CategoryTheory.ShortComplex.SnakeInput.functorL₃.obj S = S.L₃ | null | true |
CircleDeg1Lift.monotone | Mathlib.Dynamics.Circle.RotationNumber.TranslationNumber | ∀ (f : CircleDeg1Lift), Monotone ⇑f | null | true |
MulRightReflectLE.casesOn | Mathlib.Algebra.Order.Monoid.Unbundled.Defs | {M : Type u_1} →
[inst : Mul M] →
[inst_1 : LE M] →
{motive : MulRightReflectLE M → Sort u} →
(t : MulRightReflectLE M) →
((le_of_mul_le_mul_right' : ∀ {b a₁ a₂ : M}, a₁ * b ≤ a₂ * b → a₁ ≤ a₂) → motive ⋯) → motive t | null | false |
CategoryTheory.Pretriangulated.Triangle.functorHomMk._proof_1 | Mathlib.CategoryTheory.Triangulated.Basic | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.HasShift C ℤ] {J : Type u_4}
[inst_2 : CategoryTheory.Category.{u_3, u_4} J]
(A B : CategoryTheory.Functor J (CategoryTheory.Pretriangulated.Triangle C))
(hom₁ : A.comp CategoryTheory.Pretriangulated.Triangle.π₁ ⟶ B.comp Categ... | null | false |
Ideal.map_pi | Mathlib.RingTheory.Ideal.Quotient.Basic | ∀ {ι : Type u_1} {ι' : Type u_2} {R : Type u_3} [inst : Ring R] (I : Ideal R) [I.IsTwoSided] [Finite ι] (x : ι → R),
(∀ (i : ι), x i ∈ I) → ∀ (f : (ι → R) →ₗ[R] ι' → R) (i : ι'), f x i ∈ I | If `f : R^n → R^m` is an `R`-linear map and `I ⊆ R` is an ideal, then the image of `I^n` is
contained in `I^m`. | true |
ENat.pow_ne_top_iff | Mathlib.Data.ENat.Monoid | ∀ {a : ℕ∞} {n : ℕ}, a ^ n ≠ ⊤ ↔ a ≠ ⊤ ∨ n = 0 | null | true |
Nat.count_strict_mono | Mathlib.Data.Nat.Count | ∀ {p : ℕ → Prop} [inst : DecidablePred p] {m n : ℕ}, p m → m < n → Nat.count p m < Nat.count p n | null | true |
DirectSum.lequivCongrLeft_symm_lof | 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)] {κ : Type u_1} [inst_3 : DecidableEq ι] [inst_4 : DecidableEq κ] {h : ι ≃ κ}
{k : κ} {x : M (h.symm k)},
(DirectSum.lequivCongrLeft R h).symm ((DirectSum.lof R κ (fun k => ... | null | true |
Function.Embedding.twoEmbeddingEquiv.match_1 | Mathlib.Data.Fin.Tuple.Embedding | {α : Type u_1} → (motive : α × α → Sort u_2) → (x : α × α) → ((a b : α) → motive (a, b)) → motive x | null | false |
_private.Mathlib.NumberTheory.Padics.ProperSpace.0.PadicInt.totallyBounded_univ._simp_1_5 | Mathlib.NumberTheory.Padics.ProperSpace | ∀ {α : Type u_1} {β : Type u_2} {f : α → β} {s : Set α} {p : β → Prop}, (∃ y ∈ f '' s, p y) = ∃ x ∈ s, p (f x) | null | false |
SimpleGraph.CompleteEquipartiteSubgraph.toCopy.match_3 | Mathlib.Combinatorics.SimpleGraph.CompleteMultipartite | ∀ {r t : ℕ} (motive : Fin r × Fin t → Prop) (h : Fin r × Fin t),
(∀ (i₁ : Fin r) (j₁ : Fin t), motive (i₁, j₁)) → motive h | null | false |
_private.Mathlib.Tactic.NormNum.Eq.0.Mathlib.Meta.NormNum.evalEq.match_8 | Mathlib.Tactic.NormNum.Eq | (u : Lean.Level) →
(α :
have u := u;
Q(Type u)) →
(dsα : Q(DivisionSemiring «$α»)) →
(motive : Option Q(CharZero «$α») → Sort u_1) →
(__do_lift : Option Q(CharZero «$α»)) →
((_i : Q(CharZero «$α»)) → motive (some _i)) → ((x : Option Q(CharZero «$α»)) → motive x) → motive __do_l... | null | false |
CochainComplex.Lifting.coe_cocycle₁'_v_comp_eq_zero | Mathlib.Algebra.Homology.ModelCategory.Lifting | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Abelian C]
{A B X Y : CochainComplex C ℤ} {t : A ⟶ X} {i : A ⟶ B} {p : X ⟶ Y} {b : B ⟶ Y} (sq : CategoryTheory.CommSq t i p b)
(hsq : (n : ℤ) → ⋯.LiftStruct) (n m : ℤ)
(hnm : autoParam (n + 1 = m) CochainComplex.Lifting.coe_co... | null | true |
Vector.findSomeRev? | Init.Data.Vector.Basic | {α : Type u_1} → {β : Type u_2} → {n : ℕ} → (α → Option β) → Vector α n → Option β | null | true |
_private.Mathlib.Order.Interval.Finset.Nat.0.Nat.Ico_succ_left_eq_erase_Ico._simp_1_2 | Mathlib.Order.Interval.Finset.Nat | ∀ {α : Type u_1} [inst : Preorder α] [inst_1 : LocallyFiniteOrder α] {a b x : α}, (x ∈ Finset.Ico a b) = (a ≤ x ∧ x < b) | null | false |
ProofWidgets.RpcEncodablePacket.mk.injEq._@.ProofWidgets.Presentation.Expr.3227936355._hygCtx._hyg.1 | ProofWidgets.Presentation.Expr | ∀ (expr expr_1 : Lean.Json), ({ expr := expr } = { expr := expr_1 }) = (expr = expr_1) | null | false |
HasSum.smul_eq | Mathlib.Topology.Algebra.InfiniteSum.Module | ∀ {ι : Type u_4} {κ : Type u_5} {R : Type u_6} {M : Type u_8} [inst : Semiring R] [inst_1 : AddCommMonoid M]
[inst_2 : Module R M] [inst_3 : TopologicalSpace R] [inst_4 : TopologicalSpace M] [T3Space M] [ContinuousAdd M]
[ContinuousSMul R M] {f : ι → R} {g : κ → M} {s : R} {t u : M},
HasSum f s → HasSum g t → Has... | null | true |
NormedStarGroup.rec | Mathlib.Analysis.CStarAlgebra.Basic | {E : Type u_1} →
[inst : SeminormedAddCommGroup E] →
[inst_1 : StarAddMonoid E] →
{motive : NormedStarGroup E → Sort u} →
((norm_star_le : ∀ (x : E), ‖star x‖ ≤ ‖x‖) → motive ⋯) → (t : NormedStarGroup E) → motive t | null | false |
_private.Mathlib.Condensed.Light.Sequence.0.InternalProjectivityProof.cover._proof_2 | Mathlib.Condensed.Light.Sequence | ∀ {S T : LightProfinite} (π : T ⟶ CategoryTheory.MonoidalCategoryStruct.tensorObj S LightProfinite.NatUnionInfty),
CompactSpace
(↑T.toTop ⊕
↑(CompHausLike.pullback
(CategoryTheory.CategoryStruct.comp
(InternalProjectivityProof.LightProfinite.fibreIncl✝ OnePoint.infty
... | null | false |
HomotopicalAlgebra.Precylinder.mk.inj | Mathlib.AlgebraicTopology.ModelCategory.Cylinder | ∀ {C : Type u} {inst : CategoryTheory.Category.{v, u} C} {A I : C} {i₀ i₁ : A ⟶ I} {π : I ⟶ A}
{i₀_π :
autoParam (CategoryTheory.CategoryStruct.comp i₀ π = CategoryTheory.CategoryStruct.id A)
HomotopicalAlgebra.Precylinder.i₀_π._autoParam}
{i₁_π :
autoParam (CategoryTheory.CategoryStruct.comp i₁ π = C... | null | true |
HasCardinalLT.Set.cocone_ι_app | Mathlib.CategoryTheory.Presentable.Type | ∀ (X : Type u) (κ : Cardinal.{u}) (x : HasCardinalLT.Set X κ),
(HasCardinalLT.Set.cocone X κ).ι.app x = TypeCat.ofHom Subtype.val | null | true |
Equiv.prodUnique_symm_apply | Mathlib.Logic.Equiv.Prod | ∀ {α : Type u_9} {β : Type u_10} [inst : Unique β] (x : α), (Equiv.prodUnique α β).symm x = (x, default) | null | true |
MeasureTheory.Measure.sum_eq_zero | Mathlib.MeasureTheory.Measure.Sum | ∀ {α : Type u_1} {ι : Type u_2} {mα : MeasurableSpace α} {μ : ι → MeasureTheory.Measure α},
MeasureTheory.Measure.sum μ = 0 ↔ ∀ (i : ι), μ i = 0 | null | true |
Std.Async.System.SystemUser.mk.injEq | Std.Async.System | ∀ (username : String) (userId : Option Std.Async.System.UserId) (groupId : Option Std.Async.System.GroupId)
(shell : Option String) (homeDir : Option System.FilePath) (username_1 : String)
(userId_1 : Option Std.Async.System.UserId) (groupId_1 : Option Std.Async.System.GroupId) (shell_1 : Option String)
(homeDir_... | null | true |
Turing.PartrecToTM2.natEnd | Mathlib.Computability.TuringMachine.ToPartrec | Turing.PartrecToTM2.Γ' → Bool | A predicate that detects the end of a natural number, either `Γ'.cons` or `Γ'.consₗ` (or
implicitly the end of the list), for use in predicate-taking functions like `move` and `clear`. | true |
Lean.addTraceAsMessages | Lean.Util.Trace | {m : Type → Type} →
[Lean.MonadOptions m] → [Monad m] → [Lean.MonadRef m] → [Lean.MonadLog m] → [Lean.MonadTrace m] → m Unit | null | true |
Real.exp_one_rpow | Mathlib.Analysis.SpecialFunctions.Pow.Real | ∀ (x : ℝ), Real.exp 1 ^ x = Real.exp x | null | true |
CategoryTheory.Presheaf.restrictedULiftYonedaHomEquiv' | Mathlib.CategoryTheory.Limits.Presheaf | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
{ℰ : Type u₂} →
[inst_1 : CategoryTheory.Category.{v₂, u₂} ℰ] →
(A : CategoryTheory.Functor C ℰ) →
(P : CategoryTheory.Functor Cᵒᵖ (Type (max w v₁ v₂))) →
(E : ℰ) →
((CategoryTheory.CostructuredArrow.pr... | Auxiliary definition for `restrictedULiftYonedaHomEquiv`. | true |
AddCon.pi.eq_1 | Mathlib.GroupTheory.Congruence.Basic | ∀ {ι : Type u_4} {f : ι → Type u_5} [inst : (i : ι) → Add (f i)] (C : (i : ι) → AddCon (f i)),
AddCon.pi C = { toSetoid := piSetoid, add' := ⋯ } | null | true |
CategoryTheory.ShortComplex.Homotopy.rec | Mathlib.Algebra.Homology.ShortComplex.Preadditive | {C : Type u_1} →
[inst : CategoryTheory.Category.{v_1, u_1} C] →
[inst_1 : CategoryTheory.Preadditive C] →
{S₁ S₂ : CategoryTheory.ShortComplex C} →
{φ₁ φ₂ : S₁ ⟶ S₂} →
{motive : CategoryTheory.ShortComplex.Homotopy φ₁ φ₂ → Sort u} →
((h₀ : S₁.X₁ ⟶ S₂.X₁) →
(h₀_... | null | false |
PEquiv.injective_of_forall_isSome | Mathlib.Basic.PEquiv | ∀ {α : Type u} {β : Type v} {f : α ≃. β}, (∀ (a : α), (f a).isSome = true) → Function.Injective ⇑f | If the domain of a `PEquiv` is all of `α`, its forward direction is injective. | true |
CategoryTheory.CommMon.EquivLaxBraidedFunctorPUnit.commMonToLaxBraidedObj_ε | Mathlib.CategoryTheory.Monoidal.CommMon_ | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] [inst_1 : CategoryTheory.MonoidalCategory C]
[inst_2 : CategoryTheory.BraidedCategory C] (A : CategoryTheory.CommMon C),
CategoryTheory.Functor.LaxMonoidal.ε (CategoryTheory.CommMon.EquivLaxBraidedFunctorPUnit.commMonToLaxBraidedObj A) =
CategoryTheory... | null | true |
List.sum | Init.Data.List.Basic | {α : Type u_1} → [Add α] → [Zero α] → List α → α | Computes the sum of the elements of a list.
Examples:
* `[a, b, c].sum = a + (b + (c + 0))`
* `[1, 2, 5].sum = 8`
| true |
HomotopyGroup.commGroup._proof_2 | Mathlib.Topology.Homotopy.HomotopyGroup | ∀ {N : Type u_1} {X : Type u_2} [inst : TopologicalSpace X] {x : X} [inst_1 : DecidableEq N] [inst_2 : Nontrivial N]
(a b : HomotopyGroup N X x), a * b = b * a | null | false |
Set.Finite.induction_on_subset | Mathlib.Data.Set.Finite.Basic | ∀ {α : Type u} {motive : (s : Set α) → s.Finite → Prop} (s : Set α) (hs : s.Finite),
motive ∅ ⋯ →
(∀ {a : α} {t : Set α}, a ∈ s → ∀ (hts : t ⊆ s), a ∉ t → motive t ⋯ → motive (insert a t) ⋯) → motive s hs | Induction principle for finite sets: To prove a property `C` of a finite set `s`, it's enough
to prove for the empty set and to prove that `C t → C ({a} ∪ t)` for all `t ⊆ s`.
This is analogous to `Finset.induction_on'`. See also `Set.Finite.induction_on` for the version
requiring `motive t → motive ({a} ∪ t)` for all... | true |
Lean.Meta.Simp.Result.mk.noConfusion | Lean.Meta.Tactic.Simp.Types | {P : Sort u} →
{expr : Lean.Expr} →
{proof? : Option Lean.Expr} →
{cache : Bool} →
{expr' : Lean.Expr} →
{proof?' : Option Lean.Expr} →
{cache' : Bool} →
{ expr := expr, proof? := proof?, cache := cache } =
{ expr := expr', proof? := proof?', cac... | null | false |
_private.Init.Data.String.Lemmas.Iterate.0.String.Model.revPositionsFrom._proof_1 | Init.Data.String.Lemmas.Iterate | ∀ {s : String}, WellFounded (invImage (fun x => x.down) String.Pos.instWellFoundedRelationDown).1 | null | false |
_private.Lean.ImportingFlag.0.Lean.initFn._@.Lean.ImportingFlag.2251799370._hygCtx._hyg.2 | Lean.ImportingFlag | IO (IO.Ref Bool) | null | false |
CategoryTheory.MonObj.one_associator | Mathlib.CategoryTheory.Monoidal.Mon | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] [inst_1 : CategoryTheory.MonoidalCategory C] {M N P : C}
[inst_2 : CategoryTheory.MonObj M] [inst_3 : CategoryTheory.MonObj N] [inst_4 : CategoryTheory.MonObj P],
CategoryTheory.CategoryStruct.comp
(CategoryTheory.CategoryStruct.comp
(Categor... | null | true |
Array.reverse_zipWith | Init.Data.Array.Zip | ∀ {α : Type u_1} {α_1 : Type u_2} {α_2 : Type u_3} {f : α → α_1 → α_2} {as : Array α} {bs : Array α_1},
as.size = bs.size → (Array.zipWith f as bs).reverse = Array.zipWith f as.reverse bs.reverse | null | true |
LinearPMap.inverse_apply_eq | Mathlib.LinearAlgebra.LinearPMap | ∀ {R : Type u_1} [inst : Ring R] {E : Type u_4} [inst_1 : AddCommGroup E] [inst_2 : Module R E] {F : Type u_5}
[inst_3 : AddCommGroup F] [inst_4 : Module R F] {f : E →ₗ.[R] F},
f.ker = ⊥ → ∀ {y : ↥f.inverse.domain} {x : ↥f.domain}, ↑f x = ↑y → ↑f.inverse y = ↑x | null | true |
Lean.MonadCache.noConfusionType | Lean.Util.MonadCache | Sort u →
{α β : Type} →
{m : Type → Type} → Lean.MonadCache α β m → {α' β' : Type} → {m' : Type → Type} → Lean.MonadCache α' β' m' → Sort u | null | false |
Lean.Parser.Command.versoCommentBody.parenthesizer | Lean.Parser.Term | Lean.PrettyPrinter.Parenthesizer | null | true |
Polynomial.resultant_add_mul_right | Mathlib.RingTheory.Polynomial.Resultant.Basic | ∀ {R : Type u_1} [inst : CommRing R] (f g p : Polynomial R) (m n : ℕ),
p.natDegree + m ≤ n → f.natDegree ≤ m → f.resultant (g + f * p) m n = f.resultant g m n | `Res(f, g + fp) = Res(f, g)` if `deg f + deg p ≤ deg g`. | true |
CategoryTheory.Limits.pushoutCoconeEquivBinaryCofan._proof_7 | Mathlib.CategoryTheory.Limits.Constructions.Over.Products | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] {X Y Z : C} {f : X ⟶ Y} {g : X ⟶ Z}
{X_1 Y_1 Z_1 : CategoryTheory.Limits.PushoutCocone f g} (f_1 : X_1 ⟶ Y_1) (g_1 : Y_1 ⟶ Z_1),
{ hom := CategoryTheory.Under.homMk (CategoryTheory.CategoryStruct.comp f_1 g_1).hom ⋯, w := ⋯ } =
CategoryTheory.Catego... | null | false |
AbstractMeasure.instModuleContinuousMap | Mathlib.NumberTheory.Padics.Measure.Monoid | {G : Type u_1} →
{R : Type u_2} →
[inst : TopologicalSpace G] →
[inst_1 : CommRing R] →
[inst_2 : TopologicalSpace R] →
[inst_3 : IsTopologicalRing R] →
[inst_4 : Monoid G] →
[inst_5 : ContinuousMul G] → [inst_6 : LocallyCompactSpace G] → Module (AbstractMeasure G... | null | true |
_private.Init.Data.Iterators.Consumers.Access.0.Std.Iter.atIdxSlow?.match_3.eq_2 | Init.Data.Iterators.Consumers.Access | ∀ {α β : Type u_1} [inst : Std.Iterator α Id β] (it : Std.Iter β) (motive : it.Step → Sort u_2) (it' : Std.Iter β)
(property : it.IsPlausibleStep (Std.IterStep.skip it'))
(h_1 :
(it' : Std.Iter β) →
(out : β) →
(property : it.IsPlausibleStep (Std.IterStep.yield it' out)) → motive ⟨Std.IterStep.yie... | null | true |
_private.Init.Data.Order.FactoriesExtra.0.DecidableLE.ofOrd._simp_3 | Init.Data.Order.FactoriesExtra | ∀ {α : Type u} {inst : Ord α} {inst_1 : LE α} [self : Std.LawfulOrderOrd α] (a b : α),
((compare a b).isLE = true) = (a ≤ b) | null | false |
Subgroup.coe_subgroupOf | Mathlib.Algebra.Group.Subgroup.Map | ∀ {G : Type u_1} [inst : Group G] (H K : Subgroup G), ↑(H.subgroupOf K) = ⇑K.subtype ⁻¹' ↑H | null | true |
ProfiniteGrp.ProfiniteCompletion.adjunction._proof_2 | Mathlib.Topology.Algebra.Category.ProfiniteGrp.Completion | ∀ {X' X : GrpCat} {Y : ProfiniteGrp.{u_1}} (f : X' ⟶ X)
(g : X ⟶ (CategoryTheory.forget₂ ProfiniteGrp.{u_1} GrpCat).obj Y),
(ProfiniteGrp.ProfiniteCompletion.homEquiv X' Y).symm (CategoryTheory.CategoryStruct.comp f g) =
CategoryTheory.CategoryStruct.comp (ProfiniteGrp.profiniteCompletion.map f)
((Profini... | null | false |
CategoryTheory.Span.SpanBicat.compLift._proof_6 | Mathlib.CategoryTheory.Bicategory.Span.Basic | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] {Wₗ Wᵣ : CategoryTheory.MorphismProperty C}
[inst_1 : Wₗ.ContainsIdentities] [inst_2 : Wᵣ.ContainsIdentities] [inst_3 : Wₗ.HasPullbacksAgainst Wᵣ]
[inst_4 : Wₗ.IsStableUnderBaseChangeAgainst Wᵣ] [inst_5 : Wᵣ.IsStableUnderBaseChangeAgainst Wₗ]
[inst_6 ... | null | false |
NonUnitalStarSubalgebra.coe_add | Mathlib.Algebra.Star.NonUnitalSubalgebra | ∀ {R : Type u} {A : Type v} [inst : CommSemiring R] [inst_1 : NonUnitalNonAssocSemiring A] [inst_2 : Module R A]
[inst_3 : Star A] (S : NonUnitalStarSubalgebra R A) (x y : ↥S), ↑(x + y) = ↑x + ↑y | null | true |
inv_add_inv | Mathlib.Algebra.Field.Basic | ∀ {K : Type u_1} [inst : Semifield K] {a b : K}, a ≠ 0 → b ≠ 0 → a⁻¹ + b⁻¹ = (a + b) / (a * b) | null | true |
setOfPred_isOpen_sSup | Mathlib.Topology.Order | ∀ {α : Type u} {T : Set (TopologicalSpace α)}, {s | IsOpen s} = ⋂ t ∈ T, {s | IsOpen s} | null | true |
IsDedekindDomain.HeightOneSpectrum.instAlgebraSubtypeAdicCompletionMemValuationSubringAdicCompletionIntegers._proof_6 | Mathlib.RingTheory.DedekindDomain.AdicValuation | ∀ (R : Type u_2) [inst : CommRing R] [inst_1 : IsDedekindDomain R] (K : Type u_1) [inst_2 : Field K]
[inst_3 : Algebra R K] [inst_4 : IsFractionRing R K] (v : IsDedekindDomain.HeightOneSpectrum R) (r : R)
(x : ↥(IsDedekindDomain.HeightOneSpectrum.adicCompletionIntegers K v)),
{
toFun := fun r =>
... | null | false |
Matrix.IsPivotedBy.rec | Mathlib.LinearAlgebra.Matrix.Echelon.Pivot | {m : Type u_1} →
{n : Type u_2} →
{R : Type u_3} →
[inst : Zero R] →
[inst_1 : LT m] →
[inst_2 : LT n] →
{A : Matrix m n R} →
{l : m → WithTop n} →
{motive : A.IsPivotedBy l → Sort u} →
((isRowEchelon : A.IsRowEchelon) →
... | null | false |
Polynomial.shiftedLegendre | Mathlib.RingTheory.Polynomial.ShiftedLegendre | ℕ → Polynomial ℤ | `shiftedLegendre n` is an integer polynomial for each `n : ℕ`, defined by:
`Pₙ(x) = ∑ k ∈ Finset.range (n + 1), (-1)ᵏ * choose n k * choose (n + k) n * xᵏ`
These polynomials appear in combinatorics and the theory of orthogonal polynomials. | true |
ENat.top_sub_one | Mathlib.Data.ENat.Basic | ⊤ - 1 = ⊤ | null | true |
KaehlerDifferential.derivationQuotKerTotal._proof_5 | Mathlib.RingTheory.Kaehler.Basic | ∀ (R : Type u_2) (S : Type u_1) [inst : CommRing R] [inst_1 : CommRing S] [inst_2 : Algebra R S],
((KaehlerDifferential.kerTotal R S).mkQ fun₀ | 1 => 1) = 0 | null | false |
AlgebraicGeometry.IsClosedImmersion.comp_iff | Mathlib.AlgebraicGeometry.Morphisms.Separated | ∀ {X Y Z : AlgebraicGeometry.Scheme} {f : X ⟶ Y} {g : Y ⟶ Z} [AlgebraicGeometry.IsClosedImmersion g],
AlgebraicGeometry.IsClosedImmersion (CategoryTheory.CategoryStruct.comp f g) ↔ AlgebraicGeometry.IsClosedImmersion f | null | true |
AlgebraicGeometry.Scheme.IdealSheafData.vanishingIdeal._proof_1 | Mathlib.AlgebraicGeometry.IdealSheaf.Basic | ∀ {X : AlgebraicGeometry.Scheme} (U : ↑X.affineOpens), ↑U ∈ X.affineOpens | null | false |
ContDiffMapSupportedIn.coe_of_support_subset | Mathlib.Analysis.Distribution.ContDiffMapSupportedIn | ∀ {E : Type u_2} {F : Type u_3} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E] [inst_2 : NormedAddCommGroup F]
[inst_3 : NormedSpace ℝ F] {n : ℕ∞} {K : TopologicalSpace.Compacts E} {f : E → F} (hf : ContDiff ℝ (↑n) f)
(hsupp : Function.support f ⊆ ↑K) (a : E), (ContDiffMapSupportedIn.of_support_subset hf ... | null | true |
MulActionHom.instCoeTCOfMulActionSemiHomClass.eq_1 | Mathlib.GroupTheory.GroupAction.Hom | ∀ {M : Type u_2} {N : Type u_3} {φ : M → N} {X : Type u_5} [inst : SMul M X] {Y : Type u_6} [inst_1 : SMul N Y]
{F : Type u_8} [inst_2 : FunLike F X Y] [inst_3 : MulActionSemiHomClass F φ X Y],
MulActionHom.instCoeTCOfMulActionSemiHomClass = { coe := MulActionSemiHomClass.toMulActionHom } | null | true |
Bundle.Trivialization.zeroSection | Mathlib.Topology.VectorBundle.Basic | ∀ (R : Type u_1) {B : Type u_2} {F : Type u_3} {E : B → Type u_4} [inst : NontriviallyNormedField R]
[inst_1 : (x : B) → AddCommMonoid (E x)] [inst_2 : (x : B) → Module R (E x)] [inst_3 : NormedAddCommGroup F]
[inst_4 : NormedSpace R F] [inst_5 : TopologicalSpace B] [inst_6 : TopologicalSpace (Bundle.TotalSpace F E... | null | true |
AddAction.fixedPoints | Mathlib.GroupTheory.GroupAction.Defs | (M : Type u_1) → (α : Type u_3) → [inst : AddMonoid M] → [AddAction M α] → Set α | The set of elements fixed under the whole action. | true |
_private.Mathlib.Lean.Elab.InfoTree.0.Lean.Elab.InfoTree.findSomeM?.match_3 | Mathlib.Lean.Elab.InfoTree | {α : Type} →
(motive : Option α → Sort u_1) → (a : Option α) → ((a : α) → motive (some a)) → (Unit → motive none) → motive a | null | false |
Lean.Meta.Grind.Arith.Cutsat.EqCnstrProof.pow.inj | Lean.Meta.Tactic.Grind.Arith.Cutsat.Types | ∀ {ka : ℤ} {ca? : Option Lean.Meta.Grind.Arith.Cutsat.EqCnstr} {kb : ℕ}
{cb? : Option Lean.Meta.Grind.Arith.Cutsat.EqCnstr} {ka_1 : ℤ} {ca?_1 : Option Lean.Meta.Grind.Arith.Cutsat.EqCnstr}
{kb_1 : ℕ} {cb?_1 : Option Lean.Meta.Grind.Arith.Cutsat.EqCnstr},
Lean.Meta.Grind.Arith.Cutsat.EqCnstrProof.pow ka ca? kb cb?... | null | true |
Mathlib.Tactic.ModCases.IntMod.proveOnModCases | Mathlib.Tactic.ModCases | {u : Lean.Level} →
(n : Q(ℕ)) →
(a : Q(ℤ)) →
(b : Q(ℕ)) →
(p : Q(Sort u)) →
Lean.MetaM (Q(Mathlib.Tactic.ModCases.IntMod.OnModCases «$n» «$a» «$b» «$p») × List Lean.MVarId) | Proves an expression of the form `OnModCases n a b p` where `n` and `b` are raw nat literals
and `b ≤ n`. Returns the list of subgoals `?gi : a ≡ i [ZMOD n] → p`.
| true |
CategoryTheory.RingObjCat.mk.injEq | Mathlib.CategoryTheory.Monoidal.Ring | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.CartesianMonoidalCategory C]
[inst_2 : CategoryTheory.BraidedCategory C] (X : C) [ringObj : CategoryTheory.RingObj X] (X_1 : C)
(ringObj_1 : CategoryTheory.RingObj X_1),
({ X := X, ringObj := ringObj } = { X := X_1, ringObj := ringO... | null | true |
NormedAddCommGroup.toSeminormedAddCommGroup | Mathlib.Analysis.Normed.Group.Defs | {E : Type u_2} → [NormedAddCommGroup E] → SeminormedAddCommGroup E | null | true |
PadicInt.modPart | Mathlib.NumberTheory.Padics.RingHoms | ℕ → ℚ → ℤ | `modPart p r` is an integer that satisfies
`‖(r - modPart p r : ℚ_[p])‖ < 1` when `‖(r : ℚ_[p])‖ ≤ 1`,
see `PadicInt.norm_sub_modPart`.
It is the unique non-negative integer that is `< p` with this property.
(Note that this definition assumes `r : ℚ`.
See `PadicInt.zmodRepr` for a version that takes values in `ℕ`
and ... | true |
Polynomial.card_roots_le_map | Mathlib.Algebra.Polynomial.Roots | ∀ {A : Type u_1} {B : Type u_2} [inst : CommRing A] [inst_1 : CommRing B] [inst_2 : IsDomain A] [inst_3 : IsDomain B]
{p : Polynomial A} {f : A →+* B}, Polynomial.map f p ≠ 0 → p.roots.card ≤ (Polynomial.map f p).roots.card | null | true |
Lean.Compiler.LCNF.CacheAuxDeclResult.ctorElim | Lean.Compiler.LCNF.AuxDeclCache | {motive : Lean.Compiler.LCNF.CacheAuxDeclResult → Sort u} →
(ctorIdx : ℕ) →
(t : Lean.Compiler.LCNF.CacheAuxDeclResult) →
ctorIdx = t.ctorIdx → Lean.Compiler.LCNF.CacheAuxDeclResult.ctorElimType ctorIdx → motive t | null | false |
mul_invOf_cancel_right | Mathlib.Algebra.Group.Invertible.Defs | ∀ {α : Type u} [inst : Monoid α] (a b : α) [inst_1 : Invertible b], a * b * ⅟b = a | null | true |
CategoryTheory.Limits.pullbackPullbackRightIsPullback._proof_4 | Mathlib.CategoryTheory.Limits.Shapes.Pullback.Assoc | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{u_2, u_1} C] {X₁ X₂ X₃ Y₁ Y₂ : C} (f₁ : X₁ ⟶ Y₁) (f₂ : X₂ ⟶ Y₁)
(f₃ : X₂ ⟶ Y₂) (f₄ : X₃ ⟶ Y₂) [inst_1 : CategoryTheory.Limits.HasPullback f₁ f₂]
[inst_2 : CategoryTheory.Limits.HasPullback f₃ f₄]
[inst_3 :
CategoryTheory.Limits.HasPullback f₁
(CategoryTh... | null | false |
MonoidHom.coe_mrangeRestrict | Mathlib.Algebra.Group.Submonoid.Operations | ∀ {M : Type u_1} [inst : MulOneClass M] {N : Type u_5} [inst_1 : MulOneClass N] (f : M →* N) (x : M),
↑(f.mrangeRestrict x) = f x | null | true |
Std.DTreeMap.Internal.Impl.ExplorationStep.casesOn | Std.Data.DTreeMap.Internal.Model | {α : Type u} →
{β : α → Type v} →
[inst : Ord α] →
{k : α → Ordering} →
{motive : Std.DTreeMap.Internal.Impl.ExplorationStep α β k → Sort u_1} →
(t : Std.DTreeMap.Internal.Impl.ExplorationStep α β k) →
((a : α) →
(a_1 : k a = Ordering.lt) →
(a_... | null | false |
FreeAlgebra.instNoZeroDivisors | Mathlib.Algebra.FreeAlgebra | ∀ {R : Type u_1} {X : Type u_2} [inst : CommSemiring R] [NoZeroDivisors R], NoZeroDivisors (FreeAlgebra R X) | `FreeAlgebra R X` has no zero-divisors when `R` has no zero-divisors. | true |
CategoryTheory.Comma.mapLeftId | Mathlib.CategoryTheory.Comma.Basic | {A : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} A] →
{B : Type u₂} →
[inst_1 : CategoryTheory.Category.{v₂, u₂} B] →
{T : Type u₃} →
[inst_2 : CategoryTheory.Category.{v₃, u₃} T] →
(L : CategoryTheory.Functor A T) →
(R : CategoryTheory.Functor B T) →
... | The functor `Comma L R ⥤ Comma L R` induced by the identity natural transformation on `L` is
naturally isomorphic to the identity functor. | true |
Lean.Lsp.TextDocumentClientCapabilities.completion? | Lean.Data.Lsp.Capabilities | Lean.Lsp.TextDocumentClientCapabilities → Option Lean.Lsp.CompletionClientCapabilities | null | true |
List.replaceIf | Mathlib.Data.List.Defs | {α : Type u_1} → List α → List Bool → List α → List α | Given a starting list `old`, a list of Booleans and a replacement list `new`,
read the items in `old` in succession and either replace them with the next element of `new` or
not, according as to whether the corresponding Boolean is `true` or `false`. | true |
MonCat.FilteredColimits.colimitCocone._proof_2 | Mathlib.Algebra.Category.MonCat.FilteredColimits | ∀ {J : Type u_1} [inst : CategoryTheory.SmallCategory J] (F : CategoryTheory.Functor J MonCat)
[inst_1 : CategoryTheory.IsFiltered J] ⦃X Y : J⦄ (f : X ⟶ Y),
CategoryTheory.CategoryStruct.comp (F.map f) (MonCat.FilteredColimits.coconeMorphism F Y) =
CategoryTheory.CategoryStruct.comp (MonCat.FilteredColimits.coc... | null | false |
LieEquiv.left_inv | Mathlib.Algebra.Lie.Basic | ∀ {R : Type u} {L : Type v} {L' : Type w} [inst : CommRing R] [inst_1 : LieRing L] [inst_2 : LieAlgebra R L]
[inst_3 : LieRing L'] [inst_4 : LieAlgebra R L'] (self : L ≃ₗ⁅R⁆ L'),
Function.LeftInverse self.invFun (↑self.toLieHom).toFun | The inverse function of an equivalence of Lie algebras is a left inverse of the underlying
function. | true |
String.Slice.Pos.skip?_bool_eq_some_iff | Init.Data.String.Lemmas.Pattern.TakeDrop.Pred | ∀ {p : Char → Bool} {s : String.Slice} {pos res : s.Pos},
pos.skip? p = some res ↔ ∃ (h : pos ≠ s.endPos), res = pos.next h ∧ p (pos.get h) = true | null | true |
CategoryTheory.SingleFunctors.postcompIsoOfIso_hom_hom_app | Mathlib.CategoryTheory.Shift.SingleFunctors | ∀ {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] {A : Type u_5}
[inst_3 : AddMonoid A] [inst_4 : CategoryTheory.HasShift D A] [inst_5 : CategoryTheory.HasShift E A]
(F : Cate... | null | true |
_private.Mathlib.Data.List.Triplewise.0.List.triplewise_iff_getElem._proof_1_22 | Mathlib.Data.List.Triplewise | ∀ {α : Type u_1} (tail : List α) (j : ℕ), j - 1 + 1 ≤ tail.length → j - 1 < tail.length | null | false |
IsometryEquiv.subRight_apply | Mathlib.Topology.MetricSpace.IsometricSMul | ∀ {G : Type v} [inst : AddGroup G] [inst_1 : PseudoEMetricSpace G] [inst_2 : IsIsometricVAdd Gᵃᵒᵖ G] (c b : G),
(IsometryEquiv.subRight c) b = b - c | null | true |
MonoidHom.submonoidComap_surjective_of_surjective | Mathlib.Algebra.Group.Submonoid.Operations | ∀ {M : Type u_1} {N : Type u_2} [inst : MulOneClass M] [inst_1 : MulOneClass N] (f : M →* N) (N' : Submonoid N),
Function.Surjective ⇑f → Function.Surjective ⇑(f.submonoidComap N') | **Alias** of `MonoidHom.submonoidComap_surjective`. | true |
AlgebraicGeometry.AffineSpace.smoothOfRelativeDimension_of_card_eq | Mathlib.AlgebraicGeometry.AffineSpace | ∀ {n : Type u} (S : AlgebraicGeometry.Scheme) [Finite n] {m : ℕ},
Nat.card n = m → AlgebraicGeometry.SmoothOfRelativeDimension m (AlgebraicGeometry.AffineSpace n S ↘ S) | null | true |
AddSubmonoidClass.subtype | Mathlib.Algebra.Group.Submonoid.Defs | {M : Type u_1} →
{A : Type u_3} → [inst : AddZeroClass M] → [inst_1 : SetLike A M] → [hA : AddSubmonoidClass A M] → (S' : A) → ↥S' →+ M | The natural monoid hom from an `AddSubmonoid` of `AddMonoid` `M` to `M`. | true |
UInt8.add_right_neg | Init.Data.UInt.Lemmas | ∀ (a : UInt8), a + -a = 0 | null | true |
Lean.Meta.getIntrosSize._unsafe_rec | Lean.Meta.Tactic.Intro | Lean.Expr → ℕ | null | false |
CategoryTheory.Functor.instMonoidalMonMapAddMon | Mathlib.CategoryTheory.Monoidal.Mon | {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 :... | null | true |
InnerProductSpace.laplacianWithin.congr_simp | Mathlib.Analysis.InnerProductSpace.Laplacian | ∀ {E : Type u_2} [inst : NormedAddCommGroup E] [inst_1 : InnerProductSpace ℝ E] [inst_2 : FiniteDimensional ℝ E]
{F : Type u_3} [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace ℝ F] (f f_1 : E → F),
f = f_1 →
∀ (s s_1 : Set E),
s = s_1 →
∀ (a a_1 : E), a = a_1 → InnerProductSpace.laplacianWit... | null | true |
Finsupp.lsingle_apply | Mathlib.LinearAlgebra.Finsupp.Defs | ∀ {α : Type u_1} {M : Type u_2} {R : Type u_5} [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M]
(a : α) (b : M), (Finsupp.lsingle a) b = fun₀ | a => b | null | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.