tasksource/leandojo huggingface dataset:
Theorem: ProbabilityTheory.indep_bot_right
File: Mathlib/Probability/Independence/Basic.lean

tactic: intro s t _hs ht
state_before: Ω : Type u_1
ι : Type ?u.540154
m' m : MeasurableSpace Ω
μ : MeasureTheory.Measure Ω
inst✝ : IsProbabilityMeasure μ
⊢ Indep m' ⊥

tactic: rw [Set.mem_setOf_eq, MeasurableSpace.measurableSet_bot_iff] at ht
state_before: Ω : Type u_1
ι : Type ?u.540154
m' m : MeasurableSpace Ω
μ : MeasureTheory.Measure Ω
inst✝ : IsProbabilityMeasure μ
s t : Set Ω
_hs : s ∈ {s | MeasurableSet s}
ht : t ∈ {s | MeasurableSet s}
⊢ ↑↑μ (s ∩ t) = ↑↑μ s * ↑↑μ t

tactic: cases' ht with ht ht
state_before: Ω : Type u_1
ι : Type ?u.540154
m' m : MeasurableSpace Ω
μ : MeasureTheory.Measure Ω
inst✝ : IsProbabilityMeasure μ
s t : Set Ω
_hs : s ∈ {s | MeasurableSet s}
ht : t = ∅ ∨ t = Set.univ
⊢ ↑↑μ (s ∩ t) = ↑↑μ s * ↑↑μ t

tactic: rw [ht, Set.inter_empty, measure_empty, MulZeroClass.mul_zero]
state_before: case inl
Ω : Type u_1
ι : Type ?u.540154
m' m : MeasurableSpace Ω
μ : MeasureTheory.Measure Ω
inst✝ : IsProbabilityMeasure μ
s t : Set Ω
_hs : s ∈ {s | MeasurableSet s}
ht : t = ∅
⊢ ↑↑μ (s ∩ t) = ↑↑μ s * ↑↑μ t

tactic: rw [ht, Set.inter_univ, measure_univ, mul_one]
state_before: case inr
Ω : Type u_1
ι : Type ?u.540154
m' m : MeasurableSpace Ω
μ : MeasureTheory.Measure Ω
inst✝ : IsProbabilityMeasure μ
s t : Set Ω
_hs : s ∈ {s | MeasurableSet s}
ht : t = Set.univ
⊢ ↑↑μ (s ∩ t) = ↑↑μ s * ↑↑μ t
Theorem: FirstOrder.Language.BoundedFormula.realize_rel₂
File: Mathlib/ModelTheory/Semantics.lean

tactic: rw [Relations.boundedFormula₂, realize_rel, iff_eq_eq]
state_before: L : Language
L' : Language
M : Type w
N : Type ?u.55232
P : Type ?u.55235
inst✝² : Structure L M
inst✝¹ : Structure L N
inst✝ : Structure L P
α : Type u'
β : Type v'
n l : ℕ
φ ψ : BoundedFormula L α l
θ : BoundedFormula L α (Nat.succ l)
v : α → M
xs : Fin l → M
R : Relations L 2
t₁ t₂ : Term L (α ⊕ Fin l)
⊢ Realize (Relations.boundedFormula₂ R t₁ t₂) v xs ↔ RelMap R ![realize (Sum.elim v xs) t₁, realize (Sum.elim v xs) t₂]

tactic: refine' congr rfl (funext (Fin.cases _ _))
state_before: L : Language
L' : Language
M : Type w
N : Type ?u.55232
P : Type ?u.55235
inst✝² : Structure L M
inst✝¹ : Structure L N
inst✝ : Structure L P
α : Type u'
β : Type v'
n l : ℕ
φ ψ : BoundedFormula L α l
θ : BoundedFormula L α (Nat.succ l)
v : α → M
xs : Fin l → M
R : Relations L 2
t₁ t₂ : Term L (α ⊕ Fin l)
⊢ (RelMap R fun i => realize (Sum.elim v xs) (Matrix.vecCons t₁ ![t₂] i)) =
    RelMap R ![realize (Sum.elim v xs) t₁, realize (Sum.elim v xs) t₂]

tactic: simp only [Matrix.cons_val_zero]
state_before: case refine'_1
L : Language
L' : Language
M : Type w
N : Type ?u.55232
P : Type ?u.55235
inst✝² : Structure L M
inst✝¹ : Structure L N
inst✝ : Structure L P
α : Type u'
β : Type v'
n l : ℕ
φ ψ : BoundedFormula L α l
θ : BoundedFormula L α (Nat.succ l)
v : α → M
xs : Fin l → M
R : Relations L 2
t₁ t₂ : Term L (α ⊕ Fin l)
⊢ realize (Sum.elim v xs) (Matrix.vecCons t₁ ![t₂] 0) =
    Matrix.vecCons (realize (Sum.elim v xs) t₁) ![realize (Sum.elim v xs) t₂] 0

