tasksource/leandojo huggingface dataset:
Theorem: Matrix.BlockTriangular.det_fintype
File: Mathlib/LinearAlgebra/Matrix/Block.lean

tactic: refine' h.det.trans (prod_subset (subset_univ _) fun a _ ha => _)
state_before: α : Type u_1
β : Type ?u.117449
m : Type u_2
n : Type ?u.117455
o : Type ?u.117458
m' : α → Type ?u.117463
n' : α → Type ?u.117468
R : Type v
inst✝⁷ : CommRing R
M N : Matrix m m R
b : m → α
inst✝⁶ : DecidableEq m
inst✝⁵ : Fintype m
inst✝⁴ : DecidableEq n
inst✝³ : Fintype n
inst✝² : DecidableEq α
inst✝¹ : Fintype α
inst✝ : LinearOrder α
h : BlockTriangular M b
⊢ det M = ∏ k : α, det (toSquareBlock M b k)

tactic: have : IsEmpty { i // b i = a } := ⟨fun i => ha <| mem_image.2 ⟨i, mem_univ _, i.2⟩⟩
state_before: α : Type u_1
β : Type ?u.117449
m : Type u_2
n : Type ?u.117455
o : Type ?u.117458
m' : α → Type ?u.117463
n' : α → Type ?u.117468
R : Type v
inst✝⁷ : CommRing R
M N : Matrix m m R
b : m → α
inst✝⁶ : DecidableEq m
inst✝⁵ : Fintype m
inst✝⁴ : DecidableEq n
inst✝³ : Fintype n
inst✝² : DecidableEq α
inst✝¹ : Fintype α
inst✝ : LinearOrder α
h : BlockTriangular M b
a : α
x✝ : a ∈ univ
ha : ¬a ∈ image b univ
⊢ det (toSquareBlock M b a) = 1

tactic: exact det_isEmpty
state_before: α : Type u_1
β : Type ?u.117449
m : Type u_2
n : Type ?u.117455
o : Type ?u.117458
m' : α → Type ?u.117463
n' : α → Type ?u.117468
R : Type v
inst✝⁷ : CommRing R
M N : Matrix m m R
b : m → α
inst✝⁶ : DecidableEq m
inst✝⁵ : Fintype m
inst✝⁴ : DecidableEq n
inst✝³ : Fintype n
inst✝² : DecidableEq α
inst✝¹ : Fintype α
inst✝ : LinearOrder α
h : BlockTriangular M b
a : α
x✝ : a ∈ univ
ha : ¬a ∈ image b univ
this : IsEmpty { i // b i = a }
⊢ det (toSquareBlock M b a) = 1
Theorem: List.take_succ
File: Mathlib/Data/List/Basic.lean

tactic: induction' l with hd tl hl generalizing n
state_before: ι : Type ?u.175545
α : Type u
β : Type v
γ : Type w
δ : Type x
l₁ l₂ l : List α
n : ℕ
⊢ take (n + 1) l = take n l ++ Option.toList (get? l n)

tactic: simp only [Option.toList, get?, take_nil, append_nil]
state_before: case nil
ι : Type ?u.175545
α : Type u
β : Type v
γ : Type w
δ : Type x
l₁ l₂ : List α
n✝ n : ℕ
⊢ take (n + 1) [] = take n [] ++ Option.toList (get? [] n)

tactic: cases n
state_before: case cons
ι : Type ?u.175545
α : Type u
β : Type v
γ : Type w
δ : Type x
l₁ l₂ : List α
n✝ : ℕ
hd : α
tl : List α
hl : ∀ {n : ℕ}, take (n + 1) tl = take n tl ++ Option.toList (get? tl n)
n : ℕ
⊢ take (n + 1) (hd :: tl) = take n (hd :: tl) ++ Option.toList (get? (hd :: tl) n)

tactic: simp only [Option.toList, get?, eq_self_iff_true, and_self_iff, take, nil_append]
state_before: case cons.zero
ι : Type ?u.175545
α : Type u
β : Type v
γ : Type w
δ : Type x
l₁ l₂ : List α
n : ℕ
hd : α
tl : List α
hl : ∀ {n : ℕ}, take (n + 1) tl = take n tl ++ Option.toList (get? tl n)
⊢ take (zero + 1) (hd :: tl) = take zero (hd :: tl) ++ Option.toList (get? (hd :: tl) zero)

tactic: simp only [hl, cons_append, get?, eq_self_iff_true, and_self_iff, take]
state_before: case cons.succ
ι : Type ?u.175545
α : Type u
β : Type v
γ : Type w
δ : Type x
l₁ l₂ : List α
n : ℕ
hd : α
tl : List α
hl : ∀ {n : ℕ}, take (n + 1) tl = take n tl ++ Option.toList (get? tl n)
n✝ : ℕ
⊢ take (succ n✝ + 1) (hd :: tl) = take (succ n✝) (hd :: tl) ++ Option.toList (get? (hd :: tl) (succ n✝))
Theorem: EqualCharZero.pnatCast_eq_natCast
File: Mathlib/Algebra/CharP/MixedCharZero.lean

tactic: change ((PNat.isUnit_natCast (R := R) n).unit : R) = ↑n
state_before: R : Type u_1
inst✝¹ : CommRing R
inst✝ : Fact (∀ (I : Ideal R), I ≠ ⊤ → CharZero (R ⧸ I))
n : ℕ+
⊢ ↑↑n = ↑↑n

tactic: simp only [IsUnit.unit_spec]
state_before: R : Type u_1
inst✝¹ : CommRing R
inst✝ : Fact (∀ (I : Ideal R), I ≠ ⊤ → CharZero (R ⧸ I))
n : ℕ+
⊢ ↑(IsUnit.unit (_ : IsUnit ↑↑n)) = ↑↑n
Theorem: TopCat.prodIsoProd_hom_fst
File: Mathlib/Topology/Category/TopCat/Limits/Products.lean

tactic: simp [← Iso.eq_inv_comp, prodIsoProd]
state_before: J : Type v
inst✝ : SmallCategory J
X Y : TopCat
⊢ (prodIsoProd X Y).hom ≫ prodFst = prod.fst

tactic: rfl
state_before: J : Type v
inst✝ : SmallCategory J
X Y : TopCat
⊢ prodFst = BinaryFan.fst (prodBinaryFan X Y)
Theorem: CategoryTheory.Limits.coprod.desc_inl_inr
File: Mathlib/CategoryTheory/Limits/Shapes/BinaryProducts.lean

tactic: apply coprod.hom_ext
state_before: C : Type u
inst✝¹ : Category C
X✝ Y✝ X Y : C
inst✝ : HasBinaryCoproduct X Y
⊢ desc inl inr = 𝟙 (X ⨿ Y)

tactic: simp
state_before: case h₁
C : Type u
inst✝¹ : Category C
X✝ Y✝ X Y : C
inst✝ : HasBinaryCoproduct X Y
⊢ inl ≫ desc inl inr = inl ≫ 𝟙 (X ⨿ Y)

case h₂
C : Type u
inst✝¹ : Category C
X✝ Y✝ X Y : C
inst✝ : HasBinaryCoproduct X Y
⊢ inr ≫ desc inl inr = inr ≫ 𝟙 (X ⨿ Y)

tactic: simp
state_before: case h₂
C : Type u
inst✝¹ : Category C
X✝ Y✝ X Y : C
inst✝ : HasBinaryCoproduct X Y
⊢ inr ≫ desc inl inr = inr ≫ 𝟙 (X ⨿ Y)
Theorem: MeasureTheory.measure_liminf_eq_zero
File: Mathlib/MeasureTheory/Measure/MeasureSpace.lean

tactic: rw [← le_zero_iff]
state_before: α : Type u_1
β : Type ?u.73864
γ : Type ?u.73867
δ : Type ?u.73870
ι : Type ?u.73873
R : Type ?u.73876
R' : Type ?u.73879
m : MeasurableSpace α
μ μ₁ μ₂ : Measure α
s✝ s₁ s₂ t : Set α
s : ℕ → Set α
h : (∑' (i : ℕ), ↑↑μ (s i)) ≠ ⊤
⊢ ↑↑μ (liminf s atTop) = 0

tactic: have : liminf s atTop ≤ limsup s atTop :=
  liminf_le_limsup
    (by isBoundedDefault)
    (by isBoundedDefault)
state_before: α : Type u_1
β : Type ?u.73864
γ : Type ?u.73867
δ : Type ?u.73870
ι : Type ?u.73873
R : Type ?u.73876
R' : Type ?u.73879
m : MeasurableSpace α
μ μ₁ μ₂ : Measure α
s✝ s₁ s₂ t : Set α
s : ℕ → Set α
h : (∑' (i : ℕ), ↑↑μ (s i)) ≠ ⊤
⊢ ↑↑μ (liminf s atTop) ≤ 0

tactic: exact (μ.mono this).trans (by simp [measure_limsup_eq_zero h])
state_before: α : Type u_1
β : Type ?u.73864
γ : Type ?u.73867
δ : Type ?u.73870
ι : Type ?u.73873
R : Type ?u.73876
R' : Type ?u.73879
m : MeasurableSpace α
μ μ₁ μ₂ : Measure α
s✝ s₁ s₂ t : Set α
s : ℕ → Set α
h : (∑' (i : ℕ), ↑↑μ (s i)) ≠ ⊤
this : liminf s atTop ≤ limsup s atTop
⊢ ↑↑μ (liminf s atTop) ≤ 0

tactic: isBoundedDefault
state_before: α : Type u_1
β : Type ?u.73864
γ : Type ?u.73867
δ : Type ?u.73870
ι : Type ?u.73873
R : Type ?u.73876
R' : Type ?u.73879
m : MeasurableSpace α
μ μ₁ μ₂ : Measure α
s✝ s₁ s₂ t : Set α
s : ℕ → Set α
h : (∑' (i : ℕ), ↑↑μ (s i)) ≠ ⊤
⊢ IsBoundedUnder (fun x x_1 => x ≤ x_1) atTop s

tactic: isBoundedDefault
state_before: α : Type u_1
β : Type ?u.73864
γ : Type ?u.73867
δ : Type ?u.73870
ι : Type ?u.73873
R : Type ?u.73876
R' : Type ?u.73879
m : MeasurableSpace α
μ μ₁ μ₂ : Measure α
s✝ s₁ s₂ t : Set α
s : ℕ → Set α
h : (∑' (i : ℕ), ↑↑μ (s i)) ≠ ⊤
⊢ IsBoundedUnder (fun x x_1 => x ≥ x_1) atTop s

tactic: simp [measure_limsup_eq_zero h]
state_before: α : Type u_1
β : Type ?u.73864
γ : Type ?u.73867
δ : Type ?u.73870
ι : Type ?u.73873
R : Type ?u.73876
R' : Type ?u.73879
m : MeasurableSpace α
μ μ₁ μ₂ : Measure α
s✝ s₁ s₂ t : Set α
s : ℕ → Set α
h : (∑' (i : ℕ), ↑↑μ (s i)) ≠ ⊤
this : liminf s atTop ≤ limsup s atTop
⊢ ↑↑μ (limsup s atTop) ≤ 0
Theorem: Real.log_neg_iff
File: Mathlib/Analysis/SpecialFunctions/Log/Basic.lean

tactic: rw [← log_one]
state_before: x y : ℝ
h : 0 < x
⊢ log x < 0 ↔ x < 1

tactic: exact log_lt_log_iff h zero_lt_one
state_before: x y : ℝ
h : 0 < x
⊢ log x < log 1 ↔ x < 1
Theorem: SameRay.norm_add
File: Mathlib/Analysis/NormedSpace/Ray.lean

tactic: rcases h.exists_eq_smul with ⟨u, a, b, ha, hb, -, rfl, rfl⟩
state_before: E : Type u_1
inst✝³ : SeminormedAddCommGroup E
inst✝² : NormedSpace ℝ E
F : Type ?u.239
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedSpace ℝ F
x y : E
h : SameRay ℝ x y
⊢ ‖x + y‖ = ‖x‖ + ‖y‖

tactic: rw [← add_smul, norm_smul_of_nonneg (add_nonneg ha hb), norm_smul_of_nonneg ha,
  norm_smul_of_nonneg hb, add_mul]
state_before: case intro.intro.intro.intro.intro.intro.intro
E : Type u_1
inst✝³ : SeminormedAddCommGroup E
inst✝² : NormedSpace ℝ E
F : Type ?u.239
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedSpace ℝ F
u : E
a b : ℝ
ha : 0 ≤ a
hb : 0 ≤ b
h : SameRay ℝ (a • u) (b • u)
⊢ ‖a • u + b • u‖ = ‖a • u‖ + ‖b • u‖
Theorem: Asymptotics.superpolynomialDecay_iff_superpolynomialDecay_norm
File: Mathlib/Analysis/Asymptotics/SuperpolynomialDecay.lean

tactic: simp [SuperpolynomialDecay]
state_before: α : Type u_1
β : Type u_2
l : Filter α
k f g g' : α → β
inst✝ : NormedLinearOrderedField β
⊢ (∀ (n : ℕ), Tendsto (fun a => ‖k a ^ n * f a‖) l (𝓝 0)) ↔ SuperpolynomialDecay l (fun a => ‖k a‖) fun a => ‖f a‖
Theorem: himp_idem
File: Mathlib/Order/Heyting/Basic.lean

tactic: rw [himp_himp, inf_idem]
state_before: ι : Type ?u.70425
α : Type u_1
β : Type ?u.70431
inst✝ : GeneralizedHeytingAlgebra α
a b c d : α
⊢ b ⇨ b ⇨ a = b ⇨ a
Theorem: CategoryTheory.Limits.prod.diag_map
File: Mathlib/CategoryTheory/Limits/Shapes/BinaryProducts.lean

tactic: simp
state_before: C : Type u
inst✝² : Category C
X✝ Y✝ X Y : C
f : X ⟶ Y
inst✝¹ : HasBinaryProduct X X
inst✝ : HasBinaryProduct Y Y
⊢ diag X ≫ map f f = f ≫ diag Y
Theorem: Polynomial.card_support_trinomial
File: Mathlib/Data/Polynomial/Coeff.lean

tactic: rw [support_trinomial hkm hmn hx hy hz,
  card_insert_of_not_mem
    (mt mem_insert.mp (not_or_of_not hkm.ne (mt mem_singleton.mp (hkm.trans hmn).ne))),
  card_insert_of_not_mem (mt mem_singleton.mp hmn.ne), card_singleton]
state_before: R : Type u
S : Type v
a b : R
n✝ m✝ : ℕ
inst✝ : Semiring R
p q r : R[X]
k m n : ℕ
hkm : k < m
hmn : m < n
x y z : R
hx : x ≠ 0
hy : y ≠ 0
hz : z ≠ 0
⊢ card (support (↑C x * X ^ k + ↑C y * X ^ m + ↑C z * X ^ n)) = 3
Theorem: Filter.HasBasis.principal_inf
File: Mathlib/Order/Filter/Bases.lean

tactic: simpa only [inf_comm, inter_comm] using hl.inf_principal s'
state_before: α : Type u_1
β : Type ?u.44590
γ : Type ?u.44593
ι : Sort u_2
ι' : Sort ?u.44599
l l' : Filter α
p : ι → Prop
s : ι → Set α
t : Set α
i : ι
p' : ι' → Prop
s'✝ : ι' → Set α
i' : ι'
hl : HasBasis l p s
s' : Set α
⊢ HasBasis (𝓟 s' ⊓ l) p fun i => s' ∩ s i
Theorem: MeasureTheory.Measure.restrict_iUnion_congr
File: Mathlib/MeasureTheory/Measure/MeasureSpace.lean

tactic: refine' ⟨fun h i => restrict_congr_mono (subset_iUnion _ _) h, fun h => _⟩
state_before: α : Type u_2
β : Type ?u.314892
γ : Type ?u.314895
δ : Type ?u.314898
ι : Type u_1
R : Type ?u.314904
R' : Type ?u.314907
m0 : MeasurableSpace α
inst✝² : MeasurableSpace β
inst✝¹ : MeasurableSpace γ
μ μ₁ μ₂ μ₃ ν ν' ν₁ ν₂ : Measure α
s✝ s' t : Set α
inst✝ : Countable ι
s : ι → Set α
⊢ restrict μ (⋃ (i : ι), s i) = restrict ν (⋃ (i : ι), s i) ↔ ∀ (i : ι), restrict μ (s i) = restrict ν (s i)

tactic: ext1 t ht
state_before: α : Type u_2
β : Type ?u.314892
γ : Type ?u.314895
δ : Type ?u.314898
ι : Type u_1
R : Type ?u.314904
R' : Type ?u.314907
m0 : MeasurableSpace α
inst✝² : MeasurableSpace β
inst✝¹ : MeasurableSpace γ
μ μ₁ μ₂ μ₃ ν ν' ν₁ ν₂ : Measure α
s✝ s' t : Set α
inst✝ : Countable ι
s : ι → Set α
h : ∀ (i : ι), restrict μ (s i) = restrict ν (s i)
⊢ restrict μ (⋃ (i : ι), s i) = restrict ν (⋃ (i : ι), s i)

tactic: rw [iUnion_eq_iUnion_finset]
state_before: case h
α : Type u_2
β : Type ?u.314892
γ : Type ?u.314895
δ : Type ?u.314898
ι : Type u_1
R : Type ?u.314904
R' : Type ?u.314907
m0 : MeasurableSpace α
inst✝² : MeasurableSpace β
inst✝¹ : MeasurableSpace γ
μ μ₁ μ₂ μ₃ ν ν' ν₁ ν₂ : Measure α
s✝ s' t✝ : Set α
inst✝ : Countable ι
s : ι → Set α
h : ∀ (i : ι), restrict μ (s i) = restrict ν (s i)
t : Set α
ht : MeasurableSet t
D : Directed (fun x x_1 => x ⊆ x_1) fun t => ⋃ (i : ι) (_ : i ∈ t), s i
⊢ ↑↑(restrict μ (⋃ (i : ι), s i)) t = ↑↑(restrict ν (⋃ (i : ι), s i)) t

tactic: simp only [restrict_iUnion_apply_eq_iSup D ht, restrict_finset_biUnion_congr.2 fun i _ => h i]
state_before: case h
α : Type u_2
β : Type ?u.314892
γ : Type ?u.314895
δ : Type ?u.314898
ι : Type u_1
R : Type ?u.314904
R' : Type ?u.314907
m0 : MeasurableSpace α
inst✝² : MeasurableSpace β
inst✝¹ : MeasurableSpace γ
μ μ₁ μ₂ μ₃ ν ν' ν₁ ν₂ : Measure α
s✝ s' t✝ : Set α
inst✝ : Countable ι
s : ι → Set α
h : ∀ (i : ι), restrict μ (s i) = restrict ν (s i)
t : Set α
ht : MeasurableSet t
D : Directed (fun x x_1 => x ⊆ x_1) fun t => ⋃ (i : ι) (_ : i ∈ t), s i
⊢ ↑↑(restrict μ (⋃ (t : Finset ι) (i : ι) (_ : i ∈ t), s i)) t =
    ↑↑(restrict ν (⋃ (t : Finset ι) (i : ι) (_ : i ∈ t), s i)) t
Theorem: ENNReal.lt_add_of_sub_lt_left
File: Mathlib/Data/Real/ENNReal.lean

tactic: obtain rfl | hb := eq_or_ne b ∞
state_before: α : Type ?u.179238
β : Type ?u.179241
a b c d : ℝ≥0∞
r p q : ℝ≥0
h : a ≠ ⊤ ∨ b ≠ ⊤
⊢ a - b < c → a < b + c

tactic: rw [top_add, lt_top_iff_ne_top]
state_before: case inl
α : Type ?u.179238
β : Type ?u.179241
a c d : ℝ≥0∞
r p q : ℝ≥0
h : a ≠ ⊤ ∨ ⊤ ≠ ⊤
⊢ a - ⊤ < c → a < ⊤ + c

tactic: exact fun _ => h.resolve_right (Classical.not_not.2 rfl)
state_before: case inl
α : Type ?u.179238
β : Type ?u.179241
a c d : ℝ≥0∞
r p q : ℝ≥0
h : a ≠ ⊤ ∨ ⊤ ≠ ⊤
⊢ a - ⊤ < c → a ≠ ⊤

tactic: exact (cancel_of_ne hb).lt_add_of_tsub_lt_left
state_before: case inr
α : Type ?u.179238
β : Type ?u.179241
a b c d : ℝ≥0∞
r p q : ℝ≥0
h : a ≠ ⊤ ∨ b ≠ ⊤
hb : b ≠ ⊤
⊢ a - b < c → a < b + c
Theorem: MeasureTheory.quasiMeasurePreserving_div_left
File: Mathlib/MeasureTheory/Group/Prod.lean

tactic: simp_rw [div_eq_mul_inv]
state_before: G : Type u_1
inst✝⁶ : MeasurableSpace G
inst✝⁵ : Group G
inst✝⁴ : MeasurableMul₂ G
μ ν : Measure G
inst✝³ : SigmaFinite ν
inst✝² : SigmaFinite μ
s : Set G
inst✝¹ : MeasurableInv G
inst✝ : IsMulLeftInvariant μ
g : G
⊢ QuasiMeasurePreserving fun h => g / h

tactic: exact
  (measurePreserving_mul_left μ g).quasiMeasurePreserving.comp (quasiMeasurePreserving_inv μ)
state_before: G : Type u_1
inst✝⁶ : MeasurableSpace G
inst✝⁵ : Group G
inst✝⁴ : MeasurableMul₂ G
μ ν : Measure G
inst✝³ : SigmaFinite ν
inst✝² : SigmaFinite μ
s : Set G
inst✝¹ : MeasurableInv G
inst✝ : IsMulLeftInvariant μ
g : G
⊢ QuasiMeasurePreserving fun h => g * h⁻¹
Theorem: ite_eq_mem_stdSimplex
File: Mathlib/Analysis/Convex/Basic.lean

tactic: simp only
state_before: 𝕜 : Type u_1
E : Type ?u.296852
F : Type ?u.296855
β : Type ?u.296858
ι : Type u_2
inst✝¹ : OrderedSemiring 𝕜
inst✝ : Fintype ι
i j : ι
⊢ 0 ≤ (fun j => if i = j then 1 else 0) j

tactic: split_ifs <;> norm_num
state_before: 𝕜 : Type u_1
E : Type ?u.296852
F : Type ?u.296855
β : Type ?u.296858
ι : Type u_2
inst✝¹ : OrderedSemiring 𝕜
inst✝ : Fintype ι
i j : ι
⊢ 0 ≤ if i = j then 1 else 0

tactic: rw [Finset.sum_ite_eq, if_pos (Finset.mem_univ _)]
state_before: 𝕜 : Type u_1
E : Type ?u.296852
F : Type ?u.296855
β : Type ?u.296858
ι : Type u_2
inst✝¹ : OrderedSemiring 𝕜
inst✝ : Fintype ι
i : ι
⊢ ∑ x : ι, (fun j => if i = j then 1 else 0) x = 1
Theorem: Stream'.WSeq.liftRel_think_left
File: Mathlib/Data/Seq/WSeq.lean

tactic: rw [liftRel_destruct_iff, liftRel_destruct_iff]
state_before: α : Type u
β : Type v
γ : Type w
R : α → β → Prop
s : WSeq α
t : WSeq β
⊢ LiftRel R (think s) t ↔ LiftRel R s t

tactic: simp
state_before: α : Type u
β : Type v
γ : Type w
R : α → β → Prop
s : WSeq α
t : WSeq β
⊢ Computation.LiftRel (LiftRelO R (LiftRel R)) (destruct (think s)) (destruct t) ↔
    Computation.LiftRel (LiftRelO R (LiftRel R)) (destruct s) (destruct t)
Theorem: NormedAddGroupHom.Equalizer.comm_sq₂
File: Mathlib/Analysis/Normed/Group/Hom.lean

tactic: rw [comp_assoc, hf, ← comp_assoc, hf', comp_assoc]
state_before: V : Type ?u.513561
W : Type ?u.513564
V₁ : Type u_1
V₂ : Type u_4
V₃ : Type u_6
inst✝⁷ : SeminormedAddCommGroup V
inst✝⁶ : SeminormedAddCommGroup W
inst✝⁵ : SeminormedAddCommGroup V₁
inst✝⁴ : SeminormedAddCommGroup V₂
inst✝³ : SeminormedAddCommGroup V₃
f : NormedAddGroupHom V W
W₁ : Type u_3
W₂ : Type u_2
W₃ : Type u_5
inst✝² : SeminormedAddCommGroup W₁
inst✝¹ : SeminormedAddCommGroup W₂
inst✝ : SeminormedAddCommGroup W₃
g : NormedAddGroupHom V W
f₁ g₁ : NormedAddGroupHom V₁ W₁
f₂ g₂ : NormedAddGroupHom V₂ W₂
f₃ g₃ : NormedAddGroupHom V₃ W₃
φ : NormedAddGroupHom V₁ V₂
ψ : NormedAddGroupHom W₁ W₂
φ' : NormedAddGroupHom V₂ V₃
ψ' : NormedAddGroupHom W₂ W₃
hf : NormedAddGroupHom.comp ψ f₁ = NormedAddGroupHom.comp f₂ φ
hf' : NormedAddGroupHom.comp ψ' f₂ = NormedAddGroupHom.comp f₃ φ'
⊢ NormedAddGroupHom.comp (NormedAddGroupHom.comp ψ' ψ) f₁ = NormedAddGroupHom.comp f₃ (NormedAddGroupHom.comp φ' φ)
Theorem: Filter.iInf_principal
File: Mathlib/Order/Filter/Basic.lean

tactic: cases nonempty_fintype ι
state_before: α : Type u
β : Type v
γ : Type w
δ : Type ?u.122731
ι✝ : Sort x
f✝ g : Filter α
s t : Set α
ι : Type w
inst✝ : Finite ι
f : ι → Set α
⊢ (⨅ (i : ι), 𝓟 (f i)) = 𝓟 (⋂ (i : ι), f i)

tactic: simpa using iInf_principal_finset Finset.univ f
state_before: case intro
α : Type u
β : Type v
γ : Type w
δ : Type ?u.122731
ι✝ : Sort x
f✝ g : Filter α
s t : Set α
ι : Type w
inst✝ : Finite ι
f : ι → Set α
val✝ : Fintype ι
⊢ (⨅ (i : ι), 𝓟 (f i)) = 𝓟 (⋂ (i : ι), f i)
Theorem: Submodule.span_induction'
File: Mathlib/LinearAlgebra/Span.lean

tactic: refine' Exists.elim _ fun (hx : x ∈ span R s) (hc : p x hx) => hc
state_before: R : Type u_2
R₂ : Type ?u.24742
K : Type ?u.24745
M : Type u_1
M₂ : Type ?u.24751
V : Type ?u.24754
S : Type ?u.24757
inst✝⁵ : Semiring R
inst✝⁴ : AddCommMonoid M
inst✝³ : Module R M
x✝ : M
p✝ p' : Submodule R M
inst✝² : Semiring R₂
σ₁₂ : R →+* R₂
inst✝¹ : AddCommMonoid M₂
inst✝ : Module R₂ M₂
s t : Set M
p : (x : M) → x ∈ span R s → Prop
Hs : ∀ (x : M) (h : x ∈ s), p x (_ : x ∈ ↑(span R s))
H0 : p 0 (_ : 0 ∈ span R s)
H1 : ∀ (x : M) (hx : x ∈ span R s) (y : M) (hy : y ∈ span R s), p x hx → p y hy → p (x + y) (_ : x + y ∈ span R s)
H2 : ∀ (a : R) (x : M) (hx : x ∈ span R s), p x hx → p (a • x) (_ : a • x ∈ span R s)
x : M
hx : x ∈ span R s
⊢ p x hx

tactic: refine'
  span_induction hx (fun m hm => ⟨subset_span hm, Hs m hm⟩) ⟨zero_mem _, H0⟩
    (fun x y hx hy =>
      Exists.elim hx fun hx' hx =>
        Exists.elim hy fun hy' hy => ⟨add_mem hx' hy', H1 _ _ _ _ hx hy⟩)
    fun r x hx => Exists.elim hx fun hx' hx => ⟨smul_mem _ _ hx', H2 r _ _ hx⟩
state_before: R : Type u_2
R₂ : Type ?u.24742
K : Type ?u.24745
M : Type u_1
M₂ : Type ?u.24751
V : Type ?u.24754
S : Type ?u.24757
inst✝⁵ : Semiring R
inst✝⁴ : AddCommMonoid M
inst✝³ : Module R M
x✝ : M
p✝ p' : Submodule R M
inst✝² : Semiring R₂
σ₁₂ : R →+* R₂
inst✝¹ : AddCommMonoid M₂
inst✝ : Module R₂ M₂
s t : Set M
p : (x : M) → x ∈ span R s → Prop
Hs : ∀ (x : M) (h : x ∈ s), p x (_ : x ∈ ↑(span R s))
H0 : p 0 (_ : 0 ∈ span R s)
H1 : ∀ (x : M) (hx : x ∈ span R s) (y : M) (hy : y ∈ span R s), p x hx → p y hy → p (x + y) (_ : x + y ∈ span R s)
H2 : ∀ (a : R) (x : M) (hx : x ∈ span R s), p x hx → p (a • x) (_ : a • x ∈ span R s)
x : M
hx : x ∈ span R s
⊢ ∃ x_1, p x x_1
Theorem: Memℓp.infty_mul
File: Mathlib/Analysis/NormedSpace/lpSpace.lean

tactic: rw [memℓp_infty_iff]
state_before: α : Type ?u.560431
E : α → Type ?u.560436
p q : ℝ≥0∞
inst✝¹ : (i : α) → NormedAddCommGroup (E i)
I : Type u_1
B : I → Type u_2
inst✝ : (i : I) → NonUnitalNormedRing (B i)
f g : (i : I) → B i
hf : Memℓp f ⊤
hg : Memℓp g ⊤
⊢ Memℓp (f * g) ⊤

tactic: obtain ⟨⟨Cf, hCf⟩, ⟨Cg, hCg⟩⟩ := hf.bddAbove, hg.bddAbove
state_before: α : Type ?u.560431
E : α → Type ?u.560436
p q : ℝ≥0∞
inst✝¹ : (i : α) → NormedAddCommGroup (E i)
I : Type u_1
B : I → Type u_2
inst✝ : (i : I) → NonUnitalNormedRing (B i)
f g : (i : I) → B i
hf : Memℓp f ⊤
hg : Memℓp g ⊤
⊢ BddAbove (Set.range fun i => ‖(f * g) i‖)

tactic: refine' ⟨Cf * Cg, _⟩
state_before: case intro.intro
α : Type ?u.560431
E : α → Type ?u.560436
p q : ℝ≥0∞
inst✝¹ : (i : α) → NormedAddCommGroup (E i)
I : Type u_1
B : I → Type u_2
inst✝ : (i : I) → NonUnitalNormedRing (B i)
f g : (i : I) → B i
hf : Memℓp f ⊤
hg : Memℓp g ⊤
Cf : ℝ
hCf : Cf ∈ upperBounds (Set.range fun i => ‖f i‖)
Cg : ℝ
hCg : Cg ∈ upperBounds (Set.range fun i => ‖g i‖)
⊢ BddAbove (Set.range fun i => ‖(f * g) i‖)

tactic: rintro _ ⟨i, rfl⟩
state_before: case intro.intro
α : Type ?u.560431
E : α → Type ?u.560436
p q : ℝ≥0∞
inst✝¹ : (i : α) → NormedAddCommGroup (E i)
I : Type u_1
B : I → Type u_2
inst✝ : (i : I) → NonUnitalNormedRing (B i)
f g : (i : I) → B i
hf : Memℓp f ⊤
hg : Memℓp g ⊤
Cf : ℝ
hCf : Cf ∈ upperBounds (Set.range fun i => ‖f i‖)
Cg : ℝ
hCg : Cg ∈ upperBounds (Set.range fun i => ‖g i‖)
⊢ Cf * Cg ∈ upperBounds (Set.range fun i => ‖(f * g) i‖)

tactic: calc
  ‖(f * g) i‖ ≤ ‖f i‖ * ‖g i‖ := norm_mul_le (f i) (g i)
  _ ≤ Cf * Cg :=
    mul_le_mul (hCf ⟨i, rfl⟩) (hCg ⟨i, rfl⟩) (norm_nonneg _)
      ((norm_nonneg _).trans (hCf ⟨i, rfl⟩))
state_before: case intro.intro.intro
α : Type ?u.560431
E : α → Type ?u.560436
p q : ℝ≥0∞
inst✝¹ : (i : α) → NormedAddCommGroup (E i)
I : Type u_1
B : I → Type u_2
inst✝ : (i : I) → NonUnitalNormedRing (B i)
f g : (i : I) → B i
hf : Memℓp f ⊤
hg : Memℓp g ⊤
Cf : ℝ
hCf : Cf ∈ upperBounds (Set.range fun i => ‖f i‖)
Cg : ℝ
hCg : Cg ∈ upperBounds (Set.range fun i => ‖g i‖)
i : I
⊢ (fun i => ‖(f * g) i‖) i ≤ Cf * Cg
Theorem: UniformSpace.mem_nhds_iff_symm
File: Mathlib/Topology/UniformSpace/Basic.lean

tactic: rw [UniformSpace.mem_nhds_iff]
state_before: α : Type ua
β : Type ub
γ : Type uc
δ : Type ud
ι : Sort ?u.60190
inst✝ : UniformSpace α
x : α
s : Set α
⊢ s ∈ 𝓝 x ↔ ∃ V, V ∈ 𝓤 α ∧ SymmetricRel V ∧ ball x V ⊆ s

tactic: constructor
state_before: α : Type ua
β : Type ub
γ : Type uc
δ : Type ud
ι : Sort ?u.60190
inst✝ : UniformSpace α
x : α
s : Set α
⊢ (∃ V, V ∈ 𝓤 α ∧ ball x V ⊆ s) ↔ ∃ V, V ∈ 𝓤 α ∧ SymmetricRel V ∧ ball x V ⊆ s

tactic: rintro ⟨V, V_in, V_sub⟩
state_before: case mp
α : Type ua
β : Type ub
γ : Type uc
δ : Type ud
ι : Sort ?u.60190
inst✝ : UniformSpace α
x : α
s : Set α
⊢ (∃ V, V ∈ 𝓤 α ∧ ball x V ⊆ s) → ∃ V, V ∈ 𝓤 α ∧ SymmetricRel V ∧ ball x V ⊆ s

tactic: use symmetrizeRel V, symmetrize_mem_uniformity V_in, symmetric_symmetrizeRel V
state_before: case mp.intro.intro
α : Type ua
β : Type ub
γ : Type uc
δ : Type ud
ι : Sort ?u.60190
inst✝ : UniformSpace α
x : α
s : Set α
V : Set (α × α)
V_in : V ∈ 𝓤 α
V_sub : ball x V ⊆ s
⊢ ∃ V, V ∈ 𝓤 α ∧ SymmetricRel V ∧ ball x V ⊆ s

tactic: exact Subset.trans (ball_mono (symmetrizeRel_subset_self V) x) V_sub
state_before: case mp.intro.intro
α : Type ua
β : Type ub
γ : Type uc
δ : Type ud
ι : Sort ?u.60190
inst✝ : UniformSpace α
x : α
s : Set α
V : Set (α × α)
V_in : V ∈ 𝓤 α
V_sub : ball x V ⊆ s
⊢ ball x (symmetrizeRel V) ⊆ s

tactic: rintro ⟨V, V_in, _, V_sub⟩
state_before: case mpr
α : Type ua
β : Type ub
γ : Type uc
δ : Type ud
ι : Sort ?u.60190
inst✝ : UniformSpace α
x : α
s : Set α
⊢ (∃ V, V ∈ 𝓤 α ∧ SymmetricRel V ∧ ball x V ⊆ s) → ∃ V, V ∈ 𝓤 α ∧ ball x V ⊆ s

tactic: exact ⟨V, V_in, V_sub⟩
state_before: case mpr.intro.intro.intro
α : Type ua
β : Type ub
γ : Type uc
δ : Type ud
ι : Sort ?u.60190
inst✝ : UniformSpace α
x : α
s : Set α
V : Set (α × α)
V_in : V ∈ 𝓤 α
left✝ : SymmetricRel V
V_sub : ball x V ⊆ s
⊢ ∃ V, V ∈ 𝓤 α ∧ ball x V ⊆ s
Theorem: PrimeSpectrum.isOpen_iff
File: Mathlib/AlgebraicGeometry/PrimeSpectrum/Basic.lean

tactic: simp only [@eq_comm _ (Uᶜ)]
state_before: R : Type u
S : Type v
inst✝¹ : CommRing R
inst✝ : CommRing S
U : Set (PrimeSpectrum R)
⊢ IsOpen U ↔ ∃ s, Uᶜ = zeroLocus s

tactic: rfl
state_before: R : Type u
S : Type v
inst✝¹ : CommRing R
inst✝ : CommRing S
U : Set (PrimeSpectrum R)
⊢ IsOpen U ↔ ∃ s, zeroLocus s = Uᶜ
Theorem: convex_closedBall
File: Mathlib/Analysis/Convex/Normed.lean

tactic: simpa only [Metric.closedBall, sep_univ] using (convexOn_univ_dist a).convex_le r
state_before: ι : Type ?u.23609
E : Type u_1
inst✝¹ : SeminormedAddCommGroup E
inst✝ : NormedSpace ℝ E
s t : Set E
a : E
r : ℝ
⊢ Convex ℝ (closedBall a r)
Theorem: SimpleGraph.chromaticNumber_eq_zero_of_isempty
File: Mathlib/Combinatorics/SimpleGraph/Coloring.lean

tactic: rw [← nonpos_iff_eq_zero]
state_before: V : Type u
G✝ : SimpleGraph V
α : Type v
C : Coloring G✝ α
G : SimpleGraph V
inst✝ : IsEmpty V
⊢ chromaticNumber G = 0

tactic: apply csInf_le chromaticNumber_bddBelow
state_before: V : Type u
G✝ : SimpleGraph V
α : Type v
C : Coloring G✝ α
G : SimpleGraph V
inst✝ : IsEmpty V
⊢ chromaticNumber G ≤ 0

tactic: apply colorable_of_isEmpty
state_before: V : Type u
G✝ : SimpleGraph V
α : Type v
C : Coloring G✝ α
G : SimpleGraph V
inst✝ : IsEmpty V
⊢ 0 ∈ {n | Colorable G n}
Theorem: Nat.mul_div_cancel'
File: Std/Data/Nat/Lemmas.lean

tactic: have := mod_add_div m n
state_before: n m : Nat
H : n ∣ m
⊢ n * (m / n) = m

tactic: rwa [mod_eq_zero_of_dvd H, Nat.zero_add] at this
state_before: n m : Nat
H : n ∣ m
this : m % n + n * (m / n) = m
⊢ n * (m / n) = m