tasksource/leandojo huggingface dataset:
Theorem: Matrix.vecMul_add
File: Mathlib/Data/Matrix/Basic.lean

tactic: ext
state_before: l : Type ?u.857315
m : Type u_1
n : Type u_2
o : Type ?u.857324
m' : o → Type ?u.857329
n' : o → Type ?u.857334
R : Type ?u.857337
S : Type ?u.857340
α : Type v
β : Type w
γ : Type ?u.857347
inst✝¹ : NonUnitalNonAssocSemiring α
inst✝ : Fintype m
A B : Matrix m n α
x : m → α
⊢ vecMul x (A + B) = vecMul x A + vecMul x B

tactic: apply dotProduct_add
state_before: case h
l : Type ?u.857315
m : Type u_1
n : Type u_2
o : Type ?u.857324
m' : o → Type ?u.857329
n' : o → Type ?u.857334
R : Type ?u.857337
S : Type ?u.857340
α : Type v
β : Type w
γ : Type ?u.857347
inst✝¹ : NonUnitalNonAssocSemiring α
inst✝ : Fintype m
A B : Matrix m n α
x : m → α
x✝ : n
⊢ vecMul x (A + B) x✝ = (vecMul x A + vecMul x B) x✝
Theorem: List.cons_getElem_succ
File: src/lean/Init/Data/List/Basic.lean

tactic: rfl
state_before: α : Type u
β : Type v
γ : Type w
a : α
as : List α
i : Nat
h : i + 1 < length (a :: as)
⊢ getElem (a :: as) (i + 1) h = getElem as i (_ : i < length as)
Theorem: interior_mem_uniformity
File: Mathlib/Topology/UniformSpace/Basic.lean

tactic: rw [uniformity_eq_uniformity_interior]
state_before: α : Type ua
β : Type ub
γ : Type uc
δ : Type ud
ι : Sort ?u.91137
inst✝ : UniformSpace α
s : Set (α × α)
hs : s ∈ 𝓤 α
⊢ interior s ∈ 𝓤 α

tactic: exact mem_lift' hs
state_before: α : Type ua
β : Type ub
γ : Type uc
δ : Type ud
ι : Sort ?u.91137
inst✝ : UniformSpace α
s : Set (α × α)
hs : s ∈ 𝓤 α
⊢ interior s ∈ Filter.lift' (𝓤 α) interior
Theorem: measurable_findGreatest
File: Mathlib/MeasureTheory/MeasurableSpace.lean

tactic: refine' measurable_findGreatest' fun k hk => _
state_before: α : Type u_1
β : Type ?u.52344
γ : Type ?u.52347
δ : Type ?u.52350
δ' : Type ?u.52353
ι : Sort uι
s t u : Set α
inst✝¹ : MeasurableSpace α
p : α → ℕ → Prop
inst✝ : (x : α) → DecidablePred (p x)
N : ℕ
hN : ∀ (k : ℕ), k ≤ N → MeasurableSet {x | p x k}
⊢ Measurable fun x => Nat.findGreatest (p x) N

tactic: simp only [Nat.findGreatest_eq_iff, setOf_and, setOf_forall, ← compl_setOf]
state_before: α : Type u_1
β : Type ?u.52344
γ : Type ?u.52347
δ : Type ?u.52350
δ' : Type ?u.52353
ι : Sort uι
s t u : Set α
inst✝¹ : MeasurableSpace α
p : α → ℕ → Prop
inst✝ : (x : α) → DecidablePred (p x)
N : ℕ
hN : ∀ (k : ℕ), k ≤ N → MeasurableSet {x | p x k}
k : ℕ
hk : k ≤ N
⊢ MeasurableSet {x | Nat.findGreatest (p x) N = k}

tactic: repeat' apply_rules [MeasurableSet.inter, MeasurableSet.const, MeasurableSet.iInter,
  MeasurableSet.compl, hN] <;> try intros
state_before: α : Type u_1
β : Type ?u.52344
γ : Type ?u.52347
δ : Type ?u.52350
δ' : Type ?u.52353
ι : Sort uι
s t u : Set α
inst✝¹ : MeasurableSpace α
p : α → ℕ → Prop
inst✝ : (x : α) → DecidablePred (p x)
N : ℕ
hN : ∀ (k : ℕ), k ≤ N → MeasurableSet {x | p x k}
k : ℕ
hk : k ≤ N
⊢ MeasurableSet ({a | k ≤ N} ∩ ((⋂ (_ : k ≠ 0), {x | p x k}) ∩ ⋂ (i : ℕ) (_ : k < i) (_ : i ≤ N), {a | p a i}ᶜ))

