name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.67M | allowCompletion bool 2
classes |
|---|---|---|---|
Lean.Compiler.LCNF.anyFVarM | Lean.Compiler.LCNF.FVarUtil | {m : Type → Type} → {α : Type} → [Monad m] → [Lean.Compiler.LCNF.TraverseFVar α] → (Lean.FVarId → m Bool) → α → m Bool | true |
Mathlib.Meta.Finset.ProveEmptyOrConsResult.empty.noConfusion | Mathlib.Tactic.NormNum.BigOperators | {u : Lean.Level} →
{α : Q(Type u)} →
{s : Q(Finset «$α»)} →
{P : Sort u} →
{pf pf' : Q(«$s» = ∅)} →
Mathlib.Meta.Finset.ProveEmptyOrConsResult.empty pf = Mathlib.Meta.Finset.ProveEmptyOrConsResult.empty pf' →
(pf = pf' → P) → P | false |
IntermediateField.finrank_dvd_of_le_left | Mathlib.FieldTheory.IntermediateField.Algebraic | ∀ {K : Type u_1} {L : Type u_2} [inst : Field K] [inst_1 : Field L] [inst_2 : Algebra K L]
{F E : IntermediateField K L}, F ≤ E → Module.finrank (↥E) L ∣ Module.finrank (↥F) L | true |
Set.Ici.boundedOrder | Mathlib.Order.LatticeIntervals | {α : Type u_1} → [inst : Preorder α] → [OrderTop α] → {a : α} → BoundedOrder ↑(Set.Ici a) | true |
CategoryTheory.Functor.PullbackObjObj.π_iso_of_iso_left_hom | Mathlib.CategoryTheory.Limits.Shapes.Pullback.PullbackObjObj | ∀ {C₁ : Type u₁} {C₂ : Type u₂} {C₃ : Type u₃} [inst : CategoryTheory.Category.{v₁, u₁} C₁]
[inst_1 : CategoryTheory.Category.{v₂, u₂} C₂] [inst_2 : CategoryTheory.Category.{v₃, u₃} C₃]
{G : CategoryTheory.Functor C₁ᵒᵖ (CategoryTheory.Functor C₃ C₂)} {f₁ f₁' : CategoryTheory.Arrow C₁}
{f₃ : CategoryTheory.Arrow C... | true |
Std.HashSet.getD_ofList_of_mem | Std.Data.HashSet.Lemmas | ∀ {α : Type u} {x : BEq α} {x_1 : Hashable α} [EquivBEq α] [LawfulHashable α] {l : List α} {k k' fallback : α},
(k == k') = true → List.Pairwise (fun a b => (a == b) = false) l → k ∈ l → (Std.HashSet.ofList l).getD k' fallback = k | true |
CategoryTheory.Limits.colimMap_eq | Mathlib.CategoryTheory.Limits.HasLimits | ∀ {J : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} J] {C : Type u} [inst_1 : CategoryTheory.Category.{v, u} C]
{F : CategoryTheory.Functor J C} [inst_2 : CategoryTheory.Limits.HasColimitsOfShape J C]
{G : CategoryTheory.Functor J C} (α : F ⟶ G), CategoryTheory.Limits.colimMap α = CategoryTheory.Limits.colim.m... | true |
InverseSystem.pEquivOnGlue._proof_5 | Mathlib.Order.DirectedInverseSystem | ∀ {ι : Type u_1} {F : ι → Type u_3} {X : ι → Type u_2} {i : ι} [inst : LinearOrder ι]
{f : ⦃i j : ι⦄ → i ≤ j → F j → F i} [inst_1 : SuccOrder ι]
{equivSucc : ⦃i : ι⦄ → ¬IsMax i → F (Order.succ i) ≃ F i × X i} [inst_2 : WellFoundedLT ι]
(hi : Order.IsSuccPrelimit i) (e : (j : ↑(Set.Iio i)) → InverseSystem.PEquivOn... | false |
Sublattice.coe_sup._simp_1 | Mathlib.Order.Sublattice | ∀ {α : Type u_2} [inst : Lattice α] {L : Sublattice α} (a b : ↥L), ↑a ⊔ ↑b = ↑(a ⊔ b) | false |
_private.Lean.Elab.InfoTree.Main.0.Lean.Elab.formatStxRange.match_1 | Lean.Elab.InfoTree.Main | (motive : Lean.SourceInfo → Sort u_1) →
(info : Lean.SourceInfo) →
((leading : Substring.Raw) →
(pos : String.Pos.Raw) →
(trailing : Substring.Raw) →
(endPos : String.Pos.Raw) → motive (Lean.SourceInfo.original leading pos trailing endPos)) →
((pos endPos : String.Pos.Raw) → mo... | false |
Std.Time.Formats.leanDateTimeWithIdentifier | Std.Time.Format | Std.Time.GenericFormat Std.Time.Awareness.any | true |
Submonoid.coe_mul_self_eq | Mathlib.Algebra.Group.Submonoid.Pointwise | ∀ {M : Type u_3} [inst : Monoid M] (s : Submonoid M), ↑s * ↑s = ↑s | true |
LinearMap.curry_uncurryLeft | Mathlib.LinearAlgebra.Multilinear.Curry | ∀ {R : Type uR} {n : ℕ} {M : Fin n.succ → Type v} {M₂ : Type v₂} [inst : CommSemiring R]
[inst_1 : (i : Fin n.succ) → AddCommMonoid (M i)] [inst_2 : AddCommMonoid M₂]
[inst_3 : (i : Fin n.succ) → Module R (M i)] [inst_4 : Module R M₂]
(f : M 0 →ₗ[R] MultilinearMap R (fun i => M i.succ) M₂), f.uncurryLeft.curryLef... | true |
FractionalIdeal.num_zero_eq | Mathlib.RingTheory.FractionalIdeal.Basic | ∀ {R : Type u_1} [inst : CommRing R] {S : Submonoid R} {P : Type u_2} [inst_1 : CommRing P] [inst_2 : Algebra R P],
Function.Injective ⇑(algebraMap R P) → FractionalIdeal.num 0 = 0 | true |
smoothingFun_nonneg | Mathlib.Analysis.Normed.Unbundled.SmoothingSeminorm | ∀ {R : Type u_1} [inst : CommRing R] (μ : RingSeminorm R), μ 1 ≤ 1 → ∀ (x : R), 0 ≤ smoothingFun μ x | true |
Lean.Parser.Term.doReassignArrow._regBuiltin.Lean.Parser.Term.doReassignArrow.formatter_7 | Lean.Parser.Do | IO Unit | false |
RingEquiv.sumArrowEquivProdArrow_apply | Mathlib.Algebra.Ring.Equiv | ∀ {α : Type u_2} {β : Type u_3} {R : Type u_4} [inst : NonAssocSemiring R] (x : α ⊕ β → R),
(RingEquiv.sumArrowEquivProdArrow α β R) x = (Equiv.sumArrowEquivProdArrow α β R) x | true |
AlgEquiv.prodUnique._proof_1 | Mathlib.Algebra.Algebra.Prod | ∀ {A : Type u_1} {B : Type u_2} [inst : Semiring A] [inst_1 : Semiring B] [inst_2 : Unique B],
Function.LeftInverse (RingEquiv.prodZeroRing A B).symm.invFun (RingEquiv.prodZeroRing A B).symm.toFun | false |
Mathlib.Tactic.TautoSet.specialize_all | Mathlib.Tactic.TautoSet | Lean.ParserDescr | true |
CategoryTheory.Functor.LaxLeftLinear.mk._flat_ctor | Mathlib.CategoryTheory.Monoidal.Action.LinearFunctor | {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] →
[inst_3 : CategoryTheory.Mo... | false |
instCoeTCMulEquivOfMulEquivClass.eq_1 | Mathlib.Algebra.Group.Equiv.Defs | ∀ {F : Type u_1} {α : Type u_2} {β : Type u_3} [inst : EquivLike F α β] [inst_1 : Mul α] [inst_2 : Mul β]
[inst_3 : MulEquivClass F α β], instCoeTCMulEquivOfMulEquivClass = { coe := MulEquivClass.toMulEquiv } | true |
Std.Time.Day.Ordinal.ofNat._auto_1 | Std.Time.Date.Unit.Day | Lean.Syntax | false |
CategoryTheory.Cat.Hom.isoMk_inv | Mathlib.CategoryTheory.Category.Cat | ∀ {C D : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Category.{v, u} D]
{F G : CategoryTheory.Functor C D} (e : F ≅ G),
(CategoryTheory.Cat.Hom.isoMk e).inv = CategoryTheory.NatTrans.toCatHom₂ e.inv | true |
CommRingCat.forget₂Ring_preservesLimits | Mathlib.Algebra.Category.Ring.Limits | CategoryTheory.Limits.PreservesLimits (CategoryTheory.forget₂ CommRingCat RingCat) | true |
eq_zero_of_neg_eq | Mathlib.Algebra.Order.Group.Defs | ∀ {α : Type u} [inst : AddCommGroup α] [inst_1 : LinearOrder α] [IsOrderedAddMonoid α] {a : α}, -a = a → a = 0 | true |
Besicovitch.exists_goodδ | Mathlib.MeasureTheory.Covering.BesicovitchVectorSpace | ∀ (E : Type u_1) [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E] [FiniteDimensional ℝ E],
∃ δ,
0 < δ ∧
δ < 1 ∧
∀ (s : Finset E),
(∀ c ∈ s, ‖c‖ ≤ 2) → (∀ c ∈ s, ∀ d ∈ s, c ≠ d → 1 - δ ≤ ‖c - d‖) → s.card ≤ Besicovitch.multiplicity E | true |
CompleteOrthogonalIdempotents.ringEquivOfIsMulCentral._proof_2 | Mathlib.RingTheory.Idempotents | ∀ {R : Type u_1} {I : Type u_2} [inst : Fintype I] {e : I → R} [inst_1 : Semiring R]
(he : CompleteOrthogonalIdempotents e),
(∀ (i : I), IsMulCentral (e i)) →
∀ (r : R), (fun r => ∑ i, ↑(r i)) ((fun r i => ⟨(fun x => e i * x * e i) r, ⋯⟩) r) = r | false |
_private.Mathlib.Tactic.DepRewrite.0.Lean.MVarId.depRewrite.match_3 | Mathlib.Tactic.DepRewrite | (motive : Lean.Expr → Sort u_1) →
(eAbst : Lean.Expr) →
((binderName : Lean.Name) →
(binderType : Lean.Expr) →
(binderName_1 : Lean.Name) →
(binderType_1 eBody : Lean.Expr) →
(binderInfo binderInfo_1 : Lean.BinderInfo) →
motive
(Lean.Ex... | false |
RingCon.ringConGen_eq | Mathlib.RingTheory.Congruence.Basic | ∀ {R : Type u_3} [inst : Add R] [inst_1 : Mul R] (r : R → R → Prop),
ringConGen r = sInf {s | ∀ (x y : R), r x y → s x y} | true |
AddGroupSeminorm.map_zero' | Mathlib.Analysis.Normed.Group.Seminorm | ∀ {G : Type u_6} [inst : AddGroup G] (self : AddGroupSeminorm G), self.toFun 0 = 0 | true |
CompleteLatticeHom._sizeOf_1 | Mathlib.Order.Hom.CompleteLattice | {α : Type u_8} →
{β : Type u_9} →
{inst : CompleteLattice α} → {inst_1 : CompleteLattice β} → [SizeOf α] → [SizeOf β] → CompleteLatticeHom α β → ℕ | false |
NonUnitalSubsemiring.instBot._proof_2 | Mathlib.RingTheory.NonUnitalSubsemiring.Defs | ∀ {R : Type u_1} [inst : NonUnitalNonAssocSemiring R] {a b : R}, a ∈ {0} → b ∈ {0} → a * b ∈ {0} | false |
Finmap.union.eq_1 | Mathlib.Data.Finmap | ∀ {α : Type u} {β : α → Type v} [inst : DecidableEq α] (s₁ s₂ : Finmap β),
s₁.union s₂ = s₁.liftOn₂ s₂ (fun s₁ s₂ => (s₁ ∪ s₂).toFinmap) ⋯ | true |
instRingCorner._proof_14 | Mathlib.RingTheory.Idempotents | ∀ {R : Type u_1} (e : R) [inst : NonUnitalRing R] (idem : IsIdempotentElem e) (n : ℕ) (x : idem.Corner),
Semiring.npow (n + 1) x = Semiring.npow n x * x | false |
IncidenceAlgebra.instRing._proof_6 | Mathlib.Combinatorics.Enumerative.IncidenceAlgebra | ∀ {𝕜 : Type u_1} {α : Type u_2} [inst : Preorder α] [inst_1 : Ring 𝕜] (n : ℕ) (a : IncidenceAlgebra 𝕜 α),
SubNegMonoid.zsmul (Int.negSucc n) a = -SubNegMonoid.zsmul (↑n.succ) a | false |
SSet.RelativeMorphism.ofSimplex₀._proof_2 | Mathlib.AlgebraicTopology.SimplicialSet.RelativeMorphism | ∀ {X Y : SSet} (f : X ⟶ Y) (x : X.obj (Opposite.op (SimplexCategory.mk 0)))
(y : Y.obj (Opposite.op (SimplexCategory.mk 0))),
f.app (Opposite.op (SimplexCategory.mk 0)) x = y →
CategoryTheory.CategoryStruct.comp (SSet.Subcomplex.ofSimplex x).ι f =
CategoryTheory.CategoryStruct.comp (SSet.const ⟨y, ⋯⟩) (SS... | false |
DFinsupp.hasAdd₂ | Mathlib.Data.DFinsupp.Defs | {ι : Type u} →
{α : ι → Type u_2} →
{δ : (i : ι) → α i → Type v} →
[inst : (i : ι) → (j : α i) → AddZeroClass (δ i j)] → Add (Π₀ (i : ι) (j : α i), δ i j) | true |
_private.Init.Data.List.Find.0.List.head_flatten._simp_1_1 | Init.Data.List.Find | ∀ {α : Type u_1} {a : α} {xs : List α} (h : xs ≠ []), (xs.head h = a) = (xs.head? = some a) | false |
Sum.not_inr_le_inl._simp_1 | Mathlib.Data.Sum.Order | ∀ {α : Type u_1} {β : Type u_2} [inst : LE α] [inst_1 : LE β] {a : α} {b : β}, (Sum.inr b ≤ Sum.inl a) = False | false |
CategoryTheory.op_epi_iff | Mathlib.CategoryTheory.EpiMono | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {X Y : C} (f : X ⟶ Y),
CategoryTheory.Epi f.op ↔ CategoryTheory.Mono f | true |
LLVM.DLLStorageClass | Lean.Compiler.IR.LLVMBindings | Type | true |
_private.Batteries.Data.Array.Basic.0.Array.scanrMFast.loop._proof_1 | Batteries.Data.Array.Basic | ∀ {α : Type u_1} (as : Array α) (start : USize), start.toNat ≤ as.size → start - 1 < start → (start - 1).toNat < as.size | false |
List.cyclicPermutations_ne_nil._simp_1 | Mathlib.Data.List.Rotate | ∀ {α : Type u} (l : List α), (l.cyclicPermutations = []) = False | false |
CategoryTheory.MorphismProperty.ext | Mathlib.CategoryTheory.MorphismProperty.Basic | ∀ {C : Type u} [inst : CategoryTheory.CategoryStruct.{v, u} C] (W W' : CategoryTheory.MorphismProperty C),
(∀ ⦃X Y : C⦄ (f : X ⟶ Y), W f ↔ W' f) → W = W' | true |
measurable_from_prod_countable_left' | Mathlib.MeasureTheory.MeasurableSpace.Constructions | ∀ {α : Type u_1} {β : Type u_2} {γ : Type u_3} {m : MeasurableSpace α} {mβ : MeasurableSpace β} {mγ : MeasurableSpace γ}
[Countable β] {f : α × β → γ},
(∀ (y : β), Measurable fun x => f (x, y)) →
(∀ (y y' : β) (x : α), y' ∈ measurableAtom y → f (x, y') = f (x, y)) → Measurable f | true |
CategoryTheory.Limits.SingleObj.Types.sections.equivFixedPoints._proof_2 | Mathlib.CategoryTheory.Limits.Shapes.SingleObj | ∀ {M : Type u_2} [inst : Monoid M] (J : CategoryTheory.Functor (CategoryTheory.SingleObj M) (Type u_1)),
Function.RightInverse (fun p => ⟨fun x => ↑p, ⋯⟩) fun s => ⟨↑s (CategoryTheory.SingleObj.star M), ⋯⟩ | false |
Lean.Parser.withoutInfo | Lean.Parser.Basic | Lean.Parser.Parser → Lean.Parser.Parser | true |
mem_irreducibleComponent | Mathlib.Topology.Irreducible | ∀ {X : Type u_1} [inst : TopologicalSpace X] {x : X}, x ∈ irreducibleComponent x | true |
Besicovitch.SatelliteConfig.inter | Mathlib.MeasureTheory.Covering.Besicovitch | ∀ {α : Type u_1} [inst : MetricSpace α] {N : ℕ} {τ : ℝ} (self : Besicovitch.SatelliteConfig α N τ),
∀ i < Fin.last N, dist (self.c i) (self.c (Fin.last N)) ≤ self.r i + self.r (Fin.last N) | true |
CategoryTheory.ProjectiveResolution.π_f_succ | Mathlib.CategoryTheory.Preadditive.Projective.Resolution | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Limits.HasZeroObject C]
[inst_2 : CategoryTheory.Limits.HasZeroMorphisms C] {Z : C} (P : CategoryTheory.ProjectiveResolution Z) (n : ℕ),
P.π.f (n + 1) = 0 | true |
Algebra.Generators.CotangentSpace.compEquiv._proof_6 | Mathlib.RingTheory.Kaehler.JacobiZariski | ∀ {S : Type u_1} [inst : CommRing S] {T : Type u_3} [inst_1 : CommRing T] [inst_2 : Algebra S T] {ι : Type u_2}
(Q : Algebra.Generators S T ι), SMulCommClass Q.toExtension.Ring T T | false |
Finset.Ico_union_Ico' | Mathlib.Order.Interval.Finset.Basic | ∀ {α : Type u_2} [inst : LinearOrder α] [inst_1 : LocallyFiniteOrder α] {a b c d : α},
c ≤ b → a ≤ d → Finset.Ico a b ∪ Finset.Ico c d = Finset.Ico (min a c) (max b d) | true |
_private.Lean.PrettyPrinter.0.Lean.PrettyPrinter.ppConstNameWithInfos._sparseCasesOn_1 | Lean.PrettyPrinter | {α : Type u} →
{motive : Option α → Sort u_1} →
(t : Option α) → ((val : α) → motive (some val)) → (Nat.hasNotBit 2 t.ctorIdx → motive t) → motive t | false |
PUnit.sub_eq | Mathlib.Algebra.Group.PUnit | ∀ (x y : PUnit.{u_1 + 1}), x - y = PUnit.unit | true |
Subgroup.FiniteIndex | Mathlib.GroupTheory.Index | {G : Type u_1} → [inst : Group G] → Subgroup G → Prop | true |
CategoryTheory.Presieve.instHasPullbacksSingletonOfHasPullback | Mathlib.CategoryTheory.Sites.Sieves | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {X Y Z : C} (f : Y ⟶ X) (g : Z ⟶ X)
[CategoryTheory.Limits.HasPullback g f], (CategoryTheory.Presieve.singleton g).HasPullbacks f | true |
Nat.toArray_rcc_eq_singleton_iff | Init.Data.Range.Polymorphic.NatLemmas | ∀ {k m n : ℕ}, (m...=n).toArray = #[k] ↔ n = m ∧ m = k | true |
FirstOrder.Language.age.fg_substructure | Mathlib.ModelTheory.Fraisse | ∀ {L : FirstOrder.Language} {M : Type w} [inst : L.Structure M] {S : L.Substructure M},
S.FG → { α := ↥S, str := inferInstance } ∈ L.age M | true |
Std.Tactic.BVDecide.BVPred.noConfusionType | Std.Tactic.BVDecide.Bitblast.BVExpr.Basic | Sort u → Std.Tactic.BVDecide.BVPred → Std.Tactic.BVDecide.BVPred → Sort u | false |
Function.Injective.completeBooleanAlgebra._proof_4 | Mathlib.Order.CompleteBooleanAlgebra | ∀ {α : Type u_1} {β : Type u_2} [inst : Max α] [inst_1 : Min α] [inst_2 : LE α] [inst_3 : LT α] [inst_4 : Top α]
[inst_5 : Bot α] [inst_6 : Compl α] [inst_7 : HImp α] [inst_8 : SDiff α] [inst_9 : CompleteBooleanAlgebra β]
(f : α → β) (hf : Function.Injective f) (le : ∀ {x y : α}, f x ≤ f y ↔ x ≤ y) (lt : ∀ {x y : α... | false |
Filter.mem_pi_of_mem | Mathlib.Order.Filter.Pi | ∀ {ι : Type u_1} {α : ι → Type u_2} {f : (i : ι) → Filter (α i)} (i : ι) {s : Set (α i)},
s ∈ f i → Function.eval i ⁻¹' s ∈ Filter.pi f | true |
CategoryTheory.ShortComplex.cyclesFunctor_obj | Mathlib.Algebra.Homology.ShortComplex.LeftHomology | ∀ (C : Type u_1) [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
[inst_2 : CategoryTheory.Limits.HasKernels C] [inst_3 : CategoryTheory.Limits.HasCokernels C]
(S : CategoryTheory.ShortComplex C), (CategoryTheory.ShortComplex.cyclesFunctor C).obj S = S.cycles | true |
String.Slice.pos!_eq_pos | Init.Data.String.Lemmas.Basic | ∀ {s : String.Slice} {p : String.Pos.Raw} (h : String.Pos.Raw.IsValidForSlice s p), s.pos! p = s.pos p h | true |
InverseSystem.pEquivOnLim._proof_2 | Mathlib.Order.DirectedInverseSystem | ∀ {ι : Type u_2} {F : ι → Type u_3} {X : ι → Type u_1} {i : ι} [inst : LinearOrder ι]
{f : ⦃i j : ι⦄ → i ≤ j → F j → F i} [inst_1 : SuccOrder ι]
{equivSucc : ⦃i : ι⦄ → ¬IsMax i → F (Order.succ i) ≃ F i × X i} [inst_2 : WellFoundedLT ι]
(hi : Order.IsSuccPrelimit i) (e : (j : ↑(Set.Iio i)) → InverseSystem.PEquivOn... | false |
_private.Mathlib.AlgebraicGeometry.ProjectiveSpectrum.Scheme.0.AlgebraicGeometry.termSbo_ | Mathlib.AlgebraicGeometry.ProjectiveSpectrum.Scheme | Lean.ParserDescr | true |
EReal.div_zero | Mathlib.Data.EReal.Inv | ∀ {a : EReal}, a / 0 = 0 | true |
Aesop.EMap.mk.sizeOf_spec | Aesop.EMap | ∀ {α : Type u_1} [inst : SizeOf α] (rep : Lean.PArray (Option (Lean.Expr × α))) (idx : Lean.Meta.DiscrTree ℕ),
sizeOf { rep := rep, idx := idx } = 1 + sizeOf rep + sizeOf idx | true |
ProbabilityTheory.indepSets_singleton_iff | Mathlib.Probability.Independence.Basic | ∀ {Ω : Type u_1} {_mΩ : MeasurableSpace Ω} {μ : MeasureTheory.Measure Ω} {s t : Set Ω},
ProbabilityTheory.IndepSets {s} {t} μ ↔ μ (s ∩ t) = μ s * μ t | true |
Set.Pairwise.insert_of_symmetric | Mathlib.Data.Set.Pairwise.Basic | ∀ {α : Type u_1} {r : α → α → Prop} {s : Set α} {a : α},
s.Pairwise r → Symmetric r → (∀ b ∈ s, a ≠ b → r a b) → (insert a s).Pairwise r | true |
_private.Mathlib.NumberTheory.FLT.Three.0.FermatLastTheoremForThreeGen.Solution.lambda_not_dvd_y | Mathlib.NumberTheory.FLT.Three | ∀ {K : Type u_1} [inst : Field K] {ζ : K} {hζ : IsPrimitiveRoot ζ 3} (S : FermatLastTheoremForThreeGen.Solution✝ hζ)
[inst_1 : NumberField K] [IsCyclotomicExtension {3} ℚ K],
¬hζ.toInteger - 1 ∣ FermatLastTheoremForThreeGen.Solution.y✝ S | true |
_private.Mathlib.Tactic.Tauto.0.Mathlib.Tactic.Tauto.distribNotAt.match_1 | Mathlib.Tactic.Tauto | (motive : ℕ → List Lean.Expr → Sort u_1) →
(nIters : ℕ) →
(x : List Lean.Expr) →
((x : List Lean.Expr) → motive 0 x) →
((x : ℕ) → motive x []) →
((n : ℕ) → (fv : Lean.Expr) → (fvs : List Lean.Expr) → motive n.succ (fv :: fvs)) → motive nIters x | false |
Colex.exists._simp_1 | Mathlib.Order.Lex | ∀ {α : Type u_1} {p : Colex α → Prop}, (∃ a, p a) = ∃ a, p (toColex a) | false |
CategoryTheory.Limits.splitMonoOfIdempotentOfIsLimitFork_retraction | Mathlib.CategoryTheory.Limits.Shapes.Equalizers | ∀ (C : Type u) [inst : CategoryTheory.Category.{v, u} C] {X : C} {f : X ⟶ X}
(hf : CategoryTheory.CategoryStruct.comp f f = f)
{c : CategoryTheory.Limits.Fork (CategoryTheory.CategoryStruct.id X) f} (i : CategoryTheory.Limits.IsLimit c),
(CategoryTheory.Limits.splitMonoOfIdempotentOfIsLimitFork C hf i).retraction... | true |
MeasureTheory.AEEqFun.coeFn_add | Mathlib.MeasureTheory.Function.AEEqFun | ∀ {α : Type u_1} {γ : Type u_3} [inst : MeasurableSpace α] {μ : MeasureTheory.Measure α} [inst_1 : TopologicalSpace γ]
[inst_2 : Add γ] [inst_3 : ContinuousAdd γ] (f g : α →ₘ[μ] γ), ↑(f + g) =ᵐ[μ] ↑f + ↑g | true |
AlgebraicGeometry.Scheme.Modules.fromTildeΓNatTrans | Mathlib.AlgebraicGeometry.Modules.Tilde | {R : CommRingCat} →
AlgebraicGeometry.moduleSpecΓFunctor.comp (AlgebraicGeometry.tilde.functor R) ⟶
CategoryTheory.Functor.id (AlgebraicGeometry.Spec (CommRingCat.of ↑R)).Modules | true |
derivWithin_intCast | Mathlib.Analysis.Calculus.Deriv.Basic | ∀ {𝕜 : Type u} [inst : NontriviallyNormedField 𝕜] {F : Type v} [inst_1 : NormedAddCommGroup F]
[inst_2 : NormedSpace 𝕜 F] (s : Set 𝕜) [inst_3 : IntCast F] (z : ℤ), derivWithin (↑z) s = 0 | true |
ProofWidgets.LayoutKind.inline | ProofWidgets.Data.Html | ProofWidgets.LayoutKind | true |
ContinuousLinearMap.flip_smul | Mathlib.Analysis.Normed.Operator.Bilinear | ∀ {𝕜 : Type u_1} {𝕜₂ : Type u_2} {𝕜₃ : Type u_3} {E : Type u_4} {F : Type u_6} {G : Type u_8}
[inst : SeminormedAddCommGroup E] [inst_1 : SeminormedAddCommGroup F] [inst_2 : SeminormedAddCommGroup G]
[inst_3 : NontriviallyNormedField 𝕜] [inst_4 : NontriviallyNormedField 𝕜₂] [inst_5 : NontriviallyNormedField 𝕜... | true |
AddSubgroup.Commensurable.discreteTopology_iff | Mathlib.Topology.Algebra.IsUniformGroup.DiscreteSubgroup | ∀ {G : Type u_2} [inst : AddGroup G] [inst_1 : TopologicalSpace G] [IsTopologicalAddGroup G] [T2Space G]
{H K : AddSubgroup G}, H.Commensurable K → (DiscreteTopology ↥H ↔ DiscreteTopology ↥K) | true |
_private.Mathlib.Logic.Basic.0.exists_and_exists_comm.match_1_3 | Mathlib.Logic.Basic | ∀ {α : Sort u_1} {β : Sort u_2} {P : α → Prop} {Q : β → Prop} (motive : (∃ a b, P a ∧ Q b) → Prop)
(x : ∃ a b, P a ∧ Q b), (∀ (a : α) (b : β) (ha : P a) (hb : Q b), motive ⋯) → motive x | false |
IsPrimitiveRoot.neg_one | Mathlib.RingTheory.RootsOfUnity.PrimitiveRoots | ∀ {R : Type u_4} [inst : CommRing R] (p : ℕ) [Nontrivial R] [h : CharP R p], p ≠ 2 → IsPrimitiveRoot (-1) 2 | true |
AddLocalization.liftOn.eq_1 | Mathlib.GroupTheory.MonoidLocalization.Basic | ∀ {M : Type u_1} [inst : AddCommMonoid M] {S : AddSubmonoid M} {p : Sort u} (x : AddLocalization S) (f : M → ↥S → p)
(H : ∀ {a c : M} {b d : ↥S}, (AddLocalization.r S) (a, b) (c, d) → f a b = f c d),
x.liftOn f H = AddLocalization.rec f ⋯ x | true |
ContinuousLinearMapWOT.ext_dual_iff | Mathlib.Analysis.LocallyConvex.WeakOperatorTopology | ∀ {𝕜₁ : Type u_1} {𝕜₂ : Type u_2} [inst : NormedField 𝕜₁] [inst_1 : NormedField 𝕜₂] {σ : 𝕜₁ →+* 𝕜₂} {E : Type u_3}
{F : Type u_4} [inst_2 : AddCommGroup E] [inst_3 : TopologicalSpace E] [inst_4 : Module 𝕜₁ E]
[inst_5 : AddCommGroup F] [inst_6 : TopologicalSpace F] [inst_7 : Module 𝕜₂ F] [inst_8 : IsTopologi... | true |
_private.Mathlib.RingTheory.TwoSidedIdeal.Operations.0.TwoSidedIdeal.mem_span_iff_mem_addSubgroup_closure_absorbing._simp_1_1 | Mathlib.RingTheory.TwoSidedIdeal.Operations | ∀ {R : Type u_1} [inst : NonUnitalNonAssocRing R] (carrier : Set R) (zero_mem : 0 ∈ carrier)
(add_mem : ∀ {x y : R}, x ∈ carrier → y ∈ carrier → x + y ∈ carrier) (neg_mem : ∀ {x : R}, x ∈ carrier → -x ∈ carrier)
(mul_mem_left : ∀ {x y : R}, y ∈ carrier → x * y ∈ carrier)
(mul_mem_right : ∀ {x y : R}, x ∈ carrier ... | false |
Turing.PartrecToTM2.move₂_ok | Mathlib.Computability.TuringMachine.ToPartrec | ∀ {p : Turing.PartrecToTM2.Γ' → Bool} {k₁ k₂ : Turing.PartrecToTM2.K'} {q : Turing.PartrecToTM2.Λ'}
{s : Option Turing.PartrecToTM2.Γ'} {L₁ : List Turing.PartrecToTM2.Γ'} {o : Option Turing.PartrecToTM2.Γ'}
{L₂ : List Turing.PartrecToTM2.Γ'} {S : Turing.PartrecToTM2.K' → List Turing.PartrecToTM2.Γ'},
k₁ ≠ Turing.... | true |
Lean.Elab.Tactic.RCases.RCasesPatt.noConfusion | Lean.Elab.Tactic.RCases | {P : Sort u} →
{t t' : Lean.Elab.Tactic.RCases.RCasesPatt} → t = t' → Lean.Elab.Tactic.RCases.RCasesPatt.noConfusionType P t t' | false |
Filter.HasBasis.cauchySeq_iff | Mathlib.Topology.UniformSpace.Cauchy | ∀ {α : Type u} {β : Type v} [uniformSpace : UniformSpace α] {γ : Sort u_1} [Nonempty β] [inst : SemilatticeSup β]
{u : β → α} {p : γ → Prop} {s : γ → SetRel α α},
(uniformity α).HasBasis p s →
(CauchySeq u ↔ ∀ (i : γ), p i → ∃ N, ∀ (m : β), N ≤ m → ∀ (n : β), N ≤ n → (u m, u n) ∈ s i) | true |
TypeVec.toSubtype._unsafe_rec | Mathlib.Data.TypeVec | {n : ℕ} →
{α : TypeVec.{u} n} →
(p : α.Arrow (TypeVec.repeat n Prop)) →
TypeVec.Arrow (fun i => { x // TypeVec.ofRepeat (p i x) }) (TypeVec.Subtype_ p) | false |
Lean.Compiler.LCNF.Code.return.noConfusion | Lean.Compiler.LCNF.Basic | {pu : Lean.Compiler.LCNF.Purity} →
{P : Sort u} →
{fvarId fvarId' : Lean.FVarId} →
Lean.Compiler.LCNF.Code.return fvarId = Lean.Compiler.LCNF.Code.return fvarId' → (fvarId = fvarId' → P) → P | false |
_private.Mathlib.SetTheory.ZFC.Rank.0.PSet.rank_insert._simp_1_2 | Mathlib.SetTheory.ZFC.Rank | ∀ {x y z : PSet.{u}}, (x ∈ insert y z) = (x.Equiv y ∨ x ∈ z) | false |
Equiv.Perm.IsThreeCycle | Mathlib.GroupTheory.Perm.Cycle.Type | {α : Type u_1} → [Fintype α] → [DecidableEq α] → Equiv.Perm α → Prop | true |
_private.Lean.Meta.Tactic.Grind.ProofUtil.0.Lean.Meta.Grind.mkLetOfMap.match_3 | Lean.Meta.Tactic.Grind.ProofUtil | (motive : MProd Lean.Expr ℕ → Sort u_1) →
(r : MProd Lean.Expr ℕ) → ((e : Lean.Expr) → (i : ℕ) → motive ⟨e, i⟩) → motive r | false |
WittVector.idIsPolyI' | Mathlib.RingTheory.WittVector.IsPoly | ∀ (p : ℕ), WittVector.IsPoly p fun x x_1 a => a | true |
Nat.Partrec.Code.pappAck.match_1 | Mathlib.Computability.Ackermann | (motive : ℕ → Sort u_1) → (x : ℕ) → (Unit → motive 0) → ((n : ℕ) → motive n.succ) → motive x | false |
PosPart.noConfusionType | Mathlib.Algebra.Notation | Sort u → {α : Type u_1} → PosPart α → {α' : Type u_1} → PosPart α' → Sort u | false |
Lean.Meta.Grind.NormalizePattern.State.recOn | Lean.Meta.Tactic.Grind.EMatchTheorem | {motive : Lean.Meta.Grind.NormalizePattern.State → Sort u} →
(t : Lean.Meta.Grind.NormalizePattern.State) →
((symbols : Array Lean.HeadIndex) →
(symbolSet : Std.HashSet Lean.HeadIndex) →
(bvarsFound : Std.HashSet ℕ) →
motive { symbols := symbols, symbolSet := symbolSet, bvarsFound :=... | false |
Std.ExtDHashMap.Const.get_modify_self | Std.Data.ExtDHashMap.Lemmas | ∀ {α : Type u} {x : BEq α} {x_1 : Hashable α} {β : Type v} {m : Std.ExtDHashMap α fun x => β} [inst : EquivBEq α]
[inst_1 : LawfulHashable α] {k : α} {f : β → β} {h : k ∈ Std.ExtDHashMap.Const.modify m k f},
Std.ExtDHashMap.Const.get (Std.ExtDHashMap.Const.modify m k f) k h = f (Std.ExtDHashMap.Const.get m k ⋯) | true |
Module.Relations.Solution.IsPresentation.desc.congr_simp | Mathlib.Algebra.Module.Presentation.Basic | ∀ {A : Type u} [inst : Ring A] {relations : Module.Relations A} {M : Type v} [inst_1 : AddCommGroup M]
[inst_2 : Module A M] {solution solution_1 : relations.Solution M} (e_solution : solution = solution_1)
(h : solution.IsPresentation) {N : Type v'} [inst_3 : AddCommGroup N] [inst_4 : Module A N]
(s s_1 : relati... | true |
Std.DTreeMap.Internal.Impl.Const.maxKeyD_alter!_eq_self | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {instOrd : Ord α} {β : Type v} {t : Std.DTreeMap.Internal.Impl α fun x => β} [Std.TransOrd α],
t.WF →
∀ {k : α} {f : Option β → Option β},
(Std.DTreeMap.Internal.Impl.Const.alter! k f t).isEmpty = false →
∀ {fallback : α},
(Std.DTreeMap.Internal.Impl.Const.alter! k f t).maxK... | true |
_private.Mathlib.NumberTheory.NumberField.Cyclotomic.Ideal.0.IsCyclotomicExtension.Rat.«term𝒑» | Mathlib.NumberTheory.NumberField.Cyclotomic.Ideal | Lean.ParserDescr | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.