tactic: simp only [Matrix.cons_val_succ, Matrix.cons_val_fin_one, forall_const]
state_before: case refine'_2
L : Language
L' : Language
M : Type w
N : Type ?u.55232
P : Type ?u.55235
inst✝² : Structure L M
inst✝¹ : Structure L N
inst✝ : Structure L P
α : Type u'
β : Type v'
n l : ℕ
φ ψ : BoundedFormula L α l
θ : BoundedFormula L α (Nat.succ l)
v : α → M
xs : Fin l → M
R : Relations L 2
t₁ t₂ : Term L (α ⊕ Fin l)
⊢ ∀ (i : Fin 1),
    realize (Sum.elim v xs) (Matrix.vecCons t₁ ![t₂] (succ i)) =
      Matrix.vecCons (realize (Sum.elim v xs) t₁) ![realize (Sum.elim v xs) t₂] (succ i)
Theorem: CircleDeg1Lift.translationNumber_translate
File: Mathlib/Dynamics/Circle/RotationNumber/TranslationNumber.lean

tactic: simp only [translate_iterate, translate_apply, add_zero, Nat.cast_succ,
  mul_div_cancel_left (G₀ := ℝ) _ (Nat.cast_add_one_ne_zero _), tendsto_const_nhds]
state_before: f g : CircleDeg1Lift
x : ℝ
⊢ Tendsto (fun n => (↑↑(↑translate (↑Multiplicative.ofAdd x))^[n + 1]) 0 / (↑n + 1)) atTop (𝓝 x)
Theorem: Equiv.trans_toLocalEquiv
File: Mathlib/Logic/Equiv/LocalEquiv.lean

tactic: simp [LocalEquiv.trans_source, Equiv.toLocalEquiv]
state_before: α : Type u_1
β : Type u_3
γ : Type u_2
δ : Type ?u.76640
e : α ≃ β
e' : β ≃ γ
⊢ (toLocalEquiv (e.trans e')).source = (LocalEquiv.trans (toLocalEquiv e) (toLocalEquiv e')).source
Theorem: fderivWithin_id
File: Mathlib/Analysis/Calculus/FDeriv/Basic.lean

tactic: rw [DifferentiableAt.fderivWithin differentiableAt_id hxs]
state_before: 𝕜 : Type u_1
inst✝⁸ : NontriviallyNormedField 𝕜
E : Type u_2
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type ?u.1262982
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type ?u.1263077
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
G' : Type ?u.1263172
inst✝¹ : NormedAddCommGroup G'
inst✝ : NormedSpace 𝕜 G'
f f₀ f₁ g : E → F
f' f₀' f₁' g' e : E →L[𝕜] F
x : E
s t : Set E
L L₁ L₂ : Filter E
hxs : UniqueDiffWithinAt 𝕜 s x
⊢ fderivWithin 𝕜 _root_.id s x = ContinuousLinearMap.id 𝕜 E

tactic: exact fderiv_id
state_before: 𝕜 : Type u_1
inst✝⁸ : NontriviallyNormedField 𝕜
E : Type u_2
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type ?u.1262982
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type ?u.1263077
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
G' : Type ?u.1263172
inst✝¹ : NormedAddCommGroup G'
inst✝ : NormedSpace 𝕜 G'
f f₀ f₁ g : E → F
f' f₀' f₁' g' e : E →L[𝕜] F
x : E
s t : Set E
L L₁ L₂ : Filter E
hxs : UniqueDiffWithinAt 𝕜 s x
⊢ fderiv 𝕜 _root_.id x = ContinuousLinearMap.id 𝕜 E
Theorem: CategoryTheory.CosimplicialObject.δ_comp_δ''
File: Mathlib/AlgebraicTopology/SimplicialObject.lean

tactic: dsimp [δ]
state_before: C : Type u
inst✝ : Category C
X : CosimplicialObject C
n : ℕ
i : Fin (n + 3)
j : Fin (n + 2)
H : i ≤ ↑Fin.castSucc j
⊢ δ X (Fin.castLT i (_ : ↑i < n + 2)) ≫ δ X (Fin.succ j) = δ X j ≫ δ X i

tactic: simp only [← X.map_comp, ← op_comp, SimplexCategory.δ_comp_δ'' H]
state_before: C : Type u
inst✝ : Category C
X : CosimplicialObject C
n : ℕ
i : Fin (n + 3)
j : Fin (n + 2)
H : i ≤ ↑Fin.castSucc j
⊢ X.map (SimplexCategory.δ (Fin.castLT i (_ : ↑i < n + 2))) ≫ X.map (SimplexCategory.δ (Fin.succ j)) =
    X.map (SimplexCategory.δ j) ≫ X.map (SimplexCategory.δ i)
