tasksource/leandojo huggingface dataset:
Theorem: Fin.liftFun_iff_succ
File: Mathlib/Data/Fin/Basic.lean

tactic: constructor
state_before: n m : ℕ
α : Type u_1
r : α → α → Prop
inst✝ : IsTrans α r
f : Fin (n + 1) → α
⊢ ((fun x x_1 => x < x_1) ⇒ r) f f ↔ ∀ (i : Fin n), r (f (↑castSucc i)) (f (succ i))

tactic: intro H i
state_before: case mp
n m : ℕ
α : Type u_1
r : α → α → Prop
inst✝ : IsTrans α r
f : Fin (n + 1) → α
⊢ ((fun x x_1 => x < x_1) ⇒ r) f f → ∀ (i : Fin n), r (f (↑castSucc i)) (f (succ i))

tactic: exact H i.castSucc_lt_succ
state_before: case mp
n m : ℕ
α : Type u_1
r : α → α → Prop
inst✝ : IsTrans α r
f : Fin (n + 1) → α
H : ((fun x x_1 => x < x_1) ⇒ r) f f
i : Fin n
⊢ r (f (↑castSucc i)) (f (succ i))

tactic: refine' fun H i => Fin.induction _ _
state_before: case mpr
n m : ℕ
α : Type u_1
r : α → α → Prop
inst✝ : IsTrans α r
f : Fin (n + 1) → α
⊢ (∀ (i : Fin n), r (f (↑castSucc i)) (f (succ i))) → ((fun x x_1 => x < x_1) ⇒ r) f f

tactic: exact fun h => (h.not_le (zero_le i)).elim
state_before: case mpr.refine'_1
n m : ℕ
α : Type u_1
r : α → α → Prop
inst✝ : IsTrans α r
f : Fin (n + 1) → α
H : ∀ (i : Fin n), r (f (↑castSucc i)) (f (succ i))
i : Fin (n + 1)
⊢ (fun x x_1 => x < x_1) i 0 → r (f i) (f 0)

tactic: intro j ihj hij
state_before: case mpr.refine'_2
n m : ℕ
α : Type u_1
r : α → α → Prop
inst✝ : IsTrans α r
f : Fin (n + 1) → α
H : ∀ (i : Fin n), r (f (↑castSucc i)) (f (succ i))
i : Fin (n + 1)
⊢ ∀ (i_1 : Fin n),
    ((fun x x_1 => x < x_1) i (↑castSucc i_1) → r (f i) (f (↑castSucc i_1))) →
      (fun x x_1 => x < x_1) i (succ i_1) → r (f i) (f (succ i_1))

tactic: rw [← le_castSucc_iff] at hij
state_before: case mpr.refine'_2
n m : ℕ
α : Type u_1
r : α → α → Prop
inst✝ : IsTrans α r
f : Fin (n + 1) → α
H : ∀ (i : Fin n), r (f (↑castSucc i)) (f (succ i))
i : Fin (n + 1)
j : Fin n
ihj : (fun x x_1 => x < x_1) i (↑castSucc j) → r (f i) (f (↑castSucc j))
hij : i < succ j
⊢ r (f i) (f (succ j))

tactic: rcases hij.eq_or_lt with (rfl | hlt)
state_before: case mpr.refine'_2
n m : ℕ
α : Type u_1
r : α → α → Prop
inst✝ : IsTrans α r
f : Fin (n + 1) → α
H : ∀ (i : Fin n), r (f (↑castSucc i)) (f (succ i))
i : Fin (n + 1)
j : Fin n
ihj : (fun x x_1 => x < x_1) i (↑castSucc j) → r (f i) (f (↑castSucc j))
hij : i ≤ ↑castSucc j
⊢ r (f i) (f (succ j))

tactic: exacts [H j, _root_.trans (ihj hlt) (H j)]
state_before: case mpr.refine'_2.inl
n m : ℕ
α : Type u_1
r : α → α → Prop
inst✝ : IsTrans α r
f : Fin (n + 1) → α
H : ∀ (i : Fin n), r (f (↑castSucc i)) (f (succ i))
j : Fin n
ihj : (fun x x_1 => x < x_1) (↑castSucc j) (↑castSucc j) → r (f (↑castSucc j)) (f (↑castSucc j))
hij : ↑castSucc j ≤ ↑castSucc j
⊢ r (f (↑castSucc j)) (f (succ j))

case mpr.refine'_2.inr
n m : ℕ
α : Type u_1
r : α → α → Prop
inst✝ : IsTrans α r
f : Fin (n + 1) → α
H : ∀ (i : Fin n), r (f (↑castSucc i)) (f (succ i))
i : Fin (n + 1)
j : Fin n
ihj : (fun x x_1 => x < x_1) i (↑castSucc j) → r (f i) (f (↑castSucc j))
hij : i ≤ ↑castSucc j
hlt : i < ↑castSucc j
⊢ r (f i) (f (succ j))
Theorem: Monotone.continuous_of_denseRange
File: Mathlib/Topology/Algebra/Order/MonotoneContinuity.lean