tactic: apply_rules [MeasurableSet.inter, MeasurableSet.const, MeasurableSet.iInter,
MeasurableSet.compl, hN] <;> try intros
state_before: case h₂.h₂
α : Type u_1
β : Type ?u.52344
γ : Type ?u.52347
δ : Type ?u.52350
δ' : Type ?u.52353
ι : Sort uι
s t u : Set α
inst✝¹ : MeasurableSpace α
p : α → ℕ → Prop
inst✝ : (x : α) → DecidablePred (p x)
N : ℕ
hN : ∀ (k : ℕ), k ≤ N → MeasurableSet {x | p x k}
k : ℕ
hk : k ≤ N
b✝² : ℕ
b✝¹ : k < b✝²
b✝ : b✝² ≤ N
⊢ MeasurableSet ({a | p a b✝²}ᶜ)

tactic: intros
state_before: case h₂.h₂
α : Type u_1
β : Type ?u.52344
γ : Type ?u.52347
δ : Type ?u.52350
δ' : Type ?u.52353
ι : Sort uι
s t u : Set α
inst✝¹ : MeasurableSpace α
p : α → ℕ → Prop
inst✝ : (x : α) → DecidablePred (p x)
N : ℕ
hN : ∀ (k : ℕ), k ≤ N → MeasurableSet {x | p x k}
k : ℕ
hk : k ≤ N
b✝¹ : ℕ
b✝ : k < b✝¹
⊢ b✝¹ ≤ N → MeasurableSet ({a | p a b✝¹}ᶜ)
Theorem: coe_int_mem
File: Mathlib/RingTheory/Subring/Basic.lean

tactic: simp only [← zsmul_one, zsmul_mem, one_mem]
state_before: R : Type u
S : Type v
T : Type w
inst✝¹ : Ring R
inst✝ : SetLike S R
hSR : SubringClass S R
s : S
n : ℤ
⊢ ↑n ∈ s
Theorem: LinearMap.det_zero
File: Mathlib/LinearAlgebra/Determinant.lean

tactic: simp only [← zero_smul 𝕜 (1 : M →ₗ[𝕜] M), det_smul, mul_one, MonoidHom.map_one]
state_before: R : Type ?u.899641
inst✝¹² : CommRing R
M✝ : Type ?u.899647
inst✝¹¹ : AddCommGroup M✝
inst✝¹⁰ : Module R M✝
M' : Type ?u.900232
inst✝⁹ : AddCommGroup M'
inst✝⁸ : Module R M'
ι : Type ?u.900774
inst✝⁷ : DecidableEq ι
inst✝⁶ : Fintype ι
e : Basis ι R M✝
A : Type ?u.901252
inst✝⁵ : CommRing A
inst✝⁴ : Module A M✝
κ : Type ?u.901750
inst✝³ : Fintype κ
𝕜 : Type u_1
inst✝² : Field 𝕜
M : Type u_2
inst✝¹ : AddCommGroup M
inst✝ : Module 𝕜 M
⊢ ↑LinearMap.det 0 = 0 ^ FiniteDimensional.finrank 𝕜 M
Theorem: Submonoid.mul_leftInvEquiv
File: Mathlib/GroupTheory/Submonoid/Inverses.lean