Theorem: RatFunc.induction_on
File: Mathlib/FieldTheory/RatFunc.lean

tactic: simpa using f p q hq
state_before: K : Type u
inst✝¹ : CommRing K
inst✝ : IsDomain K
P : RatFunc K → Prop
x : RatFunc K
f : ∀ (p q : K[X]), q ≠ 0 → P (↑(algebraMap K[X] (RatFunc K)) p / ↑(algebraMap K[X] (RatFunc K)) q)
p q : K[X]
hq : q ≠ 0
⊢ P (RatFunc.mk p q)
Theorem: Basis.mk_coord_apply
File: Mathlib/LinearAlgebra/Basis.lean

tactic: cases' eq_or_ne j i with h h
state_before: ι : Type u_1
ι' : Type ?u.851959
R : Type u_2
R₂ : Type ?u.851965
K : Type ?u.851968
M : Type u_3
M' : Type ?u.851974
M'' : Type ?u.851977
V : Type u
V' : Type ?u.851982
v : ι → M
inst✝⁹ : Ring R
inst✝⁸ : CommRing R₂
inst✝⁷ : AddCommGroup M
inst✝⁶ : AddCommGroup M'
inst✝⁵ : AddCommGroup M''
inst✝⁴ : Module R M
inst✝³ : Module R₂ M
inst✝² : Module R M'
inst✝¹ : Module R M''
c d : R
x y : M
b : Basis ι R M
hli : LinearIndependent R v
hsp : ⊤ ≤ span R (Set.range v)
inst✝ : DecidableEq ι
i j : ι
⊢ ↑(coord (Basis.mk hli hsp) i) (v j) = if j = i then 1 else 0

tactic: simp only [h, if_true, eq_self_iff_true, mk_coord_apply_eq i]
state_before: case inl
ι : Type u_1
ι' : Type ?u.851959
R : Type u_2
R₂ : Type ?u.851965
K : Type ?u.851968
M : Type u_3
M' : Type ?u.851974
M'' : Type ?u.851977
V : Type u
V' : Type ?u.851982
v : ι → M
inst✝⁹ : Ring R
inst✝⁸ : CommRing R₂
inst✝⁷ : AddCommGroup M
inst✝⁶ : AddCommGroup M'
inst✝⁵ : AddCommGroup M''
inst✝⁴ : Module R M
inst✝³ : Module R₂ M
inst✝² : Module R M'
inst✝¹ : Module R M''
c d : R
x y : M
b : Basis ι R M
hli : LinearIndependent R v
hsp : ⊤ ≤ span R (Set.range v)
inst✝ : DecidableEq ι
i j : ι
h : j = i
⊢ ↑(coord (Basis.mk hli hsp) i) (v j) = if j = i then 1 else 0

tactic: simp only [h, if_false, mk_coord_apply_ne h]
state_before: case inr
ι : Type u_1
ι' : Type ?u.851959
R : Type u_2
R₂ : Type ?u.851965
K : Type ?u.851968
M : Type u_3
M' : Type ?u.851974
M'' : Type ?u.851977
V : Type u
V' : Type ?u.851982
v : ι → M
inst✝⁹ : Ring R
inst✝⁸ : CommRing R₂
inst✝⁷ : AddCommGroup M
inst✝⁶ : AddCommGroup M'
inst✝⁵ : AddCommGroup M''
inst✝⁴ : Module R M
inst✝³ : Module R₂ M
inst✝² : Module R M'
inst✝¹ : Module R M''
c d : R
x y : M
b : Basis ι R M
hli : LinearIndependent R v
hsp : ⊤ ≤ span R (Set.range v)
inst✝ : DecidableEq ι
i j : ι
h : j ≠ i
⊢ ↑(coord (Basis.mk hli hsp) i) (v j) = if j = i then 1 else 0
Theorem: CategoryTheory.Abelian.Pseudoelement.pseudo_surjective_of_epi
File: Mathlib/CategoryTheory/Abelian/Pseudoelements.lean

tactic: rw [Category.id_comp, ← pullback.condition, app_hom, Over.coe_hom]
state_before: C : Type u
inst✝² : Category C
inst✝¹ : Abelian C
P Q : C
f : P ⟶ Q
inst✝ : Epi f
qbar : Pseudoelement Q
q : Over Q
⊢ 𝟙 (pullback f q.hom) ≫ ((fun g => app f g) (Over.mk pullback.fst)).hom = pullback.snd ≫ q.hom
Theorem: SimplexCategory.len_le_of_mono
File: Mathlib/AlgebraicTopology/SimplexCategory.lean