tactic: simp only [image_univ, h_dense.closure_eq, univ_mem]
state_before: α : Type u_2
β : Type u_1
inst✝⁶ : LinearOrder α
inst✝⁵ : TopologicalSpace α
inst✝⁴ : OrderTopology α
inst✝³ : LinearOrder β
inst✝² : TopologicalSpace β
inst✝¹ : OrderTopology β
inst✝ : DenselyOrdered β
f : α → β
h_mono : Monotone f
h_dense : DenseRange f
a : α
⊢ closure (f '' univ) ∈ 𝓝 (f a)
Theorem: Bool.and_true
File: src/lean/Init/SimpLemmas.lean

tactic: cases b <;> rfl
state_before: b : Bool
⊢ (b && true) = b
Theorem: Real.comap_exp_nhdsWithin_Ioi_zero
File: Mathlib/Analysis/SpecialFunctions/Exp.lean

tactic: rw [← map_exp_atBot, comap_map exp_injective]
state_before: α : Type ?u.151109
x y z : ℝ
l : Filter α
⊢ comap exp (𝓝[Set.Ioi 0] 0) = atBot
Theorem: Int.fract_add_fract_le
File: Mathlib/Algebra/Order/Floor.lean

tactic: rw [fract, fract, fract, sub_add_sub_comm, sub_add, sub_le_sub_iff_left]
state_before: F : Type ?u.151819
α : Type u_1
β : Type ?u.151825
inst✝¹ : LinearOrderedRing α
inst✝ : FloorRing α
z : ℤ
a✝ a b : α
⊢ fract a + fract b ≤ fract (a + b) + 1

tactic: exact_mod_cast le_floor_add_floor a b
state_before: F : Type ?u.151819
α : Type u_1
β : Type ?u.151825
inst✝¹ : LinearOrderedRing α
inst✝ : FloorRing α
z : ℤ
a✝ a b : α
⊢ ↑⌊a + b⌋ - 1 ≤ ↑⌊a⌋ + ↑⌊b⌋
Theorem: CategoryTheory.SplitMono.mono
File: Mathlib/CategoryTheory/EpiMono.lean

tactic: replace w := w =≫ sm.retraction
state_before: C : Type u₁
inst✝ : Category C
X Y : C
f : X ⟶ Y
sm : SplitMono f
Z✝ : C
g h : Z✝ ⟶ X
w : g ≫ f = h ≫ f
⊢ g = h

tactic: simpa using w
state_before: C : Type u₁
inst✝ : Category C
X Y : C
f : X ⟶ Y
sm : SplitMono f
Z✝ : C
g h : Z✝ ⟶ X
w : (g ≫ f) ≫ sm.retraction = (h ≫ f) ≫ sm.retraction
⊢ g = h
Theorem: List.Ico.append_consecutive
File: Mathlib/Data/List/Intervals.lean

tactic: dsimp only [Ico]
state_before: n m l : ℕ
hnm : n ≤ m
hml : m ≤ l
⊢ Ico n m ++ Ico m l = Ico n l

tactic: convert range'_append n (m-n) (l-m) 1 using 2
state_before: n m l : ℕ
hnm : n ≤ m
hml : m ≤ l
⊢ range' n (m - n) ++ range' m (l - m) = range' n (l - n)

tactic: rw [one_mul, add_tsub_cancel_of_le hnm]
state_before: case h.e'_2.h.e'_6
n m l : ℕ
hnm : n ≤ m
hml : m ≤ l
⊢ range' m (l - m) = range' (n + 1 * (m - n)) (l - m)

tactic: rw [tsub_add_tsub_cancel hml hnm]
state_before: case h.e'_3.h.e'_2
n m l : ℕ
hnm : n ≤ m
hml : m ≤ l
⊢ l - n = l - m + (m - n)
Theorem: Set.ncard_diff_add_ncard_eq_ncard
File: Mathlib/Data/Set/Ncard.lean

tactic: classical
rw [ncard_eq_toFinset_card _ ht, ncard_eq_toFinset_card _ (ht.subset h),
  ncard_eq_toFinset_card _ (ht.diff s), Finite.toFinset_diff]
refine' Finset.card_sdiff_add_card_eq_card _
rwa [Finite.toFinset_subset_toFinset]
state_before: α : Type u_1
β : Type ?u.123382
s t : Set α
a b x y : α
f : α → β
h : s ⊆ t
ht : autoParam (Set.Finite t) _auto✝
⊢ ncard (t \ s) + ncard s = ncard t

