name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
HahnSeries.embDomainRingHom._proof_4 | Mathlib.RingTheory.HahnSeries.Multiplication | ∀ {Γ : Type u_1} {R : Type u_2} [inst : AddCommMonoid Γ] [inst_1 : PartialOrder Γ] {Γ' : Type u_3}
[inst_2 : AddCommMonoid Γ'] [inst_3 : PartialOrder Γ'] [inst_4 : NonAssocSemiring R] (f : Γ →+ Γ')
(hfi : Function.Injective ⇑f) (hf : ∀ (g g' : Γ), f g ≤ f g' ↔ g ≤ g') (x y : HahnSeries Γ R),
HahnSeries.embDomain ... | null | false |
_private.Mathlib.Order.Prod.Lex.Basic.0.Prod.Lex.toLex_covBy_toLex_iff._simp_1_3 | Mathlib.Order.Prod.Lex.Basic | ∀ {α : Type u_1} {β : Type u_2} {p : α × β → Prop}, (∀ (x : α × β), p x) = ∀ (a : α) (b : β), p (a, b) | null | false |
CategoryTheory.rightAdjointMate_comp | Mathlib.CategoryTheory.Monoidal.Rigid.Basic | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] [inst_1 : CategoryTheory.MonoidalCategory C] {X Y Z : C}
[inst_2 : CategoryTheory.HasRightDual X] [inst_3 : CategoryTheory.HasRightDual Y] {f : X ⟶ Y} {g : Xᘁ ⟶ Z},
CategoryTheory.CategoryStruct.comp (fᘁ) g =
CategoryTheory.CategoryStruct.comp (Categor... | null | true |
_private.Mathlib.CategoryTheory.WithTerminal.Basic.0.CategoryTheory.WithTerminal.opEquiv.match_15.eq_2 | Mathlib.CategoryTheory.WithTerminal.Basic | ∀ (C : Type u_1) (motive : CategoryTheory.WithInitial Cᵒᵖ → Sort u_2)
(h_1 : (x : Cᵒᵖ) → motive (CategoryTheory.WithInitial.of x)) (h_2 : Unit → motive CategoryTheory.WithInitial.star),
(match CategoryTheory.WithInitial.star with
| CategoryTheory.WithInitial.of x => h_1 x
| CategoryTheory.WithInitial.star =... | null | true |
InformationTheory.wrapped._@.Mathlib.InformationTheory.KullbackLeibler.Basic.3734523477._hygCtx._hyg.8 | Mathlib.InformationTheory.KullbackLeibler.Basic | Subtype (Eq @InformationTheory.definition✝) | null | false |
Std.ExtDTreeMap.getKey?_filterMap | Std.Data.ExtDTreeMap.Lemmas | ∀ {α : Type u} {β : α → Type v} {cmp : α → α → Ordering} {t : Std.ExtDTreeMap α β cmp} {γ : α → Type w}
[inst : Std.TransCmp cmp] [inst_1 : Std.LawfulEqCmp cmp] {f : (a : α) → β a → Option (γ a)} {k : α},
(Std.ExtDTreeMap.filterMap f t).getKey? k = (t.getKey? k).pfilter fun x h' => (f x (t.get x ⋯)).isSome | null | true |
withTheReader.eq_1 | Std.Do.Triple.SpecLemmas | ∀ (ρ : Type u) {m : Type u → Type v} [inst : MonadWithReaderOf ρ m] {α : Type u} (f : ρ → ρ) (x : m α),
withTheReader ρ f x = MonadWithReaderOf.withReader f x | null | true |
CategoryTheory.Functor.RightExtension.isUniversalEquivOfIso₂._proof_2 | Mathlib.CategoryTheory.Functor.KanExtension.Basic | ∀ {C : Type u_1} {H : Type u_3} {D : Type u_5} [inst : CategoryTheory.Category.{u_4, u_1} C]
[inst_1 : CategoryTheory.Category.{u_2, u_3} H] [inst_2 : CategoryTheory.Category.{u_6, u_5} D]
{L : CategoryTheory.Functor C D} {F₁ F₂ : CategoryTheory.Functor C H} (α₁ : L.RightExtension F₁)
(α₂ : L.RightExtension F₂) (... | null | false |
_private.Mathlib.Order.Directed.0.Directed.mono.match_1_1 | Mathlib.Order.Directed | ∀ {α : Type u_2} {r : α → α → Prop} {ι : Sort u_1} {f : ι → α} (a b : ι)
(motive : (∃ z, r (f a) (f z) ∧ r (f b) (f z)) → Prop) (x : ∃ z, r (f a) (f z) ∧ r (f b) (f z)),
(∀ (c : ι) (h₁ : r (f a) (f c)) (h₂ : r (f b) (f c)), motive ⋯) → motive x | null | false |
_private.Lean.Meta.Tactic.Grind.Main.0.Lean.Meta.Grind.resolveDelayedMVarAssignments | Lean.Meta.Tactic.Grind.Main | Lean.Expr → Lean.MetaM Lean.Expr | Resolves delayed metavariable assignments created inside the current `withNewMCtxDepth` block.
`instantiateMVars` only resolves a delayed assignment `?m #[xs] := ?pending` when `?pending`'s
assignment is ground (no unassigned expression metavariables). This ground restriction exists
because `val` may contain metavariab... | true |
Function.bUnion_ptsOfPeriod | Mathlib.Dynamics.PeriodicPts.Defs | ∀ {α : Type u_1} (f : α → α), ⋃ n, ⋃ (_ : n > 0), Function.ptsOfPeriod f n = Function.periodicPts f | null | true |
Std.WP.Except.instWPMonad._proof_1 | Std.WP.Monad.Instances | ∀ {ε : Type u_1} {α β : Type u_2} (x : Except ε α) (f : α → Except ε β) (post : β → Prop) (epost : ε → Prop),
Lean.Order.PartialOrder.rel (Std.WP.wp x (fun a => Std.WP.wp (f a) post epost) epost) (Std.WP.wp (x >>= f) post epost) | null | false |
Lean.Meta.ExtractLetsConfig._sizeOf_inst | Init.MetaTypes | SizeOf Lean.Meta.ExtractLetsConfig | null | false |
ProbabilityTheory.cgf_undef | Mathlib.Probability.Moments.Basic | ∀ {Ω : Type u_1} {m : MeasurableSpace Ω} {X : Ω → ℝ} {μ : MeasureTheory.Measure Ω} {t : ℝ},
¬MeasureTheory.Integrable (fun ω => Real.exp (t * X ω)) μ → ProbabilityTheory.cgf X μ t = 0 | null | true |
SimpleGraph.IsEdgeReachable.of_subsingleton | Mathlib.Combinatorics.SimpleGraph.Connectivity.EdgeConnectivity | ∀ {V : Type u_1} {G : SimpleGraph V} {k : ℕ∞} {u v : V} [Subsingleton V], G.IsEdgeReachable k u v | null | true |
SemidirectProduct.equivProd_symm_apply_left | Mathlib.GroupTheory.SemidirectProduct | ∀ {N : Type u_1} {G : Type u_2} [inst : Group N] [inst_1 : Group G] {φ : G →* MulAut N} (x : N × G),
(SemidirectProduct.equivProd.symm x).left = x.1 | null | true |
Turing.TM2to1.trNormal.eq_3 | Mathlib.Computability.TuringMachine.StackTuringMachine | ∀ {K : Type u_1} {Γ : K → Type u_2} {Λ : Type u_3} {σ : Type u_4} (k : K) (a : σ → Option (Γ k) → σ)
(q : Turing.TM2.Stmt Γ Λ σ),
Turing.TM2to1.trNormal (Turing.TM2.Stmt.pop k a q) =
Turing.TM1.Stmt.goto fun x x_1 => Turing.TM2to1.Λ'.go k (Turing.TM2to1.StAct.pop a) q | null | true |
Aesop.Check.mk | Aesop.Check | Lean.Option Bool → Aesop.Check | null | true |
herglotzRieszKernel_def | Mathlib.Analysis.Complex.Poisson | ∀ (c w z : ℂ), herglotzRieszKernel c w z = (z - c + (w - c)) / (z - c - (w - c)) | null | true |
CategoryTheory.ChosenPullbacksAlong.pullbackCone_snd | Mathlib.CategoryTheory.LocallyCartesianClosed.ChosenPullbacksAlong | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {Y Z X : C} (f : Y ⟶ X) (g : Z ⟶ X)
[inst_1 : CategoryTheory.ChosenPullbacksAlong g],
(CategoryTheory.ChosenPullbacksAlong.pullbackCone f g).snd = CategoryTheory.ChosenPullbacksAlong.snd f g | null | true |
FunLike.divisionMonoid._proof_2 | Mathlib.Algebra.Group.FunLike | ∀ {F : Type u_3} {α : Type u_1} {β : Type u_2} [inst : FunLike F α β] [inst_1 : Mul F] [inst_2 : DivisionMonoid β]
[IsMulApply F α β] (f g : F), ⇑(f * g) = ⇑f * ⇑g | null | false |
Float.Model.UnpackedFloat.compare.match_1.congr_eq_11 | Batteries.Data.Float.Lemmas | ∀ (motive : Float.Model.UnpackedFloat → Float.Model.UnpackedFloat → Sort u_1) (x x_1 : Float.Model.UnpackedFloat)
(h_1 : (x : Float.Model.UnpackedFloat) → motive Float.Model.UnpackedFloat.notANumber x)
(h_2 : (x : Float.Model.UnpackedFloat) → motive x Float.Model.UnpackedFloat.notANumber)
(h_3 :
(s₁ s₂ : Floa... | null | true |
UInt32.toUSize_lt | Init.Data.UInt.Lemmas | ∀ {a b : UInt32}, a.toUSize < b.toUSize ↔ a < b | null | true |
AddSubgroup.even._proof_1 | Mathlib.Algebra.Group.Subgroup.Even | ∀ (G : Type u_1) [inst : AddCommGroup G] {x : G}, Even x → Even (-x) | null | false |
_private.Mathlib.Analysis.SpecialFunctions.Pow.NNReal.0.NNReal.rpow_pos._simp_1_1 | Mathlib.Analysis.SpecialFunctions.Pow.NNReal | ∀ {α : Type u_1} [inst : Zero α] [inst_1 : One α] [inst_2 : PartialOrder α] [ZeroLEOneClass α] [NeZero 1],
(0 < 1) = True | null | false |
IntermediateField.restrictScalars_toSubfield | 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'] [inst_5 : Algebra L' L] [inst_6 : IsScalarTower K L' L]
{E : IntermediateField L' L}, (IntermediateField.restrictScalars K E).toSubfield = E.toSubfield | null | true |
Fin.finsetImage_natAdd_Ioc | Mathlib.Order.Interval.Finset.Fin | ∀ {n : ℕ} (m : ℕ) (i j : Fin n),
Finset.image (Fin.natAdd m) (Finset.Ioc i j) = Finset.Ioc (Fin.natAdd m i) (Fin.natAdd m j) | null | true |
_private.Aesop.Frontend.Command.0.Aesop.Frontend.Parser.initFn._@.Aesop.Frontend.Command.470559899._hygCtx._hyg.2 | Aesop.Frontend.Command | IO Unit | null | false |
MeasureTheory.VectorMeasure.setIntegral_const | Mathlib.MeasureTheory.VectorMeasure.SetIntegral | ∀ {X : Type u_2} {E : Type u_3} {F : Type u_4} {G : Type u_5} {mX : MeasurableSpace X} [inst : NormedAddCommGroup E]
[inst_1 : NormedAddCommGroup F] [inst_2 : NormedAddCommGroup G] {μ : MeasureTheory.VectorMeasure X F} {s : Set X}
[inst_3 : NormedSpace ℝ E] [inst_4 : NormedSpace ℝ F] [inst_5 : NormedSpace ℝ G] {B :... | null | true |
CommHopfAlgCat._sizeOf_1 | Mathlib.Algebra.Category.CommHopfAlgCat | {R : Type u} → {inst : CommRing R} → [SizeOf R] → CommHopfAlgCat R → ℕ | null | false |
_private.Mathlib.RingTheory.AlgebraicIndependent.TranscendenceBasis.0.AlgebraicIndependent.matroid_closure_eq._simp_1_8 | Mathlib.RingTheory.AlgebraicIndependent.TranscendenceBasis | ∀ {R : Type u_1} {A : Type w} [inst : CommRing R] [inst_1 : CommRing A] [inst_2 : Algebra R A]
[inst_3 : FaithfulSMul R A] [inst_4 : IsDomain A] {s t : Set A},
(AlgebraicIndependent.matroid R A).IsBasis s t =
(AlgebraicIndepOn R id s ∧ s ⊆ t ∧ ∀ a ∈ t, IsAlgebraic (↥(Algebra.adjoin R s)) a) | null | false |
Perfection.teichmullerAux.congr_simp | Mathlib.RingTheory.Teichmuller | ∀ {p : ℕ} [inst : Fact (Nat.Prime p)] {R : Type u_1} [inst_1 : CommRing R] {I : Ideal R} [inst_2 : CharP (R ⧸ I) p]
(x x_1 : Perfection (R ⧸ I) p), x = x_1 → ∀ (a a_1 : ℕ), a = a_1 → x.teichmullerAux a = x_1.teichmullerAux a_1 | null | true |
Lean.Meta.coerceCollectingNames? | Lean.Meta.Coe | Lean.Expr → Lean.Expr → Lean.MetaM (Lean.LOption (Lean.Expr × List Lean.Name)) | Coerces `expr` to the type `expectedType`.
Returns `.some (coerced, appliedCoeDecls)` on successful coercion,
`.none` if the expression cannot by coerced to that type,
or `.undef` if we need more metavariable assignments.
`appliedCoeDecls` is a list of names representing the names of the `Coe` instances that were
appl... | true |
MulOpposite.instMonoid._proof_5 | Mathlib.Algebra.Group.Opposite | ∀ {α : Type u_1} [inst : Monoid α] (x : ℕ) (x_1 : αᵐᵒᵖ), x_1 ^ (x + 1) = x_1 ^ x * x_1 | null | false |
AlgebraicIndependent.mvPolynomialOptionEquivPolynomialAdjoin.congr_simp | Mathlib.RingTheory.AlgebraicIndependent.Basic | ∀ {ι : Type u} {R : Type u_2} {A : Type v} {x : ι → A} [inst : CommRing R] [inst_1 : CommRing A] [inst_2 : Algebra R A]
(hx : AlgebraicIndependent R x),
hx.mvPolynomialOptionEquivPolynomialAdjoin = hx.mvPolynomialOptionEquivPolynomialAdjoin | null | true |
SSet.prodStdSimplex.pairingCore.IsType₂.strictMono_φ | Mathlib.AlgebraicTopology.SimplicialSet.AnodyneExtensions.UnionProd | ∀ {m : ℕ} {k : Fin (m + 1)} {n : ℕ} {x : ((SSet.horn (m + 1) k.castSucc).unionProd (SSet.boundary n)).N},
SSet.prodStdSimplex.pairingCore.IsType₂ x →
∀ {d : ℕ} (hd : x.dim = d), StrictMono (SSet.prodStdSimplex.pairingCore.IsType₂.φ x hd) | null | true |
BoundedContinuousFunction.instNSMul._proof_2 | Mathlib.Topology.ContinuousMap.Bounded.Basic | ∀ {α : Type u_1} {R : Type u_2} [inst : TopologicalSpace α] [inst_1 : PseudoMetricSpace R] [inst_2 : AddMonoid R]
[ContinuousAdd R] (f : BoundedContinuousFunction α R) (n : ℕ), Continuous (n • ⇑f) | null | false |
_private.Mathlib.GroupTheory.FiniteAbelian.Duality.0.CommGroup.mem_subgroupOrderIsoSubgroupMonoidHom_symm_iff._simp_1_3 | Mathlib.GroupTheory.FiniteAbelian.Duality | ∀ {G : Type u_1} [inst : Group G] {N : Type u_4} [inst_1 : Group N] {f : G ≃* N} {K : Subgroup G} {x : N},
(x ∈ Subgroup.map f.toMonoidHom K) = (f.symm x ∈ K) | null | false |
MeasureTheory.OuterMeasure.exists_measurable_superset_forall_eq_trim | Mathlib.MeasureTheory.OuterMeasure.Induced | ∀ {α : Type u_1} [inst : MeasurableSpace α] {ι : Sort u_2} [Countable ι] (μ : ι → MeasureTheory.OuterMeasure α)
(s : Set α), ∃ t, s ⊆ t ∧ MeasurableSet t ∧ ∀ (i : ι), (μ i) t = (μ i).trim s | If `μ i` is a countable family of outer measures, then for every set `s` there exists
a measurable set `t ⊇ s` such that `μ i t = (μ i).trim s` for all `i`. | true |
UpperSet.commSemigroup.eq_1 | Mathlib.Algebra.Order.UpperLower | ∀ {α : Type u_1} [inst : CommGroup α] [inst_1 : Preorder α] [inst_2 : IsOrderedMonoid α],
UpperSet.commSemigroup = Function.Injective.commSemigroup SetLike.coe ⋯ ⋯ | null | true |
Set.pow_mem_pow | Mathlib.Algebra.Group.Pointwise.Set.Basic | ∀ {α : Type u_2} [inst : Monoid α] {s : Set α} {a : α} {n : ℕ}, a ∈ s → a ^ n ∈ s ^ n | null | true |
_private.Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.ShiftLeft.0.Std.Tactic.BVDecide.BVExpr.bitblast.blastShiftLeftConst._proof_7 | Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.ShiftLeft | ∀ {w : ℕ}, ∀ curr ≤ w, ¬curr < w → ¬curr = w → False | null | false |
MeasureTheory.VectorMeasure.Integrable.finsetSum_vectorMeasure | Mathlib.MeasureTheory.VectorMeasure.Integral | ∀ {X : Type u_2} {E : Type u_4} {F : Type u_5} {mX : MeasurableSpace X} [inst : NormedAddCommGroup E]
[inst_1 : NormedAddCommGroup F] {f : X → E} {ι : Type u_7} {μ : ι → MeasureTheory.VectorMeasure X F} {s : Finset ι},
(∀ i ∈ s, (μ i).Integrable f) → (∑ i ∈ s, μ i).Integrable f | null | true |
LieAlgebra.SemiDirectSum.mk._flat_ctor | Mathlib.Algebra.Lie.SemiDirect | {R : Type u_1} →
[inst : CommRing R] →
{K : Type u_2} →
[inst_1 : LieRing K] →
[inst_2 : LieAlgebra R K] →
{L : Type u_3} →
[inst_3 : LieRing L] → [inst_4 : LieAlgebra R L] → {x : L →ₗ⁅R⁆ LieDerivation R K K} → K → L → K ⋊⁅x⁆ L | null | false |
String.Internal.next | Init.Data.String.Bootstrap | String → String.Pos.Raw → String.Pos.Raw | null | true |
CategoryTheory.TwoSquare.guitartExact_id' | Mathlib.CategoryTheory.GuitartExact.Opposite | ∀ {C₁ : Type u₁} {C₂ : Type u₂} [inst : CategoryTheory.Category.{v₁, u₁} C₁]
[inst_1 : CategoryTheory.Category.{v₂, u₂} C₂] (F : CategoryTheory.Functor C₁ C₂),
(CategoryTheory.TwoSquare.mk F (CategoryTheory.Functor.id C₁) (CategoryTheory.Functor.id C₂) F
(CategoryTheory.CategoryStruct.id F)).GuitartExact | null | true |
CategoryTheory.regularTopology.equalizerCondition_iff_of_equivalence | Mathlib.CategoryTheory.Sites.Coherent.RegularSheaves | ∀ {C : Type u_1} {D : Type u_2} {E : Type u_3} [inst : CategoryTheory.Category.{v_1, u_1} C]
[inst_1 : CategoryTheory.Category.{v_2, u_2} D] [inst_2 : CategoryTheory.Category.{v_3, u_3} E]
(P : CategoryTheory.Functor Cᵒᵖ D) (e : C ≌ E),
CategoryTheory.regularTopology.EqualizerCondition P ↔
CategoryTheory.regu... | `P` satisfies the equalizer condition iff its precomposition by an equivalence does. | true |
IsNoetherian.finsetBasisIndex | Mathlib.FieldTheory.Finiteness | (K : Type u) →
(V : Type v) →
[inst : DivisionRing K] → [inst_1 : AddCommGroup V] → [inst_2 : Module K V] → [IsNoetherian K V] → Finset V | In a Noetherian module over a division ring,
there exists a finite basis. This is the indexing `Finset`. | true |
AddSemiconjBy.neg_symm_left_iff._simp_1 | Mathlib.Algebra.Group.Semiconj.Basic | ∀ {G : Type u_1} [inst : AddGroup G] {a x y : G}, AddSemiconjBy (-a) y x = AddSemiconjBy a x y | null | false |
CategoryTheory.Coyoneda.colimitCoconeIsColimit._proof_2 | Mathlib.CategoryTheory.Limits.Yoneda | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] (X : Cᵒᵖ)
(s : CategoryTheory.Limits.Cocone (CategoryTheory.coyoneda.obj X))
(m : (CategoryTheory.Coyoneda.colimitCocone X).pt ⟶ s.pt),
(∀ (j : C), CategoryTheory.CategoryStruct.comp ((CategoryTheory.Coyoneda.colimitCocone X).ι.app j) m = s.ι.app j) →... | null | false |
Std.DTreeMap.Raw.maxKeyD_insertIfNew | Std.Data.DTreeMap.Raw.Lemmas | ∀ {α : Type u} {β : α → Type v} {cmp : α → α → Ordering} {t : Std.DTreeMap.Raw α β cmp} [Std.TransCmp cmp],
t.WF →
∀ {k : α} {v : β k} {fallback : α},
(t.insertIfNew k v).maxKeyD fallback = t.maxKey?.elim k fun k' => if cmp k' k = Ordering.lt then k else k' | null | true |
CategoryTheory.CartesianMonoidalCategory.mk | Mathlib.CategoryTheory.Monoidal.Cartesian.Basic | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
[toSemiCartesianMonoidalCategory : CategoryTheory.SemiCartesianMonoidalCategory C] →
((X Y : C) →
CategoryTheory.Limits.IsLimit
(CategoryTheory.Limits.BinaryFan.mk (CategoryTheory.SemiCartesianMonoidalCategory.fst X Y)
... | null | true |
Module.Basis.ofIsCoprimeDifferentIdeal._proof_10 | Mathlib.RingTheory.DedekindDomain.LinearDisjoint | ∀ (A : Type u_3) {K : Type u_4} {L : Type u_2} [inst : CommRing A] [inst_1 : Field K] [inst_2 : Field L]
[inst_3 : Algebra K L] (R₂ : Type u_1) [inst_4 : CommRing R₂] [inst_5 : Algebra A R₂] [Module.Finite A R₂]
{F₂ : IntermediateField K L} [inst_7 : Algebra R₂ ↥F₂] [IsDomain A] [IsDedekindDomain R₂] [IsFractionRin... | null | false |
AlgHom.liftOfSurjective._proof_2 | Mathlib.RingTheory.Ideal.Quotient.Operations | ∀ {R : Type u_3} {A : Type u_1} {B : Type u_2} [inst : CommRing R] [inst_1 : CommRing A] [inst_2 : CommRing B]
[inst_3 : Algebra R A] [inst_4 : Algebra R B] (f : A →ₐ[R] B), (RingHom.ker f.toRingHom).IsTwoSided | null | false |
Std.HashMap.Equiv.filterMap | Std.Data.HashMap.Lemmas | ∀ {α : Type u} {β : Type v} {γ : Type w} {x : BEq α} {x_1 : Hashable α} {m₁ m₂ : Std.HashMap α β}
(f : α → β → Option γ), m₁.Equiv m₂ → (Std.HashMap.filterMap f m₁).Equiv (Std.HashMap.filterMap f m₂) | null | true |
CategoryTheory.CartesianMonoidalCategory.lift_leftUnitor_hom | Mathlib.CategoryTheory.Monoidal.Cartesian.Basic | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.CartesianMonoidalCategory C] {X Y : C}
(f : X ⟶ CategoryTheory.MonoidalCategoryStruct.tensorUnit C) (g : X ⟶ Y),
CategoryTheory.CategoryStruct.comp (CategoryTheory.CartesianMonoidalCategory.lift f g)
(CategoryTheory.MonoidalCate... | null | true |
Array.find?_isSome | Init.Data.Array.Find | ∀ {α : Type u_1} {xs : Array α} {p : α → Bool}, (Array.find? p xs).isSome = true ↔ ∃ x ∈ xs, p x = true | null | true |
Std.LawfulEqCmp.opposite | Init.Data.Order.Ord | ∀ {α : Type u} {cmp : α → α → Ordering} [Std.OrientedCmp cmp] [Std.LawfulEqCmp cmp], Std.LawfulEqCmp fun a b => cmp b a | null | true |
FreeAbelianGroup.ring._proof_4 | Mathlib.GroupTheory.FreeAbelianGroup | ∀ (α : Type u_1) [inst : Monoid α] (n : ℕ) (x : FreeAbelianGroup α), x ^ (n + 1) = x ^ n * x | null | false |
_private.Std.Sat.AIG.RelabelNat.0.Std.Sat.AIG.RelabelNat.State.ofAIGAux.go.match_1.splitter | Std.Sat.AIG.RelabelNat | {α : Type} →
(motive : Std.Sat.AIG.Decl α → Sort u_1) →
(decl : Std.Sat.AIG.Decl α) →
((a : α) → decl = Std.Sat.AIG.Decl.atom a → motive (Std.Sat.AIG.Decl.atom a)) →
(decl = Std.Sat.AIG.Decl.false → motive Std.Sat.AIG.Decl.false) →
((lhs rhs : Std.Sat.AIG.Fanin) →
decl = Std.... | null | true |
_private.Init.Data.Range.Polymorphic.Internal.SignedBitVec.0.BitVec.Signed.instRxcLawfulHasSize._proof_3 | Init.Data.Range.Polymorphic.Internal.SignedBitVec | ∀ (n : ℕ), ¬n + 1 > 0 → False | null | false |
mem_openSegment_iff_div | Mathlib.Analysis.Convex.Segment | ∀ {𝕜 : Type u_1} {E : Type u_2} [inst : Semifield 𝕜] [inst_1 : LinearOrder 𝕜] [IsStrictOrderedRing 𝕜]
[inst_3 : AddCommGroup E] [inst_4 : Module 𝕜 E] {x y z : E},
x ∈ openSegment 𝕜 y z ↔ ∃ a b, 0 < a ∧ 0 < b ∧ (a / (a + b)) • y + (b / (a + b)) • z = x | null | true |
CategoryTheory.SemiCartesianMonoidalCategory.comp_toUnit_assoc | Mathlib.CategoryTheory.Monoidal.Cartesian.Basic | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.SemiCartesianMonoidalCategory C]
{X Y : C} (f : X ⟶ Y) {Z : C} (h : CategoryTheory.MonoidalCategoryStruct.tensorUnit C ⟶ Z),
CategoryTheory.CategoryStruct.comp f
(CategoryTheory.CategoryStruct.comp (CategoryTheory.SemiCartesianM... | null | true |
IsPurelyInseparable.iterateFrobenius._proof_4 | Mathlib.FieldTheory.PurelyInseparable.Exponent | ∀ (K : Type u_1) (L : Type u_2) [inst : Field K] [inst_1 : Field L] [inst_2 : Algebra K L]
[inst_3 : IsPurelyInseparable.HasExponent K L] (p : ℕ) [ExpChar K p] {n : ℕ},
IsPurelyInseparable.exponent K L ≤ n →
∀ (a b : L),
IsPurelyInseparable.iterateFrobeniusAux✝ K L p n (a + b) =
IsPurelyInseparabl... | null | false |
_private.Mathlib.Order.Nucleus.0.Nucleus.giAux._proof_2 | Mathlib.Order.Nucleus | ∀ {X : Type u_1} [inst : Order.Frame X] (n : Nucleus X) (x : X) (y : ↑(Set.range ⇑n)),
n.toClosureOperator x ≤ ↑y ↔ x ≤ ↑y | null | false |
Lean.Expr.FoldConstsImpl.State.rec | Lean.Util.FoldConsts | {motive : Lean.Expr.FoldConstsImpl.State → Sort u} →
((visited : Lean.PtrSet Lean.Expr) →
(visitedConsts : Lean.NameHashSet) → motive { visited := visited, visitedConsts := visitedConsts }) →
(t : Lean.Expr.FoldConstsImpl.State) → motive t | null | false |
Odd.neg | Mathlib.Algebra.Ring.Parity | ∀ {α : Type u_2} [inst : Ring α] {a : α}, Odd a → Odd (-a) | null | true |
KaehlerDifferential.fromIdeal_surjective | Mathlib.RingTheory.Kaehler.Basic | ∀ (R : Type u) (S : Type v) [inst : CommRing R] [inst_1 : CommRing S] [inst_2 : Algebra R S],
Function.Surjective ⇑(KaehlerDifferential.fromIdeal R S) | null | true |
ByteArray.append_left_inj._simp_1 | Init.Data.ByteArray.Lemmas | ∀ {xs₁ xs₂ : ByteArray} (ys : ByteArray), (xs₁ ++ ys = xs₂ ++ ys) = (xs₁ = xs₂) | null | false |
_private.Mathlib.Algebra.Module.LinearMap.End.0.Module.End.iterate_bijective.match_1_1 | Mathlib.Algebra.Module.LinearMap.End | ∀ (motive : ℕ → Prop) (x : ℕ), (∀ (_ : Unit), motive 0) → (∀ (n : ℕ), motive n.succ) → motive x | null | false |
List.next_eq_getElem._proof_2 | Mathlib.Data.List.Cycle | ∀ {α : Type u_1} {l : List α} {a : α}, a ∈ l → 0 < l.length | null | false |
_private.Mathlib.Combinatorics.Additive.ApproximateSubgroup.0.IsApproximateSubgroup.pow_inter_pow._proof_1_2 | Mathlib.Combinatorics.Additive.ApproximateSubgroup | ∀ {m : ℕ}, 2 ≤ m → 2 ≤ 2 * m | null | false |
AlgebraicGeometry.SheafedSpace.ext._proof_1 | Mathlib.Geometry.RingedSpace.SheafedSpace | ∀ {C : Type u_3} [inst : CategoryTheory.Category.{u_2, u_3} C] {X Y : AlgebraicGeometry.SheafedSpace C} (α β : X ⟶ Y),
α.hom.base = β.hom.base → (TopologicalSpace.Opens.map α.hom.base).op = (TopologicalSpace.Opens.map β.hom.base).op | null | false |
IsLocalDiffeomorphAt.mfderivToContinuousLinearEquiv | Mathlib.Geometry.Manifold.LocalDiffeomorph | {𝕜 : Type u_1} →
[inst : NontriviallyNormedField 𝕜] →
{E : Type u_2} →
[inst_1 : NormedAddCommGroup E] →
[inst_2 : NormedSpace 𝕜 E] →
{F : Type u_3} →
[inst_3 : NormedAddCommGroup F] →
[inst_4 : NormedSpace 𝕜 F] →
{H₁ : Type u_5} →
... | If `f` is a `C^n` local diffeomorphism at `x`, for `n ≠ 0`, the differential `df_x`
is a linear equivalence. | true |
exists_linearIndepOn_id_extension | Mathlib.LinearAlgebra.LinearIndependent.Lemmas | ∀ {K : Type u_3} {V : Type u} [inst : DivisionRing K] [inst_1 : AddCommGroup V] [inst_2 : Module K V] {s t : Set V},
LinearIndepOn K id s → s ⊆ t → ∃ b ⊆ t, s ⊆ b ∧ t ⊆ ↑(Submodule.span K b) ∧ LinearIndepOn K id b | null | true |
OrderRingIso.instInhabited | Mathlib.Algebra.Order.Hom.Ring | (α : Type u_2) → [inst : Mul α] → [inst_1 : Add α] → [inst_2 : LE α] → Inhabited (α ≃+*o α) | null | true |
Matrix.isSymm_fromBlocks_iff | Mathlib.LinearAlgebra.Matrix.Symmetric | ∀ {α : Type u_1} {n : Type u_3} {m : Type u_4} {A : Matrix m m α} {B : Matrix m n α} {C : Matrix n m α}
{D : Matrix n n α}, (Matrix.fromBlocks A B C D).IsSymm ↔ A.IsSymm ∧ B.transpose = C ∧ C.transpose = B ∧ D.IsSymm | This is the `iff` version of `Matrix.isSymm.fromBlocks`. | true |
Std.Sat.AIG.RefVec.fold.go._unary | Std.Sat.AIG.RefVecOperator.Fold | {α : Type} →
[inst : Hashable α] →
[inst_1 : DecidableEq α] →
(len : ℕ) →
(f : (aig : Std.Sat.AIG α) → aig.BinaryInput → Std.Sat.AIG.Entrypoint α) →
[Std.Sat.AIG.LawfulOperator α Std.Sat.AIG.BinaryInput f] →
(aig : Std.Sat.AIG α) ×' (_ : aig.Ref) ×' (_ : ℕ) ×' aig.RefVec len → ... | null | false |
IsProperMap.clusterPt_of_mapClusterPt | Mathlib.Topology.Maps.Proper.Basic | ∀ {X : Type u_1} {Y : Type u_2} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y] {f : X → Y},
IsProperMap f → ∀ ⦃ℱ : Filter X⦄ ⦃y : Y⦄, MapClusterPt y ℱ f → ∃ x, f x = y ∧ ClusterPt x ℱ | By definition, if `f` is a proper map and `ℱ` is any filter on `X`, then any cluster point of
`map f ℱ` is the image by `f` of some cluster point of `ℱ`. | true |
StarOrderedRing.toExistsAddOfLE | Mathlib.Algebra.Order.Star.Basic | ∀ {R : Type u_1} [inst : NonUnitalSemiring R] [inst_1 : PartialOrder R] [inst_2 : StarRing R] [StarOrderedRing R],
ExistsAddOfLE R | null | true |
Std.HashSet.Raw.not_mem_emptyWithCapacity._simp_1 | Std.Data.HashSet.RawLemmas | ∀ {α : Type u} [inst : BEq α] [inst_1 : Hashable α] {a : α} {c : ℕ}, (a ∈ Std.HashSet.Raw.emptyWithCapacity c) = False | null | false |
CategoryTheory.Limits.coneOfDiagramInitial | Mathlib.CategoryTheory.Limits.Shapes.IsTerminal | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
{J : Type u} →
[inst_1 : CategoryTheory.Category.{v, u} J] →
{X : J} → CategoryTheory.Limits.IsInitial X → (F : CategoryTheory.Functor J C) → CategoryTheory.Limits.Cone F | From a functor `F : J ⥤ C`, given an initial object of `J`, construct a cone for `J`.
In `limitOfDiagramInitial` we show it is a limit cone. | true |
_private.Init.Data.String.Lemmas.Pattern.Basic.0.String.Slice.Pattern.Model.IsLongestMatch.sliceTo._simp_1_2 | Init.Data.String.Lemmas.Pattern.Basic | ∀ {s : String.Slice} {p₀ : s.Pos} {p : (s.sliceTo p₀).Pos} {q : s.Pos} {h : q ≤ p₀},
(p₀.sliceTo q h < p) = (q < String.Slice.Pos.ofSliceTo p) | null | false |
CategoryTheory.Presheaf.coherentExtensiveEquivalence | Mathlib.CategoryTheory.Sites.Coherent.SheafComparison | {C : Type u_1} →
[inst : CategoryTheory.Category.{v_1, u_1} C] →
{A : Type u₃} →
[inst_1 : CategoryTheory.Category.{v₃, u₃} A] →
[inst_2 : CategoryTheory.Preregular C] →
[inst_3 : CategoryTheory.FinitaryExtensive C] →
[∀ (X : C), CategoryTheory.Projective X] →
Cat... | The categories of coherent sheaves and extensive sheaves on `C` are equivalent if `C` is
preregular, finitary extensive, and every object is projective.
| true |
DomMulAct.instInvOneClassOfMulOpposite.eq_1 | Mathlib.GroupTheory.GroupAction.DomAct.Basic | ∀ {M : Type u_1} [inst : InvOneClass Mᵐᵒᵖ], DomMulAct.instInvOneClassOfMulOpposite = inst | null | true |
ValuativeRel.instSemiringWithPreorder._aux_8 | Mathlib.RingTheory.Valuation.ValuativeRel.Basic | {R : Type u_1} → [Semiring R] → NSMul (ValuativeRel.WithPreorder R) | null | false |
CategoryTheory.InjectiveResolution.descIdHomotopy._proof_1 | Mathlib.CategoryTheory.Abelian.Injective.Resolution | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.Abelian C] (X : C)
(I : CategoryTheory.InjectiveResolution X),
CategoryTheory.CategoryStruct.comp I.ι
(CategoryTheory.InjectiveResolution.desc (CategoryTheory.CategoryStruct.id X) I I) =
CategoryTheory.CategoryStruct.c... | null | false |
OpenAddSubgroup.comap | Mathlib.Topology.Algebra.OpenSubgroup | {G : Type u_1} →
[inst : AddGroup G] →
[inst_1 : TopologicalSpace G] →
{N : Type u_2} →
[inst_2 : AddGroup N] →
[inst_3 : TopologicalSpace N] → (f : G →+ N) → Continuous ⇑f → OpenAddSubgroup N → OpenAddSubgroup G | The preimage of an `OpenAddSubgroup` along a continuous `AddMonoid` homomorphism
is an `OpenAddSubgroup`. | true |
Finsupp.comapDistribMulAction._proof_1 | Mathlib.Data.Finsupp.SMul | ∀ {α : Type u_1} {M : Type u_2} {G : Type u_3} [inst : Monoid G] [inst_1 : MulAction G α] [inst_2 : AddCommMonoid M]
(g : G), g • 0 = 0 | null | false |
Matrix.permMatrix_mem_colStochastic | Mathlib.LinearAlgebra.Matrix.Stochastic | ∀ {R : Type u_1} {n : Type u_2} [inst : Fintype n] [inst_1 : DecidableEq n] [inst_2 : Semiring R]
[inst_3 : PartialOrder R] [inst_4 : IsOrderedRing R] {σ : Equiv.Perm n},
Equiv.Perm.permMatrix R σ ∈ Matrix.colStochastic R n | Any permutation matrix is column stochastic. | true |
StarAlgHom.ext_iff | Mathlib.Algebra.Star.StarAlgHom | ∀ {R : Type u_2} {A : Type u_3} {B : Type u_4} [inst : CommSemiring R] [inst_1 : Semiring A] [inst_2 : Algebra R A]
[inst_3 : Star A] [inst_4 : Semiring B] [inst_5 : Algebra R B] [inst_6 : Star B] {f g : A →⋆ₐ[R] B},
f = g ↔ ∀ (x : A), f x = g x | null | true |
QuadraticMap.instNeg._proof_1 | Mathlib.LinearAlgebra.QuadraticForm.Basic | ∀ {R : Type u_3} {M : Type u_1} {N : Type u_2} [inst : CommRing R] [inst_1 : AddCommGroup M] [inst_2 : Module R M]
[inst_3 : AddCommGroup N] [inst_4 : Module R N] (Q : QuadraticMap R M N),
∃ B, ∀ (x y : M), (-⇑Q) (x + y) = (-⇑Q) x + (-⇑Q) y + (B x) y | null | false |
CategoryTheory.Grothendieck.isoMk_hom_fiber | Mathlib.CategoryTheory.Grothendieck | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {F : CategoryTheory.Functor C CategoryTheory.Cat}
{X Y : CategoryTheory.Grothendieck F} (e₁ : X.base ≅ Y.base) (e₂ : (F.map e₁.hom).toFunctor.obj X.fiber ≅ Y.fiber),
(CategoryTheory.Grothendieck.isoMk e₁ e₂).hom.fiber = e₂.hom | null | true |
MeasureTheory.Measure.Regular.exists_isCompact_not_null | Mathlib.MeasureTheory.Measure.Regular | ∀ {α : Type u_1} [inst : MeasurableSpace α] {μ : MeasureTheory.Measure α} [inst_1 : TopologicalSpace α] [μ.Regular],
(∃ K, IsCompact K ∧ μ K ≠ 0) ↔ μ ≠ 0 | null | true |
_private.Mathlib.NumberTheory.PellMatiyasevic.0.Pell.eq_pell_lem.match_1_3 | Mathlib.NumberTheory.PellMatiyasevic | ∀ {a : ℕ} (a1 : 1 < a) (motive : ℕ → ℤ√↑(Pell.d✝ a1) → Prop) (x : ℕ) (x_1 : ℤ√↑(Pell.d✝ a1)),
(∀ (x : ℤ√↑(Pell.d✝ a1)), motive 0 x) → (∀ (n : ℕ) (b : ℤ√↑(Pell.d✝ a1)), motive n.succ b) → motive x x_1 | null | false |
CategoryTheory.Limits.BinaryFan.isLimit_iff_isIso_fst | Mathlib.CategoryTheory.Limits.Shapes.BinaryProducts.BinaryFan | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {X Y : C} (h : CategoryTheory.Limits.IsTerminal Y)
(c : CategoryTheory.Limits.BinaryFan X Y), Nonempty (CategoryTheory.Limits.IsLimit c) ↔ CategoryTheory.IsIso c.fst | null | true |
_private.Lean.Meta.HaveTelescope.0.Lean.Meta.simpHaveTelescope.match_7 | Lean.Meta.HaveTelescope | (motive : Array Bool × Array Bool → Sort u_1) →
(x : Array Bool × Array Bool) → ((fixed used : Array Bool) → motive (fixed, used)) → motive x | null | false |
Std.Async.ContextAsync.instMonadExceptError | Std.Async.ContextAsync | MonadExcept IO.Error Std.Async.ContextAsync | null | true |
_private.Init.Data.UInt.Lemmas.0.UInt32.lt_of_le_of_ne._simp_1_2 | Init.Data.UInt.Lemmas | ∀ {a b : UInt32}, (a ≤ b) = (a.toNat ≤ b.toNat) | null | false |
LinearMap.range_dualMap_eq_dualAnnihilator_ker | Mathlib.LinearAlgebra.Dual.Lemmas | ∀ {K : Type u_1} {V₁ : Type u_2} {V₂ : Type u_3} [inst : Field K] [inst_1 : AddCommGroup V₁] [inst_2 : Module K V₁]
[inst_3 : AddCommGroup V₂] [inst_4 : Module K V₂] (f : V₁ →ₗ[K] V₂), f.dualMap.range = f.ker.dualAnnihilator | null | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.