tasksource/leandojo huggingface dataset:
Theorem: List.sublistsLen_succ_cons
File: Mathlib/Data/List/Sublists.lean

tactic: rw [sublistsLen, sublistsLenAux, sublistsLenAux_eq, sublistsLenAux_eq, map_id,
    append_nil]
state_before: α✝ : Type u
β : Type v
γ : Type w
α : Type u_1
n : ℕ
a : α
l : List α
⊢ sublistsLen (n + 1) (a :: l) = sublistsLen (n + 1) l ++ map (cons a) (sublistsLen n l)

tactic: rfl
state_before: α✝ : Type u
β : Type v
γ : Type w
α : Type u_1
n : ℕ
a : α
l : List α
⊢ sublistsLen (n + 1) l ++ map (id ∘ cons a) (sublistsLen n l) = sublistsLen (n + 1) l ++ map (cons a) (sublistsLen n l)
Theorem: Polynomial.opRingEquiv_symm_monomial
File: Mathlib/RingTheory/Polynomial/Opposites.lean

tactic: simp
state_before: R : Type u_1
inst✝ : Semiring R
n : ℕ
r : Rᵐᵒᵖ
⊢ ↑(opRingEquiv R) (↑(RingEquiv.symm (opRingEquiv R)) (↑(monomial n) r)) =
    ↑(opRingEquiv R) (op (↑(monomial n) (unop r)))
Theorem: Basis.prod_apply
File: Mathlib/LinearAlgebra/Basis.lean

tactic: ext <;> cases i <;>
  simp only [prod_apply_inl_fst, Sum.elim_inl, LinearMap.inl_apply, prod_apply_inr_fst,
    Sum.elim_inr, LinearMap.inr_apply, prod_apply_inl_snd, prod_apply_inr_snd, Function.comp]
