name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M |
|---|---|---|
CategoryTheory.Abelian.extFunctorObj._proof_1 | Mathlib.Algebra.Homology.DerivedCategory.Ext.Basic | ∀ (n : ℕ), n + 0 = n |
_private.Mathlib.RingTheory.PolynomialAlgebra.0.PolyEquivTensor.left_inv._simp_1_3 | Mathlib.RingTheory.PolynomialAlgebra | ∀ {R : Type u} {A : Type w} [inst : CommSemiring R] [inst_1 : Semiring A] [inst_2 : Algebra R A] (r : R) (x : A),
(algebraMap R A) r * x = r • x |
Subgroup.toAddSubgroup._proof_2 | Mathlib.Algebra.Group.Subgroup.Lattice | ∀ {G : Type u_1} [inst : Group G] (x : AddSubgroup (Additive G)),
(fun S =>
let __src := Submonoid.toAddSubmonoid S.toSubmonoid;
{ toAddSubmonoid := __src, neg_mem' := ⋯ })
((fun S =>
let __src := AddSubmonoid.toSubmonoid S.toAddSubmonoid;
{ toSubmonoid := __src, inv_mem' := ⋯ })
x) =
x |
EuclideanGeometry.orthogonalProjection.congr_simp | Mathlib.Geometry.Euclidean.Projection | ∀ {𝕜 : Type u_1} {V : Type u_2} {P : Type u_3} [inst : RCLike 𝕜] [inst_1 : NormedAddCommGroup V]
[inst_2 : InnerProductSpace 𝕜 V] [inst_3 : MetricSpace P] [inst_4 : NormedAddTorsor V P] (s : AffineSubspace 𝕜 P)
[inst_5 : Nonempty ↥s] [inst_6 : s.direction.HasOrthogonalProjection],
EuclideanGeometry.orthogonalProjection s = EuclideanGeometry.orthogonalProjection s |
Tuple.comp_sort_eq_comp_iff_monotone | Mathlib.Data.Fin.Tuple.Sort | ∀ {n : ℕ} {α : Type u_1} [inst : LinearOrder α] {f : Fin n → α} {σ : Equiv.Perm (Fin n)},
f ∘ ⇑σ = f ∘ ⇑(Tuple.sort f) ↔ Monotone (f ∘ ⇑σ) |
Lean.Meta.Grind.Arith.Cutsat.DvdCnstrProof.cooper₁ | Lean.Meta.Tactic.Grind.Arith.Cutsat.Types | Lean.Meta.Grind.Arith.Cutsat.CooperSplit → Lean.Meta.Grind.Arith.Cutsat.DvdCnstrProof |
_private.Std.Sync.Channel.0.Std.CloseableChannel.Bounded.State.casesOn | Std.Sync.Channel | {α : Type} →
{motive : Std.CloseableChannel.Bounded.State✝ α → Sort u} →
(t : Std.CloseableChannel.Bounded.State✝¹ α) →
((producers : Std.Queue (IO.Promise Bool)) →
(consumers : Std.Queue (Std.CloseableChannel.Bounded.Consumer✝ α)) →
(capacity : ℕ) →
(buf : Vector (IO.Ref (Option α)) capacity) →
(bufCount sendIdx : ℕ) →
(hsend : sendIdx < capacity) →
(recvIdx : ℕ) →
(hrecv : recvIdx < capacity) →
(closed : Bool) →
motive
{ producers := producers, consumers := consumers, capacity := capacity, buf := buf,
bufCount := bufCount, sendIdx := sendIdx, hsend := hsend, recvIdx := recvIdx,
hrecv := hrecv, closed := closed }) →
motive t |
_private.Mathlib.Data.List.OffDiag.0.List.Nodup.offDiag._proof_1_1 | Mathlib.Data.List.OffDiag | ∀ {α : Type u_1} {l : List α},
l.Nodup → ∀ (x y : α), (List.count x l * List.count y l - if x = y then List.count x l else 0) ≤ 1 |
_private.Mathlib.Topology.MetricSpace.Infsep.0.Set.Finite.infsep._simp_1_3 | Mathlib.Topology.MetricSpace.Infsep | ∀ {α : Type u} {s : Set α} {a : α} (hs : s.Finite), (a ∈ hs.toFinset) = (a ∈ s) |
LinearMap.IsReflective.coroot._proof_1 | Mathlib.LinearAlgebra.RootSystem.OfBilinear | ∀ {R : Type u_1} {M : Type u_2} [inst : CommRing R] [inst_1 : AddCommGroup M] [inst_2 : Module R M]
(B : M →ₗ[R] M →ₗ[R] R) {x : M} (hx : B.IsReflective x) (a b : M), Exists.choose ⋯ = Exists.choose ⋯ + Exists.choose ⋯ |
CompactlySupportedContinuousMap.noConfusionType | Mathlib.Topology.ContinuousMap.CompactlySupported | Sort u →
{α : Type u_5} →
{β : Type u_6} →
[inst : TopologicalSpace α] →
[inst_1 : Zero β] →
[inst_2 : TopologicalSpace β] →
CompactlySupportedContinuousMap α β →
{α' : Type u_5} →
{β' : Type u_6} →
[inst' : TopologicalSpace α'] →
[inst'_1 : Zero β'] →
[inst'_2 : TopologicalSpace β'] → CompactlySupportedContinuousMap α' β' → Sort u |
Std.Broadcast.Sync.send | Std.Sync.Broadcast | {α : Type} → Std.Broadcast.Sync α → α → IO ℕ |
_private.Mathlib.FieldTheory.Finite.Basic.0.FiniteField.exists_root_sum_quadratic._simp_1_2 | Mathlib.FieldTheory.Finite.Basic | ∀ {α : Type u_1} {β : Type u_2} [inst : DecidableEq β] {f : α → β} {s : Finset α} {b : β},
(b ∈ Finset.image f s) = ∃ a ∈ s, f a = b |
WeierstrassCurve.Projective.add | Mathlib.AlgebraicGeometry.EllipticCurve.Projective.Point | {R : Type r} → [CommRing R] → WeierstrassCurve.Projective R → (Fin 3 → R) → (Fin 3 → R) → Fin 3 → R |
List.lex_nil | Init.Data.List.Basic | ∀ {α : Type u} {lt : α → α → Bool} [inst : BEq α] {as : List α}, as.lex [] lt = false |
Subring.unop_sup | Mathlib.Algebra.Ring.Subring.MulOpposite | ∀ {R : Type u_2} [inst : Ring R] (S₁ S₂ : Subring Rᵐᵒᵖ), (S₁ ⊔ S₂).unop = S₁.unop ⊔ S₂.unop |
_private.Lean.Elab.DeclNameGen.0.Lean.Elab.Command.NameGen.MkNameState.mk.injEq | Lean.Elab.DeclNameGen | ∀ (seen : Lean.ExprSet) (consts : Lean.NameSet) (seen_1 : Lean.ExprSet) (consts_1 : Lean.NameSet),
({ seen := seen, consts := consts } = { seen := seen_1, consts := consts_1 }) = (seen = seen_1 ∧ consts = consts_1) |
CategoryTheory.Lax.LaxTrans.recOn | Mathlib.CategoryTheory.Bicategory.NaturalTransformation.Lax | {B : Type u₁} →
[inst : CategoryTheory.Bicategory B] →
{C : Type u₂} →
[inst_1 : CategoryTheory.Bicategory C] →
{F G : CategoryTheory.LaxFunctor B C} →
{motive : CategoryTheory.Lax.LaxTrans F G → Sort u} →
(t : CategoryTheory.Lax.LaxTrans F G) →
((app : (a : B) → F.obj a ⟶ G.obj a) →
(naturality :
{a b : B} →
(f : a ⟶ b) →
CategoryTheory.CategoryStruct.comp (app a) (G.map f) ⟶
CategoryTheory.CategoryStruct.comp (F.map f) (app b)) →
(naturality_naturality :
∀ {a b : B} {f g : a ⟶ b} (η : f ⟶ g),
CategoryTheory.CategoryStruct.comp (naturality f)
(CategoryTheory.Bicategory.whiskerRight (F.map₂ η) (app b)) =
CategoryTheory.CategoryStruct.comp
(CategoryTheory.Bicategory.whiskerLeft (app a) (G.map₂ η)) (naturality g)) →
(naturality_id :
∀ (a : B),
CategoryTheory.CategoryStruct.comp
(CategoryTheory.Bicategory.whiskerLeft (app a) (G.mapId a))
(naturality (CategoryTheory.CategoryStruct.id a)) =
CategoryTheory.CategoryStruct.comp (CategoryTheory.Bicategory.rightUnitor (app a)).hom
(CategoryTheory.CategoryStruct.comp (CategoryTheory.Bicategory.leftUnitor (app a)).inv
(CategoryTheory.Bicategory.whiskerRight (F.mapId a) (app a)))) →
(naturality_comp :
∀ {a b c : B} (f : a ⟶ b) (g : b ⟶ c),
CategoryTheory.CategoryStruct.comp
(CategoryTheory.Bicategory.whiskerLeft (app a) (G.mapComp f g))
(naturality (CategoryTheory.CategoryStruct.comp f g)) =
CategoryTheory.CategoryStruct.comp
(CategoryTheory.Bicategory.associator (app a) (G.map f) (G.map g)).inv
(CategoryTheory.CategoryStruct.comp
(CategoryTheory.Bicategory.whiskerRight (naturality f) (G.map g))
(CategoryTheory.CategoryStruct.comp
(CategoryTheory.Bicategory.associator (F.map f) (app b) (G.map g)).hom
(CategoryTheory.CategoryStruct.comp
(CategoryTheory.Bicategory.whiskerLeft (F.map f) (naturality g))
(CategoryTheory.CategoryStruct.comp
(CategoryTheory.Bicategory.associator (F.map f) (F.map g) (app c)).inv
(CategoryTheory.Bicategory.whiskerRight (F.mapComp f g) (app c))))))) →
motive
{ app := app, naturality := naturality, naturality_naturality := naturality_naturality,
naturality_id := naturality_id, naturality_comp := naturality_comp }) →
motive t |
Lean.PersistentEnvExtension.noConfusionType | Lean.Environment | Sort u →
{α β σ : Type} → Lean.PersistentEnvExtension α β σ → {α' β' σ' : Type} → Lean.PersistentEnvExtension α' β' σ' → Sort u |
_private.Mathlib.Analysis.InnerProductSpace.TwoDim.0.Orientation.termω | Mathlib.Analysis.InnerProductSpace.TwoDim | Lean.ParserDescr |
CategoryTheory.unop_whiskerLeft | Mathlib.CategoryTheory.Monoidal.Opposite | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] [inst_1 : CategoryTheory.MonoidalCategory C] (X : Cᵒᵖ)
{Y Z : Cᵒᵖ} (f : Y ⟶ Z),
(CategoryTheory.MonoidalCategoryStruct.whiskerLeft X f).unop =
CategoryTheory.MonoidalCategoryStruct.whiskerLeft (Opposite.unop X) f.unop |
SetRel.IsWellFounded.eq_1 | Mathlib.Order.RelSeries | ∀ {α : Type u_1} (R : SetRel α α), R.IsWellFounded = WellFounded fun x1 x2 => (x1, x2) ∈ R |
CategoryTheory.ShortComplex.LeftHomologyMapData.zero_φK | Mathlib.Algebra.Homology.ShortComplex.LeftHomology | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
{S₁ S₂ : CategoryTheory.ShortComplex C} (h₁ : S₁.LeftHomologyData) (h₂ : S₂.LeftHomologyData),
(CategoryTheory.ShortComplex.LeftHomologyMapData.zero h₁ h₂).φK = 0 |
_private.Lean.Meta.Match.Match.0.Lean.Meta.Match.MatcherKey.mk._flat_ctor | Lean.Meta.Match.Match | Lean.Expr → Bool → Bool → Lean.Meta.Match.MatcherKey✝ |
ContinuousLinearMap.restrictScalars_smul | Mathlib.Topology.Algebra.Module.LinearMap | ∀ {A : Type u_1} {M₁ : Type u_2} {M₂ : Type u_3} {R : Type u_4} {S : Type u_5} [inst : Semiring A] [inst_1 : Semiring R]
[inst_2 : Semiring S] [inst_3 : AddCommMonoid M₁] [inst_4 : Module A M₁] [inst_5 : Module R M₁]
[inst_6 : TopologicalSpace M₁] [inst_7 : AddCommMonoid M₂] [inst_8 : Module A M₂] [inst_9 : Module R M₂]
[inst_10 : TopologicalSpace M₂] [inst_11 : LinearMap.CompatibleSMul M₁ M₂ R A] [inst_12 : Module S M₂]
[inst_13 : ContinuousConstSMul S M₂] [inst_14 : SMulCommClass A S M₂] [inst_15 : SMulCommClass R S M₂] (c : S)
(f : M₁ →L[A] M₂), ContinuousLinearMap.restrictScalars R (c • f) = c • ContinuousLinearMap.restrictScalars R f |
Lean.Elab.TerminationHints.noConfusionType | Lean.Elab.PreDefinition.TerminationHint | Sort u → Lean.Elab.TerminationHints → Lean.Elab.TerminationHints → Sort u |
instLinearOrderedCommGroupWithZeroMultiplicativeOrderDualOfLinearOrderedAddCommGroupWithTop._proof_3 | Mathlib.Algebra.Order.GroupWithZero.Canonical | ∀ {α : Type u_1} [inst : LinearOrderedAddCommGroupWithTop α] (n : ℕ) (a : Multiplicative αᵒᵈ),
DivInvMonoid.zpow (↑n.succ) a = DivInvMonoid.zpow (↑n) a * a |
MeasurableSMul.mk | Mathlib.MeasureTheory.Group.Arithmetic | ∀ {M : Type u_2} {α : Type u_3} [inst : SMul M α] [inst_1 : MeasurableSpace M] [inst_2 : MeasurableSpace α]
[toMeasurableConstSMul : MeasurableConstSMul M α],
autoParam (∀ (x : α), Measurable fun x_1 => x_1 • x) MeasurableSMul.measurable_smul_const._autoParam →
MeasurableSMul M α |
List.flatMap | Init.Prelude | {α : Type u} → {β : Type v} → (α → List β) → List α → List β |
PiNat.mem_cylinder_comm | Mathlib.Topology.MetricSpace.PiNat | ∀ {E : ℕ → Type u_1} (x y : (n : ℕ) → E n) (n : ℕ), y ∈ PiNat.cylinder x n ↔ x ∈ PiNat.cylinder y n |
CategoryTheory.Limits.instPreservesColimitsOfShapeDiscreteOfFiniteOfPreservesFiniteCoproducts | Mathlib.CategoryTheory.Limits.Preserves.Finite | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
(F : CategoryTheory.Functor C D) (J : Type u) [Finite J] [CategoryTheory.Limits.PreservesFiniteCoproducts F],
CategoryTheory.Limits.PreservesColimitsOfShape (CategoryTheory.Discrete J) F |
_private.Mathlib.MeasureTheory.Integral.RieszMarkovKakutani.Real.0.RealRMK.integral_riesz_aux._simp_1_7 | Mathlib.MeasureTheory.Integral.RieszMarkovKakutani.Real | ∀ {G : Type u_1} [inst : AddSemigroup G] (a b c : G), a + (b + c) = a + b + c |
NNRat.instContinuousSub | Mathlib.Topology.Instances.Rat | ContinuousSub ℚ≥0 |
Std.TreeMap.getKeyD_diff_of_not_mem_right | Std.Data.TreeMap.Lemmas | ∀ {α : Type u} {β : Type v} {cmp : α → α → Ordering} {t₁ t₂ : Std.TreeMap α β cmp} [Std.TransCmp cmp] {k fallback : α},
k ∉ t₂ → (t₁ \ t₂).getKeyD k fallback = t₁.getKeyD k fallback |
FinPartOrd.Iso.mk_inv | Mathlib.Order.Category.FinPartOrd | ∀ {α β : FinPartOrd} (e : ↑α.toPartOrd ≃o ↑β.toPartOrd), (FinPartOrd.Iso.mk e).inv = FinPartOrd.ofHom ↑e.symm |
Std.TreeSet.Raw.min?_insert_le_self | Std.Data.TreeSet.Raw.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} {t : Std.TreeSet.Raw α cmp} [inst : Std.TransCmp cmp] (h : t.WF) {k kmi : α},
(t.insert k).min?.get ⋯ = kmi → (cmp kmi k).isLE = true |
ContinuousMap.casesOn | Mathlib.Topology.ContinuousMap.Defs | {X : Type u_1} →
{Y : Type u_2} →
[inst : TopologicalSpace X] →
[inst_1 : TopologicalSpace Y] →
{motive : C(X, Y) → Sort u} →
(t : C(X, Y)) →
((toFun : X → Y) →
(continuous_toFun : Continuous toFun) →
motive { toFun := toFun, continuous_toFun := continuous_toFun }) →
motive t |
_private.Mathlib.Topology.Instances.RatLemmas.0.«termℚ∞» | Mathlib.Topology.Instances.RatLemmas | Lean.ParserDescr |
_private.Mathlib.RepresentationTheory.Homological.GroupHomology.Functoriality.0.groupHomology.mapCycles₁_quotientGroupMk'_epi._simp_3 | Mathlib.RepresentationTheory.Homological.GroupHomology.Functoriality | ∀ {G : Type u_1} [inst : Group G] (N : Subgroup G) [nN : N.Normal] (a : G), (↑a)⁻¹ = ↑a⁻¹ |
_private.Lean.Meta.Tactic.Grind.Internalize.0.Lean.Meta.Grind.isCongruentCheck.go._unsafe_rec | Lean.Meta.Tactic.Grind.Internalize | Lean.Expr → Lean.Expr → Lean.Meta.Grind.GoalM Bool |
EReal.neg_eq_top_iff | Mathlib.Data.EReal.Operations | ∀ {x : EReal}, -x = ⊤ ↔ x = ⊥ |
ModuleCat.CoextendScalars.obj' | Mathlib.Algebra.Category.ModuleCat.ChangeOfRings | {R : Type u₁} → {S : Type u₂} → [inst : Ring R] → [inst_1 : Ring S] → (R →+* S) → ModuleCat R → ModuleCat S |
_private.Mathlib.Tactic.Push.0.Mathlib.Tactic.Push.pushNegBuiltin._sparseCasesOn_2 | Mathlib.Tactic.Push | {motive : Lean.Expr → Sort u} →
(t : Lean.Expr) → ((fn arg : Lean.Expr) → motive (fn.app arg)) → (Nat.hasNotBit 32 t.ctorIdx → motive t) → motive t |
_private.Mathlib.Order.Filter.Germ.Basic.0.Filter.Germ.IsConstant.match_1 | Mathlib.Order.Filter.Germ.Basic | ∀ {α : Type u_2} {β : Type u_1} {l : Filter α} (f : α → β) (motive : (∃ b, f =ᶠ[l] fun x => b) → Prop)
(x : ∃ b, f =ᶠ[l] fun x => b), (∀ (b : β) (hb : f =ᶠ[l] fun x => b), motive ⋯) → motive x |
Matroid.isBasis_iff_isBasis'_subset_ground | Mathlib.Combinatorics.Matroid.Basic | ∀ {α : Type u_1} {M : Matroid α} {I X : Set α}, M.IsBasis I X ↔ M.IsBasis' I X ∧ X ⊆ M.E |
ContinuousAffineMap.coe_const | Mathlib.Topology.Algebra.ContinuousAffineMap | ∀ (R : Type u_1) {V : Type u_2} {W : Type u_3} (P : Type u_4) {Q : Type u_5} [inst : Ring R] [inst_1 : AddCommGroup V]
[inst_2 : Module R V] [inst_3 : TopologicalSpace P] [inst_4 : AddTorsor V P] [inst_5 : AddCommGroup W]
[inst_6 : Module R W] [inst_7 : TopologicalSpace Q] [inst_8 : AddTorsor W Q] (q : Q),
⇑(ContinuousAffineMap.const R P q) = Function.const P q |
Polynomial.cyclotomic.roots_eq_primitiveRoots_val | Mathlib.RingTheory.Polynomial.Cyclotomic.Roots | ∀ {R : Type u_1} [inst : CommRing R] {n : ℕ} [inst_1 : IsDomain R] [NeZero ↑n],
(Polynomial.cyclotomic n R).roots = (primitiveRoots n R).val |
Subtype.mk.hinj | Mathlib.Data.Subtype | ∀ {α : Sort u} {p : α → Prop} {val : α} {property : p val} {α_1 : Sort u} {p_1 : α_1 → Prop} {val_1 : α_1}
{property_1 : p_1 val_1}, α = α_1 → p ≍ p_1 → ⟨val, property⟩ ≍ ⟨val_1, property_1⟩ → α = α_1 ∧ p ≍ p_1 ∧ val ≍ val_1 |
_private.Mathlib.Tactic.FBinop.0.FBinopElab.AnalyzeResult.maxS?._default | Mathlib.Tactic.FBinop | Option FBinopElab.SRec |
_private.Mathlib.RingTheory.Congruence.Hom.0.RingCon.mapGen_apply_apply_of_surjective.match_1_1 | Mathlib.RingTheory.Congruence.Hom | ∀ {M : Type u_1} {N : Type u_2} [inst : NonAssocSemiring M] [inst_1 : NonAssocSemiring N] {c : RingCon M} (f : M →+* N)
{x y : M} (motive : (∃ a b, c a b ∧ f a = f x ∧ f b = f y) → Prop) (x_1 : ∃ a b, c a b ∧ f a = f x ∧ f b = f y),
(∀ (a b : M) (h₁ : c a b) (h₂ : f a = f x) (h₃ : f b = f y), motive ⋯) → motive x_1 |
Module.FaithfullyFlat.iff_exact_iff_rTensor_exact | Mathlib.RingTheory.Flat.FaithfullyFlat.Basic | ∀ (R : Type u) (M : Type v) [inst : CommRing R] [inst_1 : AddCommGroup M] [inst_2 : Module R M],
Module.FaithfullyFlat R M ↔
∀ {N1 : Type (max u v)} [inst_3 : AddCommGroup N1] [inst_4 : Module R N1] {N2 : Type (max u v)}
[inst_5 : AddCommGroup N2] [inst_6 : Module R N2] {N3 : Type (max u v)} [inst_7 : AddCommGroup N3]
[inst_8 : Module R N3] (l12 : N1 →ₗ[R] N2) (l23 : N2 →ₗ[R] N3),
Function.Exact ⇑l12 ⇑l23 ↔ Function.Exact ⇑(LinearMap.rTensor M l12) ⇑(LinearMap.rTensor M l23) |
Complex.addCommGroup._proof_11 | Mathlib.Data.Complex.Basic | ∀ (a b : ℂ), a + b = b + a |
KummerDedekind.normalizedFactorsMapEquivNormalizedFactorsMinPolyMk._proof_2 | Mathlib.NumberTheory.KummerDedekind | ∀ {R : Type u_1} [inst : CommRing R] {I : Ideal R}, I.IsMaximal → NoZeroDivisors (R ⧸ I) |
UpperSemicontinuous.inf | Mathlib.Topology.Semicontinuity.Basic | ∀ {α : Type u_4} {β : Type u_5} [inst : TopologicalSpace α] [inst_1 : LinearOrder β] {f g : α → β},
UpperSemicontinuous f → UpperSemicontinuous g → UpperSemicontinuous fun x => min (f x) (g x) |
Equiv.Perm.sigmaCongrRight_refl | Mathlib.Logic.Equiv.Defs | ∀ {α : Type u_1} {β : α → Type u_2}, (Equiv.Perm.sigmaCongrRight fun a => Equiv.refl (β a)) = Equiv.refl ((a : α) × β a) |
UInt64.toUInt32_ofNatLT | Init.Data.UInt.Lemmas | ∀ {n : ℕ} (hn : n < UInt64.size), (UInt64.ofNatLT n hn).toUInt32 = UInt32.ofNat n |
_private.Lean.Compiler.IR.FreeVars.0.Lean.IR.MaxIndex.visitExpr | Lean.Compiler.IR.FreeVars | Lean.IR.Expr → Lean.IR.MaxIndex.M Unit |
ENNReal.toNNReal_zero | Mathlib.Data.ENNReal.Basic | ENNReal.toNNReal 0 = 0 |
_private.Mathlib.LinearAlgebra.Goursat.0.Submodule.goursat._simp_1_13 | Mathlib.LinearAlgebra.Goursat | ∀ {α : Sort u} {p : α → Prop} {a1 a2 : { x // p x }}, (a1 = a2) = (↑a1 = ↑a2) |
Aesop.PhaseSpec.safe.elim | Aesop.Builder.Basic | {motive : Aesop.PhaseSpec → Sort u} →
(t : Aesop.PhaseSpec) → t.ctorIdx = 0 → ((info : Aesop.SafeRuleInfo) → motive (Aesop.PhaseSpec.safe info)) → motive t |
Std.DTreeMap.Internal.Impl.toList_map | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Std.DTreeMap.Internal.Impl α β} {γ : α → Type w}
{f : (a : α) → β a → γ a},
(Std.DTreeMap.Internal.Impl.map f t).toList = List.map (fun p => ⟨p.fst, f p.fst p.snd⟩) t.toList |
ContinuousLinearMap.ratio_le_opNorm | Mathlib.Analysis.Normed.Operator.Basic | ∀ {𝕜 : Type u_1} {𝕜₂ : Type u_2} {E : Type u_4} {F : Type u_5} [inst : SeminormedAddCommGroup E]
[inst_1 : SeminormedAddCommGroup F] [inst_2 : NontriviallyNormedField 𝕜] [inst_3 : NontriviallyNormedField 𝕜₂]
[inst_4 : NormedSpace 𝕜 E] [inst_5 : NormedSpace 𝕜₂ F] {σ₁₂ : 𝕜 →+* 𝕜₂} [RingHomIsometric σ₁₂] (f : E →SL[σ₁₂] F)
(x : E), ‖f x‖ / ‖x‖ ≤ ‖f‖ |
Aesop.LocalRuleSet.mk.noConfusion | Aesop.RuleSet | {P : Sort u} →
{toBaseRuleSet : Aesop.BaseRuleSet} →
{simpTheoremsArray : Array (Lean.Name × Lean.Meta.SimpTheorems)} →
{simpTheoremsArrayNonempty : 0 < simpTheoremsArray.size} →
{simprocsArray : Array (Lean.Name × Lean.Meta.Simprocs)} →
{simprocsArrayNonempty : 0 < simprocsArray.size} →
{localNormSimpRules : Array Aesop.LocalNormSimpRule} →
{toBaseRuleSet' : Aesop.BaseRuleSet} →
{simpTheoremsArray' : Array (Lean.Name × Lean.Meta.SimpTheorems)} →
{simpTheoremsArrayNonempty' : 0 < simpTheoremsArray'.size} →
{simprocsArray' : Array (Lean.Name × Lean.Meta.Simprocs)} →
{simprocsArrayNonempty' : 0 < simprocsArray'.size} →
{localNormSimpRules' : Array Aesop.LocalNormSimpRule} →
{ toBaseRuleSet := toBaseRuleSet, simpTheoremsArray := simpTheoremsArray,
simpTheoremsArrayNonempty := simpTheoremsArrayNonempty, simprocsArray := simprocsArray,
simprocsArrayNonempty := simprocsArrayNonempty,
localNormSimpRules := localNormSimpRules } =
{ toBaseRuleSet := toBaseRuleSet', simpTheoremsArray := simpTheoremsArray',
simpTheoremsArrayNonempty := simpTheoremsArrayNonempty',
simprocsArray := simprocsArray', simprocsArrayNonempty := simprocsArrayNonempty',
localNormSimpRules := localNormSimpRules' } →
(toBaseRuleSet = toBaseRuleSet' →
simpTheoremsArray = simpTheoremsArray' →
simprocsArray = simprocsArray' → localNormSimpRules = localNormSimpRules' → P) →
P |
Nonneg.nat_ceil_coe | Mathlib.Algebra.Order.Nonneg.Floor | ∀ {α : Type u_1} [inst : Semiring α] [inst_1 : PartialOrder α] [inst_2 : IsOrderedRing α] [inst_3 : FloorSemiring α]
(a : { r // 0 ≤ r }), ⌈↑a⌉₊ = ⌈a⌉₊ |
Std.DTreeMap.Internal.Impl.minKey?_insert!_le_minKey? | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Std.DTreeMap.Internal.Impl α β} [inst : Std.TransOrd α]
(h : t.WF) {k : α} {v : β k} {km kmi : α},
t.minKey? = some km → (Std.DTreeMap.Internal.Impl.insert! k v t).minKey?.get ⋯ = kmi → (compare kmi km).isLE = true |
Set.inclusion_inclusion | Mathlib.Data.Set.Inclusion | ∀ {α : Type u_1} {s t u : Set α} (hst : s ⊆ t) (htu : t ⊆ u) (x : ↑s),
Set.inclusion htu (Set.inclusion hst x) = Set.inclusion ⋯ x |
CategoryTheory.ShortComplex.SnakeInput.L₀'_exact | Mathlib.Algebra.Homology.ShortComplex.SnakeLemma | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Abelian C]
(S : CategoryTheory.ShortComplex.SnakeInput C), S.L₀'.Exact |
Sym.coe_equivNatSumOfFintype_apply_apply | Mathlib.Data.Finsupp.Multiset | ∀ (α : Type u_1) [inst : DecidableEq α] (n : ℕ) [inst_1 : Fintype α] (s : Sym α n) (a : α),
↑((Sym.equivNatSumOfFintype α n) s) a = Multiset.count a ↑s |
Aesop.Script.STactic.ctorIdx | Aesop.Script.Tactic | Aesop.Script.STactic → ℕ |
SemiNormedGrp.explicitCokernel | Mathlib.Analysis.Normed.Group.SemiNormedGrp.Kernels | {X Y : SemiNormedGrp} → (X ⟶ Y) → SemiNormedGrp |
Lean.Grind.Linarith.le_lt_combine_cert | Init.Grind.Ordered.Linarith | Lean.Grind.Linarith.Poly → Lean.Grind.Linarith.Poly → Lean.Grind.Linarith.Poly → Bool |
AddSubsemigroup.toSubsemigroup_closure | Mathlib.Algebra.Group.Subsemigroup.Operations | ∀ {A : Type u_5} [inst : Add A] (S : Set A),
AddSubsemigroup.toSubsemigroup (AddSubsemigroup.closure S) = Subsemigroup.closure (⇑Multiplicative.toAdd ⁻¹' S) |
Lean.Expr.containsFVar | Lean.Expr | Lean.Expr → Lean.FVarId → Bool |
Aesop.instToJsonPhaseName.toJson | Aesop.Rule.Name | Aesop.PhaseName → Lean.Json |
Std.PRange.UpwardEnumerable.Map.PreservesLT.casesOn | Init.Data.Range.Polymorphic.Map | {α : Type u_1} →
{β : Type u_2} →
[inst : Std.PRange.UpwardEnumerable α] →
[inst_1 : Std.PRange.UpwardEnumerable β] →
[inst_2 : LT α] →
[inst_3 : LT β] →
{f : Std.PRange.UpwardEnumerable.Map α β} →
{motive : f.PreservesLT → Sort u} →
(t : f.PreservesLT) → ((lt_iff : ∀ {a b : α}, a < b ↔ f.toFun a < f.toFun b) → motive ⋯) → motive t |
_private.Lean.Elab.Match.0.Lean.Elab.Term.getIndexToInclude? | Lean.Elab.Match | Lean.Expr → List ℕ → Lean.Elab.TermElabM (Option Lean.Expr) |
Std.DTreeMap.Internal.Impl.toListModel_insertMin | Std.Data.DTreeMap.Internal.WF.Lemmas | ∀ {α : Type u} {β : α → Type v} [Ord α] {k : α} {v : β k} {t : Std.DTreeMap.Internal.Impl α β} {h : t.Balanced},
(Std.DTreeMap.Internal.Impl.insertMin k v t h).impl.toListModel = ⟨k, v⟩ :: t.toListModel |
ContinuousAffineMap._sizeOf_inst | Mathlib.Topology.Algebra.ContinuousAffineMap | (R : Type u_1) →
{V : Type u_2} →
{W : Type u_3} →
(P : Type u_4) →
(Q : Type u_5) →
{inst : Ring R} →
{inst_1 : AddCommGroup V} →
{inst_2 : Module R V} →
{inst_3 : TopologicalSpace P} →
{inst_4 : AddTorsor V P} →
{inst_5 : AddCommGroup W} →
{inst_6 : Module R W} →
{inst_7 : TopologicalSpace Q} →
{inst_8 : AddTorsor W Q} →
[SizeOf R] → [SizeOf V] → [SizeOf W] → [SizeOf P] → [SizeOf Q] → SizeOf (P →ᴬ[R] Q) |
MulOpposite.instNonUnitalCommCStarAlgebra._proof_1 | Mathlib.Analysis.CStarAlgebra.Classes | ∀ {A : Type u_1} [inst : NonUnitalCommCStarAlgebra A], CompleteSpace Aᵐᵒᵖ |
FormalMultilinearSeries.ofScalars_radius_eq_inv_of_tendsto_ENNReal | Mathlib.Analysis.Analytic.OfScalars | ∀ {𝕜 : Type u_1} (E : Type u_2) [inst : NontriviallyNormedField 𝕜] [inst_1 : NormedRing E] [inst_2 : NormedAlgebra 𝕜 E]
(c : ℕ → 𝕜) [NormOneClass E] {r : ENNReal},
Filter.Tendsto (fun n => ENNReal.ofReal ‖c n.succ‖ / ENNReal.ofReal ‖c n‖) Filter.atTop (nhds r) →
(FormalMultilinearSeries.ofScalars E c).radius = r⁻¹ |
CategoryTheory.Limits.pushout.instIsIsoCodiagonalOfEpi | Mathlib.CategoryTheory.Limits.Shapes.Diagonal | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] {X Y : C} (f : X ⟶ Y)
[inst_1 : CategoryTheory.Limits.HasPushout f f] [CategoryTheory.Epi f],
CategoryTheory.IsIso (CategoryTheory.Limits.pushout.codiagonal f) |
Algebra.QuasiFiniteAt.of_isOpen_singleton_fiber | Mathlib.RingTheory.ZariskisMainTheorem | ∀ {R : Type u_1} {S : Type u_2} [inst : CommRing R] [inst_1 : CommRing S] [inst_2 : Algebra R S]
[Algebra.FiniteType R S] (q : PrimeSpectrum S), IsOpen {⟨q, ⋯⟩} → Algebra.QuasiFiniteAt R q.asIdeal |
LinearIsometryEquiv.instEquivLike._proof_1 | Mathlib.Analysis.Normed.Operator.LinearIsometry | ∀ {R : Type u_1} {R₂ : Type u_2} {E : Type u_3} {E₂ : Type u_4} [inst : Semiring R] [inst_1 : Semiring R₂]
{σ₁₂ : R →+* R₂} {σ₂₁ : R₂ →+* R} [inst_2 : RingHomInvPair σ₁₂ σ₂₁] [inst_3 : RingHomInvPair σ₂₁ σ₁₂]
[inst_4 : SeminormedAddCommGroup E] [inst_5 : SeminormedAddCommGroup E₂] [inst_6 : Module R E] [inst_7 : Module R₂ E₂]
(e : E ≃ₛₗᵢ[σ₁₂] E₂), Function.LeftInverse e.invFun (↑e.toLinearEquiv).toFun |
CategoryTheory.ShortComplex.Homotopy.sub | Mathlib.Algebra.Homology.ShortComplex.Preadditive | {C : Type u_1} →
[inst : CategoryTheory.Category.{v_1, u_1} C] →
[inst_1 : CategoryTheory.Preadditive C] →
{S₁ S₂ : CategoryTheory.ShortComplex C} →
{φ₁ φ₂ φ₃ φ₄ : S₁ ⟶ S₂} →
CategoryTheory.ShortComplex.Homotopy φ₁ φ₂ →
CategoryTheory.ShortComplex.Homotopy φ₃ φ₄ → CategoryTheory.ShortComplex.Homotopy (φ₁ - φ₃) (φ₂ - φ₄) |
Batteries.CodeAction.TacticCodeActionEntry.mk.inj | Batteries.CodeAction.Attr | ∀ {declName : Lean.Name} {tacticKinds : Array Lean.Name} {declName_1 : Lean.Name} {tacticKinds_1 : Array Lean.Name},
{ declName := declName, tacticKinds := tacticKinds } = { declName := declName_1, tacticKinds := tacticKinds_1 } →
declName = declName_1 ∧ tacticKinds = tacticKinds_1 |
Finset.min'_eq_sorted_zero | Mathlib.Data.Finset.Sort | ∀ {α : Type u_1} [inst : LinearOrder α] {s : Finset α} {h : s.Nonempty}, s.min' h = (s.sort fun a b => a ≤ b)[0] |
RingCon.coe_zsmul._simp_1 | Mathlib.RingTheory.Congruence.Defs | ∀ {R : Type u_1} [inst : AddGroup R] [inst_1 : Mul R] (c : RingCon R) (z : ℤ) (x : R), z • ↑x = ↑(z • x) |
Function.update_comp_eq_of_forall_ne' | Mathlib.Logic.Function.Basic | ∀ {α : Sort u} {β : α → Sort v} [inst : DecidableEq α] {α' : Sort u_1} (g : (a : α) → β a) {f : α' → α} {i : α}
(a : β i), (∀ (x : α'), f x ≠ i) → (fun j => Function.update g i a (f j)) = fun j => g (f j) |
Module.Finite.exists_fin_quot_equiv | Mathlib.RingTheory.Finiteness.Cardinality | ∀ (R : Type u_3) (M : Type u_4) [inst : Ring R] [inst_1 : AddCommGroup M] [inst_2 : Module R M] [Module.Finite R M],
∃ n S, Nonempty (((Fin n → R) ⧸ S) ≃ₗ[R] M) |
_private.Mathlib.CategoryTheory.Filtered.Basic.0.CategoryTheory.IsFiltered.crown₄.match_1_1 | Mathlib.CategoryTheory.Filtered.Basic | (motive : Fin 0 → Sort u_1) → (a : Fin 0) → motive a |
Lean.Lsp.TextDocumentEdit.ctorIdx | Lean.Data.Lsp.Basic | Lean.Lsp.TextDocumentEdit → ℕ |
Vector.instDecidableExistsVectorZero | Init.Data.Vector.Lemmas | {α : Type u_1} → (P : Vector α 0 → Prop) → [Decidable (P #v[])] → Decidable (∃ xs, P xs) |
AddCommGrpCat.hasColimit_of_small_quot | Mathlib.Algebra.Category.Grp.Colimits | ∀ {J : Type u} [inst : CategoryTheory.Category.{v, u} J] (F : CategoryTheory.Functor J AddCommGrpCat)
[inst_1 : DecidableEq J], Small.{w, max u w} (AddCommGrpCat.Colimits.Quot F) → CategoryTheory.Limits.HasColimit F |
_private.Mathlib.Topology.Inseparable.0.inseparable_prod._simp_1_2 | Mathlib.Topology.Inseparable | ∀ {α : Type u_1} {β : Type u_2} {f₁ f₂ : Filter α} {g₁ g₂ : Filter β} [f₁.NeBot] [g₁.NeBot],
(f₁ ×ˢ g₁ = f₂ ×ˢ g₂) = (f₁ = f₂ ∧ g₁ = g₂) |
Subsemigroup.comap_top | Mathlib.Algebra.Group.Subsemigroup.Operations | ∀ {M : Type u_1} {N : Type u_2} [inst : Mul M] [inst_1 : Mul N] (f : M →ₙ* N), Subsemigroup.comap f ⊤ = ⊤ |
MeasureTheory.SimpleFunc.instNonAssocSemiring._proof_4 | Mathlib.MeasureTheory.Function.SimpleFunc | ∀ {α : Type u_1} {β : Type u_2} [inst : MeasurableSpace α] [inst_1 : NonAssocSemiring β]
(a : MeasureTheory.SimpleFunc α β), 1 * a = a |
_private.Mathlib.RingTheory.Polynomial.Bernstein.0.bernsteinPolynomial.variance._simp_1_2 | Mathlib.RingTheory.Polynomial.Bernstein | ∀ {G : Type u_1} [inst : Semigroup G] (a b c : G), a * (b * c) = a * b * c |
normalize_eq_zero._simp_1 | Mathlib.Algebra.GCDMonoid.Basic | ∀ {α : Type u_1} [inst : CommMonoidWithZero α] [inst_1 : NormalizationMonoid α] {x : α}, (normalize x = 0) = (x = 0) |
CategoryTheory.Functor.mapCoconeWhisker_hom_hom | Mathlib.CategoryTheory.Limits.Cones | ∀ {J : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} J] {K : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} K]
{C : Type u₃} [inst_2 : CategoryTheory.Category.{v₃, u₃} C] {D : Type u₄}
[inst_3 : CategoryTheory.Category.{v₄, u₄} D] (H : CategoryTheory.Functor C D) {F : CategoryTheory.Functor J C}
{E : CategoryTheory.Functor K J} {c : CategoryTheory.Limits.Cocone F},
H.mapCoconeWhisker.hom.hom = CategoryTheory.CategoryStruct.id (H.obj c.pt) |
Polynomial.orderOf_root_cyclotomic_dvd | Mathlib.RingTheory.Polynomial.Cyclotomic.Basic | ∀ {n : ℕ} (hpos : 0 < n) {p : ℕ} [inst : Fact (Nat.Prime p)] {a : ℕ}
(hroot : (Polynomial.cyclotomic n (ZMod p)).IsRoot ((Nat.castRingHom (ZMod p)) a)),
orderOf (ZMod.unitOfCoprime a ⋯) ∣ n |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.