name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.67M | allowCompletion bool 2
classes |
|---|---|---|---|
_private.Mathlib.NumberTheory.Chebyshev.0.Chebyshev.integral_theta_div_log_sq_isLittleO._simp_1_6 | Mathlib.NumberTheory.Chebyshev | ∀ {G₀ : Type u_3} [inst : GroupWithZero G₀] {a : G₀} (n : ℤ), a ≠ 0 → (a ^ n = 0) = False | false |
_private.Lean.Data.Iterators.Producers.PersistentHashMap.0.Lean.PersistentHashMap.Zipper.step.match_3.eq_2 | Lean.Data.Iterators.Producers.PersistentHashMap | ∀ {α : Type u_1} {β : Type u_2} (motive : Lean.PersistentHashMap.Zipper α β → Sort u_3)
(es : Subarray (Lean.PersistentHashMap.Entry α β (Lean.PersistentHashMap.Node α β)))
(z' : Lean.PersistentHashMap.Zipper α β) (h_1 : Unit → motive Lean.PersistentHashMap.Zipper.done)
(h_2 :
(es : Subarray (Lean.PersistentH... | true |
MvPolynomial.totalDegree_le_degrees_card | Mathlib.Algebra.MvPolynomial.Degrees | ∀ {R : Type u} {σ : Type u_1} [inst : CommSemiring R] (p : MvPolynomial σ R), p.totalDegree ≤ p.degrees.card | true |
instAddActionSubtypeMemAddSubgroupStabilizerSetElem.eq_1 | Mathlib.GroupTheory.GroupAction.SubMulAction.OfStabilizer | ∀ (G : Type u_1) [inst : AddGroup G] (α : Type u_2) [inst_1 : AddAction G α] (s : Set α),
instAddActionSubtypeMemAddSubgroupStabilizerSetElem G α s =
{ toVAdd := VAdd.ofStabilizer G α s, add_vadd := ⋯, zero_vadd := ⋯ } | true |
_private.Lean.Meta.Tactic.Grind.Arith.Cutsat.Proof.0.Lean.Meta.Grind.Arith.Cutsat.MulEqProof.mulVar.sizeOf_spec | Lean.Meta.Tactic.Grind.Arith.Cutsat.Proof | ∀ (k : ℤ) (a h : Lean.Expr),
sizeOf (Lean.Meta.Grind.Arith.Cutsat.MulEqProof.mulVar✝ k a h) = 1 + sizeOf k + sizeOf a + sizeOf h | true |
IsPrincipalIdealRing.ringKrullDim_eq_one | Mathlib.RingTheory.KrullDimension.PID | ∀ (R : Type u_1) [inst : CommRing R] [IsDomain R] [IsPrincipalIdealRing R], ¬IsField R → ringKrullDim R = 1 | true |
PreTilt.instCommRing._aux_24 | Mathlib.RingTheory.Perfection | (O : Type u_1) → [inst : CommRing O] → (p : ℕ) → [Fact (Nat.Prime p)] → [Fact ¬IsUnit ↑p] → ℕ → PreTilt O p | false |
Nat.superFactorial._f | Mathlib.Data.Nat.Factorial.SuperFactorial | (x : ℕ) → Nat.below x → ℕ | false |
_private.Mathlib.LinearAlgebra.RootSystem.Finite.Lemmas.0.RootPairing.RootPositiveForm.rootLength_lt_of_pairingIn_notMem._proof_1_13 | Mathlib.LinearAlgebra.RootSystem.Finite.Lemmas | ∀ {ι : Type u_1} {R : Type u_2} {M : Type u_3} {N : Type u_4} [inst : CommRing R] [inst_1 : AddCommGroup M]
[inst_2 : Module R M] [inst_3 : AddCommGroup N] [inst_4 : Module R N] {P : RootPairing ι R M N} [inst_5 : CharZero R]
[inst_6 : P.IsCrystallographic] (B : RootPairing.RootPositiveForm ℤ P) {i j : ι},
1 * B.... | false |
CategoryTheory.Abelian.SpectralObject.d_d._auto_7 | Mathlib.Algebra.Homology.SpectralObject.Differentials | Lean.Syntax | false |
ArithmeticFunction.eulerProduct | Mathlib.NumberTheory.ArithmeticFunction.LFunction | {ι : Type u_1} → {R : Type u_2} → [inst : CommSemiring R] → (ι → ArithmeticFunction R) → ArithmeticFunction R | true |
_private.Lean.Meta.Tactic.Contradiction.0.Lean.Meta.processGenDiseq | Lean.Meta.Tactic.Contradiction | Lean.MVarId → Lean.LocalDecl → Lean.MetaM Bool | true |
Filter.comap_eval_neBot_iff' | Mathlib.Order.Filter.Map | ∀ {ι : Type u_6} {α : ι → Type u_7} {i : ι} {f : Filter (α i)},
(Filter.comap (Function.eval i) f).NeBot ↔ (∀ (j : ι), Nonempty (α j)) ∧ f.NeBot | true |
_private.Mathlib.CategoryTheory.Category.Cat.Adjunction.0.CategoryTheory.Cat.typeToCatObjectsAdjHomEquiv._proof_2 | Mathlib.CategoryTheory.Category.Cat.Adjunction | ∀ (X : Type u_1) (C : CategoryTheory.Cat) (x : X ⟶ CategoryTheory.Cat.objects.obj C),
(fun x_1 => (CategoryTheory.Discrete.functor x).toCatHom.toFunctor.obj { as := x_1 }) = fun x_1 =>
(CategoryTheory.Discrete.functor x).toCatHom.toFunctor.obj { as := x_1 } | false |
CategoryTheory.Limits.MulticospanShape.noConfusion | Mathlib.CategoryTheory.Limits.Shapes.Multiequalizer | {P : Sort u} →
{t t' : CategoryTheory.Limits.MulticospanShape} →
t = t' → CategoryTheory.Limits.MulticospanShape.noConfusionType P t t' | false |
_private.Mathlib.Algebra.Category.Ring.Basic.0.RingCat.Hom.mk.injEq | Mathlib.Algebra.Category.Ring.Basic | ∀ {R S : RingCat} (hom' hom'_1 : ↑R →+* ↑S), ({ hom' := hom' } = { hom' := hom'_1 }) = (hom' = hom'_1) | true |
CategoryTheory.IsIso.of_isIso_comp_left | Mathlib.CategoryTheory.Iso | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {X Y Z : C} (f : X ⟶ Y) (g : Y ⟶ Z) [CategoryTheory.IsIso f]
[CategoryTheory.IsIso (CategoryTheory.CategoryStruct.comp f g)], CategoryTheory.IsIso g | true |
Std.ExtHashMap.get?_inter | Std.Data.ExtHashMap.Lemmas | ∀ {α : Type u} {β : Type v} {x : BEq α} {x_1 : Hashable α} {m₁ m₂ : Std.ExtHashMap α β} [inst : EquivBEq α]
[inst_1 : LawfulHashable α] {k : α}, (m₁ ∩ m₂).get? k = if k ∈ m₂ then m₁.get? k else none | true |
Subring.centralizer_toSubmonoid | Mathlib.Algebra.Ring.Subring.Basic | ∀ {R : Type u_1} [inst : Ring R] (s : Set R), (Subring.centralizer s).toSubmonoid = Submonoid.centralizer s | true |
_private.Lean.Server.Requests.0.Lean.Language.SnapshotTree.findInfoTreeAtPos.match_4 | Lean.Server.Requests | (motive : Option Lean.Syntax.Range → Sort u_1) →
(x : Option Lean.Syntax.Range) →
((range : Lean.Syntax.Range) → motive (some range)) → ((x : Option Lean.Syntax.Range) → motive x) → motive x | false |
Filter.Tendsto.bddBelow_range_of_cofinite | Mathlib.Topology.Order.LiminfLimsup | ∀ {ι : Type u_1} {α : Type u_2} [inst : Preorder α] [inst_1 : TopologicalSpace α] [BoundedGENhdsClass α] {u : ι → α}
{a : α} [IsCodirectedOrder α], Filter.Tendsto u Filter.cofinite (nhds a) → BddBelow (Set.range u) | true |
Std.ExtTreeMap.maxKey!_eq_iff_mem_and_forall | Std.Data.ExtTreeMap.Lemmas | ∀ {α : Type u} {β : Type v} {cmp : α → α → Ordering} {t : Std.ExtTreeMap α β cmp} [inst : Std.TransCmp cmp]
[Std.LawfulEqCmp cmp] [inst_2 : Inhabited α],
t ≠ ∅ → ∀ {km : α}, t.maxKey! = km ↔ km ∈ t ∧ ∀ k ∈ t, (cmp k km).isLE = true | true |
Subgroup.quotientSubgroupOfMapOfLE.congr_simp | Mathlib.GroupTheory.Coset.Basic | ∀ {α : Type u_1} [inst : Group α] {s t : Subgroup α} (H : Subgroup α) (h : s ≤ t) (a a_1 : ↥H ⧸ s.subgroupOf H),
a = a_1 → Subgroup.quotientSubgroupOfMapOfLE H h a = Subgroup.quotientSubgroupOfMapOfLE H h a_1 | true |
Quaternion.instInnerReal | Mathlib.Analysis.Quaternion | Inner ℝ (Quaternion ℝ) | true |
Finpartition.energy_nonneg | Mathlib.Combinatorics.SimpleGraph.Regularity.Energy | ∀ {α : Type u_1} [inst : DecidableEq α] {s : Finset α} (P : Finpartition s) (G : SimpleGraph α)
[inst_1 : DecidableRel G.Adj], 0 ≤ P.energy G | true |
Topology.isCoinducing_iff' | Mathlib.Topology.Defs.Induced | ∀ {X : Type u_1} {Y : Type u_2} [tX : TopologicalSpace X] [tY : TopologicalSpace Y] (f : X → Y),
Topology.IsCoinducing f ↔ tY = TopologicalSpace.coinduced f tX | true |
Batteries.PairingHeap | Batteries.Data.PairingHeap | (α : Type u) → (α → α → Bool) → Type (max 0 u) | true |
Std.ExtHashMap.ofList_cons | Std.Data.ExtHashMap.Lemmas | ∀ {α : Type u} {β : Type v} {x : BEq α} {x_1 : Hashable α} [inst : EquivBEq α] [inst_1 : LawfulHashable α] {k : α}
{v : β} {tl : List (α × β)}, Std.ExtHashMap.ofList ((k, v) :: tl) = (∅.insert k v).insertMany tl | true |
Nat.log.eq_def | Mathlib.Data.Nat.Log | ∀ (b n : ℕ), Nat.log b n = if b ≤ 1 then 0 else (Nat.log.go n b n).2 | true |
Filter.map_swap4_eq_comap | Mathlib.Order.Filter.Map | ∀ {α : Type u_1} {β : Type u_2} {γ : Type u_3} {δ : Type u_4} {f : Filter ((α × β) × γ × δ)},
Filter.map (fun p => ((p.1.1, p.2.1), p.1.2, p.2.2)) f = Filter.comap (fun p => ((p.1.1, p.2.1), p.1.2, p.2.2)) f | true |
CategoryTheory.MonoidalClosed | Mathlib.CategoryTheory.Monoidal.Closed.Basic | (C : Type u) → [inst : CategoryTheory.Category.{v, u} C] → [CategoryTheory.MonoidalCategory C] → Type (max u v) | true |
Equiv.toHomeomorphOfContinuousOpen_apply | Mathlib.Topology.Homeomorph.Defs | ∀ {X : Type u_1} {Y : Type u_2} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y] (e : X ≃ Y)
(h₁ : Continuous ⇑e) (h₂ : IsOpenMap ⇑e), ⇑(e.toHomeomorphOfContinuousOpen h₁ h₂) = ⇑e | true |
MvPolynomial.degreeOf_neg | Mathlib.Algebra.MvPolynomial.CommRing | ∀ {R : Type u} {σ : Type u_1} [inst : CommRing R] (i : σ) (p : MvPolynomial σ R),
MvPolynomial.degreeOf i (-p) = MvPolynomial.degreeOf i p | true |
Finset.divConst_empty_left | Mathlib.Combinatorics.Additive.DoublingConst | ∀ {G : Type u_1} [inst : Group G] [inst_1 : DecidableEq G] (B : Finset G), ∅.divConst B = 0 | true |
Module.Flat.shrink | Mathlib.RingTheory.Flat.Basic | ∀ {R : Type u} {M : Type v} [inst : CommSemiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M]
[inst_3 : Small.{v', v} M] [Module.Flat R M], Module.Flat R (Shrink.{v', v} M) | true |
UpperHalfPlane.denom_cocycle' | Mathlib.Analysis.Complex.UpperHalfPlane.MoebiusAction | ∀ (g h : GL (Fin 2) ℝ) (z : UpperHalfPlane),
UpperHalfPlane.denom (g * h) ↑z =
(UpperHalfPlane.σ h) (UpperHalfPlane.denom g ↑(UpperHalfPlane.smulAux h z)) * UpperHalfPlane.denom h ↑z | true |
_private.Mathlib.LinearAlgebra.Dimension.Finite.0.Module.finite_finsupp_iff.match_1_1 | Mathlib.LinearAlgebra.Dimension.Finite | ∀ {R : Type u_3} {M : Type u_2} [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M] {ι : Type u_1}
(motive : IsEmpty ι ∨ Subsingleton M ∨ Module.Finite R M ∧ Finite ι → Prop)
(x : IsEmpty ι ∨ Subsingleton M ∨ Module.Finite R M ∧ Finite ι),
(∀ (h : IsEmpty ι), motive ⋯) →
(∀ (h : Subsingleton ... | false |
Std.Rco.HasRcoIntersection.ctorIdx | Init.Data.Range.Polymorphic.PRange | {α : Type w} → Std.Rco.HasRcoIntersection α → ℕ | false |
CategoryTheory.Limits.pullback_map_diagonal_isPullback | Mathlib.CategoryTheory.Limits.Shapes.Diagonal | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] {X Y : C} [CategoryTheory.Limits.HasPullbacks C]
{S T : C} (f : X ⟶ T) (g : Y ⟶ T) (i : T ⟶ S) [inst_2 : CategoryTheory.Limits.HasPullback i i]
[inst_3 : CategoryTheory.Limits.HasPullback f g]
[inst_4 :
CategoryTheory.Limits.HasPullback (CategoryT... | true |
_private.Mathlib.Tactic.Widget.InteractiveUnfold.0.Mathlib.Tactic.InteractiveUnfold.unfoldProjDefaultInst?.match_7 | Mathlib.Tactic.Widget.InteractiveUnfold | (motive : Lean.Expr → Sort u_1) →
(x : Lean.Expr) →
((typeName : Lean.Name) → (i : ℕ) → (c : Lean.Expr) → motive (Lean.Expr.proj typeName i c)) →
((x : Lean.Expr) → motive x) → motive x | false |
rank_le_card | Mathlib.LinearAlgebra.Dimension.Basic | ∀ (R : Type u) (M : Type v) [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M],
Module.rank R M ≤ Cardinal.mk M | true |
Std.Sat.AIG.RefVecEntry.noConfusion | Std.Sat.AIG.Basic | {P : Sort u} →
{α : Type} →
{inst : DecidableEq α} →
{inst_1 : Hashable α} →
{inst_2 : DecidableEq α} →
{w : ℕ} →
{t : Std.Sat.AIG.RefVecEntry α w} →
{α' : Type} →
{inst' : DecidableEq α'} →
{inst'_1 : Hashable α'} →
... | false |
Set.fintypeTop | Mathlib.Data.Set.Finite.Basic | {α : Type u} → [Fintype α] → Fintype ↑⊤ | true |
Lean.Meta.Grind.Arith.Linear.isSMulNatInst | Lean.Meta.Tactic.Grind.Arith.Linear.Reify | Lean.Meta.Grind.Arith.Linear.Struct → Lean.Expr → Bool | true |
_private.Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Var.0.Std.Tactic.BVDecide.BVExpr.bitblast.blastVar.go_denote_eq._proof_1_1 | Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Var | ∀ {w : ℕ} (curr idx : ℕ), curr = idx → ¬idx < curr + 1 → False | false |
CategoryTheory.Limits.«_aux_Mathlib_CategoryTheory_Limits_Shapes_Terminal___macroRules_CategoryTheory_Limits_term⊥___1» | Mathlib.CategoryTheory.Limits.Shapes.Terminal | Lean.Macro | false |
_private.Lean.Elab.Tactic.Do.ProofMode.Delab.0.Lean.Elab.Tactic.Do.ProofMode.delabHypMarker | Lean.Elab.Tactic.Do.ProofMode.Delab | Lean.PrettyPrinter.Delaborator.Delab | true |
CategoryTheory.Functor.mapGrp.eq_1 | Mathlib.CategoryTheory.Monoidal.Grp_ | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] [inst_1 : CategoryTheory.CartesianMonoidalCategory C]
{D : Type u₂} [inst_2 : CategoryTheory.Category.{v₂, u₂} D] [inst_3 : CategoryTheory.CartesianMonoidalCategory D]
(F : CategoryTheory.Functor C D) [inst_4 : F.Monoidal],
F.mapGrp =
{ obj := fun A ... | true |
Fin.map_castSuccEmb_Iic | Mathlib.Order.Interval.Finset.Fin | ∀ {n : ℕ} (i : Fin n), Finset.map Fin.castSuccEmb (Finset.Iic i) = Finset.Iic i.castSucc | true |
summable_choose_mul_geometric_of_norm_lt_one | Mathlib.Analysis.SpecificLimits.Normed | ∀ {R : Type u_4} [inst : NormedRing R] [HasSummableGeomSeries R] (k : ℕ) {r : R},
‖r‖ < 1 → Summable fun n => ↑((n + k).choose k) * r ^ n | true |
_private.Init.Data.String.Basic.0.String.Pos.toSlice_lt._simp_1_1 | Init.Data.String.Basic | ∀ {s : String} {l r : s.Pos}, (l < r) = (l.offset < r.offset) | false |
Hyperreal.instField._proof_10 | Mathlib.Analysis.Real.Hyperreal | autoParam (∀ (x : ℝ*), Hyperreal.instField._aux_8 0 x = 0) AddMonoid.nsmul_zero._autoParam | false |
Vector.contains_iff_mem | Init.Data.Vector.Lemmas | ∀ {α : Type u_1} {n : ℕ} [inst : BEq α] [LawfulBEq α] {a : α} {as : Vector α n}, as.contains a = true ↔ a ∈ as | true |
Set.decidableMemIic | Mathlib.Order.Interval.Set.Basic | {α : Type u_1} → [inst : Preorder α] → {b x : α} → [Decidable (x ≤ b)] → Decidable (x ∈ Set.Iic b) | true |
UpperHalfPlane.dist_of_re_eq | Mathlib.Analysis.Complex.UpperHalfPlane.Metric | ∀ {z w : UpperHalfPlane}, z.re = w.re → dist z w = dist (Real.log z.im) (Real.log w.im) | true |
Lean.Meta.Grind.Order.getExpr | Lean.Meta.Tactic.Grind.Order.OrderM | Lean.Meta.Grind.Order.NodeId → Lean.Meta.Grind.Order.OrderM Lean.Expr | true |
CategoryTheory.Bicategory.Adjunction.mk | Mathlib.CategoryTheory.Bicategory.Adjunction.Basic | {B : Type u} →
[inst : CategoryTheory.Bicategory B] →
{a b : B} →
{f : a ⟶ b} →
{g : b ⟶ a} →
(unit : CategoryTheory.CategoryStruct.id a ⟶ CategoryTheory.CategoryStruct.comp f g) →
(counit : CategoryTheory.CategoryStruct.comp g f ⟶ CategoryTheory.CategoryStruct.id b) →
... | true |
BitVec.toNat_not | Init.Data.BitVec.Lemmas | ∀ {v : ℕ} {x : BitVec v}, (~~~x).toNat = 2 ^ v - 1 - x.toNat | true |
CategoryTheory.Triangulated.TStructure.triangleLEGE_map_hom₁ | Mathlib.CategoryTheory.Triangulated.TStructure.TruncLEGT | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Preadditive C]
[inst_2 : CategoryTheory.Limits.HasZeroObject C] [inst_3 : CategoryTheory.HasShift C ℤ]
[inst_4 : ∀ (n : ℤ), (CategoryTheory.shiftFunctor C n).Additive] [inst_5 : CategoryTheory.Pretriangulated C]
(t : CategoryT... | true |
SModEq.top._simp_1 | Mathlib.LinearAlgebra.SModEq.Basic | ∀ {R : Type u_1} [inst : Ring R] {M : Type u_4} [inst_1 : AddCommGroup M] [inst_2 : Module R M] {x y : M},
(x ≡ y [SMOD ⊤]) = True | false |
_private.Mathlib.Analysis.Normed.Affine.AddTorsor.0.dist_center_homothety._simp_1_1 | Mathlib.Analysis.Normed.Affine.AddTorsor | ∀ (V : Type u_2) {P : Type u_3} [inst : SeminormedAddCommGroup V] [inst_1 : PseudoMetricSpace P]
[inst_2 : NormedAddTorsor V P] (x y : P), ‖x -ᵥ y‖ = dist x y | false |
List.sum_le_max_mul_length_of_max?_eq_some_int | Init.Data.List.Int.Sum | ∀ {x : ℤ} {xs : List ℤ}, xs.max? = some x → xs.sum ≤ x * ↑xs.length | true |
CategoryTheory.Functor.leftDerivedNatTrans | Mathlib.CategoryTheory.Functor.Derived.LeftDerived | {C : Type u_1} →
{D : Type u_2} →
{H : Type u_3} →
[inst : CategoryTheory.Category.{v_1, u_1} C] →
[inst_1 : CategoryTheory.Category.{v_3, u_2} D] →
[inst_2 : CategoryTheory.Category.{v_5, u_3} H] →
(LF' LF : CategoryTheory.Functor D H) →
{F F' : CategoryTheory.Fu... | true |
DirSupClosed.eq_1 | Mathlib.Order.DirSupClosed | ∀ {α : Type u_1} [inst : Preorder α] (s : Set α),
DirSupClosed s =
∀ ⦃d : Set α⦄, d ⊆ s → d.Nonempty → DirectedOn (fun x1 x2 => x1 ≤ x2) d → ∀ ⦃a : α⦄, IsLUB d a → a ∈ s | true |
_private.Mathlib.Analysis.Calculus.FDeriv.Add.0.hasFDerivAt_comp_add_right._simp_1_1 | Mathlib.Analysis.Calculus.FDeriv.Add | ∀ {𝕜 : 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] {f : E → F} {f' : E →L[𝕜] F} {x : E},
HasFDerivAt f f' x = HasFDerivWit... | false |
Std.PartialOrderPackage.rec | Init.Data.Order.PackageFactories | {α : Type u} →
{motive : Std.PartialOrderPackage α → Sort u_1} →
([toPreorderPackage : Std.PreorderPackage α] →
(le_antisymm : ∀ (a b : α), a ≤ b → b ≤ a → a = b) →
motive { toPreorderPackage := toPreorderPackage, le_antisymm := le_antisymm }) →
(t : Std.PartialOrderPackage α) → motive t | false |
CategoryTheory.Precoverage.ZeroHypercover.Hom | Mathlib.CategoryTheory.Sites.Hypercover.Zero | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
(J : CategoryTheory.Precoverage C) → {S : C} → J.ZeroHypercover S → J.ZeroHypercover S → Type (max (max v w) w') | true |
Set.powersetCard.permOfDisjoint.eq_1 | Mathlib.LinearAlgebra.ExteriorAlgebra.Basic | ∀ {m n : ℕ} {I : Type u_2} [inst : LinearOrder I] {s : ↑(Set.powersetCard I m)} {t : ↑(Set.powersetCard I n)}
(h : Disjoint ↑s ↑t),
Set.powersetCard.permOfDisjoint h =
finSumFinEquiv.symm.trans
((↑((Set.powersetCard.orderIsoOfFin s).sumCongr (Set.powersetCard.orderIsoOfFin t))).trans
((Equiv.Finse... | true |
Diffeomorph.instCoeContMDiffMap | Mathlib.Geometry.Manifold.Diffeomorph | {𝕜 : Type u_1} →
[inst : NontriviallyNormedField 𝕜] →
{E : Type u_2} →
[inst_1 : NormedAddCommGroup E] →
[inst_2 : NormedSpace 𝕜 E] →
{E' : Type u_3} →
[inst_3 : NormedAddCommGroup E'] →
[inst_4 : NormedSpace 𝕜 E'] →
{H : Type u_5} →
... | true |
_private.Mathlib.Data.Matrix.Basis.0.Matrix.mem_range_scalar_iff_commute_single.match_1_1 | Mathlib.Data.Matrix.Basis | ∀ {n : Type u_1} {α : Type u_2} [inst : DecidableEq n] [inst_1 : Fintype n] [inst_2 : Semiring α] {M : Matrix n n α}
(motive : M ∈ Set.range ⇑(Matrix.scalar n) → Prop) (x : M ∈ Set.range ⇑(Matrix.scalar n)),
(∀ (r : α) (hr : (Matrix.scalar n) r = M), motive ⋯) → motive x | false |
or_and_left | Init.PropLemmas | ∀ {a b c : Prop}, a ∨ b ∧ c ↔ (a ∨ b) ∧ (a ∨ c) | true |
discreteTopology_iff_orderTopology_of_pred_succ | Mathlib.Topology.Instances.Discrete | ∀ {α : Type u_1} [inst : TopologicalSpace α] [inst_1 : LinearOrder α] [PredOrder α] [SuccOrder α],
DiscreteTopology α ↔ OrderTopology α | true |
String.Slice.Pattern.ForwardPattern.mk | Init.Data.String.Pattern.Basic | {ρ : Type} →
{pat : ρ} →
((s : String.Slice) → Option s.Pos) →
((s : String.Slice) → s.isEmpty = false → Option s.Pos) →
(String.Slice → Bool) → String.Slice.Pattern.ForwardPattern pat | true |
_private.Lean.Elab.Tactic.Do.ProofMode.Exfalso.0.Lean.Elab.Tactic.Do.ProofMode.falseProp | Lean.Elab.Tactic.Do.ProofMode.Exfalso | Lean.Level → Lean.Expr → Lean.Expr | true |
Lean.Widget.RpcEncodablePacket.«_@».Lean.Server.FileWorker.WidgetRequests.1923616455._hygCtx._hyg.1.noConfusionType | Lean.Server.FileWorker.WidgetRequests | Sort u → Lean.Widget.RpcEncodablePacket✝ → Lean.Widget.RpcEncodablePacket✝ → Sort u | false |
Aesop.PatSubstSource.noConfusionType | Aesop.Forward.State | Sort u → Aesop.PatSubstSource → Aesop.PatSubstSource → Sort u | false |
Cubic.equiv_symm_apply_d | Mathlib.Algebra.CubicDiscriminant | ∀ {R : Type u_1} [inst : Semiring R] (f : { p // p.degree ≤ 3 }), (Cubic.equiv.symm f).d = (↑f).coeff 0 | true |
CochainComplex.HomComplex.Cochain.v | Mathlib.Algebra.Homology.HomotopyCategory.HomComplex | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
[inst_1 : CategoryTheory.Preadditive C] →
{F G : CochainComplex C ℤ} →
{n : ℤ} → CochainComplex.HomComplex.Cochain F G n → (p q : ℤ) → p + n = q → (F.X p ⟶ G.X q) | true |
AddSemigrp._sizeOf_inst | Mathlib.Algebra.Category.Semigrp.Basic | SizeOf AddSemigrp | false |
IsSelfAdjoint.of_nonneg | Mathlib.Algebra.Order.Star.Basic | ∀ {R : Type u_1} [inst : NonUnitalSemiring R] [inst_1 : PartialOrder R] [inst_2 : StarRing R] [StarOrderedRing R]
{x : R}, 0 ≤ x → IsSelfAdjoint x | true |
_private.Batteries.Data.List.Lemmas.0.List.getElem_idxOf_eq_idxOfNth_add._proof_1_18 | Batteries.Data.List.Lemmas | ∀ {α : Type u_1} {x : α} [inst : BEq α] (head : α) (tail : List α) {n s : ℕ}
{h : n < (List.idxsOf x (head :: tail) s).length}, n < (List.findIdxs (fun x_1 => x_1 == x) (head :: tail)).length | false |
Lean.Server.FileWorker.computeQueries | Lean.Server.CodeActions.UnknownIdentifier | Lean.Server.FileWorker.EditableDocument → String.Pos.Raw → Lean.Server.RequestM (Array Lean.Server.FileWorker.Query) | true |
MeasureTheory.tendstoInDistribution_of_isEmpty._simp_1 | Mathlib.MeasureTheory.Function.ConvergenceInDistribution | ∀ {ι : Type u_1} {E : Type u_2} {Ω' : Type u_3} {Ω : ι → Type u_5} {m : (i : ι) → MeasurableSpace (Ω i)}
{μ : (i : ι) → MeasureTheory.Measure (Ω i)} [inst : ∀ (i : ι), MeasureTheory.IsProbabilityMeasure (μ i)]
{m' : MeasurableSpace Ω'} {μ' : MeasureTheory.Measure Ω'} [inst_1 : MeasureTheory.IsProbabilityMeasure μ']... | false |
_private.Mathlib.MeasureTheory.Integral.IntervalIntegral.TrapezoidalRule.0.sum_trapezoidal_error_adjacent_intervals._simp_1_1 | Mathlib.MeasureTheory.Integral.IntervalIntegral.TrapezoidalRule | ∀ {α : Type u_1} [inst : LinearOrder α] {a b c : α}, (a ∈ Set.uIcc b c) = (b ≤ a ∧ a ≤ c ∨ c ≤ a ∧ a ≤ b) | false |
SimpleGraph.Walk.IsCycle.support_nodup | Mathlib.Combinatorics.SimpleGraph.Paths | ∀ {V : Type u} {G : SimpleGraph V} {u : V} {p : G.Walk u u}, p.IsCycle → p.support.tail.Nodup | true |
CategoryTheory.ShortComplex.cyclesIsoX₂_inv_hom_id | Mathlib.Algebra.Homology.ShortComplex.LeftHomology | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
(S : CategoryTheory.ShortComplex C) [inst_2 : S.HasLeftHomology] (hg : S.g = 0),
CategoryTheory.CategoryStruct.comp (S.cyclesIsoX₂ hg).inv S.iCycles = CategoryTheory.CategoryStruct.id S.X₂ | true |
CategoryTheory.Pretriangulated.opShiftFunctorEquivalence_functor | Mathlib.CategoryTheory.Triangulated.Opposite.Basic | ∀ (C : Type u_1) [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.HasShift C ℤ] (n : ℤ),
(CategoryTheory.Pretriangulated.opShiftFunctorEquivalence C n).functor = CategoryTheory.shiftFunctor Cᵒᵖ n | true |
CategoryTheory.Abelian.OfCoimageImageComparisonIsIso.instIsIsoEImageMonoFactorisationOfHasZeroObjectOfMonoOfCoimageImageComparison | Mathlib.CategoryTheory.Abelian.Basic | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Preadditive C]
[inst_2 : CategoryTheory.Limits.HasKernels C] [inst_3 : CategoryTheory.Limits.HasCokernels C]
[CategoryTheory.Limits.HasZeroObject C] {X Y : C} (f : X ⟶ Y) [CategoryTheory.Mono f]
[CategoryTheory.IsIso (CategoryTheory... | true |
RootPairing.CoPolarization_eq | Mathlib.LinearAlgebra.RootSystem.Finite.CanonicalBilinear | ∀ {ι : Type u_1} {R : Type u_2} {M : Type u_3} {N : Type u_4} [inst : CommRing R] [inst_1 : AddCommGroup M]
[inst_2 : Module R M] [inst_3 : AddCommGroup N] [inst_4 : Module R N] (P : RootPairing ι R M N) [inst_5 : Fintype ι],
P.CoPolarization = P.flip.Polarization | true |
ONote.zero_def | Mathlib.SetTheory.Ordinal.Notation | ONote.zero = 0 | true |
SSet.Truncated.HomotopyCategory.homToNerveMk._proof_2 | Mathlib.AlgebraicTopology.SimplicialSet.NerveAdjunction | ∀ {X : SSet.Truncated 2} {C : Type u_1} [inst : CategoryTheory.SmallCategory C]
(F : CategoryTheory.Functor X.HomotopyCategory C)
(f : X.obj (Opposite.op { obj := { len := 1 }, property := _proof_12✝ })),
CategoryTheory.nerveEquiv.symm
(F.obj (SSet.Truncated.HomotopyCategory.mk (X.map (SimplexCategory.Trunc... | false |
NonUnitalRingHom.range_eq_map | Mathlib.RingTheory.NonUnitalSubring.Basic | ∀ {R : Type u} {S : Type v} [inst : NonUnitalNonAssocRing R] [inst_1 : NonUnitalNonAssocRing S] (f : R →ₙ+* S),
f.range = NonUnitalSubring.map f ⊤ | true |
Matroid.comap._proof_2 | Mathlib.Combinatorics.Matroid.Map | ∀ {α : Type u_1} {β : Type u_2} (N : Matroid β) (f : α → β) ⦃I B : Set α⦄,
N.Indep (f '' I) ∧ Set.InjOn f I →
¬Maximal (fun I => N.Indep (f '' I) ∧ Set.InjOn f I) I →
Maximal (fun I => N.Indep (f '' I) ∧ Set.InjOn f I) B →
∃ x ∈ B \ I, N.Indep (f '' insert x I) ∧ Set.InjOn f (insert x I) | false |
_private.Lean.Meta.CollectMVars.0.Lean.Meta.collectMVars.match_1 | Lean.Meta.CollectMVars | (motive : Option Lean.DelayedMetavarAssignment → Sort u_1) →
(__do_lift : Option Lean.DelayedMetavarAssignment) →
(Unit → motive none) → ((d : Lean.DelayedMetavarAssignment) → motive (some d)) → motive __do_lift | false |
CategoryTheory.Triangulated.someOctahedron' | Mathlib.CategoryTheory.Triangulated.Triangulated | {C : Type u_1} →
[inst : CategoryTheory.Category.{v_1, u_1} C] →
[inst_1 : CategoryTheory.Preadditive C] →
[inst_2 : CategoryTheory.Limits.HasZeroObject C] →
[inst_3 : CategoryTheory.HasShift C ℤ] →
[inst_4 : ∀ (n : ℤ), (CategoryTheory.shiftFunctor C n).Additive] →
[inst_5 : Ca... | true |
Preord._sizeOf_inst | Mathlib.Order.Category.Preord | SizeOf Preord | false |
AddSemigroupAction.ext | Mathlib.Algebra.Group.Action.Defs | ∀ {G : Type u_9} {P : Type u_10} {inst : AddSemigroup G} {x y : AddSemigroupAction G P}, VAdd.vadd = VAdd.vadd → x = y | true |
ContinuousLinearMap.opNorm_mulLeftRight_le | Mathlib.Analysis.Normed.Operator.Mul | ∀ (𝕜 : Type u_1) [inst : NontriviallyNormedField 𝕜] (R : Type u_3) [inst_1 : NonUnitalSeminormedRing R]
[inst_2 : NormedSpace 𝕜 R] [inst_3 : IsScalarTower 𝕜 R R] [inst_4 : SMulCommClass 𝕜 R R],
‖ContinuousLinearMap.mulLeftRight 𝕜 R‖ ≤ 1 | true |
Perfection.instRing._proof_8 | Mathlib.RingTheory.Perfection | ∀ (R : Type u_1) [inst : CommRing R] (p : ℕ) [hp : Fact (Nat.Prime p)] [inst_1 : CharP R p] (a : Perfection R p),
-↑a ∈ Perfection.subring R p | false |
Multiset.sup_dedup | Mathlib.Data.Multiset.Lattice | ∀ {α : Type u_1} [inst : SemilatticeSup α] [inst_1 : OrderBot α] [inst_2 : DecidableEq α] (s : Multiset α),
s.dedup.sup = s.sup | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.