name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
_private.Mathlib.SetTheory.ZFC.Rank.0.PSet.rank_powerset._simp_1_2 | Mathlib.SetTheory.ZFC.Rank | ∀ {x y : PSet.{u_1}}, (y ∈ x.powerset) = (y ⊆ x) | null | false |
Lean.ProjectionFunctionInfo.mk | Lean.ProjFns | Lean.Name → ℕ → ℕ → Bool → Lean.ProjectionFunctionInfo | null | true |
CFC.rpow_sqrt_nnreal | Mathlib.Analysis.SpecialFunctions.ContinuousFunctionalCalculus.Rpow.Basic | ∀ {A : Type u_1} [inst : PartialOrder A] [inst_1 : Ring A] [inst_2 : StarRing A] [inst_3 : TopologicalSpace A]
[inst_4 : StarOrderedRing A] [inst_5 : Algebra ℝ A] [inst_6 : ContinuousFunctionalCalculus ℝ A IsSelfAdjoint]
[inst_7 : NonnegSpectrumClass ℝ A] [IsSemitopologicalRing A] [T2Space A] {a : A} {x : NNReal},
... | null | true |
Real.mk_add | Mathlib.Basic.Real.Basic | ∀ {f g : CauSeq ℚ abs}, Real.mk (f + g) = Real.mk f + Real.mk g | null | true |
LieModule.isLieAbelian_of_ker_traceForm_eq_bot | Mathlib.Algebra.Lie.TraceForm | ∀ (R : Type u_1) (L : Type u_3) (M : Type u_4) [inst : CommRing R] [inst_1 : LieRing L] [inst_2 : LieAlgebra R L]
[inst_3 : AddCommGroup M] [inst_4 : Module R M] [inst_5 : LieRingModule L M] [inst_6 : LieModule R L M]
[LieRing.IsNilpotent L] [IsDomain R] [Module.Free R M] [Module.Finite R M],
LinearMap.ker (LieMo... | A nilpotent Lie algebra with a representation whose trace form is non-singular is Abelian. | true |
SubMulAction.instOne | Mathlib.GroupTheory.GroupAction.SubMulAction.Pointwise | {R : Type u_1} → {M : Type u_2} → [inst : Monoid R] → [inst_1 : MulAction R M] → [One M] → One (SubMulAction R M) | null | true |
Function.const_inv | Mathlib.Algebra.Notation.Pi.Defs | ∀ {ι : Type u_1} {G : Type u_7} [inst : Inv G] (a : G), (Function.const ι a)⁻¹ = Function.const ι a⁻¹ | null | true |
instOrderBotSubtypeIsIdempotentElem._proof_1 | Mathlib.Algebra.Order.Ring.Idempotent | ∀ {M₀ : Type u_1} [inst : CommMonoidWithZero M₀], IsIdempotentElem 0 | null | false |
_private.Std.Sat.AIG.RefVecOperator.Map.0.Std.Sat.AIG.RefVec.denote_map._proof_1_1 | Std.Sat.AIG.RefVecOperator.Map | ∀ {len : ℕ} (idx : ℕ), ¬0 ≤ idx → False | null | false |
OpenSubgroup.instOrderTop._proof_1 | Mathlib.Topology.Algebra.OpenSubgroup | ∀ {G : Type u_1} [inst : Group G] [inst_1 : TopologicalSpace G] (x : OpenSubgroup G), ↑x ⊆ Set.univ | null | false |
_private.Mathlib.Tactic.Basify.0.Mathlib.Tactic.Basify.generalizeAtoms.match_3 | Mathlib.Tactic.Basify | (motive : Array Lean.Expr × Array Lean.Expr → Sort u_1) →
(x : Array Lean.Expr × Array Lean.Expr) →
((varAtoms termAtoms : Array Lean.Expr) → motive (varAtoms, termAtoms)) → motive x | null | false |
CommAlgCat.FiniteEtale.ofHom | Mathlib.RingTheory.Etale.Finite | {R : Type u} →
[inst : CommRing R] →
{S T : Type v} →
[inst_1 : CommRing S] →
[inst_2 : CommRing T] →
[inst_3 : Algebra R S] →
[inst_4 : Algebra R T] →
[inst_5 : Module.Finite R S] →
[inst_6 : Algebra.Etale R S] →
[inst_7 : Module... | Construct a morphism in `FiniteEtale R` from an algebra map. | true |
BddDistLat.Hom.Simps.hom | Mathlib.Order.Category.BddDistLat | (X Y : BddDistLat) → X.Hom Y → BoundedLatticeHom ↑X.toDistLat ↑Y.toDistLat | Use the `ConcreteCategory.hom` projection for `@[simps]` lemmas. | true |
Lean.Server.RequestContext | Lean.Server.Requests | Type | null | true |
AlgebraicGeometry.Scheme.Modules.Hom | Mathlib.AlgebraicGeometry.Modules.Sheaf | {X : AlgebraicGeometry.Scheme} → X.Modules → X.Modules → Type u | Morphisms between `𝒪ₓ`-modules. Use `Hom.app` to act on sections. | true |
Quaternion.imJ_coe | Mathlib.Algebra.Quaternion | ∀ {R : Type u_3} [inst : CommRing R] (x : R), (↑x).imJ = 0 | null | true |
ENNReal.instSemilatticeSup._aux_1 | Mathlib.Basic.ENNReal.Basic | ENNReal → ENNReal → ENNReal | null | false |
Polynomial.instCommRingUniversalFactorizationRing._proof_25 | Mathlib.RingTheory.Polynomial.UniversalFactorizationRing | ∀ {R : Type u_1} [inst : CommRing R] {n : ℕ} (m k : ℕ) (hn : n = m + k) (p : Polynomial.MonicDegreeEq R n)
(a : Polynomial.UniversalFactorizationRing m k hn p), a * 0 = 0 | null | false |
Lean.commandDeclare_uint_simprocs_ | Lean.Meta.Tactic.Simp.BuiltinSimprocs.UInt | Lean.ParserDescr | null | true |
LinearEquiv.extendScalarsOfSurjective | Mathlib.Algebra.Algebra.Basic | {R : Type u_1} →
{S : Type u_2} →
[inst : CommSemiring R] →
[inst_1 : Semiring S] →
[inst_2 : Algebra R S] →
{M : Type u_3} →
{N : Type u_4} →
[inst_3 : AddCommMonoid M] →
[inst_4 : AddCommMonoid N] →
[inst_5 : Module R M] →
... | If `R →+* S` is surjective, then `R`-linear isomorphisms are also `S`-linear. | true |
Localization.AtPrime.mapPiEvalRingHom_comp_algebraMap | Mathlib.RingTheory.Localization.AtPrime.Basic | ∀ {ι : Type u_4} {R : ι → Type u_5} [inst : (i : ι) → CommSemiring (R i)] {i : ι} (I : Ideal (R i))
[inst_1 : I.IsPrime],
(Localization.AtPrime.mapPiEvalRingHom I).comp
(algebraMap ((i : ι) → R i) (Localization.AtPrime (Ideal.comap (Pi.evalRingHom R i) I))) =
(algebraMap (R i) (Localization.AtPrime I)).co... | null | true |
notation_class | Mathlib.Tactic.Simps.NotationClass | Lean.ParserDescr | The `@[notation_class]` attribute specifies that this is a notation class,
and this notation should be used instead of projections by `@[simps]`.
* This is only important if the projection is written differently using notation, e.g.
`+` uses `HAdd.hAdd`, not `Add.add` and `0` uses `OfNat.ofNat` not `Zero.zero`.
... | true |
FreeRing.coe_sub | Mathlib.RingTheory.FreeCommRing | ∀ {α : Type u} (x y : FreeRing α), ↑(x - y) = ↑x - ↑y | null | true |
CategoryTheory.ShortComplex.homologyπ | Mathlib.Algebra.Homology.ShortComplex.Homology | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
[inst_1 : CategoryTheory.Limits.HasZeroMorphisms C] →
(S : CategoryTheory.ShortComplex C) → [inst_2 : S.HasHomology] → S.cycles ⟶ S.homology | The canonical morphism `S.cycles ⟶ S.homology` for a short complex `S` that has homology. | true |
Topology.IsLowerSet.closure_eq_upperClosure | Mathlib.Topology.Order.UpperLowerSetTopology | ∀ {α : Type u_1} [inst : Preorder α] [inst_1 : TopologicalSpace α] [Topology.IsLowerSet α] {s : Set α},
closure s = ↑(upperClosure s) | null | true |
CategoryTheory.OplaxFunctor.PseudoCore | Mathlib.CategoryTheory.Bicategory.Functor.Oplax | {B : Type u₁} →
[inst : CategoryTheory.Bicategory B] →
{C : Type u₂} → [inst_1 : CategoryTheory.Bicategory C] → CategoryTheory.OplaxFunctor B C → Type (max (max u₁ v₁) w₂) | A structure on an oplax functor that promotes an oplax functor to a pseudofunctor.
See `Pseudofunctor.mkOfOplax`. | true |
Unitary.spectrum_subset_slitPlane_iff_norm_lt_two | Mathlib.Analysis.CStarAlgebra.Unitary.Connected | ∀ {A : Type u_1} [inst : CStarAlgebra A] {u : A}, u ∈ unitary A → (spectrum ℂ u ⊆ Complex.slitPlane ↔ ‖u - 1‖ < 2) | null | true |
Std.TreeSet.Raw.le_min! | Std.Data.TreeSet.Raw.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} {t : Std.TreeSet.Raw α cmp} [Std.TransCmp cmp] [inst : Inhabited α],
t.WF → t.isEmpty = false → ∀ {k : α}, (cmp k t.min!).isLE = true ↔ ∀ k' ∈ t, (cmp k k').isLE = true | null | true |
MeasureTheory.isMulLeftInvariant_map | Mathlib.MeasureTheory.Group.Measure | ∀ {G : Type u_1} [inst : MeasurableSpace G] [inst_1 : Mul G] {μ : MeasureTheory.Measure G} [MeasurableMul G]
{H : Type u_3} [inst_3 : MeasurableSpace H] [inst_4 : Mul H] [MeasurableMul H] [μ.IsMulLeftInvariant] (f : G →ₙ* H),
Measurable ⇑f → Function.Surjective ⇑f → (MeasureTheory.Measure.map (⇑f) μ).IsMulLeftInvar... | null | true |
CategoryTheory.Limits.binaryBiconeOfIsSplitEpiOfKernel._proof_7 | Mathlib.CategoryTheory.Preadditive.Biproducts | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] {X Y : C} {f : X ⟶ Y}
[inst_1 : CategoryTheory.IsSplitEpi f],
CategoryTheory.CategoryStruct.comp (CategoryTheory.section_ f) f = CategoryTheory.CategoryStruct.id Y | null | false |
AlgebraicGeometry.IsAffineOpen.basicOpen_basicOpen_is_basicOpen | Mathlib.AlgebraicGeometry.AffineScheme | ∀ {X : AlgebraicGeometry.Scheme} {U : X.Opens},
AlgebraicGeometry.IsAffineOpen U →
∀ (f : ↑(X.presheaf.obj (Opposite.op U))) (g : ↑(X.presheaf.obj (Opposite.op (X.basicOpen f)))),
∃ f', X.basicOpen f' = X.basicOpen g | null | true |
DistribLattice.ofInfSupLe | Mathlib.Order.Defs.Lattice | {α : Type u} → [inst : Lattice α] → (∀ (a b c : α), a ⊓ (b ⊔ c) ≤ a ⊓ b ⊔ a ⊓ c) → DistribLattice α | Prove distributivity of an existing lattice from the dual distributive law. | true |
KaehlerDifferential.moduleBaseChange._proof_3 | Mathlib.RingTheory.Kaehler.TensorProduct | ∀ (R : Type u_3) (S : Type u_1) (A : Type u_2) [inst : CommRing R] [inst_1 : CommRing S] [inst_2 : Algebra R S]
[inst_3 : CommRing A] [inst_4 : Algebra R A] (r s : A) (x : TensorProduct R S Ω[A⁄R]), (r + s) • x = r • x + s • x | null | false |
instContinuousAddWeakSpace | Mathlib.Topology.Algebra.Module.Spaces.WeakDual | ∀ (𝕜 : Type u_2) (E : Type u_1) [inst : CommSemiring 𝕜] [inst_1 : TopologicalSpace 𝕜] [inst_2 : ContinuousAdd 𝕜]
[inst_3 : ContinuousConstSMul 𝕜 𝕜] [inst_4 : AddCommMonoid E] [inst_5 : Module 𝕜 E] [inst_6 : TopologicalSpace E],
ContinuousAdd (WeakSpace 𝕜 E) | null | true |
nndist_inv_inv₀ | Mathlib.Analysis.Normed.Field.Basic | ∀ {α : Type u_1} [inst : NormedDivisionRing α] {z w : α}, z ≠ 0 → w ≠ 0 → nndist z⁻¹ w⁻¹ = nndist z w / (‖z‖₊ * ‖w‖₊) | null | true |
Sum.isLeft_iff | Init.Data.Sum.Lemmas | ∀ {α : Type u_1} {β : Type u_2} {x : α ⊕ β}, x.isLeft = true ↔ ∃ y, x = Sum.inl y | null | true |
boolAlg_dual_comp_forget_to_bddDistLat | Mathlib.Order.Category.BoolAlg | BoolAlg.dual.comp (CategoryTheory.forget₂ BoolAlg BddDistLat) =
(CategoryTheory.forget₂ BoolAlg BddDistLat).comp BddDistLat.dual | null | true |
NumberField.InfinitePlace.mkReal._proof_1 | Mathlib.NumberTheory.NumberField.InfinitePlace.Basic | ∀ {K : Type u_1} [inst : Field K] (w : { w // w.IsReal }),
(fun φ => ⟨NumberField.InfinitePlace.mk ↑φ, ⋯⟩) ⟨(↑w).embedding, ⋯⟩ = w | null | false |
_private.Batteries.Data.List.Lemmas.0.List.findIdxNth_countPBefore_of_lt_length_of_pos._proof_1_5 | Batteries.Data.List.Lemmas | ∀ {α : Type u_1} (head : α) (tail : List α) {i : ℕ} {h : i < (head :: tail).length},
-1 * ↑i + 1 ≤ 0 → i - 1 < tail.length | null | false |
_private.Lean.Elab.Declaration.0.Lean.Elab.Command.elabMutual._regBuiltin.Lean.Elab.Command.elabMutual_1 | Lean.Elab.Declaration | IO Unit | null | false |
_private.Batteries.CodeAction.Match.0.Batteries.CodeAction.matchExpand.match_1 | Batteries.CodeAction.Match | (motive : Option Lean.Syntax.Range → Sort u_1) →
(x : Option Lean.Syntax.Range) →
((headerRangeRaw : Lean.Syntax.Range) → motive (some headerRangeRaw)) →
((x : Option Lean.Syntax.Range) → motive x) → motive x | null | false |
NonUnitalAlgHomClass | Mathlib.Algebra.Algebra.NonUnitalHom | (F : Type u_1) →
(R : outParam (Type u_2)) →
(A : outParam (Type u_3)) →
(B : outParam (Type u_4)) →
[inst : Monoid R] →
[inst_1 : NonUnitalNonAssocSemiring A] →
[inst_2 : NonUnitalNonAssocSemiring B] →
[DistribMulAction R A] → [DistribMulAction R B] → [FunLike F ... | `NonUnitalAlgHomClass F R A B` asserts `F` is a type of bundled algebra homomorphisms
from `A` to `B` which are `R`-linear.
This is an abbreviation to `NonUnitalAlgSemiHomClass F (MonoidHom.id R) A B` | true |
instAssociativeUInt32HMul | Init.Data.UInt.Lemmas | Std.Associative fun x1 x2 => x1 * x2 | null | true |
_private.Lean.Parser.Term.0.Lean.Parser.Term.borrowed._regBuiltin.Lean.Parser.Term.borrowed.declRange_5 | Lean.Parser.Term | IO Unit | null | false |
_private.Init.Data.Range.Polymorphic.Internal.SignedBitVec.0.BitVec.Signed.sle_iff_rotate_le_rotate._proof_1_11 | Init.Data.Range.Polymorphic.Internal.SignedBitVec | ∀ (n : ℕ) (x y : BitVec (n + 1)), ¬(x.toNat ≤ y.toNat ↔ x.toNat + 2 ^ n ≤ y.toNat + 2 ^ n) → False | null | false |
List.Cursor.pos_le_length | Std.Do.Triple.SpecLemmas | ∀ {α : Type u_1} {l : List α} {c : l.Cursor}, c.pos ≤ l.length | null | true |
Lean.Meta.Grind.MethodsRef | Lean.Meta.Tactic.Grind.Types | Type | null | true |
_private.Mathlib.Topology.EMetricSpace.Lipschitz.0.continuousOn_prod_of_subset_closure_continuousOn_lipschitzOnWith.match_1_3 | Mathlib.Topology.EMetricSpace.Lipschitz | ∀ {α : Type u_1} {β : Type u_2} {γ : Type u_3} [inst : PseudoEMetricSpace α] [inst_1 : PseudoEMetricSpace γ]
(f : α × β → γ) {s : Set α} {t : Set β} (x : α) (y : β) (ε : ENNReal) (δ : NNReal) (x' a : α) (b : β)
(motive : (a, b) ∈ (s ∩ Metric.eball x ↑δ) ×ˢ (t ∩ {b | edist (f (x', b)) (f (x', y)) ≤ ε / 2}) → Prop)
... | null | false |
_private.Mathlib.Combinatorics.Enumerative.Schroder.0.Nat.smallSchroder.match_1.eq_2 | Mathlib.Combinatorics.Enumerative.Schroder | ∀ (motive : ℕ → Sort u_1) (h_1 : Unit → motive 0) (h_2 : Unit → motive 1) (h_3 : (n : ℕ) → motive n.succ),
(match 1 with
| 0 => h_1 ()
| 1 => h_2 ()
| n.succ => h_3 n) =
h_2 () | null | true |
_private.Mathlib.Combinatorics.Graph.Subgraph.0.Graph.IsLink.anti_of_mem | Mathlib.Combinatorics.Graph.Subgraph | ∀ {α : Type u_1} {β : Type u_2} {x y : α} {e : β} {G H : Graph α β},
G.IsLink e x y → H ≤ G → e ∈ H.edgeSet → H.IsLink e x y | null | true |
isGδ_induced | Mathlib.Topology.GDelta.Basic | ∀ {X : Type u_1} {Y : Type u_2} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y] {f : X → Y} {s : Set Y},
Continuous f → IsGδ s → IsGδ (f ⁻¹' s) | **Alias** of `IsGδ.preimage`.
---
The preimage of a Gδ set under a continuous map is Gδ. | true |
_private.Mathlib.Analysis.BoxIntegral.Basic.0.BoxIntegral.integrable_of_bounded_and_ae_continuousWithinAt._simp_1_5 | Mathlib.Analysis.BoxIntegral.Basic | ∀ {α : Type u_1} {ι : Sort u_4} {s : ι → Set α} {t : Set α}, (⋃ i, s i ⊆ t) = ∀ (i : ι), s i ⊆ t | null | false |
add_dotProduct | Mathlib.Data.Matrix.Mul | ∀ {m : Type u_2} {α : Type v} [inst : Fintype m] [inst_1 : NonUnitalNonAssocSemiring α] (u v w : m → α),
(u + v) ⬝ᵥ w = u ⬝ᵥ w + v ⬝ᵥ w | null | true |
WittVector.eval | Mathlib.RingTheory.WittVector.Defs | {p : ℕ} →
{R : Type u_1} → [CommRing R] → {k : ℕ} → (ℕ → MvPolynomial (Fin k × ℕ) ℤ) → (Fin k → WittVector p R) → WittVector p R | Let `φ` be a family of polynomials, indexed by natural numbers, whose variables come from the
disjoint union of `k` copies of `ℕ`, and let `xᵢ` be a Witt vector for `0 ≤ i < k`.
`eval φ x` evaluates `φ` mapping the variable `X_(i, n)` to the `n`th coefficient of `xᵢ`.
Instantiating `φ` with certain polynomials define... | true |
SSet.Subcomplex.PairingCore.RankFunction._sizeOf_1 | Mathlib.AlgebraicTopology.SimplicialSet.AnodyneExtensions.Rank | {X : SSet} →
{A : X.Subcomplex} → {h : A.PairingCore} → {α : Type v} → {inst : PartialOrder α} → [SizeOf α] → h.RankFunction α → ℕ | null | false |
Lean.Level.PP.Context._sizeOf_inst | Lean.Level | SizeOf Lean.Level.PP.Context | null | false |
Std.TreeMap.getEntryGT? | Std.Data.TreeMap.Basic | {α : Type u} → {β : Type v} → {cmp : α → α → Ordering} → Std.TreeMap α β cmp → α → Option (α × β) | Tries to retrieve the key-value pair with the smallest key that is greater than the given key,
returning `none` if no such pair exists.
| true |
UniformSpace.Completion.ring._proof_11 | Mathlib.Topology.Algebra.UniformRing | ∀ {α : Type u_1} [inst : Ring α] [inst_1 : UniformSpace α] [IsTopologicalRing α] [inst_3 : IsUniformAddGroup α] (a : α),
↑a * 1 = ↑a | null | false |
CentroidHom.coe_sub._simp_1 | Mathlib.Algebra.Ring.CentroidHom | ∀ {α : Type u_5} [inst : NonUnitalNonAssocRing α] (f g : CentroidHom α), ⇑f - ⇑g = ⇑(f - g) | null | false |
_private.Init.Data.Array.BinSearch.0.Array.binInsertAux._unary._proof_2 | Init.Data.Array.BinSearch | ∀ {α : Type u_1} (as : Array α) (lo : Fin as.size), ↑lo < as.size | null | false |
Semiring.toGrindSemiring._proof_15 | Mathlib.Algebra.Ring.GrindInstances | ∀ (α : Type u_1) [s : Semiring α] (x : ℕ), OfNat.ofNat x = ↑x | null | false |
Filter.Tendsto.div_const | Mathlib.Topology.Algebra.GroupWithZero | ∀ {α : Type u_1} {G₀ : Type u_3} [inst : DivInvMonoid G₀] [inst_1 : TopologicalSpace G₀] [SeparatelyContinuousMul G₀]
{f : α → G₀} {l : Filter α} {x : G₀},
Filter.Tendsto f l (nhds x) → ∀ (y : G₀), Filter.Tendsto (fun a => f a / y) l (nhds (x / y)) | null | true |
_private.Lean.LibrarySuggestions.Basic.0.Lean.LibrarySuggestions.Selector.intersperse._proof_5 | Lean.LibrarySuggestions.Basic | ∀ (c : Lean.LibrarySuggestions.Config) (suggestions₁ : Array Lean.LibrarySuggestions.Suggestion)
(__s : Array Lean.LibrarySuggestions.Suggestion × ℕ),
__s.2 < suggestions₁.size ∧ __s.1.size < c.maxSuggestions → ¬__s.2 < suggestions₁.size → False | null | false |
Lean.Doc.Inline.concat.sizeOf_spec | Lean.DocString.Types | ∀ {i : Type u} [inst : SizeOf i] (content : Array (Lean.Doc.Inline i)),
sizeOf (Lean.Doc.Inline.concat content) = 1 + sizeOf content | null | true |
RingEquiv.prodComm_trans_prodComm | Mathlib.Algebra.Ring.Prod | ∀ {R : Type u_1} {S : Type u_3} [inst : NonAssocSemiring R] [inst_1 : NonAssocSemiring S],
RingEquiv.prodComm.trans RingEquiv.prodComm = RingEquiv.refl (R × S) | null | true |
_private.Std.Data.String.ToInt.0.String.Slice.toInt?_eq_some_iff._simp_1_4 | Std.Data.String.ToInt | ∀ {α : Type u_1} {b : α} {α_1 : Type u_2} {x : Option α_1} {f : α_1 → α},
(Option.map f x = some b) = ∃ a, x = some a ∧ f a = b | null | false |
Function.surjective_iff_hasRightInverse | Mathlib.Logic.Function.Basic | ∀ {α : Sort u} {β : Sort v} {f : α → β}, Function.Surjective f ↔ Function.HasRightInverse f | null | true |
Std.WP.WPMonad.wp_monadMap_StateT_apply_eq.match_1 | Std.WP.Monad.Lemmas | {σ α : Type u_1} → (motive : α × σ → Sort u_2) → (x : α × σ) → ((a : α) → (s' : σ) → motive (a, s')) → motive x | null | false |
smul_top | Mathlib.Algebra.Order.Group.Action | ∀ {α : Type u_3} {G : Type u_4} [inst : Group G] [inst_1 : PartialOrder α] [inst_2 : MulAction G α]
[CovariantClass G α HSMul.hSMul LE.le] [inst_4 : OrderTop α] (g : G), g • ⊤ = ⊤ | A group acting monotonically fixes `⊤`. | true |
Mathlib.Tactic.AtomM.RecurseM | Mathlib.Util.AtomM.Recurse | Type → Type | The monad for `AtomM.Recurse` contains, in addition to the `AtomM` state,
a simp context for the main traversal and a cleanup function to simplify evaluation results. | true |
SemidirectProduct.mulEquivSubgroup_symm_apply | Mathlib.GroupTheory.SemidirectProduct | ∀ {G : Type u_2} [inst : Group G] {H K : Subgroup G} [inst_1 : H.Normal] (h : H.IsComplement' K) (b : G),
(SemidirectProduct.mulEquivSubgroup h).symm b = Function.surjInv ⋯ b | null | true |
_private.Mathlib.RingTheory.Ideal.KrullsHeightTheorem.0.Ideal.mem_minimalPrimes_span_of_mem_minimalPrimes_span_insert.match_1_2 | Mathlib.RingTheory.Ideal.KrullsHeightTheorem | ∀ {R : Type u_1} [inst : CommRing R] (x : R) (t : Set R) (f : R →+* R ⧸ Ideal.span t) (r : Ideal (R ⧸ Ideal.span t))
(motive : r.IsPrime ∧ Ideal.map f (Ideal.span {x}) ≤ r → Prop) (x_1 : r.IsPrime ∧ Ideal.map f (Ideal.span {x}) ≤ r),
(∀ (hr : r.IsPrime) (hxr : Ideal.map f (Ideal.span {x}) ≤ r), motive ⋯) → motive x... | null | false |
Std.Http.Protocol.H1.Reader.BodyState._sizeOf_1 | Std.Http.Protocol.H1.Reader | Std.Http.Protocol.H1.Reader.BodyState → ℕ | null | false |
SheafOfModules.LocalGeneratorsData.quasiCoherentData._proof_6 | Mathlib.Algebra.Category.ModuleCat.Sheaf.LocallyFree | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_3, u_2} C] {J : CategoryTheory.GrothendieckTopology C}
{R : CategoryTheory.Sheaf J RingCat} [inst_1 : ∀ (X : C), CategoryTheory.HasSheafify (J.over X) AddCommGrpCat]
[inst_2 : ∀ (X : C), (J.over X).WEqualsLocallyBijective AddCommGrpCat] {M : SheafOfModules R}
(q... | null | false |
AlgebraicGeometry.Scheme.IdealSheafData.range_glueDataObjι_ι | Mathlib.AlgebraicGeometry.IdealSheaf.Subscheme | ∀ {X : AlgebraicGeometry.Scheme} (I : X.IdealSheafData) (U : ↑X.affineOpens),
Set.range ⇑(CategoryTheory.CategoryStruct.comp (I.glueDataObjι U) (↑U).ι) = X.zeroLocus ↑(I.ideal U) ∩ ↑↑U | null | true |
CoalgEquiv.coe_ofClass | Mathlib.RingTheory.Coalgebra.Equiv | ∀ {R : Type u_1} {A : Type u_2} {B : Type u_3} [inst : CommSemiring R] [inst_1 : AddCommMonoid A]
[inst_2 : AddCommMonoid B] [inst_3 : Module R A] [inst_4 : Module R B] [inst_5 : CoalgebraStruct R A]
[inst_6 : CoalgebraStruct R B] (e : A ≃ₗc[R] B), ⇑↑e = ⇑e | null | true |
m_Birkhoff_inequalities | Mathlib.Algebra.Order.Group.Unbundled.Abs | ∀ {α : Type u_1} [inst : Lattice α] [inst_1 : CommGroup α] [MulLeftMono α] (a b c : α),
|(a ⊔ c) / (b ⊔ c)|ₘ ⊔ |(a ⊓ c) / (b ⊓ c)|ₘ ≤ |a / b|ₘ | null | true |
Inv.mk | Init.Prelude | {α : Type u} → (α → α) → Inv α | null | true |
AddSubgroup.relIindex_dvd_two_iff' | Mathlib.GroupTheory.Index | ∀ {G : Type u_1} [inst : AddGroup G] {H K : AddSubgroup G}, H.relIndex K ∣ 2 ↔ ∃ a ∈ K, ∀ b ∈ K, a + b ∈ H ∨ b ∈ H | **Alias** of `AddSubgroup.relIndex_dvd_two_iff'`.
---
Relative version of `AddSubgroup.index_dvd_two_iff'`. | true |
Int.fdiv.eq_5 | Init.Data.Int.DivMod.Basic | ∀ (m n : ℕ), (Int.negSucc m).fdiv (Int.ofNat n.succ) = Int.negSucc (m / n.succ) | null | true |
LinearIsometryEquiv.toSpanUnitSingleton._proof_4 | Mathlib.Analysis.Normed.Module.Span | ∀ {𝕜 : Type u_1} [inst : NormedDivisionRing 𝕜], IsDomain 𝕜 | null | false |
AbstractMeasure.instFunLikeContinuousMap._proof_3 | Mathlib.NumberTheory.Padics.Measure.Basic | ∀ {X : Type u_1} {R : Type u_2} {E : Type u_3} [inst : TopologicalSpace X] [inst_1 : AddCommGroup E]
[inst_2 : TopologicalSpace E] [inst_3 : CommRing R] [inst_4 : TopologicalSpace R] [inst_5 : IsTopologicalRing R]
[inst_6 : Module R E], Function.Injective AbstractMeasure.instFunLikeContinuousMap._aux_1 | null | false |
Geometry.SimplicialComplex.ofAffineIndependent._proof_2 | Mathlib.Analysis.Convex.SimplicialComplex.AffineIndependentUnion | ∀ {𝕜 : Type u_2} {E : Type u_1} [inst : Field 𝕜] [inst_1 : AddCommGroup E] [inst_2 : Module 𝕜 E]
(abstract : PreAbstractSimplicialComplex E),
AffineIndependent 𝕜 Subtype.val → ∀ {s : Finset E}, s ∈ abstract.faces → AffineIndependent 𝕜 fun x => ↑x | null | false |
String.Slice.instDecidableEqPos.decEq | Init.Data.String.Defs | {s : String.Slice} → (x x_1 : s.Pos) → Decidable (x = x_1) | null | true |
tsum_geometric_of_lt_one | Mathlib.Analysis.SpecificLimits.Basic | ∀ {r : ℝ}, 0 ≤ r → r < 1 → ∑' (n : ℕ), r ^ n = (1 - r)⁻¹ | null | true |
IsSimpleRing.exists_algEquiv_matrix_of_isAlgClosed | Mathlib.RingTheory.SimpleModule.IsAlgClosed | ∀ (F : Type u_1) (R : Type u_2) [inst : Field F] [IsAlgClosed F] [inst_2 : Ring R] [inst_3 : Algebra F R]
[IsSimpleRing R] [FiniteDimensional F R], ∃ n, ∃ (_ : NeZero n), Nonempty (R ≃ₐ[F] Matrix (Fin n) (Fin n) F) | The **Wedderburn–Artin Theorem** over algebraically closed fields: a finite-dimensional
simple algebra over an algebraically closed field is isomorphic to a matrix algebra over the field.
| true |
ProbabilityTheory.condExp_prod_ae_eq_integral_condDistrib₀ | Mathlib.Probability.Kernel.CondDistrib | ∀ {α : Type u_1} {β : Type u_2} {Ω : Type u_3} {F : Type u_4} [inst : MeasurableSpace Ω] [inst_1 : StandardBorelSpace Ω]
[inst_2 : Nonempty Ω] [inst_3 : NormedAddCommGroup F] {mα : MeasurableSpace α} {μ : MeasureTheory.Measure α}
[inst_4 : MeasureTheory.IsFiniteMeasure μ] {X : α → β} {Y : α → Ω} {mβ : MeasurableSpa... | The conditional expectation of a function `f` of the product `(X, Y)` is almost everywhere equal
to the integral of `y ↦ f(X, y)` against the `condDistrib` kernel. | true |
_private.Mathlib.RingTheory.Smooth.NoetherianDescent.0.Algebra.Smooth.DescentAux.q | Mathlib.RingTheory.Smooth.NoetherianDescent | {A : Type u} →
{B : Type u_2} →
[inst : CommRing A] →
[inst_1 : CommRing B] →
[inst_2 : Algebra A B] →
(self : Algebra.Smooth.DescentAux✝ A B) →
Algebra.Smooth.DescentAux.vars✝ self →
MvPolynomial (Algebra.Smooth.DescentAux.rels✝ self) (Algebra.Smooth.DescentAux.P... | null | true |
TopCat.coe_of_of | Mathlib.Topology.Category.TopCat.Basic | ∀ {X Y : Type u} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y] {f : C(X, Y)}
{x : (CategoryTheory.forget TopCat).obj ↧X}, (TopCat.ofHom f) x = f x | Replace a function coercion for a morphism `TopCat.of X ⟶ TopCat.of Y` with the definitionally
equal function coercion for a continuous map `C(X, Y)`.
| true |
_private.Lean.Meta.Tactic.Simp.BuiltinSimprocs.UInt.0._regBuiltin.UInt8.reduceMod.declare_36._@.Lean.Meta.Tactic.Simp.BuiltinSimprocs.UInt.2231631932._hygCtx._hyg.134 | Lean.Meta.Tactic.Simp.BuiltinSimprocs.UInt | IO Unit | null | false |
_private.Mathlib.Algebra.Module.ZLattice.Covolume.0._auto_28 | Mathlib.Algebra.Module.ZLattice.Covolume | Lean.Syntax | null | false |
Rep.equivalenceModuleMonoidAlgebra | Mathlib.RepresentationTheory.Rep.Iso | {k : Type u} →
{G : Type v} → [inst : CommRing k] → [inst_1 : Monoid G] → Rep.{w, u, v} k G ≌ ModuleCat (MonoidAlgebra k G) | The categorical equivalence `Rep k G ≌ ModuleCat k[G]`. | true |
Turing.ListBlank.modifyNth._unsafe_rec | Mathlib.Computability.TuringMachine.Tape | {Γ : Type u_1} → [inst : Inhabited Γ] → (Γ → Γ) → ℕ → Turing.ListBlank Γ → Turing.ListBlank Γ | null | false |
CategoryTheory.NonPreadditiveAbelian.isIso_factorThruImage | Mathlib.CategoryTheory.Abelian.NonPreadditive | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.NonPreadditiveAbelian C] {P Q : C}
(f : P ⟶ Q) [CategoryTheory.Mono f], CategoryTheory.IsIso (CategoryTheory.Abelian.factorThruImage f) | null | true |
Matroid.comap_indep_iff._simp_1 | Mathlib.Combinatorics.Matroid.Map | ∀ {α : Type u_1} {β : Type u_2} {f : α → β} {I : Set α} {N : Matroid β},
(N.comap f).Indep I = (N.Indep (f '' I) ∧ Set.InjOn f I) | null | false |
MeasureTheory.VectorMeasure.transpose_dirac | Mathlib.MeasureTheory.VectorMeasure.Integral | ∀ {X : Type u_2} {E : Type u_4} {F : Type u_5} {G : Type u_6} {mX : MeasurableSpace X} [inst : NormedAddCommGroup E]
[inst_1 : NormedSpace ℝ E] [inst_2 : NormedAddCommGroup F] [inst_3 : NormedSpace ℝ F] [inst_4 : NormedAddCommGroup G]
[inst_5 : NormedSpace ℝ G] (B : E →L[ℝ] F →L[ℝ] G) (x : X) (v : F),
(MeasureThe... | null | true |
Multiset.sym2_mono | Mathlib.Data.Multiset.Sym | ∀ {α : Type u_1} {m m' : Multiset α}, m ≤ m' → m.sym2 ≤ m'.sym2 | null | true |
Real.Angle.toReal_le_pi | Mathlib.Analysis.SpecialFunctions.Trigonometric.Angle | ∀ (θ : Real.Angle), θ.toReal ≤ Real.pi | null | true |
_private.Mathlib.FieldTheory.RatFunc.Luroth.0.RatFunc.Luroth.q | Mathlib.FieldTheory.RatFunc.Luroth | {K : Type u_1} → [inst : Field K] → (E : IntermediateField K (RatFunc K)) → Polynomial ↥E | A polynomial `q` that satisfies `φ * q = (generator E).minpolyX`. | true |
Set.inter_self | Mathlib.Data.Set.Basic | ∀ {α : Type u} (a : Set α), a ∩ a = a | null | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.