tasksource/leandojo huggingface dataset:
Theorem: Polynomial.roots_prod
File: Mathlib/Data/Polynomial/RingDivision.lean

tactic: rcases s with ⟨m, hm⟩
state_before: R : Type u
S : Type v
T : Type w
a b : R
n : ℕ
inst✝¹ : CommRing R
inst✝ : IsDomain R
p q : R[X]
ι : Type u_1
f : ι → R[X]
s : Finset ι
⊢ Finset.prod s f ≠ 0 → roots (Finset.prod s f) = Multiset.bind s.val fun i => roots (f i)

tactic: simpa [Multiset.prod_eq_zero_iff, Multiset.bind_map] using roots_multiset_prod (m.map f)
state_before: case mk
R : Type u
S : Type v
T : Type w
a b : R
n : ℕ
inst✝¹ : CommRing R
inst✝ : IsDomain R
p q : R[X]
ι : Type u_1
f : ι → R[X]
m : Multiset ι
hm : Nodup m
⊢ Finset.prod { val := m, nodup := hm } f ≠ 0 →
    roots (Finset.prod { val := m, nodup := hm } f) = Multiset.bind { val := m, nodup := hm }.val fun i => roots (f i)
Theorem: MeasureTheory.integral_eq_zero_of_mul_left_eq_neg
File: Mathlib/MeasureTheory/Group/Integration.lean