tactic: intro hyp_f_mono
state_before: x y : SimplexCategory
f : x ⟶ y
⊢ Mono f → len x ≤ len y

tactic: have f_inj : Function.Injective f.toOrderHom.toFun := mono_iff_injective.1 hyp_f_mono
state_before: x y : SimplexCategory
f : x ⟶ y
hyp_f_mono : Mono f
⊢ len x ≤ len y

tactic: simpa using Fintype.card_le_of_injective f.toOrderHom.toFun f_inj
state_before: x y : SimplexCategory
f : x ⟶ y
hyp_f_mono : Mono f
f_inj : Function.Injective ↑(Hom.toOrderHom f)
⊢ len x ≤ len y
Theorem: map_nat_cast_smul
File: Mathlib/Algebra/Module/Basic.lean

tactic: simp only [← nsmul_eq_smul_cast, AddMonoidHom.map_nsmul, map_nsmul]
state_before: α : Type ?u.172942
R✝ : Type ?u.172945
k : Type ?u.172948
S✝ : Type ?u.172951
M : Type u_1
M₂ : Type u_2
M₃ : Type ?u.172960
ι : Type ?u.172963
inst✝⁶ : AddCommMonoid M
inst✝⁵ : AddCommMonoid M₂
F : Type u_3
inst✝⁴ : AddMonoidHomClass F M M₂
f : F
R : Type u_4
S : Type u_5
inst✝³ : Semiring R
inst✝² : Semiring S
inst✝¹ : Module R M
inst✝ : Module S M₂
x : ℕ
a : M
⊢ ↑f (↑x • a) = ↑x • ↑f a
Theorem: Finset.dvd_sum
File: Mathlib/Algebra/BigOperators/Ring.lean

tactic: rcases Multiset.mem_map.1 hy with ⟨x, hx, rfl⟩
state_before: α : Type u
β : Type v
γ : Type w
s✝ s₁ s₂ : Finset α
a : α
b✝ : β
f✝ g : α → β
inst✝ : CommSemiring β
b : β
s : Finset α
f : α → β
h : ∀ (x : α), x ∈ s → b ∣ f x
y : β
hy : y ∈ Multiset.map (fun x => f x) s.val
⊢ b ∣ y

tactic: exact h x hx
state_before: case intro.intro
α : Type u
β : Type v
γ : Type w
s✝ s₁ s₂ : Finset α
a : α
b✝ : β
f✝ g : α → β
inst✝ : CommSemiring β
b : β
s : Finset α
f : α → β
h : ∀ (x : α), x ∈ s → b ∣ f x
x : α
hx : x ∈ s.val
hy : f x ∈ Multiset.map (fun x => f x) s.val
⊢ b ∣ f x
Theorem: div_left_injective
File: Mathlib/Algebra/Group/Basic.lean

tactic: simp only [div_eq_mul_inv]
state_before: α : Type ?u.56027
β : Type ?u.56030
G : Type u_1
inst✝ : Group G
a b c d : G
⊢ Injective fun a => a / b

tactic: exact fun a a' h ↦ mul_left_injective b⁻¹ h
state_before: α : Type ?u.56027
β : Type ?u.56030
G : Type u_1
inst✝ : Group G
a b c d : G
⊢ Injective fun a => a * b⁻¹
Theorem: CategoryTheory.Limits.limitFlipCompLimIsoLimitCompLim_inv_π_π
File: Mathlib/CategoryTheory/Limits/Fubini.lean

tactic: dsimp [limitFlipCompLimIsoLimitCompLim]
state_before: J K : Type v
inst✝⁶ : SmallCategory J
inst✝⁵ : SmallCategory K
C : Type u
inst✝⁴ : Category C
F : J ⥤ K ⥤ C
inst✝³ : HasLimitsOfShape J C
inst✝² : HasLimitsOfShape K C
inst✝¹ : HasLimitsOfShape (J × K) C
inst✝ : HasLimitsOfShape (K × J) C
k : K
j : J
⊢ (limitFlipCompLimIsoLimitCompLim F).inv ≫ limit.π (Functor.flip F ⋙ lim) k ≫ limit.π ((Functor.flip F).obj k) j =
    limit.π (F ⋙ lim) j ≫ limit.π (F.obj j) k

