tasksource/leandojo huggingface dataset:
Theorem: MulSalemSpencer.image
File: Mathlib/Combinatorics/Additive/SalemSpencer.lean

tactic: rintro _ _ _ ⟨a, ha, rfl⟩ ⟨b, hb, rfl⟩ ⟨c, hc, rfl⟩ habc
state_before: F : Type u_1
α : Type u_2
β : Type u_3
𝕜 : Type ?u.12908
E : Type ?u.12911
inst✝² : CommMonoid α
inst✝¹ : CommMonoid β
s : Set α
a : α
inst✝ : MulHomClass F α β
f : F
hf : InjOn (↑f) (s * s)
h : MulSalemSpencer s
⊢ MulSalemSpencer (↑f '' s)

tactic: rw [h ha hb hc (hf (mul_mem_mul ha hb) (mul_mem_mul hc hc) <| by rwa [map_mul, map_mul])]
state_before: case intro.intro.intro.intro.intro.intro
F : Type u_1
α : Type u_2
β : Type u_3
𝕜 : Type ?u.12908
E : Type ?u.12911
inst✝² : CommMonoid α
inst✝¹ : CommMonoid β
s : Set α
a✝ : α
inst✝ : MulHomClass F α β
f : F
hf : InjOn (↑f) (s * s)
h : MulSalemSpencer s
a : α
ha : a ∈ s
b : α
hb : b ∈ s
c : α
hc : c ∈ s
habc : ↑f a * ↑f b = ↑f c * ↑f c
⊢ ↑f a = ↑f b

tactic: rwa [map_mul, map_mul]
state_before: F : Type u_1
α : Type u_2
β : Type u_3
𝕜 : Type ?u.12908
E : Type ?u.12911
inst✝² : CommMonoid α
inst✝¹ : CommMonoid β
s : Set α
a✝ : α
inst✝ : MulHomClass F α β
f : F
hf : InjOn (↑f) (s * s)
h : MulSalemSpencer s
a : α
ha : a ∈ s
b : α
hb : b ∈ s
c : α
hc : c ∈ s
habc : ↑f a * ↑f b = ↑f c * ↑f c
⊢ ↑f (a * b) = ↑f (c * c)
Theorem: Equiv.Perm.apply_mem_support
File: Mathlib/GroupTheory/Perm/Support.lean

tactic: rw [mem_support, mem_support, Ne.def, Ne.def, apply_eq_iff_eq]
state_before: α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
f g : Perm α
x : α
⊢ ↑f x ∈ support f ↔ x ∈ support f
Theorem: Multiset.ndinsert_le
File: Mathlib/Data/Multiset/FinsetOps.lean

tactic: simp [h, l]
state_before: α : Type u_1
inst✝ : DecidableEq α
s✝ : Multiset α
a : α
s t : Multiset α
x✝ : s ≤ t ∧ a ∈ t
l : s ≤ t
m : a ∈ t
h : a ∈ s
⊢ ndinsert a s ≤ t

tactic: rw [ndinsert_of_not_mem h, ← cons_erase m, cons_le_cons_iff, ← le_cons_of_not_mem h,
    cons_erase m]
state_before: α : Type u_1
inst✝ : DecidableEq α
s✝ : Multiset α
a : α
s t : Multiset α
x✝ : s ≤ t ∧ a ∈ t
l : s ≤ t
m : a ∈ t
h : ¬a ∈ s
⊢ ndinsert a s ≤ t

tactic: exact l
state_before: α : Type u_1
inst✝ : DecidableEq α
s✝ : Multiset α
a : α
s t : Multiset α
x✝ : s ≤ t ∧ a ∈ t
l : s ≤ t
m : a ∈ t
h : ¬a ∈ s
⊢ s ≤ t
Theorem: Int.natAbs_eq_iff_associated
File: Mathlib/Data/Int/Associated.lean

tactic: refine' Int.natAbs_eq_natAbs_iff.trans _
state_before: a b : ℤ
⊢ natAbs a = natAbs b ↔ Associated a b

tactic: constructor
state_before: a b : ℤ
⊢ a = b ∨ a = -b ↔ Associated a b

tactic: rintro (rfl | rfl)
state_before: case mp
a b : ℤ
⊢ a = b ∨ a = -b → Associated a b

tactic: rfl
state_before: case mp.inl
a : ℤ
⊢ Associated a a

tactic: exact ⟨-1, by simp⟩
state_before: case mp.inr
b : ℤ
⊢ Associated (-b) b

