name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11.5k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
_private.Mathlib.RingTheory.AdicCompletion.Completeness.0.AdicCompletion.pow_smul_top_eq_ker_eval._simp_1_1 | Mathlib.RingTheory.AdicCompletion.Completeness | ∀ {R₁ : Type u_2} {R₂ : Type u_3} {R₃ : Type u_4} {M₁ : Type u_9} {M₂ : Type u_10} {M₃ : Type u_11} [inst : Semiring R₁]
[inst_1 : Semiring R₂] [inst_2 : Semiring R₃] [inst_3 : AddCommMonoid M₁] [inst_4 : AddCommMonoid M₂]
[inst_5 : AddCommMonoid M₃] {module_M₁ : Module R₁ M₁} {module_M₂ : Module R₂ M₂} {module_M₃ ... | null | false |
Nat.Partrec.Code.rfind'.noConfusion | Mathlib.Computability.PartrecCode | {P : Sort u} → {a a' : Nat.Partrec.Code} → a.rfind' = a'.rfind' → (a = a' → P) → P | null | false |
WellFounded.isWellOrder_iff_exists_not_lt_and_eq_or_gt | Mathlib.Order.WellFounded | ∀ {α : Type u_1} {r : α → α → Prop},
IsWellOrder α r ↔ ∀ (s : Set α), s.Nonempty → ∃ m ∈ s, ∀ x ∈ s, ¬r x m ∧ (m = x ∨ r m x) | null | true |
NormedAddGroupHom.equalizer | Mathlib.Analysis.Normed.Group.Hom | {V : Type u_1} →
{W : Type u_2} →
[inst : SeminormedAddCommGroup V] →
[inst_1 : SeminormedAddCommGroup W] → NormedAddGroupHom V W → NormedAddGroupHom V W → AddSubgroup V | The equalizer of two morphisms `f g : NormedAddGroupHom V W`. | true |
Pi.instConvexSpaceForall._proof_1 | Mathlib.Geometry.Convex.ConvexSpace.Prod | ∀ {R : Type u_3} [inst : Semiring R] [inst_1 : PartialOrder R] [inst_2 : IsStrictOrderedRing R] {ι : Type u_1}
{X : ι → Type u_2} [inst_3 : (i : ι) → Convexity.ConvexSpace R (X i)] (x : (i : ι) → X i),
(fun i => Convexity.iConvexComb (Convexity.StdSimplex.single x) fun x => x i) = x | null | false |
_private.Mathlib.Combinatorics.SetFamily.AhlswedeZhang.0.AhlswedeZhang.supSum_singleton._simp_1_1 | Mathlib.Combinatorics.SetFamily.AhlswedeZhang | ∀ {α : Type u_1} {s₁ s₂ : Finset α}, (s₁ ≤ s₂) = (s₁ ⊆ s₂) | null | false |
UInt64.lt_iff_toBitVec_lt | Init.Data.UInt.Lemmas | ∀ {a b : UInt64}, a < b ↔ a.toBitVec < b.toBitVec | null | true |
Lean.Meta.DefEqCacheKey | Lean.Meta.Basic | Type | null | true |
Std.Tactic.BVDecide.BVBinOp._sizeOf_1 | Std.Tactic.BVDecide.Bitblast.BVExpr.Basic | Std.Tactic.BVDecide.BVBinOp → ℕ | null | false |
Ordinal.nhds_eq_pure | Mathlib.SetTheory.Ordinal.Topology | ∀ {a : Ordinal.{u}}, nhds a = pure a ↔ ¬Order.IsSuccLimit a | null | true |
_private.Mathlib.Algebra.Homology.ShortComplex.Ab.0.CategoryTheory.ShortComplex.ab_exact_iff._simp_1_1 | Mathlib.Algebra.Homology.ShortComplex.Ab | ∀ {α : Sort u} {p : α → Prop} {a1 a2 : { x // p x }}, (a1 = a2) = (↑a1 = ↑a2) | null | false |
IsWeakLowerModularLattice.casesOn | Mathlib.Order.ModularLattice | {α : Type u_2} →
[inst : Lattice α] →
{motive : IsWeakLowerModularLattice α → Sort u} →
(t : IsWeakLowerModularLattice α) →
((inf_covBy_of_covBy_covBy_sup : ∀ {a b : α}, a ⋖ a ⊔ b → b ⋖ a ⊔ b → a ⊓ b ⋖ a) → motive ⋯) → motive t | null | false |
_private.Mathlib.MeasureTheory.Function.SimpleFuncDenseLp.0.MeasureTheory.«term_→ₛ_» | Mathlib.MeasureTheory.Function.SimpleFuncDenseLp | Lean.TrailingParserDescr | null | true |
Module.Finite.kerRepr | Mathlib.RingTheory.Finiteness.Cardinality | (R : Type u) →
(M : Type u_1) →
[inst : Ring R] →
[inst_1 : AddCommGroup M] → [inst_2 : Module R M] → [inst_3 : Module.Finite R M] → Submodule R (Fin ⋯.choose → R) | The kernel of a random surjective linear map from a finite free module
to a given finite module. | true |
TwoP.largeCategory._aux_3 | Mathlib.CategoryTheory.Category.TwoP | (X : TwoP) → X ⟶ X | null | false |
Numbering.dens_prefixed | Mathlib.Combinatorics.KatonaCircle | ∀ {X : Type u_1} [inst : Fintype X] [inst_1 : DecidableEq X] (s : Finset X),
(Numbering.prefixed s).dens = (↑((Fintype.card X).choose s.card))⁻¹ | null | true |
_private.Lean.Meta.Tactic.Simp.Main.0.Lean.Meta.Simp.reduceProjFn?.match_5 | Lean.Meta.Tactic.Simp.Main | (motive : Option Lean.ProjectionFunctionInfo → Sort u_1) →
(__do_lift : Option Lean.ProjectionFunctionInfo) →
(Unit → motive none) → ((projInfo : Lean.ProjectionFunctionInfo) → motive (some projInfo)) → motive __do_lift | null | false |
_private.Std.Data.DTreeMap.Internal.Lemmas.0.Std.DTreeMap.Internal.Impl.Const.keys_filter._simp_1_2 | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {instOrd : Ord α} {a b : α}, (compare a b ≠ Ordering.eq) = ((a == b) = false) | null | false |
Lean.Lsp.LeanImport.ctorIdx | Lean.Data.Lsp.Extra | Lean.Lsp.LeanImport → ℕ | null | false |
_private.Init.Data.List.Nat.TakeDrop.0.List.getElem_drop'._simp_1_1 | Init.Data.List.Nat.TakeDrop | ∀ (n k : ℕ), (n ≤ n + k) = True | null | false |
Lex.instMulAction | Mathlib.Algebra.Order.Group.Action.Synonym | {M : Type u_1} → {α : Type u_3} → [inst : Monoid M] → [MulAction M α] → MulAction (Lex M) α | null | true |
ComplexShape.Embedding.truncLE'Functor._proof_1 | Mathlib.Algebra.Homology.Embedding.TruncLE | ∀ {ι' : Type u_3} {c' : ComplexShape ι'} (C : Type u_2) [inst : CategoryTheory.Category.{u_1, u_2} C]
[inst_1 : CategoryTheory.Limits.HasZeroMorphisms C] [CategoryTheory.CategoryWithHomology C]
(K : HomologicalComplex C c') (i' : ι'), (K.sc i').HasHomology | null | false |
AlgebraicGeometry.Scheme.IdealSheafData.ofIdealTop._proof_7 | Mathlib.AlgebraicGeometry.IdealSheaf.Basic | ∀ {X : AlgebraicGeometry.Scheme} (I : Ideal ↑(X.presheaf.obj (Opposite.op ⊤))) (U : ↑X.affineOpens),
∀ x ∈ ↑U,
x ∈ X.zeroLocus ↑I ↔
x ∈ X.zeroLocus ↑(Ideal.map (CommRingCat.Hom.hom (X.presheaf.map (CategoryTheory.homOfLE ⋯).op)) I) | null | false |
_private.Init.Data.Int.Order.0.Int.ofNat_le.match_1_1 | Init.Data.Int.Order | ∀ {m n : ℕ} (motive : (∃ n_1, ↑m + ↑n_1 = ↑n) → Prop) (x : ∃ n_1, ↑m + ↑n_1 = ↑n),
(∀ (k : ℕ) (hk : ↑m + ↑k = ↑n), motive ⋯) → motive x | null | false |
CategoryTheory.HasLiftingProperty.transfiniteComposition.SqStruct.map_f' | Mathlib.CategoryTheory.SmallObject.TransfiniteCompositionLifting | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {J : Type w} [inst_1 : LinearOrder J] [inst_2 : OrderBot J]
{F : CategoryTheory.Functor J C} {c : CategoryTheory.Limits.Cocone F} {X Y : C} {p : X ⟶ Y} {f : F.obj ⊥ ⟶ X}
{g : c.pt ⟶ Y} {j : J} (sq' : CategoryTheory.HasLiftingProperty.transfiniteComposition.Sq... | null | true |
Bialgebra.comulBialgHom._proof_3 | Mathlib.RingTheory.Bialgebra.TensorProduct | ∀ (R : Type u_1) [inst : CommSemiring R], RingHomCompTriple (RingHom.id R) (RingHom.id R) (RingHom.id R) | null | false |
pow_le_pow_right' | Mathlib.Algebra.Order.Monoid.Unbundled.Pow | ∀ {M : Type u_3} [inst : Monoid M] [inst_1 : Preorder M] [MulLeftMono M] {a : M} {n m : ℕ},
1 ≤ a → n ≤ m → a ^ n ≤ a ^ m | null | true |
CategoryTheory.Precoverage.isSheafFor_subsheafify | Mathlib.CategoryTheory.Sites.Precoverage.Subsheaf | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {K : CategoryTheory.Precoverage C}
{F : CategoryTheory.Functor Cᵒᵖ (Type w)} (𝒮 : (Z : C) → Set (F.obj (Opposite.op Z))) {X : C}
{R : CategoryTheory.Presieve X},
R ∈ K.coverings X →
CategoryTheory.Presieve.IsSheafFor F R → CategoryTheory.Presieve.IsShe... | If `F` is a sheaf for `R` and `R ∈ K X`, then the `K`-sheafification of `𝒮` is a
sheaf for `R`. | true |
_private.Mathlib.Order.Filter.Bases.Basic.0.Filter.HasBasis.forall_iff.match_1_1 | Mathlib.Order.Filter.Bases.Basic | ∀ {α : Type u_2} {ι : Sort u_1} {p : ι → Prop} {s : ι → Set α} (_s : Set α) (motive : (∃ i, p i ∧ s i ⊆ _s) → Prop)
(x : ∃ i, p i ∧ s i ⊆ _s), (∀ (i : ι) (hi : p i) (his : s i ⊆ _s), motive ⋯) → motive x | null | false |
CategoryTheory.Comma.equivProd_unitIso_inv_app_left | Mathlib.CategoryTheory.Comma.Basic | ∀ {A : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} A] {B : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} B]
(L : CategoryTheory.Functor A (CategoryTheory.Discrete PUnit.{u_1 + 1}))
(R : CategoryTheory.Functor B (CategoryTheory.Discrete PUnit.{u_1 + 1})) (X : CategoryTheory.Comma L R),
((CategoryTheory... | null | true |
Set.Ici.isAtom_iff | Mathlib.Order.Atoms | ∀ {α : Type u_2} [inst : PartialOrder α] {a : α} {b : ↑(Set.Ici a)}, IsAtom b ↔ a ⋖ ↑b | null | true |
CategoryTheory.Functor.homEquivOfIsRightKanExtension._proof_3 | Mathlib.CategoryTheory.Functor.KanExtension.Basic | ∀ {C : Type u_3} {H : Type u_4} {D : Type u_1} [inst : CategoryTheory.Category.{u_6, u_3} C]
[inst_1 : CategoryTheory.Category.{u_2, u_4} H] [inst_2 : CategoryTheory.Category.{u_5, u_1} D]
(F' : CategoryTheory.Functor D H) {L : CategoryTheory.Functor C D} {F : CategoryTheory.Functor C H}
(α : L.comp F' ⟶ F) [inst... | null | false |
RBTree.RBNode.balLeft | BatteriesRecycling.RBTree.Basic | {α : Type u_1} → RBTree.RBNode α → α → RBTree.RBNode α → RBTree.RBNode α | Rebalancing a tree which has shrunk on the left. | true |
OpenNormalSubgroup.instSemilatticeSupOpenNormalSubgroup | Mathlib.Topology.Algebra.OpenSubgroup | {G : Type u} →
[inst : Group G] → [inst_1 : TopologicalSpace G] → [SeparatelyContinuousMul G] → SemilatticeSup (OpenNormalSubgroup G) | null | true |
CochainComplex.HomComplex.Cochain.leftShift_rightShift | Mathlib.Algebra.Homology.HomotopyCategory.HomComplexShift | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Preadditive C]
{K L : CochainComplex C ℤ} {n : ℤ} (γ : CochainComplex.HomComplex.Cochain K L n) (a n' : ℤ) (hn' : n' + a = n),
(γ.rightShift a n' hn').leftShift a n hn' = (a * n + a * (a - 1) / 2).negOnePow • γ.shift a | null | true |
mulRightLinearMap_apply | Mathlib.LinearAlgebra.Matrix.Bilinear | ∀ (l : Type u_1) {m : Type u_2} {n : Type u_3} (R : Type u_5) {A : Type u_6} [inst : Fintype m] [inst_1 : Semiring R]
[inst_2 : NonUnitalNonAssocSemiring A] [inst_3 : Module R A] [inst_4 : IsScalarTower R A A] (Y : Matrix m n A)
(x : Matrix l m A), (mulRightLinearMap l R Y) x = x * Y | null | true |
CategoryTheory.CostructuredArrow.toStructuredArrow_obj | Mathlib.CategoryTheory.Comma.StructuredArrow.Basic | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
(F : CategoryTheory.Functor C D) (d : D) (X : (CategoryTheory.CostructuredArrow F d)ᵒᵖ),
(CategoryTheory.CostructuredArrow.toStructuredArrow F d).obj X =
CategoryTheory.StructuredArrow.mk (Opp... | null | true |
CliffordAlgebra.ofBaseChange._proof_2 | Mathlib.LinearAlgebra.CliffordAlgebra.BaseChange | ∀ {R : Type u_3} (A : Type u_1) {V : Type u_2} [inst : CommRing R] [inst_1 : CommRing A] [inst_2 : AddCommGroup V]
[inst_3 : Algebra R A] [inst_4 : Module R V], IsScalarTower A A (TensorProduct R A V) | null | false |
Aesop.Slot.recOn | Aesop.Forward.RuleInfo | {motive : Aesop.Slot → Sort u} →
(t : Aesop.Slot) →
((typeDiscrTreeKeys? : Option (Array Lean.Meta.DiscrTree.Key)) →
(index : Aesop.SlotIndex) →
(premiseIndex : Aesop.PremiseIndex) →
(deps common : Std.HashSet Aesop.PremiseIndex) →
(forwardDeps : Array Aesop.PremiseInde... | null | false |
HilbertBasis.instFunLike._proof_1 | Mathlib.Analysis.InnerProductSpace.l2Space | ∀ {ι : Type u_2} {𝕜 : Type u_1} [inst : RCLike 𝕜] (i : ι), IsBoundedSMul 𝕜 𝕜 | null | false |
ENNReal.one_lt_two | Mathlib.Data.ENNReal.Basic | 1 < 2 | null | true |
_private.Batteries.Data.String.Legacy.0.String.Legacy.anyAux._proof_4 | Batteries.Data.String.Legacy | ∀ (s : String) (stopPos i : String.Pos.Raw),
i < stopPos → stopPos.byteIdx - (String.Pos.Raw.next s i).byteIdx < stopPos.byteIdx - i.byteIdx | null | false |
_private.Mathlib.CategoryTheory.Limits.Shapes.Reflexive.0.CategoryTheory.Limits.WalkingParallelPair.inclusionWalkingReflexivePair.match_1.splitter | Mathlib.CategoryTheory.Limits.Shapes.Reflexive | (motive : CategoryTheory.Limits.WalkingParallelPair → Sort u_1) →
(x : CategoryTheory.Limits.WalkingParallelPair) →
(Unit → motive CategoryTheory.Limits.WalkingParallelPair.one) →
(Unit → motive CategoryTheory.Limits.WalkingParallelPair.zero) → motive x | null | true |
groupCohomology.mapShortComplex₂_exact | Mathlib.RepresentationTheory.Homological.GroupCohomology.LongExactSequence | ∀ {k G : Type u} [inst : CommRing k] [inst_1 : Group G] {X : CategoryTheory.ShortComplex (Rep.{u, u, u} k G)},
X.ShortExact → ∀ (i : ℕ), (groupCohomology.mapShortComplex₂ X i).Exact | Exactness of `Hⁱ(G, X₁) ⟶ Hⁱ(G, X₂) ⟶ Hⁱ(G, X₃)`. | true |
_private.Init.Data.Nat.Div.Basic.0.Nat.mod.match_1.splitter | Init.Data.Nat.Div.Basic | (motive : ℕ → ℕ → Sort u_1) → (x x_1 : ℕ) → ((x : ℕ) → motive 0 x) → ((n m : ℕ) → motive n.succ m) → motive x x_1 | null | true |
Std.ExtHashMap.size_insertIfNew_le | Std.Data.ExtHashMap.Lemmas | ∀ {α : Type u} {β : Type v} {x : BEq α} {x_1 : Hashable α} {m : Std.ExtHashMap α β} [inst : EquivBEq α]
[inst_1 : LawfulHashable α] {k : α} {v : β}, (m.insertIfNew k v).size ≤ m.size + 1 | null | true |
Std.DTreeMap.Internal.Impl.Const.getEntryLT?.go.eq_def | Std.Data.DTreeMap.Internal.Model | ∀ {α : Type u} {β : Type v} [inst : Ord α] (k : α) (best : Option (α × β))
(a : Std.DTreeMap.Internal.Impl α fun x => β),
Std.DTreeMap.Internal.Impl.Const.getEntryLT?.go k best a =
match a with
| Std.DTreeMap.Internal.Impl.leaf => best
| Std.DTreeMap.Internal.Impl.inner size ky y l r =>
match comp... | null | true |
_private.Init.Data.List.Sort.Lemmas.0.List.mergeSort_of_pairwise._proof_1_4 | Init.Data.List.Sort.Lemmas | ∀ {α : Type u_1} (a b : α) (xs : List α),
(↑(List.MergeSort.Internal.splitInTwo ⟨a :: b :: xs, ⋯⟩).1).length < xs.length + 1 + 1 →
¬xs.length + 1 + 1 - (xs.length + 1 + 1 + 1) / 2 < xs.length + 1 + 1 → False | null | false |
Lean.Doc.Parser.UnorderedListType.ofNat | Lean.DocString.Parser | ℕ → Lean.Doc.Parser.UnorderedListType | null | true |
AdicCompletion.AdicCauchySequence.instSMulNat | Mathlib.RingTheory.AdicCompletion.Basic | {R : Type u_1} →
[inst : CommRing R] →
(I : Ideal R) →
(M : Type u_4) →
[inst_1 : AddCommGroup M] → [inst_2 : Module R M] → SMul ℕ (AdicCompletion.AdicCauchySequence I M) | null | true |
_private.Init.Data.SInt.Lemmas.0.Int32.ofNat_add._simp_1_1 | Init.Data.SInt.Lemmas | ∀ {n : ℕ}, Int32.ofNat n = Int32.ofInt ↑n | null | false |
LinearMap.toMatrixOrthonormal._proof_3 | Mathlib.Analysis.InnerProductSpace.Adjoint | ∀ {𝕜 : Type u_2} {E : Type u_1} [inst : RCLike 𝕜] [inst_1 : NormedAddCommGroup E] [inst_2 : InnerProductSpace 𝕜 E]
{n : Type u_3} [inst_3 : Fintype n] [inst_4 : DecidableEq n] (v₁ : OrthonormalBasis n 𝕜 E),
Function.LeftInverse (LinearMap.toMatrix v₁.toBasis v₁.toBasis).invFun
(↑(LinearMap.toMatrix v₁.toBas... | null | false |
List.suffix_iff_eq_drop | Init.Data.List.Nat.Sublist | ∀ {α : Type u_1} {l₁ l₂ : List α}, l₁ <:+ l₂ ↔ l₁ = List.drop (l₂.length - l₁.length) l₂ | null | true |
Pi.constNonUnitalRingHom._proof_1 | Mathlib.Algebra.Ring.Pi | ∀ (α : Type u_1) (β : Type u_2) [inst : NonUnitalNonAssocSemiring β] (x y : β),
(NonUnitalRingHom.pi fun x => NonUnitalRingHom.id β).toFun (x * y) =
(NonUnitalRingHom.pi fun x => NonUnitalRingHom.id β).toFun x *
(NonUnitalRingHom.pi fun x => NonUnitalRingHom.id β).toFun y | null | false |
Monotone.measure_iInter | Mathlib.MeasureTheory.Measure.MeasureSpace | ∀ {α : Type u_1} {ι : Type u_5} {m : MeasurableSpace α} {μ : MeasureTheory.Measure α} [inst : Preorder ι]
[IsCodirectedOrder ι] [Filter.atBot.IsCountablyGenerated] {s : ι → Set α},
Monotone s → (∀ (i : ι), MeasureTheory.NullMeasurableSet (s i) μ) → (∃ i, μ (s i) ≠ ⊤) → μ (⋂ i, s i) = ⨅ i, μ (s i) | **Continuity from above**:
the measure of the intersection of a monotone family of measurable sets
indexed by a type with countably generated `atBot` filter
is equal to the infimum of the measures. | true |
Set.sUnion_powerset_gc | Mathlib.Data.Set.Lattice | ∀ {α : Type u_1}, GaloisConnection (fun x => ⋃₀ x) fun x => 𝒫 x | `⋃₀` and `𝒫` form a Galois connection. | true |
String.Slice.Pattern.ToBackwardSearcher.DefaultBackwardSearcher.mk._flat_ctor | Init.Data.String.Pattern.Basic | {ρ : Type} →
{pat : ρ} → {s : String.Slice} → s.Pos → String.Slice.Pattern.ToBackwardSearcher.DefaultBackwardSearcher pat s | null | false |
List.firstM._unsafe_rec | Init.Data.List.Control | {m : Type u → Type v} → [Alternative m] → {α : Type w} → {β : Type u} → (α → m β) → List α → m β | null | false |
AddChar.instDecidableEq | Mathlib.Algebra.Group.AddChar | {A : Type u_1} → {M : Type u_3} → [inst : AddMonoid A] → [inst_1 : Monoid M] → DecidableEq (AddChar A M) | null | true |
CategoryTheory.Limits.WidePushoutShape.Hom.noConfusionType | Mathlib.CategoryTheory.Limits.Shapes.WidePullbacks | Sort u →
{J : Type w} →
{a a_1 : CategoryTheory.Limits.WidePushoutShape J} →
a.Hom a_1 → {J' : Type w} → {a' a'_1 : CategoryTheory.Limits.WidePushoutShape J'} → a'.Hom a'_1 → Sort u | null | false |
_private.Mathlib.Data.Set.Card.0.Set.ncard_congr._simp_1_2 | Mathlib.Data.Set.Card | ∀ {α : Type u_1} (s : Set α), s.ncard = Nat.card ↑s | null | false |
LinearMap.addMonoid._proof_1 | Mathlib.Algebra.Module.LinearMap.Defs | ∀ {R₁ : Type u_1} {R₂ : Type u_2} {M : Type u_3} {M₂ : Type u_4} [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₂} (a b c : M →ₛₗ[σ₁₂] M₂), a + b + c = a + (b + c) | null | false |
CategoryTheory.FreeGroupoid.liftNatIso.eq_1 | Mathlib.CategoryTheory.Groupoid.FreeGroupoidOfCategory | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {G : Type u₁} [inst_1 : CategoryTheory.Groupoid G]
(F₁ F₂ : CategoryTheory.Functor (CategoryTheory.FreeGroupoid C) G)
(τ : (CategoryTheory.FreeGroupoid.of C).comp F₁ ≅ (CategoryTheory.FreeGroupoid.of C).comp F₂),
CategoryTheory.FreeGroupoid.liftNatIso F₁ F₂... | null | true |
CategoryTheory.SingleFunctors.Hom.ext_iff | Mathlib.CategoryTheory.Shift.SingleFunctors | ∀ {C : Type u_1} {D : Type u_2} {inst : CategoryTheory.Category.{v_1, u_1} C}
{inst_1 : CategoryTheory.Category.{v_2, u_2} D} {A : Type u_5} {inst_2 : AddMonoid A}
{inst_3 : CategoryTheory.HasShift D A} {F G : CategoryTheory.SingleFunctors C D A} {x y : F.Hom G},
x = y ↔ x.hom = y.hom | null | true |
_private.Lean.Meta.Tactic.Grind.Arith.CommRing.NonCommSemiringM.0.Lean.Meta.Grind.Arith.CommRing.setTermNonCommSemiringId.match_1 | Lean.Meta.Tactic.Grind.Arith.CommRing.NonCommSemiringM | (motive : Option ℕ → Sort u_1) →
(__do_lift : Option ℕ) →
((semiringId' : ℕ) → motive (some semiringId')) → ((x : Option ℕ) → motive x) → motive __do_lift | null | false |
_private.Std.Do.WP.Adequate.0.Std.Do.instWPAdequateExceptTExceptPureOfLawfulMonad.match_1.splitter | Std.Do.WP.Adequate | {ε α : Type u_1} →
(motive : Except ε α → Sort u_2) →
(r : Except ε α) → ((a : α) → motive (Except.ok a)) → ((a : ε) → motive (Except.error a)) → motive r | null | true |
PadicInt.instCommRing._proof_26 | Mathlib.NumberTheory.Padics.PadicIntegers | ∀ {p : ℕ} [hp : Fact (Nat.Prime p)] (a b c : ℤ_[p]), a * (b + c) = a * b + a * c | null | false |
Homotopy.compRight._proof_2 | Mathlib.Algebra.Homology.Homotopy | ∀ {ι : Type u_3} {V : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} V] [inst_1 : CategoryTheory.Preadditive V]
{c : ComplexShape ι} {C D E : HomologicalComplex V c} {e f : C ⟶ D} (h : Homotopy e f) (g : D ⟶ E) (i : ι),
(CategoryTheory.CategoryStruct.comp e g).f i =
(((dNext i) fun i j => CategoryTheory.C... | null | false |
UniformContinuous₂.bicompl | Mathlib.Topology.UniformSpace.Basic | ∀ {α : Type ua} {β : Type ub} {γ : Type uc} {δ : Type ud} {δ' : Type u_2} [inst : UniformSpace α]
[inst_1 : UniformSpace β] [inst_2 : UniformSpace γ] [inst_3 : UniformSpace δ] [inst_4 : UniformSpace δ']
{f : α → β → γ} {ga : δ → α} {gb : δ' → β},
UniformContinuous₂ f → UniformContinuous ga → UniformContinuous gb ... | null | true |
_private.Mathlib.Topology.Partial.0.pcontinuous_iff'._simp_1_2 | Mathlib.Topology.Partial | ∀ {X : Type u} [inst : TopologicalSpace X] {x : X} {s : Set X}, (s ∈ nhds x) = ∃ t ⊆ s, IsOpen t ∧ x ∈ t | null | false |
Lean.Elab.Info | Lean.Elab.InfoTree.Types | Type | Header information for a node in `InfoTree`. | true |
StrictConvexOn.add_convexOn | Mathlib.Analysis.Convex.Function | ∀ {𝕜 : Type u_1} {E : Type u_2} {β : Type u_5} [inst : Semiring 𝕜] [inst_1 : PartialOrder 𝕜] [inst_2 : AddCommMonoid E]
[inst_3 : AddCommMonoid β] [inst_4 : PartialOrder β] [IsOrderedCancelAddMonoid β] [inst_6 : SMul 𝕜 E]
[inst_7 : DistribMulAction 𝕜 β] {s : Set E} {f g : E → β},
StrictConvexOn 𝕜 s f → Conv... | null | true |
CategoryTheory.StructuredArrow.subobjectEquiv._proof_6 | Mathlib.CategoryTheory.Subobject.Comma | ∀ {C : Type u_4} [inst : CategoryTheory.Category.{u_3, u_4} C] {D : Type u_2}
[inst_1 : CategoryTheory.Category.{u_1, u_2} D] {S : D} {T : CategoryTheory.Functor C D}
[inst_2 : CategoryTheory.Limits.HasFiniteLimits C] [inst_3 : CategoryTheory.Limits.PreservesFiniteLimits T]
(A : CategoryTheory.StructuredArrow S T... | null | false |
DiscreteTiling.PlacedTile.coe_smul | Mathlib.Combinatorics.Tiling.Tile | ∀ {G : Type u_1} {X : Type u_2} {ιₚ : Type u_3} [inst : Group G] [inst_1 : MulAction G X]
{ps : DiscreteTiling.Protoset G X ιₚ} (g : G) (pt : DiscreteTiling.PlacedTile ps), ↑(g • pt) = g • ↑pt | null | true |
CategoryTheory.pullbackShiftIso.eq_1 | Mathlib.CategoryTheory.Shift.Pullback | ∀ (C : Type u_1) [inst : CategoryTheory.Category.{v_1, u_1} C] {A : Type u_2} {B : Type u_3} [inst_1 : AddMonoid A]
[inst_2 : AddMonoid B] [inst_3 : CategoryTheory.HasShift C B] (φ : A →+ B) (a : A) (b : B) (h : b = φ a),
CategoryTheory.pullbackShiftIso C φ a b h = CategoryTheory.eqToIso ⋯ | null | true |
Lean.Elab.Tactic.Omega.MetaProblem.mk | Lean.Elab.Tactic.Omega.Frontend | Lean.Elab.Tactic.Omega.Problem →
List Lean.Expr → List Lean.Expr → Std.HashSet Lean.Expr → Lean.Elab.Tactic.Omega.MetaProblem | null | true |
AlgebraicGeometry.PresheafedSpace.IsOpenImmersion.pullbackToBaseIsOpenImmersion | Mathlib.Geometry.RingedSpace.OpenImmersion | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {X Y Z : AlgebraicGeometry.PresheafedSpace C} (f : X ⟶ Z)
[hf : AlgebraicGeometry.PresheafedSpace.IsOpenImmersion f] (g : Y ⟶ Z)
[inst_1 : AlgebraicGeometry.PresheafedSpace.IsOpenImmersion g],
AlgebraicGeometry.PresheafedSpace.IsOpenImmersion
(CategoryT... | null | true |
Coalgebra.TensorProduct.lid._proof_5 | Mathlib.RingTheory.Coalgebra.TensorProduct | ∀ (R : Type u_2) (P : Type u_1) [inst : CommSemiring R] [inst_1 : AddCommMonoid P] [inst_2 : Module R P],
Function.RightInverse (TensorProduct.lid R P).invFun (↑(TensorProduct.lid R P)).toFun | null | false |
_private.Std.Do.WP.Adequate.0.OptionT.bind.match_1.eq_1 | Std.Do.WP.Adequate | ∀ {α : Type u_1} (motive : Option α → Sort u_2) (a : α) (h_1 : (a : α) → motive (some a)) (h_2 : Unit → motive none),
(match some a with
| some a => h_1 a
| none => h_2 ()) =
h_1 a | null | true |
NNReal.sqrt_inv | Mathlib.Analysis.Real.Sqrt | ∀ (x : NNReal), NNReal.sqrt x⁻¹ = (NNReal.sqrt x)⁻¹ | null | true |
Ordinal.iSup_lt_of_lt_cof | Mathlib.SetTheory.Cardinal.Cofinality.Ordinal | ∀ {α : Type u} {f : α → Ordinal.{u}} {a : Ordinal.{u}}, Cardinal.mk α < a.cof → (∀ (i : α), f i < a) → ⨆ i, f i < a | null | true |
_private.Mathlib.Algebra.Lie.Sl2.0.IsSl2Triple.HasPrimitiveVectorWith.pow_toEnd_f_eq_zero_of_eq_nat._proof_1_4 | Mathlib.Algebra.Lie.Sl2 | (1 + 1).AtLeastTwo | null | false |
WithBot.coe_le_iff | Mathlib.Order.WithBot | ∀ {α : Type u_1} {a : α} [inst : LE α] {x : WithBot α}, ↑a ≤ x ↔ ∃ b, x = ↑b ∧ a ≤ b | null | true |
Std.DHashMap.Const.ofList_cons | Std.Data.DHashMap.Lemmas | ∀ {α : Type u} {x : BEq α} {x_1 : Hashable α} {β : Type v} {k : α} {v : β} {tl : List (α × β)},
Std.DHashMap.Const.ofList ((k, v) :: tl) = Std.DHashMap.Const.insertMany (∅.insert k v) tl | null | true |
Submodule.projectionOnto_apply_eq_zero_iff._simp_1 | Mathlib.LinearAlgebra.Projection | ∀ {R : Type u_1} [inst : Ring R] {E : Type u_2} [inst_1 : AddCommGroup E] [inst_2 : Module R E] {p q : Submodule R E}
(h : IsCompl p q) {x : E}, ((p.projectionOnto q h) x = 0) = (x ∈ q) | null | false |
_private.Std.Data.DTreeMap.Internal.Lemmas.0.Std.DTreeMap.Internal.Impl.getD_alter._simp_1_3 | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {β : α → Type v} {x : Ord α} {t : Std.DTreeMap.Internal.Impl α β} {k : α},
(k ∈ t) = (Std.DTreeMap.Internal.Impl.contains k t = true) | null | false |
_private.Mathlib.Algebra.Order.Module.Defs.0.smul_eq_smul_iff_eq_and_eq_of_pos._simp_1_1 | Mathlib.Algebra.Order.Module.Defs | ∀ {α : Type u_2} [inst : PartialOrder α] {a b : α}, (a = b) = (a ≤ b ∧ ¬a < b) | null | false |
NormalizationMonoid.casesOn | Mathlib.Algebra.GCDMonoid.Basic | {α : Type u_2} →
[inst : CommMonoidWithZero α] →
{motive : NormalizationMonoid α → Sort u} →
(t : NormalizationMonoid α) →
((normUnit : α → αˣ) →
(normUnit_zero : normUnit 0 = 1) →
(normUnit_mul : ∀ {a b : α}, a ≠ 0 → b ≠ 0 → normUnit (a * b) = normUnit a * normUnit b) →
... | null | false |
BoundedOrderHom.cancel_right | Mathlib.Order.Hom.Bounded | ∀ {α : Type u_2} {β : Type u_3} {γ : Type u_4} [inst : Preorder α] [inst_1 : Preorder β] [inst_2 : Preorder γ]
[inst_3 : BoundedOrder α] [inst_4 : BoundedOrder β] [inst_5 : BoundedOrder γ] {g₁ g₂ : BoundedOrderHom β γ}
{f : BoundedOrderHom α β}, Function.Surjective ⇑f → (g₁.comp f = g₂.comp f ↔ g₁ = g₂) | null | true |
smul_mem_fixedPoints_of_normal | Mathlib.GroupTheory.GroupAction.SubMulAction | ∀ {G : Type u_1} [inst : Group G] {α : Type u_2} [inst_1 : MulAction G α] {H : Subgroup G} [hH : H.Normal] (g : G)
{a : α}, a ∈ MulAction.fixedPoints (↥H) α → g • a ∈ MulAction.fixedPoints (↥H) α | null | true |
Lean.Elab.Info.ofErrorNameInfo.noConfusion | Lean.Elab.InfoTree.Types | {P : Sort u} →
{i i' : Lean.Elab.ErrorNameInfo} →
Lean.Elab.Info.ofErrorNameInfo i = Lean.Elab.Info.ofErrorNameInfo i' → (i = i' → P) → P | null | false |
WithBot.bot_wcovBy_coe._simp_1 | Mathlib.Order.Cover | ∀ {α : Type u_1} [inst : Preorder α] {a : α}, (⊥ ⩿ ↑a) = IsMin a | null | false |
CategoryTheory.MorphismProperty.Comma.mapLeftComp | Mathlib.CategoryTheory.MorphismProperty.Comma | {A : Type u_1} →
[inst : CategoryTheory.Category.{v_1, u_1} A] →
{B : Type u_2} →
[inst_1 : CategoryTheory.Category.{v_2, u_2} B] →
{T : Type u_3} →
[inst_2 : CategoryTheory.Category.{v_3, u_3} T] →
(R : CategoryTheory.Functor B T) →
{P : CategoryTheory.MorphismPr... | The functor `P.Comma L₁ R Q W ⥤ P.Comma L₃ R Q W` induced by the composition of two natural
transformations `l : L₁ ⟶ L₂` and `l' : L₂ ⟶ L₃` is naturally isomorphic to the composition of the
two functors induced by these natural transformations. | true |
Std.DHashMap.Internal.Raw₀.Const.wf_insertManyIfNewUnit₀ | Std.Data.DHashMap.Internal.WF | ∀ {α : Type u} [inst : BEq α] [inst_1 : Hashable α] [EquivBEq α] [LawfulHashable α] {ρ : Type w} [inst_4 : ForIn Id ρ α]
{m : Std.DHashMap.Raw α fun x => Unit} {h : 0 < m.buckets.size} {l : ρ},
m.WF → (↑↑(Std.DHashMap.Internal.Raw₀.Const.insertManyIfNewUnit ⟨m, h⟩ l)).WF | null | true |
FiniteField.frobeniusAlgEquivOfAlgebraic._proof_1 | Mathlib.FieldTheory.Finite.Basic | ∀ (K : Type u_1) [inst : Field K], IsDomain K | null | false |
_private.Mathlib.Algebra.Free.0.FreeAddMagma.liftAux.match_1.eq_2 | Mathlib.Algebra.Free | ∀ {α : Type u_1} (motive : FreeAddMagma α → Sort u_2) (x y : FreeAddMagma α)
(h_1 : (x : α) → motive (FreeAddMagma.of x)) (h_2 : (x y : FreeAddMagma α) → motive (x.add y)),
(match x.add y with
| FreeAddMagma.of x => h_1 x
| x.add y => h_2 x y) =
h_2 x y | null | true |
CategoryTheory.ShortComplex.ShortExact.exactAt_X₃._auto_1 | Mathlib.Algebra.Homology.HomologySequenceLemmas | Lean.Syntax | null | false |
Num.Prime | Mathlib.Data.Num.Prime | Num → Prop | Primality predicate for a `Num`. | true |
MulChar.exists_apply_ne_one_of_hasEnoughRootsOfUnity | Mathlib.NumberTheory.MulChar.Duality | ∀ (M : Type u_1) (R : Type u_2) [inst : CommMonoid M] [inst_1 : CommRing R] [Finite M]
[HasEnoughRootsOfUnity R (Monoid.exponent Mˣ)] [Nontrivial R] {a : M}, a ≠ 1 → ∃ χ, χ a ≠ 1 | If `M` is a finite commutative monoid and `R` is a ring that has enough roots of unity,
then for each `a ≠ 1` in `M`, there exists a multiplicative character `χ : M → R` such that
`χ a ≠ 1`. | true |
PresheafOfModules.Monoidal.tensorObj_map_tmul | Mathlib.Algebra.Category.ModuleCat.Presheaf.Monoidal | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] {R : CategoryTheory.Functor Cᵒᵖ CommRingCat}
{M₁ M₂ : PresheafOfModules (R.comp (CategoryTheory.forget₂ CommRingCat RingCat))} {X Y : Cᵒᵖ} (f : X ⟶ Y)
(m₁ : ↑(M₁.obj X)) (m₂ : ↑(M₂.obj X)),
(ModuleCat.Hom.hom ((PresheafOfModules.Monoidal.tensorObj M₁ ... | null | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.