tactic: simp
state_before: J K : Type v
inst✝⁶ : SmallCategory J
inst✝⁵ : SmallCategory K
C : Type u
inst✝⁴ : Category C
F : J ⥤ K ⥤ C
inst✝³ : HasLimitsOfShape J C
inst✝² : HasLimitsOfShape K C
inst✝¹ : HasLimitsOfShape (J × K) C
inst✝ : HasLimitsOfShape (K × J) C
k : K
j : J
⊢ ((((limitUncurryIsoLimitCompLim F).inv ≫
            (HasLimit.isoOfEquivalence (Prod.braiding K J)
                (NatIso.ofComponents fun x => Iso.refl ((F.obj x.snd).obj x.fst))).inv) ≫
          (HasLimit.isoOfNatIso (uncurryObjFlip F)).inv) ≫
        (limitUncurryIsoLimitCompLim (Functor.flip F)).hom) ≫
      limit.π (Functor.flip F ⋙ lim) k ≫ limit.π ((Functor.flip F).obj k) j =
    limit.π (F ⋙ lim) j ≫ limit.π (F.obj j) k
Theorem: imageToKernel_zero_left
File: Mathlib/Algebra/Homology/ImageToKernel.lean

tactic: ext
state_before: ι : Type ?u.8478
V : Type u
inst✝³ : Category V
inst✝² : HasZeroMorphisms V
A B C : V
f : A ⟶ B
g : B ⟶ C
inst✝¹ : HasKernels V
inst✝ : HasZeroObject V
w : 0 ≫ g = 0
⊢ imageToKernel 0 g w = 0

tactic: simp
state_before: case h
ι : Type ?u.8478
V : Type u
inst✝³ : Category V
inst✝² : HasZeroMorphisms V
A B C : V
f : A ⟶ B
g : B ⟶ C
inst✝¹ : HasKernels V
inst✝ : HasZeroObject V
w : 0 ≫ g = 0
⊢ imageToKernel 0 g w ≫ Subobject.arrow (kernelSubobject g) = 0 ≫ Subobject.arrow (kernelSubobject g)
Theorem: collinear_insert_iff_of_mem_affineSpan
File: Mathlib/LinearAlgebra/AffineSpace/FiniteDimensional.lean

tactic: rw [Collinear, Collinear, vectorSpan_insert_eq_vectorSpan h]
state_before: k : Type u_2
V : Type u_3
P : Type u_1
ι : Type ?u.320461
inst✝³ : DivisionRing k
inst✝² : AddCommGroup V
inst✝¹ : Module k V
inst✝ : AffineSpace V P
s : Set P
p : P
h : p ∈ affineSpan k s
⊢ Collinear k (insert p s) ↔ Collinear k s
Theorem: List.Nodup.rotate_congr
File: Mathlib/Data/List/Rotate.lean

tactic: have hi : i % l.length < l.length := mod_lt _ (length_pos_of_ne_nil hn)
state_before: α : Type u
l : List α
hl : Nodup l
hn : l ≠ []
i j : ℕ
h : rotate l i = rotate l j
⊢ i % length l = j % length l

tactic: have hj : j % l.length < l.length := mod_lt _ (length_pos_of_ne_nil hn)
state_before: α : Type u
l : List α
hl : Nodup l
hn : l ≠ []
i j : ℕ
h : rotate l i = rotate l j
hi : i % length l < length l
⊢ i % length l = j % length l

tactic: refine' (nodup_iff_nthLe_inj.mp hl) _ _ hi hj _
state_before: α : Type u
l : List α
hl : Nodup l
hn : l ≠ []
i j : ℕ
h : rotate l i = rotate l j
hi : i % length l < length l
hj : j % length l < length l
⊢ i % length l = j % length l

tactic: rw [← nthLe_rotate' l i, ← nthLe_rotate' l j]
state_before: α : Type u
l : List α
hl : Nodup l
hn : l ≠ []
i j : ℕ
h : rotate l i = rotate l j
hi : i % length l < length l
hj : j % length l < length l
⊢ nthLe l (i % length l) hi = nthLe l (j % length l) hj

tactic: simp [tsub_add_cancel_of_le, hi.le, hj.le, h]
state_before: α : Type u
l : List α
hl : Nodup l
hn : l ≠ []
i j : ℕ
h : rotate l i = rotate l j
hi : i % length l < length l
hj : j % length l < length l
⊢ nthLe (rotate l i) ((length l - i % length l + i % length l) % length l)
      (_ : (length l - i % length l + i % length l) % length l < length (rotate l i)) =
    nthLe (rotate l j) ((length l - j % length l + j % length l) % length l)
      (_ : (length l - j % length l + j % length l) % length l < length (rotate l j))
Theorem: SimpleGraph.iInf_adj
File: Mathlib/Combinatorics/SimpleGraph/Basic.lean

