name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M |
|---|---|---|
_private.Std.Sat.CNF.Dimacs.0.Std.Sat.CNF.DimacsState.numClauses._default | Std.Sat.CNF.Dimacs | ℕ |
_private.Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.Unital.0._auto_321 | Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.Unital | Lean.Syntax |
Lean.Meta.LazyDiscrTree.instInhabitedKey | Lean.Meta.LazyDiscrTree | Inhabited Lean.Meta.LazyDiscrTree.Key |
_private.Mathlib.Tactic.Simps.Basic.0.NameStruct.mk.inj | Mathlib.Tactic.Simps.Basic | ∀ {parent : Lean.Name} {components : List String} {parent_1 : Lean.Name} {components_1 : List String},
{ parent := parent, components := components } = { parent := parent_1, components := components_1 } →
parent = parent_1 ∧ components = components_1 |
_private.Std.Time.Zoned.Database.TZdb.0.Std.Time.Database.TZdb.localRules.match_1 | Std.Time.Zoned.Database.TZdb | (motive : Option String → Sort u_1) →
(x : Option String) → ((id : String) → motive (some id)) → ((x : Option String) → motive x) → motive x |
Dioph.diophFn_vec_comp1 | Mathlib.NumberTheory.Dioph | ∀ {n : ℕ} {S : Set (Vector3 ℕ n.succ)},
Dioph S → ∀ {f : Vector3 ℕ n → ℕ}, Dioph.DiophFn f → Dioph {v | Vector3.cons (f v) v ∈ S} |
EuclideanGeometry.Sphere.self_mem_orthRadius | Mathlib.Geometry.Euclidean.Sphere.OrthRadius | ∀ {V : Type u_1} {P : Type u_2} [inst : NormedAddCommGroup V] [inst_1 : InnerProductSpace ℝ V] [inst_2 : MetricSpace P]
[inst_3 : NormedAddTorsor V P] (s : EuclideanGeometry.Sphere P) (p : P), p ∈ s.orthRadius p |
RingHom.map_adjugate | Mathlib.LinearAlgebra.Matrix.Adjugate | ∀ {n : Type v} [inst : DecidableEq n] [inst_1 : Fintype n] {R : Type u_1} {S : Type u_2} [inst_2 : CommRing R]
[inst_3 : CommRing S] (f : R →+* S) (M : Matrix n n R), f.mapMatrix M.adjugate = (f.mapMatrix M).adjugate |
_private.Mathlib.Computability.Language.0.Language.kstar_eq_iSup_pow._simp_1_2 | Mathlib.Computability.Language | ∀ {α : Type u_1} {ι : Sort v} {l : ι → Language α} {x : List α}, (x ∈ ⨆ i, l i) = ∃ i, x ∈ l i |
Multiset.mem_Ioc._simp_1 | Mathlib.Order.Interval.Multiset | ∀ {α : Type u_1} [inst : Preorder α] [inst_1 : LocallyFiniteOrder α] {a b x : α},
(x ∈ Multiset.Ioc a b) = (a < x ∧ x ≤ b) |
_private.Mathlib.Analysis.Normed.Affine.AddTorsorBases.0.AffineBasis.centroid_mem_interior_convexHull._simp_1_2 | Mathlib.Analysis.Normed.Affine.AddTorsorBases | ∀ {α : Type u_3} [inst : Semiring α] [inst_1 : PartialOrder α] [IsOrderedRing α] [Nontrivial α] {n : ℕ},
(0 < ↑n) = (0 < n) |
Std.PRange.UpwardEnumerable.succMany_eq_get | Init.Data.Range.Polymorphic.UpwardEnumerable | ∀ {α : Type u} [inst : Std.PRange.UpwardEnumerable α] [inst_1 : Std.PRange.LawfulUpwardEnumerable α]
[inst_2 : Std.PRange.InfinitelyUpwardEnumerable α] {n : ℕ} {a : α},
Std.PRange.succMany n a = (Std.PRange.succMany? n a).get ⋯ |
Lean.Expr.NumApps.State.casesOn | Lean.Util.NumApps | {motive : Lean.Expr.NumApps.State → Sort u} →
(t : Lean.Expr.NumApps.State) →
((visited : Lean.PtrSet Lean.Expr) →
(counters : Lean.NameMap ℕ) → motive { visited := visited, counters := counters }) →
motive t |
Lean.Elab.Visibility.noConfusionType | Lean.Elab.DeclModifiers | Sort v✝ → Lean.Elab.Visibility → Lean.Elab.Visibility → Sort v✝ |
PresheafOfModules.ofPresheaf_map | Mathlib.Algebra.Category.ModuleCat.Presheaf | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {R : CategoryTheory.Functor Cᵒᵖ RingCat}
(M : CategoryTheory.Functor Cᵒᵖ Ab) [inst_1 : (X : Cᵒᵖ) → Module ↑(R.obj X) ↑(M.obj X)]
(map_smul :
∀ ⦃X Y : Cᵒᵖ⦄ (f : X ⟶ Y) (r : ↑(R.obj X)) (m : ↑(M.obj X)),
(CategoryTheory.ConcreteCategory.hom (M.map f)) (r • m) =
(CategoryTheory.ConcreteCategory.hom (R.map f)) r • (CategoryTheory.ConcreteCategory.hom (M.map f)) m)
{X Y : Cᵒᵖ} (f : X ⟶ Y),
(PresheafOfModules.ofPresheaf M map_smul).map f =
ModuleCat.ofHom
{ toFun := fun x => (CategoryTheory.ConcreteCategory.hom (M.map f)) x, map_add' := ⋯, map_smul' := ⋯ } |
MeasureTheory.Measure.ae_ae_eq_curry_of_prod | Mathlib.MeasureTheory.Measure.Prod | ∀ {α : Type u_1} {β : Type u_2} [inst : MeasurableSpace α] [inst_1 : MeasurableSpace β] {μ : MeasureTheory.Measure α}
{ν : MeasureTheory.Measure β} [MeasureTheory.SFinite ν] {γ : Type u_4} {f g : α × β → γ},
f =ᵐ[μ.prod ν] g → ∀ᵐ (x : α) ∂μ, Function.curry f x =ᵐ[ν] Function.curry g x |
DirectLimit.Ring.lift._proof_1 | Mathlib.Algebra.Colimit.DirectLimit | ∀ {ι : Type u_2} [inst : Preorder ι] (G : ι → Type u_3) {T : ⦃i j : ι⦄ → i ≤ j → Type u_4}
(f : (x x_1 : ι) → (h : x ≤ x_1) → T h) [inst_1 : (i j : ι) → (h : i ≤ j) → FunLike (T h) (G i) (G j)]
[inst_2 : DirectedSystem G fun x1 x2 x3 => ⇑(f x1 x2 x3)] [inst_3 : IsDirectedOrder ι]
[inst_4 : (i : ι) → NonAssocSemiring (G i)] [inst_5 : ∀ (i j : ι) (h : i ≤ j), RingHomClass (T h) (G i) (G j)]
[inst_6 : Nonempty ι] (P : Type u_1) [inst_7 : NonAssocSemiring P] (g : (i : ι) → G i →+* P)
(Hg : ∀ (i j : ι) (hij : i ≤ j) (x : G i), (g j) ((f i j hij) x) = (g i) x),
DirectLimit.lift f (fun x1 x2 => (g x1) x2) ⋯ 1 = 1 |
CategoryTheory.Bicategory.mateEquiv_symm_apply' | Mathlib.CategoryTheory.Bicategory.Adjunction.Mate | ∀ {B : Type u} [inst : CategoryTheory.Bicategory B] {c d e f : B} {g : c ⟶ e} {h : d ⟶ f} {l₁ : c ⟶ d} {r₁ : d ⟶ c}
{l₂ : e ⟶ f} {r₂ : f ⟶ e} (adj₁ : CategoryTheory.Bicategory.Adjunction l₁ r₁)
(adj₂ : CategoryTheory.Bicategory.Adjunction l₂ r₂)
(β : CategoryTheory.CategoryStruct.comp r₁ g ⟶ CategoryTheory.CategoryStruct.comp h r₂),
(CategoryTheory.Bicategory.mateEquiv adj₁ adj₂).symm β =
CategoryTheory.bicategoricalComp (CategoryTheory.CategoryStruct.id (CategoryTheory.CategoryStruct.comp g l₂))
(CategoryTheory.bicategoricalComp
(CategoryTheory.Bicategory.whiskerRight (CategoryTheory.Bicategory.whiskerRight adj₁.unit g) l₂)
(CategoryTheory.bicategoricalComp
(CategoryTheory.Bicategory.whiskerLeft l₁ (CategoryTheory.Bicategory.whiskerRight β l₂))
(CategoryTheory.bicategoricalComp
(CategoryTheory.Bicategory.whiskerLeft l₁ (CategoryTheory.Bicategory.whiskerLeft h adj₂.counit))
(CategoryTheory.CategoryStruct.id (CategoryTheory.CategoryStruct.comp l₁ h))))) |
Int.Linear.Poly.divAll.eq_def | Init.Data.Int.Linear | ∀ (k : ℤ) (x : Int.Linear.Poly),
Int.Linear.Poly.divAll k x =
match x with
| Int.Linear.Poly.num k' => k' % k == 0
| Int.Linear.Poly.add k' v p => k' % k == 0 && Int.Linear.Poly.divAll k p |
MeasureTheory.VectorMeasure.equivMeasure_symm_apply | Mathlib.MeasureTheory.VectorMeasure.Basic | ∀ {α : Type u_1} [inst : MeasurableSpace α] (μ : MeasureTheory.Measure α),
MeasureTheory.VectorMeasure.equivMeasure.symm μ = μ.toENNRealVectorMeasure |
Dynamics.dynEntourage_univ | Mathlib.Dynamics.TopologicalEntropy.DynamicalEntourage | ∀ {X : Type u_1} {T : X → X} {n : ℕ}, Dynamics.dynEntourage T Set.univ n = Set.univ |
IsLowerSet.compl | Mathlib.Order.UpperLower.Basic | ∀ {α : Type u_1} [inst : LE α] {s : Set α}, IsLowerSet s → IsUpperSet sᶜ |
BoxIntegral.Prepartition.mem_disjUnion._simp_1 | Mathlib.Analysis.BoxIntegral.Partition.Basic | ∀ {ι : Type u_1} {I J : BoxIntegral.Box ι} {π₁ π₂ : BoxIntegral.Prepartition I} (H : Disjoint π₁.iUnion π₂.iUnion),
(J ∈ π₁.disjUnion π₂ H) = (J ∈ π₁ ∨ J ∈ π₂) |
Std.DHashMap.Internal.AssocList.cons.injEq | Std.Data.DHashMap.Internal.AssocList.Basic | ∀ {α : Type u} {β : α → Type v} (key : α) (value : β key) (tail : Std.DHashMap.Internal.AssocList α β) (key_1 : α)
(value_1 : β key_1) (tail_1 : Std.DHashMap.Internal.AssocList α β),
(Std.DHashMap.Internal.AssocList.cons key value tail = Std.DHashMap.Internal.AssocList.cons key_1 value_1 tail_1) =
(key = key_1 ∧ value ≍ value_1 ∧ tail = tail_1) |
Subspace.quotAnnihilatorEquiv._proof_2 | Mathlib.LinearAlgebra.Dual.Lemmas | ∀ {K : Type u_1} [inst : Field K], RingHomCompTriple (RingHom.id K) (RingHom.id K) (RingHom.id K) |
Disjoint.exists_open_convexes | Mathlib.Topology.Algebra.Module.LocallyConvex | ∀ {𝕜 : Type u_1} {E : Type u_2} [inst : Field 𝕜] [inst_1 : LinearOrder 𝕜] [IsStrictOrderedRing 𝕜]
[inst_3 : AddCommGroup E] [inst_4 : Module 𝕜 E] [inst_5 : TopologicalSpace E] [IsTopologicalAddGroup E]
[ContinuousConstSMul 𝕜 E] [LocallyConvexSpace 𝕜 E] {s t : Set E},
Disjoint s t →
Convex 𝕜 s →
IsCompact s →
Convex 𝕜 t → IsClosed t → ∃ u v, IsOpen u ∧ IsOpen v ∧ Convex 𝕜 u ∧ Convex 𝕜 v ∧ s ⊆ u ∧ t ⊆ v ∧ Disjoint u v |
Matroid.uniqueBaseOn_isBase_iff | Mathlib.Combinatorics.Matroid.Constructions | ∀ {α : Type u_1} {E B I : Set α}, I ⊆ E → ((Matroid.uniqueBaseOn I E).IsBase B ↔ B = I) |
ascPochhammer_zero | Mathlib.RingTheory.Polynomial.Pochhammer | ∀ (S : Type u) [inst : Semiring S], ascPochhammer S 0 = 1 |
_private.Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.NonUnital.0._auto_268 | Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.NonUnital | Lean.Syntax |
CategoryTheory.Limits.hasPullback_unop_iff_hasPushout._simp_1 | Mathlib.CategoryTheory.Limits.Shapes.Opposites.Pullbacks | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {X Y Z : Cᵒᵖ} (f : X ⟶ Y) (g : X ⟶ Z),
CategoryTheory.Limits.HasPullback f.unop g.unop = CategoryTheory.Limits.HasPushout f g |
Lean.Meta.Cases.Context.recOn | Lean.Meta.Tactic.Cases | {motive : Lean.Meta.Cases.Context → Sort u} →
(t : Lean.Meta.Cases.Context) →
((inductiveVal : Lean.InductiveVal) →
(nminors : ℕ) →
(majorDecl : Lean.LocalDecl) →
(majorTypeFn : Lean.Expr) →
(majorTypeArgs majorTypeIndices : Array Lean.Expr) →
motive
{ inductiveVal := inductiveVal, nminors := nminors, majorDecl := majorDecl,
majorTypeFn := majorTypeFn, majorTypeArgs := majorTypeArgs,
majorTypeIndices := majorTypeIndices }) →
motive t |
AddGrpCat.instConcreteCategoryAddMonoidHomCarrier._proof_2 | Mathlib.Algebra.Category.Grp.Basic | ∀ {X Y : AddGrpCat} (f : X ⟶ Y), { hom' := f.hom' } = f |
FractionalIdeal.coeIdeal_mul._simp_1 | Mathlib.RingTheory.FractionalIdeal.Basic | ∀ {R : Type u_1} [inst : CommRing R] {S : Submonoid R} {P : Type u_2} [inst_1 : CommRing P] [inst_2 : Algebra R P]
(I J : Ideal R), ↑I * ↑J = ↑(I * J) |
Matrix.blockDiag_map | Mathlib.Data.Matrix.Block | ∀ {m : Type u_2} {n : Type u_3} {o : Type u_4} {α : Type u_12} {β : Type u_13} (M : Matrix (m × o) (n × o) α)
(f : α → β), (M.map f).blockDiag = fun k => (M.blockDiag k).map f |
Finset.biUnion_op_vadd_finset | Mathlib.Algebra.Group.Action.Pointwise.Finset | ∀ {α : Type u_2} [inst : Add α] [inst_1 : DecidableEq α] (s t : Finset α),
(t.biUnion fun a => AddOpposite.op a +ᵥ s) = s + t |
_private.Init.Data.Slice.List.Lemmas.0.List.toArray_mkSlice_rcc._simp_1_1 | Init.Data.Slice.List.Lemmas | ∀ {α : Type u_1} {xs : ListSlice α}, Std.Slice.toArray xs = (Std.Slice.toList xs).toArray |
not_of_iff_false | Init.Core | ∀ {p : Prop}, (p ↔ False) → ¬p |
Polynomial.scaleRoots_dvd_iff | Mathlib.RingTheory.Polynomial.ScaleRoots | ∀ {R : Type u_1} [inst : CommSemiring R] (p q : Polynomial R) {r : R},
IsUnit r → (p.scaleRoots r ∣ q.scaleRoots r ↔ p ∣ q) |
SimpleGraph.mk.sizeOf_spec | Mathlib.Combinatorics.SimpleGraph.Basic | ∀ {V : Type u} [inst : SizeOf V] (Adj : V → V → Prop) (symm : autoParam (Symmetric Adj) SimpleGraph.symm._autoParam)
(loopless : autoParam (Std.Irrefl Adj) SimpleGraph.loopless._autoParam),
sizeOf { Adj := Adj, symm := symm, loopless := loopless } = 1 + sizeOf loopless |
_private.Std.Data.Iterators.Lemmas.Combinators.Monadic.FilterMap.0.Std.IterM.stepAsHetT_filterMapWithPostcondition.match_3.eq_1 | Std.Data.Iterators.Lemmas.Combinators.Monadic.FilterMap | ∀ {m : Type u_1 → Type u_2} {α β : Type u_1} (motive : Std.IterStep (Std.IterM m β) β → Sort u_3) (it' : Std.IterM m β)
(out : β) (h_1 : (it' : Std.IterM m β) → (out : β) → motive (Std.IterStep.yield it' out))
(h_2 : (it' : Std.IterM m β) → motive (Std.IterStep.skip it')) (h_3 : Unit → motive Std.IterStep.done),
(match Std.IterStep.yield it' out with
| Std.IterStep.yield it' out => h_1 it' out
| Std.IterStep.skip it' => h_2 it'
| Std.IterStep.done => h_3 ()) =
h_1 it' out |
_private.Mathlib.NumberTheory.EllipticDivisibilitySequence.0.complEDS₂_mul_b._simp_1_9 | Mathlib.NumberTheory.EllipticDivisibilitySequence | ∀ {α : Type u_1} [inst : SubtractionCommMonoid α] (a b : α), -a - b = -(a + b) |
_private.Mathlib.RepresentationTheory.Homological.GroupHomology.Functoriality.0.groupHomology.mapCycles₁_quotientGroupMk'_epi._simp_2 | Mathlib.RepresentationTheory.Homological.GroupHomology.Functoriality | ∀ {k G : Type u} [inst : CommRing k] [inst_1 : Group G] {A : Rep k G} (x : G →₀ ↑A.V),
(x ∈ groupHomology.cycles₁ A) = ((x.sum fun g a => (A.ρ g⁻¹) a) = x.sum fun x a => a) |
CategoryTheory.HasShift.recOn | Mathlib.CategoryTheory.Shift.Basic | {C : Type u} →
{A : Type u_2} →
[inst : CategoryTheory.Category.{v, u} C] →
[inst_1 : AddMonoid A] →
{motive : CategoryTheory.HasShift C A → Sort u_1} →
(t : CategoryTheory.HasShift C A) →
((shift : CategoryTheory.Functor (CategoryTheory.Discrete A) (CategoryTheory.Functor C C)) →
(shiftMonoidal : shift.Monoidal) → motive { shift := shift, shiftMonoidal := shiftMonoidal }) →
motive t |
_aux_Mathlib_Analysis_Normed_Operator_LinearIsometry___unexpand_LinearIsometryEquiv_2 | Mathlib.Analysis.Normed.Operator.LinearIsometry | Lean.PrettyPrinter.Unexpander |
_private.Batteries.Data.BitVec.Lemmas.0.BitVec.msb_ofFnBE._proof_1_5 | Batteries.Data.BitVec.Lemmas | ∀ {n : ℕ} (f : Fin n → Bool), (BitVec.ofFnBE f).msb = if h : ¬n = 0 then f ⟨0, ⋯⟩ else false |
CategoryTheory.Limits.FormalCoproduct.mk.inj | Mathlib.CategoryTheory.Limits.FormalCoproducts.Basic | ∀ {C : Type u} {I : Type w} {obj : I → C} {I_1 : Type w} {obj_1 : I_1 → C},
{ I := I, obj := obj } = { I := I_1, obj := obj_1 } → I = I_1 ∧ obj ≍ obj_1 |
isEmbedding_of_iSup_eq_top_of_preimage_subset_range | Mathlib.Topology.LocalAtTarget | ∀ {X : Type u_6} {Y : Type u_7} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y] (f : X → Y),
Continuous f →
∀ {ι : Type u_4} (U : ι → TopologicalSpace.Opens Y),
Set.range f ⊆ ↑(iSup U) →
∀ (V : ι → Type u_5) [inst_2 : (i : ι) → TopologicalSpace (V i)] (iV : (i : ι) → V i → X),
(∀ (i : ι), Continuous (iV i)) →
(∀ (i : ι), f ⁻¹' ↑(U i) ⊆ Set.range (iV i)) →
(∀ (i : ι), Topology.IsEmbedding (f ∘ iV i)) → Topology.IsEmbedding f |
Nat.even_mul | Mathlib.Algebra.Group.Nat.Even | ∀ {m n : ℕ}, Even (m * n) ↔ Even m ∨ Even n |
Subring.instCompleteLattice.match_1 | Mathlib.Algebra.Ring.Subring.Basic | ∀ {R : Type u_1} [inst : Ring R] (_x : R) (motive : (∃ n, ↑n = _x) → Prop) (x : ∃ n, ↑n = _x),
(∀ (n : ℤ) (hn : ↑n = _x), motive ⋯) → motive x |
CategoryTheory.MorphismProperty.TransfiniteCompositionOfShape.ici | Mathlib.CategoryTheory.MorphismProperty.TransfiniteComposition | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
{W : CategoryTheory.MorphismProperty C} →
{J : Type w} →
[inst_1 : LinearOrder J] →
[inst_2 : SuccOrder J] →
[inst_3 : OrderBot J] →
[inst_4 : WellFoundedLT J] →
{X Y : C} →
{f : X ⟶ Y} →
(h : W.TransfiniteCompositionOfShape J f) →
(j : J) → W.TransfiniteCompositionOfShape (↑(Set.Ici j)) (h.incl.app j) |
_private.Mathlib.Tactic.Widget.LibraryRewrite.0.Mathlib.Tactic.LibraryRewrite.tacticSyntax.match_1 | Mathlib.Tactic.Widget.LibraryRewrite | (motive : Lean.MVarId × Lean.BinderInfo → Sort u_1) →
(x : Lean.MVarId × Lean.BinderInfo) →
((mvarId : Lean.MVarId) → (snd : Lean.BinderInfo) → motive (mvarId, snd)) → motive x |
Flag.maxChain | Mathlib.Order.Preorder.Chain | ∀ {α : Type u_1} [inst : LE α] (s : Flag α), IsMaxChain (fun x1 x2 => x1 ≤ x2) ↑s |
Lean.PrefixTreeNode.rec | Lean.Data.PrefixTree | {α : Type u} →
{β : Type v} →
{cmp : α → α → Ordering} →
{motive_1 : Lean.PrefixTreeNode α β cmp → Sort u_1} →
{motive_2 : Std.TreeMap.Raw α (Lean.PrefixTreeNode α β cmp) cmp → Sort u_1} →
{motive_3 : Std.DTreeMap.Raw α (fun x => Lean.PrefixTreeNode α β cmp) cmp → Sort u_1} →
{motive_4 : (Std.DTreeMap.Internal.Impl α fun x => Lean.PrefixTreeNode α β cmp) → Sort u_1} →
((a : Option β) →
(a_1 : Std.TreeMap.Raw α (Lean.PrefixTreeNode α β cmp) cmp) →
motive_2 a_1 → motive_1 (Lean.PrefixTreeNode.Node a a_1)) →
((inner : Std.DTreeMap.Raw α (fun x => Lean.PrefixTreeNode α β cmp) cmp) →
motive_3 inner → motive_2 { inner := inner }) →
((inner : Std.DTreeMap.Internal.Impl α fun x => Lean.PrefixTreeNode α β cmp) →
motive_4 inner → motive_3 { inner := inner }) →
((size : ℕ) →
(k : α) →
(v : (fun x => Lean.PrefixTreeNode α β cmp) k) →
(l r : Std.DTreeMap.Internal.Impl α fun x => Lean.PrefixTreeNode α β cmp) →
motive_1 v →
motive_4 l → motive_4 r → motive_4 (Std.DTreeMap.Internal.Impl.inner size k v l r)) →
motive_4 Std.DTreeMap.Internal.Impl.leaf → (t : Lean.PrefixTreeNode α β cmp) → motive_1 t |
Function.iterate_zero | Mathlib.Logic.Function.Iterate | ∀ {α : Type u} (f : α → α), f^[0] = id |
IsSeqCompact.exists_tendsto_of_frequently_mem | Mathlib.Topology.Sequences | ∀ {X : Type u_1} [inst : UniformSpace X] {s : Set X},
IsSeqCompact s →
∀ {u : ℕ → X}, (∃ᶠ (n : ℕ) in Filter.atTop, u n ∈ s) → CauchySeq u → ∃ x ∈ s, Filter.Tendsto u Filter.atTop (nhds x) |
Int.isSome_getElem?_toArray_rco_eq | Init.Data.Range.Polymorphic.IntLemmas | ∀ {m n : ℤ} {i : ℕ}, ((m...n).toArray[i]?.isSome = true) = (i < (n - m).toNat) |
Antivary.div_right | Mathlib.Algebra.Order.Monovary | ∀ {ι : Type u_1} {α : Type u_2} {β : Type u_3} [inst : Preorder α] [inst_1 : CommGroup β] [inst_2 : LinearOrder β]
[IsOrderedMonoid β] {f : ι → α} {g₁ g₂ : ι → β}, Antivary f g₁ → Monovary f g₂ → Antivary f (g₁ / g₂) |
rexp_neg_quadratic_isLittleO_rpow_atTop | Mathlib.Analysis.SpecialFunctions.Gaussian.PoissonSummation | ∀ {a : ℝ}, a < 0 → ∀ (b s : ℝ), (fun x => Real.exp (a * x ^ 2 + b * x)) =o[Filter.atTop] fun x => x ^ s |
Matroid.sigma._proof_4 | Mathlib.Combinatorics.Matroid.Sum | ∀ {ι : Type u_1} {α : ι → Type u_2} (M : (i : ι) → Matroid (α i)), ∃ B, ∀ (i : ι), (M i).IsBase (Sigma.mk i ⁻¹' B) |
CategoryTheory.Limits.WalkingParallelPair.one.elim | Mathlib.CategoryTheory.Limits.Shapes.Equalizers | {motive : CategoryTheory.Limits.WalkingParallelPair → Sort u} →
(t : CategoryTheory.Limits.WalkingParallelPair) →
t.ctorIdx = 1 → motive CategoryTheory.Limits.WalkingParallelPair.one → motive t |
GenContFract.IntFractPair.seq1.eq_1 | Mathlib.Algebra.ContinuedFractions.Computation.Translations | ∀ {K : Type u_1} [inst : DivisionRing K] [inst_1 : LinearOrder K] [inst_2 : FloorRing K] (v : K),
GenContFract.IntFractPair.seq1 v =
(GenContFract.IntFractPair.of v, Stream'.Seq.tail ⟨GenContFract.IntFractPair.stream v, ⋯⟩) |
Nat.lt_wfRel | Init.WF | WellFoundedRelation ℕ |
_private.Mathlib.RingTheory.Polynomial.Resultant.Basic.0.Polynomial.resultant_succ_left_deg._simp_1_13 | Mathlib.RingTheory.Polynomial.Resultant.Basic | ∀ {n : ℕ} {a b : Fin n}, (a = b) = (↑a = ↑b) |
AlgebraicGeometry.LocallyRingedSpace.IsOpenImmersion.inv_naturality | Mathlib.Geometry.RingedSpace.OpenImmersion | ∀ {X Y : AlgebraicGeometry.LocallyRingedSpace} (f : X ⟶ Y) [H : AlgebraicGeometry.LocallyRingedSpace.IsOpenImmersion f]
{U V : (TopologicalSpace.Opens ↑X.toTopCat)ᵒᵖ} (i : U ⟶ V),
CategoryTheory.CategoryStruct.comp (X.presheaf.map i)
(AlgebraicGeometry.LocallyRingedSpace.IsOpenImmersion.invApp f (Opposite.unop V)) =
CategoryTheory.CategoryStruct.comp (AlgebraicGeometry.LocallyRingedSpace.IsOpenImmersion.invApp f (Opposite.unop U))
(Y.presheaf.map ((AlgebraicGeometry.LocallyRingedSpace.IsOpenImmersion.opensFunctor f).op.map i)) |
_private.Mathlib.Data.Set.Finite.Lemmas.0.Set.exists_max_image.match_1_1 | Mathlib.Data.Set.Finite.Lemmas | ∀ {α : Type u_1} (s : Set α) (motive : s.Nonempty → Prop) (x : s.Nonempty),
(∀ (x : α) (hx : x ∈ s), motive ⋯) → motive x |
LightCondensed.freeForgetAdjunction | Mathlib.Condensed.Light.Module | (R : Type u) → [inst : Ring R] → LightCondensed.free R ⊣ LightCondensed.forget R |
Std.ExtDHashMap.contains_of_contains_insertIfNew | Std.Data.ExtDHashMap.Lemmas | ∀ {α : Type u} {x : BEq α} {x_1 : Hashable α} {β : α → Type v} {m : Std.ExtDHashMap α β} [inst : EquivBEq α]
[inst_1 : LawfulHashable α] {k a : α} {v : β k},
(m.insertIfNew k v).contains a = true → (k == a) = false → m.contains a = true |
VonNeumannAlgebra.zero_mem'._inherited_default | Mathlib.Analysis.VonNeumannAlgebra.Basic | ∀ {H : Type u} {inst : NormedAddCommGroup H} {inst_1 : InnerProductSpace ℂ H} {inst_2 : CompleteSpace H}
(carrier : Set (H →L[ℂ] H)), (∀ (r : ℂ), (algebraMap ℂ (H →L[ℂ] H)) r ∈ carrier) → 0 ∈ carrier |
_private.Mathlib.Tactic.NormNum.Result.0.Mathlib.Meta.NormNum.isNat.natElim.match_1_1 | Mathlib.Tactic.NormNum.Result | ∀ {p : ℕ → Prop} (motive : (x x_1 : ℕ) → Mathlib.Meta.NormNum.IsNat x x_1 → p x_1 → Prop) (x x_1 : ℕ)
(x_2 : Mathlib.Meta.NormNum.IsNat x x_1) (x_3 : p x_1),
(∀ (n : ℕ) (h : p n), motive (↑n) n ⋯ h) → motive x x_1 x_2 x_3 |
DirectSum.lid | Mathlib.Algebra.DirectSum.Module | (R : Type u) →
[inst : Semiring R] →
(M : Type v) →
(ι : optParam (Type u_1) PUnit.{u_1 + 1}) →
[inst_1 : AddCommMonoid M] → [inst_2 : Module R M] → [Unique ι] → (DirectSum ι fun x => M) ≃ₗ[R] M |
Array.back.congr_simp | Init.Data.List.ToArray | ∀ {α : Type u} (xs xs_1 : Array α) (e_xs : xs = xs_1) (h : 0 < xs.size), xs.back h = xs_1.back ⋯ |
Lean.IR.Alt.brecOn | Lean.Compiler.IR.Basic | {motive_1 : Lean.IR.Alt → Sort u} →
{motive_2 : Lean.IR.FnBody → Sort u} →
{motive_3 : Array Lean.IR.Alt → Sort u} →
{motive_4 : List Lean.IR.Alt → Sort u} →
(t : Lean.IR.Alt) →
((t : Lean.IR.Alt) → t.below → motive_1 t) →
((t : Lean.IR.FnBody) → t.below → motive_2 t) →
((t : Array Lean.IR.Alt) → Lean.IR.Alt.below_1 t → motive_3 t) →
((t : List Lean.IR.Alt) → Lean.IR.Alt.below_2 t → motive_4 t) → motive_1 t |
AddOpposite.instNeg.eq_1 | Mathlib.Algebra.Opposites | ∀ {α : Type u_1} [inst : Neg α], AddOpposite.instNeg = { neg := fun x => AddOpposite.op (-AddOpposite.unop x) } |
Std.Internal.List.Const.getKeyD_filter | Std.Data.Internal.List.Associative | ∀ {α : Type u} [inst : BEq α] [inst_1 : EquivBEq α] {β : Type v} {f : α → β → Bool} {l : List ((_ : α) × β)}
{k fallback : α},
Std.Internal.List.DistinctKeys l →
Std.Internal.List.getKeyD k (List.filter (fun p => f p.fst p.snd) l) fallback =
((Std.Internal.List.getKey? k l).pfilter fun x h => f x (Std.Internal.List.getValue x l ⋯)).getD fallback |
Sum.swap_rightInverse | Mathlib.Data.Sum.Basic | ∀ {α : Type u} {β : Type v}, Function.RightInverse Sum.swap Sum.swap |
_private.Init.Data.Iterators.Lemmas.Combinators.FilterMap.0.Std.Iter.forIn_filterMapWithPostcondition.match_1.eq_2 | Init.Data.Iterators.Lemmas.Combinators.FilterMap | ∀ {β₂ : Type u_1} (motive : Option β₂ → Sort u_2) (h_1 : (c : β₂) → motive (some c)) (h_2 : Unit → motive none),
(match none with
| some c => h_1 c
| none => h_2 ()) =
h_2 () |
ContinuousLinearEquiv.conjContinuousAlgEquiv_apply_apply | Mathlib.Topology.Algebra.Module.StrongTopology | ∀ {𝕜 : Type u_1} {G : Type u_4} {H : Type u_5} [inst : AddCommGroup G] [inst_1 : AddCommGroup H]
[inst_2 : NormedField 𝕜] [inst_3 : Module 𝕜 G] [inst_4 : Module 𝕜 H] [inst_5 : TopologicalSpace G]
[inst_6 : TopologicalSpace H] [inst_7 : IsTopologicalAddGroup G] [inst_8 : IsTopologicalAddGroup H]
[inst_9 : ContinuousConstSMul 𝕜 G] [inst_10 : ContinuousConstSMul 𝕜 H] (e : G ≃L[𝕜] H) (f : G →L[𝕜] G) (x : H),
(e.conjContinuousAlgEquiv f) x = e (f (e.symm x)) |
semicontinuous_restrict_iff._simp_1 | Mathlib.Topology.Semicontinuity.Defs | ∀ {α : Type u_1} {β : Type u_2} [inst : TopologicalSpace α] {r : α → β → Prop} {s : Set α},
Semicontinuous (s.restrict r) = SemicontinuousOn r s |
FreeAddMonoid.toList.eq_1 | Mathlib.Algebra.FreeMonoid.Basic | ∀ {α : Type u_1}, FreeAddMonoid.toList = Equiv.refl (FreeAddMonoid α) |
Lean.Lsp.Command.recOn | Lean.Data.Lsp.Basic | {motive : Lean.Lsp.Command → Sort u} →
(t : Lean.Lsp.Command) →
((title command : String) →
(arguments? : Option (Array Lean.Json)) →
motive { title := title, command := command, arguments? := arguments? }) →
motive t |
AlgebraicGeometry.Scheme.Modules.Hom.isIso_iff_isIso_app | Mathlib.AlgebraicGeometry.Modules.Sheaf | ∀ {X : AlgebraicGeometry.Scheme} {M N : X.Modules} {φ : M ⟶ N},
CategoryTheory.IsIso φ ↔ ∀ (U : X.Opens), CategoryTheory.IsIso (AlgebraicGeometry.Scheme.Modules.Hom.app φ U) |
_private.Mathlib.Tactic.Widget.Conv.0.Mathlib.Tactic.Conv.pathToStx.match_3 | Mathlib.Tactic.Widget.Conv | (motive : Mathlib.Tactic.Conv.Path → Sort u_1) →
(path : Mathlib.Tactic.Conv.Path) →
((arg : ℕ) →
(all : Bool) → (next : Mathlib.Tactic.Conv.Path) → motive (Mathlib.Tactic.Conv.Path.arg arg all next)) →
((next : Mathlib.Tactic.Conv.Path) → motive next.type) →
((name : Lean.Name) → (next : Mathlib.Tactic.Conv.Path) → motive (Mathlib.Tactic.Conv.Path.body name next)) →
((depth : ℕ) → motive (Mathlib.Tactic.Conv.Path.fun depth)) → motive path |
Nat.binaryRec'._proof_1 | Mathlib.Data.Nat.BinaryRec | ∀ {motive : ℕ → Sort u_1} (b : Bool) (n : ℕ) (ih : motive n), ¬(n = 0 → b = true) → Nat.bit b n = 0 |
PrincipalSeg.ordinal_type_lt | Mathlib.SetTheory.Ordinal.Basic | ∀ {α β : Type u_1} {r : α → α → Prop} {s : β → β → Prop} [inst : IsWellOrder α r] [inst_1 : IsWellOrder β s]
(h : PrincipalSeg r s), Ordinal.type r < Ordinal.type s |
Mathlib.Tactic.Abel.AbelNF.Config.mk._flat_ctor | Mathlib.Tactic.Abel | Lean.Meta.TransparencyMode → Bool → Bool → Mathlib.Tactic.Abel.AbelMode → Mathlib.Tactic.Abel.AbelNF.Config |
Mathlib.Tactic.ITauto.IProp.and'.noConfusion | Mathlib.Tactic.ITauto | {P : Sort u} →
{a : Mathlib.Tactic.ITauto.AndKind} →
{a_1 a_2 : Mathlib.Tactic.ITauto.IProp} →
{a' : Mathlib.Tactic.ITauto.AndKind} →
{a'_1 a'_2 : Mathlib.Tactic.ITauto.IProp} →
Mathlib.Tactic.ITauto.IProp.and' a a_1 a_2 = Mathlib.Tactic.ITauto.IProp.and' a' a'_1 a'_2 →
(a = a' → a_1 = a'_1 → a_2 = a'_2 → P) → P |
Mathlib.Meta.FunProp.LambdaTheorems._sizeOf_1 | Mathlib.Tactic.FunProp.Theorems | Mathlib.Meta.FunProp.LambdaTheorems → ℕ |
AlgebraicGeometry.Scheme.LocalRepresentability.glueData._proof_14 | Mathlib.AlgebraicGeometry.Sites.Representability | ∀ {F : CategoryTheory.Sheaf AlgebraicGeometry.Scheme.zariskiTopology (Type u_1)} {ι : Type u_1}
{X : ι → AlgebraicGeometry.Scheme} {f : (i : ι) → CategoryTheory.yoneda.obj (X i) ⟶ F.obj}
(hf : ∀ (i : ι), AlgebraicGeometry.IsOpenImmersion.presheaf (f i)) (i j k : ι),
CategoryTheory.CategoryStruct.comp
(⋯.lift₃ (f k) (f i) (CategoryTheory.Functor.relativelyRepresentable.pullback₃.p₂ ⋯ (f j) (f k))
(CategoryTheory.Functor.relativelyRepresentable.pullback₃.p₃ ⋯ (f j) (f k))
(CategoryTheory.Functor.relativelyRepresentable.pullback₃.p₁ ⋯ (f j) (f k)) ⋯ ⋯)
(CategoryTheory.CategoryStruct.comp
(⋯.lift₃ (f i) (f j) (CategoryTheory.Functor.relativelyRepresentable.pullback₃.p₂ ⋯ (f k) (f i))
(CategoryTheory.Functor.relativelyRepresentable.pullback₃.p₃ ⋯ (f k) (f i))
(CategoryTheory.Functor.relativelyRepresentable.pullback₃.p₁ ⋯ (f k) (f i)) ⋯ ⋯)
(⋯.lift₃ (f j) (f k) (CategoryTheory.Functor.relativelyRepresentable.pullback₃.p₂ ⋯ (f i) (f j))
(CategoryTheory.Functor.relativelyRepresentable.pullback₃.p₃ ⋯ (f i) (f j))
(CategoryTheory.Functor.relativelyRepresentable.pullback₃.p₁ ⋯ (f i) (f j)) ⋯ ⋯)) =
CategoryTheory.CategoryStruct.id (CategoryTheory.Limits.pullback (⋯.fst' (f j)) (⋯.fst' (f k))) |
_private.Mathlib.NumberTheory.PellMatiyasevic.0.Pell.matiyasevic.match_1_5 | Mathlib.NumberTheory.PellMatiyasevic | ∀ {a k x y : ℕ}
(motive :
(x = 1 ∧ y = 0 ∨
∃ u v s t b,
x * x - (a * a - 1) * y * y = 1 ∧
u * u - (a * a - 1) * v * v = 1 ∧
s * s - (b * b - 1) * t * t = 1 ∧
1 < b ∧ b ≡ 1 [MOD 4 * y] ∧ b ≡ a [MOD u] ∧ 0 < v ∧ y * y ∣ v ∧ s ≡ x [MOD u] ∧ t ≡ k [MOD 4 * y]) →
Prop)
(o :
x = 1 ∧ y = 0 ∨
∃ u v s t b,
x * x - (a * a - 1) * y * y = 1 ∧
u * u - (a * a - 1) * v * v = 1 ∧
s * s - (b * b - 1) * t * t = 1 ∧
1 < b ∧ b ≡ 1 [MOD 4 * y] ∧ b ≡ a [MOD u] ∧ 0 < v ∧ y * y ∣ v ∧ s ≡ x [MOD u] ∧ t ≡ k [MOD 4 * y]),
(∀ (x1 : x = 1) (y0 : y = 0), motive ⋯) →
(∀ (u v s t b : ℕ) (xy : x * x - (a * a - 1) * y * y = 1) (uv : u * u - (a * a - 1) * v * v = 1)
(st : s * s - (b * b - 1) * t * t = 1) (b1 : 1 < b)
(rem : b ≡ 1 [MOD 4 * y] ∧ b ≡ a [MOD u] ∧ 0 < v ∧ y * y ∣ v ∧ s ≡ x [MOD u] ∧ t ≡ k [MOD 4 * y]), motive ⋯) →
motive o |
Affine.Simplex.instFintypePointsWithCircumcenterIndex.match_3 | Mathlib.Geometry.Euclidean.Circumcenter | (n : ℕ) →
(motive : Fin (n + 1) ⊕ Unit → Sort u_1) →
(x : Fin (n + 1) ⊕ Unit) →
((a : Fin (n + 1)) → motive (Sum.inl a)) → (Unit → motive (Sum.inr PUnit.unit)) → motive x |
Submodule.annihilator | Mathlib.RingTheory.Ideal.Maps | {R : Type u_1} →
{M : Type u_2} → [inst : Semiring R] → [inst_1 : AddCommMonoid M] → [inst_2 : Module R M] → Submodule R M → Ideal R |
_private.Mathlib.RingTheory.Spectrum.Prime.Topology.0.PrimeSpectrum.stableUnderSpecialization_singleton._simp_1_5 | Mathlib.RingTheory.Spectrum.Prime.Topology | ∀ {α : Sort u_1} {p : α → Prop} {a' : α}, (∀ (a : α), a = a' → p a) = p a' |
WellFoundedLT.finite_of_iSupIndep | Mathlib.Order.CompactlyGenerated.Basic | ∀ {α : Type u_2} [inst : CompleteLattice α] [WellFoundedLT α] {ι : Type u_3} {t : ι → α},
iSupIndep t → (∀ (i : ι), t i ≠ ⊥) → Finite ι |
summable_star_iff' | Mathlib.Topology.Algebra.InfiniteSum.Constructions | ∀ {α : Type u_1} {β : Type u_2} {L : SummationFilter β} [inst : AddCommMonoid α] [inst_1 : TopologicalSpace α]
[inst_2 : StarAddMonoid α] [ContinuousStar α] {f : β → α}, Summable (star f) L ↔ Summable f L |
_private.Mathlib.Algebra.Homology.HomotopyCofiber.0.HomologicalComplex.homotopyCofiber.descSigma_ext_iff._simp_1_1 | Mathlib.Algebra.Homology.HomotopyCofiber | ∀ {α : Type u_1} {β : α → Type u_4} {a₁ a₂ : α} {b₁ : β a₁} {b₂ : β a₂}, (⟨a₁, b₁⟩ = ⟨a₂, b₂⟩) = (a₁ = a₂ ∧ b₁ ≍ b₂) |
Lean.Meta.Grind.EMatchTheoremConstraint.notDefEq | Lean.Meta.Tactic.Grind.Extension | ℕ → Lean.Meta.Grind.CnstrRHS → Lean.Meta.Grind.EMatchTheoremConstraint |
LowerSet.coe_div._simp_2 | Mathlib.Algebra.Order.UpperLower | ∀ {α : Type u_1} [inst : CommGroup α] [inst_1 : Preorder α] [inst_2 : IsOrderedMonoid α] (s t : LowerSet α),
↑s / ↑t = ↑(s / t) |
pinGroup.star_mul_self | Mathlib.LinearAlgebra.CliffordAlgebra.SpinGroup | ∀ {R : Type u_1} [inst : CommRing R] {M : Type u_2} [inst_1 : AddCommGroup M] [inst_2 : Module R M]
{Q : QuadraticForm R M} (x : ↥(pinGroup Q)), star x * x = 1 |
Lean.Grind.CommRing.instReprMon.repr._sunfold | Init.Grind.Ring.CommSolver | Lean.Grind.CommRing.Mon → ℕ → Std.Format |
IsCyclotomicExtension.Rat.p_mem_span_zeta_sub_one | Mathlib.NumberTheory.NumberField.Cyclotomic.Ideal | ∀ (p k : ℕ) [hp : Fact (Nat.Prime p)] {K : Type u_1} [inst : Field K] [inst_1 : NumberField K]
[hK : IsCyclotomicExtension {p ^ (k + 1)} ℚ K] {ζ : K} (hζ : IsPrimitiveRoot ζ (p ^ (k + 1))),
↑p ∈ Ideal.span {hζ.toInteger - 1} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.