name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.67M | allowCompletion bool 2
classes |
|---|---|---|---|
Polynomial.C_eq_intCast | Mathlib.Algebra.Polynomial.Basic | ∀ {R : Type u} [inst : Ring R] (n : ℤ), Polynomial.C ↑n = ↑n | true |
Lean.Meta.AbstractNestedProofs.Context._sizeOf_1 | Lean.Meta.AbstractNestedProofs | Lean.Meta.AbstractNestedProofs.Context → ℕ | false |
Function.Antiperiodic.const_inv_smul | Mathlib.Algebra.Ring.Periodic | ∀ {α : Type u_1} {β : Type u_2} {γ : Type u_3} {f : α → β} {c : α} [inst : AddMonoid α] [inst_1 : Neg β]
[inst_2 : Group γ] [inst_3 : DistribMulAction γ α],
Function.Antiperiodic f c → ∀ (a : γ), Function.Antiperiodic (fun x => f (a⁻¹ • x)) (a • c) | true |
PNat.XgcdType.wp | Mathlib.Data.PNat.Xgcd | PNat.XgcdType → ℕ | true |
normalize | Mathlib.Algebra.GCDMonoid.Basic | {α : Type u_1} → [inst : CommMonoidWithZero α] → [NormalizationMonoid α] → α →*₀ α | true |
_private.Lean.Server.FileWorker.RequestHandling.0.Lean.Server.FileWorker.handleDocumentSymbol.toDocumentSymbols.match_1 | Lean.Server.FileWorker.RequestHandling | (motive : String × Lean.Syntax → Sort u_1) →
(x : String × Lean.Syntax) → ((name : String) → (selection : Lean.Syntax) → motive (name, selection)) → motive x | false |
Monovary.of_inv_right | Mathlib.Algebra.Order.Monovary | ∀ {ι : Type u_1} {α : Type u_2} {β : Type u_3} [inst : PartialOrder α] [inst_1 : CommGroup β] [inst_2 : PartialOrder β]
[IsOrderedMonoid β] {f : ι → α} {g : ι → β}, Monovary f g⁻¹ → Antivary f g | true |
Module.supportDim_le_ringKrullDim | Mathlib.RingTheory.KrullDimension.Module | ∀ (R : Type u_1) [inst : CommRing R] (M : Type u_2) [inst_1 : AddCommGroup M] [inst_2 : Module R M],
Module.supportDim R M ≤ ringKrullDim R | true |
MulHom.op_symm_apply_apply | Mathlib.Algebra.Group.Equiv.Opposite | ∀ {M : Type u_3} {N : Type u_4} [inst : Mul M] [inst_1 : Mul N] (f : Mᵐᵒᵖ →ₙ* Nᵐᵒᵖ) (a : M),
(MulHom.op.symm f) a = (MulOpposite.unop ∘ ⇑f ∘ MulOpposite.op) a | true |
CategoryTheory.WellPowered | Mathlib.CategoryTheory.Subobject.WellPowered | (C : Type u₁) → [inst : CategoryTheory.Category.{v, u₁} C] → [CategoryTheory.LocallySmall.{w, v, u₁} C] → Prop | true |
DyckWord.semilength_insidePart_add_semilength_outsidePart_add_one | Mathlib.Combinatorics.Enumerative.DyckWord | ∀ {p : DyckWord}, p ≠ 0 → p.insidePart.semilength + p.outsidePart.semilength + 1 = p.semilength | true |
Subfield.topologicalClosure._proof_4 | Mathlib.Topology.Algebra.Field | ∀ {α : Type u_1} [inst : Field α] [inst_1 : TopologicalSpace α] [inst_2 : IsTopologicalDivisionRing α] (K : Subfield α),
1 ∈ K.topologicalClosure.carrier | false |
Lean.Parser.Command.namedName.parenthesizer | Lean.Parser.Syntax | Lean.PrettyPrinter.Parenthesizer | true |
OrderIso.IicTop._proof_2 | Mathlib.Order.Interval.Set.OrderIso | ∀ {α : Type u_1} [inst : Preorder α] [inst_1 : OrderTop α] (x : α), x ≤ ⊤ | false |
SimpleGraph.cliqueFree_iff | Mathlib.Combinatorics.SimpleGraph.Clique | ∀ {α : Type u_1} {G : SimpleGraph α} {n : ℕ}, G.CliqueFree n ↔ IsEmpty (SimpleGraph.completeGraph (Fin n) ↪g G) | true |
_private.Std.Sat.AIG.CNF.0.Std.Sat.AIG.toCNF.Cache.addGate._proof_2 | Std.Sat.AIG.CNF | ∀ {aig : Std.Sat.AIG ℕ} {cnf : Std.Sat.CNF ℕ} {lhs rhs : Std.Sat.AIG.Fanin} (cache : Std.Sat.AIG.toCNF.Cache✝ aig cnf),
∀ idx < aig.decls.size,
lhs.gate < idx ∧ rhs.gate < idx → ∀ (idx_1 : ℕ), idx = idx_1 → ¬lhs.gate < aig.decls.size → False | false |
op_vadd_eq_add | Mathlib.Algebra.Group.Action.Defs | ∀ {α : Type u_9} [inst : Add α] (a b : α), AddOpposite.op a +ᵥ b = b + a | true |
exists_pred_iterate_or | Mathlib.Order.SuccPred.Archimedean | ∀ {α : Type u_1} [inst : LinearOrder α] [inst_1 : PredOrder α] [IsPredArchimedean α] {a b : α},
(∃ n, Order.pred^[n] a = b) ∨ ∃ n, Order.pred^[n] b = a | true |
_private.Mathlib.Tactic.Contrapose.0.Mathlib.Tactic.Contrapose._aux_Mathlib_Tactic_Contrapose___elabRules_Mathlib_Tactic_Contrapose_contrapose_1.match_1 | Mathlib.Tactic.Contrapose | (motive : Option Lean.Expr → Option Lean.Expr → Sort u_1) →
(x x_1 : Option Lean.Expr) →
(Unit → motive none none) →
((p : Lean.Expr) → motive (some p) none) →
((q : Lean.Expr) → motive none (some q)) → ((p q : Lean.Expr) → motive (some p) (some q)) → motive x x_1 | false |
Std.Tactic.BVDecide.Normalize.BitVec.ite_then_not_ite' | Std.Tactic.BVDecide.Normalize.Bool | ∀ {w : ℕ} (c0 c1 : Bool) {a b : BitVec w},
(bif c0 then ~~~bif c1 then ~~~a else b else a) = bif c0 && !c1 then ~~~b else a | true |
DirectSum.gMulLHom._proof_7 | Mathlib.Algebra.DirectSum.Algebra | ∀ {ι : Type u_3} (R : Type u_2) (A : ι → Type u_1) [inst : CommSemiring R] [inst_1 : (i : ι) → AddCommMonoid (A i)]
[inst_2 : (i : ι) → Module R (A i)] [inst_3 : AddMonoid ι] [inst_4 : DirectSum.GSemiring A]
[inst_5 : DirectSum.GAlgebra R A] {i j : ι} (x x_1 : A i),
{ toFun := fun b => GradedMonoid.GMul.mul (x + ... | false |
Std.HashMap.Raw.toListRev_keysIter | Std.Data.HashMap.IteratorLemmas | ∀ {α β : Type u} {m : Std.HashMap.Raw α β} [inst : BEq α] [inst_1 : Hashable α] [EquivBEq α] [LawfulHashable α],
m.WF → m.keysIter.toListRev = m.keys.reverse | true |
_private.Mathlib.Topology.Compactification.OnePoint.Basic.0.OnePoint.isOpen_iff_of_notMem._simp_1_1 | Mathlib.Topology.Compactification.OnePoint.Basic | ∀ {X : Type u_1} [inst : TopologicalSpace X] {s : Set (OnePoint X)},
IsOpen s = ((OnePoint.infty ∈ s → IsCompact (OnePoint.some ⁻¹' s)ᶜ) ∧ IsOpen (OnePoint.some ⁻¹' s)) | false |
CategoryTheory.Functor.IsCartesian.domainUniqueUpToIso.congr_simp | Mathlib.CategoryTheory.FiberedCategory.Fibered | ∀ {𝒮 : Type u₁} {𝒳 : Type u₂} [inst : CategoryTheory.Category.{v₁, u₁} 𝒮] [inst_1 : CategoryTheory.Category.{v₂, u₂} 𝒳]
(p p_1 : CategoryTheory.Functor 𝒳 𝒮) (e_p : p = p_1) {R S : 𝒮} {a b : 𝒳} (f f_1 : R ⟶ S) (e_f : f = f_1)
(φ φ_1 : a ⟶ b) (e_φ : φ = φ_1) [inst_2 : p.IsCartesian f φ] {a' : 𝒳} (φ' φ'_1 : a... | true |
RootPairingCat.noConfusion | Mathlib.LinearAlgebra.RootSystem.RootPairingCat | {P : Sort u_1} →
{R : Type u} →
{inst : CommRing R} →
{t : RootPairingCat R} →
{R' : Type u} →
{inst' : CommRing R'} →
{t' : RootPairingCat R'} → R = R' → inst ≍ inst' → t ≍ t' → RootPairingCat.noConfusionType P t t' | false |
AlgebraicGeometry.exists_pow_mul_eq_zero_of_res_basicOpen_eq_zero_of_isCompact | Mathlib.AlgebraicGeometry.Morphisms.QuasiCompact | ∀ (X : AlgebraicGeometry.Scheme) {U : X.Opens},
IsCompact U.carrier →
∀ (x f : ↑(X.presheaf.obj (Opposite.op U))),
TopCat.Presheaf.restrictOpen x (X.basicOpen f) ⋯ = 0 → ∃ n, f ^ n * x = 0 | true |
_private.Lean.AddDecl.0.Lean.isNamespaceName._sparseCasesOn_1 | Lean.AddDecl | {motive : Lean.Name → Sort u} →
(t : Lean.Name) →
((pre : Lean.Name) → (str : String) → motive (pre.str str)) → (Nat.hasNotBit 2 t.ctorIdx → motive t) → motive t | false |
Finset.subtypeInsertEquivOption._proof_11 | Mathlib.Data.Finset.Insert | ∀ {α : Type u_1} [inst : DecidableEq α] {t : Finset α} {x : α} (y : ↥(insert x t)), ¬↑y = x → ↑y ∈ t | false |
PrimeSpectrum.comap_injective_of_surjective | Mathlib.RingTheory.Spectrum.Prime.RingHom | ∀ {R : Type u} {S : Type v} [inst : CommSemiring R] [inst_1 : CommSemiring S] (f : R →+* S),
Function.Surjective ⇑f → Function.Injective (PrimeSpectrum.comap f) | true |
_private.Mathlib.Tactic.MoveAdd.0.Lean.Expr.getExprInputs.match_1 | Mathlib.Tactic.MoveAdd | (motive : Lean.Expr → Sort u_1) →
(x : Lean.Expr) →
((fn arg : Lean.Expr) → motive (fn.app arg)) →
((binderName : Lean.Name) →
(bt bb : Lean.Expr) → (binderInfo : Lean.BinderInfo) → motive (Lean.Expr.lam binderName bt bb binderInfo)) →
((binderName : Lean.Name) →
(bt bb : Lean.... | false |
AlgebraicGeometry.PresheafedSpace.pushforwardDiagramToColimit._proof_2 | Mathlib.Geometry.RingedSpace.PresheafedSpace.HasColimits | ∀ {J : Type u_4} [inst : CategoryTheory.Category.{u_3, u_4} J] {C : Type u_2}
[inst_1 : CategoryTheory.Category.{u_1, u_2} C] [inst_2 : CategoryTheory.Limits.HasColimitsOfShape J TopCat]
(F : CategoryTheory.Functor J (AlgebraicGeometry.PresheafedSpace C)) (j : J),
(CategoryTheory.CategoryStruct.comp
((Top... | false |
IsLocalizedModule.surj | Mathlib.Algebra.Module.LocalizedModule.Basic | ∀ {R : Type u_1} {inst : CommSemiring R} {M : Type u_2} {M' : Type u_3} {inst_1 : AddCommMonoid M}
{inst_2 : AddCommMonoid M'} {inst_3 : Module R M} {inst_4 : Module R M'} (S : Submonoid R) (f : M →ₗ[R] M')
[self : IsLocalizedModule S f] (y : M'), ∃ x, x.2 • y = f x.1 | true |
Std.ExtHashMap.noConfusion | Std.Data.ExtHashMap.Basic | {P : Sort u_1} →
{α : Type u} →
{β : Type v} →
{inst : BEq α} →
{inst_1 : Hashable α} →
{t : Std.ExtHashMap α β} →
{α' : Type u} →
{β' : Type v} →
{inst' : BEq α'} →
{inst'_1 : Hashable α'} →
{t' : Std.ExtHashM... | false |
CategoryTheory.WithTerminal.equivComma_counitIso_hom_app_left_app | Mathlib.CategoryTheory.WithTerminal.Basic | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {D : Type u_1} [inst_1 : CategoryTheory.Category.{v_1, u_1} D]
(X : CategoryTheory.Comma (CategoryTheory.Functor.id (CategoryTheory.Functor C D)) (CategoryTheory.Functor.const C))
(X_1 : C),
(CategoryTheory.WithTerminal.equivComma.counitIso.hom.app X).left.... | true |
Batteries.AssocList.mapKey | Batteries.Data.AssocList | {α : Type u_1} → {δ : Type u_2} → {β : Type u_3} → (α → δ) → Batteries.AssocList α β → Batteries.AssocList δ β | true |
HMul.noConfusion | Init.Prelude | {P : Sort u_1} →
{α : Type u} →
{β : Type v} →
{γ : Type w} →
{t : HMul α β γ} →
{α' : Type u} →
{β' : Type v} →
{γ' : Type w} → {t' : HMul α' β' γ'} → α = α' → β = β' → γ = γ' → t ≍ t' → HMul.noConfusionType P t t' | false |
UniformSpace.isClosed_ball_of_isSymm_of_isTrans_of_mem_uniformity | Mathlib.Topology.UniformSpace.Ultra.Basic | ∀ {X : Type u_1} [inst : UniformSpace X] (x : X) {V : SetRel X X} [V.IsSymm] [V.IsTrans],
V ∈ uniformity X → IsClosed (UniformSpace.ball x V) | true |
String.utf8Len_le_of_suffix | Batteries.Data.String.Lemmas | ∀ {cs₁ cs₂ : List Char}, cs₁ <:+ cs₂ → String.utf8Len cs₁ ≤ String.utf8Len cs₂ | true |
_private.Mathlib.GroupTheory.FreeGroup.Basic.0.FreeGroup.of_injective._simp_1_3 | Mathlib.GroupTheory.FreeGroup.Basic | ∀ {α : Type u} {L₁ : List (α × Bool)} {x : α × Bool}, FreeGroup.Red [x] L₁ = (L₁ = [x]) | false |
Aesop.LocalNormSimpRule.rec | Aesop.Rule | {motive : Aesop.LocalNormSimpRule → Sort u} →
((id : Lean.Name) → (simpTheorem : Lean.Term) → motive { id := id, simpTheorem := simpTheorem }) →
(t : Aesop.LocalNormSimpRule) → motive t | false |
_private.Mathlib.Analysis.CStarAlgebra.ApproximateUnit.0.termσ | Mathlib.Analysis.CStarAlgebra.ApproximateUnit | Lean.ParserDescr | true |
Lean.Expr.abstractRangeM | Lean.Meta.Basic | Lean.Expr → ℕ → Array Lean.Expr → Lean.MetaM Lean.Expr | true |
Ultrafilter.coe_le_coe._simp_1 | Mathlib.Order.Filter.Ultrafilter.Defs | ∀ {α : Type u} {f g : Ultrafilter α}, (↑f ≤ ↑g) = (f = g) | false |
Function.locallyFinsuppWithin.memAddSubmonoid | Mathlib.Topology.LocallyFinsupp | ∀ {X : Type u_1} [inst : TopologicalSpace X] {U : Set X} {Y : Type u_2} [inst_1 : AddMonoid Y]
(D : Function.locallyFinsuppWithin U Y), ⇑D ∈ Function.locallyFinsuppWithin.addSubmonoid U | true |
Lean.RArray.get_eq_getImpl | Init.Data.RArray | @Lean.RArray.get = @Lean.RArray.getImpl | true |
Ideal.nonPrincipals | Mathlib.RingTheory.PrincipalIdealDomain | (R : Type u) → [inst : Semiring R] → Set (Ideal R) | true |
Lean.Core.CoreM.parIter | Lean.Elab.Parallel | {α : Type} → List (Lean.CoreM α) → Lean.CoreM (Std.IterM Lean.CoreM (Except Lean.Exception α)) | true |
_private.Mathlib.Algebra.GroupWithZero.Associated.0.Associates.decompositionMonoid_iff._simp_1_1 | Mathlib.Algebra.GroupWithZero.Associated | ∀ (α : Type u_1) [inst : Semigroup α], DecompositionMonoid α = ∀ (a : α), IsPrimal a | false |
_private.Lean.Meta.Tactic.Grind.Arith.Linear.Inv.0.Lean.Meta.Grind.Arith.Linear.checkUppers | Lean.Meta.Tactic.Grind.Arith.Linear.Inv | Lean.Meta.Grind.Arith.Linear.LinearM Unit | true |
Algebra.map_bot | Mathlib.Algebra.Algebra.Subalgebra.Lattice | ∀ {R : Type u} {A : Type v} {B : Type w} [inst : CommSemiring R] [inst_1 : Semiring A] [inst_2 : Algebra R A]
[inst_3 : Semiring B] [inst_4 : Algebra R B] (f : A →ₐ[R] B), Subalgebra.map f ⊥ = ⊥ | true |
AddAction.nsmul_vadd_eq_iff_minimalPeriod_dvd | Mathlib.Dynamics.PeriodicPts.Defs | ∀ {α : Type v} {G : Type u} [inst : AddGroup G] [inst_1 : AddAction G α] {a : G} {b : α} {n : ℕ},
n • a +ᵥ b = b ↔ Function.minimalPeriod (fun x => a +ᵥ x) b ∣ n | true |
CategoryTheory.Abelian.SpectralObject.cokernelSequenceE_exact._auto_3 | Mathlib.Algebra.Homology.SpectralObject.Page | Lean.Syntax | false |
RCLike.inv_pos | Mathlib.Analysis.RCLike.Basic | ∀ {K : Type u_1} [inst : RCLike K] {z : K}, 0 < z⁻¹ ↔ 0 < z | true |
List.mapIdxM.go.eq_1 | Init.Data.Array.MapIdx | ∀ {m : Type u_1 → Type u_2} {α : Type u_3} {β : Type u_1} [inst : Monad m] (f : ℕ → α → m β) (x : Array β),
List.mapIdxM.go f [] x = pure x.toList | true |
CategoryTheory.Comonad.coalgebraPreadditive._proof_7 | Mathlib.CategoryTheory.Preadditive.EilenbergMoore | ∀ (C : Type u_2) [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.Preadditive C]
(U : CategoryTheory.Comonad C) [inst_2 : U.Additive] (F G : U.Coalgebra) (x : F ⟶ G), { f := 0 • x.f, h := ⋯ } = 0 | false |
SimpleGraph.nonempty_dart_top | Mathlib.Combinatorics.SimpleGraph.Dart | ∀ {V : Type u_1} [Nontrivial V], Nonempty ⊤.Dart | true |
Filter.join._proof_3 | Mathlib.Order.Filter.Defs | ∀ {α : Type u_1} (f : Filter (Filter α)), Set.univ ∈ {s | {t | s ∈ t} ∈ f} | false |
IsCyclotomicExtension.subsingleton_iff._simp_1 | Mathlib.NumberTheory.Cyclotomic.Basic | ∀ (S : Set ℕ) (A : Type u) (B : Type v) [inst : CommRing A] [inst_1 : CommRing B] [inst_2 : Algebra A B]
[Subsingleton B], IsCyclotomicExtension S A B = (S ⊆ {0, 1}) | false |
tendsto_comp_coe_Ioo_atTop._simp_1 | Mathlib.Topology.Order.AtTopBotIxx | ∀ {X : Type u_1} [inst : LinearOrder X] [inst_1 : TopologicalSpace X] [OrderTopology X] {a b : X} {α : Type u_2}
{l : Filter α} {f : X → α},
a < b →
autoParam (Order.IsSuccPrelimit b) tendsto_comp_coe_Ioo_atTop._auto_1 →
Filter.Tendsto (fun x => f ↑x) Filter.atTop l = Filter.Tendsto f (nhdsWithin b (Set.I... | false |
CategoryTheory.Limits.ι_colimitFiberwiseColimitIso_inv_assoc | Mathlib.CategoryTheory.Limits.Shapes.Grothendieck | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {F : CategoryTheory.Functor C CategoryTheory.Cat}
{H : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} H]
(G : CategoryTheory.Functor (CategoryTheory.Grothendieck F) H)
[inst_2 :
∀ {X Y : C} (f : X ⟶ Y),
CategoryTheory.Limits.HasColimit ((F... | true |
Std.PRange.instToStreamRocIterIteratorOfUpwardEnumerable | Init.Data.Range.Polymorphic.Stream | {α : Type u_1} → [Std.PRange.UpwardEnumerable α] → Std.ToStream (Std.Roc α) (Std.Iter α) | true |
SSet.StrictSegalCore.concat.congr_simp | Mathlib.AlgebraicTopology.SimplicialSet.StrictSegal | ∀ {X : SSet} {n : ℕ} (self self_1 : X.StrictSegalCore n),
self = self_1 →
∀ (x x_1 : X.obj (Opposite.op (SimplexCategory.mk 1))) (e_x : x = x_1)
(s s_1 : X.obj (Opposite.op (SimplexCategory.mk n))) (e_s : s = s_1)
(h :
CategoryTheory.SimplicialObject.δ X 0 x = X.map ((SimplexCategory.mk 0).con... | true |
Lean.Elab.Tactic.Do.ProofMode.checkHasType | Lean.Elab.Tactic.Do.ProofMode.MGoal | Lean.Expr → Lean.Expr → optParam Bool false → Lean.MetaM Unit | true |
extProc._@.Mathlib.Tactic.Attr.Register.612238087._hygCtx._hyg.3 | Mathlib.Tactic.Attr.Register | Lean.Meta.Simp.SimprocExtension | false |
ContinuousAffineMap.toConstProdContinuousLinearMap._proof_9 | Mathlib.Analysis.Normed.Affine.ContinuousAffineMap | ∀ (𝕜 : Type u_1) (V : Type u_2) (W : Type u_3) [inst : NormedAddCommGroup V] [inst_1 : NormedAddCommGroup W]
[inst_2 : NontriviallyNormedField 𝕜] [inst_3 : NormedSpace 𝕜 V] [inst_4 : NormedSpace 𝕜 W] (x : V →ᴬ[𝕜] W),
‖{ toFun := fun f => (f 0, f.contLinear), map_add' := ⋯, map_smul' := ⋯,
invFun := f... | false |
HomotopyEquiv.mk._flat_ctor | 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} →
(hom : C ⟶ D) →
(inv : D ⟶ C) →
Homotopy (CategoryTheory.CategoryStruct.co... | false |
MeasureTheory.«_aux_Mathlib_MeasureTheory_VectorMeasure_Basic___macroRules_MeasureTheory_term_⟂ᵥ__1» | Mathlib.MeasureTheory.VectorMeasure.Basic | Lean.Macro | false |
_private.Mathlib.MeasureTheory.Measure.Haar.OfBasis.0.parallelepiped_eq_sum_segment._simp_1_2 | Mathlib.MeasureTheory.Measure.Haar.OfBasis | ∀ {ι : Type u_1} {α : Type u_2} [inst : AddCommMonoid α] (t : Finset ι) (f : ι → Set α) (a : α),
(a ∈ ∑ i ∈ t, f i) = ∃ g, ∃ (_ : ∀ {i : ι}, i ∈ t → g i ∈ f i), ∑ i ∈ t, g i = a | false |
_private.Mathlib.Data.List.Cycle.0.Cycle.Chain._simp_3 | Mathlib.Data.List.Cycle | ∀ {a b : Prop}, (a ∧ b) = (b ∧ a) | false |
Matrix.conjTransposeRingEquiv | Mathlib.LinearAlgebra.Matrix.ConjTranspose | (m : Type u_2) →
(α : Type v) →
[inst : NonUnitalNonAssocSemiring α] → [StarRing α] → [inst_2 : Fintype m] → Matrix m m α ≃+* (Matrix m m α)ᵐᵒᵖ | true |
IntermediateField.lift_relrank_comap_comap_eq_lift_relrank_inf | Mathlib.FieldTheory.Relrank | ∀ {F : Type u} {E : Type v} [inst : Field F] [inst_1 : Field E] [inst_2 : Algebra F E] {L : Type w} [inst_3 : Field L]
[inst_4 : Algebra F L] (A B : IntermediateField F E) (f : L →ₐ[F] E),
Cardinal.lift.{v, w} ((IntermediateField.comap f A).relrank (IntermediateField.comap f B)) =
Cardinal.lift.{w, v} (A.relran... | true |
QuotientGroup.completeSpace_left | Mathlib.Topology.Algebra.IsUniformGroup.Basic | ∀ (G : Type u_1) [inst : Group G] [us : UniformSpace G] [inst_1 : IsLeftUniformGroup G] [FirstCountableTopology G]
(N : Subgroup G) [inst_3 : N.Normal] [hG : CompleteSpace G], CompleteSpace (G ⧸ N) | true |
CochainComplex.mappingCone.rotateHomotopyEquiv._proof_3 | Mathlib.Algebra.Homology.HomotopyCategory.Pretriangulated | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.Preadditive C]
[inst_2 : CategoryTheory.Limits.HasBinaryBiproducts C] {K L : CochainComplex C ℤ} (φ : K ⟶ L),
CategoryTheory.CategoryStruct.comp
(CochainComplex.mappingCone.lift (CochainComplex.mappingCone.inr φ)
(... | false |
_private.Lean.Elab.StructInst.0.Lean.Elab.Term.StructInst.CtorHeaderResult.structType | Lean.Elab.StructInst | Lean.Elab.Term.StructInst.CtorHeaderResult✝ → Lean.Expr | true |
NonarchAddGroupNorm.mk.inj | Mathlib.Analysis.Normed.Group.Seminorm | ∀ {G : Type u_6} {inst : AddGroup G} {toNonarchAddGroupSeminorm : NonarchAddGroupSeminorm G}
{eq_zero_of_map_eq_zero' : ∀ (x : G), toNonarchAddGroupSeminorm.toFun x = 0 → x = 0}
{toNonarchAddGroupSeminorm_1 : NonarchAddGroupSeminorm G}
{eq_zero_of_map_eq_zero'_1 : ∀ (x : G), toNonarchAddGroupSeminorm_1.toFun x = ... | true |
Lean.Meta.Sym.Simp.EvalStepConfig.noConfusion | Lean.Meta.Sym.Simp.EvalGround | {P : Sort u} →
{t t' : Lean.Meta.Sym.Simp.EvalStepConfig} → t = t' → Lean.Meta.Sym.Simp.EvalStepConfig.noConfusionType P t t' | false |
PMF.mem_support_iff | Mathlib.Probability.ProbabilityMassFunction.Basic | ∀ {α : Type u_1} (p : PMF α) (a : α), a ∈ p.support ↔ p a ≠ 0 | true |
AugmentedSimplexCategory.instMonoidalCategory._proof_4 | Mathlib.AlgebraicTopology.SimplexCategory.Augmented.Monoidal | ∀ {X₁ X₂ X₃ Y₁ Y₂ Y₃ : AugmentedSimplexCategory} (f₁ : X₁ ⟶ Y₁) (f₂ : X₂ ⟶ Y₂) (f₃ : X₃ ⟶ Y₃),
CategoryTheory.CategoryStruct.comp
(CategoryTheory.MonoidalCategoryStruct.tensorHom (CategoryTheory.MonoidalCategoryStruct.tensorHom f₁ f₂) f₃)
(CategoryTheory.MonoidalCategoryStruct.associator Y₁ Y₂ Y₃).hom =
... | false |
_private.Init.Data.BitVec.Bitblast.0.BitVec.msb_sdiv_eq_decide._simp_1_10 | Init.Data.BitVec.Bitblast | ∀ {n : ℕ} {x y : BitVec n}, (¬x < y) = (y ≤ x) | false |
Descriptive.Tree.take_mem | Mathlib.SetTheory.Descriptive.Tree | ∀ {A : Type u_1} {T : ↥(Descriptive.tree A)} {n : ℕ} (x : ↥T), List.take n ↑x ∈ T | true |
CategoryTheory.preservesColimits_of_createsColimits_and_hasColimits | Mathlib.CategoryTheory.Limits.Creates | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
(F : CategoryTheory.Functor C D) [CategoryTheory.CreatesColimitsOfSize.{w, w', v₁, v₂, u₁, u₂} F]
[CategoryTheory.Limits.HasColimitsOfSize.{w, w', v₂, u₂} D],
CategoryTheory.Limits.PreservesColi... | true |
_private.Init.Core.0.decide_true.match_1_1 | Init.Core | ∀ (motive : Decidable True → Prop) (h : Decidable True),
(∀ (h : True), motive (isTrue h)) → (∀ (h : ¬True), motive (isFalse h)) → motive h | false |
MvPolynomial.IsSymmetric.zero | Mathlib.RingTheory.MvPolynomial.Symmetric.Defs | ∀ {σ : Type u_1} {R : Type u_3} [inst : CommSemiring R], MvPolynomial.IsSymmetric 0 | true |
Multiset.countP_attach | Mathlib.Data.Multiset.Count | ∀ {α : Type u_1} (p : α → Prop) [inst : DecidablePred p] (s : Multiset α),
Multiset.countP (fun a => p ↑a) s.attach = Multiset.countP p s | true |
_private.Mathlib.Analysis.Complex.CauchyIntegral.0.Complex.two_pi_I_inv_smul_circleIntegral_sub_inv_smul_of_differentiable_on_off_countable._simp_1_1 | Mathlib.Analysis.Complex.CauchyIntegral | (Real.pi = 0) = False | false |
Std.HashSet.toList | Std.Data.HashSet.Basic | {α : Type u} → {x : BEq α} → {x_1 : Hashable α} → Std.HashSet α → List α | true |
Std.ExtHashMap.mem_insert._simp_1 | Std.Data.ExtHashMap.Lemmas | ∀ {α : Type u} {β : Type v} {x : BEq α} {x_1 : Hashable α} {m : Std.ExtHashMap α β} [inst : EquivBEq α]
[inst_1 : LawfulHashable α] {k a : α} {v : β}, (a ∈ m.insert k v) = ((k == a) = true ∨ a ∈ m) | false |
Lean.Meta.AC.PreExpr.op.sizeOf_spec | Lean.Meta.Tactic.AC.Main | ∀ (lhs rhs : Lean.Meta.AC.PreExpr), sizeOf (lhs.op rhs) = 1 + sizeOf lhs + sizeOf rhs | true |
CompHausLike.LocallyConstant.counit._proof_4 | Mathlib.Condensed.Discrete.LocallyConstant | ∀ (P : TopCat → Prop) [inst : ∀ (S : CompHausLike P) (p : ↑S.toTop → Prop), CompHausLike.HasProp P (Subtype p)]
[inst_1 : CompHausLike.HasProp P PUnit.{u_1 + 1}] [inst_2 : CompHausLike.HasExplicitFiniteCoproducts P]
[inst_3 : CompHausLike.HasExplicitPullbacks P]
(hs :
∀ ⦃X Y : CompHausLike P⦄ (f : X ⟶ Y),
... | false |
unexpandMkArray3 | Init.NotationExtra | Lean.PrettyPrinter.Unexpander | true |
AlgebraicGeometry.Scheme.jointlySurjectiveTopology | Mathlib.AlgebraicGeometry.Sites.Pretopology | CategoryTheory.GrothendieckTopology AlgebraicGeometry.Scheme | true |
_private.Lean.Language.Basic.0.Lean.Language.SnapshotTask.ReportingRange.ofOptionInheriting.match_1 | Lean.Language.Basic | (motive : Option Lean.Syntax.Range → Sort u_1) →
(x : Option Lean.Syntax.Range) → ((range : Lean.Syntax.Range) → motive (some range)) → (Unit → motive none) → motive x | false |
Prod.instReflLex_mathlib_1 | Mathlib.Data.Prod.Basic | ∀ {α : Type u_1} {β : Type u_2} {r : α → α → Prop} {s : β → β → Prop} [Std.Refl s], Std.Refl (Prod.Lex r s) | true |
Finsupp.DegLex.monotone_degree | Mathlib.Data.Finsupp.MonomialOrder.DegLex | ∀ {α : Type u_1} [inst : LinearOrder α], Monotone fun x => Finsupp.degree (ofDegLex x) | true |
_private.Lean.Elab.Tactic.BVDecide.Frontend.Normalize.IntToBitVec.0.Lean.Elab.Tactic.BVDecide.Frontend.Normalize.M.addSizeTerm | Lean.Elab.Tactic.BVDecide.Frontend.Normalize.IntToBitVec | Lean.Expr → Lean.Elab.Tactic.BVDecide.Frontend.Normalize.M✝ Unit | true |
Mathlib.Tactic.Monoidal.StructuralOfExpr_monoidalComp | Mathlib.Tactic.CategoryTheory.Monoidal.Datatypes | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {f g h i : C} [inst_1 : CategoryTheory.MonoidalCoherence g h]
(η : f ⟶ g) (η' : f ≅ g),
η'.hom = η →
∀ (θ : h ⟶ i) (θ' : h ≅ i),
θ'.hom = θ → (CategoryTheory.monoidalIsoComp η' θ').hom = CategoryTheory.monoidalComp η θ | true |
_private.Mathlib.FieldTheory.Galois.Infinite.0.InfiniteGalois.fixingSubgroup_fixedField._simp_1_1 | Mathlib.FieldTheory.Galois.Infinite | ∀ {M : Type u_1} [inst : Mul M] {s : Subsemigroup M} {x : M}, (x ∈ s.carrier) = (x ∈ s) | false |
Std.Sat.CNF.Clause.relabel_relabel' | Std.Sat.CNF.Relabel | ∀ {α : Type u_1} {α_1 : Type u_2} {r1 : α → α_1} {α_2 : Type u_3} {r2 : α_2 → α},
Std.Sat.CNF.Clause.relabel r1 ∘ Std.Sat.CNF.Clause.relabel r2 = Std.Sat.CNF.Clause.relabel (r1 ∘ r2) | true |
Std.Net.instInhabitedSocketAddress.default | Std.Net.Addr | Std.Net.SocketAddress | true |
MulMemClass.isRightCancelMul | Mathlib.Algebra.Group.Subsemigroup.Defs | ∀ {M : Type u_1} {A : Type u_3} [inst : Mul M] [inst_1 : SetLike A M] [hA : MulMemClass A M] [IsRightCancelMul M]
(S : A), IsRightCancelMul ↥S | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.