Datasets:
mathlib-initiative
/
mathlib-types

Dataset card Data Studio Files
xet
Community
1
name
stringlengths
2
347
module
stringlengths
6
90
type
stringlengths
1
5.42M
PEquiv.trans_assoc
Mathlib.Data.PEquiv
βˆ€ {Ξ± : Type u} {Ξ² : Type v} {Ξ³ : Type w} {Ξ΄ : Type x} (f : Ξ± ≃. Ξ²) (g : Ξ² ≃. Ξ³) (h : Ξ³ ≃. Ξ΄), (f.trans g).trans h = f.trans (g.trans h)
Path.Homotopic.proj.eq_1
Mathlib.Topology.Homotopy.Product
βˆ€ {ΞΉ : Type u_1} {X : ΞΉ β†’ Type u_2} [inst : (i : ΞΉ) β†’ TopologicalSpace (X i)] {as bs : (i : ΞΉ) β†’ X i} (i : ΞΉ) (p : Path.Homotopic.Quotient as bs), Path.Homotopic.proj i p = p.map { toFun := fun p => p i, continuous_toFun := β‹― }
UInt16.ofInt_one
Init.Data.UInt.Lemmas
UInt16.ofInt 1 = 1
FormalMultilinearSeries.id._proof_4
Mathlib.Analysis.Analytic.Composition
βˆ€ (π•œ : Type u_1) (E : Type u_2) [inst : NontriviallyNormedField π•œ] [inst_1 : NormedAddCommGroup E] [inst_2 : NormedSpace π•œ E], ContinuousConstSMul π•œ E
Equiv.Perm.Basis.toCentralizer_apply
Mathlib.GroupTheory.Perm.Centralizer
βˆ€ {Ξ± : Type u_1} [inst : DecidableEq Ξ±] [inst_1 : Fintype Ξ±] {g : Equiv.Perm Ξ±} (a : g.Basis) (Ο„ : β†₯(Equiv.Perm.OnCycleFactors.range_toPermHom' g)) (x : Ξ±), ↑(a.toCentralizer Ο„) x = a.ofPermHomFun Ο„ x
_private.Lean.Meta.InferType.0.Lean.Meta.isProofQuickApp
Lean.Meta.InferType
Lean.Expr β†’ β„• β†’ Lean.MetaM Lean.LBool
ClopenUpperSet.ext_iff
Mathlib.Topology.Sets.Order
βˆ€ {Ξ± : Type u_1} [inst : TopologicalSpace Ξ±] [inst_1 : LE Ξ±] {s t : ClopenUpperSet Ξ±}, s = t ↔ ↑s = ↑t
Equiv.ext_iff
Mathlib.Logic.Equiv.Defs
βˆ€ {Ξ± : Sort u} {Ξ² : Sort v} {f g : Ξ± ≃ Ξ²}, f = g ↔ βˆ€ (x : Ξ±), f x = g x
Std.Tactic.BVDecide.BVExpr.bitblast.blastMul.blast
Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Mul
{Ξ± : Type} β†’ [inst : Hashable Ξ±] β†’ [inst_1 : DecidableEq Ξ±] β†’ {w : β„•} β†’ (aig : Std.Sat.AIG Ξ±) β†’ aig.BinaryRefVec w β†’ Std.Sat.AIG.RefVecEntry Ξ± w
Std.Internal.List.Const.getKeyD_modifyKey_self
Std.Data.Internal.List.Associative
βˆ€ {Ξ± : Type u} {Ξ² : Type v} [inst : BEq Ξ±] [EquivBEq Ξ±] {k fallback : Ξ±} {f : Ξ² β†’ Ξ²} (l : List ((_ : Ξ±) Γ— Ξ²)), Std.Internal.List.DistinctKeys l β†’ Std.Internal.List.getKeyD k (Std.Internal.List.Const.modifyKey k f l) fallback = if Std.Internal.List.containsKey k l = true then k else fallback
String.Slice.Pattern.ForwardSliceSearcher.instToForwardSearcher
Init.Data.String.Pattern.String
String.Slice.Pattern.ToForwardSearcher String.Slice String.Slice.Pattern.ForwardSliceSearcher
TopCat.GlueData.MkCore.cocycle
Mathlib.Topology.Gluing
βˆ€ (self : TopCat.GlueData.MkCore) (i j k : self.J) (x : β†₯(self.V i j)) (h : ↑x ∈ self.V i k), ↑((CategoryTheory.ConcreteCategory.hom (self.t j k)) βŸ¨β†‘((CategoryTheory.ConcreteCategory.hom (self.t i j)) x), β‹―βŸ©) = ↑((CategoryTheory.ConcreteCategory.hom (self.t i k)) βŸ¨β†‘x, h⟩)
MonCat.Colimits.monoidColimitType._proof_2
Mathlib.Algebra.Category.MonCat.Colimits
βˆ€ {J : Type u_1} [inst : CategoryTheory.Category.{u_2, u_1} J] (F : CategoryTheory.Functor J MonCat) (q : Quotient (MonCat.Colimits.colimitSetoid F)) (b c : MonCat.Colimits.ColimitType F), q * b * c = q * (b * c)
Lean.Meta.Grind.assertNext
Lean.Meta.Tactic.Grind.Intro
Lean.Meta.Grind.SearchM Bool
_private.Mathlib.Data.Countable.Defs.0.Finite.to_countable.match_1
Mathlib.Data.Countable.Defs
βˆ€ {Ξ± : Sort u_1} (motive : (βˆƒ n, Nonempty (Ξ± ≃ Fin n)) β†’ Prop) (x : βˆƒ n, Nonempty (Ξ± ≃ Fin n)), (βˆ€ (w : β„•) (e : Ξ± ≃ Fin w), motive β‹―) β†’ motive x
LocallyConstant.instAddGroup._proof_6
Mathlib.Topology.LocallyConstant.Algebra
βˆ€ {X : Type u_1} {Y : Type u_2} [inst : TopologicalSpace X] [inst_1 : AddGroup Y] (x : LocallyConstant X Y) (x_1 : β„€), ⇑(x_1 β€’ x) = ⇑(x_1 β€’ x)
NormedAddGroupHom.toAddMonoidHomClass
Mathlib.Analysis.Normed.Group.Hom
βˆ€ {V₁ : Type u_2} {Vβ‚‚ : Type u_3} [inst : SeminormedAddCommGroup V₁] [inst_1 : SeminormedAddCommGroup Vβ‚‚], AddMonoidHomClass (NormedAddGroupHom V₁ Vβ‚‚) V₁ Vβ‚‚
WType.instEncodable
Mathlib.Data.W.Basic
{Ξ± : Type u_1} β†’ {Ξ² : Ξ± β†’ Type u_2} β†’ [(a : Ξ±) β†’ Fintype (Ξ² a)] β†’ [(a : Ξ±) β†’ Encodable (Ξ² a)] β†’ [Encodable Ξ±] β†’ Encodable (WType Ξ²)
Module.supportDim_le_of_surjective
Mathlib.RingTheory.KrullDimension.Module
βˆ€ {R : Type u_1} [inst : CommRing R] {M : Type u_2} [inst_1 : AddCommGroup M] [inst_2 : Module R M] {N : Type u_3} [inst_3 : AddCommGroup N] [inst_4 : Module R N] (f : M β†’β‚—[R] N), Function.Surjective ⇑f β†’ Module.supportDim R N ≀ Module.supportDim R M
Matroid.cRk_map_eq
Mathlib.Combinatorics.Matroid.Rank.Cardinal
βˆ€ {Ξ± Ξ² : Type u} {f : Ξ± β†’ Ξ²} {X : Set Ξ²} (M : Matroid Ξ±) (hf : Set.InjOn f M.E), (M.map f hf).cRk X = M.cRk (f ⁻¹' X)
Subarray.size_le_array_size
Init.Data.Array.Subarray
βˆ€ {Ξ± : Type u_1} {s : Subarray Ξ±}, s.size ≀ s.array.size
Equiv.sumSigmaDistrib_symm_apply
Mathlib.Logic.Equiv.Sum
βˆ€ {Ξ± : Type u_10} {Ξ² : Type u_11} (t : Ξ± βŠ• Ξ² β†’ Type u_9) (a : (i : Ξ±) Γ— t (Sum.inl i) βŠ• (i : Ξ²) Γ— t (Sum.inr i)), (Equiv.sumSigmaDistrib t).symm a = Sum.elim (fun a => ⟨Sum.inl a.fst, a.snd⟩) (fun b => ⟨Sum.inr b.fst, b.snd⟩) a
_private.Mathlib.Order.Atoms.0.IsAtomic.Set.Iic.isAtomic.match_1
Mathlib.Order.Atoms
βˆ€ {Ξ± : Type u_1} [inst : PartialOrder Ξ±] [inst_1 : OrderBot Ξ±] (y : Ξ±) (motive : (βˆƒ a, IsAtom a ∧ a ≀ y) β†’ Prop) (x : βˆƒ a, IsAtom a ∧ a ≀ y), (βˆ€ (a : Ξ±) (ha : IsAtom a) (hay : a ≀ y), motive β‹―) β†’ motive x
Lean.Elab.Tactic.BVDecide.Frontend.TacticContext.ctorIdx
Lean.Elab.Tactic.BVDecide.Frontend.LRAT
Lean.Elab.Tactic.BVDecide.Frontend.TacticContext β†’ β„•
Lean.Widget.RpcEncodablePacket.Β«_@Β».Lean.Widget.InteractiveGoal.562241082._hygCtx._hyg.1.rec
Lean.Widget.InteractiveGoal
{motive : Lean.Widget.RpcEncodablePacket✝ β†’ Sort u} β†’ ((names fvarIds type : Lean.Json) β†’ (val? isInstance? isType? isInserted? isRemoved? : Option Lean.Json) β†’ motive { names := names, fvarIds := fvarIds, type := type, val? := val?, isInstance? := isInstance?, isType? := isType?, isInserted? := isInserted?, isRemoved? := isRemoved? }) β†’ (t : Lean.Widget.RpcEncodablePacket✝) β†’ motive t
Int.sub_lt_self
Init.Data.Int.Order
βˆ€ (a : β„€) {b : β„€}, 0 < b β†’ a - b < a
Commute.eq
Mathlib.Algebra.Group.Commute.Defs
βˆ€ {S : Type u_3} [inst : Mul S] {a b : S}, Commute a b β†’ a * b = b * a
AddSubmonoid.addUnitsEquivAddUnitsType._proof_3
Mathlib.Algebra.Group.Submonoid.Units
βˆ€ {M : Type u_1} [inst : AddMonoid M] (S : AddSubmonoid M) (x : AddUnits β†₯S), { val := ↑↑x, neg := ↑↑(-x), val_neg := β‹―, neg_val := β‹― } ∈ ↑(AddSubmonoid.comap (AddUnits.coeHom M) S) ∧ { val := ↑↑x, neg := ↑↑(-x), val_neg := β‹―, neg_val := β‹― } ∈ ↑(-AddSubmonoid.comap (AddUnits.coeHom M) S)
TopologicalSpace.Opens.frameMinimalAxioms._proof_4
Mathlib.Topology.Sets.Opens
βˆ€ {Ξ± : Type u_1} [inst : TopologicalSpace Ξ±] (a : TopologicalSpace.Opens Ξ±) (s : Set (TopologicalSpace.Opens Ξ±)), a βŠ“ sSup s ≀ ⨆ b ∈ s, a βŠ“ b
_private.Std.Data.DTreeMap.Internal.Lemmas.0.Std.DTreeMap.Internal.Impl.get?_eq_some_iff._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)
_private.Batteries.Data.List.Lemmas.0.List.getElem_filter_eq_getElem_getElem_findIdxs_sub._proof_1_30
Batteries.Data.List.Lemmas
βˆ€ {Ξ± : Type u_1} {p : Ξ± β†’ Bool} (head : Ξ±) (tail : List Ξ±) {i : β„•} (s : β„•) (h : i + 1 ≀ (List.filter p (head :: tail)).length), (List.findIdxs p (head :: tail) s)[i] - (s + 1) + 1 ≀ tail.length β†’ (List.findIdxs p (head :: tail) s)[i] - (s + 1) < tail.length
TensorProduct.smul_tmul
Mathlib.LinearAlgebra.TensorProduct.Basic
βˆ€ {R : Type u_1} {R' : Type u_4} [inst : CommSemiring R] [inst_1 : Monoid R'] {M : Type u_7} {N : Type u_8} [inst_2 : AddCommMonoid M] [inst_3 : AddCommMonoid N] [inst_4 : DistribMulAction R' M] [inst_5 : Module R M] [inst_6 : Module R N] [inst_7 : DistribMulAction R' N] [TensorProduct.CompatibleSMul R R' M N] (r : R') (m : M) (n : N), (r β€’ m) βŠ—β‚œ[R] n = m βŠ—β‚œ[R] (r β€’ n)
_private.Mathlib.RingTheory.Polynomial.Resultant.Basic.0.Polynomial.resultant_add_mul_monomial_right._proof_1_25
Mathlib.RingTheory.Polynomial.Resultant.Basic
βˆ€ {R : Type u_1} [inst : CommRing R] (f g : Polynomial R) (r : R) (m n k : β„•) (hk : k + m ≀ n) (hf : f.natDegree ≀ m) (hm : m β‰  0) (j₁ : Fin (m + n)) (jβ‚‚ : Fin m) (IH : ↑(Fin.castAdd n jβ‚‚) ≀ m β†’ ((fun i => Matrix.of fun j₁ jβ‚‚ => if ↑jβ‚‚ < i then f.sylvester (g + f * (Polynomial.monomial k) r) m n j₁ jβ‚‚ else f.sylvester g m n j₁ jβ‚‚) ↑(Fin.castAdd n jβ‚‚)).det = (f.sylvester g m n).det) (hi : ↑jβ‚‚ + 1 ≀ m), βŸ¨β†‘jβ‚‚ + (k + m), β‹―βŸ© = Fin.natAdd m βŸ¨β†‘jβ‚‚ + k, β‹―βŸ© β†’ (↑jβ‚‚ ≀ ↑j₁ ∧ ↑j₁ ≀ ↑jβ‚‚ + n) ∧ k ≀ ↑j₁ - ↑jβ‚‚ β†’ Β¬(↑jβ‚‚ + k ≀ ↑j₁ ∧ ↑j₁ ≀ ↑jβ‚‚ + (k + m)) β†’ m < ↑j₁ - ↑jβ‚‚ - k
MeasurableSet.mem
Mathlib.MeasureTheory.MeasurableSpace.Constructions
βˆ€ {Ξ± : Type u_1} {s : Set Ξ±} [inst : MeasurableSpace Ξ±], MeasurableSet s β†’ Measurable fun x => x ∈ s
dist_pi_const_le
Mathlib.Topology.MetricSpace.Pseudo.Pi
βˆ€ {Ξ± : Type u_1} {Ξ² : Type u_2} [inst : PseudoMetricSpace Ξ±] [inst_1 : Fintype Ξ²] (a b : Ξ±), (dist (fun x => a) fun x => b) ≀ dist a b
_private.Mathlib.Topology.Algebra.Polynomial.0.Polynomial.coeff_le_of_roots_le._simp_1_1
Mathlib.Topology.Algebra.Polynomial
βˆ€ {Ξ± : Type u_1} {Ξ² : Type v} {f : Ξ± β†’ Ξ²} {b : Ξ²} {s : Multiset Ξ±}, (b ∈ Multiset.map f s) = βˆƒ a ∈ s, f a = b
_private.Mathlib.Analysis.InnerProductSpace.Defs.0.InnerProductSpace.Core.Β«_aux_Mathlib_Analysis_InnerProductSpace_Defs___macroRules__private_Mathlib_Analysis_InnerProductSpace_Defs_0_InnerProductSpace_Core_term_†_1Β»
Mathlib.Analysis.InnerProductSpace.Defs
Lean.Macro
_private.Mathlib.Computability.TMToPartrec.0.Turing.PartrecToTM2.trStmts₁.match_1.eq_4
Mathlib.Computability.TMToPartrec
βˆ€ (motive : Turing.PartrecToTM2.Ξ›' β†’ Sort u_1) (p : Turing.PartrecToTM2.Ξ“' β†’ Bool) (k : Turing.PartrecToTM2.K') (q : Turing.PartrecToTM2.Ξ›') (h_1 : (Q : Turing.PartrecToTM2.Ξ›') β†’ (p : Turing.PartrecToTM2.Ξ“' β†’ Bool) β†’ (k₁ kβ‚‚ : Turing.PartrecToTM2.K') β†’ (q : Turing.PartrecToTM2.Ξ›') β†’ Q = Turing.PartrecToTM2.Ξ›'.move p k₁ kβ‚‚ q β†’ motive (Turing.PartrecToTM2.Ξ›'.move p k₁ kβ‚‚ q)) (h_2 : (Q : Turing.PartrecToTM2.Ξ›') β†’ (k : Turing.PartrecToTM2.K') β†’ (s : Option Turing.PartrecToTM2.Ξ“' β†’ Option Turing.PartrecToTM2.Ξ“') β†’ (q : Turing.PartrecToTM2.Ξ›') β†’ Q = Turing.PartrecToTM2.Ξ›'.push k s q β†’ motive (Turing.PartrecToTM2.Ξ›'.push k s q)) (h_3 : (Q : Turing.PartrecToTM2.Ξ›') β†’ (q : Option Turing.PartrecToTM2.Ξ“' β†’ Turing.PartrecToTM2.Ξ›') β†’ Q = Turing.PartrecToTM2.Ξ›'.read q β†’ motive (Turing.PartrecToTM2.Ξ›'.read q)) (h_4 : (Q : Turing.PartrecToTM2.Ξ›') β†’ (p : Turing.PartrecToTM2.Ξ“' β†’ Bool) β†’ (k : Turing.PartrecToTM2.K') β†’ (q : Turing.PartrecToTM2.Ξ›') β†’ Q = Turing.PartrecToTM2.Ξ›'.clear p k q β†’ motive (Turing.PartrecToTM2.Ξ›'.clear p k q)) (h_5 : (Q q : Turing.PartrecToTM2.Ξ›') β†’ Q = q.copy β†’ motive q.copy) (h_6 : (Q q : Turing.PartrecToTM2.Ξ›') β†’ Q = q.succ β†’ motive q.succ) (h_7 : (Q q₁ qβ‚‚ : Turing.PartrecToTM2.Ξ›') β†’ Q = q₁.pred qβ‚‚ β†’ motive (q₁.pred qβ‚‚)) (h_8 : (Q : Turing.PartrecToTM2.Ξ›') β†’ (k : Turing.PartrecToTM2.Cont') β†’ Q = Turing.PartrecToTM2.Ξ›'.ret k β†’ motive (Turing.PartrecToTM2.Ξ›'.ret k)), (match Turing.PartrecToTM2.Ξ›'.clear p k q with | Q@h:(Turing.PartrecToTM2.Ξ›'.move p k₁ kβ‚‚ q) => h_1 Q p k₁ kβ‚‚ q h | Q@h:(Turing.PartrecToTM2.Ξ›'.push k s q) => h_2 Q k s q h | Q@h:(Turing.PartrecToTM2.Ξ›'.read q) => h_3 Q q h | Q@h:(Turing.PartrecToTM2.Ξ›'.clear p k q) => h_4 Q p k q h | Q@h:q.copy => h_5 Q q h | Q@h:q.succ => h_6 Q q h | Q@h:(q₁.pred qβ‚‚) => h_7 Q q₁ qβ‚‚ h | Q@h:(Turing.PartrecToTM2.Ξ›'.ret k) => h_8 Q k h) = h_4 (Turing.PartrecToTM2.Ξ›'.clear p k q) p k q β‹―
Real.sign_eq_zero_iff._simp_1
Mathlib.Data.Real.Sign
βˆ€ {r : ℝ}, (r.sign = 0) = (r = 0)
minimal_nonempty_open_eq_singleton
Mathlib.Topology.Separation.Basic
βˆ€ {X : Type u_1} [inst : TopologicalSpace X] [T0Space X] {s : Set X}, IsOpen s β†’ s.Nonempty β†’ (βˆ€ t βŠ† s, t.Nonempty β†’ IsOpen t β†’ t = s) β†’ βˆƒ x, s = {x}
left_iff_dite_iff
Init.PropLemmas
βˆ€ {p : Prop} [inst : Decidable p] {x : Prop} {y : Β¬p β†’ Prop}, (x ↔ if h : p then x else y h) ↔ βˆ€ (h : Β¬p), x ↔ y h
GradedMonoid.list_prod_map_eq_dProd
Mathlib.Algebra.GradedMonoid
βˆ€ {ΞΉ : Type u_1} {Ξ± : Type u_2} {A : ΞΉ β†’ Type u_3} [inst : AddMonoid ΞΉ] [inst_1 : GradedMonoid.GMonoid A] (l : List Ξ±) (f : Ξ± β†’ GradedMonoid A), (List.map f l).prod = GradedMonoid.mk (l.dProdIndex fun i => (f i).fst) (l.dProd (fun i => (f i).fst) fun i => (f i).snd)
CategoryTheory.IsPullback.of_hasPullback
Mathlib.CategoryTheory.Limits.Shapes.Pullback.CommSq
βˆ€ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {X Y Z : C} (f : X ⟢ Z) (g : Y ⟢ Z) [inst_1 : CategoryTheory.Limits.HasPullback f g], CategoryTheory.IsPullback (CategoryTheory.Limits.pullback.fst f g) (CategoryTheory.Limits.pullback.snd f g) f g
ProbabilityTheory.Kernel.IndepFun.comp
Mathlib.Probability.Independence.Kernel.IndepFun
βˆ€ {Ξ± : Type u_1} {Ξ© : Type u_2} {Ξ² : Type u_4} {Ξ²' : Type u_5} {Ξ³ : Type u_6} {Ξ³' : Type u_7} {mΞ± : MeasurableSpace Ξ±} {mΞ© : MeasurableSpace Ξ©} {ΞΊ : ProbabilityTheory.Kernel Ξ± Ξ©} {ΞΌ : MeasureTheory.Measure Ξ±} {f : Ξ© β†’ Ξ²} {g : Ξ© β†’ Ξ²'} {mΞ² : MeasurableSpace Ξ²} {mΞ²' : MeasurableSpace Ξ²'} {mΞ³ : MeasurableSpace Ξ³} {mΞ³' : MeasurableSpace Ξ³'} {Ο† : Ξ² β†’ Ξ³} {ψ : Ξ²' β†’ Ξ³'}, ProbabilityTheory.Kernel.IndepFun f g ΞΊ ΞΌ β†’ Measurable Ο† β†’ Measurable ψ β†’ ProbabilityTheory.Kernel.IndepFun (Ο† ∘ f) (ψ ∘ g) ΞΊ ΞΌ
_private.Std.Data.Internal.List.Associative.0.Std.Internal.List.getKey_eraseKey._simp_1_1
Std.Data.Internal.List.Associative
βˆ€ {Ξ± : Type u} {Ξ² : Ξ± β†’ Type v} [inst : BEq Ξ±] {l : List ((a : Ξ±) Γ— Ξ² a)} {a : Ξ±} (h : Std.Internal.List.containsKey a l = true), some (Std.Internal.List.getKey a l h) = Std.Internal.List.getKey? a l
CategoryTheory.Under.pushout_obj
Mathlib.CategoryTheory.Comma.Over.Pullback
βˆ€ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {X Y : C} (f : X ⟢ Y) [inst_1 : CategoryTheory.Limits.HasPushoutsAlong f] (x : CategoryTheory.Under X), (CategoryTheory.Under.pushout f).obj x = CategoryTheory.Under.mk (CategoryTheory.Limits.pushout.inr x.hom f)
Order.height_toDual
Mathlib.Order.KrullDimension
βˆ€ {Ξ± : Type u_1} [inst : Preorder Ξ±] (x : Ξ±), Order.height (OrderDual.toDual x) = Order.coheight x
AddLocalization.ind
Mathlib.GroupTheory.MonoidLocalization.Basic
βˆ€ {M : Type u_1} [inst : AddCommMonoid M] {S : AddSubmonoid M} {p : AddLocalization S β†’ Prop}, (βˆ€ (y : M Γ— β†₯S), p (AddLocalization.mk y.1 y.2)) β†’ βˆ€ (x : AddLocalization S), p x
ProbabilityTheory.Kernel.partialTraj_comp_partialTraj
Mathlib.Probability.Kernel.IonescuTulcea.PartialTraj
βˆ€ {X : β„• β†’ Type u_1} {mX : (n : β„•) β†’ MeasurableSpace (X n)} {a b c : β„•} {ΞΊ : (n : β„•) β†’ ProbabilityTheory.Kernel ((i : β†₯(Finset.Iic n)) β†’ X ↑i) (X (n + 1))}, a ≀ b β†’ b ≀ c β†’ (ProbabilityTheory.Kernel.partialTraj ΞΊ b c).comp (ProbabilityTheory.Kernel.partialTraj ΞΊ a b) = ProbabilityTheory.Kernel.partialTraj ΞΊ a c
Ordinal.bsup_le
Mathlib.SetTheory.Ordinal.Family
βˆ€ {o : Ordinal.{u}} {f : (b : Ordinal.{u}) β†’ b < o β†’ Ordinal.{max u v}} {a : Ordinal.{max u v}}, (βˆ€ (i : Ordinal.{u}) (h : i < o), f i h ≀ a) β†’ o.bsup f ≀ a
Lean.Elab.TacticInfo.goalsBefore
Lean.Elab.InfoTree.Types
Lean.Elab.TacticInfo β†’ List Lean.MVarId
RingOfIntegers.exponent
Mathlib.NumberTheory.NumberField.Ideal.KummerDedekind
{K : Type u_1} β†’ [inst : Field K] β†’ NumberField.RingOfIntegers K β†’ β„•
ContMDiff.piecewise
Mathlib.Geometry.Manifold.ContMDiff.Basic
βˆ€ {π•œ : Type u_1} [inst : NontriviallyNormedField π•œ] {E : Type u_2} [inst_1 : NormedAddCommGroup E] [inst_2 : NormedSpace π•œ E] {H : Type u_3} [inst_3 : TopologicalSpace H] {I : ModelWithCorners π•œ E H} {M : Type u_4} [inst_4 : TopologicalSpace M] {E' : Type u_5} [inst_5 : NormedAddCommGroup E'] [inst_6 : NormedSpace π•œ E'] {H' : Type u_6} [inst_7 : TopologicalSpace H'] {I' : ModelWithCorners π•œ E' H'} {M' : Type u_7} [inst_8 : TopologicalSpace M'] [inst_9 : ChartedSpace H M] [inst_10 : ChartedSpace H' M'] {n : WithTop β„•βˆž} {f g : M β†’ M'} {s : Set M} [inst_11 : DecidablePred fun x => x ∈ s], ContMDiff I I' n f β†’ ContMDiff I I' n g β†’ (βˆ€ x ∈ frontier s, f =αΆ [nhds x] g) β†’ ContMDiff I I' n (s.piecewise f g)
FirstOrder.Language.mk.injEq
Mathlib.ModelTheory.Basic
βˆ€ (Functions : β„• β†’ Type u) (Relations : β„• β†’ Type v) (Functions_1 : β„• β†’ Type u) (Relations_1 : β„• β†’ Type v), ({ Functions := Functions, Relations := Relations } = { Functions := Functions_1, Relations := Relations_1 }) = (Functions = Functions_1 ∧ Relations = Relations_1)
Mathlib.Tactic.Linarith.LinarithConfig.splitHypotheses._default
Mathlib.Tactic.Linarith.Frontend
Bool
LLVM.Visibility._sizeOf_1
Lean.Compiler.IR.LLVMBindings
LLVM.Visibility β†’ β„•
NonUnitalCommRing.toNonUnitalCommSemiring._proof_2
Mathlib.Algebra.Ring.Defs
βˆ€ {Ξ± : Type u_1} [s : NonUnitalCommRing Ξ±] (a b c : Ξ±), a * (b + c) = a * b + a * c
Lean.removeRoot
Lean.Data.OpenDecl
Lean.Name β†’ Lean.Name
_private.Std.Data.DHashMap.Internal.AssocList.Lemmas.0.Std.DHashMap.Internal.AssocList.Const.alter.match_1.eq_1
Std.Data.DHashMap.Internal.AssocList.Lemmas
βˆ€ {Ξ² : Type u_1} (motive : Option Ξ² β†’ Sort u_2) (h_1 : Unit β†’ motive none) (h_2 : (b : Ξ²) β†’ motive (some b)), (match none with | none => h_1 () | some b => h_2 b) = h_1 ()
CategoryTheory.inclusion
Mathlib.CategoryTheory.ConnectedComponents
{J : Type u₁} β†’ [inst : CategoryTheory.Category.{v₁, u₁} J] β†’ (j : CategoryTheory.ConnectedComponents J) β†’ CategoryTheory.Functor j.Component (CategoryTheory.Decomposed J)
ContDiffMapSupportedInClass.casesOn
Mathlib.Analysis.Distribution.ContDiffMapSupportedIn
{B : Type u_5} β†’ {E : Type u_6} β†’ {F : Type u_7} β†’ [inst : NormedAddCommGroup E] β†’ [inst_1 : NormedAddCommGroup F] β†’ [inst_2 : NormedSpace ℝ E] β†’ [inst_3 : NormedSpace ℝ F] β†’ {n : β„•βˆž} β†’ {K : TopologicalSpace.Compacts E} β†’ {motive : ContDiffMapSupportedInClass B E F n K β†’ Sort u} β†’ (t : ContDiffMapSupportedInClass B E F n K) β†’ ([toDFunLike : DFunLike B E fun x => F] β†’ (map_contDiff : βˆ€ (f : B), ContDiff ℝ ↑n ⇑f) β†’ (map_zero_on_compl : βˆ€ (f : B), Set.EqOn (⇑f) 0 (↑K)ᢜ) β†’ motive { toDFunLike := toDFunLike, map_contDiff := map_contDiff, map_zero_on_compl := map_zero_on_compl }) β†’ motive t
Lean.Meta.Cache._sizeOf_1
Lean.Meta.Basic
Lean.Meta.Cache β†’ β„•
ExteriorAlgebra.lift_symm_apply
Mathlib.LinearAlgebra.ExteriorAlgebra.Basic
βˆ€ (R : Type u1) [inst : CommRing R] {M : Type u2} [inst_1 : AddCommGroup M] [inst_2 : Module R M] {A : Type u_1} [inst_3 : Semiring A] [inst_4 : Algebra R A] (a : ExteriorAlgebra R M →ₐ[R] A), (ExteriorAlgebra.lift R).symm a = βŸ¨β†‘((CliffordAlgebra.lift 0).symm a), β‹―βŸ©
monovary_inv_right._simp_4
Mathlib.Algebra.Order.Monovary
βˆ€ {ΞΉ : Type u_1} {Ξ± : Type u_2} {Ξ² : Type u_3} [inst : PartialOrder Ξ±] [inst_1 : AddCommGroup Ξ²] [inst_2 : PartialOrder Ξ²] [IsOrderedAddMonoid Ξ²] {f : ΞΉ β†’ Ξ±} {g : ΞΉ β†’ Ξ²}, Monovary f (-g) = Antivary f g
Mathlib.Tactic.IntervalCases.Methods.bisect._unsafe_rec
Mathlib.Tactic.IntervalCases
Mathlib.Tactic.IntervalCases.Methods β†’ Lean.MVarId β†’ Subarray Mathlib.Tactic.IntervalCases.IntervalCasesSubgoal β†’ Mathlib.Tactic.IntervalCases.Bound β†’ Mathlib.Tactic.IntervalCases.Bound β†’ Lean.Expr β†’ Lean.Expr β†’ Lean.Expr β†’ Lean.Expr β†’ Lean.Expr β†’ Lean.MetaM Unit
_private.Mathlib.NumberTheory.FermatPsp.0.Nat.exists_infinite_pseudoprimes._proof_1_6
Mathlib.NumberTheory.FermatPsp
βˆ€ {b : β„•} (m : β„•), Β¬2 ≀ b β†’ b = 1 β†’ Β¬Nat.Prime (2 * (m + 2)) β†’ 1 < 2 * (m + 2)
Mathlib.Tactic.RingNF.RingMode.ctorElimType
Mathlib.Tactic.Ring.RingNF
{motive : Mathlib.Tactic.RingNF.RingMode β†’ Sort u} β†’ β„• β†’ Sort (max 1 u)
Complex.lim_re
Mathlib.Analysis.Complex.Norm
βˆ€ (f : CauSeq β„‚ fun x => β€–xβ€–), (Complex.cauSeqRe f).lim = f.lim.re
enorm_prod_le_of_le
Mathlib.Analysis.Normed.Group.Basic
βˆ€ {ΞΉ : Type u_3} {Ξ΅ : Type u_8} [inst : TopologicalSpace Ξ΅] [inst_1 : ESeminormedCommMonoid Ξ΅] (s : Finset ΞΉ) {f : ΞΉ β†’ Ξ΅} {n : ΞΉ β†’ ENNReal}, (βˆ€ b ∈ s, β€–f bβ€–β‚‘ ≀ n b) β†’ β€–βˆ b ∈ s, f bβ€–β‚‘ ≀ βˆ‘ b ∈ s, n b
_private.Mathlib.Analysis.Hofer.0._aux_Mathlib_Analysis_Hofer___macroRules__private_Mathlib_Analysis_Hofer_0_termD_1
Mathlib.Analysis.Hofer
Lean.Macro
_private.Mathlib.Data.Nat.Factorization.Basic.0.Nat.Ico_pow_dvd_eq_Ico_of_lt._simp_1_3
Mathlib.Data.Nat.Factorization.Basic
βˆ€ {a c b : Prop}, (a ∧ c ↔ b ∧ c) = (c β†’ (a ↔ b))
Lean.Elab.Term.ToDepElimPattern.State
Lean.Elab.Match
Type
_private.Mathlib.Order.Directed.0.directedOn_iff_directed._simp_1_5
Mathlib.Order.Directed
βˆ€ {b a : Prop}, (βˆƒ (_ : a), b) = (a ∧ b)
MonoidHom.CompTriple.IsId.eq_id
Mathlib.Algebra.Group.Hom.CompTypeclasses
βˆ€ {M : Type u_1} {inst : Monoid M} {Οƒ : M β†’* M} [self : MonoidHom.CompTriple.IsId Οƒ], Οƒ = MonoidHom.id M
Equiv.prodPiEquivSumPi_apply
Mathlib.Logic.Equiv.Prod
βˆ€ {ΞΉ : Type u_9} {ΞΉ' : Type u_10} (Ο€ : ΞΉ β†’ Type u) (Ο€' : ΞΉ' β†’ Type u) (a : ((i : ΞΉ) β†’ Sum.elim Ο€ Ο€' (Sum.inl i)) Γ— ((i' : ΞΉ') β†’ Sum.elim Ο€ Ο€' (Sum.inr i'))) (i : ΞΉ βŠ• ΞΉ'), (Equiv.prodPiEquivSumPi Ο€ Ο€') a i = (Equiv.sumPiEquivProdPi (Sum.elim Ο€ Ο€')).symm a i
CategoryTheory.Functor.descOfIsLeftKanExtension_fac_app
Mathlib.CategoryTheory.Functor.KanExtension.Basic
βˆ€ {C : Type u_1} {H : Type u_3} {D : Type u_4} [inst : CategoryTheory.Category.{u_8, u_1} C] [inst_1 : CategoryTheory.Category.{u_7, u_3} H] [inst_2 : CategoryTheory.Category.{u_6, u_4} D] (F' : CategoryTheory.Functor D H) {L : CategoryTheory.Functor C D} {F : CategoryTheory.Functor C H} (Ξ± : F ⟢ L.comp F') [inst_3 : F'.IsLeftKanExtension Ξ±] (G : CategoryTheory.Functor D H) (Ξ² : F ⟢ L.comp G) (X : C), CategoryTheory.CategoryStruct.comp (Ξ±.app X) ((F'.descOfIsLeftKanExtension Ξ± G Ξ²).app (L.obj X)) = Ξ².app X
CategoryTheory.ShortComplex.LeftHomologyData.copy._proof_5
Mathlib.Algebra.Homology.ShortComplex.LeftHomology
βˆ€ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C] {S : CategoryTheory.ShortComplex C} (h : S.LeftHomologyData) {K' : C} (eK : K' β‰… h.K), CategoryTheory.CategoryStruct.comp 0 eK.inv = CategoryTheory.CategoryStruct.comp (CategoryTheory.CategoryStruct.id S.X₁) 0
Lean.Grind.CommRing.Poly.insert.go.induct_unfolding
Init.Grind.Ring.CommSolver
βˆ€ (k : β„€) (m : Lean.Grind.CommRing.Mon) (motive : Lean.Grind.CommRing.Poly β†’ Lean.Grind.CommRing.Poly β†’ Prop), (βˆ€ (k_1 : β„€), motive (Lean.Grind.CommRing.Poly.num k_1) (Lean.Grind.CommRing.Poly.add k m (Lean.Grind.CommRing.Poly.num k_1))) β†’ (βˆ€ (k_1 : β„€) (m_1 : Lean.Grind.CommRing.Mon) (p : Lean.Grind.CommRing.Poly), m.grevlex m_1 = Ordering.eq β†’ have k := k + k_1; (k == 0) = true β†’ motive (Lean.Grind.CommRing.Poly.add k_1 m_1 p) p) β†’ (βˆ€ (k_1 : β„€) (m_1 : Lean.Grind.CommRing.Mon) (p : Lean.Grind.CommRing.Poly), m.grevlex m_1 = Ordering.eq β†’ have k := k + k_1; (k == 0) = false β†’ motive (Lean.Grind.CommRing.Poly.add k_1 m_1 p) (Lean.Grind.CommRing.Poly.add k m p)) β†’ (βˆ€ (k_1 : β„€) (m_1 : Lean.Grind.CommRing.Mon) (p : Lean.Grind.CommRing.Poly), m.grevlex m_1 = Ordering.gt β†’ motive (Lean.Grind.CommRing.Poly.add k_1 m_1 p) (Lean.Grind.CommRing.Poly.add k m (Lean.Grind.CommRing.Poly.add k_1 m_1 p))) β†’ (βˆ€ (k_1 : β„€) (m_1 : Lean.Grind.CommRing.Mon) (p : Lean.Grind.CommRing.Poly), m.grevlex m_1 = Ordering.lt β†’ motive p (Lean.Grind.CommRing.Poly.insert.go k m p) β†’ motive (Lean.Grind.CommRing.Poly.add k_1 m_1 p) (Lean.Grind.CommRing.Poly.add k_1 m_1 (Lean.Grind.CommRing.Poly.insert.go k m p))) β†’ βˆ€ (a : Lean.Grind.CommRing.Poly), motive a (Lean.Grind.CommRing.Poly.insert.go k m a)
_private.Mathlib.LinearAlgebra.LinearPMap.0.LinearPMap.graph_map_fst_eq_domain._simp_1_6
Mathlib.LinearAlgebra.LinearPMap
βˆ€ {Ξ± : Sort u_1} {p : Ξ± β†’ Prop} {b : Prop}, (βˆƒ x, p x ∧ b) = ((βˆƒ x, p x) ∧ b)
MeasureTheory.exp_neg_llr
Mathlib.MeasureTheory.Measure.LogLikelihoodRatio
βˆ€ {Ξ± : Type u_1} {mΞ± : MeasurableSpace Ξ±} {ΞΌ Ξ½ : MeasureTheory.Measure Ξ±} [MeasureTheory.SigmaFinite ΞΌ] [MeasureTheory.SigmaFinite Ξ½], ΞΌ.AbsolutelyContinuous Ξ½ β†’ (fun x => Real.exp (-MeasureTheory.llr ΞΌ Ξ½ x)) =ᡐ[ΞΌ] fun x => (Ξ½.rnDeriv ΞΌ x).toReal
ContDiff.fourierPowSMulRight
Mathlib.Analysis.Fourier.FourierTransformDeriv
βˆ€ {E : Type u_1} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace β„‚ E] {V : Type u_2} {W : Type u_3} [inst_2 : NormedAddCommGroup V] [inst_3 : NormedSpace ℝ V] [inst_4 : NormedAddCommGroup W] [inst_5 : NormedSpace ℝ W] (L : V β†’L[ℝ] W β†’L[ℝ] ℝ) {f : V β†’ E} {k : WithTop β„•βˆž}, ContDiff ℝ k f β†’ βˆ€ (n : β„•), ContDiff ℝ k fun v => VectorFourier.fourierPowSMulRight L f v n
TopModuleCat
Mathlib.Algebra.Category.ModuleCat.Topology.Basic
(R : Type u) β†’ [Ring R] β†’ [TopologicalSpace R] β†’ Type (max u (v + 1))
Lean.Lsp.Ipc.CallHierarchy.rec_2
Lean.Data.Lsp.Ipc
{motive_1 : Lean.Lsp.Ipc.CallHierarchy β†’ Sort u} β†’ {motive_2 : Array Lean.Lsp.Ipc.CallHierarchy β†’ Sort u} β†’ {motive_3 : List Lean.Lsp.Ipc.CallHierarchy β†’ Sort u} β†’ ((item : Lean.Lsp.CallHierarchyItem) β†’ (fromRanges : Array Lean.Lsp.Range) β†’ (children : Array Lean.Lsp.Ipc.CallHierarchy) β†’ motive_2 children β†’ motive_1 { item := item, fromRanges := fromRanges, children := children }) β†’ ((toList : List Lean.Lsp.Ipc.CallHierarchy) β†’ motive_3 toList β†’ motive_2 { toList := toList }) β†’ motive_3 [] β†’ ((head : Lean.Lsp.Ipc.CallHierarchy) β†’ (tail : List Lean.Lsp.Ipc.CallHierarchy) β†’ motive_1 head β†’ motive_3 tail β†’ motive_3 (head :: tail)) β†’ (t : List Lean.Lsp.Ipc.CallHierarchy) β†’ motive_3 t
CategoryTheory.SmallObject.hasPushouts
Mathlib.CategoryTheory.SmallObject.IsCardinalForSmallObjectArgument
βˆ€ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] (I : CategoryTheory.MorphismProperty C) (ΞΊ : Cardinal.{w}) [inst_1 : Fact ΞΊ.IsRegular] [inst_2 : OrderBot ΞΊ.ord.ToType] [I.IsCardinalForSmallObjectArgument ΞΊ], CategoryTheory.Limits.HasPushouts C
AddSubgroup.op.instNormal
Mathlib.Algebra.Group.Subgroup.MulOppositeLemmas
βˆ€ {G : Type u_2} [inst : AddGroup G] {H : AddSubgroup G} [H.Normal], H.op.Normal
LinearMap.BilinForm.apply_apply_same_eq_zero_iff
Mathlib.LinearAlgebra.SesquilinearForm.Basic
βˆ€ {R : Type u_1} {M : Type u_5} [inst : CommRing R] [inst_1 : LinearOrder R] [IsStrictOrderedRing R] [inst_3 : AddCommGroup M] [inst_4 : Module R M] (B : LinearMap.BilinForm R M), (βˆ€ (x : M), 0 ≀ (B x) x) β†’ LinearMap.IsSymm B β†’ βˆ€ {x : M}, (B x) x = 0 ↔ x ∈ LinearMap.ker B
AnalyticAt.comp_of_eq'
Mathlib.Analysis.Analytic.Composition
βˆ€ {π•œ : Type u_1} {E : Type u_2} {F : Type u_3} {G : Type u_4} [inst : NontriviallyNormedField π•œ] [inst_1 : NormedAddCommGroup E] [inst_2 : NormedSpace π•œ E] [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace π•œ F] [inst_5 : NormedAddCommGroup G] [inst_6 : NormedSpace π•œ G] {g : F β†’ G} {f : E β†’ F} {y : F} {x : E}, AnalyticAt π•œ g y β†’ AnalyticAt π•œ f x β†’ f x = y β†’ AnalyticAt π•œ (fun z => g (f z)) x
Equiv.piCongr'.eq_1
Mathlib.Logic.Equiv.Basic
βˆ€ {Ξ± : Sort u_1} {Ξ² : Sort u_4} {W : Ξ± β†’ Sort w} {Z : Ξ² β†’ Sort z} (h₁ : Ξ± ≃ Ξ²) (hβ‚‚ : (b : Ξ²) β†’ W (h₁.symm b) ≃ Z b), h₁.piCongr' hβ‚‚ = (h₁.symm.piCongr fun b => (hβ‚‚ b).symm).symm
Fin.cast_addNat
Init.Data.Fin.Lemmas
βˆ€ {n : β„•} (m : β„•) (i : Fin n), Fin.cast β‹― (i.addNat m) = Fin.natAdd m i
unitary.val_toUnits_apply
Mathlib.Algebra.Star.Unitary
βˆ€ {R : Type u_1} [inst : Monoid R] [inst_1 : StarMul R] (x : β†₯(unitary R)), ↑(Unitary.toUnits x) = ↑x
_private.Mathlib.Topology.Metrizable.Uniformity.0.UniformSpace.metrizable_uniformity._simp_1_5
Mathlib.Topology.Metrizable.Uniformity
βˆ€ {Ξ± : Sort u_1} (a : Ξ±), (a = a) = True
List.nodup_iff_forall_not_duplicate
Mathlib.Data.List.Duplicate
βˆ€ {Ξ± : Type u_1} {l : List Ξ±}, l.Nodup ↔ βˆ€ (x : Ξ±), Β¬List.Duplicate x l
LiouvilleWith.sub_nat_iff._simp_1
Mathlib.NumberTheory.Transcendental.Liouville.LiouvilleWith
βˆ€ {p x : ℝ} {n : β„•}, LiouvilleWith p (x - ↑n) = LiouvilleWith p x
CategoryTheory.ObjectProperty.productTo
Mathlib.CategoryTheory.Generator.Basic
{C : Type u₁} β†’ [inst : CategoryTheory.Category.{v₁, u₁} C] β†’ (P : CategoryTheory.ObjectProperty C) β†’ (X : C) β†’ [inst_1 : CategoryTheory.Limits.HasProduct (P.productToFamily X)] β†’ X ⟢ ∏ᢜ P.productToFamily X
Nat.ppred
Mathlib.Data.Nat.PSub
β„• β†’ Option β„•
Matrix.instNonUnitalRing._proof_1
Mathlib.Data.Matrix.Mul
βˆ€ {n : Type u_1} {Ξ± : Type u_2} [inst : NonUnitalRing Ξ±] (a b : Matrix n n Ξ±), a - b = a + -b
instCartesianClosedLightCondSet._proof_1
Mathlib.Condensed.Light.CartesianClosed
CategoryTheory.EssentiallySmall.{u_1, u_1, u_1 + 1} LightProfiniteα΅’α΅–
Tree.noConfusionType
Mathlib.Data.Tree.Basic
{Ξ± : Type u} β†’ Sort u_1 β†’ Tree Ξ± β†’ Tree Ξ± β†’ Sort u_1
LinearEquiv._sizeOf_inst
Mathlib.Algebra.Module.Equiv.Defs
{R : Type u_14} β†’ {S : Type u_15} β†’ {inst : Semiring R} β†’ {inst_1 : Semiring S} β†’ (Οƒ : R β†’+* S) β†’ {Οƒ' : S β†’+* R} β†’ {inst_2 : RingHomInvPair Οƒ Οƒ'} β†’ {inst_3 : RingHomInvPair Οƒ' Οƒ} β†’ (M : Type u_16) β†’ (Mβ‚‚ : Type u_17) β†’ {inst_4 : AddCommMonoid M} β†’ {inst_5 : AddCommMonoid Mβ‚‚} β†’ {inst_6 : Module R M} β†’ {inst_7 : Module S Mβ‚‚} β†’ [SizeOf R] β†’ [SizeOf S] β†’ [SizeOf M] β†’ [SizeOf Mβ‚‚] β†’ SizeOf (M ≃ₛₗ[Οƒ] Mβ‚‚)
Cycle.length_nil
Mathlib.Data.List.Cycle
βˆ€ {Ξ± : Type u_1}, Cycle.nil.length = 0