name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11.5k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
CategoryTheory.ShortComplex.Exact.isIso_imageToKernel | Mathlib.CategoryTheory.Abelian.Exact | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] [inst_1 : CategoryTheory.Abelian C]
(S : CategoryTheory.ShortComplex C), S.Exact → CategoryTheory.IsIso (imageToKernel S.f S.g ⋯) | null | true |
Lean.KeyedDeclsAttribute.ExtensionState.declNames | Lean.KeyedDeclsAttribute | {γ : Type} → Lean.KeyedDeclsAttribute.ExtensionState γ → Lean.PHashSet Lean.Name | null | true |
LinearMap.mem_submoduleImage._simp_1 | Mathlib.Algebra.Module.Submodule.Range | ∀ {R : Type u_1} {M : Type u_5} [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M] {M' : Type u_10}
[inst_3 : AddCommMonoid M'] [inst_4 : Module R M'] {O : Submodule R M} {ϕ : ↥O →ₗ[R] M'} {N : Submodule R M} {x : M'},
(x ∈ ϕ.submoduleImage N) = ∃ y, ∃ (yO : y ∈ O), y ∈ N ∧ ϕ ⟨y, yO⟩ = x | null | false |
Submonoid.closure_insert_one | Mathlib.Algebra.Group.Submonoid.Basic | ∀ {M : Type u_1} [inst : MulOneClass M] (s : Set M), Submonoid.closure (insert 1 s) = Submonoid.closure s | null | true |
Lean.Meta.Grind.Arith.Cutsat.SymbolicIntInterval.isFinite | Lean.Meta.Tactic.Grind.Arith.Cutsat.ToIntInfo | Lean.Meta.Grind.Arith.Cutsat.SymbolicIntInterval → Bool | null | true |
Std.DHashMap.Const.size_le_size_insertMany_list | Std.Data.DHashMap.Lemmas | ∀ {α : Type u} {x : BEq α} {x_1 : Hashable α} {β : Type v} {m : Std.DHashMap α fun x => β} [EquivBEq α]
[LawfulHashable α] {l : List (α × β)}, m.size ≤ (Std.DHashMap.Const.insertMany m l).size | null | true |
AdjoinRoot.instCommRing | Mathlib.RingTheory.AdjoinRoot | {R : Type u_1} → [inst : CommRing R] → (f : Polynomial R) → CommRing (AdjoinRoot f) | null | true |
SimpleGraph.Walk.support_toPath_subset | Mathlib.Combinatorics.SimpleGraph.Paths | ∀ {V : Type u} {G : SimpleGraph V} {u v : V} [inst : DecidableEq V] (p : G.Walk u v), (↑p.toPath).support ⊆ p.support | **Alias** of `SimpleGraph.Walk.support_toPath_subset_support`. | true |
MeasurableSet.image_of_measurable_injOn | Mathlib.MeasureTheory.Constructions.Polish.Basic | ∀ {γ : Type u_3} {α : Type u_4} [inst : MeasurableSpace α] {s : Set γ} {f : γ → α}
[MeasurableSpace.CountablySeparated α] [inst_2 : MeasurableSpace γ] [StandardBorelSpace γ],
MeasurableSet s → Measurable f → Set.InjOn f s → MeasurableSet (f '' s) | The Lusin-Souslin theorem: if `s` is Borel-measurable in a standard Borel space,
then its image under a measurable injective map taking values in a
countably separate measurable space is also Borel-measurable. | true |
_private.Mathlib.LinearAlgebra.Pi.0.LinearMap.pi_eq_zero._simp_1_2 | Mathlib.LinearAlgebra.Pi | ∀ {α : Sort u} {β : α → Sort v} {f g : (x : α) → β x}, (f = g) = ∀ (x : α), f x = g x | null | false |
RelEmbedding.recOn | Mathlib.Order.RelIso.Basic | {α : Type u_5} →
{β : Type u_6} →
{r : α → α → Prop} →
{s : β → β → Prop} →
{motive : r ↪r s → Sort u} →
(t : r ↪r s) →
((toEmbedding : α ↪ β) →
(map_rel_iff' : ∀ {a b : α}, s (toEmbedding a) (toEmbedding b) ↔ r a b) →
motive { toEmbedding := t... | null | false |
IdealFilter.isTorsion_def | Mathlib.RingTheory.IdealFilter.Basic | ∀ {A : Type u_1} [inst : Ring A] (F : IdealFilter A) (M : Type u_2) [inst_1 : AddCommMonoid M] [inst_2 : Module A M],
F.IsTorsion M ↔ ∀ (m : M), F.IsTorsionElem m | null | true |
_private.Mathlib.Algebra.Homology.HomotopyCategory.HomComplex.0.CochainComplex.HomComplex.Cocycle.homOf._simp_1 | Mathlib.Algebra.Homology.HomotopyCategory.HomComplex | ∀ {G : Type u_3} [inst : AddGroup G] {a b : G}, (a - b = 0) = (a = b) | null | false |
_private.Init.Data.String.Decode.0.ByteArray.utf8DecodeChar?.val_assemble₁_le._proof_1_1 | Init.Data.String.Decode | ∀ {w : UInt8}, w.toNat < 128 → ¬w.toNat ≤ 127 → False | null | false |
Concept.instPartialOrder | Mathlib.Order.Concept | {α : Type u_2} → {β : Type u_3} → {r : α → β → Prop} → PartialOrder (Concept α β r) | null | true |
_private.Init.Data.List.Lemmas.0.List.length_pos_iff_exists_mem.match_1_1 | Init.Data.List.Lemmas | ∀ {α : Type u_1} {l : List α} (motive : (∃ a, a ∈ l) → Prop) (x : ∃ a, a ∈ l),
(∀ (w : α) (h : w ∈ l), motive ⋯) → motive x | null | false |
_private.Mathlib.Algebra.Torsor.Basic.0.Equiv.right_vsub_pointReflection._simp_1_1 | Mathlib.Algebra.Torsor.Basic | ∀ {α : Type u_1} [inst : SubtractionMonoid α] (a : α) (n : ℕ), -(n • a) = n • -a | null | false |
CategoryTheory.Limits.WidePullbackShape.Hom.id.elim | Mathlib.CategoryTheory.Limits.Shapes.WidePullbacks | {J : Type w} →
{motive : (a a_1 : CategoryTheory.Limits.WidePullbackShape J) → a.Hom a_1 → Sort u} →
{a a_1 : CategoryTheory.Limits.WidePullbackShape J} →
(t : a.Hom a_1) →
t.ctorIdx = 0 →
((X : CategoryTheory.Limits.WidePullbackShape J) →
motive X X (CategoryTheory.Limits.Wi... | null | false |
_private.Mathlib.GroupTheory.GroupAction.SubMulAction.OfFixingSubgroup.0.SubMulAction.fixingSubgroup_map_conj_eq._simp_1_2 | Mathlib.GroupTheory.GroupAction.SubMulAction.OfFixingSubgroup | ∀ {G : Type u_1} [inst : DivInvMonoid G] (x : G), x⁻¹ = x ^ (-1) | null | false |
Fin.dfoldrM.loop._unsafe_rec | Batteries.Data.Fin.Basic | {m : Type u_1 → Type u_2} →
[Monad m] →
(n : ℕ) →
(α : Fin (n + 1) → Type u_1) →
((i : Fin n) → α i.succ → m (α i.castSucc)) → (i : ℕ) → (h : i < n + 1) → α ⟨i, h⟩ → m (α 0) | null | false |
MeasureTheory.aecover_closedBall | Mathlib.MeasureTheory.Integral.IntegralEqImproper | ∀ {α : Type u_1} {ι : Type u_2} [inst : MeasurableSpace α] {μ : MeasureTheory.Measure α} {l : Filter ι}
[inst_1 : PseudoMetricSpace α] [OpensMeasurableSpace α] {x : α} {r : ι → ℝ},
Filter.Tendsto r l Filter.atTop → MeasureTheory.AECover μ l fun i => Metric.closedBall x (r i) | null | true |
CartanMatrix.isSimplyLaced_D | Mathlib.LinearAlgebra.Matrix.Cartan | ∀ (n : ℕ), (CartanMatrix.D n).IsSimplyLaced | null | true |
BitVec.twoPow | Init.Data.BitVec.Basic | (w : ℕ) → ℕ → BitVec w | `twoPow w i` is the bitvector `2^i` if `i < w`, and `0` otherwise. In other words, it is 2 to the
power `i`.
From the bitwise point of view, it has the `i`th bit as `1` and all other bits as `0`.
| true |
_private.Init.Data.Array.Monadic.0.Array.foldlM_filterMap.match_1.eq_1 | Init.Data.Array.Monadic | ∀ {β : Type u_1} (motive : Option β → Sort u_2) (b : β) (h_1 : (b : β) → motive (some b)) (h_2 : Unit → motive none),
(match some b with
| some b => h_1 b
| none => h_2 ()) =
h_1 b | null | true |
AddSubgroup.normalCore_le | Mathlib.Algebra.Group.Subgroup.Basic | ∀ {G : Type u_1} [inst : AddGroup G] (H : AddSubgroup G), H.normalCore ≤ H | null | true |
LocalSubring.noConfusion | Mathlib.RingTheory.LocalRing.LocalSubring | {P : Sort u} →
{R : Type u_1} →
{inst : CommRing R} →
{t : LocalSubring R} →
{R' : Type u_1} →
{inst' : CommRing R'} →
{t' : LocalSubring R'} → R = R' → inst ≍ inst' → t ≍ t' → LocalSubring.noConfusionType P t t' | null | false |
_private.Mathlib.Analysis.Complex.CanonicalDecomposition.0.Complex.canonicalFactor_ne_zero._simp_1_3 | Mathlib.Analysis.Complex.CanonicalDecomposition | ∀ {α : Type u} [inst : PseudoMetricSpace α] {x y : α} {ε : ℝ}, (y ∈ Metric.closedBall x ε) = (dist y x ≤ ε) | null | false |
_private.Batteries.Data.String.Legacy.0.String.Legacy.posOfAux._proof_1 | Batteries.Data.String.Legacy | ∀ (s : String) (stopPos pos : String.Pos.Raw),
pos < stopPos → stopPos.byteIdx - (String.Pos.Raw.next s pos).byteIdx < stopPos.byteIdx - pos.byteIdx | null | false |
Set.smul_set_univ | Mathlib.Algebra.Group.Action.Pointwise.Set.Basic | ∀ {α : Type u_2} {β : Type u_3} [inst : Group α] [inst_1 : MulAction α β] {a : α}, a • Set.univ = Set.univ | null | true |
_private.Mathlib.MeasureTheory.Function.SimpleFunc.0.MeasureTheory.SimpleFunc.support_eq._simp_1_1 | Mathlib.MeasureTheory.Function.SimpleFunc | ∀ {ι : Type u_1} {M : Type u_3} [inst : Zero M] {f : ι → M} {x : ι}, (x ∈ Function.support f) = (f x ≠ 0) | null | false |
_private.Mathlib.Algebra.GroupWithZero.Range.0.MonoidWithZeroHom.valueGroup_eq_range._simp_1_8 | Mathlib.Algebra.GroupWithZero.Range | ∀ {M₀ : Type u_2} [inst : MonoidWithZero M₀] [Nontrivial M₀] (u : M₀ˣ), (↑u = 0) = False | null | false |
UInt16.reduceLT | Lean.Meta.Tactic.Simp.BuiltinSimprocs.UInt | Lean.Meta.Simp.Simproc | null | true |
List.pop_toArray | Init.Data.List.ToArray | ∀ {α : Type u_1} (l : List α), l.toArray.pop = l.dropLast.toArray | null | true |
DilationEquiv.symm_bijective | Mathlib.Topology.MetricSpace.DilationEquiv | ∀ {X : Type u_1} {Y : Type u_2} [inst : PseudoEMetricSpace X] [inst_1 : PseudoEMetricSpace Y],
Function.Bijective DilationEquiv.symm | null | true |
Valuation.HasExtension.instIsLocalHomValuationInteger | Mathlib.RingTheory.Valuation.Extension | ∀ {R : Type u_1} [inst : CommRing R] {ΓR : Type u_6} [inst_1 : LinearOrderedCommGroupWithZero ΓR] {vR : Valuation R ΓR}
{S : Type u_9} {ΓS : Type u_10} [inst_2 : CommRing S] [inst_3 : LinearOrderedCommGroupWithZero ΓS]
[inst_4 : Algebra R S] [IsLocalHom (algebraMap R S)] {vS : Valuation S ΓS} [inst_6 : vR.HasExtens... | null | true |
Vector.instOrientedCmpCompareLex | Init.Data.Ord.Vector | ∀ {α : Type u_1} {cmp : α → α → Ordering} [Std.OrientedCmp cmp] {n : ℕ}, Std.OrientedCmp (Vector.compareLex cmp) | null | true |
_private.Mathlib.Tactic.Ring.Basic.0.Mathlib.Tactic.Ring.ExSum.evalNatCast.match_3 | Mathlib.Tactic.Ring.Basic | {v : Lean.Level} →
{β : Q(Type v)} →
(sβ : Q(CommSemiring «$β»)) →
(motive : (a : Q(ℕ)) → Mathlib.Tactic.Ring.ExSum sβ a → Sort u_1) →
(a : Q(ℕ)) →
(va : Mathlib.Tactic.Ring.ExSum sβ a) →
(Unit → motive q(0) Mathlib.Tactic.Ring.Common.ExSum.zero) →
((a b : Q(«$β»)... | null | false |
DerivedCategory.descShortComplex_triangleOfSESδ | Mathlib.Algebra.Homology.DerivedCategory.ShortExact | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Abelian C]
[inst_2 : HasDerivedCategory C] {S : CategoryTheory.ShortComplex (CochainComplex C ℤ)} (hS : S.ShortExact),
CategoryTheory.CategoryStruct.comp (DerivedCategory.Q.map (CochainComplex.mappingCone.descShortComplex S))
(D... | null | true |
DFinsupp.instDFunLike | Mathlib.Data.DFinsupp.Defs | {ι : Type u} → {β : ι → Type v} → [inst : (i : ι) → Zero (β i)] → DFunLike (Π₀ (i : ι), β i) ι β | null | true |
Mathlib.Meta.FunProp.Mor.Arg.noConfusionType | Mathlib.Tactic.FunProp.Mor | Sort u → Mathlib.Meta.FunProp.Mor.Arg → Mathlib.Meta.FunProp.Mor.Arg → Sort u | null | false |
SimpleGraph.isMaximalIndepSet_compl._simp_1 | Mathlib.Combinatorics.SimpleGraph.Clique | ∀ {α : Type u_3} {G : SimpleGraph α} (s : Finset α), Maximal Gᶜ.IsIndepSet ↑s = Maximal G.IsClique ↑s | null | false |
Std.Format.group.injEq | Init.Data.Format.Basic | ∀ (a : Std.Format) (behavior : Std.Format.FlattenBehavior) (a_1 : Std.Format) (behavior_1 : Std.Format.FlattenBehavior),
(a.group behavior = a_1.group behavior_1) = (a = a_1 ∧ behavior = behavior_1) | null | true |
RingQuot.instRing._proof_8 | Mathlib.Algebra.RingQuot | ∀ {R : Type u_1} [inst : Ring R] (r : R → R → Prop) (n : ℕ),
{ toQuot := Quot.mk (RingQuot.Rel r) ↑↑n } = { toQuot := Quot.mk (RingQuot.Rel r) ↑n } | null | false |
Sym2.rec.match_1 | Mathlib.Data.Sym.Sym2 | {α : Type u_1} → (motive : α × α → Sort u_2) → (x : α × α) → ((a b : α) → motive (a, b)) → motive x | null | false |
CategoryTheory.Abelian.extFunctorObj._proof_1 | Mathlib.Algebra.Homology.DerivedCategory.Ext.Basic | ∀ (n : ℕ), n + 0 = n | null | false |
_private.Mathlib.RingTheory.PolynomialAlgebra.0.PolyEquivTensor.left_inv._simp_1_3 | Mathlib.RingTheory.PolynomialAlgebra | ∀ {R : Type u} {A : Type w} [inst : CommSemiring R] [inst_1 : Semiring A] [inst_2 : Algebra R A] (r : R) (x : A),
(algebraMap R A) r * x = r • x | null | false |
Subgroup.toAddSubgroup._proof_2 | Mathlib.Algebra.Group.Subgroup.Lattice | ∀ {G : Type u_1} [inst : Group G] (x : AddSubgroup (Additive G)),
(fun S =>
let __src := Submonoid.toAddSubmonoid S.toSubmonoid;
{ toAddSubmonoid := __src, neg_mem' := ⋯ })
((fun S =>
let __src := AddSubmonoid.toSubmonoid S.toAddSubmonoid;
{ toSubmonoid := __src, inv_mem' := ... | null | false |
EuclideanGeometry.orthogonalProjection.congr_simp | Mathlib.Geometry.Euclidean.Projection | ∀ {𝕜 : Type u_1} {V : Type u_2} {P : Type u_3} [inst : RCLike 𝕜] [inst_1 : NormedAddCommGroup V]
[inst_2 : InnerProductSpace 𝕜 V] [inst_3 : MetricSpace P] [inst_4 : NormedAddTorsor V P] (s : AffineSubspace 𝕜 P)
[inst_5 : Nonempty ↥s] [inst_6 : s.direction.HasOrthogonalProjection],
EuclideanGeometry.orthogonal... | null | true |
AlgebraicGeometry.isSmooth_isStableUnderBaseChange | Mathlib.AlgebraicGeometry.Morphisms.Smooth | CategoryTheory.MorphismProperty.IsStableUnderBaseChange @AlgebraicGeometry.Smooth | **Alias** of `AlgebraicGeometry.smooth_isStableUnderBaseChange`.
---
Smooth is stable under base change. | true |
_private.Mathlib.Algebra.Homology.Localization.0.HomotopyCategory.quotient_map_mem_quasiIso_iff._simp_1_1 | Mathlib.Algebra.Homology.Localization | ∀ {ι : Type u_1} {C : Type u} [inst : CategoryTheory.Category.{v, u} C]
[inst_1 : CategoryTheory.Limits.HasZeroMorphisms C] {c : ComplexShape ι} {K L : HomologicalComplex C c}
[inst_2 : CategoryTheory.CategoryWithHomology C] (f : K ⟶ L), HomologicalComplex.quasiIso C c f = QuasiIso f | null | false |
ByteArray.forIn.loop._proof_4 | Init.Data.ByteArray.Basic | ∀ (as : ByteArray), ∀ i < as.size, i ≤ as.size | null | false |
AddSubgroup.upperCentralSeriesStep_eq_comap_center | Mathlib.GroupTheory.Nilpotent | ∀ {G : Type u_1} [inst : AddGroup G] (N : AddSubgroup G) [inst_1 : N.Normal],
N.upperCentralSeriesStep = AddSubgroup.comap (QuotientAddGroup.mk' N) (AddSubgroup.center (G ⧸ N)) | The proof that `upperCentralSeriesStep N` is the preimage of the centre of `G/N`\
under the canonical surjection. | true |
Tuple.comp_sort_eq_comp_iff_monotone | Mathlib.Data.Fin.Tuple.Sort | ∀ {n : ℕ} {α : Type u_1} [inst : LinearOrder α] {f : Fin n → α} {σ : Equiv.Perm (Fin n)},
f ∘ ⇑σ = f ∘ ⇑(Tuple.sort f) ↔ Monotone (f ∘ ⇑σ) | A permutation of a tuple `f` is `f` sorted if and only if it is monotone. | true |
AddMonoidAlgebra.opRingEquiv_symm_single | Mathlib.Algebra.MonoidAlgebra.Opposite | ∀ {R : Type u_1} {M : Type u_2} [inst : Semiring R] [inst_1 : Add M] (r : Rᵐᵒᵖ) (x : Mᵃᵒᵖ),
AddMonoidAlgebra.opRingEquiv.symm (AddMonoidAlgebra.single x r) =
MulOpposite.op (AddMonoidAlgebra.single (AddOpposite.unop x) (MulOpposite.unop r)) | null | true |
CategoryTheory.Functor.mapHomologicalComplexIdIso._proof_2 | Mathlib.Algebra.Homology.Additive | ∀ {ι : Type u_1} (W₁ : Type u_3) [inst : CategoryTheory.Category.{u_2, u_3} W₁]
[inst_1 : CategoryTheory.Limits.HasZeroMorphisms W₁] (c : ComplexShape ι) (K : HomologicalComplex W₁ c) (i j : ι),
c.Rel i j →
CategoryTheory.CategoryStruct.comp
(CategoryTheory.Iso.refl ((((CategoryTheory.Functor.id W₁).map... | null | false |
cfcₙ.congr_simp | Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.NonUnital | ∀ {R : Type u_3} {A : Type u_4} {p p_1 : A → Prop} (e_p : p = p_1) [inst : CommSemiring R] [inst_1 : Nontrivial R]
[inst_2 : StarRing R] [inst_3 : MetricSpace R] [inst_4 : IsTopologicalSemiring R] [inst_5 : ContinuousStar R]
[inst_6 : NonUnitalRing A] [inst_7 : StarRing A] [inst_8 : TopologicalSpace A] [inst_9 : Mo... | null | true |
Lean.Meta.Grind.Arith.Cutsat.DvdCnstrProof.cooper₁ | Lean.Meta.Tactic.Grind.Arith.Cutsat.Types | Lean.Meta.Grind.Arith.Cutsat.CooperSplit → Lean.Meta.Grind.Arith.Cutsat.DvdCnstrProof | null | true |
Matrix.specialOrthogonalGroup | Mathlib.LinearAlgebra.UnitaryGroup | (n : Type u) →
[inst : DecidableEq n] → [inst_1 : Fintype n] → (R : Type v) → [inst_2 : CommRing R] → Submonoid (Matrix n n R) | `Matrix.specialOrthogonalGroup n` is the group of orthogonal `n` by `n` where the determinant
is one. (This definition is only correct if 2 is invertible.) | true |
Equiv.mulOneClass | Mathlib.Algebra.Group.TransferInstance | {α : Type u_2} → {β : Type u_3} → α ≃ β → [MulOneClass β] → MulOneClass α | Transfer `MulOneClass` across an `Equiv` | true |
_private.Std.Sync.Channel.0.Std.CloseableChannel.Bounded.State.casesOn | Std.Sync.Channel | {α : Type} →
{motive : Std.CloseableChannel.Bounded.State✝ α → Sort u} →
(t : Std.CloseableChannel.Bounded.State✝ α) →
((producers : Std.Queue (IO.Promise Bool)) →
(consumers : Std.Queue (Std.CloseableChannel.Bounded.Consumer✝ α)) →
(capacity : ℕ) →
(buf : Vector (IO.Ref ... | null | false |
_private.Mathlib.Data.List.OffDiag.0.List.Nodup.offDiag._proof_1_1 | Mathlib.Data.List.OffDiag | ∀ {α : Type u_1} {l : List α},
l.Nodup → ∀ (x y : α), (List.count x l * List.count y l - if x = y then List.count x l else 0) ≤ 1 | null | false |
_private.Mathlib.Combinatorics.Matroid.Map.0.Matroid.mapSetEmbedding._simp_1 | Mathlib.Combinatorics.Matroid.Map | ∀ {α : Type u} {s : Set α}, (s ⊆ ∅) = (s = ∅) | null | false |
IsCyclotomicExtension.Rat.galEquivZMod.eq_1 | Mathlib.NumberTheory.NumberField.Cyclotomic.Galois | ∀ (n : ℕ) [inst : NeZero n] (K : Type u_1) [inst_1 : Field K] [inst_2 : NumberField K]
[hK : IsCyclotomicExtension {n} ℚ K],
IsCyclotomicExtension.Rat.galEquivZMod n K = IsCyclotomicExtension.autEquivPow K ⋯ | null | true |
_private.Mathlib.Data.List.Sort.0.List.erase_orderedInsert_of_notMem._proof_1_1 | Mathlib.Data.List.Sort | ∀ {α : Type u_1} {r : α → α → Prop} [inst : DecidableRel r] [inst_1 : DecidableEq α] {x : α},
(List.orderedInsert r x []).erase x = [] | null | false |
_private.Mathlib.RingTheory.Ideal.MinimalPrime.Basic.0.Ideal.map_sup_mem_minimalPrimes_of_map_quotientMk_mem_minimalPrimes.match_1_1 | Mathlib.RingTheory.Ideal.MinimalPrime.Basic | ∀ {R : Type u_2} [inst : CommSemiring R] {S : Type u_1} [inst_1 : CommRing S] [inst_2 : Algebra R S] {I : Ideal R}
{J : Ideal S} (q : Ideal S) (motive : q.IsPrime ∧ Ideal.map (algebraMap R S) I ⊔ J ≤ q → Prop)
(x : q.IsPrime ∧ Ideal.map (algebraMap R S) I ⊔ J ≤ q),
(∀ (left : q.IsPrime) (hleq : Ideal.map (algebra... | null | false |
_private.Mathlib.Topology.MetricSpace.Infsep.0.Set.Finite.infsep._simp_1_3 | Mathlib.Topology.MetricSpace.Infsep | ∀ {α : Type u} {s : Set α} {a : α} (hs : s.Finite), (a ∈ hs.toFinset) = (a ∈ s) | null | false |
Module.Basis.toMatrix_smul | Mathlib.LinearAlgebra.Matrix.Basis | ∀ {ι : Type u_1} {R₁ : Type u_9} {S : Type u_10} [inst : CommSemiring R₁] [inst_1 : Semiring S] [inst_2 : Algebra R₁ S]
[inst_3 : Fintype ι] [inst_4 : DecidableEq ι] (x : S) (b : Module.Basis ι R₁ S) (w : ι → S),
b.toMatrix (x • w) = (Algebra.leftMulMatrix b) x * b.toMatrix w | null | true |
LinearMap.IsReflective.coroot._proof_1 | Mathlib.LinearAlgebra.RootSystem.OfBilinear | ∀ {R : Type u_1} {M : Type u_2} [inst : CommRing R] [inst_1 : AddCommGroup M] [inst_2 : Module R M]
(B : M →ₗ[R] M →ₗ[R] R) {x : M} (hx : B.IsReflective x) (a b : M), Exists.choose ⋯ = Exists.choose ⋯ + Exists.choose ⋯ | null | false |
ENNReal.ofReal_essSup | Mathlib.MeasureTheory.Function.EssSup | ∀ {α : Type u_1} {m : MeasurableSpace α} {μ : MeasureTheory.Measure α} {f : α → ℝ},
Filter.IsCoboundedUnder (fun x1 x2 => x1 ≤ x2) (MeasureTheory.ae μ) f →
Filter.IsBoundedUnder (fun x1 x2 => x1 ≤ x2) (MeasureTheory.ae μ) f →
ENNReal.ofReal (essSup f μ) = essSup (fun a => ENNReal.ofReal (f a)) μ | null | true |
_private.Mathlib.RingTheory.LocalRing.ResidueField.Ideal.0.instIsFractionRingQuotientIdealResidueField._simp_3 | Mathlib.RingTheory.LocalRing.ResidueField.Ideal | ∀ {R : Type u} [inst : Ring R] {I : Ideal R} [inst_1 : I.IsTwoSided] (x y : R),
(x - y ∈ I) = ((Ideal.Quotient.mk I) x = (Ideal.Quotient.mk I) y) | null | false |
CompactlySupportedContinuousMap.noConfusionType | Mathlib.Topology.ContinuousMap.CompactlySupported | Sort u →
{α : Type u_5} →
{β : Type u_6} →
[inst : TopologicalSpace α] →
[inst_1 : Zero β] →
[inst_2 : TopologicalSpace β] →
CompactlySupportedContinuousMap α β →
{α' : Type u_5} →
{β' : Type u_6} →
[inst' : TopologicalSpace α'] →... | null | false |
HomotopyEquiv.toHomologyIso._proof_1 | Mathlib.Algebra.Homology.Homotopy | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.Preadditive C] {ι : Type u_3}
{c : ComplexShape ι} {K L : HomologicalComplex C c} (h : HomotopyEquiv K L) (i : ι) [inst_2 : K.HasHomology i]
[inst_3 : L.HasHomology i],
CategoryTheory.CategoryStruct.comp (HomologicalComplex.ho... | null | false |
IsOpen.is_const_of_deriv_eq_zero | Mathlib.Analysis.Calculus.MeanValue | ∀ {𝕜 : Type u_3} {G : Type u_4} [inst : RCLike 𝕜] [inst_1 : NormedAddCommGroup G] [inst_2 : NormedSpace 𝕜 G] {f : 𝕜 → G}
{s : Set 𝕜},
IsOpen s → IsPreconnected s → DifferentiableOn 𝕜 f s → Set.EqOn (deriv f) 0 s → ∀ {x y : 𝕜}, x ∈ s → y ∈ s → f x = f y | null | true |
Std.IterM.fold_filterMapM | Init.Data.Iterators.Lemmas.Combinators.Monadic.FilterMap | ∀ {α β γ δ : Type w} {m : Type w → Type w'} {n : Type w → Type w''} [inst : Std.Iterator α m β]
[Std.Iterators.Finite α m] [inst_2 : Monad m] [LawfulMonad m] [inst_4 : Monad n] [inst_5 : MonadAttach n]
[LawfulMonad n] [WeaklyLawfulMonadAttach n] [inst_8 : Std.IteratorLoop α m n] [Std.LawfulIteratorLoop α m n]
[in... | null | true |
Std.Broadcast.Sync.send | Std.Sync.Broadcast | {α : Type} → Std.Broadcast.Sync α → α → IO ℕ | Send a value through the channel, blocking until the transmission could be completed.
| true |
_private.Mathlib.FieldTheory.Finite.Basic.0.FiniteField.exists_root_sum_quadratic._simp_1_2 | Mathlib.FieldTheory.Finite.Basic | ∀ {α : Type u_1} {β : Type u_2} [inst : DecidableEq β] {f : α → β} {s : Finset α} {b : β},
(b ∈ Finset.image f s) = ∃ a ∈ s, f a = b | null | false |
CategoryTheory.PreGaloisCategory.PointedGaloisObject.Hom.mk | Mathlib.CategoryTheory.Galois.Prorepresentability | {C : Type u₁} →
[inst : CategoryTheory.Category.{u₂, u₁} C] →
[inst_1 : CategoryTheory.GaloisCategory C] →
{F : CategoryTheory.Functor C FintypeCat} →
{A B : CategoryTheory.PreGaloisCategory.PointedGaloisObject F} →
(val : A.obj ⟶ B.obj) →
autoParam ((CategoryTheory.ConcreteCat... | null | true |
Std.DTreeMap.Internal.Impl.getKeyLE?.eq_1 | Std.Data.DTreeMap.Internal.Model | ∀ {α : Type u} {β : α → Type v} [inst : Ord α] (k : α),
Std.DTreeMap.Internal.Impl.getKeyLE? k = Std.DTreeMap.Internal.Impl.getKeyLE?.go k none | null | true |
MulAction.stabilizer_smul_eq_right | Mathlib.GroupTheory.GroupAction.Defs | ∀ {G : Type u_1} {β : Type u_3} [inst : Group G] [inst_1 : MulAction G β] {α : Type u_4} [inst_2 : Group α]
[inst_3 : MulAction α β] [SMulCommClass G α β] (a : α) (b : β),
MulAction.stabilizer G (a • b) = MulAction.stabilizer G b | null | true |
WeierstrassCurve.Projective.add | Mathlib.AlgebraicGeometry.EllipticCurve.Projective.Point | {R : Type r} → [CommRing R] → WeierstrassCurve.Projective R → (Fin 3 → R) → (Fin 3 → R) → Fin 3 → R | The addition of two projective point representatives on a Weierstrass curve. | true |
Subring.unop_sup | Mathlib.Algebra.Ring.Subring.MulOpposite | ∀ {R : Type u_2} [inst : NonAssocRing R] (S₁ S₂ : Subring Rᵐᵒᵖ), (S₁ ⊔ S₂).unop = S₁.unop ⊔ S₂.unop | null | true |
List.lex_nil | Init.Data.List.Basic | ∀ {α : Type u} {lt : α → α → Bool} [inst : BEq α] {as : List α}, as.lex [] lt = false | null | true |
map_eq_zero._simp_1 | Mathlib.Algebra.GroupWithZero.Units.Lemmas | ∀ {G₀ : Type u_3} {M₀' : Type u_4} {F : Type u_6} [inst : GroupWithZero G₀] [inst_1 : MulZeroOneClass M₀']
[Nontrivial M₀'] [inst_3 : FunLike F G₀ M₀'] [MonoidWithZeroHomClass F G₀ M₀'] (f : F) {a : G₀}, (f a = 0) = (a = 0) | null | false |
_private.Lean.Elab.DeclNameGen.0.Lean.Elab.Command.NameGen.MkNameState.mk.injEq | Lean.Elab.DeclNameGen | ∀ (seen : Lean.ExprSet) (consts : Lean.NameSet) (seen_1 : Lean.ExprSet) (consts_1 : Lean.NameSet),
({ seen := seen, consts := consts } = { seen := seen_1, consts := consts_1 }) = (seen = seen_1 ∧ consts = consts_1) | null | true |
CategoryTheory.Lax.LaxTrans.recOn | Mathlib.CategoryTheory.Bicategory.NaturalTransformation.Lax | {B : Type u₁} →
[inst : CategoryTheory.Bicategory B] →
{C : Type u₂} →
[inst_1 : CategoryTheory.Bicategory C] →
{F G : CategoryTheory.LaxFunctor B C} →
{motive : CategoryTheory.Lax.LaxTrans F G → Sort u} →
(t : CategoryTheory.Lax.LaxTrans F G) →
((app : (a : B) → ... | null | false |
Lean.PersistentEnvExtension.noConfusionType | Lean.Environment | Sort u →
{α β σ : Type} → Lean.PersistentEnvExtension α β σ → {α' β' σ' : Type} → Lean.PersistentEnvExtension α' β' σ' → Sort u | null | false |
MeasureTheory.VectorMeasure.exists_variation_le_add | Mathlib.MeasureTheory.VectorMeasure.Variation.Basic | ∀ {X : Type u_1} {V : Type u_2} {mX : MeasurableSpace X} [inst : TopologicalSpace V] [inst_1 : ENormedAddCommMonoid V]
[inst_2 : T2Space V] (μ : MeasureTheory.VectorMeasure X V) {s : Set X},
MeasurableSet s →
∀ {ε : NNReal},
0 < ε →
μ.variation s ≠ ⊤ →
∃ P,
(∀ t ∈ P, t ⊆ s) ∧... | Measure version of `preVariation.exists_Finpartition_sum_ge`. | true |
_private.Mathlib.Analysis.InnerProductSpace.TwoDim.0.Orientation.termω | Mathlib.Analysis.InnerProductSpace.TwoDim | Lean.ParserDescr | null | true |
Lean.Expr.NumApps.State.counters | Lean.Util.NumApps | Lean.Expr.NumApps.State → Lean.NameMap ℕ | null | true |
CategoryTheory.unop_whiskerLeft | Mathlib.CategoryTheory.Monoidal.Opposite | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] [inst_1 : CategoryTheory.MonoidalCategory C] (X : Cᵒᵖ)
{Y Z : Cᵒᵖ} (f : Y ⟶ Z),
(CategoryTheory.MonoidalCategoryStruct.whiskerLeft X f).unop =
CategoryTheory.MonoidalCategoryStruct.whiskerLeft (Opposite.unop X) f.unop | null | true |
SetRel.IsWellFounded.eq_1 | Mathlib.Order.RelSeries | ∀ {α : Type u_1} (R : SetRel α α), R.IsWellFounded = WellFounded fun x1 x2 => (x1, x2) ∈ R | null | true |
_private.Mathlib.RingTheory.Coalgebra.CoassocSimps.0.CoassocSimps._aux_Mathlib_RingTheory_Coalgebra_CoassocSimps___unexpand_TensorProduct_map_1 | Mathlib.RingTheory.Coalgebra.CoassocSimps | Lean.PrettyPrinter.Unexpander | null | false |
CategoryTheory.ShortComplex.LeftHomologyMapData.zero_φK | Mathlib.Algebra.Homology.ShortComplex.LeftHomology | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
{S₁ S₂ : CategoryTheory.ShortComplex C} (h₁ : S₁.LeftHomologyData) (h₂ : S₂.LeftHomologyData),
(CategoryTheory.ShortComplex.LeftHomologyMapData.zero h₁ h₂).φK = 0 | null | true |
_private.Lean.Meta.Match.Match.0.Lean.Meta.Match.MatcherKey.mk._flat_ctor | Lean.Meta.Match.Match | Lean.Expr → Bool → Bool → Lean.Meta.Match.MatcherKey✝ | null | false |
ContinuousLinearMap.restrictScalars_smul | Mathlib.Topology.Algebra.Module.ContinuousLinearMap.RestrictScalars | ∀ {A : Type u_1} {M₁ : Type u_2} {M₂ : Type u_3} {R : Type u_4} {S : Type u_5} [inst : Semiring A] [inst_1 : Semiring R]
[inst_2 : Semiring S] [inst_3 : AddCommMonoid M₁] [inst_4 : Module A M₁] [inst_5 : Module R M₁]
[inst_6 : TopologicalSpace M₁] [inst_7 : AddCommMonoid M₂] [inst_8 : Module A M₂] [inst_9 : Module ... | null | true |
_private.Mathlib.RingTheory.HahnSeries.Multiplication.0.HahnModule.smul_add._simp_1_1 | Mathlib.RingTheory.HahnSeries.Multiplication | ∀ {α : Type u_2} [inst : Preorder α] {s t : Set α}, (s ∪ t).IsPWO = (s.IsPWO ∧ t.IsPWO) | null | false |
Lean.Elab.TerminationHints.noConfusionType | Lean.Elab.PreDefinition.TerminationHint | Sort u → Lean.Elab.TerminationHints → Lean.Elab.TerminationHints → Sort u | null | false |
NumberField.IsCMField.isConj_complexConj | Mathlib.NumberTheory.NumberField.CMField | ∀ (K : Type u_1) [inst : Field K] [inst_1 : CharZero K] [inst_2 : NumberField.IsCMField K]
[inst_3 : Algebra.IsIntegral ℚ K] (φ : K →+* ℂ),
NumberField.ComplexEmbedding.IsConj φ (NumberField.IsCMField.complexConj K) | The complex conjugation is the conjugation of any complex embedding of a CM-field.
| true |
Nat.nth_add_one | Mathlib.Data.Nat.Nth | ∀ {p : ℕ → Prop} {n : ℕ}, ¬p 0 → Nat.nth p n ≠ 0 → Nat.nth (fun i => p (i + 1)) n + 1 = Nat.nth p n | null | true |
instLinearOrderedCommGroupWithZeroMultiplicativeOrderDualOfLinearOrderedAddCommGroupWithTop._proof_3 | Mathlib.Algebra.Order.GroupWithZero.Canonical | ∀ {α : Type u_1} [inst : LinearOrderedAddCommGroupWithTop α] (n : ℕ) (a : Multiplicative αᵒᵈ),
DivInvMonoid.zpow (↑n.succ) a = DivInvMonoid.zpow (↑n) a * a | null | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.