name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11.5k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
_private.Mathlib.AlgebraicTopology.DoldKan.Degeneracies.0.AlgebraicTopology.DoldKan.DegeneraciesVanish.comp._simp_1_1 | Mathlib.AlgebraicTopology.DoldKan.Degeneracies | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Preadditive C]
{X : CategoryTheory.SimplicialObject C} {n : ℕ} {T : C} (f : X.obj (Opposite.op { len := n + 1 }) ⟶ T),
AlgebraicTopology.DoldKan.DegeneraciesVanish f = ∀ (i : Fin (n + 1)), CategoryTheory.CategoryStruct.comp (X.σ... | null | false |
Equiv.normedCommGroup.eq_1 | Mathlib.Analysis.Normed.Module.TransferInstance | ∀ {α : Type u_1} {β : Type u_2} [inst : NormedCommGroup β] (e : α ≃ β),
e.normedCommGroup =
{ toNorm := (NormedCommGroup.induced α β e.mulEquiv ⋯).toNorm,
toCommGroup := (NormedCommGroup.induced α β e.mulEquiv ⋯).toCommGroup, toPseudoMetricSpace := e.pseudometricSpace,
eq_of_dist_eq_zero := ⋯, dist_eq... | null | true |
Std.DTreeMap.Internal.Impl.containsThenInsert_fst_eq_containsₘ | Std.Data.DTreeMap.Internal.WF.Lemmas | ∀ {α : Type u} {β : α → Type v} [inst : Ord α] [Std.TransOrd α] [inst_2 : BEq α] [Std.LawfulBEqOrd α]
(t : Std.DTreeMap.Internal.Impl α β) (htb : t.Balanced),
t.Ordered → ∀ (a : α) (b : β a), (Std.DTreeMap.Internal.Impl.containsThenInsert a b t htb).1 = t.containsₘ a | null | true |
MeasureTheory.Measure.quasiMeasurePreserving_smul | Mathlib.MeasureTheory.Measure.Lebesgue.EqHaar | ∀ {E : Type u_1} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E] [inst_2 : MeasurableSpace E] [BorelSpace E]
[FiniteDimensional ℝ E] (μ : MeasureTheory.Measure E) [μ.IsAddHaarMeasure] {r : ℝ},
r ≠ 0 → MeasureTheory.Measure.QuasiMeasurePreserving (fun x => r • x) μ μ | null | true |
Metric.closedBall_eq_sphere_of_nonpos | Mathlib.Topology.MetricSpace.Pseudo.Defs | ∀ {α : Type u} [inst : PseudoMetricSpace α] {x : α} {ε : ℝ}, ε ≤ 0 → Metric.closedBall x ε = Metric.sphere x ε | Closed balls and spheres coincide when the radius is non-positive | true |
Rack.PreEnvelGroupRel'.symm | Mathlib.Algebra.Quandle | {R : Type u} →
[inst : Rack R] → {a b : Rack.PreEnvelGroup R} → Rack.PreEnvelGroupRel' R a b → Rack.PreEnvelGroupRel' R b a | null | true |
Lean.ErrorExplanation.declLoc? | Lean.ErrorExplanation | Lean.ErrorExplanation → Option Lean.DeclarationLocation | null | true |
Module.rankAtStalk_tensorProduct_of_isScalarTower | Mathlib.RingTheory.Spectrum.Prime.FreeLocus | ∀ {R : Type uR} {M : Type uM} [inst : CommRing R] [inst_1 : AddCommGroup M] [inst_2 : Module R M] [Module.Flat R M]
[Module.Finite R M] {S : Type u_1} [inst_5 : CommRing S] [inst_6 : Algebra R S] (N : Type u_2)
[inst_7 : AddCommGroup N] [inst_8 : Module R N] [inst_9 : Module S N] [inst_10 : IsScalarTower R S N]
[... | null | true |
AddSubmonoid.fromLeftNeg_leftNegEquiv_symm | Mathlib.GroupTheory.Submonoid.Inverses | ∀ {M : Type u_1} [inst : AddCommMonoid M] (S : AddSubmonoid M) (hS : S ≤ IsAddUnit.addSubmonoid M) (x : ↥S),
S.fromLeftNeg ((S.leftNegEquiv hS).symm x) = x | null | true |
AlgebraicGeometry.Scheme.instHasPullbacksPrecoverageOfHasPullbacks | Mathlib.AlgebraicGeometry.Sites.MorphismProperty | ∀ (P : CategoryTheory.MorphismProperty AlgebraicGeometry.Scheme) [P.HasPullbacks],
(AlgebraicGeometry.Scheme.precoverage P).HasPullbacks | null | true |
Lean.Elab.Tactic.MkSimpContextResult.rec | Lean.Elab.Tactic.Simp | {motive : Lean.Elab.Tactic.MkSimpContextResult → Sort u} →
((ctx : Lean.Meta.Simp.Context) →
(simprocs : Lean.Meta.Simp.SimprocsArray) →
(dischargeWrapper : Lean.Elab.Tactic.Simp.DischargeWrapper) →
(simpArgs : Array (Lean.Syntax × Lean.Elab.Tactic.ElabSimpArgResult)) →
motive { ct... | null | false |
WithTop.insertTop | Mathlib.Order.Interval.Finset.Defs | {α : Type u_1} → Finset α ↪o Finset (WithTop α) | Given a finset on `α`, lift it to being a finset on `WithTop α`
using `WithTop.some` and then insert `⊤`. | true |
_private.Batteries.Data.List.Lemmas.0.List.getElem_idxsOf_lt._proof_1_8 | Batteries.Data.List.Lemmas | ∀ {α : Type u_1} {xs : List α} {x : α} [inst : BEq α] (h : 1 ≤ (List.filter (fun x_1 => x_1 == x) xs).length),
(List.findIdxs (fun x_1 => x_1 == x) xs)[0] < xs.length | null | false |
_private.Mathlib.Algebra.GroupWithZero.Action.Pointwise.Finset.0.Finset.inv_op_smul_finset_distrib₀._simp_1_3 | Mathlib.Algebra.GroupWithZero.Action.Pointwise.Finset | ∀ {α : Type u_1} {β : Type u_2} [inst : DecidableEq β] [inst_1 : GroupWithZero α] [inst_2 : MulAction α β]
{s : Finset β} {a : α} {b : β}, a ≠ 0 → (b ∈ a • s) = (a⁻¹ • b ∈ s) | null | false |
_private.Mathlib.Topology.MetricSpace.PiNat.0.PiCountable.pseudoEMetricSpace._simp_8 | Mathlib.Topology.MetricSpace.PiNat | ∀ {a b c : Prop}, (a ∧ b → c) = (a → b → c) | null | false |
CategoryTheory.Limits.Sigma.whiskerEquiv_hom | Mathlib.CategoryTheory.Limits.Shapes.Products | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {J : Type u_1} {K : Type u_2} {f : J → C} {g : K → C}
(e : J ≃ K) (w : (j : J) → g (e j) ≅ f j) [inst_1 : CategoryTheory.Limits.HasCoproduct f]
[inst_2 : CategoryTheory.Limits.HasCoproduct g],
(CategoryTheory.Limits.Sigma.whiskerEquiv e w).hom = CategoryThe... | null | true |
SemiNormedGrp.explicitCokernelDesc._proof_1 | Mathlib.Analysis.Normed.Group.SemiNormedGrp.Kernels | ∀ {X Y Z : SemiNormedGrp} {f : X ⟶ Y} {g : Y ⟶ Z},
CategoryTheory.CategoryStruct.comp f g = 0 →
CategoryTheory.CategoryStruct.comp f g = CategoryTheory.CategoryStruct.comp 0 g | null | false |
GroupExtension.Splitting.instFunLike | Mathlib.GroupTheory.GroupExtension.Defs | {N : Type u_1} →
{E : Type u_2} →
{G : Type u_3} →
[inst : Group N] → [inst_1 : Group E] → [inst_2 : Group G] → (S : GroupExtension N E G) → FunLike S.Splitting G E | null | true |
Lean.Meta.Grind.Arith.Cutsat.EqCnstr._sizeOf_15 | Lean.Meta.Tactic.Grind.Arith.Cutsat.Types | Option Lean.Meta.Grind.Arith.Cutsat.DvdCnstr → ℕ | null | false |
LinearMap.mulLeft._proof_2 | Mathlib.Algebra.Module.LinearMap.Defs | ∀ (R : Type u_2) {A : Type u_1} [inst : Semiring R] [inst_1 : NonUnitalNonAssocSemiring A] [inst_2 : Module R A]
[SMulCommClass R A A] (a : A) (x : R) (y : A), a * x • y = x • (a * y) | null | false |
SimpleGraph.cliqueFinset.congr_simp | Mathlib.Combinatorics.SimpleGraph.Clique | ∀ {α : Type u_1} (G G_1 : SimpleGraph α),
G = G_1 →
∀ [inst : Fintype α] [inst_1 : DecidableEq α] {inst_2 : DecidableRel G.Adj} [inst_3 : DecidableRel G_1.Adj]
(n n_1 : ℕ), n = n_1 → G.cliqueFinset n = G_1.cliqueFinset n_1 | null | true |
LocallyConstant.instInhabited._proof_1 | Mathlib.Topology.LocallyConstant.Basic | ∀ {X : Type u_1} {Y : Type u_2} [inst : TopologicalSpace X] [inst_1 : Inhabited Y],
IsLocallyConstant (Function.const X default) | null | false |
Batteries.Random.MersenneTwister.State.noConfusion | Batteries.Data.Random.MersenneTwister | {P : Sort u} →
{cfg : Batteries.Random.MersenneTwister.Config} →
{t : Batteries.Random.MersenneTwister.State cfg} →
{cfg' : Batteries.Random.MersenneTwister.Config} →
{t' : Batteries.Random.MersenneTwister.State cfg'} →
cfg = cfg' → t ≍ t' → Batteries.Random.MersenneTwister.State.noConfusi... | null | false |
Std.Iter.toList_zip_of_finite_left | Std.Data.Iterators.Lemmas.Combinators.Zip | ∀ {α₁ α₂ β₁ β₂ : Type u_1} [inst : Std.Iterator α₁ Id β₁] [inst_1 : Std.Iterator α₂ Id β₂] {it₁ : Std.Iter β₁}
{it₂ : Std.Iter β₂} [Std.Iterators.Finite α₁ Id] [Std.Iterators.Productive α₂ Id],
(it₁.zip it₂).toList = it₁.toList.zip (Std.Iter.take it₁.toList.length it₂).toList | null | true |
String.mk | Init.Data.String.Bootstrap | List Char → String | null | true |
IsTopologicalGroup.mulInvClosureNhd.casesOn | Mathlib.Topology.Algebra.OpenSubgroup | {G : Type u_1} →
[inst : TopologicalSpace G] →
{T W : Set G} →
[inst_1 : Group G] →
{motive : IsTopologicalGroup.mulInvClosureNhd T W → Sort u} →
(t : IsTopologicalGroup.mulInvClosureNhd T W) →
((nhds : T ∈ nhds 1) → (inv : T⁻¹ = T) → (isOpen : IsOpen T) → (mul : W * T ⊆ W) → m... | null | false |
SSet.Truncated.instMonoidalTruncation._aux_3 | Mathlib.AlgebraicTopology.SimplicialSet.Monoidal | (n : ℕ) →
(X Y : SSet) →
CategoryTheory.MonoidalCategoryStruct.tensorObj ((SSet.truncation n).obj X) ((SSet.truncation n).obj Y) ⟶
(SSet.truncation n).obj (CategoryTheory.MonoidalCategoryStruct.tensorObj X Y) | null | false |
Option.decidableForallMem._proof_3 | Init.Data.Option.Instances | ∀ {α : Type u_1} {p : α → Prop} (a : α), ¬p a → ¬∀ a_1 ∈ some a, p a_1 | null | false |
_private.Init.Data.SInt.Bitwise.0.Int16.shiftRight_and._simp_1_1 | Init.Data.SInt.Bitwise | ∀ {a b : Int16}, (a = b) = (a.toBitVec = b.toBitVec) | null | false |
Ordnode.insert'._unsafe_rec | Mathlib.Data.Ordmap.Ordnode | {α : Type u_1} → [inst : LE α] → [DecidableLE α] → α → Ordnode α → Ordnode α | null | false |
_private.Mathlib.Algebra.SkewPolynomial.Basic.0.SkewPolynomial.monomial_eq_monomial_iff._simp_1_3 | Mathlib.Algebra.SkewPolynomial.Basic | ∀ {k : Type u_1} {G : Type u_2} [inst : AddMonoid k] (a : G) (b : k),
SkewMonoidAlgebra.single a b = { toFinsupp := fun₀ | a => b } | null | false |
_private.Lean.Meta.SynthInstance.0.Lean.Meta.SynthInstance.removeUnusedArguments? | Lean.Meta.SynthInstance | Lean.MetavarContext → Lean.Expr → Lean.MetaM (Option (Lean.Expr × Lean.Expr)) | If the type of the metavariable `mvar` has unused argument, return a pair `(α, transformer)`
where `α` is a new type without the unused arguments and the `transformer` is a function for converting a
solution with type `α` into a value that can be assigned to `mvar`.
Example: suppose `mvar` has type `(a : A) → (b : B a)... | true |
_private.Lean.Elab.Match.0.Lean.Elab.Term.withElaboratedLHS | Lean.Elab.Match | {α : Type} →
Array Lean.Elab.Term.PatternVarDecl →
Array Lean.Syntax →
Lean.Syntax →
ℕ →
Lean.Expr →
(Lean.Meta.Match.AltLHS → Lean.Expr → Lean.Elab.TermElabM α) →
ExceptT Lean.Elab.Term.PatternElabException Lean.Elab.TermElabM α | null | true |
CategoryTheory.Adjunction.right_triangle_components_assoc | Mathlib.CategoryTheory.Adjunction.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} {G : CategoryTheory.Functor D C} (self : F ⊣ G) (Y : D) {Z : C} (h : G.obj Y ⟶ Z),
CategoryTheory.CategoryStruct.comp (self.unit.app (G.obj Y))
(CategoryTheo... | Equality of the composition of the unit and counit with the identity `G ⟶ GFG ⟶ G = 𝟙` | true |
Denumerable.raise'._unsafe_rec | Mathlib.Logic.Equiv.Finset | List ℕ → ℕ → List ℕ | null | false |
RingHom.FiniteType.of_surjective | Mathlib.RingTheory.FiniteType | ∀ {A : Type u_1} {B : Type u_2} [inst : CommRing A] [inst_1 : CommRing B] (f : A →+* B),
Function.Surjective ⇑f → f.FiniteType | null | true |
_private.Lean.Meta.MkIffOfInductiveProp.0.Lean.Meta.Shape.casesOn | Lean.Meta.MkIffOfInductiveProp | {motive : Lean.Meta.Shape✝ → Sort u} →
(t : Lean.Meta.Shape✝) →
((variablesKept : List Bool) → (neqs : Option ℕ) → motive { variablesKept := variablesKept, neqs := neqs }) →
motive t | null | false |
Int16.ofBitVec_ofNat | Init.Data.SInt.Lemmas | ∀ (n : ℕ), Int16.ofBitVec (BitVec.ofNat 16 n) = Int16.ofNat n | null | true |
Ring.DirectLimit.congr._proof_6 | Mathlib.Algebra.Colimit.Ring | ∀ {ι : Type u_1} [inst : Preorder ι] {G : ι → Type u_2} [inst_1 : (i : ι) → CommRing (G i)]
{f : (i j : ι) → i ≤ j → G i →+* G j} {G' : ι → Type u_3} [inst_2 : (i : ι) → CommRing (G' i)]
{f' : (i j : ι) → i ≤ j → G' i →+* G' j} (e : (i : ι) → G i ≃+* G' i),
(∀ (i j : ι) (h : i ≤ j), (e j).toRingHom.comp (f i j h)... | null | false |
CategoryTheory.Limits.IsLimit.pullbackConeEquivBinaryFanFunctor | Mathlib.CategoryTheory.Limits.Constructions.Over.Products | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
{X Y Z : C} →
{f : Y ⟶ X} →
{g : Z ⟶ X} →
{c : CategoryTheory.Limits.PullbackCone f g} →
CategoryTheory.Limits.IsLimit c →
CategoryTheory.Limits.IsLimit (CategoryTheory.Limits.pullbackConeEquivBinaryFan.fu... | A binary fan in `Over X` is a limit if its corresponding pullback cone to `X` is a limit. | true |
CategoryTheory.MorphismProperty.Under.mapPushoutAdj._proof_7 | Mathlib.CategoryTheory.MorphismProperty.OverAdjunction | ∀ {T : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} T] (P Q : CategoryTheory.MorphismProperty T)
[inst_1 : Q.IsMultiplicative] {X Y : T} [Q.IsStableUnderCobaseChange] (f : X ⟶ Y) [inst_3 : P.HasPushoutsAlong f],
Q f → ∀ (A : P.Under Q X), Q (CategoryTheory.Limits.pushout.inl A.hom f) | null | false |
RingQuot.ringQuotToIdealQuotient | Mathlib.Algebra.RingQuot | {B : Type uR} → [inst : CommRing B] → (r : B → B → Prop) → RingQuot r →+* B ⧸ Ideal.ofRel r | The universal ring homomorphism from `RingQuot r` to `B ⧸ Ideal.ofRel r`. | true |
Std.Format.noConfusion | Init.Data.Format.Basic | {P : Sort u} → {t t' : Std.Format} → t = t' → Std.Format.noConfusionType P t t' | null | false |
CategoryTheory.Abelian.Preradical.toColon_hom_left_colonπ | Mathlib.CategoryTheory.Abelian.Preradical.Colon | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{u_2, u_1} C] [inst_1 : CategoryTheory.Abelian C]
(Φ Ψ : CategoryTheory.Abelian.Preradical C),
CategoryTheory.CategoryStruct.comp (CategoryTheory.Over.Hom.left (Φ.toColon Ψ).hom) (Φ.colonπ Ψ) = 0 | null | true |
Rat.cast_lt_natCast._simp_1 | Mathlib.Data.Rat.Cast.Order | ∀ {K : Type u_5} [inst : Field K] [inst_1 : LinearOrder K] [IsStrictOrderedRing K] {m : ℚ} {n : ℕ}, (↑m < ↑n) = (m < ↑n) | null | false |
_private.Mathlib.RingTheory.Invariant.Basic.0.Ideal.Quotient.exists_algHom_fixedPoint_quotient_under._simp_1_2 | Mathlib.RingTheory.Invariant.Basic | ∀ {G : Type u_3} [inst : AddGroup G] {a b : G}, (a - b = 0) = (a = b) | null | false |
List.maximum_of_length_pos_mem | Mathlib.Data.List.MinMax | ∀ {α : Type u_1} [inst : LinearOrder α] {l : List α} (h : 0 < l.length), List.maximum_of_length_pos h ∈ l | null | true |
Lean.Json.below | Lean.Data.Json.Basic | {motive_1 : Lean.Json → Sort u} →
{motive_2 : Array Lean.Json → Sort u} →
{motive_3 : Std.TreeMap.Raw String Lean.Json compare → Sort u} →
{motive_4 : List Lean.Json → Sort u} →
{motive_5 : Std.DTreeMap.Raw String (fun x => Lean.Json) compare → Sort u} →
{motive_6 : (Std.DTreeMap.Internal.... | null | false |
CategoryTheory.ComposableArrows.isoMkSucc_inv | Mathlib.CategoryTheory.ComposableArrows.Basic | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] {n : ℕ} {F G : CategoryTheory.ComposableArrows C (n + 1)}
(α : F.obj' 0 ⋯ ≅ G.obj' 0 ⋯) (β : F.δ₀ ≅ G.δ₀)
(w :
CategoryTheory.CategoryStruct.comp (F.map' 0 1 CategoryTheory.ComposableArrows.homMk₁._proof_4 ⋯)
(CategoryTheory.ComposableArrows... | null | true |
TensorProduct.inner_def | Mathlib.Analysis.InnerProductSpace.TensorProduct | ∀ {𝕜 : Type u_1} {E : Type u_2} {F : Type u_3} [inst : RCLike 𝕜] [inst_1 : NormedAddCommGroup E]
[inst_2 : InnerProductSpace 𝕜 E] [inst_3 : NormedAddCommGroup F] [inst_4 : InnerProductSpace 𝕜 F]
(x y : TensorProduct 𝕜 E F),
inner 𝕜 x y =
(((TensorProduct.lift (TensorProduct.mapBilinear (RingHom.id 𝕜) E... | null | true |
comap_abs_nhds_zero | Mathlib.Topology.Algebra.Order.Group | ∀ {G : Type u_1} [inst : TopologicalSpace G] [inst_1 : AddCommGroup G] [inst_2 : LinearOrder G] [IsOrderedAddMonoid G]
[OrderTopology G], Filter.comap abs (nhds 0) = nhds 0 | null | true |
Num.commSemiring._proof_5 | Mathlib.Data.Num.Lemmas | ∀ (x : Num), x * 1 = x | null | false |
CategoryTheory.AddMon.uniqueHomToTrivial | Mathlib.CategoryTheory.Monoidal.Cartesian.Mon | {D : Type u_1} →
[inst : CategoryTheory.Category.{v_1, u_1} D] →
[inst_1 : CategoryTheory.SemiCartesianMonoidalCategory D] →
(A : CategoryTheory.AddMon D) → Unique (A ⟶ CategoryTheory.AddMon.trivial D) | null | true |
NonUnitalSubalgebra.center.instNonUnitalCommRing._proof_13 | Mathlib.Algebra.Algebra.NonUnitalSubalgebra | ∀ {R : Type u_2} [inst : CommSemiring R] {A : Type u_1} [inst_1 : NonUnitalNonAssocRing A] [inst_2 : Module R A]
[inst_3 : IsScalarTower R A A] [inst_4 : SMulCommClass R A A] (a b c : ↥(NonUnitalSubalgebra.center R A)),
a * (b + c) = a * b + a * c | null | false |
_private.Mathlib.NumberTheory.Padics.PadicNumbers.0.PadicSeq.norm_eq_of_equiv | Mathlib.NumberTheory.Padics.PadicNumbers | ∀ {p : ℕ} [hp : Fact (Nat.Prime p)] {f g : PadicSeq p} (hf : ¬f ≈ 0) (hg : ¬g ≈ 0),
f ≈ g → padicNorm p (↑f (PadicSeq.stationaryPoint hf)) = padicNorm p (↑g (PadicSeq.stationaryPoint hg)) | null | true |
CategoryTheory.Limits.CategoricalPullback.CatCommSqOver.transform_map_whiskerRight | Mathlib.CategoryTheory.Limits.Shapes.Pullback.Categorical.Basic | ∀ {A : Type u₁} {B : Type u₂} {C : Type u₃} [inst : CategoryTheory.Category.{v₁, u₁} A]
[inst_1 : CategoryTheory.Category.{v₂, u₂} B] [inst_2 : CategoryTheory.Category.{v₃, u₃} C]
{F : CategoryTheory.Functor A B} {G : CategoryTheory.Functor C B} {A₁ : Type u₄} {B₁ : Type u₅} {C₁ : Type u₆}
[inst_3 : CategoryTheor... | null | true |
Matrix.transpose_zero | Mathlib.LinearAlgebra.Matrix.Defs | ∀ {m : Type u_2} {n : Type u_3} {α : Type v} [inst : Zero α], Matrix.transpose 0 = 0 | null | true |
RootPairing.Equiv.toEndUnit._proof_9 | Mathlib.LinearAlgebra.RootSystem.Hom | ∀ {ι : Type u_1} {R : Type u_4} {M : Type u_2} {N : Type u_3} [inst : CommRing R] [inst_1 : AddCommGroup M]
[inst_2 : Module R M] [inst_3 : AddCommGroup N] [inst_4 : Module R N] (P : RootPairing ι R M N) (f g : P.Aut),
{ val := ↑(f * g), inv := ↑(RootPairing.Equiv.symm P P (f * g)), val_inv := ⋯, inv_val := ⋯ } =
... | null | false |
Mathlib.Tactic.BicategoryLike.NormalExpr.brecOn.eq | Mathlib.Tactic.CategoryTheory.Coherence.Normalize | ∀ {motive : Mathlib.Tactic.BicategoryLike.NormalExpr → Sort u} (t : Mathlib.Tactic.BicategoryLike.NormalExpr)
(F_1 : (t : Mathlib.Tactic.BicategoryLike.NormalExpr) → Mathlib.Tactic.BicategoryLike.NormalExpr.below t → motive t),
Mathlib.Tactic.BicategoryLike.NormalExpr.brecOn t F_1 =
F_1 t (Mathlib.Tactic.Bicate... | null | true |
_private.Lean.Meta.Tactic.Grind.0.Lean.initFn._@.Lean.Meta.Tactic.Grind.964293774._hygCtx._hyg.2 | Lean.Meta.Tactic.Grind | IO Unit | null | false |
SimpleGraph.IsMaximumClique.maximum | Mathlib.Combinatorics.SimpleGraph.Clique | ∀ {α : Type u_3} [inst : Finite α] {G : SimpleGraph α} {s : Finset α},
G.IsMaximumClique s → ∀ (t : Finset α), G.IsClique ↑t → t.card ≤ s.card | null | true |
Stream'.Seq.terminates_ofList | Mathlib.Data.Seq.Basic | ∀ {α : Type u} (l : List α), (↑l).Terminates | null | true |
Std.Http.Headers.insertMany | Std.Http.Data.Headers | Std.Http.Headers → Std.Http.Header.Name → Array Std.Http.Header.Value → Std.Http.Headers | Inserts a new key with an array of values.
| true |
Function.locallyFinsuppWithin.closedSupport | Mathlib.Topology.LocallyFinsupp | ∀ {X : Type u_1} [inst : TopologicalSpace X] {U : Set X} {Y : Type u_2} [T1Space X] [inst_2 : Zero Y]
(D : Function.locallyFinsuppWithin U Y), IsClosed U → IsClosed D.support | If `X` is T1 and if `U` is closed, then the support of support of a function with locally finite
support within `U` is also closed.
| true |
_private.Lean.Parser.Command.0.Lean.Parser.Command.withExporting._regBuiltin.Lean.Parser.Command.withExporting.formatter_7 | Lean.Parser.Command | IO Unit | null | false |
Lean.StructureResolutionState.ctorIdx | Lean.Structure | Lean.StructureResolutionState → ℕ | null | false |
CategoryTheory.CostructuredArrow.mk_hom_eq_self | Mathlib.CategoryTheory.Comma.StructuredArrow.Basic | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
{T : D} {Y : C} {S : CategoryTheory.Functor C D} (f : S.obj Y ⟶ T), (CategoryTheory.CostructuredArrow.mk f).hom = f | null | true |
Std.TreeMap.instSliceableRooSlice._auto_1 | Std.Data.TreeMap.Slice | Lean.Syntax | null | false |
SubNegMonoid.sub._default | Mathlib.Algebra.Group.Defs | {G : Type u} →
(add : G → G → G) →
(∀ (a b c : G), a + b + c = a + (b + c)) →
(zero : G) →
(∀ (a : G), 0 + a = a) →
(∀ (a : G), a + 0 = a) →
(nsmul : ℕ → G → G) →
(∀ (x : G), nsmul 0 x = 0) → (∀ (n : ℕ) (x : G), nsmul (n + 1) x = nsmul n x + x) → (G → G) → G → G →... | null | false |
sub_eq_add_zero_sub | Mathlib.Algebra.Group.Basic | ∀ {G : Type u_3} [inst : SubNegMonoid G] (a b : G), a - b = a + (0 - b) | null | true |
DiffeologicalSpace.mkOfClosure._proof_1 | Mathlib.Geometry.Diffeology.Basic | ∀ {X : Type u_1} (g : Set ((n : ℕ) × (EuclideanSpace ℝ (Fin n) → X))) {u : Set X},
TopologicalSpace.IsOpen u ↔ ∀ {n : ℕ}, ∀ p ∈ {p | ⟨n, p⟩ ∈ g}, IsOpen (p ⁻¹' u) | null | false |
_private.Init.Data.Array.Lemmas.0.Array.foldlM_loop_empty._proof_1_2 | Init.Data.Array.Lemmas | ∀ {α : Type u_1} {s j : ℕ}, j < s → s = 0 → False | null | false |
_private.Mathlib.Analysis.Calculus.Deriv.Inverse.0.HasDerivWithinAt.eventually_ne._simp_1_2 | Mathlib.Analysis.Calculus.Deriv.Inverse | ∀ {α : Type u_2} [inst : Zero α] [inst_1 : OfNat α 2] [NeZero 2], (2 = 0) = False | null | false |
Lean.matchConstNonRecStructure | Lean.MonadEnv | {m : Type → Type} →
{α : Type} →
[Monad m] →
[Lean.MonadEnv m] →
[Lean.MonadError m] →
Lean.Expr → (Unit → m α) → (Lean.InductiveVal → List Lean.Level → Lean.ConstructorVal → m α) → m α | Matches if `e` is a constant that is a non-recursive inductive type with no indices and with one constructor.
Such a type satisfies `Lean.isNonRecStructure`.
See also `Lean.matchConstStructure` for a less restrictive version.
| true |
DiscreteQuotient.comp_finsetClopens.match_1 | Mathlib.Topology.DiscreteQuotient | (X : Type u_1) →
[inst : TopologicalSpace X] →
(motive : DiscreteQuotient X → Sort u_2) →
(x : DiscreteQuotient X) →
((f : Setoid X) →
(isOpen_setOf_rel : ∀ (x : X), IsOpen (setOf (f x))) →
motive { toSetoid := f, isOpen_setOf_rel := isOpen_setOf_rel }) →
motive x | null | false |
iSupIndep.comp' | Mathlib.Order.SupIndep | ∀ {α : Type u_1} [inst : CompleteLattice α] {ι : Sort u_5} {ι' : Sort u_6} {t : ι → α} {f : ι' → ι},
iSupIndep (t ∘ f) → Function.Surjective f → iSupIndep t | null | true |
PrimeSpectrum.isIrreducible_iff_vanishingIdeal_isPrime | Mathlib.RingTheory.Spectrum.Prime.Topology | ∀ {R : Type u} [inst : CommSemiring R] {s : Set (PrimeSpectrum R)},
IsIrreducible s ↔ (PrimeSpectrum.vanishingIdeal s).IsPrime | null | true |
emultiplicity_map_eq | Mathlib.RingTheory.Multiplicity | ∀ {α : Type u_1} {β : Type u_2} [inst : Monoid α] [inst_1 : Monoid β] {F : Type u_3} [inst_2 : EquivLike F α β]
[MulEquivClass F α β] (f : F) {a b : α}, emultiplicity (f a) (f b) = emultiplicity a b | null | true |
bddAbove_preimage_toDual | Mathlib.Order.Bounds.Basic | ∀ {α : Type u_1} [inst : Preorder α] {s : Set αᵒᵈ}, BddAbove (⇑OrderDual.toDual ⁻¹' s) ↔ BddBelow s | null | true |
ENNReal.le_of_forall_nnreal_lt | Mathlib.Data.ENNReal.Inv | ∀ {x y : ENNReal}, (∀ (r : NNReal), ↑r < x → ↑r ≤ y) → x ≤ y | null | true |
_private.Lean.Util.Recognizers.0.Lean.Expr.notNot?.match_1 | Lean.Util.Recognizers | (motive : Option Lean.Expr → Sort u_1) →
(x : Option Lean.Expr) → ((p : Lean.Expr) → motive (some p)) → (Unit → motive none) → motive x | null | false |
_private.Mathlib.Analysis.InnerProductSpace.Spectrum.0.LinearMap.IsSymmetric.unsortedEigenvectorBasis | Mathlib.Analysis.InnerProductSpace.Spectrum | {𝕜 : Type u_1} →
[inst : RCLike 𝕜] →
{E : Type u_2} →
[inst_1 : NormedAddCommGroup E] →
[inst_2 : InnerProductSpace 𝕜 E] →
{T : E →ₗ[𝕜] E} →
[FiniteDimensional 𝕜 E] → {n : ℕ} → T.IsSymmetric → Module.finrank 𝕜 E = n → OrthonormalBasis (Fin n) 𝕜 E | null | true |
AdicCompletion.map._proof_5 | Mathlib.RingTheory.AdicCompletion.Functoriality | ∀ {R : Type u_1} [inst : CommRing R] (I : Ideal R) (n : ℕ), (I ^ n).IsTwoSided | null | false |
CFC.abs_ofNat | Mathlib.Analysis.SpecialFunctions.ContinuousFunctionalCalculus.Abs | ∀ {A : Type u_2} [inst : Ring A] [inst_1 : StarRing A] [inst_2 : TopologicalSpace A] [inst_3 : Algebra ℝ A]
[inst_4 : ContinuousFunctionalCalculus ℝ A IsSelfAdjoint] [inst_5 : PartialOrder A] [inst_6 : StarOrderedRing A]
[inst_7 : NonnegSpectrumClass ℝ A] [IsTopologicalRing A] [T2Space A] [StarModule ℝ A] (n : ℕ)
... | null | true |
_private.Mathlib.RingTheory.FractionalIdeal.Operations.0.FractionalIdeal.ringEquivOfRingEquiv_spanSingleton._simp_1_3 | Mathlib.RingTheory.FractionalIdeal.Operations | ∀ {R : Type u_1} {M : Type u_4} [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M] {x y : M},
(x ∈ R ∙ y) = ∃ a, a • y = x | null | false |
CategoryTheory.FreeBicategory.Hom.ctorElimType | Mathlib.CategoryTheory.Bicategory.Free | {B : Type u} →
[inst : Quiver B] →
{motive : (a a_1 : B) → CategoryTheory.FreeBicategory.Hom a a_1 → Sort u_1} →
ℕ →
Sort
(max 1 (imax (u + 1) u_1) (imax (u + 1) (u + 1) (u + 1) (max (u + 1) (v + 1)) (max (u + 1) (v + 1)) u_1)
(imax (u + 1) (u + 1) (v + 1) u_1)) | null | false |
Fin.preimage_val_uIoo_val | Mathlib.Order.Interval.Set.Fin | ∀ {n : ℕ} (i j : Fin n), Fin.val ⁻¹' Set.uIoo ↑i ↑j = Set.uIoo i j | null | true |
LieIdeal.coe_toLieSubalgebra | Mathlib.Algebra.Lie.Ideal | ∀ (R : Type u) (L : Type v) [inst : CommRing R] [inst_1 : LieRing L] [inst_2 : LieAlgebra R L] (I : LieIdeal R L),
↑(LieIdeal.toLieSubalgebra R L I) = ↑I | null | true |
instAssociativeUInt64HXor | Init.Data.UInt.Bitwise | Std.Associative fun x1 x2 => x1 ^^^ x2 | null | true |
TopCat.instNegHomObjTopCommRingCatForget₂SubtypeRingHomαContinuousCoeContinuousMapCarrier | Mathlib.Topology.Sheaves.CommRingCat | (X : TopCat) → (R : TopCommRingCat) → Neg (X ⟶ (CategoryTheory.forget₂ TopCommRingCat TopCat).obj R) | null | true |
_private.Mathlib.Combinatorics.Extremal.RuzsaSzemeredi.0.mem_triangleIndices._simp_1 | Mathlib.Combinatorics.Extremal.RuzsaSzemeredi | ∀ {α : Type u_1} [inst : Fintype α] [inst_1 : CommRing α] {s : Finset α} {x : α × α × α},
(x ∈ triangleIndices✝ s) = ∃ y, ∃ a ∈ s, (y, y + a, y + 2 * a) = x | null | false |
OpenPartialHomeomorph.homeomorphOfImageSubsetSource._proof_2 | Mathlib.Topology.OpenPartialHomeomorph.Basic | ∀ {X : Type u_2} {Y : Type u_1} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y]
(e : OpenPartialHomeomorph X Y) {s : Set X} {t : Set Y}, s ⊆ e.source → ↑e '' s = t → t ⊆ e.target | null | false |
_private.Mathlib.CategoryTheory.WithTerminal.Cone.0.CategoryTheory.WithTerminal.coneBack_obj_pt | Mathlib.CategoryTheory.WithTerminal.Cone | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {J : Type w} [inst_1 : CategoryTheory.Category.{w', w} J]
{X : C} {K : CategoryTheory.Functor J (CategoryTheory.Over X)}
(t : CategoryTheory.Limits.Cone (CategoryTheory.WithTerminal.liftFromOver.obj K)),
(CategoryTheory.WithTerminal.coneBack✝.obj t).pt =... | null | true |
Lean.Meta.Grind.Context | Lean.Meta.Tactic.Grind.Types | Type | Context for `GrindM` monad. | true |
Std.DHashMap.Internal.Raw.getKey?_eq | Std.Data.DHashMap.Internal.Raw | ∀ {α : Type u} {β : α → Type v} [inst : BEq α] [inst_1 : Hashable α] {m : Std.DHashMap.Raw α β} (h : m.WF) {a : α},
m.getKey? a = Std.DHashMap.Internal.Raw₀.getKey? ⟨m, ⋯⟩ a | null | true |
Units.cfcRpow._auto_1 | Mathlib.Analysis.SpecialFunctions.ContinuousFunctionalCalculus.Rpow.Basic | Lean.Syntax | null | false |
_private.Mathlib.Algebra.Module.LocalizedModule.Submodule.0.IsLocalizedModule.toLocalizedQuotient'._simp_1 | Mathlib.Algebra.Module.LocalizedModule.Submodule | ∀ {R : Type u_1} {M : Type u_2} [inst : Ring R] [inst_1 : AddCommGroup M] [inst_2 : Module R M] (p : Submodule R M)
{S : Type u_3} [inst_3 : SMul S R] [inst_4 : SMul S M] [inst_5 : IsScalarTower S R M] (r : S) (x : M),
r • Submodule.Quotient.mk x = Submodule.Quotient.mk (r • x) | null | false |
_private.Init.Data.String.Basic.0.String.Pos.Raw.utf8GetAux.match_1.splitter | Init.Data.String.Basic | (motive : List Char → String.Pos.Raw → String.Pos.Raw → Sort u_1) →
(x : List Char) →
(x_1 x_2 : String.Pos.Raw) →
((x x_3 : String.Pos.Raw) → motive [] x x_3) →
((c : Char) → (cs : List Char) → (i p : String.Pos.Raw) → motive (c :: cs) i p) → motive x x_1 x_2 | null | true |
gcdMonoidOfGCD._proof_1 | Mathlib.Algebra.GCDMonoid.Basic | ∀ {α : Type u_1} [inst : CommMonoidWithZero α] [inst_1 : DecidableEq α] (gcd : α → α → α)
(gcd_dvd_left : ∀ (a b : α), gcd a b ∣ a) (a b : α),
Associated (gcd a b * if a = 0 then 0 else Classical.choose ⋯) (a * b) | null | false |
Lean.Meta.Command.ReduceConfig.rec | Init.MetaTypes | {motive : Lean.Meta.Command.ReduceConfig → Sort u} →
((types proofs implicits : Bool) →
(transparency : Lean.Meta.TransparencyMode) →
(smartUnfolding check ignoreStuckTC : Bool) →
motive
{ types := types, proofs := proofs, implicits := implicits, transparency := transparency,
... | null | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.