tactic: rw [ncard_eq_toFinset_card _ ht, ncard_eq_toFinset_card _ (ht.subset h),
  ncard_eq_toFinset_card _ (ht.diff s), Finite.toFinset_diff]
state_before: α : Type u_1
β : Type ?u.123382
s t : Set α
a b x y : α
f : α → β
h : s ⊆ t
ht : autoParam (Set.Finite t) _auto✝
⊢ ncard (t \ s) + ncard s = ncard t

tactic: refine' Finset.card_sdiff_add_card_eq_card _
state_before: α : Type u_1
β : Type ?u.123382
s t : Set α
a b x y : α
f : α → β
h : s ⊆ t
ht : autoParam (Set.Finite t) _auto✝
⊢ Finset.card (Finite.toFinset ?hs \ Finite.toFinset ?ht) + Finset.card (Finite.toFinset (_ : Set.Finite s)) =
    Finset.card (Finite.toFinset ht)

case hs
α : Type u_1
β : Type ?u.123382
s t : Set α
a b x y : α
f : α → β
h : s ⊆ t
ht : autoParam (Set.Finite t) _auto✝
⊢ Set.Finite t

case ht
α : Type u_1
β : Type ?u.123382
s t : Set α
a b x y : α
f : α → β
h : s ⊆ t
ht : autoParam (Set.Finite t) _auto✝
⊢ Set.Finite s

tactic: rwa [Finite.toFinset_subset_toFinset]
state_before: α : Type u_1
β : Type ?u.123382
s t : Set α
a b x y : α
f : α → β
h : s ⊆ t
ht : autoParam (Set.Finite t) _auto✝
⊢ Finite.toFinset (_ : Set.Finite s) ⊆ Finite.toFinset ht
Theorem: Ordinal.nfp_mul_opow_omega_add
File: Mathlib/SetTheory/Ordinal/FixedPoint.lean

tactic: apply le_antisymm
state_before: a c b : Ordinal
ha : 0 < a
hc : 0 < c
hca : c ≤ a ^ ω
⊢ nfp (fun x => a * x) (a ^ ω * b + c) = a ^ ω * succ b

tactic: apply nfp_le_fp (mul_isNormal ha).monotone
state_before: case a
a c b : Ordinal
ha : 0 < a
hc : 0 < c
hca : c ≤ a ^ ω
⊢ nfp (fun x => a * x) (a ^ ω * b + c) ≤ a ^ ω * succ b

tactic: rw [mul_succ]
state_before: case a.ab
a c b : Ordinal
ha : 0 < a
hc : 0 < c
hca : c ≤ a ^ ω
⊢ a ^ ω * b + c ≤ a ^ ω * succ b

tactic: apply add_le_add_left hca
state_before: case a.ab
a c b : Ordinal
ha : 0 < a
hc : 0 < c
hca : c ≤ a ^ ω
⊢ a ^ ω * b + c ≤ a ^ ω * b + a ^ ω

tactic: dsimp only
state_before: case a.h
a c b : Ordinal
ha : 0 < a
hc : 0 < c
hca : c ≤ a ^ ω
⊢ (fun x x_1 => x * x_1) a (a ^ ω * succ b) ≤ a ^ ω * succ b

tactic: rw [← mul_assoc, ← opow_one_add, one_add_omega]
state_before: case a.h
a c b : Ordinal
ha : 0 < a
hc : 0 < c
hca : c ≤ a ^ ω
⊢ a * (a ^ ω * succ b) ≤ a ^ ω * succ b

tactic: cases' mul_eq_right_iff_opow_omega_dvd.1 ((mul_isNormal ha).nfp_fp ((a^omega) * b + c)) with
  d hd
state_before: case a
a c b : Ordinal
ha : 0 < a
hc : 0 < c
hca : c ≤ a ^ ω
⊢ a ^ ω * succ b ≤ nfp (fun x => a * x) (a ^ ω * b + c)

tactic: rw [hd]
state_before: case a.intro
a c b : Ordinal
ha : 0 < a
hc : 0 < c
hca : c ≤ a ^ ω
d : Ordinal
hd : nfp ((fun x x_1 => x * x_1) a) (a ^ ω * b + c) = a ^ ω * d
⊢ a ^ ω * succ b ≤ nfp (fun x => a * x) (a ^ ω * b + c)

tactic: apply mul_le_mul_left'
state_before: case a.intro
a c b : Ordinal
ha : 0 < a
hc : 0 < c
hca : c ≤ a ^ ω
d : Ordinal
hd : nfp ((fun x x_1 => x * x_1) a) (a ^ ω * b + c) = a ^ ω * d
⊢ a ^ ω * succ b ≤ a ^ ω * d

