name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.67M | allowCompletion bool 2
classes |
|---|---|---|---|
ModularGroup.eq_smul_self_of_mem_fdo_mem_fdo | Mathlib.NumberTheory.Modular | ∀ {g : Matrix.SpecialLinearGroup (Fin 2) ℤ} {z : UpperHalfPlane},
z ∈ ModularGroup.fdo → g • z ∈ ModularGroup.fdo → z = g • z | true |
MulEquiv.mk.inj | Mathlib.Algebra.Group.Equiv.Defs | ∀ {M : Type u_9} {N : Type u_10} {inst : Mul M} {inst_1 : Mul N} {toEquiv : M ≃ N}
{map_mul' : ∀ (x y : M), toEquiv.toFun (x * y) = toEquiv.toFun x * toEquiv.toFun y} {toEquiv_1 : M ≃ N}
{map_mul'_1 : ∀ (x y : M), toEquiv_1.toFun (x * y) = toEquiv_1.toFun x * toEquiv_1.toFun y},
{ toEquiv := toEquiv, map_mul' := map_mul' } = { toEquiv := toEquiv_1, map_mul' := map_mul'_1 } → toEquiv = toEquiv_1 | true |
LLVM.buildGEP2 | Lean.Compiler.IR.LLVMBindings | {ctx : LLVM.Context} →
LLVM.Builder ctx →
LLVM.LLVMType ctx → LLVM.Value ctx → Array (LLVM.Value ctx) → optParam String "" → BaseIO (LLVM.Value ctx) | true |
CategoryTheory.Limits.coneUnopOfCocone_pt | Mathlib.CategoryTheory.Limits.Cones | ∀ {J : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} J] {C : Type u₃} [inst_1 : CategoryTheory.Category.{v₃, u₃} C]
{F : CategoryTheory.Functor Jᵒᵖ Cᵒᵖ} (c : CategoryTheory.Limits.Cocone F),
(CategoryTheory.Limits.coneUnopOfCocone c).pt = Opposite.unop c.pt | true |
CategoryTheory.FintypeCat.Action.isConnected_iff_transitive | Mathlib.CategoryTheory.Galois.Examples | ∀ (G : Type u) [inst : Group G] (X : Action FintypeCat G) [Nonempty X.V.obj],
CategoryTheory.PreGaloisCategory.IsConnected X ↔ MulAction.IsPretransitive G X.V.obj | true |
Set.exists_min_image | Mathlib.Data.Set.Finite.Lemmas | ∀ {α : Type u} {β : Type v} [inst : LinearOrder β] (s : Set α) (f : α → β),
s.Finite → s.Nonempty → ∃ a ∈ s, ∀ b ∈ s, f a ≤ f b | true |
MulHom.prod_comp_prodMap | Mathlib.Algebra.Group.Prod | ∀ {M : Type u_3} {N : Type u_4} {P : Type u_5} {M' : Type u_6} {N' : Type u_7} [inst : Mul M] [inst_1 : Mul N]
[inst_2 : Mul M'] [inst_3 : Mul N'] [inst_4 : Mul P] (f : P →ₙ* M) (g : P →ₙ* N) (f' : M →ₙ* M') (g' : N →ₙ* N'),
(f'.prodMap g').comp (f.prod g) = (f'.comp f).prod (g'.comp g) | true |
_private.Std.Time.Format.Basic.0.Std.Time.GenericFormat.DateBuilder.H | Std.Time.Format.Basic | Std.Time.GenericFormat.DateBuilder✝ → Option Std.Time.Hour.Ordinal | true |
ONote.opowAux2.match_1 | Mathlib.SetTheory.Ordinal.Notation | (motive : ONote × ℕ → Sort u_1) →
(x : ONote × ℕ) → ((b : ONote) → motive (b, 0)) → ((b : ONote) → (k : ℕ) → motive (b, k.succ)) → motive x | false |
Module.Basis.adjustToOrientation.congr_simp | Mathlib.LinearAlgebra.Orientation | ∀ {R : Type u_1} [inst : CommRing R] [inst_1 : LinearOrder R] [inst_2 : IsStrictOrderedRing R] {M : Type u_2}
[inst_3 : AddCommGroup M] [inst_4 : Module R M] {ι : Type u_3} [inst_5 : Fintype ι] [inst_6 : DecidableEq ι]
[inst_7 : Nonempty ι] (e e_1 : Module.Basis ι R M),
e = e_1 → ∀ (x x_1 : Orientation R M ι), x = x_1 → e.adjustToOrientation x = e_1.adjustToOrientation x_1 | true |
MeasureTheory.IsFundamentalDomain.measure_zero_of_invariant | Mathlib.MeasureTheory.Group.FundamentalDomain | ∀ {G : Type u_1} {α : Type u_3} [inst : Group G] [inst_1 : MulAction G α] [inst_2 : MeasurableSpace α] {s : Set α}
{μ : MeasureTheory.Measure α} [MeasurableConstSMul G α] [MeasureTheory.SMulInvariantMeasure G α μ] [Countable G],
MeasureTheory.IsFundamentalDomain G s μ → ∀ (t : Set α), (∀ (g : G), g • t = t) → μ (t ∩ s) = 0 → μ t = 0 | true |
differentiable_neg | Mathlib.Analysis.Calculus.Deriv.Add | ∀ {𝕜 : Type u} [inst : NontriviallyNormedField 𝕜], Differentiable 𝕜 Neg.neg | true |
CategoryTheory.Functor.Final.rec | Mathlib.CategoryTheory.Limits.Final | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
{D : Type u₂} →
[inst_1 : CategoryTheory.Category.{v₂, u₂} D] →
{F : CategoryTheory.Functor C D} →
{motive : F.Final → Sort u} →
((out : ∀ (d : D), CategoryTheory.IsConnected (CategoryTheory.StructuredArrow d F)) → motive ⋯) →
(t : F.Final) → motive t | false |
Units.val | Mathlib.Algebra.Group.Units.Defs | {α : Type u} → [inst : Monoid α] → αˣ → α | true |
_private.Init.Data.List.Find.0.List.find?_replicate_eq_none_iff._simp_1_1 | Init.Data.List.Find | ∀ {a b : Prop}, (a ∨ b) = (¬a → b) | false |
CategoryTheory.PreZeroHypercover.pullbackIso | Mathlib.CategoryTheory.Sites.Hypercover.Zero | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
{S T : C} →
(f : S ⟶ T) →
(E : CategoryTheory.PreZeroHypercover T) →
[inst_1 : ∀ (i : E.I₀), CategoryTheory.Limits.HasPullback f (E.f i)] →
[inst_2 : ∀ (i : E.I₀), CategoryTheory.Limits.HasPullback (E.f i) f] →
CategoryTheory.PreZeroHypercover.pullback₁ f E ≅ CategoryTheory.PreZeroHypercover.pullback₂ f E | true |
Set.iUnion_iUnion_eq_right | Mathlib.Data.Set.Lattice | ∀ {α : Type u_1} {β : Type u_2} {b : β} {s : (x : β) → b = x → Set α}, ⋃ x, ⋃ (h : b = x), s x h = s b ⋯ | true |
Std.DHashMap.Internal.Raw.Const.get_eq | Std.Data.DHashMap.Internal.Raw | ∀ {α : Type u} {β : Type v} [inst : BEq α] [inst_1 : Hashable α] {m : Std.DHashMap.Raw α fun x => β} {a : α}
{h : a ∈ m}, Std.DHashMap.Raw.Const.get m a h = Std.DHashMap.Internal.Raw₀.Const.get ⟨m, ⋯⟩ a ⋯ | true |
toLexLinearEquiv | Mathlib.Algebra.Order.Module.Equiv | (α : Type u_1) →
(β : Type u_2) → [inst : Semiring α] → [inst_1 : AddCommMonoid β] → [inst_2 : Module α β] → β ≃ₗ[α] Lex β | true |
SupHom.recOn | Mathlib.Order.Hom.Lattice | {α : Type u_6} →
{β : Type u_7} →
[inst : Max α] →
[inst_1 : Max β] →
{motive : SupHom α β → Sort u} →
(t : SupHom α β) →
((toFun : α → β) →
(map_sup' : ∀ (a b : α), toFun (a ⊔ b) = toFun a ⊔ toFun b) →
motive { toFun := toFun, map_sup' := map_sup' }) →
motive t | false |
_private.Init.Data.Vector.Lemmas.0.Vector.mem_flatten._simp_1_1 | Init.Data.Vector.Lemmas | ∀ {α : Type u_1} {a : α} {xss : Array (Array α)}, (a ∈ xss.flatten) = ∃ xs ∈ xss, a ∈ xs | false |
_private.Init.Data.Array.Basic.0.Array.findSomeRevM?.find.match_1 | Init.Data.Array.Basic | {β : Type u_1} →
(motive : Option β → Sort u_2) → (r : Option β) → ((val : β) → motive (some val)) → (Unit → motive none) → motive r | false |
normalize_eq_one | Mathlib.Algebra.GCDMonoid.Basic | ∀ {α : Type u_1} [inst : CommMonoidWithZero α] [inst_1 : NormalizationMonoid α] {x : α}, normalize x = 1 ↔ IsUnit x | true |
_private.Mathlib.MeasureTheory.Integral.Bochner.Basic.0.Mathlib.Meta.Positivity.evalIntegral._proof_2 | Mathlib.MeasureTheory.Integral.Bochner.Basic | ∀ (α : Q(Type)) (pα : Q(PartialOrder «$α»)) (__defeqres : PLift («$pα» =Q Real.partialOrder)),
«$pα» =Q Real.partialOrder | false |
Matrix.Semiring.smulCommClass | Mathlib.Data.Matrix.Mul | ∀ {n : Type u_3} {R : Type u_7} {α : Type v} [inst : NonUnitalNonAssocSemiring α] [inst_1 : Fintype n]
[inst_2 : Monoid R] [inst_3 : DistribMulAction R α] [SMulCommClass R α α],
SMulCommClass R (Matrix n n α) (Matrix n n α) | true |
Std.Time.Day.instDecidableLtOffset._aux_1 | Std.Time.Date.Unit.Day | {x y : Std.Time.Day.Offset} → Decidable (x < y) | false |
_private.Lean.Linter.ConstructorAsVariable.0.Lean.Linter.constructorNameAsVariable.match_1 | Lean.Linter.ConstructorAsVariable | (motive : Option Lean.Expr → Sort u_1) →
(x : Option Lean.Expr) → ((t : Lean.Expr) → motive (some t)) → ((x : Option Lean.Expr) → motive x) → motive x | false |
CFC.norm_mul_mul_star_self_of_nonneg | Mathlib.Analysis.SpecialFunctions.ContinuousFunctionalCalculus.Rpow.Isometric | ∀ {A : Type u_1} [inst : PartialOrder A] [inst_1 : NonUnitalNormedRing A] [inst_2 : StarRing A] [CStarRing A]
[inst_4 : NormedSpace ℝ A] [inst_5 : SMulCommClass ℝ A A] [inst_6 : IsScalarTower ℝ A A] [inst_7 : StarOrderedRing A]
[inst_8 : NonUnitalContinuousFunctionalCalculus ℝ A IsSelfAdjoint] [inst_9 : NonnegSpectrumClass ℝ A] {a : A} (b : A),
autoParam (0 ≤ a) CFC.norm_mul_mul_star_self_of_nonneg._auto_1 → ‖b * a * star b‖ = ‖b * CFC.sqrt a‖ ^ 2 | true |
_private.Lean.Compiler.LCNF.Simp.JpCases.0.Lean.Compiler.LCNF.Simp.mkJmpArgsAtJp | Lean.Compiler.LCNF.Simp.JpCases | Array (Lean.Compiler.LCNF.Param Lean.Compiler.LCNF.Purity.pure) →
ℕ →
Array (Lean.Compiler.LCNF.Param Lean.Compiler.LCNF.Purity.pure) →
Bool → Array (Lean.Compiler.LCNF.Arg Lean.Compiler.LCNF.Purity.pure) | true |
_private.Mathlib.Order.LiminfLimsup.0.CompleteLatticeHom.apply_limsup_iterate._simp_1_1 | Mathlib.Order.LiminfLimsup | ∀ (n m : ℕ), (n + m).succ = n + m.succ | false |
sigmaFinsuppAddEquivDFinsupp._proof_2 | Mathlib.Data.Finsupp.ToDFinsupp | ∀ {ι : Type u_3} {η : ι → Type u_2} {N : Type u_1} [inst : AddZeroClass N],
Function.RightInverse sigmaFinsuppEquivDFinsupp.invFun sigmaFinsuppEquivDFinsupp.toFun | false |
IsUniformAddGroup.isLeftUniformAddGroup | Mathlib.Topology.Algebra.IsUniformGroup.Defs | ∀ (α : Type u_1) [inst : UniformSpace α] [inst_1 : AddGroup α] [IsUniformAddGroup α], IsLeftUniformAddGroup α | true |
_private.Mathlib.GroupTheory.Perm.Cycle.Type.0.Equiv.Perm.IsThreeCycle.nodup_iff_mem_support._proof_1_6 | Mathlib.GroupTheory.Perm.Cycle.Type | ∀ {α : Type u_1} [inst_1 : DecidableEq α] {g : Equiv.Perm α} {a : α} (w : α),
2 ≤ List.count w [a, g a, g (g a)] → 1 < (List.filter (fun x => decide (x = w)) [a, g a, g (g a)]).length | false |
Action.inv_hom_hom_assoc | Mathlib.CategoryTheory.Action.Basic | ∀ {V : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} V] {G : Type u_2} [inst_1 : Monoid G] {M N : Action V G}
(f : M ≅ N) {Z : V} (h : N.V ⟶ Z),
CategoryTheory.CategoryStruct.comp f.inv.hom (CategoryTheory.CategoryStruct.comp f.hom.hom h) = h | true |
_private.Mathlib.Analysis.Complex.PhragmenLindelof.0._aux_Mathlib_Analysis_Complex_PhragmenLindelof___macroRules__private_Mathlib_Analysis_Complex_PhragmenLindelof_0_termExpR_1 | Mathlib.Analysis.Complex.PhragmenLindelof | Lean.Macro | false |
instCommRingCorner._proof_2 | Mathlib.RingTheory.Idempotents | ∀ {R : Type u_1} (e : R) [inst : NonUnitalCommRing R] (idem : IsIdempotentElem e) (n : ℕ),
IntCast.intCast (Int.negSucc n) = -↑(n + 1) | false |
Complex.cpow_two | Mathlib.Analysis.SpecialFunctions.Pow.Complex | ∀ (x : ℂ), x ^ 2 = x ^ 2 | true |
Lean.Elab.Tactic.ElabSimpArgsResult.mk.inj | Lean.Elab.Tactic.Simp | ∀ {ctx : Lean.Meta.Simp.Context} {simprocs : Lean.Meta.Simp.SimprocsArray}
{simpArgs : Array (Lean.Syntax × Lean.Elab.Tactic.ElabSimpArgResult)} {ctx_1 : Lean.Meta.Simp.Context}
{simprocs_1 : Lean.Meta.Simp.SimprocsArray} {simpArgs_1 : Array (Lean.Syntax × Lean.Elab.Tactic.ElabSimpArgResult)},
{ ctx := ctx, simprocs := simprocs, simpArgs := simpArgs } =
{ ctx := ctx_1, simprocs := simprocs_1, simpArgs := simpArgs_1 } →
ctx = ctx_1 ∧ simprocs = simprocs_1 ∧ simpArgs = simpArgs_1 | true |
Lean.Core.numBinders | Lean.Meta.ExprLens | {M : Type → Type} → [Monad M] → [Lean.MonadError M] → Lean.SubExpr.Pos → Lean.Expr → M ℕ | true |
MeromorphicAt.update | Mathlib.Analysis.Meromorphic.Basic | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_3} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] [inst_3 : DecidableEq 𝕜] {f : 𝕜 → E} {z : 𝕜},
MeromorphicAt f z → ∀ (w : 𝕜) (e : E), MeromorphicAt (Function.update f w e) z | true |
_private.Mathlib.Analysis.Real.OfDigits.0.Real.ofDigits_const_last_eq_one._simp_1_6 | Mathlib.Analysis.Real.OfDigits | ∀ {α : Type u_2} [inst : Zero α] [inst_1 : OfNat α 3] [NeZero 3], (3 = 0) = False | false |
CategoryTheory.Limits.inl_inl_pushoutAssoc_hom_assoc | Mathlib.CategoryTheory.Limits.Shapes.Pullback.Assoc | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {X₁ X₂ X₃ Z₁ Z₂ : C} (g₁ : Z₁ ⟶ X₁) (g₂ : Z₁ ⟶ X₂)
(g₃ : Z₂ ⟶ X₂) (g₄ : Z₂ ⟶ X₃) [inst_1 : CategoryTheory.Limits.HasPushout g₁ g₂]
[inst_2 : CategoryTheory.Limits.HasPushout g₃ g₄]
[inst_3 :
CategoryTheory.Limits.HasPushout (CategoryTheory.CategoryStruct.comp g₃ (CategoryTheory.Limits.pushout.inr g₁ g₂))
g₄]
[inst_4 :
CategoryTheory.Limits.HasPushout g₁
(CategoryTheory.CategoryStruct.comp g₂ (CategoryTheory.Limits.pushout.inl g₃ g₄))]
{Z : C}
(h :
CategoryTheory.Limits.pushout g₁ (CategoryTheory.CategoryStruct.comp g₂ (CategoryTheory.Limits.pushout.inl g₃ g₄)) ⟶
Z),
CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.pushout.inl g₁ g₂)
(CategoryTheory.CategoryStruct.comp
(CategoryTheory.Limits.pushout.inl
(CategoryTheory.CategoryStruct.comp g₃ (CategoryTheory.Limits.pushout.inr g₁ g₂)) g₄)
(CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.pushoutAssoc g₁ g₂ g₃ g₄).hom h)) =
CategoryTheory.CategoryStruct.comp
(CategoryTheory.Limits.pushout.inl g₁
(CategoryTheory.CategoryStruct.comp g₂ (CategoryTheory.Limits.pushout.inl g₃ g₄)))
h | true |
_private.Lean.Meta.Tactic.Grind.Solve.0.Lean.Meta.Grind.solve._sparseCasesOn_1 | Lean.Meta.Tactic.Grind.Solve | {α : Type u} →
{motive : List α → Sort u_1} →
(t : List α) →
((head : α) → (tail : List α) → motive (head :: tail)) → (Nat.hasNotBit 2 t.ctorIdx → motive t) → motive t | false |
closureCommutatorRepresentatives.eq_1 | Mathlib.GroupTheory.Commutator.Basic | ∀ (G : Type u_1) [inst : Group G],
closureCommutatorRepresentatives G =
Subgroup.closure (Prod.fst '' commutatorRepresentatives G ∪ Prod.snd '' commutatorRepresentatives G) | true |
Std.Tactic.BVDecide.BVExpr.bitblast.blastShiftLeftConst._proof_10 | Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.ShiftLeft | ∀ {w : ℕ}, 0 ≤ w | false |
IsAddIndecomposable.baseOf_subset_pos | Mathlib.Algebra.Group.Irreducible.Indecomposable | ∀ {ι : Type u_1} {M : Type u_2} {S : Type u_4} [inst : AddMonoid M] [inst_1 : LinearOrder S] [inst_2 : AddMonoid S]
(v : ι → M) (f : M →+ S), IsAddIndecomposable.baseOf v f ⊆ {i | 0 < f (v i)} | true |
Lean.Compiler.LCNF.Probe.countUnique | Lean.Compiler.LCNF.Probing | {α : Type} → [ToString α] → [BEq α] → [Hashable α] → Lean.Compiler.LCNF.Probe α (α × ℕ) | true |
NormedDivisionRing.nnratCast._inherited_default | Mathlib.Analysis.Normed.Field.Basic | {α : Type u_5} → (ℕ → α) → (α → α → α) → ℚ≥0 → α | false |
Filter.tendsto_ofReal_iff' | Mathlib.Analysis.Complex.Basic | ∀ {α : Type u_2} {𝕜 : Type u_3} [inst : RCLike 𝕜] {l : Filter α} {f : α → ℝ} {x : ℝ},
Filter.Tendsto (fun x => ↑(f x)) l (nhds ↑x) ↔ Filter.Tendsto f l (nhds x) | true |
Ordinal.IsFundamentalSeq | Mathlib.SetTheory.Ordinal.FundamentalSequence | {a o : Ordinal.{u_1}} → (↑(Set.Iio a) → ↑(Set.Iio o)) → Prop | true |
Lean.Grind.AC.instBEqSeq.beq._sparseCasesOn_1 | Init.Grind.AC | {motive : Lean.Grind.AC.Seq → Sort u} →
(t : Lean.Grind.AC.Seq) →
((x : Lean.Grind.AC.Var) → motive (Lean.Grind.AC.Seq.var x)) → (Nat.hasNotBit 1 t.ctorIdx → motive t) → motive t | false |
Lean.ToLevel.ctorIdx | Lean.ToLevel | Lean.ToLevel → ℕ | false |
Lean.IR.MaxIndex.visitFnBody | Lean.Compiler.IR.FreeVars | Lean.IR.FnBody → Lean.IR.MaxIndex.M Unit | true |
Lean.Json.«json[_]» | Lean.Data.Json.Elab | Lean.ParserDescr | true |
ExceptT.bindCont.match_1 | Init.Control.Except | {ε α : Type u_1} →
(motive : Except ε α → Sort u_2) →
(x : Except ε α) → ((a : α) → motive (Except.ok a)) → ((e : ε) → motive (Except.error e)) → motive x | false |
AlgebraicGeometry.instSurjectiveOfGeometricallyIntegral | Mathlib.AlgebraicGeometry.Geometrically.Integral | ∀ {X S : AlgebraicGeometry.Scheme} (f : X ⟶ S) [AlgebraicGeometry.GeometricallyIntegral f],
AlgebraicGeometry.Surjective f | true |
CategoryTheory.FunctorToTypes.binaryProductEquiv._proof_2 | Mathlib.CategoryTheory.Limits.Shapes.FunctorToTypes | ∀ {C : Type u_3} [inst : CategoryTheory.Category.{u_2, u_3} C] (F G : CategoryTheory.Functor C (Type u_1)) (a : C)
(x : (F ⨯ G).obj a),
(fun z => CategoryTheory.FunctorToTypes.prodMk z.1 z.2)
((fun z =>
(((CategoryTheory.FunctorToTypes.binaryProductIso F G).hom.app a z).1,
((CategoryTheory.FunctorToTypes.binaryProductIso F G).hom.app a z).2))
x) =
x | false |
AddOpposite.opUniformEquivLeft._proof_1 | Mathlib.Topology.Algebra.IsUniformGroup.Basic | ∀ (G : Type u_1) [inst : AddGroup G] [inst_1 : TopologicalSpace G] [inst_2 : IsTopologicalAddGroup G],
UniformContinuous AddOpposite.op | false |
Lean.ModuleSetup.mk | Lean.Setup | Lean.Name →
Option Lean.PkgId →
Bool →
Option (Array Lean.Import) →
Lean.NameMap Lean.ImportArtifacts →
Array System.FilePath → Array System.FilePath → Lean.LeanOptions → Lean.ModuleSetup | true |
CategoryTheory.Pseudofunctor.ObjectProperty.map_map_hom | Mathlib.CategoryTheory.Bicategory.Functor.Cat.ObjectProperty | ∀ {B : Type u} [inst : CategoryTheory.Bicategory B] {F : CategoryTheory.Pseudofunctor B CategoryTheory.Cat}
(P : F.ObjectProperty) [inst_1 : P.IsClosedUnderMapObj] {X Y : B} (f : X ⟶ Y) {X_1 Y_1 : P.Obj X} (f_1 : X_1 ⟶ Y_1),
((P.map f).map f_1).hom = (F.map f).toFunctor.map f_1.hom | true |
ContinuousMap.comp.eq_1 | Mathlib.Condensed.TopComparison | ∀ {α : Type u_1} {β : Type u_2} {γ : Type u_3} [inst : TopologicalSpace α] [inst_1 : TopologicalSpace β]
[inst_2 : TopologicalSpace γ] (f : C(β, γ)) (g : C(α, β)), f.comp g = { toFun := ⇑f ∘ ⇑g, continuous_toFun := ⋯ } | true |
LLVM.instNonemptyModule | Lean.Compiler.IR.LLVMBindings | ∀ {ctx : LLVM.Context}, Nonempty (LLVM.Module ctx) | true |
Lean.Parser.parserAliases2infoRef | Lean.Parser.Extension | IO.Ref (Lean.NameMap Lean.Parser.ParserAliasInfo) | true |
FirstOrder.Language.Substructure.mem_comap | Mathlib.ModelTheory.Substructures | ∀ {L : FirstOrder.Language} {M : Type w} {N : Type u_1} [inst : L.Structure M] [inst_1 : L.Structure N]
{S : L.Substructure N} {f : L.Hom M N} {x : M}, x ∈ FirstOrder.Language.Substructure.comap f S ↔ f x ∈ S | true |
CategoryTheory.Presieve.BindStruct.hf | Mathlib.CategoryTheory.Sites.Sieves | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {X : C} {S : CategoryTheory.Presieve X}
{R : ⦃Y : C⦄ → ⦃f : Y ⟶ X⦄ → S f → CategoryTheory.Presieve Y} {Z : C} {h : Z ⟶ X} (self : S.BindStruct R h), S self.f | true |
_private.Aesop.Frontend.Command.0.Aesop.Frontend.Parser.evalStatsReport?.match_4 | Aesop.Frontend.Command | (motive : DoResultPR Aesop.StatsReport (Option Aesop.StatsReport) PUnit.{1} → Sort u_1) →
(r : DoResultPR Aesop.StatsReport (Option Aesop.StatsReport) PUnit.{1}) →
((a : Aesop.StatsReport) → (u : PUnit.{1}) → motive (DoResultPR.pure a u)) →
((b : Option Aesop.StatsReport) → (u : PUnit.{1}) → motive (DoResultPR.return b u)) → motive r | false |
EuclideanGeometry.sin_oangle_right_mul_dist_of_oangle_eq_pi_div_two | Mathlib.Geometry.Euclidean.Angle.Oriented.RightAngle | ∀ {V : Type u_1} {P : Type u_2} [inst : NormedAddCommGroup V] [inst_1 : InnerProductSpace ℝ V] [inst_2 : MetricSpace P]
[inst_3 : NormedAddTorsor V P] [hd2 : Fact (Module.finrank ℝ V = 2)] [inst_4 : Module.Oriented ℝ V (Fin 2)]
{p₁ p₂ p₃ : P},
EuclideanGeometry.oangle p₁ p₂ p₃ = ↑(Real.pi / 2) → (EuclideanGeometry.oangle p₂ p₃ p₁).sin * dist p₁ p₃ = dist p₁ p₂ | true |
Algebra.Generators.compLocalizationAwayAlgHom_relation_eq_zero | Mathlib.RingTheory.Extension.Cotangent.LocalizationAway | ∀ {R : Type u_1} {S : Type u_2} {T : Type u_3} {ι : Type u_4} [inst : CommRing R] [inst_1 : CommRing S]
[inst_2 : Algebra R S] [inst_3 : CommRing T] [inst_4 : Algebra R T] [inst_5 : Algebra S T]
[inst_6 : IsScalarTower R S T] (g : S) [inst_7 : IsLocalization.Away g T] (P : Algebra.Generators R S ι),
(Algebra.Generators.compLocalizationAwayAlgHom T g P)
((MvPolynomial.rename Sum.inr) (P.σ g) * MvPolynomial.X (Sum.inl ()) - 1) =
0 | true |
SSet.coskAdj | Mathlib.AlgebraicTopology.SimplicialSet.Basic | (n : ℕ) → SSet.truncation n ⊣ SSet.Truncated.cosk n | true |
CochainComplex.mappingCone.d_fst_v' | Mathlib.Algebra.Homology.HomotopyCategory.MappingCone | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v, u_1} C] [inst_1 : CategoryTheory.Preadditive C]
{F G : CochainComplex C ℤ} (φ : F ⟶ G) [inst_2 : HomologicalComplex.HasHomotopyCofiber φ] (i j : ℤ) (hij : i + 1 = j),
CategoryTheory.CategoryStruct.comp ((CochainComplex.mappingCone φ).d (i - 1) i)
((↑(CochainComplex.mappingCone.fst φ)).v i j hij) =
-CategoryTheory.CategoryStruct.comp ((↑(CochainComplex.mappingCone.fst φ)).v (i - 1) i ⋯) (F.d i j) | true |
enorm_ne_zero | Mathlib.Analysis.Normed.Group.Basic | ∀ {E : Type u_8} [inst : TopologicalSpace E] [inst_1 : ENormedAddMonoid E] {a : E}, ‖a‖ₑ ≠ 0 ↔ a ≠ 0 | true |
SSet.PtSimplex.MulStruct.mk._flat_ctor | Mathlib.AlgebraicTopology.SimplicialSet.KanComplex.MulStruct | {X : SSet} →
{n : ℕ} →
{x : X.obj (Opposite.op (SimplexCategory.mk 0))} →
{f g fg : X.PtSimplex n x} →
{i : Fin n} →
(map : SSet.stdSimplex.obj (SimplexCategory.mk (n + 1)) ⟶ X) →
autoParam (CategoryTheory.CategoryStruct.comp (SSet.stdSimplex.δ i.castSucc.castSucc) map = g.map)
SSet.PtSimplex.MulStruct.δ_castSucc_castSucc_map._autoParam →
autoParam (CategoryTheory.CategoryStruct.comp (SSet.stdSimplex.δ i.castSucc.succ) map = fg.map)
SSet.PtSimplex.MulStruct.δ_succ_castSucc_map._autoParam →
autoParam (CategoryTheory.CategoryStruct.comp (SSet.stdSimplex.δ i.succ.succ) map = f.map)
SSet.PtSimplex.MulStruct.δ_succ_succ_map._autoParam →
autoParam
(∀ j < i.castSucc.castSucc,
CategoryTheory.CategoryStruct.comp (SSet.stdSimplex.δ j) map = SSet.const x)
SSet.PtSimplex.MulStruct.δ_map_of_lt._autoParam →
autoParam
(∀ (j : Fin (n + 2)),
i.succ.succ < j → CategoryTheory.CategoryStruct.comp (SSet.stdSimplex.δ j) map = SSet.const x)
SSet.PtSimplex.MulStruct.δ_map_of_gt._autoParam →
f.MulStruct g fg i | false |
_private.Lean.Meta.IndPredBelow.0.Lean.Meta.IndPredBelow.mkBelowMatcher._sparseCasesOn_7 | Lean.Meta.IndPredBelow | {motive : Bool → Sort u} → (t : Bool) → motive false → (Nat.hasNotBit 1 t.ctorIdx → motive t) → motive t | false |
_private.Lean.Meta.Sym.Simp.DiscrTree.0.Lean.Meta.Sym.pushArgsTodo._unsafe_rec | Lean.Meta.Sym.Simp.DiscrTree | Array Lean.Expr → Lean.Expr → Array Lean.Expr | false |
ENNReal.coe_iInf._simp_1 | Mathlib.Data.ENNReal.Basic | ∀ {ι : Sort u_3} [Nonempty ι] (f : ι → NNReal), ⨅ a, ↑(f a) = ↑(iInf f) | false |
_private.Mathlib.Algebra.Ring.Divisibility.Lemmas.0.dvd_smul_of_dvd.match_1_1 | Mathlib.Algebra.Ring.Divisibility.Lemmas | ∀ {R : Type u_1} [inst : Semigroup R] {x y : R} (motive : x ∣ y → Prop) (h : x ∣ y),
(∀ (k : R) (hk : y = x * k), motive ⋯) → motive h | false |
_private.Mathlib.Analysis.PSeries.0.summable_schlomilch_iff_of_nonneg._simp_1_1 | Mathlib.Analysis.PSeries | ∀ {r₁ r₂ : NNReal}, (↑r₁ ≤ ↑r₂) = (r₁ ≤ r₂) | false |
KaehlerDifferential.quotKerTotalEquiv._proof_2 | Mathlib.RingTheory.Kaehler.Basic | ∀ (R : Type u_2) (S : Type u_1) [inst : CommRing R] [inst_1 : CommRing S] [inst_2 : Algebra R S],
Function.RightInverse (⇑(KaehlerDifferential.derivationQuotKerTotal R S).liftKaehlerDifferential)
((KaehlerDifferential.kerTotal R S).liftQ (Finsupp.linearCombination S ⇑(KaehlerDifferential.D R S)) ⋯).toFun | false |
Filter.lift_principal2 | Mathlib.Order.Filter.Lift | ∀ {α : Type u_1} {f : Filter α}, f.lift Filter.principal = f | true |
Commute.pow_pow_self | Mathlib.Algebra.Group.Commute.Defs | ∀ {M : Type u_2} [inst : Monoid M] (a : M) (m n : ℕ), Commute (a ^ m) (a ^ n) | true |
Lean.Lsp.Registration.noConfusionType | Lean.Data.Lsp.Client | Sort u → Lean.Lsp.Registration → Lean.Lsp.Registration → Sort u | false |
Int.natAbs_eq_iff | Init.Data.Int.Order | ∀ {a : ℤ} {n : ℕ}, a.natAbs = n ↔ a = ↑n ∨ a = -↑n | true |
MeasureTheory.L1.setToL1'.congr_simp | Mathlib.MeasureTheory.Integral.SetToL1 | ∀ {α : Type u_1} {E : Type u_2} {F : Type u_3} (𝕜 : Type u_6) [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E]
[inst_2 : NormedAddCommGroup F] [inst_3 : NormedSpace ℝ F] {m : MeasurableSpace α} {μ : MeasureTheory.Measure α}
[inst_4 : NormedRing 𝕜] [inst_5 : Module 𝕜 E] [inst_6 : Module 𝕜 F] [inst_7 : IsBoundedSMul 𝕜 E]
[inst_8 : IsBoundedSMul 𝕜 F] [inst_9 : CompleteSpace F] {T T_1 : Set α → E →L[ℝ] F} (e_T : T = T_1) {C C_1 : ℝ}
(e_C : C = C_1) (hT : MeasureTheory.DominatedFinMeasAdditive μ T C)
(h_smul : ∀ (c : 𝕜) (s : Set α) (x : E), (T s) (c • x) = c • (T s) x),
MeasureTheory.L1.setToL1' 𝕜 hT h_smul = MeasureTheory.L1.setToL1' 𝕜 ⋯ ⋯ | true |
MeasureTheory.lpTrimToLpMeasSubgroup._proof_1 | Mathlib.MeasureTheory.Function.ConditionalExpectation.AEMeasurable | ∀ {α : Type u_1} (F : Type u_2) (p : ENNReal) [inst : NormedAddCommGroup F] {m m0 : MeasurableSpace α}
(μ : MeasureTheory.Measure α) (hm : m ≤ m0) (f : ↥(MeasureTheory.Lp F p (μ.trim hm))), MeasureTheory.MemLp (↑↑f) p μ | false |
RootPairing.Base.cartanMatrixIn_mul_diagonal_eq | Mathlib.LinearAlgebra.RootSystem.CartanMatrix | ∀ {ι : Type u_1} {R : Type u_2} {M : Type u_3} {N : Type u_4} [inst : CommRing R] [inst_1 : AddCommGroup M]
[inst_2 : Module R M] [inst_3 : AddCommGroup N] [inst_4 : Module R N] (S : Type u_5) [inst_5 : CommRing S]
[inst_6 : Algebra S R] {P : RootPairing ι R M N} [inst_7 : P.IsRootSystem] [inst_8 : P.IsValuedIn S]
(B : P.InvariantForm) (b : P.Base) [inst_9 : DecidableEq ι],
((RootPairing.Base.cartanMatrixIn S b).map ⇑(algebraMap S R) *
Matrix.diagonal fun i => (B.form (P.root ↑i)) (P.root ↑i)) =
2 • (LinearMap.BilinForm.toMatrix b.toWeightBasis) B.form | true |
Set.Ioi_disjoint_Iio_iff._simp_2 | Mathlib.Order.Interval.Set.Disjoint | ∀ {α : Type v} [inst : Preorder α] {a b : α} [DenselyOrdered α], Disjoint (Set.Ioi a) (Set.Iio b) = ¬a < b | false |
Std.Iterators.Types.FilterMap.ctorIdx | Init.Data.Iterators.Combinators.Monadic.FilterMap | {α β γ : Type w} →
{m : Type w → Type w'} →
{n : Type w → Type w''} →
{lift : ⦃α : Type w⦄ → m α → n α} →
{f : β → Std.Iterators.PostconditionT n (Option γ)} → Std.Iterators.Types.FilterMap α m n lift f → ℕ | false |
Nat.log2_eq_succ_log2_shiftRight | Mathlib.Data.Nat.BinaryRec | ∀ {n : ℕ}, n >>> 1 ≠ 0 → n.log2 = (n >>> 1).log2.succ | true |
CategoryTheory.Abelian.Ext.covariant_sequence_exact₃' | Mathlib.Algebra.Homology.DerivedCategory.Ext.ExactSequences | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Abelian C]
[inst_2 : CategoryTheory.HasExt C] (X : C) {S : CategoryTheory.ShortComplex C} (hS : S.ShortExact) (n₀ n₁ : ℕ)
(h : n₀ + 1 = n₁),
{ X₁ := AddCommGrpCat.of (CategoryTheory.Abelian.Ext X S.X₂ n₀),
X₂ := AddCommGrpCat.of (CategoryTheory.Abelian.Ext X S.X₃ n₀),
X₃ := AddCommGrpCat.of (CategoryTheory.Abelian.Ext X S.X₁ n₁),
f := AddCommGrpCat.ofHom ((CategoryTheory.Abelian.Ext.mk₀ S.g).postcomp X ⋯),
g := AddCommGrpCat.ofHom (hS.extClass.postcomp X h), zero := ⋯ }.Exact | true |
Bimod.RightUnitorBimod.hom_right_act_hom' | Mathlib.CategoryTheory.Monoidal.Bimod | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] [inst_1 : CategoryTheory.MonoidalCategory C]
[inst_2 : CategoryTheory.Limits.HasCoequalizers C] {R S : CategoryTheory.Mon C} (P : Bimod R S)
[inst_3 :
∀ (X : C),
CategoryTheory.Limits.PreservesColimitsOfSize.{0, 0, v₁, v₁, u₁, u₁}
(CategoryTheory.MonoidalCategory.tensorLeft X)]
[inst_4 :
∀ (X : C),
CategoryTheory.Limits.PreservesColimitsOfSize.{0, 0, v₁, v₁, u₁, u₁}
(CategoryTheory.MonoidalCategory.tensorRight X)],
CategoryTheory.CategoryStruct.comp (P.tensorBimod (Bimod.regular S)).actRight (Bimod.RightUnitorBimod.hom P) =
CategoryTheory.CategoryStruct.comp
(CategoryTheory.MonoidalCategoryStruct.whiskerRight (Bimod.RightUnitorBimod.hom P) S.X) P.actRight | true |
_private.Std.Data.Internal.List.Associative.0.Std.Internal.List.getValueCast?_filter_not_contains_of_contains_right._simp_1_1 | Std.Data.Internal.List.Associative | ∀ {α : Sort u_1} {p : Prop} [inst : Decidable p] {x y : α}, ((if p then x else y) = x) = (¬p → y = x) | false |
Filter.instDistribNeg._proof_2 | Mathlib.Order.Filter.Pointwise | ∀ {α : Type u_1} [inst : Mul α] [inst_1 : HasDistribNeg α] (x x_1 : Filter α),
Filter.map₂ (fun x1 x2 => x1 * x2) x (Filter.map Neg.neg x_1) =
Filter.map Neg.neg (Filter.map₂ (fun x1 x2 => x1 * x2) x x_1) | false |
CategoryTheory.LaxBraidedFunctor.hom_ext_iff | Mathlib.CategoryTheory.Monoidal.Braided.Basic | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] [inst_1 : CategoryTheory.MonoidalCategory C]
[inst_2 : CategoryTheory.BraidedCategory C] {D : Type u₂} [inst_3 : CategoryTheory.Category.{v₂, u₂} D]
[inst_4 : CategoryTheory.MonoidalCategory D] [inst_5 : CategoryTheory.BraidedCategory D]
{F G : CategoryTheory.LaxBraidedFunctor C D} {α β : F ⟶ G}, α = β ↔ α.hom.hom = β.hom.hom | true |
CategoryTheory.ShortComplex.RightHomologyMapData.compatibilityOfZerosOfIsColimitCokernelCofork._proof_1 | Mathlib.Algebra.Homology.ShortComplex.RightHomology | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
(S : CategoryTheory.ShortComplex C) (hf : S.f = 0) (hg : S.g = 0) (c : CategoryTheory.Limits.CokernelCofork S.f)
(hc : CategoryTheory.Limits.IsColimit c),
CategoryTheory.CategoryStruct.comp (CategoryTheory.ShortComplex.RightHomologyData.ofZeros S hf hg).p
(CategoryTheory.Limits.Cofork.π c) =
CategoryTheory.CategoryStruct.comp (CategoryTheory.CategoryStruct.id S).τ₂
(CategoryTheory.ShortComplex.RightHomologyData.ofIsColimitCokernelCofork S hg c hc).p | false |
Std.Internal.IsStrictCut.toIsCut | Std.Data.Internal.Cut | ∀ {α : Type u} {cmp : α → α → Ordering} {cut : α → Ordering} [self : Std.Internal.IsStrictCut cmp cut],
Std.Internal.IsCut cmp cut | true |
WellFoundedGT.toIsSuccArchimedean | Mathlib.Order.SuccPred.Archimedean | ∀ {α : Type u_1} [inst : PartialOrder α] [h : WellFoundedGT α] [inst_1 : SuccOrder α], IsSuccArchimedean α | true |
AlgebraicGeometry.Scheme.IdealSheafData.support_bot | Mathlib.AlgebraicGeometry.IdealSheaf.Basic | ∀ {X : AlgebraicGeometry.Scheme}, ⊥.support = ⊤ | true |
Std.ExtHashMap.getElem!_union_of_not_mem_left | Std.Data.ExtHashMap.Lemmas | ∀ {α : Type u} {β : Type v} {x : BEq α} {x_1 : Hashable α} {m₁ m₂ : Std.ExtHashMap α β} [inst : EquivBEq α]
[inst_1 : LawfulHashable α] {k : α} [inst_2 : Inhabited β], k ∉ m₁ → (m₁ ∪ m₂)[k]! = m₂[k]! | true |
ContDiffMapSupportedIn.iteratedFDerivLM_eq_of_scalars | Mathlib.Analysis.Distribution.ContDiffMapSupportedIn | ∀ (𝕜 : Type u_1) {E : Type u_2} {F : Type u_3} [inst : NontriviallyNormedField 𝕜] [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace ℝ E] [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace ℝ F] [inst_5 : NormedSpace 𝕜 F]
[inst_6 : SMulCommClass ℝ 𝕜 F] {n k : ℕ∞} {K : TopologicalSpace.Compacts E} {i : ℕ} (𝕜' : Type u_5)
[inst_7 : NontriviallyNormedField 𝕜'] [inst_8 : NormedSpace 𝕜' F] [inst_9 : SMulCommClass ℝ 𝕜' F],
⇑(ContDiffMapSupportedIn.iteratedFDerivLM 𝕜 n k i) = ⇑(ContDiffMapSupportedIn.iteratedFDerivLM 𝕜' n k i) | true |
AddMonoidHom.le_map_tsub | Mathlib.Algebra.Order.Sub.Unbundled.Hom | ∀ {α : Type u_1} {β : Type u_2} [inst : Preorder α] [inst_1 : AddCommMonoid α] [inst_2 : Sub α] [OrderedSub α]
[inst_4 : Preorder β] [inst_5 : AddZeroClass β] [inst_6 : Sub β] [OrderedSub β] (f : α →+ β),
Monotone ⇑f → ∀ (a b : α), f a - f b ≤ f (a - b) | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.