name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M |
|---|---|---|
Polynomial.Splits.eval_derivative | Mathlib.Algebra.Polynomial.Splits | ∀ {R : Type u_1} [inst : CommRing R] {f : Polynomial R} [inst_1 : IsDomain R] [inst_2 : DecidableEq R],
f.Splits →
∀ (x : R),
Polynomial.eval x (Polynomial.derivative f) =
f.leadingCoeff *
(Multiset.map (fun a => (Multiset.map (fun x_1 => x - x_1) (f.roots.erase a)).prod) f.roots).sum |
Std.TreeMap.Raw.mem_toList_iff_getElem?_eq_some._simp_1 | Std.Data.TreeMap.Raw.Lemmas | ∀ {α : Type u} {β : Type v} {cmp : α → α → Ordering} {t : Std.TreeMap.Raw α β cmp} [Std.TransCmp cmp]
[Std.LawfulEqCmp cmp], t.WF → ∀ {k : α} {v : β}, ((k, v) ∈ t.toList) = (t[k]? = some v) |
CategoryTheory.Limits.MultispanIndex.SymmStruct.noConfusionType | Mathlib.CategoryTheory.Limits.Shapes.Multiequalizer | Sort u_1 →
{C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
{ι : Type w} →
{I : CategoryTheory.Limits.MultispanIndex (CategoryTheory.Limits.MultispanShape.prod ι) C} →
I.SymmStruct →
{C' : Type u} →
[inst' : CategoryTheory.Category.{v, u} C'] →
{ι' : Type w} →
{I' : CategoryTheory.Limits.MultispanIndex (CategoryTheory.Limits.MultispanShape.prod ι') C'} →
I'.SymmStruct → Sort u_1 |
CochainComplex.Lifting.cocycle₁._proof_5 | Mathlib.Algebra.Homology.ModelCategory.Lifting | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.Abelian C]
{A B X Y : CochainComplex C ℤ} {t : A ⟶ X} {i : A ⟶ B} {p : X ⟶ Y} {b : B ⟶ Y} (sq : CategoryTheory.CommSq t i p b)
(hsq : (n : ℤ) → ⋯.LiftStruct) {Q : CochainComplex C ℤ} {π : B ⟶ Q} {hπ : CategoryTheory.CategoryStruct.comp i π = 0}
(hQ : CategoryTheory.Limits.IsColimit (CategoryTheory.Limits.CokernelCofork.ofπ π hπ)) {K : CochainComplex C ℤ}
{ι : K ⟶ X} {hι : CategoryTheory.CategoryStruct.comp ι p = 0}
(hK : CategoryTheory.Limits.IsLimit (CategoryTheory.Limits.KernelFork.ofι ι hι)),
CochainComplex.HomComplex.δ 1 2 (CochainComplex.Lifting.cochain₁ sq hsq hQ hK) = 0 |
CategoryTheory.Quiv.comp_eq_comp | Mathlib.CategoryTheory.Category.Quiv | ∀ {X Y Z : CategoryTheory.Quiv} (F : X ⟶ Y) (G : Y ⟶ Z), CategoryTheory.CategoryStruct.comp F G = F ⋙q G |
ZMod.ringHom_map_cast | Mathlib.Data.ZMod.Basic | ∀ {n : ℕ} {R : Type u_1} [inst : NonAssocRing R] (f : R →+* ZMod n) (k : ZMod n), f k.cast = k |
Finsupp.lattice._proof_5 | Mathlib.Order.Preorder.Finsupp | ∀ {ι : Type u_1} {M : Type u_2} [inst : Zero M] [inst_1 : Lattice M] (a b : ι →₀ M), SemilatticeInf.inf a b ≤ b |
Lean.Elab.Tactic.iterateExactly'._unsafe_rec | Mathlib.Tactic.Core | {m : Type → Type u} → [Monad m] → ℕ → m Unit → m Unit |
Lean.Environment.const2ModIdx | Lean.Environment | Lean.Environment → Std.HashMap Lean.Name Lean.ModuleIdx |
Int.floor_eq_self_iff_mem | Mathlib.Algebra.Order.Floor.Ring | ∀ {R : Type u_2} [inst : Ring R] [inst_1 : LinearOrder R] [inst_2 : FloorRing R] [IsStrictOrderedRing R] (a : R),
↑⌊a⌋ = a ↔ a ∈ Set.range Int.cast |
DirectSum.GradeZero.commRing._proof_8 | Mathlib.Algebra.DirectSum.Ring | ∀ {ι : Type u_1} [inst : DecidableEq ι] (A : ι → Type u_2) [inst_1 : (i : ι) → AddCommGroup (A i)]
[inst_2 : AddCommMonoid ι] [inst_3 : DirectSum.GCommRing A] (x : ℕ) (x_1 : A 0),
(DirectSum.of A 0) (x • x_1) = x • (DirectSum.of A 0) x_1 |
_private.Init.Data.Array.Lemmas.0.Array.map_eq_append_iff._simp_1_2 | Init.Data.Array.Lemmas | ∀ {α : Type u_1} {β : Type u_2} {xs : Array α} {ys zs : Array β} {f : α → Option β},
(Array.filterMap f xs = ys ++ zs) = ∃ as bs, xs = as ++ bs ∧ Array.filterMap f as = ys ∧ Array.filterMap f bs = zs |
Algebra.tensorH1CotangentOfIsLocalization._proof_3 | Mathlib.RingTheory.Etale.Kaehler | ∀ (R : Type u_2) {S : Type u_3} (T : Type u_1) [inst : CommRing R] [inst_1 : CommRing S] [inst_2 : CommRing T]
[inst_3 : Algebra R S] [inst_4 : Algebra R T] [inst_5 : Algebra S T] [inst_6 : IsScalarTower R S T] (M : Submonoid S)
[IsLocalization M T] (y : (Algebra.Generators.self R S).toExtension.Ring)
(hy : y ∈ Submonoid.comap (algebraMap (Algebra.Generators.self R S).toExtension.Ring S) M),
IsUnit
(((IsScalarTower.toAlgHom R S T).comp (IsScalarTower.toAlgHom R (Algebra.Generators.self R S).toExtension.Ring S))
↑⟨y, hy⟩) |
Polynomial.trailingDegree_le_of_ne_zero | Mathlib.Algebra.Polynomial.Degree.TrailingDegree | ∀ {R : Type u} {n : ℕ} [inst : Semiring R] {p : Polynomial R}, p.coeff n ≠ 0 → p.trailingDegree ≤ ↑n |
NonUnitalRingHom.copy | Mathlib.Algebra.Ring.Hom.Defs | {α : Type u_2} →
{β : Type u_3} →
[inst : NonUnitalNonAssocSemiring α] →
[inst_1 : NonUnitalNonAssocSemiring β] → (f : α →ₙ+* β) → (f' : α → β) → f' = ⇑f → α →ₙ+* β |
_private.Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.RotateRight.0.Std.Tactic.BVDecide.BVExpr.bitblast.blastRotateRight.go_get_aux._proof_1_3 | Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.RotateRight | ∀ {w : ℕ}, ∀ curr ≤ w, ∀ (idx : ℕ), ¬curr < w → ¬curr = w → False |
Lean.Meta.Tactic.TryThis.addExactSuggestions | Lean.Meta.Tactic.TryThis | Lean.Syntax →
Array Lean.Expr →
optParam (Option Lean.Syntax) none →
optParam Bool false →
optParam (Option String) none →
optParam (Option Lean.Elab.Tactic.SavedState) none → optParam Bool true → Lean.Elab.Tactic.TacticM Unit |
Commute.geom_sum₂_Ico | Mathlib.Algebra.Field.GeomSum | ∀ {K : Type u_2} [inst : DivisionRing K] {x y : K},
Commute x y →
x ≠ y → ∀ {m n : ℕ}, m ≤ n → ∑ i ∈ Finset.Ico m n, x ^ i * y ^ (n - 1 - i) = (x ^ n - y ^ (n - m) * x ^ m) / (x - y) |
CategoryTheory.projectiveDimension_lt_iff | Mathlib.CategoryTheory.Abelian.Projective.Dimension | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Abelian C] {X : C} {n : ℕ},
CategoryTheory.projectiveDimension X < ↑n ↔ CategoryTheory.HasProjectiveDimensionLT X n |
Lean.Parser.Term.termTry | Lean.Parser.Do | Lean.Parser.Parser |
IsGroupLikeElem.antipode._simp_1 | Mathlib.RingTheory.HopfAlgebra.GroupLike | ∀ {R : Type u_1} {A : Type u_2} [inst : CommSemiring R] [inst_1 : Semiring A] [inst_2 : HopfAlgebra R A] {a : A},
IsGroupLikeElem R a → IsGroupLikeElem R ((HopfAlgebraStruct.antipode R) a) = True |
ExceptT.bindCont.eq_2 | Init.Control.Lawful.Instances | ∀ {ε : Type u} {m : Type u → Type v} [inst : Monad m] {α β : Type u} (f : α → ExceptT ε m β) (e : ε),
ExceptT.bindCont f (Except.error e) = pure (Except.error e) |
intervalIntegral.derivWithin_integral_of_tendsto_ae_left._auto_1 | Mathlib.MeasureTheory.Integral.IntervalIntegral.FundThmCalculus | Lean.Syntax |
Orientation.kahler_map | Mathlib.Analysis.InnerProductSpace.TwoDim | ∀ {E : Type u_1} [inst : NormedAddCommGroup E] [inst_1 : InnerProductSpace ℝ E] [inst_2 : Fact (Module.finrank ℝ E = 2)]
(o : Orientation ℝ E (Fin 2)) {F : Type u_2} [inst_3 : NormedAddCommGroup F] [inst_4 : InnerProductSpace ℝ F]
[hF : Fact (Module.finrank ℝ F = 2)] (φ : E ≃ₗᵢ[ℝ] F) (x y : F),
(((Orientation.map (Fin 2) φ.toLinearEquiv) o).kahler x) y = (o.kahler (φ.symm x)) (φ.symm y) |
GrpTypeEquivalenceGrp.inverse._proof_1 | Mathlib.CategoryTheory.Monoidal.Internal.Types.Grp_ | ∀ (A : GrpCat),
CategoryTheory.CategoryStruct.comp
(CategoryTheory.CartesianMonoidalCategory.lift (fun x => x⁻¹)
(CategoryTheory.CategoryStruct.id
(MonTypeEquivalenceMon.inverse.obj ((CategoryTheory.forget₂ GrpCat MonCat).obj A)).X))
CategoryTheory.MonObj.mul =
CategoryTheory.CategoryStruct.comp
(CategoryTheory.SemiCartesianMonoidalCategory.toUnit
(MonTypeEquivalenceMon.inverse.obj ((CategoryTheory.forget₂ GrpCat MonCat).obj A)).X)
CategoryTheory.MonObj.one |
Fin.castSucc_lt_last._simp_2 | Mathlib.Data.Fin.SuccPred | ∀ {n : ℕ} (a : Fin n), (a.castSucc < Fin.last n) = True |
Aesop.SaturateM.Context.noConfusionType | Aesop.Saturate | Sort u → Aesop.SaturateM.Context → Aesop.SaturateM.Context → Sort u |
LinearMap.BilinForm.dualSubmoduleToDual._proof_11 | Mathlib.LinearAlgebra.BilinearForm.DualLattice | ∀ {R : Type u_2} {S : Type u_3} {M : Type u_1} [inst : CommRing R] [inst_1 : Field S] [inst_2 : AddCommGroup M]
[inst_3 : Algebra R S] [inst_4 : Module R M] [inst_5 : Module S M] [inst_6 : IsScalarTower R S M]
(B : LinearMap.BilinForm S M) [IsDomain R] [Module.IsTorsionFree R S] (N : Submodule R M) (r : R)
(x : ↥(B.dualSubmodule N)) (x_1 y : ↥N),
B.dualSubmoduleParing (r • x) (x_1 + y) = B.dualSubmoduleParing (r • x) x_1 + B.dualSubmoduleParing (r • x) y |
Nat.eq_sub_of_add_eq' | Init.Data.Nat.Lemmas | ∀ {a b c : ℕ}, b + c = a → c = a - b |
_private.Mathlib.CategoryTheory.Localization.Monoidal.Basic.0.CategoryTheory.Localization.Monoidal._aux_Mathlib_CategoryTheory_Localization_Monoidal_Basic___macroRules__private_Mathlib_CategoryTheory_Localization_Monoidal_Basic_0_CategoryTheory_Localization_Monoidal_termL'_1 | Mathlib.CategoryTheory.Localization.Monoidal.Basic | Lean.Macro |
Array.findIdx?_isSome | Init.Data.Array.Find | ∀ {α : Type u_1} {xs : Array α} {p : α → Bool}, (Array.findIdx? p xs).isSome = xs.any p |
Lean.Grind.CommRing.Stepwise.superpose_certC | Init.Grind.Ring.CommSolver | ℤ →
Lean.Grind.CommRing.Mon →
Lean.Grind.CommRing.Poly →
ℤ → Lean.Grind.CommRing.Mon → Lean.Grind.CommRing.Poly → Lean.Grind.CommRing.Poly → ℕ → Bool |
_private.Init.Data.UInt.Lemmas.0.USize.toUInt8_eq._simp_1_1 | Init.Data.UInt.Lemmas | ∀ {a b : UInt8}, (a = b) = (a.toNat = b.toNat) |
_private.Mathlib.Analysis.Calculus.TangentCone.ProperSpace.0.tangentConeAt_nonempty_of_properSpace._simp_1_7 | Mathlib.Analysis.Calculus.TangentCone.ProperSpace | ∀ {α : Type u_1} [inst : Zero α] [inst_1 : One α] [inst_2 : LE α] [ZeroLEOneClass α], (0 ≤ 1) = True |
Aesop.Options.ctorIdx | Aesop.Options.Public | Aesop.Options → ℕ |
_private.Lean.Elab.Match.0.Lean.Elab.Term.isPatternVar._sparseCasesOn_4 | Lean.Elab.Match | {motive : Lean.Expr → Sort u} →
(t : Lean.Expr) →
((declName : Lean.Name) → (us : List Lean.Level) → motive (Lean.Expr.const declName us)) →
(Nat.hasNotBit 16 t.ctorIdx → motive t) → motive t |
CategoryTheory.WithTerminal.down | Mathlib.CategoryTheory.WithTerminal.Basic | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
{X Y : C} → (CategoryTheory.WithTerminal.of X ⟶ CategoryTheory.WithTerminal.of Y) → (X ⟶ Y) |
Matrix.toBlocks₂₁ | Mathlib.Data.Matrix.Block | {l : Type u_1} →
{m : Type u_2} → {n : Type u_3} → {o : Type u_4} → {α : Type u_12} → Matrix (n ⊕ o) (l ⊕ m) α → Matrix o l α |
Dioph.«termD&_» | Mathlib.NumberTheory.Dioph | Lean.ParserDescr |
partialOrderOfSO._proof_4 | Mathlib.Order.RelClasses | ∀ {α : Type u_1} (r : α → α → Prop) [IsStrictOrder α r] (x y : α), x = y ∨ r x y → y = x ∨ r y x → x = y |
FourierTransformInv.casesOn | Mathlib.Analysis.Fourier.Notation | {E : Type u} →
{F : Type v} →
{motive : FourierTransformInv E F → Sort u_1} →
(t : FourierTransformInv E F) → ((fourierInv : E → F) → motive { fourierInv := fourierInv }) → motive t |
List.iterate.match_1 | Mathlib.Data.List.Defs | (motive : ℕ → Sort u_1) → (x : ℕ) → (Unit → motive 0) → ((n : ℕ) → motive n.succ) → motive x |
Aesop.RappId.noConfusion | Aesop.Tree.Data | {P : Sort u} → {t t' : Aesop.RappId} → t = t' → Aesop.RappId.noConfusionType P t t' |
isOpen_compl_iff._simp_1 | Mathlib.Topology.Basic | ∀ {X : Type u} {s : Set X} [inst : TopologicalSpace X], IsOpen sᶜ = IsClosed s |
_private.Mathlib.Analysis.Convex.Side.0.AffineSubspace.sSameSide_self_iff.match_1_1 | Mathlib.Analysis.Convex.Side | ∀ {R : Type u_1} {V : Type u_2} {P : Type u_3} [inst : CommRing R] [inst_1 : PartialOrder R]
[inst_2 : IsStrictOrderedRing R] [inst_3 : AddCommGroup V] [inst_4 : Module R V] [inst_5 : AddTorsor V P]
{s : AffineSubspace R P} {x : P} (motive : s.SSameSide x x → Prop) (x_1 : s.SSameSide x x),
(∀ (h : s.WSameSide x x) (hx right : x ∉ s), motive ⋯) → motive x_1 |
Pi.normedCommGroup._proof_1 | Mathlib.Analysis.Normed.Group.Constructions | ∀ {ι : Type u_1} {G : ι → Type u_2} [inst : (i : ι) → NormedCommGroup (G i)] (a b : (i : ι) → G i), a * b = b * a |
kroneckerTMulLinearEquiv._proof_2 | Mathlib.RingTheory.MatrixAlgebra | ∀ (l : Type u_1) (m : Type u_3) (n : Type u_4) (p : Type u_5) (R : Type u_8) (S : Type u_7) (M : Type u_6)
(N : Type u_2) [inst : CommSemiring R] [inst_1 : Semiring S] [inst_2 : AddCommMonoid M] [inst_3 : AddCommMonoid N]
[inst_4 : Algebra R S] [inst_5 : Module R M] [inst_6 : Module S M] [inst_7 : Module R N]
[inst_8 : IsScalarTower R S M] [inst_9 : Fintype l] [inst_10 : Fintype m] [inst_11 : Fintype n] [inst_12 : Fintype p]
[inst_13 : DecidableEq l] [inst_14 : DecidableEq m] [inst_15 : DecidableEq n] [inst_16 : DecidableEq p],
((Matrix.liftLinear R) fun ii jj =>
TensorProduct.AlgebraTensorModule.map (Matrix.singleLinearMap S ii.1 jj.1)
(Matrix.singleLinearMap R ii.2 jj.2)) ∘ₗ
TensorProduct.AlgebraTensorModule.lift (Matrix.kroneckerTMulBilinear R S) =
LinearMap.id |
Function.Injective.invOfMemRange_surjective | Mathlib.Data.Fintype.Inv | ∀ {α : Type u_1} {β : Type u_2} [inst : Fintype α] [inst_1 : DecidableEq β] {f : α → β} (hf : Function.Injective f),
Function.Surjective hf.invOfMemRange |
SSet.const_app | Mathlib.AlgebraicTopology.SimplicialSet.Basic | ∀ {X Y : SSet} (y : Y.obj (Opposite.op (SimplexCategory.mk 0))) (n : SimplexCategoryᵒᵖ) (x : X.obj n),
(SSet.const y).app n x = Y.map ((Opposite.unop n).const (SimplexCategory.mk 0) 0).op y |
AlgHom.fieldRange._proof_1 | Mathlib.FieldTheory.IntermediateField.Basic | ∀ {K : Type u_3} {L : Type u_1} {L' : Type u_2} [inst : Field K] [inst_1 : Field L] [inst_2 : Field L']
[inst_3 : Algebra K L] [inst_4 : Algebra K L'], RingHomClass (L →ₐ[K] L') L L' |
Polynomial.card_support_eraseLead_add_one | Mathlib.Algebra.Polynomial.EraseLead | ∀ {R : Type u_1} [inst : Semiring R] {f : Polynomial R}, f ≠ 0 → f.eraseLead.support.card + 1 = f.support.card |
Lean.Meta.Grind.propagateNotDown._regBuiltin.Lean.Meta.Grind.propagateNotDown.declare_1._@.Lean.Meta.Tactic.Grind.Propagate.3610191934._hygCtx._hyg.8 | Lean.Meta.Tactic.Grind.Propagate | IO Unit |
AlgebraicGeometry.locallyQuasiFinite_iff_isDiscrete_preimage_singleton | Mathlib.AlgebraicGeometry.Morphisms.QuasiFinite | ∀ {X Y : AlgebraicGeometry.Scheme} {f : X ⟶ Y} [AlgebraicGeometry.LocallyOfFiniteType f],
AlgebraicGeometry.LocallyQuasiFinite f ↔ ∀ (x : ↥Y), IsDiscrete (⇑f ⁻¹' {x}) |
Algebra.SubmersivePresentation.ofSubsingleton._proof_2 | Mathlib.RingTheory.Extension.Presentation.Submersive | ∀ (R : Type u_1) (S : Type u_3) [inst : CommRing R] [inst_1 : CommRing S] [inst_2 : Algebra R S]
[inst_3 : Subsingleton S],
Ideal.span (Set.range fun x => 1) = { val := fun x => 1, σ' := fun x => 1, aeval_val_σ' := ⋯, algebraMap_eq := ⋯ }.ker |
Std.CloseableChannel.instDecidableEqError._proof_2 | Std.Sync.Channel | ∀ (x y : Std.CloseableChannel.Error), ¬x.ctorIdx = y.ctorIdx → x = y → False |
CompleteDistribLattice.MinimalAxioms.mk.sizeOf_spec | Mathlib.Order.CompleteBooleanAlgebra | ∀ {α : Type u} [inst : SizeOf α] (toCompleteLattice : CompleteLattice α)
(inf_sSup_le_iSup_inf : ∀ (a : α) (s : Set α), a ⊓ sSup s ≤ ⨆ b ∈ s, a ⊓ b)
(iInf_sup_le_sup_sInf : ∀ (a : α) (s : Set α), ⨅ b ∈ s, a ⊔ b ≤ a ⊔ sInf s),
sizeOf
{ toCompleteLattice := toCompleteLattice, inf_sSup_le_iSup_inf := inf_sSup_le_iSup_inf,
iInf_sup_le_sup_sInf := iInf_sup_le_sup_sInf } =
1 + sizeOf toCompleteLattice |
ProfiniteAddGrp.instPreservesLimitsProfiniteForget₂ContinuousAddMonoidHomCarrierToTopTotallyDisconnectedSpaceToProfiniteContinuousMap | Mathlib.Topology.Algebra.Category.ProfiniteGrp.Basic | CategoryTheory.Limits.PreservesLimits (CategoryTheory.forget₂ ProfiniteAddGrp.{u_1} Profinite) |
Mathlib.Tactic.AtomM.Recurse.Config.contextual._default | Mathlib.Util.AtomM.Recurse | Bool |
separableClosure.adjoin_eq_of_isAlgebraic | Mathlib.FieldTheory.PurelyInseparable.Basic | ∀ {F : Type u} {E : Type v} [inst : Field F] [inst_1 : Field E] [inst_2 : Algebra F E] (K : Type w) [inst_3 : Field K]
[inst_4 : Algebra F K] [inst_5 : Algebra E K] [IsScalarTower F E K] [Algebra.IsAlgebraic F E],
IntermediateField.adjoin E ↑(separableClosure F K) = separableClosure E K |
IrreducibleSpace.rec | Mathlib.Topology.Irreducible | {X : Type u_3} →
[inst : TopologicalSpace X] →
{motive : IrreducibleSpace X → Sort u} →
([toPreirreducibleSpace : PreirreducibleSpace X] → (toNonempty : Nonempty X) → motive ⋯) →
(t : IrreducibleSpace X) → motive t |
AddMonoidHom.compLeftContinuous.congr_simp | Mathlib.Topology.ContinuousMap.StoneWeierstrass | ∀ (α : Type u_1) {β : Type u_2} [inst : TopologicalSpace α] [inst_1 : TopologicalSpace β] {γ : Type u_3}
[inst_2 : AddMonoid β] [inst_3 : ContinuousAdd β] [inst_4 : TopologicalSpace γ] [inst_5 : AddMonoid γ]
[inst_6 : ContinuousAdd γ] (g g_1 : β →+ γ) (e_g : g = g_1) (hg : Continuous ⇑g),
AddMonoidHom.compLeftContinuous α g hg = AddMonoidHom.compLeftContinuous α g_1 ⋯ |
Std.ExtDTreeMap.Const.getKey?_filter | Std.Data.ExtDTreeMap.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} {β : Type v} {t : Std.ExtDTreeMap α (fun x => β) cmp} [inst : Std.TransCmp cmp]
{f : α → β → Bool} {k : α},
(Std.ExtDTreeMap.filter f t).getKey? k = (t.getKey? k).pfilter fun x h' => f x (Std.ExtDTreeMap.Const.get t x ⋯) |
CategoryTheory.GrothendieckTopology.toPretopology._proof_4 | Mathlib.CategoryTheory.Sites.Pretopology | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{u_2, u_1} C] (J : CategoryTheory.GrothendieckTopology C) (X : C)
(S : CategoryTheory.Presieve X) (Ti : ⦃Y : C⦄ → (f : Y ⟶ X) → S f → CategoryTheory.Presieve Y),
S ∈ {R | CategoryTheory.Sieve.generate R ∈ J X} →
(∀ ⦃Y : C⦄ (f : Y ⟶ X) (H : S f), Ti f H ∈ {R | CategoryTheory.Sieve.generate R ∈ J Y}) →
S.bind Ti ∈ {R | CategoryTheory.Sieve.generate R ∈ J X} |
AntitoneOn.sup | Mathlib.Order.Lattice | ∀ {α : Type u} {β : Type v} [inst : Preorder α] [inst_1 : SemilatticeSup β] {f g : α → β} {s : Set α},
AntitoneOn f s → AntitoneOn g s → AntitoneOn (f ⊔ g) s |
_private.Mathlib.Algebra.Order.Antidiag.Nat.0.Nat.card_pair_lcm_eq.f._proof_1 | Mathlib.Algebra.Order.Antidiag.Nat | NeZero (2 + 1) |
CategoryTheory.Mon.instCartesianMonoidalCategory._proof_3 | Mathlib.CategoryTheory.Monoidal.Cartesian.Mon_ | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.CartesianMonoidalCategory C]
[inst_2 : CategoryTheory.BraidedCategory C] (M N : CategoryTheory.Mon C),
{ hom := CategoryTheory.SemiCartesianMonoidalCategory.fst M.X N.X, isMonHom_hom := ⋯ } =
CategoryTheory.CategoryStruct.comp
(CategoryTheory.MonoidalCategoryStruct.whiskerLeft M
((CategoryTheory.Limits.IsTerminal.ofUniqueHom
(fun M => { hom := CategoryTheory.SemiCartesianMonoidalCategory.toUnit M.X, isMonHom_hom := ⋯ }) ⋯).from
N))
(CategoryTheory.MonoidalCategoryStruct.rightUnitor M).hom |
StrictMonoOn.continuousWithinAt_right_of_image_mem_nhdsWithin | Mathlib.Topology.Order.MonotoneContinuity | ∀ {α : Type u_1} {β : Type u_2} [inst : LinearOrder α] [inst_1 : TopologicalSpace α] [OrderTopology α]
[inst_3 : LinearOrder β] [inst_4 : TopologicalSpace β] [OrderTopology β] [DenselyOrdered β] {f : α → β} {s : Set α}
{a : α},
StrictMonoOn f s →
s ∈ nhdsWithin a (Set.Ici a) → f '' s ∈ nhdsWithin (f a) (Set.Ici (f a)) → ContinuousWithinAt f (Set.Ici a) a |
Int.Linear.Poly.eval? | Lean.Meta.Tactic.Grind.Arith.Cutsat.Util | Int.Linear.Poly → Lean.Meta.Grind.GoalM (Option ℚ) |
Sylow.inhabited | Mathlib.GroupTheory.Sylow | {p : ℕ} → {G : Type u_1} → [inst : Group G] → Inhabited (Sylow p G) |
_private.Mathlib.Data.Ordmap.Invariants.0.Ordnode.node4L.match_1.eq_2 | Mathlib.Data.Ordmap.Invariants | ∀ {α : Type u_1} (motive : Ordnode α → α → Ordnode α → α → Ordnode α → Sort u_2) (l : Ordnode α) (x z : α)
(r : Ordnode α)
(h_1 :
(l : Ordnode α) →
(x : α) →
(size : ℕ) →
(ml : Ordnode α) →
(y : α) → (mr : Ordnode α) → (z : α) → (r : Ordnode α) → motive l x (Ordnode.node size ml y mr) z r)
(h_2 : (l : Ordnode α) → (x z : α) → (r : Ordnode α) → motive l x Ordnode.nil z r),
(match l, x, Ordnode.nil, z, r with
| l, x, Ordnode.node size ml y mr, z, r => h_1 l x size ml y mr z r
| l, x, Ordnode.nil, z, r => h_2 l x z r) =
h_2 l x z r |
_private.Lean.Meta.Tactic.Simp.Rewrite.0.Lean.Meta.Simp.discharge?'.match_3 | Lean.Meta.Tactic.Simp.Rewrite | (motive : Except Lean.Exception Lean.Meta.Simp.DischargeResult → Sort u_1) →
(x : Except Lean.Exception Lean.Meta.Simp.DischargeResult) →
(Unit → motive (Except.ok Lean.Meta.Simp.DischargeResult.proved)) →
(Unit → motive (Except.ok Lean.Meta.Simp.DischargeResult.notProved)) →
(Unit → motive (Except.ok Lean.Meta.Simp.DischargeResult.maxDepth)) →
(Unit → motive (Except.ok Lean.Meta.Simp.DischargeResult.failedAssign)) →
((err : Lean.Exception) → motive (Except.error err)) → motive x |
BitVec.slt_trichotomy | Init.Data.BitVec.Lemmas | ∀ {w : ℕ} (x y : BitVec w), x.slt y = true ∨ x = y ∨ y.slt x = true |
Set.union_diff_self | Mathlib.Order.BooleanAlgebra.Set | ∀ {α : Type u_1} {s t : Set α}, s ∪ t \ s = s ∪ t |
Matrix.mul_transvection_apply_same | Mathlib.LinearAlgebra.Matrix.Transvection | ∀ {n : Type u_1} {R : Type u₂} [inst : DecidableEq n] [inst_1 : CommRing R] (i j : n) [inst_2 : Fintype n] (a : n)
(c : R) (M : Matrix n n R), (M * Matrix.transvection i j c) a j = M a j + c * M a i |
_private.Std.Tactic.BVDecide.LRAT.Internal.Formula.RatAddSound.0.Std.Tactic.BVDecide.LRAT.Internal.DefaultFormula.mem_of_necessary_assignment._simp_1_4 | Std.Tactic.BVDecide.LRAT.Internal.Formula.RatAddSound | ∀ {α : Sort u_1} {p : α → Prop}, (¬∃ x, p x) = ∀ (x : α), ¬p x |
AddCommGroup.modEq_iff_eq_add_zsmul | Mathlib.Algebra.Group.ModEq | ∀ {G : Type u_1} [inst : AddCommGroup G] {p a b : G}, a ≡ b [PMOD p] ↔ ∃ z, b = a + z • p |
CommMonCat.fullyFaithfulForgetToMonCat.eq_1 | Mathlib.Algebra.Category.MonCat.Basic | CommMonCat.fullyFaithfulForgetToMonCat =
{ preimage := fun {X Y} f => CommMonCat.ofHom (MonCat.Hom.hom f),
map_preimage := @CommMonCat.fullyFaithfulForgetToMonCat._proof_1,
preimage_map := @CommMonCat.fullyFaithfulForgetToMonCat._proof_2 } |
NonUnitalNonAssocSemiring.mem_center_iff | Mathlib.Algebra.Ring.CentroidHom | ∀ {α : Type u_5} [inst : NonUnitalNonAssocSemiring α] (a : α),
a ∈ NonUnitalSubsemiring.center α ↔
AddMonoid.End.mulRight a = AddMonoid.End.mulLeft a ∧ AddMonoid.End.mulLeft a ∈ (CentroidHom.toEndRingHom α).rangeS |
_private.Lean.Compiler.IR.SimpleGroundExpr.0.Lean.IR.State | Lean.Compiler.IR.SimpleGroundExpr | Type |
equicontinuousWithinAt_empty._simp_1 | Mathlib.Topology.UniformSpace.Equicontinuity | ∀ {ι : Type u_1} {X : Type u_3} {α : Type u_6} [tX : TopologicalSpace X] [uα : UniformSpace α] [h : IsEmpty ι]
(F : ι → X → α) (S : Set X) (x₀ : X), EquicontinuousWithinAt F S x₀ = True |
_private.Lean.Elab.Extra.0.Lean.Elab.Term.Op.analyze.go | Lean.Elab.Extra | Lean.Elab.Term.Op.Tree✝ → StateRefT' IO.RealWorld Lean.Elab.Term.Op.AnalyzeResult✝ Lean.Elab.TermElabM Unit |
Lean.Meta.Grind.AC.EqCnstr.casesOn | Lean.Meta.Tactic.Grind.AC.Types | {motive_1 : Lean.Meta.Grind.AC.EqCnstr → Sort u} →
(t : Lean.Meta.Grind.AC.EqCnstr) →
((lhs rhs : Lean.Grind.AC.Seq) →
(h : Lean.Meta.Grind.AC.EqCnstrProof) → (id : ℕ) → motive_1 { lhs := lhs, rhs := rhs, h := h, id := id }) →
motive_1 t |
IccRightChart._proof_1 | Mathlib.Geometry.Manifold.Instances.Real | ∀ (x y : ℝ) [h : Fact (x < y)] (z : EuclideanHalfSpace 1), max (y - (↑z).ofLp 0) x ∈ Set.Icc x y |
Set.inl_compl_union_inr_compl | Mathlib.Order.BooleanAlgebra.Set | ∀ {α : Type u_1} {β : Type u_2} {s : Set α} {t : Set β}, Sum.inl '' sᶜ ∪ Sum.inr '' tᶜ = (Sum.inl '' s ∪ Sum.inr '' t)ᶜ |
_private.Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.Continuity.0.ContinuousOn.cfc_fun._simp_1_1 | Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.Continuity | ∀ {α : Type u_1} {β : Type u_2} {ι : Type u_4} {p : Filter ι} [inst : UniformSpace β] {𝔖 : Set (Set α)}
{F : ι → UniformOnFun α β 𝔖} {f : UniformOnFun α β 𝔖},
Filter.Tendsto F p (nhds f) = ∀ s ∈ 𝔖, TendstoUniformlyOn (⇑(UniformOnFun.toFun 𝔖) ∘ F) ((UniformOnFun.toFun 𝔖) f) p s |
LocallyConstant.mk | Mathlib.Topology.LocallyConstant.Basic | {X : Type u_5} →
{Y : Type u_6} → [inst : TopologicalSpace X] → (toFun : X → Y) → IsLocallyConstant toFun → LocallyConstant X Y |
CategoryTheory.Functor.instMonoidalActionMapAction | Mathlib.CategoryTheory.Action.Monoidal | {V : Type u_1} →
[inst : CategoryTheory.Category.{v_1, u_1} V] →
{G : Type u_2} →
[inst_1 : Monoid G] →
{W : Type u_3} →
[inst_2 : CategoryTheory.Category.{v_2, u_3} W] →
[inst_3 : CategoryTheory.MonoidalCategory V] →
[inst_4 : CategoryTheory.MonoidalCategory W] →
(F : CategoryTheory.Functor V W) → [F.Monoidal] → (F.mapAction G).Monoidal |
Homeomorph.neg._proof_1 | Mathlib.Topology.Algebra.Group.Basic | ∀ (G : Type u_1) [inst : TopologicalSpace G] [inst_1 : InvolutiveNeg G] [ContinuousNeg G], Continuous fun a => -a |
SimpleGraph.UnitDistEmbedding.noConfusion | Mathlib.Combinatorics.SimpleGraph.UnitDistance.Basic | {P : Sort u} →
{V : Type u_1} →
{G : SimpleGraph V} →
{E : Type u_3} →
{inst : MetricSpace E} →
{t : G.UnitDistEmbedding E} →
{V' : Type u_1} →
{G' : SimpleGraph V'} →
{E' : Type u_3} →
{inst' : MetricSpace E'} →
{t' : G'.UnitDistEmbedding E'} →
V = V' →
G ≍ G' → E = E' → inst ≍ inst' → t ≍ t' → SimpleGraph.UnitDistEmbedding.noConfusionType P t t' |
alternatingGroup.isCoatom_stabilizer_of_ncard_lt_ncard_compl | Mathlib.GroupTheory.SpecificGroups.Alternating.MaximalSubgroups | ∀ {α : Type u_1} [inst : Fintype α] [inst_1 : DecidableEq α] {s : Set α},
s.Nontrivial → s.ncard < sᶜ.ncard → IsCoatom (MulAction.stabilizer (↥(alternatingGroup α)) s) |
toAlgHom_comp_sectionOfRetractionKerToTensorAux | Mathlib.RingTheory.Smooth.Kaehler | ∀ {R : Type u_1} {P : Type u_2} {S : Type u_3} [inst : CommRing R] [inst_1 : CommRing P] [inst_2 : CommRing S]
[inst_3 : Algebra R P] [inst_4 : Algebra P S] (l : TensorProduct P S Ω[P⁄R] →ₗ[P] ↥(RingHom.ker (algebraMap P S)))
(hl : l ∘ₗ KaehlerDifferential.kerToTensor R P S = LinearMap.id) (σ : S → P)
(hσ : ∀ (x : S), (algebraMap P S) (σ x) = x) [inst_5 : Algebra R S] [inst_6 : IsScalarTower R P S]
(hf' : RingHom.ker (algebraMap P S) ^ 2 = ⊥),
Function.Surjective ⇑(algebraMap P S) →
(IsScalarTower.toAlgHom R P S).comp (sectionOfRetractionKerToTensorAux l hl σ hσ hf') = AlgHom.id R S |
_private.Mathlib.Data.Finset.Slice.0.Set.sized_iUnion._simp_1_2 | Mathlib.Data.Finset.Slice | ∀ {α : Type u} {ι : Sort v} {x : α} {s : ι → Set α}, (x ∈ ⋃ i, s i) = ∃ i, x ∈ s i |
Bimod.comp | Mathlib.CategoryTheory.Monoidal.Bimod | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
[inst_1 : CategoryTheory.MonoidalCategory C] →
{A B : CategoryTheory.Mon C} → {M N O : Bimod A B} → M.Hom N → N.Hom O → M.Hom O |
CategoryTheory.CommShift₂Setup._sizeOf_inst | Mathlib.CategoryTheory.Shift.CommShiftTwo | (D : Type u_5) →
{inst : CategoryTheory.Category.{v_5, u_5} D} →
(M : Type u_6) →
{inst_1 : AddCommMonoid M} →
{inst_2 : CategoryTheory.HasShift D M} → [SizeOf D] → [SizeOf M] → SizeOf (CategoryTheory.CommShift₂Setup D M) |
List.head_append_right | Init.Data.List.Lemmas | ∀ {α : Type u_1} {l₁ l₂ : List α} (w : l₁ ++ l₂ ≠ []) (h : l₁ = []), (l₁ ++ l₂).head w = l₂.head ⋯ |
GrpCat.fullyFaithfulForget₂ToMonCat._proof_2 | Mathlib.Algebra.Category.Grp.Basic | ∀ {X Y : GrpCat} (f : X ⟶ Y), GrpCat.ofHom (MonCat.Hom.hom ((CategoryTheory.forget₂ GrpCat MonCat).map f)) = f |
QuadraticMap.isOrtho_comm | Mathlib.LinearAlgebra.QuadraticForm.Basic | ∀ {R : Type u_3} {M : Type u_4} {N : Type u_5} [inst : CommSemiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M]
[inst_3 : AddCommMonoid N] [inst_4 : Module R N] {Q : QuadraticMap R M N} {x y : M}, Q.IsOrtho x y ↔ Q.IsOrtho y x |
Subgroup.finite_quotient_of_finiteIndex | Mathlib.GroupTheory.Index | ∀ {G : Type u_1} [inst : Group G] {H : Subgroup G} [H.FiniteIndex], Finite (G ⧸ H) |
Matroid.IsCocircuit.delete_isCocircuit | Mathlib.Combinatorics.Matroid.Minor.Contract | ∀ {α : Type u_1} {M : Matroid α} {K D : Set α}, M.IsCocircuit K → D ⊂ K → (M.delete D).IsCocircuit (K \ D) |
_private.Mathlib.Order.Interval.Finset.Basic.0.Finset.Iic_top._simp_1_1 | Mathlib.Order.Interval.Finset.Basic | ∀ {α : Type u_1} [inst : Preorder α] [inst_1 : LocallyFiniteOrderBot α] {a x : α}, (x ∈ Finset.Iic a) = (x ≤ a) |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.