tactic: have := le_nfp (Mul.mul a) ((a^omega) * b + c)
state_before: case a.intro.bc
a c b : Ordinal
ha : 0 < a
hc : 0 < c
hca : c ≤ a ^ ω
d : Ordinal
hd : nfp ((fun x x_1 => x * x_1) a) (a ^ ω * b + c) = a ^ ω * d
⊢ succ b ≤ d

tactic: erw [hd] at this
state_before: case a.intro.bc
a c b : Ordinal
ha : 0 < a
hc : 0 < c
hca : c ≤ a ^ ω
d : Ordinal
hd : nfp ((fun x x_1 => x * x_1) a) (a ^ ω * b + c) = a ^ ω * d
this : a ^ ω * b + c ≤ nfp (Mul.mul a) (a ^ ω * b + c)
⊢ succ b ≤ d

tactic: have := (add_lt_add_left hc ((a^omega) * b)).trans_le this
state_before: case a.intro.bc
a c b : Ordinal
ha : 0 < a
hc : 0 < c
hca : c ≤ a ^ ω
d : Ordinal
hd : nfp ((fun x x_1 => x * x_1) a) (a ^ ω * b + c) = a ^ ω * d
this : a ^ ω * b + c ≤ a ^ ω * d
⊢ succ b ≤ d

tactic: rw [add_zero, mul_lt_mul_iff_left (opow_pos omega ha)] at this
state_before: case a.intro.bc
a c b : Ordinal
ha : 0 < a
hc : 0 < c
hca : c ≤ a ^ ω
d : Ordinal
hd : nfp ((fun x x_1 => x * x_1) a) (a ^ ω * b + c) = a ^ ω * d
this✝ : a ^ ω * b + c ≤ a ^ ω * d
this : a ^ ω * b + 0 < a ^ ω * d
⊢ succ b ≤ d

tactic: rwa [succ_le_iff]
state_before: case a.intro.bc
a c b : Ordinal
ha : 0 < a
hc : 0 < c
hca : c ≤ a ^ ω
d : Ordinal
hd : nfp ((fun x x_1 => x * x_1) a) (a ^ ω * b + c) = a ^ ω * d
this✝ : a ^ ω * b + c ≤ a ^ ω * d
this : b < d
⊢ succ b ≤ d
Theorem: zpow_sub_one
File: Mathlib/Algebra/GroupPower/Lemmas.lean

tactic: rw [← zpow_add_one, sub_add_cancel]
state_before: α : Type ?u.112035
M : Type u
N : Type v
G : Type w
H : Type x
A : Type y
B : Type z
R : Type u₁
S : Type u₂
inst✝ : Group G
a : G
n : ℤ
⊢ a ^ (n - 1) * a * a⁻¹ = a ^ n * a⁻¹
Theorem: Real.rpow_nat_cast
File: Mathlib/Analysis/SpecialFunctions/Pow/Real.lean

tactic: simpa using rpow_int_cast x n
state_before: x✝ y z x : ℝ
n : ℕ
⊢ x ^ ↑n = x ^ n
Theorem: negSucc_zsmul
File: Mathlib/Algebra/Group/Defs.lean

tactic: rw [← ofNat_zsmul]
state_before: G✝ : Type ?u.52115
inst✝¹ : DivInvMonoid G✝
a✝ b : G✝
G : Type u_1
inst✝ : SubNegMonoid G
a : G
n : ℕ
⊢ Int.negSucc n • a = -((n + 1) • a)

tactic: exact SubNegMonoid.zsmul_neg' n a
state_before: G✝ : Type ?u.52115
inst✝¹ : DivInvMonoid G✝
a✝ b : G✝
G : Type u_1
inst✝ : SubNegMonoid G
a : G
n : ℕ
⊢ Int.negSucc n • a = -(↑(n + 1) • a)
Theorem: finprod_mem_biUnion
File: Mathlib/Algebra/BigOperators/Finprod.lean

tactic: haveI := hI.fintype
state_before: α : Type u_2
β : Type ?u.368420
ι : Type u_1
G : Type ?u.368426
M : Type u_3
N : Type ?u.368432
inst✝¹ : CommMonoid M
inst✝ : CommMonoid N
f g : α → M
a b : α
s t✝ : Set α
I : Set ι
t : ι → Set α
h : PairwiseDisjoint I t
hI : Set.Finite I
ht : ∀ (i : ι), i ∈ I → Set.Finite (t i)
⊢ (∏ᶠ (a : α) (_ : a ∈ ⋃ (x : ι) (_ : x ∈ I), t x), f a) = ∏ᶠ (i : ι) (_ : i ∈ I) (j : α) (_ : j ∈ t i), f j

