name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
Mathlib.Tactic.Basify.ElimEntry.ctorIdx | Mathlib.Tactic.Basify.Attr | Mathlib.Tactic.Basify.ElimEntry → ℕ | null | false |
ProbabilityTheory.Kernel.IsMarkovKernel.comp | Mathlib.Probability.Kernel.Composition.Comp | ∀ {α : Type u_1} {β : Type u_2} {γ : Type u_3} {mα : MeasurableSpace α} {mβ : MeasurableSpace β}
{mγ : MeasurableSpace γ} (η : ProbabilityTheory.Kernel β γ) [ProbabilityTheory.IsMarkovKernel η]
(κ : ProbabilityTheory.Kernel α β) [ProbabilityTheory.IsMarkovKernel κ], ProbabilityTheory.IsMarkovKernel (η.comp κ) | null | true |
CategoryTheory.Adjunction.leftAdjointIdIso_hom_app | Mathlib.CategoryTheory.Adjunction.CompositionIso | ∀ {C₀ : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C₀] {F G : CategoryTheory.Functor C₀ C₀} (adj : F ⊣ G)
(e : G ≅ CategoryTheory.Functor.id C₀) (X : C₀),
(adj.leftAdjointIdIso e).hom.app X = CategoryTheory.CategoryStruct.comp (F.map (e.inv.app X)) (adj.counit.app X) | null | true |
_private.Mathlib.RingTheory.Adjoin.Field.0.AlgEquiv.adjoinSingletonEquivAdjoinRootMinpoly._simp_2 | Mathlib.RingTheory.Adjoin.Field | ∀ {R : Type u} {A : Type z} [inst : CommSemiring R] [inst_1 : Semiring A] [inst_2 : Algebra R A] (x : A)
(p : Polynomial R), Polynomial.eval₂ (algebraMap R A) x p = (Polynomial.aeval x) p | null | false |
_private.Mathlib.Topology.Algebra.ProperAction.Basic.0.t2Space_quotient_mulAction_of_properSMul._simp_4 | Mathlib.Topology.Algebra.ProperAction.Basic | ∀ {α : Type u_1} {β : Type u_2} {p : α × β → Prop}, (∃ x, p x) = ∃ a b, p (a, b) | null | false |
Sbtw.trans_wbtw_left_ne | Mathlib.Analysis.Convex.Between | ∀ {R : Type u_1} {V : Type u_2} {P : Type u_4} [inst : Ring R] [inst_1 : PartialOrder R] [inst_2 : AddCommGroup V]
[inst_3 : Module R V] [inst_4 : AddTorsor V P] [IsOrderedRing R] [IsDomain R] [Module.IsTorsionFree R V]
{w x y z : P}, Sbtw R w y z → Wbtw R w x y → x ≠ z | null | true |
ProbabilityTheory.gaussianReal_const_sub | Mathlib.Probability.Distributions.Gaussian.Real | ∀ {μ : ℝ} {v : NNReal} {Ω : Type u_1} {mΩ : MeasurableSpace Ω} {P : MeasureTheory.Measure Ω} {X : Ω → ℝ},
ProbabilityTheory.HasLaw X (ProbabilityTheory.gaussianReal μ v) P →
∀ (y : ℝ), ProbabilityTheory.HasLaw (fun ω => y - X ω) (ProbabilityTheory.gaussianReal (y - μ) v) P | If `X` is a real random variable with Gaussian law with mean `μ` and variance `v`, then `y - X`
has Gaussian law with mean `y - μ` and variance `v`. | true |
Aesop.RuleStats.mk.injEq | Aesop.Stats.Basic | ∀ (rule : Aesop.DisplayRuleName) (elapsed : Aesop.Nanos) (successful : Bool) (rule_1 : Aesop.DisplayRuleName)
(elapsed_1 : Aesop.Nanos) (successful_1 : Bool),
({ rule := rule, elapsed := elapsed, successful := successful } =
{ rule := rule_1, elapsed := elapsed_1, successful := successful_1 }) =
(rule = r... | null | true |
BitVec.instDecidableExistsBitVecSucc._proof_1 | Init.Data.BitVec.Decidable | ∀ {n : ℕ} (P : BitVec (n + 1) → Prop), (¬∀ (v : BitVec (n + 1)), ¬P v) ↔ ∃ v, P v | null | false |
Set.finite_iff_bddAbove_bddBelow | Mathlib.Order.Interval.Finset.Defs | ∀ {α : Type u_3} {s : Set α} [Nonempty α] [inst : Lattice α] [LocallyFiniteOrder α], s.Finite ↔ BddAbove s ∧ BddBelow s | null | true |
GroupExtension.Section.inv_mul_mem_range_inl | Mathlib.GroupTheory.GroupExtension.Basic | ∀ {N : Type u_1} {G : Type u_2} [inst : Group N] [inst_1 : Group G] {E : Type u_3} [inst_2 : Group E]
{S : GroupExtension N E G} (σ σ' : S.Section) (g : G), (σ g)⁻¹ * σ' g ∈ S.inl.range | null | true |
Rep.coinvariantsTensorFreeLEquiv._proof_4 | Mathlib.RepresentationTheory.Coinvariants | ∀ {k G : Type u_1} [inst : CommRing k] [inst_1 : Group G] (A : Rep.{u_1, u_1, u_1} k G) (α : Type u_1)
[inst_2 : DecidableEq α], A.finsuppToCoinvariantsTensorFree α ∘ₗ A.coinvariantsTensorFreeToFinsupp α = LinearMap.id | null | false |
Lean.Elab.Structural.RecArgInfo._sizeOf_1 | Lean.Elab.PreDefinition.Structural.RecArgInfo | Lean.Elab.Structural.RecArgInfo → ℕ | null | false |
Finset.fiber_card_ne_zero_iff_mem_image | Mathlib.Data.Finset.Card | ∀ {α : Type u_1} {β : Type u_2} (s : Finset α) (f : α → β) [inst : DecidableEq β] (y : β),
{x ∈ s | f x = y}.card ≠ 0 ↔ y ∈ Finset.image f s | null | true |
Polynomial.isRoot_cyclotomic_prime_pow_mul_iff_of_charP | Mathlib.RingTheory.Polynomial.Cyclotomic.Expand | ∀ {m k p : ℕ} {R : Type u_1} [inst : CommRing R] [IsDomain R] [hp : Fact (Nat.Prime p)] [hchar : CharP R p] {μ : R}
[NeZero ↑m], (Polynomial.cyclotomic (p ^ k * m) R).IsRoot μ ↔ IsPrimitiveRoot μ m | If `R` is of characteristic `p` and `¬p ∣ m`, then `ζ` is a root of `cyclotomic (p ^ k * m) R`
if and only if it is a primitive `m`-th root of unity. | true |
Stream'.Seq.fold.match_1 | Mathlib.Data.Seq.Defs | {α : Type u_2} →
{β : Type u_1} →
(motive : β × Stream'.Seq α → Sort u_3) →
(x : β × Stream'.Seq α) → ((acc : β) → (x : Stream'.Seq α) → motive (acc, x)) → motive x | null | false |
Equiv.natSumNatEquivNat | Mathlib.Logic.Equiv.Nat | ℕ ⊕ ℕ ≃ ℕ | An equivalence between `ℕ ⊕ ℕ` and `ℕ`, by mapping `(Sum.inl x)` to `2 * x` and `(Sum.inr x)` to
`2 * x + 1`.
| true |
_private.Mathlib.GroupTheory.Nilpotent.0.Group.nilpotencyClass_quotient_center._simp_1_1 | Mathlib.GroupTheory.Nilpotent | ∀ {G : Type u_1} [inst : Group G] [Group.IsNilpotent G], (Group.nilpotencyClass G = 0) = Subsingleton G | null | false |
Semiring.mk._flat_ctor | Mathlib.Algebra.Ring.Defs | {α : Type u} →
(zero : α) →
(add : α → α → α) →
(∀ (a b c : α), a + b + c = a + (b + c)) →
(∀ (a : α), 0 + a = a) →
(∀ (a : α), a + 0 = a) →
(nsmul : ℕ → α → α) →
autoParam (∀ (x : α), 0 • x = 0) AddMonoid.nsmul_zero._autoParam →
autoParam (∀ (n : ... | null | false |
Prod.addAction._proof_1 | Mathlib.Algebra.Group.Action.Prod | ∀ {M : Type u_3} {α : Type u_1} {β : Type u_2} [inst : AddMonoid M] [inst_1 : AddAction M α] [inst_2 : AddAction M β]
(x x_1 : M) (x_2 : α × β), (x + x_1) +ᵥ x_2 = x +ᵥ x_1 +ᵥ x_2 | null | false |
_private.Mathlib.NumberTheory.NumberField.CanonicalEmbedding.ConvexBody.0.NumberField.mixedEmbedding.convexBodyLT'_mem._simp_1_1 | Mathlib.NumberTheory.NumberField.CanonicalEmbedding.ConvexBody | ∀ {α : Type u} {β : Type v} {s : Set α} {t : Set β} {p : α × β}, (p ∈ s ×ˢ t) = (p.1 ∈ s ∧ p.2 ∈ t) | null | false |
Array.mapFinIdx_eq_mapIdx | Init.Data.Array.MapIdx | ∀ {α : Type u_1} {β : Type u_2} {xs : Array α} {f : (i : ℕ) → α → i < xs.size → β} {g : ℕ → α → β},
(∀ (i : ℕ) (h : i < xs.size), f i xs[i] h = g i xs[i]) → xs.mapFinIdx f = Array.mapIdx g xs | null | true |
_private.Std.Http.Internal.Char.0.Std.Http.Internal.Char.qdtext.match_1.eq_3 | Std.Http.Internal.Char | ∀ (motive : Char → Sort u_1) (h_1 : Unit → motive '\t') (h_2 : Unit → motive ' ') (h_3 : Unit → motive '!')
(h_4 : (x : Char) → motive x),
(match '!' with
| '\t' => h_1 ()
| ' ' => h_2 ()
| '!' => h_3 ()
| x => h_4 x) =
h_3 () | null | true |
DivisionMonoid.ctorIdx | Mathlib.Algebra.Group.DivInvMonoid | {G : Type u_2} → DivisionMonoid G → ℕ | null | false |
Lean.Parser.Command.importPath.parenthesizer | Lean.Parser.Command | Lean.PrettyPrinter.Parenthesizer | null | true |
Fin.val_ofNat | Init.Data.Fin.Lemmas | ∀ (n : ℕ) [inst : NeZero n] (a : ℕ), ↑(Fin.ofNat n a) = a % n | null | true |
Lean.Language.SnapshotTree.mk.sizeOf_spec | Lean.Language.Basic | ∀ (element : Lean.Language.Snapshot) (children : Array (Lean.Language.SnapshotTask Lean.Language.SnapshotTree)),
sizeOf { element := element, children := children } = 1 + sizeOf element + sizeOf children | null | true |
Continuous.clog | Mathlib.Analysis.SpecialFunctions.Complex.Log | ∀ {α : Type u_1} [inst : TopologicalSpace α] {f : α → ℂ},
Continuous f → (∀ (x : α), f x ∈ Complex.slitPlane) → Continuous fun t => Complex.log (f t) | null | true |
HomologicalComplex.mapBifunctor₁₂.d₃_eq_zero | Mathlib.Algebra.Homology.BifunctorAssociator | ∀ {C₁ : Type u_1} {C₂ : Type u_2} {C₁₂ : Type u_3} {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 |
MultilinearMap.addCommMonoid | Mathlib.LinearAlgebra.Multilinear.Basic | {R : Type uR} →
{ι : Type uι} →
{M₁ : ι → Type v₁} →
{M₂ : Type v₂} →
[inst : Semiring R] →
[inst_1 : (i : ι) → AddCommMonoid (M₁ i)] →
[inst_2 : AddCommMonoid M₂] →
[inst_3 : (i : ι) → Module R (M₁ i)] → [inst_4 : Module R M₂] → AddCommMonoid (MultilinearMap R M₁... | null | true |
IsBezout.span_pair_isPrincipal | Mathlib.RingTheory.PrincipalIdealDomain | ∀ {R : Type u} [inst : Ring R] [IsBezout R] (x y : R), Submodule.IsPrincipal (Ideal.span {x, y}) | null | true |
_private.Mathlib.Computability.PartrecCode.0.Nat.Partrec.Code.evaln_complete._simp_1_27 | Mathlib.Computability.PartrecCode | ∀ {α : Sort u_1} {β : Sort u_2} {f : α → β} {p : α → Prop} {q : β → Prop},
(∃ b, (∃ a, p a ∧ f a = b) ∧ q b) = ∃ a, p a ∧ q (f a) | null | false |
PrincipalSeg.isSuccPrelimit_apply_iff | Mathlib.Order.SuccPred.InitialSeg | ∀ {α : Type u_1} {β : Type u_2} {a : α} [inst : PartialOrder α] [inst_1 : PartialOrder β] (f : α <i β),
Order.IsSuccPrelimit (f.toRelEmbedding a) ↔ Order.IsSuccPrelimit a | null | true |
CategoryTheory.Limits.WalkingPair.equivBool._proof_1 | Mathlib.CategoryTheory.Limits.Shapes.BinaryProducts.WalkingPair | ∀ (j : CategoryTheory.Limits.WalkingPair),
(fun b => Bool.recOn b CategoryTheory.Limits.WalkingPair.right CategoryTheory.Limits.WalkingPair.left)
((fun x =>
match x with
| CategoryTheory.Limits.WalkingPair.left => true
| CategoryTheory.Limits.WalkingPair.right => false)
j) ... | null | false |
ProfiniteAddGrp.ofHom_apply | Mathlib.Topology.Algebra.Category.ProfiniteGrp.Basic | ∀ {X Y : Type u} [inst : AddGroup X] [inst_1 : TopologicalSpace X] [inst_2 : IsTopologicalAddGroup X]
[inst_3 : CompactSpace X] [inst_4 : TotallyDisconnectedSpace X] [inst_5 : AddGroup Y] [inst_6 : TopologicalSpace Y]
[inst_7 : IsTopologicalAddGroup Y] [inst_8 : CompactSpace Y] [inst_9 : TotallyDisconnectedSpace Y]... | null | true |
minimalPrimes | Mathlib.RingTheory.Ideal.MinimalPrime.Basic | (R : Type u_1) → [inst : CommSemiring R] → Set (Ideal R) | `minimalPrimes R` is the set of minimal primes of `R`.
This is defined as `Ideal.minimalPrimes ⊥`. | true |
Nondet.ofListM | Batteries.Control.Nondet.Basic | {σ : Type} → {m : Type → Type} → [Monad m] → [inst : Lean.MonadBacktrack σ m] → {α : Type} → List (m α) → Nondet m α | Lift a list of monadic values to a nondeterministic value.
We ensure that each monadic value is evaluated with the same backtrackable state.
| true |
HasFDerivWithinAt.of_restrictScalars | Mathlib.Analysis.Calculus.FDeriv.RestrictScalars | ∀ (𝕜 : Type u_1) [inst : NontriviallyNormedField 𝕜] {𝕜' : Type u_2} [inst_1 : NontriviallyNormedField 𝕜']
[inst_2 : NormedAlgebra 𝕜 𝕜'] {E : Type u_3} [inst_3 : NormedAddCommGroup E] [inst_4 : NormedSpace 𝕜 E]
[inst_5 : NormedSpace 𝕜' E] [inst_6 : IsScalarTower 𝕜 𝕜' E] {F : Type u_4} [inst_7 : NormedAddCo... | null | true |
MeasureTheory.eLpNorm_smul_le_mul_eLpNorm_of_pos | Mathlib.MeasureTheory.Function.LpSeminorm.CompareExp | ∀ {𝕜 : Type u_1} {α : Type u_2} {E : Type u_3} {m : MeasurableSpace α} {μ : MeasureTheory.Measure α}
[inst : NormedRing 𝕜] [inst_1 : NormedAddCommGroup E] [inst_2 : MulActionWithZero 𝕜 E] [IsBoundedSMul 𝕜 E] {f : α → E}
{φ : α → 𝕜} {p q r : ENNReal},
0 < r →
∀ [hpqr : p.HolderTriple q r],
MeasureTh... | Hölder's inequality, as an inequality on the `ℒp` seminorm of a scalar product `φ • f`. | true |
_private.Mathlib.NumberTheory.Padics.PadicVal.Basic.0.padicValRat.lt_sum_of_lt._simp_1_1 | Mathlib.NumberTheory.Padics.PadicVal.Basic | ∀ {α : Type u_1} [inst : DecidableEq α] {s : Finset α} {a b : α}, (a ∈ insert b s) = (a = b ∨ a ∈ s) | null | false |
MulAction.IsBlock.univ | Mathlib.GroupTheory.GroupAction.Blocks | ∀ {G : Type u_1} [inst : Group G] {X : Type u_2} [inst_1 : MulAction G X], MulAction.IsBlock G Set.univ | The full set is a block. | true |
Std.HashSet.getD_diff_of_not_mem_left | Std.Data.HashSet.Lemmas | ∀ {α : Type u} {x : BEq α} {x_1 : Hashable α} {m₁ m₂ : Std.HashSet α} [EquivBEq α] [LawfulHashable α] {k fallback : α},
k ∉ m₁ → (m₁ \ m₂).getD k fallback = fallback | null | true |
CompHausLike.finiteCoproduct.desc | Mathlib.Topology.Category.CompHausLike.Limits | {P : TopCat → Prop} →
{α : Type w} →
[inst : Finite α] →
(X : α → CompHausLike P) →
[inst_1 : CompHausLike.HasExplicitFiniteCoproduct X] →
{B : CompHausLike P} → ((a : α) → X a ⟶ B) → (CompHausLike.finiteCoproduct X ⟶ B) | To construct a morphism from the explicit finite coproduct, it suffices to
specify a morphism from each of its factors.
This is essentially the universal property of the coproduct.
| true |
ContinuousMap.induction_on | Mathlib.Topology.ContinuousMap.StoneWeierstrass | ∀ {𝕜 : Type u_1} [inst : RCLike 𝕜] {s : Set 𝕜} {p : C(↑s, 𝕜) → Prop},
(∀ (r : 𝕜), p (ContinuousMap.const (↑s) r)) →
p (ContinuousMap.restrict s (ContinuousMap.id 𝕜)) →
p (star (ContinuousMap.restrict s (ContinuousMap.id 𝕜))) →
(∀ (f g : C(↑s, 𝕜)), p f → p g → p (f + g)) →
(∀ (f g :... | An induction principle for `C(s, 𝕜)`. | true |
_private.Mathlib.Combinatorics.SimpleGraph.Acyclic.0.SimpleGraph.IsTree.card_edgeFinset._simp_1_7 | Mathlib.Combinatorics.SimpleGraph.Acyclic | ∀ {α : Type u_4} {f : Sym2 α → Prop}, (∀ (x : Sym2 α), f x) = ∀ (x y : α), f s(x, y) | null | false |
List.Vector.continuous_eraseIdx | Mathlib.Topology.List | ∀ {α : Type u_1} [inst : TopologicalSpace α] {n : ℕ} {i : Fin (n + 1)}, Continuous (List.Vector.eraseIdx i) | null | true |
_private.Mathlib.CategoryTheory.ObjectProperty.FiniteProducts.0.CategoryTheory.ObjectProperty.prop_of_isLimit_fan.match_1_1 | Mathlib.CategoryTheory.ObjectProperty.FiniteProducts | ∀ {J : Type u_1} (motive : CategoryTheory.Discrete J → Prop) (h : CategoryTheory.Discrete J),
(∀ (j : J), motive { as := j }) → motive h | null | false |
Ordinal.enumOrdOrderIso | Mathlib.SetTheory.Ordinal.Enum | (s : Set Ordinal.{u_1}) → ¬BddAbove s → Ordinal.{u_1} ≃o ↑s | An order isomorphism between an unbounded set of ordinals and the ordinals. | true |
Lean.Parser.Command.checkAssertions.formatter | Lean.Parser.Command | Lean.PrettyPrinter.Formatter | null | true |
Std.Internal.List.minEntry?_of_perm | Std.Data.Internal.List.Associative | ∀ {α : Type u} {β : α → Type v} [inst : Ord α] [Std.TransOrd α] [inst_2 : BEq α] [Std.LawfulBEqOrd α]
{l l' : List ((a : α) × β a)},
Std.Internal.List.DistinctKeys l → l.Perm l' → Std.Internal.List.minEntry? l = Std.Internal.List.minEntry? l' | null | true |
Lean.Parser.SyntaxStack.casesOn | Lean.Parser.Types | {motive : Lean.Parser.SyntaxStack → Sort u} →
(t : Lean.Parser.SyntaxStack) →
((raw : Array Lean.Syntax) → (drop : ℕ) → motive { raw := raw, drop := drop }) → motive t | null | false |
Equiv.Perm.sign_eq_prod_prod_Ioi | Mathlib.GroupTheory.Perm.Fin | ∀ {n : ℕ} (σ : Equiv.Perm (Fin n)), Equiv.Perm.sign σ = ∏ i, ∏ j > i, if σ i < σ j then 1 else -1 | null | true |
Std.Http.Header.instReprHost | Std.Http.Data.Headers.Basic | Repr Std.Http.Header.Host | null | true |
FormalMultilinearSeries.ofScalarsSum | Mathlib.Analysis.Analytic.OfScalars | {𝕜 : Type u_1} →
{E : Type u_2} →
[inst : Field 𝕜] →
[inst_1 : Ring E] → [Algebra 𝕜 E] → [inst : TopologicalSpace E] → [IsTopologicalRing E] → (ℕ → 𝕜) → E → E | The sum of the formal power series. Takes the value `0` outside the radius of convergence. | true |
FP.Float.inf.inj | Mathlib.Data.FP.Basic | ∀ {C : FP.FloatCfg} {a a_1 : Bool}, FP.Float.inf a = FP.Float.inf a_1 → a = a_1 | null | true |
_private.Mathlib.Tactic.Variable.0.Mathlib.Command.Variable.initFn._@.Mathlib.Tactic.Variable.1155143173._hygCtx._hyg.4 | Mathlib.Tactic.Variable | IO (Lean.Option Bool) | null | false |
CategoryTheory.IsKernelPair.equivalenceRelation | Mathlib.CategoryTheory.EquivalenceRelation | {C : Type u_1} →
[inst : CategoryTheory.Category.{v_1, u_1} C] →
{X Y : C} →
(f : X ⟶ Y) →
{R : C} →
(p₁ p₂ : R ⟶ X) →
{t : CategoryTheory.Limits.PullbackCone p₂ p₁} →
CategoryTheory.Limits.IsLimit t →
CategoryTheory.IsKernelPair f p₁ p₂ → Category... | A kernel pair gives rise to an equivalence relation. | true |
_private.Mathlib.LinearAlgebra.Isomorphisms.0.LinearMap.quotientInfEquivSupQuotient_surjective._simp_1_2 | Mathlib.LinearAlgebra.Isomorphisms | ∀ {R : Type u_1} {R₂ : Type u_2} {M : Type u_4} {M₂ : Type u_5} [inst : Semiring R] [inst_1 : Semiring R₂]
[inst_2 : AddCommMonoid M] [inst_3 : AddCommMonoid M₂] [inst_4 : Module R M] [inst_5 : Module R₂ M₂] {σ₁₂ : R →+* R₂}
{x : M} {f : M →ₛₗ[σ₁₂] M₂} {p : Submodule R₂ M₂}, (x ∈ Submodule.comap f p) = (f x ∈ p) | null | false |
ProofWidgets.ExprPresenter | ProofWidgets.Presentation.Expr | Type | An `Expr` presenter is similar to a delaborator but outputs HTML trees instead of syntax, and
the output HTML can contain elements which interact with the original `Expr` in some way. We call
interactive outputs with a reference to the original input *presentations*. | true |
CategoryTheory.Subobject.widePullbackι.eq_1 | Mathlib.CategoryTheory.Subobject.Lattice | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] [inst_1 : CategoryTheory.LocallySmall.{w, v₁, u₁} C]
[inst_2 : CategoryTheory.WellPowered.{w, v₁, u₁} C] [inst_3 : CategoryTheory.Limits.HasWidePullbacks C] {A : C}
(s : Set (CategoryTheory.Subobject A)),
CategoryTheory.Subobject.widePullbackι s = Catego... | null | true |
Prefunctor.map_reverse | Mathlib.Combinatorics.Quiver.Symmetric | ∀ {U : Type u_1} {V : Type u_2} [inst : Quiver U] [inst_1 : Quiver V] [inst_2 : Quiver.HasReverse U]
[inst_3 : Quiver.HasReverse V] (φ : U ⥤q V) [φ.MapReverse] {u v : U} (e : u ⟶ v),
φ.map (Quiver.reverse e) = Quiver.reverse (φ.map e) | null | true |
MulActionSemiHomClass.rec | Mathlib.GroupTheory.GroupAction.Hom | {F : Type u_8} →
{M : Type u_9} →
{N : Type u_10} →
{φ : M → N} →
{X : Type u_11} →
{Y : Type u_12} →
[inst : SMul M X] →
[inst_1 : SMul N Y] →
[inst_2 : FunLike F X Y] →
{motive : MulActionSemiHomClass F φ X Y → Sort u} →
... | null | false |
_private.Std.Data.DTreeMap.Internal.Lemmas.0.Std.DTreeMap.Internal.Impl.Const.size_alter_le_size._proof_1_1 | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u_1} {β : Type u_2} {t : Std.DTreeMap.Internal.Impl α fun x => β}, ¬t.size - 1 ≤ t.size + 1 → False | null | false |
Irrational.eventually_forall_le_dist_cast_rat_of_den_le | Mathlib.Topology.Instances.Irrational | ∀ {x : ℝ}, Irrational x → ∀ (n : ℕ), ∀ᶠ (ε : ℝ) in nhds 0, ∀ (r : ℚ), r.den ≤ n → ε ≤ dist x ↑r | null | true |
CategoryTheory.yonedaAddGrpObj_obj_coe | Mathlib.CategoryTheory.Monoidal.Cartesian.Grp | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.CartesianMonoidalCategory C] (G : C)
[inst_2 : CategoryTheory.AddGrpObj G] (X : Cᵒᵖ), ↑((CategoryTheory.yonedaAddGrpObj G).obj X) = (Opposite.unop X ⟶ G) | null | true |
CategoryTheory.Limits.ColimitPresentation.isColimit | Mathlib.CategoryTheory.Limits.Presentation | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
{J : Type w} →
[inst_1 : CategoryTheory.Category.{t, w} J] →
{X : C} →
(self : CategoryTheory.Limits.ColimitPresentation J X) →
CategoryTheory.Limits.IsColimit { pt := X, ι := self.ι } | `X` is the colimit of the `Dᵢ` via `sᵢ`. | true |
Order.sub_one_wcovBy._simp_1 | Mathlib.Algebra.Order.SuccPred | ∀ {α : Type u_1} [inst : Preorder α] [inst_1 : Sub α] [inst_2 : One α] [PredSubOrder α] (x : α), (x - 1 ⩿ x) = True | null | false |
tprod_setElem_eq_tprod_setElem_diff | Mathlib.Topology.Algebra.InfiniteSum.Basic | ∀ {α : Type u_1} {β : Type u_2} [inst : CommMonoid α] [inst_1 : TopologicalSpace α] {f : β → α} (s t : Set β),
(∀ b ∈ t, f b = 1) → ∏' (a : ↑s), f ↑a = ∏' (a : ↑(s \ t)), f ↑a | **Alias** of `tprod_setElem_eq_tprod_setElem_sdiff`.
---
If `f b = 1` for all `b ∈ t`, then the product of `f a` with `a ∈ s` is the same as the
product of `f a` with `a ∈ s ∖ t`. | true |
ProfiniteAddGrp.instAddGroupCarrierToTopTotallyDisconnectedSpacePtProfiniteLimitConeCompForget₂ContinuousAddMonoidHomToProfiniteContinuousMap._proof_18 | Mathlib.Topology.Algebra.Category.ProfiniteGrp.Basic | ∀ {J : Type u_1} [inst : CategoryTheory.SmallCategory J] (F : CategoryTheory.Functor J ProfiniteAddGrp.{max u_1 u_2}),
autoParam
(∀
(a b : ↑(Profinite.limitCone (F.comp (CategoryTheory.forget₂ ProfiniteAddGrp.{max u_2 u_1} Profinite))).pt.toTop),
a - b = a + -b)
SubNegMonoid.sub_eq_add_neg._autoPa... | null | false |
Lean.Diff.Histogram.Entry | Lean.Util.Diff | Type u → ℕ → ℕ → Type | A histogram entry consists of the number of times the element occurs in the left and right input
arrays along with an index at which the element can be found, if applicable.
| true |
RelEmbedding.symm | Mathlib.Order.RelIso.Basic | ∀ {α : Type u_1} {β : Type u_2} {r : α → α → Prop} {s : β → β → Prop} (f : r ↪r s) [Std.Symm s], Std.Symm r | null | true |
Rack.EnvelGroup | Mathlib.Algebra.Quandle | (R : Type u_1) → [Rack R] → Type u_1 | The universal enveloping group for the rack R.
| true |
_private.Lean.Data.Lsp.LanguageFeatures.0.Lean.Lsp.instToJsonSemanticTokenModifier.toJson.match_1 | Lean.Data.Lsp.LanguageFeatures | (motive : Lean.Lsp.SemanticTokenModifier → Sort u_1) →
(x : Lean.Lsp.SemanticTokenModifier) →
(Unit → motive Lean.Lsp.SemanticTokenModifier.declaration) →
(Unit → motive Lean.Lsp.SemanticTokenModifier.definition) →
(Unit → motive Lean.Lsp.SemanticTokenModifier.readonly) →
(Unit → motive Le... | null | false |
SSet.stdSimplex.const | Mathlib.AlgebraicTopology.SimplicialSet.StdSimplex | (n : ℕ) → Fin (n + 1) → (m : SimplexCategoryᵒᵖ) → (SSet.stdSimplex.obj { len := n }).obj m | The (degenerate) `m`-simplex in the standard simplex concentrated in vertex `k`. | true |
UpperHalfPlane.instAddActionReal._proof_1 | Mathlib.Analysis.Complex.UpperHalfPlane.Basic | ∀ (x : ℝ) (z : UpperHalfPlane), 0 < (↑x + ↑z).im | null | false |
MeasureTheory.IsAddFundamentalDomain.mono | Mathlib.MeasureTheory.Group.FundamentalDomain | ∀ {G : Type u_1} {α : Type u_3} [inst : AddGroup G] [inst_1 : AddAction G α] [inst_2 : MeasurableSpace α] {s : Set α}
{μ : MeasureTheory.Measure α},
MeasureTheory.IsAddFundamentalDomain G s μ →
∀ {ν : MeasureTheory.Measure α}, ν.AbsolutelyContinuous μ → MeasureTheory.IsAddFundamentalDomain G s ν | null | true |
CategoryTheory.Mon.braiding_hom_hom | Mathlib.CategoryTheory.Monoidal.Mon | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] [inst_1 : CategoryTheory.MonoidalCategory C]
[inst_2 : CategoryTheory.SymmetricCategory C] (M N : CategoryTheory.Mon C), (β_ M N).hom.hom = (β_ M.X N.X).hom | null | true |
CategoryTheory.BasedFunctor.w | Mathlib.CategoryTheory.FiberedCategory.BasedCategory | ∀ {𝒮 : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} 𝒮] {𝒳 : CategoryTheory.BasedCategory 𝒮}
{𝒴 : CategoryTheory.BasedCategory 𝒮} (self : CategoryTheory.BasedFunctor 𝒳 𝒴), self.comp 𝒴.p = 𝒳.p | null | true |
Equidecomp.refl | Mathlib.Algebra.Group.Action.Equidecomp | (X : Type u_1) → (G : Type u_2) → [inst : Monoid G] → [inst_1 : MulAction G X] → Equidecomp X G | The identity function is an equidecomposition of the space with itself. | true |
Std.HashMap.getElem!_ofList_of_mem | Std.Data.HashMap.Lemmas | ∀ {α : Type u} {β : Type v} {x : BEq α} {x_1 : Hashable α} [EquivBEq α] [LawfulHashable α] {l : List (α × β)}
{k k' : α},
(k == k') = true →
∀ {v : β} [inst : Inhabited β],
List.Pairwise (fun a b => (a.1 == b.1) = false) l → (k, v) ∈ l → (Std.HashMap.ofList l)[k']! = v | null | true |
Matrix.isIndecomposable_iff_blockTriangular_const | Mathlib.LinearAlgebra.Matrix.Block | ∀ {α : Type u_1} {m : Type u_2} {R : Type v} [inst : LinearOrder α] [Nontrivial α] [Finite m] [inst_3 : Zero R]
(M : Matrix m m R), M.IsIndecomposable ↔ ∀ (b : m → α), M.BlockTriangular b → ∃ a, b = Function.const m a | null | true |
Nat.Internal.SOM.Expr.add.noConfusion | Init.Data.Nat.Internal.SOM | {P : Sort u} → {a b a' b' : Nat.Internal.SOM.Expr} → a.add b = a'.add b' → (a = a' → b = b' → P) → P | null | false |
PrimeSpectrum.BasicConstructibleSetData.rec | Mathlib.RingTheory.Spectrum.Prime.ConstructibleSet | {R : Type u_1} →
{motive : PrimeSpectrum.BasicConstructibleSetData R → Sort u} →
((f : R) → (n : ℕ) → (g : Fin n → R) → motive { f := f, n := n, g := g }) →
(t : PrimeSpectrum.BasicConstructibleSetData R) → motive t | null | false |
Quot.lift.decidablePred | Mathlib.Data.Quot | {α : Sort u_1} →
(r : α → α → Prop) →
(f : α → Prop) → (h : ∀ (a b : α), r a b → f a = f b) → [hf : DecidablePred f] → DecidablePred (Quot.lift f h) | null | true |
SaturatedAddSubmonoid.ext_iff | Mathlib.Algebra.Group.Submonoid.Saturation | ∀ {M : Type u_1} [inst : AddZeroClass M] {s₁ s₂ : SaturatedAddSubmonoid M},
s₁ = s₂ ↔ s₁.toAddSubmonoid = s₂.toAddSubmonoid | null | true |
Lean.Meta.RecursorUnivLevelPos._sizeOf_inst | Lean.Meta.RecursorInfo | SizeOf Lean.Meta.RecursorUnivLevelPos | null | false |
Mathlib.Tactic.BicategoryLike.IsoLift._sizeOf_1 | Mathlib.Tactic.CategoryTheory.Coherence.Datatypes | Mathlib.Tactic.BicategoryLike.IsoLift → ℕ | null | false |
String.Slice.Pattern.Model.isMatch_iff | Init.Data.String.Lemmas.Pattern.Basic | ∀ {ρ : Type} {pat : ρ} [inst : String.Slice.Pattern.Model.PatternModel pat] {s : String.Slice} {pos : s.Pos},
String.Slice.Pattern.Model.IsMatch pat pos ↔ String.Slice.Pattern.Model.PatternModel.Matches pat (s.sliceTo pos).copy | null | true |
Equiv.Perm.one_lt_card_support_of_ne_one | Mathlib.GroupTheory.Perm.Support | ∀ {α : Type u_1} [inst : DecidableEq α] [inst_1 : Fintype α] {f : Equiv.Perm α}, f ≠ 1 → 1 < f.support.card | null | true |
Representation.char_dual | Mathlib.RepresentationTheory.Character | ∀ {G : Type u_1} {k : Type u_2} {V : Type u_3} [inst : Group G] [inst_1 : Field k] [inst_2 : AddCommGroup V]
[inst_3 : Module k V] [FiniteDimensional k V] (ρ : Representation k G V) (g : G), ρ.dual.character g = ρ.character g⁻¹ | null | true |
_private.Mathlib.Algebra.Ring.Subsemiring.Basic.0.Subsemiring.prod_top._simp_1_1 | Mathlib.Algebra.Ring.Subsemiring.Basic | ∀ {R : Type u} {S : Type v} [inst : NonAssocSemiring R] [inst_1 : NonAssocSemiring S] {s : Subsemiring R}
{t : Subsemiring S} {p : R × S}, (p ∈ s.prod t) = (p.1 ∈ s ∧ p.2 ∈ t) | null | false |
IsSimpleOrder.equivBool.congr_simp | Mathlib.Order.Atoms | ∀ {α : Type u_4} [inst : DecidableEq α] [inst_1 : LE α] [inst_2 : BoundedOrder α] [inst_3 : IsSimpleOrder α],
IsSimpleOrder.equivBool = IsSimpleOrder.equivBool | null | true |
RatCast.mk._flat_ctor | Batteries.Classes.RatCast | {K : Type u} → (ℚ → K) → RatCast K | null | false |
_private.Mathlib.RingTheory.QuasiFinite.Basic.0.Algebra.QuasiFiniteAt.isClopen_singleton._proof_1_2 | Mathlib.RingTheory.QuasiFinite.Basic | 2 ≠ 0 | null | false |
SemiRingCat.instCategory._proof_3 | Mathlib.Algebra.Category.Ring.Basic | ∀ {W X Y Z : SemiRingCat} (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 |
Submodule.pointwiseNeg | Mathlib.Algebra.Module.Submodule.Pointwise | {R : Type u_2} →
{M : Type u_3} → [inst : Semiring R] → [inst_1 : AddCommGroup M] → [inst_2 : Module R M] → Neg (Submodule R M) | The submodule with every element negated. Note if `R` is a ring and not just a semiring, this
is a no-op, as shown by `Submodule.neg_eq_self`.
Recall that When `R` is the semiring corresponding to the nonnegative elements of `R'`,
`Submodule R' M` is the type of cones of `M`. This instance reflects such cones about `0... | true |
BesselPotentialSpace.instSMul._proof_6 | Mathlib.Analysis.FunctionalSpaces.BesselPotentialSpace | ∀ {F : Type u_1} [inst : NormedAddCommGroup F] [inst_1 : NormedSpace ℂ F], IsBoundedSMul ℂ F | null | false |
_private.Mathlib.SetTheory.Lists.0.Lists'.ofList.match_1.eq_2 | Mathlib.SetTheory.Lists | ∀ {α : Type u_1} (motive : List (Lists α) → Sort u_2) (a : Lists α) (l : List (Lists α)) (h_1 : Unit → motive [])
(h_2 : (a : Lists α) → (l : List (Lists α)) → motive (a :: l)),
(match a :: l with
| [] => h_1 ()
| a :: l => h_2 a l) =
h_2 a l | null | true |
CategoryTheory.Equivalence.ctorIdx | Mathlib.CategoryTheory.Equivalence | {C : Type u₁} →
{D : Type u₂} →
{inst : CategoryTheory.Category.{v₁, u₁} C} → {inst_1 : CategoryTheory.Category.{v₂, u₂} D} → (C ≌ D) → ℕ | null | false |
_private.Mathlib.Algebra.ContinuedFractions.Computation.Translations.0.GenContFract.IntFractPair.exists_succ_nth_stream_of_fr_zero._simp_1_2 | Mathlib.Algebra.ContinuedFractions.Computation.Translations | ∀ {G : Type u_3} [inst : AddGroup G] {a b : G}, (a - b = 0) = (a = b) | null | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.