tactic: simp
state_before: b : ℤ
⊢ -b * ↑(-1) = b

tactic: rintro ⟨u, rfl⟩
state_before: case mpr
a b : ℤ
⊢ Associated a b → a = b ∨ a = -b

tactic: obtain rfl | rfl := Int.units_eq_one_or u
state_before: case mpr.intro
a : ℤ
u : ℤˣ
⊢ a = a * ↑u ∨ a = -(a * ↑u)

tactic: exact Or.inl (by simp)
state_before: case mpr.intro.inl
a : ℤ
⊢ a = a * ↑1 ∨ a = -(a * ↑1)

tactic: simp
state_before: a : ℤ
⊢ a = a * ↑1

tactic: exact Or.inr (by simp)
state_before: case mpr.intro.inr
a : ℤ
⊢ a = a * ↑(-1) ∨ a = -(a * ↑(-1))

tactic: simp
state_before: a : ℤ
⊢ a = -(a * ↑(-1))
Theorem: Basis.reindexFinsetRange_self
File: Mathlib/LinearAlgebra/Basis.lean

tactic: rw [reindexFinsetRange, reindex_apply, reindexRange_apply]
state_before: ι : Type u_2
ι' : Type ?u.421677
R : Type u_3
R₂ : Type ?u.421683
K : Type ?u.421686
M : Type u_1
M' : Type ?u.421692
M'' : Type ?u.421695
V : Type u
V' : Type ?u.421700
inst✝⁶ : Semiring R
inst✝⁵ : AddCommMonoid M
inst✝⁴ : Module R M
inst✝³ : AddCommMonoid M'
inst✝² : Module R M'
b b₁ : Basis ι R M
i✝ : ι
c : R
x : M
b' : Basis ι' R M'
e : ι ≃ ι'
inst✝¹ : Fintype ι
inst✝ : DecidableEq M
i : ι
h : optParam (↑b i ∈ Finset.image (↑b) Finset.univ) (_ : ↑b i ∈ Finset.image (↑b) Finset.univ)
⊢ ↑(reindexFinsetRange b) { val := ↑b i, property := h } = ↑b i

tactic: rfl
state_before: ι : Type u_2
ι' : Type ?u.421677
R : Type u_3
R₂ : Type ?u.421683
K : Type ?u.421686
M : Type u_1
M' : Type ?u.421692
M'' : Type ?u.421695
V : Type u
V' : Type ?u.421700
inst✝⁶ : Semiring R
inst✝⁵ : AddCommMonoid M
inst✝⁴ : Module R M
inst✝³ : AddCommMonoid M'
inst✝² : Module R M'
b b₁ : Basis ι R M
i✝ : ι
c : R
x : M
b' : Basis ι' R M'
e : ι ≃ ι'
inst✝¹ : Fintype ι
inst✝ : DecidableEq M
i : ι
h : optParam (↑b i ∈ Finset.image (↑b) Finset.univ) (_ : ↑b i ∈ Finset.image (↑b) Finset.univ)
⊢ ↑(↑(Equiv.subtypeEquiv (Equiv.refl M) (_ : ∀ (a : M), a ∈ range ↑b ↔ a ∈ Finset.image (↑b) Finset.univ)).symm
        { val := ↑b i, property := h }) =
    ↑b i
Theorem: Set.image2_union_right
File: Mathlib/Data/Set/NAry.lean