tactic: rw [biUnion_eq_iUnion, finprod_mem_iUnion, ← finprod_set_coe_eq_finprod_mem]
state_before: α : Type u_2
β : Type ?u.368420
ι : Type u_1
G : Type ?u.368426
M : Type u_3
N : Type ?u.368432
inst✝¹ : CommMonoid M
inst✝ : CommMonoid N
f g : α → M
a b : α
s t✝ : Set α
I : Set ι
t : ι → Set α
h : PairwiseDisjoint I t
hI : Set.Finite I
ht : ∀ (i : ι), i ∈ I → Set.Finite (t i)
this : Fintype ↑I
⊢ (∏ᶠ (a : α) (_ : a ∈ ⋃ (x : ι) (_ : x ∈ I), t x), f a) = ∏ᶠ (i : ι) (_ : i ∈ I) (j : α) (_ : j ∈ t i), f j

tactic: exacts [fun x y hxy => h x.2 y.2 (Subtype.coe_injective.ne hxy), fun b => ht b b.2]
state_before: case h
α : Type u_2
β : Type ?u.368420
ι : Type u_1
G : Type ?u.368426
M : Type u_3
N : Type ?u.368432
inst✝¹ : CommMonoid M
inst✝ : CommMonoid N
f g : α → M
a b : α
s t✝ : Set α
I : Set ι
t : ι → Set α
h : PairwiseDisjoint I t
hI : Set.Finite I
ht : ∀ (i : ι), i ∈ I → Set.Finite (t i)
this : Fintype ↑I
⊢ Pairwise (Disjoint on fun x => t ↑x)

case ht
α : Type u_2
β : Type ?u.368420
ι : Type u_1
G : Type ?u.368426
M : Type u_3
N : Type ?u.368432
inst✝¹ : CommMonoid M
inst✝ : CommMonoid N
f g : α → M
a b : α
s t✝ : Set α
I : Set ι
t : ι → Set α
h : PairwiseDisjoint I t
hI : Set.Finite I
ht : ∀ (i : ι), i ∈ I → Set.Finite (t i)
this : Fintype ↑I
⊢ ∀ (i : ↑I), Set.Finite (t ↑i)
Theorem: SimplicialObject.Splitting.ιSummand_epi_naturality
File: Mathlib/AlgebraicTopology/SplitSimplicialObject.lean

tactic: dsimp [ιSummand]
state_before: C : Type u_2
inst✝² : Category C
inst✝¹ : HasFiniteCoproducts C
X Y : SimplicialObject C
s : Splitting X
Δ₁ Δ₂ : SimplexCategoryᵒᵖ
A : IndexSet Δ₁
p : Δ₁ ⟶ Δ₂
inst✝ : Epi p.unop
⊢ ιSummand s A ≫ X.map p = ιSummand s (IndexSet.epiComp A p)

tactic: erw [colimit.ι_desc, colimit.ι_desc, Cofan.mk_ι_app, Cofan.mk_ι_app]
state_before: C : Type u_2
inst✝² : Category C
inst✝¹ : HasFiniteCoproducts C
X Y : SimplicialObject C
s : Splitting X
Δ₁ Δ₂ : SimplexCategoryᵒᵖ
A : IndexSet Δ₁
p : Δ₁ ⟶ Δ₂
inst✝ : Epi p.unop
⊢ (ιCoprod s.N A ≫ map X s.ι Δ₁) ≫ X.map p = ιCoprod s.N (IndexSet.epiComp A p) ≫ map X s.ι Δ₂

tactic: dsimp only [IndexSet.epiComp, IndexSet.e]
state_before: C : Type u_2
inst✝² : Category C
inst✝¹ : HasFiniteCoproducts C
X Y : SimplicialObject C
s : Splitting X
Δ₁ Δ₂ : SimplexCategoryᵒᵖ
A : IndexSet Δ₁
p : Δ₁ ⟶ Δ₂
inst✝ : Epi p.unop
⊢ (ι s (len { as := A }.as.fst.unop) ≫ X.map (IndexSet.e { as := A }.as).op) ≫ X.map p =
    ι s (len { as := IndexSet.epiComp A p }.as.fst.unop) ≫ X.map (IndexSet.e { as := IndexSet.epiComp A p }.as).op

tactic: rw [op_comp, X.map_comp, assoc, Quiver.Hom.op_unop]
state_before: C : Type u_2
inst✝² : Category C
inst✝¹ : HasFiniteCoproducts C
X Y : SimplicialObject C
s : Splitting X
Δ₁ Δ₂ : SimplexCategoryᵒᵖ
A : IndexSet Δ₁
p : Δ₁ ⟶ Δ₂
inst✝ : Epi p.unop
⊢ (ι s (len A.fst.unop) ≫ X.map (↑A.snd).op) ≫ X.map p = ι s (len A.fst.unop) ≫ X.map (p.unop ≫ ↑A.snd).op
Theorem: Turing.ListBlank.append_mk
File: Mathlib/Computability/TuringMachine.lean

