name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.67M | allowCompletion bool 2
classes |
|---|---|---|---|
Lean.Meta.Grind.Arith.Cutsat.LeCnstr.below | Lean.Meta.Tactic.Grind.Arith.Cutsat.Types | {motive_1 : Lean.Meta.Grind.Arith.Cutsat.EqCnstr → Sort u} →
{motive_2 : Lean.Meta.Grind.Arith.Cutsat.EqCnstrProof → Sort u} →
{motive_3 : Lean.Meta.Grind.Arith.Cutsat.DvdCnstr → Sort u} →
{motive_4 : Lean.Meta.Grind.Arith.Cutsat.CooperSplitPred → Sort u} →
{motive_5 : Lean.Meta.Grind.Arith.Cutsat.C... | false |
_private.Mathlib.Data.Seq.Computation.0.Computation.results_thinkN.match_1_1 | Mathlib.Data.Seq.Computation | ∀ {α : Type u_1} {s : Computation α} {a : α} {m : ℕ} (motive : ℕ → s.Results a m → Prop) (x : ℕ) (x_1 : s.Results a m),
(∀ (h : s.Results a m), motive 0 h) → (∀ (n : ℕ) (h : s.Results a m), motive n.succ h) → motive x x_1 | false |
NonUnitalCommCStarAlgebra.casesOn | Mathlib.Analysis.CStarAlgebra.Classes | {A : Type u_1} →
{motive : NonUnitalCommCStarAlgebra A → Sort u} →
(t : NonUnitalCommCStarAlgebra A) →
([toNonUnitalNormedCommRing : NonUnitalNormedCommRing A] →
[toStarRing : StarRing A] →
[toCompleteSpace : CompleteSpace A] →
[toCStarRing : CStarRing A] →
... | false |
Std.HashMap.Raw.getElem!_filter | Std.Data.HashMap.RawLemmas | ∀ {α : Type u} {β : Type v} [inst : BEq α] [inst_1 : Hashable α] {m : Std.HashMap.Raw α β} [inst_2 : EquivBEq α]
[inst_3 : LawfulHashable α] [inst_4 : Inhabited β] {f : α → β → Bool} {k : α} (h : m.WF),
(Std.HashMap.Raw.filter f m)[k]! = (m[k]?.pfilter fun x h' => f (m.getKey k ⋯) x).get! | true |
Subalgebra.instPartialOrder | Mathlib.Algebra.Algebra.Subalgebra.Basic | {R : Type u} →
{A : Type v} →
[inst : CommSemiring R] → [inst_1 : Semiring A] → [inst_2 : Algebra R A] → PartialOrder (Subalgebra R A) | true |
_private.Mathlib.NumberTheory.NumberField.InfinitePlace.Ramification.0.NumberField.InfinitePlace.nat_card_stabilizer_eq_one_or_two._simp_1_4 | Mathlib.NumberTheory.NumberField.InfinitePlace.Ramification | ∀ {a b : Prop}, (a ∨ b ↔ a) = (b → a) | false |
ContDiffMapSupportedIn.casesOn | Mathlib.Analysis.Distribution.ContDiffMapSupportedIn | {E : Type u_2} →
{F : Type u_3} →
[inst : NormedAddCommGroup E] →
[inst_1 : NormedSpace ℝ E] →
[inst_2 : NormedAddCommGroup F] →
[inst_3 : NormedSpace ℝ F] →
{n : ℕ∞} →
{K : TopologicalSpace.Compacts E} →
{motive : ContDiffMapSupportedIn E F n K → ... | false |
CategoryTheory.Pseudofunctor.mapComp'_inv_whiskerRight_mapComp'₀₂₃_inv_assoc | Mathlib.CategoryTheory.Bicategory.Strict.Pseudofunctor | ∀ {B : Type u₁} {C : Type u₂} [inst : CategoryTheory.Bicategory B] [inst_1 : CategoryTheory.Bicategory.Strict B]
[inst_2 : CategoryTheory.Bicategory C] (F : CategoryTheory.Pseudofunctor B C) {b₀ b₁ b₂ b₃ : B} (f₀₁ : b₀ ⟶ b₁)
(f₁₂ : b₁ ⟶ b₂) (f₂₃ : b₂ ⟶ b₃) (f₀₂ : b₀ ⟶ b₂) (f₁₃ : b₁ ⟶ b₃) (f : b₀ ⟶ b₃)
(h₀₂ : Cate... | true |
_private.Lean.Elab.Match.0.Lean.Elab.Term.expandNonAtomicDiscrs?.loop._f | Lean.Elab.Match | Lean.Syntax →
(discrs : List Lean.Syntax) →
List.below (motive := fun discrs => Array Lean.Syntax → Lean.Elab.TermElabM Lean.Syntax) discrs →
Array Lean.Syntax → Lean.Elab.TermElabM Lean.Syntax | false |
DomMulAct.stabilizer_ncard | Mathlib.GroupTheory.Perm.DomMulAct | ∀ {α : Type u_1} {ι : Type u_2} (f : α → ι) [Finite α] [inst : Fintype ι],
{g | f ∘ ⇑g = f}.ncard = ∏ i, {a | f a = i}.ncard.factorial | true |
Std.ExtDHashMap.alter_eq_empty_iff._simp_1 | Std.Data.ExtDHashMap.Lemmas | ∀ {α : Type u} {x : BEq α} {x_1 : Hashable α} {β : α → Type v} {m : Std.ExtDHashMap α β} [inst : LawfulBEq α] {k : α}
{f : Option (β k) → Option (β k)}, (m.alter k f = ∅) = ((m = ∅ ∨ m.size = 1 ∧ k ∈ m) ∧ f (m.get? k) = none) | false |
_private.Mathlib.Topology.Compactness.Compact.0.isCompact_pi_infinite._simp_1_1 | Mathlib.Topology.Compactness.Compact | ∀ {X : Type u} [inst : TopologicalSpace X] {s : Set X},
IsCompact s = ∀ (f : Ultrafilter X), ↑f ≤ Filter.principal s → ∃ x ∈ s, ↑f ≤ nhds x | false |
CategoryTheory.IsSplitCoequalizer.casesOn | Mathlib.CategoryTheory.Limits.Shapes.SplitCoequalizer | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
{X Y : C} →
{f g : X ⟶ Y} →
{Z : C} →
{π : Y ⟶ Z} →
{motive : CategoryTheory.IsSplitCoequalizer f g π → Sort u_1} →
(t : CategoryTheory.IsSplitCoequalizer f g π) →
((rightSection : Z ⟶ Y) →... | false |
Int.lcm_assoc | Init.Data.Int.Gcd | ∀ (a b c : ℤ), (↑(a.lcm b)).lcm c = a.lcm ↑(b.lcm c) | true |
MeasureTheory.SimpleFunc.preimage_eq_empty_iff | Mathlib.MeasureTheory.Function.SimpleFunc | ∀ {α : Type u_1} {β : Type u_2} [inst : MeasurableSpace α] (f : MeasureTheory.SimpleFunc α β) (b : β),
⇑f ⁻¹' {b} = ∅ ↔ b ∉ f.range | true |
ZFSet.prod.eq_1 | Mathlib.SetTheory.ZFC.Basic | ZFSet.prod = ZFSet.pairSep fun x x_1 => True | true |
Filter.tendsto_nhds_atTop | Mathlib.Topology.Order.Filter | ∀ {X : Type u_2} [inst : TopologicalSpace X] [inst_1 : PartialOrder X] [OrderTopology X] [NoMaxOrder X],
Filter.Tendsto nhds Filter.atTop (nhds Filter.atTop) | true |
Batteries.PairingHeapImp.Heap.NoSibling.nil | Batteries.Data.PairingHeap | ∀ {α : Type u_1}, Batteries.PairingHeapImp.Heap.nil.NoSibling | true |
ZFSet.sep | Mathlib.SetTheory.ZFC.Basic | (ZFSet.{u_1} → Prop) → ZFSet.{u_1} → ZFSet.{u_1} | true |
CategoryTheory.Triangulated.TStructure.Heart.essImage_eq_heart | Mathlib.CategoryTheory.Triangulated.TStructure.Heart | ∀ {C : Type u} {inst : CategoryTheory.Category.{v, u} 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 : CategoryTheory.... | true |
Nat.testBit_shiftRight | Init.Data.Nat.Bitwise.Lemmas | ∀ {i j : ℕ} (x : ℕ), (x >>> i).testBit j = x.testBit (i + j) | true |
Nat.dvd_iff_prime_pow_dvd_dvd | Mathlib.Data.Nat.Factorization.Basic | ∀ (n d : ℕ), d ∣ n ↔ ∀ (p k : ℕ), Nat.Prime p → p ^ k ∣ d → p ^ k ∣ n | true |
dense_discrete | Mathlib.Topology.Order | ∀ {α : Type u_1} [inst : TopologicalSpace α] [DiscreteTopology α] {s : Set α}, Dense s ↔ s = Set.univ | true |
bddBelow_def | Mathlib.Order.Bounds.Basic | ∀ {α : Type u_1} [inst : Preorder α] {s : Set α}, BddBelow s ↔ ∃ x, ∀ y ∈ s, x ≤ y | true |
CategoryTheory.Functor.Fiber.inducedFunctor._proof_5 | Mathlib.CategoryTheory.FiberedCategory.Fiber | ∀ {𝒮 : Type u_4} {𝒳 : Type u_2} [inst : CategoryTheory.Category.{u_3, u_4} 𝒮]
[inst_1 : CategoryTheory.Category.{u_1, u_2} 𝒳] {p : CategoryTheory.Functor 𝒳 𝒮} {S : 𝒮} {C : Type u_6}
[inst_2 : CategoryTheory.Category.{u_5, u_6} C] {F : CategoryTheory.Functor C 𝒳}
(hF : F.comp p = (CategoryTheory.Functor.co... | false |
QuotientAddGroup.quotientAddEquivOfEq_mk | Mathlib.GroupTheory.QuotientGroup.Basic | ∀ {G : Type u} [inst : AddGroup G] {M N : AddSubgroup G} [inst_1 : M.Normal] [inst_2 : N.Normal] (h : M = N) (x : G),
(QuotientAddGroup.quotientAddEquivOfEq h) ↑x = ↑x | true |
Std.Http.Method.baselineControl.sizeOf_spec | Std.Internal.Http.Data.Method | sizeOf Std.Http.Method.baselineControl = 1 | true |
Lean.PLevelSet | Lean.Level | Type | true |
ProbabilityTheory.uncenteredCovarianceBilinDual._proof_1 | Mathlib.Probability.Moments.CovarianceBilinDual | IsTopologicalAddGroup ℝ | false |
AdicCompletion.of_inj._simp_1 | Mathlib.RingTheory.AdicCompletion.Basic | ∀ {R : Type u_1} [inst : CommRing R] {I : Ideal R} {M : Type u_4} [inst_1 : AddCommGroup M] [inst_2 : Module R M]
[IsHausdorff I M] {a b : M}, ((AdicCompletion.of I M) a = (AdicCompletion.of I M) b) = (a = b) | false |
ProbabilityTheory.Kernel.iIndepSet_iff_iIndepSets_singleton | Mathlib.Probability.Independence.Kernel.Indep | ∀ {α : Type u_1} {Ω : Type u_2} {ι : Type u_3} {_mα : MeasurableSpace α} {_mΩ : MeasurableSpace Ω}
{κ : ProbabilityTheory.Kernel α Ω} {μ : MeasureTheory.Measure α} {f : ι → Set Ω},
(∀ (i : ι), MeasurableSet (f i)) →
(ProbabilityTheory.Kernel.iIndepSet f κ μ ↔ ProbabilityTheory.Kernel.iIndepSets (fun i => {f i})... | true |
MulEquiv.opOp.eq_1 | Mathlib.Algebra.Group.Equiv.Opposite | ∀ (M : Type u_3) [inst : Mul M],
MulEquiv.opOp M = { toEquiv := MulOpposite.opEquiv.trans MulOpposite.opEquiv, map_mul' := ⋯ } | true |
_private.Mathlib.MeasureTheory.Integral.IntervalIntegral.TrapezoidalRule.0.sum_trapezoidal_integral_adjacent_intervals._simp_1_11 | Mathlib.MeasureTheory.Integral.IntervalIntegral.TrapezoidalRule | ∀ {R : Type u_1} [inst : AddMonoidWithOne R] [CharZero R] (n : ℕ), (↑n + 1 = 0) = False | false |
Batteries.RBNode.toArray | Batteries.Data.RBMap.Basic | {α : Type u_1} → Batteries.RBNode α → Array α | true |
Std.Iterators.Types.ULiftIterator.mk.injEq | Init.Data.Iterators.Combinators.Monadic.ULift | ∀ {α : Type u} {m : Type u → Type u'} {n : Type (max u v) → Type v'} {β : Type u}
{lift : ⦃γ : Type u⦄ → m γ → Std.Iterators.ULiftT n γ} (inner inner_1 : Std.IterM m β),
({ inner := inner } = { inner := inner_1 }) = (inner = inner_1) | true |
SimpleGraph.center_eq_univ_iff_radius_eq_ediam | Mathlib.Combinatorics.SimpleGraph.Diam | ∀ {α : Type u_1} {G : SimpleGraph α} [Nonempty α], G.center = Set.univ ↔ G.radius = G.ediam | true |
_private.Mathlib.Analysis.Analytic.Binomial.0.Real.one_div_one_sub_rpow_hasFPowerSeriesOnBall_zero._proof_1_3 | Mathlib.Analysis.Analytic.Binomial | ContinuousConstSMul ℝ ℂ | false |
_private.Mathlib.MeasureTheory.Integral.Bochner.ContinuousLinearMap.0.integral_withDensity_eq_integral_smul._simp_1_2 | Mathlib.MeasureTheory.Integral.Bochner.ContinuousLinearMap | ∀ {α : Type u_1} {ε : Type u_4} {m : MeasurableSpace α} {μ : MeasureTheory.Measure α} [inst : ENorm ε] {f : α → ε},
MeasureTheory.HasFiniteIntegral f μ = (∫⁻ (a : α), ‖f a‖ₑ ∂μ < ⊤) | false |
Matrix.conjTranspose_eq_diagonal._simp_1 | Mathlib.LinearAlgebra.Matrix.ConjTranspose | ∀ {n : Type u_3} {α : Type v} [inst : DecidableEq n] [inst_1 : AddMonoid α] [inst_2 : StarAddMonoid α]
{M : Matrix n n α} {v : n → α}, (M.conjTranspose = Matrix.diagonal v) = (M = Matrix.diagonal (star v)) | false |
CochainComplex.IsKProjective.mk | Mathlib.Algebra.Homology.HomotopyCategory.KProjective | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Abelian C]
{K : CochainComplex C ℤ},
(∀ {L : CochainComplex C ℤ} (f : K ⟶ L), HomologicalComplex.Acyclic L → Nonempty (Homotopy f 0)) → K.IsKProjective | true |
_private.Mathlib.Order.Disjointed.0.disjointed_partialSups._simp_1_1 | Mathlib.Order.Disjointed | ∀ {α : Type u_2} [inst : GeneralizedCoheytingAlgebra α] {a b c : α}, (a \ b ≤ c) = (a ≤ b ⊔ c) | false |
norm_smul_inv_norm | Mathlib.Analysis.Normed.Module.RCLike.Basic | ∀ {𝕜 : Type u_1} [inst : RCLike 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E] [inst_2 : NormedSpace 𝕜 E] {x : E},
x ≠ 0 → ‖(↑‖x‖)⁻¹ • x‖ = 1 | true |
HomologicalComplexUpToQuasiIso.homologyFunctorFactorsh | Mathlib.Algebra.Homology.Localization | (C : Type u_1) →
[inst : CategoryTheory.Category.{v_1, u_1} C] →
{ι : Type u_2} →
(c : ComplexShape ι) →
[inst_1 : CategoryTheory.Preadditive C] →
[inst_2 : CategoryTheory.CategoryWithHomology C] →
[inst_3 : (HomologicalComplex.quasiIso C c).HasLocalization] →
[in... | true |
_private.Lean.Meta.Match.Match.0.Lean.Meta.Match.triviallyComplete | Lean.Meta.Match.Match | Lean.Meta.Match.Problem → Bool | true |
_private.Std.Internal.Http.Data.URI.Encoding.0.Std.Http.URI.ByteArray.toList_toByteArray | Std.Internal.Http.Data.URI.Encoding | ∀ (ba : ByteArray), ba.data.toList.toByteArray = ba | true |
_private.Std.Data.DTreeMap.Internal.Lemmas.0.Std.DTreeMap.Internal.Impl.getKey_eq._simp_1_3 | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {β : α → Type v} {x : Ord α} {t : Std.DTreeMap.Internal.Impl α β} {k : α},
(k ∈ t) = (Std.DTreeMap.Internal.Impl.contains k t = true) | false |
_private.Lean.Meta.Tactic.Cbv.CbvEvalExt.0.Lean.Meta.Tactic.Cbv.instBEqCbvEvalEntry.beq.match_1 | Lean.Meta.Tactic.Cbv.CbvEvalExt | (motive : Lean.Meta.Tactic.Cbv.CbvEvalEntry → Lean.Meta.Tactic.Cbv.CbvEvalEntry → Sort u_1) →
(x x_1 : Lean.Meta.Tactic.Cbv.CbvEvalEntry) →
((a a_1 : Lean.Name) →
(a_2 : Lean.Meta.Sym.Simp.Theorem) →
(b b_1 : Lean.Name) →
(b_2 : Lean.Meta.Sym.Simp.Theorem) →
motive { or... | false |
CompactExhaustion.mk.noConfusion | Mathlib.Topology.Compactness.SigmaCompact | {X : Type u_4} →
{inst : TopologicalSpace X} →
{P : Sort u} →
{toFun : ℕ → Set X} →
{isCompact' : ∀ (n : ℕ), IsCompact (toFun n)} →
{subset_interior_succ' : ∀ (n : ℕ), toFun n ⊆ interior (toFun (n + 1))} →
{iUnion_eq' : ⋃ n, toFun n = Set.univ} →
{toFun' : ℕ → Set... | false |
isLindelof_iff_countable_subfamily_closed | Mathlib.Topology.Compactness.Lindelof | ∀ {X : Type u} [inst : TopologicalSpace X] {s : Set X},
IsLindelof s ↔
∀ {ι : Type u} (t : ι → Set X),
(∀ (i : ι), IsClosed (t i)) → s ∩ ⋂ i, t i = ∅ → ∃ u, u.Countable ∧ s ∩ ⋂ i ∈ u, t i = ∅ | true |
IsWeakLowerModularLattice.rec | Mathlib.Order.ModularLattice | {α : Type u_2} →
[inst : Lattice α] →
{motive : IsWeakLowerModularLattice α → Sort u} →
((inf_covBy_of_covBy_covBy_sup : ∀ {a b : α}, a ⋖ a ⊔ b → b ⋖ a ⊔ b → a ⊓ b ⋖ a) → motive ⋯) →
(t : IsWeakLowerModularLattice α) → motive t | false |
_private.Std.Data.DTreeMap.Internal.Zipper.0.Std.DTreeMap.Internal.toList_rocIter | Std.Data.DTreeMap.Internal.Zipper | ∀ {α : Type u_1} {β : α → Type u_2} [inst : Ord α] [Std.TransOrd α] {t : Std.DTreeMap.Internal.Impl α β}
{t_ord : t.Ordered} {lowerBound upperBound : α},
(Std.DTreeMap.Internal.rocIterator t lowerBound upperBound).toList =
List.filter (fun e => decide ((compare e.fst lowerBound).isGT = true ∧ (compare e.fst upp... | true |
CategoryTheory.Triangulated.TStructure.natTransTruncLEOfLE_ι_assoc | 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 |
Orientation.rightAngleRotation_neg_orientation | Mathlib.Analysis.InnerProductSpace.TwoDim | ∀ {E : Type u_1} [inst : NormedAddCommGroup E] [inst_1 : InnerProductSpace ℝ E] [inst_2 : Fact (Module.finrank ℝ E = 2)]
(o : Orientation ℝ E (Fin 2)) (x : E), (-o).rightAngleRotation x = -o.rightAngleRotation x | true |
_private.Mathlib.Data.Finset.Card.0.Finset.exists_eq_insert_iff._proof_1_1 | Mathlib.Data.Finset.Card | ∀ {α : Type u_1} [inst : DecidableEq α] {s t : Finset α}, (∃ a ∉ s, insert a s = t) → s ⊆ t ∧ s.card + 1 = t.card | false |
Ideal.Quotient.ring._proof_21 | Mathlib.RingTheory.Ideal.Quotient.Defs | ∀ {R : Type u_1} [inst : Ring R] (I : Ideal R) [inst_1 : I.IsTwoSided],
autoParam (∀ (a : R ⧸ I), Ideal.Quotient.ring._aux_19 I 0 a = 0) SubNegMonoid.zsmul_zero'._autoParam | false |
ZeroAtInftyContinuousMap.dist_toBCF_eq_dist | Mathlib.Topology.ContinuousMap.ZeroAtInfty | ∀ {α : Type u} {β : Type v} [inst : TopologicalSpace α] [inst_1 : PseudoMetricSpace β] [inst_2 : Zero β]
{f g : ZeroAtInftyContinuousMap α β}, dist f.toBCF g.toBCF = dist f g | true |
Int.Linear.eq_of_core_cert | Init.Data.Int.Linear | Int.Linear.Poly → Int.Linear.Poly → Int.Linear.Poly → Bool | true |
_private.Batteries.Tactic.Lint.Misc.0.Batteries.Tactic.Lint.univParamsGrouped.match_1 | Batteries.Tactic.Lint.Misc | (motive : Lean.Expr → Sort u_1) →
(x : Lean.Expr) →
((u : Lean.Level) → motive (Lean.Expr.sort u)) →
((n : Lean.Name) → (us : List Lean.Level) → motive (Lean.Expr.const n us)) →
((x : Lean.Expr) → motive x) → motive x | false |
_private.Mathlib.AlgebraicGeometry.Limits.0.AlgebraicGeometry.nonempty_isColimit_cofanMk_of._simp_1_4 | Mathlib.AlgebraicGeometry.Limits | ∀ {α : Type u} {ι : Sort v} {x : α} {s : ι → Set α}, (x ∈ ⋃ i, s i) = ∃ i, x ∈ s i | false |
lt_hasSum | Mathlib.Topology.Algebra.InfiniteSum.Order | ∀ {ι : Type u_1} {α : Type u_3} {L : SummationFilter ι} [inst : AddCommMonoid α] [inst_1 : Preorder α]
[IsOrderedAddMonoid α] [inst_3 : TopologicalSpace α] [OrderClosedTopology α] {f : ι → α} {a : α} [L.NeBot] [L.LeAtTop]
[AddRightStrictMono α], HasSum f a L → ∀ (i : ι), (∀ (j : ι), j ≠ i → 0 ≤ f j) → ∀ (j : ι), j ... | true |
Fin.finsetImage_castAdd_uIcc | Mathlib.Order.Interval.Finset.Fin | ∀ {n : ℕ} (m : ℕ) (i j : Fin n),
Finset.image (Fin.castAdd m) (Finset.uIcc i j) = Finset.uIcc (Fin.castAdd m i) (Fin.castAdd m j) | true |
Lean.EffectiveImport._sizeOf_1 | Lean.Environment | Lean.EffectiveImport → ℕ | false |
CategoryTheory.GrothendieckTopology.OneHypercover.isStronglySeparatedFor | Mathlib.CategoryTheory.Sites.Hypercover.SheafOfTypes | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] {J : CategoryTheory.GrothendieckTopology C} {X : C}
{E : J.OneHypercover X} {F : CategoryTheory.Functor Cᵒᵖ (Type u_2)},
CategoryTheory.Presieve.IsSeparated J F → E.IsStronglySeparatedFor F | true |
Prefunctor.mapPath_nil | Mathlib.Combinatorics.Quiver.Path | ∀ {V : Type u₁} [inst : Quiver V] {W : Type u₂} [inst_1 : Quiver W] (F : V ⥤q W) (a : V),
F.mapPath Quiver.Path.nil = Quiver.Path.nil | true |
Equiv.setCongr_symm_apply | Mathlib.Logic.Equiv.Set | ∀ {α : Type u_3} {s t : Set α} (h : s = t) (b : { b // (fun x => x ∈ t) b }), (Equiv.setCongr h).symm b = ⟨↑b, ⋯⟩ | true |
Mathlib.Meta.NormNum.Result.add._auto_1 | Mathlib.Tactic.NormNum.Basic | Lean.Syntax | false |
WeierstrassCurve.Jacobian.Equation | Mathlib.AlgebraicGeometry.EllipticCurve.Jacobian.Basic | {R : Type r} → [CommRing R] → WeierstrassCurve.Jacobian R → (Fin 3 → R) → Prop | true |
CategoryTheory.PresheafOfGroups.OneCochain.ev_precomp | Mathlib.CategoryTheory.Sites.NonabelianCohomology.H1 | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {G : CategoryTheory.Functor Cᵒᵖ GrpCat} {I : Type w'}
{U : I → C} (self : CategoryTheory.PresheafOfGroups.OneCochain G U) (i j : I) ⦃T T' : C⦄ (φ : T ⟶ T') (a : T' ⟶ U i)
(b : T' ⟶ U j),
(CategoryTheory.ConcreteCategory.hom (G.map φ.op)) (self.ev i j a b) =... | true |
_private.Mathlib.Combinatorics.Additive.ApproximateSubgroup.0.IsApproximateAddSubgroup.card_nsmul_le._proof_1_3 | Mathlib.Combinatorics.Additive.ApproximateSubgroup | ∀ (n : ℕ), ¬n + 2 = 0 | false |
Algebra.Generators.finiteType | Mathlib.RingTheory.Extension.Generators | ∀ {R : Type u} {S : Type v} [inst : CommRing R] [inst_1 : CommRing S] [inst_2 : Algebra R S] {α : Type u_2} [Finite α]
(P : Algebra.Generators R S α), Algebra.FiniteType R S | true |
Lean.Elab.Tactic.Location.wildcard.elim | Lean.Elab.Tactic.Location | {motive : Lean.Elab.Tactic.Location → Sort u} →
(t : Lean.Elab.Tactic.Location) → t.ctorIdx = 0 → motive Lean.Elab.Tactic.Location.wildcard → motive t | false |
ProbabilityTheory.poissonMeasure_singleton | Mathlib.Probability.Distributions.Poisson.Basic | ∀ (r : NNReal) (n : ℕ),
(ProbabilityTheory.poissonMeasure r) {n} = ENNReal.ofReal (Real.exp (-↑r) * ↑r ^ n / ↑n.factorial) | true |
PresheafOfModules.colimitPresheafOfModules_obj | Mathlib.Algebra.Category.ModuleCat.Presheaf.Colimits | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {R : CategoryTheory.Functor Cᵒᵖ RingCat} {J : Type u₂}
[inst_1 : CategoryTheory.Category.{v₂, u₂} J] (F : CategoryTheory.Functor J (PresheafOfModules R))
[inst_2 :
∀ {X Y : Cᵒᵖ} (f : X ⟶ Y),
CategoryTheory.Limits.PreservesColimit (F.comp (Preshea... | true |
Std.Time.Timestamp.instHAddOffset_1 | Std.Time.DateTime.Timestamp | HAdd Std.Time.Timestamp Std.Time.Week.Offset Std.Time.Timestamp | true |
Int.sq_ne_two_mod_four | Mathlib.NumberTheory.PythagoreanTriples | ∀ (z : ℤ), z * z % 4 ≠ 2 | true |
Fin.snocOrderIso._proof_4 | Mathlib.Order.Fin.Tuple | ∀ {n : ℕ} (α : Fin (n + 1) → Type u_1) [inst : (i : Fin (n + 1)) → LE (α i)]
{a b : α (Fin.last n) × ((i : Fin n) → α i.castSucc)}, (Fin.snocEquiv α) a ≤ (Fin.snocEquiv α) b ↔ a ≤ b | false |
_private.Mathlib.LinearAlgebra.RootSystem.Finite.G2.0.RootPairing.chainBotCoeff_if_one_zero._proof_1_4 | 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} [inst_5 : Finite ι]
[inst_6 : CharZero R] [inst_7 : IsDomain R] {i j : ι} [inst_8 : P.IsNotG2],
RootPairing.ch... | false |
_private.Mathlib.NumberTheory.ModularForms.EisensteinSeries.E2.Defs.0.EisensteinSeries._aux_Mathlib_NumberTheory_ModularForms_EisensteinSeries_E2_Defs___macroRules__private_Mathlib_NumberTheory_ModularForms_EisensteinSeries_E2_Defs_0_EisensteinSeries_termφ_1 | Mathlib.NumberTheory.ModularForms.EisensteinSeries.E2.Defs | Lean.Macro | false |
Lean.Elab.Command.Scope.varUIds | Lean.Elab.Command.Scope | Lean.Elab.Command.Scope → Array Lean.Name | true |
_private.Mathlib.Data.List.Basic.0.List.erase_getElem._proof_1_34 | Mathlib.Data.List.Basic | ∀ {ι : Type u_1} [inst : BEq ι] [inst_1 : LawfulBEq ι] (a : ι) (l : List ι) (n : ℕ) (hi : n + 1 < (a :: l).length)
(w : ι) (h_5 : (a == (a :: l)[n + 1]) = true)
(h_6 : ¬-1 * ↑(List.count w (List.take (n + 1) (a :: l))) + ↑(if (l[n] == w) = true then 1 else 0) ≤ 0)
(h_7 : ¬-1 * ↑(List.count w ((a :: l).eraseIdx (n... | false |
Std.DTreeMap.Internal.Impl.get!_insertMany_list_of_contains_eq_false | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Std.DTreeMap.Internal.Impl α β} [Std.TransOrd α] [inst : BEq α]
[Std.LawfulBEqOrd α] [inst_2 : Std.LawfulEqOrd α] (h : t.WF) {l : List ((a : α) × β a)} {k : α}
[inst_3 : Inhabited (β k)], (List.map Sigma.fst l).contains k = false → (↑(t.insertMany l ⋯)).get! k ... | true |
FiniteAddGrp.casesOn | Mathlib.Algebra.Category.Grp.FiniteGrp | {motive : FiniteAddGrp.{u} → Sort u_1} →
(t : FiniteAddGrp.{u}) →
((toAddGrp : AddGrpCat) → [isFinite : Finite ↑toAddGrp] → motive { toAddGrp := toAddGrp, isFinite := isFinite }) →
motive t | false |
NormedAddGroupHom.zsmul._proof_1 | Mathlib.Analysis.Normed.Group.Hom | ∀ {V₁ : Type u_2} {V₂ : Type u_1} [inst : SeminormedAddCommGroup V₁] [inst_1 : SeminormedAddCommGroup V₂] (z : ℤ)
(f : NormedAddGroupHom V₁ V₂) (b : ℝ), (∀ (v : V₁), ‖f.toFun v‖ ≤ b * ‖v‖) → ∀ (v : V₁), ‖(z • ⇑f) v‖ ≤ ‖z‖ • b * ‖v‖ | false |
Lean.MonadRecDepth.mk._flat_ctor | Lean.Exception | {m : Type → Type} → ({α : Type} → ℕ → m α → m α) → m ℕ → m ℕ → Lean.MonadRecDepth m | false |
stdSimplex.ext | Mathlib.Analysis.Convex.StdSimplex | ∀ {S : Type u_1} [inst : Semiring S] [inst_1 : PartialOrder S] {X : Type u_2} [inst_2 : Fintype X]
{s t : ↑(stdSimplex S X)}, ⇑s = ⇑t → s = t | true |
Mathlib.Tactic.LibraryRewrite.Kind.ctorElimType | Mathlib.Tactic.Widget.LibraryRewrite | {motive : Mathlib.Tactic.LibraryRewrite.Kind → Sort u} → ℕ → Sort (max 1 u) | false |
Finset.disjSum_ssubset_disjSum_of_subset_of_ssubset | Mathlib.Data.Finset.Sum | ∀ {α : Type u_1} {β : Type u_2} {s₁ s₂ : Finset α} {t₁ t₂ : Finset β}, s₁ ⊆ s₂ → t₁ ⊂ t₂ → s₁.disjSum t₁ ⊂ s₂.disjSum t₂ | true |
_private.Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.Add.0.Std.Tactic.BVDecide.BVExpr.bitblast.FullAdderInput.cast.match_1.splitter | Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.Add | {α : Type} →
[inst : Hashable α] →
[inst_1 : DecidableEq α] →
{aig1 : Std.Sat.AIG α} →
(motive : Std.Tactic.BVDecide.BVExpr.bitblast.FullAdderInput aig1 → Sort u_1) →
(val : Std.Tactic.BVDecide.BVExpr.bitblast.FullAdderInput aig1) →
((lhs rhs cin : aig1.Ref) → motive { lhs := l... | true |
Mathlib.Tactic.Widget.StringDiagram.Node.noConfusion | Mathlib.Tactic.Widget.StringDiagram | {P : Sort u} →
{t t' : Mathlib.Tactic.Widget.StringDiagram.Node} →
t = t' → Mathlib.Tactic.Widget.StringDiagram.Node.noConfusionType P t t' | false |
Part.instDiv.eq_1 | Mathlib.Data.Part | ∀ {α : Type u_1} [inst : Div α], Part.instDiv = { div := fun a b => (fun x1 x2 => x1 / x2) <$> a <*> b } | true |
CategoryTheory.Abelian.extFunctor_map_app | Mathlib.Algebra.Homology.DerivedCategory.Ext.Basic | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Abelian C]
[inst_2 : CategoryTheory.HasExt C] (n : ℕ) {X₁ X₂ : Cᵒᵖ} (f : X₁ ⟶ X₂) (Y : C),
((CategoryTheory.Abelian.extFunctor n).map f).app Y =
AddCommGrpCat.ofHom (AddMonoidHom.mk' (fun α => (CategoryTheory.Abelian.Ext.mk₀ f.uno... | true |
AddSubmonoid.op_eq_top._simp_1 | Mathlib.Algebra.Group.Submonoid.MulOpposite | ∀ {M : Type u_2} [inst : AddZeroClass M] {S : AddSubmonoid M}, (S.op = ⊤) = (S = ⊤) | false |
HomotopicalAlgebra.CofibrantObject.homRel._proof_1 | Mathlib.AlgebraicTopology.ModelCategory.CofibrantObjectHomotopy | ∀ (C : Type u_2) [inst : CategoryTheory.Category.{u_1, u_2} C] [HomotopicalAlgebra.ModelCategory C],
CategoryTheory.Limits.HasColimitsOfShape (CategoryTheory.Discrete PEmpty.{1}) C | false |
List.rdropWhile_eq_self_iff | Mathlib.Data.List.DropRight | ∀ {α : Type u_1} {p : α → Bool} {l : List α}, List.rdropWhile p l = l ↔ ∀ (hl : l ≠ []), ¬p (l.getLast hl) = true | true |
_private.Init.Data.Int.DivMod.Lemmas.0.Int.bmod_self_add_one._proof_1_1 | Init.Data.Int.DivMod.Lemmas | ∀ {x : ℕ}, ↑x = -1 → False | false |
Mathlib.Tactic.rsuffices | Mathlib.Tactic.RSuffices | Lean.ParserDescr | true |
_private.Mathlib.Algebra.Homology.SpectralObject.HasSpectralSequence.0.CategoryTheory.Abelian.SpectralObject.instHasSpectralSequenceFinHAddNatOfNatProdIntCoreE₂CohomologicalFin._proof_1 | Mathlib.Algebra.Homology.SpectralObject.HasSpectralSequence | ∀ (r r' : ℤ), r + 1 = r' → 2 ≤ r → 2 ≤ r' | false |
Lean.MacroScopesView.noConfusionType | Init.Prelude | Sort u → Lean.MacroScopesView → Lean.MacroScopesView → Sort u | false |
SetLike.gCommMonoid._proof_1 | Mathlib.Algebra.GradedMonoid | ∀ {ι : Type u_1} {R : Type u_2} {S : Type u_3} [inst : SetLike S R] [inst_1 : CommMonoid R] [inst_2 : AddCommMonoid ι]
(A : ι → S) [inst_3 : SetLike.GradedMonoid A] (x x_1 : GradedMonoid fun i => ↥(A i)), x * x_1 = x_1 * x | false |
MultilinearMap.restr_norm_le | Mathlib.Analysis.Normed.Module.Multilinear.Basic | ∀ {𝕜 : Type u} {G : Type wG} {G' : Type wG'} [inst : NontriviallyNormedField 𝕜] [inst_1 : SeminormedAddCommGroup G]
[inst_2 : NormedSpace 𝕜 G] [inst_3 : SeminormedAddCommGroup G'] [inst_4 : NormedSpace 𝕜 G'] {k n : ℕ}
(f : MultilinearMap 𝕜 (fun x => G) G') (s : Finset (Fin n)) (hk : s.card = k) (z : G) {C : ℝ}... | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.