tactic: simp [iInf]
state_before: ι : Sort u_1
𝕜 : Type ?u.21433
V : Type u
W : Type v
X : Type w
G : SimpleGraph V
G' : SimpleGraph W
a b c u v w : V
e : Sym2 V
f : ι → SimpleGraph V
⊢ Adj (⨅ (i : ι), f i) a b ↔ (∀ (i : ι), Adj (f i) a b) ∧ a ≠ b
Theorem: Ordinal.mem_closure_iff_bsup
File: Mathlib/SetTheory/Ordinal/Topology.lean

tactic: simp only [exists_prop]
state_before: s : Set Ordinal
a : Ordinal
⊢ (∃ o, o ≠ 0 ∧ ∃ f, (∀ (x : Ordinal) (hx : x < o), f x hx ∈ s) ∧ bsup o f = a) ↔
    ∃ o _ho f, (∀ (i : Ordinal) (hi : i < o), f i hi ∈ s) ∧ bsup o f = a
Theorem: sup_sup_distrib_left
File: Mathlib/Order/Lattice.lean

tactic: rw [sup_sup_sup_comm, sup_idem]
state_before: α : Type u
β : Type v
inst✝ : SemilatticeSup α
a✝ b✝ c✝ d a b c : α
⊢ a ⊔ (b ⊔ c) = a ⊔ b ⊔ (a ⊔ c)
Theorem: List.Nodup.length_le_card
File: Mathlib/Data/Fintype/Card.lean

tactic: classical exact List.toFinset_card_of_nodup h ▸ l.toFinset.card_le_univ
state_before: α✝ : Type ?u.13820
β : Type ?u.13823
γ : Type ?u.13826
α : Type u_1
inst✝ : Fintype α
l : List α
h : Nodup l
⊢ length l ≤ Fintype.card α

tactic: exact List.toFinset_card_of_nodup h ▸ l.toFinset.card_le_univ
state_before: α✝ : Type ?u.13820
β : Type ?u.13823
γ : Type ?u.13826
α : Type u_1
inst✝ : Fintype α
l : List α
h : Nodup l
⊢ length l ≤ Fintype.card α
Theorem: convexJoin_left_comm
File: Mathlib/Analysis/Convex/Join.lean

tactic: simp_rw [← convexJoin_assoc, convexJoin_comm]
state_before: ι : Sort ?u.68928
𝕜 : Type u_2
E : Type u_1
inst✝² : LinearOrderedField 𝕜
inst✝¹ : AddCommGroup E
inst✝ : Module 𝕜 E
s✝ t✝ u✝ : Set E
x y : E
s t u : Set E
⊢ convexJoin 𝕜 s (convexJoin 𝕜 t u) = convexJoin 𝕜 t (convexJoin 𝕜 s u)
Theorem: LeftOrdContinuous.comp
File: Mathlib/Order/OrdContinuous.lean

tactic: simpa only [image_image] using hg (hf h)
state_before: α : Type u
β : Type v
γ : Type w
ι : Sort x
inst✝² : Preorder α
inst✝¹ : Preorder β
inst✝ : Preorder γ
g : β → γ
f : α → β
hg : LeftOrdContinuous g
hf : LeftOrdContinuous f
s : Set α
x : α
h : IsLUB s x
⊢ IsLUB (g ∘ f '' s) ((g ∘ f) x)
Theorem: Lagrange.eval_interpolate_at_node
File: Mathlib/LinearAlgebra/Lagrange.lean

tactic: rw [interpolate_apply, eval_finset_sum, ← add_sum_erase _ _ hi]
state_before: F : Type u_2
inst✝¹ : Field F
ι : Type u_1
inst✝ : DecidableEq ι
s t : Finset ι
i j : ι
v r r' : ι → F
hvs : Set.InjOn v ↑s
hi : i ∈ s
⊢ eval (v i) (↑(interpolate s v) r) = r i

tactic: simp_rw [eval_mul, eval_C, eval_basis_self hvs hi, mul_one, add_right_eq_self]
state_before: F : Type u_2
inst✝¹ : Field F
ι : Type u_1
inst✝ : DecidableEq ι
s t : Finset ι
i j : ι
v r r' : ι → F
hvs : Set.InjOn v ↑s
hi : i ∈ s
⊢ eval (v i) (↑C (r i) * Lagrange.basis s v i) + ∑ x in Finset.erase s i, eval (v i) (↑C (r x) * Lagrange.basis s v x) =
    r i

tactic: refine' sum_eq_zero fun j H => _
state_before: F : Type u_2
inst✝¹ : Field F
ι : Type u_1
inst✝ : DecidableEq ι
s t : Finset ι
i j : ι
v r r' : ι → F
hvs : Set.InjOn v ↑s
hi : i ∈ s
⊢ ∑ x in Finset.erase s i, r x * eval (v i) (Lagrange.basis s v x) = 0

