name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11.5k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
CategoryTheory.Bicategory.Prod.sectL._proof_8 | Mathlib.CategoryTheory.Bicategory.Product | ∀ (B : Type u_2) [inst : CategoryTheory.Bicategory B] {C : Type u_6} [inst_1 : CategoryTheory.Bicategory C] (c : C)
{a b c_1 : B} {f g : a ⟶ b} (η : f ⟶ g) (h : b ⟶ c_1),
CategoryTheory.Prod.mkHom (CategoryTheory.Bicategory.whiskerRight η h)
(CategoryTheory.CategoryStruct.id (CategoryTheory.CategoryStruct.id ... | null | false |
FirstOrder.Language.presburger.funMap_one | Mathlib.ModelTheory.Arithmetic.Presburger.Basic | ∀ {M : Type u_2} [inst : Zero M] [inst_1 : One M] [inst_2 : Add M] {v : Fin 0 → M},
FirstOrder.Language.Structure.funMap FirstOrder.presburgerFunc.one v = 1 | null | true |
CategoryTheory.IsoCat | Mathlib.CategoryTheory.IsoCat | (C : Type u_1) →
(D : Type u_2) →
[CategoryTheory.Category.{v_1, u_1} C] →
[CategoryTheory.Category.{v_2, u_2} D] → Type (max (max (max u_1 u_2) v_1) v_2) | An isomorphism of categories: a pair of functors whose composites are equal to the
identity functors. | true |
definition._proof_2._@.Mathlib.Analysis.InnerProductSpace.PiL2.1554134833._hygCtx._hyg.2 | Mathlib.Analysis.InnerProductSpace.PiL2 | ∀ {ι : Type u_1} {𝕜 : Type u_2} [inst : RCLike 𝕜] {E : Type u_3} [inst_1 : NormedAddCommGroup E]
[inst_2 : InnerProductSpace 𝕜 E] [inst_3 : Fintype ι] [FiniteDimensional 𝕜 E] {n : ℕ},
Module.finrank 𝕜 E = n →
∀ [inst_5 : DecidableEq ι] {V : ι → Submodule 𝕜 E},
DirectSum.IsInternal V →
(Ortho... | null | false |
_private.BatteriesRecycling.RBTree.Lemmas.0.RBTree.RBNode.mem_insert_of_mem._simp_1_5 | BatteriesRecycling.RBTree.Lemmas | ∀ {α : Type u_1} {x : α} {t : RBTree.RBNode α}, (x ∈ t) = (x ∈ t.toList) | null | false |
TopologicalSpace.prod_mono | Mathlib.Topology.Constructions.SumProd | ∀ {α : Type u_5} {β : Type u_6} {σ₁ σ₂ : TopologicalSpace α} {τ₁ τ₂ : TopologicalSpace β},
σ₁ ≤ σ₂ → τ₁ ≤ τ₂ → instTopologicalSpaceProd ≤ instTopologicalSpaceProd | null | true |
BoundedContinuousFunction.rec | Mathlib.Topology.ContinuousMap.Bounded.Basic | {α : Type u} →
{β : Type v} →
[inst : TopologicalSpace α] →
[inst_1 : PseudoMetricSpace β] →
{motive : BoundedContinuousFunction α β → Sort u_1} →
((toContinuousMap : C(α, β)) →
(map_bounded' : ∃ C, ∀ (x y : α), dist (toContinuousMap.toFun x) (toContinuousMap.toFun y) ≤ C) →
... | null | false |
_private.Mathlib.RingTheory.Coalgebra.CoassocSimps.0.CoassocSimps.«termλ» | Mathlib.RingTheory.Coalgebra.CoassocSimps | Lean.ParserDescr | null | true |
_private.Mathlib.Combinatorics.SimpleGraph.Finite.0.SimpleGraph.exists_minimal_degree_vertex._proof_1_3 | Mathlib.Combinatorics.SimpleGraph.Finite | ∀ {V : Type u_1} (G : SimpleGraph V) [inst : Fintype V] [inst_1 : DecidableRel G.Adj] [Nonempty V],
∃ v, G.minDegree = G.degree v | null | false |
CategoryTheory.ShortComplex.opcyclesFunctor | Mathlib.Algebra.Homology.ShortComplex.RightHomology | (C : Type u_1) →
[inst : CategoryTheory.Category.{v_1, u_1} C] →
[inst_1 : CategoryTheory.Limits.HasZeroMorphisms C] →
[CategoryTheory.Limits.HasKernels C] →
[CategoryTheory.Limits.HasCokernels C] → CategoryTheory.Functor (CategoryTheory.ShortComplex C) C | The opcycles functor `ShortComplex C ⥤ C` which sends a short complex `S` to `S.opcycles`
which is a cokernel of `S.f : S.X₁ ⟶ S.X₂`. | true |
monovaryOn_neg | Mathlib.Algebra.Order.Monovary | ∀ {ι : Type u_1} {α : Type u_2} {β : Type u_3} [inst : AddCommGroup α] [inst_1 : PartialOrder α] [IsOrderedAddMonoid α]
[inst_3 : AddCommGroup β] [inst_4 : PartialOrder β] [IsOrderedAddMonoid β] {s : Set ι} {f : ι → α} {g : ι → β},
MonovaryOn (-f) (-g) s ↔ MonovaryOn f g s | null | true |
_private.Batteries.Data.MLList.Basic.0.MLList.Spec.mk.sizeOf_spec | Batteries.Data.MLList.Basic | ∀ {m : Type u → Type u} [inst : (a : Type u) → SizeOf (m a)] (listM : Type u → Type u) (nil : {α : Type u} → listM α)
(cons : {α : Type u} → α → listM α → listM α) (thunk : {α : Type u} → (Unit → listM α) → listM α)
(squash : {α : Type u} → (Unit → m (listM α)) → listM α)
(uncons : {α : Type u} → [Monad m] → list... | null | true |
Lean.Elab.Term.elabLetDelayedDecl | Lean.Elab.Binders | Lean.Elab.Term.TermElab | null | true |
Array.appendCore.loop | Init.Prelude | {α : Type u} → Array α → ℕ → ℕ → Array α → Array α | null | true |
coe_iterateFrobeniusEquiv | Mathlib.FieldTheory.Perfect | ∀ (R : Type u_1) (p n : ℕ) [inst : CommSemiring R] [inst_1 : ExpChar R p] [inst_2 : PerfectRing R p],
⇑(iterateFrobeniusEquiv R p n) = ⇑(iterateFrobenius R p n) | null | true |
FormalGroup.Point | Mathlib.RingTheory.FormalGroup.Basic | {R : Type u_1} → [inst : CommRing R] → FormalGroup R → Type → Type (max u_1 0) | `Point F σ` represents the mathematical space of points of a formal group $F$
taking values in the formal power series ring `R⟦X_σ⟧`.
Mathematically, a 1-dimensional formal group law $F$ over a ring $R$ defines a group
structure on the elements of a complete local $R$-algebra (specifically, its maximal ideal)
via the ... | true |
_private.Std.Sync.Channel.0.Std.CloseableChannel.Bounded.incMod | Std.Sync.Channel | ℕ → ℕ → ℕ | null | true |
Flow.cont' | Mathlib.Dynamics.Flow | ∀ {τ : Type u_1} [inst : TopologicalSpace τ] [inst_1 : AddMonoid τ] [inst_2 : ContinuousAdd τ] {α : Type u_2}
[inst_3 : TopologicalSpace α] (self : Flow τ α), Continuous (Function.uncurry self.toFun) | null | true |
Subgroup.FG.eq_1 | Mathlib.GroupTheory.Finiteness | ∀ {G : Type u_3} [inst : Group G] (P : Subgroup G), P.FG = ∃ S, Subgroup.closure ↑S = P | null | true |
instDecidableEqColex | Mathlib.Order.Lex | (α : Type u_2) → [DecidableEq α] → DecidableEq (Colex α) | null | true |
Turing.Dir.ofNat_ctorIdx | Mathlib.Computability.TuringMachine.Tape | ∀ (x : Turing.Dir), Turing.Dir.ofNat x.ctorIdx = x | null | true |
Colex.instIsCancelMul | Mathlib.Algebra.Order.Group.Synonym | ∀ {α : Type u_1} [inst : Mul α] [IsCancelMul α], IsCancelMul (Colex α) | null | true |
AlgEquiv.aut._proof_8 | Mathlib.Algebra.Algebra.Equiv | ∀ {R : Type u_1} {A₁ : Type u_2} [inst : CommSemiring R] [inst_1 : Semiring A₁] [inst_2 : Algebra R A₁]
(x : A₁ ≃ₐ[R] A₁), 1 * x = x | null | false |
_private.Mathlib.FieldTheory.Differential.Basic.0.Differential.logDeriv_div._simp_1_7 | Mathlib.FieldTheory.Differential.Basic | ∀ {R : Type u_1} [inst : AddMonoidWithOne R] [CharZero R] (n : ℕ), (↑n + 1 = 0) = False | null | false |
MulEquiv.toMonCatIso | Mathlib.Algebra.Category.MonCat.Basic | {X Y : Type u} → [inst : Monoid X] → [inst_1 : Monoid Y] → X ≃* Y → (MonCat.of X ≅ MonCat.of Y) | Build an isomorphism in the category `MonCat` from a `MulEquiv` between `Monoid`s. | true |
InfClosed.infClosure_eq | Mathlib.Order.SupClosed | ∀ {α : Type u_3} [inst : SemilatticeInf α] {s : Set α}, InfClosed s → infClosure s = s | **Alias** of the reverse direction of `infClosure_eq_self`. | true |
_private.Lean.Elab.Tactic.Try.0.Lean.Elab.Tactic.Try.isAccessible._sparseCasesOn_1.else_eq | Lean.Elab.Tactic.Try | ∀ {α : Type u} {motive : Option α → Sort u_1} (t : Option α) (some : (val : α) → motive (some val))
(«else» : Nat.hasNotBit 2 t.ctorIdx → motive t) (h : Nat.hasNotBit 2 t.ctorIdx),
Lean.Elab.Tactic.Try.isAccessible._sparseCasesOn_1✝ t some «else» = «else» h | null | false |
Filter.prod_map_map_eq' | Mathlib.Order.Filter.Prod | ∀ {α₁ : Type u_6} {α₂ : Type u_7} {β₁ : Type u_8} {β₂ : Type u_9} (f : α₁ → α₂) (g : β₁ → β₂) (F : Filter α₁)
(G : Filter β₁), Filter.map f F ×ˢ Filter.map g G = Filter.map (Prod.map f g) (F ×ˢ G) | null | true |
_private.Mathlib.LinearAlgebra.Finsupp.Span.0.Finsupp.iInf_ker_lapply_le_bot._simp_1_4 | Mathlib.LinearAlgebra.Finsupp.Span | ∀ (R : Type u_1) {M : Type u_3} [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M] {x : M},
(x ∈ ⊥) = (x = 0) | null | false |
Submonoid.mk_inv_mul_mk_eq_one | Mathlib.Algebra.Group.Submonoid.Units | ∀ {M : Type u_1} [inst : Monoid M] (S : Submonoid M) {x : Mˣ} (h : x ∈ S.units),
⟨(Units.coeHom M) x⁻¹, ⋯⟩ * ⟨(Units.coeHom M) x, ⋯⟩ = 1 | null | true |
_private.Std.Http.Internal.IndexMultiMap.0.Std.Internal.IndexMultiMap.insert.match_1.congr_eq_2 | Std.Http.Internal.IndexMultiMap | ∀ (motive : Option (Array ℕ) → Sort u_1) (x : Option (Array ℕ)) (h_1 : (idxs : Array ℕ) → motive (some idxs))
(h_2 : Unit → motive none),
x = none →
(match x with
| some idxs => h_1 idxs
| none => h_2 ()) ≍
h_2 () | null | true |
CategoryTheory.Limits.CategoricalPullback.CatCommSqOver.precomposeObjTransformObjSquare_iso_hom_comp | 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... | The square `precomposeTransformSquare` respects compositions. | true |
AlgebraicGeometry.IsLocallyArtinian.discreteTopology_of_isAffine | Mathlib.AlgebraicGeometry.Artinian | ∀ {X : AlgebraicGeometry.Scheme} [AlgebraicGeometry.IsLocallyArtinian X], DiscreteTopology ↥X | **Alias** of `AlgebraicGeometry.IsLocallyArtinian.discreteTopology`. | true |
Lean.Meta.Tactic.Cbv.getMatchTheorems | Lean.Meta.Tactic.Cbv.TheoremsLookup | Lean.Name → Lean.MetaM Lean.Meta.Sym.Simp.Theorems | null | true |
AlgebraicGeometry.Scheme.instAddCommGroupEllAdicCohomology._proof_21 | Mathlib.AlgebraicGeometry.Sites.ElladicCohomology | ∀ (X : AlgebraicGeometry.Scheme) (ℓ : ℕ) [inst : Fact (Nat.Prime ℓ)] (n : ℕ),
autoParam
(∀ (n_1 : ℕ) (a : X.EllAdicCohomology ℓ n),
AlgebraicGeometry.Scheme.instAddCommGroupEllAdicCohomology._aux_17 X ℓ n (Int.negSucc n_1) a =
-AlgebraicGeometry.Scheme.instAddCommGroupEllAdicCohomology._aux_17 X ℓ n... | null | false |
_aux_Mathlib_Combinatorics_Quiver_Basic___unexpand_Quiver_Hom_1 | Mathlib.Combinatorics.Quiver.Basic | Lean.PrettyPrinter.Unexpander | null | false |
CategoryTheory.Bicategory.Adj.iso₂Mk._proof_1 | Mathlib.CategoryTheory.Bicategory.Adjunction.Adj | ∀ {B : Type u_3} [inst : CategoryTheory.Bicategory B] {a b : CategoryTheory.Bicategory.Adj B} {α β : a ⟶ b}
(el : α.l ≅ β.l) (er : β.r ≅ α.r),
(CategoryTheory.Bicategory.conjugateEquiv β.adj α.adj) el.hom = er.hom →
(CategoryTheory.Bicategory.conjugateEquiv α.adj β.adj) el.inv = er.inv | null | false |
CategoryTheory.instPreadditiveOpposite._proof_10 | Mathlib.CategoryTheory.Preadditive.Opposite | ∀ (C : Type u_2) [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.Preadditive C] (X Y : Cᵒᵖ)
(a : X ⟶ Y), -a + a = 0 | null | false |
_private.Mathlib.Algebra.GCDMonoid.Basic.0.normalizationMonoidOfMonoidHomRightInverse._simp_1 | Mathlib.Algebra.GCDMonoid.Basic | ∀ {α : Type u} [inst : Monoid α] {u v : αˣ}, (u = v) = (↑u = ↑v) | null | false |
String.Slice.Pos.byte.eq_1 | Init.Data.String.Basic | ∀ {s : String.Slice} (pos : s.Pos) (h : pos ≠ s.endPos), pos.byte h = s.getUTF8Byte pos.offset ⋯ | null | true |
_private.Mathlib.Analysis.Convex.Jensen.0.StrictConvexOn.map_sum_eq_iff_of_pos._simp_1_3 | Mathlib.Analysis.Convex.Jensen | ∀ {ι : Type u_1} {R : Type u_5} {M : Type u_6} [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M]
{f : ι → R} {s : Finset ι} {x : M}, ∑ i ∈ s, f i • x = (∑ i ∈ s, f i) • x | null | false |
_private.Mathlib.Analysis.CStarAlgebra.GelfandDuality.0.IsSelfAdjoint.nnnorm_sum_eq_sup._proof_1_2 | Mathlib.Analysis.CStarAlgebra.GelfandDuality | ∀ {ι : Type u_1} (j : ι) (s : Finset ι), j ∉ s → ∀ i ∈ s, ¬j = i | null | false |
CategoryTheory.Monoidal.InducingFunctorData.rec | Mathlib.CategoryTheory.Monoidal.Transport | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
[inst_1 : CategoryTheory.MonoidalCategory C] →
{D : Type u₂} →
[inst_2 : CategoryTheory.Category.{v₂, u₂} D] →
[inst_3 : CategoryTheory.MonoidalCategoryStruct D] →
{F : CategoryTheory.Functor D C} →
{mo... | null | false |
AlgebraicGeometry.Scheme.Modules.pushforwardId | Mathlib.AlgebraicGeometry.Modules.Sheaf | (X : AlgebraicGeometry.Scheme) →
AlgebraicGeometry.Scheme.Modules.pushforward (CategoryTheory.CategoryStruct.id X) ≅
CategoryTheory.Functor.id X.Modules | The pushforward of sheaves of modules by the identity morphism identifies
to the identity functor. | true |
Mathlib.Linter.linter.style.setOption | Mathlib.Tactic.Linter.Style | Lean.Option Bool | The `setOption` linter emits a warning on a `set_option` command, term or tactic
which sets a `pp`, `profiler` or `trace` option.
It also warns on an option containing `maxHeartbeats`
(as these should be scoped as `set_option ... in` instead). | true |
_private.Lean.Message.0.Lean.MessageData.initFn._@.Lean.Message.1084813479._hygCtx._hyg.4 | Lean.Message | IO (Lean.Option ℕ) | null | false |
Ideal.quotientToQuotientRangePowQuotSucc | Mathlib.NumberTheory.RamificationInertia.Basic | {R : Type u} →
[inst : CommRing R] →
{S : Type v} →
[inst_1 : CommRing S] →
[inst_2 : Algebra R S] →
(p : Ideal R) →
(P : Ideal S) →
[hfp : NeZero (p.ramificationIdx P)] →
{i : ℕ} →
{a : S} →
a ∈ P ^ i →
... | `S ⧸ P` embeds into the quotient by `P^(i+1) ⧸ P^e` as a subspace of `P^i ⧸ P^e`. | true |
CategoryTheory.MonoidalLinear.whiskerLeft_smul | Mathlib.CategoryTheory.Monoidal.Linear | ∀ {R : Type u_1} {inst : Semiring R} {C : Type u_2} {inst_1 : CategoryTheory.Category.{v_1, u_2} C}
{inst_2 : CategoryTheory.Preadditive C} {inst_3 : CategoryTheory.Linear R C}
{inst_4 : CategoryTheory.MonoidalCategory C} {inst_5 : CategoryTheory.MonoidalPreadditive C}
[self : CategoryTheory.MonoidalLinear R C] (... | null | true |
CategoryTheory.ULift.upFunctor | Mathlib.CategoryTheory.Category.ULift | {C : Type u₁} → [inst : CategoryTheory.Category.{v₁, u₁} C] → CategoryTheory.Functor C (ULift.{u₂, u₁} C) | The functorial version of `ULift.up`. | true |
Mathlib.Tactic.filterUpwards | Mathlib.Order.Filter.Defs | Lean.ParserDescr | `filter_upwards [h₁, ⋯, hₙ]` replaces a goal of the form `s ∈ f` and terms
`h₁ : t₁ ∈ f, ⋯, hₙ : tₙ ∈ f` with `∀ x, x ∈ t₁ → ⋯ → x ∈ tₙ → x ∈ s`.
The list is an optional parameter, `[]` being its default value.
`filter_upwards [h₁, ⋯, hₙ] with a₁ a₂ ⋯ aₖ` is a short form for
`{ filter_upwards [h₁, ⋯, hₙ], intro a₁ a₂ ... | true |
EReal.sub_le_iff_le_add | Mathlib.Data.EReal.Operations | ∀ {a b c : EReal}, b ≠ ⊥ ∨ c ≠ ⊤ → b ≠ ⊤ ∨ c ≠ ⊥ → (a - b ≤ c ↔ a ≤ c + b) | null | true |
CategoryTheory.Subobject.ofMkLE | Mathlib.CategoryTheory.Subobject.Basic | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
{B A : C} →
(f : A ⟶ B) →
[inst_1 : CategoryTheory.Mono f] →
(X : CategoryTheory.Subobject B) →
CategoryTheory.Subobject.mk f ≤ X → (A ⟶ CategoryTheory.Subobject.underlying.obj X) | An inequality of subobjects is witnessed by some morphism between the corresponding objects. | true |
instTotallyDisconnectedSpaceMultiplicative | Mathlib.Topology.Connected.TotallyDisconnected | ∀ {α : Type u} [inst : TopologicalSpace α] [TotallyDisconnectedSpace α], TotallyDisconnectedSpace (Multiplicative α) | null | true |
BooleanAlgebra.toBooleanRing._proof_5 | Mathlib.Algebra.Ring.BooleanRing | ∀ {α : Type u_1} [inst : BooleanAlgebra α] (n : ℕ), (↑n).castDef = ↑n | null | false |
Module.Finite.addMonoidHom | Mathlib.LinearAlgebra.FreeModule.Finite.Matrix | ∀ (M : Type v) (N : Type w) [inst : AddCommGroup M] [Module.Finite ℤ M] [Module.Free ℤ M] [inst_3 : AddCommGroup N]
[Module.Finite ℤ N], Module.Finite ℤ (M →+ N) | null | true |
ContinuousAffineMap.const_contLinear | Mathlib.Topology.Algebra.ContinuousAffineMap | ∀ {R : Type u_1} {V : Type u_2} {W : Type u_3} {P : Type u_4} {Q : Type u_5} [inst : Ring R] [inst_1 : AddCommGroup V]
[inst_2 : Module R V] [inst_3 : TopologicalSpace P] [inst_4 : AddTorsor V P] [inst_5 : AddCommGroup W]
[inst_6 : Module R W] [inst_7 : TopologicalSpace Q] [inst_8 : AddTorsor W Q] [inst_9 : Topolog... | null | true |
CategoryTheory.ObjectProperty.Is.rec | Mathlib.CategoryTheory.ObjectProperty.Basic | {C : Type u} →
[inst : CategoryTheory.CategoryStruct.{v, u} C] →
{P : CategoryTheory.ObjectProperty C} →
{X : C} → {motive : P.Is X → Sort u_1} → ((prop : P X) → motive ⋯) → (t : P.Is X) → motive t | null | false |
Lean.Meta.Grind.Arith.Cutsat.DiseqCnstrProof.reorder.injEq | Lean.Meta.Tactic.Grind.Arith.Cutsat.Types | ∀ (c c_1 : Lean.Meta.Grind.Arith.Cutsat.DiseqCnstr),
(Lean.Meta.Grind.Arith.Cutsat.DiseqCnstrProof.reorder c = Lean.Meta.Grind.Arith.Cutsat.DiseqCnstrProof.reorder c_1) =
(c = c_1) | null | true |
_private.Lean.Meta.Tactic.Simp.BuiltinSimprocs.Fin.0.Fin.reduceEq._regBuiltin.Fin.reduceEq.declare_1._@.Lean.Meta.Tactic.Simp.BuiltinSimprocs.Fin.995461402._hygCtx._hyg.23 | Lean.Meta.Tactic.Simp.BuiltinSimprocs.Fin | IO Unit | null | false |
Lean.Core.Context.cancelTk? | Lean.CoreM | Lean.Core.Context → Option IO.CancelToken | If set, used to cancel elaboration from outside when results are not needed anymore. | true |
Std.ExtTreeSet.mem_inter_iff | Std.Data.ExtTreeSet.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} {t₁ t₂ : Std.ExtTreeSet α cmp} [inst : Std.TransCmp cmp] {k : α},
k ∈ t₁ ∩ t₂ ↔ k ∈ t₁ ∧ k ∈ t₂ | null | true |
HeytAlg.ext_iff | Mathlib.Order.Category.HeytAlg | ∀ {X Y : HeytAlg} {f g : X ⟶ Y},
f = g ↔ ∀ (x : ↑X), (CategoryTheory.ConcreteCategory.hom f) x = (CategoryTheory.ConcreteCategory.hom g) x | null | true |
convexHull_neg | Mathlib.Analysis.Convex.Hull | ∀ {𝕜 : Type u_1} {E : Type u_2} [inst : Ring 𝕜] [inst_1 : PartialOrder 𝕜] [inst_2 : AddCommGroup E]
[inst_3 : Module 𝕜 E] (s : Set E), (convexHull 𝕜) (-s) = -(convexHull 𝕜) s | null | true |
CategoryTheory.ShortComplex.HomologyData.ofEpiMonoFactorisation.leftHomologyData_i | Mathlib.Algebra.Homology.ShortComplex.Abelian | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Abelian C]
(S : CategoryTheory.ShortComplex C) {kf : CategoryTheory.Limits.KernelFork S.g}
{cc : CategoryTheory.Limits.CokernelCofork S.f} (hkf : CategoryTheory.Limits.IsLimit kf)
(hcc : CategoryTheory.Limits.IsColimit cc) {H : C} {... | null | true |
_private.Batteries.Data.List.Lemmas.0.List.dropPrefix?.match_1.eq_1 | Batteries.Data.List.Lemmas | ∀ {α : Type u_1} (motive : List α → List α → Sort u_2) (list : List α) (h_1 : (list : List α) → motive list [])
(h_2 : (head : α) → (tail : List α) → motive [] (head :: tail))
(h_3 : (a : α) → (as : List α) → (b : α) → (bs : List α) → motive (a :: as) (b :: bs)),
(match list, [] with
| list, [] => h_1 list
... | null | true |
SimpleGraph.Subgraph.Connected.mono' | Mathlib.Combinatorics.SimpleGraph.Connectivity.Subgraph | ∀ {V : Type u} {G : SimpleGraph V} {H H' : G.Subgraph},
(∀ (v w : V), H.Adj v w → H'.Adj v w) → H.verts = H'.verts → H.Connected → H'.Connected | null | true |
dvd_mul_gcd_of_dvd_mul | Mathlib.Algebra.GCDMonoid.Basic | ∀ {α : Type u_1} [inst : CommMonoidWithZero α] [inst_1 : GCDMonoid α] {m n k : α}, k ∣ m * n → k ∣ m * gcd k n | null | true |
CategoryTheory.GlueData.mk | Mathlib.CategoryTheory.GlueData | {C : Type u₁} →
[inst : CategoryTheory.Category.{v, u₁} C] →
(J : Type v) →
(U : J → C) →
(V : J × J → C) →
(f : (i j : J) → V (i, j) ⟶ U i) →
autoParam (∀ (i j : J), CategoryTheory.Mono (f i j)) CategoryTheory.GlueData.f_mono._autoParam →
(f_hasPullback :
... | null | true |
Lean.Elab.MonadParentDecl.casesOn | Lean.Elab.InfoTree.Types | {m : Type → Type} →
{motive : Lean.Elab.MonadParentDecl m → Sort u} →
(t : Lean.Elab.MonadParentDecl m) →
((getParentDeclName? : m (Option Lean.Name)) → motive { getParentDeclName? := getParentDeclName? }) → motive t | null | false |
_private.Lean.Parser.Basic.0.Lean.Parser.rawStrLitFnAux.errorUnterminated | Lean.Parser.Basic | String.Pos.Raw → Lean.Parser.ParserState → Lean.Parser.ParserState | Gives the "unterminated raw string literal" error.
| true |
Std.Rio.mem_iff_mem_Rco | Init.Data.Range.Polymorphic.Lemmas | ∀ {α : Type u_1} {r : Std.Rio α} [inst : LE α] [inst_1 : LT α] [inst_2 : Std.PRange.Least? α]
[inst_3 : Std.PRange.UpwardEnumerable α] [Std.PRange.LawfulUpwardEnumerable α] [Std.PRange.LawfulUpwardEnumerableLE α]
[inst_6 : Std.PRange.LawfulUpwardEnumerableLeast? α] [Std.Rxo.IsAlwaysFinite α] {a : α},
a ∈ r ↔ a ∈ ... | null | true |
Filter.div_le_div_right | Mathlib.Order.Filter.Pointwise | ∀ {α : Type u_2} [inst : Div α] {f₁ f₂ g : Filter α}, f₁ ≤ f₂ → f₁ / g ≤ f₂ / g | null | true |
RingEquiv.piOptionEquivProd | Mathlib.Algebra.Ring.Equiv | {ι : Type u_7} →
{R : Option ι → Type u_8} →
[inst : (i : Option ι) → NonUnitalNonAssocSemiring (R i)] →
((i : Option ι) → R i) ≃+* R none × ((i : ι) → R (some i)) | This is `Equiv.piOptionEquivProd` as a `RingEquiv`. | true |
_private.Lean.Elab.Tactic.Conv.Basic.0.Lean.Elab.Tactic.Conv.evalConvConvSeq._regBuiltin.Lean.Elab.Tactic.Conv.evalConvConvSeq_1 | Lean.Elab.Tactic.Conv.Basic | IO Unit | null | false |
_private.Mathlib.Analysis.Analytic.Composition.0.HasFPowerSeriesWithinAt.comp._simp_1_1 | Mathlib.Analysis.Analytic.Composition | ∀ {α : Type u} [inst : LinearOrder α] {a b c : α}, (a < min b c) = (a < b ∧ a < c) | null | false |
_private.Mathlib.Analysis.PSeries.0.Real.summable_nat_rpow_inv._simp_1_1 | Mathlib.Analysis.PSeries | ∀ (x : ℝ) (n : ℕ), x ^ n = x ^ ↑n | null | false |
MeasureTheory.memLp_zero_iff_aestronglyMeasurable._simp_1 | Mathlib.MeasureTheory.Function.LpSeminorm.Basic | ∀ {α : Type u_1} {ε : Type u_2} {m0 : MeasurableSpace α} {μ : MeasureTheory.Measure α} [inst : ENorm ε]
[inst_1 : TopologicalSpace ε] {f : α → ε}, MeasureTheory.MemLp f 0 μ = MeasureTheory.AEStronglyMeasurable f μ | null | false |
instDecidablePredPermMemSetDerangements | Mathlib.Combinatorics.Derangements.Finite | {α : Type u_1} → [DecidableEq α] → [Fintype α] → DecidablePred fun x => x ∈ derangements α | null | true |
MulOpposite.instMulOneClass._proof_1 | Mathlib.Algebra.Group.Opposite | ∀ {α : Type u_1} [inst : MulOneClass α] (x : αᵐᵒᵖ), 1 * x = x | null | false |
Submodule.range_inclusion | Mathlib.Algebra.Module.Submodule.Range | ∀ {R : Type u_1} {M : Type u_5} [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M]
(p q : Submodule R M) (h : p ≤ q), (Submodule.inclusion h).range = Submodule.comap q.subtype p | null | true |
MulEquiv.AddMonoid.End._proof_1 | Mathlib.Algebra.Group.Equiv.TypeTags | ∀ {M : Type u_1} [inst : AddMonoid M] (x x_1 : AddMonoid.End M),
AddMonoidHom.toMultiplicative.toFun (x * x_1) = AddMonoidHom.toMultiplicative.toFun (x * x_1) | null | false |
instSubsingleton | Init.Core | ∀ (p : Prop), Subsingleton p | null | true |
CommRingCat.tensorProd_map_right | Mathlib.Algebra.Category.Ring.Under.Basic | ∀ (R S : CommRingCat) [inst : Algebra ↑R ↑S] {X Y : CategoryTheory.Under R} (f : X ⟶ Y),
((R.tensorProd S).map f).right =
CommRingCat.ofHom ↑(Algebra.TensorProduct.map (AlgHom.id ↑S ↑S) (CommRingCat.toAlgHom f)) | null | true |
Complex.isAlgebraic_sin_rat_mul_pi | Mathlib.NumberTheory.Niven | ∀ (q : ℚ), IsAlgebraic ℤ (Complex.sin (↑q * ↑Real.pi)) | `sin(q * π)` for `q : ℚ` is algebraic over `ℤ`, using the complex `sin` function. | true |
Std.Tactic.BVDecide.Normalize.Bool.ite_else_ite' | Std.Tactic.BVDecide.Normalize.Bool | ∀ {α : Sort u_1} (c0 c1 : Bool) {a b : α}, (bif c0 then a else bif c1 then a else b) = bif !c0 && !c1 then b else a | null | true |
InitialSeg.transPrincipal_apply | Mathlib.Order.InitialSeg | ∀ {α : Type u_1} {β : Type u_2} {γ : Type u_3} {r : α → α → Prop} {s : β → β → Prop} {t : γ → γ → Prop}
[inst : IsWellOrder β s] [inst_1 : IsTrans γ t] (f : InitialSeg r s) (g : PrincipalSeg s t) (a : α),
(f.transPrincipal g).toRelEmbedding a = g.toRelEmbedding (f a) | null | true |
ModuleCat.HasLimits.limitCone._proof_1 | Mathlib.Algebra.Category.ModuleCat.Limits | ∀ {R : Type u_2} [inst : Ring R] {J : Type u_4} [inst_1 : CategoryTheory.Category.{u_3, u_4} J]
(F : CategoryTheory.Functor J (ModuleCat R))
[inst_2 : Small.{u_1, max u_4 u_1} ↑(F.comp (CategoryTheory.forget (ModuleCat R))).sections] (x x_1 : J)
(f : x ⟶ x_1),
CategoryTheory.CategoryStruct.comp
(((Categor... | null | false |
MulEquiv.piCongrRight_symm | Mathlib.Algebra.Group.Equiv.Basic | ∀ {η : Type u_16} {Ms : η → Type u_17} {Ns : η → Type u_18} [inst : (j : η) → Mul (Ms j)]
[inst_1 : (j : η) → Mul (Ns j)] (es : (j : η) → Ms j ≃* Ns j),
(MulEquiv.piCongrRight es).symm = MulEquiv.piCongrRight fun i => (es i).symm | null | true |
LieSubalgebra.exists_nested_lieIdeal_coe_eq_iff | Mathlib.Algebra.Lie.Ideal | ∀ (R : Type u) {L : Type v} [inst : CommRing R] [inst_1 : LieRing L] [inst_2 : LieAlgebra R L] (K : LieSubalgebra R L)
{K' : LieSubalgebra R L} (h : K ≤ K'),
(∃ I, LieIdeal.toLieSubalgebra R (↥K') I = LieSubalgebra.ofLe h) ↔ ∀ (x y : L), x ∈ K' → y ∈ K → ⁅x, y⁆ ∈ K | null | true |
Pi.evalNonUnitalRingHom._proof_2 | Mathlib.Algebra.Ring.Pi | ∀ {I : Type u_2} (f : I → Type u_1) [inst : (i : I) → NonUnitalNonAssocSemiring (f i)] (i : I) (x y : (i : I) → f i),
(↑(Pi.evalAddMonoidHom f i)).toFun (x + y) =
(↑(Pi.evalAddMonoidHom f i)).toFun x + (↑(Pi.evalAddMonoidHom f i)).toFun y | null | false |
_private.Init.Data.List.MinMaxIdx.0.List.minIdxOn_nil_eq_iff_true.match_1_1 | Init.Data.List.MinMaxIdx | ∀ {α : Type u_1} (motive : [] ≠ [] → Prop) (h : [] ≠ []), motive h | null | false |
CategoryTheory.Cokleisli.mk._flat_ctor | Mathlib.CategoryTheory.Monad.Kleisli | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] → {U : CategoryTheory.Comonad C} → C → CategoryTheory.Cokleisli U | null | false |
ContDiffBump.rOut | Mathlib.Analysis.Calculus.BumpFunction.Basic | {E : Type u_1} → {c : E} → ContDiffBump c → ℝ | real numbers `0 < rIn < rOut` | true |
Submodule.ClosedComplemented.complement | Mathlib.Topology.Algebra.Module.Complement | {R : Type u_1} →
[inst : Ring R] →
{M : Type u_2} →
[inst_1 : TopologicalSpace M] →
[inst_2 : AddCommGroup M] → [inst_3 : Module R M] → {p : Submodule R M} → p.ClosedComplemented → Submodule R M | An arbitrary choice of topological complement of a topologically complemented submodule. | true |
NormedAddCommGroup.ofCoreReplaceTopology._proof_1 | Mathlib.Analysis.Normed.Module.Basic | ∀ {𝕜 : Type u_2} {E : Type u_1} [inst : NormedField 𝕜] [inst_1 : AddCommGroup E] [inst_2 : Module 𝕜 E] [inst_3 : Norm E]
[T : TopologicalSpace E] (core : NormedSpace.Core 𝕜 E) (H : T = PseudoEMetricSpace.toUniformSpace.toTopologicalSpace)
{x y : E}, dist x y = 0 → x = y | null | false |
ContinuousLinearEquiv.summable | Mathlib.Topology.Algebra.InfiniteSum.Module | ∀ {ι : Type u_5} {R : Type u_7} {R₂ : Type u_8} {M : Type u_9} {M₂ : Type u_10} [inst : Semiring R]
[inst_1 : Semiring R₂] [inst_2 : AddCommMonoid M] [inst_3 : Module R M] [inst_4 : AddCommMonoid M₂]
[inst_5 : Module R₂ M₂] [inst_6 : TopologicalSpace M] [inst_7 : TopologicalSpace M₂] {σ : R →+* R₂} {σ' : R₂ →+* R}
... | null | true |
Std.HashSet.Raw.Equiv.of_forall_contains_eq | Std.Data.HashSet.RawLemmas | ∀ {α : Type u} [inst : BEq α] [inst_1 : Hashable α] {m₁ m₂ : Std.HashSet.Raw α} [LawfulBEq α],
m₁.WF → m₂.WF → (∀ (k : α), m₁.contains k = m₂.contains k) → m₁.Equiv m₂ | null | true |
FreeAddMonoid.casesOn_zero | Mathlib.Algebra.FreeMonoid.Basic | ∀ {α : Type u_1} {C : FreeAddMonoid α → Sort u_6} (h0 : C 0)
(ih : (x : α) → (xs : FreeAddMonoid α) → C (FreeAddMonoid.of x + xs)), FreeAddMonoid.casesOn 0 h0 ih = h0 | null | true |
ContinuousMap.coeFnRingHom_apply | Mathlib.Topology.ContinuousMap.Algebra | ∀ {α : Type u_1} {β : Type u_2} [inst : TopologicalSpace α] [inst_1 : TopologicalSpace β] [inst_2 : Semiring β]
[inst_3 : IsTopologicalSemiring β] (f : C(α, β)) (a : α), ContinuousMap.coeFnRingHom f a = f a | null | true |
_private.Std.Sync.Broadcast.0.Std.Bounded.State.size | Std.Sync.Broadcast | {α : Type} → Std.Bounded.State✝ α → ℕ | Current number of messages stored in the circular buffer.
| true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.