tactic: simp only [leftInvEquiv_apply, fromCommLeftInv, mul_fromLeftInv]
state_before: M : Type u_1
inst✝ : CommMonoid M
S : Submonoid M
hS : S ≤ IsUnit.submonoid M
x : { x // x ∈ leftInv S }
⊢ ↑x * ↑(↑(leftInvEquiv S hS) x) = 1
Theorem: Num.div_zero
File: Mathlib/Data/Num/Lemmas.lean

tactic: cases n
state_before: n : Num
⊢ div n 0 = 0

tactic: rfl
state_before: case zero

⊢ div zero 0 = 0

tactic: simp [Num.div]
state_before: case pos
a✝ : PosNum
⊢ div (pos a✝) 0 = 0
Theorem: ZMod.nat_coe_zmod_eq_iff
File: Mathlib/Data/ZMod/Basic.lean

tactic: constructor
state_before: p n : ℕ
z : ZMod p
inst✝ : NeZero p
⊢ ↑n = z ↔ ∃ k, n = val z + p * k

tactic: rintro rfl
state_before: case mp
p n : ℕ
z : ZMod p
inst✝ : NeZero p
⊢ ↑n = z → ∃ k, n = val z + p * k

tactic: refine' ⟨n / p, _⟩
state_before: case mp
p n : ℕ
inst✝ : NeZero p
⊢ ∃ k, n = val ↑n + p * k

tactic: rw [val_nat_cast, Nat.mod_add_div]
state_before: case mp
p n : ℕ
inst✝ : NeZero p
⊢ n = val ↑n + p * (n / p)

tactic: rintro ⟨k, rfl⟩
state_before: case mpr
p n : ℕ
z : ZMod p
inst✝ : NeZero p
⊢ (∃ k, n = val z + p * k) → ↑n = z

tactic: rw [Nat.cast_add, nat_cast_zmod_val, Nat.cast_mul, nat_cast_self, MulZeroClass.zero_mul,
  add_zero]
state_before: case mpr.intro
p : ℕ
z : ZMod p
inst✝ : NeZero p
k : ℕ
⊢ ↑(val z + p * k) = z
Theorem: PowerBasis.minpolyGen_map
File: Mathlib/RingTheory/PowerBasis.lean

tactic: dsimp only [minpolyGen, map_dim]
state_before: R : Type ?u.698148
S : Type u_2
T : Type ?u.698154
inst✝¹¹ : CommRing R
inst✝¹⁰ : Ring S
inst✝⁹ : Algebra R S
A : Type u_1
B : Type ?u.698460
inst✝⁸ : CommRing A
inst✝⁷ : CommRing B
inst✝⁶ : IsDomain B
inst✝⁵ : Algebra A B
K : Type ?u.698882
inst✝⁴ : Field K
S' : Type u_3
inst✝³ : CommRing S'
inst✝² : Algebra R S'
inst✝¹ : Algebra A S
inst✝ : Algebra A S'
pb : PowerBasis A S
e : S ≃ₐ[A] S'
⊢ minpolyGen (map pb e) = minpolyGen pb

tactic: simp only [LinearEquiv.trans_apply, map_basis, Basis.map_repr, map_gen,
  AlgEquiv.toLinearEquiv_apply, e.toLinearEquiv_symm, AlgEquiv.map_pow,
  AlgEquiv.symm_apply_apply, sub_right_inj]
state_before: R : Type ?u.698148
S : Type u_2
T : Type ?u.698154
inst✝¹¹ : CommRing R
inst✝¹⁰ : Ring S
inst✝⁹ : Algebra R S
A : Type u_1
B : Type ?u.698460
inst✝⁸ : CommRing A
inst✝⁷ : CommRing B
inst✝⁶ : IsDomain B
inst✝⁵ : Algebra A B
K : Type ?u.698882
inst✝⁴ : Field K
S' : Type u_3
inst✝³ : CommRing S'
inst✝² : Algebra R S'
inst✝¹ : Algebra A S
inst✝ : Algebra A S'
pb : PowerBasis A S
e : S ≃ₐ[A] S'
⊢ (X ^ pb.dim - Finset.sum Finset.univ fun i => ↑C (↑(↑(map pb e).basis.repr ((map pb e).gen ^ pb.dim)) i) * X ^ ↑i) =
    X ^ pb.dim - Finset.sum Finset.univ fun i => ↑C (↑(↑pb.basis.repr (pb.gen ^ pb.dim)) i) * X ^ ↑i
Theorem: String.Iterator.ValidFor.setCurr'
File: Std/Data/String/Lemmas.lean

tactic: cases h.out'
state_before: l r : List Char
c : Char
it : Iterator
h : ValidFor l r it
⊢ ValidFor l (List.modifyHead (fun x => c) r) (setCurr it c)

tactic: simp [Iterator.setCurr]
state_before: case refl
l r : List Char
c : Char
h : ValidFor l r { s := { data := List.reverse l ++ r }, i := { byteIdx := utf8Len (List.reverse l) } }
⊢ ValidFor l (List.modifyHead (fun x => c) r)
    (setCurr { s := { data := List.reverse l ++ r }, i := { byteIdx := utf8Len (List.reverse l) } } c)

tactic: refine .of_eq _ ?_ (by simp)
state_before: case refl
l r : List Char
c : Char
h : ValidFor l r { s := { data := List.reverse l ++ r }, i := { byteIdx := utf8Len (List.reverse l) } }
⊢ ValidFor l
    (match r with
    | [] => []
    | a :: l => c :: l)
    { s := set { data := List.reverse l ++ r } { byteIdx := utf8Len l } c, i := { byteIdx := utf8Len l } }

tactic: have := set_of_valid l.reverse r c
state_before: case refl
l r : List Char
c : Char
h : ValidFor l r { s := { data := List.reverse l ++ r }, i := { byteIdx := utf8Len (List.reverse l) } }
⊢ { s := set { data := List.reverse l ++ r } { byteIdx := utf8Len l } c, i := { byteIdx := utf8Len l } }.s.data =
    List.reverseAux l
      (match r with
      | [] => []
      | a :: l => c :: l)

tactic: simp at this
state_before: case refl
l r : List Char
c : Char
h : ValidFor l r { s := { data := List.reverse l ++ r }, i := { byteIdx := utf8Len (List.reverse l) } }
this :
  set { data := List.reverse l ++ r } { byteIdx := utf8Len (List.reverse l) } c =
    { data := List.reverse l ++ List.modifyHead (fun x => c) r }
⊢ { s := set { data := List.reverse l ++ r } { byteIdx := utf8Len l } c, i := { byteIdx := utf8Len l } }.s.data =
    List.reverseAux l
      (match r with
      | [] => []
      | a :: l => c :: l)

tactic: simp [List.reverseAux_eq, this]
state_before: case refl
l r : List Char
c : Char
h : ValidFor l r { s := { data := List.reverse l ++ r }, i := { byteIdx := utf8Len (List.reverse l) } }
this :
  set { data := List.reverse l ++ r } { byteIdx := utf8Len l } c =
    {
      data :=
        List.reverse l ++
          match r with
          | [] => []
          | a :: l => c :: l }
⊢ { s := set { data := List.reverse l ++ r } { byteIdx := utf8Len l } c, i := { byteIdx := utf8Len l } }.s.data =
    List.reverseAux l
      (match r with
      | [] => []
      | a :: l => c :: l)

tactic: simp
state_before: l r : List Char
c : Char
h : ValidFor l r { s := { data := List.reverse l ++ r }, i := { byteIdx := utf8Len (List.reverse l) } }
⊢ { s := set { data := List.reverse l ++ r } { byteIdx := utf8Len l } c, i := { byteIdx := utf8Len l } }.i.byteIdx =
    utf8Len l
Theorem: int_prod_range_nonneg
File: Mathlib/Analysis/Convex/SpecificFunctions/Deriv.lean

tactic: rcases hn with ⟨n, rfl⟩
state_before: m : ℤ
n : ℕ
hn : Even n
⊢ 0 ≤ ∏ k in Finset.range n, (m - ↑k)

tactic: induction' n with n ihn
state_before: case intro
m : ℤ
n : ℕ
⊢ 0 ≤ ∏ k in Finset.range (n + n), (m - ↑k)

tactic: rw [← two_mul] at ihn
state_before: case intro.succ
m : ℤ
n : ℕ
ihn : 0 ≤ ∏ k in Finset.range (n + n), (m - ↑k)
⊢ 0 ≤ ∏ k in Finset.range (Nat.succ n + Nat.succ n), (m - ↑k)

tactic: rw [← two_mul, Nat.succ_eq_add_one, mul_add, mul_one, ← one_add_one_eq_two, ← add_assoc,
  Finset.prod_range_succ, Finset.prod_range_succ, mul_assoc]
state_before: case intro.succ
m : ℤ
n : ℕ
ihn : 0 ≤ ∏ k in Finset.range (2 * n), (m - ↑k)
⊢ 0 ≤ ∏ k in Finset.range (Nat.succ n + Nat.succ n), (m - ↑k)

tactic: refine' mul_nonneg ihn _
state_before: case intro.succ
m : ℤ
n : ℕ
ihn : 0 ≤ ∏ k in Finset.range (2 * n), (m - ↑k)
⊢ 0 ≤ (∏ x in Finset.range ((1 + 1) * n), (m - ↑x)) * ((m - ↑((1 + 1) * n)) * (m - ↑((1 + 1) * n + 1)))

tactic: generalize (1 + 1) * n = k
state_before: case intro.succ
m : ℤ
n : ℕ
ihn : 0 ≤ ∏ k in Finset.range (2 * n), (m - ↑k)
⊢ 0 ≤ (m - ↑((1 + 1) * n)) * (m - ↑((1 + 1) * n + 1))

tactic: cases' le_or_lt m k with hmk hmk
state_before: case intro.succ
m : ℤ
n : ℕ
ihn : 0 ≤ ∏ k in Finset.range (2 * n), (m - ↑k)
k : ℕ
⊢ 0 ≤ (m - ↑k) * (m - ↑(k + 1))

tactic: simp
state_before: case intro.zero
m : ℤ
⊢ 0 ≤ ∏ k in Finset.range (Nat.zero + Nat.zero), (m - ↑k)

tactic: have : m ≤ k + 1 := hmk.trans (lt_add_one (k : ℤ)).le
state_before: case intro.succ.inl
m : ℤ
n : ℕ
ihn : 0 ≤ ∏ k in Finset.range (2 * n), (m - ↑k)
k : ℕ
hmk : m ≤ ↑k
⊢ 0 ≤ (m - ↑k) * (m - ↑(k + 1))

tactic: convert mul_nonneg_of_nonpos_of_nonpos (sub_nonpos_of_le hmk) _
state_before: case intro.succ.inl
m : ℤ
n : ℕ
ihn : 0 ≤ ∏ k in Finset.range (2 * n), (m - ↑k)
k : ℕ
hmk : m ≤ ↑k
this : m ≤ ↑k + 1
⊢ 0 ≤ (m - ↑k) * (m - ↑(k + 1))

tactic: convert sub_nonpos_of_le this
state_before: case intro.succ.inl.convert_2
m : ℤ
n : ℕ
ihn : 0 ≤ ∏ k in Finset.range (2 * n), (m - ↑k)
k : ℕ
hmk : m ≤ ↑k
this : m ≤ ↑k + 1
⊢ m - ↑(k + 1) ≤ 0

tactic: exact mul_nonneg (sub_nonneg_of_le hmk.le) (sub_nonneg_of_le hmk)
state_before: case intro.succ.inr
m : ℤ
n : ℕ
ihn : 0 ≤ ∏ k in Finset.range (2 * n), (m - ↑k)
k : ℕ
hmk : ↑k < m
⊢ 0 ≤ (m - ↑k) * (m - ↑(k + 1))
Theorem: MulLECancellable.mul_le_iff_le_one_left
File: Mathlib/Algebra/Order/Monoid/Lemmas.lean

tactic: rw [mul_comm, ha.mul_le_iff_le_one_right]
state_before: α : Type u_1
β : Type ?u.88936
inst✝² : LE α
inst✝¹ : CommMonoid α
inst✝ : CovariantClass α α (fun x x_1 => x * x_1) fun x x_1 => x ≤ x_1
a b : α
ha : MulLECancellable a
⊢ b * a ≤ a ↔ b ≤ 1
Theorem: IsROrC.bit1_re
File: Mathlib/Data/IsROrC/Basic.lean

tactic: simp only [bit1, map_add, bit0_re, one_re]
state_before: K : Type u_1
E : Type ?u.1751927
inst✝ : IsROrC K
z : K
⊢ ↑re (bit1 z) = bit1 (↑re z)
Theorem: List.pwFilter_sublist
File: Mathlib/Data/List/Pairwise.lean

tactic: by_cases h : ∀ y ∈ pwFilter R l, R x y
state_before: α : Type u_1
β : Type ?u.50704
R S T : α → α → Prop
a : α
l✝ : List α
inst✝ : DecidableRel R
x : α
l : List α
⊢ pwFilter R (x :: l) <+ x :: l

tactic: rw [pwFilter_cons_of_pos h]
state_before: case pos
α : Type u_1
β : Type ?u.50704
R S T : α → α → Prop
a : α
l✝ : List α
inst✝ : DecidableRel R
x : α
l : List α
h : ∀ (y : α), y ∈ pwFilter R l → R x y
⊢ pwFilter R (x :: l) <+ x :: l

tactic: exact (pwFilter_sublist l).cons_cons _
state_before: case pos
α : Type u_1
β : Type ?u.50704
R S T : α → α → Prop
a : α
l✝ : List α
inst✝ : DecidableRel R
x : α
l : List α
h : ∀ (y : α), y ∈ pwFilter R l → R x y
⊢ x :: pwFilter R l <+ x :: l

tactic: rw [pwFilter_cons_of_neg h]
state_before: case neg
α : Type u_1
β : Type ?u.50704
R S T : α → α → Prop
a : α
l✝ : List α
inst✝ : DecidableRel R
x : α
l : List α
h : ¬∀ (y : α), y ∈ pwFilter R l → R x y
⊢ pwFilter R (x :: l) <+ x :: l

tactic: exact sublist_cons_of_sublist _ (pwFilter_sublist l)
state_before: case neg
α : Type u_1
β : Type ?u.50704
R S T : α → α → Prop
a : α
l✝ : List α
inst✝ : DecidableRel R
x : α
l : List α
h : ¬∀ (y : α), y ∈ pwFilter R l → R x y
⊢ pwFilter R l <+ x :: l
Theorem: Zspan.floor_eq_self_of_mem
File: Mathlib/Algebra/Module/Zlattice.lean

tactic: apply b.ext_elem
state_before: E : Type u_1
ι : Type u_2
K : Type u_3
inst✝⁴ : NormedLinearOrderedField K
inst✝³ : NormedAddCommGroup E
inst✝² : NormedSpace K E
b : Basis ι K E
inst✝¹ : FloorRing K
inst✝ : Fintype ι
m : E
h : m ∈ span ℤ (Set.range ↑b)
⊢ ↑(floor b m) = m

tactic: simp_rw [repr_floor_apply b]
state_before: E : Type u_1
ι : Type u_2
K : Type u_3
inst✝⁴ : NormedLinearOrderedField K
inst✝³ : NormedAddCommGroup E
inst✝² : NormedSpace K E
b : Basis ι K E
inst✝¹ : FloorRing K
inst✝ : Fintype ι
m : E
h : m ∈ span ℤ (Set.range ↑b)
⊢ ∀ (i : ι), ↑(↑b.repr ↑(floor b m)) i = ↑(↑b.repr m) i

tactic: intro i
state_before: E : Type u_1
ι : Type u_2
K : Type u_3
inst✝⁴ : NormedLinearOrderedField K
inst✝³ : NormedAddCommGroup E
inst✝² : NormedSpace K E
b : Basis ι K E
inst✝¹ : FloorRing K
inst✝ : Fintype ι
m : E
h : m ∈ span ℤ (Set.range ↑b)
⊢ ∀ (i : ι), ↑⌊↑(↑b.repr m) i⌋ = ↑(↑b.repr m) i

tactic: obtain ⟨z, hz⟩ := (b.mem_span_iff_repr_mem ℤ _).mp h i
state_before: E : Type u_1
ι : Type u_2
K : Type u_3
inst✝⁴ : NormedLinearOrderedField K
inst✝³ : NormedAddCommGroup E
inst✝² : NormedSpace K E
b : Basis ι K E
inst✝¹ : FloorRing K
inst✝ : Fintype ι
m : E
h : m ∈ span ℤ (Set.range ↑b)
i : ι
⊢ ↑⌊↑(↑b.repr m) i⌋ = ↑(↑b.repr m) i

tactic: rw [← hz]
state_before: case intro
E : Type u_1
ι : Type u_2
K : Type u_3
inst✝⁴ : NormedLinearOrderedField K
inst✝³ : NormedAddCommGroup E
inst✝² : NormedSpace K E
b : Basis ι K E
inst✝¹ : FloorRing K
inst✝ : Fintype ι
m : E
h : m ∈ span ℤ (Set.range ↑b)
i : ι
z : ℤ
hz : ↑(algebraMap ℤ K) z = ↑(↑b.repr m) i
⊢ ↑⌊↑(↑b.repr m) i⌋ = ↑(↑b.repr m) i

tactic: exact congr_arg (Int.cast : ℤ → K) (Int.floor_intCast z)
state_before: case intro
E : Type u_1
ι : Type u_2
K : Type u_3
inst✝⁴ : NormedLinearOrderedField K
inst✝³ : NormedAddCommGroup E
inst✝² : NormedSpace K E
b : Basis ι K E
inst✝¹ : FloorRing K
inst✝ : Fintype ι
m : E
h : m ∈ span ℤ (Set.range ↑b)
i : ι
z : ℤ
hz : ↑(algebraMap ℤ K) z = ↑(↑b.repr m) i
⊢ ↑⌊↑(algebraMap ℤ K) z⌋ = ↑(algebraMap ℤ K) z
Theorem: CategoryTheory.Limits.hasStrictInitialObjects_of_initial_is_strict
File: Mathlib/CategoryTheory/Limits/Shapes/StrictInitial.lean

tactic: rw [← assoc, IsIso.hom_inv_id]
state_before: C : Type u
inst✝¹ : Category C
inst✝ : HasInitial C
h : ∀ (A : C) (f : A ⟶ ⊥_ C), IsIso f
I A : C
f : A ⟶ I
hI : IsInitial I
this : IsIso (f ≫ IsInitial.to hI (⊥_ C))
⊢ f ≫ IsInitial.to hI (⊥_ C) ≫ inv (f ≫ IsInitial.to hI (⊥_ C)) = 𝟙 A
Theorem: abs_lt_of_sq_lt_sq
File: Mathlib/Algebra/GroupPower/Order.lean

tactic: rwa [← abs_of_nonneg hy, ← sq_lt_sq]
state_before: β : Type ?u.263157
A : Type ?u.263160
G : Type ?u.263163
M : Type ?u.263166
R : Type u_1
inst✝ : LinearOrderedRing R
x y : R
h : x ^ 2 < y ^ 2
hy : 0 ≤ y
⊢ abs x < y
Theorem: List.length_rotate
File: Mathlib/Data/List/Rotate.lean

tactic: rw [rotate_eq_rotate', length_rotate']
state_before: α : Type u
l : List α
n : ℕ
⊢ length (rotate l n) = length l
Theorem: NormedSpace.isVonNBounded_closedBall
File: Mathlib/Analysis/LocallyConvex/Bounded.lean

tactic: linarith
state_before: 𝕜 : Type u_1
𝕜' : Type ?u.241289
E : Type u_2
E' : Type ?u.241295
F : Type ?u.241298
ι : Type ?u.241301
inst✝² : NontriviallyNormedField 𝕜
inst✝¹ : SeminormedAddCommGroup E
inst✝ : NormedSpace 𝕜 E
r : ℝ
⊢ r < r + 1
Theorem: Multiset.filter_cons_of_neg
File: Mathlib/Data/Multiset/Basic.lean

tactic: simpa using h
state_before: α : Type u_1
β : Type ?u.209744
γ : Type ?u.209747
p : α → Prop
inst✝ : DecidablePred p
a : α
s : Multiset α
l : List α
h : ¬p a
⊢ ¬decide (p a) = true
Theorem: IsPrimitiveRoot.zpowers_eq
File: Mathlib/RingTheory/RootsOfUnity/Basic.lean

tactic: apply SetLike.coe_injective
state_before: M : Type ?u.3298392
N : Type ?u.3298395
G : Type ?u.3298398
R : Type u_1
S : Type ?u.3298404
F : Type ?u.3298407
inst✝⁴ : CommMonoid M
inst✝³ : CommMonoid N
inst✝² : DivisionCommMonoid G
k✝ l : ℕ
inst✝¹ : CommRing R
ζ✝ : Rˣ
h✝ : IsPrimitiveRoot ζ✝ k✝
inst✝ : IsDomain R
k : ℕ+
ζ : Rˣ
h : IsPrimitiveRoot ζ ↑k
⊢ Subgroup.zpowers ζ = rootsOfUnity k R

tactic: haveI F : Fintype (Subgroup.zpowers ζ) := Fintype.ofEquiv _ h.zmodEquivZpowers.toEquiv
state_before: case a
M : Type ?u.3298392
N : Type ?u.3298395
G : Type ?u.3298398
R : Type u_1
S : Type ?u.3298404
F : Type ?u.3298407
inst✝⁴ : CommMonoid M
inst✝³ : CommMonoid N
inst✝² : DivisionCommMonoid G
k✝ l : ℕ
inst✝¹ : CommRing R
ζ✝ : Rˣ
h✝ : IsPrimitiveRoot ζ✝ k✝
inst✝ : IsDomain R
k : ℕ+
ζ : Rˣ
h : IsPrimitiveRoot ζ ↑k
⊢ ↑(Subgroup.zpowers ζ) = ↑(rootsOfUnity k R)

tactic: refine'
  @Set.eq_of_subset_of_card_le Rˣ (Subgroup.zpowers ζ) (rootsOfUnity k R) F
    (rootsOfUnity.fintype R k)
    (Subgroup.zpowers_le_of_mem <| show ζ ∈ rootsOfUnity k R from h.pow_eq_one) _
state_before: case a
M : Type ?u.3298392
N : Type ?u.3298395
G : Type ?u.3298398
R : Type u_1
S : Type ?u.3298404
F✝ : Type ?u.3298407
inst✝⁴ : CommMonoid M
inst✝³ : CommMonoid N
inst✝² : DivisionCommMonoid G
k✝ l : ℕ
inst✝¹ : CommRing R
ζ✝ : Rˣ
h✝ : IsPrimitiveRoot ζ✝ k✝
inst✝ : IsDomain R
k : ℕ+
ζ : Rˣ
h : IsPrimitiveRoot ζ ↑k
F : Fintype { x // x ∈ Subgroup.zpowers ζ }
⊢ ↑(Subgroup.zpowers ζ) = ↑(rootsOfUnity k R)

tactic: calc
  Fintype.card (rootsOfUnity k R) ≤ k := card_rootsOfUnity R k
  _ = Fintype.card (ZMod k) := (ZMod.card k).symm
  _ = Fintype.card (Subgroup.zpowers ζ) := Fintype.card_congr h.zmodEquivZpowers.toEquiv
state_before: case a
M : Type ?u.3298392
N : Type ?u.3298395
G : Type ?u.3298398
R : Type u_1
S : Type ?u.3298404
F✝ : Type ?u.3298407
inst✝⁴ : CommMonoid M
inst✝³ : CommMonoid N
inst✝² : DivisionCommMonoid G
k✝ l : ℕ
inst✝¹ : CommRing R
ζ✝ : Rˣ
h✝ : IsPrimitiveRoot ζ✝ k✝
inst✝ : IsDomain R
k : ℕ+
ζ : Rˣ
h : IsPrimitiveRoot ζ ↑k
F : Fintype { x // x ∈ Subgroup.zpowers ζ }
⊢ Fintype.card ↑↑(rootsOfUnity k R) ≤ Fintype.card ↑↑(Subgroup.zpowers ζ)
Theorem: NNReal.inner_le_Lp_mul_Lp_of_norm_eq_zero
File: Mathlib/Analysis/MeanInequalities.lean

tactic: simp only [hf, hpq.ne_zero, one_div, sum_eq_zero_iff, zero_rpow, MulZeroClass.zero_mul,
  inv_eq_zero, Ne.def, not_false_iff, le_zero_iff, mul_eq_zero]
state_before: ι : Type u
s : Finset ι
f g : ι → ℝ≥0
p q : ℝ
hpq : Real.IsConjugateExponent p q
hf : ∑ i in s, f i ^ p = 0
⊢ ∑ i in s, f i * g i ≤ (∑ i in s, f i ^ p) ^ (1 / p) * (∑ i in s, g i ^ q) ^ (1 / q)

tactic: intro i his
state_before: ι : Type u
s : Finset ι
f g : ι → ℝ≥0
p q : ℝ
hpq : Real.IsConjugateExponent p q
hf : ∑ i in s, f i ^ p = 0
⊢ ∀ (x : ι), x ∈ s → f x = 0 ∨ g x = 0

tactic: left
state_before: ι : Type u
s : Finset ι
f g : ι → ℝ≥0
p q : ℝ
hpq : Real.IsConjugateExponent p q
hf : ∑ i in s, f i ^ p = 0
i : ι
his : i ∈ s
⊢ f i = 0 ∨ g i = 0

tactic: rw [sum_eq_zero_iff] at hf
state_before: case h
ι : Type u
s : Finset ι
f g : ι → ℝ≥0
p q : ℝ
hpq : Real.IsConjugateExponent p q
hf : ∑ i in s, f i ^ p = 0
i : ι
his : i ∈ s
⊢ f i = 0

tactic: exact (rpow_eq_zero_iff.mp (hf i his)).left
state_before: case h
ι : Type u
s : Finset ι
f g : ι → ℝ≥0
p q : ℝ
hpq : Real.IsConjugateExponent p q
hf : ∀ (x : ι), x ∈ s → f x ^ p = 0
i : ι
his : i ∈ s
⊢ f i = 0
Theorem: CategoryTheory.isIso_of_comp_hom_eq_id
File: Mathlib/CategoryTheory/Iso.lean

tactic: rw [(comp_hom_eq_id _).mp h]
state_before: C : Type u
inst✝¹ : Category C
X Y Z : C
g : X ⟶ Y
inst✝ : IsIso g
f : Y ⟶ X
h : f ≫ g = 𝟙 Y
⊢ IsIso f

tactic: infer_instance
state_before: C : Type u
inst✝¹ : Category C
X Y Z : C
g : X ⟶ Y
inst✝ : IsIso g
f : Y ⟶ X
h : f ≫ g = 𝟙 Y
⊢ IsIso (inv g)
Theorem: Complex.ext_abs_arg
File: Mathlib/Analysis/SpecialFunctions/Complex/Arg.lean

tactic: rw [← abs_mul_exp_arg_mul_I x, ← abs_mul_exp_arg_mul_I y, h₁, h₂]
state_before: x y : ℂ
h₁ : ↑abs x = ↑abs y
h₂ : arg x = arg y
⊢ x = y
Theorem: Subgroup.nat_card_dvd_of_injective
File: Mathlib/GroupTheory/Index.lean

tactic: rw [Nat.card_congr (MonoidHom.ofInjective hf).toEquiv]
state_before: G✝ : Type ?u.97421
inst✝² : Group G✝
H✝ K L : Subgroup G✝
G : Type u_1
H : Type u_2
inst✝¹ : Group G
inst✝ : Group H
f : G →* H
hf : Function.Injective ↑f
⊢ Nat.card G ∣ Nat.card H

tactic: exact Dvd.intro f.range.index f.range.card_mul_index
state_before: G✝ : Type ?u.97421
inst✝² : Group G✝
H✝ K L : Subgroup G✝
G : Type u_1
H : Type u_2
inst✝¹ : Group G
inst✝ : Group H
f : G →* H
hf : Function.Injective ↑f
⊢ Nat.card { x // x ∈ MonoidHom.range f } ∣ Nat.card H
Theorem: CategoryTheory.Limits.colimit.pre_pre
File: Mathlib/CategoryTheory/Limits/HasLimits.lean

tactic: ext j
state_before: J : Type u₁
inst✝⁶ : Category J
K : Type u₂
inst✝⁵ : Category K
C : Type u
inst✝⁴ : Category C
F : J ⥤ C
inst✝³ : HasColimit F
E : K ⥤ J
inst✝² : HasColimit (E ⋙ F)
L : Type u₃
inst✝¹ : Category L
D : L ⥤ K
inst✝ h : HasColimit (D ⋙ E ⋙ F)
⊢ pre (E ⋙ F) D ≫ pre F E = pre F (D ⋙ E)

tactic: rw [← assoc, colimit.ι_pre, colimit.ι_pre]
state_before: case w
J : Type u₁
inst✝⁶ : Category J
K : Type u₂
inst✝⁵ : Category K
C : Type u
inst✝⁴ : Category C
F : J ⥤ C
inst✝³ : HasColimit F
E : K ⥤ J
inst✝² : HasColimit (E ⋙ F)
L : Type u₃
inst✝¹ : Category L
D : L ⥤ K
inst✝ h : HasColimit (D ⋙ E ⋙ F)
j : L
⊢ ι (D ⋙ E ⋙ F) j ≫ pre (E ⋙ F) D ≫ pre F E = ι (D ⋙ E ⋙ F) j ≫ pre F (D ⋙ E)

tactic: haveI : HasColimit ((D ⋙ E) ⋙ F) := h
state_before: case w
J : Type u₁
inst✝⁶ : Category J
K : Type u₂
inst✝⁵ : Category K
C : Type u
inst✝⁴ : Category C
F : J ⥤ C
inst✝³ : HasColimit F
E : K ⥤ J
inst✝² : HasColimit (E ⋙ F)
L : Type u₃
inst✝¹ : Category L
D : L ⥤ K
inst✝ h : HasColimit (D ⋙ E ⋙ F)
j : L
⊢ ι F (E.obj (D.obj j)) = ι (D ⋙ E ⋙ F) j ≫ pre F (D ⋙ E)

tactic: exact (colimit.ι_pre F (D ⋙ E) j).symm
state_before: case w
J : Type u₁
inst✝⁶ : Category J
K : Type u₂
inst✝⁵ : Category K
C : Type u
inst✝⁴ : Category C
F : J ⥤ C
inst✝³ : HasColimit F
E : K ⥤ J
inst✝² : HasColimit (E ⋙ F)
L : Type u₃
inst✝¹ : Category L
D : L ⥤ K
inst✝ h : HasColimit (D ⋙ E ⋙ F)
j : L
this : HasColimit ((D ⋙ E) ⋙ F)
⊢ ι F (E.obj (D.obj j)) = ι (D ⋙ E ⋙ F) j ≫ pre F (D ⋙ E)