tasksource/leandojo huggingface dataset:
Theorem: Nat.dvd_ord_compl_of_dvd_not_dvd
File: Mathlib/Data/Nat/Factorization/Basic.lean

tactic: rcases eq_or_ne n 0 with (rfl | hn0)
state_before: p d n : ℕ
hdn : d ∣ n
hpd : ¬p ∣ d
⊢ d ∣ n / p ^ ↑(factorization n) p

tactic: rcases eq_or_ne d 0 with (rfl | hd0)
state_before: case inr
p d n : ℕ
hdn : d ∣ n
hpd : ¬p ∣ d
hn0 : n ≠ 0
⊢ d ∣ n / p ^ ↑(factorization n) p

tactic: rw [← factorization_le_iff_dvd hd0 (ord_compl_pos p hn0).ne', factorization_ord_compl]
state_before: case inr.inr
p d n : ℕ
hdn : d ∣ n
hpd : ¬p ∣ d
hn0 : n ≠ 0
hd0 : d ≠ 0
⊢ d ∣ n / p ^ ↑(factorization n) p

tactic: intro q
state_before: case inr.inr
p d n : ℕ
hdn : d ∣ n
hpd : ¬p ∣ d
hn0 : n ≠ 0
hd0 : d ≠ 0
⊢ factorization d ≤ Finsupp.erase p (factorization n)

tactic: rcases eq_or_ne q p with (rfl | hqp)
state_before: case inr.inr
p d n : ℕ
hdn : d ∣ n
hpd : ¬p ∣ d
hn0 : n ≠ 0
hd0 : d ≠ 0
q : ℕ
⊢ ↑(factorization d) q ≤ ↑(Finsupp.erase p (factorization n)) q

tactic: simp
state_before: case inl
p d : ℕ
hpd : ¬p ∣ d
hdn : d ∣ 0
⊢ d ∣ 0 / p ^ ↑(factorization 0) p

tactic: simp at hpd
state_before: case inr.inl
p n : ℕ
hn0 : n ≠ 0
hdn : 0 ∣ n
hpd : ¬p ∣ 0
⊢ 0 ∣ n / p ^ ↑(factorization n) p

tactic: simp [factorization_eq_zero_iff, hpd]
state_before: case inr.inr.inl
d n : ℕ
hdn : d ∣ n
hn0 : n ≠ 0
hd0 : d ≠ 0
q : ℕ
hpd : ¬q ∣ d
⊢ ↑(factorization d) q ≤ ↑(Finsupp.erase q (factorization n)) q

tactic: simp [hqp, (factorization_le_iff_dvd hd0 hn0).2 hdn q]
state_before: case inr.inr.inr
p d n : ℕ
hdn : d ∣ n
hpd : ¬p ∣ d
hn0 : n ≠ 0
hd0 : d ≠ 0
q : ℕ
hqp : q ≠ p
⊢ ↑(factorization d) q ≤ ↑(Finsupp.erase p (factorization n)) q
Theorem: wbtw_rotate_iff
File: Mathlib/Analysis/Convex/Between.lean

tactic: rw [wbtw_comm, wbtw_swap_right_iff, eq_comm]
state_before: R : Type u_1
V : Type u_2
V' : Type ?u.209912
P : Type u_3
P' : Type ?u.209918
inst✝⁷ : OrderedRing R
inst✝⁶ : AddCommGroup V
inst✝⁵ : Module R V
inst✝⁴ : AddTorsor V P
inst✝³ : AddCommGroup V'
inst✝² : Module R V'
inst✝¹ : AddTorsor V' P'
inst✝ : NoZeroSMulDivisors R V
x y z : P
⊢ Wbtw R x y z ∧ Wbtw R z x y ↔ x = y
Theorem: Finset.sdiff_singleton_eq_erase
File: Mathlib/Data/Finset/Basic.lean

tactic: ext
state_before: α : Type u_1
β : Type ?u.245010
γ : Type ?u.245013
inst✝ : DecidableEq α
s✝ t u v : Finset α
a✝ b a : α
s : Finset α
⊢ s \ {a} = erase s a

tactic: rw [mem_erase, mem_sdiff, mem_singleton, and_comm]
state_before: case a
α : Type u_1
β : Type ?u.245010
γ : Type ?u.245013
inst✝ : DecidableEq α
s✝ t u v : Finset α
a✝¹ b a : α
s : Finset α
a✝ : α
⊢ a✝ ∈ s \ {a} ↔ a✝ ∈ erase s a
Theorem: Nat.dist_cast_rat
File: Mathlib/Topology/Instances/Rat.lean

tactic: rw [← Nat.dist_cast_real, ← Rat.dist_cast]
state_before: x y : ℕ
⊢ dist ↑x ↑y = dist x y

tactic: congr
state_before: x y : ℕ
⊢ dist ↑↑x ↑↑y = dist ↑x ↑y
Theorem: locallyConnectedSpace_of_connected_bases
File: Mathlib/Topology/Connected.lean

tactic: rw [locallyConnectedSpace_iff_connected_basis]
state_before: α : Type u
β : Type v
ι✝ : Type ?u.116895
π : ι✝ → Type ?u.116900
inst✝ : TopologicalSpace α
s t u v : Set α
ι : Type u_1
b : α → ι → Set α
p : α → ι → Prop
hbasis : ∀ (x : α), Filter.HasBasis (𝓝 x) (p x) (b x)
hconnected : ∀ (x : α) (i : ι), p x i → IsPreconnected (b x i)
⊢ LocallyConnectedSpace α

tactic: exact fun x =>
  (hbasis x).to_hasBasis
    (fun i hi => ⟨b x i, ⟨(hbasis x).mem_of_mem hi, hconnected x i hi⟩, subset_rfl⟩) fun s hs =>
    ⟨(hbasis x).index s hs.1, ⟨(hbasis x).property_index hs.1, (hbasis x).set_index_subset hs.1⟩⟩
state_before: α : Type u
β : Type v
ι✝ : Type ?u.116895
π : ι✝ → Type ?u.116900
inst✝ : TopologicalSpace α
s t u v : Set α
ι : Type u_1
b : α → ι → Set α
p : α → ι → Prop
hbasis : ∀ (x : α), Filter.HasBasis (𝓝 x) (p x) (b x)
hconnected : ∀ (x : α) (i : ι), p x i → IsPreconnected (b x i)
⊢ ∀ (x : α), Filter.HasBasis (𝓝 x) (fun s => s ∈ 𝓝 x ∧ IsPreconnected s) id
Theorem: FirstOrder.Language.LHom.realize_onTerm
File: Mathlib/ModelTheory/Semantics.lean

tactic: induction' t with _ n f ts ih
state_before: L : Language
L' : Language
M : Type w
N : Type ?u.25879
P : Type ?u.25882
inst✝⁴ : Structure L M
inst✝³ : Structure L N
inst✝² : Structure L P
α : Type u'
β : Type v'
inst✝¹ : Structure L' M
φ : L →ᴸ L'
inst✝ : IsExpansionOn φ M
t : Term L α
v : α → M
⊢ Term.realize v (onTerm φ t) = Term.realize v t

tactic: rfl
state_before: case var
L : Language
L' : Language
M : Type w
N : Type ?u.25879
P : Type ?u.25882
inst✝⁴ : Structure L M
inst✝³ : Structure L N
inst✝² : Structure L P
α : Type u'
β : Type v'
inst✝¹ : Structure L' M
φ : L →ᴸ L'
inst✝ : IsExpansionOn φ M
v : α → M
_a✝ : α
⊢ Term.realize v (onTerm φ (var _a✝)) = Term.realize v (var _a✝)

tactic: simp only [Term.realize, LHom.onTerm, LHom.map_onFunction, ih]
state_before: case func
L : Language
L' : Language
M : Type w
N : Type ?u.25879
P : Type ?u.25882
inst✝⁴ : Structure L M
inst✝³ : Structure L N
inst✝² : Structure L P
α : Type u'
β : Type v'
inst✝¹ : Structure L' M
φ : L →ᴸ L'
inst✝ : IsExpansionOn φ M
v : α → M
n : ℕ
f : Functions L n
ts : Fin n → Term L α
ih : ∀ (a : Fin n), Term.realize v (onTerm φ (ts a)) = Term.realize v (ts a)
⊢ Term.realize v (onTerm φ (func f ts)) = Term.realize v (func f ts)
Theorem: CategoryTheory.Limits.IsColimit.hom_ext
File: Mathlib/CategoryTheory/Limits/IsLimit.lean

tactic: rw [h.hom_desc f, h.hom_desc f']
state_before: J : Type u₁
inst✝² : Category J
K : Type u₂
inst✝¹ : Category K
C : Type u₃
inst✝ : Category C
F : J ⥤ C
t : Cocone F
h : IsColimit t
W : C
f f' : t.pt ⟶ W
w : ∀ (j : J), t.ι.app j ≫ f = t.ι.app j ≫ f'
⊢ f = f'

tactic: congr
state_before: J : Type u₁
inst✝² : Category J
K : Type u₂
inst✝¹ : Category K
C : Type u₃
inst✝ : Category C
F : J ⥤ C
t : Cocone F
h : IsColimit t
W : C
f f' : t.pt ⟶ W
w : ∀ (j : J), t.ι.app j ≫ f = t.ι.app j ≫ f'
⊢ desc h { pt := W, ι := NatTrans.mk fun b => t.ι.app b ≫ f } =
    desc h { pt := W, ι := NatTrans.mk fun b => t.ι.app b ≫ f' }

tactic: exact funext w
state_before: case h.e_8.h.e_ι.e_app
J : Type u₁
inst✝² : Category J
K : Type u₂
inst✝¹ : Category K
C : Type u₃
inst✝ : Category C
F : J ⥤ C
t : Cocone F
h : IsColimit t
W : C
f f' : t.pt ⟶ W
w : ∀ (j : J), t.ι.app j ≫ f = t.ι.app j ≫ f'
⊢ (fun b => t.ι.app b ≫ f) = fun b => t.ι.app b ≫ f'
Theorem: Matrix.range_cons_cons_empty
File: Mathlib/Data/Fin/VecNotation.lean

tactic: rw [range_cons, range_cons_empty, Set.singleton_union]
state_before: α : Type u
m n o : ℕ
m' : Type ?u.21814
n' : Type ?u.21817
o' : Type ?u.21820
x y : α
u : Fin 0 → α
⊢ Set.range (vecCons x (vecCons y u)) = {x, y}
Theorem: toIocMod_add_zsmul
File: Mathlib/Algebra/Order/ToIntervalMod.lean

tactic: rw [toIocMod, toIocDiv_add_zsmul, toIocMod, add_smul]
state_before: α : Type u_1
inst✝ : LinearOrderedAddCommGroup α
hα : Archimedean α
p : α
hp : 0 < p
a✝ b✝ c : α
n : ℤ
a b : α
m : ℤ
⊢ toIocMod hp a (b + m • p) = toIocMod hp a b

tactic: abel
state_before: α : Type u_1
inst✝ : LinearOrderedAddCommGroup α
hα : Archimedean α
p : α
hp : 0 < p
a✝ b✝ c : α
n : ℤ
a b : α
m : ℤ
⊢ b + m • p - (toIocDiv hp a b • p + m • p) = b - toIocDiv hp a b • p
Theorem: Polynomial.toFinsupp_mul
File: Mathlib/Data/Polynomial/Basic.lean

tactic: cases a
state_before: R : Type u
a✝ b✝ : R
m n : ℕ
inst✝ : Semiring R
p q a b : R[X]
⊢ (a * b).toFinsupp = a.toFinsupp * b.toFinsupp

tactic: cases b
state_before: case ofFinsupp
R : Type u
a b✝ : R
m n : ℕ
inst✝ : Semiring R
p q b : R[X]
toFinsupp✝ : AddMonoidAlgebra R ℕ
⊢ ({ toFinsupp := toFinsupp✝ } * b).toFinsupp = { toFinsupp := toFinsupp✝ }.toFinsupp * b.toFinsupp

tactic: rw [← ofFinsupp_mul]
state_before: case ofFinsupp.ofFinsupp
R : Type u
a b : R
m n : ℕ
inst✝ : Semiring R
p q : R[X]
toFinsupp✝¹ toFinsupp✝ : AddMonoidAlgebra R ℕ
⊢ ({ toFinsupp := toFinsupp✝¹ } * { toFinsupp := toFinsupp✝ }).toFinsupp =
    { toFinsupp := toFinsupp✝¹ }.toFinsupp * { toFinsupp := toFinsupp✝ }.toFinsupp
Theorem: ENNReal.mul_top'
File: Mathlib/Data/Real/ENNReal.lean

tactic: convert WithTop.mul_top' a
state_before: α : Type ?u.83091
β : Type ?u.83094
a b c d : ℝ≥0∞
r p q : ℝ≥0
⊢ a * ⊤ = if a = 0 then 0 else ⊤
Theorem: Int.ModEq.sub
File: Mathlib/Data/Int/ModEq.lean

tactic: rw [sub_eq_add_neg, sub_eq_add_neg]
state_before: m n a b c d : ℤ
h₁ : a ≡ b [ZMOD n]
h₂ : c ≡ d [ZMOD n]
⊢ a - c ≡ b - d [ZMOD n]

tactic: exact h₁.add h₂.neg
state_before: m n a b c d : ℤ
h₁ : a ≡ b [ZMOD n]
h₂ : c ≡ d [ZMOD n]
⊢ a + -c ≡ b + -d [ZMOD n]
Theorem: MeasureTheory.L1.norm_integral_le
File: Mathlib/MeasureTheory/Integral/Bochner.lean

tactic: simp only [integral]
state_before: α : Type u_1
E : Type u_2
F : Type ?u.541632
𝕜 : Type ?u.541635
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: Nat.fib_bit1
File: Mathlib/Data/Nat/Fib.lean

tactic: rw [Nat.bit1_eq_succ_bit0, bit0_eq_two_mul, fib_two_mul_add_one]
state_before: n : ℕ
⊢ fib (bit1 n) = fib (n + 1) ^ 2 + fib n ^ 2
Theorem: MeasureTheory.regular_inv_iff
File: Mathlib/MeasureTheory/Group/Measure.lean

tactic: constructor
state_before: 𝕜 : Type ?u.524091
G : Type u_1
H : Type ?u.524097
inst✝⁶ : MeasurableSpace G
inst✝⁵ : MeasurableSpace H
inst✝⁴ : TopologicalSpace G
inst✝³ : BorelSpace G
μ : Measure G
inst✝² : Group G
inst✝¹ : TopologicalGroup G
inst✝ : T2Space G
⊢ Regular (Measure.inv μ) ↔ Regular μ

tactic: intro h
state_before: case mp
𝕜 : Type ?u.524091
G : Type u_1
H : Type ?u.524097
inst✝⁶ : MeasurableSpace G
inst✝⁵ : MeasurableSpace H
inst✝⁴ : TopologicalSpace G
inst✝³ : BorelSpace G
μ : Measure G
inst✝² : Group G
inst✝¹ : TopologicalGroup G
inst✝ : T2Space G
⊢ Regular (Measure.inv μ) → Regular μ

tactic: rw [← μ.inv_inv]
state_before: case mp
𝕜 : Type ?u.524091
G : Type u_1
H : Type ?u.524097
inst✝⁶ : MeasurableSpace G
inst✝⁵ : MeasurableSpace H
inst✝⁴ : TopologicalSpace G
inst✝³ : BorelSpace G
μ : Measure G
inst✝² : Group G
inst✝¹ : TopologicalGroup G
inst✝ : T2Space G
h : Regular (Measure.inv μ)
⊢ Regular μ

tactic: exact Measure.Regular.inv
state_before: case mp
𝕜 : Type ?u.524091
G : Type u_1
H : Type ?u.524097
inst✝⁶ : MeasurableSpace G
inst✝⁵ : MeasurableSpace H
inst✝⁴ : TopologicalSpace G
inst✝³ : BorelSpace G
μ : Measure G
inst✝² : Group G
inst✝¹ : TopologicalGroup G
inst✝ : T2Space G
h : Regular (Measure.inv μ)
⊢ Regular (Measure.inv (Measure.inv μ))

tactic: intro h
state_before: case mpr
𝕜 : Type ?u.524091
G : Type u_1
H : Type ?u.524097
inst✝⁶ : MeasurableSpace G
inst✝⁵ : MeasurableSpace H
inst✝⁴ : TopologicalSpace G
inst✝³ : BorelSpace G
μ : Measure G
inst✝² : Group G
inst✝¹ : TopologicalGroup G
inst✝ : T2Space G
⊢ Regular μ → Regular (Measure.inv μ)

tactic: exact Measure.Regular.inv
state_before: case mpr
𝕜 : Type ?u.524091
G : Type u_1
H : Type ?u.524097
inst✝⁶ : MeasurableSpace G
inst✝⁵ : MeasurableSpace H
inst✝⁴ : TopologicalSpace G
inst✝³ : BorelSpace G
μ : Measure G
inst✝² : Group G
inst✝¹ : TopologicalGroup G
inst✝ : T2Space G
h : Regular μ
⊢ Regular (Measure.inv μ)
Theorem: Int.floor_le_neg_one_iff
File: Mathlib/Algebra/Order/Floor.lean

tactic: rw [← zero_sub (1 : ℤ), floor_le_sub_one_iff, cast_zero]
state_before: F : Type ?u.123535
α : Type u_1
β : Type ?u.123541
inst✝¹ : LinearOrderedRing α
inst✝ : FloorRing α
z : ℤ
a : α
⊢ ⌊a⌋ ≤ -1 ↔ a < 0
Theorem: RingHom.ker_isMaximal_of_surjective
File: Mathlib/RingTheory/Ideal/Operations.lean

tactic: refine'
  Ideal.isMaximal_iff.mpr
    ⟨fun h1 => one_ne_zero' K <| map_one f ▸ (mem_ker f).mp h1, fun J x hJ hxf hxJ => _⟩
state_before: R✝ : Type u
S : Type v
T : Type w
R : Type u_1
K : Type u_2
F : Type u_3
inst✝² : Ring R
inst✝¹ : Field K
inst✝ : RingHomClass F R K
f : F
hf : Function.Surjective ↑f
⊢ Ideal.IsMaximal (ker f)

tactic: obtain ⟨y, hy⟩ := hf (f x)⁻¹
state_before: R✝ : Type u
S : Type v
T : Type w
R : Type u_1
K : Type u_2
F : Type u_3
inst✝² : Ring R
inst✝¹ : Field K
inst✝ : RingHomClass F R K
f : F
hf : Function.Surjective ↑f
J : Ideal R
x : R
hJ : ker f ≤ J
hxf : ¬x ∈ ker f
hxJ : x ∈ J
⊢ 1 ∈ J

tactic: have H : 1 = y * x - (y * x - 1) := (sub_sub_cancel _ _).symm
state_before: case intro
R✝ : Type u
S : Type v
T : Type w
R : Type u_1
K : Type u_2
F : Type u_3
inst✝² : Ring R
inst✝¹ : Field K
inst✝ : RingHomClass F R K
f : F
hf : Function.Surjective ↑f
J : Ideal R
x : R
hJ : ker f ≤ J
hxf : ¬x ∈ ker f
hxJ : x ∈ J
y : R
hy : ↑f y = (↑f x)⁻¹
⊢ 1 ∈ J

tactic: rw [H]
state_before: case intro
R✝ : Type u
S : Type v
T : Type w
R : Type u_1
K : Type u_2
F : Type u_3
inst✝² : Ring R
inst✝¹ : Field K
inst✝ : RingHomClass F R K
f : F
hf : Function.Surjective ↑f
J : Ideal R
x : R
hJ : ker f ≤ J
hxf : ¬x ∈ ker f
hxJ : x ∈ J
y : R
hy : ↑f y = (↑f x)⁻¹
H : 1 = y * x - (y * x - 1)
⊢ 1 ∈ J

tactic: refine' J.sub_mem (J.mul_mem_left _ hxJ) (hJ _)
state_before: case intro
R✝ : Type u
S : Type v
T : Type w
R : Type u_1
K : Type u_2
F : Type u_3
inst✝² : Ring R
inst✝¹ : Field K
inst✝ : RingHomClass F R K
f : F
hf : Function.Surjective ↑f
J : Ideal R
x : R
hJ : ker f ≤ J
hxf : ¬x ∈ ker f
hxJ : x ∈ J
y : R
hy : ↑f y = (↑f x)⁻¹
H : 1 = y * x - (y * x - 1)
⊢ y * x - (y * x - 1) ∈ J

tactic: rw [mem_ker]
state_before: case intro
R✝ : Type u
S : Type v
T : Type w
R : Type u_1
K : Type u_2
F : Type u_3
inst✝² : Ring R
inst✝¹ : Field K
inst✝ : RingHomClass F R K
f : F
hf : Function.Surjective ↑f
J : Ideal R
x : R
hJ : ker f ≤ J
hxf : ¬x ∈ ker f
hxJ : x ∈ J
y : R
hy : ↑f y = (↑f x)⁻¹
H : 1 = y * x - (y * x - 1)
⊢ y * x - 1 ∈ ker f

tactic: simp only [hy, map_sub, map_one, map_mul, inv_mul_cancel (mt (mem_ker f).mpr hxf), sub_self]
state_before: case intro
R✝ : Type u
S : Type v
T : Type w
R : Type u_1
K : Type u_2
F : Type u_3
inst✝² : Ring R
inst✝¹ : Field K
inst✝ : RingHomClass F R K
f : F
hf : Function.Surjective ↑f
J : Ideal R
x : R
hJ : ker f ≤ J
hxf : ¬x ∈ ker f
hxJ : x ∈ J
y : R
hy : ↑f y = (↑f x)⁻¹
H : 1 = y * x - (y * x - 1)
⊢ ↑f (y * x - 1) = 0
Theorem: Ultrafilter.le_nhds_lim
File: Mathlib/Topology/SubsetProperties.lean

tactic: rcases isCompact_univ.ultrafilter_le_nhds F (by simp) with ⟨x, -, h⟩
state_before: α : Type u
β : Type v
ι : Type ?u.150954
π : ι → Type ?u.150959
inst✝² : TopologicalSpace α
inst✝¹ : TopologicalSpace β
s t : Set α
inst✝ : CompactSpace α
F : Ultrafilter α
⊢ ↑F ≤ 𝓝 (lim F)

tactic: exact le_nhds_lim ⟨x, h⟩
state_before: case intro.intro
α : Type u
β : Type v
ι : Type ?u.150954
π : ι → Type ?u.150959
inst✝² : TopologicalSpace α
inst✝¹ : TopologicalSpace β
s t : Set α
inst✝ : CompactSpace α
F : Ultrafilter α
x : α
h : ↑F ≤ 𝓝 x
⊢ ↑F ≤ 𝓝 (lim F)

tactic: simp
state_before: α : Type u
β : Type v
ι : Type ?u.150954
π : ι → Type ?u.150959
inst✝² : TopologicalSpace α
inst✝¹ : TopologicalSpace β
s t : Set α
inst✝ : CompactSpace α
F : Ultrafilter α
⊢ ↑F ≤ 𝓟 univ
Theorem: MeasureTheory.L2.inner_indicatorConstLp_one
File: Mathlib/MeasureTheory/Function/L2Space.lean

tactic: rw [L2.inner_indicatorConstLp_eq_inner_set_integral 𝕜 hs hμs (1 : 𝕜) f]
state_before: α : Type u_1
E : Type ?u.160393
F : Type ?u.160396
𝕜 : Type u_2
inst✝⁴ : IsROrC 𝕜
inst✝³ : MeasurableSpace α
μ : Measure α
inst✝² : NormedAddCommGroup E
inst✝¹ : InnerProductSpace 𝕜 E
inst✝ : NormedAddCommGroup F
s : Set α
hs : MeasurableSet s
hμs : ↑↑μ s ≠ ⊤
f : { x // x ∈ Lp 𝕜 2 }
⊢ inner (indicatorConstLp 2 hs hμs 1) f = ∫ (x : α) in s, ↑↑f x ∂μ

tactic: simp
state_before: α : Type u_1
E : Type ?u.160393
F : Type ?u.160396
𝕜 : Type u_2
inst✝⁴ : IsROrC 𝕜
inst✝³ : MeasurableSpace α
μ : Measure α
inst✝² : NormedAddCommGroup E
inst✝¹ : InnerProductSpace 𝕜 E
inst✝ : NormedAddCommGroup F
s : Set α
hs : MeasurableSet s
hμs : ↑↑μ s ≠ ⊤
f : { x // x ∈ Lp 𝕜 2 }
⊢ inner 1 (∫ (x : α) in s, ↑↑f x ∂μ) = ∫ (x : α) in s, ↑↑f x ∂μ
Theorem: CategoryTheory.Functor.isMittagLeffler_iff_subset_range_comp
File: Mathlib/CategoryTheory/CofilteredSystem.lean

tactic: simp_rw [isMittagLeffler_iff_eventualRange, eventualRange_eq_iff]
state_before: J : Type u
inst✝¹ : Category J
F : J ⥤ Type v
i j k : J
s : Set (F.obj i)
inst✝ : IsCofilteredOrEmpty J
⊢ IsMittagLeffler F ↔ ∀ (j : J), ∃ i f, ∀ ⦃k : J⦄ (g : k ⟶ i), range (F.map f) ⊆ range (F.map (g ≫ f))
Theorem: Cubic.degree_of_c_eq_zero
File: Mathlib/Algebra/CubicDiscriminant.lean

tactic: simpa only [of_c_eq_zero ha hb hc] using degree_C_le
state_before: R : Type u_1
S : Type ?u.583385
F : Type ?u.583388
K : Type ?u.583391
P Q : Cubic R
a b c d a' b' c' d' : R
inst✝ : Semiring R
ha : P.a = 0
hb : P.b = 0
hc : P.c = 0
⊢ degree (toPoly P) ≤ 0
Theorem: MonoidHom.map_finprod_pLift
File: Mathlib/Algebra/BigOperators/Finprod.lean

tactic: rw [finprod_eq_prod_pLift_of_mulSupport_subset h.coe_toFinset.ge,
  finprod_eq_prod_pLift_of_mulSupport_subset, f.map_prod]
state_before: G : Type ?u.47261
M : Type u_1
N : Type u_2
α : Sort u_3
β : Sort ?u.47273
ι : Sort ?u.47276
inst✝¹ : CommMonoid M
inst✝ : CommMonoid N
f : M →* N
g : α → M
h : Set.Finite (mulSupport (g ∘ PLift.down))
⊢ ↑f (∏ᶠ (x : α), g x) = ∏ᶠ (x : α), ↑f (g x)

tactic: rw [h.coe_toFinset]
state_before: G : Type ?u.47261
M : Type u_1
N : Type u_2
α : Sort u_3
β : Sort ?u.47273
ι : Sort ?u.47276
inst✝¹ : CommMonoid M
inst✝ : CommMonoid N
f : M →* N
g : α → M
h : Set.Finite (mulSupport (g ∘ PLift.down))
⊢ mulSupport ((fun x => ↑f (g x)) ∘ PLift.down) ⊆ ↑(Finite.toFinset h)

tactic: exact mulSupport_comp_subset f.map_one (g ∘ PLift.down)
state_before: G : Type ?u.47261
M : Type u_1
N : Type u_2
α : Sort u_3
β : Sort ?u.47273
ι : Sort ?u.47276
inst✝¹ : CommMonoid M
inst✝ : CommMonoid N
f : M →* N
g : α → M
h : Set.Finite (mulSupport (g ∘ PLift.down))
⊢ mulSupport ((fun x => ↑f (g x)) ∘ PLift.down) ⊆ mulSupport (g ∘ PLift.down)
Theorem: PFun.dom_of_mem_fix
File: Mathlib/Data/PFun.lean

tactic: let ⟨h₁, h₂⟩ := Part.mem_assert_iff.1 h
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.19159
δ : Type ?u.19162
ε : Type ?u.19165
ι : Type ?u.19168
f : α →. β ⊕ α
a : α
b : β
h : b ∈ fix f a
⊢ (f a).Dom

tactic: rw [WellFounded.fixFEq] at h₂
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.19159
δ : Type ?u.19162
ε : Type ?u.19165
ι : Type ?u.19168
f : α →. β ⊕ α
a : α
b : β
h : b ∈ fix f a
h₁ : Acc (fun x y => Sum.inr x ∈ f y) a
h₂ :
  b ∈
    WellFounded.fixF
      (fun a IH =>
        Part.assert (f a).Dom fun hf =>
          match e : Part.get (f a) hf with
          | Sum.inl b => Part.some b
          | Sum.inr a' => IH a' (_ : ∃ h, Part.get (f a) h = Sum.inr a'))
      a h₁
⊢ (f a).Dom

tactic: exact h₂.fst.fst
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.19159
δ : Type ?u.19162
ε : Type ?u.19165
ι : Type ?u.19168
f : α →. β ⊕ α
a : α
b : β
h : b ∈ fix f a
h₁ : Acc (fun x y => Sum.inr x ∈ f y) a
h₂ :
  b ∈
    Part.assert (f a).Dom fun hf =>
      match e : Part.get (f a) hf with
      | Sum.inl b => Part.some b
      | Sum.inr a' =>
        (fun y p =>
            WellFounded.fixF
              (fun a IH =>
                Part.assert (f a).Dom fun hf =>
                  match e : Part.get (f a) hf with
                  | Sum.inl b => Part.some b
                  | Sum.inr a' => IH a' (_ : ∃ h, Part.get (f a) h = Sum.inr a'))
              y (_ : Acc (fun y x => Sum.inr y ∈ f x) y))
          a' (_ : ∃ h, Part.get (f a) h = Sum.inr a')
⊢ (f a).Dom
Theorem: Fin.prod_univ_castSucc
File: Mathlib/Algebra/BigOperators/Fin.lean

tactic: simpa [mul_comm] using prod_univ_succAbove f (last n)
state_before: α : Type ?u.8633
β : Type u_1
inst✝ : CommMonoid β
n : ℕ
f : Fin (n + 1) → β
⊢ ∏ i : Fin (n + 1), f i = (∏ i : Fin n, f (↑castSucc i)) * f (last n)
Theorem: MeasureTheory.VectorMeasure.mapRange_add
File: Mathlib/MeasureTheory/Measure/VectorMeasure.lean

tactic: ext
state_before: α : Type u_1
β : Type ?u.336628
m inst✝⁷ : MeasurableSpace α
inst✝⁶ : MeasurableSpace β
M : Type u_2
inst✝⁵ : AddCommMonoid M
inst✝⁴ : TopologicalSpace M
v✝ : VectorMeasure α M
N : Type u_3
inst✝³ : AddCommMonoid N
inst✝² : TopologicalSpace N
inst✝¹ : ContinuousAdd M
inst✝ : ContinuousAdd N
v w : VectorMeasure α M
f : M →+ N
hf : Continuous ↑f
⊢ mapRange (v + w) f hf = mapRange v f hf + mapRange w f hf

tactic: simp
state_before: case h
α : Type u_1
β : Type ?u.336628
m inst✝⁷ : MeasurableSpace α
inst✝⁶ : MeasurableSpace β
M : Type u_2
inst✝⁵ : AddCommMonoid M
inst✝⁴ : TopologicalSpace M
v✝ : VectorMeasure α M
N : Type u_3
inst✝³ : AddCommMonoid N
inst✝² : TopologicalSpace N
inst✝¹ : ContinuousAdd M
inst✝ : ContinuousAdd N
v w : VectorMeasure α M
f : M →+ N
hf : Continuous ↑f
i✝ : Set α
a✝ : MeasurableSet i✝
⊢ ↑(mapRange (v + w) f hf) i✝ = ↑(mapRange v f hf + mapRange w f hf) i✝
Theorem: Sum.lex_inr_inr
File: Mathlib/Data/Sum/Basic.lean

tactic: cases h
state_before: α : Type u
α' : Type w
β : Type v
β' : Type x
γ : Type ?u.28729
δ : Type ?u.28732
r r₁ r₂ : α → α → Prop
s s₁ s₂ : β → β → Prop
a a₁ a₂ : α
b b₁ b₂ : β
x y : α ⊕ β
h : Lex r s (inr b₁) (inr b₂)
⊢ s b₁ b₂

tactic: assumption
state_before: case inr
α : Type u
α' : Type w
β : Type v
β' : Type x
γ : Type ?u.28729
δ : Type ?u.28732
r r₁ r₂ : α → α → Prop
s s₁ s₂ : β → β → Prop
a a₁ a₂ : α
b b₁ b₂ : β
x y : α ⊕ β
h✝ : s b₁ b₂
⊢ s b₁ b₂
Theorem: map_mul_map_eq_map_mul_map
File: Mathlib/Algebra/Hom/Freiman.lean

tactic: simp_rw [← prod_pair] at h⊢
state_before: F : Type u_2
α : Type u_1
β : Type u_3
γ : Type ?u.29208
δ : Type ?u.29211
G : Type ?u.29214
inst✝⁶ : FunLike F α fun x => β
inst✝⁵ : CommMonoid α
inst✝⁴ : CommMonoid β
inst✝³ : CommMonoid γ
inst✝² : CommMonoid δ
inst✝¹ : CommGroup G
A : Set α
B : Set β
C : Set γ
n : ℕ
a b c d : α
inst✝ : FreimanHomClass F A β 2
f : F
ha : a ∈ A
hb : b ∈ A
hc : c ∈ A
hd : d ∈ A
h : a * b = c * d
⊢ ↑f a * ↑f b = ↑f c * ↑f d

tactic: refine' map_prod_eq_map_prod f _ _ (card_pair _ _) (card_pair _ _) h <;> simp [ha, hb, hc, hd]
state_before: F : Type u_2
α : Type u_1
β : Type u_3
γ : Type ?u.29208
δ : Type ?u.29211
G : Type ?u.29214
inst✝⁶ : FunLike F α fun x => β
inst✝⁵ : CommMonoid α
inst✝⁴ : CommMonoid β
inst✝³ : CommMonoid γ
inst✝² : CommMonoid δ
inst✝¹ : CommGroup G
A : Set α
B : Set β
C : Set γ
n : ℕ
a b c d : α
inst✝ : FreimanHomClass F A β 2
f : F
ha : a ∈ A
hb : b ∈ A
hc : c ∈ A
hd : d ∈ A
h : prod {a, b} = prod {c, d}
⊢ prod {↑f a, ↑f b} = prod {↑f c, ↑f d}