state_before: ι : Type u_1
ι' : Type u_2
R : Type u_5
R₂ : Type ?u.588552
K : Type ?u.588555
M : Type u_3
M' : Type u_4
M'' : Type ?u.588564
V : Type u
V' : Type ?u.588569
inst✝⁴ : Semiring R
inst✝³ : AddCommMonoid M
inst✝² : Module R M
inst✝¹ : AddCommMonoid M'
inst✝ : Module R M'
b b₁ : Basis ι R M
i✝ : ι
c : R
x : M
b' : Basis ι' R M'
i : ι ⊕ ι'
⊢ ↑(Basis.prod b b') i = Sum.elim (↑(LinearMap.inl R M M') ∘ ↑b) (↑(LinearMap.inr R M M') ∘ ↑b') i
Theorem: nnnorm_inv
File: Mathlib/Analysis/Normed/Field/Basic.lean

tactic: simp
state_before: α : Type u_1
β : Type ?u.217000
γ : Type ?u.217003
ι : Type ?u.217006
inst✝ : NormedDivisionRing α
a : α
⊢ ↑‖a⁻¹‖₊ = ↑‖a‖₊⁻¹
Theorem: Set.Finite.toFinset_singleton
File: Mathlib/Data/Set/Finite.lean

tactic: simp
state_before: α : Type u
β : Type v
ι : Sort w
γ : Type x
a : α
ha : optParam (Set.Finite {a}) (_ : Set.Finite {a})
⊢ ∀ (a_1 : α), a_1 ∈ Finite.toFinset ha ↔ a_1 ∈ {a}
Theorem: Filter.seq_pure
File: Mathlib/Order/Filter/Basic.lean

tactic: refine' le_antisymm (le_map fun s hs => _) (le_seq fun s hs t ht => _)
state_before: α : Type u
β : Type v
γ : Type w
δ : Type ?u.294266
ι : Sort x
f : Filter (α → β)
a : α
⊢ seq f (pure a) = map (fun g => g a) f

tactic: rw [← seq_singleton]
state_before: case refine'_1
α : Type u
β : Type v
γ : Type w
δ : Type ?u.294266
ι : Sort x
f : Filter (α → β)
a : α
s : Set (α → β)
hs : s ∈ f
⊢ (fun g => g a) '' s ∈ seq f (pure a)

tactic: exact seq_mem_seq hs singleton_mem_pure
state_before: case refine'_1
α : Type u
β : Type v
γ : Type w
δ : Type ?u.294266
ι : Sort x
f : Filter (α → β)
a : α
s : Set (α → β)
hs : s ∈ f
⊢ Set.seq s {a} ∈ seq f (pure a)

tactic: refine' sets_of_superset (map (fun g : α → β => g a) f) (image_mem_map hs) _
state_before: case refine'_2
α : Type u
β : Type v
γ : Type w
δ : Type ?u.294266
ι : Sort x
f : Filter (α → β)
a : α
s : Set (α → β)
hs : s ∈ f
t : Set α
ht : t ∈ pure a
⊢ Set.seq s t ∈ map (fun g => g a) f

tactic: rintro b ⟨g, hg, rfl⟩
state_before: case refine'_2
α : Type u
β : Type v
γ : Type w
δ : Type ?u.294266
ι : Sort x
f : Filter (α → β)
a : α
s : Set (α → β)
hs : s ∈ f
t : Set α
ht : t ∈ pure a
⊢ (fun g => g a) '' s ⊆ Set.seq s t

tactic: exact ⟨g, hg, a, ht, rfl⟩
state_before: case refine'_2.intro.intro
α : Type u
β : Type v
γ : Type w
δ : Type ?u.294266
ι : Sort x
f : Filter (α → β)
a : α
s : Set (α → β)
hs : s ∈ f
t : Set α
ht : t ∈ pure a
g : α → β
hg : g ∈ s
⊢ (fun g => g a) g ∈ Set.seq s t
Theorem: Polynomial.coeff_one_add_X_pow
File: Mathlib/Data/Polynomial/Coeff.lean

tactic: rw [add_comm _ X, coeff_X_add_one_pow]
state_before: R✝ : Type u
S : Type v
a b : R✝
n✝ m : ℕ
inst✝¹ : Semiring R✝
p q r : R✝[X]
R : Type u_1
inst✝ : Semiring R
n k : ℕ
⊢ coeff ((1 + X) ^ n) k = ↑(Nat.choose n k)
Theorem: List.append_subset
File: Std/Data/List/Lemmas.lean

tactic: simp [subset_def, or_imp, forall_and]
state_before: α : Type u_1
l₁ l₂ l : List α
⊢ l₁ ++ l₂ ⊆ l ↔ l₁ ⊆ l ∧ l₂ ⊆ l
Theorem: LocalRing.closedPoint_mem_iff
File: Mathlib/AlgebraicGeometry/PrimeSpectrum/Basic.lean

tactic: constructor
state_before: R : Type u
S : Type v
inst✝² : CommRing R
inst✝¹ : CommRing S
inst✝ : LocalRing R
U : TopologicalSpace.Opens (PrimeSpectrum R)
⊢ closedPoint R ∈ U ↔ U = ⊤

tactic: rw [eq_top_iff]
state_before: case mp
R : Type u
S : Type v
inst✝² : CommRing R
inst✝¹ : CommRing S
inst✝ : LocalRing R
U : TopologicalSpace.Opens (PrimeSpectrum R)
⊢ closedPoint R ∈ U → U = ⊤

tactic: exact fun h x _ => (specializes_closedPoint x).mem_open U.2 h
state_before: case mp
R : Type u
S : Type v
inst✝² : CommRing R
inst✝¹ : CommRing S
inst✝ : LocalRing R
U : TopologicalSpace.Opens (PrimeSpectrum R)
⊢ closedPoint R ∈ U → ⊤ ≤ U

tactic: rintro rfl
state_before: case mpr
R : Type u
S : Type v
inst✝² : CommRing R
inst✝¹ : CommRing S
inst✝ : LocalRing R
U : TopologicalSpace.Opens (PrimeSpectrum R)
⊢ U = ⊤ → closedPoint R ∈ U

tactic: trivial
state_before: case mpr
R : Type u
S : Type v
inst✝² : CommRing R
inst✝¹ : CommRing S
inst✝ : LocalRing R
⊢ closedPoint R ∈ ⊤
Theorem: Complex.tendsto_log_nhdsWithin_im_nonneg_of_re_neg_of_im_zero
File: Mathlib/Analysis/SpecialFunctions/Complex/Log.lean

tactic: simpa only [log, arg_eq_pi_iff.2 ⟨hre, him⟩] using
  (continuousWithinAt_log_of_re_neg_of_im_zero hre him).tendsto
state_before: z : ℂ
hre : z.re < 0
him : z.im = 0
⊢ Tendsto log (𝓝[{z | 0 ≤ z.im}] z) (𝓝 (↑(Real.log (↑abs z)) + ↑π * I))
Theorem: Gamma_mem
File: Mathlib/NumberTheory/ModularForms/CongruenceSubgroups.lean

tactic: rw [Gamma_mem']
state_before: N✝ N : ℕ
γ : SL(2, ℤ)
⊢ γ ∈ Gamma N ↔ ↑(↑γ 0 0) = 1 ∧ ↑(↑γ 0 1) = 0 ∧ ↑(↑γ 1 0) = 0 ∧ ↑(↑γ 1 1) = 1

tactic: constructor
state_before: N✝ N : ℕ
γ : SL(2, ℤ)
⊢ ↑(SpecialLinearGroup.map (Int.castRingHom (ZMod N))) γ = 1 ↔
    ↑(↑γ 0 0) = 1 ∧ ↑(↑γ 0 1) = 0 ∧ ↑(↑γ 1 0) = 0 ∧ ↑(↑γ 1 1) = 1

tactic: intro h
state_before: case mp
N✝ N : ℕ
γ : SL(2, ℤ)
⊢ ↑(SpecialLinearGroup.map (Int.castRingHom (ZMod N))) γ = 1 →
    ↑(↑γ 0 0) = 1 ∧ ↑(↑γ 0 1) = 0 ∧ ↑(↑γ 1 0) = 0 ∧ ↑(↑γ 1 1) = 1

tactic: simp [← SL_reduction_mod_hom_val N γ, h]
state_before: case mp
N✝ N : ℕ
γ : SL(2, ℤ)
h : ↑(SpecialLinearGroup.map (Int.castRingHom (ZMod N))) γ = 1
⊢ ↑(↑γ 0 0) = 1 ∧ ↑(↑γ 0 1) = 0 ∧ ↑(↑γ 1 0) = 0 ∧ ↑(↑γ 1 1) = 1

tactic: intro h
state_before: case mpr
N✝ N : ℕ
γ : SL(2, ℤ)
⊢ ↑(↑γ 0 0) = 1 ∧ ↑(↑γ 0 1) = 0 ∧ ↑(↑γ 1 0) = 0 ∧ ↑(↑γ 1 1) = 1 →
    ↑(SpecialLinearGroup.map (Int.castRingHom (ZMod N))) γ = 1

tactic: ext i
state_before: case mpr
N✝ N : ℕ
γ : SL(2, ℤ)
h : ↑(↑γ 0 0) = 1 ∧ ↑(↑γ 0 1) = 0 ∧ ↑(↑γ 1 0) = 0 ∧ ↑(↑γ 1 1) = 1
⊢ ↑(SpecialLinearGroup.map (Int.castRingHom (ZMod N))) γ = 1

tactic: intro j
state_before: case mpr.a
N✝ N : ℕ
γ : SL(2, ℤ)
h : ↑(↑γ 0 0) = 1 ∧ ↑(↑γ 0 1) = 0 ∧ ↑(↑γ 1 0) = 0 ∧ ↑(↑γ 1 1) = 1
i : Fin 2
⊢ ∀ (j : Fin 2), ↑(↑(SpecialLinearGroup.map (Int.castRingHom (ZMod N))) γ) i j = ↑1 i j

tactic: rw [SL_reduction_mod_hom_val N γ]
state_before: case mpr.a
N✝ N : ℕ
γ : SL(2, ℤ)
h : ↑(↑γ 0 0) = 1 ∧ ↑(↑γ 0 1) = 0 ∧ ↑(↑γ 1 0) = 0 ∧ ↑(↑γ 1 1) = 1
i j : Fin 2
⊢ ↑(↑(SpecialLinearGroup.map (Int.castRingHom (ZMod N))) γ) i j = ↑1 i j

tactic: fin_cases i <;> fin_cases j <;> simp only [h]
state_before: case mpr.a
N✝ N : ℕ
γ : SL(2, ℤ)
h : ↑(↑γ 0 0) = 1 ∧ ↑(↑γ 0 1) = 0 ∧ ↑(↑γ 1 0) = 0 ∧ ↑(↑γ 1 1) = 1
i j : Fin 2
⊢ ↑(↑γ i j) = ↑1 i j

tactic: exacts [h.1, h.2.1, h.2.2.1, h.2.2.2]
state_before: case mpr.a.head.head
N✝ N : ℕ
γ : SL(2, ℤ)
h : ↑(↑γ 0 0) = 1 ∧ ↑(↑γ 0 1) = 0 ∧ ↑(↑γ 1 0) = 0 ∧ ↑(↑γ 1 1) = 1
⊢ ↑(↑γ { val := 0, isLt := (_ : 0 < 2) } { val := 0, isLt := (_ : 0 < 2) }) =
    ↑1 { val := 0, isLt := (_ : 0 < 2) } { val := 0, isLt := (_ : 0 < 2) }

case mpr.a.head.tail.head
N✝ N : ℕ
γ : SL(2, ℤ)
h : ↑(↑γ 0 0) = 1 ∧ ↑(↑γ 0 1) = 0 ∧ ↑(↑γ 1 0) = 0 ∧ ↑(↑γ 1 1) = 1
⊢ ↑(↑γ { val := 0, isLt := (_ : 0 < 2) } { val := 1, isLt := (_ : (fun a => a < 2) 1) }) =
    ↑1 { val := 0, isLt := (_ : 0 < 2) } { val := 1, isLt := (_ : (fun a => a < 2) 1) }

case mpr.a.tail.head.head
N✝ N : ℕ
γ : SL(2, ℤ)
h : ↑(↑γ 0 0) = 1 ∧ ↑(↑γ 0 1) = 0 ∧ ↑(↑γ 1 0) = 0 ∧ ↑(↑γ 1 1) = 1
⊢ ↑(↑γ { val := 1, isLt := (_ : (fun a => a < 2) 1) } { val := 0, isLt := (_ : 0 < 2) }) =
    ↑1 { val := 1, isLt := (_ : (fun a => a < 2) 1) } { val := 0, isLt := (_ : 0 < 2) }

case mpr.a.tail.head.tail.head
N✝ N : ℕ
γ : SL(2, ℤ)
h : ↑(↑γ 0 0) = 1 ∧ ↑(↑γ 0 1) = 0 ∧ ↑(↑γ 1 0) = 0 ∧ ↑(↑γ 1 1) = 1
⊢ ↑(↑γ { val := 1, isLt := (_ : (fun a => a < 2) 1) } { val := 1, isLt := (_ : (fun a => a < 2) 1) }) =
    ↑1 { val := 1, isLt := (_ : (fun a => a < 2) 1) } { val := 1, isLt := (_ : (fun a => a < 2) 1) }
Theorem: Nat.digits_len_le_digits_len_succ
File: Mathlib/Data/Nat/Digits.lean

tactic: rcases Decidable.eq_or_ne n 0 with (rfl | hn)
state_before: n✝ b n : ℕ
⊢ List.length (digits b n) ≤ List.length (digits b (n + 1))

tactic: cases' le_or_lt b 1 with hb hb
state_before: case inr
n✝ b n : ℕ
hn : n ≠ 0
⊢ List.length (digits b n) ≤ List.length (digits b (n + 1))

tactic: simpa [digits_len, hb, hn] using log_mono_right (le_succ _)
state_before: case inr.inr
n✝ b n : ℕ
hn : n ≠ 0
hb : 1 < b
⊢ List.length (digits b n) ≤ List.length (digits b (n + 1))

tactic: simp
state_before: case inl
n b : ℕ
⊢ List.length (digits b 0) ≤ List.length (digits b (0 + 1))

tactic: interval_cases b <;> simp_arith [digits_zero_succ', hn]
state_before: case inr.inl
n✝ b n : ℕ
hn : n ≠ 0
hb : b ≤ 1
⊢ List.length (digits b n) ≤ List.length (digits b (n + 1))
Theorem: Fin.le_val_last
File: Mathlib/Data/Fin/Basic.lean

tactic: rw [Fin.cast_nat_eq_last]
state_before: n m : ℕ
i : Fin (n + 1)
⊢ i ≤ ↑n

tactic: exact Fin.le_last i
state_before: n m : ℕ
i : Fin (n + 1)
⊢ i ≤ last n
Theorem: LocalHomeomorph.IsImage.interior
File: Mathlib/Topology/LocalHomeomorph.lean

tactic: simpa only [closure_compl, compl_compl] using h.compl.closure.compl
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.45365
δ : Type ?u.45368
inst✝³ : TopologicalSpace α
inst✝² : TopologicalSpace β
inst✝¹ : TopologicalSpace γ
inst✝ : TopologicalSpace δ
e : LocalHomeomorph α β
e' : LocalHomeomorph β γ
s : Set α
t : Set β
x : α
y : β
h : IsImage e s t
⊢ IsImage e (interior s) (interior t)
Theorem: Finset.inter_insert_of_not_mem
File: Mathlib/Data/Finset/Basic.lean

tactic: rw [inter_comm, insert_inter_of_not_mem h, inter_comm]
state_before: α : Type u_1
β : Type ?u.186096
γ : Type ?u.186099
inst✝ : DecidableEq α
s s₁✝ s₂✝ t t₁ t₂ u v : Finset α
a✝ b : α
s₁ s₂ : Finset α
a : α
h : ¬a ∈ s₁
⊢ s₁ ∩ insert a s₂ = s₁ ∩ s₂
Theorem: Matrix.exists_vecMul_eq_zero_iff
File: Mathlib/LinearAlgebra/Matrix/ToLinearEquiv.lean

tactic: simpa only [← M.det_transpose, ← mulVec_transpose] using exists_mulVec_eq_zero_iff
state_before: R : Type ?u.531459
M✝ : Type ?u.531462
inst✝⁶ : CommRing R
inst✝⁵ : AddCommGroup M✝
inst✝⁴ : Module R M✝
n : Type u_2
inst✝³ : Fintype n
A : Type u_1
inst✝² : DecidableEq n
inst✝¹ : CommRing A
inst✝ : IsDomain A
M : Matrix n n A
⊢ (∃ v x, vecMul v M = 0) ↔ det M = 0
Theorem: LatticeOrderedCommGroup.neg_of_one_le_inv
File: Mathlib/Algebra/Order/LatticeGroup.lean

tactic: rw [neg_eq_pos_inv]
state_before: α : Type u
inst✝¹ : Lattice α
inst✝ : CommGroup α
a : α
h : 1 ≤ a⁻¹
⊢ a⁻ = a⁻¹

tactic: exact pos_of_one_le _ h
state_before: α : Type u
inst✝¹ : Lattice α
inst✝ : CommGroup α
a : α
h : 1 ≤ a⁻¹
⊢ a⁻¹⁺ = a⁻¹
Theorem: Bool.and_left_comm
File: Mathlib/Data/Bool/Basic.lean

tactic: decide
state_before: ⊢ ∀ (a b c : Bool), (a && (b && c)) = (b && (a && c))
Theorem: Set.smul_inter_ne_empty_iff'
File: Mathlib/Data/Set/Pointwise/SMul.lean

tactic: simp_rw [smul_inter_ne_empty_iff, div_eq_mul_inv]
state_before: F : Type ?u.142914
α : Type u_1
β : Type ?u.142920
γ : Type ?u.142923
inst✝¹ : Group α
inst✝ : MulAction α β
s✝ t✝ A B : Set β
a : α
x✝ : β
s t : Set α
x : α
⊢ x • s ∩ t ≠ ∅ ↔ ∃ a b, (a ∈ t ∧ b ∈ s) ∧ a / b = x
Theorem: multiplicity.finite_prime_left
File: Mathlib/Algebra/Squarefree.lean

tactic: revert hb
state_before: R : Type u_1
inst✝¹ : CancelCommMonoidWithZero R
inst✝ : WfDvdMonoid R
a b : R
ha : Prime a
hb : b ≠ 0
⊢ Finite a b

tactic: refine'
  WfDvdMonoid.induction_on_irreducible b (fun c => c.irrefl.elim) (fun u hu _ => _)
    fun b p hb hp ih _ => _
state_before: R : Type u_1
inst✝¹ : CancelCommMonoidWithZero R
inst✝ : WfDvdMonoid R
a b : R
ha : Prime a
⊢ b ≠ 0 → Finite a b

tactic: rw [multiplicity.finite_iff_dom, multiplicity.isUnit_right ha.not_unit hu]
state_before: case refine'_1
R : Type u_1
inst✝¹ : CancelCommMonoidWithZero R
inst✝ : WfDvdMonoid R
a b : R
ha : Prime a
u : R
hu : IsUnit u
x✝ : u ≠ 0
⊢ Finite a u

tactic: exact PartENat.dom_natCast 0
state_before: case refine'_1
R : Type u_1
inst✝¹ : CancelCommMonoidWithZero R
inst✝ : WfDvdMonoid R
a b : R
ha : Prime a
u : R
hu : IsUnit u
x✝ : u ≠ 0
⊢ 0.Dom

tactic: refine'
  multiplicity.finite_mul ha
    (multiplicity.finite_iff_dom.mpr
      (PartENat.dom_of_le_natCast (show multiplicity a p ≤ ↑1 from _)))
    (ih hb)
state_before: case refine'_2
R : Type u_1
inst✝¹ : CancelCommMonoidWithZero R
inst✝ : WfDvdMonoid R
a b✝ : R
ha : Prime a
b p : R
hb : b ≠ 0
hp : Irreducible p
ih : b ≠ 0 → Finite a b
x✝ : p * b ≠ 0
⊢ Finite a (p * b)

tactic: norm_cast
state_before: case refine'_2
R : Type u_1
inst✝¹ : CancelCommMonoidWithZero R
inst✝ : WfDvdMonoid R
a b✝ : R
ha : Prime a
b p : R
hb : b ≠ 0
hp : Irreducible p
ih : b ≠ 0 → Finite a b
x✝ : p * b ≠ 0
⊢ multiplicity a p ≤ 1

tactic: exact
  ((multiplicity.squarefree_iff_multiplicity_le_one p).mp hp.squarefree a).resolve_right
    ha.not_unit
state_before: case refine'_2
R : Type u_1
inst✝¹ : CancelCommMonoidWithZero R
inst✝ : WfDvdMonoid R
a b✝ : R
ha : Prime a
b p : R
hb : b ≠ 0
hp : Irreducible p
ih : b ≠ 0 → Finite a b
x✝ : p * b ≠ 0
⊢ multiplicity a p ≤ 1
Theorem: Equiv.Perm.viaFintypeEmbedding_apply_mem_range
File: Mathlib/Logic/Equiv/Fintype.lean

tactic: simp only [viaFintypeEmbedding, Function.Embedding.invOfMemRange]
state_before: α : Type u_2
β : Type u_1
inst✝¹ : Fintype α
inst✝ : DecidableEq β
e : Perm α
f : α ↪ β
b : β
h : b ∈ Set.range ↑f
⊢ ↑(viaFintypeEmbedding e f) b = ↑f (↑e (Function.Embedding.invOfMemRange f { val := b, property := h }))

tactic: rw [Equiv.Perm.extendDomain_apply_subtype]
state_before: α : Type u_2
β : Type u_1
inst✝¹ : Fintype α
inst✝ : DecidableEq β
e : Perm α
f : α ↪ β
b : β
h : b ∈ Set.range ↑f
⊢ ↑(extendDomain e (Function.Embedding.toEquivRange f)) b =
    ↑f (↑e (Function.Injective.invOfMemRange (_ : Function.Injective ↑f) { val := b, property := h }))

tactic: congr
state_before: α : Type u_2
β : Type u_1
inst✝¹ : Fintype α
inst✝ : DecidableEq β
e : Perm α
f : α ↪ β
b : β
h : b ∈ Set.range ↑f
⊢ ↑(↑(Function.Embedding.toEquivRange f)
        (↑e (↑(Function.Embedding.toEquivRange f).symm { val := b, property := ?h }))) =
    ↑f (↑e (Function.Injective.invOfMemRange (_ : Function.Injective ↑f) { val := b, property := h }))

case h
α : Type u_2
β : Type u_1
inst✝¹ : Fintype α
inst✝ : DecidableEq β
e : Perm α
f : α ↪ β
b : β
h : b ∈ Set.range ↑f
⊢ b ∈ Set.range ↑f
Theorem: Nat.zero_lor'
File: Mathlib/Data/Nat/Bitwise.lean

tactic: simp only [Nat.bitwise'_zero_left, Bool.false_or, eq_self_iff_true, Bool.cond_true, Nat.lor']
state_before: n : ℕ
⊢ lor' 0 n = n
Theorem: ContinuousLinearMap.iteratedFDeriv_comp_left
File: Mathlib/Analysis/Calculus/ContDiff.lean

tactic: simp only [← iteratedFDerivWithin_univ]
state_before: 𝕜 : Type u_1
inst✝¹⁰ : NontriviallyNormedField 𝕜
D : Type uD
inst✝⁹ : NormedAddCommGroup D
inst✝⁸ : NormedSpace 𝕜 D
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type ?u.207422
inst✝¹ : NormedAddCommGroup X
inst✝ : NormedSpace 𝕜 X
s s₁ t u : Set E
f✝ f₁ : E → F
g✝ : F → G
x✝ x₀ : E
c : F
b : E × F → G
m n : ℕ∞
p : E → FormalMultilinearSeries 𝕜 E F
f : E → F
g : F →L[𝕜] G
hf : ContDiff 𝕜 n f
x : E
i : ℕ
hi : ↑i ≤ n
⊢ iteratedFDeriv 𝕜 i (↑g ∘ f) x = compContinuousMultilinearMap g (iteratedFDeriv 𝕜 i f x)

tactic: exact g.iteratedFDerivWithin_comp_left hf.contDiffOn uniqueDiffOn_univ (mem_univ x) hi
state_before: 𝕜 : Type u_1
inst✝¹⁰ : NontriviallyNormedField 𝕜
D : Type uD
inst✝⁹ : NormedAddCommGroup D
inst✝⁸ : NormedSpace 𝕜 D
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type ?u.207422
inst✝¹ : NormedAddCommGroup X
inst✝ : NormedSpace 𝕜 X
s s₁ t u : Set E
f✝ f₁ : E → F
g✝ : F → G
x✝ x₀ : E
c : F
b : E × F → G
m n : ℕ∞
p : E → FormalMultilinearSeries 𝕜 E F
f : E → F
g : F →L[𝕜] G
hf : ContDiff 𝕜 n f
x : E
i : ℕ
hi : ↑i ≤ n
⊢ iteratedFDerivWithin 𝕜 i (↑g ∘ f) univ x = compContinuousMultilinearMap g (iteratedFDerivWithin 𝕜 i f univ x)
Theorem: FractionalIdeal.mem_span_mul_finite_of_mem_mul
File: Mathlib/RingTheory/FractionalIdeal.lean

tactic: simpa using mem_coe.mpr hx
state_before: R : Type u_1
inst✝⁶ : CommRing R
S : Submonoid R
P : Type u_2
inst✝⁵ : CommRing P
inst✝⁴ : Algebra R P
loc : IsLocalization S P
P' : Type ?u.673289
inst✝³ : CommRing P'
inst✝² : Algebra R P'
loc' : IsLocalization S P'
P'' : Type ?u.673742
inst✝¹ : CommRing P''
inst✝ : Algebra R P''
loc'' : IsLocalization S P''
I✝ J✝ : FractionalIdeal S P
g : P →ₐ[R] P'
I J : FractionalIdeal S P
x : P
hx : x ∈ I * J
⊢ x ∈ ↑I * ↑J
Theorem: measurable_of_Ici
File: Mathlib/MeasureTheory/Constructions/BorelSpace/Basic.lean

tactic: apply measurable_of_Iio
state_before: α : Type u_2
β : Type ?u.1090485
γ : Type ?u.1090488
γ₂ : Type ?u.1090491
δ : Type u_1
ι : Sort y
s t u : Set α
inst✝¹² : TopologicalSpace α
inst✝¹¹ : MeasurableSpace α
inst✝¹⁰ : BorelSpace α
inst✝⁹ : TopologicalSpace β
inst✝⁸ : MeasurableSpace β
inst✝⁷ : BorelSpace β
inst✝⁶ : TopologicalSpace γ
inst✝⁵ : MeasurableSpace γ
inst✝⁴ : BorelSpace γ
inst✝³ : MeasurableSpace δ
inst✝² : LinearOrder α
inst✝¹ : OrderTopology α
inst✝ : SecondCountableTopology α
f : δ → α
hf : ∀ (x : α), MeasurableSet (f ⁻¹' Ici x)
⊢ Measurable f

tactic: simp_rw [← compl_Ici, preimage_compl, MeasurableSet.compl_iff]
state_before: case hf
α : Type u_2
β : Type ?u.1090485
γ : Type ?u.1090488
γ₂ : Type ?u.1090491
δ : Type u_1
ι : Sort y
s t u : Set α
inst✝¹² : TopologicalSpace α
inst✝¹¹ : MeasurableSpace α
inst✝¹⁰ : BorelSpace α
inst✝⁹ : TopologicalSpace β
inst✝⁸ : MeasurableSpace β
inst✝⁷ : BorelSpace β
inst✝⁶ : TopologicalSpace γ
inst✝⁵ : MeasurableSpace γ
inst✝⁴ : BorelSpace γ
inst✝³ : MeasurableSpace δ
inst✝² : LinearOrder α
inst✝¹ : OrderTopology α
inst✝ : SecondCountableTopology α
f : δ → α
hf : ∀ (x : α), MeasurableSet (f ⁻¹' Ici x)
⊢ ∀ (x : α), MeasurableSet (f ⁻¹' Iio x)

tactic: assumption
state_before: case hf
α : Type u_2
β : Type ?u.1090485
γ : Type ?u.1090488
γ₂ : Type ?u.1090491
δ : Type u_1
ι : Sort y
s t u : Set α
inst✝¹² : TopologicalSpace α
inst✝¹¹ : MeasurableSpace α
inst✝¹⁰ : BorelSpace α
inst✝⁹ : TopologicalSpace β
inst✝⁸ : MeasurableSpace β
inst✝⁷ : BorelSpace β
inst✝⁶ : TopologicalSpace γ
inst✝⁵ : MeasurableSpace γ
inst✝⁴ : BorelSpace γ
inst✝³ : MeasurableSpace δ
inst✝² : LinearOrder α
inst✝¹ : OrderTopology α
inst✝ : SecondCountableTopology α
f : δ → α
hf : ∀ (x : α), MeasurableSet (f ⁻¹' Ici x)
⊢ ∀ (x : α), MeasurableSet (f ⁻¹' Ici x)
Theorem: SemidirectProduct.inl_left_mul_inr_right
File: Mathlib/GroupTheory/SemidirectProduct.lean

tactic: ext <;> simp
state_before: N : Type u_1
G : Type u_2
H : Type ?u.94951
inst✝² : Group N
inst✝¹ : Group G
inst✝ : Group H
φ : G →* MulAut N
x : N ⋊[φ] G
⊢ ↑inl x.left * ↑inr x.right = x
Theorem: BoxIntegral.Box.disjoint_withBotCoe
File: Mathlib/Analysis/BoxIntegral/Box/Basic.lean

tactic: simp only [disjoint_iff_inf_le, ← withBotCoe_subset_iff, coe_inf]
state_before: ι : Type u_1
I✝ J✝ : Box ι
x y : ι → ℝ
I J : WithBot (Box ι)
⊢ Disjoint ↑I ↑J ↔ Disjoint I J

tactic: rfl
state_before: ι : Type u_1
I✝ J✝ : Box ι
x y : ι → ℝ
I J : WithBot (Box ι)
⊢ ↑I ⊓ ↑J ≤ ⊥ ↔ ↑I ∩ ↑J ⊆ ↑⊥
Theorem: Polynomial.coe_lt_degree
File: Mathlib/Data/Polynomial/Degree/Lemmas.lean

tactic: by_cases h : p = 0
state_before: R : Type u
S : Type v
ι : Type w
a b : R
m n✝ : ℕ
inst✝¹ : Semiring R
p✝ q r : R[X]
inst✝ : Semiring S
p : R[X]
n : ℕ
⊢ ↑n < degree p ↔ n < natDegree p

tactic: simp [degree_eq_natDegree h, Nat.cast_withBot, WithBot.coe_lt_coe]
state_before: case neg
R : Type u
S : Type v
ι : Type w
a b : R
m n✝ : ℕ
inst✝¹ : Semiring R
p✝ q r : R[X]
inst✝ : Semiring S
p : R[X]
n : ℕ
h : ¬p = 0
⊢ ↑n < degree p ↔ n < natDegree p

tactic: simp [h]
state_before: case pos
R : Type u
S : Type v
ι : Type w
a b : R
m n✝ : ℕ
inst✝¹ : Semiring R
p✝ q r : R[X]
inst✝ : Semiring S
p : R[X]
n : ℕ
h : p = 0
⊢ ↑n < degree p ↔ n < natDegree p
Theorem: IsAddGroupHom.sub
File: Mathlib/Deprecated/Group.lean

tactic: simpa only [sub_eq_add_neg] using hf.add hg.neg
state_before: α✝ : Type u
β✝ : Type v
α : Type u_1
β : Type u_2
inst✝¹ : AddGroup α
inst✝ : AddCommGroup β
f g : α → β
hf : IsAddGroupHom f
hg : IsAddGroupHom g
⊢ IsAddGroupHom fun a => f a - g a
Theorem: Filter.lift_iInf_of_map_univ
File: Mathlib/Order/Filter/Lift.lean

tactic: cases isEmpty_or_nonempty ι
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.26409
ι : Sort u_3
f✝ f₁ f₂ : Filter α
g✝ g₁ g₂ : Set α → Filter β
f : ι → Filter α
g : Set α → Filter β
hg : ∀ (s t : Set α), g (s ∩ t) = g s ⊓ g t
hg' : g univ = ⊤
⊢ Filter.lift (iInf f) g = ⨅ (i : ι), Filter.lift (f i) g

tactic: simp [iInf_of_empty, hg']
state_before: case inl
α : Type u_1
β : Type u_2
γ : Type ?u.26409
ι : Sort u_3
f✝ f₁ f₂ : Filter α
g✝ g₁ g₂ : Set α → Filter β
f : ι → Filter α
g : Set α → Filter β
hg : ∀ (s t : Set α), g (s ∩ t) = g s ⊓ g t
hg' : g univ = ⊤
h✝ : IsEmpty ι
⊢ Filter.lift (iInf f) g = ⨅ (i : ι), Filter.lift (f i) g

tactic: exact lift_iInf hg
state_before: case inr
α : Type u_1
β : Type u_2
γ : Type ?u.26409
ι : Sort u_3
f✝ f₁ f₂ : Filter α
g✝ g₁ g₂ : Set α → Filter β
f : ι → Filter α
g : Set α → Filter β
hg : ∀ (s t : Set α), g (s ∩ t) = g s ⊓ g t
hg' : g univ = ⊤
h✝ : Nonempty ι
⊢ Filter.lift (iInf f) g = ⨅ (i : ι), Filter.lift (f i) g
Theorem: Behrend.sphere_zero_right
File: Mathlib/Combinatorics/Additive/Behrend.lean

tactic: simp [sphere]
state_before: α : Type ?u.23124
β : Type ?u.23127
n✝ d k✝ N : ℕ
x : Fin n✝ → ℕ
n k : ℕ
⊢ sphere (n + 1) 0 k = ∅
Theorem: MeasureTheory.lintegral_div_right_eq_self
File: Mathlib/MeasureTheory/Group/Integration.lean

tactic: simp_rw [div_eq_mul_inv]
state_before: 𝕜 : Type ?u.31885
M : Type ?u.31888
α : Type ?u.31891
G : Type u_1
E : Type ?u.31897
F : Type ?u.31900
inst✝⁷ : MeasurableSpace G
inst✝⁶ : NormedAddCommGroup E
inst✝⁵ : NormedSpace ℝ E
inst✝⁴ : CompleteSpace E
inst✝³ : NormedAddCommGroup F
μ : Measure G
f✝ : G → E
g✝ : G
inst✝² : Group G
inst✝¹ : MeasurableMul G
inst✝ : IsMulRightInvariant μ
f : G → ℝ≥0∞
g : G
⊢ (∫⁻ (x : G), f (x / g) ∂μ) = ∫⁻ (x : G), f x ∂μ

tactic: rw [lintegral_mul_right_eq_self f g⁻¹]
state_before: 𝕜 : Type ?u.31885
M : Type ?u.31888
α : Type ?u.31891
G : Type u_1
E : Type ?u.31897
F : Type ?u.31900
inst✝⁷ : MeasurableSpace G
inst✝⁶ : NormedAddCommGroup E
inst✝⁵ : NormedSpace ℝ E
inst✝⁴ : CompleteSpace E
inst✝³ : NormedAddCommGroup F
μ : Measure G
f✝ : G → E
g✝ : G
inst✝² : Group G
inst✝¹ : MeasurableMul G
inst✝ : IsMulRightInvariant μ
f : G → ℝ≥0∞
g : G
⊢ (∫⁻ (x : G), f (x * g⁻¹) ∂μ) = ∫⁻ (x : G), f x ∂μ