name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.67M | allowCompletion bool 2
classes |
|---|---|---|---|
RingCon.mkₐ._proof_1 | Mathlib.Algebra.RingQuot | ∀ (S : Type u_2) [inst : CommSemiring S] {A : Type u_1} [inst_1 : Semiring A] [inst_2 : Algebra S A] (c : RingCon A)
(x : S), (↑↑c.mk').toFun ((algebraMap S A) x) = (↑↑c.mk').toFun ((algebraMap S A) x) | false |
SimpleGraph.Copy.toLineGraphEmbedding | Mathlib.Combinatorics.SimpleGraph.LineGraph | {V : Type u_1} → {V' : Type u_2} → {G : SimpleGraph V} → {G' : SimpleGraph V'} → G.Copy G' → G.lineGraph ↪g G'.lineGraph | true |
Function.Surjective.semiring._proof_1 | Mathlib.Algebra.Ring.InjSurj | ∀ {R : Type u_2} {S : Type u_1} (f : R → S) (hf : Function.Surjective f) [inst : Mul S] [inst_1 : Zero S]
[inst_2 : One S] [inst_3 : Pow S ℕ] [inst_4 : Semiring R] (zero : f 0 = 0) (one : f 1 = 1)
(mul : ∀ (x y : R), f (x * y) = f x * f y) (npow : ∀ (x : R) (n : ℕ), f (x ^ n) = f x ^ n) (x : S),
Monoid.npow 0 x =... | false |
ContMDiffMap.group._proof_4 | Mathlib.Geometry.Manifold.Algebra.SmoothFunctions | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {E' : Type u_3} [inst_3 : NormedAddCommGroup E'] [inst_4 : NormedSpace 𝕜 E'] {H : Type u_4}
[inst_5 : TopologicalSpace H] {I : ModelWithCorners 𝕜 E H} {H' : Type u_5} [inst_6 : Topologi... | false |
Set.Pairwise.eq | Mathlib.Logic.Pairwise | ∀ {α : Type u_1} {r : α → α → Prop} {s : Set α} {a b : α}, s.Pairwise r → a ∈ s → b ∈ s → ¬r a b → a = b | true |
ContinuousLinearMap.hasFDerivAtFilter | Mathlib.Analysis.Calculus.FDeriv.Linear | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : AddCommGroup E] [inst_2 : Module 𝕜 E]
[inst_3 : TopologicalSpace E] {F : Type u_3} [inst_4 : AddCommGroup F] [inst_5 : Module 𝕜 F]
[inst_6 : TopologicalSpace F] (f : E →L[𝕜] F) {L : Filter (E × E)}, HasFDerivAtFilter (⇑f) f L | true |
Lean.PrettyPrinter.ppConstNameWithInfos | Lean.PrettyPrinter | Lean.Name → Lean.MetaM Lean.FormatWithInfos | true |
HeytAlg | Mathlib.Order.Category.HeytAlg | Type (u_1 + 1) | true |
Std.DHashMap.Internal.Raw₀.Const.getKey?_filter | Std.Data.DHashMap.Internal.RawLemmas | ∀ {α : Type u} [inst : BEq α] [inst_1 : Hashable α] {β : Type v} (m : Std.DHashMap.Internal.Raw₀ α fun x => β)
[inst_2 : EquivBEq α] [inst_3 : LawfulHashable α] {f : α → β → Bool} {k : α} (h : (↑m).WF),
(Std.DHashMap.Internal.Raw₀.filter f m).getKey? k =
(m.getKey? k).pfilter fun x h' => f x (Std.DHashMap.Inter... | true |
_private.Mathlib.CategoryTheory.ComposableArrows.Basic.0.CategoryTheory.ComposableArrows.homMk₀.match_1.splitter | Mathlib.CategoryTheory.ComposableArrows.Basic | (motive : Fin (0 + 1) → Sort u_1) → (i : Fin (0 + 1)) → ((isLt : 0 < 0 + 1) → motive ⟨0, isLt⟩) → motive i | true |
Irrational.of_natCast_add | Mathlib.NumberTheory.Real.Irrational | ∀ {x : ℝ} (m : ℕ), Irrational (↑m + x) → Irrational x | true |
_private.Std.Data.DTreeMap.Internal.Lemmas.0.Std.DTreeMap.Internal.Impl.getD_inter_of_contains_right._simp_1_1 | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {x : Ord α} {x_1 : BEq α} [Std.LawfulBEqOrd α] {a b : α}, (compare a b = Ordering.eq) = ((a == b) = true) | false |
List.merge_perm_append._unary | Init.Data.List.Sort.Lemmas | ∀ {α : Type u_1} (le : α → α → Bool) (_x : (_ : List α) ×' List α), (_x.1.merge _x.2 le).Perm (_x.1 ++ _x.2) | false |
_private.Mathlib.Tactic.DeriveCountable.0.Mathlib.Deriving.Countable.cons_eq_imp_init | Mathlib.Tactic.DeriveCountable | ∀ {p : Prop} {a b b' : ℕ}, (b = b' → p) → Nat.pair a b = Nat.pair a b' → p | true |
CategoryTheory.CommShift₂Setup.hε._autoParam | Mathlib.CategoryTheory.Shift.CommShiftTwo | Lean.Syntax | false |
Function.locallyFinsuppWithin.single_pos_int_one._simp_1 | Mathlib.Topology.LocallyFinsupp | ∀ {X : Type u_1} [inst : TopologicalSpace X] [inst_1 : DecidableEq X] {x : X},
(0 < Function.locallyFinsuppWithin.single x 1) = True | false |
AddMonoidAlgebra.instHopfAlgebraStruct._proof_2 | Mathlib.RingTheory.HopfAlgebra.MonoidAlgebra | ∀ (R : Type u_1) (A : Type u_3) [inst : CommSemiring R] [inst_1 : Semiring A] [inst_2 : HopfAlgebra R A] (G : Type u_2),
SMulCommClass R R (AddMonoidAlgebra A G) | false |
Finset.mem_sigmaLift | Mathlib.Data.Finset.Sigma | ∀ {ι : Type u_1} {α : ι → Type u_2} {β : ι → Type u_3} {γ : ι → Type u_4} [inst : DecidableEq ι]
(f : ⦃i : ι⦄ → α i → β i → Finset (γ i)) (a : Sigma α) (b : Sigma β) (x : Sigma γ),
x ∈ Finset.sigmaLift f a b ↔ ∃ (ha : a.fst = x.fst) (hb : b.fst = x.fst), x.snd ∈ f (ha ▸ a.snd) (hb ▸ b.snd) | true |
CategoryTheory.Abelian.SpectralObject.dKernelSequence_X₃ | Mathlib.Algebra.Homology.SpectralObject.Homology | ∀ {C : Type u_1} {ι : Type u_2} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Abelian C]
[inst_2 : CategoryTheory.Category.{v_2, u_2} ι] (X : CategoryTheory.Abelian.SpectralObject C ι)
{i₀ i₁ i₂ i₃ i₄ i₅ : ι} (f₁ : i₀ ⟶ i₁) (f₂ : i₁ ⟶ i₂) (f₃ : i₂ ⟶ i₃) (f₄ : i₃ ⟶ i₄) (f₅ : i₄ ⟶ i₅) (f₂₃ : ... | true |
_private.Mathlib.RingTheory.PicardGroup.0.Submodule.ker_unitsToPic.match_1_1 | Mathlib.RingTheory.PicardGroup | ∀ (R : Type u_1) (A : Type u_2) [inst : CommSemiring R] [inst_1 : Semiring A] [inst_2 : Algebra R A]
(I : (Submodule R A)ˣ) (e : R ≃ₗ[R] ↥↑I) (e' : R ≃ₗ[R] ↥↑I⁻¹)
(motive : (∃ r, ↑(e 1) * ↑(e' 1) = (algebraMap R A) ↑r) → Prop) (x : ∃ r, ↑(e 1) * ↑(e' 1) = (algebraMap R A) ↑r),
(∀ (r : Rˣ) (hr : ↑(e 1) * ↑(e' 1) =... | false |
_private.Std.Data.DTreeMap.Internal.Balancing.0.Std.DTreeMap.Internal.Impl.balanceL!.match_1.eq_3 | Std.Data.DTreeMap.Internal.Balancing | ∀ {α : Type u_1} {β : α → Type u_2} (motive : Std.DTreeMap.Internal.Impl α β → Sort u_3) (size : ℕ) (lk : α) (lv : β lk)
(size_1 : ℕ) (lrk : α) (lrv : β lrk) (l r : Std.DTreeMap.Internal.Impl α β)
(h_1 : Unit → motive Std.DTreeMap.Internal.Impl.leaf)
(h_2 :
(size : ℕ) →
(k : α) →
(v : β k) →
... | true |
instCommMonoidPNat._proof_7 | Mathlib.Data.PNat.Basic | autoParam (∀ (n : ℕ) (x : ℕ+), instCommMonoidPNat._aux_4 (n + 1) x = instCommMonoidPNat._aux_4 n x * x)
Monoid.npow_succ._autoParam | false |
Units.coe_star_inv | Mathlib.Algebra.Star.Basic | ∀ {R : Type u} [inst : Monoid R] [inst_1 : StarMul R] (u : Rˣ), ↑(star u)⁻¹ = star ↑u⁻¹ | true |
Order.IsSuccLimit.bot_lt | Mathlib.Order.SuccPred.Limit | ∀ {α : Type u_1} {a : α} [inst : PartialOrder α] [inst_1 : OrderBot α], Order.IsSuccLimit a → ⊥ < a | true |
Std.Net.IPv6Addr.toString | Std.Net.Addr | Std.Net.IPv6Addr → String | true |
AlgebraicGeometry.mono_pushoutSection_of_iSup_eq | Mathlib.AlgebraicGeometry.Morphisms.Flat | ∀ {X Y S T : AlgebraicGeometry.Scheme} {f : T ⟶ S} {g : Y ⟶ X} {iX : X ⟶ S} {iY : Y ⟶ T}
(H : CategoryTheory.IsPullback g iY iX f) {US : S.Opens} {UT : T.Opens} {UX : X.Opens}
(hUST : UT ≤ (TopologicalSpace.Opens.map f.base).obj US) (hUSX : UX ≤ (TopologicalSpace.Opens.map iX.base).obj US)
{UY : Y.Opens} (hUY : U... | true |
_private.Init.Data.Nat.Fold.0.Nat.foldTR.loop | Init.Data.Nat.Fold | {α : Type u} → (n : ℕ) → ((i : ℕ) → i < n → α → α) → (j : ℕ) → j ≤ n → α → α | true |
Lean.Elab.InlayHintKind | Lean.Elab.InfoTree.InlayHints | Type | true |
CategoryTheory.forget_obj | Mathlib.CategoryTheory.ConcreteCategory.Forget | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] {FC : outParam (C → C → Type u_2)}
{CC : outParam (C → Type w)} [inst_1 : outParam ((X Y : C) → FunLike (FC X Y) (CC X) (CC Y))]
[inst_2 : CategoryTheory.ConcreteCategory C FC] (X : C), (CategoryTheory.forget C).obj X = CategoryTheory.ToType X | true |
SimpleGraph.natCast_card_dart_eq_dotProduct | Mathlib.Combinatorics.SimpleGraph.AdjMatrix | ∀ {α : Type u_1} {V : Type u_2} (G : SimpleGraph V) [inst : DecidableRel G.Adj] [inst_1 : Fintype V]
[inst_2 : NonAssocSemiring α], ↑(Fintype.card G.Dart) = (SimpleGraph.adjMatrix α G).mulVec 1 ⬝ᵥ 1 | true |
FreeAbelianGroup.liftMonoid._proof_8 | Mathlib.GroupTheory.FreeAbelianGroup | ∀ {α : Type u_1} {R : Type u_2} [inst : Monoid α] [inst_1 : Ring R] (f : α →* R),
(↑{ toFun := ⇑(FreeAbelianGroup.lift ⇑f), map_one' := ⋯, map_mul' := ⋯, map_zero' := ⋯, map_add' := ⋯ }).comp
FreeAbelianGroup.ofMulHom =
f | false |
RingHom.id_apply | Mathlib.Algebra.Ring.Hom.Defs | ∀ {α : Type u_2} {x : NonAssocSemiring α} (x_1 : α), (RingHom.id α) x_1 = x_1 | true |
Nat.cast_pow._simp_1 | Mathlib.Data.Nat.Cast.Basic | ∀ {α : Type u_1} [inst : Semiring α] (m n : ℕ), ↑m ^ n = ↑(m ^ n) | false |
_private.Init.Grind.Ring.CommSolver.0.Lean.Grind.CommRing.Expr.toPoly.match_4.eq_6 | Init.Grind.Ring.CommSolver | ∀ (motive : Lean.Grind.CommRing.Expr → Sort u_1) (a b : Lean.Grind.CommRing.Expr)
(h_1 : (k : ℤ) → motive (Lean.Grind.CommRing.Expr.num k))
(h_2 : (k : ℤ) → motive (Lean.Grind.CommRing.Expr.intCast k))
(h_3 : (k : ℕ) → motive (Lean.Grind.CommRing.Expr.natCast k))
(h_4 : (x : Lean.Grind.CommRing.Var) → motive (L... | true |
_private.Lean.Compiler.LCNF.ToMono.0.Lean.Compiler.LCNF.argsToMonoRedArg.match_1 | Lean.Compiler.LCNF.ToMono | (motive : Lean.Compiler.LCNF.Arg Lean.Compiler.LCNF.Purity.pure → Sort u_1) →
(redArg : Lean.Compiler.LCNF.Arg Lean.Compiler.LCNF.Purity.pure) →
((fvarId : Lean.FVarId) → motive (Lean.Compiler.LCNF.Arg.fvar fvarId)) →
(Unit → motive Lean.Compiler.LCNF.Arg.erased) →
((expr : Lean.Expr) → motive (Lean... | false |
List.Cursor.casesOn | Std.Do.Triple.SpecLemmas | {α : Type u} →
{l : List α} →
{motive : l.Cursor → Sort u_1} →
(t : l.Cursor) →
((«prefix» suffix : List α) →
(property : «prefix» ++ suffix = l) →
motive { «prefix» := «prefix», suffix := suffix, property := property }) →
motive t | false |
Lean.IR.IRType.isDefiniteRef | Lean.Compiler.IR.Basic | Lean.IR.IRType → Bool | true |
_private.Init.Data.Sum.Lemmas.0.Sum.exists.match_1_3 | Init.Data.Sum.Lemmas | ∀ {α : Type u_1} {β : Type u_2} {p : α ⊕ β → Prop} (motive : ((∃ a, p (Sum.inl a)) ∨ ∃ b, p (Sum.inr b)) → Prop)
(x : (∃ a, p (Sum.inl a)) ∨ ∃ b, p (Sum.inr b)),
(∀ (a : α) (h : p (Sum.inl a)), motive ⋯) → (∀ (b : β) (h : p (Sum.inr b)), motive ⋯) → motive x | false |
Lean.Grind.instCommRingBitVec._proof_2 | Init.GrindInstances.Ring.BitVec | ∀ {w : ℕ} (n : ℕ) (a : BitVec w), n • a = ↑n * a | false |
CategoryTheory.Limits.pushoutPushoutRightIsPushout | Mathlib.CategoryTheory.Limits.Shapes.Pullback.Assoc | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
{X₁ X₂ X₃ Z₁ Z₂ : C} →
(g₁ : Z₁ ⟶ X₁) →
(g₂ : Z₁ ⟶ X₂) →
(g₃ : Z₂ ⟶ X₂) →
(g₄ : Z₂ ⟶ X₃) →
[inst_1 : CategoryTheory.Limits.HasPushout g₁ g₂] →
[inst_2 : CategoryTheory.Limits.HasPushout g₃ ... | true |
Affine.Simplex.exsphere_compl | Mathlib.Geometry.Euclidean.Incenter | ∀ {V : Type u_1} {P : Type u_2} [inst : NormedAddCommGroup V] [inst_1 : InnerProductSpace ℝ V] [inst_2 : MetricSpace P]
[inst_3 : NormedAddTorsor V P] {n : ℕ} [inst_4 : NeZero n] (s : Affine.Simplex ℝ P n) (signs : Finset (Fin (n + 1))),
s.exsphere signsᶜ = s.exsphere signs | true |
Subspace.orderIsoFiniteCodimDim | Mathlib.LinearAlgebra.Dual.Lemmas | {K : Type u_4} →
{V : Type u_5} →
[inst : Field K] →
[inst_1 : AddCommGroup V] →
[inst_2 : Module K V] → { W // FiniteDimensional K (V ⧸ W) } ≃o { W // FiniteDimensional K ↥W }ᵒᵈ | true |
MeasureTheory.Measure.ae_le_pi | Mathlib.MeasureTheory.Constructions.Pi | ∀ {ι : Type u_1} {α : ι → Type u_3} [inst : Fintype ι] [inst_1 : (i : ι) → MeasurableSpace (α i)]
{μ : (i : ι) → MeasureTheory.Measure (α i)} [∀ (i : ι), MeasureTheory.SigmaFinite (μ i)] {β : ι → Type u_4}
[inst_3 : (i : ι) → Preorder (β i)] {f f' : (i : ι) → α i → β i},
(∀ (i : ι), f i ≤ᵐ[μ i] f' i) → (fun x i =... | true |
Aesop.ForwardRulePriority.normSafe.sizeOf_spec | Aesop.Rule.Forward | ∀ (n : ℤ), sizeOf (Aesop.ForwardRulePriority.normSafe n) = 1 + sizeOf n | true |
LinearMap.kerComplementEquivRange._proof_1 | Mathlib.LinearAlgebra.Prod | ∀ {R : Type u_1} [inst : Ring R], RingHomSurjective (RingHom.id R) | false |
Function.Bijective.existsUnique_iff | Mathlib.Logic.Function.Basic | ∀ {α : Sort u_1} {β : Sort u_2} {f : α → β}, Function.Bijective f → ∀ {p : β → Prop}, (∃! y, p y) ↔ ∃! x, p (f x) | true |
BitVec.msb_neg_of_ne_intMin_of_ne_zero | Init.Data.BitVec.Bitblast | ∀ {w : ℕ} {x : BitVec w}, x ≠ BitVec.intMin w → x ≠ 0#w → (-x).msb = !x.msb | true |
_private.Mathlib.Combinatorics.SimpleGraph.Regularity.Chunk.0.SzemerediRegularity.card_nonuniformWitness_sdiff_biUnion_star._simp_1_2 | Mathlib.Combinatorics.SimpleGraph.Regularity.Chunk | ∀ {α : Sort u_1} {p : α → Prop}, (¬∃ x, p x) = ∀ (x : α), ¬p x | false |
CharTwo.natCast_cases | Mathlib.Algebra.CharP.Two | ∀ (R : Type u_1) [inst : AddMonoidWithOne R] [CharP R 2] (n : ℕ), ↑n = 0 ∨ ↑n = 1 | true |
Std.Internal.List.getValue?_filter_not_contains_map_fst_of_contains_right | Std.Data.Internal.List.Associative | ∀ {α : Type u} {β : Type v} [inst : BEq α] [EquivBEq α] {l₁ l₂ : List ((_ : α) × β)} {k : α},
Std.Internal.List.DistinctKeys l₁ →
Std.Internal.List.containsKey k l₂ = true →
Std.Internal.List.getValue? k (List.filter (fun p => !(List.map Sigma.fst l₂).contains p.fst) l₁) = none | true |
Int.log_zpow | Mathlib.Data.Int.Log | ∀ {R : Type u_1} [inst : Semifield R] [inst_1 : LinearOrder R] [IsStrictOrderedRing R] [inst_3 : FloorSemiring R]
{b : ℕ}, 1 < b → ∀ (z : ℤ), Int.log b (↑b ^ z) = z | true |
ProbabilityTheory.condExpKernel_ae_eq_condExp | Mathlib.Probability.Kernel.Condexp | ∀ {Ω : Type u_1} {m : MeasurableSpace Ω} [mΩ : MeasurableSpace Ω] [inst : StandardBorelSpace Ω]
{μ : MeasureTheory.Measure Ω} [inst_1 : MeasureTheory.IsFiniteMeasure μ],
m ≤ mΩ →
∀ {s : Set Ω},
MeasurableSet s → (fun ω => ((ProbabilityTheory.condExpKernel μ m) ω).real s) =ᵐ[μ] μ[s.indicator fun ω => 1 | m... | true |
Subfield.mk.injEq | Mathlib.Algebra.Field.Subfield.Defs | ∀ {K : Type u} [inst : DivisionRing K] (toSubring : Subring K)
(inv_mem' : ∀ x ∈ toSubring.carrier, x⁻¹ ∈ toSubring.carrier) (toSubring_1 : Subring K)
(inv_mem'_1 : ∀ x ∈ toSubring_1.carrier, x⁻¹ ∈ toSubring_1.carrier),
({ toSubring := toSubring, inv_mem' := inv_mem' } = { toSubring := toSubring_1, inv_mem' := in... | true |
Lean.Compiler.LCNF.JoinPointFinder.FindState.mk.injEq | Lean.Compiler.LCNF.JoinPoints | ∀ (candidates candidates_1 : Std.HashMap Lean.FVarId Lean.Compiler.LCNF.JoinPointFinder.CandidateInfo),
({ candidates := candidates } = { candidates := candidates_1 }) = (candidates = candidates_1) | true |
RCLike.realRingEquiv._proof_1 | Mathlib.Analysis.RCLike.Basic | ∀ {K : Type u_1} [inst : RCLike K], RCLike.I = 0 → ∀ (x : K), ↑(RCLike.re x) = x | false |
Mathlib.Tactic.Ring.pow_add | Mathlib.Tactic.Ring.Common | ∀ {R : Type u_1} [inst : CommSemiring R] {a c₁ c₂ : R} {b₁ b₂ : ℕ} {d : R},
a ^ b₁ = c₁ → a ^ b₂ = c₂ → c₁ * c₂ = d → a ^ (b₁ + b₂) = d | true |
CategoryTheory.Triangulated.Octahedron'.triangle_mor₁ | Mathlib.CategoryTheory.Triangulated.Triangulated | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Preadditive C]
[inst_2 : CategoryTheory.Limits.HasZeroObject C] [inst_3 : CategoryTheory.HasShift C ℤ]
[inst_4 : ∀ (n : ℤ), (CategoryTheory.shiftFunctor C n).Additive] [inst_5 : CategoryTheory.Pretriangulated C]
{X₁ X₂ X₃ Z₁₂ ... | true |
_private.Mathlib.RingTheory.MvPolynomial.EulerIdentity.0.MvPolynomial.IsWeightedHomogeneous.sum_weight_X_mul_pderiv._simp_1_3 | Mathlib.RingTheory.MvPolynomial.EulerIdentity | ∀ {α : Type u} [inst : NonAssocSemiring α] (n : ℕ) (a : α), ↑n * a = n • a | false |
FirstOrder.Language.Substructure.gciMapComap | Mathlib.ModelTheory.Substructures | {L : FirstOrder.Language} →
{M : Type w} →
{N : Type u_1} →
[inst : L.Structure M] →
[inst_1 : L.Structure N] →
{f : L.Hom M N} →
Function.Injective ⇑f →
GaloisCoinsertion (FirstOrder.Language.Substructure.map f) (FirstOrder.Language.Substructure.comap f) | true |
ContinuousMonoidHom.instContinuousEval | Mathlib.Topology.Algebra.Group.CompactOpen | ∀ (A : Type u_2) (B : Type u_3) [inst : Monoid A] [inst_1 : Monoid B] [inst_2 : TopologicalSpace A]
[inst_3 : TopologicalSpace B] [LocallyCompactPair A B], ContinuousEval (A →ₜ* B) A B | true |
Polynomial.Splits.neg | Mathlib.Algebra.Polynomial.Splits | ∀ {R : Type u_1} [inst : Ring R] {f : Polynomial R}, f.Splits → (-f).Splits | true |
ContinuousMap.liftCover_coe' | Mathlib.Topology.ContinuousMap.Basic | ∀ {α : Type u_1} {β : Type u_2} [inst : TopologicalSpace α] [inst_1 : TopologicalSpace β] {A : Set (Set α)}
{F : (s : Set α) → s ∈ A → C(↑s, β)}
{hF :
∀ (s : Set α) (hs : s ∈ A) (t : Set α) (ht : t ∈ A) (x : α) (hxi : x ∈ s) (hxj : x ∈ t),
(F s hs) ⟨x, hxi⟩ = (F t ht) ⟨x, hxj⟩}
{hA : ∀ (x : α), ∃ i ∈ A,... | true |
Std.Time.Day.instLEOffset._aux_1 | Std.Time.Date.Unit.Day | Std.Time.Day.Offset → Std.Time.Day.Offset → Prop | false |
AffineSubspace.instCompleteLattice._proof_13 | Mathlib.LinearAlgebra.AffineSpace.AffineSubspace.Defs | ∀ {k : Type u_3} {V : Type u_2} {P : Type u_1} [inst : Ring k] [inst_1 : AddCommGroup V] [inst_2 : Module k V]
[S : AddTorsor V P] (x : k) (x_1 x_2 x_3 : P), False → x_2 ∈ ∅ → x_3 ∈ ∅ → x • (x_1 -ᵥ x_2) +ᵥ x_3 ∈ ∅ | false |
CategoryTheory.Sieve._sizeOf_1 | Mathlib.CategoryTheory.Sites.Sieves | {C : Type u₁} → {inst : CategoryTheory.Category.{v₁, u₁} C} → {X : C} → [SizeOf C] → CategoryTheory.Sieve X → ℕ | false |
Ideal.minimalPrimes.equivIrreducibleComponents._proof_4 | Mathlib.RingTheory.Spectrum.Prime.Topology | ∀ {R : Type u_1} [inst : CommSemiring R] (I : Ideal R) (x : ↑{p | p.IsPrime ∧ I ≤ p}),
(↑⟨{ asIdeal := ↑x, isPrime := ⋯ }, ⋯⟩).asIdeal.IsPrime ∧ I ≤ (↑⟨{ asIdeal := ↑x, isPrime := ⋯ }, ⋯⟩).asIdeal | false |
Lean.SubExpr.Pos.typeCoord | Lean.SubExpr | ℕ | true |
_private.Mathlib.GroupTheory.Commutator.Basic.0.Subgroup.commutator_prod_prod._simp_1_1 | Mathlib.GroupTheory.Commutator.Basic | ∀ {G : Type u_1} [inst : Group G] {N : Type u_5} [inst_1 : Group N] {H : Subgroup G} {K : Subgroup N}
{J : Subgroup (G × N)},
(J ≤ H.prod K) = (Subgroup.map (MonoidHom.fst G N) J ≤ H ∧ Subgroup.map (MonoidHom.snd G N) J ≤ K) | false |
Lean.Widget.InteractiveGoal | Lean.Widget.InteractiveGoal | Type | true |
Membership.ctorIdx | Init.Prelude | {α : outParam (Type u)} → {γ : Type v} → Membership α γ → ℕ | false |
HomologicalComplex.instIsStrictlySupportedTruncLE | Mathlib.Algebra.Homology.Embedding.TruncLE | ∀ {ι : Type u_1} {ι' : Type u_2} {c : ComplexShape ι} {c' : ComplexShape ι'} {C : Type u_3}
[inst : CategoryTheory.Category.{v_1, u_3} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
(K : HomologicalComplex C c') (e : c.Embedding c') [inst_2 : e.IsTruncLE] [inst_3 : ∀ (i' : ι'), K.HasHomology i']
[inst_4 :... | true |
Hyperreal.epsilon_ne_zero | Mathlib.Analysis.Real.Hyperreal | Hyperreal.epsilon ≠ 0 | true |
String.Slice.ByteIterator.s | Init.Data.String.Iterate | String.Slice.ByteIterator → String.Slice | true |
Circle.instIsTopologicalGroup | Mathlib.Analysis.Complex.Circle | IsTopologicalGroup Circle | true |
CategoryTheory.Groupoid.isoEquivHom._proof_6 | Mathlib.CategoryTheory.Groupoid | ∀ {C : Type u_2} [inst : CategoryTheory.Groupoid C] (X Y : C),
Function.RightInverse (fun f => { hom := f, inv := CategoryTheory.Groupoid.inv f, hom_inv_id := ⋯, inv_hom_id := ⋯ })
CategoryTheory.Iso.hom | false |
_private.Std.Time.Format.Basic.0.Std.Time.parseQuarterNumber | Std.Time.Format.Basic | Std.Internal.Parsec.String.Parser Std.Time.Month.Quarter | true |
TopologicalSpace.Opens.functor_map_eq_inf | Mathlib.Topology.Category.TopCat.Opens | ∀ {X : TopCat} (U V : TopologicalSpace.Opens ↑X),
⋯.functor.obj ((TopologicalSpace.Opens.map U.inclusion').obj V) = V ⊓ U | true |
Set.subset_accumulate | Mathlib.Data.Set.Accumulate | ∀ {α : Type u_1} {β : Type u_2} {s : α → Set β} [inst : Preorder α] {x : α}, s x ⊆ Set.accumulate s x | true |
WithAbs.map_apply | Mathlib.Analysis.Normed.Ring.WithAbs | ∀ {R : Type u_1} {S : Type u_2} [inst : Semiring S] [inst_1 : PartialOrder S] [inst_2 : Semiring R]
(v : AbsoluteValue R S) {T : Type u_3} [inst_3 : Semiring T] (w : AbsoluteValue T S) (f : R →+* T) (x : WithAbs v),
(WithAbs.map v w f) x = WithAbs.toAbs w (f x.ofAbs) | true |
contDiff_prodMk_right | Mathlib.Analysis.Calculus.ContDiff.Operations | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type uE} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {F : Type uF} [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace 𝕜 F] {n : WithTop ℕ∞}
(e₀ : E), ContDiff 𝕜 n fun f => (e₀, f) | true |
_private.Std.Internal.Async.Select.0.Std.Internal.IO.Async.shuffleIt.go.eq_def | Std.Internal.Async.Select | ∀ {α : Type u} (xs : Array α) (gen : StdGen) (i : ℕ),
Std.Internal.IO.Async.shuffleIt.go✝ xs gen i =
if x : i < xs.size - 1 then
match randNat gen i (xs.size - 1) with
| (j, gen) =>
have xs := xs.swapIfInBounds i j;
Std.Internal.IO.Async.shuffleIt.go✝¹ xs gen (i + 1)
else xs | true |
_private.Mathlib.Tactic.Linter.TextBased.0.Mathlib.Linter.TextBased.StyleError.noConfusionType | Mathlib.Tactic.Linter.TextBased | Sort u → Mathlib.Linter.TextBased.StyleError✝ → Mathlib.Linter.TextBased.StyleError✝ → Sort u | false |
PEquiv.mk.inj | Mathlib.Data.PEquiv | ∀ {α : Type u} {β : Type v} {toFun : α → Option β} {invFun : β → Option α}
{inv : ∀ (a : α) (b : β), invFun b = some a ↔ toFun a = some b} {toFun_1 : α → Option β} {invFun_1 : β → Option α}
{inv_1 : ∀ (a : α) (b : β), invFun_1 b = some a ↔ toFun_1 a = some b},
{ toFun := toFun, invFun := invFun, inv := inv } = { ... | true |
_private.Mathlib.Analysis.Matrix.Normed.0.Matrix.norm_unitOf | Mathlib.Analysis.Matrix.Normed | ∀ {α : Type u_5} [inst : NormedDivisionRing α] [inst_1 : NormedAlgebra ℝ α] (a : α), ‖Matrix.unitOf✝ a‖₊ = 1 | true |
instTotallyDisconnectedSpaceSum | Mathlib.Topology.Connected.TotallyDisconnected | ∀ {α : Type u} {β : Type v} [inst : TopologicalSpace α] [inst_1 : TopologicalSpace β] [TotallyDisconnectedSpace α]
[TotallyDisconnectedSpace β], TotallyDisconnectedSpace (α ⊕ β) | true |
Topology.CWComplex.instRelCWComplex._proof_5 | Mathlib.Topology.CWComplex.Classical.Basic | ∀ {X : Type u_1} [inst : TopologicalSpace X] (C : Set X) [inst_1 : Topology.CWComplex C],
∀ A ⊆ C,
(∀ (n : ℕ) (j : Topology.CWComplex.cell C n),
IsClosed (A ∩ ↑(Topology.CWComplex.map n j) '' Metric.closedBall 0 1)) ∧
IsClosed (A ∩ ∅) →
IsClosed A | false |
Nat.fermatNumber | Mathlib.NumberTheory.Fermat | ℕ → ℕ | true |
Std.Time.instHAddOffsetOffset | Std.Time.Date.Basic | HAdd Std.Time.Nanosecond.Offset Std.Time.Millisecond.Offset Std.Time.Nanosecond.Offset | true |
ωCPO.instLargeCategory._proof_3 | Mathlib.Order.Category.OmegaCompletePartialOrder | ∀ {W X Y Z : ωCPO} (f : W.carrier →𝒄 X.carrier) (g : X.carrier →𝒄 Y.carrier) (h : Y.carrier →𝒄 Z.carrier),
h.comp (g.comp f) = (h.comp g).comp f | false |
CategoryTheory.Linear.homCongr_symm_apply | Mathlib.CategoryTheory.Linear.Basic | ∀ (k : Type u_1) {C : Type u_2} [inst : CategoryTheory.Category.{v_1, u_2} C] [inst_1 : Semiring k]
[inst_2 : CategoryTheory.Preadditive C] [inst_3 : CategoryTheory.Linear k C] {X Y W Z : C} (f₁ : X ≅ Y) (f₂ : W ≅ Z)
(f : Y ⟶ Z),
(CategoryTheory.Linear.homCongr k f₁ f₂).symm f =
CategoryTheory.CategoryStruct.... | true |
_private.Lean.Meta.Tactic.Grind.PP.0.Lean.Meta.Grind.Result.and.match_1 | Lean.Meta.Tactic.Grind.PP | (motive : Lean.Meta.Grind.Result✝ → Lean.Meta.Grind.Result✝ → Sort u_1) →
(x x_1 : Lean.Meta.Grind.Result✝¹) →
((x : Lean.Meta.Grind.Result✝²) → motive Lean.Meta.Grind.Result.no✝ x) →
((x : Lean.Meta.Grind.Result✝³) → motive x Lean.Meta.Grind.Result.no✝¹) →
((x : Lean.Meta.Grind.Result✝⁴) → motive L... | false |
ONote.NF.mk | Mathlib.SetTheory.Ordinal.Notation | ∀ {o : ONote}, Exists o.NFBelow → o.NF | true |
CategoryTheory.Functor.CoreMonoidal.associativity._autoParam | Mathlib.CategoryTheory.Monoidal.Functor | Lean.Syntax | false |
MeasureTheory.definition._@.Mathlib.MeasureTheory.Function.ConditionalLExpectation.118845607._hygCtx._hyg.8 | Mathlib.MeasureTheory.Function.ConditionalLExpectation | {Ω : Type u_1} → {mΩ₀ : MeasurableSpace Ω} → MeasurableSpace Ω → MeasureTheory.Measure Ω → (Ω → ENNReal) → Ω → ENNReal | false |
AddAction.compHom._proof_1 | Mathlib.Algebra.Group.Action.Hom | ∀ {M : Type u_3} {N : Type u_2} (α : Type u_1) [inst : AddMonoid M] [inst_1 : AddAction M α] [inst_2 : AddMonoid N]
(g : N →+ M) (x x_1 : N) (x_2 : α), (x + x_1) +ᵥ x_2 = x +ᵥ x_1 +ᵥ x_2 | false |
_private.Init.Meta.Defs.0.Lean.Syntax.structEq._sparseCasesOn_2 | Init.Meta.Defs | {motive_1 : Lean.Syntax → Sort u} →
(t : Lean.Syntax) →
((info : Lean.SourceInfo) →
(kind : Lean.SyntaxNodeKind) → (args : Array Lean.Syntax) → motive_1 (Lean.Syntax.node info kind args)) →
(Nat.hasNotBit 2 t.ctorIdx → motive_1 t) → motive_1 t | false |
_private.Mathlib.Topology.Connected.Clopen.0.IsClopen.isPreconnected_iff._proof_1_5 | Mathlib.Topology.Connected.Clopen | ∀ {α : Type u_1} {s : Set α} (a b : Set α), s ∩ (a ∩ b) = ∅ → Disjoint (s ∩ a) (s ∩ b) | false |
Nat.digits_of_two_le_of_pos | Mathlib.Data.Nat.Digits.Defs | ∀ {n b : ℕ}, 2 ≤ b → 0 < n → b.digits n = n % b :: b.digits (n / b) | true |
NonUnitalAlgHom.inr_apply | Mathlib.Algebra.Algebra.NonUnitalHom | ∀ {R : Type u} [inst : Monoid R] {A : Type v} {B : Type w} [inst_1 : NonUnitalNonAssocSemiring A]
[inst_2 : DistribMulAction R A] [inst_3 : NonUnitalNonAssocSemiring B] [inst_4 : DistribMulAction R B] (x : B),
(NonUnitalAlgHom.inr R A B) x = (0, x) | true |
Pi.instLattice._proof_2 | Mathlib.Order.Lattice | ∀ {ι : Type u_1} {α' : ι → Type u_2} [inst : (i : ι) → Lattice (α' i)] (a b : (i : ι) → α' i),
SemilatticeInf.inf a b ≤ b | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.