name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M |
|---|---|---|
Stream'.homomorphism | Mathlib.Data.Stream.Init | ∀ {α : Type u} {β : Type v} (f : α → β) (a : α), Stream'.pure f ⊛ Stream'.pure a = Stream'.pure (f a) |
_private.Mathlib.Geometry.RingedSpace.LocallyRingedSpace.ResidueField.0.AlgebraicGeometry.LocallyRingedSpace.basicOpen_eq_bot_iff_forall_evaluation_eq_zero._simp_1_1 | Mathlib.Geometry.RingedSpace.LocallyRingedSpace.ResidueField | ∀ {α : Sort u} {p : α → Prop} {q : { a // p a } → Prop}, (∀ (x : { a // p a }), q x) = ∀ (a : α) (b : p a), q ⟨a, b⟩ |
DFinsupp.nonempty_neLocus_iff | Mathlib.Data.DFinsupp.NeLocus | ∀ {α : Type u_1} {N : α → Type u_2} [inst : DecidableEq α] [inst_1 : (a : α) → DecidableEq (N a)]
[inst_2 : (a : α) → Zero (N a)] {f g : Π₀ (a : α), N a}, (f.neLocus g).Nonempty ↔ f ≠ g |
Module.mapEvalEquiv._proof_1 | Mathlib.LinearAlgebra.Dual.Defs | ∀ (R : Type u_1) [inst : CommSemiring R], RingHomSurjective (RingHom.id R) |
Num.instOrOp | Mathlib.Data.Num.Bitwise | OrOp Num |
AlgebraicGeometry.StructureSheaf.const_apply | Mathlib.AlgebraicGeometry.StructureSheaf | ∀ {R M : Type u} [inst : CommRing R] [inst_1 : AddCommGroup M] [inst_2 : Module R M] (f : M) (g : R)
(U : TopologicalSpace.Opens ↑(AlgebraicGeometry.PrimeSpectrum.Top R)) (hu : ∀ x ∈ U, g ∈ x.asIdeal.primeCompl)
(x : ↥U), ↑(AlgebraicGeometry.StructureSheaf.const f g U hu) x = LocalizedModule.mk f ⟨g, ⋯⟩ |
Submodule.mem_toAffineSubspace._simp_1 | Mathlib.LinearAlgebra.AffineSpace.AffineSubspace.Defs | ∀ {k : Type u_1} {V : Type u_2} [inst : Ring k] [inst_1 : AddCommGroup V] [inst_2 : Module k V] {p : Submodule k V}
{x : V}, (x ∈ p.toAffineSubspace) = (x ∈ p) |
_private.Mathlib.MeasureTheory.Measure.AddContent.0.MeasureTheory.AddContent.onIoc._proof_14 | Mathlib.MeasureTheory.Measure.AddContent | ∀ {α : Type u_1} [inst : LinearOrder α] (I : Finset (Set α)) (u v u' : α),
u ≤ u' →
⋃₀ ↑(I.erase (Set.Ioc u' v)) = Set.Ioc u u' → ⋃₀ ↑(I.erase (Set.Ioc u' v)) ∈ {s | ∃ u v, u ≤ v ∧ s = Set.Ioc u v} |
Lean.Meta.SolveByElim.SolveByElimConfig.testSolutions | Lean.Meta.Tactic.SolveByElim | optParam Lean.Meta.SolveByElim.SolveByElimConfig { } →
(List Lean.Expr → Lean.MetaM Bool) → Lean.Meta.SolveByElim.SolveByElimConfig |
CategoryTheory.MorphismProperty.pushout_inl | Mathlib.CategoryTheory.MorphismProperty.Limits | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {P : CategoryTheory.MorphismProperty C}
[P.IsStableUnderCobaseChange] {A B A' : C} (f : A ⟶ A') (g : A ⟶ B) [inst_2 : CategoryTheory.Limits.HasPushout f g],
P g → P (CategoryTheory.Limits.pushout.inl f g) |
ContinuousSemilinearEquivClass.map_continuous | Mathlib.Topology.Algebra.Module.Equiv | ∀ {F : Type u_1} {R : outParam (Type u_2)} {S : outParam (Type u_3)} {inst : Semiring R} {inst_1 : Semiring S}
{σ : outParam (R →+* S)} {σ' : outParam (S →+* R)} {inst_2 : RingHomInvPair σ σ'} {inst_3 : RingHomInvPair σ' σ}
{M : outParam (Type u_4)} {inst_4 : TopologicalSpace M} {inst_5 : AddCommMonoid M} {M₂ : outParam (Type u_5)}
{inst_6 : TopologicalSpace M₂} {inst_7 : AddCommMonoid M₂} {inst_8 : Module R M} {inst_9 : Module S M₂}
{inst_10 : EquivLike F M M₂} [self : ContinuousSemilinearEquivClass F σ M M₂] (f : F), Continuous ⇑f |
CategoryTheory.ShortComplex.FunctorEquivalence.inverse_map_τ₂ | Mathlib.Algebra.Homology.ShortComplex.FunctorEquivalence | ∀ (J : Type u_1) (C : Type u_2) [inst : CategoryTheory.Category.{v_1, u_1} J]
[inst_1 : CategoryTheory.Category.{v_2, u_2} C] [inst_2 : CategoryTheory.Limits.HasZeroMorphisms C]
{X Y : CategoryTheory.Functor J (CategoryTheory.ShortComplex C)} (φ : X ⟶ Y),
((CategoryTheory.ShortComplex.FunctorEquivalence.inverse J C).map φ).τ₂ =
CategoryTheory.Functor.whiskerRight φ CategoryTheory.ShortComplex.π₂ |
Polynomial.cyclotomic_irreducible_pow_of_irreducible_pow | Mathlib.RingTheory.Polynomial.Cyclotomic.Expand | ∀ {p : ℕ},
Nat.Prime p →
∀ {R : Type u_1} [inst : CommRing R] [IsDomain R] {n m : ℕ},
m ≤ n → Irreducible (Polynomial.cyclotomic (p ^ n) R) → Irreducible (Polynomial.cyclotomic (p ^ m) R) |
_private.Mathlib.Data.Seq.Computation.0.Stream'.cons.match_1.eq_2 | Mathlib.Data.Seq.Computation | ∀ (motive : ℕ → Sort u_1) (n : ℕ) (h_1 : Unit → motive 0) (h_2 : (n : ℕ) → motive n.succ),
(match n.succ with
| 0 => h_1 ()
| n.succ => h_2 n) =
h_2 n |
Lean.Name.componentsRev._sunfold | Lean.Data.Name | Lean.Name → List Lean.Name |
PartialEquiv.image_symm_image_of_subset_target | Mathlib.Logic.Equiv.PartialEquiv | ∀ {α : Type u_1} {β : Type u_2} (e : PartialEquiv α β) {s : Set β}, s ⊆ e.target → ↑e '' (↑e.symm '' s) = s |
DistLat.Iso.mk._proof_2 | Mathlib.Order.Category.DistLat | ∀ {α β : DistLat} (e : ↑α ≃o ↑β),
CategoryTheory.CategoryStruct.comp (DistLat.ofHom { toFun := ⇑e, map_sup' := ⋯, map_inf' := ⋯ })
(DistLat.ofHom { toFun := ⇑e.symm, map_sup' := ⋯, map_inf' := ⋯ }) =
CategoryTheory.CategoryStruct.id α |
instCoeTCAddEquivOfAddEquivClass | Mathlib.Algebra.Group.Equiv.Defs | {F : Type u_1} →
{α : Type u_2} →
{β : Type u_3} →
[inst : EquivLike F α β] → [inst_1 : Add α] → [inst_2 : Add β] → [AddEquivClass F α β] → CoeTC F (α ≃+ β) |
DistribLattice.ofInfSupLe._proof_2 | Mathlib.Order.Lattice | ∀ {α : Type u_1} [inst : Lattice α] (inf_sup_le : ∀ (a b c : α), a ⊓ (b ⊔ c) ≤ a ⊓ b ⊔ a ⊓ c) (a b : αᵒᵈᵒᵈ),
Lattice.inf a b ≤ b |
_private.Std.Data.DTreeMap.Internal.Model.0.Std.DTreeMap.Internal.Impl.maxView.match_1.splitter | Std.Data.DTreeMap.Internal.Model | {α : Type u_1} →
{β : α → Type u_2} →
(l : Std.DTreeMap.Internal.Impl α β) →
(motive :
(r : Std.DTreeMap.Internal.Impl α β) →
r.Balanced → Std.DTreeMap.Internal.Impl.BalancedAtRoot l.size r.size → Sort u_3) →
(r : Std.DTreeMap.Internal.Impl α β) →
(hr : r.Balanced) →
(hlr : Std.DTreeMap.Internal.Impl.BalancedAtRoot l.size r.size) →
((hr : Std.DTreeMap.Internal.Impl.leaf.Balanced) →
(hlr : Std.DTreeMap.Internal.Impl.BalancedAtRoot l.size Std.DTreeMap.Internal.Impl.leaf.size) →
motive Std.DTreeMap.Internal.Impl.leaf hr hlr) →
((size : ℕ) →
(k' : α) →
(v' : β k') →
(l' r' : Std.DTreeMap.Internal.Impl α β) →
(hr : (Std.DTreeMap.Internal.Impl.inner size k' v' l' r').Balanced) →
(hlr :
Std.DTreeMap.Internal.Impl.BalancedAtRoot l.size
(Std.DTreeMap.Internal.Impl.inner size k' v' l' r').size) →
motive (Std.DTreeMap.Internal.Impl.inner size k' v' l' r') hr hlr) →
motive r hr hlr |
Aesop.UnorderedArraySet.partition | Aesop.Util.UnorderedArraySet | {α : Type u_1} →
[inst : BEq α] → (α → Bool) → Aesop.UnorderedArraySet α → Aesop.UnorderedArraySet α × Aesop.UnorderedArraySet α |
CategoryTheory.Limits.Trident.ofι._proof_1 | Mathlib.CategoryTheory.Limits.Shapes.WideEqualizers | ∀ {J : Type u_3} {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] {X Y : C} {f : J → (X ⟶ Y)}
[inst_1 : Nonempty J] {P : C} (ι : P ⟶ X),
(∀ (j₁ j₂ : J), CategoryTheory.CategoryStruct.comp ι (f j₁) = CategoryTheory.CategoryStruct.comp ι (f j₂)) →
∀ (i j : CategoryTheory.Limits.WalkingParallelFamily J) (f_1 : i ⟶ j),
CategoryTheory.CategoryStruct.comp
(((CategoryTheory.Functor.const (CategoryTheory.Limits.WalkingParallelFamily J)).obj P).map f_1)
(CategoryTheory.Limits.WalkingParallelFamily.casesOn j ι
(CategoryTheory.CategoryStruct.comp ι (f (Classical.arbitrary J)))) =
CategoryTheory.CategoryStruct.comp
(CategoryTheory.Limits.WalkingParallelFamily.casesOn i ι
(CategoryTheory.CategoryStruct.comp ι (f (Classical.arbitrary J))))
((CategoryTheory.Limits.parallelFamily f).map f_1) |
analyticOrderAt_mul_eq_top_of_right | Mathlib.Analysis.Analytic.Order | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {f g : 𝕜 → 𝕜} {z₀ : 𝕜},
analyticOrderAt g z₀ = ⊤ → analyticOrderAt (f * g) z₀ = ⊤ |
_private.Lean.Elab.Quotation.0.Lean.Elab.Term.Quotation.getSepFromSplice._sparseCasesOn_1 | Lean.Elab.Quotation | {motive_1 : Lean.Syntax → Sort u} →
(t : Lean.Syntax) →
((info : Lean.SourceInfo) → (val : String) → motive_1 (Lean.Syntax.atom info val)) →
(Nat.hasNotBit 4 t.ctorIdx → motive_1 t) → motive_1 t |
Lean.Lsp.CompletionParams._sizeOf_inst | Lean.Data.Lsp.LanguageFeatures | SizeOf Lean.Lsp.CompletionParams |
_private.Mathlib.MeasureTheory.PiSystem.0.piiUnionInter_singleton._simp_1_6 | Mathlib.MeasureTheory.PiSystem | ∀ {α : Type u_1} {a b : α}, (b ∈ {a}) = (b = a) |
Finite.ciInf_inf | Mathlib.Data.Fintype.Order | ∀ {α : Type u_1} {ι : Type u_2} [Finite ι] [inst : ConditionallyCompleteLattice α] [Nonempty ι] {f : ι → α} {a : α},
(⨅ i, f i) ⊓ a = ⨅ i, f i ⊓ a |
CliffordAlgebra.ofBaseChange_tmul_one | Mathlib.LinearAlgebra.CliffordAlgebra.BaseChange | ∀ {R : Type u_1} (A : Type u_2) {V : Type u_3} [inst : CommRing R] [inst_1 : CommRing A] [inst_2 : AddCommGroup V]
[inst_3 : Algebra R A] [inst_4 : Module R V] [inst_5 : Invertible 2] (Q : QuadraticForm R V) (z : A),
(CliffordAlgebra.ofBaseChange A Q) (z ⊗ₜ[R] 1) = (algebraMap A (CliffordAlgebra (QuadraticForm.baseChange A Q))) z |
WithVal | Mathlib.Topology.Algebra.Valued.WithVal | {R : Type u_1} →
{Γ₀ : Type u_2} → [inst : LinearOrderedCommGroupWithZero Γ₀] → [inst_1 : Ring R] → Valuation R Γ₀ → Type u_1 |
Int.add_shiftLeft | Init.Data.Int.Bitwise.Lemmas | ∀ (a b : ℤ) (n : ℕ), (a + b) <<< n = a <<< n + b <<< n |
_private.Mathlib.Order.InitialSeg.0.collapseF | Mathlib.Order.InitialSeg | {α : Type u_1} →
{β : Type u_2} →
{r : α → α → Prop} → {s : β → β → Prop} → [IsWellOrder β s] → (f : r ↪r s) → (a : α) → { b // ¬s (f a) b } |
_private.Mathlib.MeasureTheory.Constructions.SimpleGraph.0.SimpleGraph.measurable_edgeSet._simp_1_1 | Mathlib.MeasureTheory.Constructions.SimpleGraph | ∀ {V : Type u} (G : SimpleGraph V) {v w : V}, (s(v, w) ∈ G.edgeSet) = G.Adj v w |
TrivSqZeroExt.commRing._proof_8 | Mathlib.Algebra.TrivSqZeroExt.Basic | ∀ {R : Type u_1} {M : Type u_2} [inst : CommRing R] [inst_1 : AddCommGroup M] [inst_2 : Module R M]
[inst_3 : Module Rᵐᵒᵖ M] (a : TrivSqZeroExt R M), a * 1 = a |
_private.Lean.Meta.Tactic.Grind.AC.Eq.0.Lean.Grind.AC.Seq.findSimpAC?.match_4 | Lean.Meta.Tactic.Grind.AC.Eq | (motive : Option (Option (Lean.Meta.Grind.AC.EqCnstr × Lean.Grind.AC.SubsetResult)) → Sort u_1) →
(x : Option (Option (Lean.Meta.Grind.AC.EqCnstr × Lean.Grind.AC.SubsetResult))) →
(Unit → motive none) →
((a : Option (Lean.Meta.Grind.AC.EqCnstr × Lean.Grind.AC.SubsetResult)) → motive (some a)) → motive x |
_private.Mathlib.Analysis.Meromorphic.FactorizedRational.0.MeromorphicOn.extract_zeros_poles_log._simp_1_3 | Mathlib.Analysis.Meromorphic.FactorizedRational | ∀ {M₀ : Type u_1} [inst : MulZeroClass M₀] [NoZeroDivisors M₀] {a b : M₀}, (a * b = 0) = (a = 0 ∨ b = 0) |
Quiver.FreeGroupoid.quotInv | Mathlib.CategoryTheory.Groupoid.FreeGroupoid | {V : Type u} → [inst : Quiver V] → {X Y : Quiver.FreeGroupoid V} → (X ⟶ Y) → (Y ⟶ X) |
_private.Mathlib.RingTheory.Spectrum.Prime.FreeLocus.0.Module.rankAtStalk_eq_zero_iff_subsingleton._simp_1_1 | Mathlib.RingTheory.Spectrum.Prime.FreeLocus | ∀ {α : Type u} {s : Set α}, (s = ∅) = ∀ (x : α), x ∉ s |
List.getElem_pmap | Init.Data.List.Attach | ∀ {α : Type u_1} {β : Type u_2} {p : α → Prop} (f : (a : α) → p a → β) {l : List α} (h : ∀ a ∈ l, p a) {i : ℕ}
(hn : i < (List.pmap f l h).length), (List.pmap f l h)[i] = f l[i] ⋯ |
_private.Std.Data.DTreeMap.Internal.Zipper.0.Std.DTreeMap.Internal.Impl.pruneLE.match_1.eq_1 | Std.Data.DTreeMap.Internal.Zipper | ∀ (motive : Ordering → Sort u_1) (h_1 : Unit → motive Ordering.lt) (h_2 : Unit → motive Ordering.eq)
(h_3 : Unit → motive Ordering.gt),
(match Ordering.lt with
| Ordering.lt => h_1 ()
| Ordering.eq => h_2 ()
| Ordering.gt => h_3 ()) =
h_1 () |
CategoryTheory.Limits.Fork.IsLimit.homIso._proof_4 | Mathlib.CategoryTheory.Limits.Shapes.Equalizers | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] {X Y : C} {f g : X ⟶ Y}
{t : CategoryTheory.Limits.Fork f g} (ht : CategoryTheory.Limits.IsLimit t) (Z : C) (x : Z ⟶ t.pt),
↑(CategoryTheory.Limits.Fork.IsLimit.lift' ht ↑⟨CategoryTheory.CategoryStruct.comp x t.ι, ⋯⟩ ⋯) = x |
CategoryTheory.Limits.cospanCompIso_inv_app_left | Mathlib.CategoryTheory.Limits.Shapes.Pullback.Cospan | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {D : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
(F : CategoryTheory.Functor C D) {X Y Z : C} (f : X ⟶ Z) (g : Y ⟶ Z),
(CategoryTheory.Limits.cospanCompIso F f g).inv.app CategoryTheory.Limits.WalkingCospan.left =
CategoryTheory.CategoryStruct.id
((CategoryTheory.Limits.cospan (F.map f) (F.map g)).obj CategoryTheory.Limits.WalkingCospan.left) |
EuclideanGeometry.Sphere.ext_iff | Mathlib.Geometry.Euclidean.Sphere.Basic | ∀ {P : Type u_2} {inst : MetricSpace P} {x y : EuclideanGeometry.Sphere P},
x = y ↔ x.center = y.center ∧ x.radius = y.radius |
Fin.image_castSucc_Ioi | Mathlib.Order.Interval.Set.Fin | ∀ {n : ℕ} (i : Fin n), Fin.castSucc '' Set.Ioi i = Set.Ioo i.castSucc (Fin.last n) |
Mathlib.Meta.Positivity.div_nonneg_of_pos_of_nonneg | Mathlib.Algebra.Order.Field.Basic | ∀ {α : Type u_4} [inst : GroupWithZero α] [inst_1 : PartialOrder α] {a b : α} [PosMulReflectLT α],
0 < a → 0 ≤ b → 0 ≤ a / b |
_private.Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.Unital.0.wrapped._proof_1._@.Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.Unital.1784184353._hygCtx._hyg.8 | Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.Unital | @definition✝ = @definition✝ |
CategoryTheory.ComposableArrows.fourδ₁Toδ₀._auto_1 | Mathlib.CategoryTheory.ComposableArrows.Four | Lean.Syntax |
Lean.PrettyPrinter.OneLine.State.mk._flat_ctor | Lean.PrettyPrinter.Formatter | Std.Format → ℕ → List (ℕ × Std.Format) → Lean.PrettyPrinter.OneLine.State |
_private.Mathlib.Algebra.Polynomial.Splits.0.Polynomial.Splits.comp_of_natDegree_le_one_of_invertible._simp_1_1 | Mathlib.Algebra.Polynomial.Splits | ∀ {α : Type u_1} {β : Type v} {f : α → β} {b : β} {s : Multiset α}, (b ∈ Multiset.map f s) = ∃ a ∈ s, f a = b |
lt_sSup_iff | Mathlib.Order.CompleteLattice.Defs | ∀ {α : Type u_1} [inst : CompleteLinearOrder α] {s : Set α} {b : α}, b < sSup s ↔ ∃ a ∈ s, b < a |
Lean.Compiler.LCNF.Simp.CtorInfo.ctor.inj | Lean.Compiler.LCNF.Simp.DiscrM | ∀ {val : Lean.ConstructorVal} {args : Array (Lean.Compiler.LCNF.Arg Lean.Compiler.LCNF.Purity.pure)}
{val_1 : Lean.ConstructorVal} {args_1 : Array (Lean.Compiler.LCNF.Arg Lean.Compiler.LCNF.Purity.pure)},
Lean.Compiler.LCNF.Simp.CtorInfo.ctor val args = Lean.Compiler.LCNF.Simp.CtorInfo.ctor val_1 args_1 →
val = val_1 ∧ args = args_1 |
Std.ExtDTreeMap.getKey_insert_self | Std.Data.ExtDTreeMap.Lemmas | ∀ {α : Type u} {β : α → Type v} {cmp : α → α → Ordering} {t : Std.ExtDTreeMap α β cmp} [inst : Std.TransCmp cmp] {k : α}
{v : β k}, (t.insert k v).getKey k ⋯ = k |
CategoryTheory.Functor.LaxMonoidal.tensorHom_ε_comp_μ_assoc | Mathlib.CategoryTheory.Monoidal.Functor | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] [inst_1 : CategoryTheory.MonoidalCategory C] {D : Type u₂}
[inst_2 : CategoryTheory.Category.{v₂, u₂} D] [inst_3 : CategoryTheory.MonoidalCategory D]
(F : CategoryTheory.Functor C D) [inst_4 : F.LaxMonoidal] {X : C} {Y : D} (f : Y ⟶ F.obj X) {Z : D}
(h :
F.obj (CategoryTheory.MonoidalCategoryStruct.tensorObj X (CategoryTheory.MonoidalCategoryStruct.tensorUnit C)) ⟶ Z),
CategoryTheory.CategoryStruct.comp
(CategoryTheory.MonoidalCategoryStruct.tensorHom f (CategoryTheory.Functor.LaxMonoidal.ε F))
(CategoryTheory.CategoryStruct.comp
(CategoryTheory.Functor.LaxMonoidal.μ F X (CategoryTheory.MonoidalCategoryStruct.tensorUnit C)) h) =
CategoryTheory.CategoryStruct.comp
(CategoryTheory.MonoidalCategoryStruct.whiskerRight f (CategoryTheory.MonoidalCategoryStruct.tensorUnit D))
(CategoryTheory.CategoryStruct.comp (CategoryTheory.MonoidalCategoryStruct.rightUnitor (F.obj X)).hom
(CategoryTheory.CategoryStruct.comp (F.map (CategoryTheory.MonoidalCategoryStruct.rightUnitor X).inv) h)) |
CategoryTheory.Lax.OplaxTrans.vCompNaturality | Mathlib.CategoryTheory.Bicategory.NaturalTransformation.Lax | {B : Type u₁} →
[inst : CategoryTheory.Bicategory B] →
{C : Type u₂} →
[inst_1 : CategoryTheory.Bicategory C] →
{F G H : CategoryTheory.LaxFunctor B C} →
(η : CategoryTheory.Lax.OplaxTrans F G) →
(θ : CategoryTheory.Lax.OplaxTrans G H) →
{a b : B} →
(f : a ⟶ b) →
CategoryTheory.CategoryStruct.comp (F.map f)
(CategoryTheory.CategoryStruct.comp (η.app b) (θ.app b)) ⟶
CategoryTheory.CategoryStruct.comp (CategoryTheory.CategoryStruct.comp (η.app a) (θ.app a))
(H.map f) |
Ordering.isEq | Init.Data.Ord.Basic | Ordering → Bool |
List.Vector.set._proof_1 | Mathlib.Data.Vector.Basic | ∀ {α : Type u_1} {n : ℕ} (v : List.Vector α n) (i : Fin n) (a : α), ((↑v).set (↑i) a).length = n |
_private.Mathlib.Combinatorics.SimpleGraph.Subgraph.0.SimpleGraph.Subgraph.map_mono._simp_1_1 | Mathlib.Combinatorics.SimpleGraph.Subgraph | ∀ {α : Type u} {β : Type v} (f : α → β) (s : Set α) (y : β), (y ∈ f '' s) = ∃ x ∈ s, f x = y |
List.ofFn_congr | Mathlib.Data.List.OfFn | ∀ {α : Type u} {m n : ℕ} (h : m = n) (f : Fin m → α), List.ofFn f = List.ofFn fun i => f (Fin.cast ⋯ i) |
Std.DTreeMap.Raw.self_le_maxKey?_insert | Std.Data.DTreeMap.Raw.Lemmas | ∀ {α : Type u} {β : α → Type v} {cmp : α → α → Ordering} {t : Std.DTreeMap.Raw α β cmp} [inst : Std.TransCmp cmp]
(h : t.WF) {k : α} {v : β k} {kmi : α}, (t.insert k v).maxKey?.get ⋯ = kmi → (cmp k kmi).isLE = true |
CategoryTheory.Limits.Cones.extendComp_inv_hom | Mathlib.CategoryTheory.Limits.Cones | ∀ {J : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} J] {C : Type u₃} [inst_1 : CategoryTheory.Category.{v₃, u₃} C]
{F : CategoryTheory.Functor J C} (s : CategoryTheory.Limits.Cone F) {X Y : C} (f : X ⟶ Y) (g : Y ⟶ s.pt),
(CategoryTheory.Limits.Cones.extendComp s f g).inv.hom = CategoryTheory.CategoryStruct.id X |
_private.Mathlib.Probability.Martingale.Upcrossing.0.MeasureTheory.upcrossingStrat_le_one._simp_1_2 | Mathlib.Probability.Martingale.Upcrossing | ∀ {α : Type v} [inst : LinearOrder α] {a₁ a₂ b₁ b₂ : α},
Disjoint (Set.Ico a₁ a₂) (Set.Ico b₁ b₂) = (min a₂ b₂ ≤ max a₁ b₁) |
AlgHom.toEnd._proof_1 | Mathlib.Algebra.Algebra.Hom | ∀ {R : Type u_2} {A : Type u_1} [inst : CommSemiring R] [inst_1 : Semiring A] [inst_2 : Algebra R A],
AlgHom.toLinearMap 1 = AlgHom.toLinearMap 1 |
Lean.NameHashSet.insert | Lean.Data.NameMap.Basic | Lean.NameHashSet → Lean.Name → Std.HashSet Lean.Name |
CategoryTheory.PreOneHypercover.congrIndexOneOfEqIso_inv_p₁ | Mathlib.CategoryTheory.Sites.Hypercover.One | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {S : C} {E : CategoryTheory.PreOneHypercover S}
{i i' j j' : E.I₀} (hii' : i = i') (hjj' : j = j') (k : E.I₁ i j),
CategoryTheory.CategoryStruct.comp (CategoryTheory.PreOneHypercover.congrIndexOneOfEqIso hii' hjj' k).inv
(E.p₁ ((CategoryTheory.PreOneHypercover.congrIndexOneOfEq hii' hjj') k)) =
CategoryTheory.CategoryStruct.comp (E.p₁ k) (CategoryTheory.eqToHom ⋯) |
BooleanSubalgebra | Mathlib.Order.BooleanSubalgebra | (α : Type u_2) → [BooleanAlgebra α] → Type u_2 |
LocallyConstant.instNonUnitalCommSemiring | Mathlib.Topology.LocallyConstant.Algebra | {X : Type u_1} →
{Y : Type u_2} → [inst : TopologicalSpace X] → [NonUnitalCommSemiring Y] → NonUnitalCommSemiring (LocallyConstant X Y) |
_private.Mathlib.Tactic.Linter.Whitespace.0.Mathlib.Linter.FormatError.mk._flat_ctor | Mathlib.Tactic.Linter.Whitespace | ℕ → String.Pos.Raw → ℕ → String → ℕ → String.Pos.Raw → Mathlib.Linter.FormatError✝ |
Lean.Meta.Monotonicity.defaultFailK | Lean.Elab.Tactic.Monotonicity | {α : Type} → Lean.Expr → Array Lean.Name → Lean.MetaM α |
MeasurableSpace.sUnion_countablePartition | Mathlib.MeasureTheory.MeasurableSpace.CountablyGenerated | ∀ (α : Type u_3) [inst : MeasurableSpace α] [inst_1 : MeasurableSpace.CountablyGenerated α] (n : ℕ),
⋃₀ MeasurableSpace.countablePartition α n = Set.univ |
Delone.DeloneSet.mapIsometry_symm_apply_packingRadius | Mathlib.Analysis.AperiodicOrder.Delone.Basic | ∀ {X : Type u_1} {Y : Type u_2} [inst : MetricSpace X] [inst_1 : MetricSpace Y] (f : X ≃ᵢ Y) (D : Delone.DeloneSet Y),
((Delone.DeloneSet.mapIsometry f).symm D).packingRadius = D.packingRadius |
ChartedSpaceCore.noConfusionType | Mathlib.Geometry.Manifold.ChartedSpace | Sort u →
{H : Type u_5} →
[inst : TopologicalSpace H] →
{M : Type u_6} →
ChartedSpaceCore H M →
{H' : Type u_5} → [inst' : TopologicalSpace H'] → {M' : Type u_6} → ChartedSpaceCore H' M' → Sort u |
Submodule.lTensorOne'.eq_1 | Mathlib.LinearAlgebra.TensorProduct.Submodule | ∀ {R : Type u} {S : Type v} [inst : CommSemiring R] [inst_1 : Semiring S] [inst_2 : Algebra R S] (N : Submodule R S),
N.lTensorOne' =
↑(LinearEquiv.ofEq ((Subalgebra.toSubmodule ⊥).mulMap N).range N ⋯) ∘ₗ
((Subalgebra.toSubmodule ⊥).mulMap N).rangeRestrict |
_private.Mathlib.NumberTheory.JacobiSum.Basic.0.jacobiSum_nontrivial_inv._simp_1_11 | Mathlib.NumberTheory.JacobiSum.Basic | ∀ {R : Type u_1} [inst : AddMonoidWithOne R] [CharZero R] (n : ℕ), (↑n + 1 = 0) = False |
HomotopicalAlgebra.CofibrantObject.HoCat.bifibrantResolution'._proof_1 | Mathlib.AlgebraicTopology.ModelCategory.BifibrantObjectHomotopy | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : HomotopicalAlgebra.ModelCategory C]
(X : HomotopicalAlgebra.CofibrantObject C),
CategoryTheory.CategoryStruct.comp (HomotopicalAlgebra.CofibrantObject.toHoCat.map X.iBifibrantResolutionObj)
(HomotopicalAlgebra.BifibrantObject.HoCat.ιCofibrantObject.map
(HomotopicalAlgebra.BifibrantObject.toHoCat.map
(HomotopicalAlgebra.CofibrantObject.bifibrantResolutionMap (CategoryTheory.CategoryStruct.id X)))) =
CategoryTheory.CategoryStruct.comp (HomotopicalAlgebra.CofibrantObject.toHoCat.map X.iBifibrantResolutionObj)
(HomotopicalAlgebra.BifibrantObject.HoCat.ιCofibrantObject.map
(CategoryTheory.CategoryStruct.id (HomotopicalAlgebra.BifibrantObject.toHoCat.obj X.bifibrantResolutionObj))) |
Lean.StructureFieldInfo.noConfusionType | Lean.Structure | Sort u → Lean.StructureFieldInfo → Lean.StructureFieldInfo → Sort u |
UInt64.mul_assoc | Init.Data.UInt.Lemmas | ∀ (a b c : UInt64), a * b * c = a * (b * c) |
Batteries.Tactic.TransRelation._sizeOf_1 | Batteries.Tactic.Trans | Batteries.Tactic.TransRelation → ℕ |
EuclideanGeometry.Sphere.secondInter_mem._simp_1 | Mathlib.Geometry.Euclidean.Sphere.SecondInter | ∀ {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} (v : V), (s.secondInter p v ∈ s) = (p ∈ s) |
Std.DHashMap.Raw.Const.get!_filter_of_getKey?_eq_some | Std.Data.DHashMap.RawLemmas | ∀ {α : Type u} [inst : BEq α] [inst_1 : Hashable α] {β : Type v} {m : Std.DHashMap.Raw α fun x => β} [EquivBEq α]
[LawfulHashable α] [inst_4 : Inhabited β] {f : α → β → Bool} {k k' : α},
m.WF →
m.getKey? k = some k' →
Std.DHashMap.Raw.Const.get! (Std.DHashMap.Raw.filter f m) k =
(Option.filter (fun x => f k' x) (Std.DHashMap.Raw.Const.get? m k)).get! |
_private.Lean.Meta.InferType.0.Lean.Meta.isArrowProposition'.match_1 | Lean.Meta.InferType | (motive : Lean.Expr → ℕ → Sort u_1) →
(x : Lean.Expr) →
(x_1 : ℕ) →
((binderName : Lean.Name) →
(t b : Lean.Expr) →
(binderInfo : Lean.BinderInfo) → (n : ℕ) → motive (Lean.Expr.forallE binderName t b binderInfo) n.succ) →
((declName : Lean.Name) →
(t value b : Lean.Expr) → (nondep : Bool) → (n : ℕ) → motive (Lean.Expr.letE declName t value b nondep) n) →
((data : Lean.MData) → (e : Lean.Expr) → (n : ℕ) → motive (Lean.Expr.mdata data e) n) →
((idx : ℕ) → motive (Lean.Expr.bvar idx) 0) →
((type : Lean.Expr) → motive type 0) → ((x : Lean.Expr) → (x_2 : ℕ) → motive x x_2) → motive x x_1 |
PowerBasis.mk.injEq | Mathlib.RingTheory.PowerBasis | ∀ {R : Type u_7} {S : Type u_8} [inst : CommRing R] [inst_1 : Ring S] [inst_2 : Algebra R S] (gen : S) (dim : ℕ)
(basis : Module.Basis (Fin dim) R S) (basis_eq_pow : ∀ (i : Fin dim), basis i = gen ^ ↑i) (gen_1 : S) (dim_1 : ℕ)
(basis_1 : Module.Basis (Fin dim_1) R S) (basis_eq_pow_1 : ∀ (i : Fin dim_1), basis_1 i = gen_1 ^ ↑i),
({ gen := gen, dim := dim, basis := basis, basis_eq_pow := basis_eq_pow } =
{ gen := gen_1, dim := dim_1, basis := basis_1, basis_eq_pow := basis_eq_pow_1 }) =
(gen = gen_1 ∧ dim = dim_1 ∧ basis ≍ basis_1) |
PadicAlgCl.isUltrametricDist | Mathlib.NumberTheory.Padics.Complex | ∀ (p : ℕ) [hp : Fact (Nat.Prime p)], IsUltrametricDist (PadicAlgCl p) |
_private.Mathlib.ModelTheory.Basic.0.FirstOrder.Language.isEmpty_empty._simp_1 | Mathlib.ModelTheory.Basic | ∀ {α : Type u_4} {β : Type u_5}, IsEmpty (α ⊕ β) = (IsEmpty α ∧ IsEmpty β) |
_private.Mathlib.ModelTheory.Complexity.0.FirstOrder.Language.BoundedFormula.realize_toPrenexImp._simp_1_2 | Mathlib.ModelTheory.Complexity | ∀ {L : FirstOrder.Language} {M : Type w} [inst : L.Structure M] {α : Type u'} {l : ℕ} {φ ψ : L.BoundedFormula α l}
{v : α → M} {xs : Fin l → M}, (φ.imp ψ).Realize v xs = (φ.Realize v xs → ψ.Realize v xs) |
sdiff_sdiff_le | Mathlib.Order.Heyting.Basic | ∀ {α : Type u_2} [inst : GeneralizedCoheytingAlgebra α] {a b : α}, a \ (a \ b) ≤ b |
_private.Mathlib.CategoryTheory.ComposableArrows.Basic.0._auto_385 | Mathlib.CategoryTheory.ComposableArrows.Basic | Lean.Syntax |
Lean.PrettyPrinter.Formatter.categoryFormatter | Lean.PrettyPrinter.Formatter | Lean.Name → Lean.PrettyPrinter.Formatter |
CategoryTheory.ComposableArrows.Exact.cokerIsoKer_hom_fac | Mathlib.Algebra.Homology.ExactSequenceFour | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{u_2, u_1} C] [inst_1 : CategoryTheory.Preadditive C]
[inst_2 : CategoryTheory.Balanced C] {n : ℕ} {S : CategoryTheory.ComposableArrows C (n + 3)} (hS : S.Exact) (k : ℕ)
(hk : autoParam (k ≤ n) CategoryTheory.ComposableArrows.Exact.cokerIsoKer_hom_fac._auto_1)
[inst_3 : CategoryTheory.Limits.HasCokernel (S.map' k (k + 1) ⋯ ⋯)]
[inst_4 : CategoryTheory.Limits.HasKernel (S.map' (k + 2) (k + 3) ⋯ ⋯)],
CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.cokernel.π (S.map' k (k + 1) ⋯ ⋯))
(CategoryTheory.CategoryStruct.comp (hS.cokerIsoKer k ⋯).hom
(CategoryTheory.Limits.kernel.ι (S.map' (k + 2) (k + 3) ⋯ ⋯))) =
S.map' (k + 1) (k + 2) ⋯ ⋯ |
_private.Init.Data.Array.Basic.0.Array.takeWhile.go._unary._proof_1 | Init.Data.Array.Basic | ∀ {α : Type u_1} (as : Array α) (i : ℕ) (acc : Array α) (h : i < as.size),
InvImage (fun x1 x2 => x1 < x2) (fun x => PSigma.casesOn x fun i acc => as.size - i) ⟨i + 1, acc.push as[i]⟩ ⟨i, acc⟩ |
CategoryTheory.Abelian.SpectralObject.coreE₂CohomologicalFin._proof_24 | Mathlib.Algebra.Homology.SpectralObject.HasSpectralSequence | ∀ (l : ℕ) (r r' : ℤ) (pq pq' : ℤ × Fin l),
(ComplexShape.spectralSequenceFin l (r, 1 - r)).Rel pq pq' →
∀ (hrr' : autoParam (r + 1 = r') CategoryTheory.Abelian.SpectralObject.SpectralSequenceDataCore._auto_41)
(hr : autoParam (2 ≤ r) CategoryTheory.Abelian.SpectralObject.SpectralSequenceDataCore._auto_43),
⟨(↑↑pq.2 - (r' - 2)).toNat, ⋯⟩ = pq'.2.castSucc |
Std.Time.Modifier.F | Std.Time.Format.Basic | Std.Time.Number → Std.Time.Modifier |
StateRefT'.run | Init.Control.StateRef | {ω σ : Type} → {m : Type → Type} → [Monad m] → [MonadLiftT (ST ω) m] → {α : Type} → StateRefT' ω σ m α → σ → m (α × σ) |
IsDedekindDomain.HeightOneSpectrum.adicCompletionIntegers | Mathlib.RingTheory.DedekindDomain.AdicValuation | {R : Type u_1} →
[inst : CommRing R] →
[inst_1 : IsDedekindDomain R] →
(K : Type u_2) →
[inst_2 : Field K] →
[inst_3 : Algebra R K] →
[inst_4 : IsFractionRing R K] →
(v : IsDedekindDomain.HeightOneSpectrum R) →
ValuationSubring (IsDedekindDomain.HeightOneSpectrum.adicCompletion K v) |
LinearOrderedAddCommGroup.negGen_eq_of_top | Mathlib.Algebra.Order.Group.Cyclic | ∀ (G : Type u_1) [inst : AddCommGroup G] [inst_1 : LinearOrder G] [inst_2 : IsOrderedAddMonoid G]
[inst_3 : Nontrivial G] [inst_4 : IsAddCyclic G],
LinearOrderedAddCommGroup.negGen G = LinearOrderedAddCommGroup.Subgroup.negGen ⊤ |
IsCompl.sup_eq_top | Mathlib.Order.Disjoint | ∀ {α : Type u_1} [inst : Lattice α] [inst_1 : BoundedOrder α] {x y : α}, IsCompl x y → x ⊔ y = ⊤ |
ENNReal.one_le_coe_iff._simp_1 | Mathlib.Data.ENNReal.Basic | ∀ {r : NNReal}, (1 ≤ ↑r) = (1 ≤ r) |
MeasureTheory.crossing_eq_crossing_of_lowerCrossingTime_lt | Mathlib.Probability.Martingale.Upcrossing | ∀ {Ω : Type u_1} {a b : ℝ} {f : ℕ → Ω → ℝ} {N n : ℕ} {ω : Ω} {M : ℕ},
N ≤ M →
MeasureTheory.lowerCrossingTime a b f N n ω < N →
MeasureTheory.upperCrossingTime a b f M n ω = MeasureTheory.upperCrossingTime a b f N n ω ∧
MeasureTheory.lowerCrossingTime a b f M n ω = MeasureTheory.lowerCrossingTime a b f N n ω |
Std.Time.instHSubOffsetOffset_41 | Std.Time.Date.Basic | HSub Std.Time.Week.Offset Std.Time.Day.Offset Std.Time.Day.Offset |
CategoryTheory.Localization.Construction.WhiskeringLeftEquivalence.inverse._proof_6 | Mathlib.CategoryTheory.Localization.Construction | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] (W : CategoryTheory.MorphismProperty C) (D : Type u_4)
[inst_1 : CategoryTheory.Category.{u_3, u_4} D] (G : W.FunctorsInverting D),
CategoryTheory.Localization.Construction.natTransExtension
(CategoryTheory.CategoryStruct.comp (CategoryTheory.eqToHom ⋯)
(CategoryTheory.CategoryStruct.comp (CategoryTheory.CategoryStruct.id G).hom (CategoryTheory.eqToHom ⋯))) =
CategoryTheory.CategoryStruct.id (CategoryTheory.Localization.Construction.lift G.obj ⋯) |
Filter.HasBasis.forall_iff | Mathlib.Order.Filter.Bases.Basic | ∀ {α : Type u_1} {ι : Sort u_4} {l : Filter α} {p : ι → Prop} {s : ι → Set α},
l.HasBasis p s →
∀ {P : Set α → Prop}, (∀ ⦃s t : Set α⦄, s ⊆ t → P s → P t) → ((∀ s ∈ l, P s) ↔ ∀ (i : ι), p i → P (s i)) |
String.Pos.noConfusionType | Init.Data.String.Defs | Sort u → {s : String} → s.Pos → {s' : String} → s'.Pos → Sort u |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.