name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M |
|---|---|---|
ModelPi | Mathlib.Geometry.Manifold.ChartedSpace | {ι : Type u_5} → (ι → Type u_6) → Type (max u_5 u_6) |
CategoryTheory.Square.commSq | Mathlib.CategoryTheory.Square | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] (sq : CategoryTheory.Square C),
CategoryTheory.CommSq sq.f₁₂ sq.f₁₃ sq.f₂₄ sq.f₃₄ |
LieSubalgebra.coe_sInf | Mathlib.Algebra.Lie.Subalgebra | ∀ {R : Type u} {L : Type v} [inst : CommRing R] [inst_1 : LieRing L] [inst_2 : LieAlgebra R L]
(S : Set (LieSubalgebra R L)), ↑(sInf S) = ⋂ s ∈ S, ↑s |
_private.Mathlib.Tactic.TermCongr.0.Mathlib.Tactic.TermCongr.CongrResult.mk'.toEqPf | Mathlib.Tactic.TermCongr | Lean.Expr → Lean.Expr → Lean.MetaM Lean.Expr |
Aesop.ForwardHypData.noConfusion | Aesop.RuleTac.Forward.Basic | {P : Sort u} → {t t' : Aesop.ForwardHypData} → t = t' → Aesop.ForwardHypData.noConfusionType P t t' |
_private.Mathlib.CategoryTheory.Limits.Shapes.Preorder.TransfiniteCompositionOfShape.0.CategoryTheory.TransfiniteCompositionOfShape.map._simp_3 | Mathlib.CategoryTheory.Limits.Shapes.Preorder.TransfiniteCompositionOfShape | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
(self : CategoryTheory.Functor C D) {X Y Z : C} (f : X ⟶ Y) (g : Y ⟶ Z),
CategoryTheory.CategoryStruct.comp (self.map f) (self.map g) = self.map (CategoryTheory.CategoryStruct.comp f g) |
_private.Lean.Compiler.LCNF.Level.0.Lean.Compiler.LCNF.NormLevelParam.normLevel.match_1 | Lean.Compiler.LCNF.Level | (motive : Lean.Compiler.LCNF.NormLevelParam.State → Sort u_1) →
(x : Lean.Compiler.LCNF.NormLevelParam.State) →
((nextIdx : ℕ) →
(map : Std.HashMap Lean.Name Lean.Level) →
(paramNames : Array Lean.Name) → motive { nextIdx := nextIdx, map := map, paramNames := paramNames }) →
motive x |
Lean.Lsp.SignatureHelpTriggerKind.contentChange.elim | Lean.Data.Lsp.LanguageFeatures | {motive : Lean.Lsp.SignatureHelpTriggerKind → Sort u} →
(t : Lean.Lsp.SignatureHelpTriggerKind) →
t.ctorIdx = 2 → motive Lean.Lsp.SignatureHelpTriggerKind.contentChange → motive t |
Matrix.linearIndependent_rows_of_invertible | Mathlib.LinearAlgebra.Matrix.NonsingularInverse | ∀ {m : Type u} [inst : DecidableEq m] {K : Type u_3} [inst_1 : Field K] [inst_2 : Fintype m] (A : Matrix m m K)
[Invertible A], LinearIndependent K A.row |
Lean.Grind.instOfNatInt16SintOfNatNat | Init.GrindInstances.ToInt | Lean.Grind.ToInt.OfNat Int16 (Lean.Grind.IntInterval.sint 16) |
Nat.bit_lt_bit | Mathlib.Data.Nat.Bits | ∀ {m n : ℕ} (a b : Bool), m < n → Nat.bit a m < Nat.bit b n |
CategoryTheory.SimplicialThickening.Path.rec | Mathlib.AlgebraicTopology.SimplicialNerve | {J : Type u_1} →
[inst : LinearOrder J] →
{i j : J} →
{motive : CategoryTheory.SimplicialThickening.Path i j → Sort u} →
((I : Set J) →
(left : i ∈ I) →
(right : j ∈ I) →
(left_le : ∀ k ∈ I, i ≤ k) →
(le_right : ∀ k ∈ I, k ≤ j) →
motive { I := I, left := left, right := right, left_le := left_le, le_right := le_right }) →
(t : CategoryTheory.SimplicialThickening.Path i j) → motive t |
Int32.reduceOfInt._regBuiltin.Int32.reduceOfInt.declare_1._@.Lean.Meta.Tactic.Simp.BuiltinSimprocs.SInt.2667021113._hygCtx._hyg.376 | Lean.Meta.Tactic.Simp.BuiltinSimprocs.SInt | IO Unit |
Lean.Compiler.LCNF.FixedParams.Context.recOn | Lean.Compiler.LCNF.FixedParams | {motive : Lean.Compiler.LCNF.FixedParams.Context → Sort u} →
(t : Lean.Compiler.LCNF.FixedParams.Context) →
((decls : Array (Lean.Compiler.LCNF.Decl Lean.Compiler.LCNF.Purity.pure)) →
(main : Lean.Compiler.LCNF.Decl Lean.Compiler.LCNF.Purity.pure) →
(assignment : Lean.FVarIdMap Lean.Compiler.LCNF.FixedParams.AbsValue) →
motive { decls := decls, main := main, assignment := assignment }) →
motive t |
CategoryTheory.Functor.preservesLimit_cospan_of_mem_presieve | Mathlib.CategoryTheory.Sites.Precoverage | ∀ {C : Type u_1} {D : Type u_2} {inst : CategoryTheory.Category.{v_1, u_1} C}
{inst_1 : CategoryTheory.Category.{v_2, u_2} D} {F : CategoryTheory.Functor C D} {X : C}
(R : CategoryTheory.Presieve X) [self : F.PreservesPairwisePullbacks R] ⦃Y Z : C⦄ ⦃f : Y ⟶ X⦄ ⦃g : Z ⟶ X⦄,
R f → R g → CategoryTheory.Limits.PreservesLimit (CategoryTheory.Limits.cospan f g) F |
MonomialOrder.lex._proof_3 | Mathlib.Data.Finsupp.MonomialOrder | ∀ {σ : Type u_1} (a b : σ →₀ ℕ), toLex (a + b) = toLex a + toLex b |
CategoryTheory.Arrow.isoOfNatIso._proof_2 | Mathlib.CategoryTheory.Comma.Arrow | ∀ {C : Type u_4} {D : Type u_2} [inst : CategoryTheory.Category.{u_3, u_4} C]
[inst_1 : CategoryTheory.Category.{u_1, u_2} D] {F G : CategoryTheory.Functor C D} (e : F ≅ G)
(f : CategoryTheory.Arrow C),
CategoryTheory.CategoryStruct.comp (e.app f.left).hom (G.mapArrow.obj f).hom =
CategoryTheory.CategoryStruct.comp (F.mapArrow.obj f).hom (e.app f.right).hom |
ValuationSubring.mem_ofSubring._simp_1 | Mathlib.RingTheory.Valuation.ValuationSubring | ∀ {K : Type u} [inst : Field K] (R : Subring K) (hR : ∀ (x : K), x ∈ R ∨ x⁻¹ ∈ R) (x : K),
(x ∈ ValuationSubring.ofSubring R hR) = (x ∈ R) |
TensorProduct.AlgebraTensorModule.lTensor_comp | Mathlib.LinearAlgebra.TensorProduct.Tower | ∀ {R : Type uR} {A : Type uA} {M : Type uM} {N : Type uN} {Q : Type uQ} {Q' : Type uQ'} [inst : CommSemiring R]
[inst_1 : Semiring A] [inst_2 : Algebra R A] [inst_3 : AddCommMonoid M] [inst_4 : Module R M] [inst_5 : Module A M]
[inst_6 : IsScalarTower R A M] [inst_7 : AddCommMonoid N] [inst_8 : Module R N] [inst_9 : AddCommMonoid Q]
[inst_10 : Module R Q] [inst_11 : AddCommMonoid Q'] [inst_12 : Module R Q'] (f₂ : Q →ₗ[R] Q') (f₁ : N →ₗ[R] Q),
(TensorProduct.AlgebraTensorModule.lTensor A M) (f₂ ∘ₗ f₁) =
(TensorProduct.AlgebraTensorModule.lTensor A M) f₂ ∘ₗ (TensorProduct.AlgebraTensorModule.lTensor A M) f₁ |
DMatrix.instUnique | Mathlib.Data.Matrix.DMatrix | {m : Type u_1} → {n : Type u_2} → {α : m → n → Type v} → [(i : m) → (j : n) → Unique (α i j)] → Unique (DMatrix m n α) |
Parser.Attr.qify_simps | Mathlib.Tactic.Attr.Register | Lean.ParserDescr |
_private.Std.Data.DTreeMap.Internal.Lemmas.0.Std.DTreeMap.Internal.Impl.Equiv.forM_eq._simp_1_2 | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {instOrd : Ord α} {a b : α}, (compare a b ≠ Ordering.eq) = ((a == b) = false) |
SimplicialObject.Splitting.cofan_inj_id | Mathlib.AlgebraicTopology.SimplicialObject.Split | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] {X : CategoryTheory.SimplicialObject C}
(s : SimplicialObject.Splitting X) (n : ℕ),
(s.cofan (Opposite.op (SimplexCategory.mk n))).inj
(SimplicialObject.Splitting.IndexSet.id (Opposite.op (SimplexCategory.mk n))) =
s.ι n |
StrictMonoOn.union | Mathlib.Order.Monotone.Union | ∀ {α : Type u_1} {β : Type u_2} [inst : LinearOrder α] [inst_1 : Preorder β] {f : α → β} {s t : Set α} {c : α},
StrictMonoOn f s → StrictMonoOn f t → IsGreatest s c → IsLeast t c → StrictMonoOn f (s ∪ t) |
Polynomial.isMonicOfDegree_X_add_one | Mathlib.Algebra.Polynomial.Degree.IsMonicOfDegree | ∀ {R : Type u_1} [inst : Semiring R] [Nontrivial R] (r : R), (Polynomial.X + Polynomial.C r).IsMonicOfDegree 1 |
Lean.Meta.TransparencyMode.noConfusion | Init.MetaTypes | {P : Sort v✝} → {x y : Lean.Meta.TransparencyMode} → x = y → Lean.Meta.TransparencyMode.noConfusionType P x y |
FinBoolAlg.noConfusion | Mathlib.Order.Category.FinBoolAlg | {P : Sort u} → {t t' : FinBoolAlg} → t = t' → FinBoolAlg.noConfusionType P t t' |
CategoryTheory.ShortComplex.π_moduleCatCyclesIso_hom_assoc_apply | Mathlib.Algebra.Homology.ShortComplex.ModuleCat | ∀ {R : Type u} [inst : Ring R] (S : CategoryTheory.ShortComplex (ModuleCat R)) {Z : ModuleCat R}
(h : S.moduleCatLeftHomologyData.H ⟶ Z) (x : ↑S.cycles),
(CategoryTheory.ConcreteCategory.hom h)
((CategoryTheory.ConcreteCategory.hom S.moduleCatHomologyIso.hom)
((CategoryTheory.ConcreteCategory.hom S.homologyπ) x)) =
(CategoryTheory.ConcreteCategory.hom h)
(S.moduleCatToCycles.range.mkQ ((CategoryTheory.ConcreteCategory.hom S.moduleCatCyclesIso.hom) x)) |
Plausible.InjectiveFunction.shrink._proof_5 | Mathlib.Testing.Plausible.Functions | ∀ {α : Type} (xs' ys' : List α),
xs'.Perm ys' →
xs'.length ≤ ys'.length →
ys'.length ≤ xs'.length →
(List.map Sigma.fst (List.map Prod.toSigma (xs'.zip ys'))).Perm
(List.map Sigma.snd (List.map Prod.toSigma (xs'.zip ys'))) |
CategoryTheory.Comonad.forget_creates_limits_of_comonad_preserves | Mathlib.CategoryTheory.Monad.Limits | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {J : Type u} [inst_1 : CategoryTheory.Category.{v, u} J]
{T : CategoryTheory.Comonad C} [CategoryTheory.Limits.PreservesLimitsOfShape J T.toFunctor]
(D : CategoryTheory.Functor J T.Coalgebra) [CategoryTheory.Limits.HasLimit (D.comp T.forget)],
CategoryTheory.Limits.HasLimit D |
List.SortedLT.map_toDual | Mathlib.Data.List.Sort | ∀ {α : Type u_1} [inst : Preorder α] {l : List α}, (List.map (⇑OrderDual.toDual) l).SortedLT → l.SortedGT |
Nat.findGreatest_eq_zero_iff | Mathlib.Data.Nat.Find | ∀ {k : ℕ} {P : ℕ → Prop} [inst : DecidablePred P], Nat.findGreatest P k = 0 ↔ ∀ ⦃n : ℕ⦄, 0 < n → n ≤ k → ¬P n |
CentroidHom.centerToCentroidCenter | Mathlib.Algebra.Ring.CentroidHom | {α : Type u_5} →
[inst : NonUnitalNonAssocSemiring α] → ↥(NonUnitalSubsemiring.center α) →ₙ+* ↥(Subsemiring.center (CentroidHom α)) |
LieEquiv.ofSubalgebras_apply | Mathlib.Algebra.Lie.Subalgebra | ∀ {R : Type u} {L₁ : Type v} {L₂ : Type w} [inst : CommRing R] [inst_1 : LieRing L₁] [inst_2 : LieRing L₂]
[inst_3 : LieAlgebra R L₁] [inst_4 : LieAlgebra R L₂] (L₁' : LieSubalgebra R L₁) (L₂' : LieSubalgebra R L₂)
(e : L₁ ≃ₗ⁅R⁆ L₂) (h : LieSubalgebra.map e.toLieHom L₁' = L₂') (x : ↥L₁'),
↑((LieEquiv.ofSubalgebras L₁' L₂' e h) x) = e ↑x |
_private.Std.Data.DHashMap.Internal.Raw.0.Std.DHashMap.Raw.diff.eq_1 | Std.Data.DHashMap.Internal.Raw | ∀ {α : Type u} {β : α → Type v} [inst : BEq α] [inst_1 : Hashable α] (m₁ m₂ : Std.DHashMap.Raw α β),
m₁.diff m₂ =
if h₁ : 0 < m₁.buckets.size then
if h₂ : 0 < m₂.buckets.size then ↑(Std.DHashMap.Internal.Raw₀.diff ⟨m₁, h₁⟩ ⟨m₂, h₂⟩) else m₁
else m₂ |
CategoryTheory.isFinitelyPresentable_iff_preservesFilteredColimits | Mathlib.CategoryTheory.Presentable.Finite | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {X : C},
CategoryTheory.IsFinitelyPresentable X ↔
CategoryTheory.Limits.PreservesFilteredColimits (CategoryTheory.coyoneda.obj (Opposite.op X)) |
isPreirreducible_iff_isClosed_union_isClosed | Mathlib.Topology.Irreducible | ∀ {X : Type u_1} [inst : TopologicalSpace X] {s : Set X},
IsPreirreducible s ↔ ∀ (z₁ z₂ : Set X), IsClosed z₁ → IsClosed z₂ → s ⊆ z₁ ∪ z₂ → s ⊆ z₁ ∨ s ⊆ z₂ |
IntermediateField.LinearDisjoint.symm | Mathlib.FieldTheory.LinearDisjoint | ∀ {F : Type u} {E : Type v} [inst : Field F] [inst_1 : Field E] [inst_2 : Algebra F E] {A B : IntermediateField F E},
A.LinearDisjoint ↥B → B.LinearDisjoint ↥A |
instModuleTensorProductMop._proof_1 | Mathlib.Algebra.Azumaya.Defs | ∀ (R : Type u_1) (A : Type u_2) [inst : CommSemiring R] [inst_1 : Semiring A] [inst_2 : Algebra R A],
IsScalarTower R Aᵐᵒᵖ A |
CategoryTheory.Limits.ChosenPullback₃.w₁_assoc | Mathlib.CategoryTheory.Limits.Shapes.Pullback.ChosenPullback | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {X₁ X₂ X₃ S : C} {f₁ : X₁ ⟶ S} {f₂ : X₂ ⟶ S} {f₃ : X₃ ⟶ S}
{h₁₂ : CategoryTheory.Limits.ChosenPullback f₁ f₂} {h₂₃ : CategoryTheory.Limits.ChosenPullback f₂ f₃}
{h₁₃ : CategoryTheory.Limits.ChosenPullback f₁ f₃} (h : CategoryTheory.Limits.ChosenPullback₃ h₁₂ h₂₃ h₁₃) {Z : C}
(h_1 : S ⟶ Z),
CategoryTheory.CategoryStruct.comp h.p₁ (CategoryTheory.CategoryStruct.comp f₁ h_1) =
CategoryTheory.CategoryStruct.comp h.p h_1 |
List.find?_append | Init.Data.List.Impl | ∀ {α : Type u_1} {p : α → Bool} {xs ys : List α}, List.find? p (xs ++ ys) = (List.find? p xs).or (List.find? p ys) |
CategoryTheory.Bicategory.Equivalence.mk.inj | Mathlib.CategoryTheory.Bicategory.Adjunction.Basic | ∀ {B : Type u} {inst : CategoryTheory.Bicategory B} {a b : B} {hom : a ⟶ b} {inv : b ⟶ a}
{unit : CategoryTheory.CategoryStruct.id a ≅ CategoryTheory.CategoryStruct.comp hom inv}
{counit : CategoryTheory.CategoryStruct.comp inv hom ≅ CategoryTheory.CategoryStruct.id b}
{left_triangle :
autoParam
(CategoryTheory.Bicategory.leftZigzagIso unit counit =
CategoryTheory.Bicategory.leftUnitor hom ≪≫ (CategoryTheory.Bicategory.rightUnitor hom).symm)
CategoryTheory.Bicategory.Equivalence.left_triangle._autoParam}
{hom_1 : a ⟶ b} {inv_1 : b ⟶ a}
{unit_1 : CategoryTheory.CategoryStruct.id a ≅ CategoryTheory.CategoryStruct.comp hom_1 inv_1}
{counit_1 : CategoryTheory.CategoryStruct.comp inv_1 hom_1 ≅ CategoryTheory.CategoryStruct.id b}
{left_triangle_1 :
autoParam
(CategoryTheory.Bicategory.leftZigzagIso unit_1 counit_1 =
CategoryTheory.Bicategory.leftUnitor hom_1 ≪≫ (CategoryTheory.Bicategory.rightUnitor hom_1).symm)
CategoryTheory.Bicategory.Equivalence.left_triangle._autoParam},
{ hom := hom, inv := inv, unit := unit, counit := counit, left_triangle := left_triangle } =
{ hom := hom_1, inv := inv_1, unit := unit_1, counit := counit_1, left_triangle := left_triangle_1 } →
hom = hom_1 ∧ inv = inv_1 ∧ unit ≍ unit_1 ∧ counit ≍ counit_1 |
Ideal.IsTwoSided.mul_one | Mathlib.RingTheory.Ideal.Operations | ∀ {R : Type u} [inst : Semiring R] {I : Ideal R} [I.IsTwoSided], I * 1 = I |
_private.Mathlib.RingTheory.AlgebraicIndependent.TranscendenceBasis.0.AlgebraicIndependent.matroid_spanning_iff_of_subsingleton._simp_1_2 | Mathlib.RingTheory.AlgebraicIndependent.TranscendenceBasis | ∀ {α : Type u_2} (M : Matroid α) (S : Set α), M.Spanning S = (M.closure S = M.E ∧ S ⊆ M.E) |
SheafOfModules.hasLimitsOfSize | Mathlib.Algebra.Category.ModuleCat.Sheaf.Limits | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {J : CategoryTheory.GrothendieckTopology C}
(R : CategoryTheory.Sheaf J RingCat),
CategoryTheory.Limits.HasLimitsOfSize.{v₂, v, max u₁ v, max (max (max (v + 1) u) u₁) v₁} (SheafOfModules R) |
MeasureTheory.Lp.constₗ | Mathlib.MeasureTheory.Function.LpSpace.Indicator | {α : Type u_1} →
{E : Type u_2} →
{m : MeasurableSpace α} →
(p : ENNReal) →
(μ : MeasureTheory.Measure α) →
[inst : NormedAddCommGroup E] →
[MeasureTheory.IsFiniteMeasure μ] →
(𝕜 : Type u_3) →
[inst_2 : NormedRing 𝕜] →
[inst_3 : Module 𝕜 E] → [inst_4 : IsBoundedSMul 𝕜 E] → E →ₗ[𝕜] ↥(MeasureTheory.Lp E p μ) |
LinearPMap | Mathlib.LinearAlgebra.LinearPMap | (R : Type u) →
[inst : Ring R] →
(E : Type v) →
[inst_1 : AddCommGroup E] →
[Module R E] → (F : Type w) → [inst_3 : AddCommGroup F] → [Module R F] → Type (max v w) |
_private.Lean.Meta.Tactic.Grind.EMatchAction.0.Lean.Meta.Grind.Action.CollectState.collectedThms._default | Lean.Meta.Tactic.Grind.EMatchAction | Std.HashSet (Lean.Meta.Grind.Origin × Lean.Meta.Grind.EMatchTheoremKind) |
ProbabilityTheory.«_aux_Mathlib_Probability_ConditionalProbability___macroRules_ProbabilityTheory_term__[|_]_1» | Mathlib.Probability.ConditionalProbability | Lean.Macro |
Associated.of_pow_associated_of_prime' | Mathlib.Algebra.GroupWithZero.Associated | ∀ {M : Type u_1} [inst : CommMonoidWithZero M] [IsCancelMulZero M] {p₁ p₂ : M} {k₁ k₂ : ℕ},
Prime p₁ → Prime p₂ → 0 < k₂ → Associated (p₁ ^ k₁) (p₂ ^ k₂) → Associated p₁ p₂ |
MeasureTheory.Filtration.natural | Mathlib.Probability.Process.Filtration | {Ω : Type u_1} →
{ι : Type u_2} →
{m : MeasurableSpace Ω} →
{β : ι → Type u_3} →
[inst : (i : ι) → TopologicalSpace (β i)] →
[∀ (i : ι), TopologicalSpace.MetrizableSpace (β i)] →
[mβ : (i : ι) → MeasurableSpace (β i)] →
[∀ (i : ι), BorelSpace (β i)] →
[inst_3 : Preorder ι] →
(u : (i : ι) → Ω → β i) →
(∀ (i : ι), MeasureTheory.StronglyMeasurable (u i)) → MeasureTheory.Filtration ι m |
List.toChunks.go | Batteries.Data.List.Basic | {α : Type u_1} → ℕ → List α → Array α → Array (List α) → List (List α) |
Path.extend | Mathlib.Topology.Path | {X : Type u_1} → [inst : TopologicalSpace X] → {x y : X} → Path x y → C(ℝ, X) |
Lean.Lsp.PrepareRenameParams._sizeOf_1 | Lean.Data.Lsp.LanguageFeatures | Lean.Lsp.PrepareRenameParams → ℕ |
_private.Mathlib.Algebra.SkewMonoidAlgebra.Basic.0.SkewMonoidAlgebra.coeff.match_1.eq_1 | Mathlib.Algebra.SkewMonoidAlgebra.Basic | ∀ {k : Type u_1} {G : Type u_2} [inst : AddMonoid k] (motive : SkewMonoidAlgebra k G → Sort u_3) (p : G →₀ k)
(h_1 : (p : G →₀ k) → motive { toFinsupp := p }),
(match { toFinsupp := p } with
| { toFinsupp := p } => h_1 p) =
h_1 p |
CategoryTheory.Limits.kernelFactorThruImage.eq_1 | Mathlib.CategoryTheory.Limits.Shapes.Kernels | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C] {X Y : C}
(f : X ⟶ Y) [inst_2 : CategoryTheory.Limits.HasKernel f] [inst_3 : CategoryTheory.Limits.HasImage f]
[inst_4 : CategoryTheory.Limits.HasKernel (CategoryTheory.Limits.factorThruImage f)],
CategoryTheory.Limits.kernelFactorThruImage f =
(CategoryTheory.Limits.kernelCompMono (CategoryTheory.Limits.factorThruImage f)
(CategoryTheory.Limits.image.ι f)).symm ≪≫
CategoryTheory.Limits.kernel.congr
(CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.factorThruImage f) (CategoryTheory.Limits.image.ι f))
f ⋯ |
Std.Tactic.BVDecide.BVExpr.Cache.insert._proof_4 | Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Expr | ∀ {aig : Std.Sat.AIG Std.Tactic.BVDecide.BVBit} {w : ℕ} (expr : Std.Tactic.BVDecide.BVExpr w) (refs : aig.RefVec w)
(map : Std.DHashMap Std.Tactic.BVDecide.BVExpr.Cache.Key fun k => Vector Std.Sat.AIG.Fanin k.w),
(∀ {i : ℕ} (k : Std.Tactic.BVDecide.BVExpr.Cache.Key) (h1 : k ∈ map) (h2 : i < k.w),
(map.get k h1)[i].gate < aig.decls.size) →
∀ {i : ℕ} (k : Std.Tactic.BVDecide.BVExpr.Cache.Key) (h1 : k ∈ map.insert { w := w, expr := expr } refs.refs)
(h2 : i < k.w), ((map.insert { w := w, expr := expr } refs.refs).get k h1)[i].gate < aig.decls.size |
_private.Mathlib.RingTheory.ClassGroup.0.ClassGroup.mk_eq_one_of_coe_ideal._proof_1_1 | Mathlib.RingTheory.ClassGroup | ∀ {R : Type u_1} [inst : CommRing R] (x i : R), x * i ≠ 0 → ¬i = 0 |
_private.Mathlib.Topology.Connected.Basic.0.IsPreconnected.iUnion_of_reflTransGen._simp_1_1 | Mathlib.Topology.Connected.Basic | ∀ {α : Type u} (x : α), (x ∈ Set.univ) = True |
Equiv.optionCongr_apply | Mathlib.Logic.Equiv.Option | ∀ {α : Type u_1} {β : Type u_2} (e : α ≃ β) (a : Option α), e.optionCongr a = Option.map (⇑e) a |
Turing.ToPartrec.stepRet.eq_def | Mathlib.Computability.TMConfig | ∀ (x : Turing.ToPartrec.Cont) (x_1 : List ℕ),
Turing.ToPartrec.stepRet x x_1 =
match x, x_1 with
| Turing.ToPartrec.Cont.halt, v => Turing.ToPartrec.Cfg.halt v
| Turing.ToPartrec.Cont.cons₁ fs as k, v => Turing.ToPartrec.stepNormal fs (Turing.ToPartrec.Cont.cons₂ v k) as
| Turing.ToPartrec.Cont.cons₂ ns k, v => Turing.ToPartrec.stepRet k (ns.headI :: v)
| Turing.ToPartrec.Cont.comp f k, v => Turing.ToPartrec.stepNormal f k v
| Turing.ToPartrec.Cont.fix f k, v =>
if v.headI = 0 then Turing.ToPartrec.stepRet k v.tail
else Turing.ToPartrec.stepNormal f (Turing.ToPartrec.Cont.fix f k) v.tail |
Polynomial.le_gaussNorm | Mathlib.RingTheory.Polynomial.GaussNorm | ∀ {R : Type u_1} {F : Type u_2} [inst : Semiring R] [inst_1 : FunLike F R ℝ] (v : F) {c : ℝ} (p : Polynomial R)
[ZeroHomClass F R ℝ] [NonnegHomClass F R ℝ], 0 ≤ c → ∀ (i : ℕ), v (p.coeff i) * c ^ i ≤ Polynomial.gaussNorm v c p |
Function.Injective.mulOneClass._proof_2 | Mathlib.Algebra.Group.InjSurj | ∀ {M₁ : Type u_2} {M₂ : Type u_1} [inst : Mul M₁] [inst_1 : One M₁] [inst_2 : MulOneClass M₂] (f : M₁ → M₂),
f 1 = 1 → (∀ (x y : M₁), f (x * y) = f x * f y) → ∀ (x : M₁), f (x * 1) = f x |
WeierstrassCurve.toCharTwoNF_spec | Mathlib.AlgebraicGeometry.EllipticCurve.NormalForms | ∀ {F : Type u_2} [inst : Field F] [CharP F 2] (W : WeierstrassCurve F) [inst_2 : DecidableEq F],
(W.toCharTwoNF • W).IsCharTwoNF |
_private.Init.Data.String.Decode.0.ByteArray.utf8DecodeChar?.toBitVec_eq_of_isInvalidContinuationByte_eq_false | Init.Data.String.Decode | ∀ {b : UInt8},
ByteArray.utf8DecodeChar?.isInvalidContinuationByte b = false → b.toBitVec = 2#2 ++ BitVec.setWidth 6 b.toBitVec |
inf_sup_self | Mathlib.Order.Lattice | ∀ {α : Type u} [inst : Lattice α] {a b : α}, a ⊓ (a ⊔ b) = a |
CategoryTheory.Preadditive.epi_of_cokernel_zero | Mathlib.CategoryTheory.Preadditive.Basic | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Preadditive C] {X Y : C} {f : X ⟶ Y}
[inst_2 : CategoryTheory.Limits.HasColimit (CategoryTheory.Limits.parallelPair f 0)],
CategoryTheory.Limits.cokernel.π f = 0 → CategoryTheory.Epi f |
MonCat.ofHom_hom | Mathlib.Algebra.Category.MonCat.Basic | ∀ {M N : MonCat} (f : M ⟶ N), MonCat.ofHom (MonCat.Hom.hom f) = f |
_private.Lean.Meta.WHNF.0.Lean.Meta.whnfCore.go._unsafe_rec | Lean.Meta.WHNF | Lean.Expr → Lean.MetaM Lean.Expr |
ZMod.ringEquivOfPrime | Mathlib.Data.ZMod.Basic | (R : Type u_1) → [inst : Ring R] → [inst_1 : Fintype R] → {p : ℕ} → Nat.Prime p → Fintype.card R = p → ZMod p ≃+* R |
_private.Lean.Elab.PreDefinition.Eqns.0.Lean.Elab.Eqns.mkEqns.doRealize | Lean.Elab.PreDefinition.Eqns | Lean.Name → Lean.Name → Lean.DefinitionVal → Lean.Expr → Lean.MetaM Unit |
_private.Std.Data.ExtDTreeMap.Lemmas.0.Std.ExtDTreeMap.insertMany_list_eq_empty_iff._simp_1_1 | Std.Data.ExtDTreeMap.Lemmas | ∀ {α : Type u} {β : α → Type v} {cmp : α → α → Ordering} {t : Std.ExtDTreeMap α β cmp} [Std.TransCmp cmp],
(t = ∅) = (t.isEmpty = true) |
CategoryTheory.FreeBicategory.mk_associator_hom | Mathlib.CategoryTheory.Bicategory.Free | ∀ {B : Type u} [inst : Quiver B] {a b c d : CategoryTheory.FreeBicategory B} (f : a ⟶ b) (g : b ⟶ c) (h : c ⟶ d),
Quot.mk CategoryTheory.FreeBicategory.Rel (CategoryTheory.FreeBicategory.Hom₂.associator f g h) =
(CategoryTheory.Bicategory.associator f g h).hom |
Aesop.SearchM.State.mk._flat_ctor | Aesop.Search.SearchM | {Q : Type} → [inst : Aesop.Queue Q] → Aesop.Iteration → Q → Bool → Aesop.SearchM.State Q |
WeierstrassCurve.Projective.dblZ_ne_zero_of_Y_ne' | Mathlib.AlgebraicGeometry.EllipticCurve.Projective.Formula | ∀ {R : Type r} [inst : CommRing R] {W' : WeierstrassCurve.Projective R} [NoZeroDivisors R] {P Q : Fin 3 → R},
W'.Equation P →
W'.Equation Q → P 2 ≠ 0 → Q 2 ≠ 0 → P 0 * Q 2 = Q 0 * P 2 → P 1 * Q 2 ≠ W'.negY Q * P 2 → W'.dblZ P ≠ 0 |
_private.Mathlib.SetTheory.Ordinal.CantorNormalForm.0.Ordinal.CNF.eval_single_add'._simp_1_2 | Mathlib.SetTheory.Ordinal.CantorNormalForm | ∀ {G : Type u_1} [inst : Add G] [IsLeftCancelAdd G] (a : G) {b c : G}, (a + b = a + c) = (b = c) |
Lean.Meta.Grind.AC.MonadGetStruct.ctorIdx | Lean.Meta.Tactic.Grind.AC.Util | {m : Type → Type} → Lean.Meta.Grind.AC.MonadGetStruct m → ℕ |
_private.Mathlib.MeasureTheory.Measure.Haar.Basic.0.MeasureTheory.Measure.haar.index_union_eq._simp_1_2 | Mathlib.MeasureTheory.Measure.Haar.Basic | ∀ {α : Type u} {ι : Sort v} {x : α} {s : ι → Set α}, (x ∈ ⋃ i, s i) = ∃ i, x ∈ s i |
Dyadic.blt.eq_3 | Init.Data.Dyadic.Basic | ∀ (n k : ℤ) (hn : n % 2 = 1), (Dyadic.ofOdd n k hn).blt Dyadic.zero = decide (n < 0) |
max_zero_add_max_neg_zero_eq_abs_self | Mathlib.Algebra.Order.Group.Abs | ∀ {G : Type u_1} [inst : AddCommGroup G] [inst_1 : LinearOrder G] [IsOrderedAddMonoid G] (a : G),
max a 0 + max (-a) 0 = |a| |
Polynomial.ofFn._proof_1 | Mathlib.Algebra.Polynomial.OfFn | ∀ {R : Type u_1} [inst : Semiring R] [inst_1 : DecidableEq R] (n : ℕ) (x y : Fin n → R),
{ toFinsupp := (List.ofFn (x + y)).toFinsupp } =
{ toFinsupp := (List.ofFn x).toFinsupp } + { toFinsupp := (List.ofFn y).toFinsupp } |
Equiv.nonUnitalNonAssocRing._proof_3 | Mathlib.Algebra.Ring.TransferInstance | ∀ {α : Type u_2} {β : Type u_1} (e : α ≃ β) [inst : NonUnitalNonAssocRing β] (x y : α),
e (e.symm (e x * e y)) = e x * e y |
GetElem.casesOn | Init.GetElem | {coll : Type u} →
{idx : Type v} →
{elem : Type w} →
{valid : coll → idx → Prop} →
{motive : GetElem coll idx elem valid → Sort u_1} →
(t : GetElem coll idx elem valid) →
((getElem : (xs : coll) → (i : idx) → valid xs i → elem) → motive { getElem := getElem }) → motive t |
Equiv.Perm.extendDomain_one | Mathlib.Algebra.Group.End | ∀ {α : Type u_4} {β : Type u_5} {p : β → Prop} [inst : DecidablePred p] (f : α ≃ Subtype p),
Equiv.Perm.extendDomain 1 f = 1 |
TopCat.prodIsoProd_hom_snd | Mathlib.Topology.Category.TopCat.Limits.Products | ∀ (X Y : TopCat),
CategoryTheory.CategoryStruct.comp (X.prodIsoProd Y).hom TopCat.prodSnd = CategoryTheory.Limits.prod.snd |
Lean.Elab.Do.DoElemContKind.noConfusion | Lean.Elab.Do.Basic | {P : Sort v✝} → {x y : Lean.Elab.Do.DoElemContKind} → x = y → Lean.Elab.Do.DoElemContKind.noConfusionType P x y |
Lean.ScopedEnvExtension.StateStack.recOn | Lean.ScopedEnvExtension | {α β σ : Type} →
{motive : Lean.ScopedEnvExtension.StateStack α β σ → Sort u} →
(t : Lean.ScopedEnvExtension.StateStack α β σ) →
((stateStack : List (Lean.ScopedEnvExtension.State σ)) →
(scopedEntries : Lean.ScopedEnvExtension.ScopedEntries β) →
(newEntries : List (Lean.ScopedEnvExtension.Entry α)) →
motive { stateStack := stateStack, scopedEntries := scopedEntries, newEntries := newEntries }) →
motive t |
_private.Mathlib.RingTheory.Multiplicity.0.Nat.finiteMultiplicity_iff.match_1_1 | Mathlib.RingTheory.Multiplicity | ∀ {b : ℕ} (motive : (a : ℕ) → (∀ (n : ℕ), a ^ n ∣ b) → a ≠ 0 → a ≠ 1 → a ≤ 1 → Prop) (a : ℕ) (h : ∀ (n : ℕ), a ^ n ∣ b)
(ha : a ≠ 0) (ha1 : a ≠ 1) (x : a ≤ 1),
(∀ (h : ∀ (n : ℕ), 0 ^ n ∣ b) (ha : 0 ≠ 0) (ha1 : 0 ≠ 1) (x : 0 ≤ 1), motive 0 h ha ha1 x) →
(∀ (h : ∀ (n : ℕ), 1 ^ n ∣ b) (ha : 1 ≠ 0) (ha1 : 1 ≠ 1) (x : 1 ≤ 1), motive 1 h ha ha1 x) →
(∀ (b_1 : ℕ) (h : ∀ (n : ℕ), (b_1 + 2) ^ n ∣ b) (ha : b_1 + 2 ≠ 0) (ha1 : b_1 + 2 ≠ 1) (x : b_1 + 2 ≤ 1),
motive b_1.succ.succ h ha ha1 x) →
motive a h ha ha1 x |
Mathlib.Tactic._aux_Mathlib_Tactic_SplitIfs___elabRules_Mathlib_Tactic_splitIfs_1 | Mathlib.Tactic.SplitIfs | Lean.Elab.Tactic.Tactic |
norm_le_norm_div_add | Mathlib.Analysis.Normed.Group.Basic | ∀ {E : Type u_5} [inst : SeminormedGroup E] (a b : E), ‖a‖ ≤ ‖a / b‖ + ‖b‖ |
NonemptyInterval.length_nonneg | Mathlib.Algebra.Order.Interval.Basic | ∀ {α : Type u_2} [inst : AddCommGroup α] [inst_1 : PartialOrder α] [IsOrderedAddMonoid α] (s : NonemptyInterval α),
0 ≤ s.length |
MeasureTheory.AnalyticSet.preimage | Mathlib.MeasureTheory.Constructions.Polish.Basic | ∀ {X : Type u_3} {Y : Type u_4} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y] [PolishSpace X] [T2Space Y]
{s : Set Y}, MeasureTheory.AnalyticSet s → ∀ {f : X → Y}, Continuous f → MeasureTheory.AnalyticSet (f ⁻¹' s) |
_private.Mathlib.Data.List.Cycle.0.List.prev_eq_getElem?_idxOf_pred_of_ne_head._proof_1_16 | Mathlib.Data.List.Cycle | ∀ {α : Type u_1} {a : α} (x y : α) (tail : List α), a ∈ x :: y :: tail → 0 < (x :: y :: tail).length |
instMulActionSemiHomClassMulActionHom | Mathlib.GroupTheory.GroupAction.Hom | ∀ {M : Type u_2} {N : Type u_3} (φ : M → N) (X : Type u_5) [inst : SMul M X] (Y : Type u_6) [inst_1 : SMul N Y],
MulActionSemiHomClass (X →ₑ[φ] Y) φ X Y |
ProbabilityTheory.Kernel.coe_mk | Mathlib.Probability.Kernel.Defs | ∀ {α : Type u_1} {β : Type u_2} {mα : MeasurableSpace α} {mβ : MeasurableSpace β} (f : α → MeasureTheory.Measure β)
(hf : Measurable f), ⇑{ toFun := f, measurable' := hf } = f |
_private.Mathlib.Data.Seq.Computation.0.Computation.LiftRel.symm.match_1_3 | Mathlib.Data.Seq.Computation | ∀ {α : Type u_1} (R : α → α → Prop) (x : Computation α) {x_1 : α} (motive : (∃ b ∈ x, R x_1 b) → Prop)
(x_2 : ∃ b ∈ x, R x_1 b), (∀ (b : α) (b2 : b ∈ x) (ab : R x_1 b), motive ⋯) → motive x_2 |
CommGroupWithZero.instNormalizedGCDMonoid._proof_1 | Mathlib.Algebra.GCDMonoid.Basic | ∀ (G₀ : Type u_1) [inst : CommGroupWithZero G₀] [inst_1 : DecidableEq G₀] {x y : G₀},
x ≠ 0 →
y ≠ 0 →
↑(if h : x * y = 0 then 1 else (Units.mk0 (x * y) h)⁻¹) =
↑((if h : x = 0 then 1 else (Units.mk0 x h)⁻¹) * if h : y = 0 then 1 else (Units.mk0 y h)⁻¹) |
List.attach_reverse | Init.Data.List.Attach | ∀ {α : Type u_1} {xs : List α},
xs.reverse.attach =
List.map
(fun x =>
match x with
| ⟨x, h⟩ => ⟨x, ⋯⟩)
xs.attach.reverse |
AlgebraicGeometry.Scheme.Hom.normalizationDiagramMap._proof_1 | Mathlib.AlgebraicGeometry.Normalization | ∀ {X Y : AlgebraicGeometry.Scheme} (f : X ⟶ Y) {U V : (TopologicalSpace.Opens ↥Y)ᵒᵖ} (i : U ⟶ V),
CategoryTheory.CategoryStruct.comp (Y.presheaf.map i)
(CommRingCat.ofHom
(algebraMap ↑(Y.presheaf.obj (Opposite.op (Opposite.unop V)))
↥(integralClosure ↑(Y.presheaf.obj (Opposite.op (Opposite.unop V)))
↑(X.presheaf.obj (Opposite.op ((TopologicalSpace.Opens.map f.base).obj (Opposite.unop V))))))) =
CategoryTheory.CategoryStruct.comp
(CommRingCat.ofHom
(algebraMap ↑(Y.presheaf.obj (Opposite.op (Opposite.unop U)))
↥(integralClosure ↑(Y.presheaf.obj (Opposite.op (Opposite.unop U)))
↑(X.presheaf.obj (Opposite.op ((TopologicalSpace.Opens.map f.base).obj (Opposite.unop U)))))))
((AlgebraicGeometry.Scheme.Hom.normalizationDiagram f).map i) |
AlgebraicGeometry.Scheme.Cover.gluedCover._proof_4 | Mathlib.AlgebraicGeometry.Gluing | ∀ {X : AlgebraicGeometry.Scheme} (𝒰 : X.OpenCover) (i j k : 𝒰.I₀),
CategoryTheory.Limits.HasPullback (CategoryTheory.Limits.pullback.fst (𝒰.f i) (𝒰.f j))
(CategoryTheory.Limits.pullback.fst (𝒰.f i) (𝒰.f k)) |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.