name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M |
|---|---|---|
Batteries.RBNode.Path.zoom_fill | Batteries.Data.RBMap.Alter | ∀ {α : Type u_1} {cut : α → Ordering} {t : Batteries.RBNode α} {path : Batteries.RBNode.Path α}
{t' : Batteries.RBNode α} {path' : Batteries.RBNode.Path α},
Batteries.RBNode.zoom cut t path = (t', path') → path.fill t = path'.fill t' |
CategoryTheory.Presieve.functorPushforward | Mathlib.CategoryTheory.Sites.Sieves | {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 : C} → CategoryTheory.Presieve X → CategoryTheory.Presieve (F.obj X) |
SimplexCategory.Truncated.Hom.tr_id | Mathlib.AlgebraicTopology.SimplexCategory.Defs | ∀ {n : ℕ} (a : SimplexCategory) (ha : autoParam (a.len ≤ n) SimplexCategory.Truncated.Hom.tr_id._auto_1),
SimplexCategory.Truncated.Hom.tr (CategoryTheory.CategoryStruct.id a) ha ha =
CategoryTheory.CategoryStruct.id { obj := a, property := ha } |
ProbabilityTheory.Kernel.densityProcess_empty | Mathlib.Probability.Kernel.Disintegration.Density | ∀ {α : Type u_1} {β : Type u_2} {γ : Type u_3} {mα : MeasurableSpace α} {mβ : MeasurableSpace β}
{mγ : MeasurableSpace γ} [inst : MeasurableSpace.CountablyGenerated γ] (κ : ProbabilityTheory.Kernel α (γ × β))
(ν : ProbabilityTheory.Kernel α γ) (n : ℕ) (a : α) (x : γ), κ.densityProcess ν n a x ∅ = 0 |
Lean.Elab.FVarAliasInfo.mk | Lean.Elab.InfoTree.Types | Lean.Name → Lean.FVarId → Lean.FVarId → Lean.Elab.FVarAliasInfo |
Monotone.seq_pos_lt_seq_of_le_of_lt | Mathlib.Order.Iterate | ∀ {α : Type u_1} [inst : Preorder α] {f : α → α} {x y : ℕ → α},
Monotone f →
∀ {n : ℕ}, 0 < n → x 0 ≤ y 0 → (∀ k < n, x (k + 1) ≤ f (x k)) → (∀ k < n, f (y k) < y (k + 1)) → x n < y n |
_private.Init.Data.Int.DivMod.Lemmas.0.Int.fmod_sub_cancel_left._simp_1_2 | Init.Data.Int.DivMod.Lemmas | ∀ {a b : ℤ}, (b.fmod a = 0) = (a ∣ b) |
Mathlib.Tactic.BicategoryLike.Mor₂.whiskerLeft.inj | Mathlib.Tactic.CategoryTheory.Coherence.Datatypes | ∀ {e : Lean.Expr} {isoLift? : Option Mathlib.Tactic.BicategoryLike.IsoLift} {f g h : Mathlib.Tactic.BicategoryLike.Mor₁}
{η : Mathlib.Tactic.BicategoryLike.Mor₂} {e_1 : Lean.Expr} {isoLift?_1 : Option Mathlib.Tactic.BicategoryLike.IsoLift}
{f_1 g_1 h_1 : Mathlib.Tactic.BicategoryLike.Mor₁} {η_1 : Mathlib.Tactic.BicategoryLike.Mor₂},
Mathlib.Tactic.BicategoryLike.Mor₂.whiskerLeft e isoLift? f g h η =
Mathlib.Tactic.BicategoryLike.Mor₂.whiskerLeft e_1 isoLift?_1 f_1 g_1 h_1 η_1 →
e = e_1 ∧ isoLift? = isoLift?_1 ∧ f = f_1 ∧ g = g_1 ∧ h = h_1 ∧ η = η_1 |
Std.DHashMap.Internal.Raw₀.filterₘ | Std.Data.DHashMap.Internal.Model | {α : Type u} →
{β : α → Type v} → Std.DHashMap.Internal.Raw₀ α β → ((a : α) → β a → Bool) → Std.DHashMap.Internal.Raw₀ α β |
Lean.Elab.Tactic.TacticParsedSnapshot.toSnapshot | Lean.Elab.Term.TermElabM | Lean.Elab.Tactic.TacticParsedSnapshot → Lean.Language.Snapshot |
Lean.Lsp.InlayHintKind.casesOn | Lean.Data.Lsp.LanguageFeatures | {motive : Lean.Lsp.InlayHintKind → Sort u} →
(t : Lean.Lsp.InlayHintKind) → motive Lean.Lsp.InlayHintKind.type → motive Lean.Lsp.InlayHintKind.parameter → motive t |
Aesop.LocalRuleSet.forwardRulePatternSubstsInLocalDecl | Aesop.RuleSet | Aesop.LocalRuleSet → Lean.LocalDecl → Aesop.BaseM (Array (Aesop.ForwardRule × Aesop.Substitution)) |
RingHom.coe_inj | Mathlib.Algebra.Ring.Hom.Defs | ∀ {α : Type u_2} {β : Type u_3} {x : NonAssocSemiring α} {x_1 : NonAssocSemiring β} ⦃f g : α →+* β⦄, ⇑f = ⇑g → f = g |
_private.Lean.Meta.Tactic.Simp.BuiltinSimprocs.BitVec.0._regBuiltin.BitVec.reduceBitVecOfFin.declare_333._@.Lean.Meta.Tactic.Simp.BuiltinSimprocs.BitVec.4171913895._hygCtx._hyg.13 | Lean.Meta.Tactic.Simp.BuiltinSimprocs.BitVec | IO Unit |
OmegaCompletePartialOrder.Chain.ext | Mathlib.Order.OmegaCompletePartialOrder | ∀ {α : Type u_2} [inst : Preorder α] ⦃f g : OmegaCompletePartialOrder.Chain α⦄, ⇑f = ⇑g → f = g |
onePointEquivSphereOfFinrankEq._proof_5 | Mathlib.Topology.Compactification.OnePoint.Sphere | ∀ {ι : Type u_1} {V : Type u_2} [inst : Fintype ι] [inst_1 : AddCommGroup V] [inst_2 : Module ℝ V],
Module.finrank ℝ V + 1 = Fintype.card ι → Nonempty ι |
Int.strongRec.eq_1 | Mathlib.Data.Int.Basic | ∀ {m : ℤ} {motive : ℤ → Sort u_1} (lt : (n : ℤ) → n < m → motive n)
(ge : (n : ℤ) → n ≥ m → ((k : ℤ) → k < n → motive k) → motive n) (n : ℤ),
Int.strongRec lt ge n =
if hnm : n < m then lt n hnm
else
ge n ⋯
(Int.inductionOn' (motive := fun x => (k : ℤ) → k < x → motive k) n m lt
(fun _n a ih l a_1 => if hlm : l < m then lt l hlm else ge l ⋯ fun k x => ih k ⋯) fun n x hn l x_1 => hn l ⋯) |
CovBy | Mathlib.Order.Defs.PartialOrder | {α : Type u_2} → [LT α] → α → α → Prop |
CategoryTheory.PreOneHypercover.cylinderHomotopy._proof_2 | Mathlib.CategoryTheory.Sites.Hypercover.Homotopy | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] {S : C} {E : CategoryTheory.PreOneHypercover S}
{F : CategoryTheory.PreOneHypercover S} [inst_1 : CategoryTheory.Limits.HasPullbacks C] (f g : E.Hom F)
(p : (CategoryTheory.PreOneHypercover.cylinder f g).I₀),
CategoryTheory.CategoryStruct.comp
(CategoryTheory.Limits.pullback.snd (CategoryTheory.Limits.pullback.lift (f.h₀ p.fst) (g.h₀ p.fst) ⋯)
(F.toPullback p.snd))
(F.p₂ p.snd) =
((CategoryTheory.PreOneHypercover.cylinderHom f g).comp g).h₀ p |
CategoryTheory.Limits.CategoricalPullback.CatCommSqOver.precompose._proof_6 | Mathlib.CategoryTheory.Limits.Shapes.Pullback.Categorical.Basic | ∀ {A : Type u_6} {B : Type u_3} {C : Type u_8} [inst : CategoryTheory.Category.{u_5, u_6} A]
[inst_1 : CategoryTheory.Category.{u_2, u_3} B] [inst_2 : CategoryTheory.Category.{u_7, u_8} C]
(F : CategoryTheory.Functor A B) (G : CategoryTheory.Functor C B) {X : Type u_1} {Y : Type u_9}
[inst_3 : CategoryTheory.Category.{u_4, u_1} X] [inst_4 : CategoryTheory.Category.{u_10, u_9} Y]
{U V : CategoryTheory.Functor X Y} (α : U ⟶ V) (x : CategoryTheory.Limits.CategoricalPullback.CatCommSqOver F G Y),
CategoryTheory.CategoryStruct.comp
(CategoryTheory.Functor.whiskerRight (CategoryTheory.Functor.whiskerRight α x.fst) F)
({
obj := fun S =>
{ fst := V.comp S.fst, snd := V.comp S.snd,
iso := V.associator S.fst F ≪≫ V.isoWhiskerLeft S.iso ≪≫ (V.associator S.snd G).symm },
map := fun {S S'} φ => { fst := V.whiskerLeft φ.fst, snd := V.whiskerLeft φ.snd, w := ⋯ }, map_id := ⋯,
map_comp := ⋯ }.obj
x).iso.hom =
CategoryTheory.CategoryStruct.comp
({
obj := fun S =>
{ fst := U.comp S.fst, snd := U.comp S.snd,
iso := U.associator S.fst F ≪≫ U.isoWhiskerLeft S.iso ≪≫ (U.associator S.snd G).symm },
map := fun {S S'} φ => { fst := U.whiskerLeft φ.fst, snd := U.whiskerLeft φ.snd, w := ⋯ }, map_id := ⋯,
map_comp := ⋯ }.obj
x).iso.hom
(CategoryTheory.Functor.whiskerRight (CategoryTheory.Functor.whiskerRight α x.snd) G) |
IntermediateField.intermediateFieldMap_apply_coe | Mathlib.FieldTheory.IntermediateField.Basic | ∀ {K : Type u_1} {L : Type u_2} {L' : Type u_3} [inst : Field K] [inst_1 : Field L] [inst_2 : Field L']
[inst_3 : Algebra K L] [inst_4 : Algebra K L'] (e : L ≃ₐ[K] L') (E : IntermediateField K L) (a : ↥E),
↑((IntermediateField.intermediateFieldMap e E) a) = e ↑a |
GradedObject.eulerChar_eq_sum_finSet_of_finrankSupport_subset | Mathlib.Algebra.Homology.EulerCharacteristic | ∀ {R : Type u_1} [inst : Ring R] {ι : Type u_2} (c : ComplexShape ι) [inst_1 : c.EulerCharSigns]
(X : CategoryTheory.GradedObject ι (ModuleCat R)) (indices : Finset ι),
GradedObject.finrankSupport X ⊆ ↑indices →
GradedObject.eulerChar c X = ∑ i ∈ indices, ↑(c.χ i) * ↑(Module.finrank R ↑(X i)) |
Cardinal.powerlt_mono_left | Mathlib.SetTheory.Cardinal.Basic | ∀ (a : Cardinal.{u_1}), Monotone fun c => a ^< c |
Lean.Expr.FindStep.done | Lean.Util.FindExpr | Lean.Expr.FindStep |
midpoint_eq_midpoint_iff_vsub_eq_vsub | Mathlib.LinearAlgebra.AffineSpace.Midpoint | ∀ (R : Type u_1) {V : Type u_2} {P : Type u_4} [inst : Ring R] [inst_1 : Invertible 2] [inst_2 : AddCommGroup V]
[inst_3 : Module R V] [inst_4 : AddTorsor V P] {x x' y y' : P}, midpoint R x y = midpoint R x' y' ↔ x -ᵥ x' = y' -ᵥ y |
CategoryTheory.Limits.MultispanShape.ctorIdx | Mathlib.CategoryTheory.Limits.Shapes.Multiequalizer | CategoryTheory.Limits.MultispanShape → ℕ |
_private.Mathlib.Data.Int.CardIntervalMod.0.Nat.Ico_filter_modEq_cast._simp_1_4 | Mathlib.Data.Int.CardIntervalMod | ∀ {α : Sort u_1} {p : α → Prop} {q : (∃ x, p x) → Prop}, (∀ (h : ∃ x, p x), q h) = ∀ (x : α) (h : p x), q ⋯ |
IsLowerSet.vadd | Mathlib.Algebra.Order.UpperLower | ∀ {α : Type u_1} [inst : AddCommGroup α] [inst_1 : Preorder α] [IsOrderedAddMonoid α] {s : Set α} {a : α},
IsLowerSet s → IsLowerSet (a +ᵥ s) |
PrimeSpectrum.noConfusion | Mathlib.RingTheory.Spectrum.Prime.Defs | {P : Sort u} →
{R : Type u_1} →
{inst : CommSemiring R} →
{t : PrimeSpectrum R} →
{R' : Type u_1} →
{inst' : CommSemiring R'} →
{t' : PrimeSpectrum R'} → R = R' → inst ≍ inst' → t ≍ t' → PrimeSpectrum.noConfusionType P t t' |
CategoryTheory.ObjectProperty.shiftClosure_le_iff | Mathlib.CategoryTheory.ObjectProperty.Shift | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] (P Q : CategoryTheory.ObjectProperty C) {A : Type u_2}
[inst_1 : AddMonoid A] [inst_2 : CategoryTheory.HasShift C A] [Q.IsClosedUnderIsomorphisms] [Q.IsStableUnderShift A],
P.shiftClosure A ≤ Q ↔ P ≤ Q |
_private.Mathlib.Analysis.InnerProductSpace.Positive.0.ContinuousLinearMap.isPositive_iff_eq_sum_rankOne._simp_1_4 | Mathlib.Analysis.InnerProductSpace.Positive | ∀ {K : Type u_1} [inst : RCLike K] (r s : ℝ), ↑r * ↑s = ↑(r * s) |
_private.Lean.Server.ProtocolOverview.0.Lean.Server.Overview.MessageOverview.rpcRequest.elim | Lean.Server.ProtocolOverview | {motive : Lean.Server.Overview.MessageOverview✝ → Sort u} →
(t : Lean.Server.Overview.MessageOverview✝¹) →
Lean.Server.Overview.MessageOverview.ctorIdx✝ t = 1 →
((o : Lean.Server.Overview.RpcRequestOverview✝) → motive (Lean.Server.Overview.MessageOverview.rpcRequest✝ o)) →
motive t |
Std.Tactic.BVDecide.BVExpr.bitblast.blastRotateRight._proof_12 | Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.RotateRight | ∀ {w : ℕ}, 0 ≤ w |
CategoryTheory.Limits.HasCokernels.mk._flat_ctor | Mathlib.CategoryTheory.Limits.Shapes.Kernels | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C],
autoParam (∀ {X Y : C} (f : X ⟶ Y), CategoryTheory.Limits.HasCokernel f)
CategoryTheory.Limits.HasCokernels.has_colimit._autoParam →
CategoryTheory.Limits.HasCokernels C |
_private.Mathlib.NumberTheory.Padics.MahlerBasis.0.PadicInt.mahlerSeries_apply_nat._proof_1_1 | Mathlib.NumberTheory.Padics.MahlerBasis | ∀ {m n : ℕ}, m ≤ n → ∀ (i : ℕ), m < i + (n + 1) |
Lean.Meta.RefinedDiscrTree.Trie.node._flat_ctor | Mathlib.Lean.Meta.RefinedDiscrTree.Basic | {α : Type} →
Array α →
Option Lean.Meta.RefinedDiscrTree.TrieIndex →
Std.HashMap ℕ Lean.Meta.RefinedDiscrTree.TrieIndex →
Std.HashMap Lean.Meta.RefinedDiscrTree.Key Lean.Meta.RefinedDiscrTree.TrieIndex →
Array (Lean.Meta.RefinedDiscrTree.LazyEntry × α) → Lean.Meta.RefinedDiscrTree.Trie α |
Lean.Lsp.WorkspaceSymbolParams.noConfusionType | Lean.Data.Lsp.LanguageFeatures | Sort u → Lean.Lsp.WorkspaceSymbolParams → Lean.Lsp.WorkspaceSymbolParams → Sort u |
NumberField.mixedEmbedding.fundamentalCone.realSpaceToLogSpace._proof_2 | Mathlib.NumberTheory.NumberField.CanonicalEmbedding.NormLeOne | ∀ {K : Type u_1} [inst : Field K] [inst_1 : NumberField K] (x x_1 : NumberField.mixedEmbedding.realSpace K),
(fun w => (x + x_1) ↑w - (↑(↑w).mult * ∑ w', (x + x_1) w') * (↑(Module.finrank ℚ K))⁻¹) =
(fun w => x ↑w - (↑(↑w).mult * ∑ w', x w') * (↑(Module.finrank ℚ K))⁻¹) + fun w =>
x_1 ↑w - (↑(↑w).mult * ∑ w', x_1 w') * (↑(Module.finrank ℚ K))⁻¹ |
Int.lcm_mul_right_right | Init.Data.Int.Gcd | ∀ (a b : ℤ), a.lcm (a * b) = a.natAbs * b.natAbs |
qExpansionRingHom | Mathlib.NumberTheory.ModularForms.QExpansion | {Γ : Subgroup (GL (Fin 2) ℝ)} →
(h : ℝ) →
[inst : Γ.HasDetPlusMinusOne] →
0 < h → h ∈ Γ.strictPeriods → (DirectSum ℤ fun k => ModularForm Γ k) →+* PowerSeries ℂ |
UInt32.lt_add_one | Init.Data.UInt.Lemmas | ∀ {c : UInt32}, c ≠ -1 → c < c + 1 |
PrimeMultiset.prod | Mathlib.Data.PNat.Factors | PrimeMultiset → ℕ+ |
String.Slice.Pattern.ToForwardSearcher.mk | Init.Data.String.Pattern.Basic | {ρ : Type} →
{pat : ρ} →
{σ : outParam (String.Slice → Type)} →
((s : String.Slice) → Std.Iter (String.Slice.Pattern.SearchStep s)) → String.Slice.Pattern.ToForwardSearcher pat σ |
UpperHalfPlane.num._proof_1 | Mathlib.Analysis.Complex.UpperHalfPlane.MoebiusAction | NeZero (1 + 1) |
Lean.Elab.Tactic.BVDecide.Frontend.Normalize.getEqIffEnumToBitVecEqFor | Lean.Elab.Tactic.BVDecide.Frontend.Normalize.Enums | Lean.Name → Lean.MetaM Lean.Name |
IntermediateField.isSeparable_of_mem_isSeparable | Mathlib.FieldTheory.SeparableDegree | ∀ (F : Type u) (E : Type v) [inst : Field F] [inst_1 : Field E] [inst_2 : Algebra F E] {L : IntermediateField F E}
[Algebra.IsSeparable F ↥L] {x : E}, x ∈ L → IsSeparable F x |
RootPairing.nsmul_notMem_range_root | Mathlib.LinearAlgebra.RootSystem.Reduced | ∀ {ι : Type u_1} {R : Type u_2} {M : Type u_3} {N : Type u_4} [inst : CommRing R] [inst_1 : AddCommGroup M]
[inst_2 : Module R M] [inst_3 : AddCommGroup N] [inst_4 : Module R N] (P : RootPairing ι R M N) [CharZero R]
[IsAddTorsionFree M] [P.IsReduced] {n : ℕ} [n.AtLeastTwo] {i : ι}, n • P.root i ∉ Set.range ⇑P.root |
Aesop.GoalId.casesOn | Aesop.Tree.Data | {motive : Aesop.GoalId → Sort u} → (t : Aesop.GoalId) → ((toNat : ℕ) → motive { toNat := toNat }) → motive t |
CategoryTheory.Bicategory.OplaxTrans.ComonadBicat.toOplax | Mathlib.CategoryTheory.Bicategory.Monad.Basic | {B : Type u} →
[inst : CategoryTheory.Bicategory B] →
CategoryTheory.Bicategory.OplaxTrans.ComonadBicat B →
CategoryTheory.OplaxFunctor (CategoryTheory.LocallyDiscrete (CategoryTheory.Discrete PUnit.{1})) B |
_private.Lean.Meta.Tactic.Grind.Types.0.Lean.Meta.Grind.isCongruent.goEq | Lean.Meta.Tactic.Grind.Types | Lean.Meta.Grind.ENodeMap → Lean.Expr → Lean.Expr → Lean.Expr → Lean.Expr → Bool |
_private.Lean.Data.Lsp.Internal.0.Lean.Lsp.instBEqRefIdent.beq.match_1 | Lean.Data.Lsp.Internal | (motive : Lean.Lsp.RefIdent → Lean.Lsp.RefIdent → Sort u_1) →
(x x_1 : Lean.Lsp.RefIdent) →
((a a_1 b b_1 : String) → motive (Lean.Lsp.RefIdent.const a a_1) (Lean.Lsp.RefIdent.const b b_1)) →
((a a_1 b b_1 : String) → motive (Lean.Lsp.RefIdent.fvar a a_1) (Lean.Lsp.RefIdent.fvar b b_1)) →
((x x_2 : Lean.Lsp.RefIdent) → motive x x_2) → motive x x_1 |
Unitization.inrNonUnitalAlgHom._proof_1 | Mathlib.Algebra.Algebra.Unitization | ∀ (R : Type u_1) (A : Type u_2) [inst : CommSemiring R] [inst_1 : NonUnitalSemiring A] [inst_2 : Module R A] (r : R)
(m : A), ↑(r • m) = r • ↑m |
_private.Lean.Meta.LitValues.0.Lean.Meta.normLitValue.match_13 | Lean.Meta.LitValues | (motive : Option UInt16 → Sort u_1) →
(__do_lift : Option UInt16) → ((n : UInt16) → motive (some n)) → ((x : Option UInt16) → motive x) → motive __do_lift |
_private.Init.Data.Int.Order.0.Int.toNat_sub''.match_1_1 | Init.Data.Int.Order | ∀ (motive : (a b : ℤ) → (∃ n, a = ↑n) → (∃ n, b = ↑n) → 0 ≤ a → 0 ≤ b → Prop) (a b : ℤ) (x : ∃ n, a = ↑n)
(x_1 : ∃ n, b = ↑n) (ha : 0 ≤ a) (hb : 0 ≤ b),
(∀ (w w_1 : ℕ) (ha : 0 ≤ ↑w) (hb : 0 ≤ ↑w_1), motive ↑w ↑w_1 ⋯ ⋯ ha hb) → motive a b x x_1 ha hb |
_private.Std.Data.DTreeMap.Internal.Operations.0.PSigma.casesOn._arg_pusher | Std.Data.DTreeMap.Internal.Operations | ∀ {α : Sort u} {β : α → Sort v} {motive : PSigma β → Sort u_1} (α_1 : Sort u✝) (β_1 : α_1 → Sort v✝)
(f : (x : α_1) → β_1 x) (rel : PSigma β → α_1 → Prop) (t : PSigma β)
(mk : (fst : α) → (snd : β fst) → ((y : α_1) → rel ⟨fst, snd⟩ y → β_1 y) → motive ⟨fst, snd⟩),
(PSigma.casesOn (motive := fun t => ((y : α_1) → rel t y → β_1 y) → motive t) t mk fun y h => f y) =
PSigma.casesOn t fun fst snd => mk fst snd fun y h => f y |
_private.Mathlib.RingTheory.Flat.Basic.0.Module.Flat.directSum_iff._simp_1_3 | Mathlib.RingTheory.Flat.Basic | ∀ {R₁ : Type u_2} {R₂ : Type u_3} {R₃ : Type u_4} {M₁ : Type u_9} {M₂ : Type u_10} {M₃ : Type u_11} [inst : Semiring R₁]
[inst_1 : Semiring R₂] [inst_2 : Semiring R₃] [inst_3 : AddCommMonoid M₁] [inst_4 : AddCommMonoid M₂]
[inst_5 : AddCommMonoid M₃] {module_M₁ : Module R₁ M₁} {module_M₂ : Module R₂ M₂} {module_M₃ : Module R₃ M₃}
{σ₁₂ : R₁ →+* R₂} {σ₂₃ : R₂ →+* R₃} {σ₁₃ : R₁ →+* R₃} [inst_6 : RingHomCompTriple σ₁₂ σ₂₃ σ₁₃] (f : M₂ →ₛₗ[σ₂₃] M₃)
(g : M₁ →ₛₗ[σ₁₂] M₂), ⇑f ∘ ⇑g = ⇑(f ∘ₛₗ g) |
Std.DHashMap.Internal.Raw₀.Const.insertMany_nil | Std.Data.DHashMap.Internal.RawLemmas | ∀ {α : Type u} [inst : BEq α] [inst_1 : Hashable α] {β : Type v} (m : Std.DHashMap.Internal.Raw₀ α fun x => β),
↑(Std.DHashMap.Internal.Raw₀.Const.insertMany m []) = m |
List.dropLast_append_cons | Init.Data.List.Lemmas | ∀ {α : Type u_1} {l₁ : List α} {b : α} {l₂ : List α}, (l₁ ++ b :: l₂).dropLast = l₁ ++ (b :: l₂).dropLast |
Subarray.scanlM.eq_1 | Batteries.Data.Array.Scan | ∀ {m : Type u_1 → Type u_2} {β : Type u_1} {α : Type u_3} [inst : Monad m] (f : β → α → m β) (init : β)
(as : Subarray α), Subarray.scanlM f init as = Array.scanlM f init as.array as.start as.stop |
MeasureTheory.Measure.sum_fintype | Mathlib.MeasureTheory.Measure.MeasureSpace | ∀ {α : Type u_1} {ι : Type u_5} {m0 : MeasurableSpace α} [inst : Fintype ι] (μ : ι → MeasureTheory.Measure α),
MeasureTheory.Measure.sum μ = ∑ i, μ i |
LightCondensed.instMonoidalClosedFunctorOppositeLightProfiniteModuleCat._proof_1 | Mathlib.Condensed.Light.Monoidal | ∀ (R : Type u_1) [inst : CommRing R], (CategoryTheory.equivSmallModel LightProfinite).op.congrLeft.functor.IsEquivalence |
Finset.preimage_add_right_zero' | Mathlib.Algebra.Group.Pointwise.Finset.Basic | ∀ {α : Type u_2} [inst : AddGroup α] {b : α}, Finset.preimage 0 (fun x => x + -b) ⋯ = {b} |
FreeAddMagma.add | Mathlib.Algebra.Free | {α : Type u} → FreeAddMagma α → FreeAddMagma α → FreeAddMagma α |
Lean.Meta.FindSplitImpl.Context.recOn | Lean.Meta.Tactic.SplitIf | {motive : Lean.Meta.FindSplitImpl.Context → Sort u} →
(t : Lean.Meta.FindSplitImpl.Context) →
((exceptionSet : Lean.ExprSet) →
(kind : Lean.Meta.SplitKind) → motive { exceptionSet := exceptionSet, kind := kind }) →
motive t |
Lean.Lsp.FoldingRange.mk.noConfusion | Lean.Data.Lsp.LanguageFeatures | {P : Sort u} →
{startLine endLine : ℕ} →
{kind? : Option Lean.Lsp.FoldingRangeKind} →
{startLine' endLine' : ℕ} →
{kind?' : Option Lean.Lsp.FoldingRangeKind} →
{ startLine := startLine, endLine := endLine, kind? := kind? } =
{ startLine := startLine', endLine := endLine', kind? := kind?' } →
(startLine = startLine' → endLine = endLine' → kind? = kind?' → P) → P |
Lean.Meta.AC.PreExpr.brecOn.go | Lean.Meta.Tactic.AC.Main | {motive : Lean.Meta.AC.PreExpr → Sort u} →
(t : Lean.Meta.AC.PreExpr) →
((t : Lean.Meta.AC.PreExpr) → Lean.Meta.AC.PreExpr.below t → motive t) → motive t ×' Lean.Meta.AC.PreExpr.below t |
Set.opEquiv_self | Mathlib.Data.Set.Opposite | {α : Type u_1} → (s : Set α) → ↑s.op ≃ ↑s |
Complex.sin_surjective | Mathlib.Analysis.SpecialFunctions.Trigonometric.Complex | Function.Surjective Complex.sin |
Module.FinitePresentation.linearEquivMap._proof_3 | Mathlib.Algebra.Module.FinitePresentation | ∀ {R : Type u_1} [inst : CommRing R], IsScalarTower R R R |
Order.Icc_subset_Ico_succ_right._simp_1 | Mathlib.Order.SuccPred.Basic | ∀ {α : Type u_1} [inst : Preorder α] [inst_1 : SuccOrder α] [NoMaxOrder α] (a b : α),
(Set.Icc a b ⊆ Set.Ico a (Order.succ b)) = True |
Algebra.IsAlgebraic.algHomEquivAlgHomOfSplits._proof_1 | Mathlib.FieldTheory.IsAlgClosed.Basic | ∀ (A : Type u_1) [Field A], Nontrivial A |
_private.Mathlib.GroupTheory.Perm.Cycle.Type.0.Equiv.Perm.IsThreeCycle.nodup_iff_mem_support._proof_1_560 | Mathlib.GroupTheory.Perm.Cycle.Type | ∀ {α : Type u_1} [inst_1 : DecidableEq α] {g : Equiv.Perm α} {a : α} (w w_1 : α)
(h :
List.idxOfNth w [g (g a)] {g a, g (g a)}.card + 1 ≤
(List.filter (fun x => decide (x = w_1)) [g a, g (g a)]).length),
(List.findIdxs (fun x => decide (x = w_1)) [g a, g (g a)])[List.idxOfNth w [g (g a)] {g a, g (g a)}.card] <
[g a, g (g a)].length |
AddCon.ker.congr_simp | Mathlib.Algebra.Colimit.Module | ∀ {M : Type u_1} {N : Type u_2} {F : Type u_4} [inst : Add M] [inst_1 : Add N] [inst_2 : FunLike F M N]
[inst_3 : AddHomClass F M N] (f f_1 : F), f = f_1 → AddCon.ker f = AddCon.ker f_1 |
CategoryTheory.Functor.chosenProd.fst | Mathlib.CategoryTheory.Monoidal.Cartesian.FunctorCategory | {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.CartesianMonoidalCategory C] →
(F₁ F₂ : CategoryTheory.Functor J C) → F₁.chosenProd F₂ ⟶ F₁ |
FinBoolAlg.hasForgetToFinBddDistLat._proof_4 | Mathlib.Order.Category.FinBoolAlg | { obj := fun X => FinBddDistLat.of ↑X.toBoolAlg, map := fun {X Y} f => FinBddDistLat.ofHom (BoolAlg.Hom.hom f.hom),
map_id := FinBoolAlg.hasForgetToFinBddDistLat._proof_1,
map_comp := @FinBoolAlg.hasForgetToFinBddDistLat._proof_2 }.comp
(CategoryTheory.forget FinBddDistLat) =
CategoryTheory.forget FinBoolAlg |
_private.Mathlib.Order.Interval.Finset.Nat.0.Nat.image_sub_const_Ico._proof_1_3 | Mathlib.Order.Interval.Finset.Nat | ∀ {a b c : ℕ} (x : ℕ), a - c ≤ x ∧ x < b - c → (a ≤ x + c ∧ x + c < b) ∧ x + c - c = x |
ENNReal.add_halves | Mathlib.Data.ENNReal.Inv | ∀ (a : ENNReal), a / 2 + a / 2 = a |
Finset.map_insert | Mathlib.Data.Finset.Image | ∀ {α : Type u_1} {β : Type u_2} [inst : DecidableEq α] [inst_1 : DecidableEq β] (f : α ↪ β) (a : α) (s : Finset α),
Finset.map f (insert a s) = insert (f a) (Finset.map f s) |
_private.Init.Data.Array.InsertionSort.0.Array.insertionSort.swapLoop.match_1 | Init.Data.Array.InsertionSort | (motive : ℕ → Sort u_1) → (j : ℕ) → (j = 0 → motive 0) → ((j' : ℕ) → j = j'.succ → motive j'.succ) → motive j |
RingHomId.eq_id | Mathlib.Algebra.Ring.CompTypeclasses | ∀ {R : Type u_4} {inst : Semiring R} {σ : R →+* R} [self : RingHomId σ], σ = RingHom.id R |
LinearEquiv.piRing | Mathlib.LinearAlgebra.Pi | (R : Type u) →
(M : Type v) →
(ι : Type x) →
[inst : Semiring R] →
(S : Type u_4) →
[Fintype ι] →
[DecidableEq ι] →
[inst_3 : Semiring S] →
[inst_4 : AddCommMonoid M] →
[inst_5 : Module R M] →
[inst_6 : Module S M] → [inst_7 : SMulCommClass R S M] → ((ι → R) →ₗ[R] M) ≃ₗ[S] ι → M |
_private.Mathlib.Analysis.Real.Hyperreal.0.Hyperreal.infinitePos_of_tendsto_top._simp_1_3 | Mathlib.Analysis.Real.Hyperreal | ∀ {α : Type u_1} [inst : LinearOrder α] {a b : α}, (¬a < b) = (b ≤ a) |
Std.Internal.List.maxKeyD_le_maxKeyD_insertEntry | Std.Data.Internal.List.Associative | ∀ {α : Type u} {β : α → Type v} [inst : Ord α] [Std.TransOrd α] [inst_2 : BEq α] [Std.LawfulBEqOrd α]
{l : List ((a : α) × β a)},
Std.Internal.List.DistinctKeys l →
l.isEmpty = false →
∀ {k : α} {v : β k} {fallback : α},
(compare (Std.Internal.List.maxKeyD l fallback)
(Std.Internal.List.maxKeyD (Std.Internal.List.insertEntry k v l) fallback)).isLE =
true |
Finset.prod_ite_of_false | Mathlib.Algebra.BigOperators.Group.Finset.Piecewise | ∀ {ι : Type u_1} {M : Type u_3} {s : Finset ι} [inst : CommMonoid M] {p : ι → Prop} [inst_1 : DecidablePred p],
(∀ x ∈ s, ¬p x) → ∀ (f g : ι → M), (∏ x ∈ s, if p x then f x else g x) = ∏ x ∈ s, g x |
_private.Lean.Meta.ExprTraverse.0.Lean.Meta.traverseForallWithPos.visit.match_1 | Lean.Meta.ExprTraverse | (motive : Lean.Expr → Sort u_1) →
(x : Lean.Expr) →
((n : Lean.Name) → (d b : Lean.Expr) → (c : Lean.BinderInfo) → motive (Lean.Expr.forallE n d b c)) →
((e : Lean.Expr) → motive e) → motive x |
Equiv.recOn | Mathlib.Logic.Equiv.Defs | {α : Sort u_1} →
{β : Sort u_2} →
{motive : α ≃ β → Sort u} →
(t : α ≃ β) →
((toFun : α → β) →
(invFun : β → α) →
(left_inv : Function.LeftInverse invFun toFun) →
(right_inv : Function.RightInverse invFun toFun) →
motive { toFun := toFun, invFun := invFun, left_inv := left_inv, right_inv := right_inv }) →
motive t |
Continuous.cfcₙ_nnreal'._auto_3 | Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.Continuity | Lean.Syntax |
topologicalAddGroup_inf | Mathlib.Topology.Algebra.Group.Basic | ∀ {G : Type w} [inst : AddGroup G] {t₁ t₂ : TopologicalSpace G},
IsTopologicalAddGroup G → IsTopologicalAddGroup G → IsTopologicalAddGroup G |
Acc.casesOn | Init.WF | {α : Sort u} →
{r : α → α → Prop} →
{motive : (a : α) → Acc r a → Sort u_1} →
{a : α} → (t : Acc r a) → ((x : α) → (h : ∀ (y : α), r y x → Acc r y) → motive x ⋯) → motive a t |
Function.Embedding.instAddAction._proof_1 | Mathlib.GroupTheory.GroupAction.Embedding | ∀ {α : Type u_1} {β : Type u_2}, Function.Injective fun f => ⇑f |
Multiset.powerset._proof_1 | Mathlib.Data.Multiset.Powerset | ∀ {α : Type u_1} (x x_1 : List α),
(List.isSetoid α) x x_1 →
Quot.mk (⇑(List.isSetoid (Multiset α))) (Multiset.powersetAux x) =
Quot.mk (⇑(List.isSetoid (Multiset α))) (Multiset.powersetAux x_1) |
ZFSet.Insert.match_5 | Mathlib.SetTheory.ZFC.Basic | ∀ (α : Type u_1) (A : α → PSet.{u_1}) (α_1 : Type u_1) (A_1 : α_1 → PSet.{u_1}) (b : (PSet.mk α_1 A_1).Type)
(motive : (∃ a, (A a).Equiv (A_1 b)) → Prop) (x : ∃ a, (A a).Equiv (A_1 b)),
(∀ (a : α) (ha : (A a).Equiv (A_1 b)), motive ⋯) → motive x |
List.Sublist.flatMap | Mathlib.Data.List.Flatten | ∀ {α : Type u_1} {β : Type u_2} {l₁ l₂ : List α},
l₁.Sublist l₂ → ∀ (f : α → List β), (List.flatMap f l₁).Sublist (List.flatMap f l₂) |
Ring.zsmul | Mathlib.Algebra.Ring.Defs | {R : Type u} → [self : Ring R] → ℤ → R → R |
MeasureTheory.StronglyAdapted.progMeasurable_of_continuous | Mathlib.Probability.Process.Adapted | ∀ {Ω : Type u_1} {ι : Type u_2} {m : MeasurableSpace Ω} [inst : Preorder ι] {f : MeasureTheory.Filtration ι m}
{β : Type u_3} [inst_1 : TopologicalSpace β] {u : ι → Ω → β} [inst_2 : TopologicalSpace ι]
[TopologicalSpace.MetrizableSpace ι] [SecondCountableTopology ι] [inst_5 : MeasurableSpace ι] [OpensMeasurableSpace ι]
[TopologicalSpace.PseudoMetrizableSpace β],
MeasureTheory.StronglyAdapted f u → (∀ (ω : Ω), Continuous fun i => u i ω) → MeasureTheory.ProgMeasurable f u |
Equiv.simpleGraph | Mathlib.Combinatorics.SimpleGraph.Maps | {V : Type u_1} → {W : Type u_2} → V ≃ W → SimpleGraph V ≃ SimpleGraph W |
Std.Internal.List.minKey!_insertEntryIfNew_le_minKey! | Std.Data.Internal.List.Associative | ∀ {α : Type u} {β : α → Type v} [inst : Ord α] [Std.TransOrd α] [inst_2 : BEq α] [Std.LawfulBEqOrd α]
[inst_4 : Inhabited α] {l : List ((a : α) × β a)},
Std.Internal.List.DistinctKeys l →
l.isEmpty = false →
∀ {k : α} {v : β k},
(compare (Std.Internal.List.minKey! (Std.Internal.List.insertEntryIfNew k v l))
(Std.Internal.List.minKey! l)).isLE =
true |
QuadraticAlgebra.instNonUnitalNonAssocSemiring | Mathlib.Algebra.QuadraticAlgebra.Defs | {R : Type u_1} → {a b : R} → [NonUnitalNonAssocSemiring R] → NonUnitalNonAssocSemiring (QuadraticAlgebra R a b) |
CompactlySupportedContinuousMap.smulc_apply | Mathlib.Topology.ContinuousMap.CompactlySupported | ∀ {α : Type u_2} {β : Type u_3} {γ : Type u_4} [inst : TopologicalSpace α] [inst_1 : TopologicalSpace β]
[inst_2 : Zero β] [inst_3 : TopologicalSpace γ] [inst_4 : SMulZeroClass γ β] [inst_5 : ContinuousSMul γ β]
{F : Type u_5} [inst_6 : FunLike F α γ] [inst_7 : ContinuousMapClass F α γ] (f : F)
(g : CompactlySupportedContinuousMap α β) (x : α), (f • g) x = f x • g x |
Lean.Meta.Grind.SplitInfo.arg | Lean.Meta.Tactic.Grind.Types | Lean.Expr → Lean.Expr → ℕ → Lean.Expr → Lean.Meta.Grind.SplitSource → Lean.Meta.Grind.SplitInfo |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.