tactic: rw [eval_basis_of_ne (mem_erase.mp H).1 hi, MulZeroClass.mul_zero]
state_before: F : Type u_2
inst✝¹ : Field F
ι : Type u_1
inst✝ : DecidableEq ι
s t : Finset ι
i j✝ : ι
v r r' : ι → F
hvs : Set.InjOn v ↑s
hi : i ∈ s
j : ι
H : j ∈ Finset.erase s i
⊢ r j * eval (v i) (Lagrange.basis s v j) = 0
Theorem: MeasureTheory.setToFun_smul_left
File: Mathlib/MeasureTheory/Integral/SetToL1.lean

tactic: by_cases hf : Integrable f μ
state_before: α : Type u_1
E : Type u_2
F : Type u_3
F' : Type ?u.1360856
G : Type ?u.1360859
𝕜 : Type ?u.1360862
p : ℝ≥0∞
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace ℝ E
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace ℝ F
inst✝³ : NormedAddCommGroup F'
inst✝² : NormedSpace ℝ F'
inst✝¹ : NormedAddCommGroup G
m : MeasurableSpace α
μ : Measure α
inst✝ : CompleteSpace F
T T' T'' : Set α → E →L[ℝ] F
C C' C'' : ℝ
f✝ g : α → E
hT : DominatedFinMeasAdditive μ T C
c : ℝ
f : α → E
⊢ setToFun μ (fun s => c • T s) (_ : DominatedFinMeasAdditive μ (fun s => c • T s) (‖c‖ * C)) f = c • setToFun μ T hT f

tactic: simp_rw [setToFun_eq _ hf, L1.setToL1_smul_left hT c]
state_before: case pos
α : Type u_1
E : Type u_2
F : Type u_3
F' : Type ?u.1360856
G : Type ?u.1360859
𝕜 : Type ?u.1360862
p : ℝ≥0∞
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace ℝ E
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace ℝ F
inst✝³ : NormedAddCommGroup F'
inst✝² : NormedSpace ℝ F'
inst✝¹ : NormedAddCommGroup G
m : MeasurableSpace α
μ : Measure α
inst✝ : CompleteSpace F
T T' T'' : Set α → E →L[ℝ] F
C C' C'' : ℝ
f✝ g : α → E
hT : DominatedFinMeasAdditive μ T C
c : ℝ
f : α → E
hf : Integrable f
⊢ setToFun μ (fun s => c • T s) (_ : DominatedFinMeasAdditive μ (fun s => c • T s) (‖c‖ * C)) f = c • setToFun μ T hT f

tactic: simp_rw [setToFun_undef _ hf, smul_zero]
state_before: case neg
α : Type u_1
E : Type u_2
F : Type u_3
F' : Type ?u.1360856
G : Type ?u.1360859
𝕜 : Type ?u.1360862
p : ℝ≥0∞
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace ℝ E
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace ℝ F
inst✝³ : NormedAddCommGroup F'
inst✝² : NormedSpace ℝ F'
inst✝¹ : NormedAddCommGroup G
m : MeasurableSpace α
μ : Measure α
inst✝ : CompleteSpace F
T T' T'' : Set α → E →L[ℝ] F
C C' C'' : ℝ
f✝ g : α → E
hT : DominatedFinMeasAdditive μ T C
c : ℝ
f : α → E
hf : ¬Integrable f
⊢ setToFun μ (fun s => c • T s) (_ : DominatedFinMeasAdditive μ (fun s => c • T s) (‖c‖ * C)) f = c • setToFun μ T hT f
Theorem: Ordinal.sup_typein_limit
File: Mathlib/SetTheory/Ordinal/Arithmetic.lean

tactic: assumption
state_before: α : Type ?u.343526
β : Type ?u.343529
γ : Type ?u.343532
r : α → α → Prop
s : β → β → Prop
t : γ → γ → Prop
o : Ordinal
ho : ∀ (a : Ordinal), a < o → succ a < o
⊢ ∀ (a : Ordinal), a < o → succ a < o
Theorem: hasSum_iff_tendsto_nat_of_nonneg
File: Mathlib/Topology/Instances/ENNReal.lean

tactic: lift f to ℕ → ℝ≥0 using hf
state_before: α : Type ?u.341642
β : Type ?u.341645
γ : Type ?u.341648
f : ℕ → ℝ
hf : ∀ (i : ℕ), 0 ≤ f i
r : ℝ
⊢ HasSum f r ↔ Tendsto (fun n => ∑ i in Finset.range n, f i) atTop (𝓝 r)

