name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
AddEquiv.mk.sizeOf_spec | Mathlib.Algebra.Group.Equiv.Defs | ∀ {A : Type u_9} {B : Type u_10} [inst : Add A] [inst_1 : Add B] [inst_2 : SizeOf A] [inst_3 : SizeOf B]
(toEquiv : A ≃ B) (map_add' : ∀ (x y : A), toEquiv.toFun (x + y) = toEquiv.toFun x + toEquiv.toFun y),
sizeOf { toEquiv := toEquiv, map_add' := map_add' } = 1 + sizeOf toEquiv | null | true |
HomotopicalAlgebra.LeftHomotopyRel.postcomp | Mathlib.AlgebraicTopology.ModelCategory.LeftHomotopy | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {X Y : C}
[inst_1 : HomotopicalAlgebra.CategoryWithWeakEquivalences C] {f g : X ⟶ Y},
HomotopicalAlgebra.LeftHomotopyRel f g →
∀ {Z : C} (p : Y ⟶ Z),
HomotopicalAlgebra.LeftHomotopyRel (CategoryTheory.CategoryStruct.comp f p)
(CategoryTheory... | null | true |
_private.Init.Data.String.Basic.0.String.Pos.toSlice_le._simp_1_1 | Init.Data.String.Basic | ∀ {s : String.Slice} {l r : s.Pos}, (l ≤ r) = (l.offset ≤ r.offset) | null | false |
HomologicalComplex₂.D₁_totalShift₂XIso_hom | Mathlib.Algebra.Homology.TotalComplexShift | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Preadditive C]
(K : HomologicalComplex₂ C (ComplexShape.up ℤ) (ComplexShape.up ℤ)) (y : ℤ) [inst_2 : K.HasTotal (ComplexShape.up ℤ)]
(n₀ n₁ n₀' n₁' : ℤ) (h₀ : n₀ + y = n₀') (h₁ : n₁ + y = n₁'),
CategoryTheory.CategoryStruct.co... | null | true |
ByteArray.extract_eq_empty_iff | Init.Data.ByteArray.Lemmas | ∀ {b : ByteArray} {i j : ℕ}, b.extract i j = ByteArray.empty ↔ min j b.size ≤ i | null | true |
Lean.instInhabitedAuxParentProjectionInfo.default | Lean.ProjFns | Lean.AuxParentProjectionInfo | null | true |
_private.Mathlib.Analysis.Calculus.BumpFunction.FiniteDimension.0.IsOpen.exists_contDiff_support_eq._simp_1_1 | Mathlib.Analysis.Calculus.BumpFunction.FiniteDimension | ∀ {α : Type u_1} {a : α} {s : Set α}, ({a} ⊆ s) = (a ∈ s) | null | false |
Mathlib.Tactic.Coherence._aux_Mathlib_Tactic_CategoryTheory_Coherence___elabRules_Mathlib_Tactic_Coherence_pure_coherence_internal_1 | Mathlib.Tactic.CategoryTheory.Coherence | Lean.Elab.Tactic.Tactic | The same as `pure_coherence`, but used internally in `coherence` without the warning. | false |
_private.Aesop.Forward.State.0.Aesop.instBEqRawHyp.beq.match_1 | Aesop.Forward.State | (motive : Aesop.RawHyp → Aesop.RawHyp → Sort u_1) →
(x x_1 : Aesop.RawHyp) →
((a b : Lean.FVarId) → motive (Aesop.RawHyp.fvarId a) (Aesop.RawHyp.fvarId b)) →
((a b : Aesop.Substitution) → motive (Aesop.RawHyp.patSubst a) (Aesop.RawHyp.patSubst b)) →
((x x_2 : Aesop.RawHyp) → motive x x_2) → motive x... | null | false |
CategoryTheory.Monad.id._proof_1 | Mathlib.CategoryTheory.Monad.Basic | ∀ (C : Type u_2) [inst : CategoryTheory.Category.{u_1, u_2} C] (X : C),
CategoryTheory.CategoryStruct.comp
((CategoryTheory.Functor.id C).map ((CategoryTheory.CategoryStruct.id (CategoryTheory.Functor.id C)).app X))
((CategoryTheory.CategoryStruct.id (CategoryTheory.Functor.id C)).app X) =
CategoryThe... | null | false |
ProbabilityTheory.IndepFun.map_mul_eq_map_mconv_map₀ | Mathlib.Probability.Independence.Basic | ∀ {Ω : Type u_7} {mΩ : MeasurableSpace Ω} {μ : MeasureTheory.Measure Ω} {M : Type u_10} [inst : Monoid M]
[inst_1 : MeasurableSpace M] [MeasurableMul₂ M] [MeasureTheory.IsFiniteMeasure μ] {f g : Ω → M},
AEMeasurable f μ →
AEMeasurable g μ →
ProbabilityTheory.IndepFun f g μ →
MeasureTheory.Measure.... | null | true |
AEMeasurable.fun_inf | Mathlib.MeasureTheory.Order.Lattice | ∀ {M : Type u_1} [inst : MeasurableSpace M] {α : Type u_2} {m : MeasurableSpace α} {μ : MeasureTheory.Measure α}
{f g : α → M} [inst_1 : Min M] [MeasurableInf₂ M],
AEMeasurable f μ → AEMeasurable g μ → AEMeasurable (fun i => f i ⊓ g i) μ | Eta-expanded form of `AEMeasurable.inf` | true |
_private.Batteries.Data.AssocList.Lemmas.0.Batteries.AssocList.beq.match_1.splitter | Batteries.Data.AssocList.Lemmas | {α : Type u_1} →
{β : Type u_2} →
(motive : Batteries.AssocList α β → Batteries.AssocList α β → Sort u_3) →
(x x_1 : Batteries.AssocList α β) →
(Unit → motive Batteries.AssocList.nil Batteries.AssocList.nil) →
((key : α) →
(value : β) →
(tail : Batteries.Assoc... | null | true |
multiplicity_addValuation_apply | Mathlib.RingTheory.Valuation.PrimeMultiplicity | ∀ {R : Type u_1} [inst : CommRing R] [inst_1 : IsDomain R] {p : R} {hp : Prime p} {r : R},
(multiplicity_addValuation hp) r = emultiplicity p r | null | true |
ContDiffAt.exists_forall_mem_closedBall_exists_eq_forall_mem_Ioo_hasDerivAt | Mathlib.Analysis.ODE.ExistUnique | ∀ {E : Type u_1} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E] [CompleteSpace E] {f : E → E} {x₀ : E},
ContDiffAt ℝ 1 f x₀ →
∀ (t₀ : ℝ),
∃ r > 0,
∃ ε > 0, ∀ x ∈ Metric.closedBall x₀ r, ∃ α, α t₀ = x ∧ ∀ t ∈ Set.Ioo (t₀ - ε) (t₀ + ε), HasDerivAt α (f (α t)) t | If a vector field `f : E → E` is continuously differentiable at `x₀ : E`, then it admits an
integral curve `α : ℝ → E` defined on an open interval, with initial condition `α t₀ = x`, where
`x` may be different from `x₀`. | true |
Path.Homotopy.transAssoc._proof_4 | Mathlib.AlgebraicTopology.FundamentalGroupoid.Basic | ⟨Path.Homotopy.transAssocReparamAux 1, Path.Homotopy.transAssoc._proof_3⟩ = 1 | null | false |
Std.Tactic.BVDecide.Normalize.BitVec.beq_one_eq_ite' | Std.Tactic.BVDecide.Normalize.Bool | ∀ {b : Bool} {a : BitVec 1}, (b == (a == 1#1)) = (a == bif b then 1#1 else 0#1) | null | true |
HasFibers.instFaithfulFibι | Mathlib.CategoryTheory.FiberedCategory.HasFibers | ∀ {𝒮 : Type u₁} {𝒳 : Type u₂} [inst : CategoryTheory.Category.{v₁, u₁} 𝒮] [inst_1 : CategoryTheory.Category.{v₂, u₂} 𝒳]
(p : CategoryTheory.Functor 𝒳 𝒮) [inst_2 : HasFibers p] (S : 𝒮), (HasFibers.ι S).Faithful | null | true |
CategoryTheory.InjectiveResolution.toRightDerivedZero'._proof_2 | Mathlib.CategoryTheory.Abelian.RightDerived | ∀ {C : Type u_4} [inst : CategoryTheory.Category.{u_3, u_4} C] {D : Type u_2}
[inst_1 : CategoryTheory.Category.{u_1, u_2} D] [inst_2 : CategoryTheory.Abelian C]
[inst_3 : CategoryTheory.Abelian D] {X : C} (P : CategoryTheory.InjectiveResolution X)
(F : CategoryTheory.Functor C D) [inst_4 : F.Additive],
Categor... | null | false |
instCategoryCompactum._proof_9 | Mathlib.Topology.Category.Compactum | autoParam
(∀ {W X Y Z : Compactum} (f : W ⟶ X) (g : X ⟶ Y) (h : Y ⟶ Z),
CategoryTheory.CategoryStruct.comp (CategoryTheory.CategoryStruct.comp f g) h =
CategoryTheory.CategoryStruct.comp f (CategoryTheory.CategoryStruct.comp g h))
CategoryTheory.Category.assoc._autoParam | null | false |
CategoryTheory.ParametrizedAdjunction.rec | Mathlib.CategoryTheory.Adjunction.Parametrized | {C₁ : Type u₁} →
{C₂ : Type u₂} →
{C₃ : Type u₃} →
[inst : CategoryTheory.Category.{v₁, u₁} C₁] →
[inst_1 : CategoryTheory.Category.{v₂, u₂} C₂] →
[inst_2 : CategoryTheory.Category.{v₃, u₃} C₃] →
{F : CategoryTheory.Functor C₁ (CategoryTheory.Functor C₂ C₃)} →
{G ... | null | false |
Turing.PartrecToTM2.tr.eq_2 | Mathlib.Computability.TuringMachine.ToPartrec | ∀ (k : Turing.PartrecToTM2.K') (f : Option Turing.PartrecToTM2.Γ' → Option Turing.PartrecToTM2.Γ')
(q : Turing.PartrecToTM2.Λ'),
Turing.PartrecToTM2.tr (Turing.PartrecToTM2.Λ'.push k f q) =
Turing.TM2.Stmt.branch (fun s => (f s).isSome)
(Turing.TM2.Stmt.push k (fun s => (f s).getD default) (Turing.TM2.Stm... | null | true |
Std.DTreeMap.getKeyD_minKey! | Std.Data.DTreeMap.Lemmas | ∀ {α : Type u} {β : α → Type v} {cmp : α → α → Ordering} {t : Std.DTreeMap α β cmp} [Std.TransCmp cmp]
[inst : Inhabited α], t.isEmpty = false → ∀ {fallback : α}, t.getKeyD t.minKey! fallback = t.minKey! | null | true |
PMF.seq.eq_1 | Mathlib.Probability.ProbabilityMassFunction.Constructions | ∀ {α : Type u_1} {β : Type u_2} (q : PMF (α → β)) (p : PMF α), q.seq p = q.bind fun m => p.bind fun a => PMF.pure (m a) | null | true |
Lean.Linter.CodeQuality.Entry.mk._flat_ctor | Lean.Linter.CodeQuality.Basic | String → Lean.Linter.CodeQuality.Source → Lean.Linter.CodeQuality.Value → Lean.Linter.CodeQuality.Entry | null | false |
Equiv.addEquiv._proof_1 | Mathlib.Algebra.Group.TransferInstance | ∀ {α : Type u_2} {β : Type u_1} (e : α ≃ β) [inst : Add β] (x y : α), e.toFun (x + y) = e.toFun x + e.toFun y | null | false |
_private.Mathlib.Combinatorics.SimpleGraph.Walk.Subwalks.0.SimpleGraph.Walk.take_isSubwalk_take._simp_1_2 | Mathlib.Combinatorics.SimpleGraph.Walk.Subwalks | ∀ {α : Type u_1} {l₁ l₂ : List α}, l₁ <+: l₂ → (l₁ <:+: l₂) = True | null | false |
CategoryTheory.yonedaAddMon._proof_5 | Mathlib.CategoryTheory.Monoidal.Cartesian.Mon | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.CartesianMonoidalCategory C]
(x : CategoryTheory.AddMon C),
{
app := fun x_1 =>
AddMonCat.ofHom
(CategoryTheory.IsAddMonHom.addMonoidHom (CategoryTheory.CategoryStruct.id x).hom (Opposite.unop x_1)),
... | null | false |
SupIrred.ne_bot | Mathlib.Order.Irreducible | ∀ {α : Type u_2} [inst : SemilatticeSup α] {a : α} [inst_1 : OrderBot α], SupIrred a → a ≠ ⊥ | null | true |
HomologicalComplex.mapBifunctor₂₃.d₃_eq | Mathlib.Algebra.Homology.BifunctorAssociator | ∀ {C₁ : Type u_1} {C₂ : Type u_2} {C₂₃ : Type u_4} {C₃ : Type u_5} {C₄ : Type u_6}
[inst : CategoryTheory.Category.{v_1, u_1} C₁] [inst_1 : CategoryTheory.Category.{v_2, u_2} C₂]
[inst_2 : CategoryTheory.Category.{v_3, u_5} C₃] [inst_3 : CategoryTheory.Category.{v_4, u_6} C₄]
[inst_4 : CategoryTheory.Category.{v_... | null | true |
Set.nonempty_sInter._simp_1 | Mathlib.Data.Set.Lattice.Bounded | ∀ {α : Type u_1} {c : Set (Set α)}, (⋂₀ c).Nonempty = ∃ a, ∀ b ∈ c, a ∈ b | null | false |
_private.Mathlib.RingTheory.Valuation.ValuationSubring.0.ValuationSubring.ofPrime_idealOfLE._simp_1_2 | Mathlib.RingTheory.Valuation.ValuationSubring | ∀ {M : Type u_1} [inst : MulOneClass M] {s : Subsemigroup M} {x : M} (h_one : 1 ∈ s.carrier),
(x ∈ { toSubsemigroup := s, one_mem' := h_one }) = (x ∈ s) | null | false |
DirSupInaccOn | Mathlib.Order.DirSupClosed | {α : Type u_1} → [Preorder α] → Set (Set α) → Set α → Prop | A predicate for a set which is inaccessible by directed suprema of nonempty sets in `D`.
This is the complement of a `DirSupClosedOn` set. | true |
extDeriv_apply_vectorField_of_pairwise_commute | Mathlib.Analysis.Calculus.DifferentialForm.VectorField | ∀ {𝕜 : 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] {n : ℕ} {x : E}
{ω : E → E [⋀^Fin n]→L[𝕜] F} {V : Fin (n + 1) → E → E},
DifferentiableAt 𝕜 ω x →
(∀ (i :... | Let `ω` be a differentiable `n`-form and `V i` be `n + 1` differentiable vector fields.
If `V i` pairwise commute at `x`, i.e., $[V_i, V_j](x) = 0$ for all `i ≠ j`, then
$$
dω(V_0(x), \dots, V_{n + 1}(x)) = \sum_{i=0}^{n + 1} (-1)^i •
D_x\left(ω\big(x; V_0(x), \dots, \widehat{V_i(x)}, \dots, V_{n + 1}(x)\big)\ri... | true |
Convexity.StdSimplex | Mathlib.Geometry.Convex.ConvexSpace.Defs | (R : Type u) → [LE R] → [AddCommMonoid R] → [One R] → Type v → Type (max u v) | The space of nonnegative functions `X → R` which take finitely many non-zero values summing
to 1.
One can interpret this as the standard simplex in `R^⊕X` (`R^X` for finite `X`), with the embedding
being the map `weights : StdSimplex R X → R^⊕X`.
Note in particular that, in the common case where `X := M` is a `R`-mod... | true |
_private.Mathlib.Analysis.SpecialFunctions.Complex.Circle.0.Circle.not_isPreconnected_compl_pair._simp_1_1 | Mathlib.Analysis.SpecialFunctions.Complex.Circle | ∀ {α : Type u} [inst : TopologicalSpace α] {s : Set α},
IsPreconnected s = ∀ (u v : Set α), IsClosed u → IsClosed v → s ⊆ u ∪ v → s ∩ (u ∩ v) = ∅ → s ⊆ u ∨ s ⊆ v | null | false |
RBTree.RBSet.isEmpty_iff_toList_eq_nil | Batteries.Recycling.RBTree.Lemmas | ∀ {α : Type u_1} {cmp : α → α → Ordering} {t : RBTree.RBSet α cmp}, t.isEmpty = true ↔ t.toList = [] | null | true |
BitVec.toNat_cpop_concat | Init.Data.BitVec.Lemmas | ∀ {w : ℕ} {x : BitVec w} {b : Bool}, (x.concat b).cpop.toNat = b.toNat + x.cpop.toNat | null | true |
Polynomial.recOnHorner._unary._proof_15 | Mathlib.Algebra.Polynomial.Inductions | ∀ {R : Type u_2} [inst : Semiring R] {M : Polynomial R → Sort u_1} (p : Polynomial R),
M (p.divX * Polynomial.X + Polynomial.C 0) = M (p.divX * Polynomial.X + 0) | null | false |
Aesop.instInhabitedNormalizationState.default | Aesop.Tree.Data | Aesop.NormalizationState | null | true |
_private.Std.Data.DHashMap.Lemmas.0.Std.DHashMap.mem_alter._simp_1_1 | Std.Data.DHashMap.Lemmas | ∀ {α : Type u} {β : α → Type v} {x : BEq α} {x_1 : Hashable α} {m : Std.DHashMap α β} {a : α},
(a ∈ m) = (m.contains a = true) | null | false |
DifferentiableOn.mul_const | Mathlib.Analysis.Calculus.FDeriv.Mul | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {s : Set E} {𝔸 : Type u_4} [inst_3 : NormedRing 𝔸] [inst_4 : NormedAlgebra 𝕜 𝔸]
{a : E → 𝔸}, DifferentiableOn 𝕜 a s → ∀ (b : 𝔸), DifferentiableOn 𝕜 (fun y => a y * b) s | null | true |
CategoryTheory.Limits.KernelFork.IsLimit.ofιUnop._proof_4 | Mathlib.CategoryTheory.Limits.Shapes.Opposites.Kernels | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
{K X Y : Cᵒᵖ} (i : K ⟶ X) {f : X ⟶ Y} (w : CategoryTheory.CategoryStruct.comp i f = 0)
(h : CategoryTheory.Limits.IsLimit (CategoryTheory.Limits.KernelFork.ofι i w)) {Z' : C} (x : Opposite.unop X ⟶ Z')... | null | false |
FiniteField.frobeniusAlgEquiv._proof_1 | Mathlib.FieldTheory.Finite.Basic | ∀ (K : Type u_2) (R : Type u_1) [inst : Field K] [inst_1 : Fintype K] [inst_2 : CommRing R] [inst_3 : Algebra K R]
(p : ℕ) [ExpChar R p] [PerfectRing R p], Function.Bijective ⇑(FiniteField.frobeniusAlgHom K R) | null | false |
UniformSpace.Completion.extensionHom._proof_2 | Mathlib.Topology.Algebra.UniformRing | ∀ {α : Type u_2} [inst : Ring α] {β : Type u_1} [inst_1 : Ring β], AddMonoidHomClass (α →+* β) α β | null | false |
_private.Mathlib.Order.Cover.0.WithTop.covBy_top_iff._simp_1_2 | Mathlib.Order.Cover | ∀ {α : Type u_1} {p : WithTop α → Prop}, (∀ (x : WithTop α), p x) = (p ⊤ ∧ ∀ (x : α), p ↑x) | null | false |
_private.Lean.Data.FuzzyMatching.0.Lean.FuzzyMatching.Score | Lean.Data.FuzzyMatching | Type | Represents a fuzzy matching score where `Score.awful` is the worst score possible. | true |
_private.Qq.Macro.0.Qq.Impl.quoteExpr.match_1 | Qq.Macro | (motive : Qq.Impl.ExprBackSubstResult → Sort u_1) →
(r : Qq.Impl.ExprBackSubstResult) →
((r : Lean.Expr) → motive (Qq.Impl.ExprBackSubstResult.quoted r)) →
((r : Lean.Expr) → motive (Qq.Impl.ExprBackSubstResult.unquoted r)) → motive r | null | false |
FreeLieAlgebra.lift_of_apply | Mathlib.Algebra.Lie.Free | ∀ {R : Type u} {X : Type v} [inst : CommRing R] {L : Type w} [inst_1 : LieRing L] [inst_2 : LieAlgebra R L] (f : X → L)
(x : X), ((FreeLieAlgebra.lift R) f) (FreeLieAlgebra.of R x) = f x | null | true |
CategoryTheory.SplitMono | Mathlib.CategoryTheory.EpiMono | {C : Type u₁} → [inst : CategoryTheory.Category.{v₁, u₁} C] → {X Y : C} → (X ⟶ Y) → Type v₁ | A split monomorphism is a morphism `f : X ⟶ Y` with a given retraction `retraction f : Y ⟶ X`
such that `f ≫ retraction f = 𝟙 X`.
Every split monomorphism is a monomorphism.
| true |
instAlgebraUniversalEnvelopingAlgebra._aux_1 | Mathlib.Algebra.Lie.UniversalEnveloping | (R : Type u_1) →
(L : Type u_2) →
[inst : CommRing R] →
[inst_1 : LieRing L] →
[inst_2 : LieAlgebra R L] → R → UniversalEnvelopingAlgebra R L → UniversalEnvelopingAlgebra R L | null | false |
MDifferentiableWithinAt.prodMap' | Mathlib.Geometry.Manifold.MFDeriv.SpecificFunctions | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {H : Type u_3} [inst_3 : TopologicalSpace H] {I : ModelWithCorners 𝕜 E H} {M : Type u_4}
[inst_4 : TopologicalSpace M] [inst_5 : ChartedSpace H M] {E' : Type u_5} [inst_6 : NormedAddComm... | The product map of two `C^n` functions within a set at a point is `C^n`
within the product set at the product point. | true |
CategoryTheory.Localization.Construction.morphismProperty_eq_top' | Mathlib.CategoryTheory.Localization.Construction | ∀ {C : Type uC} [inst : CategoryTheory.Category.{uC', uC} C] {W : CategoryTheory.MorphismProperty C}
(P : CategoryTheory.MorphismProperty W.Localization) [P.IsStableUnderComposition],
(∀ ⦃X Y : C⦄ (f : X ⟶ Y), P (W.Q.map f)) → (∀ ⦃X Y : W.Localization⦄ (e : X ≅ Y), P e.hom → P e.inv) → P = ⊤ | A `MorphismProperty` in `W.Localization` is satisfied by all
morphisms in the localized category if it contains the image of the
morphisms in the original category, if is stable under composition
and if the property is stable by passing to inverses. | true |
FreeGroup.of_ne_one._simp_2 | Mathlib.GroupTheory.FreeGroup.Reduce | ∀ {α : Type u_1} (a : α), (FreeGroup.of a = 1) = False | null | false |
Lean.TSyntax.ctorIdx | Init.Prelude | {ks : Lean.SyntaxNodeKinds} → Lean.TSyntax ks → ℕ | null | false |
_private.Mathlib.Algebra.Algebra.Subalgebra.Basic.0.Subalgebra.isDomain._proof_1 | Mathlib.Algebra.Algebra.Subalgebra.Basic | ∀ {R : Type u_2} {A : Type u_1} [inst : CommRing R] [inst_1 : Ring A] [IsDomain A] [inst_3 : Algebra R A]
(S : Subalgebra R A), IsDomain ↥S | null | false |
AddEquiv.toMultiplicativeLeft._proof_7 | Mathlib.Algebra.Group.Equiv.TypeTags | ∀ {G : Type u_1} {H : Type u_2} [inst : Add G] [inst_1 : Mul H] (f : Multiplicative G ≃* H),
Function.RightInverse f.invFun f.toFun | null | false |
CategoryTheory.ObjectProperty.IsClosedUnderFiniteColimits | Mathlib.CategoryTheory.ObjectProperty.FiniteLimits | {C : Type u_1} → [inst : CategoryTheory.Category.{v_1, u_1} C] → CategoryTheory.ObjectProperty C → Prop | A typeclass expressing that a property of objects is closed under finite colimits. | true |
Std.DTreeMap.Internal.Impl.Const.get?_congr | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {instOrd : Ord α} {β : Type v} {t : Std.DTreeMap.Internal.Impl α fun x => β} [Std.TransOrd α],
t.WF →
∀ {a b : α},
compare a b = Ordering.eq → Std.DTreeMap.Internal.Impl.Const.get? t a = Std.DTreeMap.Internal.Impl.Const.get? t b | null | true |
_private.Mathlib.Topology.Baire.LocallyCompactRegular.0.BaireSpace.of_t2Space_locallyCompactSpace._simp_2 | Mathlib.Topology.Baire.LocallyCompactRegular | ∀ {α : Type u} (x : α) (a b : Set α), (x ∈ a ∩ b) = (x ∈ a ∧ x ∈ b) | null | false |
Matrix.detp_smul_adjp | Mathlib.LinearAlgebra.Matrix.SemiringInverse | ∀ {n : Type u_1} {R : Type u_3} [inst : Fintype n] [inst_1 : DecidableEq n] [inst_2 : CommSemiring R]
{A B : Matrix n n R},
A * B = 1 →
A + (Matrix.detp 1 A • Matrix.adjp (-1) B + Matrix.detp (-1) A • Matrix.adjp 1 B) =
Matrix.detp 1 A • Matrix.adjp 1 B + Matrix.detp (-1) A • Matrix.adjp (-1) B | null | true |
Std.DHashMap.Internal.AssocList.foldrM | Std.Data.DHashMap.Internal.AssocList.Basic | {α : Type u} →
{β : α → Type v} →
{δ : Type w} →
{m : Type w → Type w'} → [Monad m] → ((a : α) → β a → δ → m δ) → δ → Std.DHashMap.Internal.AssocList α β → m δ | Internal implementation detail of the hash map | true |
CategoryTheory.Limits.isCokernelEpiComp._proof_1 | Mathlib.CategoryTheory.Limits.Shapes.Kernels | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
{X Y : C} {f : X ⟶ Y} {c : CategoryTheory.Limits.CokernelCofork f} {W : C} (g : W ⟶ X) {h : W ⟶ Y},
h = CategoryTheory.CategoryStruct.comp g f →
CategoryTheory.CategoryStruct.comp h (CategoryTheory... | null | false |
_private.Mathlib.Analysis.CStarAlgebra.Multiplier.0.DoubleCentralizer.instCStarRing._simp_2 | Mathlib.Analysis.CStarAlgebra.Multiplier | ∀ {𝕜 : Type u_1} {𝕜₂ : Type u_2} {E : Type u_4} {F : Type u_5} [inst : NormedAddCommGroup E]
[inst_1 : SeminormedAddCommGroup F] [inst_2 : DenselyNormedField 𝕜] [inst_3 : NontriviallyNormedField 𝕜₂]
[inst_4 : NormedSpace 𝕜 E] [inst_5 : NormedSpace 𝕜₂ F] {σ₁₂ : 𝕜 →+* 𝕜₂} [inst_6 : RingHomIsometric σ₁₂]
(f ... | null | false |
SimpleGraph.Walk.IsCircuit.map | Mathlib.Combinatorics.SimpleGraph.Paths | ∀ {V : Type u} {V' : Type v} {G : SimpleGraph V} {G' : SimpleGraph V'} {f : G →g G'} {u : V} {p : G.Walk u u},
Function.Injective ⇑f → p.IsCircuit → (SimpleGraph.Walk.map f p).IsCircuit | **Alias** of the reverse direction of `SimpleGraph.Walk.isCircuit_map_iff_of_injective`. | true |
CategoryTheory.Limits.isIsoZeroEquiv._proof_3 | Mathlib.CategoryTheory.Limits.Shapes.ZeroMorphisms | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
(X Y : C),
CategoryTheory.CategoryStruct.id X = 0 ∧ CategoryTheory.CategoryStruct.id Y = 0 →
CategoryTheory.CategoryStruct.comp 0 0 = CategoryTheory.CategoryStruct.id X ∧
CategoryTheory.Categ... | null | false |
_private.Mathlib.LinearAlgebra.Matrix.FixedDetMatrices.0.FixedDetMatrices.reduce_mem_reps._simp_1_6 | Mathlib.LinearAlgebra.Matrix.FixedDetMatrices | ∀ {α : Type u} [inst : AddGroup α] [inst_1 : LE α] [AddLeftMono α] [AddRightMono α] {a b : α}, (b ≤ -a) = (a ≤ -b) | null | false |
_private.Mathlib.Tactic.Linter.Style.0.Mathlib.Linter.Style.longLine.longLineLinter | Mathlib.Tactic.Linter.Style | Lean.Linter | The "longLine" linter emits a warning on lines longer than
`linter.style.longLine.maxLineLength` (which defaults to 100) characters.
We allow lines containing URLs to be longer, though. | true |
SemimoduleCat.Hom._sizeOf_1 | Mathlib.Algebra.Category.ModuleCat.Semi | {R : Type u} → {inst : Semiring R} → {M N : SemimoduleCat R} → [SizeOf R] → M.Hom N → ℕ | null | false |
_private.Mathlib.Tactic.Inclusion.Core.Inclusion.0.Inclusion.ppInclusionExpr | Mathlib.Tactic.Inclusion.Core.Inclusion | Lean.Expr → Inclusion.InclusionM Lean.MessageData | null | true |
Std.Http.Chunk.ExtensionName.ctorIdx | Std.Http.Data.Chunk | Std.Http.Chunk.ExtensionName → ℕ | null | false |
StarAlgebra.elemental.characterSpaceToSpectrum._proof_7 | Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.Basic | ∀ {A : Type u_1} [inst : CStarAlgebra A] (x : A), x ∈ StarAlgebra.elemental ℂ x | null | false |
ContinuousLinearMap.compLpₗ₂._proof_8 | Mathlib.MeasureTheory.Function.LpSpace.Basic | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜], RingHomIsometric (RingHom.id 𝕜) | null | false |
InfHom.id.eq_1 | Mathlib.Order.Hom.Lattice | ∀ (α : Type u_2) [inst : Min α], InfHom.id α = { toFun := id, map_inf' := ⋯ } | null | true |
Action.instConcreteCategoryHomSubtypeV | Mathlib.CategoryTheory.Action.Basic | (V : Type u_1) →
[inst : CategoryTheory.Category.{v_1, u_1} V] →
(G : Type u_2) →
[inst_1 : Monoid G] →
{FV : V → V → Type u_3} →
{CV : V → Type u_4} →
[inst_2 : (X Y : V) → FunLike (FV X Y) (CV X) (CV Y)] →
[inst_3 : CategoryTheory.ConcreteCategory V FV] →
... | null | true |
SemidirectProduct.inr_splitting | Mathlib.GroupTheory.GroupExtension.Defs | {N : Type u_1} →
{G : Type u_3} →
[inst : Group G] → [inst_1 : Group N] → (φ : G →* MulAut N) → (SemidirectProduct.toGroupExtension φ).Splitting | A canonical splitting of the group extension associated to the semidirect product | true |
Equiv.ord_def | Mathlib.Logic.Equiv.Defs | ∀ {α : Type u_1} {β : Type u_2} (e : α ≃ β) [inst : Ord β] (a b : α), compare a b = compare (e a) (e b) | null | true |
TensorAlgebra.GradedAlgebra.ι_apply._proof_1 | Mathlib.LinearAlgebra.TensorAlgebra.Grading | ∀ (R : Type u_1) (M : Type u_2) [inst : CommSemiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M] (m : M),
(TensorAlgebra.ι R) m ∈ (TensorAlgebra.ι R).range ^ 1 | null | false |
CategoryTheory.Functor.FullyFaithful.addGrpObj | Mathlib.CategoryTheory.Monoidal.Grp | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
[inst_1 : CategoryTheory.CartesianMonoidalCategory C] →
{D : Type u₂} →
[inst_2 : CategoryTheory.Category.{v₂, u₂} D] →
[inst_3 : CategoryTheory.CartesianMonoidalCategory D] →
{F : CategoryTheory.Functor C D} →
... | Pullback an additive group object along a fully faithful monoidal functor. | true |
CartanMatrix.E₈ | Mathlib.LinearAlgebra.Matrix.Cartan.Basic | Matrix (Fin 8) (Fin 8) ℤ | Deprecated alias for `E 8`. | true |
Mathlib.Tactic.Translate.Config.doc._default | Mathlib.Tactic.Translate.Core | Option (Lean.TSyntax `Lean.Parser.Command.docComment) | null | false |
_private.Mathlib.Combinatorics.SetFamily.AhlswedeZhang.0.Finset.infs_aux | Mathlib.Combinatorics.SetFamily.AhlswedeZhang | ∀ {α : Type u_1} [inst : DistribLattice α] [inst_1 : DecidableEq α] {s t : Finset α} {a : α},
a ∈ lowerClosure ↑(s ⊼ t) ↔ a ∈ lowerClosure ↑s ∧ a ∈ lowerClosure ↑t | null | true |
NonAssocRing.toAddCommGroupWithOne | Mathlib.Algebra.Ring.Defs | {α : Type u_1} → [self : NonAssocRing α] → AddCommGroupWithOne α | null | true |
ContDiffWithinAt.contDiffBump | Mathlib.Analysis.Calculus.BumpFunction.Basic | ∀ {E : Type u_1} {X : Type u_2} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E] [inst_2 : NormedAddCommGroup X]
[inst_3 : NormedSpace ℝ X] [inst_4 : HasContDiffBump E] {n : ℕ∞} {c g : X → E} {s : Set X}
{f : (x : X) → ContDiffBump (c x)} {x : X},
ContDiffWithinAt ℝ (↑n) c s x →
ContDiffWithinAt ℝ (↑n... | `ContDiffBump` is `𝒞ⁿ` in all its arguments. | true |
WithCStarModule.norm_apply_le_norm | Mathlib.Analysis.CStarAlgebra.Module.Constructions | ∀ {A : Type u_1} [inst : NonUnitalCStarAlgebra A] [inst_1 : PartialOrder A] {ι : Type u_2} {E : ι → Type u_3}
[inst_2 : Fintype ι] [inst_3 : (i : ι) → NormedAddCommGroup (E i)] [inst_4 : (i : ι) → Module ℂ (E i)]
[inst_5 : (i : ι) → SMul A (E i)] [inst_6 : (i : ι) → CStarModule A (E i)] [StarOrderedRing A]
(x : W... | null | true |
Nat.xor_right_injective | Batteries.Data.Nat.Bitwise.Lemmas | ∀ {x : ℕ}, Function.Injective fun x_1 => x ^^^ x_1 | null | true |
TopologicalSpace.le_def | Mathlib.Topology.Order | ∀ {α : Type u_1} {t s : TopologicalSpace α}, t ≤ s ↔ IsOpen ≤ IsOpen | null | true |
ValuationSubring.one_mem | Mathlib.RingTheory.Valuation.ValuationSubring | ∀ {K : Type u} [inst : Field K] (A : ValuationSubring K), 1 ∈ A | null | true |
TrivSqZeroExt.instAlgebra._proof_2 | Mathlib.Algebra.TrivSqZeroExt.Basic | ∀ (R' : Type u_1) (M : Type u_2) [inst : CommSemiring R'] [inst_1 : AddCommMonoid M] [inst_2 : Module R' M]
[inst_3 : Module R'ᵐᵒᵖ M] [IsCentralScalar R' M], IsScalarTower R' R'ᵐᵒᵖ M | null | false |
Lean.Elab.Command.InductiveElabStep3.finalize | Lean.Elab.MutualInductive | Lean.Elab.Command.InductiveElabStep3 → Lean.Elab.TermElabM Unit | Finalize the inductive type, after they are all added to the environment, after auxiliary definitions are added, and after computed fields are registered.
The `levelParams`, `params`, and `replaceIndFVars` arguments of `prefinalize` are still valid here. | true |
ContinuousLinearMap.postcompContinuousAffineMap | Mathlib.Topology.Algebra.ContinuousAffineMap.Topology | {R : Type u_1} →
{V : Type u_2} →
{W : Type u_3} →
{W₂ : Type u_4} →
(P : Type u_5) →
[inst : NormedField R] →
[inst_1 : AddCommGroup V] →
[inst_2 : Module R V] →
[inst_3 : TopologicalSpace V] →
[inst_4 : AddTorsor V P] →
... | Post-composition of continuous affine maps by a fixed continuous linear map, as a continuous
linear map. | true |
CategoryTheory.PullbackShift.adjunction | Mathlib.CategoryTheory.Shift.Pullback | {C : Type u_1} →
[inst : CategoryTheory.Category.{v_1, u_1} C] →
{A : Type u_2} →
{B : Type u_3} →
[inst_1 : AddMonoid A] →
[inst_2 : AddMonoid B] →
[inst_3 : CategoryTheory.HasShift C B] →
(φ : A →+ B) →
{D : Type u_4} →
[inst_4 ... | The adjunction `adj`, seen as an adjunction between `PullbackShift.functor F φ`
and `PullbackShift.functor G φ`.
| true |
MeasureTheory.SimpleFunc.ofIsEmpty._proof_1 | Mathlib.MeasureTheory.Function.SimpleFunc | ∀ {α : Type u_1} [IsEmpty α], Finite α | null | false |
Turing.TM0.Machine.map_step | Mathlib.Computability.TuringMachine.PostTuringMachine | ∀ {Γ : Type u_1} [inst : Inhabited Γ] {Γ' : Type u_2} [inst_1 : Inhabited Γ'] {Λ : Type u_3} [inst_2 : Inhabited Λ]
{Λ' : Type u_4} [inst_3 : Inhabited Λ'] (M : Turing.TM0.Machine Γ Λ) (f₁ : Turing.PointedMap Γ Γ')
(f₂ : Turing.PointedMap Γ' Γ) (g₁ : Λ → Λ') (g₂ : Λ' → Λ) {S : Set Λ},
Function.RightInverse f₁.f f... | null | true |
Differentiable.dimH_range_le | Mathlib.Topology.MetricSpace.HausdorffDimension | ∀ {E : Type u_5} {F : Type u_6} [inst : NormedAddCommGroup E] [inst_1 : NormedAddCommGroup F] {f : E → F}
[inst_2 : NormedSpace ℝ E] [inst_3 : NormedSpace ℝ F] [FiniteDimensional ℝ E],
Differentiable ℝ f → dimH (Set.range f) ≤ ↑(Module.finrank ℝ E) | The Hausdorff dimension of the range of a differentiable function defined on a
finite-dimensional real normed space is at most the dimension of its domain as a vector space over
`ℝ`. | true |
CategoryTheory.NatTrans.CommShift.verticalComposition | Mathlib.CategoryTheory.Shift.CommShift | ∀ {C₁ : Type u_1} {C₂ : Type u_2} {C₃ : Type u_3} {D₁ : Type u_4} {D₂ : Type u_5} {D₃ : Type u_6}
[inst : CategoryTheory.Category.{v_1, u_1} C₁] [inst_1 : CategoryTheory.Category.{v_2, u_2} C₂]
[inst_2 : CategoryTheory.Category.{v_3, u_3} C₃] [inst_3 : CategoryTheory.Category.{v_4, u_4} D₁]
[inst_4 : CategoryTheo... | Assume that we have a diagram of categories
```
C₁ ⥤ D₁
‖ ‖
v v
C₂ ⥤ D₂
‖ ‖
v v
C₃ ⥤ D₃
```
with functors `F₁₂ : C₁ ⥤ C₂`, `F₂₃ : C₂ ⥤ C₃` and `F₁₃ : C₁ ⥤ C₃` on the first
column that are related by a natural transformation `α : F₁₃ ⟶ F₁₂ ⋙ F₂₃`
and similarly `β : G₁₂ ⋙ G₂₃ ⟶ G₁₃` on the second column. ... | true |
CategoryTheory.MonoidalCategory.LawfulDayConvolutionMonoidalCategoryStruct.casesOn | Mathlib.CategoryTheory.Monoidal.DayConvolution | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
{V : Type u₂} →
[inst_1 : CategoryTheory.Category.{v₂, u₂} V] →
[inst_2 : CategoryTheory.MonoidalCategory C] →
[inst_3 : CategoryTheory.MonoidalCategory V] →
{D : Type u₃} →
[inst_4 : CategoryTheory.Cat... | null | false |
Lean.Json.instCoeArrayStructured | Lean.Data.Json.Basic | Coe (Array Lean.Json) Lean.Json.Structured | null | true |
groupCohomology.map_one_fst_of_isCocycle₂ | Mathlib.RepresentationTheory.Homological.GroupCohomology.LowDegree | ∀ {G : Type u_1} {A : Type u_2} [inst : Monoid G] [inst_1 : AddCommGroup A] [inst_2 : MulAction G A] {f : G × G → A},
groupCohomology.IsCocycle₂ f → ∀ (g : G), f (1, g) = f (1, 1) | null | true |
_private.Mathlib.MeasureTheory.VectorMeasure.AddContent.0.MeasureTheory.VectorMeasure.exists_extension_of_isSetRing_of_le_measure_of_dense._simp_1_6 | Mathlib.MeasureTheory.VectorMeasure.AddContent | ∀ {α : Type u_1} {m : MeasurableSpace α} {s₁ s₂ : Set α},
MeasurableSet s₁ → MeasurableSet s₂ → MeasurableSet (s₁ ∪ s₂) = True | null | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.