tasksource/leandojo huggingface dataset:
Theorem: CompleteLattice.lsum_comp_mapRange_toSpanSingleton
File: Mathlib/LinearAlgebra/Dfinsupp.lean

tactic: ext
state_before: ι : Type u_3
R : Type u_1
S : Type ?u.550551
M : ι → Type ?u.550556
N : Type u_2
dec_ι : DecidableEq ι
inst✝³ : Semiring R
inst✝² : AddCommMonoid N
inst✝¹ : Module R N
inst✝ : (m : R) → Decidable (m ≠ 0)
p : ι → Submodule R N
v : ι → N
hv : ∀ (i : ι), v i ∈ p i
⊢ LinearMap.comp (↑(lsum ℕ) fun i => Submodule.subtype (p i))
      (LinearMap.comp
        (mapRange.linearMap fun i =>
          LinearMap.toSpanSingleton R { x // x ∈ p i } { val := v i, property := (_ : v i ∈ p i) })
        ↑(finsuppLequivDfinsupp R)) =
    Finsupp.total ι N R v

tactic: simp
state_before: case h.h
ι : Type u_3
R : Type u_1
S : Type ?u.550551
M : ι → Type ?u.550556
N : Type u_2
dec_ι : DecidableEq ι
inst✝³ : Semiring R
inst✝² : AddCommMonoid N
inst✝¹ : Module R N
inst✝ : (m : R) → Decidable (m ≠ 0)
p : ι → Submodule R N
v : ι → N
hv : ∀ (i : ι), v i ∈ p i
a✝ : ι
⊢ ↑(LinearMap.comp
          (LinearMap.comp (↑(lsum ℕ) fun i => Submodule.subtype (p i))
            (LinearMap.comp
              (mapRange.linearMap fun i =>
                LinearMap.toSpanSingleton R { x // x ∈ p i } { val := v i, property := (_ : v i ∈ p i) })
              ↑(finsuppLequivDfinsupp R)))
          (Finsupp.lsingle a✝))
      1 =
    ↑(LinearMap.comp (Finsupp.total ι N R v) (Finsupp.lsingle a✝)) 1
Theorem: Matrix.mul_fin_two
File: Mathlib/Data/Matrix/Notation.lean

tactic: ext (i j)
state_before: α : Type u
o n m : ℕ
m' : Type uₘ
n' : Type uₙ
o' : Type uₒ
a b : ℕ
inst✝¹ : AddCommMonoid α
inst✝ : Mul α
a₁₁ a₁₂ a₂₁ a₂₂ b₁₁ b₁₂ b₂₁ b₂₂ : α
⊢ ↑of ![![a₁₁, a₁₂], ![a₂₁, a₂₂]] ⬝ ↑of ![![b₁₁, b₁₂], ![b₂₁, b₂₂]] =
    ↑of ![![a₁₁ * b₁₁ + a₁₂ * b₂₁, a₁₁ * b₁₂ + a₁₂ * b₂₂], ![a₂₁ * b₁₁ + a₂₂ * b₂₁, a₂₁ * b₁₂ + a₂₂ * b₂₂]]

tactic: fin_cases i <;> fin_cases j <;> simp [Matrix.mul, dotProduct, Fin.sum_univ_succ]
state_before: case a.h
α : Type u
o n m : ℕ
m' : Type uₘ
n' : Type uₙ
o' : Type uₒ
a b : ℕ
inst✝¹ : AddCommMonoid α
inst✝ : Mul α
a₁₁ a₁₂ a₂₁ a₂₂ b₁₁ b₁₂ b₂₁ b₂₂ : α
i j : Fin 2
⊢ (↑of ![![a₁₁, a₁₂], ![a₂₁, a₂₂]] ⬝ ↑of ![![b₁₁, b₁₂], ![b₂₁, b₂₂]]) i j =
    ↑of ![![a₁₁ * b₁₁ + a₁₂ * b₂₁, a₁₁ * b₁₂ + a₁₂ * b₂₂], ![a₂₁ * b₁₁ + a₂₂ * b₂₁, a₂₁ * b₁₂ + a₂₂ * b₂₂]] i j
Theorem: CategoryTheory.Limits.zero_of_target_iso_zero
File: Mathlib/CategoryTheory/Limits/Shapes/ZeroMorphisms.lean

tactic: have h : f = f ≫ i.hom ≫ 𝟙 0 ≫ i.inv := by simp only [Iso.hom_inv_id, id_comp, comp_id]
state_before: C : Type u
inst✝³ : Category C
D : Type u'
inst✝² : Category D
inst✝¹ : HasZeroObject C
inst✝ : HasZeroMorphisms C
X Y : C
f : X ⟶ Y
i : Y ≅ 0
⊢ f = 0

tactic: simpa using h
state_before: C : Type u
inst✝³ : Category C
D : Type u'
inst✝² : Category D
inst✝¹ : HasZeroObject C
inst✝ : HasZeroMorphisms C
X Y : C
f : X ⟶ Y
i : Y ≅ 0
h : f = f ≫ i.hom ≫ 𝟙 0 ≫ i.inv
⊢ f = 0

tactic: simp only [Iso.hom_inv_id, id_comp, comp_id]
state_before: C : Type u
inst✝³ : Category C
D : Type u'
inst✝² : Category D
inst✝¹ : HasZeroObject C
inst✝ : HasZeroMorphisms C
X Y : C
f : X ⟶ Y
i : Y ≅ 0
⊢ f = f ≫ i.hom ≫ 𝟙 0 ≫ i.inv
Theorem: Option.map_eq_some'
File: Std/Data/Option/Lemmas.lean

tactic: cases x <;> simp
state_before: α✝¹ : Type u_1
b : α✝¹
α✝ : Type u_2
x : Option α✝
f : α✝ → α✝¹
⊢ Option.map f x = some b ↔ ∃ a, x = some a ∧ f a = b
Theorem: Set.image2_swap
File: Mathlib/Data/Set/NAry.lean

tactic: ext
state_before: α : Type u_1
α' : Type ?u.12485
β : Type u_2
β' : Type ?u.12491
γ : Type u_3
γ' : Type ?u.12497
δ : Type ?u.12500
δ' : Type ?u.12503
ε : Type ?u.12506
ε' : Type ?u.12509
ζ : Type ?u.12512
ζ' : Type ?u.12515
ν : Type ?u.12518
f f' : α → β → γ
g g' : α → β → γ → δ
s✝ s' : Set α
t✝ t' : Set β
u u' : Set γ
v : Set δ
a a' : α
b b' : β
c c' : γ
d d' : δ
s : Set α
t : Set β
⊢ image2 f s t = image2 (fun a b => f b a) t s

tactic: constructor <;> rintro ⟨a, b, ha, hb, rfl⟩ <;> exact ⟨b, a, hb, ha, rfl⟩
state_before: case h
α : Type u_1
α' : Type ?u.12485
β : Type u_2
β' : Type ?u.12491
γ : Type u_3
γ' : Type ?u.12497
δ : Type ?u.12500
δ' : Type ?u.12503
ε : Type ?u.12506
ε' : Type ?u.12509
ζ : Type ?u.12512
ζ' : Type ?u.12515
ν : Type ?u.12518
f f' : α → β → γ
g g' : α → β → γ → δ
s✝ s' : Set α
t✝ t' : Set β
u u' : Set γ
v : Set δ
a a' : α
b b' : β
c c' : γ
d d' : δ
s : Set α
t : Set β
x✝ : γ
⊢ x✝ ∈ image2 f s t ↔ x✝ ∈ image2 (fun a b => f b a) t s
Theorem: Set.Ici_iSup₂
File: Mathlib/Data/Set/Lattice.lean

tactic: simp_rw [Ici_iSup]
state_before: α : Type u_1
β : Type ?u.296264
γ : Type ?u.296267
ι : Sort u_2
ι' : Sort ?u.296273
ι₂ : Sort ?u.296276
κ : ι → Sort u_3
κ₁ : ι → Sort ?u.296286
κ₂ : ι → Sort ?u.296291
κ' : ι' → Sort ?u.296296
inst✝ : CompleteLattice α
f : (i : ι) → κ i → α
⊢ Ici (⨆ (i : ι) (j : κ i), f i j) = ⋂ (i : ι) (j : κ i), Ici (f i j)
Theorem: EqualCharZero.PNat.isUnit_natCast
File: Mathlib/Algebra/CharP/MixedCharZero.lean

tactic: rw [← Ideal.span_singleton_eq_top]
state_before: R : Type u_1
inst✝ : CommRing R
h : Fact (∀ (I : Ideal R), I ≠ ⊤ → CharZero (R ⧸ I))
n : ℕ+
⊢ IsUnit ↑↑n

tactic: apply not_imp_comm.mp (h.elim (Ideal.span {↑n}))
state_before: R : Type u_1
inst✝ : CommRing R
h : Fact (∀ (I : Ideal R), I ≠ ⊤ → CharZero (R ⧸ I))
n : ℕ+
⊢ Ideal.span {↑↑n} = ⊤

tactic: intro h_char_zero
state_before: R : Type u_1
inst✝ : CommRing R
h : Fact (∀ (I : Ideal R), I ≠ ⊤ → CharZero (R ⧸ I))
n : ℕ+
⊢ ¬CharZero (R ⧸ Ideal.span {↑↑n})

tactic: apply h_char_zero.cast_injective.ne n.ne_zero
state_before: R : Type u_1
inst✝ : CommRing R
h : Fact (∀ (I : Ideal R), I ≠ ⊤ → CharZero (R ⧸ I))
n : ℕ+
h_char_zero : CharZero (R ⧸ Ideal.span {↑↑n})
⊢ False

tactic: rw [← map_natCast (Ideal.Quotient.mk _), Nat.cast_zero, Ideal.Quotient.eq_zero_iff_mem]
state_before: R : Type u_1
inst✝ : CommRing R
h : Fact (∀ (I : Ideal R), I ≠ ⊤ → CharZero (R ⧸ I))
n : ℕ+
h_char_zero : CharZero (R ⧸ Ideal.span {↑↑n})
⊢ ↑↑n = ↑0

tactic: exact Ideal.subset_span (Set.mem_singleton _)
state_before: R : Type u_1
inst✝ : CommRing R
h : Fact (∀ (I : Ideal R), I ≠ ⊤ → CharZero (R ⧸ I))
n : ℕ+
h_char_zero : CharZero (R ⧸ Ideal.span {↑↑n})
⊢ ↑↑n ∈ Ideal.span {↑↑n}
Theorem: Nat.isCompl_even_odd
File: Mathlib/Data/Nat/Parity.lean

tactic: simp only [← Set.compl_setOf, isCompl_compl, odd_iff_not_even]
state_before: m n : ℕ
⊢ IsCompl {n | Even n} {n | Odd n}
Theorem: Nat.coe_ofDigits
File: Mathlib/Data/Nat/Digits.lean

tactic: induction' L with d L ih
state_before: n : ℕ
α : Type u_1
inst✝ : Semiring α
b : ℕ
L : List ℕ
⊢ ↑(ofDigits b L) = ofDigits (↑b) L

tactic: simp [ofDigits]
state_before: case nil
n : ℕ
α : Type u_1
inst✝ : Semiring α
b : ℕ
⊢ ↑(ofDigits b []) = ofDigits ↑b []

tactic: dsimp [ofDigits]
state_before: case cons
n : ℕ
α : Type u_1
inst✝ : Semiring α
b d : ℕ
L : List ℕ
ih : ↑(ofDigits b L) = ofDigits (↑b) L
⊢ ↑(ofDigits b (d :: L)) = ofDigits (↑b) (d :: L)

tactic: push_cast
state_before: case cons
n : ℕ
α : Type u_1
inst✝ : Semiring α
b d : ℕ
L : List ℕ
ih : ↑(ofDigits b L) = ofDigits (↑b) L
⊢ ↑(d + b * ofDigits b L) = ↑d + ↑b * ofDigits (↑b) L

tactic: rw [ih]
state_before: case cons
n : ℕ
α : Type u_1
inst✝ : Semiring α
b d : ℕ
L : List ℕ
ih : ↑(ofDigits b L) = ofDigits (↑b) L
⊢ ↑d + ↑b * ↑(ofDigits b L) = ↑d + ↑b * ofDigits (↑b) L
Theorem: NNRat.toNNRat_sum_of_nonneg
File: Mathlib/Data/Rat/NNRat.lean

tactic: rw [← coe_inj, coe_sum, Rat.coe_toNNRat _ (Finset.sum_nonneg hf)]
state_before: α : Type u_1
p q : ℚ≥0
s : Finset α
f : α → ℚ
hf : ∀ (a : α), a ∈ s → 0 ≤ f a
⊢ toNNRat (∑ a in s, f a) = ∑ a in s, toNNRat (f a)

tactic: exact Finset.sum_congr rfl fun x hxs ↦ by rw [Rat.coe_toNNRat _ (hf x hxs)]
state_before: α : Type u_1
p q : ℚ≥0
s : Finset α
f : α → ℚ
hf : ∀ (a : α), a ∈ s → 0 ≤ f a
⊢ ∑ i in s, f i = ∑ a in s, ↑(toNNRat (f a))

tactic: rw [Rat.coe_toNNRat _ (hf x hxs)]
state_before: α : Type u_1
p q : ℚ≥0
s : Finset α
f : α → ℚ
hf : ∀ (a : α), a ∈ s → 0 ≤ f a
x : α
hxs : x ∈ s
⊢ f x = ↑(toNNRat (f x))
Theorem: HolorIndex.drop_drop
File: Mathlib/Data/Holor.lean

tactic: simp [add_comm, assocRight, drop, cast_type, List.drop_drop]
state_before: ds₁ ds₂ ds₃ is : List ℕ
h : Forall₂ (fun x x_1 => x < x_1) is (ds₁ ++ ds₂ ++ ds₃)
⊢ ↑(drop (drop (assocRight { val := is, property := h }))) = ↑(drop { val := is, property := h })
Theorem: CategoryTheory.ProjectiveResolution.homotopyEquiv_inv_π
File: Mathlib/CategoryTheory/Preadditive/ProjectiveResolution.lean

tactic: simp [homotopyEquiv]
state_before: C : Type u
inst✝⁴ : Category C
inst✝³ : HasZeroObject C
inst✝² : Preadditive C
inst✝¹ : HasEqualizers C
inst✝ : HasImages C
X : C
P Q : ProjectiveResolution X
⊢ (homotopyEquiv P Q).inv ≫ P.π = Q.π
Theorem: PFunctor.supp_eq
File: Mathlib/Data/PFunctor/Univariate/Basic.lean

tactic: ext x
state_before: P : PFunctor
α : Type u
a : P.A
f : B P a → α
⊢ supp { fst := a, snd := f } = f '' univ

tactic: simp only [supp, image_univ, mem_range, mem_setOf_eq]
state_before: case h
P : PFunctor
α : Type u
a : P.A
f : B P a → α
x : α
⊢ x ∈ supp { fst := a, snd := f } ↔ x ∈ f '' univ

tactic: constructor <;> intro h
state_before: case h
P : PFunctor
α : Type u
a : P.A
f : B P a → α
x : α
⊢ (∀ ⦃p : α → Prop⦄, Liftp p { fst := a, snd := f } → p x) ↔ ∃ y, f y = x

tactic: apply @h fun x => ∃ y : P.B a, f y = x
state_before: case h.mp
P : PFunctor
α : Type u
a : P.A
f : B P a → α
x : α
h : ∀ ⦃p : α → Prop⦄, Liftp p { fst := a, snd := f } → p x
⊢ ∃ y, f y = x

tactic: rw [liftp_iff']
state_before: case h.mp
P : PFunctor
α : Type u
a : P.A
f : B P a → α
x : α
h : ∀ ⦃p : α → Prop⦄, Liftp p { fst := a, snd := f } → p x
⊢ Liftp (fun x => ∃ y, f y = x) { fst := a, snd := f }

tactic: intro
state_before: case h.mp
P : PFunctor
α : Type u
a : P.A
f : B P a → α
x : α
h : ∀ ⦃p : α → Prop⦄, Liftp p { fst := a, snd := f } → p x
⊢ ∀ (i : B P a), ∃ y, f y = f i

tactic: refine' ⟨_, rfl⟩
state_before: case h.mp
P : PFunctor
α : Type u
a : P.A
f : B P a → α
x : α
h : ∀ ⦃p : α → Prop⦄, Liftp p { fst := a, snd := f } → p x
i✝ : B P a
⊢ ∃ y, f y = f i✝

tactic: simp only [liftp_iff']
state_before: case h.mpr
P : PFunctor
α : Type u
a : P.A
f : B P a → α
x : α
h : ∃ y, f y = x
⊢ ∀ ⦃p : α → Prop⦄, Liftp p { fst := a, snd := f } → p x

tactic: cases h
state_before: case h.mpr
P : PFunctor
α : Type u
a : P.A
f : B P a → α
x : α
h : ∃ y, f y = x
⊢ ∀ ⦃p : α → Prop⦄, (∀ (i : B P a), p (f i)) → p x

tactic: subst x
state_before: case h.mpr.intro
P : PFunctor
α : Type u
a : P.A
f : B P a → α
x : α
w✝ : B P a
h✝ : f w✝ = x
⊢ ∀ ⦃p : α → Prop⦄, (∀ (i : B P a), p (f i)) → p x

tactic: tauto
state_before: case h.mpr.intro
P : PFunctor
α : Type u
a : P.A
f : B P a → α
w✝ : B P a
⊢ ∀ ⦃p : α → Prop⦄, (∀ (i : B P a), p (f i)) → p (f w✝)
Theorem: Matrix.two_mul_expl
File: Mathlib/Data/Matrix/Basic.lean

tactic: simp only [Matrix.mul_eq_mul]
state_before: case refine_4
l : Type ?u.237230
m : Type ?u.237233
n : Type ?u.237236
o : Type ?u.237239
m' : o → Type ?u.237244
n' : o → Type ?u.237249
R✝ : Type ?u.237252
S : Type ?u.237255
α : Type v
β : Type w
γ : Type ?u.237262
R : Type u_1
inst✝ : CommRing R
A B : Matrix (Fin 2) (Fin 2) R
⊢ (A * B) 1 1 = A 1 0 * B 0 1 + A 1 1 * B 1 1

tactic: rw [Matrix.mul_apply, Finset.sum_fin_eq_sum_range, Finset.sum_range_succ, Finset.sum_range_succ]
state_before: case refine_4
l : Type ?u.237230
m : Type ?u.237233
n : Type ?u.237236
o : Type ?u.237239
m' : o → Type ?u.237244
n' : o → Type ?u.237249
R✝ : Type ?u.237252
S : Type ?u.237255
α : Type v
β : Type w
γ : Type ?u.237262
R : Type u_1
inst✝ : CommRing R
A B : Matrix (Fin 2) (Fin 2) R
⊢ (A ⬝ B) 1 1 = A 1 0 * B 0 1 + A 1 1 * B 1 1

tactic: simp
state_before: case refine_4
l : Type ?u.237230
m : Type ?u.237233
n : Type ?u.237236
o : Type ?u.237239
m' : o → Type ?u.237244
n' : o → Type ?u.237249
R✝ : Type ?u.237252
S : Type ?u.237255
α : Type v
β : Type w
γ : Type ?u.237262
R : Type u_1
inst✝ : CommRing R
A B : Matrix (Fin 2) (Fin 2) R
⊢ (((∑ x in Finset.range 0, if h : x < 2 then A 1 { val := x, isLt := h } * B { val := x, isLt := h } 1 else 0) +
        if h : 0 < 2 then A 1 { val := 0, isLt := h } * B { val := 0, isLt := h } 1 else 0) +
      if h : 1 < 2 then A 1 { val := 1, isLt := h } * B { val := 1, isLt := h } 1 else 0) =
    A 1 0 * B 0 1 + A 1 1 * B 1 1
Theorem: CategoryTheory.IsEquivalence.inv_fun_map
File: Mathlib/CategoryTheory/Equivalence.lean

tactic: erw [NatIso.naturality_1]
state_before: C : Type u₁
inst✝² : Category C
D : Type u₂
inst✝¹ : Category D
F : C ⥤ D
inst✝ : IsEquivalence F
X Y : C
f : X ⟶ Y
⊢ (Functor.inv F).map (F.map f) =
    (Equivalence.unitInv (asEquivalence F)).app X ≫ f ≫ (Equivalence.unit (asEquivalence F)).app Y

tactic: rfl
state_before: C : Type u₁
inst✝² : Category C
D : Type u₂
inst✝¹ : Category D
F : C ⥤ D
inst✝ : IsEquivalence F
X Y : C
f : X ⟶ Y
⊢ (Functor.inv F).map (F.map f) = ((asEquivalence F).functor ⋙ (asEquivalence F).inverse).map f
Theorem: Zsqrtd.nonneg_antisymm
File: Mathlib/NumberTheory/Zsqrtd/Basic.lean

tactic: decide
state_before: d : ℕ
dnsq : Nonsquare d
x : ℕ
xy : Nonneg { re := -[x+1], im := 0 }
x✝ : Nonneg (-{ re := -[x+1], im := 0 })
⊢ 0 < 1

tactic: decide
state_before: d : ℕ
dnsq : Nonsquare d
x : ℕ
x✝ : Nonneg { re := ↑(x + 1), im := 0 }
yx : Nonneg (-{ re := ↑(x + 1), im := 0 })
⊢ 0 < 1

tactic: let t := le_antisymm yx xy
state_before: d : ℕ
dnsq : Nonsquare d
x y : ℕ
xy : SqLe (y + 1) d (x + 1) 1
yx : SqLe (Nat.add x 0 + 1) 1 (Nat.succ y) d
⊢ { re := ↑(x + 1), im := -[y+1] } = 0

tactic: rw [one_mul] at t
state_before: d : ℕ
dnsq : Nonsquare d
x y : ℕ
xy : SqLe (y + 1) d (x + 1) 1
yx : SqLe (Nat.add x 0 + 1) 1 (Nat.succ y) d
t : 1 * (Nat.add x 0 + 1) * (Nat.add x 0 + 1) = d * Nat.succ y * Nat.succ y := le_antisymm yx xy
⊢ { re := ↑(x + 1), im := -[y+1] } = 0

tactic: exact absurd t (not_divides_sq _ _)
state_before: d : ℕ
dnsq : Nonsquare d
x y : ℕ
xy : SqLe (y + 1) d (x + 1) 1
yx : SqLe (Nat.add x 0 + 1) 1 (Nat.succ y) d
t : (Nat.add x 0 + 1) * (Nat.add x 0 + 1) = d * Nat.succ y * Nat.succ y
⊢ { re := ↑(x + 1), im := -[y+1] } = 0

tactic: let t := le_antisymm xy yx
state_before: d : ℕ
dnsq : Nonsquare d
x y : ℕ
xy : SqLe (x + 1) 1 (y + 1) d
yx : SqLe (Nat.add y 0 + 1) d (Nat.succ x) 1
⊢ { re := -[x+1], im := ↑(y + 1) } = 0

tactic: rw [one_mul] at t
state_before: d : ℕ
dnsq : Nonsquare d
x y : ℕ
xy : SqLe (x + 1) 1 (y + 1) d
yx : SqLe (Nat.add y 0 + 1) d (Nat.succ x) 1
t : 1 * (x + 1) * (x + 1) = d * (y + 1) * (y + 1) := le_antisymm xy yx
⊢ { re := -[x+1], im := ↑(y + 1) } = 0

tactic: exact absurd t (not_divides_sq _ _)
state_before: d : ℕ
dnsq : Nonsquare d
x y : ℕ
xy : SqLe (x + 1) 1 (y + 1) d
yx : SqLe (Nat.add y 0 + 1) d (Nat.succ x) 1
t : (x + 1) * (x + 1) = d * (y + 1) * (y + 1)
⊢ { re := -[x+1], im := ↑(y + 1) } = 0
Theorem: Int.isUnit_eq_or_eq_neg
File: Mathlib/Data/Int/Units.lean

tactic: rcases isUnit_eq_one_or hb with (rfl | rfl)
state_before: a b : ℤ
ha : IsUnit a
hb : IsUnit b
⊢ a = b ∨ a = -b

tactic: exact isUnit_eq_one_or ha
state_before: case inl
a : ℤ
ha : IsUnit a
hb : IsUnit 1
⊢ a = 1 ∨ a = -1

tactic: rwa [or_comm, neg_neg, ← isUnit_iff]
state_before: case inr
a : ℤ
ha : IsUnit a
hb : IsUnit (-1)
⊢ a = -1 ∨ a = - -1
Theorem: Finsupp.single_le_iff
File: Mathlib/Data/Finsupp/Order.lean

tactic: simp
state_before: ι : Type u_1
α : Type u_2
inst✝ : CanonicallyOrderedAddMonoid α
i : ι
x : α
f : ι →₀ α
⊢ (∀ (i_1 : ι), i_1 ∈ {i} → ↑(single i x) i_1 ≤ ↑f i_1) ↔ x ≤ ↑f i
Theorem: Ideal.rank_pow_quot_aux
File: Mathlib/NumberTheory/RamificationInertia.lean

tactic: letI : Field (R ⧸ p) := Ideal.Quotient.field _
state_before: R : Type u
inst✝⁵ : CommRing R
S : Type v
inst✝⁴ : CommRing S
f : R →+* S
p : Ideal R
P : Ideal S
hfp : NeZero e
inst✝³ : IsDomain S
inst✝² : IsDedekindDomain S
inst✝¹ : IsMaximal p
inst✝ : IsPrime P
hP0 : P ≠ ⊥
i : ℕ
hi : i < e
⊢ Module.rank (R ⧸ p) { x // x ∈ map (Quotient.mk (P ^ e)) (P ^ i) } =
    Module.rank (R ⧸ p) (S ⧸ P) + Module.rank (R ⧸ p) { x // x ∈ map (Quotient.mk (P ^ e)) (P ^ (i + 1)) }

tactic: rw [rank_eq_of_injective _ (powQuotSuccInclusion_injective f p P i),
  (quotientRangePowQuotSuccInclusionEquiv f p P hP0 hi).symm.rank_eq]
state_before: R : Type u
inst✝⁵ : CommRing R
S : Type v
inst✝⁴ : CommRing S
f : R →+* S
p : Ideal R
P : Ideal S
hfp : NeZero e
inst✝³ : IsDomain S
inst✝² : IsDedekindDomain S
inst✝¹ : IsMaximal p
inst✝ : IsPrime P
hP0 : P ≠ ⊥
i : ℕ
hi : i < e
this : Field (R ⧸ p) := Quotient.field p
⊢ Module.rank (R ⧸ p) { x // x ∈ map (Quotient.mk (P ^ e)) (P ^ i) } =
    Module.rank (R ⧸ p) (S ⧸ P) + Module.rank (R ⧸ p) { x // x ∈ map (Quotient.mk (P ^ e)) (P ^ (i + 1)) }

tactic: exact (rank_quotient_add_rank (LinearMap.range (powQuotSuccInclusion f p P i))).symm
state_before: R : Type u
inst✝⁵ : CommRing R
S : Type v
inst✝⁴ : CommRing S
f : R →+* S
p : Ideal R
P : Ideal S
hfp : NeZero e
inst✝³ : IsDomain S
inst✝² : IsDedekindDomain S
inst✝¹ : IsMaximal p
inst✝ : IsPrime P
hP0 : P ≠ ⊥
i : ℕ
hi : i < e
this : Field (R ⧸ p) := Quotient.field p
⊢ Module.rank (R ⧸ p) { x // x ∈ map (Quotient.mk (P ^ e)) (P ^ i) } =
    Module.rank (R ⧸ p)
        ({ x // x ∈ map (Quotient.mk (P ^ e)) (P ^ i) } ⧸ LinearMap.range (powQuotSuccInclusion f p P i)) +
      Module.rank (R ⧸ p) { x // x ∈ LinearMap.range (powQuotSuccInclusion f p P i) }
Theorem: Polynomial.degree_eq_card_roots
File: Mathlib/Data/Polynomial/Splits.lean

tactic: rw [degree_eq_natDegree p_ne_zero, natDegree_eq_card_roots hsplit]
state_before: F : Type u
K : Type v
L : Type w
inst✝² : Field K
inst✝¹ : Field L
inst✝ : Field F
i✝ : K →+* L
p : K[X]
i : K →+* L
p_ne_zero : p ≠ 0
hsplit : Splits i p
⊢ degree p = ↑(↑Multiset.card (roots (map i p)))
Theorem: OrderRingIso.refl_apply
File: Mathlib/Algebra/Order/Hom/Ring.lean

tactic: rfl
state_before: F : Type ?u.65495
α : Type u_1
β : Type ?u.65501
γ : Type ?u.65504
δ : Type ?u.65507
inst✝¹¹ : Mul α
inst✝¹⁰ : Add α
inst✝⁹ : LE α
inst✝⁸ : Mul β
inst✝⁷ : Add β
inst✝⁶ : LE β
inst✝⁵ : Mul γ
inst✝⁴ : Add γ
inst✝³ : LE γ
inst✝² : Mul δ
inst✝¹ : Add δ
inst✝ : LE δ
x : α
⊢ ↑(OrderRingIso.refl α) x = x
Theorem: Ring.mul_inverse_cancel_left
File: Mathlib/Algebra/GroupWithZero/Units/Basic.lean

tactic: rw [← mul_assoc, mul_inverse_cancel x h, one_mul]
state_before: α : Type ?u.7593
M₀ : Type u_1
G₀ : Type ?u.7599
M₀' : Type ?u.7602
G₀' : Type ?u.7605
F : Type ?u.7608
F' : Type ?u.7611
inst✝ : MonoidWithZero M₀
x y : M₀
h : IsUnit x
⊢ x * (inverse x * y) = y
Theorem: CategoryTheory.Meq.equiv_symm_eq_apply
File: Mathlib/CategoryTheory/Sites/Sheafification.lean

tactic: rw [← equiv_apply]
state_before: C : Type u
inst✝⁴ : Category C
J : GrothendieckTopology C
D : Type w
inst✝³ : Category D
inst✝² : ConcreteCategory D
inst✝¹ : PreservesLimits (forget D)
X : C
P : Cᵒᵖ ⥤ D
S : GrothendieckTopology.Cover J X
inst✝ : HasMultiequalizer (GrothendieckTopology.Cover.index S P)
x : Meq P S
I : GrothendieckTopology.Cover.Arrow S
⊢ (forget D).map (Multiequalizer.ι (GrothendieckTopology.Cover.index S P) I) (↑(equiv P S).symm x) = ↑x I

tactic: simp
state_before: C : Type u
inst✝⁴ : Category C
J : GrothendieckTopology C
D : Type w
inst✝³ : Category D
inst✝² : ConcreteCategory D
inst✝¹ : PreservesLimits (forget D)
X : C
P : Cᵒᵖ ⥤ D
S : GrothendieckTopology.Cover J X
inst✝ : HasMultiequalizer (GrothendieckTopology.Cover.index S P)
x : Meq P S
I : GrothendieckTopology.Cover.Arrow S
⊢ ↑(↑(equiv P S) (↑(equiv P S).symm x)) I = ↑x I
Theorem: Finset.exists_lt_sum_fiber_of_sum_fiber_nonpos_of_nsmul_lt_sum
File: Mathlib/Combinatorics/Pigeonhole.lean

tactic: simpa
state_before: α : Type u
β : Type v
M : Type w
inst✝¹ : DecidableEq β
s : Finset α
t : Finset β
f : α → β
w : α → M
b : M
n : ℕ
inst✝ : LinearOrderedCancelAddCommMonoid M
ht : ∀ (y : β), ¬y ∈ t → ∑ x in filter (fun x => f x = y) s, w x ≤ 0
hb : card t • b < ∑ x in s, w x
⊢ ∑ _y in t, b < ∑ x in s, w x
Theorem: SimpleGraph.iInf_adj_of_nonempty
File: Mathlib/Combinatorics/SimpleGraph/Basic.lean

tactic: rw [iInf, sInf_adj_of_nonempty (Set.range_nonempty _), Set.forall_range_iff]
state_before: ι : Sort u_1
𝕜 : Type ?u.23218
V : Type u
W : Type v
X : Type w
G : SimpleGraph V
G' : SimpleGraph W
a b c u v w : V
e : Sym2 V
inst✝ : Nonempty ι
f : ι → SimpleGraph V
⊢ Adj (⨅ (i : ι), f i) a b ↔ ∀ (i : ι), Adj (f i) a b
Theorem: mem_nhdsWithin_Ici_iff_exists_mem_Ioc_Ico_subset
File: Mathlib/Topology/Order/Basic.lean

tactic: norm_num
state_before: α : Type u
β : Type v
γ : Type w
inst✝² : TopologicalSpace α
inst✝¹ : LinearOrder α
inst✝ : OrderTopology α
a u' : α
s : Set α
hu' : a < u'
⊢ List.get?
      [s ∈ 𝓝[Ici a] a, s ∈ 𝓝[Icc a u'] a, s ∈ 𝓝[Ico a u'] a, ∃ u, u ∈ Ioc a u' ∧ Ico a u ⊆ s,
        ∃ u, u ∈ Ioi a ∧ Ico a u ⊆ s]
      0 =
    some (s ∈ 𝓝[Ici a] a)

tactic: norm_num
state_before: α : Type u
β : Type v
γ : Type w
inst✝² : TopologicalSpace α
inst✝¹ : LinearOrder α
inst✝ : OrderTopology α
a u' : α
s : Set α
hu' : a < u'
⊢ List.get?
      [s ∈ 𝓝[Ici a] a, s ∈ 𝓝[Icc a u'] a, s ∈ 𝓝[Ico a u'] a, ∃ u, u ∈ Ioc a u' ∧ Ico a u ⊆ s,
        ∃ u, u ∈ Ioi a ∧ Ico a u ⊆ s]
      3 =
    some (∃ u, u ∈ Ioc a u' ∧ Ico a u ⊆ s)
Theorem: MeasureTheory.Measure.comap_apply₀
File: Mathlib/MeasureTheory/Measure/MeasureSpace.lean

tactic: rw [comap, dif_pos (And.intro hfi hf)] at hs⊢
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.225222
δ : Type ?u.225225
ι : Type ?u.225228
R : Type ?u.225231
R' : Type ?u.225234
m0 : MeasurableSpace α
inst✝² : MeasurableSpace β
inst✝¹ : MeasurableSpace γ
μ✝ μ₁ μ₂ μ₃ ν ν' ν₁ ν₂ : Measure α
s s' t : Set α
inst✝ : MeasurableSpace α
f : α → β
μ : Measure β
hfi : Injective f
hf : ∀ (s : Set α), MeasurableSet s → NullMeasurableSet (f '' s)
hs : NullMeasurableSet s
⊢ ↑↑(comap f μ) s = ↑↑μ (f '' s)

tactic: rw [toMeasure_apply₀ _ _ hs, OuterMeasure.comap_apply]
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.225222
δ : Type ?u.225225
ι : Type ?u.225228
R : Type ?u.225231
R' : Type ?u.225234
m0 : MeasurableSpace α
inst✝² : MeasurableSpace β
inst✝¹ : MeasurableSpace γ
μ✝ μ₁ μ₂ μ₃ ν ν' ν₁ ν₂ : Measure α
s s' t : Set α
inst✝ : MeasurableSpace α
f : α → β
μ : Measure β
hfi : Injective f
hf : ∀ (s : Set α), MeasurableSet s → NullMeasurableSet (f '' s)
hs : NullMeasurableSet s
⊢ ↑↑(OuterMeasure.toMeasure (↑(OuterMeasure.comap f) ↑μ)
            (_ :
              ∀ (s : Set α),
                MeasurableSet s →
                  ∀ (t : Set α),
                    ↑(↑(OuterMeasure.comap f) ↑μ) t =
                      ↑(↑(OuterMeasure.comap f) ↑μ) (t ∩ s) + ↑(↑(OuterMeasure.comap f) ↑μ) (t \ s)))
      s =
    ↑↑μ (f '' s)
Theorem: Complex.finrank_real_complex
File: Mathlib/Data/Complex/Module.lean

tactic: rw [finrank_eq_card_basis basisOneI, Fintype.card_fin]
state_before: R : Type ?u.167341
S : Type ?u.167344
⊢ finrank ℝ ℂ = 2
Theorem: Nat.factorial_mul_descFactorial
File: Mathlib/Data/Nat/Factorial/Basic.lean

tactic: rw [descFactorial_zero, mul_one, tsub_zero]
state_before: n : ℕ
x✝ : 0 ≤ n
⊢ (n - 0)! * descFactorial n 0 = n !

tactic: exfalso
state_before: k : ℕ
h : succ k ≤ 0
⊢ (0 - succ k)! * descFactorial 0 (succ k) = 0!

tactic: exact not_succ_le_zero k h
state_before: case h
k : ℕ
h : succ k ≤ 0
⊢ False

tactic: rw [succ_descFactorial_succ, succ_sub_succ, ← mul_assoc, mul_comm (n - k)!, mul_assoc,
  factorial_mul_descFactorial (Nat.succ_le_succ_iff.1 h), factorial_succ]
state_before: n k : ℕ
h : succ k ≤ succ n
⊢ (succ n - succ k)! * descFactorial (succ n) (succ k) = (succ n)!
Theorem: Multiset.powersetAux_perm_powersetAux'
File: Mathlib/Data/Multiset/Powerset.lean

tactic: rw [powersetAux_eq_map_coe]
state_before: α : Type u_1
l : List α
⊢ powersetAux l ~ powersetAux' l

tactic: exact (sublists_perm_sublists' _).map _
state_before: α : Type u_1
l : List α
⊢ List.map ofList (sublists l) ~ powersetAux' l
Theorem: lipschitz_on_univ
File: Mathlib/Topology/MetricSpace/Lipschitz.lean

tactic: simp [LipschitzOnWith, LipschitzWith]
state_before: α : Type u
β : Type v
γ : Type w
ι : Type x
inst✝¹ : PseudoEMetricSpace α
inst✝ : PseudoEMetricSpace β
K : ℝ≥0
f : α → β
⊢ LipschitzOnWith K f univ ↔ LipschitzWith K f
Theorem: pochhammer_eval_one
File: Mathlib/RingTheory/Polynomial/Pochhammer.lean

tactic: rw_mod_cast [pochhammer_nat_eq_ascFactorial, Nat.zero_ascFactorial]
state_before: S✝ : Type ?u.28714
inst✝¹ : Semiring S✝
r n✝ : ℕ
S : Type u_1
inst✝ : Semiring S
n : ℕ
⊢ eval 1 (pochhammer S n) = ↑n !
Theorem: List.Nodup.mem_erase_iff
File: Mathlib/Data/List/Nodup.lean

tactic: rw [d.erase_eq_filter, mem_filter, and_comm, decide_eq_true_iff]
state_before: α : Type u
β : Type v
l l₁ l₂ : List α
r : α → α → Prop
a b : α
inst✝ : DecidableEq α
d : Nodup l
⊢ a ∈ List.erase l b ↔ a ≠ b ∧ a ∈ l