name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.67M | allowCompletion bool 2
classes |
|---|---|---|---|
CategoryTheory.GrothendieckTopology.over._proof_3 | Mathlib.CategoryTheory.Sites.Over | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{u_2, u_1} C] (J : CategoryTheory.GrothendieckTopology C) (X : C)
(Y : CategoryTheory.Over X) (S R : CategoryTheory.Sieve Y),
(∀ ⦃Y_1 : CategoryTheory.Over X⦄ ⦃f : Y_1 ⟶ Y⦄,
S.arrows f → CategoryTheory.Sieve.pullback f R ∈ ⇑(CategoryTheory.Sieve.overEquiv Y_1) ... | false |
Std.DTreeMap.Internal.Impl.Const.entryAtIdx?.match_1.congr_eq_1 | Std.Data.DTreeMap.Internal.Model | ∀ {α : Type u_1} {β : Type u_2} (motive : (Std.DTreeMap.Internal.Impl α fun x => β) → ℕ → Sort u_3)
(x : Std.DTreeMap.Internal.Impl α fun x => β) (x_1 : ℕ) (h_1 : (x : ℕ) → motive Std.DTreeMap.Internal.Impl.leaf x)
(h_2 :
(size : ℕ) →
(k : α) →
(v : β) →
(l r : Std.DTreeMap.Internal.Impl... | true |
Complex.UnitDisc.star_zero | Mathlib.Analysis.Complex.UnitDisc.Basic | star 0 = 0 | true |
CategoryTheory.CommComon.mk.inj | Mathlib.CategoryTheory.Monoidal.CommComon_ | ∀ {C : Type u₁} {inst : CategoryTheory.Category.{v₁, u₁} C} {inst_1 : CategoryTheory.MonoidalCategory C}
{inst_2 : CategoryTheory.BraidedCategory C} {X : C} {comon : CategoryTheory.ComonObj X}
{comm : CategoryTheory.IsCommComonObj X} {X_1 : C} {comon_1 : CategoryTheory.ComonObj X_1}
{comm_1 : CategoryTheory.IsCom... | true |
Lean.Data.AC.instReprExpr.repr._sunfold | Init.Data.AC | Lean.Data.AC.Expr → ℕ → Std.Format | false |
unitInterval.coe_symm_eq | Mathlib.Topology.UnitInterval | ∀ (x : ↑unitInterval), ↑(unitInterval.symm x) = 1 - ↑x | true |
List.getElem_eq_getD | Init.Data.List.Lemmas | ∀ {α : Type u_1} {l : List α} {i : ℕ} {h : i < l.length} (fallback : α), l[i] = l.getD i fallback | true |
AdicCompletion.evalₐ._proof_2 | Mathlib.RingTheory.AdicCompletion.Algebra | ∀ {R : Type u_1} [inst : CommRing R] (I : Ideal R) (n : ℕ), (I ^ n • ⊤).IsTwoSided | false |
SSet.Subcomplex.Pairing.RankFunction.toWeakRankFunction | Mathlib.AlgebraicTopology.SimplicialSet.AnodyneExtensions.Rank | {X : SSet} →
{A : X.Subcomplex} →
(P : A.Pairing) → (α : Type v) → [inst : PartialOrder α] → P.RankFunction α → P.WeakRankFunction α | true |
CategoryTheory.Limits.Fork.IsLimit.ofExistsUnique._proof_3 | Mathlib.CategoryTheory.Limits.Shapes.Equalizers | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] {X Y : C} {f g : X ⟶ Y}
{t : CategoryTheory.Limits.Fork f g}
(hs : ∀ (s : CategoryTheory.Limits.Fork f g), ∃! l, CategoryTheory.CategoryStruct.comp l t.ι = s.ι)
(s : CategoryTheory.Limits.Fork f g),
CategoryTheory.CategoryStruct.comp (Classical.choo... | false |
Lean.Meta.Grind.Arith.Linear.NatStruct.ctorIdx | Lean.Meta.Tactic.Grind.Arith.Linear.Types | Lean.Meta.Grind.Arith.Linear.NatStruct → ℕ | false |
Lean.Lsp.instToJsonDefinitionParams.toJson | Lean.Data.Lsp.LanguageFeatures | Lean.Lsp.DefinitionParams → Lean.Json | true |
PowerSeries.constantCoeff.eq_def | Mathlib.RingTheory.PowerSeries.Substitution | ∀ {R : Type u_1} [inst : Semiring R], PowerSeries.constantCoeff = MvPowerSeries.constantCoeff | true |
MvQPF.corecF_eq | Mathlib.Data.QPF.Multivariate.Constructions.Cofix | ∀ {n : ℕ} {F : TypeVec.{u} (n + 1) → Type u} [q : MvQPF F] {α : TypeVec.{u} n} {β : Type u} (g : β → F (α ::: β))
(x : β),
MvPFunctor.M.dest (MvQPF.P F) (MvQPF.corecF g x) = MvFunctor.map (TypeVec.id ::: MvQPF.corecF g) (MvQPF.repr (g x)) | true |
CategoryTheory.NatTrans.hcomp._proof_3._to_dual_1 | Mathlib.CategoryTheory.Functor.Category | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] {D : Type u_6}
[inst_1 : CategoryTheory.Category.{u_5, u_6} D] {E : Type u_4} [inst_2 : CategoryTheory.Category.{u_3, u_4} E]
{F G : CategoryTheory.Functor C D} {H I : CategoryTheory.Functor D E} (α : G ⟶ F) (β : I ⟶ H) ⦃X Y : C⦄ (f : Y ⟶ X),
Category... | false |
dbgTraceVal | Init.Util | {α : Type u} → [ToString α] → α → α | true |
Equiv.sumCompl._proof_2 | Mathlib.Logic.Equiv.Sum | ∀ {α : Type u_1} (p : α → Prop) [inst : DecidablePred p] (a : α),
Sum.elim Subtype.val Subtype.val ((fun a => if h : p a then Sum.inl ⟨a, h⟩ else Sum.inr ⟨a, h⟩) a) = a | false |
ProbabilityTheory.condExpKernel_eq | Mathlib.Probability.Kernel.Condexp | ∀ {Ω : Type u_1} [mΩ : MeasurableSpace Ω] [inst : StandardBorelSpace Ω] (μ : MeasureTheory.Measure Ω)
[inst_1 : MeasureTheory.IsFiniteMeasure μ] [h : Nonempty Ω] (m : MeasurableSpace Ω),
ProbabilityTheory.condExpKernel μ m = (ProbabilityTheory.condDistrib id id μ).comap id ⋯ | true |
CategoryTheory.Limits.Cofan.IsColimit.prod | Mathlib.CategoryTheory.Limits.Shapes.Products | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
{ι : Type u_1} →
{ι' : Type u_2} →
{X : ι → ι' → C} →
(c : (i : ι) → CategoryTheory.Limits.Cofan fun j => X i j) →
((i : ι) → CategoryTheory.Limits.IsColimit (c i)) →
(c' : CategoryTheory.Limits.Cofan fun ... | true |
PrimeSpectrum.ConstructibleSetData.toSet_map | Mathlib.RingTheory.Spectrum.Prime.ConstructibleSet | ∀ {R : Type u_1} {S : Type u_2} [inst : CommSemiring R] [inst_1 : CommSemiring S] (f : R →+* S)
(s : PrimeSpectrum.ConstructibleSetData R),
(PrimeSpectrum.ConstructibleSetData.map f s).toSet = PrimeSpectrum.comap f ⁻¹' s.toSet | true |
CategoryTheory.MonoidalCategory.DayFunctor.equiv_functor_map | Mathlib.CategoryTheory.Monoidal.DayConvolution.DayFunctor | ∀ (C : Type u₁) [inst : CategoryTheory.Category.{v₁, u₁} C] (V : Type u₂) [inst_1 : CategoryTheory.Category.{v₂, u₂} V]
[inst_2 : CategoryTheory.MonoidalCategory C] [inst_3 : CategoryTheory.MonoidalCategory V]
{X Y : CategoryTheory.MonoidalCategory.DayFunctor C V} (α : X ⟶ Y),
(CategoryTheory.MonoidalCategory.Day... | true |
_private.Std.Time.Date.ValidDate.0.Std.Time.ValidDate.ofOrdinal.go.eq_def | Std.Time.Date.ValidDate | ∀ {leap : Bool} (ordinal : Std.Time.Day.Ordinal.OfYear leap) (idx : Std.Time.Month.Ordinal) (acc : ℤ)
(h : ↑ordinal > acc) (p : acc = (Std.Time.Month.Ordinal.cumulativeDays leap idx).val),
Std.Time.ValidDate.ofOrdinal.go✝ ordinal idx acc h p =
let monthDays := Std.Time.Month.Ordinal.days leap idx;
if h₁ : ↑... | true |
Mathlib.Tactic.Order.Graph.tarjanDFS._unsafe_rec | Mathlib.Tactic.Order.Graph.Tarjan | Mathlib.Tactic.Order.Graph → ℕ → StateM Mathlib.Tactic.Order.Graph.TarjanState Unit | false |
_private.Init.Omega.Constraint.0.Lean.Omega.Constraint.exact_sat._simp_1_3 | Init.Omega.Constraint | ∀ {p q : Prop} {x : Decidable p} {x_1 : Decidable q}, (decide p = decide q) = (p ↔ q) | false |
CategoryTheory.Adjunction.rightAdjointUniq_trans_assoc | Mathlib.CategoryTheory.Adjunction.Unique | ∀ {C : Type u_1} {D : Type u_2} [inst : CategoryTheory.Category.{v_1, u_1} C]
[inst_1 : CategoryTheory.Category.{v_2, u_2} D] {F : CategoryTheory.Functor C D}
{G G' G'' : CategoryTheory.Functor D C} (adj1 : F ⊣ G) (adj2 : F ⊣ G') (adj3 : F ⊣ G'')
{Z : CategoryTheory.Functor D C} (h : G'' ⟶ Z),
CategoryTheory.Ca... | true |
Std.TreeMap.Raw.minKeyD_eq_getD_keysArray | Std.Data.TreeMap.Raw.Lemmas | ∀ {α : Type u} {β : Type v} {cmp : α → α → Ordering} {t : Std.TreeMap.Raw α β cmp} [Std.TransCmp cmp],
t.WF → ∀ {fallback : α}, t.minKeyD fallback = t.keysArray.getD 0 fallback | true |
Lex.instMulActionWithZero | Mathlib.Algebra.Order.GroupWithZero.Action.Synonym | {G₀ : Type u_1} →
{M₀ : Type u_2} →
[inst : MonoidWithZero G₀] → [inst_1 : AddMonoid M₀] → [MulActionWithZero G₀ M₀] → MulActionWithZero (Lex G₀) M₀ | true |
_private.Mathlib.Combinatorics.SimpleGraph.Walk.Traversal.0.SimpleGraph.Walk.penultimate_mem_dropLast_support._proof_1_11 | Mathlib.Combinatorics.SimpleGraph.Walk.Traversal | ∀ {V : Type u_1} {G : SimpleGraph V} {u v : V} {p : G.Walk u v},
p.penultimate ≠ v → p.getVert (p.length - 1) ∈ p.support.dropLast | false |
OrderDual.toDual_trans_ofDual | Mathlib.Order.OrderDual | ∀ {α : Type u_1}, OrderDual.toDual.trans OrderDual.ofDual = Equiv.refl α | true |
Finset.Nat.antidiagonalEquivFin._proof_5 | Mathlib.Data.Finset.NatAntidiagonal | ∀ (n i : ℕ), i < n + 1 → (i, n - i) ∈ Finset.antidiagonal n | false |
IsAdjoinRootMonic.basis._proof_3 | Mathlib.RingTheory.IsAdjoinRoot | ∀ {R : Type u_1} [inst : CommRing R], RingHomInvPair (RingHom.id R) (RingHom.id R) | false |
Std.TreeSet.self_le_max!_insert | Std.Data.TreeSet.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} {t : Std.TreeSet α cmp} [Std.TransCmp cmp] [inst : Inhabited α] {k : α},
(cmp k (t.insert k).max!).isLE = true | true |
Invertible.subsingleton | Mathlib.Algebra.Group.Invertible.Defs | ∀ {α : Type u} [inst : Monoid α] (a : α), Subsingleton (Invertible a) | true |
Std.Http.Header.TransferEncoding.isValid | Std.Internal.Http.Data.Headers.Basic | ∀ (self : Std.Http.Header.TransferEncoding), Std.Http.Header.TransferEncoding.Validate self.codings = true | true |
Std.Do.SVal.curry_uncurry | Std.Do.SPred.SVal | ∀ {α : Type u} {σs : List (Type u)} {f : Std.Do.SVal σs α}, Std.Do.SVal.curry f.uncurry = f | true |
FirstOrder.Language.Theory.IsMaximal.isComplete | Mathlib.ModelTheory.Satisfiability | ∀ {L : FirstOrder.Language} {T : L.Theory}, T.IsMaximal → T.IsComplete | true |
CategoryTheory.Pseudofunctor.Grothendieck.map_id_eq | Mathlib.CategoryTheory.Bicategory.Grothendieck | ∀ {𝒮 : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} 𝒮]
(F : CategoryTheory.Pseudofunctor (CategoryTheory.LocallyDiscrete 𝒮) CategoryTheory.Cat),
CategoryTheory.Pseudofunctor.Grothendieck.map (CategoryTheory.CategoryStruct.id F) =
CategoryTheory.Functor.id F.Grothendieck | true |
Lean.Language.SnapshotTree.mk.injEq | Lean.Language.Basic | ∀ (element : Lean.Language.Snapshot) (children : Array (Lean.Language.SnapshotTask Lean.Language.SnapshotTree))
(element_1 : Lean.Language.Snapshot) (children_1 : Array (Lean.Language.SnapshotTask Lean.Language.SnapshotTree)),
({ element := element, children := children } = { element := element_1, children := child... | true |
Set.Iio_infinite | Mathlib.Order.Interval.Set.Infinite | ∀ {α : Type u_1} [inst : Preorder α] [NoMinOrder α] (a : α), (Set.Iio a).Infinite | true |
_private.Mathlib.Combinatorics.SimpleGraph.Acyclic.0.SimpleGraph.IsAcyclic.isPath_iff_isChain._simp_1_1 | Mathlib.Combinatorics.SimpleGraph.Acyclic | ∀ {V : Type u} {G : SimpleGraph V} {u : V} (p : G.Walk u u),
p.IsCycle = (p.IsTrail ∧ p ≠ SimpleGraph.Walk.nil ∧ p.support.tail.Nodup) | false |
ProbabilityTheory.iIndepFun.charFun_map_sum_eq_prod | Mathlib.Probability.Independence.CharacteristicFunction | ∀ {Ω : Type u_1} {mΩ : MeasurableSpace Ω} {P : MeasureTheory.Measure Ω} {ι : Type u_2} {E : Type u_3}
[inst : MeasurableSpace E] [inst_1 : NormedAddCommGroup E] [BorelSpace E] [SecondCountableTopology E] {X : ι → Ω → E}
[inst_4 : Fintype ι] [inst_5 : InnerProductSpace ℝ E],
(∀ (i : ι), AEMeasurable (X i) P) →
... | true |
_private.Mathlib.GroupTheory.FreeGroup.Basic.0.FreeAddGroup.of_injective.match_1_1 | Mathlib.GroupTheory.FreeGroup.Basic | ∀ {α : Type u_1} (x x_1 : α) (motive : Relation.Join FreeAddGroup.Red [(x, true)] [(x_1, true)] → Prop)
(x_2 : Relation.Join FreeAddGroup.Red [(x, true)] [(x_1, true)]),
(∀ (L₁ : List (α × Bool)) (hx : FreeAddGroup.Red [(x, true)] L₁) (hy : FreeAddGroup.Red [(x_1, true)] L₁), motive ⋯) →
motive x_2 | false |
_private.Mathlib.RingTheory.Jacobson.Ring.0.Ideal.radical_eq_jacobson.match_1_1 | Mathlib.RingTheory.Jacobson.Ring | ∀ {R : Type u_1} [inst : CommRing R] (I _J : Ideal R) (motive : _J ∈ {J | I ≤ J ∧ J.IsMaximal} → Prop)
(x : _J ∈ {J | I ≤ J ∧ J.IsMaximal}), (∀ (hJ : I ≤ _J) (hJ_max : _J.IsMaximal), motive ⋯) → motive x | false |
_private.Mathlib.NumberTheory.Padics.RingHoms.0.PadicInt.appr_spec._simp_1_1 | Mathlib.NumberTheory.Padics.RingHoms | ∀ {α : Type u} [inst : CommSemiring α] {x y : α}, (x ∈ Ideal.span {y}) = (y ∣ x) | false |
RootPairing.EmbeddedG2.instIsG2OfIsIrreducible | Mathlib.LinearAlgebra.RootSystem.Finite.G2 | ∀ {ι : 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) [P.EmbeddedG2]
[P.IsIrreducible], P.IsG2 | true |
Semifield.nnratCast_def | Mathlib.Algebra.Field.Defs | ∀ {K : Type u_2} [self : Semifield K] (q : ℚ≥0), ↑q = ↑q.num / ↑q.den | true |
Int.gcd_pow_right_of_gcd_eq_one | Init.Data.Int.Gcd | ∀ {n m : ℤ} {k : ℕ}, n.gcd m = 1 → n.gcd (m ^ k) = 1 | true |
Localization.monoidOf._proof_1 | Mathlib.GroupTheory.MonoidLocalization.Basic | ∀ {M : Type u_1} [inst : CommMonoid M] (S : Submonoid M) (x y : M),
Localization.mk (x * y) 1 = Localization.mk x 1 * Localization.mk y 1 | false |
Aesop.Frontend.RuleConfig.validateForAdditionalRules | Aesop.Frontend.RuleExpr | {m : Type → Type} →
[Monad m] → [Lean.MonadError m] → Aesop.Frontend.RuleConfig → Aesop.RuleSetName → m Aesop.Frontend.RuleConfig | true |
piChartedSpace._proof_2 | Mathlib.Geometry.Manifold.ChartedSpace | ∀ {ι : Type u_1} [inst : Finite ι] (H : ι → Type u_2) [inst_1 : (i : ι) → TopologicalSpace (H i)] (M : ι → Type u_3)
[inst_2 : (i : ι) → TopologicalSpace (M i)] [inst_3 : (i : ι) → ChartedSpace (H i) (M i)] (f : (i : ι) → M i),
(OpenPartialHomeomorph.pi fun i => chartAt (H i) (f i)) ∈
OpenPartialHomeomorph.pi '... | false |
Int.trailingZeros_two_mul_add_one | Init.Data.Dyadic.Basic | ∀ (i : ℤ), (2 * i + 1).trailingZeros = 0 | true |
Set.infinite_smul_set._simp_2 | Mathlib.Algebra.Group.Action.Pointwise.Set.Finite | ∀ {G : Type u_1} {α : Type u_2} [inst : Group G] [inst_1 : MulAction G α] {a : G} {s : Set α},
(a • s).Infinite = s.Infinite | false |
Pi.instIsBoundedSMul | Mathlib.Topology.MetricSpace.Algebra | ∀ {ι : Type u_3} [inst : Fintype ι] {α : Type u_4} {β : ι → Type u_5} [inst_1 : PseudoMetricSpace α]
[inst_2 : (i : ι) → PseudoMetricSpace (β i)] [inst_3 : Zero α] [inst_4 : (i : ι) → Zero (β i)]
[inst_5 : (i : ι) → SMul α (β i)] [∀ (i : ι), IsBoundedSMul α (β i)], IsBoundedSMul α ((i : ι) → β i) | true |
Lean.IR.IRType.rec_2 | Lean.Compiler.IR.Basic | {motive_1 : Lean.IR.IRType → Sort u} →
{motive_2 : Array Lean.IR.IRType → Sort u} →
{motive_3 : List Lean.IR.IRType → Sort u} →
motive_1 Lean.IR.IRType.float →
motive_1 Lean.IR.IRType.uint8 →
motive_1 Lean.IR.IRType.uint16 →
motive_1 Lean.IR.IRType.uint32 →
motive... | false |
_private.Lean.Compiler.LCNF.CompilerM.0.Lean.Compiler.LCNF.normArgImp._unsafe_rec | Lean.Compiler.LCNF.CompilerM | {pu : Lean.Compiler.LCNF.Purity} →
Lean.Compiler.LCNF.FVarSubst pu → Lean.Compiler.LCNF.Arg pu → Bool → Lean.Compiler.LCNF.Arg pu | false |
_private.Mathlib.ModelTheory.Order.0.FirstOrder.Language.model_preorder._simp_4 | Mathlib.ModelTheory.Order | ∀ {L : FirstOrder.Language} {M : Type w} [inst : L.Structure M] {r : L.Relations 2},
M ⊨ r.transitive = IsTrans M fun x y => FirstOrder.Language.Structure.RelMap r ![x, y] | false |
Ultrafilter | Mathlib.Order.Filter.Ultrafilter.Defs | Type u_2 → Type u_2 | true |
_private.Lean.Compiler.IR.EmitLLVM.0.Lean.IR.EmitLLVM.emitExternCall._sparseCasesOn_1 | Lean.Compiler.IR.EmitLLVM | {α : Type u} →
{motive : Option α → Sort u_1} →
(t : Option α) → ((val : α) → motive (some val)) → (Nat.hasNotBit 2 t.ctorIdx → motive t) → motive t | false |
Function.locallyFinsuppWithin.supportLocallyFiniteWithinDomain' | Mathlib.Topology.LocallyFinsupp | ∀ {X : Type u_1} [inst : TopologicalSpace X] {U : Set X} {Y : Type u_2} [inst_1 : Zero Y]
(self : Function.locallyFinsuppWithin U Y), ∀ z ∈ U, ∃ t ∈ nhds z, (t ∩ Function.support self.toFun).Finite | true |
RingEquiv.coe_toEquiv | Mathlib.Algebra.Ring.Equiv | ∀ {R : Type u_4} {S : Type u_5} [inst : Mul R] [inst_1 : Mul S] [inst_2 : Add R] [inst_3 : Add S] (f : R ≃+* S),
⇑↑f = ⇑f | true |
CategoryTheory.ShortComplex.mapHomologyIso'_hom_naturality_assoc | Mathlib.Algebra.Homology.ShortComplex.PreservesHomology | ∀ {C : Type u_1} {D : Type u_2} [inst : CategoryTheory.Category.{v_1, u_1} C]
[inst_1 : CategoryTheory.Category.{v_2, u_2} D] [inst_2 : CategoryTheory.Limits.HasZeroMorphisms C]
[inst_3 : CategoryTheory.Limits.HasZeroMorphisms D] {S₁ S₂ : CategoryTheory.ShortComplex C} (φ : S₁ ⟶ S₂)
(F : CategoryTheory.Functor C ... | true |
BoundedVariationOn.vectorMeasure.congr_simp | Mathlib.MeasureTheory.VectorMeasure.BoundedVariation | ∀ {α : Type u_1} [inst : LinearOrder α] [inst_1 : DenselyOrdered α] [inst_2 : TopologicalSpace α]
[inst_3 : OrderTopology α] [inst_4 : SecondCountableTopology α] [inst_5 : CompactIccSpace α] [hα : MeasurableSpace α]
[inst_6 : BorelSpace α] {E : Type u_2} [inst_7 : NormedAddCommGroup E] [inst_8 : CompleteSpace E] {f... | true |
_private.Init.Data.String.Decode.0.utf8DecodeChar?_eq_assemble₄._proof_3 | Init.Data.String.Decode | ∀ {b : ByteArray}, 4 ≤ b.size → ¬2 < b.size → False | false |
Rat.toNNRat._proof_1 | Mathlib.Data.NNRat.Defs | ∀ (q : ℚ), 0 ≤ max q 0 | false |
StateCpsT.instMonadLiftOfMonad | Init.Control.StateCps | {σ : Type u} → {m : Type u → Type v} → [Monad m] → MonadLift m (StateCpsT σ m) | true |
CategoryTheory.PreGaloisCategory.action_ext_of_isGalois | Mathlib.CategoryTheory.Galois.IsFundamentalgroup | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{u₂, u₁} C] (F : CategoryTheory.Functor C FintypeCat) {G : Type u_1}
[inst_1 : Group G] [inst_2 : (X : C) → MulAction G (F.obj X).obj] [CategoryTheory.PreGaloisCategory.IsNaturalSMul F G]
[inst_4 : CategoryTheory.GaloisCategory C] [CategoryTheory.PreGaloisCategory.Fib... | true |
AdjoinRoot.mapRingEquiv._proof_3 | Mathlib.RingTheory.AdjoinRoot | ∀ {R : Type u_2} {S : Type u_1} [inst : CommRing R] [inst_1 : CommRing S] (f : R ≃+* S) (p : Polynomial R)
(q : Polynomial S) (h : Associated (Polynomial.map (↑f) p) q),
(AdjoinRoot.map (↑f) p q ⋯).comp (AdjoinRoot.map (↑f.symm) q p ⋯) = RingHom.id (AdjoinRoot q) | false |
Finset.image_add_left' | Mathlib.Algebra.Group.Pointwise.Finset.Basic | ∀ {α : Type u_2} [inst : DecidableEq α] [inst_1 : AddGroup α] {t : Finset α} {a : α},
Finset.image (fun b => -a + b) t = t.preimage (fun b => a + b) ⋯ | true |
LieModuleHom.map_add | Mathlib.Algebra.Lie.Basic | ∀ {M : Type u_4} {N : Type u_5} {F : Type u_9} [inst : Add M] [inst_1 : Add N] [inst_2 : FunLike F M N]
[AddHomClass F M N] (f : F) (x y : M), f (x + y) = f x + f y | true |
HahnSeries.embDomainOrderEmbedding_apply | Mathlib.RingTheory.HahnSeries.Lex | ∀ {Γ : Type u_1} {R : Type u_2} [inst : LinearOrder Γ] [inst_1 : PartialOrder R] {Γ' : Type u_3}
[inst_2 : LinearOrder Γ'] (f : Γ ↪o Γ') [inst_3 : Zero R] (a : Lex (HahnSeries Γ R)),
(HahnSeries.embDomainOrderEmbedding f) a = toLex (HahnSeries.embDomain f (ofLex a)) | true |
Int.instIsDomain | Mathlib.Algebra.Ring.Int.Defs | IsDomain ℤ | true |
BitVec.natCast_eq_ofNat | Init.Data.BitVec.Basic | ∀ (w x : ℕ), ↑x = BitVec.ofNat w x | true |
nhdsGE_eq_iInf_inf_principal | Mathlib.Topology.Order.Basic | ∀ {α : Type u} [inst : TopologicalSpace α] [inst_1 : Preorder α] [OrderTopology α] (a : α),
nhdsWithin a (Set.Ici a) = (⨅ u, ⨅ (_ : a < u), Filter.principal (Set.Iio u)) ⊓ Filter.principal (Set.Ici a) | true |
CategoryTheory.Abelian.SpectralObject.SpectralSequenceDataCore.le₃₃' | Mathlib.Algebra.Homology.SpectralObject.HasSpectralSequence | ∀ {ι : Type u_2} {κ : Type u_3} [inst : Preorder ι] {c : ℤ → ComplexShape κ} {r₀ : ℤ}
(data : CategoryTheory.Abelian.SpectralObject.SpectralSequenceDataCore ι c r₀) {r r' : ℤ} (hrr' : r + 1 = r')
(hr : r₀ ≤ r) (pq' : κ) {i₃ i₃' : ι}, i₃ = data.i₃ r pq' ⋯ → i₃' = data.i₃ r' pq' ⋯ → i₃ ≤ i₃' | true |
Filter.vaddAssocClass | Mathlib.Order.Filter.Pointwise | ∀ {α : Type u_2} {β : Type u_3} {γ : Type u_4} [inst : VAdd α β] [inst_1 : VAdd α γ] [inst_2 : VAdd β γ]
[VAddAssocClass α β γ], VAddAssocClass α β (Filter γ) | true |
antideriv_bernoulliFun | Mathlib.NumberTheory.ZetaValues | ∀ (k : ℕ) (x : ℝ), HasDerivAt (fun x => bernoulliFun (k + 1) x / (↑k + 1)) (bernoulliFun k x) x | true |
Nat.Coprime.of_dvd_left | Mathlib.Data.Nat.GCD.Basic | ∀ {a₁ a₂ b : ℕ}, a₁ ∣ a₂ → a₂.Coprime b → a₁.Coprime b | true |
SeparationQuotient.mk_zpow | Mathlib.Topology.Algebra.SeparationQuotient.Basic | ∀ {G : Type u_1} [inst : TopologicalSpace G] [inst_1 : Group G] [inst_2 : IsTopologicalGroup G] (x : G) (n : ℤ),
SeparationQuotient.mk (x ^ n) = SeparationQuotient.mk x ^ n | true |
ConvexCone.mem_toPointedCone._simp_1 | Mathlib.Geometry.Convex.Cone.Pointed | ∀ {R : Type u_1} {E : Type u_2} [inst : Semiring R] [inst_1 : PartialOrder R] [inst_2 : IsOrderedRing R]
[inst_3 : AddCommMonoid E] [inst_4 : Module R E] {C : ConvexCone R E} (hC : C.Pointed) (x : E),
(x ∈ C.toPointedCone hC) = (x ∈ C) | false |
StrictAnti.isMin_of_apply | Mathlib.Order.Monotone.Basic | ∀ {α : Type u} {β : Type v} [inst : Preorder α] [inst_1 : Preorder β] {f : α → β} {a : α},
StrictAnti f → IsMax (f a) → IsMin a | true |
Set.singletonMulHom | Mathlib.Algebra.Group.Pointwise.Set.Basic | {α : Type u_2} → [inst : Mul α] → α →ₙ* Set α | true |
Polynomial.sum_monomial_eq | Mathlib.Algebra.Polynomial.Basic | ∀ {R : Type u} [inst : Semiring R] (p : Polynomial R), (p.sum fun n a => (Polynomial.monomial n) a) = p | true |
MonoidHom.isOpenQuotientMap_of_isQuotientMap | Mathlib.Topology.Algebra.Group.Basic | ∀ {A : Type u_1} [inst : Group A] [inst_1 : TopologicalSpace A] [ContinuousMul A] {B : Type u_2} [inst_3 : Group B]
[inst_4 : TopologicalSpace B] {F : Type u_3} [inst_5 : FunLike F A B] [MonoidHomClass F A B] {φ : F},
Topology.IsQuotientMap ⇑φ → IsOpenQuotientMap ⇑φ | true |
_private.Mathlib.Algebra.Group.Irreducible.Lemmas.0.MulEquiv.irreducible_iff._simp_1_1 | Mathlib.Algebra.Group.Irreducible.Lemmas | ∀ {M : Type u_1} [inst : Monoid M] {p : M}, Irreducible p = (¬IsUnit p ∧ ∀ ⦃a b : M⦄, p = a * b → IsUnit a ∨ IsUnit b) | false |
CategoryTheory.instSmallArrowOfLocallySmall | Mathlib.CategoryTheory.EssentiallySmall | ∀ (C : Type u) [inst : CategoryTheory.Category.{v, u} C] [Small.{w, u} C] [CategoryTheory.LocallySmall.{w, v, u} C],
Small.{w, max u v} (CategoryTheory.Arrow C) | true |
EMetric.infEdist_le_edist_of_mem | Mathlib.Topology.MetricSpace.HausdorffDistance | ∀ {α : Type u} [inst : PseudoEMetricSpace α] {x y : α} {s : Set α}, y ∈ s → Metric.infEDist x s ≤ edist x y | true |
LieModule.coe_chainBot | Mathlib.Algebra.Lie.Weights.Chain | ∀ {R : Type u_1} {L : Type u_2} [inst : CommRing R] [inst_1 : LieRing L] [inst_2 : LieAlgebra R L] {M : Type u_3}
[inst_3 : AddCommGroup M] [inst_4 : Module R M] [inst_5 : LieRingModule L M] [inst_6 : LieModule R L M]
[inst_7 : LieRing.IsNilpotent L] [inst_8 : IsAddTorsionFree R] [inst_9 : IsDomain R]
[inst_10 : ... | true |
Submodule.factor.eq_1 | Mathlib.RingTheory.AdicCompletion.Basic | ∀ {R : Type u_1} {M : Type u_2} [inst : Ring R] [inst_1 : AddCommGroup M] [inst_2 : Module R M] {p p' : Submodule R M}
(H : p ≤ p'), Submodule.factor H = p.mapQ p' LinearMap.id H | true |
Matrix.circulant_isSymm_apply | Mathlib.LinearAlgebra.Matrix.Circulant | ∀ {α : Type u_1} {n : Type u_3} [inst : SubtractionMonoid n] {v : n → α},
(Matrix.circulant v).IsSymm → ∀ (i : n), v (-i) = v i | true |
_private.Lean.Widget.Diff.0.Lean.Widget.exprDiffCore.match_1 | Lean.Widget.Diff | (motive : Lean.Expr × Lean.Expr → Sort u_1) →
(x : Lean.Expr × Lean.Expr) → ((beforeArg afterArg : Lean.Expr) → motive (beforeArg, afterArg)) → motive x | false |
Real.inv_goldenRatio | Mathlib.NumberTheory.Real.GoldenRatio | Real.goldenRatio⁻¹ = -Real.goldenConj | true |
Set.image_subtype_val_Ico_Ici | Mathlib.Order.Interval.Set.Image | ∀ {α : Type u_1} [inst : Preorder α] {a b : α} (c : ↑(Set.Ico a b)), Subtype.val '' Set.Ici c = Set.Ico (↑c) b | true |
_private.Mathlib.Computability.TuringMachine.ToPartrec.0.Turing.PartrecToTM2.trNormal.match_1.splitter | Mathlib.Computability.TuringMachine.ToPartrec | (motive : Turing.ToPartrec.Code → Turing.PartrecToTM2.Cont' → Sort u_1) →
(x : Turing.ToPartrec.Code) →
(x_1 : Turing.PartrecToTM2.Cont') →
((k : Turing.PartrecToTM2.Cont') → motive Turing.ToPartrec.Code.zero' k) →
((k : Turing.PartrecToTM2.Cont') → motive Turing.ToPartrec.Code.succ k) →
(... | true |
instConditionallyCompleteLinearOrderTropical._proof_3 | Mathlib.Algebra.Tropical.Lattice | ∀ {R : Type u_1} [inst : ConditionallyCompleteLinearOrder R] (s : Set (Tropical R)), ¬BddBelow s → sInf s = sInf ∅ | false |
MagmaCat.Hom.ctorIdx | Mathlib.Algebra.Category.Semigrp.Basic | {A B : MagmaCat} → A.Hom B → ℕ | false |
Equiv.sumPiEquivProdPi._proof_1 | Mathlib.Logic.Equiv.Prod | ∀ {ι : Type u_3} {ι' : Type u_2} (π : ι ⊕ ι' → Type u_1) (f : (i : ι ⊕ ι') → π i),
(fun g t => Sum.rec g.1 g.2 t) ((fun f => (fun i => f (Sum.inl i), fun i' => f (Sum.inr i'))) f) = f | false |
Lean.Compiler.LCNF.CompilerM.Context._sizeOf_1 | Lean.Compiler.LCNF.CompilerM | Lean.Compiler.LCNF.CompilerM.Context → ℕ | false |
Finsupp.optionElim_apply_some | Mathlib.Data.Finsupp.Option | ∀ {α : Type u_1} {M : Type u_2} [inst : Zero M] (y : M) (f : α →₀ M) (x : α), (Finsupp.optionElim y f) (some x) = f x | true |
instInhabitedMulAlgebraNorm | Mathlib.Analysis.Normed.Unbundled.AlgebraNorm | (K : Type u_1) → [inst : NormedField K] → Inhabited (MulAlgebraNorm K K) | true |
_private.Mathlib.RingTheory.GradedAlgebra.TensorProduct.0.GradedAlgHom.liftEquiv._simp_2 | Mathlib.RingTheory.GradedAlgebra.TensorProduct | ∀ {S : Type u_3} {M : outParam (Type u_4)} {inst : Add M} {inst_1 : SetLike S M} [self : AddMemClass S M] {s : S}
{a b : M}, a ∈ s → b ∈ s → (a + b ∈ s) = True | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.