name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.67M | allowCompletion bool 2
classes |
|---|---|---|---|
Std.LawfulRightIdentity.recOn | Init.Core | {α : Sort u} →
{β : Sort u_1} →
{op : α → β → α} →
{o : β} →
{motive : Std.LawfulRightIdentity op o → Sort u_2} →
(t : Std.LawfulRightIdentity op o) →
([toRightIdentity : Std.RightIdentity op o] → (right_id : ∀ (a : α), op a o = a) → motive ⋯) → motive t | false |
Lean.Server.FileWorker.SemanticTokensState.mk.sizeOf_spec | Lean.Server.FileWorker.SemanticHighlighting | sizeOf { } = 1 | true |
Nat.stirlingFirst_one_right | Mathlib.Combinatorics.Enumerative.Stirling | ∀ (n : ℕ), (n + 1).stirlingFirst 1 = n.factorial | true |
CategoryTheory.GrothendieckTopology.OneHypercover.id_h₁ | Mathlib.CategoryTheory.Sites.Hypercover.One | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {J : CategoryTheory.GrothendieckTopology C} {S : C}
(E : J.OneHypercover S) {i j : E.I₀} (x : E.I₁ i j),
(CategoryTheory.CategoryStruct.id E).h₁ x = CategoryTheory.CategoryStruct.id (E.Y x) | true |
ModuleCat.instModuleCarrierMkOfSMul' | Mathlib.Algebra.Category.ModuleCat.Basic | {R : Type u} →
[inst : Ring R] → {A : AddCommGrpCat} → (φ : R →+* CategoryTheory.End A) → Module R ↑(ModuleCat.mkOfSMul' φ) | true |
_private.Mathlib.Analysis.SpecialFunctions.Pow.Asymptotics.0.isLittleO_exp_neg_mul_rpow_atTop._simp_1_6 | Mathlib.Analysis.SpecialFunctions.Pow.Asymptotics | ∀ {G₀ : Type u_3} [inst : GroupWithZero G₀] {a : G₀} (n : ℤ), a ≠ 0 → (a ^ n = 0) = False | false |
_private.Lean.Meta.Basic.0.Lean.Meta.realizeValue.match_7 | Lean.Meta.Basic | (motive : Option Lean.Meta.RealizeValueResult✝ → Sort u_1) →
(x : Option Lean.Meta.RealizeValueResult✝¹) →
((res : Lean.Meta.RealizeValueResult✝²) → motive (some res)) →
((x : Option Lean.Meta.RealizeValueResult✝³) → motive x) → motive x | false |
Nat.Linear.ExprCnstr.denote_toPoly | Init.Data.Nat.Linear | ∀ (ctx : Nat.Linear.Context) (c : Nat.Linear.ExprCnstr),
Nat.Linear.PolyCnstr.denote ctx c.toPoly = Nat.Linear.ExprCnstr.denote ctx c | true |
HeytAlg.Hom.recOn | Mathlib.Order.Category.HeytAlg | {X Y : HeytAlg} →
{motive : X.Hom Y → Sort u_1} → (t : X.Hom Y) → ((hom' : HeytingHom ↑X ↑Y) → motive { hom' := hom' }) → motive t | false |
Aesop.Options'.ctorIdx | Aesop.Options.Internal | Aesop.Options' → ℕ | false |
_private.Mathlib.Data.ENNReal.Basic.0.ENNReal.iUnion_Ioo_coe_nat._simp_1_1 | Mathlib.Data.ENNReal.Basic | ∀ {α : Type u_1} [inst : Preorder α] {a b : α}, Set.Ioo a b = Set.Ioi a ∩ Set.Iio b | false |
_private.Mathlib.Tactic.Linarith.Verification.0.Mathlib.Tactic.Linarith.mkLTZeroProof.match_1 | Mathlib.Tactic.Linarith.Verification | (motive : List (Lean.Expr × ℕ) → Sort u_1) →
(x : List (Lean.Expr × ℕ)) →
(Unit → motive []) →
((h : Lean.Expr) → (c : ℕ) → motive [(h, c)]) →
((h : Lean.Expr) → (c : ℕ) → (t : List (Lean.Expr × ℕ)) → motive ((h, c) :: t)) → motive x | false |
Lean.Meta.Grind.AC.getOpId | Lean.Meta.Tactic.Grind.AC.Util | Lean.Meta.Grind.AC.ACM ℕ | true |
Multiset.singleton_inj | Mathlib.Data.Multiset.ZeroCons | ∀ {α : Type u_1} {a b : α}, {a} = {b} ↔ a = b | true |
Lean.Lsp.instToJsonWorkspaceClientCapabilities | Lean.Data.Lsp.Capabilities | Lean.ToJson Lean.Lsp.WorkspaceClientCapabilities | true |
IsBoundedBilinearMap.isBigO' | Mathlib.Analysis.Normed.Operator.BoundedLinearMaps | ∀ {𝕜 : Type u_1} {E : Type u_2} {F : Type u_3} {G : Type u_4} [inst : Semiring 𝕜] [inst_1 : SeminormedAddCommGroup E]
[inst_2 : Module 𝕜 E] [inst_3 : SeminormedAddCommGroup F] [inst_4 : Module 𝕜 F] [inst_5 : SeminormedAddCommGroup G]
[inst_6 : Module 𝕜 G] {f : E × F → G}, IsBoundedBilinearMap 𝕜 f → f =O[⊤] fun p => ‖p‖ * ‖p‖ | true |
_private.Mathlib.NumberTheory.LSeries.Nonvanishing.0.DirichletCharacter.one_lt_re_one_add | Mathlib.NumberTheory.LSeries.Nonvanishing | ∀ {x : ℝ}, 0 < x → ∀ (y : ℝ), 1 < (1 + ↑x).re ∧ 1 < (1 + ↑x + Complex.I * ↑y).re ∧ 1 < (1 + ↑x + 2 * Complex.I * ↑y).re | true |
_private.Init.Data.String.Iterator.0.String.Legacy.Iterator.hasNext.eq_1 | Init.Data.String.Iterator | ∀ (s : String) (i : String.Pos.Raw), { s := s, i := i }.hasNext = decide (i.byteIdx < s.rawEndPos.byteIdx) | true |
_private.Mathlib.Tactic.Simps.Basic.0.Lean.Meta.mkSimpContextResult._sparseCasesOn_1 | Mathlib.Tactic.Simps.Basic | {motive : Lean.Elab.Tactic.Simp.DischargeWrapper → Sort u} →
(t : Lean.Elab.Tactic.Simp.DischargeWrapper) →
motive Lean.Elab.Tactic.Simp.DischargeWrapper.default → (Nat.hasNotBit 1 t.ctorIdx → motive t) → motive t | false |
IsSemitopologicalSemiring.continuousNeg_of_mul | Mathlib.Topology.Algebra.Ring.Basic | ∀ {R : Type u_1} [inst : TopologicalSpace R] [inst_1 : NonAssocRing R] [SeparatelyContinuousMul R], ContinuousNeg R | true |
PowerSeries.coe_orderHom | Mathlib.RingTheory.PowerSeries.Order | ∀ {R : Type u_1} [inst : Semiring R] [inst_1 : NoZeroDivisors R] [inst_2 : Nontrivial R],
⇑PowerSeries.orderHom = PowerSeries.order | true |
Finset.Ico_diff_Ico_left | Mathlib.Order.Interval.Finset.Basic | ∀ {α : Type u_2} [inst : LinearOrder α] [inst_1 : LocallyFiniteOrder α] (a b c : α),
Finset.Ico a b \ Finset.Ico a c = Finset.Ico (max a c) b | true |
_private.Batteries.Data.List.Lemmas.0.List.getElem_filter_eq_getElem_getElem_findIdxs_sub._proof_1_49 | Batteries.Data.List.Lemmas | ∀ {α : Type u_1} {p : α → Bool} (head : α) (tail : List α),
(∀ {i : ℕ} (s : ℕ) (h : i < (List.filter p tail).length),
(List.filter p tail)[i] = tail[(List.findIdxs p tail s)[i] - s]) →
∀ {i : ℕ} (s : ℕ) (h : i < (List.filter p (head :: tail)).length),
(List.findIdxs p (head :: tail) s)[i] - s + 1 ≤ (head :: tail).length →
¬p head = true → 0 < (List.filter p tail).length | false |
CategoryTheory.ShortComplex.exact_of_f_is_kernel | Mathlib.Algebra.Homology.ShortComplex.Exact | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Preadditive C]
(S : CategoryTheory.ShortComplex C) (hS : CategoryTheory.Limits.IsLimit (CategoryTheory.Limits.KernelFork.ofι S.f ⋯))
[S.HasHomology], S.Exact | true |
CoxeterSystem.map_simple | Mathlib.GroupTheory.Coxeter.Basic | ∀ {B : Type u_1} {W : Type u_3} {H : Type u_4} [inst : Group W] [inst_1 : Group H] {M : CoxeterMatrix B}
(cs : CoxeterSystem M W) (e : W ≃* H) (i : B), (cs.map e).simple i = e (cs.simple i) | true |
ENNReal.mul_inv_le_one | Mathlib.Data.ENNReal.Inv | ∀ (a : ENNReal), a * a⁻¹ ≤ 1 | true |
_private.Mathlib.RingTheory.Ideal.Height.0.Ideal.height_bot._simp_1_2 | Mathlib.RingTheory.Ideal.Height | ∀ {ι : Sort u_1} {f : ι → ℕ∞}, (⨅ i, f i = 0) = ∃ i, f i = 0 | false |
Std.DHashMap.Raw.Const.get_unitOfList | Std.Data.DHashMap.RawLemmas | ∀ {α : Type u} [inst : BEq α] [inst_1 : Hashable α] {l : List α} {k : α} {h : k ∈ Std.DHashMap.Raw.Const.unitOfList l},
Std.DHashMap.Raw.Const.get (Std.DHashMap.Raw.Const.unitOfList l) k h = () | true |
WeierstrassCurve._sizeOf_1 | Mathlib.AlgebraicGeometry.EllipticCurve.Weierstrass | {R : Type u} → [SizeOf R] → WeierstrassCurve R → ℕ | false |
Codisjoint.eq_top_of_le | Mathlib.Order.Disjoint | ∀ {α : Type u_1} [inst : PartialOrder α] [inst_1 : OrderTop α] {a b : α}, Codisjoint a b → b ≤ a → a = ⊤ | true |
Array.find?_range_eq_some._simp_1 | Init.Data.Array.Range | ∀ {n i : ℕ} {p : ℕ → Bool},
(Array.find? p (Array.range n) = some i) = (p i = true ∧ i ∈ Array.range n ∧ ∀ j < i, (!p j) = true) | false |
CategoryTheory.NatTrans.IsMonoidal.hcomp | Mathlib.CategoryTheory.Monoidal.NaturalTransformation | ∀ {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.MonoidalCategory D] {E : Type u₃}
[inst_4 : CategoryTheory.Category.{v₃, u₃} E] [inst_5 : CategoryTheory.MonoidalCategory E]
{F₁ F₂ : CategoryTheory.Functor C D} (τ : F₁ ⟶ F₂) [inst_6 : F₁.LaxMonoidal] [inst_7 : F₂.LaxMonoidal]
{G₁ G₂ : CategoryTheory.Functor D E} [inst_8 : G₁.LaxMonoidal] [inst_9 : G₂.LaxMonoidal] (τ' : G₁ ⟶ G₂)
[CategoryTheory.NatTrans.IsMonoidal τ] [CategoryTheory.NatTrans.IsMonoidal τ'],
CategoryTheory.NatTrans.IsMonoidal (τ ◫ τ') | true |
Aesop.Script.LazyStep.postGoals | Aesop.Script.Step | Aesop.Script.LazyStep → Array Lean.MVarId | true |
ContinuousMap.instSemigroupWithZeroOfContinuousMul | Mathlib.Topology.ContinuousMap.Algebra | {α : Type u_1} →
{β : Type u_2} →
[inst : TopologicalSpace α] →
[inst_1 : TopologicalSpace β] → [inst_2 : SemigroupWithZero β] → [ContinuousMul β] → SemigroupWithZero C(α, β) | true |
IsLocalizedModule.map_surjective._simp_1 | Mathlib.Algebra.Module.LocalizedModule.Basic | ∀ {R : Type u_1} [inst : CommSemiring R] (S : Submonoid R) {M : Type u_2} {M' : Type u_3} [inst_1 : AddCommMonoid M]
[inst_2 : AddCommMonoid M'] [inst_3 : Module R M] [inst_4 : Module R M'] (f : M →ₗ[R] M')
[inst_5 : IsLocalizedModule S f] {N : Type u_6} {N' : Type u_7} [inst_6 : AddCommMonoid N] [inst_7 : AddCommMonoid N']
[inst_8 : Module R N] [inst_9 : Module R N'] (g : N →ₗ[R] N') [inst_10 : IsLocalizedModule S g] (h : M →ₗ[R] N),
Function.Surjective ⇑h → Function.Surjective ⇑((IsLocalizedModule.map S f g) h) = True | false |
IsPrimitiveRoot.integralPowerBasisOfPrimePow.eq_1 | Mathlib.NumberTheory.NumberField.Cyclotomic.Basic | ∀ {p k : ℕ} {K : Type u} [inst : Field K] {ζ : K} [hp : Fact (Nat.Prime p)] [inst_1 : CharZero K]
[inst_2 : IsCyclotomicExtension {p ^ k} ℚ K] (hζ : IsPrimitiveRoot ζ (p ^ k)),
hζ.integralPowerBasisOfPrimePow = (Algebra.adjoin.powerBasis' ⋯).map hζ.adjoinEquivRingOfIntegersOfPrimePow | true |
_private.Mathlib.CategoryTheory.WithTerminal.Cone.0.CategoryTheory.WithTerminal.id.match_1.eq_1 | Mathlib.CategoryTheory.WithTerminal.Cone | ∀ {C : Type u_1} (motive : CategoryTheory.WithTerminal C → Sort u_2) (a : C)
(h_1 : (a : C) → motive (CategoryTheory.WithTerminal.of a)) (h_2 : Unit → motive CategoryTheory.WithTerminal.star),
(match CategoryTheory.WithTerminal.of a with
| CategoryTheory.WithTerminal.of a => h_1 a
| CategoryTheory.WithTerminal.star => h_2 ()) =
h_1 a | true |
Tree.brecOn.go | Mathlib.Data.Tree.Basic | {α : Type u} →
{motive : Tree α → Sort u_1} → (t : Tree α) → ((t : Tree α) → Tree.below t → motive t) → motive t ×' Tree.below t | true |
Subgroup.commutator | Mathlib.GroupTheory.Commutator.Basic | {G : Type u_1} → [inst : Group G] → Bracket (Subgroup G) (Subgroup G) | true |
Submodule.tensorSpanEquivSpan._proof_1 | Mathlib.LinearAlgebra.Span.TensorProduct | ∀ (A : Type u_1) [inst : CommSemiring A], RingHomCompTriple (RingHom.id A) (RingHom.id A) (RingHom.id A) | false |
ContinuousLinearMap.opNNNorm_mul_flip_apply | Mathlib.Analysis.CStarAlgebra.Unitization | ∀ (𝕜 : Type u_1) {E : Type u_2} [inst : NontriviallyNormedField 𝕜] [inst_1 : NonUnitalNormedRing E]
[inst_2 : StarRing E] [NormedStarGroup E] [inst_4 : NormedSpace 𝕜 E] [inst_5 : IsScalarTower 𝕜 E E]
[inst_6 : SMulCommClass 𝕜 E E] [RegularNormedAlgebra 𝕜 E] (a : E), ‖(ContinuousLinearMap.mul 𝕜 E).flip a‖₊ = ‖a‖₊ | true |
_private.Mathlib.Topology.Sets.VietorisTopology.0.TopologicalSpace.IsTopologicalBasis.compacts._proof_1_12 | Mathlib.Topology.Sets.VietorisTopology | ∀ {α : Type u_1} [inst : TopologicalSpace α] (K : TopologicalSpace.Compacts α) (w : Set (Set α)),
(¬∀ W ∈ w, (↑K ∩ W).Nonempty) → ∀ W ∈ {W | W ∈ w ∧ (↑K ∩ W).Nonempty}, (↑K ∩ W).Nonempty | false |
Mathlib.Tactic.Bicategory.StructuralOfExpr_bicategoricalComp | Mathlib.Tactic.CategoryTheory.Bicategory.Datatypes | ∀ {B : Type u} [inst : CategoryTheory.Bicategory B] {a b : B} {f g h i : a ⟶ b}
[inst_1 : CategoryTheory.BicategoricalCoherence g h] (η : f ⟶ g) (η' : f ≅ g),
η'.hom = η →
∀ (θ : h ⟶ i) (θ' : h ≅ i),
θ'.hom = θ → (CategoryTheory.bicategoricalIsoComp η' θ').hom = CategoryTheory.bicategoricalComp η θ | true |
_private.Lean.Compiler.LCNF.JoinPoints.0.Lean.Compiler.LCNF.JoinPointContextExtender.extend.go._unsafe_rec | Lean.Compiler.LCNF.JoinPoints | Lean.Compiler.LCNF.Code Lean.Compiler.LCNF.Purity.pure →
Lean.Compiler.LCNF.JoinPointContextExtender.ExtendM (Lean.Compiler.LCNF.Code Lean.Compiler.LCNF.Purity.pure) | false |
CategoryTheory.ObjectProperty.tStructure._proof_8 | Mathlib.CategoryTheory.Triangulated.TStructure.Induced | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.Preadditive C]
[inst_2 : CategoryTheory.Limits.HasZeroObject C] [inst_3 : CategoryTheory.HasShift C ℤ]
[inst_4 : ∀ (n : ℤ), (CategoryTheory.shiftFunctor C n).Additive] [inst_5 : CategoryTheory.Pretriangulated C]
(P : CategoryTheory.ObjectProperty C) (t : CategoryTheory.Triangulated.TStructure C) [inst_6 : P.IsTriangulated]
(n a n' : ℤ),
a + n' = n →
∀ (X : P.FullSubcategory), t.ge n X.obj → t.ge n' ((CategoryTheory.shiftFunctor P.FullSubcategory a).obj X).obj | false |
HomogeneousLocalization.NumDenSameDeg.instCommMonoid._proof_5 | Mathlib.RingTheory.GradedAlgebra.HomogeneousLocalization | ∀ {ι : Type u_1} {A : Type u_2} {σ : Type u_3} [inst : CommRing A] [inst_1 : SetLike σ A]
[inst_2 : AddSubmonoidClass σ A] {𝒜 : ι → σ} (x : Submonoid A) [inst_3 : AddCommMonoid ι] [inst_4 : DecidableEq ι]
[inst_5 : GradedRing 𝒜] (x_1 : HomogeneousLocalization.NumDenSameDeg 𝒜 x), x_1 * 1 = x_1 | false |
Rack.toEnvelGroup.mapAux.eq_2 | Mathlib.Algebra.Quandle | ∀ {R : Type u_1} [inst : Rack R] {G : Type u_2} [inst_1 : Group G] (f : ShelfHom R (Quandle.Conj G)) (x_1 : R),
Rack.toEnvelGroup.mapAux f (Rack.PreEnvelGroup.incl x_1) = f x_1 | true |
ContinuousMonoidHom.mk._flat_ctor | Mathlib.Topology.Algebra.ContinuousMonoidHom | {A : Type u_2} →
{B : Type u_3} →
[inst : Monoid A] →
[inst_1 : Monoid B] →
[inst_2 : TopologicalSpace A] →
[inst_3 : TopologicalSpace B] →
(toFun : A → B) →
toFun 1 = 1 →
(∀ (x y : A), toFun (x * y) = toFun x * toFun y) →
autoParam (Continuous toFun) ContinuousMap.continuous_toFun._autoParam → A →ₜ* B | false |
_private.Mathlib.Combinatorics.Matroid.Rank.Cardinal.0.Matroid.rankFinite_iff_cRank_lt_aleph0.match_1_1 | Mathlib.Combinatorics.Matroid.Rank.Cardinal | ∀ {α : Type u_1} {M : Matroid α} (motive : M.RankFinite → Prop) (h : M.RankFinite),
(∀ (B : Set α) (hB : M.IsBase B) (fin : B.Finite), motive ⋯) → motive h | false |
ProbabilityTheory.covarianceBilinDual_apply | Mathlib.Probability.Moments.CovarianceBilinDual | ∀ {E : Type u_1} [inst : NormedAddCommGroup E] {mE : MeasurableSpace E} {μ : MeasureTheory.Measure E}
[inst_1 : NormedSpace ℝ E] [inst_2 : BorelSpace E] [CompleteSpace E] [MeasureTheory.IsFiniteMeasure μ],
MeasureTheory.MemLp id 2 μ →
∀ (L₁ L₂ : StrongDual ℝ E),
((ProbabilityTheory.covarianceBilinDual μ) L₁) L₂ =
∫ (x : E), (L₁ x - ∫ (x : E), L₁ x ∂μ) * (L₂ x - ∫ (x : E), L₂ x ∂μ) ∂μ | true |
StateTransition.EvalsTo.mk | Mathlib.Computability.StateTransition | {σ : Type u_1} →
{f : σ → Option σ} →
{a : σ} → {b : Option σ} → (steps : ℕ) → (flip bind f)^[steps] (some a) = b → StateTransition.EvalsTo f a b | true |
Real.nonempty_algEquiv_or | Mathlib.Analysis.Complex.Polynomial.Basic | ∀ (F : Type u_1) [inst : Field F] [inst_1 : Algebra ℝ F] [Algebra.IsAlgebraic ℝ F],
Nonempty (F ≃ₐ[ℝ] ℝ) ∨ Nonempty (F ≃ₐ[ℝ] ℂ) | true |
deriv_fun_mul | Mathlib.Analysis.Calculus.Deriv.Mul | ∀ {𝕜 : Type u} [inst : NontriviallyNormedField 𝕜] {x : 𝕜} {𝔸 : Type u_3} [inst_1 : NormedRing 𝔸]
[inst_2 : NormedAlgebra 𝕜 𝔸] {c d : 𝕜 → 𝔸},
DifferentiableAt 𝕜 c x → DifferentiableAt 𝕜 d x → deriv (fun y => c y * d y) x = deriv c x * d x + c x * deriv d x | true |
TopCat.Presheaf.SheafConditionPairwiseIntersections.coneEquivUnitIsoApp | Mathlib.Topology.Sheaves.SheafCondition.EqualizerProducts | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
[inst_1 : CategoryTheory.Limits.HasProducts C] →
{X : TopCat} →
(F : TopCat.Presheaf C X) →
{ι : Type v'} →
(U : ι → TopologicalSpace.Opens ↑X) →
(c : CategoryTheory.Limits.Cone ((CategoryTheory.Pairwise.diagram U).op.comp F)) →
(CategoryTheory.Functor.id
(CategoryTheory.Limits.Cone ((CategoryTheory.Pairwise.diagram U).op.comp F))).obj
c ≅
((TopCat.Presheaf.SheafConditionPairwiseIntersections.coneEquivFunctor F U).comp
(TopCat.Presheaf.SheafConditionPairwiseIntersections.coneEquivInverse F U)).obj
c | true |
Graph.IsSubgraph.isLoopAt_congr | Mathlib.Combinatorics.Graph.Subgraph | ∀ {α : Type u_1} {β : Type u_2} {x : α} {e : β} {G H : Graph α β},
H ≤ G → e ∈ H.edgeSet → (H.IsLoopAt e x ↔ G.IsLoopAt e x) | true |
_private.Std.Data.DHashMap.Internal.RawLemmas.0.Std.DHashMap.Internal.Raw₀.Const.mem_toArray_iff_get?_eq_some._simp_1_1 | Std.Data.DHashMap.Internal.RawLemmas | ∀ {α : Type u} {β : Type v} (m : Std.DHashMap.Internal.Raw₀ α fun x => β),
Std.DHashMap.Raw.Const.toArray ↑m = (Std.DHashMap.Raw.Const.toList ↑m).toArray | false |
Aesop.Script.LazyStep.tacticBuilders_ne._autoParam | Aesop.Script.Step | Lean.Syntax | false |
CategoryTheory.NonPreadditiveAbelian.monoIsKernelOfCokernel | Mathlib.CategoryTheory.Abelian.NonPreadditive | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
[inst_1 : CategoryTheory.NonPreadditiveAbelian C] →
{X Y : C} →
{f : X ⟶ Y} →
[CategoryTheory.Mono f] →
(s : CategoryTheory.Limits.Cofork f 0) →
CategoryTheory.Limits.IsColimit s →
CategoryTheory.Limits.IsLimit (CategoryTheory.Limits.KernelFork.ofι f ⋯) | true |
Set.mul_subset_mul | Mathlib.Algebra.Group.Pointwise.Set.Basic | ∀ {α : Type u_2} [inst : Mul α] {s₁ s₂ t₁ t₂ : Set α}, s₁ ⊆ t₁ → s₂ ⊆ t₂ → s₁ * s₂ ⊆ t₁ * t₂ | true |
CategoryTheory.Functor.CoreMonoidal.toOplaxMonoidal._proof_4 | Mathlib.CategoryTheory.Monoidal.Functor | ∀ {C : Type u_4} [inst : CategoryTheory.Category.{u_3, u_4} C] [inst_1 : CategoryTheory.MonoidalCategory C]
{D : Type u_2} [inst_2 : CategoryTheory.Category.{u_1, u_2} D] [inst_3 : CategoryTheory.MonoidalCategory D]
{F : CategoryTheory.Functor C D} (h : F.CoreMonoidal) (x : C),
(CategoryTheory.MonoidalCategoryStruct.leftUnitor (F.obj x)).inv =
CategoryTheory.CategoryStruct.comp (F.map (CategoryTheory.MonoidalCategoryStruct.leftUnitor x).inv)
(CategoryTheory.CategoryStruct.comp (h.μIso (CategoryTheory.MonoidalCategoryStruct.tensorUnit C) x).inv
(CategoryTheory.MonoidalCategoryStruct.whiskerRight h.εIso.inv (F.obj x))) | false |
_private.Mathlib.Topology.Semicontinuity.Hemicontinuity.0.lowerHemicontinuous_iff_isOpen_compl_preimage_Iic_compl._simp_1_6 | Mathlib.Topology.Semicontinuity.Hemicontinuity | ∀ {X : Type u} [inst : TopologicalSpace X] {s : Set X}, IsOpen s = ∀ x ∈ s, s ∈ nhds x | false |
Function.Even.eq_1 | Mathlib.Analysis.Fourier.ZMod | ∀ {α : Type u_1} {β : Type u_2} [inst : Neg α] (f : α → β), Function.Even f = ∀ (a : α), f (-a) = f a | true |
SupHom.copy._proof_1 | Mathlib.Order.Hom.Lattice | ∀ {α : Type u_2} {β : Type u_1} [inst : Max α] [inst_1 : Max β] (f : SupHom α β) (f' : α → β),
f' = ⇑f → ∀ (a b : α), f' (a ⊔ b) = f' a ⊔ f' b | false |
SignType.LE | Mathlib.Data.Sign.Defs | SignType → SignType → Prop | true |
Tree.numNodes._sunfold | Mathlib.Data.Tree.Basic | {α : Type u} → Tree α → ℕ | false |
_private.Mathlib.Analysis.InnerProductSpace.Rayleigh.0.ContinuousLinearMap.bddAbove_rayleighQuotient.match_1_1 | Mathlib.Analysis.InnerProductSpace.Rayleigh | ∀ {𝕜 : Type u_2} [inst : RCLike 𝕜] {E : Type u_1} [inst_1 : NormedAddCommGroup E] [inst_2 : InnerProductSpace 𝕜 E]
(T : E →L[𝕜] E) (x : ℝ) (motive : (x ∈ Set.range fun x => |T.rayleighQuotient x|) → Prop)
(x_1 : x ∈ Set.range fun x => |T.rayleighQuotient x|),
(∀ (y : E) (h : (fun x => |T.rayleighQuotient x|) y = x), motive ⋯) → motive x_1 | false |
Profinite.toCompHaus.reflective._proof_2 | Mathlib.Topology.Category.Profinite.Basic | (CompHausLike.toCompHausLike Profinite.toCompHaus.reflective._proof_1).Full | false |
Lean.Meta.reduceNatNativeUnsafe | Lean.Meta.WHNF | Lean.Name → Lean.MetaM ℕ | true |
Matrix.Pivot.reindex_exists_list_transvec_mul_mul_list_transvec_eq_diagonal | Mathlib.LinearAlgebra.Matrix.Transvection | ∀ {n : Type u_1} {p : Type u_2} {𝕜 : Type u_3} [inst : Field 𝕜] [inst_1 : DecidableEq n] [inst_2 : DecidableEq p]
[inst_3 : Fintype n] [inst_4 : Fintype p] (M : Matrix p p 𝕜) (e : p ≃ n),
(∃ L L' D,
(List.map Matrix.TransvectionStruct.toMatrix L).prod * (Matrix.reindexAlgEquiv 𝕜 𝕜 e) M *
(List.map Matrix.TransvectionStruct.toMatrix L').prod =
Matrix.diagonal D) →
∃ L L' D,
(List.map Matrix.TransvectionStruct.toMatrix L).prod * M * (List.map Matrix.TransvectionStruct.toMatrix L').prod =
Matrix.diagonal D | true |
Matrix.discr | Mathlib.LinearAlgebra.Matrix.Charpoly.Disc | {R : Type u_1} → {n : Type u_2} → [CommRing R] → [Fintype n] → [DecidableEq n] → Matrix n n R → R | true |
CategoryTheory.Pseudofunctor.whiskerLeft_mapId_hom | Mathlib.CategoryTheory.Bicategory.Functor.Pseudofunctor | ∀ {B : Type u₁} [inst : CategoryTheory.Bicategory B] {C : Type u₂} [inst_1 : CategoryTheory.Bicategory C]
(F : CategoryTheory.Pseudofunctor B C) {a b : B} (f : a ⟶ b),
CategoryTheory.Bicategory.whiskerLeft (F.map f) (F.mapId b).hom =
CategoryTheory.CategoryStruct.comp (F.mapComp f (CategoryTheory.CategoryStruct.id b)).inv
(CategoryTheory.CategoryStruct.comp (F.map₂ (CategoryTheory.Bicategory.rightUnitor f).hom)
(CategoryTheory.Bicategory.rightUnitor (F.map f)).inv) | true |
Monoid.Coprod.swap_bijective | Mathlib.GroupTheory.Coprod.Basic | ∀ {M : Type u_1} {N : Type u_2} [inst : MulOneClass M] [inst_1 : MulOneClass N],
Function.Bijective ⇑(Monoid.Coprod.swap M N) | true |
IsLeftCancelMul.mk | Mathlib.Algebra.Group.Defs | ∀ {G : Type u} [inst : Mul G], (∀ (a : G), IsLeftRegular a) → IsLeftCancelMul G | true |
Associates.instCommMonoid._proof_4 | Mathlib.Algebra.GroupWithZero.Associated | ∀ {M : Type u_1} [inst : CommMonoid M] (a : M), ⟦1 * a⟧ = ⟦a⟧ | false |
Set.inv_smul_set_distrib₀ | Mathlib.Algebra.GroupWithZero.Action.Pointwise.Set | ∀ {α : Type u_1} [inst : GroupWithZero α] (a : α) (s : Set α), (a • s)⁻¹ = MulOpposite.op a⁻¹ • s⁻¹ | true |
DFA.recOn | Mathlib.Computability.DFA | {α : Type u} →
{σ : Type v} →
{motive : DFA α σ → Sort u_1} →
(t : DFA α σ) →
((step : σ → α → σ) →
(start : σ) → (accept : Set σ) → motive { step := step, start := start, accept := accept }) →
motive t | false |
_private.Mathlib.RingTheory.Extension.Cotangent.Basis.0.Algebra.Generators.PresentationOfFreeCotangent.Aux.span_range_mk_kerGen | Mathlib.RingTheory.Extension.Cotangent.Basis | ∀ {R : Type u_1} {S : Type u_2} [inst : CommRing R] [inst_1 : CommRing S] [inst_2 : Algebra R S] {ι : Type u_4}
{P : Algebra.Generators R S ι} {σ : Type u_5} {b : Module.Basis σ S P.toExtension.Cotangent}
(D : Algebra.Generators.PresentationOfFreeCotangent.Aux✝ P b),
Submodule.span (Algebra.Generators.PresentationOfFreeCotangent.Aux.T✝ D)
(Set.range fun i =>
Algebra.Extension.Cotangent.mk (Algebra.Generators.PresentationOfFreeCotangent.Aux.kerGen✝ D i)) =
⊤ | true |
Fin.partialProd_succ' | Mathlib.Algebra.BigOperators.Fin | ∀ {M : Type u_2} [inst : Monoid M] {n : ℕ} (f : Fin (n + 1) → M) (j : Fin (n + 1)),
Fin.partialProd f j.succ = f 0 * Fin.partialProd (Fin.tail f) j | true |
Heyting.Regular.toRegular._proof_1 | Mathlib.Order.Heyting.Regular | ∀ {α : Type u_1} [inst : HeytingAlgebra α] (a : α), Heyting.IsRegular aᶜᶜ | false |
RatFunc.valuationIdeal._proof_2 | Mathlib.NumberTheory.RatFunc.Ostrowski | ∀ {K : Type u_1} {Γ : Type u_2} [inst : Field K] [inst_1 : LinearOrderedCommGroupWithZero Γ]
{v : Valuation (RatFunc K) Γ} [inst_2 : v.IsNontrivial] [inst_3 : Valuation.IsTrivialOn K v] (hle : v RatFunc.X ≤ 1),
Polynomial K ∙ RatFunc.uniformizingPolynomial hle ≠ ⊥ | false |
SecondCountableTopology.recOn | Mathlib.Topology.Bases | {α : Type u} →
[t : TopologicalSpace α] →
{motive : SecondCountableTopology α → Sort u_1} →
(t_1 : SecondCountableTopology α) →
((is_open_generated_countable : ∃ b, b.Countable ∧ t = TopologicalSpace.generateFrom b) → motive ⋯) → motive t_1 | false |
Vector.set_append | Init.Data.Vector.Lemmas | ∀ {α : Type u_1} {n m : ℕ} {xs : Vector α n} {ys : Vector α m} {i : ℕ} {x : α} (h : i < n + m),
(xs ++ ys).set i x h = if h' : i < n then xs.set i x h' ++ ys else xs ++ ys.set (i - n) x ⋯ | true |
CategoryTheory.IsVanKampenColimit.map_reflective | Mathlib.CategoryTheory.Limits.VanKampen | ∀ {J : Type v'} [inst : CategoryTheory.Category.{u', v'} J] {C : Type u} [inst_1 : CategoryTheory.Category.{v, u} C]
{D : Type u_2} [inst_2 : CategoryTheory.Category.{v_2, u_2} D] [CategoryTheory.Limits.HasColimitsOfShape J C]
{Gl : CategoryTheory.Functor C D} {Gr : CategoryTheory.Functor D C} (adj : Gl ⊣ Gr) [Gr.Full] [Gr.Faithful]
{F : CategoryTheory.Functor J D} {c : CategoryTheory.Limits.Cocone (F.comp Gr)},
CategoryTheory.IsVanKampenColimit c →
∀ [∀ (X : D) (f : X ⟶ Gl.obj c.pt), CategoryTheory.Limits.HasPullback (Gr.map f) (adj.unit.app c.pt)]
[∀ (X : D) (f : X ⟶ Gl.obj c.pt),
CategoryTheory.Limits.PreservesLimit (CategoryTheory.Limits.cospan (Gr.map f) (adj.unit.app c.pt)) Gl]
[∀ (X : C) (i : J) (f : X ⟶ c.pt),
CategoryTheory.Limits.PreservesLimit (CategoryTheory.Limits.cospan f (c.ι.app i)) Gl],
CategoryTheory.IsVanKampenColimit (Gl.mapCocone c) | true |
_private.Std.Data.DTreeMap.Internal.Lemmas.0.Std.DTreeMap.Internal.Impl.isSome_maxKey?_of_isSome_maxKey?_erase._simp_1_3 | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {β : α → Type v} {x : Ord α} {t : Std.DTreeMap.Internal.Impl α β} {k : α},
(k ∈ t) = (Std.DTreeMap.Internal.Impl.contains k t = true) | false |
TopologicalSpace.Compacts.isometry_toCloseds | Mathlib.Topology.MetricSpace.Closeds | ∀ {α : Type u_1} [inst : EMetricSpace α], Isometry TopologicalSpace.Compacts.toCloseds | true |
EisensteinSeries.gammaSetEquiv._proof_4 | Mathlib.NumberTheory.ModularForms.EisensteinSeries.Defs | ∀ {N r : ℕ} (a : Fin 2 → ZMod N) [inst : NeZero r] (γ : Matrix.SpecialLinearGroup (Fin 2) ℤ)
(v :
↑(EisensteinSeries.gammaSet N r (Matrix.vecMul a ↑((Matrix.SpecialLinearGroup.map (Int.castRingHom (ZMod N))) γ)))),
(fun v => ⟨Matrix.vecMul ↑v ↑γ, ⋯⟩) ((fun v => ⟨Matrix.vecMul ↑v ↑γ⁻¹, ⋯⟩) v) = v | false |
Mathlib.Meta.Positivity.pos_of_isNNRat | Mathlib.Tactic.Positivity.Core | ∀ {A : Type u_1} {e : A} {n d : ℕ} [inst : Semiring A] [inst_1 : LinearOrder A] [IsStrictOrderedRing A],
Mathlib.Meta.NormNum.IsNNRat e n d → decide (0 < n) = true → 0 < e | true |
Lean.Meta.ReduceMatcherResult.casesOn | Lean.Meta.WHNF | {motive : Lean.Meta.ReduceMatcherResult → Sort u} →
(t : Lean.Meta.ReduceMatcherResult) →
((val : Lean.Expr) → motive (Lean.Meta.ReduceMatcherResult.reduced val)) →
((val : Lean.Expr) → motive (Lean.Meta.ReduceMatcherResult.stuck val)) →
motive Lean.Meta.ReduceMatcherResult.notMatcher → motive Lean.Meta.ReduceMatcherResult.partialApp → motive t | false |
OpenPartialHomeomorph.singletonChartedSpace._proof_2 | Mathlib.Geometry.Manifold.HasGroupoid | ∀ {H : Type u_1} [inst : TopologicalSpace H] {α : Type u_2} [inst_1 : TopologicalSpace α]
(e : OpenPartialHomeomorph α H), e ∈ {e} | false |
ContinuousCohomology.homogeneousCochains._proof_3 | Mathlib.Algebra.Category.ContinuousCohomology.Basic | (ComplexShape.embeddingUp'Add 1 1).IsRelIff | false |
OpenPartialHomeomorph.coe_ofContinuousOpen | Mathlib.Topology.OpenPartialHomeomorph.Basic | ∀ {X : Type u_1} {Y : Type u_3} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y] (e : PartialEquiv X Y)
(hc : ContinuousOn (↑e) e.source) (ho : IsOpenMap ↑e) (hs : IsOpen e.source),
↑(OpenPartialHomeomorph.ofContinuousOpen e hc ho hs) = ↑e | true |
Nat.strongRecOn'_beta | Mathlib.Data.Nat.Init | ∀ {n : ℕ} {P : ℕ → Sort u_1} {h : (n : ℕ) → ((m : ℕ) → m < n → P m) → P n},
n.strongRecOn' h = h n fun m x => m.strongRecOn' h | true |
_private.Plausible.Gen.0.Plausible.test | Plausible.Gen | ℕ → Plausible.Gen ℕ | true |
CategoryTheory.GradedObject.TriangleIndexData.p₂₃ | Mathlib.CategoryTheory.GradedObject.Unitor | {I₁ : Type u_1} →
{I₂ : Type u_2} →
{I₃ : Type u_3} →
{J : Type u_4} →
[inst : Zero I₂] →
{r : I₁ × I₂ × I₃ → J} → {π : I₁ × I₃ → J} → CategoryTheory.GradedObject.TriangleIndexData r π → I₂ × I₃ → I₃ | true |
Filter.empty_notMem._simp_1 | Mathlib.Order.Filter.Basic | ∀ {α : Type u} (f : Filter α) [f.NeBot], (∅ ∈ f) = False | false |
MulSemiringAction.toAlgEquiv.congr_simp | Mathlib.FieldTheory.Galois.Basic | ∀ {G : Type u_2} (R : Type u_3) (A : Type u_4) [inst : CommSemiring R] [inst_1 : Semiring A] [inst_2 : Algebra R A]
[inst_3 : Group G] [inst_4 : MulSemiringAction G A] [inst_5 : SMulCommClass G R A] (g g_1 : G),
g = g_1 → MulSemiringAction.toAlgEquiv R A g = MulSemiringAction.toAlgEquiv R A g_1 | true |
GroupNorm.coe_sup._simp_2 | Mathlib.Analysis.Normed.Group.Seminorm | ∀ {E : Type u_3} [inst : Group E] (p q : GroupNorm E), ⇑p ⊔ ⇑q = ⇑(p ⊔ q) | false |
ULift.down_ratCast | Mathlib.Algebra.Field.ULift | ∀ {α : Type u} [inst : RatCast α] (q : ℚ), (↑q).down = ↑q | true |
_private.Mathlib.Tactic.MoveAdd.0.Lean.Expr.getExprInputs._sparseCasesOn_1 | Mathlib.Tactic.MoveAdd | {motive : Lean.Expr → Sort u} →
(t : Lean.Expr) →
((fn arg : Lean.Expr) → motive (fn.app arg)) →
((binderName : Lean.Name) →
(binderType body : Lean.Expr) →
(binderInfo : Lean.BinderInfo) → motive (Lean.Expr.lam binderName binderType body binderInfo)) →
((binderName : Lean.Name) →
(binderType body : Lean.Expr) →
(binderInfo : Lean.BinderInfo) → motive (Lean.Expr.forallE binderName binderType body binderInfo)) →
((declName : Lean.Name) →
(type value body : Lean.Expr) →
(nondep : Bool) → motive (Lean.Expr.letE declName type value body nondep)) →
((data : Lean.MData) → (expr : Lean.Expr) → motive (Lean.Expr.mdata data expr)) →
((typeName : Lean.Name) →
(idx : ℕ) → (struct : Lean.Expr) → motive (Lean.Expr.proj typeName idx struct)) →
(Nat.hasNotBit 3552 t.ctorIdx → motive t) → motive t | false |
CategoryTheory.instComonadicLeftAdjointCoalgebraForget | Mathlib.CategoryTheory.Monad.Adjunction | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
(G : CategoryTheory.Comonad C) → CategoryTheory.ComonadicLeftAdjoint G.forget | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.