name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M |
|---|---|---|
Mathlib.Tactic.TFAE.proveChain._unsafe_rec | Mathlib.Tactic.TFAE | Array (ℕ × ℕ × Lean.Expr) →
Array Q(Prop) →
ℕ → List ℕ → (P : Q(Prop)) → (l : Q(List Prop)) → Lean.MetaM Q(List.IsChain (fun x1 x2 => x1 → x2) («$P» :: «$l»)) |
CategoryTheory.Functor.currying_inverse_obj_obj_obj | Mathlib.CategoryTheory.Functor.Currying | ∀ {C : Type u₂} [inst : CategoryTheory.Category.{v₂, u₂} C] {D : Type u₃} [inst_1 : CategoryTheory.Category.{v₃, u₃} D]
{E : Type u₄} [inst_2 : CategoryTheory.Category.{v₄, u₄} E] (F : CategoryTheory.Functor (C × D) E) (X : C) (Y : D),
((CategoryTheory.Functor.currying.inverse.obj F).obj X).obj Y = F.obj (X, Y) |
Nondet.filterM | Batteries.Control.Nondet.Basic | {σ : Type} →
{m : Type → Type} →
[Monad m] → [inst : Lean.MonadBacktrack σ m] → {α : Type} → (α → m (ULift.{0, 0} Bool)) → Nondet m α → Nondet m α |
NonUnitalAlgHom.snd_prod | Mathlib.Algebra.Algebra.NonUnitalHom | ∀ {R : Type u} [inst : Monoid R] {A : Type v} {B : Type w} {C : Type w₁} [inst_1 : NonUnitalNonAssocSemiring A]
[inst_2 : DistribMulAction R A] [inst_3 : NonUnitalNonAssocSemiring B] [inst_4 : NonUnitalNonAssocSemiring C]
[inst_5 : DistribMulAction R B] [inst_6 : DistribMulAction R C] (f : A →ₙₐ[R] B) (g : A →ₙₐ[R] C),
(NonUnitalAlgHom.snd R B C).comp (f.prod g) = g |
_private.Mathlib.MeasureTheory.Measure.Haar.InnerProductSpace.0.volumePreservingSymmMeasurableEquivToLpProdAux._proof_4 | Mathlib.MeasureTheory.Measure.Haar.InnerProductSpace | ∀ (U : Type u_1) [inst : NormedAddCommGroup U] [inst_1 : InnerProductSpace ℝ U], BorelSpace (PiLp 2 fun x => ℝ) |
NonUnitalIsometricContinuousFunctionalCalculus.norm_quasispectrum_le._auto_1 | Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.Isometric | Lean.Syntax |
_private.Lean.Meta.Tactic.Split.0.Lean.Meta.splitTarget?.go._unsafe_rec | Lean.Meta.Tactic.Split | Lean.MVarId → Bool → Bool → Lean.Expr → Lean.ExprSet → Lean.MetaM (Option (List Lean.MVarId)) |
_private.Mathlib.Algebra.Lie.Nilpotent.0.LieIdeal.coe_lcs_eq._simp_1_2 | Mathlib.Algebra.Lie.Nilpotent | ∀ {R : Type u} {L : Type v} {M : Type w} [inst : CommRing R] [inst_1 : LieRing L] [inst_2 : AddCommGroup M]
[inst_3 : Module R M] [inst_4 : LieRingModule L M] (x : M), (x ∈ ⊤) = True |
WeierstrassCurve.Jacobian.Point.mk_ne_zero | Mathlib.AlgebraicGeometry.EllipticCurve.Jacobian.Point | ∀ {R : Type r} [inst : CommRing R] {W' : WeierstrassCurve.Jacobian R} [inst_1 : Nontrivial R] {X Y : R}
(h : W'.NonsingularLift ⟦![X, Y, 1]⟧), { point := ⟦![X, Y, 1]⟧, nonsingular := h } ≠ 0 |
MvPowerSeries.coeff_mul_left_one_sub_of_lt_order | Mathlib.RingTheory.MvPowerSeries.Order | ∀ {σ : Type u_1} {R : Type u_3} [inst : Ring R] {f g : MvPowerSeries σ R} (d : σ →₀ ℕ),
↑(Finsupp.degree d) < g.order → (MvPowerSeries.coeff d) (f * (1 - g)) = (MvPowerSeries.coeff d) f |
Lean.Parser.Term.completion.formatter | Lean.Parser.Term | Lean.PrettyPrinter.Formatter |
AffineSubspace.mem_direction_iff_eq_vsub_left | Mathlib.LinearAlgebra.AffineSpace.AffineSubspace.Defs | ∀ {k : Type u_1} {V : Type u_2} {P : Type u_3} [inst : Ring k] [inst_1 : AddCommGroup V] [inst_2 : Module k V]
[inst_3 : AddTorsor V P] {s : AffineSubspace k P} {p : P}, p ∈ s → ∀ (v : V), v ∈ s.direction ↔ ∃ p₂ ∈ s, v = p -ᵥ p₂ |
Subalgebra.finrank_right_dvd_finrank_sup_of_free | Mathlib.Algebra.Algebra.Subalgebra.Rank | ∀ {R : Type u_1} {S : Type u_2} [inst : CommRing R] [inst_1 : CommRing S] [inst_2 : Algebra R S] (A B : Subalgebra R S)
[Module.Free R ↥B] [Module.Free ↥B ↥(Algebra.adjoin ↥B ↑A)], Module.finrank R ↥B ∣ Module.finrank R ↥(A ⊔ B) |
Prod.instSubsingletonUnits | Mathlib.Algebra.Group.Prod | ∀ {M : Type u_3} {N : Type u_4} [inst : Monoid M] [inst_1 : Monoid N] [Subsingleton Mˣ] [Subsingleton Nˣ],
Subsingleton (M × N)ˣ |
UInt32.ofBitVec_mod | Init.Data.UInt.Lemmas | ∀ (a b : BitVec 32), { toBitVec := a % b } = { toBitVec := a } % { toBitVec := b } |
Aesop.instInhabitedRule.default | Aesop.Rule.Basic | {a : Type} → [Inhabited a] → Aesop.Rule a |
CategoryTheory.CartesianMonoidalCategory.mono_lift_of_mono_right | Mathlib.CategoryTheory.Monoidal.Cartesian.Basic | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.CartesianMonoidalCategory C]
{W X Y : C} (f : W ⟶ X) (g : W ⟶ Y) [CategoryTheory.Mono g],
CategoryTheory.Mono (CategoryTheory.CartesianMonoidalCategory.lift f g) |
Subgroup.rightCosetEquivSubgroup.eq_1 | Mathlib.GroupTheory.Coset.Basic | ∀ {α : Type u_1} [inst : Group α] {s : Subgroup α} (g : α),
Subgroup.rightCosetEquivSubgroup g =
{ toFun := fun x => ⟨↑x * g⁻¹, ⋯⟩, invFun := fun x => ⟨↑x * g, ⋯⟩, left_inv := ⋯, right_inv := ⋯ } |
CategoryTheory.Localization.Lifting₂.ctorIdx | Mathlib.CategoryTheory.Localization.Bifunctor | {C₁ : Type u_1} →
{C₂ : Type u_2} →
{D₁ : Type u_3} →
{D₂ : Type u_4} →
{E : Type u_5} →
{inst : CategoryTheory.Category.{v_1, u_1} C₁} →
{inst_1 : CategoryTheory.Category.{v_2, u_2} C₂} →
{inst_2 : CategoryTheory.Category.{v_3, u_3} D₁} →
{inst_3 : CategoryTheory.Category.{v_4, u_4} D₂} →
{inst_4 : CategoryTheory.Category.{v_5, u_5} E} →
{L₁ : CategoryTheory.Functor C₁ D₁} →
{L₂ : CategoryTheory.Functor C₂ D₂} →
{W₁ : CategoryTheory.MorphismProperty C₁} →
{W₂ : CategoryTheory.MorphismProperty C₂} →
{F : CategoryTheory.Functor C₁ (CategoryTheory.Functor C₂ E)} →
{F' : CategoryTheory.Functor D₁ (CategoryTheory.Functor D₂ E)} →
CategoryTheory.Localization.Lifting₂ L₁ L₂ W₁ W₂ F F' → ℕ |
_private.Mathlib.Algebra.Polynomial.Degree.Defs.0.Polynomial.degree_le_iff_coeff_zero._simp_1_2 | Mathlib.Algebra.Polynomial.Degree.Defs | ∀ {α : Type u_2} {β : Type u_3} [inst : SemilatticeSup α] [inst_1 : OrderBot α] {s : Finset β} {f : β → α} {a : α},
(s.sup f ≤ a) = ∀ b ∈ s, f b ≤ a |
_private.Mathlib.Topology.Connected.Clopen.0.nonempty_frontier_iff._simp_1_1 | Mathlib.Topology.Connected.Clopen | ∀ {α : Type u} {s : Set α}, s.Nonempty = (s ≠ ∅) |
SimpleGraph.IsClique.of_induce | Mathlib.Combinatorics.SimpleGraph.Clique | ∀ {α : Type u_1} {G : SimpleGraph α} {S : G.Subgraph} {F : Set α} {A : Set ↑F},
(S.induce F).coe.IsClique A → G.IsClique (Subtype.val '' A) |
ULift.seminormedCommRing._proof_15 | Mathlib.Analysis.Normed.Ring.Basic | ∀ {α : Type u_2} [inst : SeminormedCommRing α] (n : ℕ) (a : ULift.{u_1, u_2} α),
SubNegMonoid.zsmul (↑n.succ) a = SubNegMonoid.zsmul (↑n) a + a |
NonarchAddGroupNorm.rec | Mathlib.Analysis.Normed.Group.Seminorm | {G : Type u_6} →
[inst : AddGroup G] →
{motive : NonarchAddGroupNorm G → Sort u} →
((toNonarchAddGroupSeminorm : NonarchAddGroupSeminorm G) →
(eq_zero_of_map_eq_zero' : ∀ (x : G), toNonarchAddGroupSeminorm.toFun x = 0 → x = 0) →
motive
{ toNonarchAddGroupSeminorm := toNonarchAddGroupSeminorm,
eq_zero_of_map_eq_zero' := eq_zero_of_map_eq_zero' }) →
(t : NonarchAddGroupNorm G) → motive t |
exteriorPower.pairingDual | Mathlib.LinearAlgebra.ExteriorPower.Pairing | (R : Type u_1) →
(M : Type u_2) →
[inst : CommRing R] →
[inst_1 : AddCommGroup M] →
[inst_2 : Module R M] → (n : ℕ) → ↥(⋀[R]^n (Module.Dual R M)) →ₗ[R] Module.Dual R ↥(⋀[R]^n M) |
Ordinal.cof_eq | Mathlib.SetTheory.Cardinal.Cofinality | ∀ {α : Type u} (r : α → α → Prop) [inst : IsWellOrder α r],
∃ S, Set.Unbounded r S ∧ Cardinal.mk ↑S = (Ordinal.type r).cof |
Std.DHashMap.Internal.Raw₀.Const.get_modify | Std.Data.DHashMap.Internal.RawLemmas | ∀ {α : Type u} [inst : BEq α] [inst_1 : Hashable α] {β : Type v} [inst_2 : EquivBEq α] [inst_3 : LawfulHashable α]
(m : Std.DHashMap.Internal.Raw₀ α fun x => β) (h : (↑m).WF) {k k' : α} {f : β → β}
(hc : (Std.DHashMap.Internal.Raw₀.Const.modify m k f).contains k' = true),
Std.DHashMap.Internal.Raw₀.Const.get (Std.DHashMap.Internal.Raw₀.Const.modify m k f) k' hc =
if heq : (k == k') = true then f (Std.DHashMap.Internal.Raw₀.Const.get m k ⋯)
else Std.DHashMap.Internal.Raw₀.Const.get m k' ⋯ |
basis_toMatrix_basisFun_mul | Mathlib.LinearAlgebra.Matrix.Basis | ∀ {ι : Type u_1} {R : Type u_5} [inst : CommSemiring R] [inst_1 : Fintype ι] (b : Module.Basis ι R (ι → R))
(A : Matrix ι ι R), b.toMatrix ⇑(Pi.basisFun R ι) * A = Matrix.of fun i j => (b.repr (A.col j)) i |
CategoryTheory.Limits.ReflectsCofilteredLimitsOfSize | Mathlib.CategoryTheory.Limits.Preserves.Filtered | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
{D : Type u₂} → [inst_1 : CategoryTheory.Category.{v₂, u₂} D] → CategoryTheory.Functor C D → Prop |
_private.Init.Data.Array.Range.0.Array.mem_range'_1._simp_1_1 | Init.Data.Array.Range | ∀ {s step m n : ℕ}, (m ∈ Array.range' s n step) = ∃ i < n, m = s + step * i |
SemiconjBy.op | Mathlib.Algebra.Group.Opposite | ∀ {α : Type u_1} [inst : Mul α] {a x y : α},
SemiconjBy a x y → SemiconjBy (MulOpposite.op a) (MulOpposite.op y) (MulOpposite.op x) |
CategoryTheory.Functor.CoreMonoidal.toLaxMonoidal.eq_1 | Mathlib.CategoryTheory.Monoidal.Braided.Transport | ∀ {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} (h : F.CoreMonoidal),
h.toLaxMonoidal =
{ ε := h.εIso.hom, μ := fun X Y => (h.μIso X Y).hom, μ_natural_left := ⋯, μ_natural_right := ⋯, associativity := ⋯,
left_unitality := ⋯, right_unitality := ⋯ } |
Int.cast_natCast | Mathlib.Data.Int.Cast.Basic | ∀ {R : Type u} [inst : AddGroupWithOne R] (n : ℕ), ↑↑n = ↑n |
Asymptotics.IsBigO.integrableAtFilter | Mathlib.MeasureTheory.Integral.Asymptotics | ∀ {α : Type u_1} {E : Type u_2} {F : Type u_3} [inst : NormedAddCommGroup E] {f : α → E} {g : α → F} {l : Filter α}
[inst_1 : MeasurableSpace α] [inst_2 : NormedAddCommGroup F] {μ : MeasureTheory.Measure α} [l.IsMeasurablyGenerated],
f =O[l] g →
StronglyMeasurableAtFilter f l μ → MeasureTheory.IntegrableAtFilter g l μ → MeasureTheory.IntegrableAtFilter f l μ |
SkewMonoidAlgebra.liftNCAlgHom | Mathlib.Algebra.SkewMonoidAlgebra.Lift | {k : Type u_1} →
{G : Type u_2} →
[inst : CommSemiring k] →
[inst_1 : Monoid G] →
{A : Type u_4} →
{B : Type u_5} →
[inst_2 : Semiring A] →
[inst_3 : Algebra k A] →
[inst_4 : Semiring B] →
[inst_5 : Algebra k B] →
[inst_6 : MulSemiringAction G A] →
[inst_7 : SMulCommClass G k A] →
(f : A →ₐ[k] B) →
(g : G →* B) →
(∀ {x : A} {y : G}, f (y • x) * g y = g y * f x) → SkewMonoidAlgebra A G →ₐ[k] B |
Real.sin_two_mul | Mathlib.Analysis.Complex.Trigonometric | ∀ (x : ℝ), Real.sin (2 * x) = 2 * Real.sin x * Real.cos x |
CategoryTheory.Limits.hasColimit_of_coequalizer_and_coproduct | Mathlib.CategoryTheory.Limits.Constructions.LimitsOfProductsAndEqualizers | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {J : Type w} [inst_1 : CategoryTheory.SmallCategory J]
(F : CategoryTheory.Functor J C) [CategoryTheory.Limits.HasColimit (CategoryTheory.Discrete.functor F.obj)]
[CategoryTheory.Limits.HasColimit (CategoryTheory.Discrete.functor fun f => F.obj f.fst.1)]
[CategoryTheory.Limits.HasCoequalizers C], CategoryTheory.Limits.HasColimit F |
AddGroupConeClass | Mathlib.Algebra.Order.Group.Cone | (S : Type u_1) → (G : outParam (Type u_2)) → [AddCommGroup G] → [SetLike S G] → Prop |
Profinite.NobelingProof.spanCone._proof_4 | Mathlib.Topology.Category.Profinite.Nobeling.Basic | ∀ {I : Type u_1} {C : Set (I → Bool)}, TotallyDisconnectedSpace { x // x ∈ C } |
List.twoStepInduction._proof_2 | Mathlib.Data.List.Induction | ∀ {α : Type u_1} (x y : α) (xs : List α), (invImage (fun x => x) sizeOfWFRel).1 xs (x :: y :: xs) |
isClosed_empty | Mathlib.Topology.Basic | ∀ {X : Type u} [inst : TopologicalSpace X], IsClosed ∅ |
AddChar.zmodAddEquiv._proof_3 | Mathlib.Analysis.Fourier.FiniteAbelian.PontryaginDuality | ∀ {n : ℕ} [inst : NeZero n],
Function.Bijective ⇑(AddChar.circleEquivComplex.toAddMonoidHom.comp AddChar.zmodHom.toAddMonoidHom) |
Lean.Elab.Term.CollectPatternVars.Context.newArgs | Lean.Elab.PatternVar | Lean.Elab.Term.CollectPatternVars.Context → Array Lean.Term |
NegMemClass.neg | Mathlib.Algebra.Group.Subgroup.Defs | {G : Type u_5} → {S : Type u_6} → [inst : Neg G] → [inst_1 : SetLike S G] → [NegMemClass S G] → {H : S} → Neg ↥H |
Lean.Elab.Term.PostponeBehavior.ctorElimType | Lean.Elab.SyntheticMVars | {motive : Lean.Elab.Term.PostponeBehavior → Sort u} → ℕ → Sort (max 1 u) |
ModuleCat.hom_whiskerLeft | Mathlib.Algebra.Category.ModuleCat.Monoidal.Basic | ∀ {R : Type u} [inst : CommRing R] (L : ModuleCat R) {M N : ModuleCat R} (f : M ⟶ N),
ModuleCat.Hom.hom (CategoryTheory.MonoidalCategoryStruct.whiskerLeft L f) =
LinearMap.lTensor (↑L) (ModuleCat.Hom.hom f) |
IsLocalization.orderIsoOfMaximal._proof_7 | Mathlib.RingTheory.Jacobson.Ring | ∀ {R : Type u_1} {S : Type u_2} [inst : CommRing R] [inst_1 : CommRing S] (y : R) [inst_2 : Algebra R S]
[inst_3 : IsLocalization.Away y S] [inst_4 : IsJacobsonRing R] (I : { p // p.IsMaximal ∧ y ∉ p }),
⟨Ideal.comap (algebraMap R S) ↑⟨Ideal.map (algebraMap R S) ↑I, ⋯⟩, ⋯⟩ = I |
CategoryTheory.InjectiveResolution.desc.eq_1 | Mathlib.CategoryTheory.Abelian.Injective.Resolution | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Abelian C] {Y Z : C} (f : Z ⟶ Y)
(I : CategoryTheory.InjectiveResolution Y) (J : CategoryTheory.InjectiveResolution Z),
CategoryTheory.InjectiveResolution.desc f I J =
J.cocomplex.mkHom I.cocomplex (CategoryTheory.InjectiveResolution.descFZero f I J)
(CategoryTheory.InjectiveResolution.descFOne f I J) ⋯ fun n x =>
match x with
| ⟨g, ⟨g', w⟩⟩ => ⟨(I.descFSucc J n g g' ⋯).fst, ⋯⟩ |
_private.Mathlib.Combinatorics.SimpleGraph.Paths.0.SimpleGraph.Walk.exists_isPath_forall_isPath_length_le_length.match_1_1 | Mathlib.Combinatorics.SimpleGraph.Paths | ∀ {V : Type u_1} (G : SimpleGraph V) (n : ℕ),
let s := {n | ∃ u v p, p.IsPath ∧ p.length = n};
∀ (motive : n ∈ s → Prop) (x : n ∈ s),
(∀ (w w_1 : V) (w_2 : G.Walk w w_1) (hp : w_2.IsPath) (hn : w_2.length = n), motive ⋯) → motive x |
Aesop.ForwardClusterStateStats.casesOn | Aesop.Stats.Basic | {motive : Aesop.ForwardClusterStateStats → Sort u} →
(t : Aesop.ForwardClusterStateStats) →
((slots : ℕ) →
(instantiationStats : Array Aesop.ForwardInstantiationStats) →
motive { slots := slots, instantiationStats := instantiationStats }) →
motive t |
HahnSeries.isPWO_support._simp_1 | Mathlib.RingTheory.HahnSeries.Basic | ∀ {Γ : Type u_1} {R : Type u_3} [inst : PartialOrder Γ] [inst_1 : Zero R] (x : HahnSeries Γ R), x.support.IsPWO = True |
Primcodable.subtype._proof_1 | Mathlib.Computability.Primrec.Basic | ∀ {α : Type u_1} [inst : Primcodable α] {p : α → Prop} [inst_1 : DecidablePred p] (n : ℕ),
Encodable.encode ((Encodable.decode n).bind fun a => Option.guard (fun b => decide (p b)) a) =
Encodable.encode ((Encodable.decode n).bind fun x => if h : p x then some ⟨x, h⟩ else none) |
Equiv.withBotCongr_refl | Mathlib.Order.WithBot | ∀ {α : Type u_1}, (Equiv.refl α).withBotCongr = Equiv.refl (WithBot α) |
SeparationQuotient.lift.congr_simp | Mathlib.Topology.Inseparable | ∀ {X : Type u_1} {α : Type u_4} [inst : TopologicalSpace X] (f f_1 : X → α) (e_f : f = f_1)
(hf : ∀ (x y : X), Inseparable x y → f x = f y) (a a_1 : SeparationQuotient X),
a = a_1 → SeparationQuotient.lift f hf a = SeparationQuotient.lift f_1 ⋯ a_1 |
ae_restrict_le_codiscreteWithin | Mathlib.MeasureTheory.Topology | ∀ {α : Type u_1} [inst : MeasurableSpace α] [inst_1 : TopologicalSpace α] [SecondCountableTopology α]
{μ : MeasureTheory.Measure α} [MeasureTheory.NoAtoms μ] {U : Set α},
MeasurableSet U → MeasureTheory.ae (μ.restrict U) ≤ Filter.codiscreteWithin U |
instNonUnitalCStarAlgebraSubtypePreLpMemAddSubgroupLpTopENNReal._proof_3 | Mathlib.Analysis.CStarAlgebra.lpSpace | ∀ {I : Type u_1} {A : I → Type u_2} [inst : (i : I) → NonUnitalCStarAlgebra (A i)], CStarRing ↥(lp A ⊤) |
_private.Mathlib.Data.List.Cycle.0.List.prev_eq_getElem?_idxOf_pred_of_ne_head._proof_1_19 | Mathlib.Data.List.Cycle | ∀ {α : Type u_1} {a : α} (x y : α) (tail : List α), a ∈ x :: y :: tail → ¬a = x → a ∈ y :: tail |
FreeRing.castFreeCommRing.eq_1 | Mathlib.RingTheory.FreeCommRing | ∀ {α : Type u_1}, FreeRing.castFreeCommRing = ⇑FreeRing.toFreeCommRing |
Std.Time.Internal.Bounded.LE.toFin._proof_2 | Std.Time.Internal.Bounded | ∀ {lo hi : ℤ} (n : Std.Time.Internal.Bounded.LE lo hi), 0 ≤ lo → 0 ≤ hi + 1 |
MeasurableSpace.mapNatBool | Mathlib.MeasureTheory.MeasurableSpace.CountablyGenerated | (α : Type u_1) → [inst : MeasurableSpace α] → [MeasurableSpace.CountablyGenerated α] → α → ℕ → Bool |
UniqueFactorizationMonoid.toNormalizedGCDMonoid._proof_8 | Mathlib.RingTheory.UniqueFactorizationDomain.GCDMonoid | ∀ (α : Type u_1) [inst : CommMonoidWithZero α] [inst_1 : UniqueFactorizationMonoid α] [inst_2 : NormalizationMonoid α]
(a b : α), (Associates.mk a ⊓ Associates.mk b).out ∣ b |
BitVec.extractLsb_xor | Init.Data.BitVec.Lemmas | ∀ {w : ℕ} {y x : BitVec w} {hi lo : ℕ},
BitVec.extractLsb lo hi (x ^^^ y) = BitVec.extractLsb lo hi x ^^^ BitVec.extractLsb lo hi y |
IsNilpotent.of_pow | Mathlib.Algebra.GroupWithZero.Basic | ∀ {R : Type u_3} [inst : MonoidWithZero R] {x : R} {m : ℕ}, IsNilpotent (x ^ m) → IsNilpotent x |
CommRingCat.piFanIsLimit | Mathlib.Algebra.Category.Ring.Constructions | {ι : Type u} → (R : ι → CommRingCat) → CategoryTheory.Limits.IsLimit (CommRingCat.piFan R) |
DirectSum.fromAddMonoid | Mathlib.Algebra.DirectSum.Basic | {ι : Type v} →
{β : ι → Type w} →
[inst : (i : ι) → AddCommMonoid (β i)] →
[DecidableEq ι] →
{γ : Type u₁} → [inst_2 : AddCommMonoid γ] → (DirectSum ι fun i => γ →+ β i) →+ γ →+ DirectSum ι fun i => β i |
IsUnit.eq_one | Mathlib.Algebra.Group.Units.Defs | ∀ {M : Type u_1} [inst : Monoid M] {a : M} [Subsingleton Mˣ], IsUnit a → a = 1 |
ValuativeRel.exists_valuation_posSubmonoid_div_valuation_posSubmonoid_eq | Mathlib.RingTheory.Valuation.ValuativeRel.Basic | ∀ {R : Type u_1} [inst : CommRing R] [inst_1 : ValuativeRel R] (γ : (ValuativeRel.ValueGroupWithZero R)ˣ),
∃ a b, (ValuativeRel.valuation R) ↑a / (ValuativeRel.valuation R) ↑b = ↑γ |
Unitary.map_comp | Mathlib.Algebra.Star.Unitary | ∀ {R : Type u_2} {S : Type u_3} {T : Type u_4} [inst : Monoid R] [inst_1 : StarMul R] [inst_2 : Monoid S]
[inst_3 : StarMul S] [inst_4 : Monoid T] [inst_5 : StarMul T] (g : S →⋆* T) (f : R →⋆* S),
Unitary.map (g.comp f) = (Unitary.map g).comp (Unitary.map f) |
Finset.centerMass_pair | Mathlib.Analysis.Convex.Combination | ∀ {R : Type u_1} {E : Type u_3} {ι : Type u_5} [inst : Field R] [inst_1 : AddCommGroup E] [inst_2 : Module R E]
(i j : ι) (w : ι → R) (z : ι → E) [inst_3 : DecidableEq ι],
i ≠ j → {i, j}.centerMass w z = (w i / (w i + w j)) • z i + (w j / (w i + w j)) • z j |
_private.Lean.Compiler.LCNF.ExplicitRC.0.Lean.Compiler.LCNF.CollectDerivedValInfo.collect | Lean.Compiler.LCNF.ExplicitRC | Array (Lean.Compiler.LCNF.Param Lean.Compiler.LCNF.Purity.impure) →
Lean.Compiler.LCNF.Code Lean.Compiler.LCNF.Purity.impure →
Lean.Compiler.LCNF.CompilerM (Lean.Compiler.LCNF.DerivedValMap✝ × Lean.FVarIdHashSet) |
ProfiniteAddGrp.instHasForget₂ContinuousAddMonoidHomCarrierToTopTotallyDisconnectedSpaceToProfiniteProfiniteContinuousMap._proof_5 | Mathlib.Topology.Algebra.Category.ProfiniteGrp.Basic | ∀ {X : ProfiniteAddGrp.{u_1}}, CompHausLike.HasProp (fun Y => TotallyDisconnectedSpace ↑Y) ↑X.toProfinite.1 |
Mathlib.Tactic.Ring.CSLift.ctorIdx | Mathlib.Tactic.Ring.Basic | {α : Type u} → {β : outParam (Type u)} → Mathlib.Tactic.Ring.CSLift α β → ℕ |
ProbabilityTheory.Kernel.IsMarkovKernel.comp | Mathlib.Probability.Kernel.Composition.Comp | ∀ {α : Type u_1} {β : Type u_2} {γ : Type u_3} {mα : MeasurableSpace α} {mβ : MeasurableSpace β}
{mγ : MeasurableSpace γ} (η : ProbabilityTheory.Kernel β γ) [ProbabilityTheory.IsMarkovKernel η]
(κ : ProbabilityTheory.Kernel α β) [ProbabilityTheory.IsMarkovKernel κ], ProbabilityTheory.IsMarkovKernel (η.comp κ) |
CategoryTheory.Adjunction.leftAdjointIdIso_hom_app | Mathlib.CategoryTheory.Adjunction.CompositionIso | ∀ {C₀ : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C₀] {F G : CategoryTheory.Functor C₀ C₀} (adj : F ⊣ G)
(e : G ≅ CategoryTheory.Functor.id C₀) (X : C₀),
(adj.leftAdjointIdIso e).hom.app X = CategoryTheory.CategoryStruct.comp (F.map (e.inv.app X)) (adj.counit.app X) |
_private.Mathlib.RingTheory.Adjoin.Field.0.AlgEquiv.adjoinSingletonEquivAdjoinRootMinpoly._simp_2 | Mathlib.RingTheory.Adjoin.Field | ∀ {R : Type u} {A : Type z} [inst : CommSemiring R] [inst_1 : Semiring A] [inst_2 : Algebra R A] (x : A)
(p : Polynomial R), Polynomial.eval₂ (algebraMap R A) x p = (Polynomial.aeval x) p |
_private.Mathlib.Topology.Algebra.ProperAction.Basic.0.t2Space_quotient_mulAction_of_properSMul._simp_4 | Mathlib.Topology.Algebra.ProperAction.Basic | ∀ {α : Type u_1} {β : Type u_2} {p : α × β → Prop}, (∃ x, p x) = ∃ a b, p (a, b) |
Sbtw.trans_wbtw_left_ne | Mathlib.Analysis.Convex.Between | ∀ {R : Type u_1} {V : Type u_2} {P : Type u_4} [inst : Ring R] [inst_1 : PartialOrder R] [inst_2 : AddCommGroup V]
[inst_3 : Module R V] [inst_4 : AddTorsor V P] [IsOrderedRing R] [IsDomain R] [Module.IsTorsionFree R V]
{w x y z : P}, Sbtw R w y z → Wbtw R w x y → x ≠ z |
ProbabilityTheory.gaussianReal_const_sub | Mathlib.Probability.Distributions.Gaussian.Real | ∀ {μ : ℝ} {v : NNReal} {Ω : Type u_1} {mΩ : MeasurableSpace Ω} {P : MeasureTheory.Measure Ω} {X : Ω → ℝ},
ProbabilityTheory.HasLaw X (ProbabilityTheory.gaussianReal μ v) P →
∀ (y : ℝ), ProbabilityTheory.HasLaw (fun ω => y - X ω) (ProbabilityTheory.gaussianReal (y - μ) v) P |
Aesop.RuleStats.mk.injEq | Aesop.Stats.Basic | ∀ (rule : Aesop.DisplayRuleName) (elapsed : Aesop.Nanos) (successful : Bool) (rule_1 : Aesop.DisplayRuleName)
(elapsed_1 : Aesop.Nanos) (successful_1 : Bool),
({ rule := rule, elapsed := elapsed, successful := successful } =
{ rule := rule_1, elapsed := elapsed_1, successful := successful_1 }) =
(rule = rule_1 ∧ elapsed = elapsed_1 ∧ successful = successful_1) |
BitVec.instDecidableExistsBitVecSucc._proof_1 | Init.Data.BitVec.Decidable | ∀ {n : ℕ} (P : BitVec (n + 1) → Prop), (¬∀ (v : BitVec (n + 1)), ¬P v) ↔ ∃ v, P v |
GroupExtension.Section.inv_mul_mem_range_inl | Mathlib.GroupTheory.GroupExtension.Basic | ∀ {N : Type u_1} {G : Type u_2} [inst : Group N] [inst_1 : Group G] {E : Type u_3} [inst_2 : Group E]
{S : GroupExtension N E G} (σ σ' : S.Section) (g : G), (σ g)⁻¹ * σ' g ∈ S.inl.range |
Rep.coinvariantsTensorFreeLEquiv._proof_4 | Mathlib.RepresentationTheory.Coinvariants | ∀ {k G : Type u_1} [inst : CommRing k] [inst_1 : Group G] (A : Rep k G) (α : Type u_1) [inst_2 : DecidableEq α],
A.finsuppToCoinvariantsTensorFree α ∘ₗ A.coinvariantsTensorFreeToFinsupp α = LinearMap.id |
_private.Lean.Meta.Tactic.Grind.AC.Eq.0.PSigma.casesOn._arg_pusher | Lean.Meta.Tactic.Grind.AC.Eq | ∀ {α : 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 |
Lean.Elab.Structural.RecArgInfo._sizeOf_1 | Lean.Elab.PreDefinition.Structural.RecArgInfo | Lean.Elab.Structural.RecArgInfo → ℕ |
Finset.fiber_card_ne_zero_iff_mem_image | Mathlib.Data.Finset.Card | ∀ {α : Type u_1} {β : Type u_2} (s : Finset α) (f : α → β) [inst : DecidableEq β] (y : β),
{x ∈ s | f x = y}.card ≠ 0 ↔ y ∈ Finset.image f s |
Polynomial.isRoot_cyclotomic_prime_pow_mul_iff_of_charP | Mathlib.RingTheory.Polynomial.Cyclotomic.Expand | ∀ {m k p : ℕ} {R : Type u_1} [inst : CommRing R] [IsDomain R] [hp : Fact (Nat.Prime p)] [hchar : CharP R p] {μ : R}
[NeZero ↑m], (Polynomial.cyclotomic (p ^ k * m) R).IsRoot μ ↔ IsPrimitiveRoot μ m |
Stream'.Seq.fold.match_1 | Mathlib.Data.Seq.Defs | {α : Type u_2} →
{β : Type u_1} →
(motive : β × Stream'.Seq α → Sort u_3) →
(x : β × Stream'.Seq α) → ((acc : β) → (x : Stream'.Seq α) → motive (acc, x)) → motive x |
Equiv.natSumNatEquivNat | Mathlib.Logic.Equiv.Nat | ℕ ⊕ ℕ ≃ ℕ |
Lean.Elab.Tactic.GuardExpr.MatchKind.noConfusionType | Lean.Elab.Tactic.Guard | Sort u → Lean.Elab.Tactic.GuardExpr.MatchKind → Lean.Elab.Tactic.GuardExpr.MatchKind → Sort u |
Semiring.mk._flat_ctor | Mathlib.Algebra.Ring.Defs | {α : Type u} →
(add : α → α → α) →
(∀ (a b c : α), a + b + c = a + (b + c)) →
(zero : α) →
(∀ (a : α), 0 + a = a) →
(∀ (a : α), a + 0 = a) →
(nsmul : ℕ → α → α) →
autoParam (∀ (x : α), nsmul 0 x = 0) AddMonoid.nsmul_zero._autoParam →
autoParam (∀ (n : ℕ) (x : α), nsmul (n + 1) x = nsmul n x + x) AddMonoid.nsmul_succ._autoParam →
(∀ (a b : α), a + b = b + a) →
(mul : α → α → α) →
(∀ (a b c : α), a * (b + c) = a * b + a * c) →
(∀ (a b c : α), (a + b) * c = a * c + b * c) →
(∀ (a : α), 0 * a = 0) →
(∀ (a : α), a * 0 = 0) →
(∀ (a b c : α), a * b * c = a * (b * c)) →
(one : α) →
(∀ (a : α), 1 * a = a) →
(∀ (a : α), a * 1 = a) →
(natCast : ℕ → α) →
autoParam (natCast 0 = 0) AddMonoidWithOne.natCast_zero._autoParam →
autoParam (∀ (n : ℕ), natCast (n + 1) = natCast n + 1)
AddMonoidWithOne.natCast_succ._autoParam →
(npow : ℕ → α → α) →
autoParam (∀ (x : α), npow 0 x = 1) Monoid.npow_zero._autoParam →
autoParam (∀ (n : ℕ) (x : α), npow (n + 1) x = npow n x * x)
Monoid.npow_succ._autoParam →
Semiring α |
Prod.addAction._proof_1 | Mathlib.Algebra.Group.Action.Prod | ∀ {M : Type u_3} {α : Type u_1} {β : Type u_2} [inst : AddMonoid M] [inst_1 : AddAction M α] [inst_2 : AddAction M β]
(x x_1 : M) (x_2 : α × β), (x + x_1) +ᵥ x_2 = x +ᵥ x_1 +ᵥ x_2 |
_private.Mathlib.NumberTheory.NumberField.CanonicalEmbedding.ConvexBody.0.NumberField.mixedEmbedding.convexBodyLT'_mem._simp_1_1 | Mathlib.NumberTheory.NumberField.CanonicalEmbedding.ConvexBody | ∀ {α : Type u} {β : Type v} {s : Set α} {t : Set β} {p : α × β}, (p ∈ s ×ˢ t) = (p.1 ∈ s ∧ p.2 ∈ t) |
Array.mapFinIdx_eq_mapIdx | Init.Data.Array.MapIdx | ∀ {α : Type u_1} {β : Type u_2} {xs : Array α} {f : (i : ℕ) → α → i < xs.size → β} {g : ℕ → α → β},
(∀ (i : ℕ) (h : i < xs.size), f i xs[i] h = g i xs[i]) → xs.mapFinIdx f = Array.mapIdx g xs |
DivisionMonoid.ctorIdx | Mathlib.Algebra.Group.Defs | {G : Type u} → DivisionMonoid G → ℕ |
Lean.Parser.Command.importPath.parenthesizer | Lean.Parser.Command | Lean.PrettyPrinter.Parenthesizer |
Fin.val_ofNat | Init.Data.Fin.Lemmas | ∀ (n : ℕ) [inst : NeZero n] (a : ℕ), ↑(Fin.ofNat n a) = a % n |
Lean.Language.SnapshotTree.mk.sizeOf_spec | Lean.Language.Basic | ∀ (element : Lean.Language.Snapshot) (children : Array (Lean.Language.SnapshotTask Lean.Language.SnapshotTree)),
sizeOf { element := element, children := children } = 1 + sizeOf element + sizeOf children |
Continuous.clog | Mathlib.Analysis.SpecialFunctions.Complex.Log | ∀ {α : Type u_1} [inst : TopologicalSpace α] {f : α → ℂ},
Continuous f → (∀ (x : α), f x ∈ Complex.slitPlane) → Continuous fun t => Complex.log (f t) |
HomologicalComplex.mapBifunctor₁₂.d₃_eq_zero | Mathlib.Algebra.Homology.BifunctorAssociator | ∀ {C₁ : Type u_1} {C₂ : Type u_2} {C₁₂ : Type u_3} {C₃ : Type u_5} {C₄ : Type u_6}
[inst : CategoryTheory.Category.{v_1, u_1} C₁] [inst_1 : CategoryTheory.Category.{v_2, u_2} C₂]
[inst_2 : CategoryTheory.Category.{v_3, u_5} C₃] [inst_3 : CategoryTheory.Category.{v_4, u_6} C₄]
[inst_4 : CategoryTheory.Category.{v_5, u_3} C₁₂] [inst_5 : CategoryTheory.Limits.HasZeroMorphisms C₁]
[inst_6 : CategoryTheory.Limits.HasZeroMorphisms C₂] [inst_7 : CategoryTheory.Limits.HasZeroMorphisms C₃]
[inst_8 : CategoryTheory.Preadditive C₁₂] [inst_9 : CategoryTheory.Preadditive C₄]
(F₁₂ : CategoryTheory.Functor C₁ (CategoryTheory.Functor C₂ C₁₂))
(G : CategoryTheory.Functor C₁₂ (CategoryTheory.Functor C₃ C₄)) [inst_10 : F₁₂.PreservesZeroMorphisms]
[inst_11 : ∀ (X₁ : C₁), (F₁₂.obj X₁).PreservesZeroMorphisms] [inst_12 : G.Additive]
[inst_13 : ∀ (X₁₂ : C₁₂), (G.obj X₁₂).PreservesZeroMorphisms] {ι₁ : Type u_7} {ι₂ : Type u_8} {ι₃ : Type u_9}
{ι₁₂ : Type u_10} {ι₄ : Type u_12} [inst_14 : DecidableEq ι₄] {c₁ : ComplexShape ι₁} {c₂ : ComplexShape ι₂}
{c₃ : ComplexShape ι₃} (K₁ : HomologicalComplex C₁ c₁) (K₂ : HomologicalComplex C₂ c₂) (K₃ : HomologicalComplex C₃ c₃)
(c₁₂ : ComplexShape ι₁₂) (c₄ : ComplexShape ι₄) [inst_15 : TotalComplexShape c₁ c₂ c₁₂]
[inst_16 : TotalComplexShape c₁₂ c₃ c₄] [inst_17 : K₁.HasMapBifunctor K₂ F₁₂ c₁₂] [inst_18 : DecidableEq ι₁₂]
[inst_19 : (K₁.mapBifunctor K₂ F₁₂ c₁₂).HasMapBifunctor K₃ G c₄] (i₁ : ι₁) (i₂ : ι₂) (i₃ : ι₃) (j : ι₄),
¬c₃.Rel i₃ (c₃.next i₃) → HomologicalComplex.mapBifunctor₁₂.d₃ F₁₂ G K₁ K₂ K₃ c₁₂ c₄ i₁ i₂ i₃ j = 0 |
MultilinearMap.addCommMonoid | Mathlib.LinearAlgebra.Multilinear.Basic | {R : Type uR} →
{ι : Type uι} →
{M₁ : ι → Type v₁} →
{M₂ : Type v₂} →
[inst : Semiring R] →
[inst_1 : (i : ι) → AddCommMonoid (M₁ i)] →
[inst_2 : AddCommMonoid M₂] →
[inst_3 : (i : ι) → Module R (M₁ i)] → [inst_4 : Module R M₂] → AddCommMonoid (MultilinearMap R M₁ M₂) |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.