name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M |
|---|---|---|
Order.IsIdeal.Directed | Mathlib.Order.Ideal | ∀ {P : Type u_2} [inst : LE P] {I : Set P}, Order.IsIdeal I → DirectedOn (fun x1 x2 => x1 ≤ x2) I |
CategoryTheory.Pretriangulated.productTriangle.π_hom₃ | Mathlib.CategoryTheory.Triangulated.Basic | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.HasShift C ℤ] {J : Type u_1}
(T : J → CategoryTheory.Pretriangulated.Triangle C) [inst_2 : CategoryTheory.Limits.HasProduct fun j => (T j).obj₁]
[inst_3 : CategoryTheory.Limits.HasProduct fun j => (T j).obj₂]
[inst_4 : CategoryTheory.Limits.HasProduct fun j => (T j).obj₃]
[inst_5 : CategoryTheory.Limits.HasProduct fun j => (CategoryTheory.shiftFunctor C 1).obj (T j).obj₁] (j : J),
(CategoryTheory.Pretriangulated.productTriangle.π T j).hom₃ = CategoryTheory.Limits.Pi.π (fun j => (T j).obj₃) j |
SimpleGraph.Subgraph.instFinite | Mathlib.Combinatorics.SimpleGraph.Subgraph | ∀ {V : Type u} {G : SimpleGraph V} [Finite V], Finite G.Subgraph |
CategoryTheory.Limits.Pi.map_π | Mathlib.CategoryTheory.Limits.Shapes.Products | ∀ {β : Type w} {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {f g : β → C}
[inst_1 : CategoryTheory.Limits.HasProduct f] [inst_2 : CategoryTheory.Limits.HasProduct g] (p : (b : β) → f b ⟶ g b)
(b : β),
CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.Pi.map p) (CategoryTheory.Limits.Pi.π g b) =
CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.Pi.π f b) (p b) |
MeasureTheory.AEEqFun.mul_toGerm | Mathlib.MeasureTheory.Function.AEEqFun | ∀ {α : Type u_1} {γ : Type u_3} [inst : MeasurableSpace α] {μ : MeasureTheory.Measure α} [inst_1 : TopologicalSpace γ]
[inst_2 : Mul γ] [inst_3 : ContinuousMul γ] (f g : α →ₘ[μ] γ), (f * g).toGerm = f.toGerm * g.toGerm |
_private.Mathlib.Lean.Meta.CongrTheorems.0.Lean.Meta.mkHCongrWithArity'.prove._sparseCasesOn_3 | Mathlib.Lean.Meta.CongrTheorems | {α : Type u} →
{motive : List α → Sort u_1} →
(t : List α) →
((head : α) → (tail : List α) → motive (head :: tail)) → (Nat.hasNotBit 2 t.ctorIdx → motive t) → motive t |
CategoryTheory.ObjectProperty.fullMonoidalClosedSubcategory._proof_2 | Mathlib.CategoryTheory.Monoidal.Subcategory | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.MonoidalCategory C]
(P : CategoryTheory.ObjectProperty C) [inst_2 : P.IsMonoidal] [inst_3 : CategoryTheory.MonoidalClosed C]
[inst_4 : P.IsMonoidalClosed] (X : P.FullSubcategory) ⦃X_1 Y : P.FullSubcategory⦄ (f : X_1 ⟶ Y),
CategoryTheory.CategoryStruct.comp ((CategoryTheory.Functor.id P.FullSubcategory).map f)
(CategoryTheory.ObjectProperty.homMk ((CategoryTheory.ihom.coev X.obj).app Y.obj)) =
CategoryTheory.CategoryStruct.comp
(CategoryTheory.ObjectProperty.homMk ((CategoryTheory.ihom.coev X.obj).app X_1.obj))
(((CategoryTheory.MonoidalCategory.tensorLeft X).comp (P.lift (P.ι.comp (CategoryTheory.ihom X.obj)) ⋯)).map f) |
_private.Lean.IdentifierSuggestion.0.Lean.throwUnknownNameWithSuggestions.match_1 | Lean.IdentifierSuggestion | (motive : Option Lean.Name → Sort u_1) →
(x : Option Lean.Name) → (Unit → motive none) → ((prefixName : Lean.Name) → motive (some prefixName)) → motive x |
_private.Std.Time.Format.Basic.0.Std.Time.exactlyChars.go._unary._proof_1 | Std.Time.Format.Basic | ∀ (size : ℕ) (acc : String) (count : ℕ),
¬count ≥ size →
∀ (res : Char),
InvImage (fun x1 x2 => x1 < x2) (fun x => PSigma.casesOn x fun acc count => size - count)
⟨acc.push res, count.succ⟩ ⟨acc, count⟩ |
Lean.Elab.Tactic.Do.ProofMode.initFn._@.Lean.Elab.Tactic.Do.ProofMode.Cases.723085142._hygCtx._hyg.2 | Lean.Elab.Tactic.Do.ProofMode.Cases | IO Unit |
SupHom.subtypeVal | Mathlib.Order.Hom.Lattice | {β : Type u_3} →
[inst : SemilatticeSup β] → {P : β → Prop} → (Psup : ∀ ⦃x y : β⦄, P x → P y → P (x ⊔ y)) → SupHom { x // P x } β |
CStarMatrix.of_add_of | Mathlib.Analysis.CStarAlgebra.CStarMatrix | ∀ {m : Type u_1} {n : Type u_2} {A : Type u_5} [inst : Add A] (f g : Matrix m n A),
CStarMatrix.ofMatrix f + CStarMatrix.ofMatrix g = CStarMatrix.ofMatrix (f + g) |
Lean.Expr.hasLooseBVarInExplicitDomain | Lean.Expr | Lean.Expr → ℕ → Bool → Bool |
CategoryTheory.Adjunction.homEquiv_naturality_right_square | 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} (adj : F ⊣ G) {X' X : C} {Y Y' : D} (f : X' ⟶ X)
(g : X ⟶ G.obj Y') (h : X' ⟶ G.obj Y) (k : Y ⟶ Y'),
CategoryTheory.CategoryStruct.comp f g = CategoryTheory.CategoryStruct.comp h (G.map k) →
CategoryTheory.CategoryStruct.comp (F.map f) ((adj.homEquiv X Y').symm g) =
CategoryTheory.CategoryStruct.comp ((adj.homEquiv X' Y).symm h) k |
LinearEquiv.coe_injective | Mathlib.Algebra.Module.Equiv.Defs | ∀ {R : Type u_1} {S : Type u_6} {M : Type u_7} {M₂ : Type u_9} [inst : Semiring R] [inst_1 : Semiring S]
[inst_2 : AddCommMonoid M] [inst_3 : AddCommMonoid M₂] {modM : Module R M} {modM₂ : Module S M₂} {σ : R →+* S}
{σ' : S →+* R} [inst_4 : RingHomInvPair σ σ'] [inst_5 : RingHomInvPair σ' σ], Function.Injective DFunLike.coe |
Mathlib.Tactic.Group.group | Mathlib.Tactic.Group | Lean.ParserDescr |
Std.Rxi.HasSize.casesOn | Init.Data.Range.Polymorphic.Basic | {α : Type u} →
{motive : Std.Rxi.HasSize α → Sort u_1} →
(t : Std.Rxi.HasSize α) → ((size : α → ℕ) → motive { size := size }) → motive t |
_private.Lean.Util.ReplaceLevel.0.Lean.Expr.ReplaceLevelImpl.replaceUnsafeM.match_1 | Lean.Util.ReplaceLevel | (motive : Lean.Expr → Sort u_1) →
(e : Lean.Expr) →
((binderName : Lean.Name) →
(d b : Lean.Expr) → (binderInfo : Lean.BinderInfo) → motive (Lean.Expr.forallE binderName d b binderInfo)) →
((binderName : Lean.Name) →
(d b : Lean.Expr) → (binderInfo : Lean.BinderInfo) → motive (Lean.Expr.lam binderName d b binderInfo)) →
((data : Lean.MData) → (b : Lean.Expr) → motive (Lean.Expr.mdata data b)) →
((declName : Lean.Name) →
(t v b : Lean.Expr) → (nondep : Bool) → motive (Lean.Expr.letE declName t v b nondep)) →
((f a : Lean.Expr) → motive (f.app a)) →
((typeName : Lean.Name) → (idx : ℕ) → (b : Lean.Expr) → motive (Lean.Expr.proj typeName idx b)) →
((u : Lean.Level) → motive (Lean.Expr.sort u)) →
((declName : Lean.Name) → (us : List Lean.Level) → motive (Lean.Expr.const declName us)) →
((e : Lean.Expr) → motive e) → motive e |
SeparationQuotient.instRing._proof_6 | Mathlib.Topology.Algebra.SeparationQuotient.Basic | ∀ {R : Type u_1} [inst : TopologicalSpace R] [inst_1 : Ring R] [IsTopologicalRing R], ContinuousConstSMul ℤ R |
Congr!.plausiblyEqualTypes._unsafe_rec | Mathlib.Tactic.CongrExclamation | Lean.Expr → Lean.Expr → optParam ℕ 5 → Lean.MetaM Bool |
MeasurableEq.mk | Mathlib.MeasureTheory.MeasurableSpace.Constructions | ∀ {α : Type u_1} [inst : MeasurableSpace α], MeasurableSet (Set.diagonal α) → MeasurableEq α |
Std.DTreeMap.Internal.Impl.isEmpty_insertMany_list | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Std.DTreeMap.Internal.Impl α β} [Std.TransOrd α] (h : t.WF)
{l : List ((a : α) × β a)}, (↑(t.insertMany l ⋯)).isEmpty = (t.isEmpty && l.isEmpty) |
instComplSubtypeProdAndEqHMulFstSndOfNatHAdd | Mathlib.Algebra.Order.Ring.Idempotent | {R : Type u_1} → [inst : CommMonoid R] → [inst_1 : AddCommMonoid R] → Compl { a // a.1 * a.2 = 0 ∧ a.1 + a.2 = 1 } |
_private.Mathlib.Analysis.Polynomial.MahlerMeasure.0.Polynomial.mahlerMeasure_X_add_C._simp_1_1 | Mathlib.Analysis.Polynomial.MahlerMeasure | ∀ {α : Type u_1} [inst : SubtractionMonoid α] (a b : α), a + b = a - -b |
_private.Batteries.Data.RBMap.Lemmas.0.Batteries.RBNode.balance1.match_1.splitter._sparseCasesOn_2 | Batteries.Data.RBMap.Lemmas | {α : Type u} →
{motive : Batteries.RBNode α → Sort u_1} →
(t : Batteries.RBNode α) →
((c : Batteries.RBColor) →
(l : Batteries.RBNode α) → (v : α) → (r : Batteries.RBNode α) → motive (Batteries.RBNode.node c l v r)) →
(Nat.hasNotBit 2 t.ctorIdx → motive t) → motive t |
Plausible.InjectiveFunction.instArbitraryInt | Mathlib.Testing.Plausible.Functions | Plausible.Arbitrary (Plausible.InjectiveFunction ℤ) |
HomotopicalAlgebra.CategoryWithCofibrations.recOn | Mathlib.AlgebraicTopology.ModelCategory.CategoryWithCofibrations | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
{motive : HomotopicalAlgebra.CategoryWithCofibrations C → Sort u_1} →
(t : HomotopicalAlgebra.CategoryWithCofibrations C) →
((cofibrations : CategoryTheory.MorphismProperty C) → motive { cofibrations := cofibrations }) → motive t |
_private.Mathlib.MeasureTheory.Function.SimpleFunc.0.MeasureTheory.SimpleFunc.restrict_lintegral._simp_1_1 | Mathlib.MeasureTheory.Function.SimpleFunc | ∀ {α : Type u_1} {β : Type u_2} [inst : MeasurableSpace α] (f : MeasureTheory.SimpleFunc α β) (x : α),
(f x ∈ f.range) = True |
LieAlgebra.isNilpotent_ad_of_mem_rootSpace | Mathlib.Algebra.Lie.Weights.Chain | ∀ {L : Type u_2} [inst : LieRing L] {K : Type u_4} [inst_1 : Field K] [CharZero K] [inst_3 : LieAlgebra K L]
(H : LieSubalgebra K L) [inst_4 : LieRing.IsNilpotent ↥H] [LieModule.IsTriangularizable K (↥H) L]
[FiniteDimensional K L] {x : L} {χ : ↥H → K},
χ ≠ 0 → x ∈ LieAlgebra.rootSpace H χ → IsNilpotent ((LieAlgebra.ad K L) x) |
Nat.isLeast_nth_of_infinite | Mathlib.Data.Nat.Nth | ∀ {p : ℕ → Prop}, (setOf p).Infinite → ∀ (n : ℕ), IsLeast {i | p i ∧ ∀ k < n, Nat.nth p k < i} (Nat.nth p n) |
CliffordAlgebra.reverseOp_ι | Mathlib.LinearAlgebra.CliffordAlgebra.Conjugation | ∀ {R : Type u_1} [inst : CommRing R] {M : Type u_2} [inst_1 : AddCommGroup M] [inst_2 : Module R M]
{Q : QuadraticForm R M} (m : M),
CliffordAlgebra.reverseOp ((CliffordAlgebra.ι Q) m) = MulOpposite.op ((CliffordAlgebra.ι Q) m) |
Std.Time.Modifier.s.noConfusion | Std.Time.Format.Basic | {P : Sort u} →
{presentation presentation' : Std.Time.Number} →
Std.Time.Modifier.s presentation = Std.Time.Modifier.s presentation' → (presentation = presentation' → P) → P |
Lean.Meta.Grind.mkExtension._auto_1 | Lean.Meta.Tactic.Grind.Extension | Lean.Syntax |
Lean.ScopedEnvExtension.ScopedEntries.casesOn | Lean.ScopedEnvExtension | {β : Type} →
{motive : Lean.ScopedEnvExtension.ScopedEntries β → Sort u} →
(t : Lean.ScopedEnvExtension.ScopedEntries β) →
((map : Lean.SMap Lean.Name (Lean.PArray β)) → motive { map := map }) → motive t |
NonUnitalSubsemiring.instSetLike | Mathlib.RingTheory.NonUnitalSubsemiring.Defs | {R : Type u} → [inst : NonUnitalNonAssocSemiring R] → SetLike (NonUnitalSubsemiring R) R |
_private.Mathlib.CategoryTheory.Generator.Preadditive.0.CategoryTheory.Preadditive.isSeparating_iff._simp_1_1 | Mathlib.CategoryTheory.Generator.Preadditive | ∀ {G : Type u_3} [inst : AddGroup G] {a b : G}, (a - b = 0) = (a = b) |
Lean.Server.handleCodeActionResolve | Lean.Server.CodeActions.Basic | Lean.Lsp.CodeAction → Lean.Server.RequestM (Lean.Server.RequestTask Lean.Lsp.CodeAction) |
_private.Lean.Meta.Tactic.FunInd.0.Lean.Tactic.FunInd.M.tell | Lean.Meta.Tactic.FunInd | Lean.Expr → Lean.Tactic.FunInd.M✝ Unit |
Lean.Elab.Rewrites.evalExact._regBuiltin.Lean.Elab.Rewrites.evalExact.declRange_3 | Lean.Elab.Tactic.Rewrites | IO Unit |
Lean.Elab.Term.elabWithoutExpectedTypeAttr | Lean.Elab.App | Lean.TagAttribute |
PseudoMetricSpace.noConfusionType | Mathlib.Topology.MetricSpace.Pseudo.Defs | Sort u_1 → {α : Type u} → PseudoMetricSpace α → {α' : Type u} → PseudoMetricSpace α' → Sort u_1 |
Real.tendsto_rightDeriv_mul_log_atTop | Mathlib.Analysis.SpecialFunctions.Log.NegMulLog | Filter.Tendsto (fun x => derivWithin (fun x => x * Real.log x) (Set.Ioi x) x) Filter.atTop Filter.atTop |
Lean.Kernel.Exception.toMessageData | Lean.Message | Lean.Kernel.Exception → Lean.Options → Lean.MessageData |
Std.DTreeMap.Internal.Impl.getKeyD_alter! | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Std.DTreeMap.Internal.Impl α β} [Std.TransOrd α]
[inst : Std.LawfulEqOrd α],
t.WF →
∀ {k k' fallback : α} {f : Option (β k) → Option (β k)},
(Std.DTreeMap.Internal.Impl.alter! k f t).getKeyD k' fallback =
if compare k k' = Ordering.eq then if (f (t.get? k)).isSome = true then k else fallback
else t.getKeyD k' fallback |
Lean.Lsp.instFromJsonPartialResultParams | Lean.Data.Lsp.Basic | Lean.FromJson Lean.Lsp.PartialResultParams |
isOpen_sum_iff | Mathlib.Topology.Constructions.SumProd | ∀ {X : Type u} {Y : Type v} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y] {s : Set (X ⊕ Y)},
IsOpen s ↔ IsOpen (Sum.inl ⁻¹' s) ∧ IsOpen (Sum.inr ⁻¹' s) |
Monoid.toMulAction._proof_2 | Mathlib.Algebra.Group.Action.Defs | ∀ (M : Type u_1) [inst : Monoid M] (a : M), 1 * a = a |
subsingleton_iff_zero_eq_one | Mathlib.Algebra.GroupWithZero.Basic | ∀ {M₀ : Type u_1} [inst : MulZeroOneClass M₀], 0 = 1 ↔ Subsingleton M₀ |
Lean.instEmptyCollectionPrefixTree | Lean.Data.PrefixTree | {α : Type u_1} → {β : Type u_2} → {p : α → α → Ordering} → EmptyCollection (Lean.PrefixTree α β p) |
Equiv.removeNone_aux_none | Mathlib.Logic.Equiv.Option | ∀ {α : Type u_1} {β : Type u_2} (e : Option α ≃ Option β) {x : α},
e (some x) = none → some (e.removeNone_aux x) = e none |
Int32.toISize_ofNat | Init.Data.SInt.Lemmas | ∀ {n : ℕ}, n ≤ 2147483647 → (OfNat.ofNat n).toISize = OfNat.ofNat n |
MeasureTheory.eLpNormEssSup_le_of_ae_nnnorm_bound | Mathlib.MeasureTheory.Function.LpSeminorm.Basic | ∀ {α : Type u_1} {F : Type u_5} {m0 : MeasurableSpace α} {μ : MeasureTheory.Measure α} [inst : NormedAddCommGroup F]
{f : α → F} {C : NNReal}, (∀ᵐ (x : α) ∂μ, ‖f x‖₊ ≤ C) → MeasureTheory.eLpNormEssSup f μ ≤ ↑C |
ZeroLEOneClass.rec | Mathlib.Algebra.Order.ZeroLEOne | {α : Type u_2} →
[inst : Zero α] →
[inst_1 : One α] →
[inst_2 : LE α] →
{motive : ZeroLEOneClass α → Sort u} → ((zero_le_one : 0 ≤ 1) → motive ⋯) → (t : ZeroLEOneClass α) → motive t |
UpperHalfPlane.IsZeroAtImInfty.petersson_isZeroAtImInfty_left | Mathlib.NumberTheory.ModularForms.Petersson | ∀ {F : Type u_1} {F' : Type u_2} [inst : FunLike F UpperHalfPlane ℂ] [inst_1 : FunLike F' UpperHalfPlane ℂ] (k : ℤ)
(Γ : Subgroup (GL (Fin 2) ℝ)) [Fact (IsCusp OnePoint.infty Γ)] [Γ.HasDetPlusMinusOne] [DiscreteTopology ↥Γ]
[ModularFormClass F Γ k] [ModularFormClass F' Γ k] {f : F},
UpperHalfPlane.IsZeroAtImInfty ⇑f → ∀ (f' : F'), UpperHalfPlane.IsZeroAtImInfty (UpperHalfPlane.petersson k ⇑f ⇑f') |
List.Vector.instLawfulTraversableFlipNat | Mathlib.Data.Vector.Basic | ∀ {n : ℕ}, LawfulTraversable (flip List.Vector n) |
AddSubmonoid.instInfSet._proof_2 | Mathlib.Algebra.Group.Submonoid.Basic | ∀ {M : Type u_1} [inst : AddZeroClass M] (s : Set (AddSubmonoid M)) {a b : M},
a ∈ ⋂ t ∈ s, ↑t → b ∈ ⋂ t ∈ s, ↑t → a + b ∈ ⋂ x ∈ s, ↑x |
PFunctor.Approx.Agree.continu | Mathlib.Data.PFunctor.Univariate.M | ∀ {F : PFunctor.{uA, uB}} (x : PFunctor.Approx.CofixA F 0) (y : PFunctor.Approx.CofixA F 1), PFunctor.Approx.Agree x y |
SlashInvariantForm.constℝ._proof_1 | Mathlib.NumberTheory.ModularForms.SlashInvariantForms | ∀ {Γ : Subgroup (GL (Fin 2) ℝ)} [Γ.HasDetPlusMinusOne] (x : ℝ),
∀ g ∈ Γ,
∀ (τ : UpperHalfPlane),
SlashAction.map 0 g (Function.const UpperHalfPlane ↑x) τ = Function.const UpperHalfPlane (↑x) τ |
Eq.mpr_prop | Init.SimpLemmas | ∀ {p q : Prop}, p = q → q → p |
_private.Mathlib.Analysis.Analytic.Basic.0.HasFPowerSeriesWithinOnBall.congr._simp_1_1 | Mathlib.Analysis.Analytic.Basic | ∀ {α : Type u} {x a : α} {s : Set α}, (x ∈ insert a s) = (x = a ∨ x ∈ s) |
_private.Mathlib.Data.QPF.Multivariate.Basic.0.MvQPF.mem_supp._proof_1_1 | Mathlib.Data.QPF.Multivariate.Basic | ∀ {n : ℕ} {F : TypeVec.{u_1} n → Type u_2} [q : MvQPF F] {α : TypeVec.{u_1} n} (x : F α) (i : Fin2 n) (u : α i),
(∀ (a : (MvQPF.P F).A) (f : ((MvQPF.P F).B a).Arrow α), MvQPF.abs ⟨a, f⟩ = x → u ∈ f i '' Set.univ) →
∀ ⦃P : (i : Fin2 n) → α i → Prop⦄, MvFunctor.LiftP P x → P i u |
_private.Mathlib.Algebra.Lie.CartanExists.0.LieAlgebra.engel_isBot_of_isMin._simp_1_6 | Mathlib.Algebra.Lie.CartanExists | ∀ {R : Type u} {L : Type v} {M : Type w} [inst : CommRing R] [inst_1 : LieRing L] [inst_2 : AddCommGroup M]
[inst_3 : Module R M] [inst_4 : LieRingModule L M] (p : Submodule R M)
(h : ∀ {x : L} {m : M}, m ∈ p.carrier → ⁅x, m⁆ ∈ p.carrier) {x : M},
(x ∈ { toSubmodule := p, lie_mem := h }) = (x ∈ p) |
Lean.Meta.SynthInstance.Waiter.recOn | Lean.Meta.SynthInstance | {motive : Lean.Meta.SynthInstance.Waiter → Sort u} →
(t : Lean.Meta.SynthInstance.Waiter) →
((a : Lean.Meta.SynthInstance.ConsumerNode) → motive (Lean.Meta.SynthInstance.Waiter.consumerNode a)) →
motive Lean.Meta.SynthInstance.Waiter.root → motive t |
LieIdeal.lcs | Mathlib.Algebra.Lie.Nilpotent | {R : Type u_1} →
{L : Type u_2} →
[inst : CommRing R] →
[inst_1 : LieRing L] →
[inst_2 : LieAlgebra R L] →
LieIdeal R L →
(M : Type u_3) →
[inst_3 : AddCommGroup M] → [inst_4 : Module R M] → [inst_5 : LieRingModule L M] → ℕ → LieSubmodule R L M |
ExteriorAlgebra.ι | Mathlib.LinearAlgebra.ExteriorAlgebra.Basic | (R : Type u1) →
[inst : CommRing R] → {M : Type u2} → [inst_1 : AddCommGroup M] → [inst_2 : Module R M] → M →ₗ[R] ExteriorAlgebra R M |
AddSubmonoid.leftNeg | Mathlib.GroupTheory.Submonoid.Inverses | {M : Type u_1} → [inst : AddMonoid M] → AddSubmonoid M → AddSubmonoid M |
CategoryTheory.Bicategory.Adj.Hom.mk.inj | Mathlib.CategoryTheory.Bicategory.Adjunction.Adj | ∀ {B : Type u} {inst : CategoryTheory.Bicategory B} {a b : B} {l : a ⟶ b} {r : b ⟶ a}
{adj : CategoryTheory.Bicategory.Adjunction l r} {l_1 : a ⟶ b} {r_1 : b ⟶ a}
{adj_1 : CategoryTheory.Bicategory.Adjunction l_1 r_1},
{ l := l, r := r, adj := adj } = { l := l_1, r := r_1, adj := adj_1 } → l = l_1 ∧ r = r_1 ∧ adj ≍ adj_1 |
Matrix.projVandermonde_map | Mathlib.LinearAlgebra.Vandermonde | ∀ {R : Type u_1} [inst : CommRing R] {n : ℕ} {R' : Type u_3} [inst_1 : CommRing R'] (φ : R →+* R') (v w : Fin n → R),
(Matrix.projVandermonde (fun i => φ (v i)) fun i => φ (w i)) = φ.mapMatrix (Matrix.projVandermonde v w) |
CategoryTheory.Subobject.isoOfEqMk_inv | Mathlib.CategoryTheory.Subobject.Basic | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {B A : C} (X : CategoryTheory.Subobject B) (f : A ⟶ B)
[inst_1 : CategoryTheory.Mono f] (h : X = CategoryTheory.Subobject.mk f),
(X.isoOfEqMk f h).inv = CategoryTheory.Subobject.ofMkLE f X ⋯ |
Finset.noncommProd_singleton | Mathlib.Data.Finset.NoncommProd | ∀ {α : Type u_3} {β : Type u_4} [inst : Monoid β] (a : α) (f : α → β), {a}.noncommProd f ⋯ = f a |
_private.Mathlib.Algebra.Homology.HomotopyCategory.MappingCocone.0.CochainComplex.mappingCocone.inr_v_descCochain_v._proof_1_1 | Mathlib.Algebra.Homology.HomotopyCategory.MappingCocone | ∀ (p q : ℤ), p + 1 = q → p = q + -1 |
String.Pos.instLinearOrderPackage._proof_9 | Init.Data.String.OrderInstances | ∀ {s : String},
let this := inferInstance;
let this_1 := inferInstance;
let this_2 :=
let this := inferInstance;
let this_2 := inferInstance;
Max.leftLeaningOfLE s.Pos;
∀ (a b : s.Pos), a ⊔ b = if b ≤ a then a else b |
FirstOrder.Language.Theory.ModelsBoundedFormula.eq_1 | Mathlib.ModelTheory.Equivalence | ∀ {L : FirstOrder.Language} (T : L.Theory) {α : Type w} {n : ℕ} (φ : L.BoundedFormula α n),
T ⊨ᵇ φ = ∀ (M : T.ModelType) (v : α → ↑M) (xs : Fin n → ↑M), φ.Realize v xs |
ContinuousMap.mem_setOfIdeal | Mathlib.Topology.ContinuousMap.Ideals | ∀ {X : Type u_1} {R : Type u_2} [inst : TopologicalSpace X] [inst_1 : Semiring R] [inst_2 : TopologicalSpace R]
[inst_3 : IsTopologicalSemiring R] {I : Ideal C(X, R)} {x : X}, x ∈ ContinuousMap.setOfIdeal I ↔ ∃ f ∈ I, f x ≠ 0 |
PowerSeries.idealX._proof_1 | Mathlib.RingTheory.LaurentSeries | ∀ (K : Type u_1) [inst : Field K], Ideal.span {PowerSeries.X} ≠ ⊥ |
Lean.Parser.Command.prefix.formatter | Lean.Parser.Syntax | Lean.PrettyPrinter.Formatter |
Std.DTreeMap.Const.minKey?_modify_eq_minKey? | Std.Data.DTreeMap.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} {β : Type v} {t : Std.DTreeMap α (fun x => β) cmp} [Std.TransCmp cmp]
[Std.LawfulEqCmp cmp] {k : α} {f : β → β}, (Std.DTreeMap.Const.modify t k f).minKey? = t.minKey? |
Orthonormal.exists_hilbertBasis_extension | Mathlib.Analysis.InnerProductSpace.l2Space | ∀ {𝕜 : Type u_2} [inst : RCLike 𝕜] {E : Type u_3} [inst_1 : NormedAddCommGroup E] [inst_2 : InnerProductSpace 𝕜 E]
[CompleteSpace E] {s : Set E}, Orthonormal 𝕜 Subtype.val → ∃ w b, s ⊆ w ∧ ⇑b = Subtype.val |
RootPairing.ofBilinear._proof_4 | Mathlib.LinearAlgebra.RootSystem.OfBilinear | ∀ {R : Type u_2} {M : Type u_1} [inst : CommRing R] [inst_1 : AddCommGroup M] [inst_2 : Module R M]
(B : M →ₗ[R] M →ₗ[R] R) (hSB : B.IsSymm) (x : ↑{x | B.IsReflective x}),
Function.RightInverse (fun y => ⟨(Module.reflection ⋯) ↑y, ⋯⟩) fun y => ⟨(Module.reflection ⋯) ↑y, ⋯⟩ |
snd_himp | Mathlib.Order.Heyting.Basic | ∀ {α : Type u_2} {β : Type u_3} [inst : HImp α] [inst_1 : HImp β] (a b : α × β), (a ⇨ b).2 = a.2 ⇨ b.2 |
Bimod.AssociatorBimod.homAux._proof_1 | Mathlib.CategoryTheory.Monoidal.Bimod | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.MonoidalCategory C]
[inst_2 : CategoryTheory.Limits.HasCoequalizers C]
[inst_3 :
∀ (X : C),
CategoryTheory.Limits.PreservesColimitsOfSize.{0, 0, u_1, u_1, u_2, u_2}
(CategoryTheory.MonoidalCategory.tensorLeft X)]
[inst_4 :
∀ (X : C),
CategoryTheory.Limits.PreservesColimitsOfSize.{0, 0, u_1, u_1, u_2, u_2}
(CategoryTheory.MonoidalCategory.tensorRight X)]
{R S T U : CategoryTheory.Mon C} (P : Bimod R S) (Q : Bimod S T) (L : Bimod T U),
CategoryTheory.CategoryStruct.comp
((CategoryTheory.MonoidalCategory.tensorRight L.X).map
(CategoryTheory.MonoidalCategoryStruct.whiskerRight P.actRight Q.X))
(CategoryTheory.CategoryStruct.comp (CategoryTheory.MonoidalCategoryStruct.associator P.X Q.X L.X).hom
(CategoryTheory.CategoryStruct.comp
(CategoryTheory.MonoidalCategoryStruct.whiskerLeft P.X
(CategoryTheory.Limits.coequalizer.π (CategoryTheory.MonoidalCategoryStruct.whiskerRight Q.actRight L.X)
(CategoryTheory.CategoryStruct.comp (CategoryTheory.MonoidalCategoryStruct.associator Q.X T.X L.X).hom
(CategoryTheory.MonoidalCategoryStruct.whiskerLeft Q.X L.actLeft))))
(CategoryTheory.Limits.coequalizer.π
(CategoryTheory.MonoidalCategoryStruct.whiskerRight P.actRight (Q.tensorBimod L).X)
(CategoryTheory.CategoryStruct.comp
(CategoryTheory.MonoidalCategoryStruct.associator P.X S.X (Q.tensorBimod L).X).hom
(CategoryTheory.MonoidalCategoryStruct.whiskerLeft P.X (Q.tensorBimod L).actLeft))))) =
CategoryTheory.CategoryStruct.comp
((CategoryTheory.MonoidalCategory.tensorRight L.X).map
(CategoryTheory.CategoryStruct.comp (CategoryTheory.MonoidalCategoryStruct.associator P.X S.X Q.X).hom
(CategoryTheory.MonoidalCategoryStruct.whiskerLeft P.X Q.actLeft)))
(CategoryTheory.CategoryStruct.comp (CategoryTheory.MonoidalCategoryStruct.associator P.X Q.X L.X).hom
(CategoryTheory.CategoryStruct.comp
(CategoryTheory.MonoidalCategoryStruct.whiskerLeft P.X
(CategoryTheory.Limits.coequalizer.π (CategoryTheory.MonoidalCategoryStruct.whiskerRight Q.actRight L.X)
(CategoryTheory.CategoryStruct.comp (CategoryTheory.MonoidalCategoryStruct.associator Q.X T.X L.X).hom
(CategoryTheory.MonoidalCategoryStruct.whiskerLeft Q.X L.actLeft))))
(CategoryTheory.Limits.coequalizer.π
(CategoryTheory.MonoidalCategoryStruct.whiskerRight P.actRight (Q.tensorBimod L).X)
(CategoryTheory.CategoryStruct.comp
(CategoryTheory.MonoidalCategoryStruct.associator P.X S.X (Q.tensorBimod L).X).hom
(CategoryTheory.MonoidalCategoryStruct.whiskerLeft P.X (Q.tensorBimod L).actLeft))))) |
AddCon.mkAddHom_apply | Mathlib.GroupTheory.Congruence.Hom | ∀ {M : Type u_1} [inst : Add M] (c : AddCon M) (a : M), c.mkAddHom a = ↑a |
MulSemiringActionHom.comp._proof_4 | Mathlib.GroupTheory.GroupAction.Hom | ∀ {M : Type u_6} [inst : Monoid M] {N : Type u_4} [inst_1 : Monoid N] {P : Type u_5} [inst_2 : Monoid P] {φ : M →* N}
{ψ : N →* P} {R : Type u_2} [inst_3 : Semiring R] [inst_4 : MulSemiringAction M R] {S : Type u_3}
[inst_5 : Semiring S] [inst_6 : MulSemiringAction N S] {T : Type u_1} [inst_7 : Semiring T]
[inst_8 : MulSemiringAction P T] (g : S →ₑ+*[ψ] T) (f : R →ₑ+*[φ] S) (x y : R),
(↑↑((↑g).comp ↑f)).toFun (x * y) = (↑↑((↑g).comp ↑f)).toFun x * (↑↑((↑g).comp ↑f)).toFun y |
ContinuousMap.instNonUnitalNormedRing._proof_3 | Mathlib.Topology.ContinuousMap.Compact | ∀ {α : Type u_1} [inst : TopologicalSpace α] [inst_1 : CompactSpace α] {R : Type u_2} [inst_2 : NonUnitalNormedRing R]
(a : C(α, R)), 0 * a = 0 |
_private.Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Var.0.Std.Tactic.BVDecide.BVExpr.bitblast.blastVar.go_denote_eq._proof_1_3 | Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Var | ∀ {w : ℕ} (curr idx : ℕ), curr < idx → ¬curr + 1 ≤ idx → False |
CategoryTheory.monoidalOfHasFiniteProducts.tensorObj | Mathlib.CategoryTheory.Monoidal.OfHasFiniteProducts | ∀ (C : Type u) [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Limits.HasTerminal C]
[inst_2 : CategoryTheory.Limits.HasBinaryProducts C] (X Y : C),
CategoryTheory.MonoidalCategoryStruct.tensorObj X Y = (X ⨯ Y) |
unitInterval.tendsto_sigmoid_atBot | Mathlib.Analysis.SpecialFunctions.Sigmoid | Filter.Tendsto unitInterval.sigmoid Filter.atBot (nhds 0) |
CategoryTheory.GradedObject.comapEquiv._proof_1 | Mathlib.CategoryTheory.GradedObject | ∀ {β γ : Type u_1} (e : β ≃ γ), (fun i => i) = ⇑e.symm ∘ ⇑e |
_private.Init.Data.Iterators.Lemmas.Combinators.FilterMap.0.Std.Iter.length_eq_match_step.match_1.eq_3 | Init.Data.Iterators.Lemmas.Combinators.FilterMap | ∀ {α β : Type u_1} (motive : Std.IterStep (Std.Iter β) β → Sort u_2)
(h_1 : (it' : Std.Iter β) → (out : β) → motive (Std.IterStep.yield it' out))
(h_2 : (it' : Std.Iter β) → motive (Std.IterStep.skip it')) (h_3 : Unit → motive Std.IterStep.done),
(match Std.IterStep.done with
| Std.IterStep.yield it' out => h_1 it' out
| Std.IterStep.skip it' => h_2 it'
| Std.IterStep.done => h_3 ()) =
h_3 () |
Simps.ParsedProjectionData.mk.injEq | Mathlib.Tactic.Simps.Basic | ∀ (strName : Lean.Name) (strStx : Lean.Syntax) (newName : Lean.Name) (newStx : Lean.Syntax) (isDefault isPrefix : Bool)
(expr? : Option Lean.Expr) (projNrs : Array ℕ) (isCustom : Bool) (strName_1 : Lean.Name) (strStx_1 : Lean.Syntax)
(newName_1 : Lean.Name) (newStx_1 : Lean.Syntax) (isDefault_1 isPrefix_1 : Bool) (expr?_1 : Option Lean.Expr)
(projNrs_1 : Array ℕ) (isCustom_1 : Bool),
({ strName := strName, strStx := strStx, newName := newName, newStx := newStx, isDefault := isDefault,
isPrefix := isPrefix, expr? := expr?, projNrs := projNrs, isCustom := isCustom } =
{ strName := strName_1, strStx := strStx_1, newName := newName_1, newStx := newStx_1, isDefault := isDefault_1,
isPrefix := isPrefix_1, expr? := expr?_1, projNrs := projNrs_1, isCustom := isCustom_1 }) =
(strName = strName_1 ∧
strStx = strStx_1 ∧
newName = newName_1 ∧
newStx = newStx_1 ∧
isDefault = isDefault_1 ∧
isPrefix = isPrefix_1 ∧ expr? = expr?_1 ∧ projNrs = projNrs_1 ∧ isCustom = isCustom_1) |
WeierstrassCurve.Affine.negY.eq_1 | Mathlib.AlgebraicGeometry.EllipticCurve.Affine.Formula | ∀ {R : Type r} [inst : CommRing R] (W' : WeierstrassCurve.Affine R) (x y : R), W'.negY x y = -y - W'.a₁ * x - W'.a₃ |
Lean.Try.Config.ctorIdx | Init.Try | Lean.Try.Config → ℕ |
CategoryTheory.Functor.Fiber.inducedFunctor.congr_simp | Mathlib.CategoryTheory.FiberedCategory.Grothendieck | ∀ {𝒮 : Type u₁} {𝒳 : Type u₂} [inst : CategoryTheory.Category.{v₁, u₁} 𝒮] [inst_1 : CategoryTheory.Category.{v₂, u₂} 𝒳]
{p : CategoryTheory.Functor 𝒳 𝒮} {S : 𝒮} {C : Type u₃} [inst_2 : CategoryTheory.Category.{v₃, u₃} C]
{F F_1 : CategoryTheory.Functor C 𝒳} (e_F : F = F_1) (hF : F.comp p = (CategoryTheory.Functor.const C).obj S),
CategoryTheory.Functor.Fiber.inducedFunctor hF = CategoryTheory.Functor.Fiber.inducedFunctor ⋯ |
IsOfFinAddOrder.nsmul | Mathlib.GroupTheory.OrderOfElement | ∀ {G : Type u_1} [inst : AddMonoid G] {a : G} {n : ℕ}, IsOfFinAddOrder a → IsOfFinAddOrder (n • a) |
_private.Mathlib.Order.Nucleus.0.Nucleus.instHImp._simp_4 | Mathlib.Order.Nucleus | ∀ {b : Prop} (α : Sort u_1) [i : Nonempty α], (∀ (a : α), b) = b |
_private.Mathlib.MeasureTheory.MeasurableSpace.Constructions.0.measurableAtom_eq_of_mem._simp_1_2 | Mathlib.MeasureTheory.MeasurableSpace.Constructions | ∀ {α : Type u} {ι : Sort v} {x : α} {s : ι → Set α}, (x ∈ ⋂ i, s i) = ∀ (i : ι), x ∈ s i |
_private.Init.Data.Array.Attach.0.Array.pmapImpl.eq_1 | Init.Data.Array.Attach | ∀ {α : Type u_1} {β : Type u_2} {P : α → Prop} (f : (a : α) → P a → β) (xs : Array α) (H : ∀ a ∈ xs, P a),
Array.pmapImpl f xs H =
Array.map
(fun x =>
match x with
| ⟨x, h'⟩ => f x h')
(xs.attachWith P H) |
Lean.IR.initFn._@.Lean.Compiler.IR.SimpleGroundExpr.160484116._hygCtx._hyg.2 | Lean.Compiler.IR.SimpleGroundExpr | IO (Lean.EnvExtension Lean.IR.SimpleGroundExtState) |
MeasurableInf.measurable_const_inf._autoParam | Mathlib.MeasureTheory.Order.Lattice | Lean.Syntax |
IsPrimePow.ne_zero | Mathlib.Algebra.IsPrimePow | ∀ {R : Type u_1} [inst : CommMonoidWithZero R] [NoZeroDivisors R] {n : R}, IsPrimePow n → n ≠ 0 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.