name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M |
|---|---|---|
_private.Lean.Compiler.IR.LLVMBindings.0.LLVM.LLVMType.mk.sizeOf_spec | Lean.Compiler.IR.LLVMBindings | ∀ {ctx : LLVM.Context} (ptr : USize), sizeOf { ptr := ptr } = 1 + sizeOf ptr |
MeasureTheory.Adapted.measurable_le | Mathlib.Probability.Process.Adapted | ∀ {Ω : Type u_1} {ι : Type u_2} {m : MeasurableSpace Ω} [inst : Preorder ι] {f : MeasureTheory.Filtration ι m}
{β : ι → Type u_3} [inst_1 : (i : ι) → MeasurableSpace (β i)] {u : (i : ι) → Ω → β i} {i j : ι},
MeasureTheory.Adapted f u → i ≤ j → Measurable (u i) |
TopCat.instCreatesLimitsSheafPresheafForgetOfHasLimits | Mathlib.Topology.Sheaves.Limits | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
[CategoryTheory.Limits.HasLimits C] → (X : TopCat) → CategoryTheory.CreatesLimits (TopCat.Sheaf.forget C X) |
Lean.Meta.SizeOfSpecNested.Context.ctorIdx | Lean.Meta.SizeOf | Lean.Meta.SizeOfSpecNested.Context → ℕ |
IsOpen.trivializationDiscrete_baseSet | Mathlib.Topology.Covering.Basic | ∀ {E : Type u_1} {X : Type u_2} [inst : TopologicalSpace E] [inst_1 : TopologicalSpace X] {f : E → X}
[inst_2 : Nonempty (X → E)] {ι : Type u_3} [inst_3 : Nonempty ι] [inst_4 : TopologicalSpace ι]
[inst_5 : DiscreteTopology ι] (U : ι → Set E) (V : Set X) (open_V : IsOpen V)
(open_iff : ∀ (i : ι) {W : Set X}, W ⊆ V → (IsOpen W ↔ IsOpen (f ⁻¹' W ∩ U i))) (inj : ∀ (i : ι), Set.InjOn f (U i))
(surj : ∀ (i : ι), Set.SurjOn f (U i) V) (disjoint : Pairwise (Function.onFun Disjoint U))
(exhaustive : f ⁻¹' V ⊆ ⋃ i, U i),
(IsOpen.trivializationDiscrete U V open_V open_iff inj surj disjoint exhaustive).baseSet = V |
FirstOrder.Field.instModelACFOfCharPOfIsAlgClosed | Mathlib.ModelTheory.Algebra.Field.IsAlgClosed | ∀ {K : Type u_1} [inst : Field K] [inst_1 : FirstOrder.Ring.CompatibleRing K] {p : ℕ} [CharP K p] [IsAlgClosed K],
K ⊨ FirstOrder.Language.Theory.ACF p |
Ordinal.veblen_le_veblen_iff_right | Mathlib.SetTheory.Ordinal.Veblen | ∀ {o a b : Ordinal.{u}}, Ordinal.veblen o a ≤ Ordinal.veblen o b ↔ a ≤ b |
Lean.Elab.Tactic.BVDecide.Frontend.Normalize.SharedCoefficients.mk.noConfusion | Lean.Elab.Tactic.BVDecide.Frontend.Normalize.AC | {P : Sort u} →
{common x y common' x' y' : Lean.Elab.Tactic.BVDecide.Frontend.Normalize.CoefficientsMap} →
{ common := common, x := x, y := y } = { common := common', x := x', y := y' } →
(common = common' → x = x' → y = y' → P) → P |
Std.Broadcast.close | Std.Sync.Broadcast | {α : Type} → Std.Broadcast α → IO Unit |
Nat.Primrec'.below | Mathlib.Computability.Primrec.List | {motive : {n : ℕ} → (a : List.Vector ℕ n → ℕ) → Nat.Primrec' a → Prop} →
{n : ℕ} → {a : List.Vector ℕ n → ℕ} → Nat.Primrec' a → Prop |
MeasureTheory.Measure.compProd_apply_prod | Mathlib.Probability.Kernel.Composition.MeasureCompProd | ∀ {α : Type u_1} {β : Type u_2} {mα : MeasurableSpace α} {mβ : MeasurableSpace β} {μ : MeasureTheory.Measure α}
{κ : ProbabilityTheory.Kernel α β} [MeasureTheory.SFinite μ] [ProbabilityTheory.IsSFiniteKernel κ] {s : Set α}
{t : Set β}, MeasurableSet s → MeasurableSet t → (μ.compProd κ) (s ×ˢ t) = ∫⁻ (a : α) in s, (κ a) t ∂μ |
CategoryTheory.IsIso.eq_inv_comp._simp_2 | Mathlib.CategoryTheory.Iso | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {X Y Z : C} (α : X ⟶ Y) [inst_1 : CategoryTheory.IsIso α]
{f : X ⟶ Z} {g : Y ⟶ Z},
(g = CategoryTheory.CategoryStruct.comp (CategoryTheory.inv α) f) = (CategoryTheory.CategoryStruct.comp α g = f) |
Singleton.mk.noConfusion | Init.Core | {α : outParam (Type u)} →
{β : Type v} →
{P : Sort u_1} →
{singleton singleton' : α → β} →
{ singleton := singleton } = { singleton := singleton' } → (singleton ≍ singleton' → P) → P |
_private.Mathlib.LinearAlgebra.Matrix.Rank.0.Matrix.cRank_diagonal._simp_1_1 | Mathlib.LinearAlgebra.Matrix.Rank | ∀ {α : Sort u_1} {P : Prop} [inst : Decidable P] {a b c : α}, ((if P then a else b) = c) = ((P → a = c) ∧ (¬P → b = c)) |
CategoryTheory.Adjunction.compCoyonedaIso | Mathlib.CategoryTheory.Adjunction.Basic | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
{D : Type u₂} →
[inst_1 : CategoryTheory.Category.{v₁, u₂} D] →
{F : CategoryTheory.Functor C D} →
{G : CategoryTheory.Functor D C} →
(F ⊣ G) →
(F.op.comp CategoryTheory.coyoneda ≅
CategoryTheory.coyoneda.comp ((CategoryTheory.Functor.whiskeringLeft D C (Type v₁)).obj G)) |
Lean.Elab.Tactic.Grind.Context.ctx | Lean.Elab.Tactic.Grind.Basic | Lean.Elab.Tactic.Grind.Context → Lean.Meta.Grind.Context |
Lean.Compiler.LCNF.UnreachableBranches.InterpContext | Lean.Compiler.LCNF.ElimDeadBranches | Type |
Order.IsSuccLimit | Mathlib.Order.SuccPred.Limit | {α : Type u_1} → [Preorder α] → α → Prop |
IsLocalExtr | Mathlib.Topology.Order.LocalExtr | {α : Type u} → {β : Type v} → [TopologicalSpace α] → [Preorder β] → (α → β) → α → Prop |
PiTensorProduct.dualDistribInvOfBasis.congr_simp | Mathlib.LinearAlgebra.PiTensorProduct.Dual | ∀ {ι : Type u_1} {R : Type u_2} {κ : ι → Type u_3} {M : ι → Type u_4} [inst : CommRing R]
[inst_1 : (i : ι) → AddCommGroup (M i)] [inst_2 : (i : ι) → Module R (M i)] [inst_3 : Finite ι]
[inst_4 : ∀ (i : ι), Finite (κ i)] (b b_1 : (i : ι) → Module.Basis (κ i) R (M i)),
b = b_1 → PiTensorProduct.dualDistribInvOfBasis b = PiTensorProduct.dualDistribInvOfBasis b_1 |
_private.Mathlib.Algebra.GroupWithZero.Center.0.Set.zero_mem_centralizer._simp_1_1 | Mathlib.Algebra.GroupWithZero.Center | ∀ {M : Type u_1} {S : Set M} [inst : Mul M] {c : M}, (c ∈ S.centralizer) = ∀ m ∈ S, m * c = c * m |
LSeries.abscissaOfAbsConv_congr' | Mathlib.NumberTheory.LSeries.Convergence | ∀ {f g : ℕ → ℂ}, f =ᶠ[Filter.atTop] g → LSeries.abscissaOfAbsConv f = LSeries.abscissaOfAbsConv g |
exists_ratio_deriv_eq_ratio_slope' | Mathlib.Analysis.Calculus.Deriv.MeanValue | ∀ (f : ℝ → ℝ) {a b : ℝ},
a < b →
∀ (g : ℝ → ℝ) {lfa lga lfb lgb : ℝ},
DifferentiableOn ℝ f (Set.Ioo a b) →
DifferentiableOn ℝ g (Set.Ioo a b) →
Filter.Tendsto f (nhdsWithin a (Set.Ioi a)) (nhds lfa) →
Filter.Tendsto g (nhdsWithin a (Set.Ioi a)) (nhds lga) →
Filter.Tendsto f (nhdsWithin b (Set.Iio b)) (nhds lfb) →
Filter.Tendsto g (nhdsWithin b (Set.Iio b)) (nhds lgb) →
∃ c ∈ Set.Ioo a b, (lgb - lga) * deriv f c = (lfb - lfa) * deriv g c |
MemHolder.of_le' | Mathlib.Topology.MetricSpace.HolderNorm | ∀ {X : Type u_1} {Y : Type u_2} [inst : PseudoEMetricSpace X] [inst_1 : PseudoEMetricSpace Y] {r : NNReal} {f : X → Y}
{s : NNReal}, MemHolder r f → s ≤ r → (∃ C, ∀ (x y : X), edist x y ≤ ↑C) → MemHolder s f |
Lean.Meta.Simp.ResultQ.mk | Qq.Simp | {u : Lean.Level} →
{α : Q(Sort u)} →
{e : Q(«$α»)} → (expr : Q(«$α»)) → Option Q(«$e» = «$expr») → optParam Bool true → Lean.Meta.Simp.ResultQ e |
AddChar.coe_mul._simp_1 | Mathlib.Algebra.Group.AddChar | ∀ {A : Type u_2} {M : Type u_3} [inst : AddMonoid A] [inst_1 : CommMonoid M] (ψ χ : AddChar A M), ⇑ψ * ⇑χ = ⇑(ψ * χ) |
Std.DTreeMap.Internal.Const.RiiSliceData.mk.noConfusion | Std.Data.DTreeMap.Internal.Zipper | {α : Type u} →
{β : Type v} →
{P : Sort u_1} →
{treeMap : Std.DTreeMap.Internal.Impl α fun x => β} →
{range : Std.Rii α} →
{treeMap' : Std.DTreeMap.Internal.Impl α fun x => β} →
{range' : Std.Rii α} →
{ treeMap := treeMap, range := range } = { treeMap := treeMap', range := range' } →
(treeMap ≍ treeMap' → range ≍ range' → P) → P |
ContDiffMapSupportedIn.structureMapLM_apply_withOrder | Mathlib.Analysis.Distribution.ContDiffMapSupportedIn | ∀ (𝕜 : Type u_1) {E : Type u_2} {F : Type u_3} [inst : NontriviallyNormedField 𝕜] [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace ℝ E] [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace ℝ F] [inst_5 : NormedSpace 𝕜 F]
[inst_6 : SMulCommClass ℝ 𝕜 F] {n : ℕ∞} {K : TopologicalSpace.Compacts E} {i : ℕ}
(f : ContDiffMapSupportedIn E F n K),
⇑((ContDiffMapSupportedIn.structureMapLM 𝕜 n i) f) = if ↑i ≤ n then iteratedFDeriv ℝ i ⇑f else 0 |
ProbabilityTheory.iIndepFun.indepFun_mul_left | Mathlib.Probability.Independence.Basic | ∀ {Ω : Type u_1} {ι : Type u_2} {_mΩ : MeasurableSpace Ω} {μ : MeasureTheory.Measure Ω} {β : Type u_10}
{m : MeasurableSpace β} [inst : Mul β] [MeasurableMul₂ β] {f : ι → Ω → β},
ProbabilityTheory.iIndepFun f μ →
(∀ (i : ι), Measurable (f i)) → ∀ (i j k : ι), i ≠ k → j ≠ k → ProbabilityTheory.IndepFun (f i * f j) (f k) μ |
FermatLastTheoremForThreeGen.Solution'.c | Mathlib.NumberTheory.FLT.Three | {K : Type u_1} →
[inst : Field K] →
{ζ : K} → {hζ : IsPrimitiveRoot ζ 3} → FermatLastTheoremForThreeGen.Solution' hζ → NumberField.RingOfIntegers K |
Mathlib.Linter.Style.initFn._@.Mathlib.Tactic.Linter.DeprecatedSyntaxLinter.3986038175._hygCtx._hyg.4 | Mathlib.Tactic.Linter.DeprecatedSyntaxLinter | IO (Lean.Option Bool) |
LowerSet.map | Mathlib.Order.UpperLower.CompleteLattice | {α : Type u_1} → {β : Type u_2} → [inst : Preorder α] → [inst_1 : Preorder β] → α ≃o β → LowerSet α ≃o LowerSet β |
_private.Mathlib.AlgebraicTopology.ModelCategory.Over.0.HomotopicalAlgebra.fibrations_over_iff._simp_1_2 | Mathlib.AlgebraicTopology.ModelCategory.Over | ∀ {T : Type u_3} [inst : CategoryTheory.Category.{v_3, u_3} T] {W : CategoryTheory.MorphismProperty T} {X : T}
{Y Z : CategoryTheory.Over X} (f : Y ⟶ Z), W.over f = W f.left |
CategoryTheory.ShortComplex.X₃ | Mathlib.Algebra.Homology.ShortComplex.Basic | {C : Type u_1} →
[inst : CategoryTheory.Category.{v_1, u_1} C] →
[inst_1 : CategoryTheory.Limits.HasZeroMorphisms C] → CategoryTheory.ShortComplex C → C |
Function.LeftInverse.eq | Mathlib.Logic.Function.Basic | ∀ {α : Sort u_1} {β : Sort u_2} {g : β → α} {f : α → β}, Function.LeftInverse g f → ∀ (x : α), g (f x) = x |
Aesop.ForwardHypData.mk.inj | Aesop.RuleTac.Forward.Basic | ∀ {depths depths_1 : Std.HashMap Lean.FVarId ℕ}, { depths := depths } = { depths := depths_1 } → depths = depths_1 |
DirectSum.coe_decompose_mul_of_right_mem_of_le | Mathlib.RingTheory.GradedAlgebra.Basic | ∀ {ι : Type u_1} {A : Type u_3} {σ : Type u_4} [inst : Semiring A] [inst_1 : DecidableEq ι] [inst_2 : AddCommMonoid ι]
[inst_3 : PartialOrder ι] [CanonicallyOrderedAdd ι] [inst_5 : SetLike σ A] [inst_6 : AddSubmonoidClass σ A]
(𝒜 : ι → σ) [inst_7 : GradedRing 𝒜] {a b : A} {n i : ι} [inst_8 : Sub ι] [OrderedSub ι] [AddLeftReflectLE ι],
b ∈ 𝒜 i → i ≤ n → ↑(((DirectSum.decompose 𝒜) (a * b)) n) = ↑(((DirectSum.decompose 𝒜) a) (n - i)) * b |
_private.Mathlib.Data.Ordmap.Ordset.0.Ordnode.adjustWith.match_1.splitter | Mathlib.Data.Ordmap.Ordset | {α : Type u_1} →
(motive : Ordnode α → Sort u_2) →
(x : Ordnode α) →
(Unit → motive Ordnode.nil) →
((sz : ℕ) → (l : Ordnode α) → (y : α) → (r : Ordnode α) → motive (Ordnode.node sz l y r)) → motive x |
Submodule.toBaseChange_surjective' | Mathlib.LinearAlgebra.TensorProduct.Tower | ∀ {R : Type u_1} {M : Type u_2} (A : Type u_3) [inst : CommSemiring R] [inst_1 : Semiring A] [inst_2 : Algebra R A]
[inst_3 : AddCommMonoid M] [inst_4 : Module R M] (p : Submodule R M) {y : TensorProduct R A M},
y ∈ Submodule.baseChange A p → ∃ x, ↑((Submodule.toBaseChange A p) x) = y |
Subalgebra.topologicalClosure_comap_homeomorph | Mathlib.Topology.Algebra.Algebra | ∀ {R : Type u_1} [inst : CommSemiring R] {A : Type u} [inst_1 : TopologicalSpace A] [inst_2 : Semiring A]
[inst_3 : Algebra R A] [inst_4 : IsTopologicalSemiring A] (s : Subalgebra R A) {B : Type u_2}
[inst_5 : TopologicalSpace B] [inst_6 : Ring B] [inst_7 : IsTopologicalRing B] [inst_8 : Algebra R B] (f : B →ₐ[R] A)
(f' : B ≃ₜ A), ⇑f = ⇑f' → Subalgebra.comap f s.topologicalClosure = (Subalgebra.comap f s).topologicalClosure |
ScottContinuous.inf₂.match_1 | Mathlib.Order.ScottContinuity.Complete | {β : Type u_1} → (motive : β × β → Sort u_2) → (x : β × β) → ((a b : β) → motive (a, b)) → motive x |
Set.MapsTo.mem_iff | Mathlib.Data.Set.Function | ∀ {α : Type u_1} {β : Type u_2} {s : Set α} {t : Set β} {f : α → β},
Set.MapsTo f s t → Set.MapsTo f sᶜ tᶜ → ∀ {x : α}, f x ∈ t ↔ x ∈ s |
LinearMap.lflip._proof_1 | Mathlib.LinearAlgebra.BilinearMap | ∀ {S : Type u_5} [inst : Semiring S] {R₂ : Type u_1} [inst_1 : Semiring R₂] {S₂ : Type u_6} [inst_2 : Semiring S₂]
{N : Type u_4} {P : Type u_3} [inst_3 : AddCommMonoid N] [inst_4 : AddCommMonoid P] [inst_5 : Module S N]
[inst_6 : Module R₂ P] [inst_7 : Module S₂ P] [inst_8 : SMulCommClass S₂ R₂ P] {σ₁₂ : S →+* S₂} {R₀ : Type u_2}
[inst_9 : Semiring R₀] [inst_10 : Module R₀ P] [inst_11 : SMulCommClass S₂ R₀ P] [SMulCommClass R₂ R₀ P],
SMulCommClass R₂ R₀ (N →ₛₗ[σ₁₂] P) |
Semigrp.hom_inv_apply | Mathlib.Algebra.Category.Semigrp.Basic | ∀ {X Y : Semigrp} (e : X ≅ Y) (s : ↑Y),
(CategoryTheory.ConcreteCategory.hom e.hom) ((CategoryTheory.ConcreteCategory.hom e.inv) s) = s |
Ideal.Quotient.tower_quotient_map_quotient | Mathlib.RingTheory.Ideal.Over | ∀ {R : Type u_1} [inst : CommRing R] {S : Type u_2} [inst_1 : CommRing S] {p : Ideal R} [inst_2 : Algebra R S],
IsScalarTower R (R ⧸ p) (S ⧸ Ideal.map (algebraMap R S) p) |
CategoryTheory.Functor.CoreMonoidal.mk | Mathlib.CategoryTheory.Monoidal.Functor | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
[inst_1 : CategoryTheory.MonoidalCategory C] →
{D : Type u₂} →
[inst_2 : CategoryTheory.Category.{v₂, u₂} D] →
[inst_3 : CategoryTheory.MonoidalCategory D] →
{F : CategoryTheory.Functor C D} →
(εIso :
CategoryTheory.MonoidalCategoryStruct.tensorUnit D ≅
F.obj (CategoryTheory.MonoidalCategoryStruct.tensorUnit C)) →
(μIso :
(X Y : C) →
CategoryTheory.MonoidalCategoryStruct.tensorObj (F.obj X) (F.obj Y) ≅
F.obj (CategoryTheory.MonoidalCategoryStruct.tensorObj X Y)) →
autoParam
(∀ {X Y : C} (f : X ⟶ Y) (X' : C),
CategoryTheory.CategoryStruct.comp
(CategoryTheory.MonoidalCategoryStruct.whiskerRight (F.map f) (F.obj X')) (μIso Y X').hom =
CategoryTheory.CategoryStruct.comp (μIso X X').hom
(F.map (CategoryTheory.MonoidalCategoryStruct.whiskerRight f X')))
CategoryTheory.Functor.CoreMonoidal.μIso_hom_natural_left._autoParam →
autoParam
(∀ {X Y : C} (X' : C) (f : X ⟶ Y),
CategoryTheory.CategoryStruct.comp
(CategoryTheory.MonoidalCategoryStruct.whiskerLeft (F.obj X') (F.map f)) (μIso X' Y).hom =
CategoryTheory.CategoryStruct.comp (μIso X' X).hom
(F.map (CategoryTheory.MonoidalCategoryStruct.whiskerLeft X' f)))
CategoryTheory.Functor.CoreMonoidal.μIso_hom_natural_right._autoParam →
autoParam
(∀ (X Y Z : C),
CategoryTheory.CategoryStruct.comp
(CategoryTheory.MonoidalCategoryStruct.whiskerRight (μIso X Y).hom (F.obj Z))
(CategoryTheory.CategoryStruct.comp
(μIso (CategoryTheory.MonoidalCategoryStruct.tensorObj X Y) Z).hom
(F.map (CategoryTheory.MonoidalCategoryStruct.associator X Y Z).hom)) =
CategoryTheory.CategoryStruct.comp
(CategoryTheory.MonoidalCategoryStruct.associator (F.obj X) (F.obj Y) (F.obj Z)).hom
(CategoryTheory.CategoryStruct.comp
(CategoryTheory.MonoidalCategoryStruct.whiskerLeft (F.obj X) (μIso Y Z).hom)
(μIso X (CategoryTheory.MonoidalCategoryStruct.tensorObj Y Z)).hom))
CategoryTheory.Functor.CoreMonoidal.associativity._autoParam →
autoParam
(∀ (X : C),
(CategoryTheory.MonoidalCategoryStruct.leftUnitor (F.obj X)).hom =
CategoryTheory.CategoryStruct.comp
(CategoryTheory.MonoidalCategoryStruct.whiskerRight εIso.hom (F.obj X))
(CategoryTheory.CategoryStruct.comp
(μIso (CategoryTheory.MonoidalCategoryStruct.tensorUnit C) X).hom
(F.map (CategoryTheory.MonoidalCategoryStruct.leftUnitor X).hom)))
CategoryTheory.Functor.CoreMonoidal.left_unitality._autoParam →
autoParam
(∀ (X : C),
(CategoryTheory.MonoidalCategoryStruct.rightUnitor (F.obj X)).hom =
CategoryTheory.CategoryStruct.comp
(CategoryTheory.MonoidalCategoryStruct.whiskerLeft (F.obj X) εIso.hom)
(CategoryTheory.CategoryStruct.comp
(μIso X (CategoryTheory.MonoidalCategoryStruct.tensorUnit C)).hom
(F.map (CategoryTheory.MonoidalCategoryStruct.rightUnitor X).hom)))
CategoryTheory.Functor.CoreMonoidal.right_unitality._autoParam →
F.CoreMonoidal |
Lean.Lsp.RpcConnected.mk.inj | Lean.Data.Lsp.Extra | ∀ {sessionId sessionId_1 : UInt64}, { sessionId := sessionId } = { sessionId := sessionId_1 } → sessionId = sessionId_1 |
_private.Mathlib.Logic.Function.Iterate.0.Function.iterate_add.match_1_1 | Mathlib.Logic.Function.Iterate | ∀ (motive : ℕ → Prop) (x : ℕ), (∀ (a : Unit), motive 0) → (∀ (n : ℕ), motive n.succ) → motive x |
_private.Mathlib.MeasureTheory.Measure.Tight.0.MeasureTheory.IsTightMeasureSet.map._simp_1_5 | Mathlib.MeasureTheory.Measure.Tight | ∀ {α : Type u_1} {s t : Set α}, (sᶜ ⊆ tᶜ) = (t ⊆ s) |
Lean.Elab.PartialTermInfo.toElabInfo | Lean.Elab.InfoTree.Types | Lean.Elab.PartialTermInfo → Lean.Elab.ElabInfo |
AddCommute.zero_left | Mathlib.Algebra.Group.Commute.Defs | ∀ {M : Type u_2} [inst : AddZeroClass M] (a : M), AddCommute 0 a |
_aux_Mathlib_LinearAlgebra_SModEq_Basic___unexpand_SModEq_1 | Mathlib.LinearAlgebra.SModEq.Basic | Lean.PrettyPrinter.Unexpander |
Tactic.ReduceModChar.TypeToCharPResult.ctorElim | Mathlib.Tactic.ReduceModChar | {u : Lean.Level} →
{α : Q(Type u)} →
{motive : Tactic.ReduceModChar.TypeToCharPResult α → Sort u} →
(ctorIdx : ℕ) →
(t : Tactic.ReduceModChar.TypeToCharPResult α) →
ctorIdx = t.ctorIdx → Tactic.ReduceModChar.TypeToCharPResult.ctorElimType ctorIdx → motive t |
CommRingCat | Mathlib.Algebra.Category.Ring.Basic | Type (u + 1) |
Mathlib.Tactic.Find.«_aux_Mathlib_Tactic_Find___elabRules_Mathlib_Tactic_Find_command#find__1» | Mathlib.Tactic.Find | Lean.Elab.Command.CommandElab |
_private.Mathlib.Data.Nat.Multiplicity.0.Nat.Prime.emultiplicity_choose_prime_pow_add_emultiplicity._simp_1_1 | Mathlib.Data.Nat.Multiplicity | ∀ {α : Type u_2} {s t : Finset α}, Disjoint s t = ∀ ⦃a : α⦄, a ∈ t → a ∉ s |
AffineEquiv.toAffineMap_injective | Mathlib.LinearAlgebra.AffineSpace.AffineEquiv | ∀ {k : Type u_1} {P₁ : Type u_2} {P₂ : Type u_3} {V₁ : Type u_6} {V₂ : Type u_7} [inst : Ring k]
[inst_1 : AddCommGroup V₁] [inst_2 : AddCommGroup V₂] [inst_3 : Module k V₁] [inst_4 : Module k V₂]
[inst_5 : AddTorsor V₁ P₁] [inst_6 : AddTorsor V₂ P₂], Function.Injective AffineEquiv.toAffineMap |
Computation.Bind.f.match_1 | Mathlib.Data.Seq.Computation | {α : Type u_1} →
{β : Type u_2} →
(motive : Computation α ⊕ Computation β → Sort u_3) →
(x : Computation α ⊕ Computation β) →
((ca : Computation α) → motive (Sum.inl ca)) → ((cb : Computation β) → motive (Sum.inr cb)) → motive x |
CategoryTheory.Abelian.SpectralObject.kernelSequenceOpcyclesEIso._proof_2 | Mathlib.Algebra.Homology.SpectralObject.Page | ∀ {C : Type u_2} {ι : Type u_4} [inst : CategoryTheory.Category.{u_1, u_2} C]
[inst_1 : CategoryTheory.Category.{u_3, u_4} ι] [inst_2 : CategoryTheory.Abelian C]
(X : CategoryTheory.Abelian.SpectralObject C ι) {i j k l : ι} (f₁ : i ⟶ j) (f₂ : j ⟶ k) (f₃ : k ⟶ l) (n₀ n₁ n₂ : ℤ)
(hn₁ : n₀ + 1 = n₁) (hn₂ : n₁ + 1 = n₂),
CategoryTheory.CategoryStruct.comp
(CategoryTheory.Iso.refl
{ X₁ := (X.shortComplex f₁ f₂ f₃ n₀ n₁ n₂ hn₁ hn₂).homology,
X₂ := (X.shortComplex f₁ f₂ f₃ n₀ n₁ n₂ hn₁ hn₂).opcycles,
X₃ := (X.shortComplex f₁ f₂ f₃ n₀ n₁ n₂ hn₁ hn₂).X₃,
f := (X.shortComplex f₁ f₂ f₃ n₀ n₁ n₂ hn₁ hn₂).homologyι,
g := (X.shortComplex f₁ f₂ f₃ n₀ n₁ n₂ hn₁ hn₂).fromOpcycles, zero := ⋯ }.X₁).hom
(X.kernelSequenceOpcyclesE f₁ f₂ f₃ n₀ n₁ n₂ hn₁ hn₂).f =
CategoryTheory.CategoryStruct.comp
{ X₁ := (X.shortComplex f₁ f₂ f₃ n₀ n₁ n₂ hn₁ hn₂).homology,
X₂ := (X.shortComplex f₁ f₂ f₃ n₀ n₁ n₂ hn₁ hn₂).opcycles,
X₃ := (X.shortComplex f₁ f₂ f₃ n₀ n₁ n₂ hn₁ hn₂).X₃,
f := (X.shortComplex f₁ f₂ f₃ n₀ n₁ n₂ hn₁ hn₂).homologyι,
g := (X.shortComplex f₁ f₂ f₃ n₀ n₁ n₂ hn₁ hn₂).fromOpcycles, zero := ⋯ }.f
(X.opcyclesIso f₁ f₂ f₃ n₀ n₁ n₂ hn₁ hn₂).hom |
Std.ExtTreeSet.minD_empty | Std.Data.ExtTreeSet.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} [inst : Std.TransCmp cmp] {fallback : α}, ∅.minD fallback = fallback |
HahnSeries.instSMulZeroClass | Mathlib.RingTheory.HahnSeries.Addition | {Γ : Type u_1} →
{R : Type u_3} →
[inst : PartialOrder Γ] →
{V : Type u_8} → [inst_1 : Zero V] → [SMulZeroClass R V] → SMulZeroClass R (HahnSeries Γ V) |
_private.Lean.Server.FileWorker.WidgetRequests.0.Lean.Widget.unfoldMessageDataTracesContaining._unsafe_rec | Lean.Server.FileWorker.WidgetRequests | String → ℕ → Lean.MessageData → Lean.NamingContext → Option Lean.MessageDataContext → BaseIO (Lean.MessageData × Bool) |
birkhoffAverage_apply_sub_birkhoffAverage | Mathlib.Dynamics.BirkhoffSum.Average | ∀ {R : Type u_1} {α : Type u_2} {M : Type u_3} [inst : DivisionSemiring R] [inst_1 : AddCommGroup M]
[inst_2 : Module R M] (f : α → α) (g : α → M) (n : ℕ) (x : α),
birkhoffAverage R f g n (f x) - birkhoffAverage R f g n x = (↑n)⁻¹ • (g (f^[n] x) - g x) |
Representation.IntertwiningMap.instAddCommMonoid._proof_6 | Mathlib.RepresentationTheory.Intertwining | ∀ {A : Type u_1} {G : Type u_2} {V : Type u_3} {W : Type u_4} [inst : Semiring A] [inst_1 : Monoid G]
[inst_2 : AddCommMonoid V] [inst_3 : AddCommMonoid W] [inst_4 : Module A V] [inst_5 : Module A W]
(ρ : Representation A G V) (σ : Representation A G W) (x : ρ.IntertwiningMap σ), 0 • x = 0 |
Partrec.optionCasesOn_right | Mathlib.Computability.Partrec | ∀ {α : Type u_1} {β : Type u_2} {σ : Type u_4} [inst : Primcodable α] [inst_1 : Primcodable β] [inst_2 : Primcodable σ]
{o : α → Option β} {f : α → σ} {g : α → β →. σ},
Computable o → Computable f → Partrec₂ g → Partrec fun a => Option.casesOn (o a) (Part.some (f a)) (g a) |
Lean.InductiveVal.ctors | Lean.Declaration | Lean.InductiveVal → List Lean.Name |
EMetric.exists_ball_subset_ball | Mathlib.Topology.EMetricSpace.Defs | ∀ {α : Type u} [inst : PseudoEMetricSpace α] {x y : α} {ε : ENNReal},
y ∈ Metric.eball x ε → ∃ ε' > 0, Metric.eball y ε' ⊆ Metric.eball x ε |
Lean.Elab.Term.UseImplicitLambdaResult.yes.inj | Lean.Elab.Term.TermElabM | ∀ {expectedType expectedType_1 : Lean.Expr},
Lean.Elab.Term.UseImplicitLambdaResult.yes expectedType = Lean.Elab.Term.UseImplicitLambdaResult.yes expectedType_1 →
expectedType = expectedType_1 |
RightDerivMeasurableAux.B | Mathlib.Analysis.Calculus.FDeriv.Measurable | {F : Type u_1} → [inst : NormedAddCommGroup F] → [NormedSpace ℝ F] → (ℝ → F) → Set F → ℝ → ℝ → ℝ → Set ℝ |
Finset.mem_mul | Mathlib.Algebra.Group.Pointwise.Finset.Basic | ∀ {α : Type u_2} [inst : DecidableEq α] [inst_1 : Mul α] {s t : Finset α} {x : α},
x ∈ s * t ↔ ∃ y ∈ s, ∃ z ∈ t, y * z = x |
Lean.Lsp.WorkspaceEdit._sizeOf_1 | Lean.Data.Lsp.Basic | Lean.Lsp.WorkspaceEdit → ℕ |
Filter.limsSup_top | Mathlib.Order.LiminfLimsup | ∀ {α : Type u_1} [inst : CompleteLattice α], ⊤.limsSup = ⊤ |
AlgebraicGeometry.Scheme.IdealSheafData.radical_sup | Mathlib.AlgebraicGeometry.IdealSheaf.Basic | ∀ {X : AlgebraicGeometry.Scheme} {I J : X.IdealSheafData}, (I ⊔ J).radical = (I.radical ⊔ J.radical).radical |
AffineSubspace.sOppSide_pointReflection | Mathlib.Analysis.Convex.Side | ∀ {R : Type u_1} {V : Type u_2} {P : Type u_4} [inst : Field R] [inst_1 : LinearOrder R]
[inst_2 : IsStrictOrderedRing R] [inst_3 : AddCommGroup V] [inst_4 : Module R V] [inst_5 : AddTorsor V P]
{s : AffineSubspace R P} {x y : P}, x ∈ s → y ∉ s → s.SOppSide y ((AffineEquiv.pointReflection R x) y) |
CommGrpCat.ctorIdx | Mathlib.Algebra.Category.Grp.Basic | CommGrpCat → ℕ |
UInt8.mul_def | Init.Data.UInt.Lemmas | ∀ (a b : UInt8), a * b = { toBitVec := a.toBitVec * b.toBitVec } |
Matrix.toLinearEquiv'_symm_apply | Mathlib.LinearAlgebra.Matrix.ToLinearEquiv | ∀ {n : Type u_1} [inst : Fintype n] {R : Type u_2} [inst_1 : CommRing R] [inst_2 : DecidableEq n] (P : Matrix n n R)
(h : Invertible P), ↑(P.toLinearEquiv' h).symm = Matrix.toLin' ⅟P |
_private.Mathlib.RingTheory.Polynomial.IsIntegral.0.IsIntegral.coeff._proof_1_2 | Mathlib.RingTheory.Polynomial.IsIntegral | ∀ {R : Type u_1} {S : Type u_2} [inst : CommRing R] [inst_1 : CommRing S] [inst_2 : Algebra R S] (x : Polynomial R)
(x_1 : Polynomial S),
(Polynomial.mapRingHom (algebraMap R S)) x * x_1 = x_1 * (Polynomial.mapRingHom (algebraMap R S)) x |
AddMonoidHom.add._proof_1 | Mathlib.Algebra.Group.Hom.Basic | ∀ {M : Type u_2} {N : Type u_1} [inst : AddZeroClass M] [inst_1 : AddCommMonoid N] (f g : M →+ N), f 0 + g 0 = 0 |
Lean.Meta.Sym.BackwardRule.expr | Lean.Meta.Sym.Apply | Lean.Meta.Sym.BackwardRule → Lean.Expr |
Computation.LiftRel.symm | Mathlib.Data.Seq.Computation | ∀ {α : Type u} (R : α → α → Prop), Symmetric R → Symmetric (Computation.LiftRel R) |
MeasureTheory.Measure.nullMeasurable_comp_snd | Mathlib.MeasureTheory.Measure.Prod | ∀ {α : Type u_1} {β : Type u_2} {γ : Type u_3} [inst : MeasurableSpace α] [inst_1 : MeasurableSpace β]
[inst_2 : MeasurableSpace γ] {μ : MeasureTheory.Measure α} {ν : MeasureTheory.Measure β} [MeasureTheory.SFinite ν]
[NeZero μ] {f : β → γ}, MeasureTheory.NullMeasurable (f ∘ Prod.snd) (μ.prod ν) ↔ MeasureTheory.NullMeasurable f ν |
Set.inter_mul_union_subset_union | Mathlib.Algebra.Group.Pointwise.Set.Basic | ∀ {α : Type u_2} [inst : Mul α] {s₁ s₂ t₁ t₂ : Set α}, s₁ ∩ s₂ * (t₁ ∪ t₂) ⊆ s₁ * t₁ ∪ s₂ * t₂ |
_private.Mathlib.Combinatorics.SimpleGraph.Paths.0.SimpleGraph.Walk.IsCycle.count_support._proof_1_9 | Mathlib.Combinatorics.SimpleGraph.Paths | ∀ {V : Type u_1} {G : SimpleGraph V} {v : V} [inst : DecidableEq V] {c : G.Walk v v},
1 ≤ (List.findIdxs (fun x => decide (x = v)) c.support.tail).length →
0 < (List.findIdxs (fun x => decide (x = v)) c.support.tail).length |
UInt64.toUSize_ofFin | Init.Data.UInt.Lemmas | ∀ (n : Fin UInt64.size), (UInt64.ofFin n).toUSize = USize.ofNat ↑n |
WithZero.map'_comp | Mathlib.Algebra.GroupWithZero.WithZero | ∀ {α : Type u_1} {β : Type u_2} {γ : Type u_3} [inst : MulOneClass α] [inst_1 : MulOneClass β] [inst_2 : MulOneClass γ]
(f : α →* β) (g : β →* γ), WithZero.map' (g.comp f) = (WithZero.map' g).comp (WithZero.map' f) |
Filter.disjoint_prod | Mathlib.Order.Filter.Prod | ∀ {α : Type u_1} {β : Type u_2} {f : Filter α} {g : Filter β} {f' : Filter α} {g' : Filter β},
Disjoint (f ×ˢ g) (f' ×ˢ g') ↔ Disjoint f f' ∨ Disjoint g g' |
GaloisConnection.u_eq_top | Mathlib.Order.GaloisConnection.Defs | ∀ {α : Type u} {β : Type v} [inst : PartialOrder α] [inst_1 : Preorder β] [inst_2 : OrderTop α] {l : α → β} {u : β → α},
GaloisConnection l u → ∀ {x : β}, u x = ⊤ ↔ l ⊤ ≤ x |
instDistribPNat | Mathlib.Data.PNat.Basic | Distrib ℕ+ |
_private.Lean.Elab.Tactic.Decide.0.Lean.Elab.Tactic.preprocessPropToDecide | Lean.Elab.Tactic.Decide | Lean.Expr → Lean.Elab.TermElabM Lean.Expr |
_private.Mathlib.RingTheory.SimpleModule.Isotypic.0.isFullyInvariant_iff_le_imp_isotypicComponent_le.match_1_5 | Mathlib.RingTheory.SimpleModule.Isotypic | ∀ {R : Type u_2} {M : Type u_1} [inst : Ring R] [inst_1 : AddCommGroup M] [inst_2 : Module R M] (S S' : Submodule R M)
(e : ↥S' ≃ₗ[R] ↥S) (motive : (∃ h, h ∘ₗ S.subtype = S'.subtype ∘ₗ ↑e.symm) → Prop)
(x : ∃ h, h ∘ₗ S.subtype = S'.subtype ∘ₗ ↑e.symm),
(∀ (p : M →ₗ[R] M) (eq : p ∘ₗ S.subtype = S'.subtype ∘ₗ ↑e.symm), motive ⋯) → motive x |
Lean.Parser.Command.structFields.formatter | Lean.Parser.Command | Lean.PrettyPrinter.Formatter |
Representation.mem_invariants_iff_of_forall_mem_zpowers | Mathlib.RepresentationTheory.Invariants | ∀ {k : Type u_1} {G : Type u_2} {V : Type u_3} [inst : CommSemiring k] [inst_1 : Group G] [inst_2 : AddCommMonoid V]
[inst_3 : Module k V] (ρ : Representation k G V) (g : G),
(∀ (x : G), x ∈ Subgroup.zpowers g) → ∀ (x : V), x ∈ ρ.invariants ↔ (ρ g) x = x |
Lean.Grind.CommRing.Poly.combine.go.eq_def | Init.Grind.Ring.CommSolver | ∀ (fuel : ℕ) (p₁ p₂ : Lean.Grind.CommRing.Poly),
Lean.Grind.CommRing.Poly.combine.go fuel p₁ p₂ =
match fuel with
| 0 => p₁.concat p₂
| fuel.succ =>
match p₁, p₂ with
| Lean.Grind.CommRing.Poly.num k₁, Lean.Grind.CommRing.Poly.num k₂ => Lean.Grind.CommRing.Poly.num (k₁ + k₂)
| Lean.Grind.CommRing.Poly.num k₁, Lean.Grind.CommRing.Poly.add k₂ m₂ p₂ =>
(Lean.Grind.CommRing.Poly.add k₂ m₂ p₂).addConst k₁
| Lean.Grind.CommRing.Poly.add k₁ m₁ p₁, Lean.Grind.CommRing.Poly.num k₂ =>
(Lean.Grind.CommRing.Poly.add k₁ m₁ p₁).addConst k₂
| Lean.Grind.CommRing.Poly.add k₁ m₁ p₁, Lean.Grind.CommRing.Poly.add k₂ m₂ p₂ =>
match m₁.grevlex m₂ with
| Ordering.eq =>
have k := k₁ + k₂;
bif k == 0 then Lean.Grind.CommRing.Poly.combine.go fuel p₁ p₂
else Lean.Grind.CommRing.Poly.add k m₁ (Lean.Grind.CommRing.Poly.combine.go fuel p₁ p₂)
| Ordering.gt =>
Lean.Grind.CommRing.Poly.add k₁ m₁
(Lean.Grind.CommRing.Poly.combine.go fuel p₁ (Lean.Grind.CommRing.Poly.add k₂ m₂ p₂))
| Ordering.lt =>
Lean.Grind.CommRing.Poly.add k₂ m₂
(Lean.Grind.CommRing.Poly.combine.go fuel (Lean.Grind.CommRing.Poly.add k₁ m₁ p₁) p₂) |
Mathlib.Tactic.IntervalCases.Methods.bisect | Mathlib.Tactic.IntervalCases | Mathlib.Tactic.IntervalCases.Methods →
Lean.MVarId →
Subarray Mathlib.Tactic.IntervalCases.IntervalCasesSubgoal →
Mathlib.Tactic.IntervalCases.Bound →
Mathlib.Tactic.IntervalCases.Bound → Lean.Expr → Lean.Expr → Lean.Expr → Lean.Expr → Lean.Expr → Lean.MetaM Unit |
CategoryTheory.finCategoryOpposite | Mathlib.CategoryTheory.FinCategory.Basic | {J : Type v} → [inst : CategoryTheory.SmallCategory J] → [CategoryTheory.FinCategory J] → CategoryTheory.FinCategory Jᵒᵖ |
Mathlib.Tactic.rflTac | Mathlib.Tactic.Relation.Rfl | Lean.Elab.Tactic.TacticM Unit |
IsCompact.lt_sInf_iff_of_continuous | Mathlib.Topology.Order.Compact | ∀ {α : Type u_2} {β : Type u_3} [inst : ConditionallyCompleteLinearOrder α] [inst_1 : TopologicalSpace α]
[inst_2 : TopologicalSpace β] [ClosedIicTopology α] {f : β → α} {K : Set β},
IsCompact K → K.Nonempty → ContinuousOn f K → ∀ (y : α), y < sInf (f '' K) ↔ ∀ x ∈ K, y < f x |
_private.Lean.Compiler.IR.LLVMBindings.0.LLVM.Builder.mk._flat_ctor | Lean.Compiler.IR.LLVMBindings | {Context : Sort u_1} → {ctx : Context} → USize → LLVM.Builder ctx |
Std.Tactic.BVDecide.BVExpr.bitblast.blastExtract._proof_6 | Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Extract | ∀ {newWidth : ℕ}, ∀ curr ≤ newWidth, ¬curr < newWidth → curr = newWidth |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.