name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M |
|---|---|---|
AddMonoidAlgebra.mapRangeAlgEquiv._proof_7 | Mathlib.Algebra.MonoidAlgebra.Basic | ∀ (R : Type u_4) {A : Type u_3} {B : Type u_2} (M : Type u_1) [inst : CommSemiring R] [inst_1 : Semiring A]
[inst_2 : Semiring B] [inst_3 : Algebra R A] [inst_4 : Algebra R B] [inst_5 : AddMonoid M] (e : A ≃ₐ[R] B) (r : R),
(↑↑(AddMonoidAlgebra.mapRangeAlgHom M ↑e).toRingHom).toFun ((algebraMap R (AddMonoidAlgebra A M)) r) =
(algebraMap R (AddMonoidAlgebra B M)) r |
_private.Init.Data.Range.Polymorphic.Internal.SignedBitVec.0.BitVec.Signed.instRxcLawfulHasSize._proof_3 | Init.Data.Range.Polymorphic.Internal.SignedBitVec | ∀ (n : ℕ), ¬n + 1 > 0 → False |
mem_openSegment_iff_div | Mathlib.Analysis.Convex.Segment | ∀ {𝕜 : Type u_1} {E : Type u_2} [inst : Semifield 𝕜] [inst_1 : LinearOrder 𝕜] [IsStrictOrderedRing 𝕜]
[inst_3 : AddCommGroup E] [inst_4 : Module 𝕜 E] {x y z : E},
x ∈ openSegment 𝕜 y z ↔ ∃ a b, 0 < a ∧ 0 < b ∧ (a / (a + b)) • y + (b / (a + b)) • z = x |
Batteries.RBNode.depth.eq_def | Batteries.Data.RBMap.Depth | ∀ {α : Type u_1} (x : Batteries.RBNode α),
x.depth =
match x with
| Batteries.RBNode.nil => 0
| Batteries.RBNode.node c a v b => max a.depth b.depth + 1 |
CategoryTheory.SemiCartesianMonoidalCategory.comp_toUnit_assoc | Mathlib.CategoryTheory.Monoidal.Cartesian.Basic | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.SemiCartesianMonoidalCategory C]
{X Y : C} (f : X ⟶ Y) {Z : C} (h : CategoryTheory.MonoidalCategoryStruct.tensorUnit C ⟶ Z),
CategoryTheory.CategoryStruct.comp f
(CategoryTheory.CategoryStruct.comp (CategoryTheory.SemiCartesianMonoidalCategory.toUnit Y) h) =
CategoryTheory.CategoryStruct.comp (CategoryTheory.SemiCartesianMonoidalCategory.toUnit X) h |
IsPurelyInseparable.iterateFrobenius._proof_4 | Mathlib.FieldTheory.PurelyInseparable.Exponent | ∀ (K : Type u_1) (L : Type u_2) [inst : Field K] [inst_1 : Field L] [inst_2 : Algebra K L]
[inst_3 : IsPurelyInseparable.HasExponent K L] (p : ℕ) [ExpChar K p] {n : ℕ},
IsPurelyInseparable.exponent K L ≤ n →
∀ (a b : L),
IsPurelyInseparable.iterateFrobeniusAux✝ K L p n (a + b) =
IsPurelyInseparable.iterateFrobeniusAux✝¹ K L p n a + IsPurelyInseparable.iterateFrobeniusAux✝² K L p n b |
_private.Mathlib.Order.Nucleus.0.Nucleus.giAux._proof_2 | Mathlib.Order.Nucleus | ∀ {X : Type u_1} [inst : Order.Frame X] (n : Nucleus X) (x : X) (y : ↑(Set.range ⇑n)),
n.toClosureOperator x ≤ ↑y ↔ x ≤ ↑y |
Lean.Expr.FoldConstsImpl.State.rec | Lean.Util.FoldConsts | {motive : Lean.Expr.FoldConstsImpl.State → Sort u} →
((visited : Lean.PtrSet Lean.Expr) →
(visitedConsts : Lean.NameHashSet) → motive { visited := visited, visitedConsts := visitedConsts }) →
(t : Lean.Expr.FoldConstsImpl.State) → motive t |
Odd.neg | Mathlib.Algebra.Ring.Parity | ∀ {α : Type u_2} [inst : Ring α] {a : α}, Odd a → Odd (-a) |
KaehlerDifferential.fromIdeal_surjective | Mathlib.RingTheory.Kaehler.Basic | ∀ (R : Type u) (S : Type v) [inst : CommRing R] [inst_1 : CommRing S] [inst_2 : Algebra R S],
Function.Surjective ⇑(KaehlerDifferential.fromIdeal R S) |
ByteArray.append_left_inj._simp_1 | Init.Data.ByteArray.Lemmas | ∀ {xs₁ xs₂ : ByteArray} (ys : ByteArray), (xs₁ ++ ys = xs₂ ++ ys) = (xs₁ = xs₂) |
_private.Mathlib.Algebra.Module.LinearMap.End.0.Module.End.iterate_bijective.match_1_1 | Mathlib.Algebra.Module.LinearMap.End | ∀ (motive : ℕ → Prop) (x : ℕ), (∀ (a : Unit), motive 0) → (∀ (n : ℕ), motive n.succ) → motive x |
List.next_eq_getElem._proof_2 | Mathlib.Data.List.Cycle | ∀ {α : Type u_1} {l : List α} {a : α}, a ∈ l → 0 < l.length |
_private.Mathlib.Combinatorics.Additive.ApproximateSubgroup.0.IsApproximateSubgroup.pow_inter_pow._proof_1_2 | Mathlib.Combinatorics.Additive.ApproximateSubgroup | ∀ {m : ℕ}, 2 ≤ m → 2 ≤ 2 * m |
AlgebraicGeometry.SheafedSpace.ext._proof_1 | Mathlib.Geometry.RingedSpace.SheafedSpace | ∀ {C : Type u_3} [inst : CategoryTheory.Category.{u_2, u_3} C] {X Y : AlgebraicGeometry.SheafedSpace C} (α β : X ⟶ Y),
α.hom.base = β.hom.base → (TopologicalSpace.Opens.map α.hom.base).op = (TopologicalSpace.Opens.map β.hom.base).op |
IsLocalDiffeomorphAt.mfderivToContinuousLinearEquiv | Mathlib.Geometry.Manifold.LocalDiffeomorph | {𝕜 : Type u_1} →
[inst : NontriviallyNormedField 𝕜] →
{E : Type u_2} →
[inst_1 : NormedAddCommGroup E] →
[inst_2 : NormedSpace 𝕜 E] →
{F : Type u_3} →
[inst_3 : NormedAddCommGroup F] →
[inst_4 : NormedSpace 𝕜 F] →
{H : Type u_4} →
[inst_5 : TopologicalSpace H] →
{G : Type u_5} →
[inst_6 : TopologicalSpace G] →
{I : ModelWithCorners 𝕜 E H} →
{J : ModelWithCorners 𝕜 F G} →
{M : Type u_6} →
[inst_7 : TopologicalSpace M] →
[inst_8 : ChartedSpace H M] →
{N : Type u_7} →
[inst_9 : TopologicalSpace N] →
[inst_10 : ChartedSpace G N] →
{n : WithTop ℕ∞} →
{f : M → N} →
{x : M} →
IsLocalDiffeomorphAt I J n f x →
n ≠ 0 → TangentSpace I x ≃L[𝕜] TangentSpace J (f x) |
exists_linearIndepOn_id_extension | Mathlib.LinearAlgebra.LinearIndependent.Lemmas | ∀ {K : Type u_3} {V : Type u} [inst : DivisionRing K] [inst_1 : AddCommGroup V] [inst_2 : Module K V] {s t : Set V},
LinearIndepOn K id s → s ⊆ t → ∃ b ⊆ t, s ⊆ b ∧ t ⊆ ↑(Submodule.span K b) ∧ LinearIndepOn K id b |
OrderRingIso.instInhabited | Mathlib.Algebra.Order.Hom.Ring | (α : Type u_2) → [inst : Mul α] → [inst_1 : Add α] → [inst_2 : LE α] → Inhabited (α ≃+*o α) |
Matrix.isSymm_fromBlocks_iff | Mathlib.LinearAlgebra.Matrix.Symmetric | ∀ {α : Type u_1} {n : Type u_3} {m : Type u_4} {A : Matrix m m α} {B : Matrix m n α} {C : Matrix n m α}
{D : Matrix n n α}, (Matrix.fromBlocks A B C D).IsSymm ↔ A.IsSymm ∧ B.transpose = C ∧ C.transpose = B ∧ D.IsSymm |
Std.Sat.AIG.RefVec.fold.go._unary | Std.Sat.AIG.RefVecOperator.Fold | {α : Type} →
[inst : Hashable α] →
[inst_1 : DecidableEq α] →
(len : ℕ) →
(f : (aig : Std.Sat.AIG α) → aig.BinaryInput → Std.Sat.AIG.Entrypoint α) →
[Std.Sat.AIG.LawfulOperator α Std.Sat.AIG.BinaryInput f] →
(aig : Std.Sat.AIG α) ×' (_ : aig.Ref) ×' (_ : ℕ) ×' aig.RefVec len → Std.Sat.AIG.Entrypoint α |
IsProperMap.clusterPt_of_mapClusterPt | Mathlib.Topology.Maps.Proper.Basic | ∀ {X : Type u_1} {Y : Type u_2} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y] {f : X → Y},
IsProperMap f → ∀ ⦃ℱ : Filter X⦄ ⦃y : Y⦄, MapClusterPt y ℱ f → ∃ x, f x = y ∧ ClusterPt x ℱ |
StarOrderedRing.toExistsAddOfLE | Mathlib.Algebra.Order.Star.Basic | ∀ {R : Type u_1} [inst : NonUnitalSemiring R] [inst_1 : PartialOrder R] [inst_2 : StarRing R] [StarOrderedRing R],
ExistsAddOfLE R |
Std.HashSet.Raw.not_mem_emptyWithCapacity._simp_1 | Std.Data.HashSet.RawLemmas | ∀ {α : Type u} [inst : BEq α] [inst_1 : Hashable α] {a : α} {c : ℕ}, (a ∈ Std.HashSet.Raw.emptyWithCapacity c) = False |
CategoryTheory.Functor.chosenProd.snd | Mathlib.CategoryTheory.Monoidal.Cartesian.FunctorCategory | {C : Type u} →
{inst : CategoryTheory.Category.{v, u} C} →
[self : CategoryTheory.SemiCartesianMonoidalCategory C] →
(X Y : C) → CategoryTheory.MonoidalCategoryStruct.tensorObj X Y ⟶ Y |
CategoryTheory.Limits.coneOfDiagramInitial | Mathlib.CategoryTheory.Limits.Shapes.IsTerminal | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
{J : Type u} →
[inst_1 : CategoryTheory.Category.{v, u} J] →
{X : J} → CategoryTheory.Limits.IsInitial X → (F : CategoryTheory.Functor J C) → CategoryTheory.Limits.Cone F |
CategoryTheory.Presheaf.coherentExtensiveEquivalence | Mathlib.CategoryTheory.Sites.Coherent.SheafComparison | {C : Type u_1} →
[inst : CategoryTheory.Category.{v_1, u_1} C] →
{A : Type u₃} →
[inst_1 : CategoryTheory.Category.{v₃, u₃} A] →
[inst_2 : CategoryTheory.Preregular C] →
[inst_3 : CategoryTheory.FinitaryExtensive C] →
[∀ (X : C), CategoryTheory.Projective X] →
CategoryTheory.Sheaf (CategoryTheory.coherentTopology C) A ≌
CategoryTheory.Sheaf (CategoryTheory.extensiveTopology C) A |
DomMulAct.instInvOneClassOfMulOpposite.eq_1 | Mathlib.GroupTheory.GroupAction.DomAct.Basic | ∀ {M : Type u_1} [inst : InvOneClass Mᵐᵒᵖ], DomMulAct.instInvOneClassOfMulOpposite = inst |
CategoryTheory.InjectiveResolution.descIdHomotopy._proof_1 | Mathlib.CategoryTheory.Abelian.Injective.Resolution | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.Abelian C] (X : C)
(I : CategoryTheory.InjectiveResolution X),
CategoryTheory.CategoryStruct.comp I.ι
(CategoryTheory.InjectiveResolution.desc (CategoryTheory.CategoryStruct.id X) I I) =
CategoryTheory.CategoryStruct.comp ((CochainComplex.single₀ C).map (CategoryTheory.CategoryStruct.id X)) I.ι |
_private.Mathlib.Order.Interval.Set.WithBotTop.0.WithBot.preimage_coe_Ioc_bot._simp_1_1 | Mathlib.Order.Interval.Set.WithBotTop | ∀ {α : Type u_1} [inst : Preorder α] {a b : α}, Set.Ioc a b = Set.Ioi a ∩ Set.Iic b |
OpenAddSubgroup.comap | Mathlib.Topology.Algebra.OpenSubgroup | {G : Type u_1} →
[inst : AddGroup G] →
[inst_1 : TopologicalSpace G] →
{N : Type u_2} →
[inst_2 : AddGroup N] →
[inst_3 : TopologicalSpace N] → (f : G →+ N) → Continuous ⇑f → OpenAddSubgroup N → OpenAddSubgroup G |
Finsupp.comapDistribMulAction._proof_1 | Mathlib.Data.Finsupp.SMul | ∀ {α : Type u_1} {M : Type u_2} {G : Type u_3} [inst : Monoid G] [inst_1 : MulAction G α] [inst_2 : AddCommMonoid M]
(g : G), g • 0 = 0 |
_private.Mathlib.Order.Category.FinBddDistLat.0.FinBddDistLat.Hom.mk.sizeOf_spec | Mathlib.Order.Category.FinBddDistLat | ∀ {X Y : FinBddDistLat} (hom' : BoundedLatticeHom ↑X.toDistLat ↑Y.toDistLat), sizeOf { hom' := hom' } = 1 + sizeOf hom' |
Matrix.permMatrix_mem_colStochastic | Mathlib.LinearAlgebra.Matrix.Stochastic | ∀ {R : Type u_1} {n : Type u_2} [inst : Fintype n] [inst_1 : DecidableEq n] [inst_2 : Semiring R]
[inst_3 : PartialOrder R] [inst_4 : IsOrderedRing R] {σ : Equiv.Perm n},
Equiv.Perm.permMatrix R σ ∈ Matrix.colStochastic R n |
StarAlgHom.ext_iff | Mathlib.Algebra.Star.StarAlgHom | ∀ {R : Type u_2} {A : Type u_3} {B : Type u_4} [inst : CommSemiring R] [inst_1 : Semiring A] [inst_2 : Algebra R A]
[inst_3 : Star A] [inst_4 : Semiring B] [inst_5 : Algebra R B] [inst_6 : Star B] {f g : A →⋆ₐ[R] B},
f = g ↔ ∀ (x : A), f x = g x |
QuadraticMap.instNeg._proof_1 | Mathlib.LinearAlgebra.QuadraticForm.Basic | ∀ {R : Type u_3} {M : Type u_1} {N : Type u_2} [inst : CommRing R] [inst_1 : AddCommGroup M] [inst_2 : Module R M]
[inst_3 : AddCommGroup N] [inst_4 : Module R N] (Q : QuadraticMap R M N),
∃ B, ∀ (x y : M), (-⇑Q) (x + y) = (-⇑Q) x + (-⇑Q) y + (B x) y |
CategoryTheory.Grothendieck.isoMk_hom_fiber | Mathlib.CategoryTheory.Grothendieck | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {F : CategoryTheory.Functor C CategoryTheory.Cat}
{X Y : CategoryTheory.Grothendieck F} (e₁ : X.base ≅ Y.base) (e₂ : (F.map e₁.hom).toFunctor.obj X.fiber ≅ Y.fiber),
(CategoryTheory.Grothendieck.isoMk e₁ e₂).hom.fiber = e₂.hom |
MeasureTheory.Measure.Regular.exists_isCompact_not_null | Mathlib.MeasureTheory.Measure.Regular | ∀ {α : Type u_1} [inst : MeasurableSpace α] {μ : MeasureTheory.Measure α} [inst_1 : TopologicalSpace α] [μ.Regular],
(∃ K, IsCompact K ∧ μ K ≠ 0) ↔ μ ≠ 0 |
_private.Mathlib.NumberTheory.PellMatiyasevic.0.Pell.eq_pell_lem.match_1_3 | Mathlib.NumberTheory.PellMatiyasevic | ∀ {a : ℕ} (a1 : 1 < a) (motive : ℕ → ℤ√↑(Pell.d✝ a1) → Prop) (x : ℕ) (x_1 : ℤ√↑(Pell.d✝¹ a1)),
(∀ (x : ℤ√↑(Pell.d✝² a1)), motive 0 x) → (∀ (n : ℕ) (b : ℤ√↑(Pell.d✝³ a1)), motive n.succ b) → motive x x_1 |
CategoryTheory.Limits.BinaryFan.isLimit_iff_isIso_fst | Mathlib.CategoryTheory.Limits.Shapes.BinaryProducts | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {X Y : C} (h : CategoryTheory.Limits.IsTerminal Y)
(c : CategoryTheory.Limits.BinaryFan X Y), Nonempty (CategoryTheory.Limits.IsLimit c) ↔ CategoryTheory.IsIso c.fst |
isUpperSet_setOf._simp_1 | Mathlib.Order.UpperLower.Basic | ∀ {α : Type u_1} [inst : Preorder α] {p : α → Prop}, IsUpperSet {a | p a} = Monotone p |
_private.Lean.Meta.HaveTelescope.0.Lean.Meta.simpHaveTelescope.match_7 | Lean.Meta.HaveTelescope | (motive : Array Bool × Array Bool → Sort u_1) →
(__discr : Array Bool × Array Bool) → ((fixed used : Array Bool) → motive (fixed, used)) → motive __discr |
_private.Init.Data.UInt.Lemmas.0.UInt32.lt_of_le_of_ne._simp_1_2 | Init.Data.UInt.Lemmas | ∀ {a b : UInt32}, (a ≤ b) = (a.toNat ≤ b.toNat) |
LinearMap.range_dualMap_eq_dualAnnihilator_ker | Mathlib.LinearAlgebra.Dual.Lemmas | ∀ {K : Type u_1} {V₁ : Type u_2} {V₂ : Type u_3} [inst : Field K] [inst_1 : AddCommGroup V₁] [inst_2 : Module K V₁]
[inst_3 : AddCommGroup V₂] [inst_4 : Module K V₂] (f : V₁ →ₗ[K] V₂), f.dualMap.range = f.ker.dualAnnihilator |
CategoryTheory.Under.postEquiv_functor | Mathlib.CategoryTheory.Comma.Over.Basic | ∀ {T : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} T] {D : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
(X : T) (F : T ≌ D), (CategoryTheory.Under.postEquiv X F).functor = CategoryTheory.Under.post F.functor |
_private.Mathlib.Algebra.FreeAlgebra.0.FreeAlgebra.liftAux._proof_1 | Mathlib.Algebra.FreeAlgebra | ∀ (R : Type u_1) {X : Type u_2} [inst : CommSemiring R] {A : Type u_3} [inst_1 : Semiring A] [inst_2 : Algebra R A]
(f : X → A) (a b : FreeAlgebra.Pre R X),
FreeAlgebra.Rel R X a b → FreeAlgebra.liftFun R X f a = FreeAlgebra.liftFun R X f b |
HasStrictDerivAt.clog | Mathlib.Analysis.SpecialFunctions.Complex.LogDeriv | ∀ {f : ℂ → ℂ} {f' x : ℂ},
HasStrictDerivAt f f' x → f x ∈ Complex.slitPlane → HasStrictDerivAt (fun t => Complex.log (f t)) (f' / f x) x |
BooleanSubalgebra.val_bot | Mathlib.Order.BooleanSubalgebra | ∀ {α : Type u_2} [inst : BooleanAlgebra α] {L : BooleanSubalgebra α}, ↑⊥ = ⊥ |
PFun.preimage_eq | Mathlib.Data.PFun | ∀ {α : Type u_1} {β : Type u_2} (f : α →. β) (s : Set β), f.preimage s = f.core s ∩ f.Dom |
Codisjoint.sup_right' | Mathlib.Order.Disjoint | ∀ {α : Type u_1} [inst : SemilatticeSup α] [inst_1 : OrderTop α] {a b : α} (c : α),
Codisjoint a b → Codisjoint a (c ⊔ b) |
_private.Mathlib.Data.Fin.Tuple.Reflection.0.FinVec.prod_eq.match_1_1 | Mathlib.Data.Fin.Tuple.Reflection | ∀ {α : Type u_1} (motive : (x : ℕ) → (Fin x → α) → Prop) (x : ℕ) (x_1 : Fin x → α),
(∀ (x : Fin 0 → α), motive 0 x) →
(∀ (a : Fin 1 → α), motive 1 a) → (∀ (n : ℕ) (a : Fin (n + 2) → α), motive n.succ.succ a) → motive x x_1 |
HomotopicalAlgebra.CofibrantObject.ι | Mathlib.AlgebraicTopology.ModelCategory.Bifibrant | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
[inst_1 : HomotopicalAlgebra.CategoryWithCofibrations C] →
[inst_2 : CategoryTheory.Limits.HasInitial C] → CategoryTheory.Functor (HomotopicalAlgebra.CofibrantObject C) C |
Lean.Parser.Term.doUnless._regBuiltin.Lean.Parser.Term.doUnless_1 | Lean.Parser.Do | IO Unit |
Bipointed.swap._proof_1 | Mathlib.CategoryTheory.Category.Bipointed | ∀ (X : Bipointed),
{ toFun := (CategoryTheory.CategoryStruct.id X).toFun, map_fst := ⋯, map_snd := ⋯ } =
CategoryTheory.CategoryStruct.id { X := X.X, toProd := X.toProd.swap } |
TopologicalSpace.PositiveCompacts.locallyCompactSpace_of_addGroup | Mathlib.Topology.Algebra.Group.Compact | ∀ {G : Type u} [inst : TopologicalSpace G] [inst_1 : AddGroup G] [IsTopologicalAddGroup G]
(K : TopologicalSpace.PositiveCompacts G), LocallyCompactSpace G |
_private.Lean.Meta.Transform.0.Lean.Meta.transformWithCache.visit.visitPost._unsafe_rec | Lean.Meta.Transform | {m : Type → Type} →
[Monad m] →
[MonadLiftT Lean.MetaM m] →
[MonadControlT Lean.MetaM m] →
(Lean.Expr → m Lean.TransformStep) →
(Lean.Expr → m Lean.TransformStep) →
Bool →
Bool →
Bool →
(x : STWorld IO.RealWorld m) →
MonadLiftT (ST IO.RealWorld) m →
Lean.Expr → Lean.MonadCacheT Lean.ExprStructEq Lean.Expr m Lean.Expr |
_private.Lean.Elab.Tactic.Do.ProofMode.Refine.0.Lean.Elab.Tactic.Do.ProofMode.patAsTerm.match_1 | Lean.Elab.Tactic.Do.ProofMode.Refine | (motive : Lean.Parser.Tactic.MRefinePat → Sort u_1) →
(pat : Lean.Parser.Tactic.MRefinePat) →
((t : Lean.TSyntax `term) → motive (Lean.Parser.Tactic.MRefinePat.pure t)) →
((name : Lean.TSyntax `Lean.binderIdent) → motive (Lean.Parser.Tactic.MRefinePat.one name)) →
((x : Lean.Parser.Tactic.MRefinePat) → motive x) → motive pat |
_private.Mathlib.FieldTheory.Finite.Basic.0._aux_Mathlib_FieldTheory_Finite_Basic___macroRules__private_Mathlib_FieldTheory_Finite_Basic_0_termQ_1 | Mathlib.FieldTheory.Finite.Basic | Lean.Macro |
MeasureTheory.Filtration.mk.inj | Mathlib.Probability.Process.Filtration | ∀ {Ω : Type u_1} {ι : Type u_2} {inst : Preorder ι} {m : MeasurableSpace Ω} {seq : ι → MeasurableSpace Ω}
{mono' : Monotone seq} {le' : ∀ (i : ι), seq i ≤ m} {seq_1 : ι → MeasurableSpace Ω} {mono'_1 : Monotone seq_1}
{le'_1 : ∀ (i : ι), seq_1 i ≤ m},
{ seq := seq, mono' := mono', le' := le' } = { seq := seq_1, mono' := mono'_1, le' := le'_1 } → seq = seq_1 |
AddSubgroup.isComplement'_bot_top | Mathlib.GroupTheory.Complement | ∀ {G : Type u_1} [inst : AddGroup G], ⊥.IsComplement' ⊤ |
NonUnitalAlgHom.rec | Mathlib.Algebra.Algebra.NonUnitalHom | {R : Type u} →
{S : Type u₁} →
[inst : Monoid R] →
[inst_1 : Monoid S] →
{φ : R →* S} →
{A : Type v} →
{B : Type w} →
[inst_2 : NonUnitalNonAssocSemiring A] →
[inst_3 : DistribMulAction R A] →
[inst_4 : NonUnitalNonAssocSemiring B] →
[inst_5 : DistribMulAction S B] →
{motive : (A →ₛₙₐ[φ] B) → Sort u_1} →
((toDistribMulActionHom : A →ₑ+[φ] B) →
(map_mul' :
∀ (x y : A),
toDistribMulActionHom.toFun (x * y) =
toDistribMulActionHom.toFun x * toDistribMulActionHom.toFun y) →
motive { toDistribMulActionHom := toDistribMulActionHom, map_mul' := map_mul' }) →
(t : A →ₛₙₐ[φ] B) → motive t |
Set.mul_mem_center | Mathlib.Algebra.Group.Center | ∀ {M : Type u_1} [inst : Mul M] {z₁ z₂ : M}, z₁ ∈ Set.center M → z₂ ∈ Set.center M → z₁ * z₂ ∈ Set.center M |
Nat.xor_mod_two_eq_one._simp_1 | Init.Data.Nat.Bitwise.Lemmas | ∀ {a b : ℕ}, ((a ^^^ b) % 2 = 1) = ¬(a % 2 = 1 ↔ b % 2 = 1) |
Function.IsPeriodicPt.piMap | Mathlib.Dynamics.PeriodicPts.Defs | ∀ {ι : Type u_1} {α : ι → Type u_2} {f : (i : ι) → α i → α i} {x : (i : ι) → α i} {n : ℕ},
(∀ (i : ι), Function.IsPeriodicPt (f i) n (x i)) → Function.IsPeriodicPt (Pi.map f) n x |
Std.ExtTreeSet.get_min? | Std.Data.ExtTreeSet.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} {t : Std.ExtTreeSet α cmp} [inst : Std.TransCmp cmp] {km : α}
{hc : t.contains km = true}, t.min?.get ⋯ = km → t.get km hc = km |
Mathlib.Tactic.BicategoryLike.MonadMor₂Iso.noConfusion | Mathlib.Tactic.CategoryTheory.Coherence.Datatypes | {P : Sort u} →
{m : Type → Type} →
{t : Mathlib.Tactic.BicategoryLike.MonadMor₂Iso m} →
{m' : Type → Type} →
{t' : Mathlib.Tactic.BicategoryLike.MonadMor₂Iso m'} →
m = m' → t ≍ t' → Mathlib.Tactic.BicategoryLike.MonadMor₂Iso.noConfusionType P t t' |
_private.Init.Data.BitVec.Lemmas.0.BitVec.msb_twoPow._simp_1_2 | Init.Data.BitVec.Lemmas | ∀ {a b c : Prop}, (a ∧ b → c) = (a → b → c) |
CategoryTheory.Limits.limit.hom_ext_iff | Mathlib.CategoryTheory.Limits.HasLimits | ∀ {J : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} J] {C : Type u} [inst_1 : CategoryTheory.Category.{v, u} C]
{F : CategoryTheory.Functor J C} [inst_2 : CategoryTheory.Limits.HasLimit F] {X : C}
{f f' : X ⟶ CategoryTheory.Limits.limit F},
f = f' ↔
∀ (j : J),
CategoryTheory.CategoryStruct.comp f (CategoryTheory.Limits.limit.π F j) =
CategoryTheory.CategoryStruct.comp f' (CategoryTheory.Limits.limit.π F j) |
Lean.ModuleDoc.mk._flat_ctor | Lean.DocString.Extension | String → Lean.DeclarationRange → Lean.ModuleDoc |
ConvexCone.hull_min | Mathlib.Geometry.Convex.Cone.Basic | ∀ {R : Type u_2} {M : Type u_4} [inst : Semiring R] [inst_1 : PartialOrder R] [inst_2 : AddCommMonoid M]
[inst_3 : SMul R M] {C : ConvexCone R M} {s : Set M}, s ⊆ ↑C → ConvexCone.hull R s ≤ C |
InverseSystem.piEquivLim | Mathlib.Order.DirectedInverseSystem | {ι : Type u_6} →
{F : ι → Type u_7} →
{X : ι → Type u_8} →
{i : ι} →
[inst : LinearOrder ι] →
{f : ⦃i j : ι⦄ → i ≤ j → F j → F i} →
{equiv : (j : ↑(Set.Iio i)) → F ↑j ≃ InverseSystem.piLT X ↑j} →
InverseSystem.IsNatEquiv f equiv →
F i ≃ ↑(InverseSystem.limit f i) →
Order.IsSuccPrelimit i → (j : ↑(Set.Iic i)) → F ↑j ≃ InverseSystem.piLT X ↑j |
_private.Mathlib.Analysis.SpecialFunctions.ContinuousFunctionalCalculus.Rpow.IntegralRepresentation.0.CFC.exists_measure_nnrpow_eq_integral_cfcₙ_rpowIntegrand₀₁._proof_1_3 | Mathlib.Analysis.SpecialFunctions.ContinuousFunctionalCalculus.Rpow.IntegralRepresentation | ∀ (A : Type u_1) [inst : NonUnitalNormedRing A] [inst_1 : NormedSpace ℝ A] [inst_2 : PartialOrder A]
[NonnegSpectrumClass ℝ A] (a : A), 0 ≤ a → quasispectrum ℝ a ⊆ Set.Ici 0 |
Equiv.prodEmpty | Mathlib.Logic.Equiv.Prod | (α : Type u_9) → α × Empty ≃ Empty |
CategoryTheory.instCategoryComonad._proof_4 | Mathlib.CategoryTheory.Monad.Basic | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] (M : CategoryTheory.Comonad C) (X : C),
CategoryTheory.CategoryStruct.comp ((CategoryTheory.CategoryStruct.id M.toFunctor).app X) (M.δ.app X) =
CategoryTheory.CategoryStruct.comp (M.δ.app X)
(CategoryTheory.CategoryStruct.comp ((CategoryTheory.CategoryStruct.id M.toFunctor).app (M.obj X))
(M.map ((CategoryTheory.CategoryStruct.id M.toFunctor).app X))) |
AddSemigroupAction.casesOn | Mathlib.Algebra.Group.Action.Defs | {G : Type u_9} →
{P : Type u_10} →
[inst : AddSemigroup G] →
{motive : AddSemigroupAction G P → Sort u} →
(t : AddSemigroupAction G P) →
([toVAdd : VAdd G P] →
(add_vadd : ∀ (g₁ g₂ : G) (p : P), (g₁ + g₂) +ᵥ p = g₁ +ᵥ g₂ +ᵥ p) →
motive { toVAdd := toVAdd, add_vadd := add_vadd }) →
motive t |
Polynomial.expand_pow | Mathlib.Algebra.Polynomial.Expand | ∀ {R : Type u} [inst : CommSemiring R] (p q : ℕ) (f : Polynomial R),
(Polynomial.expand R (p ^ q)) f = (⇑(Polynomial.expand R p))^[q] f |
CategoryTheory.OplaxFunctor.PseudoCore.mk._flat_ctor | Mathlib.CategoryTheory.Bicategory.Functor.Oplax | {B : Type u₁} →
[inst : CategoryTheory.Bicategory B] →
{C : Type u₂} →
[inst_1 : CategoryTheory.Bicategory C] →
{F : CategoryTheory.OplaxFunctor B C} →
(mapIdIso :
(a : B) → F.map (CategoryTheory.CategoryStruct.id a) ≅ CategoryTheory.CategoryStruct.id (F.obj a)) →
(mapCompIso :
{a b c : B} →
(f : a ⟶ b) →
(g : b ⟶ c) →
F.map (CategoryTheory.CategoryStruct.comp f g) ≅
CategoryTheory.CategoryStruct.comp (F.map f) (F.map g)) →
autoParam (∀ {a : B}, (mapIdIso a).hom = F.mapId a)
CategoryTheory.OplaxFunctor.PseudoCore.mapIdIso_hom._autoParam →
autoParam (∀ {a b c : B} (f : a ⟶ b) (g : b ⟶ c), (mapCompIso f g).hom = F.mapComp f g)
CategoryTheory.OplaxFunctor.PseudoCore.mapCompIso_hom._autoParam →
F.PseudoCore |
_private.Mathlib.Order.Height.0.Set.one_le_chainHeight_iff._simp_1_1 | Mathlib.Order.Height | ∀ {n : ℕ∞}, (n < 1) = (n = 0) |
_private.Mathlib.Analysis.SpecialFunctions.Trigonometric.Chebyshev.Orthogonality.0.Polynomial.Chebyshev.integral_eval_T_real_mul_self_measureT_zero._simp_1_1 | Mathlib.Analysis.SpecialFunctions.Trigonometric.Chebyshev.Orthogonality | ∀ {R : Type u} [inst : CommSemiring R] {p q : Polynomial R} {x : R},
Polynomial.eval x p * Polynomial.eval x q = Polynomial.eval x (p * q) |
CategoryTheory.Limits.Trident.app_zero_assoc | Mathlib.CategoryTheory.Limits.Shapes.WideEqualizers | ∀ {J : Type w} {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {X Y : C} {f : J → (X ⟶ Y)}
(s : CategoryTheory.Limits.Trident f) (j : J) {Z : C} (h : Y ⟶ Z),
CategoryTheory.CategoryStruct.comp (s.π.app CategoryTheory.Limits.WalkingParallelFamily.zero)
(CategoryTheory.CategoryStruct.comp (f j) h) =
CategoryTheory.CategoryStruct.comp (s.π.app CategoryTheory.Limits.WalkingParallelFamily.one) h |
SignType.pos | Mathlib.Data.Sign.Defs | SignType |
IterateMulAct.instCommMonoid._proof_5 | Mathlib.GroupTheory.GroupAction.IterateAct | ∀ {α : Type u_1} {f : α → α} (x x_1 : IterateMulAct f), x * x_1 = x_1 * x |
OrderedFinpartition.compAlongOrderedFinpartitionₗ._proof_1 | Mathlib.Analysis.Calculus.ContDiff.FaaDiBruno | ∀ {𝕜 : Type u_3} [inst : NontriviallyNormedField 𝕜] {E : Type u_1} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {F : Type u_4} [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace 𝕜 F] {G : Type u_2}
[inst_5 : NormedAddCommGroup G] [inst_6 : NormedSpace 𝕜 G] {n : ℕ} (c : OrderedFinpartition n)
(f : ContinuousMultilinearMap 𝕜 (fun i => F) G) (p : (i : Fin c.length) → ContinuousMultilinearMap 𝕜 (fun i => E) F)
(m : Fin c.length) (q q' : ContinuousMultilinearMap 𝕜 (fun i => E) F),
(fun p => c.compAlongOrderedFinpartition f p) (Function.update p m (q + q')) =
(fun p => c.compAlongOrderedFinpartition f p) (Function.update p m q) +
(fun p => c.compAlongOrderedFinpartition f p) (Function.update p m q') |
Lean.Meta.Tactic.Backtrack.BacktrackConfig.mk._flat_ctor | Lean.Meta.Tactic.Backtrack | ℕ →
(List Lean.MVarId → List Lean.MVarId → Lean.MetaM (Option (List Lean.MVarId))) →
(Lean.MVarId → Lean.MetaM Bool) →
(Lean.MVarId → Lean.MetaM (Option (List Lean.MVarId))) → Bool → Lean.Meta.Tactic.Backtrack.BacktrackConfig |
_private.Init.Control.Lawful.Instances.0.EStateM.bind.match_1.eq_1 | Init.Control.Lawful.Instances | ∀ {ε σ α : Type u_1} (motive : EStateM.Result ε σ α → Sort u_2) (a : α) (s : σ)
(h_1 : (a : α) → (s : σ) → motive (EStateM.Result.ok a s))
(h_2 : (e : ε) → (s : σ) → motive (EStateM.Result.error e s)),
(match EStateM.Result.ok a s with
| EStateM.Result.ok a s => h_1 a s
| EStateM.Result.error e s => h_2 e s) =
h_1 a s |
TopHom._sizeOf_inst | Mathlib.Order.Hom.Bounded | (α : Type u_6) → (β : Type u_7) → {inst : Top α} → {inst_1 : Top β} → [SizeOf α] → [SizeOf β] → SizeOf (TopHom α β) |
εNFA.εClosure.below.step | Mathlib.Computability.EpsilonNFA | ∀ {α : Type u} {σ : Type v} {M : εNFA α σ} {S : Set σ} {motive : (a : σ) → M.εClosure S a → Prop} (s t : σ)
(a : t ∈ M.step s none) (a_1 : M.εClosure S s), εNFA.εClosure.below a_1 → motive s a_1 → εNFA.εClosure.below ⋯ |
ModularGroup.one_lt_normSq_T_zpow_smul | Mathlib.NumberTheory.Modular | ∀ {z : UpperHalfPlane}, z ∈ ModularGroup.fdo → ∀ (n : ℤ), 1 < Complex.normSq ↑(ModularGroup.T ^ n • z) |
not_addDissociated | Mathlib.Combinatorics.Additive.Dissociation | ∀ {α : Type u_1} [inst : AddCommGroup α] {s : Set α},
¬AddDissociated s ↔ ∃ t, ↑t ⊆ s ∧ ∃ u, ↑u ⊆ s ∧ t ≠ u ∧ ∑ x ∈ t, x = ∑ x ∈ u, x |
Std.Internal.List.List.getValueD_filter_containsKey_of_containsKey_right | Std.Data.Internal.List.Associative | ∀ {α : Type u} {β : Type v} [inst : BEq α] [EquivBEq α] {l₁ l₂ : List ((_ : α) × β)} {k : α} {fallback : β},
Std.Internal.List.DistinctKeys l₁ →
Std.Internal.List.containsKey k l₂ = true →
Std.Internal.List.getValueD k (List.filter (fun p => Std.Internal.List.containsKey p.fst l₂) l₁) fallback =
Std.Internal.List.getValueD k l₁ fallback |
CochainComplex.mappingConeHomOfDegreewiseSplitIso | Mathlib.Algebra.Homology.HomotopyCategory.DegreewiseSplit | {C : Type u_1} →
[inst : CategoryTheory.Category.{v, u_1} C] →
[inst_1 : CategoryTheory.Preadditive C] →
(S : CategoryTheory.ShortComplex (CochainComplex C ℤ)) →
(σ : (n : ℤ) → (S.map (HomologicalComplex.eval C (ComplexShape.up ℤ) n)).Splitting) →
[inst_2 : CategoryTheory.Limits.HasBinaryBiproducts C] →
CochainComplex.mappingCone (CochainComplex.homOfDegreewiseSplit S σ) ≅
(CategoryTheory.shiftFunctor (CochainComplex C ℤ) 1).obj S.X₂ |
_private.Lean.Server.FileWorker.WidgetRequests.0.Lean.Widget.findTaggedTextMatches | Lean.Server.FileWorker.WidgetRequests | {α : Type u_1} → String → Lean.Widget.TaggedText α → (α → String) → Array String.Pos.Raw |
Lean.Meta.InductionSubgoal.fields | Lean.Meta.Tactic.Induction | Lean.Meta.InductionSubgoal → Array Lean.Expr |
Tuple.lt_card_le_iff_apply_le_of_monotone | Mathlib.Data.Fin.Tuple.Sort | ∀ {n : ℕ} {α : Type u_1} {j : Fin n} {f : Fin n → α} [inst : Preorder α] {a : α} [inst_1 : DecidableLE α],
Monotone f → (↑j < {i | f i ≤ a}.card ↔ f j ≤ a) |
GrpCat.sectionsSubgroup._proof_2 | Mathlib.Algebra.Category.Grp.Limits | ∀ {J : Type u_3} [inst : CategoryTheory.Category.{u_2, u_3} J] (F : CategoryTheory.Functor J GrpCat)
{a b : (j : J) → ↑((F.comp (CategoryTheory.forget₂ GrpCat MonCat)).obj j)},
a ∈ (MonCat.sectionsSubmonoid (F.comp (CategoryTheory.forget₂ GrpCat MonCat))).carrier →
b ∈ (MonCat.sectionsSubmonoid (F.comp (CategoryTheory.forget₂ GrpCat MonCat))).carrier →
a * b ∈ (MonCat.sectionsSubmonoid (F.comp (CategoryTheory.forget₂ GrpCat MonCat))).carrier |
_private.Init.Data.List.Monadic.0.List.mapM'.match_1.splitter | Init.Data.List.Monadic | {α : Type u_1} →
(motive : List α → Sort u_2) →
(x : List α) → (Unit → motive []) → ((a : α) → (l : List α) → motive (a :: l)) → motive x |
CategoryTheory.EnrichedCategory.id_comp._autoParam | Mathlib.CategoryTheory.Enriched.Basic | Lean.Syntax |
CategoryTheory.Functor.hasStrongEpiMonoFactorisations_imp_of_isEquivalence | Mathlib.CategoryTheory.Limits.Shapes.Images | ∀ {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) [F.IsEquivalence]
[h : CategoryTheory.Limits.HasStrongEpiMonoFactorisations C], CategoryTheory.Limits.HasStrongEpiMonoFactorisations D |
OrderIso.sumLexIioIci._proof_1 | Mathlib.Order.Hom.Lex | ∀ {α : Type u_1} [inst : LinearOrder α] (x : α), Set.Ici x = {y | ¬y < x} |
ContDiffWithinAt._proof_3 | Mathlib.Analysis.Calculus.ContDiff.Defs | ∀ (𝕜 : Type u_1) [inst : NontriviallyNormedField 𝕜] {F : Type u_2} [inst_1 : NormedAddCommGroup F]
[inst_2 : NormedSpace 𝕜 F], SMulCommClass 𝕜 𝕜 F |
Batteries.Tactic.GeneralizeProofs.withGeneralizedProofs | Batteries.Tactic.GeneralizeProofs | {α : Type} →
[Nonempty α] →
Lean.Expr →
Option Lean.Expr →
(Array Lean.Expr → Array Lean.Expr → Lean.Expr → Batteries.Tactic.GeneralizeProofs.MGen α) →
Batteries.Tactic.GeneralizeProofs.MGen α |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.