name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.67M | allowCompletion bool 2
classes |
|---|---|---|---|
List.mergeSort_of_sorted | Init.Data.List.Sort.Lemmas | ∀ {α : Type u_1} {le : α → α → Bool} {l : List α}, List.Pairwise (fun a b => le a b = true) l → l.mergeSort le = l | true |
QuasispectrumRestricts.nonUnitalStarAlgHom | Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.Restrict | {R : Type u} →
{S : Type v} →
{A : Type w} →
[inst : Semifield R] →
[inst_1 : StarRing R] →
[inst_2 : TopologicalSpace R] →
[inst_3 : IsTopologicalSemiring R] →
[inst_4 : ContinuousStar R] →
[inst_5 : Field S] →
[inst_6 : StarRing... | true |
_private.Mathlib.RingTheory.MvPolynomial.Symmetric.NewtonIdentities.0.MvPolynomial.NewtonIdentities.disjoint_filter_pairs_lt_filter_pairs_eq | Mathlib.RingTheory.MvPolynomial.Symmetric.NewtonIdentities | ∀ (σ : Type u_1) [inst : DecidableEq σ] [inst_1 : Fintype σ] (k : ℕ),
Disjoint ({t ∈ MvPolynomial.NewtonIdentities.pairs✝ σ k | t.1.card < k})
({t ∈ MvPolynomial.NewtonIdentities.pairs✝¹ σ k | t.1.card = k}) | true |
EStateM.Result.map_error | Batteries.Lean.EStateM | ∀ {ε σ α β : Type u_1} (f : α → β) (e : ε) (s : σ),
EStateM.Result.map f (EStateM.Result.error e s) = EStateM.Result.error e s | true |
DFinsupp.mkAddGroupHom | Mathlib.Data.DFinsupp.Defs | {ι : Type u} →
{β : ι → Type v} →
[DecidableEq ι] → [inst : (i : ι) → AddGroup (β i)] → (s : Finset ι) → ((i : ↑↑s) → β ↑i) →+ Π₀ (i : ι), β i | true |
MonoidHom.noncommPiCoprod.eq_1 | Mathlib.GroupTheory.NoncommPiCoprod | ∀ {M : Type u_1} [inst : Monoid M] {ι : Type u_2} [inst_1 : Fintype ι] {N : ι → Type u_3}
[inst_2 : (i : ι) → Monoid (N i)] (ϕ : (i : ι) → N i →* M)
(hcomm : Pairwise fun i j => ∀ (x : N i) (y : N j), Commute ((ϕ i) x) ((ϕ j) y)),
MonoidHom.noncommPiCoprod ϕ hcomm =
{ toFun := fun f => Finset.univ.noncommProd... | true |
MulEquiv.monoidHomCongrLeftEquiv._proof_1 | Mathlib.Algebra.Group.Equiv.Basic | ∀ {M₁ : Type u_1} {M₂ : Type u_3} {N : Type u_2} [inst : MulOneClass M₁] [inst_1 : MulOneClass M₂] [inst_2 : Monoid N]
(e : M₁ ≃* M₂) (f : M₁ →* N), (fun f => f.comp e.toMonoidHom) ((fun f => f.comp e.symm.toMonoidHom) f) = f | false |
Pi.involutiveNeg._proof_1 | Mathlib.Algebra.Group.Pi.Basic | ∀ {I : Type u_1} {f : I → Type u_2} [inst : (i : I) → InvolutiveNeg (f i)] (x : (i : I) → f i), - -x = x | false |
String.Slice.SplitIterator.instIteratorIdSubslice._proof_7 | Init.Data.String.Slice | ∀ {ρ : Type} {σ : String.Slice → Type}
[inst : (s : String.Slice) → Std.Iterator (σ s) Id (String.Slice.Pattern.SearchStep s)] {pat : ρ}
[inst_1 : String.Slice.Pattern.ToForwardSearcher pat σ] {s : String.Slice} (currPos : s.Pos)
(searcher searcher' : Std.Iter (String.Slice.Pattern.SearchStep s)) (startPos endPos... | false |
Lean.Elab.Term.elabRunElab._regBuiltin.Lean.Elab.Term.elabRunElab.declRange_5 | Lean.Elab.BuiltinNotation | IO Unit | false |
abs_eq_abs | Mathlib.Algebra.Order.Group.Unbundled.Abs | ∀ {α : Type u_1} [inst : AddGroup α] [inst_1 : LinearOrder α] {a b : α}, |a| = |b| ↔ a = b ∨ a = -b | true |
_private.Mathlib.Topology.Algebra.RestrictedProduct.TopologicalSpace.0.RestrictedProduct.continuous_dom_pi._simp_1_4 | Mathlib.Topology.Algebra.RestrictedProduct.TopologicalSpace | ∀ {α : Type u_1} {β : Type u_2} {γ : Type u_3} {f : β → γ} {g : α → β} {x : Filter α} {y : Filter γ},
Filter.Tendsto f (Filter.map g x) y = Filter.Tendsto (f ∘ g) x y | false |
_private.Std.Data.DTreeMap.Internal.Lemmas.0.Std.DTreeMap.Internal.Impl.getKeyD_minKey!._simp_1_2 | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {instOrd : Ord α} {a b : α}, (compare a b ≠ Ordering.eq) = ((a == b) = false) | false |
UInt32.and_not_self | Init.Data.UInt.Bitwise | ∀ {a : UInt32}, a &&& ~~~a = 0 | true |
OrderRingHom | Mathlib.Algebra.Order.Hom.Ring | (α : Type u_6) →
(β : Type u_7) → [NonAssocSemiring α] → [Preorder α] → [NonAssocSemiring β] → [Preorder β] → Type (max u_6 u_7) | true |
Std.DTreeMap.Internal.Impl.minView.eq_1 | Std.Data.DTreeMap.Internal.Model | ∀ {α : Type u} {β : α → Type v} (k : α) (v : β k) (r : Std.DTreeMap.Internal.Impl α β) (hr : r.Balanced)
(hl_2 : Std.DTreeMap.Internal.Impl.leaf.Balanced)
(hlr_2 : Std.DTreeMap.Internal.Impl.BalancedAtRoot Std.DTreeMap.Internal.Impl.leaf.size r.size),
Std.DTreeMap.Internal.Impl.minView k v Std.DTreeMap.Internal.I... | true |
TopCat.effectiveEpiStructOfQuotientMap._proof_2 | Mathlib.Topology.Category.TopCat.EffectiveEpi | ∀ {X : TopCat} (a : ↑X), Continuous fun x => a | false |
IsUltrametricDist.closedBall_openSubgroup._proof_3 | Mathlib.Analysis.Normed.Group.Ultra | ∀ (S : Type u_1) [inst : SeminormedGroup S] {r : ℝ} {x : S}, x ∈ Metric.closedBall 1 r → x⁻¹ ∈ Metric.closedBall 1 r | false |
OpenSubgroup.mem_inf._simp_2 | Mathlib.Topology.Algebra.OpenSubgroup | ∀ {G : Type u_1} [inst : Group G] [inst_1 : TopologicalSpace G] {U V : OpenSubgroup G} {x : G},
(x ∈ U ⊓ V) = (x ∈ U ∧ x ∈ V) | false |
Std.DHashMap.Raw.contains_inter | Std.Data.DHashMap.RawLemmas | ∀ {α : Type u} {β : α → Type v} [inst : BEq α] [inst_1 : Hashable α] {m₁ m₂ : Std.DHashMap.Raw α β} [EquivBEq α]
[LawfulHashable α] {k : α}, m₁.WF → m₂.WF → (m₁ ∩ m₂).contains k = (m₁.contains k && m₂.contains k) | true |
_private.Mathlib.Algebra.DirectSum.Basic.0.DirectSum.id._proof_3 | Mathlib.Algebra.DirectSum.Basic | ∀ (M : Type u_2) (ι : Type u_1) [inst : AddCommMonoid M] [inst_1 : Unique ι] (x y : DirectSum ι fun i => M),
(DirectSum.of (fun x => M) default) ((DirectSum.toAddMonoid fun x => AddMonoidHom.id M) x) = x →
(DirectSum.of (fun x => M) default) ((DirectSum.toAddMonoid fun x => AddMonoidHom.id M) y) = y →
(Dire... | false |
Lean.Firefox.ProfileMeta.sampleUnits._default | Lean.Util.Profiler | Lean.Firefox.SampleUnits | false |
Lean.EffectiveImport.mk.noConfusion | Lean.Environment | {P : Sort u} →
{toImport : Lean.Import} →
{irPhases : Lean.IRPhases} →
{toImport' : Lean.Import} →
{irPhases' : Lean.IRPhases} →
{ toImport := toImport, irPhases := irPhases } = { toImport := toImport', irPhases := irPhases' } →
(toImport = toImport' → irPhases = irPhases' → P)... | false |
Set.Ioi_insert | Mathlib.Order.Interval.Set.Basic | ∀ {α : Type u_1} [inst : PartialOrder α] {a : α}, insert a (Set.Ioi a) = Set.Ici a | true |
Lean.Compiler.LCNF.MonadCodeBind.recOn | Lean.Compiler.LCNF.Bind | {m : Type → Type} →
{motive : Lean.Compiler.LCNF.MonadCodeBind m → Sort u} →
(t : Lean.Compiler.LCNF.MonadCodeBind m) →
((codeBind :
{pu : Lean.Compiler.LCNF.Purity} →
Lean.Compiler.LCNF.Code pu →
(Lean.FVarId → m (Lean.Compiler.LCNF.Code pu)) → m (Lean.Compiler.LCN... | false |
_private.Mathlib.MeasureTheory.Measure.Restrict.0.MeasureTheory.ae_restrict_iff₀._simp_1_3 | Mathlib.MeasureTheory.Measure.Restrict | ∀ {a b : Prop}, (a ∧ b) = (b ∧ a) | false |
CategoryTheory.SmallObject.SuccStruct.Iteration.mkOfLimit._proof_1 | Mathlib.CategoryTheory.SmallObject.Iteration.Nonempty | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{u_2, u_1} C] {Φ : CategoryTheory.SmallObject.SuccStruct C}
{J : Type u_3} [inst_1 : LinearOrder J] [inst_2 : OrderBot J] [inst_3 : SuccOrder J] [inst_4 : WellFoundedLT J]
[inst_5 : CategoryTheory.Limits.HasIterationOfShape J C] {j : J} (hj : Order.IsSuccLimit j)
(... | false |
CategoryTheory.DifferentialObject.Hom.mk.congr_simp | Mathlib.CategoryTheory.DifferentialObject | ∀ {S : Type u_1} [inst : AddMonoidWithOne S] {C : Type u} [inst_1 : CategoryTheory.Category.{v, u} C]
[inst_2 : CategoryTheory.Limits.HasZeroMorphisms C] [inst_3 : CategoryTheory.HasShift C S]
{X Y : CategoryTheory.DifferentialObject S C} (f f_1 : X.obj ⟶ Y.obj) (e_f : f = f_1)
(comm :
CategoryTheory.Category... | true |
_private.Std.Data.Internal.List.Associative.0.Std.Internal.List.alterKey_cons_perm.match_1.splitter | Std.Data.Internal.List.Associative | {α : Type u_3} →
{β : α → Type u_1} →
{k : α} →
(motive : Option (β k) → Sort u_2) →
(x : Option (β k)) → (Unit → motive none) → ((v : β k) → motive (some v)) → motive x | true |
Nonneg.semiring._proof_14 | Mathlib.Algebra.Order.Nonneg.Basic | ∀ {α : Type u_1} [inst : Semiring α] [inst_1 : PartialOrder α] [inst_2 : ZeroLEOneClass α], ↑1 = 1 | false |
ComplexShape.Embedding.extendFunctor_obj | Mathlib.Algebra.Homology.Embedding.Extend | ∀ {ι : Type u_1} {ι' : Type u_2} {c : ComplexShape ι} {c' : ComplexShape ι'} (e : c.Embedding c') (C : Type u_3)
[inst : CategoryTheory.Category.{v_1, u_3} C] [inst_1 : CategoryTheory.Limits.HasZeroObject C]
[inst_2 : CategoryTheory.Limits.HasZeroMorphisms C] (K : HomologicalComplex C c),
(e.extendFunctor C).obj ... | true |
GradedAlgebra.algebraMap_apply | Mathlib.RingTheory.GradedAlgebra.TensorProduct | ∀ {ι : Type u_1} {R : Type u_2} {A : Type u_3} {S : Type u_4} [inst : CommSemiring R] [inst_1 : CommSemiring S]
[inst_2 : Algebra R S] [inst_3 : DecidableEq ι] [inst_4 : AddCommMonoid ι] [inst_5 : CommSemiring A]
[inst_6 : Algebra R A] (𝒜 : ι → Submodule R A) [inst_7 : GradedAlgebra 𝒜] (x : ↥(Submodule.baseChange... | true |
WittVector.truncateFun_add | Mathlib.RingTheory.WittVector.Truncated | ∀ {p : ℕ} (n : ℕ) {R : Type u_1} [inst : CommRing R] [inst_1 : Fact (Nat.Prime p)] (x y : WittVector p R),
WittVector.truncateFun n (x + y) = WittVector.truncateFun n x + WittVector.truncateFun n y | true |
MessageActionItem.title | Lean.Data.Lsp.Window | MessageActionItem → String | true |
Pi.vaddAssocClass | Mathlib.Algebra.Group.Action.Pi | ∀ {ι : Type u_1} {M : Type u_2} {N : Type u_3} {α : ι → Type u_4} [inst : VAdd M N] [inst_1 : (i : ι) → VAdd N (α i)]
[inst_2 : (i : ι) → VAdd M (α i)] [∀ (i : ι), VAddAssocClass M N (α i)], VAddAssocClass M N ((i : ι) → α i) | true |
instPseudoEMetricSpaceULift | Mathlib.Topology.EMetricSpace.Defs | {α : Type u} → [PseudoEMetricSpace α] → PseudoEMetricSpace (ULift.{u_2, u} α) | true |
Action.forget._proof_2 | Mathlib.CategoryTheory.Action.Basic | ∀ (V : Type u_2) [inst : CategoryTheory.Category.{u_1, u_2} V] (G : Type u_3) [inst_1 : Monoid G] {X Y Z : Action V G}
(f : X ⟶ Y) (g : Y ⟶ Z), (CategoryTheory.CategoryStruct.comp f g).hom = CategoryTheory.CategoryStruct.comp f.hom g.hom | false |
_private.Mathlib.Algebra.Polynomial.FieldDivision.0.Polynomial.dvd_C_mul.match_1_1 | Mathlib.Algebra.Polynomial.FieldDivision | ∀ {R : Type u_1} {a : R} [inst : Field R] {p q : Polynomial R} (motive : p ∣ Polynomial.C a * q → Prop)
(x : p ∣ Polynomial.C a * q), (∀ (r : Polynomial R) (hr : Polynomial.C a * q = p * r), motive ⋯) → motive x | false |
Std.Sat.AIG.denote._proof_4 | Std.Sat.AIG.Basic | ∀ {α : Type} (x : ℕ) (decls : Array (Std.Sat.AIG.Decl α)),
x < decls.size → ∀ (lhs rhs : Std.Sat.AIG.Fanin), lhs.gate < x ∧ rhs.gate < x → rhs.gate < decls.size | false |
Antitone.lowerBounds_range_comp_tendsto_atTop | Mathlib.Order.Filter.AtTopBot.Tendsto | ∀ {α : Type u_3} {β : Type u_4} {γ : Type u_5} [inst : Preorder β] [inst_1 : Preorder γ] {l : Filter α} [l.NeBot]
{f : β → γ},
Antitone f →
∀ {g : α → β}, Filter.Tendsto g l Filter.atTop → lowerBounds (Set.range (f ∘ g)) = lowerBounds (Set.range f) | true |
CategoryTheory.ProjectiveResolution.isoExt._proof_4 | Mathlib.CategoryTheory.Abelian.Ext | ∀ {R : Type u_2} [inst : Ring R] {C : Type u_3} [inst_1 : CategoryTheory.Category.{u_1, u_3} C]
[inst_2 : CategoryTheory.Abelian C] [inst_3 : CategoryTheory.Linear R C] {X : C}
(P : CategoryTheory.ProjectiveResolution X) (n : ℕ) (Y : C),
(HomologicalComplex.sc (P.complex.linearYonedaObj R Y) n).HasHomology | false |
Lean.Meta.Rewrites.RwDirection._sizeOf_inst | Lean.Meta.Tactic.Rewrites | SizeOf Lean.Meta.Rewrites.RwDirection | false |
Int.natAbs_inj_of_nonpos_of_nonneg | Mathlib.Data.Int.Lemmas | ∀ {a b : ℤ}, a ≤ 0 → 0 ≤ b → (a.natAbs = b.natAbs ↔ -a = b) | true |
Nat.coprime_of_dvd' | Mathlib.Data.Nat.Prime.Basic | ∀ {m n : ℕ}, (∀ (k : ℕ), Nat.Prime k → k ∣ m → k ∣ n → k ∣ 1) → m.Coprime n | true |
Set.univ_inter | Mathlib.Data.Set.Basic | ∀ {α : Type u} (a : Set α), Set.univ ∩ a = a | true |
_private.Mathlib.GroupTheory.Perm.Cycle.Type.0.Equiv.Perm.IsThreeCycle.nodup_iff_mem_support._proof_1_650 | Mathlib.GroupTheory.Perm.Cycle.Type | ∀ {α : Type u_1} [inst_1 : DecidableEq α] {g : Equiv.Perm α} {a : α} (w : α)
(h :
List.idxOfNth w [g (g a)] (List.idxOfNth w [g (g a)] 1) + 1 ≤
(List.filter (fun x => decide (x = w)) [a, g a, g (g a)]).length),
(List.findIdxs (fun x => decide (x = w)) [a, g a, g (g a)])[List.idxOfNth w [g (g a)] (List.idx... | false |
PreTilt.mk_comp_untilt_eq_coeff_zero | Mathlib.RingTheory.Perfectoid.Untilt | ∀ {O : Type u_1} [inst : CommRing O] {p : ℕ} [inst_1 : Fact (Nat.Prime p)] [inst_2 : Fact ¬IsUnit ↑p]
[inst_3 : IsAdicComplete (Ideal.span {↑p}) O],
⇑(Ideal.Quotient.mk (Ideal.span {↑p})) ∘ ⇑PreTilt.untilt = ⇑(PreTilt.coeff 0) | true |
Topology.WithScott.instPreorder | Mathlib.Topology.Order.ScottTopology | {α : Type u_1} → [Preorder α] → Preorder (Topology.WithScott α) | true |
Lean.IR.EmitC.emitFullApp | Lean.Compiler.IR.EmitC | Lean.IR.VarId → Lean.IR.IRType → Lean.IR.FunId → Array Lean.IR.Arg → Lean.IR.EmitC.M Unit | true |
Array.all_eq_false' | Init.Data.Array.Lemmas | ∀ {α : Type u_1} {p : α → Bool} {as : Array α}, as.all p = false ↔ ∃ x ∈ as, ¬p x = true | true |
_private.Init.Data.Nat.SOM.0.Nat.SOM.Poly.mulMon.eq_1 | Init.Data.Nat.SOM | ∀ (p : Nat.SOM.Poly) (k : ℕ) (m : Nat.SOM.Mon), p.mulMon k m = Nat.SOM.Poly.mulMon.go✝ k m p [] | true |
_private.Mathlib.CategoryTheory.WithTerminal.Cone.0.CategoryTheory.WithInitial.coconeBack._proof_7 | Mathlib.CategoryTheory.WithTerminal.Cone | ∀ {C : Type u_4} [inst : CategoryTheory.Category.{u_2, u_4} C] {J : Type u_3}
[inst_1 : CategoryTheory.Category.{u_1, u_3} J] {X : C} {K : CategoryTheory.Functor J (CategoryTheory.Under X)}
(X_1 : CategoryTheory.Limits.Cocone (CategoryTheory.WithInitial.liftFromUnder.obj K)),
{ hom := CategoryTheory.Under.homMk (... | false |
CategoryTheory.Limits.CompleteLattice.hasColimits_of_completeLattice | Mathlib.CategoryTheory.Limits.Lattice | ∀ {α : Type u} [inst : CompleteLattice α], CategoryTheory.Limits.HasColimitsOfSize.{w, w', u, u} α | true |
nhds_bot_basis | Mathlib.Topology.Order.Basic | ∀ {α : Type u} [inst : TopologicalSpace α] [inst_1 : LinearOrder α] [inst_2 : OrderBot α] [OrderTopology α]
[Nontrivial α], (nhds ⊥).HasBasis (fun a => ⊥ < a) fun a => Set.Iio a | true |
Set.sInter_subset_of_mem | Mathlib.Data.Set.Lattice | ∀ {α : Type u_1} {S : Set (Set α)} {t : Set α}, t ∈ S → ⋂₀ S ⊆ t | true |
CategoryTheory.Limits.HasColimit.isoOfNatIso_ι_inv_assoc | Mathlib.CategoryTheory.Limits.HasLimits | ∀ {J : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} J] {C : Type u} [inst_1 : CategoryTheory.Category.{v, u} C]
{F G : CategoryTheory.Functor J C} [inst_2 : CategoryTheory.Limits.HasColimit F]
[inst_3 : CategoryTheory.Limits.HasColimit G] (w : F ≅ G) (j : J) {Z : C} (h : CategoryTheory.Limits.colimit F ⟶ Z),
... | true |
_private.Std.Data.DHashMap.Internal.AssocList.Lemmas.0.Std.DHashMap.Internal.AssocList.foldrM.eq_def | Std.Data.DHashMap.Internal.AssocList.Lemmas | ∀ {α : Type u} {β : α → Type v} {δ : Type w} {m : Type w → Type w'} [inst : Monad m] (f : (a : α) → β a → δ → m δ)
(x : δ) (x_1 : Std.DHashMap.Internal.AssocList α β),
Std.DHashMap.Internal.AssocList.foldrM f x x_1 =
match x, x_1 with
| d, Std.DHashMap.Internal.AssocList.nil => pure d
| d, Std.DHashMap.... | true |
Lean.Json.brecOn_2.eq | Lean.Data.Json.Basic | ∀ {motive_1 : Lean.Json → Sort u} {motive_2 : Array Lean.Json → Sort u}
{motive_3 : Std.TreeMap.Raw String Lean.Json compare → Sort u} {motive_4 : List Lean.Json → Sort u}
{motive_5 : Std.DTreeMap.Raw String (fun x => Lean.Json) compare → Sort u}
{motive_6 : (Std.DTreeMap.Internal.Impl String fun x => Lean.Json) ... | true |
Real.holderTriple_iff | Mathlib.Data.Real.ConjExponents | ∀ (p q r : ℝ), p.HolderTriple q r ↔ p⁻¹ + q⁻¹ = r⁻¹ ∧ 0 < p ∧ 0 < q | true |
Lean.Elab.Tactic.Conv.getRhs | Lean.Elab.Tactic.Conv.Basic | Lean.Elab.Tactic.TacticM Lean.Expr | true |
MeasureTheory.Measure.innerRegularWRT_preimage_one_hasCompactSupport_measure_ne_top_of_group | Mathlib.MeasureTheory.Measure.EverywherePos | ∀ {G : Type u_2} [inst : Group G] [inst_1 : TopologicalSpace G] [IsTopologicalGroup G] [LocallyCompactSpace G]
[inst_4 : MeasurableSpace G] [BorelSpace G] {μ : MeasureTheory.Measure G} [μ.IsMulLeftInvariant]
[MeasureTheory.IsFiniteMeasureOnCompacts μ] [μ.InnerRegularCompactLTTop],
μ.InnerRegularWRT (fun s => ∃ f,... | true |
FreeAlgebra.instFree | Mathlib.LinearAlgebra.FreeAlgebra | ∀ (R : Type u) (X : Type v) [inst : CommSemiring R], Module.Free R (FreeAlgebra R X) | true |
Polynomial.mapAlgHom_coe_ringHom | Mathlib.Algebra.Polynomial.AlgebraMap | ∀ {R : Type u} {A : Type z} {B : Type u_2} [inst : CommSemiring R] [inst_1 : Semiring A] [inst_2 : Semiring B]
[inst_3 : Algebra R A] [inst_4 : Algebra R B] (f : A →ₐ[R] B), ↑(Polynomial.mapAlgHom f) = Polynomial.mapRingHom ↑f | true |
Int.Linear.cooper_right_split.eq_1 | Init.Data.Int.Linear | ∀ (ctx : Int.Linear.Context) (p₁ p₂ : Int.Linear.Poly) (k : ℕ),
Int.Linear.cooper_right_split ctx p₁ p₂ k =
(Int.Linear.Poly.denote' ctx
(((p₁.tail.mul_k p₂.leadCoeff).combine (p₂.tail.mul_k (-p₁.leadCoeff))).addConst (-p₁.leadCoeff * ↑k)) ≤
0 ∧
p₂.leadCoeff ∣ Int.Linear.Poly.denote' ctx (... | true |
List.zip_eq_zip_take_min | Init.Data.List.Nat.TakeDrop | ∀ {α : Type u_1} {β : Type u_2} {l₁ : List α} {l₂ : List β},
l₁.zip l₂ = (List.take (min l₁.length l₂.length) l₁).zip (List.take (min l₁.length l₂.length) l₂) | true |
CategoryTheory.instIsRegularEpiCategorySheafTypeOfHasSheafify | Mathlib.CategoryTheory.Sites.RegularEpi | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{u_3, u_1} C] (J : CategoryTheory.GrothendieckTopology C)
[CategoryTheory.HasSheafify J (Type u)], CategoryTheory.IsRegularEpiCategory (CategoryTheory.Sheaf J (Type u)) | true |
_private.Mathlib.Data.Finset.Basic.0.Finset.erase_singleton._proof_1_1 | Mathlib.Data.Finset.Basic | ∀ {α : Type u_1} [inst : DecidableEq α] (a : α), {a}.erase a = ∅ | false |
MonomialOrder.lex._proof_1 | Mathlib.Data.Finsupp.MonomialOrder | ∀ {σ : Type u_1} [inst : LinearOrder σ], IsOrderedCancelAddMonoid (Lex (σ →₀ ℕ)) | false |
Lean.Order.Array.monotone_mapM | Init.Internal.Order.Lemmas | ∀ {m : Type u → Type v} [inst : Monad m] [inst_1 : (α : Type u) → Lean.Order.PartialOrder (m α)] [Lean.Order.MonoBind m]
{α β : Type u} {γ : Type w} [inst_3 : Lean.Order.PartialOrder γ] (xs : Array α) (f : γ → α → m β),
Lean.Order.monotone f → Lean.Order.monotone fun x => Array.mapM (f x) xs | true |
Std.Internal.List.DistinctKeys.casesOn | Std.Data.Internal.List.Defs | {α : Type u} →
{β : α → Type v} →
[inst : BEq α] →
{l : List ((a : α) × β a)} →
{motive : Std.Internal.List.DistinctKeys l → Sort u_1} →
(t : Std.Internal.List.DistinctKeys l) →
((distinct : List.Pairwise (fun a b => (a == b) = false) (Std.Internal.List.keys l)) → motive ⋯) → m... | false |
Lean.PPFns | Lean.Util.PPExt | Type | true |
Lean.KVMap.instValueBool.match_1 | Lean.Data.KVMap | (motive : Lean.DataValue → Sort u_1) →
(x : Lean.DataValue) → ((b : Bool) → motive (Lean.DataValue.ofBool b)) → ((x : Lean.DataValue) → motive x) → motive x | false |
MvPowerSeries.weightedOrder_le | Mathlib.RingTheory.MvPowerSeries.Order | ∀ {σ : Type u_1} {R : Type u_2} [inst : Semiring R] (w : σ → ℕ) {f : MvPowerSeries σ R} {d : σ →₀ ℕ},
(MvPowerSeries.coeff d) f ≠ 0 → MvPowerSeries.weightedOrder w f ≤ ↑((Finsupp.weight w) d) | true |
Continuous.edist | Mathlib.Topology.Instances.ENNReal.Lemmas | ∀ {α : Type u_1} {β : Type u_2} [inst : PseudoEMetricSpace α] [inst_1 : TopologicalSpace β] {f g : β → α},
Continuous f → Continuous g → Continuous fun b => edist (f b) (g b) | true |
BoxIntegral.TaggedPrepartition.IsSubordinate | Mathlib.Analysis.BoxIntegral.Partition.Tagged | {ι : Type u_1} →
{I : BoxIntegral.Box ι} → [Fintype ι] → BoxIntegral.TaggedPrepartition I → ((ι → ℝ) → ↑(Set.Ioi 0)) → Prop | true |
_private.Batteries.Data.List.Perm.0.List.Perm.idxBij_leftInverse_idxBij_symm._proof_1_9 | Batteries.Data.List.Perm | ∀ {α : Type u_1} [inst : BEq α] [inst_1 : LawfulBEq α] {xs ys : List α} (h : xs.Perm ys) (w : Fin ys.length)
(h_1 : List.countBefore ys[w] ys ↑w + 1 ≤ (List.filter (fun x => x == xs[⋯.idxBij w]) ys).length),
(List.findIdxs (fun x => x == xs[⋯.idxBij w]) ys)[List.countBefore ys[w] ys ↑w] < ys.length | false |
_private.Init.Data.List.Range.0.List.getElem?_zipIdx.match_1_1 | Init.Data.List.Range | ∀ {α : Type u_1} (motive : List α → ℕ → ℕ → Prop) (x : List α) (x_1 x_2 : ℕ),
(∀ (x x_3 : ℕ), motive [] x x_3) →
(∀ (head : α) (tail : List α) (x : ℕ), motive (head :: tail) x 0) →
(∀ (head : α) (l : List α) (n m : ℕ), motive (head :: l) n m.succ) → motive x x_1 x_2 | false |
VitaliFamily.filterAt_enlarge | Mathlib.MeasureTheory.Covering.VitaliFamily | ∀ {X : Type u_1} [inst : PseudoMetricSpace X] {m0 : MeasurableSpace X} {μ : MeasureTheory.Measure X}
(v : VitaliFamily μ) {δ : ℝ} (δpos : 0 < δ), (v.enlarge δ δpos).filterAt = v.filterAt | true |
DoubleCentralizer.coe._proof_2 | Mathlib.Analysis.CStarAlgebra.Multiplier | ∀ (𝕜 : Type u_1) {A : Type u_2} [inst : NontriviallyNormedField 𝕜] [inst_1 : NonUnitalNormedRing A]
[inst_2 : NormedSpace 𝕜 A], SMulCommClass 𝕜 𝕜 A | false |
_private.Mathlib.NumberTheory.Padics.HeightOneSpectrum.0.Rat.int_algebraMap_surjective._simp_1_1 | Mathlib.NumberTheory.Padics.HeightOneSpectrum | ∀ (R : Type u) (S : Type v) (A : Type w) [inst : CommSemiring R] [inst_1 : CommSemiring S] [inst_2 : Semiring A]
[inst_3 : Algebra R S] [inst_4 : Algebra S A] [inst_5 : Algebra R A] [IsScalarTower R S A] (x : R),
(algebraMap S A) ((algebraMap R S) x) = (algebraMap R A) x | false |
CategoryTheory.Pseudofunctor.mapComp'_comp_id_hom_app_assoc | Mathlib.CategoryTheory.Bicategory.Strict.Pseudofunctor | ∀ {B : Type u_1} [inst : CategoryTheory.Bicategory B] [inst_1 : CategoryTheory.Bicategory.Strict B]
(F : CategoryTheory.Pseudofunctor B CategoryTheory.Cat) {b₀ b₁ : B} (f : b₀ ⟶ b₁) (X : ↑(F.obj b₀)) {Z : ↑(F.obj b₁)}
(h : (F.map (CategoryTheory.CategoryStruct.id b₁)).toFunctor.obj ((F.map f).toFunctor.obj X) ⟶ Z),... | true |
hasBasis_nhdsSet_Ici_Ici | Mathlib.Topology.Order.NhdsSet | ∀ {α : Type u_1} [inst : LinearOrder α] [inst_1 : TopologicalSpace α] [OrderTopology α] (a : α)
[(nhdsWithin a (Set.Iio a)).NeBot], (nhdsSet (Set.Ici a)).HasBasis (fun x => x < a) Set.Ici | true |
CategoryTheory.Cat.HasLimits.limitConeIsLimit | Mathlib.CategoryTheory.Category.Cat.Limit | {J : Type v} →
[inst : CategoryTheory.SmallCategory J] →
(F : CategoryTheory.Functor J CategoryTheory.Cat) →
CategoryTheory.Limits.IsLimit (CategoryTheory.Cat.HasLimits.limitCone F) | true |
_private.Mathlib.MeasureTheory.Measure.AEMeasurable.0.cond.match_1.eq_1 | Mathlib.MeasureTheory.Measure.AEMeasurable | ∀ (motive : Bool → Sort u_1) (h_1 : Unit → motive true) (h_2 : Unit → motive false),
(match true with
| true => h_1 ()
| false => h_2 ()) =
h_1 () | true |
Std.TreeMap.get!_union_of_not_mem_right | Std.Data.TreeMap.Lemmas | ∀ {α : Type u} {β : Type v} {cmp : α → α → Ordering} {t₁ t₂ : Std.TreeMap α β cmp} [Std.TransCmp cmp] {k : α}
[inst : Inhabited β], k ∉ t₂ → (t₁ ∪ t₂).get! k = t₁.get! k | true |
IsAbsoluteValue.mk | Mathlib.Algebra.Order.AbsoluteValue.Basic | ∀ {S : Type u_5} [inst : Semiring S] [inst_1 : PartialOrder S] {R : Type u_6} [inst_2 : Semiring R] {f : R → S},
(∀ (x : R), 0 ≤ f x) →
(∀ {x : R}, f x = 0 ↔ x = 0) →
(∀ (x y : R), f (x + y) ≤ f x + f y) → (∀ (x y : R), f (x * y) = f x * f y) → IsAbsoluteValue f | true |
Filter.frequently_imp_distrib_right | Mathlib.Order.Filter.Basic | ∀ {α : Type u} {f : Filter α} [f.NeBot] {p : α → Prop} {q : Prop},
(∃ᶠ (x : α) in f, p x → q) ↔ (∀ᶠ (x : α) in f, p x) → q | true |
matPolyEquiv_symm_apply_coeff | Mathlib.RingTheory.MatrixPolynomialAlgebra | ∀ {R : Type u_1} [inst : CommSemiring R] {n : Type w} [inst_1 : DecidableEq n] [inst_2 : Fintype n]
(p : Polynomial (Matrix n n R)) (i j : n) (k : ℕ), (matPolyEquiv.symm p i j).coeff k = p.coeff k i j | true |
Lean.Parser.Tactic.Conv.rewrite | Init.Conv | Lean.ParserDescr | true |
Std.TreeMap.Raw.toList_rco | Std.Data.TreeMap.Raw.Slice | ∀ {α : Type u} {β : Type v} (cmp : autoParam (α → α → Ordering) Std.TreeMap.Raw.toList_rco._auto_1) [Std.TransCmp cmp]
{t : Std.TreeMap.Raw α β cmp},
t.WF →
∀ {lowerBound upperBound : α},
Std.Slice.toList (Std.Rco.Sliceable.mkSlice t lowerBound...upperBound) =
List.filter (fun e => decide ((cmp e.... | true |
Finset.inf'_congr | Mathlib.Data.Finset.Lattice.Fold | ∀ {α : Type u_2} {β : Type u_3} [inst : SemilatticeInf α] {s : Finset β} (H : s.Nonempty) {t : Finset β} {f g : β → α}
(h₁ : s = t), (∀ x ∈ s, f x = g x) → s.inf' H f = t.inf' ⋯ g | true |
CategoryTheory.yoneda'_comp | Mathlib.CategoryTheory.Sites.Types | CategoryTheory.yoneda'.comp (CategoryTheory.sheafToPresheaf CategoryTheory.typesGrothendieckTopology (Type u)) =
CategoryTheory.yoneda | true |
ContinuousMap.HomotopyWith.ext_iff | Mathlib.Topology.Homotopy.Basic | ∀ {X : Type u} {Y : Type v} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y] {f₀ f₁ : C(X, Y)}
{P : C(X, Y) → Prop} {F G : f₀.HomotopyWith f₁ P}, F = G ↔ ∀ (x : ↑unitInterval × X), F x = G x | true |
Vector.mapFinIdxM | Init.Data.Vector.Basic | {n : ℕ} →
{α : Type u} →
{β : Type v} → {m : Type v → Type w} → [Monad m] → Vector α n → ((i : ℕ) → α → i < n → m β) → m (Vector β n) | true |
_private.Mathlib.CategoryTheory.Limits.Types.Images.0.CategoryTheory.Limits.Types.limitOfSurjectionsSurjective.preimage.match_1 | Mathlib.CategoryTheory.Limits.Types.Images | (motive : ℕ → Sort u_1) → (x : ℕ) → (Unit → motive 0) → ((n : ℕ) → motive n.succ) → motive x | false |
MonoidHom.coe_of_map_mul_inv | Mathlib.Algebra.Group.Hom.Basic | ∀ {G : Type u_5} [inst : Group G] {H : Type u_8} [inst_1 : Group H] (f : G → H)
(map_div : ∀ (a b : G), f (a * b⁻¹) = f a * (f b)⁻¹), ⇑(MonoidHom.ofMapMulInv f map_div) = f | true |
CategoryTheory.AddMonObj.zero_eq_zero | Mathlib.CategoryTheory.Monoidal.Cartesian.Mon_ | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v, u_1} C] [inst_1 : CategoryTheory.CartesianMonoidalCategory C]
(M : C) [inst_2 : CategoryTheory.AddMonObj M], CategoryTheory.AddMonObj.zero = 0 | true |
FirstOrder.Language.ElementarilyEquivalent.toModel | Mathlib.ModelTheory.Bundled | {L : FirstOrder.Language} →
(T : L.Theory) →
{M : T.ModelType} → {N : Type u_1} → [LN : L.Structure N] → L.ElementarilyEquivalent (↑M) N → T.ModelType | true |
SimpleGraph.finsubgraphOfAdj.eq_1 | Mathlib.Combinatorics.SimpleGraph.Finsubgraph | ∀ {V : Type u} {G : SimpleGraph V} {u v : V} (e : G.Adj u v), SimpleGraph.finsubgraphOfAdj e = ⟨G.subgraphOfAdj e, ⋯⟩ | true |
Filter.pi_mono | Mathlib.Order.Filter.Pi | ∀ {ι : Type u_1} {α : ι → Type u_2} {f₁ f₂ : (i : ι) → Filter (α i)},
(∀ (i : ι), f₁ i ≤ f₂ i) → Filter.pi f₁ ≤ Filter.pi f₂ | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.