name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.67M | allowCompletion bool 2
classes |
|---|---|---|---|
_private.Mathlib.RingTheory.Unramified.Locus.0.Algebra.unramifiedLocus_eq_compl_support._simp_1_2 | Mathlib.RingTheory.Unramified.Locus | ∀ {R : Type u_1} {M : Type u_2} [inst : CommRing R] [inst_1 : AddCommGroup M] [inst_2 : Module R M]
{p : PrimeSpectrum R}, (p ∉ Module.support R M) = Subsingleton (LocalizedModule p.asIdeal.primeCompl M) | false |
String.Pos.Raw.instLinearOrderPackage._proof_1 | Init.Data.String.OrderInstances | let this := inferInstance;
let this_1 :=
let this := inferInstance;
inferInstance;
∀ (a b : String.Pos.Raw), a < b ↔ a ≤ b ∧ ¬b ≤ a | false |
ZNum.decidableLT | Mathlib.Data.Num.Basic | DecidableLT ZNum | true |
CompHausLike.LocallyConstant.sigmaComparison_comp_sigmaIso | Mathlib.Condensed.Discrete.LocallyConstant | ∀ {P : TopCat → Prop} [inst : ∀ (S : CompHausLike P) (p : ↑S.toTop → Prop), CompHausLike.HasProp P (Subtype p)]
{Q : CompHausLike P} {Z : Type (max u w)} (r : LocallyConstant (↑Q.toTop) Z) (a : Function.Fiber ⇑r)
[inst_1 : CompHausLike.HasExplicitFiniteCoproducts P]
(X : CategoryTheory.Functor (CompHausLike P)ᵒᵖ ... | true |
_private.Lean.Meta.Tactic.Grind.Arith.CommRing.SemiringM.0.Lean.Meta.Grind.Arith.CommRing.setTermSemiringId.match_1 | Lean.Meta.Tactic.Grind.Arith.CommRing.SemiringM | (motive : Option ℕ → Sort u_1) →
(__do_lift : Option ℕ) →
((semiringId' : ℕ) → motive (some semiringId')) → ((x : Option ℕ) → motive x) → motive __do_lift | false |
Array.range'_append_1 | Init.Data.Array.Range | ∀ {s m n : ℕ}, Array.range' s m ++ Array.range' (s + m) n = Array.range' s (m + n) | true |
Finset.prod_prod_Ioi_mul_eq_prod_prod_off_diag | Mathlib.Algebra.Order.BigOperators.Group.LocallyFinite | ∀ {α : Type u_1} {M : Type u_2} [inst : CommMonoid M] [inst_1 : LinearOrder α] [inst_2 : Fintype α]
[inst_3 : LocallyFiniteOrderTop α] [LocallyFiniteOrderBot α] (f : α → α → M),
∏ i, ∏ j ∈ Finset.Ioi i, f j i * f i j = ∏ i, ∏ j ∈ {i}ᶜ, f j i | true |
NonUnitalNonAssocRing.toHasDistribNeg._proof_3 | Mathlib.Algebra.Ring.Defs | ∀ {α : Type u_1} [inst : NonUnitalNonAssocRing α] (a : α), - -a = a | false |
FundamentalGroupoid.instSubsingletonHomPUnit | Mathlib.AlgebraicTopology.FundamentalGroupoid.PUnit | ∀ {x y : FundamentalGroupoid PUnit.{u_1 + 1}}, Subsingleton (x ⟶ y) | true |
_private.Mathlib.Analysis.SpecificLimits.Normed.0.Monotone.tendsto_le_alternating_series._simp_1_2 | Mathlib.Analysis.SpecificLimits.Normed | ∀ {α : Type u} [inst : AddGroup α] [inst_1 : LE α] [AddRightMono α] {a b c : α}, (a - c ≤ b) = (a ≤ b + c) | false |
Submonoid.LocalizationMap.mulEquivOfMulEquiv | Mathlib.GroupTheory.MonoidLocalization.Maps | {M : Type u_1} →
[inst : CommMonoid M] →
{S : Submonoid M} →
{N : Type u_2} →
[inst_1 : CommMonoid N] →
{P : Type u_3} →
[inst_2 : CommMonoid P] →
S.LocalizationMap N →
{T : Submonoid P} →
{Q : Type u_4} →
[ins... | true |
_private.Mathlib.Dynamics.TopologicalEntropy.NetEntropy.0.Dynamics.coverMincard_le_netMaxcard._simp_1_5 | Mathlib.Dynamics.TopologicalEntropy.NetEntropy | ∀ {a b : Prop}, (¬(a ∧ b)) = (a → ¬b) | false |
Submodule.finiteDimensional_iSup | Mathlib.LinearAlgebra.FiniteDimensional.Basic | ∀ {K : Type u} {V : Type v} [inst : DivisionRing K] [inst_1 : AddCommGroup V] [inst_2 : Module K V] {ι : Sort u_1}
[Finite ι] (S : ι → Submodule K V) [∀ (i : ι), FiniteDimensional K ↥(S i)], FiniteDimensional K ↥(⨆ i, S i) | true |
LieSubmodule.ext | Mathlib.Algebra.Lie.Submodule | ∀ {R : Type u} {L : Type v} {M : Type w} [inst : CommRing R] [inst_1 : LieRing L] [inst_2 : AddCommGroup M]
[inst_3 : Module R M] [inst_4 : LieRingModule L M] (N N' : LieSubmodule R L M), (∀ (m : M), m ∈ N ↔ m ∈ N') → N = N' | true |
_private.Init.Data.BitVec.Lemmas.0.BitVec.clzAuxRec_le._proof_1_1 | Init.Data.BitVec.Lemmas | ¬1 < 2 → False | false |
Lean.StructureDescr.fields | Lean.Structure | Lean.StructureDescr → Array Lean.StructureFieldInfo | true |
FirstOrder.Language.DirectLimit.inductionOn | Mathlib.ModelTheory.DirectLimit | ∀ {L : FirstOrder.Language} {ι : Type v} [inst : Preorder ι] {G : ι → Type w} [inst_1 : (i : ι) → L.Structure (G i)]
{f : (i j : ι) → i ≤ j → L.Embedding (G i) (G j)} [inst_2 : IsDirectedOrder ι]
[inst_3 : DirectedSystem G fun i j h => ⇑(f i j h)] [inst_4 : Nonempty ι]
{C : FirstOrder.Language.DirectLimit G f → P... | true |
mul_mem_ball_iff_norm | Mathlib.Analysis.Normed.Group.Basic | ∀ {E : Type u_5} [inst : SeminormedCommGroup E] {a b : E} {r : ℝ}, a * b ∈ Metric.ball a r ↔ ‖b‖ < r | true |
_private.Batteries.Data.String.Lemmas.0.String.Legacy.instDecidableEqIterator.decEq.match_1.splitter | Batteries.Data.String.Lemmas | (motive : String.Legacy.Iterator → String.Legacy.Iterator → Sort u_1) →
(x x_1 : String.Legacy.Iterator) →
((a : String) →
(a_1 : String.Pos.Raw) →
(b : String) → (b_1 : String.Pos.Raw) → motive { s := a, i := a_1 } { s := b, i := b_1 }) →
motive x x_1 | true |
CategoryTheory.Limits.Types.TypeMax.colimitCocone | Mathlib.CategoryTheory.Limits.Types.Colimits | {J : Type v} →
[inst : CategoryTheory.Category.{w, v} J] →
(F : CategoryTheory.Functor J (Type (max v u))) → CategoryTheory.Limits.Cocone F | true |
_private.Std.Data.Iterators.Lemmas.Equivalence.HetT.0.Std.Iterators.HetT.pmap_map._simp_1_1 | Std.Data.Iterators.Lemmas.Equivalence.HetT | ∀ {m : Type w → Type w'} [inst : Monad m] [LawfulMonad m] {α : Type v} {x y : Std.Iterators.HetT m α},
(x = y) =
∃ (h : x.Property = y.Property),
∀ (β : Type w) (f : (a : α) → x.Property a → m β), x.prun f = y.prun fun a ha => f a ⋯ | false |
_private.Lean.Elab.Tactic.Grind.ShowState.0.Lean.Elab.Tactic.Grind.evalShowLocalThms._regBuiltin._private.Lean.Elab.Tactic.Grind.ShowState.0.Lean.Elab.Tactic.Grind.evalShowLocalThms_1 | Lean.Elab.Tactic.Grind.ShowState | IO Unit | false |
CategoryTheory.Localization.inverts | Mathlib.CategoryTheory.Localization.Predicate | ∀ {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] (L : CategoryTheory.Functor C D)
(W : CategoryTheory.MorphismProperty C) [L.IsLocalization W], W.IsInvertedBy L | true |
Set.iUnion₂_inter | Mathlib.Data.Set.Lattice | ∀ {α : Type u_1} {ι : Sort u_5} {κ : ι → Sort u_8} (s : (i : ι) → κ i → Set α) (t : Set α),
(⋃ i, ⋃ j, s i j) ∩ t = ⋃ i, ⋃ j, s i j ∩ t | true |
_private.Mathlib.Order.WithBot.0.WithBot.noMaxOrder.match_1 | Mathlib.Order.WithBot | ∀ {α : Type u_1} [inst : LT α] (a : α) (motive : (∃ b, a < b) → Prop) (x : ∃ b, a < b),
(∀ (b : α) (hba : a < b), motive ⋯) → motive x | false |
CategoryTheory.Functor.OplaxRightLinear.noConfusion | Mathlib.CategoryTheory.Monoidal.Action.LinearFunctor | {P : Sort u} →
{D : Type u_1} →
{D' : Type u_2} →
{inst : CategoryTheory.Category.{v_1, u_1} D} →
{inst_1 : CategoryTheory.Category.{v_2, u_2} D'} →
{F : CategoryTheory.Functor D D'} →
{C : Type u_3} →
{inst_2 : CategoryTheory.Category.{v_3, u_3} C} →
... | false |
TopologicalSpace.instWellFoundedLTClosedsOfNoetherianSpace | Mathlib.Topology.NoetherianSpace | ∀ {α : Type u_1} [inst : TopologicalSpace α] [TopologicalSpace.NoetherianSpace α],
WellFoundedLT (TopologicalSpace.Closeds α) | true |
Finset.erase_val | Mathlib.Data.Finset.Erase | ∀ {α : Type u_1} [inst : DecidableEq α] (s : Finset α) (a : α), (s.erase a).val = s.val.erase a | true |
BddDistLat.Iso.mk._proof_3 | Mathlib.Order.Category.BddDistLat | ∀ {α β : BddDistLat} (e : ↑α.toDistLat ≃o ↑β.toDistLat),
CategoryTheory.CategoryStruct.comp
(BddDistLat.ofHom
(let __src := { toFun := ⇑e, map_sup' := ⋯, map_inf' := ⋯ };
{ toFun := ⇑e, map_sup' := ⋯, map_inf' := ⋯, map_top' := ⋯, map_bot' := ⋯ }))
(BddDistLat.ofHom
(let __src := {... | false |
SimpleGraph.Walk.ofBoxProdLeft._proof_2 | Mathlib.Combinatorics.SimpleGraph.Prod | ∀ {α : Type u_1} {β : Type u_2} {H : SimpleGraph β} {x : α × β} (v : α × β), H.Adj x.2 v.2 ∧ x.1 = v.1 → v.1 = x.1 | false |
List.isEqv.eq_2 | Init.Data.List.Lemmas | ∀ {α : Type u} (x : α → α → Bool) (a : α) (as : List α) (b : α) (bs : List α),
(a :: as).isEqv (b :: bs) x = (x a b && as.isEqv bs x) | true |
_private.Lean.Meta.Tactic.Grind.MBTC.0.Lean.Meta.Grind.instHashableKey.hash.match_1 | Lean.Meta.Tactic.Grind.MBTC | (motive : Lean.Meta.Grind.Key✝ → Sort u_1) →
(x : Lean.Meta.Grind.Key✝¹) → ((a : Lean.Expr) → motive { mask := a }) → motive x | false |
AffineBasis.instInhabitedPUnit._proof_1 | Mathlib.LinearAlgebra.AffineSpace.Basis | ∀ {k : Type u_2} [inst : Ring k], affineSpan k (Set.range id) = ⊤ | false |
CategoryTheory.Abelian.im | Mathlib.CategoryTheory.Abelian.Basic | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
[CategoryTheory.Abelian C] → CategoryTheory.Functor (CategoryTheory.Arrow C) C | true |
MonoidHom.exists_nhds_isBounded | Mathlib.MeasureTheory.Measure.Haar.NormedSpace | ∀ {G : Type u_1} {H : Type u_2} [inst : MeasurableSpace G] [inst_1 : Group G] [inst_2 : TopologicalSpace G]
[IsTopologicalGroup G] [BorelSpace G] [LocallyCompactSpace G] [inst_6 : MeasurableSpace H]
[inst_7 : SeminormedGroup H] [OpensMeasurableSpace H] (f : G →* H),
Measurable ⇑f → ∀ (x : G), ∃ s ∈ nhds x, Bornol... | true |
QuotientGroup.equivQuotientZPowOfEquiv_symm | Mathlib.GroupTheory.QuotientGroup.Basic | ∀ {A B : Type u} [inst : CommGroup A] [inst_1 : CommGroup B] (e : A ≃* B) (n : ℤ),
(QuotientGroup.equivQuotientZPowOfEquiv e n).symm = QuotientGroup.equivQuotientZPowOfEquiv e.symm n | true |
Lean.Lsp.RpcConnected.casesOn | Lean.Data.Lsp.Extra | {motive : Lean.Lsp.RpcConnected → Sort u} →
(t : Lean.Lsp.RpcConnected) → ((sessionId : UInt64) → motive { sessionId := sessionId }) → motive t | false |
Measure.eq_prod_of_integral_prod_mul_boundedContinuousFunction | Mathlib.MeasureTheory.Measure.HasOuterApproxClosedProd | ∀ {ι : Type u_1} {T : Type u_4} {X : ι → Type u_5} {mX : (i : ι) → MeasurableSpace (X i)}
[inst : (i : ι) → TopologicalSpace (X i)] [∀ (i : ι), BorelSpace (X i)] [∀ (i : ι), HasOuterApproxClosed (X i)]
{mT : MeasurableSpace T} [inst_3 : TopologicalSpace T] [BorelSpace T] [HasOuterApproxClosed T] [inst_6 : Fintype ι... | true |
IsApproximateSubgroup.subgroup | Mathlib.Combinatorics.Additive.ApproximateSubgroup | ∀ {G : Type u_1} [inst : Group G] {S : Type u_2} [inst_1 : SetLike S G] [SubgroupClass S G] {H : S},
IsApproximateSubgroup 1 ↑H | true |
HomotopicalAlgebra.FibrantObject.HoCat.ιCompResolutionNatTrans._proof_3 | Mathlib.AlgebraicTopology.ModelCategory.FibrantObjectHomotopy | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : HomotopicalAlgebra.ModelCategory C]
(x x_1 : HomotopicalAlgebra.FibrantObject C) (f : x ⟶ x_1),
HomotopicalAlgebra.FibrantObject.toHoCat.map
(CategoryTheory.CategoryStruct.comp f
{ hom := HomotopicalAlgebra.FibrantObject.HoCat.iR... | false |
symmetrizeRel_subset_self | Mathlib.Topology.UniformSpace.Defs | ∀ {α : Type ua} (V : SetRel α α), symmetrizeRel V ⊆ V | true |
Sylow.mulEquivIteratedWreathProduct._proof_3 | Mathlib.GroupTheory.RegularWreathProduct | ∀ (n : ℕ) (G : Type u_1) [Finite G], Finite (Fin n → G) | false |
LocallyFiniteOrder.toLocallyFiniteOrderBot._proof_2 | Mathlib.Order.Interval.Finset.Defs | ∀ {α : Type u_1} [inst : Preorder α] [inst_1 : OrderBot α] [inst_2 : LocallyFiniteOrder α] (a x : α),
x ∈ Finset.Ico ⊥ a ↔ x < a | false |
_private.Mathlib.RingTheory.MvPolynomial.WeightedHomogeneous.0.MvPolynomial.weightedTotalDegree'_eq_bot_iff._simp_1_4 | Mathlib.RingTheory.MvPolynomial.WeightedHomogeneous | ∀ {α : Type u_1} {a : α}, (↑a = ⊥) = False | false |
Std.HashSet.Raw.get_diff | Std.Data.HashSet.RawLemmas | ∀ {α : Type u} [inst : BEq α] [inst_1 : Hashable α] {m₁ m₂ : Std.HashSet.Raw α} [inst_2 : EquivBEq α]
[inst_3 : LawfulHashable α] (h₁ : m₁.WF) (h₂ : m₂.WF) {k : α} {h_mem : k ∈ m₁ \ m₂},
(m₁ \ m₂).get k h_mem = m₁.get k ⋯ | true |
PadicInt.norm_intCast_lt_one_iff | Mathlib.NumberTheory.Padics.PadicIntegers | ∀ {p : ℕ} [hp : Fact (Nat.Prime p)] {z : ℤ}, ‖↑z‖ < 1 ↔ ↑p ∣ z | true |
_private.Lean.Widget.UserWidget.0.Lean.Widget.builtinModulesRef | Lean.Widget.UserWidget | IO.Ref (Std.TreeMap UInt64 (Lean.Name × Lean.Widget.Module) compare) | true |
LieSubalgebra.span_univ | Mathlib.Algebra.Lie.Subalgebra | ∀ (R : Type u) (L : Type v) [inst : CommRing R] [inst_1 : LieRing L] [inst_2 : LieAlgebra R L],
LieSubalgebra.lieSpan R L Set.univ = ⊤ | true |
CategoryTheory.Lax.OplaxTrans.mk.sizeOf_spec | Mathlib.CategoryTheory.Bicategory.NaturalTransformation.Lax | ∀ {B : Type u₁} [inst : CategoryTheory.Bicategory B] {C : Type u₂} [inst_1 : CategoryTheory.Bicategory C]
{F G : CategoryTheory.LaxFunctor B C} [inst_2 : SizeOf B] [inst_3 : SizeOf C] (app : (a : B) → F.obj a ⟶ G.obj a)
(naturality :
{a b : B} →
(f : a ⟶ b) →
CategoryTheory.CategoryStruct.comp (F.... | true |
Batteries.BinomialHeap.merge.match_1 | Batteries.Data.BinomialHeap.Basic | {α : Type u_1} →
{le : α → α → Bool} →
(motive : Batteries.BinomialHeap α le → Batteries.BinomialHeap α le → Sort u_2) →
(x x_1 : Batteries.BinomialHeap α le) →
((b₁ : Batteries.BinomialHeap.Imp.Heap α) →
(h₁ : Batteries.BinomialHeap.Imp.Heap.WF le 0 b₁) →
(b₂ : Batteries.B... | false |
List.min_replicate | Init.Data.List.MinMax | ∀ {α : Type u_1} [inst : Min α] [Std.MinEqOr α] {n : ℕ} {a : α} (h : List.replicate n a ≠ []),
(List.replicate n a).min h = a | true |
_private.Aesop.Tree.Tracing.0.Aesop.Goal.traceMetadata.match_1 | Aesop.Tree.Tracing | (motive : Option (Lean.MVarId × Lean.Meta.SavedState) → Sort u_1) →
(x : Option (Lean.MVarId × Lean.Meta.SavedState)) →
(Unit → motive none) →
((goal : Lean.MVarId) → (state : Lean.Meta.SavedState) → motive (some (goal, state))) → motive x | false |
Valuation.IsEquiv.orderRingIso.congr_simp | Mathlib.Topology.Algebra.Valued.WithVal | ∀ {R : Type u_4} {Γ₀ : Type u_5} {Γ₀' : Type u_6} [inst : Ring R] [inst_1 : LinearOrderedCommGroupWithZero Γ₀]
[inst_2 : LinearOrderedCommGroupWithZero Γ₀'] {v : Valuation R Γ₀} {w : Valuation R Γ₀'} (h : v.IsEquiv w),
h.orderRingIso = h.orderRingIso | true |
_private.Mathlib.Algebra.Group.TypeTags.Basic.0.isRegular_toMul._simp_1_2 | Mathlib.Algebra.Group.TypeTags.Basic | ∀ {R : Type u_1} [inst : Mul R] {c : R}, IsRegular c = (IsLeftRegular c ∧ IsRightRegular c) | false |
Nat.mul_pos_iff_of_pos_left | Init.Data.Nat.Lemmas | ∀ {a b : ℕ}, 0 < a → (0 < a * b ↔ 0 < b) | true |
LinOrd.instConcreteCategoryOrderHomCarrier._proof_4 | Mathlib.Order.Category.LinOrd | ∀ {X Y Z : LinOrd} (f : X ⟶ Y) (g : Y ⟶ Z) (x : ↑X), (CategoryTheory.CategoryStruct.comp f g).hom' x = g.hom' (f.hom' x) | false |
HomologicalComplex.monoidalCategoryStruct._proof_4 | Mathlib.Algebra.Homology.Monoidal | ∀ (C : Type u_3) [inst : CategoryTheory.Category.{u_2, u_3} C] [inst_1 : CategoryTheory.MonoidalCategory C]
[inst_2 : CategoryTheory.Preadditive C] {I : Type u_1} [inst_3 : AddMonoid I] (c : ComplexShape I)
[∀ (X₁ X₂ X₃ : CategoryTheory.GradedObject I C), X₁.HasGoodTensor₁₂Tensor X₂ X₃] (K₁ K₂ K₃ : HomologicalCompl... | false |
_private.Mathlib.CategoryTheory.MorphismProperty.OfObjectProperty.0.CategoryTheory.MorphismProperty.ofObjectProperty_map_le.match_1_1 | Mathlib.CategoryTheory.MorphismProperty.OfObjectProperty | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] (P Q : CategoryTheory.ObjectProperty C) {D : Type u_4}
[inst_1 : CategoryTheory.Category.{u_3, u_4} D] (F : CategoryTheory.Functor C D) ⦃X Y : D⦄ (f : X ⟶ Y)
(motive : (CategoryTheory.MorphismProperty.ofObjectProperty P Q).map F f → Prop)
(h : (Catego... | false |
CategoryTheory.NatIso.ofComponents'_hom_app | Mathlib.CategoryTheory.NatIso | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
{F G : CategoryTheory.Functor C D} (app : (X : C) → F.obj X ≅ G.obj X)
(naturality :
autoParam
(∀ {X Y : C} (f : Y ⟶ X),
CategoryTheory.CategoryStruct.comp (app Y).inv (F.map f) ... | true |
OrderIso.symm_image_image | Mathlib.Order.Hom.Set | ∀ {α : Type u_1} {β : Type u_2} [inst : LE α] [inst_1 : LE β] (e : α ≃o β) (s : Set α), ⇑e.symm '' (⇑e '' s) = s | true |
spinGroup.mul_star_self_of_mem | Mathlib.LinearAlgebra.CliffordAlgebra.SpinGroup | ∀ {R : Type u_1} [inst : CommRing R] {M : Type u_2} [inst_1 : AddCommGroup M] [inst_2 : Module R M]
{Q : QuadraticForm R M} {x : CliffordAlgebra Q}, x ∈ spinGroup Q → x * star x = 1 | true |
_private.Mathlib.Algebra.GroupWithZero.NonZeroDivisors.0.associatesNonZeroDivisorsEquiv._simp_1 | Mathlib.Algebra.GroupWithZero.NonZeroDivisors | ∀ {M₀ : Type u_2} [inst : MonoidWithZero M₀] {r : M₀},
(r ∈ nonZeroDivisors M₀) = ((∀ (x : M₀), r * x = 0 → x = 0) ∧ ∀ (x : M₀), x * r = 0 → x = 0) | false |
Lean.Parser.sepByElemParser.formatter | Lean.Parser.Extra | Lean.PrettyPrinter.Formatter → String → Lean.PrettyPrinter.Formatter | true |
Submodule.finite_iSup | Mathlib.RingTheory.Finiteness.Lattice | ∀ {R : Type u_2} {V : Type u_3} [inst : Ring R] [inst_1 : AddCommGroup V] [inst_2 : Module R V] {ι : Sort u_1}
[Finite ι] (S : ι → Submodule R V) [∀ (i : ι), Module.Finite R ↥(S i)], Module.Finite R ↥(⨆ i, S i) | true |
Lean.Meta.Grind.Arith.Cutsat.ToIntInfo.ofLE? | Lean.Meta.Tactic.Grind.Arith.Cutsat.ToIntInfo | Lean.Meta.Grind.Arith.Cutsat.ToIntInfo → Option (Option Lean.Expr) | true |
_private.Mathlib.RingTheory.Valuation.Extension.0.Valuation.HasExtension.ofComapInteger._simp_1_2 | Mathlib.RingTheory.Valuation.Extension | ∀ {R : Type u} {S : Type v} [inst : NonAssocRing R] [inst_1 : NonAssocRing S] {s : Subring S} {f : R →+* S} {x : R},
(x ∈ Subring.comap f s) = (f x ∈ s) | false |
_private.Init.Data.Int.Order.0.Int.instLawfulOrderLT._simp_2 | Init.Data.Int.Order | ∀ {a b : Prop} [Decidable a], (a → b) = (¬a ∨ b) | false |
ContinuousMultilinearMap.zero_apply | Mathlib.Topology.Algebra.Module.Multilinear.Basic | ∀ {R : Type u} {ι : Type v} {M₁ : ι → Type w₁} {M₂ : Type w₂} [inst : Semiring R]
[inst_1 : (i : ι) → AddCommMonoid (M₁ i)] [inst_2 : AddCommMonoid M₂] [inst_3 : (i : ι) → Module R (M₁ i)]
[inst_4 : Module R M₂] [inst_5 : (i : ι) → TopologicalSpace (M₁ i)] [inst_6 : TopologicalSpace M₂]
(m : (i : ι) → M₁ i), 0 m ... | true |
Order.height_eq_krullDim_Iic | Mathlib.Order.KrullDimension | ∀ {α : Type u_1} [inst : Preorder α] (x : α), ↑(Order.height x) = Order.krullDim ↑(Set.Iic x) | true |
Lean.Elab.WF.GuessLex.RecCallCache.callerName | Lean.Elab.PreDefinition.WF.GuessLex | Lean.Elab.WF.GuessLex.RecCallCache → Lean.Name | true |
Batteries.RBNode.lowerBound?_eq_find? | Batteries.Data.RBMap.Lemmas | ∀ {α : Type u_1} {x : α} {t : Batteries.RBNode α} {cut : α → Ordering} (lb : Option α),
Batteries.RBNode.find? cut t = some x → Batteries.RBNode.lowerBound? cut t lb = some x | true |
_private.Mathlib.Order.KrullDimension.0.Order.height_le_of_krullDim_preimage_le._proof_1_4 | Mathlib.Order.KrullDimension | ∀ {α : Type u_1} [inst : Preorder α] {m : ℕ} (p : LTSeries α),
p.length ≤ m + (p.length - (m + 1)) → p.length > m → False | false |
_private.Plausible.Gen.0.Plausible.Gen.backtrackFuel.match_1 | Plausible.Gen | (motive : ℕ → Sort u_1) → (fuel : ℕ) → (Unit → motive Nat.zero) → ((fuel' : ℕ) → motive fuel'.succ) → motive fuel | false |
HomologicalComplex.HomologySequence.snakeInput._proof_37 | Mathlib.Algebra.Homology.HomologySequence | ∀ {C : Type u_2} {ι : Type u_3} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.Abelian C]
{c : ComplexShape ι} {S : CategoryTheory.ShortComplex (HomologicalComplex C c)} (i j : ι),
CategoryTheory.Epi
((HomologicalComplex.HomologySequence.composableArrows₃ S.X₂ i j).map' 2 3
Homolog... | false |
CategoryTheory.DifferentialObject.mk._flat_ctor | 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] →
(obj : C) →
(d : obj ⟶ (CategoryTheory.shiftFunctor C 1).obj ... | false |
PiTensorProduct.ofFinsuppEquiv'.eq_1 | Mathlib.LinearAlgebra.PiTensorProduct.Finsupp | ∀ {R : Type u_1} {ι : Type u_2} {κ : ι → Type u_3} [inst : CommSemiring R] [inst_1 : Fintype ι] [inst_2 : DecidableEq ι]
[inst_3 : (i : ι) → DecidableEq (κ i)] [inst_4 : DecidableEq R],
PiTensorProduct.ofFinsuppEquiv' =
PiTensorProduct.ofFinsuppEquiv.trans
(Finsupp.lcongr (Equiv.refl ((i : ι) → κ i)) (PiT... | true |
Turing.TM0.Machine.map_respects | Mathlib.Computability.TuringMachine.PostTuringMachine | ∀ {Γ : Type u_1} [inst : Inhabited Γ] {Γ' : Type u_2} [inst_1 : Inhabited Γ'] {Λ : Type u_3} [inst_2 : Inhabited Λ]
{Λ' : Type u_4} [inst_3 : Inhabited Λ'] (M : Turing.TM0.Machine Γ Λ) (f₁ : Turing.PointedMap Γ Γ')
(f₂ : Turing.PointedMap Γ' Γ) (g₁ : Turing.PointedMap Λ Λ') (g₂ : Λ' → Λ) {S : Set Λ},
Turing.TM0.S... | true |
LaurentPolynomial.ext | Mathlib.Algebra.Polynomial.Laurent | ∀ {R : Type u_1} [inst : Semiring R] {p q : LaurentPolynomial R}, (∀ (a : ℤ), p a = q a) → p = q | true |
signedDist_triangle_left | Mathlib.Geometry.Euclidean.SignedDist | ∀ {V : Type u_1} {P : Type u_2} [inst : NormedAddCommGroup V] [inst_1 : InnerProductSpace ℝ V] [inst_2 : MetricSpace P]
[inst_3 : NormedAddTorsor V P] (v : V) (p q r : P), ((signedDist v) p) q - ((signedDist v) p) r = ((signedDist v) r) q | true |
CategoryTheory.Functor.PreservesLeftKanExtension | Mathlib.CategoryTheory.Functor.KanExtension.Preserves | {A : Type u_1} →
{B : Type u_2} →
{C : Type u_3} →
{D : Type u_4} →
[inst : CategoryTheory.Category.{v_1, u_1} A] →
[inst_1 : CategoryTheory.Category.{v_2, u_2} B] →
[inst_2 : CategoryTheory.Category.{v_3, u_3} C] →
[inst_3 : CategoryTheory.Category.{v_4, u_4} D] ... | true |
ContinuousMap.exists_finite_sum_smul_approximation_of_mem_uniformity | Mathlib.Topology.UniformSpace.ProdApproximation | ∀ {X : Type u_1} {Y : Type u_2} {R : Type u_3} {V : Type u_4} [inst : TopologicalSpace X] [TotallyDisconnectedSpace X]
[T2Space X] [CompactSpace X] [inst_4 : TopologicalSpace Y] [CompactSpace Y] [inst_6 : AddCommGroup V]
[inst_7 : UniformSpace V] [IsUniformAddGroup V] {S : Set (V × V)} [inst_9 : TopologicalSpace R]... | true |
Nat.gcd_dvd_gcd_mul_right_left | Init.Data.Nat.Gcd | ∀ (m n k : ℕ), m.gcd n ∣ (m * k).gcd n | true |
_private.Lean.Meta.Tactic.FunInd.0.Lean.Tactic.FunInd.buildInductionBody._unsafe_rec | Lean.Meta.Tactic.FunInd | Array Lean.FVarId →
Array Lean.FVarId →
Lean.Expr →
Lean.FVarId → Lean.FVarId → (Lean.Expr → Option Lean.Expr) → Lean.Expr → Lean.Tactic.FunInd.M2✝ Lean.Expr | false |
CategoryTheory.Discrete.ctorIdx | Mathlib.CategoryTheory.Discrete.Basic | {α : Type u₁} → CategoryTheory.Discrete α → ℕ | false |
CompleteLattice.mk._flat_ctor | Mathlib.Order.CompleteLattice.Defs | {α : Type u_8} →
(le lt : α → α → Prop) →
(∀ (a : α), le a a) →
(∀ (a b c : α), le a b → le b c → le a c) →
autoParam (∀ (a b : α), lt a b ↔ le a b ∧ ¬le b a) Preorder.lt_iff_le_not_ge._autoParam →
(∀ (a b : α), le a b → le b a → a = b) →
(sup : α → α → α) →
(∀ (a... | false |
Lean.Lsp.Ipc.expandModuleHierarchyImports | Lean.Data.Lsp.Ipc | ℕ → Lean.Lsp.DocumentUri → Lean.Lsp.Ipc.IpcM (Option Lean.Lsp.Ipc.ModuleHierarchy × ℕ) | true |
_private.Mathlib.GroupTheory.Perm.Cycle.Type.0.Equiv.Perm.IsThreeCycle.nodup_iff_mem_support._proof_1_362 | Mathlib.GroupTheory.Perm.Cycle.Type | ∀ {α : Type u_1} [inst_1 : DecidableEq α] {g : Equiv.Perm α} {a : α} (w : α) (h_3 : ¬[g a, g (g a)].Nodup) (w_1 : α)
(h_5 : 2 ≤ List.count w_1 [g a, g (g a)]),
(List.findIdxs (fun x => decide (x = w_1))
[g a,
g (g a)])[List.findIdxNth (fun x => decide (x = w_1)) [g a, g (g a)] (List.idxOfNth w_1 [... | false |
Holor.assocLeft.eq_1 | Mathlib.Data.Holor | ∀ {α : Type} {ds₁ ds₂ ds₃ : List ℕ}, Holor.assocLeft = cast ⋯ | true |
AlgebraicGeometry.Scheme.pretopology._proof_3 | Mathlib.AlgebraicGeometry.Sites.Pretopology | ∀ (P : CategoryTheory.MorphismProperty AlgebraicGeometry.Scheme) [P.IsMultiplicative],
(AlgebraicGeometry.Scheme.precoverage P).IsStableUnderComposition | false |
WeierstrassCurve.Projective.Point | Mathlib.AlgebraicGeometry.EllipticCurve.Projective.Point | {R : Type r} → [CommRing R] → WeierstrassCurve.Projective R → Type r | true |
CategoryTheory.Pretriangulated.invRotateIsoRotateRotateShiftFunctorNegOne | Mathlib.CategoryTheory.Triangulated.TriangleShift | (C : Type u) →
[inst : CategoryTheory.Category.{v, u} C] →
[inst_1 : CategoryTheory.Preadditive C] →
[inst_2 : CategoryTheory.HasShift C ℤ] →
[∀ (n : ℤ), (CategoryTheory.shiftFunctor C n).Additive] →
CategoryTheory.Pretriangulated.invRotate C ≅
(CategoryTheory.Pretriangulated.r... | true |
_private.Mathlib.Algebra.Homology.HomotopyCategory.HomComplexSingle.0.CochainComplex.HomComplex.Cochain.δ_fromSingleMk._proof_1_3 | Mathlib.Algebra.Homology.HomotopyCategory.HomComplexSingle | ∀ {p q n : ℤ}, p + n = q → ∀ (n' q' : ℤ), p + n' = q' → ¬q + 1 = q' → ¬n + 1 = n' | false |
_private.Mathlib.Topology.Instances.AddCircle.DenseSubgroup.0.dense_addSubgroupClosure_pair_iff._simp_1_8 | Mathlib.Topology.Instances.AddCircle.DenseSubgroup | ∀ {G₀ : Type u_3} [inst : GroupWithZero G₀] {a : G₀} (n : ℤ), a ≠ 0 → (a ^ n = 0) = False | false |
ContinuousAlternatingMap.piLinearEquiv._proof_4 | Mathlib.Topology.Algebra.Module.Alternating.Basic | ∀ {A : Type u_1} {M : Type u_2} {ι : Type u_4} [inst : Semiring A] [inst_1 : AddCommMonoid M]
[inst_2 : TopologicalSpace M] [inst_3 : Module A M] {ι' : Type u_5} {M' : ι' → Type u_3}
[inst_4 : (i : ι') → AddCommMonoid (M' i)] [inst_5 : (i : ι') → TopologicalSpace (M' i)]
[inst_6 : ∀ (i : ι'), ContinuousAdd (M' i)... | false |
_private.Mathlib.Analysis.Complex.Hadamard.0.Complex.HadamardThreeLines.norm_le_interp_of_mem_verticalClosedStrip₀₁'._simp_1_6 | Mathlib.Analysis.Complex.Hadamard | ∀ {α : Type u} {β : Type v} (f : α → β) (s : Set α) (y : β), (y ∈ f '' s) = ∃ x ∈ s, f x = y | false |
BiheytingHom.comp_apply | Mathlib.Order.Heyting.Hom | ∀ {α : Type u_2} {β : Type u_3} {γ : Type u_4} [inst : BiheytingAlgebra α] [inst_1 : BiheytingAlgebra β]
[inst_2 : BiheytingAlgebra γ] (f : BiheytingHom β γ) (g : BiheytingHom α β) (a : α), (f.comp g) a = f (g a) | true |
ValuativeRel.IsRankLeOne | Mathlib.RingTheory.Valuation.ValuativeRel.Basic | (R : Type u_1) → [inst : CommRing R] → [ValuativeRel R] → Prop | true |
QuadraticMap.Isometry.proj_apply | Mathlib.LinearAlgebra.QuadraticForm.Prod | ∀ {ι : Type u_1} {R : Type u_2} {P : Type u_7} {Mᵢ : ι → Type u_8} [inst : CommSemiring R]
[inst_1 : (i : ι) → AddCommMonoid (Mᵢ i)] [inst_2 : AddCommMonoid P] [inst_3 : (i : ι) → Module R (Mᵢ i)]
[inst_4 : Module R P] [inst_5 : Fintype ι] [inst_6 : DecidableEq ι] (i : ι) (Q : QuadraticMap R (Mᵢ i) P)
(f : (x : ι... | true |
_private.Aesop.Tree.AddRapp.0.Aesop.copyGoals.match_1 | Aesop.Tree.AddRapp | (motive : Aesop.ForwardState × Aesop.ForwardRuleMatches × Aesop.UnorderedArraySet Lean.MVarId → Sort u_1) →
(__discr : Aesop.ForwardState × Aesop.ForwardRuleMatches × Aesop.UnorderedArraySet Lean.MVarId) →
((forwardState : Aesop.ForwardState) →
(forwardRuleMatches : Aesop.ForwardRuleMatches) →
(... | false |
BitVec.setWidth_eq_append_extractLsb' | Init.Data.BitVec.Lemmas | ∀ {v : ℕ} {x : BitVec v} {w : ℕ}, BitVec.setWidth w x = BitVec.cast ⋯ (0#(w - v) ++ BitVec.extractLsb' 0 (min v w) x) | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.