name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M |
|---|---|---|
Lean.KVMap.entries | Lean.Data.KVMap | Lean.KVMap → List (Lean.Name × Lean.DataValue) |
ULift.leftCancelMonoid.eq_1 | Mathlib.Algebra.Group.ULift | ∀ {α : Type u} [inst : LeftCancelMonoid α],
ULift.leftCancelMonoid = Function.Injective.leftCancelMonoid ⇑Equiv.ulift ⋯ ⋯ ⋯ ⋯ |
Aesop.LocalRuleSet.simprocsArray | Aesop.RuleSet | Aesop.LocalRuleSet → Array (Lean.Name × Lean.Meta.Simprocs) |
isTotallyDisconnected_iff_lt | Mathlib.Topology.Order.IntermediateValue | ∀ {α : Type u} [inst : ConditionallyCompleteLinearOrder α] [inst_1 : TopologicalSpace α] [OrderTopology α]
[DenselyOrdered α] {s : Set α}, IsTotallyDisconnected s ↔ ∀ x ∈ s, ∀ y ∈ s, x < y → ∃ z ∉ s, z ∈ Set.Ioo x y |
LieModule.chainTop | Mathlib.Algebra.Lie.Weights.Chain | {R : Type u_1} →
{L : Type u_2} →
[inst : CommRing R] →
[inst_1 : LieRing L] →
[inst_2 : LieAlgebra R L] →
{M : Type u_3} →
[inst_3 : AddCommGroup M] →
[inst_4 : Module R M] →
[inst_5 : LieRingModule L M] →
[inst_6 : LieModule R L M] →
[inst_7 : LieRing.IsNilpotent L] →
[IsAddTorsionFree R] →
[IsDomain R] →
[Module.IsTorsionFree R M] →
[IsNoetherian R M] → (L → R) → LieModule.Weight R L M → LieModule.Weight R L M |
_private.Mathlib.Analysis.Normed.Module.Alternating.Uncurry.Fin.0.ContinuousAlternatingMap.alternatizeUncurryFinCLM.aux._proof_10 | Mathlib.Analysis.Normed.Module.Alternating.Uncurry.Fin | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜], RingHomCompTriple (RingHom.id 𝕜) (RingHom.id 𝕜) (RingHom.id 𝕜) |
groupHomology.chains₁ToCoinvariantsKer | Mathlib.RepresentationTheory.Homological.GroupHomology.LowDegree | {k G : Type u} →
[inst : CommRing k] →
[inst_1 : Group G] →
(A : Rep k G) → ModuleCat.of k (G →₀ ↑A.V) ⟶ ModuleCat.of k ↥(Representation.Coinvariants.ker A.ρ) |
FreeSimplexQuiver.homRel.δ_comp_δ | Mathlib.AlgebraicTopology.SimplexCategory.GeneratorsRelations.Basic | ∀ {n : ℕ} {i j : Fin (n + 2)},
i ≤ j →
FreeSimplexQuiver.homRel
(CategoryTheory.CategoryStruct.comp ((CategoryTheory.Paths.of FreeSimplexQuiver).map (FreeSimplexQuiver.δ i))
((CategoryTheory.Paths.of FreeSimplexQuiver).map (FreeSimplexQuiver.δ j.succ)))
(CategoryTheory.CategoryStruct.comp ((CategoryTheory.Paths.of FreeSimplexQuiver).map (FreeSimplexQuiver.δ j))
((CategoryTheory.Paths.of FreeSimplexQuiver).map (FreeSimplexQuiver.δ i.castSucc))) |
CategoryTheory.HasLiftingProperty.transfiniteComposition.SqStruct.w₂ | Mathlib.CategoryTheory.SmallObject.TransfiniteCompositionLifting | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {J : Type w} [inst_1 : LinearOrder J] [inst_2 : OrderBot J]
{F : CategoryTheory.Functor J C} {c : CategoryTheory.Limits.Cocone F} {X Y : C} {p : X ⟶ Y} {f : F.obj ⊥ ⟶ X}
{g : c.pt ⟶ Y} {j : J} (self : CategoryTheory.HasLiftingProperty.transfiniteComposition.SqStruct c p f g j),
CategoryTheory.CategoryStruct.comp self.f' p = CategoryTheory.CategoryStruct.comp (c.ι.app j) g |
ContinuousMultilinearMap.norm_iteratedFDerivComponent_le | Mathlib.Analysis.Normed.Module.Multilinear.Basic | ∀ {𝕜 : Type u} {ι : Type v} {E₁ : ι → Type wE₁} {G : Type wG} [inst : NontriviallyNormedField 𝕜]
[inst_1 : (i : ι) → SeminormedAddCommGroup (E₁ i)] [inst_2 : (i : ι) → NormedSpace 𝕜 (E₁ i)]
[inst_3 : SeminormedAddCommGroup G] [inst_4 : NormedSpace 𝕜 G] [inst_5 : Fintype ι] {α : Type u_1}
[inst_6 : Fintype α] (f : ContinuousMultilinearMap 𝕜 E₁ G) {s : Set ι} (e : α ≃ ↑s)
[inst_7 : DecidablePred fun x => x ∈ s] (x : (i : ι) → E₁ i),
‖(f.iteratedFDerivComponent e) fun x_1 => x ↑x_1‖ ≤ ‖f‖ * ‖x‖ ^ (Fintype.card ι - Fintype.card α) |
small_iff | Mathlib.Logic.Small.Defs | ∀ (α : Type v), Small.{w, v} α ↔ ∃ S, Nonempty (α ≃ S) |
_private.Mathlib.Algebra.Order.Star.Basic.0.MulOpposite.instStarOrderedRing._simp_1 | Mathlib.Algebra.Order.Star.Basic | ∀ {α : Type u_1} {β : Type u_2} {ι : Sort u_4} (g : α → β) (f : ι → α), g '' Set.range f = Set.range fun x => g (f x) |
Mathlib.Tactic.Widget.homType? | Mathlib.Tactic.Widget.CommDiag | Lean.Expr → Option (Lean.Expr × Lean.Expr) |
MulActionWithZero.toMulAction | Mathlib.Algebra.GroupWithZero.Action.Defs | {M₀ : Type u_2} →
{A : Type u_7} → {inst : MonoidWithZero M₀} → {inst_1 : Zero A} → [self : MulActionWithZero M₀ A] → MulAction M₀ A |
Vector.set._proof_1 | Init.Data.Vector.Basic | ∀ {α : Type u_1} {n : ℕ} (xs : Vector α n), ∀ i < n, i < xs.toArray.size |
subset_refl | Mathlib.Order.RelClasses | ∀ {α : Type u} [inst : HasSubset α] [Std.Refl fun x1 x2 => x1 ⊆ x2] (a : α), a ⊆ a |
MeromorphicOn.mono_set | Mathlib.Analysis.Meromorphic.Basic | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_3} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {f : 𝕜 → E} {U : Set 𝕜}, MeromorphicOn f U → ∀ {V : Set 𝕜}, V ⊆ U → MeromorphicOn f V |
Lean.Meta.Grind.AC.instInhabitedEqCnstr | Lean.Meta.Tactic.Grind.AC.Types | Inhabited Lean.Meta.Grind.AC.EqCnstr |
Std.Tactic.BVDecide.BVExpr.bitblast.blastConst._proof_4 | Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Const | ∀ {w : ℕ}, ∀ curr ≤ w, ¬curr < w → curr = w |
Lean.Meta.Config.assignSyntheticOpaque | Lean.Meta.Basic | Lean.Meta.Config → Bool |
IO.Error.permissionDenied.inj | Init.System.IOError | ∀ {filename : Option String} {osCode : UInt32} {details : String} {filename_1 : Option String} {osCode_1 : UInt32}
{details_1 : String},
IO.Error.permissionDenied filename osCode details = IO.Error.permissionDenied filename_1 osCode_1 details_1 →
filename = filename_1 ∧ osCode = osCode_1 ∧ details = details_1 |
Fin.natAdd_natAdd | Init.Data.Fin.Lemmas | ∀ (m n : ℕ) {p : ℕ} (i : Fin p), Fin.natAdd m (Fin.natAdd n i) = Fin.cast ⋯ (Fin.natAdd (m + n) i) |
AnalyticWithinAt.exists_hasFTaylorSeriesUpToOn | Mathlib.Analysis.Calculus.FDeriv.Analytic | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {F : Type v} [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace 𝕜 F] {f : E → F} {x : E}
{s : Set E} [CompleteSpace F] (n : WithTop ℕ∞),
AnalyticWithinAt 𝕜 f s x →
∃ u ∈ nhdsWithin x (insert x s), ∃ p, HasFTaylorSeriesUpToOn n f p u ∧ ∀ (i : ℕ), AnalyticOn 𝕜 (fun x => p x i) u |
MeasureTheory.AEEqFun.coeFn_posPart | Mathlib.MeasureTheory.Function.AEEqFun | ∀ {α : Type u_1} {γ : Type u_3} [inst : MeasurableSpace α] {μ : MeasureTheory.Measure α} [inst_1 : TopologicalSpace γ]
[inst_2 : LinearOrder γ] [inst_3 : OrderClosedTopology γ] [inst_4 : Zero γ] (f : α →ₘ[μ] γ),
↑f.posPart =ᵐ[μ] fun a => max (↑f a) 0 |
CategoryTheory.Bicategory.leftUnitor | Mathlib.CategoryTheory.Bicategory.Basic | {B : Type u} →
[self : CategoryTheory.Bicategory B] →
{a b : B} → (f : a ⟶ b) → CategoryTheory.CategoryStruct.comp (CategoryTheory.CategoryStruct.id a) f ≅ f |
CategoryTheory.shiftFunctorAdd'.eq_1 | Mathlib.CategoryTheory.Shift.Basic | ∀ (C : Type u) {A : Type u_1} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : AddMonoid A]
[inst_2 : CategoryTheory.HasShift C A] (i j k : A) (h : i + j = k),
CategoryTheory.shiftFunctorAdd' C i j k h = CategoryTheory.eqToIso ⋯ ≪≫ CategoryTheory.shiftFunctorAdd C i j |
_private.Mathlib.Combinatorics.SimpleGraph.Connectivity.Connected.0.SimpleGraph.ConnectedComponent.walk_toSimpleGraph._unary._proof_10 | Mathlib.Combinatorics.SimpleGraph.Connectivity.Connected | ∀ {V : Type u_1} {G : SimpleGraph V} {v : V} (u : V) (p : G.Walk u v), p ≍ p |
MulActionHom.instCommSemiring | Mathlib.GroupTheory.GroupAction.Hom | {M : Type u_2} →
{N : Type u_3} →
{X : Type u_4} →
{Y : Type u_5} →
{σ : M → N} →
[inst : SMul M X] →
[inst_1 : Monoid N] →
[inst_2 : CommSemiring Y] → [inst_3 : MulSemiringAction N Y] → CommSemiring (X →ₑ[σ] Y) |
DivisibleHull.mk_add_mk | Mathlib.GroupTheory.DivisibleHull | ∀ {M : Type u_1} [inst : AddCommMonoid M] {m1 m2 : M} {s1 s2 : ℕ+},
DivisibleHull.mk m1 s1 + DivisibleHull.mk m2 s2 = DivisibleHull.mk (↑s2 • m1 + ↑s1 • m2) (s1 * s2) |
CategoryTheory.Limits.ChosenPullback₃.hp₁._autoParam | Mathlib.CategoryTheory.Limits.Shapes.Pullback.ChosenPullback | Lean.Syntax |
LawfulBitraversable.mk | Mathlib.Control.Bitraversable.Basic | ∀ {t : Type u → Type u → Type u} [inst : Bitraversable t] [toLawfulBifunctor : LawfulBifunctor t],
(∀ {α β : Type u} (x : t α β), bitraverse pure pure x = pure x) →
(∀ {F G : Type u → Type u} [inst_1 : Applicative F] [inst_2 : Applicative G] [LawfulApplicative F]
[LawfulApplicative G] {α α' β β' γ γ' : Type u} (f : β → F γ) (f' : β' → F γ') (g : α → G β) (g' : α' → G β')
(x : t α α'),
bitraverse (Functor.Comp.mk ∘ Functor.map f ∘ g) (Functor.Comp.mk ∘ Functor.map f' ∘ g') x =
Functor.Comp.mk (bitraverse f f' <$> bitraverse g g' x)) →
(∀ {α α' β β' : Type u} (f : α → β) (f' : α' → β') (x : t α α'),
bitraverse (pure ∘ f) (pure ∘ f') x = pure (bimap f f' x)) →
(∀ {F G : Type u → Type u} [inst_1 : Applicative F] [inst_2 : Applicative G] [LawfulApplicative F]
[LawfulApplicative G] (η : ApplicativeTransformation F G) {α α' β β' : Type u} (f : α → F β)
(f' : α' → F β') (x : t α α'),
(fun {α} => η.app α) (bitraverse f f' x) =
bitraverse ((fun {α} => η.app α) ∘ f) ((fun {α} => η.app α) ∘ f') x) →
LawfulBitraversable t |
unitary.linearIsometryEquiv_coe_symm_apply | Mathlib.Analysis.InnerProductSpace.Adjoint | ∀ {𝕜 : Type u_1} [inst : RCLike 𝕜] {H : Type u_5} [inst_1 : NormedAddCommGroup H] [inst_2 : InnerProductSpace 𝕜 H]
[inst_3 : CompleteSpace H] (e : H ≃ₗᵢ[𝕜] H), ↑(Unitary.linearIsometryEquiv.symm e) = ↑e.toContinuousLinearEquiv |
CategoryTheory.Pretriangulated.TriangleOpEquivalence.unitIso | Mathlib.CategoryTheory.Triangulated.Opposite.Triangle | (C : Type u_1) →
[inst : CategoryTheory.Category.{v_1, u_1} C] →
[inst_1 : CategoryTheory.HasShift C ℤ] →
CategoryTheory.Functor.id (CategoryTheory.Pretriangulated.Triangle C)ᵒᵖ ≅
(CategoryTheory.Pretriangulated.TriangleOpEquivalence.functor C).comp
(CategoryTheory.Pretriangulated.TriangleOpEquivalence.inverse C) |
NonUnitalRingHom.rangeRestrict_surjective | Mathlib.RingTheory.NonUnitalSubring.Basic | ∀ {R : Type u} {S : Type v} [inst : NonUnitalNonAssocRing R] [inst_1 : NonUnitalNonAssocRing S] (f : R →ₙ+* S),
Function.Surjective ⇑f.rangeRestrict |
_private.Init.Data.Nat.Power2.Basic.0.Nat.nextPowerOfTwo.go._unary._proof_2 | Init.Data.Nat.Power2.Basic | ∀ (n power : ℕ) (h : power > 0),
power < n →
InvImage (fun x1 x2 => x1 < x2) (fun x => PSigma.casesOn x fun power h => n - power) ⟨power * 2, ⋯⟩ ⟨power, h⟩ |
LowerSet.sdiff_lt_left._simp_1 | Mathlib.Order.UpperLower.Closure | ∀ {α : Type u_1} [inst : Preorder α] {s : LowerSet α} {t : Set α}, (s.sdiff t < s) = ¬Disjoint (↑s) t |
GrpCat.instCreatesLimitsOfSizeUliftFunctor._proof_1 | Mathlib.Algebra.Category.Grp.Ulift | ∀ {J : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} J] {x : CategoryTheory.Functor J GrpCat},
CategoryTheory.Limits.HasLimit x |
WType._sizeOf_1 | Mathlib.Data.W.Basic | {α : Type u_1} → {β : α → Type u_2} → [SizeOf α] → [(a : α) → SizeOf (β a)] → WType β → ℕ |
Std.instDecidableEqRci | Init.Data.Range.Polymorphic.PRange | {α : Type u_1} → [DecidableEq α] → DecidableEq (Std.Rci α) |
Function.LeftInverse.rightInverse_of_surjective | Mathlib.Logic.Function.Basic | ∀ {α : Sort u_1} {β : Sort u_2} {f : α → β} {g : β → α},
Function.LeftInverse f g → Function.Surjective g → Function.RightInverse f g |
_private.Lean.Meta.Tactic.Grind.Proof.0.Lean.Meta.Grind.mkHCongrProof'._unsafe_rec | Lean.Meta.Tactic.Grind.Proof | Lean.Expr → Lean.Expr → ℕ → Lean.Expr → Lean.Expr → Bool → Lean.Meta.Grind.GoalM Lean.Expr |
BooleanSubalgebra.map._proof_3 | Mathlib.Order.BooleanSubalgebra | ∀ {α : Type u_2} {β : Type u_1} [inst : BooleanAlgebra α] [inst_1 : BooleanAlgebra β] (f : BoundedLatticeHom α β)
(L : BooleanSubalgebra α), SupClosed (⇑f '' ↑L) |
real_inner_I_smul_self | Mathlib.Analysis.InnerProductSpace.Basic | ∀ (𝕜 : Type u_1) {E : Type u_2} [inst : RCLike 𝕜] [inst_1 : SeminormedAddCommGroup E] [inst_2 : InnerProductSpace 𝕜 E]
(x : E), inner ℝ x (RCLike.I • x) = 0 |
CategoryTheory.sectionsFunctorNatIsoCoyoneda | Mathlib.CategoryTheory.Yoneda | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
(X : Type (max u₁ u₂)) →
[Unique X] →
CategoryTheory.Functor.sectionsFunctor C ≅
CategoryTheory.coyoneda.obj (Opposite.op ((CategoryTheory.Functor.const C).obj X)) |
WithOne | Mathlib.Algebra.Group.WithOne.Defs | Type u_1 → Type u_1 |
Representation.free | Mathlib.RepresentationTheory.Basic | (k : Type u_6) →
(G : Type u_7) → [inst : CommSemiring k] → [inst_1 : Monoid G] → (α : Type u_8) → Representation k G (α →₀ G →₀ k) |
Lean.Parser.Tactic.Grind.mbtc | Init.Grind.Interactive | Lean.ParserDescr |
Primrec.subtype_val_iff | Mathlib.Computability.Primrec.Basic | ∀ {α : Type u_1} {β : Type u_2} [inst : Primcodable α] [inst_1 : Primcodable β] {p : β → Prop}
[inst_2 : DecidablePred p] {hp : PrimrecPred p} {f : α → Subtype p}, (Primrec fun a => ↑(f a)) ↔ Primrec f |
Lean.Grind.CommRing.Poly.mulMonC.go | Init.Grind.Ring.CommSolver | ℤ → Lean.Grind.CommRing.Mon → ℕ → Lean.Grind.CommRing.Poly → Lean.Grind.CommRing.Poly |
Equiv.simpleGraph._proof_1 | Mathlib.Combinatorics.SimpleGraph.Maps | ∀ {V : Type u_1} {W : Type u_2} (e : V ≃ W) (x : SimpleGraph V),
SimpleGraph.comap (⇑e) (SimpleGraph.comap (⇑e.symm) x) = x |
Path.Homotopy.hcomp._proof_8 | Mathlib.Topology.Homotopy.Path | ∀ {X : Type u_1} [inst : TopologicalSpace X] {x₀ x₁ x₂ : X} {p₀ q₀ : Path x₀ x₁} {p₁ q₁ : Path x₁ x₂}
(F : p₀.Homotopy q₀) (G : p₁.Homotopy q₁),
Continuous fun x => if ↑x.2 ≤ 1 / 2 then (F.eval x.1).extend (2 * ↑x.2) else (G.eval x.1).extend (2 * ↑x.2 - 1) |
Std.DHashMap.Raw.Const.all_eq_false_iff_exists_mem_get | Std.Data.DHashMap.RawLemmas | ∀ {α : Type u} [inst : BEq α] [inst_1 : Hashable α] {β : Type v} {m : Std.DHashMap.Raw α fun x => β} [LawfulBEq α]
{p : α → β → Bool}, m.WF → (m.all p = false ↔ ∃ a, ∃ (h : a ∈ m), p a (Std.DHashMap.Raw.Const.get m a h) = false) |
Lean.Elab.Tactic.ElimApp.Result.motive | Lean.Elab.Tactic.Induction | Lean.Elab.Tactic.ElimApp.Result → Lean.MVarId |
ModularForm.coe_eq_zero_iff._simp_1 | Mathlib.NumberTheory.ModularForms.Basic | ∀ {Γ : Subgroup (GL (Fin 2) ℝ)} {k : ℤ} (f : ModularForm Γ k), (⇑f = 0) = (f = 0) |
Submodule.subtypeₗᵢ_toContinuousLinearMap | Mathlib.Analysis.Normed.Operator.LinearIsometry | ∀ {E : Type u_5} [inst : SeminormedAddCommGroup E] {R' : Type u_11} [inst_1 : Ring R'] [inst_2 : Module R' E]
(p : Submodule R' E), p.subtypeₗᵢ.toContinuousLinearMap = p.subtypeL |
Differential.logDeriv.eq_1 | Mathlib.FieldTheory.Differential.Basic | ∀ {R : Type u_1} [inst : Field R] [inst_1 : Differential R] (a : R), Differential.logDeriv a = a′ / a |
Array.toList_mapFinIdxM | Init.Data.Array.MapIdx | ∀ {m : Type u_1 → Type u_2} {α : Type u_3} {β : Type u_1} [inst : Monad m] [LawfulMonad m] {xs : Array α}
{f : (i : ℕ) → α → i < xs.size → m β}, Array.toList <$> xs.mapFinIdxM f = xs.toList.mapFinIdxM f |
IsCompact.exists_isGLB | Mathlib.Topology.Order.Compact | ∀ {α : Type u_2} [inst : LinearOrder α] [inst_1 : TopologicalSpace α] [ClosedIicTopology α] {s : Set α},
IsCompact s → s.Nonempty → ∃ x ∈ s, IsGLB s x |
_private.Init.Data.Nat.Basic.0.Nat.exists_eq_succ_of_ne_zero.match_1_1 | Init.Data.Nat.Basic | ∀ (motive : (x : ℕ) → x ≠ 0 → Prop) (x : ℕ) (x_1 : x ≠ 0), (∀ (n : ℕ) (x : n + 1 ≠ 0), motive n.succ x) → motive x x_1 |
CategoryTheory.ShortComplex.SnakeInput.Hom.comp | Mathlib.Algebra.Homology.ShortComplex.SnakeLemma | {C : Type u_1} →
[inst : CategoryTheory.Category.{v_1, u_1} C] →
[inst_1 : CategoryTheory.Abelian C] →
{S₁ S₂ S₃ : CategoryTheory.ShortComplex.SnakeInput C} → S₁.Hom S₂ → S₂.Hom S₃ → S₁.Hom S₃ |
CategoryTheory.ReflPrefunctor.«_aux_Mathlib_Combinatorics_Quiver_ReflQuiver___macroRules_CategoryTheory_ReflPrefunctor_term_⥤rq__1» | Mathlib.Combinatorics.Quiver.ReflQuiver | Lean.Macro |
Nat.Pseudoperfect.eq_1 | Mathlib.NumberTheory.FactorisationProperties | ∀ (n : ℕ), n.Pseudoperfect = (0 < n ∧ ∃ s ⊆ n.properDivisors, ∑ i ∈ s, i = n) |
Finset.smul_sum | Mathlib.Algebra.BigOperators.GroupWithZero.Action | ∀ {M : Type u_1} {N : Type u_2} {γ : Type u_3} [inst : AddCommMonoid N] [inst_1 : DistribSMul M N] {r : M} {f : γ → N}
{s : Finset γ}, r • ∑ x ∈ s, f x = ∑ x ∈ s, r • f x |
OrderMonoidIso.val_inv_unitsWithZero_symm_apply | Mathlib.Algebra.Order.Hom.MonoidWithZero | ∀ {α : Type u_6} [inst : Group α] [inst_1 : Preorder α] (a : α), ↑(OrderMonoidIso.unitsWithZero.symm a)⁻¹ = (↑a)⁻¹ |
ContMDiffOn.clm_bundle_apply₂ | Mathlib.Geometry.Manifold.VectorBundle.Hom | ∀ {𝕜 : Type u_1} {B : Type u_2} {F₁ : Type u_3} {F₂ : Type u_4} {F₃ : Type u_5} {M : Type u_6}
[inst : NontriviallyNormedField 𝕜] {n : WithTop ℕ∞} {E₁ : B → Type u_7} [inst_1 : (x : B) → AddCommGroup (E₁ x)]
[inst_2 : (x : B) → Module 𝕜 (E₁ x)] [inst_3 : NormedAddCommGroup F₁] [inst_4 : NormedSpace 𝕜 F₁]
[inst_5 : TopologicalSpace (Bundle.TotalSpace F₁ E₁)] [inst_6 : (x : B) → TopologicalSpace (E₁ x)] {E₂ : B → Type u_8}
[inst_7 : (x : B) → AddCommGroup (E₂ x)] [inst_8 : (x : B) → Module 𝕜 (E₂ x)] [inst_9 : NormedAddCommGroup F₂]
[inst_10 : NormedSpace 𝕜 F₂] [inst_11 : TopologicalSpace (Bundle.TotalSpace F₂ E₂)]
[inst_12 : (x : B) → TopologicalSpace (E₂ x)] {E₃ : B → Type u_9} [inst_13 : (x : B) → AddCommGroup (E₃ x)]
[inst_14 : (x : B) → Module 𝕜 (E₃ x)] [inst_15 : NormedAddCommGroup F₃] [inst_16 : NormedSpace 𝕜 F₃]
[inst_17 : TopologicalSpace (Bundle.TotalSpace F₃ E₃)] [inst_18 : (x : B) → TopologicalSpace (E₃ x)] {EB : Type u_10}
[inst_19 : NormedAddCommGroup EB] [inst_20 : NormedSpace 𝕜 EB] {HB : Type u_11} [inst_21 : TopologicalSpace HB]
{IB : ModelWithCorners 𝕜 EB HB} [inst_22 : TopologicalSpace B] [inst_23 : ChartedSpace HB B] {EM : Type u_12}
[inst_24 : NormedAddCommGroup EM] [inst_25 : NormedSpace 𝕜 EM] {HM : Type u_13} [inst_26 : TopologicalSpace HM]
{IM : ModelWithCorners 𝕜 EM HM} [inst_27 : TopologicalSpace M] [inst_28 : ChartedSpace HM M]
[inst_29 : FiberBundle F₁ E₁] [inst_30 : VectorBundle 𝕜 F₁ E₁] [inst_31 : FiberBundle F₂ E₂]
[inst_32 : VectorBundle 𝕜 F₂ E₂] [inst_33 : FiberBundle F₃ E₃] [inst_34 : ⋯], ⋯ |
CategoryTheory.Limits.BinaryCofan.isColimitMk._proof_2 | Mathlib.CategoryTheory.Limits.Shapes.BinaryProducts | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] {X Y W : C} {inl : X ⟶ W} {inr : Y ⟶ W}
(desc : (s : CategoryTheory.Limits.BinaryCofan X Y) → W ⟶ s.pt),
(∀ (s : CategoryTheory.Limits.BinaryCofan X Y) (m : W ⟶ s.pt),
CategoryTheory.CategoryStruct.comp inl m = s.inl →
CategoryTheory.CategoryStruct.comp inr m = s.inr → m = desc s) →
∀ (s : CategoryTheory.Limits.Cocone (CategoryTheory.Limits.pair X Y))
(m : (CategoryTheory.Limits.BinaryCofan.mk inl inr).pt ⟶ s.pt),
(∀ (j : CategoryTheory.Discrete CategoryTheory.Limits.WalkingPair),
CategoryTheory.CategoryStruct.comp ((CategoryTheory.Limits.BinaryCofan.mk inl inr).ι.app j) m = s.ι.app j) →
m = desc s |
Finsupp.lsingle_range_le_ker_lapply | Mathlib.LinearAlgebra.Finsupp.Span | ∀ {α : Type u_1} {M : Type u_2} {R : Type u_5} [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M]
(s t : Set α), Disjoint s t → ⨆ a ∈ s, (Finsupp.lsingle a).range ≤ ⨅ a ∈ t, (Finsupp.lapply a).ker |
CategoryTheory.ShortComplex.homMk_τ₁ | Mathlib.Algebra.Homology.ShortComplex.Basic | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
{S₁ S₂ : CategoryTheory.ShortComplex C} (τ₁ : S₁.X₁ ⟶ S₂.X₁) (τ₂ : S₁.X₂ ⟶ S₂.X₂) (τ₃ : S₁.X₃ ⟶ S₂.X₃)
(comm₁₂ : CategoryTheory.CategoryStruct.comp τ₁ S₂.f = CategoryTheory.CategoryStruct.comp S₁.f τ₂)
(comm₂₃ : CategoryTheory.CategoryStruct.comp τ₂ S₂.g = CategoryTheory.CategoryStruct.comp S₁.g τ₃),
(CategoryTheory.ShortComplex.homMk τ₁ τ₂ τ₃ comm₁₂ comm₂₃).τ₁ = τ₁ |
Matroid.IsCircuit.eq_fundCircuit_of_subset | Mathlib.Combinatorics.Matroid.Circuit | ∀ {α : Type u_1} {M : Matroid α} {C I : Set α} {e : α},
M.IsCircuit C → M.Indep I → C ⊆ insert e I → C = M.fundCircuit e I |
LieDerivation.exp_map_apply | Mathlib.Algebra.Lie.Derivation.Basic | ∀ {R : Type u_1} {L : Type u_2} [inst : CommRing R] [inst_1 : LieRing L] [inst_2 : LieAlgebra R L]
[inst_3 : LieAlgebra ℚ L] (D : LieDerivation R L L) (h : IsNilpotent ↑D) (l : L), (D.exp h) l = (IsNilpotent.exp ↑D) l |
Lean.Elab.Structural.EqnInfo._sizeOf_1 | Lean.Elab.PreDefinition.Structural.Eqns | Lean.Elab.Structural.EqnInfo → ℕ |
Std.IterM.Equiv.of_morphism | Std.Data.Iterators.Lemmas.Equivalence.Basic | ∀ {α₁ α₂ : Type w} {m : Type w → Type w'} [inst : Monad m] [inst_1 : LawfulMonad m] {β : Type w}
[inst_2 : Std.Iterator α₁ m β] [inst_3 : Std.Iterator α₂ m β] (ita : Std.IterM m β)
(f : Std.IterM m β → Std.IterM m β),
(∀ (it : Std.IterM m β), (f it).stepAsHetT = Std.IterStep.mapIterator f <$> it.stepAsHetT) → ita.Equiv (f ita) |
MonadReaderOf.read | Init.Prelude | {ρ : semiOutParam (Type u)} → {m : Type u → Type v} → [self : MonadReaderOf ρ m] → m ρ |
Ideal.Pure.eq_1 | Mathlib.RingTheory.Ideal.Pure | ∀ {R : Type u_1} [inst : CommRing R] (I : Ideal R), I.Pure = Module.Flat R (R ⧸ I) |
Asymptotics.transIsEquivalentIsLittleO | Mathlib.Analysis.Asymptotics.AsymptoticEquivalent | {α : Type u_1} →
{β : Type u_2} →
{β₂ : Type u_3} →
[inst : NormedAddCommGroup β] →
[inst_1 : Norm β₂] →
{l : Filter α} → Trans (Asymptotics.IsEquivalent l) (Asymptotics.IsLittleO l) (Asymptotics.IsLittleO l) |
CategoryTheory.PreOneHypercover.cylinder_X | Mathlib.CategoryTheory.Sites.Hypercover.Homotopy | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {S : C} {E : CategoryTheory.PreOneHypercover S}
{F : CategoryTheory.PreOneHypercover S} [inst_1 : CategoryTheory.Limits.HasPullbacks C] (f g : E.Hom F)
(p : (i : E.I₀) × F.I₁ (f.s₀ i) (g.s₀ i)),
(CategoryTheory.PreOneHypercover.cylinder f g).X p = CategoryTheory.PreOneHypercover.cylinderX f g p.snd |
CategoryTheory.CostructuredArrow.ιCompGrothendieckPrecompFunctorToCommaCompFst_hom_app | Mathlib.CategoryTheory.Comma.StructuredArrow.Functor | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
{E : Type u₃} [inst_2 : CategoryTheory.Category.{v₃, u₃} E] (L : CategoryTheory.Functor C D)
(R : CategoryTheory.Functor E D) (X : E) (X_1 : ↑((R.comp (CategoryTheory.CostructuredArrow.functor L)).obj X)),
(CategoryTheory.CostructuredArrow.ιCompGrothendieckPrecompFunctorToCommaCompFst L R X).hom.app X_1 =
CategoryTheory.CategoryStruct.id X_1.left |
Homeomorph.ext | Mathlib.Topology.Homeomorph.Defs | ∀ {X : Type u_1} {Y : Type u_2} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y] {h h' : X ≃ₜ Y},
(∀ (x : X), h x = h' x) → h = h' |
Std.DHashMap.Internal.Raw₀.Const.getKeyD_filter | Std.Data.DHashMap.Internal.RawLemmas | ∀ {α : Type u} [inst : BEq α] [inst_1 : Hashable α] {β : Type v} (m : Std.DHashMap.Internal.Raw₀ α fun x => β)
[inst_2 : EquivBEq α] [inst_3 : LawfulHashable α] {f : α → β → Bool} {k fallback : α} (h : (↑m).WF),
(Std.DHashMap.Internal.Raw₀.filter f m).getKeyD k fallback =
((m.getKey? k).pfilter fun x h' => f x (Std.DHashMap.Internal.Raw₀.Const.get m x ⋯)).getD fallback |
Submodule.IsLattice.smul | Mathlib.Algebra.Module.Lattice | ∀ {R : Type u_1} [inst : CommRing R] (A : Type u_2) [inst_1 : CommRing A] [inst_2 : Algebra R A] {V : Type u_3}
[inst_3 : AddCommGroup V] [inst_4 : Module R V] [inst_5 : Module A V] [inst_6 : IsScalarTower R A V]
(M : Submodule R V) [Submodule.IsLattice A M] (a : Aˣ), Submodule.IsLattice A (a • M) |
Algebra.Generators.localizationAway._proof_5 | Mathlib.RingTheory.Extension.Generators | ∀ {R : Type u_1} (S : Type u_2) [inst : CommRing R] [inst_1 : CommRing S] [inst_2 : Algebra R S] (r : R)
[inst_3 : IsLocalization.Away r S],
algebraMap (MvPolynomial Unit R) S = ↑(MvPolynomial.aeval fun x => IsLocalization.Away.invSelf r) |
TensorProduct.mapOfCompatibleSMul | Mathlib.LinearAlgebra.TensorProduct.Basic | (R : Type u_1) →
[inst : CommSemiring R] →
(A : Type u_6) →
(M : Type u_7) →
(N : Type u_8) →
[inst_1 : AddCommMonoid M] →
[inst_2 : AddCommMonoid N] →
[inst_3 : Module R M] →
[inst_4 : Module R N] →
[inst_5 : CommSemiring A] →
[inst_6 : Module A M] →
[inst_7 : Module A N] →
[inst_8 : SMulCommClass R A M] →
[TensorProduct.CompatibleSMul R A M N] → TensorProduct A M N →ₗ[A] TensorProduct R M N |
_private.Mathlib.Algebra.Homology.SpectralSequence.ComplexShape.0.ComplexShape.spectralSequenceFin._proof_4 | Mathlib.Algebra.Homology.SpectralSequence.ComplexShape | ∀ (l : ℕ) (u : ℤ × ℤ) {i i' j : ℤ × Fin l},
i.1 + u.1 = j.1 ∧ ↑↑i.2 + u.2 = ↑↑j.2 → i'.1 + u.1 = j.1 ∧ ↑↑i'.2 + u.2 = ↑↑j.2 → i.1 = i'.1 |
_private.Mathlib.Data.Nat.Factorial.Basic.0.Nat.pow_sub_le_descFactorial.match_1_1 | Mathlib.Data.Nat.Factorial.Basic | ∀ (motive : ℕ → Prop) (x : ℕ), (∀ (a : Unit), motive 0) → (∀ (k : ℕ), motive k.succ) → motive x |
BitVec.toNat_shiftConcat_eq_of_lt | Init.Data.BitVec.Lemmas | ∀ {w : ℕ} {x : BitVec w} {b : Bool} {k : ℕ}, k < w → x.toNat < 2 ^ k → (x.shiftConcat b).toNat = x.toNat * 2 + b.toNat |
CategoryTheory.Limits.MulticospanIndex.sectionsEquiv._proof_3 | Mathlib.CategoryTheory.Limits.Types.Multiequalizer | ∀ {J : CategoryTheory.Limits.MulticospanShape} (I : CategoryTheory.Limits.MulticospanIndex J (Type u_1))
(s : I.sections),
(fun i =>
match i with
| CategoryTheory.Limits.WalkingMulticospan.left i => s.val i
| CategoryTheory.Limits.WalkingMulticospan.right j => I.fst j (s.val (J.fst j))) ∈
I.multicospan.sections |
MeasureTheory.ComplexMeasure.absolutelyContinuous_ennreal_iff | Mathlib.MeasureTheory.Measure.Complex | ∀ {α : Type u_1} {m : MeasurableSpace α} (c : MeasureTheory.ComplexMeasure α)
(μ : MeasureTheory.VectorMeasure α ENNReal),
MeasureTheory.VectorMeasure.AbsolutelyContinuous c μ ↔
MeasureTheory.VectorMeasure.AbsolutelyContinuous (MeasureTheory.ComplexMeasure.re c) μ ∧
MeasureTheory.VectorMeasure.AbsolutelyContinuous (MeasureTheory.ComplexMeasure.im c) μ |
IsSymmetricRel.iInter | Mathlib.Topology.UniformSpace.Defs | ∀ {α : Type ua} {ι : Sort u_1} {U : ι → SetRel α α}, (∀ (i : ι), IsSymmetricRel (U i)) → IsSymmetricRel (⋂ i, U i) |
_private.Lean.Compiler.LCNF.JoinPoints.0.Lean.Compiler.LCNF.JoinPointFinder.removeCandidatesInArg | Lean.Compiler.LCNF.JoinPoints | Lean.Compiler.LCNF.Arg Lean.Compiler.LCNF.Purity.pure → Lean.Compiler.LCNF.JoinPointFinder.FindM Unit |
Polynomial.zero_of_eval_zero | Mathlib.Algebra.Polynomial.Roots | ∀ {R : Type u} [inst : CommRing R] [IsDomain R] [Infinite R] (p : Polynomial R),
(∀ (x : R), Polynomial.eval x p = 0) → p = 0 |
RingQuot.definition._@.Mathlib.Algebra.RingQuot.3673095128._hygCtx._hyg.2 | Mathlib.Algebra.RingQuot | (S : Type uS) →
[inst : CommSemiring S] →
{A : Type uA} → [inst_1 : Semiring A] → [inst_2 : Algebra S A] → (s : A → A → Prop) → A →ₐ[S] RingQuot s |
Set.NPow | Mathlib.Algebra.Group.Pointwise.Set.Basic | {α : Type u_2} → [One α] → [Mul α] → Pow (Set α) ℕ |
Std.TreeSet.Raw.instSliceableRccSlice | Std.Data.TreeSet.Raw.Slice | {α : Type u} →
(cmp : autoParam (α → α → Ordering) Std.TreeSet.Raw.instSliceableRccSlice._auto_1) →
Std.Rcc.Sliceable (Std.TreeSet.Raw α cmp) α (Std.DTreeMap.Internal.Unit.RccSlice α) |
Lean.Elab.Tactic.BVDecide.Frontend.Normalize.MatchKind.enumWithDefault.elim | Lean.Elab.Tactic.BVDecide.Frontend.Normalize.Basic | {motive : Lean.Elab.Tactic.BVDecide.Frontend.Normalize.MatchKind → Sort u} →
(t : Lean.Elab.Tactic.BVDecide.Frontend.Normalize.MatchKind) →
t.ctorIdx = 1 →
((info : Lean.InductiveVal) →
(ctors : Array Lean.ConstructorVal) →
motive (Lean.Elab.Tactic.BVDecide.Frontend.Normalize.MatchKind.enumWithDefault info ctors)) →
motive t |
Finset.one_le_divConst_self | Mathlib.Combinatorics.Additive.DoublingConst | ∀ {G : Type u_1} [inst : Group G] [inst_1 : DecidableEq G] {A : Finset G}, A.Nonempty → 1 ≤ A.divConst A |
Lean.Meta.StructProjDecl._sizeOf_inst | Lean.Meta.Structure | SizeOf Lean.Meta.StructProjDecl |
OpenPartialHomeomorph.ofSet_symm | Mathlib.Topology.OpenPartialHomeomorph.IsImage | ∀ {X : Type u_1} [inst : TopologicalSpace X] {s : Set X} (hs : IsOpen s),
(OpenPartialHomeomorph.ofSet s hs).symm = OpenPartialHomeomorph.ofSet s hs |
Std.Time.Database.TZdb.inst.match_1 | Std.Time.Zoned.Database.TZdb | (motive : Option String → Sort u_1) →
(env : Option String) → ((path : String) → motive (some path)) → ((x : Option String) → motive x) → motive env |
_private.Mathlib.RingTheory.MvPolynomial.WeightedHomogeneous.0.MvPolynomial.weightedHomogeneousComponent_finsupp._simp_1_2 | Mathlib.RingTheory.MvPolynomial.WeightedHomogeneous | ∀ {α : Sort u_1} {p : α → Prop}, (¬∃ x, p x) = ∀ (x : α), ¬p x |
_private.Mathlib.Topology.LocallyFinite.0.LocallyFinite.closure_iUnion._simp_1_1 | Mathlib.Topology.LocallyFinite | ∀ {X : Type u} [inst : TopologicalSpace X] {x : X} {s : Set X}, (x ∈ closure s) = (nhdsWithin x s).NeBot |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.