tactic: induction l₁ <;>
  simp only [*, ListBlank.append, List.nil_append, List.cons_append, ListBlank.cons_mk]
state_before: Γ : Type u_1
inst✝ : Inhabited Γ
l₁ l₂ : List Γ
⊢ append l₁ (mk l₂) = mk (l₁ ++ l₂)
Theorem: ENNReal.iSup_zero_eq_zero
File: Mathlib/Data/Real/ENNReal.lean

tactic: simp
state_before: α : Type ?u.869401
β : Type ?u.869404
a b c d : ℝ≥0∞
r p q : ℝ≥0
ι : Sort u_1
⊢ (⨆ (x : ι), 0) = 0
Theorem: Real.sin_eq_zero_iff
File: Mathlib/Analysis/SpecialFunctions/Trigonometric/Basic.lean

tactic: simp [sub_eq_add_neg, sin_add, h, sin_int_mul_pi]
state_before: x : ℝ
h : sin x = 0
h₃ : x - ↑⌊x / π⌋ * π > 0
⊢ 0 = sin (x - ↑⌊x / π⌋ * π)
Theorem: HilbertBasis.repr_self
File: Mathlib/Analysis/InnerProductSpace/l2Space.lean

tactic: simp
state_before: ι : Type u_1
𝕜 : Type u_2
inst✝⁴ : IsROrC 𝕜
E : Type u_3
inst✝³ : NormedAddCommGroup E
inst✝² : InnerProductSpace 𝕜 E
cplt : CompleteSpace E
G : ι → Type ?u.697102
inst✝¹ : (i : ι) → NormedAddCommGroup (G i)
inst✝ : (i : ι) → InnerProductSpace 𝕜 (G i)
b : HilbertBasis ι 𝕜 E
i : ι
⊢ ↑b.repr ((fun i => ↑(LinearIsometryEquiv.symm b.repr) (lp.single 2 i 1)) i) = lp.single 2 i 1
Theorem: Finsupp.tail_cons
File: Mathlib/Data/Finsupp/Fin.lean

tactic: simp only [tail_apply, cons_succ]
state_before: n : ℕ
i : Fin n
M : Type u_1
inst✝ : Zero M
y : M
t : Fin (n + 1) →₀ M
s : Fin n →₀ M
k : Fin n
⊢ ↑(tail (cons y s)) k = ↑s k
Theorem: IsCoatom.isMaximal
File: Mathlib/Order/Ideal.lean

tactic: simp [hI.2 _ hJ]
state_before: P : Type u_1
inst✝² : LE P
inst✝¹ : IsDirected P fun x x_1 => x ≤ x_1
inst✝ : Nonempty P
I : Ideal P
hI : IsCoatom I
src✝ : IsProper I := IsCoatom.isProper hI
x✝ : Ideal P
hJ : I < x✝
⊢ ↑x✝ = univ
Theorem: upperSemicontinuousAt_sum
File: Mathlib/Topology/Semicontinuous.lean

tactic: simp_rw [← upperSemicontinuousWithinAt_univ_iff] at *
state_before: α : Type u_2
inst✝⁵ : TopologicalSpace α
β : Type ?u.204861
inst✝⁴ : Preorder β
f✝ g : α → β
x : α
s t : Set α
y z : β
ι : Type u_1
γ : Type u_3
inst✝³ : LinearOrderedAddCommMonoid γ
inst✝² : TopologicalSpace γ
inst✝¹ : OrderTopology γ
inst✝ : ContinuousAdd γ
f : ι → α → γ
a : Finset ι
ha : ∀ (i : ι), i ∈ a → UpperSemicontinuousAt (f i) x
⊢ UpperSemicontinuousAt (fun z => ∑ i in a, f i z) x

tactic: exact upperSemicontinuousWithinAt_sum ha
state_before: α : Type u_2
inst✝⁵ : TopologicalSpace α
β : Type ?u.204861
inst✝⁴ : Preorder β
f✝ g : α → β
x : α
s t : Set α
y z : β
ι : Type u_1
γ : Type u_3
inst✝³ : LinearOrderedAddCommMonoid γ
inst✝² : TopologicalSpace γ
inst✝¹ : OrderTopology γ
inst✝ : ContinuousAdd γ
f : ι → α → γ
a : Finset ι
ha : ∀ (i : ι), i ∈ a → UpperSemicontinuousWithinAt (f i) univ x
⊢ UpperSemicontinuousWithinAt (fun z => ∑ i in a, f i z) univ x
Theorem: Fin.succAbove_eq_zero_iff
File: Mathlib/Data/Fin/Basic.lean