tactic: simp_rw [← self_eq_neg ℝ E, ← integral_neg, ← hf', integral_mul_left_eq_self]
state_before: 𝕜 : Type ?u.46088
M : Type ?u.46091
α : Type ?u.46094
G : Type u_1
E : Type u_2
F : Type ?u.46103
inst✝⁷ : MeasurableSpace G
inst✝⁶ : NormedAddCommGroup E
inst✝⁵ : NormedSpace ℝ E
inst✝⁴ : CompleteSpace E
inst✝³ : NormedAddCommGroup F
μ : Measure G
f : G → E
g : G
inst✝² : Group G
inst✝¹ : MeasurableMul G
inst✝ : IsMulLeftInvariant μ
hf' : ∀ (x : G), f (g * x) = -f x
⊢ (∫ (x : G), f x ∂μ) = 0
Theorem: MvPolynomial.mem_support_iff
File: Mathlib/Data/MvPolynomial/Basic.lean

tactic: simp [support, coeff]
state_before: R : Type u
S₁ : Type v
S₂ : Type w
S₃ : Type x
σ : Type u_1
a a' a₁ a₂ : R
e : ℕ
n m✝ : σ
s : σ →₀ ℕ
inst✝¹ : CommSemiring R
inst✝ : CommSemiring S₁
p✝ q p : MvPolynomial σ R
m : σ →₀ ℕ
⊢ m ∈ support p ↔ coeff m p ≠ 0
Theorem: LieSubmodule.lieSpan_le
File: Mathlib/Algebra/Lie/Submodule.lean

tactic: constructor
state_before: R : Type u
L : Type v
M : Type w
inst✝⁶ : CommRing R
inst✝⁵ : LieRing L
inst✝⁴ : LieAlgebra R L
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : LieRingModule L M
inst✝ : LieModule R L M
N✝ N' : LieSubmodule R L M
I J : LieIdeal R L
s : Set M
N : LieSubmodule R L M
⊢ lieSpan R L s ≤ N ↔ s ⊆ ↑N

tactic: exact Subset.trans subset_lieSpan
state_before: case mp
R : Type u
L : Type v
M : Type w
inst✝⁶ : CommRing R
inst✝⁵ : LieRing L
inst✝⁴ : LieAlgebra R L
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : LieRingModule L M
inst✝ : LieModule R L M
N✝ N' : LieSubmodule R L M
I J : LieIdeal R L
s : Set M
N : LieSubmodule R L M
⊢ lieSpan R L s ≤ N → s ⊆ ↑N

tactic: intro hs m hm
state_before: case mpr
R : Type u
L : Type v
M : Type w
inst✝⁶ : CommRing R
inst✝⁵ : LieRing L
inst✝⁴ : LieAlgebra R L
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : LieRingModule L M
inst✝ : LieModule R L M
N✝ N' : LieSubmodule R L M
I J : LieIdeal R L
s : Set M
N : LieSubmodule R L M
⊢ s ⊆ ↑N → lieSpan R L s ≤ N

tactic: rw [mem_lieSpan] at hm
state_before: case mpr
R : Type u
L : Type v
M : Type w
inst✝⁶ : CommRing R
inst✝⁵ : LieRing L
inst✝⁴ : LieAlgebra R L
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : LieRingModule L M
inst✝ : LieModule R L M
N✝ N' : LieSubmodule R L M
I J : LieIdeal R L
s : Set M
N : LieSubmodule R L M
hs : s ⊆ ↑N
m : M
hm : m ∈ lieSpan R L s
⊢ m ∈ N

tactic: exact hm _ hs
state_before: case mpr
R : Type u
L : Type v
M : Type w
inst✝⁶ : CommRing R
inst✝⁵ : LieRing L
inst✝⁴ : LieAlgebra R L
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : LieRingModule L M
inst✝ : LieModule R L M
N✝ N' : LieSubmodule R L M
I J : LieIdeal R L
s : Set M
N : LieSubmodule R L M
hs : s ⊆ ↑N
m : M
hm : ∀ (N : LieSubmodule R L M), s ⊆ ↑N → m ∈ N
⊢ m ∈ N
Theorem: Subgroup.subgroupOf_sup
File: Mathlib/GroupTheory/Subgroup/Basic.lean

tactic: refine'
  map_injective_of_ker_le B.subtype (ker_le_comap _ _)
    (le_trans (ker_le_comap B.subtype _) le_sup_left) _
state_before: G : Type u_1
G' : Type ?u.712969
inst✝³ : Group G
inst✝² : Group G'
A✝ : Type ?u.712978
inst✝¹ : AddGroup A✝
N : Type ?u.712984
inst✝ : Group N
A A' B : Subgroup G
hA : A ≤ B
hA' : A' ≤ B
⊢ subgroupOf (A ⊔ A') B = subgroupOf A B ⊔ subgroupOf A' B

tactic: simp only [subgroupOf, map_comap_eq, map_sup, subtype_range]
state_before: G : Type u_1
G' : Type ?u.712969
inst✝³ : Group G
inst✝² : Group G'
A✝ : Type ?u.712978
inst✝¹ : AddGroup A✝
N : Type ?u.712984
inst✝ : Group N
A A' B : Subgroup G
hA : A ≤ B
hA' : A' ≤ B
⊢ map (Subgroup.subtype B) (subgroupOf (A ⊔ A') B) = map (Subgroup.subtype B) (subgroupOf A B ⊔ subgroupOf A' B)

tactic: rw [inf_of_le_right (sup_le hA hA'), inf_of_le_right hA', inf_of_le_right hA]
state_before: G : Type u_1
G' : Type ?u.712969
inst✝³ : Group G
inst✝² : Group G'
A✝ : Type ?u.712978
inst✝¹ : AddGroup A✝
N : Type ?u.712984
inst✝ : Group N
A A' B : Subgroup G
hA : A ≤ B
hA' : A' ≤ B
⊢ B ⊓ (A ⊔ A') = B ⊓ A ⊔ B ⊓ A'
Theorem: isUnit_of_mul_isUnit_right
File: Mathlib/Algebra/Group/Units.lean

tactic: rwa [mul_comm]
state_before: α : Type u
M : Type u_1
N : Type ?u.63823
inst✝ : CommMonoid M
x y : M
hu : IsUnit (x * y)
⊢ IsUnit (y * x)
Theorem: LatticeOrderedCommGroup.abs_inv_comm
File: Mathlib/Algebra/Order/LatticeGroup.lean

tactic: dsimp only [Abs.abs]
state_before: α : Type u
inst✝¹ : Lattice α
inst✝ : CommGroup α
a b : α
⊢ abs (a / b) = abs (b / a)

tactic: rw [inv_div a b, ← inv_inv (a / b), inv_div, sup_comm]
state_before: α : Type u
inst✝¹ : Lattice α
inst✝ : CommGroup α
a b : α
⊢ a / b ⊔ (a / b)⁻¹ = b / a ⊔ (b / a)⁻¹
Theorem: UniformOnFun.comap_eq
File: Mathlib/Topology/UniformSpace/UniformConvergenceTopology.lean

tactic: simp_rw [UniformOnFun.uniformSpace, UniformSpace.comap_iInf, UniformFun.comap_eq, ←
  UniformSpace.comap_comap]
state_before: α : Type u_1
β : Type u_3
γ : Type u_2
ι : Type ?u.75481
s s' : Set α
x : α
p : Filter ι
g : ι → α
inst✝ : UniformSpace β
𝔖 : Set (Set α)
f : γ → β
⊢ uniformSpace α γ 𝔖 = UniformSpace.comap ((fun x x_1 => x ∘ x_1) f) (uniformSpace α β 𝔖)

tactic: rfl
state_before: α : Type u_1
β : Type u_3
γ : Type u_2
ι : Type ?u.75481
s s' : Set α
x : α
p : Filter ι
g : ι → α
inst✝ : UniformSpace β
𝔖 : Set (Set α)
f : γ → β
⊢ (⨅ (s : Set α) (_ : s ∈ 𝔖), UniformSpace.comap ((fun x => f ∘ x) ∘ restrict s) (UniformFun.uniformSpace (↑s) β)) =
    ⨅ (i : Set α) (_ : i ∈ 𝔖), UniformSpace.comap (restrict i ∘ fun x => f ∘ x) (UniformFun.uniformSpace (↑i) β)
Theorem: PerfectClosure.mk_zero
File: Mathlib/FieldTheory/PerfectClosure.lean

tactic: induction' n with n ih
state_before: K : Type u
inst✝² : CommRing K
p : ℕ
inst✝¹ : Fact (Nat.Prime p)
inst✝ : CharP K p
n : ℕ
⊢ mk K p (n, 0) = 0

tactic: rw [← ih]
state_before: case succ
K : Type u
inst✝² : CommRing K
p : ℕ
inst✝¹ : Fact (Nat.Prime p)
inst✝ : CharP K p
n : ℕ
ih : mk K p (n, 0) = 0
⊢ mk K p (Nat.succ n, 0) = 0

tactic: symm
state_before: case succ
K : Type u
inst✝² : CommRing K
p : ℕ
inst✝¹ : Fact (Nat.Prime p)
inst✝ : CharP K p
n : ℕ
ih : mk K p (n, 0) = 0
⊢ mk K p (Nat.succ n, 0) = mk K p (n, 0)

tactic: apply Quot.sound
state_before: case succ
K : Type u
inst✝² : CommRing K
p : ℕ
inst✝¹ : Fact (Nat.Prime p)
inst✝ : CharP K p
n : ℕ
ih : mk K p (n, 0) = 0
⊢ mk K p (n, 0) = mk K p (Nat.succ n, 0)

tactic: have := R.intro (p := p) n (0 : K)
state_before: case succ.a
K : Type u
inst✝² : CommRing K
p : ℕ
inst✝¹ : Fact (Nat.Prime p)
inst✝ : CharP K p
n : ℕ
ih : mk K p (n, 0) = 0
⊢ R K p (n, 0) (Nat.succ n, 0)

tactic: rwa [frobenius_zero K p] at this
state_before: case succ.a
K : Type u
inst✝² : CommRing K
p : ℕ
inst✝¹ : Fact (Nat.Prime p)
inst✝ : CharP K p
n : ℕ
ih : mk K p (n, 0) = 0
this : R K p (n, 0) (n + 1, ↑(frobenius K p) 0)
⊢ R K p (n, 0) (Nat.succ n, 0)

tactic: rfl
state_before: case zero
K : Type u
inst✝² : CommRing K
p : ℕ
inst✝¹ : Fact (Nat.Prime p)
inst✝ : CharP K p
⊢ mk K p (Nat.zero, 0) = 0
Theorem: Associated.refl
File: Mathlib/Algebra/Associated.lean

tactic: simp
state_before: α : Type u_1
β : Type ?u.144651
γ : Type ?u.144654
δ : Type ?u.144657
inst✝ : Monoid α
x : α
⊢ x * ↑1 = x
Theorem: Finset.inter_product
File: Mathlib/Data/Finset/Prod.lean

tactic: ext ⟨x, y⟩
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.74538
s s' : Finset α
t t' : Finset β
a : α
b : β
inst✝¹ : DecidableEq α
inst✝ : DecidableEq β
⊢ (s ∩ s') ×ˢ t = s ×ˢ t ∩ s' ×ˢ t

tactic: simp only [← and_and_right, mem_inter, mem_product]
state_before: case a.mk
α : Type u_1
β : Type u_2
γ : Type ?u.74538
s s' : Finset α
t t' : Finset β
a : α
b : β
inst✝¹ : DecidableEq α
inst✝ : DecidableEq β
x : α
y : β
⊢ (x, y) ∈ (s ∩ s') ×ˢ t ↔ (x, y) ∈ s ×ˢ t ∩ s' ×ˢ t
Theorem: MeasureTheory.OuterMeasure.sup_apply
File: Mathlib/MeasureTheory/Measure/OuterMeasure.lean

tactic: have := iSup_apply (fun b => cond b m₁ m₂) s
state_before: α : Type u_1
β : Type ?u.69435
R : Type ?u.69438
R' : Type ?u.69441
ms : Set (OuterMeasure α)
m m₁ m₂ : OuterMeasure α
s : Set α
⊢ ↑(m₁ ⊔ m₂) s = ↑m₁ s ⊔ ↑m₂ s

tactic: rwa [iSup_bool_eq, iSup_bool_eq] at this
state_before: α : Type u_1
β : Type ?u.69435
R : Type ?u.69438
R' : Type ?u.69441
ms : Set (OuterMeasure α)
m m₁ m₂ : OuterMeasure α
s : Set α
this : ↑(⨆ (i : Bool), bif i then m₁ else m₂) s = ⨆ (i : Bool), ↑(bif i then m₁ else m₂) s
⊢ ↑(m₁ ⊔ m₂) s = ↑m₁ s ⊔ ↑m₂ s
Theorem: Submonoid.closure_singleton_le_iff_mem
File: Mathlib/GroupTheory/Submonoid/Basic.lean

tactic: rw [closure_le, singleton_subset_iff, SetLike.mem_coe]
state_before: M : Type u_1
N : Type ?u.28852
A : Type ?u.28855
inst✝¹ : MulOneClass M
s : Set M
inst✝ : AddZeroClass A
t : Set A
S : Submonoid M
m : M
p : Submonoid M
⊢ closure {m} ≤ p ↔ m ∈ p
Theorem: Nat.dvd_of_forall_prime_mul_dvd
File: Mathlib/Data/Nat/Prime.lean

tactic: obtain rfl | ha := eq_or_ne a 1
state_before: a b : ℕ
hdvd : ∀ (p : ℕ), Prime p → p ∣ a → p * a ∣ b
⊢ a ∣ b

tactic: obtain ⟨p, hp⟩ := exists_prime_and_dvd ha
state_before: case inr
a b : ℕ
hdvd : ∀ (p : ℕ), Prime p → p ∣ a → p * a ∣ b
ha : a ≠ 1
⊢ a ∣ b

tactic: exact _root_.trans (dvd_mul_left a p) (hdvd p hp.1 hp.2)
state_before: case inr.intro
a b : ℕ
hdvd : ∀ (p : ℕ), Prime p → p ∣ a → p * a ∣ b
ha : a ≠ 1
p : ℕ
hp : Prime p ∧ p ∣ a
⊢ a ∣ b

tactic: apply one_dvd
state_before: case inl
b : ℕ
hdvd : ∀ (p : ℕ), Prime p → p ∣ 1 → p * 1 ∣ b
⊢ 1 ∣ b
Theorem: Submonoid.closure_induction'
File: Mathlib/GroupTheory/Submonoid/Basic.lean

tactic: refine' Exists.elim _ fun (hx : x ∈ closure s) (hc : p x hx) => hc
state_before: M : Type u_1
N : Type ?u.23218
A : Type ?u.23221
inst✝¹ : MulOneClass M
s✝ : Set M
inst✝ : AddZeroClass A
t : Set A
S : Submonoid M
s : Set M
p : (x : M) → x ∈ closure s → Prop
Hs : ∀ (x : M) (h : x ∈ s), p x (_ : x ∈ ↑(closure s))
H1 : p 1 (_ : 1 ∈ closure s)
Hmul : ∀ (x : M) (hx : x ∈ closure s) (y : M) (hy : y ∈ closure s), p x hx → p y hy → p (x * y) (_ : x * y ∈ closure s)
x : M
hx : x ∈ closure s
⊢ p x hx

tactic: exact
  closure_induction hx (fun x hx => ⟨_, Hs x hx⟩) ⟨_, H1⟩ fun x y ⟨hx', hx⟩ ⟨hy', hy⟩ =>
    ⟨_, Hmul _ _ _ _ hx hy⟩
state_before: M : Type u_1
N : Type ?u.23218
A : Type ?u.23221
inst✝¹ : MulOneClass M
s✝ : Set M
inst✝ : AddZeroClass A
t : Set A
S : Submonoid M
s : Set M
p : (x : M) → x ∈ closure s → Prop
Hs : ∀ (x : M) (h : x ∈ s), p x (_ : x ∈ ↑(closure s))
H1 : p 1 (_ : 1 ∈ closure s)
Hmul : ∀ (x : M) (hx : x ∈ closure s) (y : M) (hy : y ∈ closure s), p x hx → p y hy → p (x * y) (_ : x * y ∈ closure s)
x : M
hx : x ∈ closure s
⊢ ∃ x_1, p x x_1
Theorem: abs_eq
File: Mathlib/Algebra/Order/Group/Abs.lean

tactic: refine' ⟨eq_or_eq_neg_of_abs_eq, _⟩
state_before: α : Type u_1
inst✝ : LinearOrderedAddCommGroup α
a b c d : α
hb : 0 ≤ b
⊢ abs a = b ↔ a = b ∨ a = -b

tactic: rintro (rfl | rfl) <;> simp only [abs_neg, abs_of_nonneg hb]
state_before: α : Type u_1
inst✝ : LinearOrderedAddCommGroup α
a b c d : α
hb : 0 ≤ b
⊢ a = b ∨ a = -b → abs a = b
Theorem: toIcoMod_le_toIocMod
File: Mathlib/Algebra/Order/ToIntervalMod.lean

tactic: rw [toIcoMod, toIocMod, sub_le_sub_iff_left]
state_before: α : Type u_1
inst✝ : LinearOrderedAddCommGroup α
hα : Archimedean α
p : α
hp : 0 < p
a✝ b✝ c : α
n : ℤ
a b : α
⊢ toIcoMod hp a b ≤ toIocMod hp a b

tactic: exact zsmul_mono_left hp.le (toIocDiv_wcovby_toIcoDiv _ _ _).le
state_before: α : Type u_1
inst✝ : LinearOrderedAddCommGroup α
hα : Archimedean α
p : α
hp : 0 < p
a✝ b✝ c : α
n : ℤ
a b : α
⊢ toIocDiv hp a b • p ≤ toIcoDiv hp a b • p
Theorem: nat_sub_dvd_pow_sub_pow
File: Mathlib/Algebra/GeomSum.lean

tactic: cases' le_or_lt y x with h h
state_before: α : Type u
x y n : ℕ
⊢ x - y ∣ x ^ n - y ^ n

tactic: have : y ^ n ≤ x ^ n := Nat.pow_le_pow_of_le_left h _
state_before: case inl
α : Type u
x y n : ℕ
h : y ≤ x
⊢ x - y ∣ x ^ n - y ^ n

tactic: exact_mod_cast sub_dvd_pow_sub_pow (x : ℤ) (↑y) n
state_before: case inl
α : Type u
x y n : ℕ
h : y ≤ x
this : y ^ n ≤ x ^ n
⊢ x - y ∣ x ^ n - y ^ n

tactic: have : x ^ n ≤ y ^ n := Nat.pow_le_pow_of_le_left h.le _
state_before: case inr
α : Type u
x y n : ℕ
h : x < y
⊢ x - y ∣ x ^ n - y ^ n

tactic: exact (Nat.sub_eq_zero_of_le this).symm ▸ dvd_zero (x - y)
state_before: case inr
α : Type u
x y n : ℕ
h : x < y
this : x ^ n ≤ y ^ n
⊢ x - y ∣ x ^ n - y ^ n
Theorem: Finsupp.mapDomain_congr
File: Mathlib/Data/Finsupp/Basic.lean

tactic: simp only [h _ H]
state_before: α : Type u_1
β : Type u_3
γ : Type ?u.168671
ι : Type ?u.168674
M : Type u_2
M' : Type ?u.168680
N : Type ?u.168683
P : Type ?u.168686
G : Type ?u.168689
H✝ : Type ?u.168692
R : Type ?u.168695
S : Type ?u.168698
inst✝ : AddCommMonoid M
v v₁ v₂ : α →₀ M
f g : α → β
h : ∀ (x : α), x ∈ v.support → f x = g x
x✝ : α
H : x✝ ∈ v.support
⊢ (fun a => single (f a)) x✝ (↑v x✝) = (fun a => single (g a)) x✝ (↑v x✝)
Theorem: Real.two_le_pi
File: Mathlib/Analysis/SpecialFunctions/Trigonometric/Basic.lean

tactic: norm_num
state_before: ⊢ 0 < 2

tactic: rw [div_self (two_ne_zero' ℝ)]
state_before: ⊢ 2 / 2 ≤ π / 2

tactic: exact one_le_pi_div_two
state_before: ⊢ 1 ≤ π / 2
Theorem: Set.intersecting_iff_pairwise_not_disjoint
File: Mathlib/Combinatorics/SetFamily/Intersecting.lean

tactic: refine' ⟨fun h => ⟨fun a ha b hb _ => h ha hb, _⟩, fun h a ha b hb hab => _⟩
state_before: α : Type u_1
inst✝¹ : SemilatticeInf α
inst✝ : OrderBot α
s t : Set α
a b c : α
⊢ Intersecting s ↔ (Set.Pairwise s fun a b => ¬Disjoint a b) ∧ s ≠ {⊥}

tactic: have := h.1.eq ha hb (Classical.not_not.2 hab)
state_before: case refine'_2
α : Type u_1
inst✝¹ : SemilatticeInf α
inst✝ : OrderBot α
s t : Set α
a✝ b✝ c : α
h : (Set.Pairwise s fun a b => ¬Disjoint a b) ∧ s ≠ {⊥}
a : α
ha : a ∈ s
b : α
hb : b ∈ s
hab : Disjoint a b
⊢ False

tactic: rw [this, disjoint_self] at hab
state_before: case refine'_2
α : Type u_1
inst✝¹ : SemilatticeInf α
inst✝ : OrderBot α
s t : Set α
a✝ b✝ c : α
h : (Set.Pairwise s fun a b => ¬Disjoint a b) ∧ s ≠ {⊥}
a : α
ha : a ∈ s
b : α
hb : b ∈ s
hab : Disjoint a b
this : a = b
⊢ False

tactic: rw [hab] at hb
state_before: case refine'_2
α : Type u_1
inst✝¹ : SemilatticeInf α
inst✝ : OrderBot α
s t : Set α
a✝ b✝ c : α
h : (Set.Pairwise s fun a b => ¬Disjoint a b) ∧ s ≠ {⊥}
a : α
ha : a ∈ s
b : α
hb : b ∈ s
hab : b = ⊥
this : a = b
⊢ False

tactic: exact
  h.2
    (eq_singleton_iff_unique_mem.2
      ⟨hb, fun c hc => not_ne_iff.1 fun H => h.1 hb hc H.symm disjoint_bot_left⟩)
state_before: case refine'_2
α : Type u_1
inst✝¹ : SemilatticeInf α
inst✝ : OrderBot α
s t : Set α
a✝ b✝ c : α
h : (Set.Pairwise s fun a b => ¬Disjoint a b) ∧ s ≠ {⊥}
a : α
ha : a ∈ s
b : α
hb : ⊥ ∈ s
hab : b = ⊥
this : a = b
⊢ False

tactic: rintro rfl
state_before: case refine'_1
α : Type u_1
inst✝¹ : SemilatticeInf α
inst✝ : OrderBot α
s t : Set α
a b c : α
h : Intersecting s
⊢ s ≠ {⊥}

tactic: exact intersecting_singleton.1 h rfl
state_before: case refine'_1
α : Type u_1
inst✝¹ : SemilatticeInf α
inst✝ : OrderBot α
t : Set α
a b c : α
h : Intersecting {⊥}
⊢ False
Theorem: MeasureTheory.Content.innerContent_bot
File: Mathlib/MeasureTheory/Measure/Content.lean

tactic: refine' le_antisymm _ (zero_le _)
state_before: G : Type w
inst✝ : TopologicalSpace G
μ : Content G
⊢ innerContent μ ⊥ = 0

tactic: rw [← μ.empty]
state_before: G : Type w
inst✝ : TopologicalSpace G
μ : Content G
⊢ innerContent μ ⊥ ≤ 0

tactic: refine' iSup₂_le fun K hK => _
state_before: G : Type w
inst✝ : TopologicalSpace G
μ : Content G
⊢ innerContent μ ⊥ ≤ (fun s => ↑(toFun μ s)) ⊥

tactic: have : K = ⊥ := by
  ext1
  rw [subset_empty_iff.mp hK, Compacts.coe_bot]
state_before: G : Type w
inst✝ : TopologicalSpace G
μ : Content G
K : Compacts G
hK : ↑K ⊆ ↑⊥
⊢ (fun s => ↑(toFun μ s)) K ≤ (fun s => ↑(toFun μ s)) ⊥

tactic: rw [this]
state_before: G : Type w
inst✝ : TopologicalSpace G
μ : Content G
K : Compacts G
hK : ↑K ⊆ ↑⊥
this : K = ⊥
⊢ (fun s => ↑(toFun μ s)) K ≤ (fun s => ↑(toFun μ s)) ⊥

tactic: ext1
state_before: G : Type w
inst✝ : TopologicalSpace G
μ : Content G
K : Compacts G
hK : ↑K ⊆ ↑⊥
⊢ K = ⊥

tactic: rw [subset_empty_iff.mp hK, Compacts.coe_bot]
state_before: case h
G : Type w
inst✝ : TopologicalSpace G
μ : Content G
K : Compacts G
hK : ↑K ⊆ ↑⊥
⊢ ↑K = ↑⊥
Theorem: FilterBasis.eq_iInf_principal
File: Mathlib/Order/Filter/Bases.lean

tactic: ext U
state_before: α : Type u_1
β : Type ?u.4090
γ : Type ?u.4093
ι : Sort ?u.4096
ι' : Sort ?u.4099
B : FilterBasis α
this : Directed (fun x x_1 => x ≥ x_1) fun s => 𝓟 ↑s
⊢ FilterBasis.filter B = ⨅ (s : ↑B.sets), 𝓟 ↑s

tactic: simp [mem_filter_iff, mem_iInf_of_directed this]
state_before: case a
α : Type u_1
β : Type ?u.4090
γ : Type ?u.4093
ι : Sort ?u.4096
ι' : Sort ?u.4099
B : FilterBasis α
this : Directed (fun x x_1 => x ≥ x_1) fun s => 𝓟 ↑s
U : Set α
⊢ U ∈ FilterBasis.filter B ↔ U ∈ ⨅ (s : ↑B.sets), 𝓟 ↑s

tactic: rintro ⟨U, U_in⟩ ⟨V, V_in⟩
state_before: α : Type u_1
β : Type ?u.4090
γ : Type ?u.4093
ι : Sort ?u.4096
ι' : Sort ?u.4099
B : FilterBasis α
⊢ Directed (fun x x_1 => x ≥ x_1) fun s => 𝓟 ↑s

tactic: rcases B.inter_sets U_in V_in with ⟨W, W_in, W_sub⟩
state_before: case mk.mk
α : Type u_1
β : Type ?u.4090
γ : Type ?u.4093
ι : Sort ?u.4096
ι' : Sort ?u.4099
B : FilterBasis α
U : Set α
U_in : U ∈ B.sets
V : Set α
V_in : V ∈ B.sets
⊢ ∃ z,
    (fun x x_1 => x ≥ x_1) ((fun s => 𝓟 ↑s) { val := U, property := U_in }) ((fun s => 𝓟 ↑s) z) ∧
      (fun x x_1 => x ≥ x_1) ((fun s => 𝓟 ↑s) { val := V, property := V_in }) ((fun s => 𝓟 ↑s) z)

tactic: use ⟨W, W_in⟩
state_before: case mk.mk.intro.intro
α : Type u_1
β : Type ?u.4090
γ : Type ?u.4093
ι : Sort ?u.4096
ι' : Sort ?u.4099
B : FilterBasis α
U : Set α
U_in : U ∈ B.sets
V : Set α
V_in : V ∈ B.sets
W : Set α
W_in : W ∈ B.sets
W_sub : W ⊆ U ∩ V
⊢ ∃ z,
    (fun x x_1 => x ≥ x_1) ((fun s => 𝓟 ↑s) { val := U, property := U_in }) ((fun s => 𝓟 ↑s) z) ∧
      (fun x x_1 => x ≥ x_1) ((fun s => 𝓟 ↑s) { val := V, property := V_in }) ((fun s => 𝓟 ↑s) z)

tactic: simp only [ge_iff_le, le_principal_iff, mem_principal, Subtype.coe_mk]
state_before: case mk.mk.intro.intro
α : Type u_1
β : Type ?u.4090
γ : Type ?u.4093
ι : Sort ?u.4096
ι' : Sort ?u.4099
B : FilterBasis α
U : Set α
U_in : U ∈ B.sets
V : Set α
V_in : V ∈ B.sets
W : Set α
W_in : W ∈ B.sets
W_sub : W ⊆ U ∩ V
⊢ (fun x x_1 => x ≥ x_1) ((fun s => 𝓟 ↑s) { val := U, property := U_in })
      ((fun s => 𝓟 ↑s) { val := W, property := W_in }) ∧
    (fun x x_1 => x ≥ x_1) ((fun s => 𝓟 ↑s) { val := V, property := V_in })
      ((fun s => 𝓟 ↑s) { val := W, property := W_in })

tactic: exact subset_inter_iff.mp W_sub
state_before: case mk.mk.intro.intro
α : Type u_1
β : Type ?u.4090
γ : Type ?u.4093
ι : Sort ?u.4096
ι' : Sort ?u.4099
B : FilterBasis α
U : Set α
U_in : U ∈ B.sets
V : Set α
V_in : V ∈ B.sets
W : Set α
W_in : W ∈ B.sets
W_sub : W ⊆ U ∩ V
⊢ W ⊆ U ∧ W ⊆ V
Theorem: AlgebraicTopology.DoldKan.Isδ₀.eq_δ₀
File: Mathlib/AlgebraicTopology/DoldKan/FunctorGamma.lean

tactic: obtain ⟨j, rfl⟩ := SimplexCategory.eq_δ_of_mono i
state_before: C : Type ?u.2249
inst✝² : Category C
inst✝¹ : Preadditive C
K K' : ChainComplex C ℕ
f : K ⟶ K'
Δ Δ' Δ'' : SimplexCategory
n : ℕ
i : [n] ⟶ [n + 1]
inst✝ : Mono i
hi : Isδ₀ i
⊢ i = SimplexCategory.δ 0

tactic: rw [iff] at hi
state_before: case intro
C : Type ?u.2249
inst✝² : Category C
inst✝¹ : Preadditive C
K K' : ChainComplex C ℕ
f : K ⟶ K'
Δ Δ' Δ'' : SimplexCategory
n : ℕ
j : Fin (n + 2)
inst✝ : Mono (SimplexCategory.δ j)
hi : Isδ₀ (SimplexCategory.δ j)
⊢ SimplexCategory.δ j = SimplexCategory.δ 0

tactic: rw [hi]
state_before: case intro
C : Type ?u.2249
inst✝² : Category C
inst✝¹ : Preadditive C
K K' : ChainComplex C ℕ
f : K ⟶ K'
Δ Δ' Δ'' : SimplexCategory
n : ℕ
j : Fin (n + 2)
inst✝ : Mono (SimplexCategory.δ j)
hi : j = 0
⊢ SimplexCategory.δ j = SimplexCategory.δ 0
Theorem: MeasureTheory.BoundedContinuousFunction.inner_toLp
File: Mathlib/MeasureTheory/Function/L2Space.lean

tactic: apply integral_congr_ae
state_before: α : Type u_1
inst✝⁴ : TopologicalSpace α
inst✝³ : MeasureSpace α
inst✝² : BorelSpace α
𝕜 : Type u_2
inst✝¹ : IsROrC 𝕜
μ : Measure α
inst✝ : IsFiniteMeasure μ
f g : α →ᵇ 𝕜
⊢ inner (↑(BoundedContinuousFunction.toLp 2 μ 𝕜) f) (↑(BoundedContinuousFunction.toLp 2 μ 𝕜) g) =
    ∫ (x : α), ↑(starRingEnd ((fun a => 𝕜) x)) (↑f x) * ↑g x ∂μ

tactic: have hf_ae := f.coeFn_toLp 2 μ 𝕜
state_before: case h
α : Type u_1
inst✝⁴ : TopologicalSpace α
inst✝³ : MeasureSpace α
inst✝² : BorelSpace α
𝕜 : Type u_2
inst✝¹ : IsROrC 𝕜
μ : Measure α
inst✝ : IsFiniteMeasure μ
f g : α →ᵇ 𝕜
⊢ (fun a =>
      inner (↑↑(↑(BoundedContinuousFunction.toLp 2 μ 𝕜) f) a) (↑↑(↑(BoundedContinuousFunction.toLp 2 μ 𝕜) g) a)) =ᵐ[μ]
    fun a => ↑(starRingEnd ((fun a => 𝕜) a)) (↑f a) * ↑g a

tactic: have hg_ae := g.coeFn_toLp 2 μ 𝕜
state_before: case h
α : Type u_1
inst✝⁴ : TopologicalSpace α
inst✝³ : MeasureSpace α
inst✝² : BorelSpace α
𝕜 : Type u_2
inst✝¹ : IsROrC 𝕜
μ : Measure α
inst✝ : IsFiniteMeasure μ
f g : α →ᵇ 𝕜
hf_ae : ↑↑(↑(BoundedContinuousFunction.toLp 2 μ 𝕜) f) =ᵐ[μ] ↑f
⊢ (fun a =>
      inner (↑↑(↑(BoundedContinuousFunction.toLp 2 μ 𝕜) f) a) (↑↑(↑(BoundedContinuousFunction.toLp 2 μ 𝕜) g) a)) =ᵐ[μ]
    fun a => ↑(starRingEnd ((fun a => 𝕜) a)) (↑f a) * ↑g a

tactic: filter_upwards [hf_ae, hg_ae] with _ hf hg
state_before: case h
α : Type u_1
inst✝⁴ : TopologicalSpace α
inst✝³ : MeasureSpace α
inst✝² : BorelSpace α
𝕜 : Type u_2
inst✝¹ : IsROrC 𝕜
μ : Measure α
inst✝ : IsFiniteMeasure μ
f g : α →ᵇ 𝕜
hf_ae : ↑↑(↑(BoundedContinuousFunction.toLp 2 μ 𝕜) f) =ᵐ[μ] ↑f
hg_ae : ↑↑(↑(BoundedContinuousFunction.toLp 2 μ 𝕜) g) =ᵐ[μ] ↑g
⊢ (fun a =>
      inner (↑↑(↑(BoundedContinuousFunction.toLp 2 μ 𝕜) f) a) (↑↑(↑(BoundedContinuousFunction.toLp 2 μ 𝕜) g) a)) =ᵐ[μ]
    fun a => ↑(starRingEnd ((fun a => 𝕜) a)) (↑f a) * ↑g a

tactic: rw [hf, hg]
state_before: case h
α : Type u_1
inst✝⁴ : TopologicalSpace α
inst✝³ : MeasureSpace α
inst✝² : BorelSpace α
𝕜 : Type u_2
inst✝¹ : IsROrC 𝕜
μ : Measure α
inst✝ : IsFiniteMeasure μ
f g : α →ᵇ 𝕜
hf_ae : ↑↑(↑(BoundedContinuousFunction.toLp 2 μ 𝕜) f) =ᵐ[μ] ↑f
hg_ae : ↑↑(↑(BoundedContinuousFunction.toLp 2 μ 𝕜) g) =ᵐ[μ] ↑g
a✝ : α
hf : ↑↑(↑(BoundedContinuousFunction.toLp 2 μ 𝕜) f) a✝ = ↑f a✝
hg : ↑↑(↑(BoundedContinuousFunction.toLp 2 μ 𝕜) g) a✝ = ↑g a✝
⊢ inner (↑↑(↑(BoundedContinuousFunction.toLp 2 μ 𝕜) f) a✝) (↑↑(↑(BoundedContinuousFunction.toLp 2 μ 𝕜) g) a✝) =
    ↑(starRingEnd 𝕜) (↑f a✝) * ↑g a✝

tactic: simp
state_before: case h
α : Type u_1
inst✝⁴ : TopologicalSpace α
inst✝³ : MeasureSpace α
inst✝² : BorelSpace α
𝕜 : Type u_2
inst✝¹ : IsROrC 𝕜
μ : Measure α
inst✝ : IsFiniteMeasure μ
f g : α →ᵇ 𝕜
hf_ae : ↑↑(↑(BoundedContinuousFunction.toLp 2 μ 𝕜) f) =ᵐ[μ] ↑f
hg_ae : ↑↑(↑(BoundedContinuousFunction.toLp 2 μ 𝕜) g) =ᵐ[μ] ↑g
a✝ : α
hf : ↑↑(↑(BoundedContinuousFunction.toLp 2 μ 𝕜) f) a✝ = ↑f a✝
hg : ↑↑(↑(BoundedContinuousFunction.toLp 2 μ 𝕜) g) a✝ = ↑g a✝
⊢ inner (↑f a✝) (↑g a✝) = ↑(starRingEnd 𝕜) (↑f a✝) * ↑g a✝
Theorem: integral_sin_pow_even_mul_cos_pow_even
File: Mathlib/Analysis/SpecialFunctions/Integrals.lean

tactic: field_simp [pow_mul, sin_sq, cos_sq, ← sub_sub, (by ring : (2 : ℝ) - 1 = 1)]
state_before: a b : ℝ
n✝ m n : ℕ
⊢ (∫ (x : ℝ) in a..b, sin x ^ (2 * m) * cos x ^ (2 * n)) =
    ∫ (x : ℝ) in a..b, ((1 - cos (2 * x)) / 2) ^ m * ((1 + cos (2 * x)) / 2) ^ n

tactic: ring
state_before: a b : ℝ
n✝ m n : ℕ
⊢ 2 - 1 = 1
Theorem: FirstOrder.Language.Ultraproduct.funMap_cast
File: Mathlib/ModelTheory/Ultraproducts.lean

tactic: apply funMap_quotient_mk'
state_before: α : Type u_1
M : α → Type u_2
u : Ultrafilter α
L : Language
inst✝ : (a : α) → Structure L (M a)
n : ℕ
f : Functions L n
x : Fin n → (a : α) → M a
⊢ (funMap f fun i => Quotient.mk' (x i)) = Quotient.mk' fun a => funMap f fun i => x i a