tactic: rw [← image2_swap, image2_union_left, image2_swap f, image2_swap f]
state_before: α : Type u_2
α' : Type ?u.14061
β : Type u_3
β' : Type ?u.14067
γ : Type u_1
γ' : Type ?u.14073
δ : Type ?u.14076
δ' : Type ?u.14079
ε : Type ?u.14082
ε' : Type ?u.14085
ζ : Type ?u.14088
ζ' : Type ?u.14091
ν : Type ?u.14094
f f' : α → β → γ
g g' : α → β → γ → δ
s s' : Set α
t t' : Set β
u u' : Set γ
v : Set δ
a a' : α
b b' : β
c c' : γ
d d' : δ
⊢ image2 f s (t ∪ t') = image2 f s t ∪ image2 f s t'
Theorem: ball_add_closedBall
File: Mathlib/Analysis/NormedSpace/Pointwise.lean

tactic: rw [ball_add, thickening_closedBall hε hδ b, Metric.vadd_ball, vadd_eq_add]
state_before: 𝕜 : Type ?u.933372
E : Type u_1
inst✝³ : NormedField 𝕜
inst✝² : SeminormedAddCommGroup E
inst✝¹ : NormedSpace 𝕜 E
inst✝ : NormedSpace ℝ E
x y z : E
δ ε : ℝ
hε : 0 < ε
hδ : 0 ≤ δ
a b : E
⊢ Metric.ball a ε + Metric.closedBall b δ = Metric.ball (a + b) (ε + δ)
Theorem: Complex.zero_cpow
File: Mathlib/Analysis/SpecialFunctions/Pow/Complex.lean

tactic: simp [cpow_def, *]
state_before: x : ℂ
h : x ≠ 0
⊢ 0 ^ x = 0
Theorem: Int.cast_mul_eq_zsmul_cast
File: Mathlib/Algebra/GroupPower/Lemmas.lean

tactic: simp
state_before: α : Type u_1
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✝ : AddCommGroupWithOne α
m : ℤ
⊢ ∀ (n : ℤ), ↑(0 * n) = 0 • ↑n

tactic: simp [add_mul, add_zsmul, ih]
state_before: α : Type u_1
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✝ : AddCommGroupWithOne α
m k : ℤ
x✝ : 0 ≤ k
ih : ∀ (n : ℤ), ↑(k * n) = k • ↑n
n : ℤ
⊢ ↑((k + 1) * n) = (k + 1) • ↑n

tactic: simp [sub_mul, sub_zsmul, ih, ← sub_eq_add_neg]
state_before: α : Type u_1
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✝ : AddCommGroupWithOne α
m k : ℤ
x✝ : k ≤ 0
ih : ∀ (n : ℤ), ↑(k * n) = k • ↑n
n : ℤ
⊢ ↑((k - 1) * n) = (k - 1) • ↑n
Theorem: Padic.norm_lt_pow_iff_norm_le_pow_sub_one
File: Mathlib/NumberTheory/Padics/PadicNumbers.lean

tactic: rw [norm_le_pow_iff_norm_lt_pow_add_one, sub_add_cancel]
state_before: p : ℕ
hp : Fact (Nat.Prime p)
x : ℚ_[p]
n : ℤ
⊢ ‖x‖ < ↑p ^ n ↔ ‖x‖ ≤ ↑p ^ (n - 1)
Theorem: DoubleQuot.ker_quotQuotMk
File: Mathlib/RingTheory/Ideal/QuotientOperations.lean

tactic: rw [RingHom.ker_eq_comap_bot, quotQuotMk, ← comap_comap, ← RingHom.ker, mk_ker,
  comap_map_of_surjective (Ideal.Quotient.mk I) Quotient.mk_surjective, ← RingHom.ker, mk_ker,
  sup_comm]
state_before: R : Type u
inst✝ : CommRing R
I J : Ideal R
⊢ RingHom.ker (quotQuotMk I J) = I ⊔ J
Theorem: Setoid.sup_def
File: Mathlib/Data/Setoid/Basic.lean

tactic: rw [sup_eq_eqvGen]
state_before: α : Type u_1
β : Type ?u.7769
r s : Setoid α
⊢ r ⊔ s = EqvGen.Setoid (Rel r ⊔ Rel s)

tactic: rfl
state_before: α : Type u_1
β : Type ?u.7769
r s : Setoid α
⊢ (EqvGen.Setoid fun x y => Rel r x y ∨ Rel s x y) = EqvGen.Setoid (Rel r ⊔ Rel s)
Theorem: MeasureTheory.snormEssSup_smul_measure
File: Mathlib/MeasureTheory/Function/LpSeminorm.lean

tactic: simp_rw [snormEssSup]
state_before: α : Type u_1
E : Type ?u.2067351
F : Type u_2
G : Type ?u.2067357
m m0 : MeasurableSpace α
p : ℝ≥0∞
q : ℝ
μ ν : Measure α
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedAddCommGroup G
f : α → F
c : ℝ≥0∞
hc : c ≠ 0
⊢ snormEssSup f (c • μ) = snormEssSup f μ

tactic: exact essSup_smul_measure hc
state_before: α : Type u_1
E : Type ?u.2067351
F : Type u_2
G : Type ?u.2067357
m m0 : MeasurableSpace α
p : ℝ≥0∞
q : ℝ
μ ν : Measure α
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedAddCommGroup G
f : α → F
c : ℝ≥0∞
hc : c ≠ 0
⊢ essSup (fun x => ↑‖f x‖₊) (c • μ) = essSup (fun x => ↑‖f x‖₊) μ
Theorem: nhds_order_unbounded
File: Mathlib/Topology/Order/Basic.lean

tactic: simp only [nhds_eq_order, ← inf_biInf, ← biInf_inf, *, ← inf_principal, ← Ioi_inter_Iio]
state_before: α : Type u
β : Type v
γ : Type w
inst✝¹ : TopologicalSpace α
inst✝ : Preorder α
t : OrderTopology α
a : α
hu : ∃ u, a < u
hl : ∃ l, l < a
⊢ 𝓝 a = ⨅ (l : α) (_ : l < a) (u : α) (_ : a < u), 𝓟 (Ioo l u)

tactic: rfl
state_before: α : Type u
β : Type v
γ : Type w
inst✝¹ : TopologicalSpace α
inst✝ : Preorder α
t : OrderTopology α
a : α
hu : ∃ u, a < u
hl : ∃ l, l < a
⊢ ((⨅ (b : α) (_ : b ∈ Iio a), 𝓟 (Ioi b)) ⊓ ⨅ (b : α) (_ : b ∈ Ioi a), 𝓟 (Iio b)) =
    (⨅ (i : α) (_ : i < a), 𝓟 (Ioi i)) ⊓ ⨅ (i : α) (_ : a < i), 𝓟 (Iio i)
Theorem: Cardinal.infinite_iff
File: Mathlib/SetTheory/Cardinal/Basic.lean

tactic: rw [← not_lt, lt_aleph0_iff_finite, not_finite_iff_infinite]
state_before: α✝ β α : Type u
⊢ Infinite α ↔ ℵ₀ ≤ (#α)
Theorem: Fin.predAbove_right_monotone
File: Mathlib/Data/Fin/Basic.lean

tactic: dsimp [predAbove]
state_before: n m : ℕ
p : Fin n
a b : Fin (n + 1)
H : a ≤ b
⊢ predAbove p a ≤ predAbove p b

tactic: split_ifs with ha hb hb
state_before: n m : ℕ
p : Fin n
a b : Fin (n + 1)
H : a ≤ b
⊢ (if h : ↑castSucc p < a then pred a (_ : a ≠ 0) else castLT a (_ : ↑a < n)) ≤
    if h : ↑castSucc p < b then pred b (_ : b ≠ 0) else castLT b (_ : ↑b < n)

tactic: all_goals simp only [le_iff_val_le_val, coe_pred]
state_before: case inl.inl
n m : ℕ
p : Fin n
a b : Fin (n + 1)
H : a ≤ b
ha : ↑castSucc p < a
hb : ↑castSucc p < b
⊢ pred a (_ : a ≠ 0) ≤ pred b (_ : b ≠ 0)

case inl.inr
n m : ℕ
p : Fin n
a b : Fin (n + 1)
H : a ≤ b
ha : ↑castSucc p < a
hb : ¬↑castSucc p < b
⊢ pred a (_ : a ≠ 0) ≤ castLT b (_ : ↑b < n)

case inr.inl
n m : ℕ
p : Fin n
a b : Fin (n + 1)
H : a ≤ b
ha : ¬↑castSucc p < a
hb : ↑castSucc p < b
⊢ castLT a (_ : ↑a < n) ≤ pred b (_ : b ≠ 0)

case inr.inr
n m : ℕ
p : Fin n
a b : Fin (n + 1)
H : a ≤ b
ha : ¬↑castSucc p < a
hb : ¬↑castSucc p < b
⊢ castLT a (_ : ↑a < n) ≤ castLT b (_ : ↑b < n)

tactic: simp only [le_iff_val_le_val, coe_pred]
state_before: case inr.inr
n m : ℕ
p : Fin n
a b : Fin (n + 1)
H : a ≤ b
ha : ¬↑castSucc p < a
hb : ¬↑castSucc p < b
⊢ castLT a (_ : ↑a < n) ≤ castLT b (_ : ↑b < n)

tactic: exact pred_le_pred H
state_before: case inl.inl
n m : ℕ
p : Fin n
a b : Fin (n + 1)
H : a ≤ b
ha : ↑castSucc p < a
hb : ↑castSucc p < b
⊢ ↑a - 1 ≤ ↑b - 1

tactic: calc
  _ ≤ _ := Nat.pred_le _
  _ ≤ _ := H
state_before: case inl.inr
n m : ℕ
p : Fin n
a b : Fin (n + 1)
H : a ≤ b
ha : ↑castSucc p < a
hb : ¬↑castSucc p < b
⊢ ↑a - 1 ≤ ↑(castLT b (_ : ↑b < n))

tactic: simp at ha
state_before: case inr.inl
n m : ℕ
p : Fin n
a b : Fin (n + 1)
H : a ≤ b
ha : ¬↑castSucc p < a
hb : ↑castSucc p < b
⊢ ↑(castLT a (_ : ↑a < n)) ≤ ↑b - 1

tactic: exact le_pred_of_lt (lt_of_le_of_lt ha hb)
state_before: case inr.inl
n m : ℕ
p : Fin n
a b : Fin (n + 1)
H : a ≤ b
ha✝ : ¬↑castSucc p < a
hb : ↑castSucc p < b
ha : a ≤ ↑castSucc p
⊢ ↑(castLT a (_ : ↑a < n)) ≤ ↑b - 1

tactic: exact H
state_before: case inr.inr
n m : ℕ
p : Fin n
a b : Fin (n + 1)
H : a ≤ b
ha : ¬↑castSucc p < a
hb : ¬↑castSucc p < b
⊢ ↑(castLT a (_ : ↑a < n)) ≤ ↑(castLT b (_ : ↑b < n))
Theorem: FermatPsp.coprime_of_probablePrime
File: Mathlib/NumberTheory/FermatPsp.lean

tactic: by_cases h₃ : 2 ≤ n
state_before: n b : ℕ
h : ProbablePrime n b
h₁ : 1 ≤ n
h₂ : 1 ≤ b
⊢ Nat.coprime n b

tactic: apply Nat.coprime_of_dvd
state_before: case pos
n b : ℕ
h : ProbablePrime n b
h₁ : 1 ≤ n
h₂ : 1 ≤ b
h₃ : 2 ≤ n
⊢ Nat.coprime n b

tactic: rintro k hk ⟨m, rfl⟩ ⟨j, rfl⟩
state_before: case pos.H
n b : ℕ
h : ProbablePrime n b
h₁ : 1 ≤ n
h₂ : 1 ≤ b
h₃ : 2 ≤ n
⊢ ∀ (k : ℕ), Nat.Prime k → k ∣ n → ¬k ∣ b

tactic: apply Nat.Prime.not_dvd_one hk
state_before: case pos.H.intro.intro
k : ℕ
hk : Nat.Prime k
m : ℕ
h₁ : 1 ≤ k * m
h₃ : 2 ≤ k * m
j : ℕ
h₂ : 1 ≤ k * j
h : ProbablePrime (k * m) (k * j)
⊢ False

tactic: replace h := dvd_of_mul_right_dvd h
state_before: case pos.H.intro.intro
k : ℕ
hk : Nat.Prime k
m : ℕ
h₁ : 1 ≤ k * m
h₃ : 2 ≤ k * m
j : ℕ
h₂ : 1 ≤ k * j
h : ProbablePrime (k * m) (k * j)
⊢ k ∣ 1

tactic: rw [Nat.dvd_add_iff_right h, Nat.sub_add_cancel (Nat.one_le_pow _ _ h₂)]
state_before: case pos.H.intro.intro
k : ℕ
hk : Nat.Prime k
m : ℕ
h₁ : 1 ≤ k * m
h₃ : 2 ≤ k * m
j : ℕ
h₂ : 1 ≤ k * j
h : k ∣ (k * j) ^ (k * m - 1) - 1
⊢ k ∣ 1

tactic: refine' dvd_of_mul_right_dvd (dvd_pow_self (k * j) _)
state_before: case pos.H.intro.intro
k : ℕ
hk : Nat.Prime k
m : ℕ
h₁ : 1 ≤ k * m
h₃ : 2 ≤ k * m
j : ℕ
h₂ : 1 ≤ k * j
h : k ∣ (k * j) ^ (k * m - 1) - 1
⊢ k ∣ (k * j) ^ (k * m - 1)

tactic: linarith [tsub_pos_of_lt (one_lt_two.trans_le h₃)]
state_before: case pos.H.intro.intro
k : ℕ
hk : Nat.Prime k
m : ℕ
h₁ : 1 ≤ k * m
h₃ : 2 ≤ k * m
j : ℕ
h₂ : 1 ≤ k * j
h : k ∣ (k * j) ^ (k * m - 1) - 1
⊢ k * m - 1 ≠ 0

tactic: rw [show n = 1 by linarith]
state_before: case neg
n b : ℕ
h : ProbablePrime n b
h₁ : 1 ≤ n
h₂ : 1 ≤ b
h₃ : ¬2 ≤ n
⊢ Nat.coprime n b

tactic: norm_num
state_before: case neg
n b : ℕ
h : ProbablePrime n b
h₁ : 1 ≤ n
h₂ : 1 ≤ b
h₃ : ¬2 ≤ n
⊢ Nat.coprime 1 b

tactic: linarith
state_before: n b : ℕ
h : ProbablePrime n b
h₁ : 1 ≤ n
h₂ : 1 ≤ b
h₃ : ¬2 ≤ n
⊢ n = 1
Theorem: Ideal.multiset_prod_le_inf
File: Mathlib/RingTheory/Ideal/Operations.lean

tactic: refine' s.induction_on _ _
state_before: R : Type u
ι : Type ?u.260476
inst✝ : CommSemiring R
I J K L : Ideal R
s : Multiset (Ideal R)
⊢ Multiset.prod s ≤ Multiset.inf s

tactic: intro a s ih
state_before: case refine'_2
R : Type u
ι : Type ?u.260476
inst✝ : CommSemiring R
I J K L : Ideal R
s : Multiset (Ideal R)
⊢ ∀ ⦃a : Ideal R⦄ {s : Multiset (Ideal R)},
    Multiset.prod s ≤ Multiset.inf s → Multiset.prod (a ::ₘ s) ≤ Multiset.inf (a ::ₘ s)

tactic: rw [Multiset.prod_cons, Multiset.inf_cons]
state_before: case refine'_2
R : Type u
ι : Type ?u.260476
inst✝ : CommSemiring R
I J K L : Ideal R
s✝ : Multiset (Ideal R)
a : Ideal R
s : Multiset (Ideal R)
ih : Multiset.prod s ≤ Multiset.inf s
⊢ Multiset.prod (a ::ₘ s) ≤ Multiset.inf (a ::ₘ s)

tactic: exact le_trans mul_le_inf (inf_le_inf le_rfl ih)
state_before: case refine'_2
R : Type u
ι : Type ?u.260476
inst✝ : CommSemiring R
I J K L : Ideal R
s✝ : Multiset (Ideal R)
a : Ideal R
s : Multiset (Ideal R)
ih : Multiset.prod s ≤ Multiset.inf s
⊢ a * Multiset.prod s ≤ a ⊓ Multiset.inf s

tactic: rw [Multiset.inf_zero]
state_before: case refine'_1
R : Type u
ι : Type ?u.260476
inst✝ : CommSemiring R
I J K L : Ideal R
s : Multiset (Ideal R)
⊢ Multiset.prod 0 ≤ Multiset.inf 0

tactic: exact le_top
state_before: case refine'_1
R : Type u
ι : Type ?u.260476
inst✝ : CommSemiring R
I J K L : Ideal R
s : Multiset (Ideal R)
⊢ Multiset.prod 0 ≤ ⊤
Theorem: Equiv.sumCongr_trans
File: Mathlib/Logic/Equiv/Basic.lean

tactic: ext i
state_before: α₁ : Type u_1
β₁ : Type u_2
α₂ : Type u_3
β₂ : Type u_4
γ₁ : Type u_5
γ₂ : Type u_6
e : α₁ ≃ β₁
f : α₂ ≃ β₂
g : β₁ ≃ γ₁
h : β₂ ≃ γ₂
⊢ (sumCongr e f).trans (sumCongr g h) = sumCongr (e.trans g) (f.trans h)

tactic: cases i <;> rfl
state_before: case H
α₁ : Type u_1
β₁ : Type u_2
α₂ : Type u_3
β₂ : Type u_4
γ₁ : Type u_5
γ₂ : Type u_6
e : α₁ ≃ β₁
f : α₂ ≃ β₂
g : β₁ ≃ γ₁
h : β₂ ≃ γ₂
i : α₁ ⊕ α₂
⊢ ↑((sumCongr e f).trans (sumCongr g h)) i = ↑(sumCongr (e.trans g) (f.trans h)) i
Theorem: List.count_replicate
File: Mathlib/Data/List/Count.lean

tactic: split
state_before: α : Type u_1
l : List α
inst✝ : DecidableEq α
a b : α
n : ℕ
⊢ count a (replicate n b) = if a = b then n else 0

tactic: exacts [‹a = b› ▸ count_replicate_self _ _, count_eq_zero.2 <| mt eq_of_mem_replicate ‹a ≠ b›]
state_before: case inl
α : Type u_1
l : List α
inst✝ : DecidableEq α
a b : α
n : ℕ
h✝ : a = b
⊢ count a (replicate n b) = n

case inr
α : Type u_1
l : List α
inst✝ : DecidableEq α
a b : α
n : ℕ
h✝ : ¬a = b
⊢ count a (replicate n b) = 0
Theorem: MeasureTheory.L1.integral_eq
File: Mathlib/MeasureTheory/Integral/Bochner.lean

tactic: simp only [integral]
state_before: α : Type u_1
E : Type u_2
F : Type ?u.411128
𝕜 : Type ?u.411131
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedAddCommGroup F
m : MeasurableSpace α
μ : Measure α
inst✝⁵ : NormedSpace ℝ E
inst✝⁴ : NontriviallyNormedField 𝕜
inst✝³ : NormedSpace 𝕜 E
inst✝² : SMulCommClass ℝ 𝕜 E
inst✝¹ : NormedSpace ℝ F
inst✝ : CompleteSpace E
f : { x // x ∈ Lp E 1 }
⊢ integral f = ↑integralCLM f
Theorem: PFun.dom_comp
File: Mathlib/Data/PFun.lean

tactic: ext
state_before: α : Type u_3
β : Type u_1
γ : Type u_2
δ : Type ?u.54232
ε : Type ?u.54235
ι : Type ?u.54238
f✝ : α →. β
f : β →. γ
g : α →. β
⊢ Dom (comp f g) = preimage g (Dom f)

tactic: simp_rw [mem_preimage, mem_dom, comp_apply, Part.mem_bind_iff, ← exists_and_right]
state_before: case h
α : Type u_3
β : Type u_1
γ : Type u_2
δ : Type ?u.54232
ε : Type ?u.54235
ι : Type ?u.54238
f✝ : α →. β
f : β →. γ
g : α →. β
x✝ : α
⊢ x✝ ∈ Dom (comp f g) ↔ x✝ ∈ preimage g (Dom f)

tactic: rw [exists_comm]
state_before: case h
α : Type u_3
β : Type u_1
γ : Type u_2
δ : Type ?u.54232
ε : Type ?u.54235
ι : Type ?u.54238
f✝ : α →. β
f : β →. γ
g : α →. β
x✝ : α
⊢ (∃ y a, a ∈ g x✝ ∧ y ∈ f a) ↔ ∃ y x, x ∈ f y ∧ y ∈ g x✝

tactic: simp_rw [and_comm]
state_before: case h
α : Type u_3
β : Type u_1
γ : Type u_2
δ : Type ?u.54232
ε : Type ?u.54235
ι : Type ?u.54238
f✝ : α →. β
f : β →. γ
g : α →. β
x✝ : α
⊢ (∃ b a, b ∈ g x✝ ∧ a ∈ f b) ↔ ∃ y x, x ∈ f y ∧ y ∈ g x✝
Theorem: IsProjective.iff_projective
File: Mathlib/Algebra/Category/ModuleCat/Projective.lean

tactic: refine' ⟨fun h => _, fun h => _⟩
state_before: R : Type u
inst✝² : Ring R
P : Type (max u v)
inst✝¹ : AddCommGroup P
inst✝ : Module R P
⊢ Module.Projective R P ↔ Projective (of R P)

tactic: letI : Module.Projective R (ModuleCat.of R P) := h
state_before: case refine'_1
R : Type u
inst✝² : Ring R
P : Type (max u v)
inst✝¹ : AddCommGroup P
inst✝ : Module R P
h : Module.Projective R P
⊢ Projective (of R P)

tactic: exact ⟨fun E X epi => Module.projective_lifting_property _ _
  ((ModuleCat.epi_iff_surjective _).mp epi)⟩
state_before: case refine'_1
R : Type u
inst✝² : Ring R
P : Type (max u v)
inst✝¹ : AddCommGroup P
inst✝ : Module R P
h : Module.Projective R P
this : Module.Projective R ↑(of R P) := h
⊢ Projective (of R P)

tactic: refine' Module.Projective.of_lifting_property.{u,v} _
state_before: case refine'_2
R : Type u
inst✝² : Ring R
P : Type (max u v)
inst✝¹ : AddCommGroup P
inst✝ : Module R P
h : Projective (of R P)
⊢ Module.Projective R P

tactic: intro E X mE mX sE sX f g s
state_before: case refine'_2
R : Type u
inst✝² : Ring R
P : Type (max u v)
inst✝¹ : AddCommGroup P
inst✝ : Module R P
h : Projective (of R P)
⊢ ∀ {M : Type (max v u)} {N : Type (max u v)} [inst : AddCommGroup M] [inst_1 : AddCommGroup N] [inst_2 : Module R M]
    [inst_3 : Module R N] (f : M →ₗ[R] N) (g : P →ₗ[R] N), Function.Surjective ↑f → ∃ h, comp f h = g

tactic: haveI : Epi (↟f) := (ModuleCat.epi_iff_surjective (↟f)).mpr s
state_before: case refine'_2
R : Type u
inst✝² : Ring R
P : Type (max u v)
inst✝¹ : AddCommGroup P
inst✝ : Module R P
h : Projective (of R P)
E : Type (max v u)
X : Type (max u v)
mE : AddCommGroup E
mX : AddCommGroup X
sE : Module R E
sX : Module R X
f : E →ₗ[R] X
g : P →ₗ[R] X
s : Function.Surjective ↑f
⊢ ∃ h, comp f h = g

tactic: letI : Projective (ModuleCat.of R P) := h
state_before: case refine'_2
R : Type u
inst✝² : Ring R
P : Type (max u v)
inst✝¹ : AddCommGroup P
inst✝ : Module R P
h : Projective (of R P)
E : Type (max v u)
X : Type (max u v)
mE : AddCommGroup E
mX : AddCommGroup X
sE : Module R E
sX : Module R X
f : E →ₗ[R] X
g : P →ₗ[R] X
s : Function.Surjective ↑f
this : Epi (↟f)
⊢ ∃ h, comp f h = g

tactic: exact ⟨Projective.factorThru (↟g) (↟f), Projective.factorThru_comp (↟g) (↟f)⟩
state_before: case refine'_2
R : Type u
inst✝² : Ring R
P : Type (max u v)
inst✝¹ : AddCommGroup P
inst✝ : Module R P
h : Projective (of R P)
E : Type (max v u)
X : Type (max u v)
mE : AddCommGroup E
mX : AddCommGroup X
sE : Module R E
sX : Module R X
f : E →ₗ[R] X
g : P →ₗ[R] X
s : Function.Surjective ↑f
this✝ : Epi (↟f)
this : Projective (of R P) := h
⊢ ∃ h, comp f h = g
Theorem: Nat.dvd_prime_pow
File: Mathlib/Data/Nat/Prime.lean

tactic: simp_rw [_root_.dvd_prime_pow  (prime_iff.mp pp)  m, associated_eq_eq]
state_before: p : ℕ
pp : Prime p
m i : ℕ
⊢ i ∣ p ^ m ↔ ∃ k, k ≤ m ∧ i = p ^ k
Theorem: Nat.dist_eq_zero
File: Mathlib/Data/Nat/Dist.lean

tactic: rw [h, dist_self]
state_before: n m : ℕ
h : n = m
⊢ dist n m = 0
Theorem: InnerProductGeometry.sin_angle_add_of_inner_eq_zero
File: Mathlib/Geometry/Euclidean/Angle/Unoriented/RightAngle.lean

tactic: rw [angle_add_eq_arcsin_of_inner_eq_zero h h0,
  Real.sin_arcsin (le_trans (by norm_num) (div_nonneg (norm_nonneg _) (norm_nonneg _)))
    (div_le_one_of_le _ (norm_nonneg _))]
state_before: V : Type u_1
inst✝¹ : NormedAddCommGroup V
inst✝ : InnerProductSpace ℝ V
x y : V
h : inner x y = 0
h0 : x ≠ 0 ∨ y ≠ 0
⊢ Real.sin (angle x (x + y)) = ‖y‖ / ‖x + y‖

tactic: rw [mul_self_le_mul_self_iff (norm_nonneg _) (norm_nonneg _),
  norm_add_sq_eq_norm_sq_add_norm_sq_real h]
state_before: V : Type u_1
inst✝¹ : NormedAddCommGroup V
inst✝ : InnerProductSpace ℝ V
x y : V
h : inner x y = 0
h0 : x ≠ 0 ∨ y ≠ 0
⊢ ‖y‖ ≤ ‖x + y‖

tactic: exact le_add_of_nonneg_left (mul_self_nonneg _)
state_before: V : Type u_1
inst✝¹ : NormedAddCommGroup V
inst✝ : InnerProductSpace ℝ V
x y : V
h : inner x y = 0
h0 : x ≠ 0 ∨ y ≠ 0
⊢ ‖y‖ * ‖y‖ ≤ ‖x‖ * ‖x‖ + ‖y‖ * ‖y‖

tactic: norm_num
state_before: V : Type u_1
inst✝¹ : NormedAddCommGroup V
inst✝ : InnerProductSpace ℝ V
x y : V
h : inner x y = 0
h0 : x ≠ 0 ∨ y ≠ 0
⊢ -1 ≤ 0