tactic: simp only [← succAbove_ne_zero_zero ha, OrderEmbedding.eq_iff_eq, iff_self]
state_before: n m : ℕ
inst✝ : NeZero n
a : Fin (n + 1)
b : Fin n
ha : a ≠ 0
⊢ ↑(succAbove a) b = 0 ↔ b = 0
Theorem: MeasureTheory.Memℒp.im
File: Mathlib/MeasureTheory/Function/LpSeminorm.lean

tactic: have : ∀ x, ‖IsROrC.im (f x)‖ ≤ 1 * ‖f x‖ := by
  intro x
  rw [one_mul]
  exact IsROrC.norm_im_le_norm (f x)
state_before: α : Type u_2
E : Type ?u.6150522
F : Type ?u.6150525
G : Type ?u.6150528
m m0 : MeasurableSpace α
p : ℝ≥0∞
q : ℝ
μ ν : Measure α
inst✝³ : NormedAddCommGroup E
inst✝² : NormedAddCommGroup F
inst✝¹ : NormedAddCommGroup G
𝕜 : Type u_1
inst✝ : IsROrC 𝕜
f : α → 𝕜
hf : Memℒp f p
⊢ Memℒp (fun x => ↑IsROrC.im (f x)) p

tactic: refine' hf.of_le_mul _ (eventually_of_forall this)
state_before: α : Type u_2
E : Type ?u.6150522
F : Type ?u.6150525
G : Type ?u.6150528
m m0 : MeasurableSpace α
p : ℝ≥0∞
q : ℝ
μ ν : Measure α
inst✝³ : NormedAddCommGroup E
inst✝² : NormedAddCommGroup F
inst✝¹ : NormedAddCommGroup G
𝕜 : Type u_1
inst✝ : IsROrC 𝕜
f : α → 𝕜
hf : Memℒp f p
this : ∀ (x : α), ‖↑IsROrC.im (f x)‖ ≤ 1 * ‖f x‖
⊢ Memℒp (fun x => ↑IsROrC.im (f x)) p

tactic: exact IsROrC.continuous_im.comp_aestronglyMeasurable hf.1
state_before: α : Type u_2
E : Type ?u.6150522
F : Type ?u.6150525
G : Type ?u.6150528
m m0 : MeasurableSpace α
p : ℝ≥0∞
q : ℝ
μ ν : Measure α
inst✝³ : NormedAddCommGroup E
inst✝² : NormedAddCommGroup F
inst✝¹ : NormedAddCommGroup G
𝕜 : Type u_1
inst✝ : IsROrC 𝕜
f : α → 𝕜
hf : Memℒp f p
this : ∀ (x : α), ‖↑IsROrC.im (f x)‖ ≤ 1 * ‖f x‖
⊢ AEStronglyMeasurable (fun x => ↑IsROrC.im (f x)) μ

tactic: intro x
state_before: α : Type u_2
E : Type ?u.6150522
F : Type ?u.6150525
G : Type ?u.6150528
m m0 : MeasurableSpace α
p : ℝ≥0∞
q : ℝ
μ ν : Measure α
inst✝³ : NormedAddCommGroup E
inst✝² : NormedAddCommGroup F
inst✝¹ : NormedAddCommGroup G
𝕜 : Type u_1
inst✝ : IsROrC 𝕜
f : α → 𝕜
hf : Memℒp f p
⊢ ∀ (x : α), ‖↑IsROrC.im (f x)‖ ≤ 1 * ‖f x‖

tactic: rw [one_mul]
state_before: α : Type u_2
E : Type ?u.6150522
F : Type ?u.6150525
G : Type ?u.6150528
m m0 : MeasurableSpace α
p : ℝ≥0∞
q : ℝ
μ ν : Measure α
inst✝³ : NormedAddCommGroup E
inst✝² : NormedAddCommGroup F
inst✝¹ : NormedAddCommGroup G
𝕜 : Type u_1
inst✝ : IsROrC 𝕜
f : α → 𝕜
hf : Memℒp f p
x : α
⊢ ‖↑IsROrC.im (f x)‖ ≤ 1 * ‖f x‖

tactic: exact IsROrC.norm_im_le_norm (f x)
state_before: α : Type u_2
E : Type ?u.6150522
F : Type ?u.6150525
G : Type ?u.6150528
m m0 : MeasurableSpace α
p : ℝ≥0∞
q : ℝ
μ ν : Measure α
inst✝³ : NormedAddCommGroup E
inst✝² : NormedAddCommGroup F
inst✝¹ : NormedAddCommGroup G
𝕜 : Type u_1
inst✝ : IsROrC 𝕜
f : α → 𝕜
hf : Memℒp f p
x : α
⊢ ‖↑IsROrC.im (f x)‖ ≤ ‖f x‖
Theorem: CategoryTheory.NatIso.cancel_natIso_hom_left
File: Mathlib/CategoryTheory/NatIso.lean

