tasksource/leandojo huggingface dataset:
Theorem: CategoryTheory.Limits.π_comp_cokernelIsoOfEq_inv
File: Mathlib/CategoryTheory/Limits/Shapes/Kernels.lean

tactic: cases h
state_before: C : Type u
inst✝⁴ : Category C
inst✝³ : HasZeroMorphisms C
X Y : C
f✝ : X ⟶ Y
inst✝² : HasCokernel f✝
f g : X ⟶ Y
inst✝¹ : HasCokernel f
inst✝ : HasCokernel g
h : f = g
⊢ cokernel.π g ≫ (cokernelIsoOfEq h).inv = cokernel.π f

tactic: simp
state_before: case refl
C : Type u
inst✝⁴ : Category C
inst✝³ : HasZeroMorphisms C
X Y : C
f✝ : X ⟶ Y
inst✝² : HasCokernel f✝
f : X ⟶ Y
inst✝¹ inst✝ : HasCokernel f
⊢ cokernel.π f ≫ (cokernelIsoOfEq (_ : f = f)).inv = cokernel.π f
Theorem: IsComplete.union
File: Mathlib/Topology/UniformSpace/Cauchy.lean

tactic: simp only [isComplete_iff_ultrafilter', Ultrafilter.union_mem_iff, or_imp] at *
state_before: α : Type u
β : Type v
inst✝ : UniformSpace α
s t : Set α
hs : IsComplete s
ht : IsComplete t
⊢ IsComplete (s ∪ t)

tactic: exact fun l hl =>
  ⟨fun hsl => (hs l hl hsl).imp fun x hx => ⟨Or.inl hx.1, hx.2⟩, fun htl =>
    (ht l hl htl).imp fun x hx => ⟨Or.inr hx.1, hx.2⟩⟩
state_before: α : Type u
β : Type v
inst✝ : UniformSpace α
s t : Set α
hs : ∀ (l : Ultrafilter α), Cauchy ↑l → s ∈ l → ∃ x, x ∈ s ∧ ↑l ≤ 𝓝 x
ht : ∀ (l : Ultrafilter α), Cauchy ↑l → t ∈ l → ∃ x, x ∈ t ∧ ↑l ≤ 𝓝 x
⊢ ∀ (l : Ultrafilter α), Cauchy ↑l → (s ∈ l → ∃ x, x ∈ s ∪ t ∧ ↑l ≤ 𝓝 x) ∧ (t ∈ l → ∃ x, x ∈ s ∪ t ∧ ↑l ≤ 𝓝 x)
Theorem: Polynomial.hasseDeriv_apply_one
File: Mathlib/Data/Polynomial/HasseDeriv.lean

tactic: rw [← C_1, hasseDeriv_C k _ hk]
state_before: R : Type u_1
inst✝ : Semiring R
k : ℕ
f : R[X]
hk : 0 < k
⊢ ↑(hasseDeriv k) 1 = 0
Theorem: Zsqrtd.coe_int_dvd_iff
File: Mathlib/NumberTheory/Zsqrtd/Basic.lean

tactic: constructor
state_before: d z : ℤ
a : ℤ√d
⊢ ↑z ∣ a ↔ z ∣ a.re ∧ z ∣ a.im

tactic: rintro ⟨x, rfl⟩
state_before: case mp
d z : ℤ
a : ℤ√d
⊢ ↑z ∣ a → z ∣ a.re ∧ z ∣ a.im

tactic: simp only [add_zero, coe_int_re, MulZeroClass.zero_mul, mul_im, dvd_mul_right, and_self_iff,
  mul_re, mul_zero, coe_int_im]
state_before: case mp.intro
d z : ℤ
x : ℤ√d
⊢ z ∣ (↑z * x).re ∧ z ∣ (↑z * x).im

tactic: rintro ⟨⟨r, hr⟩, ⟨i, hi⟩⟩
state_before: case mpr
d z : ℤ
a : ℤ√d
⊢ z ∣ a.re ∧ z ∣ a.im → ↑z ∣ a

tactic: use ⟨r, i⟩
state_before: case mpr.intro.intro.intro
d z : ℤ
a : ℤ√d
r : ℤ
hr : a.re = z * r
i : ℤ
hi : a.im = z * i
⊢ ↑z ∣ a

tactic: rw [smul_val, ext]
state_before: case mpr.intro.intro.intro
d z : ℤ
a : ℤ√d
r : ℤ
hr : a.re = z * r
i : ℤ
hi : a.im = z * i
⊢ a = ↑z * { re := r, im := i }

tactic: exact ⟨hr, hi⟩
state_before: case mpr.intro.intro.intro
d z : ℤ
a : ℤ√d
r : ℤ
hr : a.re = z * r
i : ℤ
hi : a.im = z * i
⊢ a.re = { re := z * r, im := z * i }.re ∧ a.im = { re := z * r, im := z * i }.im
Theorem: List.ofFn_succ
File: Mathlib/Data/List/OfFn.lean

tactic: simp
state_before: α : Type u
n : ℕ
f : Fin (succ n) → α
⊢ length (ofFn f) = length (f 0 :: ofFn fun i => f (Fin.succ i))

tactic: cases i
state_before: α : Type u
n : ℕ
f : Fin (succ n) → α
i : ℕ
hi₁ : i < length (ofFn f)
hi₂ : i < length (f 0 :: ofFn fun i => f (Fin.succ i))
⊢ get (ofFn f) { val := i, isLt := hi₁ } = get (f 0 :: ofFn fun i => f (Fin.succ i)) { val := i, isLt := hi₂ }

tactic: . simp
state_before: case zero
α : Type u
n : ℕ
f : Fin (succ n) → α
hi₁ : zero < length (ofFn f)
hi₂ : zero < length (f 0 :: ofFn fun i => f (Fin.succ i))
⊢ get (ofFn f) { val := zero, isLt := hi₁ } = get (f 0 :: ofFn fun i => f (Fin.succ i)) { val := zero, isLt := hi₂ }

case succ
α : Type u
n : ℕ
f : Fin (succ n) → α
n✝ : ℕ
hi₁ : succ n✝ < length (ofFn f)
hi₂ : succ n✝ < length (f 0 :: ofFn fun i => f (Fin.succ i))
⊢ get (ofFn f) { val := succ n✝, isLt := hi₁ } =
    get (f 0 :: ofFn fun i => f (Fin.succ i)) { val := succ n✝, isLt := hi₂ }

tactic: . simp
state_before: case succ
α : Type u
n : ℕ
f : Fin (succ n) → α
n✝ : ℕ
hi₁ : succ n✝ < length (ofFn f)
hi₂ : succ n✝ < length (f 0 :: ofFn fun i => f (Fin.succ i))
⊢ get (ofFn f) { val := succ n✝, isLt := hi₁ } =
    get (f 0 :: ofFn fun i => f (Fin.succ i)) { val := succ n✝, isLt := hi₂ }

tactic: simp
state_before: case zero
α : Type u
n : ℕ
f : Fin (succ n) → α
hi₁ : zero < length (ofFn f)
hi₂ : zero < length (f 0 :: ofFn fun i => f (Fin.succ i))
⊢ get (ofFn f) { val := zero, isLt := hi₁ } = get (f 0 :: ofFn fun i => f (Fin.succ i)) { val := zero, isLt := hi₂ }

tactic: simp
state_before: case succ
α : Type u
n : ℕ
f : Fin (succ n) → α
n✝ : ℕ
hi₁ : succ n✝ < length (ofFn f)
hi₂ : succ n✝ < length (f 0 :: ofFn fun i => f (Fin.succ i))
⊢ get (ofFn f) { val := succ n✝, isLt := hi₁ } =
    get (f 0 :: ofFn fun i => f (Fin.succ i)) { val := succ n✝, isLt := hi₂ }
Theorem: Mathlib.Meta.NormNum.minFacHelper_2
File: Mathlib/Tactic/NormNum/Prime.lean

tactic: refine minFacHelper_1 e h λ h2 ↦ ?_
state_before: n k k' : ℕ
e : k + 2 = k'
nk : ¬Nat.Prime k
h : MinFacHelper n k
⊢ MinFacHelper n k'

tactic: rw [← h2] at nk
state_before: n k k' : ℕ
e : k + 2 = k'
nk : ¬Nat.Prime k
h : MinFacHelper n k
h2 : minFac n = k
⊢ False

tactic: exact nk <| minFac_prime h.one_lt.ne'
state_before: n k k' : ℕ
e : k + 2 = k'
nk : ¬Nat.Prime (minFac n)
h : MinFacHelper n k
h2 : minFac n = k
⊢ False
Theorem: Int.le.intro
File: Std/Data/Int/Lemmas.lean

tactic: rw [← h, Int.add_comm]
state_before: a b : Int
n : Nat
h : a + ↑n = b
⊢ b - a = ↑n

tactic: simp [Int.sub_eq_add_neg, Int.add_assoc]
state_before: a b : Int
n : Nat
h : a + ↑n = b
⊢ ↑n + a - a = ↑n
Theorem: Nat.ArithmeticFunction.cardDistinctFactors_apply_prime_pow
File: Mathlib/NumberTheory/ArithmeticFunction.lean

tactic: rw [cardDistinctFactors_apply, hp.factors_pow, List.replicate_dedup hk, List.length_singleton]
state_before: R : Type ?u.569893
p k : ℕ
hp : Prime p
hk : k ≠ 0
⊢ ↑ω (p ^ k) = 1
Theorem: CategoryTheory.Limits.HasImage.uniq
File: Mathlib/CategoryTheory/Limits/Shapes/Images.lean

tactic: simp [w]
state_before: C : Type u
inst✝¹ : Category C
X Y : C
f : X ⟶ Y
inst✝ : HasImage f
F' : MonoFactorisation f
l : image f ⟶ F'.I
w : l ≫ F'.m = image.ι f
⊢ l ≫ F'.m = image.lift F' ≫ F'.m
Theorem: MeasureTheory.snorm'_trim
File: Mathlib/MeasureTheory/Function/LpSeminorm.lean

tactic: simp_rw [snorm']
state_before: α : Type u_1
E : Type u_2
F : Type ?u.3169381
G : Type ?u.3169384
m m0 : MeasurableSpace α
p : ℝ≥0∞
q : ℝ
μ ν : Measure α
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedAddCommGroup G
hm : m ≤ m0
f : α → E
hf : StronglyMeasurable f
⊢ snorm' f q (Measure.trim ν hm) = snorm' f q ν

tactic: congr 1
state_before: α : Type u_1
E : Type u_2
F : Type ?u.3169381
G : Type ?u.3169384
m m0 : MeasurableSpace α
p : ℝ≥0∞
q : ℝ
μ ν : Measure α
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedAddCommGroup G
hm : m ≤ m0
f : α → E
hf : StronglyMeasurable f
⊢ (∫⁻ (a : α), ↑‖f a‖₊ ^ q ∂Measure.trim ν hm) ^ (1 / q) = (∫⁻ (a : α), ↑‖f a‖₊ ^ q ∂ν) ^ (1 / q)

tactic: refine' lintegral_trim hm _
state_before: case e_a
α : Type u_1
E : Type u_2
F : Type ?u.3169381
G : Type ?u.3169384
m m0 : MeasurableSpace α
p : ℝ≥0∞
q : ℝ
μ ν : Measure α
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedAddCommGroup G
hm : m ≤ m0
f : α → E
hf : StronglyMeasurable f
⊢ (∫⁻ (a : α), ↑‖f a‖₊ ^ q ∂Measure.trim ν hm) = ∫⁻ (a : α), ↑‖f a‖₊ ^ q ∂ν

tactic: refine' @Measurable.pow_const _ _ _ _ _ _ _ m _ (@Measurable.coe_nnreal_ennreal _ m _ _) q
state_before: case e_a
α : Type u_1
E : Type u_2
F : Type ?u.3169381
G : Type ?u.3169384
m m0 : MeasurableSpace α
p : ℝ≥0∞
q : ℝ
μ ν : Measure α
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedAddCommGroup G
hm : m ≤ m0
f : α → E
hf : StronglyMeasurable f
⊢ Measurable fun a => ↑‖f a‖₊ ^ q

tactic: apply @StronglyMeasurable.measurable
state_before: case e_a
α : Type u_1
E : Type u_2
F : Type ?u.3169381
G : Type ?u.3169384
m m0 : MeasurableSpace α
p : ℝ≥0∞
q : ℝ
μ ν : Measure α
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedAddCommGroup G
hm : m ≤ m0
f : α → E
hf : StronglyMeasurable f
⊢ Measurable fun a => ‖f a‖₊

tactic: exact @StronglyMeasurable.nnnorm α m _ _ _ hf
state_before: case e_a.hf
α : Type u_1
E : Type u_2
F : Type ?u.3169381
G : Type ?u.3169384
m m0 : MeasurableSpace α
p : ℝ≥0∞
q : ℝ
μ ν : Measure α
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedAddCommGroup G
hm : m ≤ m0
f : α → E
hf : StronglyMeasurable f
⊢ StronglyMeasurable fun a => ‖f a‖₊
Theorem: Finset.weightedVSubOfPoint_apply_const
File: Mathlib/LinearAlgebra/AffineSpace/Combination.lean

tactic: rw [weightedVSubOfPoint_apply, sum_smul]
state_before: k : Type u_3
V : Type u_1
P : Type u_4
inst✝² : Ring k
inst✝¹ : AddCommGroup V
inst✝ : Module k V
S : AffineSpace V P
ι : Type u_2
s : Finset ι
ι₂ : Type ?u.17439
s₂ : Finset ι₂
w : ι → k
p b : P
⊢ ↑(weightedVSubOfPoint s (fun x => p) b) w = (∑ i in s, w i) • (p -ᵥ b)
Theorem: MeasureTheory.integrableOn_finite_biUnion
File: Mathlib/MeasureTheory/Integral/IntegrableOn.lean

tactic: refine hs.induction_on ?_ ?_
state_before: α : Type u_2
β : Type u_1
E : Type u_3
F : Type ?u.1506239
inst✝¹ : MeasurableSpace α
inst✝ : NormedAddCommGroup E
f g : α → E
s✝ t✝ : Set α
μ ν : Measure α
s : Set β
hs : Set.Finite s
t : β → Set α
⊢ IntegrableOn f (⋃ (i : β) (_ : i ∈ s), t i) ↔ ∀ (i : β), i ∈ s → IntegrableOn f (t i)

tactic: simp
state_before: case refine_1
α : Type u_2
β : Type u_1
E : Type u_3
F : Type ?u.1506239
inst✝¹ : MeasurableSpace α
inst✝ : NormedAddCommGroup E
f g : α → E
s✝ t✝ : Set α
μ ν : Measure α
s : Set β
hs : Set.Finite s
t : β → Set α
⊢ IntegrableOn f (⋃ (i : β) (_ : i ∈ ∅), t i) ↔ ∀ (i : β), i ∈ ∅ → IntegrableOn f (t i)

tactic: intro a s _ _ hf
state_before: case refine_2
α : Type u_2
β : Type u_1
E : Type u_3
F : Type ?u.1506239
inst✝¹ : MeasurableSpace α
inst✝ : NormedAddCommGroup E
f g : α → E
s✝ t✝ : Set α
μ ν : Measure α
s : Set β
hs : Set.Finite s
t : β → Set α
⊢ ∀ {a : β} {s : Set β},
    ¬a ∈ s →
      Set.Finite s →
        (IntegrableOn f (⋃ (i : β) (_ : i ∈ s), t i) ↔ ∀ (i : β), i ∈ s → IntegrableOn f (t i)) →
          (IntegrableOn f (⋃ (i : β) (_ : i ∈ insert a s), t i) ↔ ∀ (i : β), i ∈ insert a s → IntegrableOn f (t i))

tactic: simp [hf, or_imp, forall_and]
state_before: case refine_2
α : Type u_2
β : Type u_1
E : Type u_3
F : Type ?u.1506239
inst✝¹ : MeasurableSpace α
inst✝ : NormedAddCommGroup E
f g : α → E
s✝¹ t✝ : Set α
μ ν : Measure α
s✝ : Set β
hs : Set.Finite s✝
t : β → Set α
a : β
s : Set β
a✝¹ : ¬a ∈ s
a✝ : Set.Finite s
hf : IntegrableOn f (⋃ (i : β) (_ : i ∈ s), t i) ↔ ∀ (i : β), i ∈ s → IntegrableOn f (t i)
⊢ IntegrableOn f (⋃ (i : β) (_ : i ∈ insert a s), t i) ↔ ∀ (i : β), i ∈ insert a s → IntegrableOn f (t i)
Theorem: Complex.log_I
File: Mathlib/Analysis/SpecialFunctions/Complex/Log.lean

tactic: simp [log]
state_before: ⊢ log I = ↑π / 2 * I
Theorem: Option.orElse_eq_none
File: Mathlib/Data/Option/Basic.lean

tactic: cases o
state_before: α : Type u_1
β : Type ?u.19607
γ : Type ?u.19610
δ : Type ?u.19613
o o' : Option α
⊢ (HOrElse.hOrElse o fun x => o') = none ↔ o = none ∧ o' = none

tactic: simp only [true_and, none_orElse, eq_self_iff_true]
state_before: case none
α : Type u_1
β : Type ?u.19607
γ : Type ?u.19610
δ : Type ?u.19613
o' : Option α
⊢ (HOrElse.hOrElse none fun x => o') = none ↔ none = none ∧ o' = none

tactic: simp only [some_orElse, false_and]
state_before: case some
α : Type u_1
β : Type ?u.19607
γ : Type ?u.19610
δ : Type ?u.19613
o' : Option α
val✝ : α
⊢ (HOrElse.hOrElse (some val✝) fun x => o') = none ↔ some val✝ = none ∧ o' = none
Theorem: TopologicalSpace.IsTopologicalBasis.isOpenMap_iff
File: Mathlib/Topology/Bases.lean

tactic: refine' ⟨fun H o ho => H _ (hB.isOpen ho), fun hf o ho => _⟩
state_before: α : Type u
t : TopologicalSpace α
β : Type u_1
inst✝ : TopologicalSpace β
B : Set (Set α)
hB : IsTopologicalBasis B
f : α → β
⊢ IsOpenMap f ↔ ∀ (s : Set α), s ∈ B → IsOpen (f '' s)

tactic: rw [hB.open_eq_sUnion' ho, sUnion_eq_iUnion, image_iUnion]
state_before: α : Type u
t : TopologicalSpace α
β : Type u_1
inst✝ : TopologicalSpace β
B : Set (Set α)
hB : IsTopologicalBasis B
f : α → β
hf : ∀ (s : Set α), s ∈ B → IsOpen (f '' s)
o : Set α
ho : IsOpen o
⊢ IsOpen (f '' o)

tactic: exact isOpen_iUnion fun s => hf s s.2.1
state_before: α : Type u
t : TopologicalSpace α
β : Type u_1
inst✝ : TopologicalSpace β
B : Set (Set α)
hB : IsTopologicalBasis B
f : α → β
hf : ∀ (s : Set α), s ∈ B → IsOpen (f '' s)
o : Set α
ho : IsOpen o
⊢ IsOpen (⋃ (i : ↑{s | s ∈ B ∧ s ⊆ o}), f '' ↑i)
Theorem: MvPolynomial.rename_eval₂
File: Mathlib/Data/MvPolynomial/Rename.lean

tactic: intros
state_before: case h_X
σ : Type u_1
τ : Type u_3
α : Type ?u.539883
R : Type u_2
S : Type ?u.539889
inst✝¹ : CommSemiring R
inst✝ : CommSemiring S
f : R →+* S
k : σ → τ
g✝ : τ → S
p : MvPolynomial σ R
g : τ → MvPolynomial σ R
⊢ ∀ (p : MvPolynomial σ R) (n : σ),
    ↑(rename k) (eval₂ C (g ∘ k) p) = eval₂ C (↑(rename k) ∘ g) (↑(rename k) p) →
      ↑(rename k) (eval₂ C (g ∘ k) (p * X n)) = eval₂ C (↑(rename k) ∘ g) (↑(rename k) (p * X n))

tactic: simp [*]
state_before: case h_X
σ : Type u_1
τ : Type u_3
α : Type ?u.539883
R : Type u_2
S : Type ?u.539889
inst✝¹ : CommSemiring R
inst✝ : CommSemiring S
f : R →+* S
k : σ → τ
g✝ : τ → S
p : MvPolynomial σ R
g : τ → MvPolynomial σ R
p✝ : MvPolynomial σ R
n✝ : σ
a✝ : ↑(rename k) (eval₂ C (g ∘ k) p✝) = eval₂ C (↑(rename k) ∘ g) (↑(rename k) p✝)
⊢ ↑(rename k) (eval₂ C (g ∘ k) (p✝ * X n✝)) = eval₂ C (↑(rename k) ∘ g) (↑(rename k) (p✝ * X n✝))
Theorem: Matrix.blockDiag_diagonal
File: Mathlib/Data/Matrix/Block.lean

tactic: obtain rfl | hij := Decidable.eq_or_ne i j
state_before: l : Type ?u.178877
m : Type u_2
n : Type ?u.178883
o : Type u_1
p : Type ?u.178889
q : Type ?u.178892
m' : o → Type ?u.178897
n' : o → Type ?u.178902
p' : o → Type ?u.178907
R : Type ?u.178910
S : Type ?u.178913
α : Type u_3
β : Type ?u.178919
inst✝³ : Zero α
inst✝² : Zero β
inst✝¹ : DecidableEq o
inst✝ : DecidableEq m
d : m × o → α
k : o
i j : m
⊢ blockDiag (diagonal d) k i j = diagonal (fun i => d (i, k)) i j

tactic: rw [blockDiag_apply, diagonal_apply_eq, diagonal_apply_eq]
state_before: case inl
l : Type ?u.178877
m : Type u_2
n : Type ?u.178883
o : Type u_1
p : Type ?u.178889
q : Type ?u.178892
m' : o → Type ?u.178897
n' : o → Type ?u.178902
p' : o → Type ?u.178907
R : Type ?u.178910
S : Type ?u.178913
α : Type u_3
β : Type ?u.178919
inst✝³ : Zero α
inst✝² : Zero β
inst✝¹ : DecidableEq o
inst✝ : DecidableEq m
d : m × o → α
k : o
i : m
⊢ blockDiag (diagonal d) k i i = diagonal (fun i => d (i, k)) i i

tactic: rw [blockDiag_apply, diagonal_apply_ne _ hij, diagonal_apply_ne _ (mt _ hij)]
state_before: case inr
l : Type ?u.178877
m : Type u_2
n : Type ?u.178883
o : Type u_1
p : Type ?u.178889
q : Type ?u.178892
m' : o → Type ?u.178897
n' : o → Type ?u.178902
p' : o → Type ?u.178907
R : Type ?u.178910
S : Type ?u.178913
α : Type u_3
β : Type ?u.178919
inst✝³ : Zero α
inst✝² : Zero β
inst✝¹ : DecidableEq o
inst✝ : DecidableEq m
d : m × o → α
k : o
i j : m
hij : i ≠ j
⊢ blockDiag (diagonal d) k i j = diagonal (fun i => d (i, k)) i j

tactic: exact Prod.fst_eq_iff.mpr
state_before: l : Type ?u.178877
m : Type u_2
n : Type ?u.178883
o : Type u_1
p : Type ?u.178889
q : Type ?u.178892
m' : o → Type ?u.178897
n' : o → Type ?u.178902
p' : o → Type ?u.178907
R : Type ?u.178910
S : Type ?u.178913
α : Type u_3
β : Type ?u.178919
inst✝³ : Zero α
inst✝² : Zero β
inst✝¹ : DecidableEq o
inst✝ : DecidableEq m
d : m × o → α
k : o
i j : m
hij : i ≠ j
⊢ (i, k) = (j, k) → i = j
Theorem: Multiset.map_mk_eq_map_mk_of_rel
File: Mathlib/Data/Multiset/Basic.lean

tactic: simp [ih, Quot.sound hab]
state_before: α : Type u_1
β : Type ?u.478700
γ : Type ?u.478703
r : α → α → Prop
s t : Multiset α
hst : Rel r s t
a✝ b✝ : α
as✝ bs✝ : Multiset α
hab : r a✝ b✝
_hst : Rel r as✝ bs✝
ih : map (Quot.mk r) as✝ = map (Quot.mk r) bs✝
⊢ map (Quot.mk r) (a✝ ::ₘ as✝) = map (Quot.mk r) (b✝ ::ₘ bs✝)
Theorem: Equiv.Perm.sign_sumCongr
File: Mathlib/GroupTheory/Perm/Sign.lean

tactic: suffices sign (sumCongr σa (1 : Perm β)) = sign σa ∧ sign (sumCongr (1 : Perm α) σb) = sign σb
  by rw [← this.1, ← this.2, ← sign_mul, sumCongr_mul, one_mul, mul_one]
state_before: α : Type u
β : Type v
inst✝³ : DecidableEq α
inst✝² : Fintype α
inst✝¹ : DecidableEq β
inst✝ : Fintype β
σa : Perm α
σb : Perm β
⊢ ↑sign (sumCongr σa σb) = ↑sign σa * ↑sign σb

tactic: constructor
state_before: α : Type u
β : Type v
inst✝³ : DecidableEq α
inst✝² : Fintype α
inst✝¹ : DecidableEq β
inst✝ : Fintype β
σa : Perm α
σb : Perm β
⊢ ↑sign (sumCongr σa 1) = ↑sign σa ∧ ↑sign (sumCongr 1 σb) = ↑sign σb

tactic: rw [← this.1, ← this.2, ← sign_mul, sumCongr_mul, one_mul, mul_one]
state_before: α : Type u
β : Type v
inst✝³ : DecidableEq α
inst✝² : Fintype α
inst✝¹ : DecidableEq β
inst✝ : Fintype β
σa : Perm α
σb : Perm β
this : ↑sign (sumCongr σa 1) = ↑sign σa ∧ ↑sign (sumCongr 1 σb) = ↑sign σb
⊢ ↑sign (sumCongr σa σb) = ↑sign σa * ↑sign σb

tactic: refine' σa.swap_induction_on ?_ fun σa' a₁ a₂ ha ih => ?_
state_before: case left
α : Type u
β : Type v
inst✝³ : DecidableEq α
inst✝² : Fintype α
inst✝¹ : DecidableEq β
inst✝ : Fintype β
σa : Perm α
σb : Perm β
⊢ ↑sign (sumCongr σa 1) = ↑sign σa

tactic: simp
state_before: case left.refine'_1
α : Type u
β : Type v
inst✝³ : DecidableEq α
inst✝² : Fintype α
inst✝¹ : DecidableEq β
inst✝ : Fintype β
σa : Perm α
σb : Perm β
⊢ ↑sign (sumCongr 1 1) = ↑sign 1

tactic: rw [← one_mul (1 : Perm β), ← sumCongr_mul, sign_mul, sign_mul, ih, sumCongr_swap_one,
  sign_swap ha, sign_swap (Sum.inl_injective.ne_iff.mpr ha)]
state_before: case left.refine'_2
α : Type u
β : Type v
inst✝³ : DecidableEq α
inst✝² : Fintype α
inst✝¹ : DecidableEq β
inst✝ : Fintype β
σa : Perm α
σb : Perm β
σa' : Perm α
a₁ a₂ : α
ha : a₁ ≠ a₂
ih : ↑sign (sumCongr σa' 1) = ↑sign σa'
⊢ ↑sign (sumCongr (swap a₁ a₂ * σa') 1) = ↑sign (swap a₁ a₂ * σa')

tactic: refine' σb.swap_induction_on ?_ fun σb' b₁ b₂ hb ih => ?_
state_before: case right
α : Type u
β : Type v
inst✝³ : DecidableEq α
inst✝² : Fintype α
inst✝¹ : DecidableEq β
inst✝ : Fintype β
σa : Perm α
σb : Perm β
⊢ ↑sign (sumCongr 1 σb) = ↑sign σb

tactic: simp
state_before: case right.refine'_1
α : Type u
β : Type v
inst✝³ : DecidableEq α
inst✝² : Fintype α
inst✝¹ : DecidableEq β
inst✝ : Fintype β
σa : Perm α
σb : Perm β
⊢ ↑sign (sumCongr 1 1) = ↑sign 1

tactic: rw [← one_mul (1 : Perm α), ← sumCongr_mul, sign_mul, sign_mul, ih, sumCongr_one_swap,
  sign_swap hb, sign_swap (Sum.inr_injective.ne_iff.mpr hb)]
state_before: case right.refine'_2
α : Type u
β : Type v
inst✝³ : DecidableEq α
inst✝² : Fintype α
inst✝¹ : DecidableEq β
inst✝ : Fintype β
σa : Perm α
σb σb' : Perm β
b₁ b₂ : β
hb : b₁ ≠ b₂
ih : ↑sign (sumCongr 1 σb') = ↑sign σb'
⊢ ↑sign (sumCongr 1 (swap b₁ b₂ * σb')) = ↑sign (swap b₁ b₂ * σb')
Theorem: Real.lt_sq_of_sqrt_lt
File: Mathlib/Data/Real/Sqrt.lean

tactic: have hy := x.sqrt_nonneg.trans_lt h
state_before: x y : ℝ
h : sqrt x < y
⊢ x < y ^ 2

tactic: rwa [← sqrt_lt_sqrt_iff_of_pos (sq_pos_of_pos hy), sqrt_sq hy.le]
state_before: x y : ℝ
h : sqrt x < y
hy : 0 < y
⊢ x < y ^ 2
Theorem: Finset.sum_card_le
File: Mathlib/Algebra/BigOperators/Order.lean

tactic: simp_rw [univ_inter]
state_before: ι : Type ?u.105253
α : Type u_1
β : Type ?u.105259
M : Type ?u.105262
N : Type ?u.105265
G : Type ?u.105268
k : Type ?u.105271
R : Type ?u.105274
inst✝¹ : DecidableEq α
s : Finset α
B : Finset (Finset α)
n : ℕ
inst✝ : Fintype α
h : ∀ (a : α), card (filter ((fun x x_1 => x ∈ x_1) a) B) ≤ n
⊢ ∑ s in B, card s = ∑ s in B, card (univ ∩ s)
Theorem: FreeProduct.lift_range_le
File: Mathlib/GroupTheory/FreeProduct.lean

tactic: rintro _ ⟨x, rfl⟩
state_before: ι : Type u_3
M : ι → Type ?u.337350
inst✝³ : (i : ι) → Monoid (M i)
N✝ : Type ?u.337361
inst✝² : Monoid N✝
G : ι → Type u_2
inst✝¹ : (i : ι) → Group (G i)
N : Type u_1
inst✝ : Group N
f : (i : ι) → G i →* N
s : Subgroup N
h : ∀ (i : ι), MonoidHom.range (f i) ≤ s
⊢ MonoidHom.range (↑lift f) ≤ s

tactic: induction' x using FreeProduct.induction_on with i x x y hx hy
state_before: case intro
ι : Type u_3
M : ι → Type ?u.337350
inst✝³ : (i : ι) → Monoid (M i)
N✝ : Type ?u.337361
inst✝² : Monoid N✝
G : ι → Type u_2
inst✝¹ : (i : ι) → Group (G i)
N : Type u_1
inst✝ : Group N
f : (i : ι) → G i →* N
s : Subgroup N
h : ∀ (i : ι), MonoidHom.range (f i) ≤ s
x : FreeProduct fun i => G i
⊢ ↑(↑lift f) x ∈ s

tactic: exact s.one_mem
state_before: case intro.h_one
ι : Type u_3
M : ι → Type ?u.337350
inst✝³ : (i : ι) → Monoid (M i)
N✝ : Type ?u.337361
inst✝² : Monoid N✝
G : ι → Type u_2
inst✝¹ : (i : ι) → Group (G i)
N : Type u_1
inst✝ : Group N
f : (i : ι) → G i →* N
s : Subgroup N
h : ∀ (i : ι), MonoidHom.range (f i) ≤ s
⊢ ↑(↑lift f) 1 ∈ s

tactic: simp only [lift_of, SetLike.mem_coe]
state_before: case intro.h_of
ι : Type u_3
M : ι → Type ?u.337350
inst✝³ : (i : ι) → Monoid (M i)
N✝ : Type ?u.337361
inst✝² : Monoid N✝
G : ι → Type u_2
inst✝¹ : (i : ι) → Group (G i)
N : Type u_1
inst✝ : Group N
f : (i : ι) → G i →* N
s : Subgroup N
h : ∀ (i : ι), MonoidHom.range (f i) ≤ s
i : ι
x : G i
⊢ ↑(↑lift f) (↑of x) ∈ s

tactic: exact h i (Set.mem_range_self x)
state_before: case intro.h_of
ι : Type u_3
M : ι → Type ?u.337350
inst✝³ : (i : ι) → Monoid (M i)
N✝ : Type ?u.337361
inst✝² : Monoid N✝
G : ι → Type u_2
inst✝¹ : (i : ι) → Group (G i)
N : Type u_1
inst✝ : Group N
f : (i : ι) → G i →* N
s : Subgroup N
h : ∀ (i : ι), MonoidHom.range (f i) ≤ s
i : ι
x : G i
⊢ ↑(f i) x ∈ s

tactic: simp only [map_mul, SetLike.mem_coe]
state_before: case intro.h_mul
ι : Type u_3
M : ι → Type ?u.337350
inst✝³ : (i : ι) → Monoid (M i)
N✝ : Type ?u.337361
inst✝² : Monoid N✝
G : ι → Type u_2
inst✝¹ : (i : ι) → Group (G i)
N : Type u_1
inst✝ : Group N
f : (i : ι) → G i →* N
s : Subgroup N
h : ∀ (i : ι), MonoidHom.range (f i) ≤ s
x y : FreeProduct fun i => G i
hx : ↑(↑lift f) x ∈ s
hy : ↑(↑lift f) y ∈ s
⊢ ↑(↑lift f) (x * y) ∈ s

tactic: exact s.mul_mem hx hy
state_before: case intro.h_mul
ι : Type u_3
M : ι → Type ?u.337350
inst✝³ : (i : ι) → Monoid (M i)
N✝ : Type ?u.337361
inst✝² : Monoid N✝
G : ι → Type u_2
inst✝¹ : (i : ι) → Group (G i)
N : Type u_1
inst✝ : Group N
f : (i : ι) → G i →* N
s : Subgroup N
h : ∀ (i : ι), MonoidHom.range (f i) ≤ s
x y : FreeProduct fun i => G i
hx : ↑(↑lift f) x ∈ s
hy : ↑(↑lift f) y ∈ s
⊢ ↑(↑lift f) x * ↑(↑lift f) y ∈ s
Theorem: padicNorm.sub
File: Mathlib/NumberTheory/Padics/PadicNorm.lean

tactic: rw [sub_eq_add_neg, ← padicNorm.neg r]
state_before: p : ℕ
hp : Fact (Nat.Prime p)
q r : ℚ
⊢ padicNorm p (q - r) ≤ max (padicNorm p q) (padicNorm p r)

tactic: exact padicNorm.nonarchimedean
state_before: p : ℕ
hp : Fact (Nat.Prime p)
q r : ℚ
⊢ padicNorm p (q + -r) ≤ max (padicNorm p q) (padicNorm p (-r))
Theorem: EqualCharZero.of_algebraRat
File: Mathlib/Algebra/CharP/MixedCharZero.lean

tactic: intro I hI
state_before: R : Type u_1
inst✝¹ : CommRing R
inst✝ : Algebra ℚ R
⊢ ∀ (I : Ideal R), I ≠ ⊤ → CharZero (R ⧸ I)

tactic: constructor
state_before: R : Type u_1
inst✝¹ : CommRing R
inst✝ : Algebra ℚ R
I : Ideal R
hI : I ≠ ⊤
⊢ CharZero (R ⧸ I)

tactic: intro a b h_ab
state_before: case cast_injective
R : Type u_1
inst✝¹ : CommRing R
inst✝ : Algebra ℚ R
I : Ideal R
hI : I ≠ ⊤
⊢ Function.Injective Nat.cast

tactic: contrapose! hI
state_before: case cast_injective
R : Type u_1
inst✝¹ : CommRing R
inst✝ : Algebra ℚ R
I : Ideal R
hI : I ≠ ⊤
a b : ℕ
h_ab : ↑a = ↑b
⊢ a = b

tactic: refine' I.eq_top_of_isUnit_mem _ (IsUnit.map (algebraMap ℚ R) (IsUnit.mk0 (a - b : ℚ) _))
state_before: case cast_injective
R : Type u_1
inst✝¹ : CommRing R
inst✝ : Algebra ℚ R
I : Ideal R
a b : ℕ
h_ab : ↑a = ↑b
hI : a ≠ b
⊢ I = ⊤

tactic: simpa only [Ne.def, sub_eq_zero] using (@Nat.cast_injective ℚ _ _).ne hI
state_before: case cast_injective.refine'_2
R : Type u_1
inst✝¹ : CommRing R
inst✝ : Algebra ℚ R
I : Ideal R
a b : ℕ
h_ab : ↑a = ↑b
hI : a ≠ b
⊢ ↑a - ↑b ≠ 0

tactic: simpa only [← Ideal.Quotient.eq_zero_iff_mem, map_sub, sub_eq_zero, map_natCast]
state_before: case cast_injective.refine'_1
R : Type u_1
inst✝¹ : CommRing R
inst✝ : Algebra ℚ R
I : Ideal R
a b : ℕ
h_ab : ↑a = ↑b
hI : a ≠ b
⊢ ↑(algebraMap ℚ R) (↑a - ↑b) ∈ I