name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M |
|---|---|---|
Unitization.instCommSemiring._proof_4 | Mathlib.Algebra.Algebra.Unitization | ∀ {R : Type u_1} {A : Type u_2} [inst : CommSemiring R] [inst_1 : NonUnitalCommSemiring A] [inst_2 : Module R A]
(a : Unitization R A), a * 0 = 0 |
Subalgebra.frontier_spectrum | Mathlib.Analysis.Normed.Algebra.Spectrum | ∀ {𝕜 : Type u_3} {A : Type u_4} {SA : Type u_5} [inst : NormedRing A] [CompleteSpace A] [inst_2 : SetLike SA A]
[inst_3 : SubringClass SA A] [inst_4 : NormedField 𝕜] [inst_5 : NormedAlgebra 𝕜 A] [instSMulMem : SMulMemClass SA 𝕜 A]
(S : SA) [hS : IsClosed ↑S] (x : ↥S), frontier (spectrum 𝕜 x) ⊆ spectrum 𝕜 ↑x |
HahnSeries.SummableFamily.hasFiniteSupport_smul | Mathlib.RingTheory.HahnSeries.Summable | ∀ {Γ : Type u_1} {Γ' : Type u_2} {R : Type u_3} {V : Type u_4} {α : Type u_5} {β : Type u_6} [inst : PartialOrder Γ]
[inst_1 : PartialOrder Γ'] [inst_2 : AddCommMonoid V] [inst_3 : AddCommMonoid R] [inst_4 : SMulWithZero R V]
(s : HahnSeries.SummableFamily Γ R α) (t : HahnSeries.SummableFamily Γ' V β) (gh : Γ × Γ'),
Function.HasFiniteSupport fun i => (s i.1).coeff gh.1 • (t i.2).coeff gh.2 |
ProbabilityTheory.IsFiniteKernel.exists_univ_le | Mathlib.Probability.Kernel.Defs | ∀ {α : Type u_1} {β : Type u_2} {mα : MeasurableSpace α} {mβ : MeasurableSpace β} {κ : ProbabilityTheory.Kernel α β}
[self : ProbabilityTheory.IsFiniteKernel κ], ∃ C < ⊤, ∀ (a : α), (κ a) Set.univ ≤ C |
CompletelyPositiveMap.map_cstarMatrix_nonneg' | Mathlib.Analysis.CStarAlgebra.CompletelyPositiveMap | ∀ {A₁ : Type u_1} {A₂ : Type u_2} [inst : NonUnitalCStarAlgebra A₁] [inst_1 : NonUnitalCStarAlgebra A₂]
[inst_2 : PartialOrder A₁] [inst_3 : PartialOrder A₂] [inst_4 : StarOrderedRing A₁] [inst_5 : StarOrderedRing A₂]
(self : CompletelyPositiveMap A₁ A₂) (k : ℕ) (M : CStarMatrix (Fin k) (Fin k) A₁), 0 ≤ M → 0 ≤ M.map ⇑self.toLinearMap |
CategoryTheory.Functor.IsLocallyDirected.casesOn | Mathlib.CategoryTheory.LocallyDirected | {J : Type u_1} →
[inst : CategoryTheory.Category.{v_1, u_1} J] →
{F : CategoryTheory.Functor J (Type u_2)} →
{motive : F.IsLocallyDirected → Sort u} →
(t : F.IsLocallyDirected) →
((cond :
∀ {i j k : J} (fi : i ⟶ k) (fj : j ⟶ k) (xi : F.obj i) (xj : F.obj j),
F.map fi xi = F.map fj xj → ∃ l fli flj x, F.map fli x = xi ∧ F.map flj x = xj) →
motive ⋯) →
motive t |
contDiffOn_clm_apply | Mathlib.Analysis.Calculus.ContDiff.FiniteDimension | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {D : Type uD} [inst_1 : NormedAddCommGroup D]
[inst_2 : NormedSpace 𝕜 D] {E : Type uE} [inst_3 : NormedAddCommGroup E] [inst_4 : NormedSpace 𝕜 E] {F : Type uF}
[inst_5 : NormedAddCommGroup F] [inst_6 : NormedSpace 𝕜 F] {n : WithTop ℕ∞} [CompleteSpace 𝕜] {f : D → E →L[𝕜] F}
{s : Set D} [FiniteDimensional 𝕜 E], ContDiffOn 𝕜 n f s ↔ ∀ (y : E), ContDiffOn 𝕜 n (fun x => (f x) y) s |
ZMod.intCast_eq_zero_iff_even | Mathlib.Data.ZMod.Basic | ∀ {n : ℤ}, ↑n = 0 ↔ Even n |
generatePiSystem.inter | Mathlib.MeasureTheory.PiSystem | ∀ {α : Type u_1} {S : Set (Set α)} {s t : Set α},
generatePiSystem S s → generatePiSystem S t → (s ∩ t).Nonempty → generatePiSystem S (s ∩ t) |
_private.Mathlib.Computability.StateTransition.0.StateTransition.tr_eval'.match_1_1 | Mathlib.Computability.StateTransition | ∀ {σ₁ σ₂ : Type u_1} (f₁ : σ₁ → Option σ₁) (tr : σ₁ → σ₂) (a₁ : σ₁) (b₂ : σ₂)
(motive : (∃ b₁, tr b₁ = b₂ ∧ b₁ ∈ StateTransition.eval f₁ a₁) → Prop)
(x : ∃ b₁, tr b₁ = b₂ ∧ b₁ ∈ StateTransition.eval f₁ a₁),
(∀ (b₁ : σ₁) (bb : tr b₁ = b₂) (hb : b₁ ∈ StateTransition.eval f₁ a₁), motive ⋯) → motive x |
ContinuousLinearMap.mulLeftRight._proof_3 | Mathlib.Analysis.Normed.Operator.Mul | ∀ (𝕜 : Type u_1) [inst : NontriviallyNormedField 𝕜] (R : Type u_2) [inst_1 : NonUnitalSeminormedRing R]
[inst_2 : NormedSpace 𝕜 R], SMulCommClass 𝕜 𝕜 (R →L[𝕜] R) |
Std.HashMap.getKey!_filterMap | Std.Data.HashMap.Lemmas | ∀ {α : Type u} {β : Type v} {γ : Type w} {x : BEq α} {x_1 : Hashable α} {m : Std.HashMap α β} [inst : EquivBEq α]
[inst_1 : LawfulHashable α] [inst_2 : Inhabited α] {f : α → β → Option γ} {k : α},
(Std.HashMap.filterMap f m).getKey! k = ((m.getKey? k).pfilter fun x_2 h' => (f x_2 m[x_2]).isSome).get! |
Bifunctor.mapEquiv_refl_refl | Mathlib.Logic.Equiv.Functor | ∀ {α : Type u} {α' : Type v} (F : Type u → Type v → Type w) [inst : Bifunctor F] [inst_1 : LawfulBifunctor F],
Bifunctor.mapEquiv F (Equiv.refl α) (Equiv.refl α') = Equiv.refl (F α α') |
CategoryTheory.CategoryOfElements.instHasInitialElementsOfIsCorepresentable | Mathlib.CategoryTheory.Limits.Elements | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {F : CategoryTheory.Functor C (Type u_1)}
[F.IsCorepresentable], CategoryTheory.Limits.HasInitial F.Elements |
Std.TreeMap.Raw.getKey?_insert_self | Std.Data.TreeMap.Raw.Lemmas | ∀ {α : Type u} {β : Type v} {cmp : α → α → Ordering} {t : Std.TreeMap.Raw α β cmp} [Std.TransCmp cmp],
t.WF → ∀ {k : α} {v : β}, (t.insert k v).getKey? k = some k |
DistLat.mk.injEq | Mathlib.Order.Category.DistLat | ∀ (carrier : Type u_1) [str : DistribLattice carrier] (carrier_1 : Type u_1) (str_1 : DistribLattice carrier_1),
({ carrier := carrier, str := str } = { carrier := carrier_1, str := str_1 }) = (carrier = carrier_1 ∧ str ≍ str_1) |
DiffContOnCl.ball_subset_image_closedBall | Mathlib.Analysis.Complex.OpenMapping | ∀ {f : ℂ → ℂ} {z₀ : ℂ} {ε r : ℝ},
DiffContOnCl ℂ f (Metric.ball z₀ r) →
0 < r →
(∀ z ∈ Metric.sphere z₀ r, ε ≤ ‖f z - f z₀‖) →
(∃ᶠ (z : ℂ) in nhds z₀, f z ≠ f z₀) → Metric.ball (f z₀) (ε / 2) ⊆ f '' Metric.closedBall z₀ r |
PartialEquiv.disjointUnion._proof_5 | Mathlib.Logic.Equiv.PartialEquiv | ∀ {α : Type u_2} {β : Type u_1} (e e' : PartialEquiv α β), e.target.ite e.target e'.target = e.target ∪ e'.target |
NoetherNormalization.T1._proof_1 | Mathlib.RingTheory.NoetherNormalization | ∀ {n : ℕ}, NeZero (n + 1) |
_private.Mathlib.Probability.ProbabilityMassFunction.Monad.0.PMF.bindOnSupport_eq_zero_iff._simp_1_1 | Mathlib.Probability.ProbabilityMassFunction.Monad | ∀ {α : Type u_1} {f : α → ENNReal}, (∑' (i : α), f i = 0) = ∀ (i : α), f i = 0 |
Homotopy.mkCoinductiveAux₂._proof_1 | Mathlib.Algebra.Homology.Homotopy | ∀ {V : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} V] [inst_1 : CategoryTheory.Preadditive V]
{P Q : CochainComplex V ℕ} (e : P ⟶ Q) (zero : P.X 1 ⟶ Q.X 0),
e.f 0 = CategoryTheory.CategoryStruct.comp (P.d 0 1) zero →
e.f 0 =
CategoryTheory.CategoryStruct.comp 0 (HomologicalComplex.dTo Q 0) +
CategoryTheory.CategoryStruct.comp (HomologicalComplex.dFrom P 0)
(CategoryTheory.CategoryStruct.comp (HomologicalComplex.xNextIso P ⋯).hom zero) |
BitVec.toNat_intMin | Init.Data.BitVec.Lemmas | ∀ {w : ℕ}, (BitVec.intMin w).toNat = 2 ^ (w - 1) % 2 ^ w |
HMul.hMul | Init.Prelude | {α : Type u} → {β : Type v} → {γ : outParam (Type w)} → [self : HMul α β γ] → α → β → γ |
ContinuousLinearMap.smulRight.congr_simp | Mathlib.Topology.Algebra.Module.LinearMap | ∀ {M₁ : Type u_4} [inst : TopologicalSpace M₁] [inst_1 : AddCommMonoid M₁] {M₂ : Type u_6}
[inst_2 : TopologicalSpace M₂] [inst_3 : AddCommMonoid M₂] {R : Type u_9} {S : Type u_10} [inst_4 : Semiring R]
[inst_5 : Semiring S] [inst_6 : Module R M₁] [inst_7 : Module R M₂] [inst_8 : Module R S] [inst_9 : Module S M₂]
[inst_10 : IsScalarTower R S M₂] [inst_11 : TopologicalSpace S] [inst_12 : ContinuousSMul S M₂] (c c_1 : M₁ →L[R] S),
c = c_1 → ∀ (f f_1 : M₂), f = f_1 → c.smulRight f = c_1.smulRight f_1 |
Set.finset_prod_mem_finset_prod | Mathlib.Algebra.Group.Pointwise.Set.BigOperators | ∀ {ι : Type u_1} {α : Type u_2} [inst : CommMonoid α] (t : Finset ι) (f : ι → Set α) (g : ι → α),
(∀ i ∈ t, g i ∈ f i) → ∏ i ∈ t, g i ∈ ∏ i ∈ t, f i |
SimpleGraph.Walk.isHamiltonianCycle_iff_isCycle_and_length_eq | Mathlib.Combinatorics.SimpleGraph.Hamiltonian | ∀ {α : Type u_1} [inst : DecidableEq α] {G : SimpleGraph α} {a : α} {p : G.Walk a a} [inst_1 : Fintype α],
p.IsHamiltonianCycle ↔ p.IsCycle ∧ p.length = Fintype.card α |
EMetricSpace.rec | Mathlib.Topology.EMetricSpace.Defs | {α : Type u} →
{motive : EMetricSpace α → Sort u_1} →
([toPseudoEMetricSpace : PseudoEMetricSpace α] →
(eq_of_edist_eq_zero : ∀ {x y : α}, edist x y = 0 → x = y) →
motive { toPseudoEMetricSpace := toPseudoEMetricSpace, eq_of_edist_eq_zero := eq_of_edist_eq_zero }) →
(t : EMetricSpace α) → motive t |
Lean.Meta.ApplyConfig.mk.sizeOf_spec | Init.Meta.Defs | ∀ (newGoals : Lean.Meta.ApplyNewGoals) (synthAssignedInstances allowSynthFailures approx : Bool),
sizeOf
{ newGoals := newGoals, synthAssignedInstances := synthAssignedInstances,
allowSynthFailures := allowSynthFailures, approx := approx } =
1 + sizeOf newGoals + sizeOf synthAssignedInstances + sizeOf allowSynthFailures + sizeOf approx |
FiniteArchimedeanClass.mk.congr_simp | Mathlib.RingTheory.HahnSeries.Lex | ∀ {M : Type u_1} [inst : AddCommGroup M] [inst_1 : LinearOrder M] [inst_2 : IsOrderedAddMonoid M] (a a_1 : M)
(e_a : a = a_1) (h : a ≠ 0), FiniteArchimedeanClass.mk a h = FiniteArchimedeanClass.mk a_1 ⋯ |
Lean.Meta.Grind.Arith.isArithTerm | Lean.Meta.Tactic.Grind.Arith.Util | Lean.Expr → Bool |
_private.Mathlib.Data.Nat.Factors.0.Nat.mem_primeFactorsList_mul._simp_1_1 | Mathlib.Data.Nat.Factors | ∀ {a b c : Prop}, (a ∧ b ↔ a ∧ c) = (a → (b ↔ c)) |
NumberField.IsTotallyComplex.casesOn | Mathlib.NumberTheory.NumberField.InfinitePlace.TotallyRealComplex | {K : Type u_1} →
[inst : Field K] →
{motive : NumberField.IsTotallyComplex K → Sort u} →
(t : NumberField.IsTotallyComplex K) →
((isComplex : ∀ (v : NumberField.InfinitePlace K), v.IsComplex) → motive ⋯) → motive t |
minpoly.mem_range_of_degree_eq_one | Mathlib.FieldTheory.Minpoly.Basic | ∀ (A : Type u_1) {B : Type u_2} [inst : CommRing A] [inst_1 : Ring B] [inst_2 : Algebra A B] (x : B),
(minpoly A x).degree = 1 → x ∈ (algebraMap A B).range |
CategoryTheory.Pseudofunctor.mapComp_assoc_left_hom_assoc | Mathlib.CategoryTheory.Bicategory.Functor.Pseudofunctor | ∀ {B : Type u₁} [inst : CategoryTheory.Bicategory B] {C : Type u₂} [inst_1 : CategoryTheory.Bicategory C]
(F : CategoryTheory.Pseudofunctor B C) {a b c d : B} (f : a ⟶ b) (g : b ⟶ c) (h : c ⟶ d) {Z : F.obj a ⟶ F.obj d}
(h_1 : CategoryTheory.CategoryStruct.comp (CategoryTheory.CategoryStruct.comp (F.map f) (F.map g)) (F.map h) ⟶ Z),
CategoryTheory.CategoryStruct.comp (F.mapComp (CategoryTheory.CategoryStruct.comp f g) h).hom
(CategoryTheory.CategoryStruct.comp (CategoryTheory.Bicategory.whiskerRight (F.mapComp f g).hom (F.map h)) h_1) =
CategoryTheory.CategoryStruct.comp (F.map₂ (CategoryTheory.Bicategory.associator f g h).hom)
(CategoryTheory.CategoryStruct.comp (F.mapComp f (CategoryTheory.CategoryStruct.comp g h)).hom
(CategoryTheory.CategoryStruct.comp (CategoryTheory.Bicategory.whiskerLeft (F.map f) (F.mapComp g h).hom)
(CategoryTheory.CategoryStruct.comp (CategoryTheory.Bicategory.associator (F.map f) (F.map g) (F.map h)).inv
h_1))) |
Matroid.IsBase.ncard_eq_ncard_of_isBase | Mathlib.Combinatorics.Matroid.Basic | ∀ {α : Type u_1} {M : Matroid α} {B₁ B₂ : Set α}, M.IsBase B₁ → M.IsBase B₂ → B₁.ncard = B₂.ncard |
Sym2.Mem.other' | Mathlib.Data.Sym.Sym2 | {α : Type u_1} → [DecidableEq α] → {a : α} → {z : Sym2 α} → a ∈ z → α |
CategoryTheory.Functor.IsLeftKanExtension.recOn | Mathlib.CategoryTheory.Functor.KanExtension.Basic | {C : Type u_1} →
{H : Type u_3} →
{D : Type u_4} →
[inst : CategoryTheory.Category.{v_1, u_1} C] →
[inst_1 : CategoryTheory.Category.{v_3, u_3} H] →
[inst_2 : CategoryTheory.Category.{v_4, u_4} D] →
{F' : CategoryTheory.Functor D H} →
{L : CategoryTheory.Functor C D} →
{F : CategoryTheory.Functor C H} →
{α : F ⟶ L.comp F'} →
{motive : F'.IsLeftKanExtension α → Sort u} →
(t : F'.IsLeftKanExtension α) →
((nonempty_isUniversal :
Nonempty
(CategoryTheory.StructuredArrow.IsUniversal
(CategoryTheory.Functor.LeftExtension.mk F' α))) →
motive ⋯) →
motive t |
CategoryTheory.Functor.category._proof_4 | Mathlib.CategoryTheory.Functor.Category | ∀ {C : Type u_3} [inst : CategoryTheory.Category.{u_1, u_3} C] {D : Type u_4}
[inst_1 : CategoryTheory.Category.{u_2, u_4} D] {X Y : CategoryTheory.Functor C D} (f : CategoryTheory.NatTrans X Y),
f.vcomp (CategoryTheory.NatTrans.id Y) = f |
LinearEquiv.extendScalarsOfIsLocalization._proof_1 | Mathlib.RingTheory.Localization.Module | ∀ {R : Type u_4} [inst : CommSemiring R] (S : Submonoid R) (A : Type u_2) [inst_1 : CommSemiring A]
[inst_2 : Algebra R A] [inst_3 : IsLocalization S A] {M : Type u_3} {N : Type u_1} [inst_4 : AddCommMonoid M]
[inst_5 : Module R M] [inst_6 : Module A M] [inst_7 : IsScalarTower R A M] [inst_8 : AddCommMonoid N]
[inst_9 : Module R N] [inst_10 : Module A N] [inst_11 : IsScalarTower R A N] (f : M ≃ₗ[R] N),
LinearMap.extendScalarsOfIsLocalization S A ↑f ∘ₗ LinearMap.extendScalarsOfIsLocalization S A ↑f.symm = LinearMap.id |
TopologicalSpace.Clopens.mk.injEq | Mathlib.Topology.Sets.Closeds | ∀ {α : Type u_4} [inst : TopologicalSpace α] (carrier : Set α) (isClopen' : IsClopen carrier) (carrier_1 : Set α)
(isClopen'_1 : IsClopen carrier_1),
({ carrier := carrier, isClopen' := isClopen' } = { carrier := carrier_1, isClopen' := isClopen'_1 }) =
(carrier = carrier_1) |
Lean.Parser.Term.rightact._regBuiltin.Lean.Parser.Term.rightact_1 | Lean.Parser.Term | IO Unit |
Std.DTreeMap.Internal.Impl.SizedBalancedTree.mk._flat_ctor | Std.Data.DTreeMap.Internal.Operations | {α : Type u} →
{β : α → Type v} →
{lb ub : ℕ} →
(impl : Std.DTreeMap.Internal.Impl α β) →
impl.Balanced → lb ≤ impl.size → impl.size ≤ ub → Std.DTreeMap.Internal.Impl.SizedBalancedTree α β lb ub |
MonObj.mopEquiv | Mathlib.CategoryTheory.Monoidal.Opposite.Mon_ | (C : Type u_1) →
[inst : CategoryTheory.Category.{v_1, u_1} C] →
[inst_1 : CategoryTheory.MonoidalCategory C] → CategoryTheory.Mon C ≌ CategoryTheory.Mon Cᴹᵒᵖ |
_private.Mathlib.Algebra.Module.TransferInstance.0.Equiv.noZeroSMulDivisors._simp_1_1 | Mathlib.Algebra.Module.TransferInstance | ∀ {α : Sort u_1} {β : Sort u_2} (e : α ≃ β) {x : β} {y : α}, (y = e.symm x) = (e y = x) |
Array.replicate_append_replicate | Init.Data.Array.Lemmas | ∀ {n : ℕ} {α : Type u_1} {a : α} {m : ℕ}, Array.replicate n a ++ Array.replicate m a = Array.replicate (n + m) a |
_private.Mathlib.Analysis.Fourier.FourierTransformDeriv.0.VectorFourier.norm_iteratedFDeriv_fourierPowSMulRight._proof_1_5 | Mathlib.Analysis.Fourier.FourierTransformDeriv | ∀ {k : ℕ} (i : ℕ), k - i ≤ k |
Polynomial.taylor_mul | Mathlib.Algebra.Polynomial.Taylor | ∀ {R : Type u_1} [inst : CommSemiring R] (r : R) (p q : Polynomial R),
(Polynomial.taylor r) (p * q) = (Polynomial.taylor r) p * (Polynomial.taylor r) q |
_private.Mathlib.RingTheory.FiniteType.0.Algebra.FiniteType.of_surjective._simp_1_2 | Mathlib.RingTheory.FiniteType | ∀ {R : Type u} {A : Type v} {B : Type w} [inst : CommSemiring R] [inst_1 : Semiring A] [inst_2 : Algebra R A]
[inst_3 : Semiring B] [inst_4 : Algebra R B] (φ : A →ₐ[R] B) {y : B}, (y ∈ φ.range) = ∃ x, φ x = y |
Lean.Lsp.LeanDidOpenTextDocumentParams.rec | Lean.Data.Lsp.Extra | {motive : Lean.Lsp.LeanDidOpenTextDocumentParams → Sort u} →
((toDidOpenTextDocumentParams : Lean.Lsp.DidOpenTextDocumentParams) →
(dependencyBuildMode? : Option Lean.Lsp.DependencyBuildMode) →
motive
{ toDidOpenTextDocumentParams := toDidOpenTextDocumentParams,
dependencyBuildMode? := dependencyBuildMode? }) →
(t : Lean.Lsp.LeanDidOpenTextDocumentParams) → motive t |
Lean.IR.IRType.erased.sizeOf_spec | Lean.Compiler.IR.Basic | sizeOf Lean.IR.IRType.erased = 1 |
MeasureTheory.hausdorffMeasure_orthogonalProjection_le | Mathlib.MeasureTheory.Measure.Hausdorff | ∀ {𝕜 : Type u_4} {E : Type u_5} [inst : RCLike 𝕜] [inst_1 : NormedAddCommGroup E] [inst_2 : InnerProductSpace 𝕜 E]
[inst_3 : MeasurableSpace E] [inst_4 : BorelSpace E] (K : Submodule 𝕜 E) [inst_5 : K.HasOrthogonalProjection] (d : ℝ)
(s : Set E),
0 ≤ d →
(MeasureTheory.Measure.hausdorffMeasure d) (⇑K.orthogonalProjection '' s) ≤
(MeasureTheory.Measure.hausdorffMeasure d) s |
_private.Mathlib.Algebra.Homology.Additive.0.CategoryTheory.NatIso.mapHomologicalComplex._simp_1 | Mathlib.Algebra.Homology.Additive | ∀ {ι : Type u_1} {W₁ : Type u_3} {W₂ : Type u_4} [inst : CategoryTheory.Category.{v_2, u_3} W₁]
[inst_1 : CategoryTheory.Category.{v_3, u_4} W₂] [inst_2 : CategoryTheory.Limits.HasZeroMorphisms W₁]
[inst_3 : CategoryTheory.Limits.HasZeroMorphisms W₂] (c : ComplexShape ι) {F G H : CategoryTheory.Functor W₁ W₂}
[inst_4 : F.PreservesZeroMorphisms] [inst_5 : G.PreservesZeroMorphisms] [inst_6 : H.PreservesZeroMorphisms]
(α : F ⟶ G) (β : G ⟶ H),
CategoryTheory.CategoryStruct.comp (CategoryTheory.NatTrans.mapHomologicalComplex α c)
(CategoryTheory.NatTrans.mapHomologicalComplex β c) =
CategoryTheory.NatTrans.mapHomologicalComplex (CategoryTheory.CategoryStruct.comp α β) c |
_private.Mathlib.RingTheory.Polynomial.Cyclotomic.Basic.0.Polynomial.coprime_of_root_cyclotomic._simp_1_2 | Mathlib.RingTheory.Polynomial.Cyclotomic.Basic | ∀ {α : Type u_2} [inst : Zero α] [inst_1 : One α] [NeZero 1], (1 = 0) = False |
Lean.Elab.Info.ofPartialTermInfo.elim | Lean.Elab.InfoTree.Types | {motive : Lean.Elab.Info → Sort u} →
(t : Lean.Elab.Info) →
t.ctorIdx = 2 → ((i : Lean.Elab.PartialTermInfo) → motive (Lean.Elab.Info.ofPartialTermInfo i)) → motive t |
_private.Mathlib.AlgebraicGeometry.Cover.QuasiCompact.0.AlgebraicGeometry.QuasiCompactCover.instPullback₁Scheme._simp_2 | Mathlib.AlgebraicGeometry.Cover.QuasiCompact | ∀ {α : Type u} {ι : Sort v} {x : α} {s : ι → Set α}, (x ∈ ⋃ i, s i) = ∃ i, x ∈ s i |
OrderIso.dualAntisymmetrization._proof_2 | Mathlib.Order.Antisymmetrization | ∀ (α : Type u_1) [inst : Preorder α] (a : α),
Quotient.map' id ⋯ (Quotient.map' id ⋯ (Quotient.mk'' a)) = Quotient.mk'' a |
_private.Mathlib.Tactic.Algebraize.0.Lean.Attr.algebraizeGetParam.match_1 | Mathlib.Tactic.Algebraize | (motive : Lean.Name → Sort u_1) →
(thm : Lean.Name) → ((t : String) → motive (`RingHom.str t)) → ((x : Lean.Name) → motive x) → motive thm |
_private.Mathlib.CategoryTheory.CommSq.0.CategoryTheory.CommSq.LiftStruct.ext.match_1 | Mathlib.CategoryTheory.CommSq | ∀ {C : Type u_2} {inst : CategoryTheory.Category.{u_1, u_2} C} {A B X Y : C} {f : A ⟶ X} {i : A ⟶ B} {p : X ⟶ Y}
{g : B ⟶ Y} {sq : CategoryTheory.CommSq f i p g} (motive : sq.LiftStruct → Prop) (h : sq.LiftStruct),
(∀ (l : B ⟶ X)
(fac_left :
autoParam (CategoryTheory.CategoryStruct.comp i l = f) CategoryTheory.CommSq.LiftStruct.fac_left._autoParam)
(fac_right :
autoParam (CategoryTheory.CategoryStruct.comp l p = g) CategoryTheory.CommSq.LiftStruct.fac_right._autoParam),
motive { l := l, fac_left := fac_left, fac_right := fac_right }) →
motive h |
ProbabilityTheory.iCondIndepSet | Mathlib.Probability.Independence.Conditional | {Ω : Type u_1} →
{ι : Type u_2} →
(m' : MeasurableSpace Ω) →
{mΩ : MeasurableSpace Ω} →
[StandardBorelSpace Ω] →
m' ≤ mΩ →
(ι → Set Ω) →
(μ : autoParam (MeasureTheory.Measure Ω) ProbabilityTheory.iCondIndepSet._auto_1) →
[MeasureTheory.IsFiniteMeasure μ] → Prop |
Quot.lift₂._proof_1 | Mathlib.Data.Quot | ∀ {α : Sort u_3} {β : Sort u_1} {γ : Sort u_2} {r : α → α → Prop} {s : β → β → Prop} (f : α → β → γ)
(hr : ∀ (a : α) (b₁ b₂ : β), s b₁ b₂ → f a b₁ = f a b₂),
(∀ (a₁ a₂ : α) (b : β), r a₁ a₂ → f a₁ b = f a₂ b) → ∀ (a₁ a₂ : α), r a₁ a₂ → Quot.lift (f a₁) ⋯ = Quot.lift (f a₂) ⋯ |
IdemSemiring.ofSemiring | Mathlib.Algebra.Order.Kleene | {α : Type u_1} → [inst : Semiring α] → (∀ (a : α), a + a = a) → IdemSemiring α |
Mathlib.Tactic.Says.says.verify | Mathlib.Tactic.Says | Lean.Option Bool |
_private.Mathlib.Data.List.Permutation.0.List.count_permutations'Aux_self._simp_1_2 | Mathlib.Data.List.Permutation | ∀ {α : Type u_1} {β : Type u_2} {b : β} {f : α → β} {l : List α}, (b ∈ List.map f l) = ∃ a ∈ l, f a = b |
CategoryTheory.Adjunction.CoreHomEquivUnitCounit.mk.inj | Mathlib.CategoryTheory.Adjunction.Basic | ∀ {C : Type u₁} {inst : CategoryTheory.Category.{v₁, u₁} C} {D : Type u₂} {inst_1 : CategoryTheory.Category.{v₂, u₂} D}
{F : CategoryTheory.Functor C D} {G : CategoryTheory.Functor D C}
{homEquiv : (X : C) → (Y : D) → (F.obj X ⟶ Y) ≃ (X ⟶ G.obj Y)} {unit : CategoryTheory.Functor.id C ⟶ F.comp G}
{counit : G.comp F ⟶ CategoryTheory.Functor.id D}
{homEquiv_unit :
autoParam
(∀ {X : C} {Y : D} {f : F.obj X ⟶ Y},
(homEquiv X Y) f = CategoryTheory.CategoryStruct.comp (unit.app X) (G.map f))
CategoryTheory.Adjunction.CoreHomEquivUnitCounit.homEquiv_unit._autoParam}
{homEquiv_counit :
autoParam
(∀ {X : C} {Y : D} {g : X ⟶ G.obj Y},
(homEquiv X Y).symm g = CategoryTheory.CategoryStruct.comp (F.map g) (counit.app Y))
CategoryTheory.Adjunction.CoreHomEquivUnitCounit.homEquiv_counit._autoParam}
{homEquiv_1 : (X : C) → (Y : D) → (F.obj X ⟶ Y) ≃ (X ⟶ G.obj Y)} {unit_1 : CategoryTheory.Functor.id C ⟶ F.comp G}
{counit_1 : G.comp F ⟶ CategoryTheory.Functor.id D}
{homEquiv_unit_1 :
autoParam
(∀ {X : C} {Y : D} {f : F.obj X ⟶ Y},
(homEquiv_1 X Y) f = CategoryTheory.CategoryStruct.comp (unit_1.app X) (G.map f))
CategoryTheory.Adjunction.CoreHomEquivUnitCounit.homEquiv_unit._autoParam}
{homEquiv_counit_1 :
autoParam
(∀ {X : C} {Y : D} {g : X ⟶ G.obj Y},
(homEquiv_1 X Y).symm g = CategoryTheory.CategoryStruct.comp (F.map g) (counit_1.app Y))
CategoryTheory.Adjunction.CoreHomEquivUnitCounit.homEquiv_counit._autoParam},
{ homEquiv := homEquiv, unit := unit, counit := counit, homEquiv_unit := homEquiv_unit,
homEquiv_counit := homEquiv_counit } =
{ homEquiv := homEquiv_1, unit := unit_1, counit := counit_1, homEquiv_unit := homEquiv_unit_1,
homEquiv_counit := homEquiv_counit_1 } →
homEquiv = homEquiv_1 ∧ unit = unit_1 ∧ counit = counit_1 |
List.snd_idxToSigmaCount._proof_2 | Batteries.Data.List.Count | ∀ {α : Type u_1} [inst : BEq α] [inst_1 : ReflBEq α] {xs : List α} {i : Fin xs.length},
List.countBefore xs[↑i] xs ↑i < List.count (xs.idxToSigmaCount i).fst xs |
_private.Lean.Data.RArray.0.Lean.RArray.ofFn.go._unary._proof_1 | Lean.Data.RArray | ∀ {n : ℕ},
WellFounded
(invImage
(fun x =>
PSigma.casesOn x fun lb ub => PSigma.casesOn ub fun ub h1 => PSigma.casesOn h1 fun h1 h2 => (ub, ub - lb))
Prod.instWellFoundedRelation).1 |
MonoidHom.mker | Mathlib.Algebra.Group.Submonoid.Operations | {M : Type u_1} →
{N : Type u_2} →
[inst : MulOneClass M] →
[inst_1 : MulOneClass N] →
{F : Type u_4} → [inst_2 : FunLike F M N] → [mc : MonoidHomClass F M N] → F → Submonoid M |
Multiset.decidableExistsMultiset._proof_1 | Mathlib.Data.Multiset.Defs | ∀ {α : Type u_1} {p : α → Prop} (l : List α), (∃ a ∈ l, p a) ↔ ∃ x ∈ ⟦l⟧, p x |
_private.Std.Data.DHashMap.Internal.AssocList.Lemmas.0.List.filterMap.match_1.eq_2 | Std.Data.DHashMap.Internal.AssocList.Lemmas | ∀ {β : Type u_1} (motive : Option β → Sort u_2) (b : β) (h_1 : Unit → motive none) (h_2 : (b : β) → motive (some b)),
(match some b with
| none => h_1 ()
| some b => h_2 b) =
h_2 b |
TwoSidedIdeal.equivMatrix.congr_simp | Mathlib.LinearAlgebra.Matrix.Ideal | ∀ {R : Type u_1} {n : Type u_2} [inst : NonAssocRing R] [inst_1 : Fintype n] [inst_2 : Nonempty n]
[inst_3 : DecidableEq n], TwoSidedIdeal.equivMatrix = TwoSidedIdeal.equivMatrix |
_private.Std.Data.Internal.List.Associative.0.Std.Internal.List.length_alterKey._simp_1_4 | Std.Data.Internal.List.Associative | ∀ {α : Type u} {β : α → Type v} [inst : BEq α] [inst_1 : LawfulBEq α] {l : List ((a : α) × β a)} {a : α}
(h : Std.Internal.List.containsKey a l = true),
some (Std.Internal.List.getValueCast a l h) = Std.Internal.List.getValueCast? a l |
LinearIndependent.fintypeLinearCombination_injective | Mathlib.LinearAlgebra.LinearIndependent.Defs | ∀ {ι : Type u'} {R : Type u_2} {M : Type u_4} {v : ι → M} [inst : Semiring R] [inst_1 : AddCommMonoid M]
[inst_2 : Module R M] [inst_3 : Fintype ι],
LinearIndependent R v → Function.Injective ⇑(Fintype.linearCombination R v) |
instAlgebraCliffordAlgebra | Mathlib.LinearAlgebra.CliffordAlgebra.Basic | {R : Type u_1} →
[inst : CommRing R] →
{M : Type u_2} →
[inst_1 : AddCommGroup M] → [inst_2 : Module R M] → (Q : QuadraticForm R M) → Algebra R (CliffordAlgebra Q) |
Lean.SubExpr.Pos.fromString? | Lean.SubExpr | String → Except String Lean.SubExpr.Pos |
LinearEquiv.piRing.eq_1 | Mathlib.LinearAlgebra.Pi | ∀ (R : Type u) (M : Type v) (ι : Type x) [inst : Semiring R] (S : Type u_4) [inst_1 : Fintype ι]
[inst_2 : 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],
LinearEquiv.piRing R M ι S =
(LinearMap.lsum R (fun x => R) S).symm ≪≫ₗ LinearEquiv.piCongrRight fun x => LinearMap.ringLmapEquivSelf R S M |
_private.Mathlib.RepresentationTheory.FiniteIndex.0.Rep.coindToInd_of_support_subset_orbit._simp_1_2 | Mathlib.RepresentationTheory.FiniteIndex | ∀ {α : Sort u_1} {r : Setoid α} {x y : α}, (⟦x⟧ = ⟦y⟧) = r x y |
LieModule.isNilpotent_of_top_iff._simp_1 | Mathlib.Algebra.Lie.Nilpotent | ∀ {R : Type u} {L : Type v} {M : Type w} [inst : CommRing R] [inst_1 : LieRing L] [inst_2 : LieAlgebra R L]
[inst_3 : AddCommGroup M] [inst_4 : Module R M] [inst_5 : LieRingModule L M] [LieModule R L M],
LieModule.IsNilpotent (↥⊤) M = LieModule.IsNilpotent L M |
CategoryTheory.Monoidal.CommMonFunctorCategoryEquivalence.unitIso | Mathlib.CategoryTheory.Monoidal.Internal.FunctorCategory | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
{D : Type u₂} →
[inst_1 : CategoryTheory.Category.{v₂, u₂} D] →
[inst_2 : CategoryTheory.MonoidalCategory D] →
[inst_3 : CategoryTheory.BraidedCategory D] →
CategoryTheory.Functor.id (CategoryTheory.CommMon (CategoryTheory.Functor C D)) ≅
CategoryTheory.Monoidal.CommMonFunctorCategoryEquivalence.functor.comp
CategoryTheory.Monoidal.CommMonFunctorCategoryEquivalence.inverse |
«_aux_Mathlib_Algebra_Lie_Basic___macroRules_term_→ₗ⁅_⁆__1» | Mathlib.Algebra.Lie.Basic | Lean.Macro |
_private.Lean.Meta.Tactic.Simp.Rewrite.0.Lean.Meta.Simp.tryTheoremCore.match_1 | Lean.Meta.Tactic.Simp.Rewrite | (motive : Option Lean.Meta.Simp.Result → Sort u_1) →
(__do_lift : Option Lean.Meta.Simp.Result) →
(Unit → motive none) → ((r : Lean.Meta.Simp.Result) → motive (some r)) → motive __do_lift |
SymmetricPower.«_aux_Mathlib_LinearAlgebra_TensorPower_Symmetric___delab_app_SymmetricPower_term⨂ₛ[_]_,__1» | Mathlib.LinearAlgebra.TensorPower.Symmetric | Lean.PrettyPrinter.Delaborator.Delab |
CategoryTheory.Sieve.giGenerate._proof_1 | Mathlib.CategoryTheory.Sites.Sieves | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] {X : C} (x : CategoryTheory.Sieve X) (x_1 : C)
(x_2 : x_1 ⟶ X), x.arrows x_2 → ∃ Y h g, x.arrows g ∧ CategoryTheory.CategoryStruct.comp h g = x_2 |
GromovHausdorff.auxGluing._proof_5 | Mathlib.Topology.MetricSpace.GromovHausdorff | ∀ (X : ℕ → Type) [inst : (n : ℕ) → MetricSpace (X n)] [inst_1 : ∀ (n : ℕ), CompactSpace (X n)]
[inst_2 : ∀ (n : ℕ), Nonempty (X n)] (n : ℕ) (Y : GromovHausdorff.AuxGluingStruct (X n)),
Isometry (Metric.toGlueR ⋯ ⋯ ∘ GromovHausdorff.optimalGHInjr (X n) (X (n + 1))) |
_private.Std.Data.DTreeMap.Internal.Operations.0.Std.DTreeMap.Internal.Impl.maxView._proof_8 | Std.Data.DTreeMap.Internal.Operations | ∀ {α : Type u_1} {β : α → Type u_2} (l : Std.DTreeMap.Internal.Impl α β) (size : ℕ) (k' : α) (v' : β k')
(l' r' : Std.DTreeMap.Internal.Impl α β),
(Std.DTreeMap.Internal.Impl.inner size k' v' l' r').Balanced →
Std.DTreeMap.Internal.Impl.BalancedAtRoot l.size (Std.DTreeMap.Internal.Impl.inner size k' v' l' r').size →
∀ (dt : Std.DTreeMap.Internal.Impl α β),
dt.size = l'.size + r'.size → Std.DTreeMap.Internal.Impl.BalanceLErasePrecond l.size dt.size |
Circle.exp_eq_exp | Mathlib.Analysis.SpecialFunctions.Complex.Circle | ∀ {x y : ℝ}, Circle.exp x = Circle.exp y ↔ ∃ m, x = y + ↑m * (2 * Real.pi) |
NumberField.mixedEmbedding.fundamentalCone.idealSetEquiv._proof_4 | Mathlib.NumberTheory.NumberField.CanonicalEmbedding.FundamentalCone | ∀ (K : Type u_1) [inst : Field K] [inst_1 : NumberField K]
(J : ↥(nonZeroDivisors (Ideal (NumberField.RingOfIntegers K))))
(x x_1 : ↑(NumberField.mixedEmbedding.fundamentalCone.idealSet K J)),
(fun a => ⟨NumberField.mixedEmbedding.fundamentalCone.idealSetMap K J a, ⋯⟩) x =
(fun a => ⟨NumberField.mixedEmbedding.fundamentalCone.idealSetMap K J a, ⋯⟩) x_1 →
x = x_1 |
CategoryTheory.isProjective | Mathlib.CategoryTheory.Preadditive.Projective.Basic | (C : Type u) → [inst : CategoryTheory.Category.{v, u} C] → CategoryTheory.ObjectProperty C |
_private.Mathlib.Algebra.Group.Fin.Basic.0.Fin.le_sub_one_iff._simp_1_1 | Mathlib.Algebra.Group.Fin.Basic | ∀ {n : ℕ} {a b : Fin n}, (a ≤ b) = (↑a ≤ ↑b) |
Valuation.ideal_isPrincipal | Mathlib.RingTheory.Valuation.Discrete.Basic | ∀ {Γ : Type u_1} [inst : LinearOrderedCommGroupWithZero Γ] {K : Type u_2} [inst_1 : Field K] (v : Valuation K Γ)
[IsCyclic ↥(MonoidWithZeroHom.valueGroup v)] [Nontrivial ↥(MonoidWithZeroHom.valueGroup v)]
(I : Ideal ↥v.valuationSubring), Submodule.IsPrincipal I |
Prod.instOrderTop | Mathlib.Order.BoundedOrder.Basic | (α : Type u) → (β : Type v) → [inst : LE α] → [inst_1 : LE β] → [OrderTop α] → [OrderTop β] → OrderTop (α × β) |
_private.Mathlib.Algebra.Category.Grp.EpiMono.0.GrpCat.SurjectiveOfEpiAuxs._aux_Mathlib_Algebra_Category_Grp_EpiMono___macroRules__private_Mathlib_Algebra_Category_Grp_EpiMono_0_GrpCat_SurjectiveOfEpiAuxs_termSX'_1 | Mathlib.Algebra.Category.Grp.EpiMono | Lean.Macro |
_private.Mathlib.Analysis.Calculus.ContDiff.Convolution.0.MeasureTheory.hasFDerivAt_convolution_right_with_param._simp_1_9 | Mathlib.Analysis.Calculus.ContDiff.Convolution | ∀ {α : Sort u_1} {p : α → Prop} {a' : α}, (∃ a, p a ∧ a = a') = p a' |
Equiv.swap_eq_refl_iff | Mathlib.Logic.Equiv.Basic | ∀ {α : Sort u_1} [inst : DecidableEq α] {x y : α}, Equiv.swap x y = Equiv.refl α ↔ x = y |
MulAction.block_stabilizerOrderIso.match_3 | Mathlib.GroupTheory.GroupAction.Blocks | (G : Type u_1) →
[inst : Group G] →
{X : Type u_2} →
[inst_1 : MulAction G X] →
(a : X) →
(motive : ↑(Set.Ici (MulAction.stabilizer G a)) → Sort u_3) →
(x : ↑(Set.Ici (MulAction.stabilizer G a))) →
((H : Subgroup G) → (hH : H ∈ Set.Ici (MulAction.stabilizer G a)) → motive ⟨H, hH⟩) → motive x |
CategoryTheory.Functor.PushoutObjObj.ofHasPushout_ι | Mathlib.CategoryTheory.Limits.Shapes.Pullback.PullbackObjObj | ∀ {C₁ : Type u₁} {C₂ : Type u₂} {C₃ : Type u₃} [inst : CategoryTheory.Category.{v₁, u₁} C₁]
[inst_1 : CategoryTheory.Category.{v₂, u₂} C₂] [inst_2 : CategoryTheory.Category.{v₃, u₃} C₃]
{F : CategoryTheory.Functor C₁ (CategoryTheory.Functor C₂ C₃)} {X₁ Y₁ : C₁} {f₁ : X₁ ⟶ Y₁} {X₂ Y₂ : C₂} {f₂ : X₂ ⟶ Y₂}
[inst_3 : CategoryTheory.Limits.HasPushout ((F.map f₁).app X₂) ((F.obj X₁).map f₂)],
(CategoryTheory.Functor.PushoutObjObj.ofHasPushout F f₁ f₂).ι =
CategoryTheory.Limits.pushout.desc ((F.obj Y₁).map f₂) ((F.map f₁).app Y₂) ⋯ |
Units.le_of_inv_mul_le_one | Mathlib.Algebra.Order.Monoid.Unbundled.Units | ∀ {M : Type u_1} [inst : Monoid M] [inst_1 : LE M] [MulLeftMono M] (u : Mˣ) {a : M}, ↑u⁻¹ * a ≤ 1 → a ≤ ↑u |
_private.Batteries.Data.MLList.Basic.0.MLList.MLListImpl.nil | Batteries.Data.MLList.Basic | {m : Type u → Type u} → {α : Type u} → MLList.MLListImpl✝ m α |
Mathlib.Tactic.Order.ToInt.toInt_sup_toInt_eq_toInt | Mathlib.Tactic.Order.ToInt | ∀ {α : Type u_1} [inst : LinearOrder α] {n : ℕ} (val : Fin n → α) (i j k : Fin n),
max (Mathlib.Tactic.Order.ToInt.toInt val i) (Mathlib.Tactic.Order.ToInt.toInt val j) =
Mathlib.Tactic.Order.ToInt.toInt val k ↔
max (val i) (val j) = val k |
Lean.Compiler.LCNF.FindUsed.State.mk.sizeOf_spec | Lean.Compiler.LCNF.ReduceArity | ∀ (used : Lean.FVarIdHashSet), sizeOf { used := used } = 1 + sizeOf used |
Tropical.untrop_injective | Mathlib.Algebra.Tropical.Basic | ∀ {R : Type u}, Function.Injective Tropical.untrop |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.