tactic: simp only [cancel_epi, refl]
state_before: C : Type u₁
inst✝² : Category C
D : Type u₂
inst✝¹ : Category D
E : Type u₃
inst✝ : Category E
F G : C ⥤ D
α : F ≅ G
X : C
Z : D
g g' : G.obj X ⟶ Z
⊢ α.hom.app X ≫ g = α.hom.app X ≫ g' ↔ g = g'
Theorem: compRel_assoc
File: Mathlib/Topology/UniformSpace/Basic.lean

tactic: ext ⟨a, b⟩
state_before: α : Type ua
β : Type ub
γ : Type uc
δ : Type ud
ι : Sort ?u.12185
r s t : Set (α × α)
⊢ r ○ s ○ t = r ○ (s ○ t)

tactic: simp only [mem_compRel]
state_before: case h.mk
α : Type ua
β : Type ub
γ : Type uc
δ : Type ud
ι : Sort ?u.12185
r s t : Set (α × α)
a b : α
⊢ (a, b) ∈ r ○ s ○ t ↔ (a, b) ∈ r ○ (s ○ t)

tactic: tauto
state_before: case h.mk
α : Type ua
β : Type ub
γ : Type uc
δ : Type ud
ι : Sort ?u.12185
r s t : Set (α × α)
a b : α
⊢ (∃ z, (∃ z_1, (a, z_1) ∈ r ∧ (z_1, z) ∈ s) ∧ (z, b) ∈ t) ↔ ∃ z, (a, z) ∈ r ∧ ∃ z_1, (z, z_1) ∈ s ∧ (z_1, b) ∈ t
Theorem: Additive.isNormalAddSubgroup_iff
File: Mathlib/Deprecated/Subgroup.lean

tactic: rintro ⟨h₁, h₂⟩
state_before: G : Type u_1
H : Type ?u.20782
A : Type ?u.20785
a a₁ a₂ b c : G
inst✝ : Group G
s : Set G
⊢ IsNormalAddSubgroup s → IsNormalSubgroup s

tactic: exact @IsNormalSubgroup.mk G _ _ (Additive.isAddSubgroup_iff.1 h₁) @h₂
state_before: case mk
G : Type u_1
H : Type ?u.20782
A : Type ?u.20785
a a₁ a₂ b c : G
inst✝ : Group G
s : Set G
h₁ : IsAddSubgroup s
h₂ : ∀ (n : Additive G), n ∈ s → ∀ (g : Additive G), g + n + -g ∈ s
⊢ IsNormalSubgroup s
Theorem: Pell.pellZd_sub
File: Mathlib/NumberTheory/PellMatiyasevic.lean

tactic: let t := pellZd_add a1 n (m - n)
state_before: a : ℕ
a1 : 1 < a
m n : ℕ
h : n ≤ m
⊢ pellZd a1 (m - n) = pellZd a1 m * star (pellZd a1 n)

tactic: rw [add_tsub_cancel_of_le h] at t
state_before: a : ℕ
a1 : 1 < a
m n : ℕ
h : n ≤ m
t : pellZd a1 (n + (m - n)) = pellZd a1 n * pellZd a1 (m - n) := pellZd_add a1 n (m - n)
⊢ pellZd a1 (m - n) = pellZd a1 m * star (pellZd a1 n)

tactic: rw [t, mul_comm (pellZd _ n) _, mul_assoc, isPell_norm.1 (isPell_pellZd _ _), mul_one]
state_before: a : ℕ
a1 : 1 < a
m n : ℕ
h : n ≤ m
t : pellZd a1 m = pellZd a1 n * pellZd a1 (m - n)
⊢ pellZd a1 (m - n) = pellZd a1 m * star (pellZd a1 n)
Theorem: List.set_eq_take_cons_drop
File: Mathlib/Data/List/Basic.lean

tactic: rw [set_eq_modifyNth, modifyNth_eq_take_cons_drop _ h]
state_before: ι : Type ?u.221077
α : Type u
β : Type v
γ : Type w
δ : Type x
l₁ l₂ : List α
a : α
n : ℕ
l : List α
h : n < length l
⊢ set l n a = take n l ++ a :: drop (n + 1) l
Theorem: Rat.add_comm
File: Mathlib/Data/Rat/Defs.lean

tactic: simp [h₁, h₂, add_comm, mul_comm]
state_before: a b c : ℚ
n₁ : ℤ
d₁ : ℕ
h₁ : d₁ ≠ 0
n₂ : ℤ
d₂ : ℕ
h₂ : d₂ ≠ 0
⊢ n₁ /. ↑d₁ + n₂ /. ↑d₂ = n₂ /. ↑d₂ + n₁ /. ↑d₁