tactic: simp only [HasSum, ← NNReal.coe_sum, NNReal.tendsto_coe']
state_before: case intro
α : Type ?u.341642
β : Type ?u.341645
γ : Type ?u.341648
r : ℝ
f : ℕ → ℝ≥0
⊢ HasSum (fun i => ↑(f i)) r ↔ Tendsto (fun n => ∑ i in Finset.range n, (fun i => ↑(f i)) i) atTop (𝓝 r)

tactic: exact exists_congr fun hr => NNReal.hasSum_iff_tendsto_nat
state_before: case intro
α : Type ?u.341642
β : Type ?u.341645
γ : Type ?u.341648
r : ℝ
f : ℕ → ℝ≥0
⊢ (∃ hx, Tendsto (fun a => ∑ a in a, f a) atTop (𝓝 { val := r, property := hx })) ↔
    ∃ hx, Tendsto (fun a => ∑ a in Finset.range a, f a) atTop (𝓝 { val := r, property := hx })
Theorem: Polynomial.support_C_mul_X_pow
File: Mathlib/Data/Polynomial/Basic.lean

tactic: rw [C_mul_X_pow_eq_monomial, support_monomial n h]
state_before: R : Type u
a b : R
m n✝ : ℕ
inst✝ : Semiring R
p q : R[X]
n : ℕ
c : R
h : c ≠ 0
⊢ support (↑C c * X ^ n) = {n}
Theorem: Module.projective_def'
File: Mathlib/Algebra/Module/Projective.lean

tactic: simp_rw [projective_def, FunLike.ext_iff, Function.LeftInverse, comp_apply, id_apply]
state_before: R : Type u_1
inst✝⁶ : Semiring R
P : Type u_2
inst✝⁵ : AddCommMonoid P
inst✝⁴ : Module R P
M : Type ?u.2418
inst✝³ : AddCommMonoid M
inst✝² : Module R M
N : Type ?u.2448
inst✝¹ : AddCommMonoid N
inst✝ : Module R N
⊢ Projective R P ↔ ∃ s, comp (Finsupp.total P P R id) s = LinearMap.id
Theorem: Subgroup.isComplement_top_right
File: Mathlib/GroupTheory/Complement.lean

tactic: refine'
  ⟨fun h => Set.exists_eq_singleton_iff_nonempty_subsingleton.mpr ⟨_, fun a ha b hb => _⟩, _⟩
state_before: G : Type u_1
inst✝ : Group G
H K : Subgroup G
S T : Set G
⊢ IsComplement S ⊤ ↔ ∃ g, S = {g}

tactic: obtain ⟨a, _⟩ := h.2 1
state_before: case refine'_1
G : Type u_1
inst✝ : Group G
H K : Subgroup G
S T : Set G
h : IsComplement S ⊤
⊢ Set.Nonempty S

tactic: exact ⟨a.1.1, a.1.2⟩
state_before: case refine'_1.intro
G : Type u_1
inst✝ : Group G
H K : Subgroup G
S T : Set G
h : IsComplement S ⊤
a : ↑S × ↑⊤
h✝ : (fun x => ↑x.fst * ↑x.snd) a = 1
⊢ Set.Nonempty S

tactic: have : (⟨⟨a, ha⟩, ⟨_, mem_top a⁻¹⟩⟩ : S × (⊤ : Set G)) = ⟨⟨b, hb⟩, ⟨_, mem_top b⁻¹⟩⟩ :=
  h.1 ((mul_inv_self a).trans (mul_inv_self b).symm)
state_before: case refine'_2
G : Type u_1
inst✝ : Group G
H K : Subgroup G
S T : Set G
h : IsComplement S ⊤
a : G
ha : a ∈ S
b : G
hb : b ∈ S
⊢ a = b

tactic: exact Subtype.ext_iff.mp (Prod.ext_iff.mp this).1
state_before: case refine'_2
G : Type u_1
inst✝ : Group G
H K : Subgroup G
S T : Set G
h : IsComplement S ⊤
a : G
ha : a ∈ S
b : G
hb : b ∈ S
this :
  ({ val := a, property := ha }, { val := a⁻¹, property := (_ : a⁻¹ ∈ ⊤) }) =
    ({ val := b, property := hb }, { val := b⁻¹, property := (_ : b⁻¹ ∈ ⊤) })
⊢ a = b

tactic: rintro ⟨g, rfl⟩
state_before: case refine'_3
G : Type u_1
inst✝ : Group G
H K : Subgroup G
S T : Set G
⊢ (∃ g, S = {g}) → IsComplement S ⊤

tactic: exact isComplement_singleton_top
state_before: case refine'_3.intro
G : Type u_1
inst✝ : Group G
H K : Subgroup G
T : Set G
g : G
⊢ IsComplement {g} ⊤