name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
Submodule.mkQL | Mathlib.Topology.Algebra.Module.ContinuousLinearMap.Quotient | {R : Type u_1} →
[inst : Ring R] →
{M : Type u_3} →
[inst_1 : TopologicalSpace M] →
[inst_2 : AddCommGroup M] → [inst_3 : Module R M] → (S : Submodule R M) → M →L[R] M ⧸ S | `Submodule.mkQ` as a `ContinuousLinearMap`. | true |
Std.DTreeMap.Internal.Impl.min?_keys | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Std.DTreeMap.Internal.Impl α β} [Std.TransOrd α] [inst : Min α]
[inst_1 : LE α] [Std.LawfulOrderOrd α] [Std.LawfulOrderMin α] [Std.LawfulOrderLeftLeaningMin α] [Std.LawfulEqOrd α],
t.WF → t.keys.min? = t.minKey? | null | true |
_private.Lean.Elab.SetOption.0.Lean.Elab.initFn._@.Lean.Elab.SetOption.1989029226._hygCtx._hyg.4 | Lean.Elab.SetOption | IO (Lean.Option Bool) | null | false |
FractionalIdeal.mem_coeSubmodule._simp_1 | Mathlib.RingTheory.FractionalIdeal.Basic | ∀ {R : Type u_1} [inst : CommRing R] {P : Type u_2} [inst_1 : CommRing P] [inst_2 : Algebra R P] {x : P} {I : Ideal R},
(x ∈ IsLocalization.coeSubmodule P I) = ∃ x' ∈ I, (algebraMap R P) x' = x | null | false |
MeasureTheory.Measure.sInf_caratheodory | Mathlib.MeasureTheory.Measure.CompleteLattice | ∀ {α : Type u_1} {mα : MeasurableSpace α} {m : Set (MeasureTheory.Measure α)} (s : Set α),
MeasurableSet s → MeasurableSet s | null | true |
Filter.add_neBot_iff | Mathlib.Order.Filter.Pointwise | ∀ {α : Type u_2} [inst : Add α] {f g : Filter α}, (f + g).NeBot ↔ f.NeBot ∧ g.NeBot | null | true |
Nat.fold_congr._proof_2 | Init.Data.Nat.Fold | ∀ {n m : ℕ}, n = m → ∀ i < m, i < n | null | false |
_private.Mathlib.Analysis.Calculus.InverseFunctionTheorem.ApproximatesLinearOn.0.ApproximatesLinearOn.surjOn_closedBall_of_nonlinearRightInverse._simp_1_1 | Mathlib.Analysis.Calculus.InverseFunctionTheorem.ApproximatesLinearOn | ∀ {γ : Type w} [inst : MetricSpace γ] {x y : γ}, (dist x y ≤ 0) = (x = y) | null | false |
SimpleGraph.exists_isAcyclic_reachable_eq_le_of_le_of_isAcyclic | Mathlib.Combinatorics.SimpleGraph.Acyclic | ∀ {V : Type u_1} {G H : SimpleGraph V},
H ≤ G → H.IsAcyclic → ∃ F, H ≤ F ∧ F ≤ G ∧ F.IsAcyclic ∧ F.Reachable = G.Reachable | Every acyclic subgraph can be extended to a spanning forest. | true |
CategoryTheory.ComposableArrows.sc'Map_τ₃ | Mathlib.Algebra.Homology.ExactSequence | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
{n : ℕ} {S₁ S₂ : CategoryTheory.ComposableArrows C n} (φ : S₁ ⟶ S₂) (h₁ : S₁.IsComplex) (h₂ : S₂.IsComplex)
(i j k : ℕ) (hij : autoParam (i + 1 = j) CategoryTheory.ComposableArrows.sc'Map._auto_1)
(h... | null | true |
ModularForm.restrict_eq_zero_iff._simp_1 | Mathlib.NumberTheory.ModularForms.NormTrace | ∀ {𝒢 ℋ : Subgroup (GL (Fin 2) ℝ)} {k : ℤ} (hGH : 𝒢 ≤ ℋ) {f : ModularForm ℋ k},
(ModularForm.restrict hGH f = 0) = (f = 0) | null | false |
PNat.pos_of_div_pos | Mathlib.Data.PNat.Basic | ∀ {n : ℕ+} {a : ℕ}, a ∣ ↑n → 0 < a | null | true |
Scott.isOpen_univ | Mathlib.Topology.OmegaCompletePartialOrder | ∀ (α : Type u) [inst : OmegaCompletePartialOrder α], Scott.IsOpen α Set.univ | null | true |
NormedRing.inverse_one_sub_norm | Mathlib.Analysis.Normed.Ring.Units | ∀ {R : Type u_1} [inst : NormedRing R] [HasSummableGeomSeries R], (fun t => Ring.inverse (1 - t)) =O[nhds 0] fun _t => 1 | null | true |
CategoryTheory.Grpd.forgetToCat._proof_1 | Mathlib.CategoryTheory.Groupoid.Grpd.Basic | ∀ (X : CategoryTheory.Grpd),
CategoryTheory.Functor.toCatHom (CategoryTheory.CategoryStruct.id X) = CategoryTheory.CategoryStruct.id ↧↑X | null | false |
_private.Mathlib.MeasureTheory.Function.StronglyMeasurable.Basic.0.MeasureTheory.simpleFuncAux.congr_simp | Mathlib.MeasureTheory.Function.StronglyMeasurable.Basic | ∀ {α : Type u_1} {β : Type u_2} {x : MeasurableSpace α} [inst : MeasurableSingletonClass α] (f f_1 : α → β),
f = f_1 →
∀ (g g_1 : ℕ → α),
g = g_1 → ∀ (a a_1 : ℕ), a = a_1 → MeasureTheory.simpleFuncAux✝ f g a = MeasureTheory.simpleFuncAux✝ f_1 g_1 a_1 | null | true |
HomotopyEquiv.symm_homotopyInvHomId | Mathlib.Algebra.Homology.Homotopy | ∀ {ι : Type u_1} {V : Type u} [inst : CategoryTheory.Category.{v, u} V] [inst_1 : CategoryTheory.Preadditive V]
{c : ComplexShape ι} {C D : HomologicalComplex V c} (f : HomotopyEquiv C D),
f.symm.homotopyInvHomId = f.homotopyHomInvId | null | true |
CategoryTheory.WithTerminal.commaFromOver | Mathlib.CategoryTheory.WithTerminal.Cone | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
{J : Type w} →
[inst_1 : CategoryTheory.Category.{w', w} J] →
{X : C} →
CategoryTheory.Functor (CategoryTheory.Functor J (CategoryTheory.Over X))
(CategoryTheory.Comma (CategoryTheory.Functor.id (CategoryTheory.Funct... | The category of functors `J ⥤ Over X` can be seen as part of a comma category,
namely the comma category constructed from the identity of the category of functors
`J ⥤ C` and the functor that maps `X : C` to the constant functor `J ⥤ C`.
Given a functor `K : J ⥤ Over X`, it is mapped to a natural transformation from t... | true |
CategoryTheory.StrictPseudofunctor.mk.noConfusion | Mathlib.CategoryTheory.Bicategory.Functor.StrictPseudofunctor | {B : Type u₁} →
{inst : CategoryTheory.Bicategory B} →
{C : Type u₂} →
{inst_1 : CategoryTheory.Bicategory C} →
{P : Sort u} →
{toStrictlyUnitaryPseudofunctor : CategoryTheory.StrictlyUnitaryPseudofunctor B C} →
{map_comp :
autoParam
(∀ {a b c ... | null | false |
Lean.Widget.TaggedText.instRpcEncodable | Lean.Widget.TaggedText | {α : Type} → [Lean.Server.RpcEncodable α] → Lean.Server.RpcEncodable (Lean.Widget.TaggedText α) | null | true |
Rel.interedges_eq_biUnion | Mathlib.Combinatorics.SimpleGraph.Density | ∀ {α : Type u_4} {β : Type u_5} (r : α → β → Prop) [inst : (a : α) → DecidablePred (r a)] {s : Finset α} {t : Finset β}
[inst_1 : DecidableEq α] [inst_2 : DecidableEq β],
Rel.interedges r s t = s.biUnion fun x => Finset.map { toFun := fun x_1 => (x, x_1), inj' := ⋯ } ({y ∈ t | r x y}) | null | true |
_private.Mathlib.Algebra.Group.Subsemigroup.Membership.0.Subsemigroup.mem_iSup_of_directed.match_1_1 | Mathlib.Algebra.Group.Subsemigroup.Membership | ∀ {M : Type u_2} [inst : Mul M] {ι : Sort u_1} {S : ι → Subsemigroup M} {x : M} (motive : (∃ i, x ∈ S i) → Prop)
(x_1 : ∃ i, x ∈ S i), (∀ (i : ι) (hi : x ∈ S i), motive ⋯) → motive x_1 | null | false |
sub_add_eq_sub_sub | Mathlib.Algebra.Group.Basic | ∀ {α : Type u_1} [inst : SubtractionCommMonoid α] (a b c : α), a - (b + c) = a - b - c | null | true |
AddGroup.rank_le_of_surjective | Mathlib.GroupTheory.Rank | ∀ {G : Type u_1} {H : Type u_2} [inst : AddGroup G] [inst_1 : AddGroup H] [inst_2 : AddGroup.FG G]
[inst_3 : AddGroup.FG H] (f : G →+ H), Function.Surjective ⇑f → AddGroup.rank H ≤ AddGroup.rank G | null | true |
Homeomorph.isEmbedding_comp_iff | Mathlib.Topology.Homeomorph.Defs | ∀ {X : Type u_1} {Y : Type u_2} {Z : Type u_3} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y]
[inst_2 : TopologicalSpace Z] (e : X ≃ₜ Y) {f : Y → Z}, Topology.IsEmbedding (f ∘ ⇑e) ↔ Topology.IsEmbedding f | null | true |
CategoryTheory.prod.associator._proof_1 | Mathlib.CategoryTheory.Products.Associator | ∀ (C : Type u_2) [inst : CategoryTheory.Category.{u_4, u_2} C] (D : Type u_1)
[inst_1 : CategoryTheory.Category.{u_5, u_1} D] (E : Type u_3) [inst_2 : CategoryTheory.Category.{u_6, u_3} E]
(X : (C × D) × E),
CategoryTheory.Prod.mkHom (CategoryTheory.CategoryStruct.id X).1.1
(CategoryTheory.Prod.mkHom (Categ... | null | false |
RingCon.smulCommClass | Mathlib.RingTheory.Congruence.Basic | ∀ {α : Type u_1} {R : Type u_3} [inst : Add R] [inst_1 : MulOneClass R] [inst_2 : SMul α R]
[inst_3 : IsScalarTower α R R] [SMulCommClass α R R] (c : RingCon R), SMulCommClass α c.Quotient c.Quotient | null | true |
List.form_perm_zpow_apply_mem_imp_mem | Mathlib.GroupTheory.Perm.List | ∀ {α : Type u_1} [inst : DecidableEq α] (l : List α), ∀ x ∈ l, ∀ (n : ℤ), (l.formPerm ^ n) x ∈ l | null | true |
Std.IterM.toListRev.go.eq_1 | Init.Data.Iterators.Lemmas.Consumers.Monadic.Collect | ∀ {α : Type w} {m : Type w → Type w'} [inst : Monad m] {β : Type w} [inst_1 : Std.Iterator α m β] (it : Std.IterM m β)
(acc : List β),
Std.IterM.toListRev.go it acc =
WellFounded.extrinsicFix₂ (InvImage Std.IterM.TerminationMeasures.Finite.Rel fun x => x.fst.finitelyManySteps!)
(fun it acc recur => do
... | null | true |
UsesSetNotationForOrder.noConfusion | Mathlib.Tactic.SetNotationForOrder | {P : Sort u} →
{α : Type u_1} →
{t : UsesSetNotationForOrder α} →
{α' : Type u_1} →
{t' : UsesSetNotationForOrder α'} → α = α' → t ≍ t' → UsesSetNotationForOrder.noConfusionType P t t' | null | false |
ModuleCat.CoextendScalars.instCoeFunCarrierObjCoextendScalarsForall | Mathlib.Algebra.Category.ModuleCat.ChangeOfRings | {R : Type u₁} →
{S : Type u₂} →
[inst : Ring R] →
[inst_1 : Ring S] →
(f : R →+* S) → (M : ModuleCat R) → CoeFun ↑((ModuleCat.coextendScalars f).obj M) fun x => S → ↑M | null | true |
Topology.IsLower.closure_singleton | Mathlib.Topology.Order.LowerUpperTopology | ∀ {α : Type u_1} [inst : Preorder α] [inst_1 : TopologicalSpace α] [Topology.IsLower α] (a : α), closure {a} = Set.Ici a | The closure of a singleton `{a}` in the lower topology is the left-closed right-infinite interval
$[a, ∞)$.
| true |
CategoryTheory.Pseudofunctor.toLax._proof_7 | Mathlib.CategoryTheory.Bicategory.Functor.Pseudofunctor | ∀ {B : Type u_5} [inst : CategoryTheory.Bicategory B] {C : Type u_3} [inst_1 : CategoryTheory.Bicategory C]
(F : CategoryTheory.Pseudofunctor B C) {a b : B} (f : a ⟶ b),
F.map₂ (CategoryTheory.Bicategory.leftUnitor f).inv =
CategoryTheory.CategoryStruct.comp (CategoryTheory.Bicategory.leftUnitor (F.map f)).inv
... | null | false |
Sublattice.pi_univ_bot | Mathlib.Order.Sublattice | ∀ {κ : Type u_5} {π : κ → Type u_6} [inst : (i : κ) → Lattice (π i)] [Nonempty κ],
(Sublattice.pi Set.univ fun x => ⊥) = ⊥ | null | true |
_private.Batteries.Util.ProofWanted.0.WantedRefInfo.noConfusionType | Batteries.Util.ProofWanted | Sort u → WantedRefInfo✝ → WantedRefInfo✝ → Sort u | null | false |
ContinuousMap.HomotopyWith.noConfusionType | Mathlib.Topology.Homotopy.Basic | Sort u_1 →
{X : Type u} →
{Y : Type v} →
[inst : TopologicalSpace X] →
[inst_1 : TopologicalSpace Y] →
{f₀ f₁ : C(X, Y)} →
{P : C(X, Y) → Prop} →
f₀.HomotopyWith f₁ P →
{X' : Type u} →
{Y' : Type v} →
[inst' : ... | null | false |
Nat.Partition.card_restricted_eq_card_countRestricted | Mathlib.Combinatorics.Enumerative.Partition.Glaisher | ∀ (n : ℕ) {m : ℕ}, 0 < m → (Nat.Partition.restricted n fun x => ¬m ∣ x).card = (Nat.Partition.countRestricted n m).card | null | true |
Cubic.coeff_eq_b | Mathlib.Algebra.CubicDiscriminant | ∀ {R : Type u_1} {P : Cubic R} [inst : Semiring R], P.toPoly.coeff 2 = P.b | null | true |
Std.DTreeMap.Const.get?_unitOfList | Std.Data.DTreeMap.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} [Std.TransCmp cmp] [inst : BEq α] [Std.LawfulBEqCmp cmp] {l : List α} {k : α},
Std.DTreeMap.Const.get? (Std.DTreeMap.Const.unitOfList l cmp) k = if l.contains k = true then some () else none | null | true |
_private.Mathlib.Analysis.Normed.Field.Approximation.0.Polynomial.exists_monic_and_natDegree_eq_and_norm_map_algebraMap_coeff_sub_lt._simp_1_1 | Mathlib.Analysis.Normed.Field.Approximation | ∀ {R : Type u} [inst : Semiring R], Polynomial.Monic 1 = True | null | false |
NonUnitalAlgebra.instIsMulCommutative_adjoin | Mathlib.Algebra.Algebra.NonUnitalSubalgebra | ∀ {R : Type u_1} {A : Type u_2} [inst : CommSemiring R] [inst_1 : NonUnitalSemiring A] [inst_2 : Module R A]
[inst_3 : IsScalarTower R A A] [inst_4 : SMulCommClass R A A] {S : Type u_3} [inst_5 : SetLike S A]
[inst_6 : MulMemClass S A] (s : S) [IsMulCommutative ↥s], IsMulCommutative ↥(NonUnitalAlgebra.adjoin R ↑s) | null | true |
LibraryNote.RCLike_instance | Mathlib.Analysis.RCLike.Lemmas | Batteries.Util.LibraryNote | This instance generates a type-class problem with a metavariable `?m` that should satisfy
`RCLike ?m`. Since this can only be satisfied by `ℝ` or `ℂ`, this does not cause problems. | true |
ZMod.euler_criterion | Mathlib.NumberTheory.LegendreSymbol.Basic | ∀ (p : ℕ) [inst : Fact (Nat.Prime p)] {a : ZMod p}, a ≠ 0 → (IsSquare a ↔ a ^ (p / 2) = 1) | Euler's Criterion: a nonzero `a : ZMod p` is a square if and only if `x ^ (p / 2) = 1`. | true |
TopCat.Presheaf.stalkSpecializes_stalkFunctor_map_assoc | Mathlib.Topology.Sheaves.Stalks | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Limits.HasColimits C] {X : TopCat}
{F G : TopCat.Presheaf C X} (f : F ⟶ G) {x y : ↑X} (h : x ⤳ y) {Z : C}
(h_1 : (TopCat.Presheaf.stalkFunctor C x).obj G ⟶ Z),
CategoryTheory.CategoryStruct.comp (F.stalkSpecializes h)
(Categor... | null | true |
List.Nodup.not_mem_erase | Init.Data.List.Erase | ∀ {α : Type u_1} [inst : BEq α] {l : List α} [LawfulBEq α] {a : α}, l.Nodup → a ∉ l.erase a | null | true |
Summable.mono_filter | Mathlib.Topology.Algebra.InfiniteSum.Defs | ∀ {α : Type u_1} {β : Type u_2} [inst : AddCommMonoid α] [inst_1 : TopologicalSpace α] {f : β → α}
{L₁ L₂ : SummationFilter β}, Summable f L₂ → L₁.filter ≤ L₂.filter → Summable f L₁ | null | true |
Matroid.IsNonloop.mem_ground | Mathlib.Combinatorics.Matroid.Loop | ∀ {α : Type u_1} {M : Matroid α} {e : α}, M.IsNonloop e → e ∈ M.E | null | true |
Frm.hasForgetToLat._proof_1 | Mathlib.Order.Category.Frm | ∀ (X : Frm),
Lat.ofHom { toFun := ⇑(Frm.Hom.hom (CategoryTheory.CategoryStruct.id X)), map_sup' := ⋯, map_inf' := ⋯ } =
CategoryTheory.CategoryStruct.id ↧↑X | null | false |
Batteries.Tactic.casePattArg | Batteries.Tactic.Case | Lean.ParserDescr | Clause for a `case ... : ...` tactic. | true |
Int32.neg_eq_not_add | Init.Data.SInt.Bitwise | ∀ (a : Int32), -a = ~~~a + 1 | null | true |
WeierstrassCurve.Affine.CoordinateRing.basis_one | Mathlib.AlgebraicGeometry.EllipticCurve.Affine.Point | ∀ {R : Type r} [inst : CommRing R] {W' : WeierstrassCurve.Affine R},
(WeierstrassCurve.Affine.CoordinateRing.basis W') 1 = (WeierstrassCurve.Affine.CoordinateRing.mk W') Polynomial.X | null | true |
NonAssocCommRing.intCast._inherited_default | Mathlib.Algebra.Ring.Defs | {α : Type u} → (α → α) → (ℕ → α) → ℤ → α | null | false |
Turing.PartrecToTM2.Γ'.enumList_getElem?_ctorIdx_eq | Mathlib.Computability.TuringMachine.ToPartrec | ∀ (x : Turing.PartrecToTM2.Γ'), Turing.PartrecToTM2.Γ'.enumList[x.ctorIdx]? = some x | null | true |
Submonoid.LocalizationMap.ofMulEquivOfLocalizations_apply | Mathlib.GroupTheory.MonoidLocalization.Maps | ∀ {M : Type u_1} [inst : CommMonoid M] {S : Submonoid M} {N : Type u_2} [inst_1 : CommMonoid N] {P : Type u_3}
[inst_2 : CommMonoid P] (f : S.LocalizationMap N) {k : N ≃* P} (x : M), (f.ofMulEquivOfLocalizations k) x = k (f x) | null | true |
_private.Mathlib.NumberTheory.ModularForms.LevelOne.GradedRing.0.ModularForm.E₄CubeSubE₆SqForm_isCuspForm._simp_1_1 | Mathlib.NumberTheory.ModularForms.LevelOne.GradedRing | ∀ {k : ℤ} (f : ModularForm (Matrix.SpecialLinearGroup.mapGL ℝ).range k),
f.IsCuspForm = ((PowerSeries.coeff 0) (UpperHalfPlane.qExpansion 1 ⇑f) = 0) | null | false |
CategoryTheory.Functor.Monoidal.ext_iff | Mathlib.CategoryTheory.Monoidal.Functor | ∀ {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} {x y : F.Monoidal},
x = y ↔
CategoryTheory.Functor.LaxMonoidal.ε F ... | null | true |
Batteries.PairingHeapImp.Heap.noConfusionType | Batteries.Data.PairingHeap | Sort u_1 → {α : Type u} → Batteries.PairingHeapImp.Heap α → {α' : Type u} → Batteries.PairingHeapImp.Heap α' → Sort u_1 | null | false |
_private.Init.Data.String.Lemmas.Pattern.Char.0.String.Slice.Pattern.Model.Char.matchAt?_eq._simp_1_1 | Init.Data.String.Lemmas.Pattern.Char | ∀ {c : Char} {s : String.Slice} {pos pos' : s.Pos},
String.Slice.Pattern.Model.IsLongestMatchAt c pos pos' = ∃ (h : pos ≠ s.endPos), pos' = pos.next h ∧ pos.get h = c | null | false |
ContinuousMultilinearMap.curryRight | Mathlib.Analysis.Normed.Module.Multilinear.Curry | {𝕜 : Type u} →
{n : ℕ} →
{Ei : Fin n.succ → Type wEi} →
{G : Type wG} →
[inst : NontriviallyNormedField 𝕜] →
[inst_1 : (i : Fin n.succ) → NormedAddCommGroup (Ei i)] →
[inst_2 : (i : Fin n.succ) → NormedSpace 𝕜 (Ei i)] →
[inst_3 : NormedAddCommGroup G] →
... | Given a continuous multilinear map `f` in `n+1` variables, split the last variable to obtain
a continuous multilinear map in `n` variables into continuous linear maps, given by
`m ↦ (x ↦ f (snoc m x))`. | true |
ProbabilityTheory.Kernel.partialTraj_comp_partialTraj'' | Mathlib.Probability.Kernel.IonescuTulcea.PartialTraj | ∀ {X : ℕ → Type u_1} {mX : (n : ℕ) → MeasurableSpace (X n)} {a : ℕ}
{κ : (n : ℕ) → ProbabilityTheory.Kernel ((i : ↥(Finset.Iic n)) → X ↑i) (X (n + 1))}
[∀ (n : ℕ), ProbabilityTheory.IsMarkovKernel (κ n)] {b c : ℕ},
c ≤ b →
(ProbabilityTheory.Kernel.partialTraj κ b c).comp (ProbabilityTheory.Kernel.partialTraj... | Same as `partialTraj_comp_partialTraj` but only assuming `b ≤ c`. It requires Markov kernels. | true |
instFaithfulVAdd | Mathlib.Algebra.Group.Action.Faithful | ∀ (R : Type u_4) [inst : AddZeroClass R], FaithfulVAdd R R | `instVAddOfAdd` is faithful when there is a (right) identity. | true |
_private.Mathlib.Data.Nat.Squarefree.0.Nat.minSqFacAux.match_1.splitter | Mathlib.Data.Nat.Squarefree | (motive : ℕ → ℕ → Sort u_1) → (x x_1 : ℕ) → ((n k : ℕ) → motive n k) → motive x x_1 | null | true |
_private.Mathlib.GroupTheory.Finiteness.0.AddMonoid.fg_iff_exists_freeAddGroup_hom_surjective_finite.match_1_1 | Mathlib.GroupTheory.Finiteness | ∀ {M : Type u_1} [inst : AddMonoid M] (motive : (∃ S, ∃ (_ : S.Finite), ∃ φ, Function.Surjective ⇑φ) → Prop)
(h : ∃ S, ∃ (_ : S.Finite), ∃ φ, Function.Surjective ⇑φ),
(∀ (S : Set M) (hS : S.Finite) (φ : FreeAddMonoid ↑S →+ M) (hφ : Function.Surjective ⇑φ), motive ⋯) → motive h | null | false |
spectrum.add_singleton_eq | Mathlib.Algebra.Algebra.Spectrum.Basic | ∀ {R : Type u} {A : Type v} [inst : CommRing R] [inst_1 : Ring A] [inst_2 : Algebra R A] (a : A) (r : R),
spectrum R a + {r} = spectrum R (a + (algebraMap R A) r) | null | true |
USize.ofFin_shiftLeft | Init.Data.UInt.Bitwise | ∀ (a b : Fin USize.size), ↑b < System.Platform.numBits → USize.ofFin (a <<< b) = USize.ofFin a <<< USize.ofFin b | null | true |
Matrix.invertibleOfFromBlocks₂₂Invertible | Mathlib.LinearAlgebra.Matrix.SchurComplement | {m : Type u_2} →
{n : Type u_3} →
{α : Type u_4} →
[inst : Fintype m] →
[inst_1 : Fintype n] →
[inst_2 : DecidableEq m] →
[inst_3 : DecidableEq n] →
[inst_4 : CommRing α] →
(A : Matrix m m α) →
(B : Matrix m n α) →
... | If a block matrix is invertible and so is its bottom left element, then so is the corresponding
Schur complement. | true |
String.Slice.all_prop_eq_all_decide | Init.Data.String.Lemmas.Pattern.Pred | ∀ {p : Char → Prop} [inst : DecidablePred p] {s : String.Slice}, s.all p = s.all fun x => decide (p x) | null | true |
Std.Http.URI.Authority.recOn | Std.Http.Data.URI.Basic | {motive : Std.Http.URI.Authority → Sort u} →
(t : Std.Http.URI.Authority) →
((userInfo : Option Std.Http.URI.UserInfo) →
(host : Std.Http.URI.Host) →
(port : Std.Http.URI.Port) → motive { userInfo := userInfo, host := host, port := port }) →
motive t | null | false |
_private.Mathlib.Analysis.SpecialFunctions.Trigonometric.Complex.0.Complex.tan_eq_zero_iff._simp_1_1 | Mathlib.Analysis.SpecialFunctions.Trigonometric.Complex | ∀ {α : Sort u_1} {a b : α}, (a = b) = (b = a) | null | false |
Polynomial.Splits.degree_eq_one_of_irreducible | Mathlib.Algebra.Polynomial.Splits | ∀ {R : Type u_1} [inst : Field R] {f : Polynomial R}, f.Splits → Irreducible f → f.degree = 1 | null | true |
Algebra.intNorm_intNorm | Mathlib.RingTheory.IntegralClosure.IntegralRestrict | ∀ (A : Type u_1) (B : Type u_6) [inst : CommRing A] [inst_1 : CommRing B] [inst_2 : Algebra A B]
[inst_3 : IsIntegrallyClosed A] [inst_4 : IsDomain A] [inst_5 : IsDomain B] [inst_6 : IsIntegrallyClosed B]
[inst_7 : Algebra.IsIntegral A B] [inst_8 : Module.IsTorsionFree A B] {C : Type u_9} [inst_9 : CommRing C]
[i... | null | true |
Similar.comp_right_iff._simp_1 | Mathlib.Topology.MetricSpace.Similarity | ∀ {ι : Type u_1} {P₁ : Type u_3} {P₂ : Type u_4} {P₃ : Type u_5} {v₁ : ι → P₁} {v₂ : ι → P₂}
[inst : PseudoEMetricSpace P₁] [inst_1 : PseudoEMetricSpace P₂] [inst_2 : PseudoEMetricSpace P₃] {F : Type u_6}
[inst_3 : FunLike F P₂ P₃] [DilationClass F P₂ P₃] (f : F), Similar v₁ (⇑f ∘ v₂) = Similar v₁ v₂ | null | false |
OrderedFinpartition.compAlongOrderedFinpartitionL._proof_1 | Mathlib.Analysis.Calculus.ContDiff.FaaDiBruno | ∀ (𝕜 : Type u_1) [inst : NontriviallyNormedField 𝕜] (E : Type u_2) [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] (G : Type u_3) [inst_3 : NormedAddCommGroup G] [inst_4 : NormedSpace 𝕜 G] {n : ℕ},
SMulCommClass 𝕜 𝕜 (E [×n]→L[𝕜] G) | null | false |
instLocallyPathConnectedSpaceEuclideanQuadrant | Mathlib.Geometry.Manifold.Instances.Real | ∀ {n : ℕ}, LocallyPathConnectedSpace (EuclideanQuadrant n) | null | true |
fderiv_fun_const | Mathlib.Analysis.Calculus.FDeriv.Const | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : AddCommGroup E] [inst_2 : Module 𝕜 E]
[inst_3 : TopologicalSpace E] {F : Type u_3} [inst_4 : AddCommGroup F] [inst_5 : Module 𝕜 F]
[inst_6 : TopologicalSpace F] (c : F), (fderiv 𝕜 fun x => c) = 0 | null | true |
_private.Mathlib.Data.WSeq.Basic.0.Stream'.WSeq.destruct_join.match_1_1 | Mathlib.Data.WSeq.Basic | ∀ {α : Type u_1}
(motive :
(c1 c2 : Computation (Option (α × Stream'.WSeq α))) →
(c1 = c2 ∨ ∃ S, c1 = S.join.destruct ∧ c2 = S.destruct.bind Stream'.WSeq.destruct_join.aux) → Prop)
(c1 c2 : Computation (Option (α × Stream'.WSeq α)))
(h : c1 = c2 ∨ ∃ S, c1 = S.join.destruct ∧ c2 = S.destruct.bind Stream'... | null | false |
SSet.Subcomplex.PairingCore.WeakRankFunction.mk.inj | Mathlib.AlgebraicTopology.SimplicialSet.AnodyneExtensions.Rank | ∀ {X : SSet} {A : X.Subcomplex} {h : A.PairingCore} {α : Type v} {inst : PartialOrder α} {rank : h.ι → α}
{lt : ∀ {x y : h.ι}, h.AncestralRel x y → h.dim x = h.dim y → rank x < rank y} {rank_1 : h.ι → α}
{lt_1 : ∀ {x y : h.ι}, h.AncestralRel x y → h.dim x = h.dim y → rank_1 x < rank_1 y},
{ rank := rank, lt := lt... | null | true |
Subgroup.center | Mathlib.GroupTheory.Subgroup.Center | (G : Type u_1) → [inst : Group G] → Subgroup G | The center of a group `G` is the set of elements that commute with everything in `G` | true |
Nat.zeckendorf._unsafe_rec | Mathlib.Data.Nat.Fib.Zeckendorf | ℕ → List ℕ | null | false |
IsInvariantSubring.toMulSemiringAction._proof_3 | Mathlib.Algebra.Ring.Action.Invariant | ∀ (M : Type u_2) {R : Type u_1} [inst : Monoid M] [inst_1 : Ring R] [inst_2 : MulSemiringAction M R] (S : Subring R)
[inst_3 : IsInvariantSubring M S] (s : ↥S), 1 • s = s | null | false |
Std.ExtDHashMap.size_filterMap_eq_size_iff | Std.Data.ExtDHashMap.Lemmas | ∀ {α : Type u} {x : BEq α} {x_1 : Hashable α} {β : α → Type v} {m : Std.ExtDHashMap α β} {γ : α → Type w}
[inst : LawfulBEq α] {f : (a : α) → β a → Option (γ a)},
(Std.ExtDHashMap.filterMap f m).size = m.size ↔ ∀ (a : α) (h : a ∈ m), (f a (m.get a h)).isSome = true | null | true |
Std.DTreeMap.Internal.Impl.Const.size_filter!_eq_size_iff | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {instOrd : Ord α} {β : Type v} {t : Std.DTreeMap.Internal.Impl α fun x => β} [Std.TransOrd α]
{f : α → β → Bool},
t.WF →
((Std.DTreeMap.Internal.Impl.filter! f t).size = t.size ↔
∀ (a : α) (h : Std.DTreeMap.Internal.Impl.contains a t = true),
f (t.getKey a h) (Std.DTreeMap.Internal.... | null | true |
measurableVAdd_iterateAddAct._simp_1 | Mathlib.MeasureTheory.Group.Arithmetic | ∀ {α : Type u_2} {x : MeasurableSpace α} {f : α → α}, MeasurableVAdd (IterateAddAct f) α = Measurable f | null | false |
CochainComplex.mappingCone.mapOfHomotopy._proof_3 | Mathlib.Algebra.Homology.HomotopyCategory.Pretriangulated | -1 + 0 = -1 | null | false |
CategoryTheory.Functor.CoconeTypes.IsColimit.equiv_symm_ι_apply | Mathlib.CategoryTheory.Limits.Types.ColimitType | ∀ {J : Type u} [inst : CategoryTheory.Category.{v, u} J] {F : CategoryTheory.Functor J (Type w₀)} {c : F.CoconeTypes}
(hc : c.IsColimit) (j : J) (x : F.obj j), hc.equiv.symm (c.ι j x) = F.ιColimitType j x | null | true |
CoalgEquiv.noConfusionType | Mathlib.RingTheory.Coalgebra.Equiv | Sort u →
{R : Type u_5} →
[inst : CommSemiring R] →
{A : Type u_6} →
{B : Type u_7} →
[inst_1 : AddCommMonoid A] →
[inst_2 : AddCommMonoid B] →
[inst_3 : Module R A] →
[inst_4 : Module R B] →
[inst_5 : CoalgebraStruct R A] →
... | null | false |
_private.Mathlib.Analysis.Normed.Algebra.GelfandMazur.0.NormedAlgebra.Real.norm_φ_eq_norm_φ_of_isMinOn._proof_1_2 | Mathlib.Analysis.Normed.Algebra.GelfandMazur | ∀ n > 0, n < 2 * n | null | false |
_private.Init.Data.Fin.Lemmas.0.Fin.eq_zero_or_eq_succ.match_1_1 | Init.Data.Fin.Lemmas | ∀ {n : ℕ} (motive : Fin (n + 1) → Prop) (x : Fin (n + 1)),
(∀ (_ : Unit), motive ⟨0, ⋯⟩) → (∀ (j : ℕ) (h : j + 1 < n + 1), motive ⟨j.succ, h⟩) → motive x | null | false |
tsum_geometric_two | Mathlib.Analysis.SpecificLimits.Basic | ∑' (n : ℕ), (1 / 2) ^ n = 2 | null | true |
_private.Init.Data.List.Count.0.List.countP_filterMap._simp_1_1 | Init.Data.List.Count | ∀ {α : Type u_1} {p : α → Bool}, List.filter p = List.filterMap (Option.guard fun x => p x) | null | false |
HomologicalComplex.extendSingleIso_hom_f | Mathlib.Algebra.Homology.Embedding.Extend | ∀ {ι : Type u_1} {ι' : Type u_2} {c : ComplexShape ι} {c' : ComplexShape ι'} {C : Type u_3}
[inst : CategoryTheory.Category.{v_1, u_3} C] [inst_1 : CategoryTheory.Limits.HasZeroObject C]
[inst_2 : CategoryTheory.Limits.HasZeroMorphisms C] [inst_3 : DecidableEq ι] (e : c.Embedding c') (X : C)
[inst_4 : DecidableEq... | null | true |
_private.Mathlib.MeasureTheory.VectorMeasure.IntegrationByParts.0.MeasureTheory.VectorMeasure.ext_of_Icc._proof_1_3 | Mathlib.MeasureTheory.VectorMeasure.IntegrationByParts | ∀ {α : Type u_1} [inst : LinearOrder α] (u : ℕ → α),
Monotone u →
∀ (v : ℕ → α),
Antitone v → ∀ ⦃m n : ℕ⦄, m ≤ n → ∀ ⦃x : α⦄, x ∈ (fun n => Set.Icc (v n) (u n)) m → x ∈ Set.Icc (v n) (u n) | null | false |
CategoryTheory.MonoidalCoherence.noConfusionType | Mathlib.Tactic.CategoryTheory.MonoidalComp | Sort u_1 →
{C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
{X Y : C} →
CategoryTheory.MonoidalCoherence X Y →
{C' : Type u} →
[inst' : CategoryTheory.Category.{v, u} C'] →
{X' Y' : C'} → CategoryTheory.MonoidalCoherence X' Y' → Sort u_1 | null | false |
Lean.Meta.Grind.TGrindStep | Lean.Meta.Tactic.Grind.Action | Type | null | true |
PiLp.normedSpace | Mathlib.Analysis.Normed.Lp.PiLp | (p : ENNReal) →
(𝕜 : Type u_1) →
{ι : Type u_2} →
(β : ι → Type u_4) →
[hp : Fact (1 ≤ p)] →
[inst : Fintype ι] →
[inst_1 : NormedField 𝕜] →
[inst_2 : (i : ι) → SeminormedAddCommGroup (β i)] →
[(i : ι) → NormedSpace 𝕜 (β i)] → NormedSpace 𝕜 (Pi... | The product of finitely many normed spaces is a normed space, with the `L^p` norm. | true |
_private.Lean.Parser.Command.0.Lean.Parser.Command.end._regBuiltin.Lean.Parser.Command.end_1 | Lean.Parser.Command | IO Unit | null | false |
isLowerSet_iInter | Mathlib.Order.UpperLower.Basic | ∀ {α : Type u_1} {ι : Sort u_3} [inst : LE α] {f : ι → Set α}, (∀ (i : ι), IsLowerSet (f i)) → IsLowerSet (⋂ i, f i) | null | true |
String.Slice.subslice.congr_simp | Init.Data.String.Subslice | ∀ (s : String.Slice) (newStart newStart_1 : s.Pos) (e_newStart : newStart = newStart_1) (newEnd newEnd_1 : s.Pos)
(e_newEnd : newEnd = newEnd_1) (h : newStart ≤ newEnd),
s.subslice newStart newEnd h = s.subslice newStart_1 newEnd_1 ⋯ | null | true |
MvPolynomial.counit_C | Mathlib.Algebra.MvPolynomial.Counit | ∀ (R : Type u_3) [inst : CommRing R] (n : ℤ), (MvPolynomial.counit R) (MvPolynomial.C n) = ↑n | null | true |
Matroid.delete_contract_eq_sdiff | Mathlib.Combinatorics.Matroid.Minor.Contract | ∀ {α : Type u_1} (M : Matroid α) (D C : Set α), (M.delete D).contract C = (M.delete D).contract (C \ D) | null | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.