name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
InfTopHom.dual.eq_1 | Mathlib.Order.Hom.BoundedLattice | ∀ {α : Type u_2} {β : Type u_3} [inst : Min α] [inst_1 : Top α] [inst_2 : Min β] [inst_3 : Top β],
InfTopHom.dual =
{ toFun := fun f => { toSupHom := InfHom.dual f.toInfHom, map_bot' := ⋯ },
invFun := fun f => { toInfHom := InfHom.dual.symm f.toSupHom, map_top' := ⋯ }, left_inv := ⋯, right_inv := ⋯ } | null | true |
CategoryTheory.Pseudofunctor.ObjectProperty.fullsubcategory._proof_4 | Mathlib.CategoryTheory.Bicategory.Functor.Cat.ObjectProperty | ∀ {B : Type u_2} [inst : CategoryTheory.Bicategory B] {F : CategoryTheory.Pseudofunctor B CategoryTheory.Cat}
(P : F.ObjectProperty) [inst_1 : P.IsClosedUnderMapObj] {a b : B} {f g h : a ⟶ b} (η : f ⟶ g) (θ : g ⟶ h),
{ toNatTrans := P.map₂ (CategoryTheory.CategoryStruct.comp η θ) } =
CategoryTheory.CategoryStru... | null | false |
MonoidAlgebra.uniqueLinearEquiv | Mathlib.Algebra.MonoidAlgebra.Module | (R : Type u_1) →
{S : Type u_2} →
(M : Type u_3) →
[inst : Semiring R] →
[inst_1 : Semiring S] → [inst_2 : Module R S] → [One M] → [Subsingleton M] → MonoidAlgebra S M ≃ₗ[R] S | The trivial monoid algebra is the base ring. | true |
mdifferentiableWithinAt_of_isInvertible_mfderivWithin | Mathlib.Geometry.Manifold.MFDeriv.Basic | ∀ {𝕜 : 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... | null | true |
Lean.Elab.Structural.addSmartUnfoldingDef | Lean.Elab.PreDefinition.Structural.SmartUnfolding | Lean.LocalContext × Lean.LocalInstances → Lean.Elab.PreDefinition → ℕ → Lean.Elab.TermElabM Unit | null | true |
Turing.TM1.eval | Mathlib.Computability.TuringMachine.PostTuringMachine | {Γ : Type u_1} →
{Λ : Type u_2} →
{σ : Type u_3} →
[Inhabited Λ] →
[inst : Inhabited Γ] → [Inhabited σ] → (Λ → Turing.TM1.Stmt Γ Λ σ) → List Γ → Part (Turing.ListBlank Γ) | Evaluate a TM to completion, resulting in an output list on the tape (with an indeterminate
number of blanks on the end). | true |
MvPowerSeries.coeff_mul | Mathlib.RingTheory.MvPowerSeries.Basic | ∀ {σ : Type u_1} {R : Type u_2} [inst : Semiring R] (n : σ →₀ ℕ) (φ ψ : MvPowerSeries σ R) [inst_1 : DecidableEq σ],
(MvPowerSeries.coeff n) (φ * ψ) =
∑ p ∈ Finset.HasAntidiagonal.antidiagonal n, (MvPowerSeries.coeff p.1) φ * (MvPowerSeries.coeff p.2) ψ | null | true |
CategoryTheory.Bicategory.LeftExtension.IsAbsKan.hasAbsLeftKanExtension | Mathlib.CategoryTheory.Bicategory.Kan.HasKan | ∀ {B : Type u} [inst : CategoryTheory.Bicategory B] {a b c : B} {f : a ⟶ b} {g : a ⟶ c}
{t : CategoryTheory.Bicategory.LeftExtension f g} (H : t.IsAbsKan),
CategoryTheory.Bicategory.HasAbsLeftKanExtension f g | null | true |
_private.Plausible.Gen.0.Plausible.Gen.arrayOf.match_1 | Plausible.Gen | (motive : ULift.{u_1, 0} ℕ → Sort u_2) → (x : ULift.{u_1, 0} ℕ) → ((sz : ℕ) → motive { down := sz }) → motive x | null | false |
OrderMonoidHom.coe_mk | Mathlib.Algebra.Order.Hom.Monoid | ∀ {α : Type u_2} {β : Type u_3} [inst : Preorder α] [inst_1 : Preorder β] [inst_2 : MulOneClass α]
[inst_3 : MulOneClass β] (f : α →* β) (h : Monotone (↑f).toFun), ⇑{ toMonoidHom := f, monotone' := h } = ⇑f | null | true |
MeasureTheory.integrableOn_univ | Mathlib.MeasureTheory.Integral.IntegrableOn | ∀ {α : Type u_1} {ε : Type u_3} {mα : MeasurableSpace α} {f : α → ε} {μ : MeasureTheory.Measure α}
[inst : TopologicalSpace ε] [inst_1 : ContinuousENorm ε],
MeasureTheory.IntegrableOn f Set.univ μ ↔ MeasureTheory.Integrable f μ | null | true |
AlgebraicGeometry.Proj.lift_awayMapₐ_awayMapₐ_surjective | Mathlib.AlgebraicGeometry.ProjectiveSpectrum.Proper | ∀ {σ : Type u_1} {A : Type u_2} [inst : CommRing A] [inst_1 : SetLike σ A] [inst_2 : AddSubgroupClass σ A] (𝒜 : ℕ → σ)
[inst_3 : GradedRing 𝒜] {d e : ℕ} {f : A} (hf : f ∈ 𝒜 d) {g : A} (hg : g ∈ 𝒜 e) {x : A} (hx : x = f * g),
0 < d →
Function.Surjective
⇑(Algebra.TensorProduct.lift (HomogeneousLocaliza... | null | true |
Equiv.subtypeInjectiveEquivEmbedding | Mathlib.Logic.Embedding.Basic | (α : Sort u_1) → (β : Sort u_2) → { f // Function.Injective f } ≃ (α ↪ β) | The type of embeddings `α ↪ β` is equivalent to
the subtype of all injective functions `α → β`. | true |
Infinite.casesOn | Mathlib.Basic.Finite.Defs | {α : Sort u_3} → {motive : Infinite α → Sort u} → (t : Infinite α) → ((not_finite : ¬Finite α) → motive ⋯) → motive t | null | false |
Nat.sub_succ' | Init.Data.Nat.Lemmas | ∀ (m n : ℕ), m - n.succ = m - n - 1 | A version of `Nat.sub_succ` in the form `_ - 1` instead of `Nat.pred _`. | true |
_private.Lean.Meta.Sym.Arith.Poly.0.Lean.Grind.CommRing.Poly.mulConst'._sparseCasesOn_1 | Lean.Meta.Sym.Arith.Poly | {α : Type u} →
{motive : Option α → Sort u_1} →
(t : Option α) → ((val : α) → motive (some val)) → (Nat.hasNotBit 2 t.ctorIdx → motive t) → motive t | null | false |
AddSubgroup.centerCongr.eq_1 | Mathlib.GroupTheory.Subgroup.Center | ∀ {G : Type u_1} {H : Type u_2} [inst : AddGroup G] [inst_1 : AddGroup H] (e : G ≃+ H),
AddSubgroup.centerCongr e = AddSubmonoid.centerCongr e | null | true |
CategoryTheory.GrothendieckTopology.instIsIsoFunctorOppositeToPresheafFiberNatTransPointBotCoeEquivHomUnopOpObjTypeShrinkYonedaSymmShrinkYonedaObjObjEquivId | Mathlib.CategoryTheory.Sites.Point.Presheaf | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.LocallySmall.{w, v, u} C] (X : C)
(A : Type u_1) [inst_2 : CategoryTheory.Category.{u_2, u_1} A]
[inst_3 : CategoryTheory.Limits.HasColimitsOfSize.{w, w, u_2, u_1} A],
CategoryTheory.IsIso
((CategoryTheory.GrothendieckTopology.p... | null | true |
Lean.Meta.ACLt.ReduceMode.ctorElimType | Lean.Meta.ACLt | {motive : Lean.Meta.ACLt.ReduceMode → Sort u} → ℕ → Sort (max 1 u) | null | false |
totallyBounded_iff_subset_finite_iUnion_nhds_one | Mathlib.Topology.Algebra.IsUniformGroup.Basic | ∀ {α : Type u_1} [inst : UniformSpace α] [inst_1 : Group α] [IsUniformGroup α] {s : Set α},
TotallyBounded s ↔ ∀ U ∈ nhds 1, ∃ t, t.Finite ∧ s ⊆ ⋃ y ∈ t, y • U | null | true |
_private.Mathlib.Combinatorics.SimpleGraph.CycleGraph.0.SimpleGraph.cycleGraph.cycleCons._proof_5 | Mathlib.Combinatorics.SimpleGraph.CycleGraph | ∀ (n : ℕ), NeZero (n + 3) | null | false |
PseudoEpimorphismClass.exists_map_eq_of_map_le | Mathlib.Topology.Order.Hom.Esakia | ∀ {F : Type u_6} {α : outParam (Type u_7)} {β : outParam (Type u_8)} {inst : Preorder α} {inst_1 : Preorder β}
{inst_2 : FunLike F α β} [self : PseudoEpimorphismClass F α β] (f : F) ⦃a : α⦄ ⦃b : β⦄, f a ≤ b → ∃ c, a ≤ c ∧ f c = b | null | true |
PEmpty.rec._@.Mathlib.Util.CompileInductive.1077078790._hygCtx._hyg.3 | Mathlib.Util.CompileInductive | (motive : PEmpty.{u} → Sort u_1) → (t : PEmpty.{u}) → motive t | null | false |
CategoryTheory.Limits.prod.inl | Mathlib.CategoryTheory.Limits.Shapes.ZeroMorphisms | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
[CategoryTheory.Limits.HasZeroMorphisms C] →
(X Y : C) → [inst_2 : CategoryTheory.Limits.HasBinaryProduct X Y] → X ⟶ X ⨯ Y | If a category `C` has 0-morphisms, there is a canonical inclusion from the first component `X`
into any product of objects `X ⨯ Y`. | true |
Subfield.relrank_mul_rank_top | Mathlib.FieldTheory.Relrank | ∀ {E : Type v} [inst : Field E] {A B : Subfield E}, A ≤ B → A.relrank B * Module.rank (↥B) E = Module.rank (↥A) E | null | true |
groupHomology.cyclesMap_comp_cyclesIso₀_hom | Mathlib.RepresentationTheory.Homological.GroupHomology.Functoriality | ∀ {k G H : Type u} [inst : CommRing k] [inst_1 : Group G] [inst_2 : Group H] {A : Rep.{u, u, u} k G}
{B : Rep.{u, u, u} k H} (f : G →* H) (φ : A ⟶ Rep.res f B),
CategoryTheory.CategoryStruct.comp (groupHomology.cyclesMap f φ 0) (groupHomology.cyclesIso₀ B).hom =
CategoryTheory.CategoryStruct.comp (groupHomology... | null | true |
ContinuousMap.instNonUnitalNonAssocSemiringOfIsTopologicalSemiring._proof_4 | Mathlib.Topology.ContinuousMap.Algebra | ∀ {α : Type u_1} {β : Type u_2} [inst : TopologicalSpace α] [inst_1 : TopologicalSpace β]
[inst_2 : NonUnitalNonAssocSemiring β] [inst_3 : IsTopologicalSemiring β] (a : C(α, β)), a * 0 = 0 | null | false |
IsometryEquiv.toEquiv_injective | Mathlib.Topology.MetricSpace.Isometry | ∀ {α : Type u} {β : Type v} [inst : PseudoEMetricSpace α] [inst_1 : PseudoEMetricSpace β],
Function.Injective IsometryEquiv.toEquiv | null | true |
CochainComplex.HomComplex.Cochain.fromSingleMk._proof_2 | Mathlib.Algebra.Homology.HomotopyCategory.HomComplexSingle | IsRightCancelAdd ℤ | null | false |
Set.nonempty_uIoo._simp_1 | Mathlib.Order.Interval.Set.UnorderedInterval | ∀ {α : Type u_1} [inst : LinearOrder α] {a b : α} [DenselyOrdered α], (Set.uIoo a b).Nonempty = (a ≠ b) | null | false |
Submodule.hasDistribPointwiseNeg._proof_1 | Mathlib.Algebra.Algebra.Operations | ∀ {R : Type u_1} [inst : CommSemiring R] {A : Type u_2} [inst_1 : Ring A] [inst_2 : Algebra R A], IsScalarTower R A A | null | false |
Filter.mem_principal | Mathlib.Order.Filter.Defs | ∀ {α : Type u_1} {s t : Set α}, s ∈ Filter.principal t ↔ t ⊆ s | null | true |
HomologicalComplex₂.flipEquivalenceCounitIso._proof_1 | Mathlib.Algebra.Homology.HomologicalBicomplex | ∀ (C : Type u_3) [inst : CategoryTheory.Category.{u_2, u_3} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
{I₁ : Type u_1} {I₂ : Type u_4} (c₁ : ComplexShape I₁) (c₂ : ComplexShape I₂) (K : HomologicalComplex₂ C c₂ c₁)
(i₂ : I₂) (i j : I₁),
c₁.Rel i j →
CategoryTheory.CategoryStruct.comp
(Cate... | null | false |
HMul.ctorIdx | Init.Prelude | {α : Type u} → {β : Type v} → {γ : outParam (Type w)} → HMul α β γ → ℕ | null | false |
LinOrd.instCategory._proof_3 | Mathlib.Order.Category.LinOrd | ∀ {W X Y Z : LinOrd} (f : W.Hom X) (g : X.Hom Y) (h : Y.Hom Z),
{ hom' := h.hom'.comp { hom' := g.hom'.comp f.hom' }.hom' } =
{ hom' := { hom' := h.hom'.comp g.hom' }.hom'.comp f.hom' } | null | false |
_private.Mathlib.Condensed.Light.Sequence.0.InternalProjectivityProof.fibres_compl_eq_iUnion | Mathlib.Condensed.Light.Sequence | ∀ {S : Type u_1} {T : Type u_2} {X : Type u_3} (π : T → S × Option X) (σ : Option X → S → T),
(∀ (x : Option X) (s : S), (π (σ x s)).2 = x) →
(InternalProjectivityProof.fibres✝ π σ)ᶜ = ⋃ i, (Set.range (σ (some i)))ᶜ ∩ Prod.snd ∘ π ⁻¹' {↑i} | null | true |
USize.toBitVec_min | Init.Data.UInt.Lemmas | ∀ {a b : USize}, (a ⊓ b).toBitVec = a.toBitVec ⊓ b.toBitVec | null | true |
Std.Sat.AIG.Fanin.ofRaw._flat_ctor | Std.Sat.AIG.Basic | ℕ → Std.Sat.AIG.Fanin | null | false |
Representation.LinearizeMonoidal.μ_apply_single_single | Mathlib.RepresentationTheory.Action | ∀ {G : Type v} [inst : Monoid G] {X Y : Action (Type w) G} {k : Type u} [inst_1 : CommSemiring k] (x : X.V) (y : Y.V)
(r s : k),
(Representation.LinearizeMonoidal.μ X Y) (MonoidAlgebra.single x r ⊗ₜ[k] MonoidAlgebra.single y s) =
MonoidAlgebra.single (x, y) (r * s) | null | true |
CategoryTheory.ShortComplex.exact_of_iso | Mathlib.Algebra.Homology.ShortComplex.Exact | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
{S₁ S₂ : CategoryTheory.ShortComplex C} (e : S₁ ≅ S₂), S₁.Exact → S₂.Exact | null | true |
Int.erdos_ginzburg_ziv | Mathlib.Combinatorics.Additive.ErdosGinzburgZiv | ∀ {ι : Type u_1} {n : ℕ} {s : Finset ι} (a : ι → ℤ), 2 * n - 1 ≤ s.card → ∃ t ⊆ s, t.card = n ∧ ↑n ∣ ∑ i ∈ t, a i | The **Erdős–Ginzburg–Ziv theorem** for `ℤ`.
Any sequence of at least `2 * n - 1` elements of `ℤ` contains a subsequence of `n` elements whose
sum is divisible by `n`. | true |
_private.Lean.Meta.Tactic.Grind.ForallProp.0.Lean.Meta.Grind.propagateForallPropUp.propagateImpliesUp | Lean.Meta.Tactic.Grind.ForallProp | Lean.Expr → Lean.Expr → Lean.Expr → Lean.Meta.Grind.GoalM Unit | null | true |
IO.Process.SpawnArgs.env._default | Init.System.IO | Array (String × Option String) | null | false |
TwoSidedIdeal.ker._proof_4 | Mathlib.RingTheory.TwoSidedIdeal.Kernel | ∀ {R : Type u_1} {S : Type u_2} {F : Type u_3} [inst : FunLike F R S] (f : F), Equivalence fun x y => f x = f y | null | false |
Set.monotone_powerset | Mathlib.Data.Set.Basic | ∀ {α : Type u}, Monotone Set.powerset | null | true |
TopologicalSpace.Opens.map_comp_map | Mathlib.Topology.Category.TopCat.Opens | ∀ {X Y Z : TopCat} (f : X ⟶ Y) (g : Y ⟶ Z) {U V : TopologicalSpace.Opens ↑Z} (i : U ⟶ V),
(TopologicalSpace.Opens.map (CategoryTheory.CategoryStruct.comp f g)).map i =
(TopologicalSpace.Opens.map f).map ((TopologicalSpace.Opens.map g).map i) | null | true |
TrivSqZeroExt.addGroupWithOne._proof_2 | Mathlib.Algebra.TrivSqZeroExt.Basic | ∀ {R : Type u_1} {M : Type u_2} [inst : AddGroupWithOne R] [inst_1 : AddGroup M] (a : TrivSqZeroExt R M), 0 • a = 0 | null | false |
_private.Mathlib.Data.List.Interleave.0.List.interleaves_ofFn_even._proof_1_40 | Mathlib.Data.List.Interleave | ∀ {n : ℕ} (i : ℕ), i / 2 + 9 ≤ n → i / 2 + 7 < n | null | false |
_private.Init.Data.String.Lemmas.Splits.0.String.Slice.splits_singleton_right_iff._simp_1_1 | Init.Data.String.Lemmas.Splits | ∀ {s : String.Slice}, (s.startPos ≠ s.endPos) = (s.isEmpty = false) | null | false |
Ideal.span_range_eq_iSup | Mathlib.RingTheory.Ideal.Span | ∀ {α : Type u} [inst : Semiring α] {ι : Type u_1} (x : ι → α), Ideal.span (Set.range x) = ⨆ i, Ideal.span {x i} | null | true |
Complementeds.coe_inj._simp_1 | Mathlib.Order.Disjoint | ∀ {α : Type u_1} [inst : Lattice α] [inst_1 : BoundedOrder α] {a b : Complementeds α}, (↑a = ↑b) = (a = b) | null | false |
Continuous.matrix_elem | Mathlib.Topology.Instances.Matrix | ∀ {X : Type u_1} {m : Type u_4} {n : Type u_5} {R : Type u_8} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace R]
{A : X → Matrix m n R}, Continuous A → ∀ (i : m) (j : n), Continuous fun x => A x i j | null | true |
Cardinal.Real.Icc_countable_iff._simp_1 | Mathlib.Analysis.Real.Cardinality | ∀ {x y : ℝ}, (Set.Icc x y).Countable = (y ≤ x) | null | false |
AlgebraicGeometry.IsDominant | Mathlib.AlgebraicGeometry.Morphisms.UnderlyingMap | {X Y : AlgebraicGeometry.Scheme} → (X ⟶ Y) → Prop | A morphism of schemes is dominant if the underlying map has dense range. | true |
_private.Std.Data.Internal.List.Associative.0.Std.Internal.List.min_apply | Std.Data.Internal.List.Associative | ∀ {α : Type u} {β : α → Type v} [inst : Ord α] {e₁ e₂ : (a : α) × β a} {f : (a : α) × β a → (a : α) × β a},
compare e₁.fst e₂.fst = compare (f e₁).fst (f e₂).fst → f e₁ ⊓ f e₂ = f (e₁ ⊓ e₂) | null | true |
_private.Lean.Compiler.Specialize.0.Lean.Compiler.elabSpecArgs._proof_4 | Lean.Compiler.Specialize | ∀ (argNames : Array Lean.Name) (idx : ℕ), ¬idx - 1 ≥ argNames.size → ¬idx - 1 < argNames.size → False | null | false |
Lean.ModuleArtifacts._sizeOf_1 | Lean.Setup | Lean.ModuleArtifacts → ℕ | null | false |
_private.Std.Data.Internal.List.Associative.0.Std.Internal.List.insertListIfNewUnit.eq_2 | Std.Data.Internal.List.Associative | ∀ {α : Type u} [inst : BEq α] (l : List ((_ : α) × Unit)) (hd : α) (tl : List α),
Std.Internal.List.insertListIfNewUnit l (hd :: tl) =
Std.Internal.List.insertListIfNewUnit (Std.Internal.List.insertEntryIfNew hd () l) tl | null | true |
Complex.hasStrictDerivAt_sinh | Mathlib.Analysis.SpecialFunctions.Trigonometric.DerivHyp | ∀ (x : ℂ), HasStrictDerivAt Complex.sinh (Complex.cosh x) x | The complex hyperbolic sine function is everywhere strictly differentiable, with the derivative
`cosh x`. | true |
Std.DTreeMap.Const.get?_congr | Std.Data.DTreeMap.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} {β : Type v} {t : Std.DTreeMap α (fun x => β) cmp} [Std.TransCmp cmp] {a b : α},
cmp a b = Ordering.eq → Std.DTreeMap.Const.get? t a = Std.DTreeMap.Const.get? t b | null | true |
completeSpace_congr | Mathlib.Topology.UniformSpace.UniformEmbedding | ∀ {α : Type u} {β : Type v} [inst : UniformSpace α] [inst_1 : UniformSpace β] {e : α ≃ β},
IsUniformEmbedding ⇑e → (CompleteSpace α ↔ CompleteSpace β) | See also `IsUniformInducing.completeSpace_congr`
for a version that works for non-injective maps. | true |
String.Pos.Raw.IsValidForSlice.ofSlice | Init.Data.String.Basic | ∀ {s : String} {p : String.Pos.Raw}, String.Pos.Raw.IsValidForSlice s.toSlice p → String.Pos.Raw.IsValid s p | null | true |
Sigma.instLocallyFiniteOrder._proof_4 | Mathlib.Data.Sigma.Interval | ∀ {ι : Type u_1} {α : ι → Type u_2} [inst : DecidableEq ι] [inst_1 : (i : ι) → Preorder (α i)]
[inst_2 : (i : ι) → LocallyFiniteOrder (α i)] (x x_1 x_2 : (i : ι) × α i),
x_2 ∈ Finset.sigmaLift (fun x => Finset.Ioo) x x_1 ↔ x < x_2 ∧ x_2 < x_1 | null | false |
Std.DTreeMap.Internal.Impl.Const.beq.eq_1 | Std.Data.DTreeMap.Internal.WF.Lemmas | ∀ {α : Type u} {β : Type v} [inst : Ord α] [inst_1 : BEq β] (t₁ t₂ : Std.DTreeMap.Internal.Impl α fun x => β),
Std.DTreeMap.Internal.Impl.Const.beq t₁ t₂ =
if t₁.size ≠ t₂.size then false else t₁.all fun k v => Std.DTreeMap.Internal.Impl.Const.get? t₂ k == some v | null | true |
SSet.RelativeMorphism.image_le | Mathlib.AlgebraicTopology.SimplicialSet.RelativeMorphism | ∀ {X Y : SSet} {A : X.Subcomplex} {B : Y.Subcomplex} {φ : A.toSSet ⟶ B.toSSet} (f : SSet.RelativeMorphism A B φ),
A.image f.map ≤ B | null | true |
Field.ofMinimalAxioms._proof_2 | Mathlib.Algebra.Field.MinimalAxioms | ∀ (K : Type u_1) [inst : Add K] [inst_1 : Mul K] [inst_2 : Neg K] [inst_3 : Inv K] [inst_4 : Zero K] [inst_5 : One K]
(add_assoc : ∀ (a b c : K), a + b + c = a + (b + c)) (zero_add : ∀ (a : K), 0 + a = a)
(neg_add_cancel : ∀ (a : K), -a + a = 0) (mul_assoc : ∀ (a b c : K), a * b * c = a * (b * c))
(mul_comm : ∀ (... | null | false |
Commute.cfcₙ_nnreal | Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.Commute | ∀ {A : Type u_2} [inst : NonUnitalRing A] [inst_1 : StarRing A] [inst_2 : Module ℝ A] [inst_3 : IsScalarTower ℝ A A]
[inst_4 : SMulCommClass ℝ A A] [inst_5 : TopologicalSpace A]
[inst_6 : NonUnitalContinuousFunctionalCalculus ℝ A IsSelfAdjoint] [IsTopologicalRing A] [T2Space A]
[inst_9 : PartialOrder A] [inst_10 ... | A version of `Commute.cfcₙ` or `IsSelfAdjoint.commute_cfcₙ` which does not require any
interaction with `star` when the base ring is `ℝ≥0`. | true |
QuadraticAlgebra.algebraMap_eq_mapRingHom | Mathlib.Algebra.QuadraticAlgebra.BaseChange | ∀ {R : Type u_1} (S : Type u_2) [inst : CommSemiring R] [inst_1 : CommSemiring S] [inst_2 : Algebra R S] (a b : R),
algebraMap (QuadraticAlgebra R a b) (QuadraticAlgebra S ((algebraMap R S) a) ((algebraMap R S) b)) =
QuadraticAlgebra.mapRingHom (algebraMap R S) a b | null | true |
_private.Mathlib.FieldTheory.Isaacs.0.Field.nonempty_algHom_of_exists_root.match_1_3 | Mathlib.FieldTheory.Isaacs | ∀ {F : Type u_2} {E : Type u_3} {K : Type u_1} [inst : Field F] [inst_1 : Field E] [inst_2 : Field K]
[inst_3 : Algebra F E] [inst_4 : Algebra F K] (α : E) (motive : (∃ y, (Polynomial.aeval y) (minpoly F α) = 0) → Prop)
(x : ∃ y, (Polynomial.aeval y) (minpoly F α) = 0),
(∀ (β : K) (hβ : (Polynomial.aeval β) (minp... | null | false |
_private.Mathlib.RingTheory.RootsOfUnity.Basic.0.mem_rootsOfUnity_prime_pow_mul_iff._simp_1_1 | Mathlib.RingTheory.RootsOfUnity.Basic | ∀ {M : Type u_1} [inst : CommMonoid M] (k : ℕ) (ζ : Mˣ), (ζ ∈ rootsOfUnity k M) = (↑ζ ^ k = 1) | null | false |
Mathlib.Tactic.BicategoryLike.normalize._f | Mathlib.Tactic.CategoryTheory.Coherence.PureCoherence | {ρ : Type} →
[Mathlib.Tactic.BicategoryLike.MonadMor₁ (Mathlib.Tactic.BicategoryLike.CoherenceM ρ)] →
[Mathlib.Tactic.BicategoryLike.MonadMor₂Iso (Mathlib.Tactic.BicategoryLike.CoherenceM ρ)] →
(f : Mathlib.Tactic.BicategoryLike.Mor₁) →
Mathlib.Tactic.BicategoryLike.Mor₁.below (motive := fun f =>
... | null | false |
CategoryTheory.MonoOver.isoMk_hom | Mathlib.CategoryTheory.Subobject.MonoOver | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {X : C} {f g : CategoryTheory.MonoOver X}
(h : f.obj.left ≅ g.obj.left)
(w : autoParam (CategoryTheory.CategoryStruct.comp h.hom g.arrow = f.arrow) CategoryTheory.MonoOver.isoMk._auto_1),
(CategoryTheory.MonoOver.isoMk h w).hom = CategoryTheory.MonoOver.... | null | true |
_private.Lean.Parser.Command.0.Lean.Parser.Command.declaration._regBuiltin.Lean.Parser.Command.nonrec.formatter_37 | Lean.Parser.Command | IO Unit | null | false |
AlgebraicGeometry.Scheme.RationalMap.toPartialMap._proof_6 | Mathlib.AlgebraicGeometry.Birational.RationalMap | ∀ {X Y : AlgebraicGeometry.Scheme} [AlgebraicGeometry.IsReduced X] [Y.IsSeparated] (f : X.RationalMap Y)
(x y : f.openCoverDomain.I₀),
CategoryTheory.CategoryStruct.comp
(CategoryTheory.Limits.pullback.fst (f.openCoverDomain.f x) (f.openCoverDomain.f y))
(CategoryTheory.CategoryStruct.comp (X.isoOfEq ⋯)... | null | false |
commBialgCatEquivComonCommAlgCat._proof_9 | Mathlib.Algebra.Category.CommBialgCat | ∀ (R : Type u_1) [inst : CommRing R],
CategoryTheory.CategoryStruct.comp (CategoryTheory.CategoryStruct.id (CategoryTheory.Functor.id (CommBialgCat R)))
(CategoryTheory.CategoryStruct.id
({ obj := fun A => Opposite.op { X := Opposite.op ↧↑A, mon := CommAlgCat.monObjOpOf },
map := fun {A B}... | null | false |
Matrix.toLinearEquivRight'OfInv._proof_1 | Mathlib.LinearAlgebra.Matrix.ToLin | ∀ {R : Type u_1} [inst : Semiring R] {m : Type u_3} {n : Type u_2} [inst_1 : Fintype m] [inst_2 : DecidableEq m]
[inst_3 : Fintype n] [inst_4 : DecidableEq n] {M : Matrix m n R} {M' : Matrix n m R},
M' * M = 1 → ∀ (x : n → R), (Matrix.toLinearMapRight' M) ((Matrix.toLinearMapRight' M') x) = x | null | false |
_private.Mathlib.Order.Fin.InsertNth.0.Fin.insertNth_monotone._proof_1_16 | Mathlib.Order.Fin.InsertNth | ∀ {n : ℕ} (i j : Fin n) (hj : i.castSucc < j.succ), i.castSucc.succ.succAbove (j.succ.succ.pred ⋯) = j.succ.succ | null | false |
CategoryTheory.IsCardinalFiltered.exists_cardinal_directed.Diagram.sup._proof_3 | Mathlib.CategoryTheory.Presentable.Directed | ∀ {J : Type u_1} [inst : CategoryTheory.SmallCategory J] {κ : Cardinal.{u_1}} [Fact κ.IsRegular]
(D₁ D₂ : CategoryTheory.IsCardinalFiltered.exists_cardinal_directed.Diagram J κ), (D₁.W ⊔ D₂.W).HasCardinalLT κ | null | false |
Function.ExtendByZero.linearMap | Mathlib.LinearAlgebra.Pi | (R : Type u) →
{ι : Type x} →
{η : Type u_1} →
[inst : Semiring R] →
(M : Type u_2) → [inst_1 : AddCommMonoid M] → [inst_2 : Module R M] → (ι → η) → (ι → M) →ₗ[R] η → M | `Function.extend s f 0` as a bundled linear map. | true |
Std.Internal.List.isEmpty_filter_eq_true | Std.Data.Internal.List.Associative | ∀ {α : Type u} {β : α → Type v} [inst : BEq α] [inst_1 : LawfulBEq α] {f : (a : α) → β a → Bool}
{l : List ((a : α) × β a)},
Std.Internal.List.DistinctKeys l →
((List.filter (fun p => f p.fst p.snd) l).isEmpty = true ↔
∀ (k : α) (h : Std.Internal.List.containsKey k l = true), f k (Std.Internal.List.getVal... | null | true |
ModuleCat.preservesColimit_restrictScalars | Mathlib.Algebra.Category.ModuleCat.ChangeOfRings | ∀ {R : Type u_1} {S : Type u_2} [inst : Ring R] [inst_1 : Ring S] (f : R →+* S) {J : Type u_3}
[inst_2 : CategoryTheory.Category.{v_1, u_3} J] (F : CategoryTheory.Functor J (ModuleCat S))
[CategoryTheory.Limits.HasColimit (F.comp (CategoryTheory.forget₂ (ModuleCat S) AddCommGrpCat))],
CategoryTheory.Limits.Preser... | null | true |
CategoryTheory.Limits.limitFlipIsoCompLim._proof_3 | Mathlib.CategoryTheory.Limits.FunctorCategory.Basic | ∀ {C : Type u_4} [inst : CategoryTheory.Category.{u_3, u_4} C] {J : Type u_2}
[inst_1 : CategoryTheory.Category.{u_1, u_2} J] {K : Type u_6} [inst_2 : CategoryTheory.Category.{u_5, u_6} K]
[CategoryTheory.Limits.HasLimitsOfShape J C] (F : CategoryTheory.Functor K (CategoryTheory.Functor J C)) (k : K),
CategoryThe... | null | false |
_private.Mathlib.Basic.Logic.Basic.0.BEx.elim.match_1_1 | Mathlib.Basic.Logic.Basic | ∀ {α : Sort u_1} {p : α → Prop} {P : (x : α) → p x → Prop} {b : Prop}
(motive : (∃ x, ∃ (h : p x), P x h) → (∀ (a : α) (h : p a), P a h → b) → Prop) (x : ∃ x, ∃ (h : p x), P x h)
(x_1 : ∀ (a : α) (h : p a), P a h → b),
(∀ (a : α) (h₁ : p a) (h₂ : P a h₁) (h' : ∀ (a : α) (h : p a), P a h → b), motive ⋯ h') → motiv... | null | false |
ContMDiff.cle_arrowCongr | Mathlib.Geometry.Manifold.ContMDiff.NormedSpace | ∀ {𝕜 : 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] {F₁ : Type u_8} [inst_6 : NormedAddComm... | null | true |
CategoryTheory.IsCardinalLocallyPresentable.mk._flat_ctor | Mathlib.CategoryTheory.Presentable.LocallyPresentable | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {κ : Cardinal.{w}} [inst_1 : Fact κ.IsRegular],
autoParam (∀ (X Y : C), Small.{w, v} (X ⟶ Y)) CategoryTheory.LocallySmall.hom_small._autoParam →
(∃ P, ∃ (_ : CategoryTheory.ObjectProperty.EssentiallySmall.{w, v, u} P), P.IsCardinalFilteredGenerator κ) →
... | null | false |
MonoidAlgebra.rTensorEquivAlgEquiv.invFun | Mathlib.RingTheory.TensorProduct.MonoidAlgebra | {R : Type u_1} →
{M : Type u_2} →
{S : Type u_4} →
{A : Type u_5} →
{B : Type u_6} →
[inst : CommSemiring R] →
[inst_1 : CommSemiring S] →
[inst_2 : CommSemiring A] →
[inst_3 : CommSemiring B] →
[inst_4 : Algebra R S] →
... | Implementation detail. | true |
Nat.add_le_add_iff_right._simp_1 | Init.Data.Nat.Basic | ∀ {m k n : ℕ}, (m + n ≤ k + n) = (m ≤ k) | null | false |
pointedToTwoPSnd._proof_3 | Mathlib.CategoryTheory.Category.TwoP | ∀ {X Y Z : Pointed} (f : X ⟶ Y) (g : Y ⟶ Z),
{ hom := { toFun := Option.map (CategoryTheory.CategoryStruct.comp f g).toFun, map_fst := ⋯, map_snd := ⋯ } } =
CategoryTheory.CategoryStruct.comp { hom := { toFun := Option.map f.toFun, map_fst := ⋯, map_snd := ⋯ } }
{ hom := { toFun := Option.map g.toFun, map_f... | null | false |
Std.Do.ExceptConds.entails_true._simp_1 | Std.Do.PostCond | ∀ {ps : Std.Do.PostShape} {x : Std.Do.ExceptConds ps}, x.entails Std.Do.ExceptConds.true = True | null | false |
Sym2.diag_diagElem | Mathlib.Data.Sym.Sym2 | ∀ {α : Type u_1} {z : Sym2 α} (h : z.IsDiag), Sym2.diag (z.diagElem h) = z | null | true |
_private.Mathlib.Analysis.Normed.Operator.ContinuousAlgEquiv.0.auxContinuousLinearEquiv._proof_12 | Mathlib.Analysis.Normed.Operator.ContinuousAlgEquiv | ∀ {𝕜 : Type u_3} {V : Type u_2} {W : Type u_1} [inst : RCLike 𝕜] [inst_1 : NormedAddCommGroup V]
[inst_2 : InnerProductSpace 𝕜 V] [inst_3 : CompleteSpace V] [inst_4 : NormedAddCommGroup W]
[inst_5 : InnerProductSpace 𝕜 W] [inst_6 : CompleteSpace W] (e : V ≃L[𝕜] W) {α' : 𝕜},
Continuous ⇑(α' • ContinuousLinea... | null | false |
Float.toRatParts | Batteries.Data.Float.Basic | Float → Option (ℤ × ℤ) | Returns `v, exp` integers such that `f = v * 2^exp`.
(`e` is not minimal, but `v.abs` will be at most `2^53 - 1`.)
Returns `none` when `f` is not finite (i.e. `inf`, `-inf` or a `nan`). | true |
Std.DHashMap.Raw.getKey_union_of_not_mem_right | Std.Data.DHashMap.RawLemmas | ∀ {α : Type u} [inst : BEq α] [inst_1 : Hashable α] {β : α → Type v} {m₁ m₂ : Std.DHashMap.Raw α β}
[inst_2 : EquivBEq α] [inst_3 : LawfulHashable α] (h₁ : m₁.WF) (h₂ : m₂.WF) {k : α} (not_mem : k ∉ m₂)
{h' : k ∈ m₁ ∪ m₂}, (m₁ ∪ m₂).getKey k h' = m₁.getKey k ⋯ | null | true |
map_imaginaryPart | Mathlib.LinearAlgebra.Complex.Module | ∀ {A : Type u_1} [inst : AddCommGroup A] [inst_1 : Module ℂ A] [inst_2 : StarAddMonoid A] [inst_3 : StarModule ℂ A]
{B : Type u_2} {F : Type u_3} [inst_4 : AddCommGroup B] [inst_5 : Module ℂ B] [inst_6 : StarAddMonoid B]
[inst_7 : StarModule ℂ B] [inst_8 : FunLike F A B] [StarHomClass F A B] [LinearMapClass F ℂ A B... | null | true |
ONote.add._f | Mathlib.SetTheory.Ordinal.Notation | (x : ONote) → ONote.below (motive := fun x => ONote → ONote) x → ONote → ONote | null | false |
Representation.asAlgebraHom_of | Mathlib.RepresentationTheory.Basic | ∀ {k : Type u_1} {G : Type u_2} {V : Type u_3} [inst : CommSemiring k] [inst_1 : Monoid G] [inst_2 : AddCommMonoid V]
[inst_3 : Module k V] (ρ : Representation k G V) (g : G), ρ.asAlgebraHom ((MonoidAlgebra.of k G) g) = ρ g | null | true |
Std.TreeMap.Raw.maxKeyD_le | Std.Data.TreeMap.Raw.Lemmas | ∀ {α : Type u} {β : Type v} {cmp : α → α → Ordering} {t : Std.TreeMap.Raw α β cmp} [Std.TransCmp cmp],
t.WF →
t.isEmpty = false → ∀ {k fallback : α}, (cmp (t.maxKeyD fallback) k).isLE = true ↔ ∀ k' ∈ t, (cmp k' k).isLE = true | null | true |
List.zipWith._f | Init.Data.List.Basic | {α : Type u} →
{β : Type v} →
{γ : Type w} → (α → β → γ) → (x : List α) → List.below (motive := fun x => List β → List γ) x → List β → List γ | null | false |
Std.Packages.PreorderOfLEArgs._sizeOf_1 | Init.Data.Order.PackageFactories | {α : Type u} → [SizeOf α] → Std.Packages.PreorderOfLEArgs α → ℕ | null | false |
commutatorElement_one_left | Mathlib.GroupTheory.Commutator.Basic | ∀ {G : Type u_1} [inst : Group G] (g : G), ⁅1, g⁆ = 1 | null | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.