tasksource/leandojo huggingface dataset:
Theorem: Multiset.bind_powerset_len
File: Mathlib/Data/Multiset/Powerset.lean

tactic: induction S using Quotient.inductionOn
state_before: α✝ : Type ?u.61956
α : Type u_1
S : Multiset α
⊢ (bind (range (↑card S + 1)) fun k => powersetLen k S) = powerset S

tactic: simp_rw [quot_mk_to_coe, powerset_coe', powersetLen_coe, ← coe_range, coe_bind, ← List.bind_map,
  coe_card]
state_before: case h
α✝ : Type ?u.61956
α : Type u_1
a✝ : List α
⊢ (bind (range (↑card (Quotient.mk (isSetoid α) a✝) + 1)) fun k => powersetLen k (Quotient.mk (isSetoid α) a✝)) =
    powerset (Quotient.mk (isSetoid α) a✝)

tactic: exact coe_eq_coe.mpr ((List.range_bind_sublistsLen_perm _).map _)
state_before: case h
α✝ : Type ?u.61956
α : Type u_1
a✝ : List α
⊢ ↑(List.map ofList (List.bind (List.range (length a✝ + 1)) fun a => sublistsLen a a✝)) =
    ↑(List.map ofList (sublists' a✝))
Theorem: RatFunc.num_dvd
File: Mathlib/FieldTheory/RatFunc.lean

tactic: constructor
state_before: K : Type u
inst✝ : Field K
x : RatFunc K
p : K[X]
hp : p ≠ 0
⊢ num x ∣ p ↔ ∃ q hq, x = ↑(algebraMap K[X] (RatFunc K)) p / ↑(algebraMap K[X] (RatFunc K)) q

tactic: rintro ⟨q, rfl⟩
state_before: case mp
K : Type u
inst✝ : Field K
x : RatFunc K
p : K[X]
hp : p ≠ 0
⊢ num x ∣ p → ∃ q hq, x = ↑(algebraMap K[X] (RatFunc K)) p / ↑(algebraMap K[X] (RatFunc K)) q

tactic: obtain ⟨_hx, hq⟩ := mul_ne_zero_iff.mp hp
state_before: case mp.intro
K : Type u
inst✝ : Field K
x : RatFunc K
q : K[X]
hp : num x * q ≠ 0
⊢ ∃ q_1 hq, x = ↑(algebraMap K[X] (RatFunc K)) (num x * q) / ↑(algebraMap K[X] (RatFunc K)) q_1

tactic: use denom x * q
state_before: case mp.intro.intro
K : Type u
inst✝ : Field K
x : RatFunc K
q : K[X]
hp : num x * q ≠ 0
_hx : num x ≠ 0
hq : q ≠ 0
⊢ ∃ q_1 hq, x = ↑(algebraMap K[X] (RatFunc K)) (num x * q) / ↑(algebraMap K[X] (RatFunc K)) q_1

tactic: rw [RingHom.map_mul, RingHom.map_mul, ← div_mul_div_comm, div_self, mul_one, num_div_denom]
state_before: case mp.intro.intro
K : Type u
inst✝ : Field K
x : RatFunc K
q : K[X]
hp : num x * q ≠ 0
_hx : num x ≠ 0
hq : q ≠ 0
⊢ ∃ hq, x = ↑(algebraMap K[X] (RatFunc K)) (num x * q) / ↑(algebraMap K[X] (RatFunc K)) (denom x * q)

tactic: exact ⟨mul_ne_zero (denom_ne_zero x) hq, rfl⟩
state_before: case mp.intro.intro
K : Type u
inst✝ : Field K
x : RatFunc K
q : K[X]
hp : num x * q ≠ 0
_hx : num x ≠ 0
hq : q ≠ 0
⊢ ∃ hq, x = x

tactic: exact algebraMap_ne_zero hq
state_before: case mp.intro.intro
K : Type u
inst✝ : Field K
x : RatFunc K
q : K[X]
hp : num x * q ≠ 0
_hx : num x ≠ 0
hq : q ≠ 0
⊢ ↑(algebraMap K[X] (RatFunc K)) q ≠ 0

tactic: rintro ⟨q, hq, rfl⟩
state_before: case mpr
K : Type u
inst✝ : Field K
x : RatFunc K
p : K[X]
hp : p ≠ 0
⊢ (∃ q hq, x = ↑(algebraMap K[X] (RatFunc K)) p / ↑(algebraMap K[X] (RatFunc K)) q) → num x ∣ p

tactic: exact num_div_dvd p hq
state_before: case mpr.intro.intro
K : Type u
inst✝ : Field K
p : K[X]
hp : p ≠ 0
q : K[X]
hq : q ≠ 0
⊢ num (↑(algebraMap K[X] (RatFunc K)) p / ↑(algebraMap K[X] (RatFunc K)) q) ∣ p
Theorem: FirstOrder.Language.BoundedFormula.relabel_ex
File: Mathlib/ModelTheory/Syntax.lean

tactic: simp [BoundedFormula.ex]
state_before: L : Language
L' : Language
M : Type w
N : Type ?u.97781
P : Type ?u.97784
inst✝² : Structure L M
inst✝¹ : Structure L N
inst✝ : Structure L P
α : Type u'
β : Type v'
γ : Type ?u.97812
n : ℕ
g : α → β ⊕ Fin n
k : ℕ
φ : BoundedFormula L α (k + 1)
⊢ relabel g (BoundedFormula.ex φ) = BoundedFormula.ex (relabel g φ)
Theorem: Equiv.Perm.cycleFactorsFinset_one
File: Mathlib/GroupTheory/Perm/Cycle/Basic.lean

tactic: simp [cycleFactorsFinset_eq_empty_iff]
state_before: ι : Type ?u.2750685
α : Type u_1
β : Type ?u.2750691
inst✝¹ : DecidableEq α
inst✝ : Fintype α
f : Perm α
⊢ cycleFactorsFinset 1 = ∅
Theorem: Polynomial.eval₂_primPart_eq_zero
File: Mathlib/RingTheory/Polynomial/Content.lean

tactic: rw [eq_C_content_mul_primPart p, eval₂_mul, eval₂_C] at hp
state_before: R : Type u_2
inst✝⁴ : CommRing R
inst✝³ : IsDomain R
inst✝² : NormalizedGCDMonoid R
S : Type u_1
inst✝¹ : CommRing S
inst✝ : IsDomain S
f : R →+* S
hinj : Function.Injective ↑f
p : R[X]
s : S
hpzero : p ≠ 0
hp : eval₂ f s p = 0
⊢ eval₂ f s (primPart p) = 0

tactic: have hcont : p.content ≠ 0 := fun h => hpzero (content_eq_zero_iff.1 h)
state_before: R : Type u_2
inst✝⁴ : CommRing R
inst✝³ : IsDomain R
inst✝² : NormalizedGCDMonoid R
S : Type u_1
inst✝¹ : CommRing S
inst✝ : IsDomain S
f : R →+* S
hinj : Function.Injective ↑f
p : R[X]
s : S
hpzero : p ≠ 0
hp : ↑f (content p) * eval₂ f s (primPart p) = 0
⊢ eval₂ f s (primPart p) = 0

tactic: replace hcont := Function.Injective.ne hinj hcont
state_before: R : Type u_2
inst✝⁴ : CommRing R
inst✝³ : IsDomain R
inst✝² : NormalizedGCDMonoid R
S : Type u_1
inst✝¹ : CommRing S
inst✝ : IsDomain S
f : R →+* S
hinj : Function.Injective ↑f
p : R[X]
s : S
hpzero : p ≠ 0
hp : ↑f (content p) * eval₂ f s (primPart p) = 0
hcont : content p ≠ 0
⊢ eval₂ f s (primPart p) = 0

tactic: rw [map_zero] at hcont
state_before: R : Type u_2
inst✝⁴ : CommRing R
inst✝³ : IsDomain R
inst✝² : NormalizedGCDMonoid R
S : Type u_1
inst✝¹ : CommRing S
inst✝ : IsDomain S
f : R →+* S
hinj : Function.Injective ↑f
p : R[X]
s : S
hpzero : p ≠ 0
hp : ↑f (content p) * eval₂ f s (primPart p) = 0
hcont : ↑f (content p) ≠ ↑f 0
⊢ eval₂ f s (primPart p) = 0

tactic: exact eq_zero_of_ne_zero_of_mul_left_eq_zero hcont hp
state_before: R : Type u_2
inst✝⁴ : CommRing R
inst✝³ : IsDomain R
inst✝² : NormalizedGCDMonoid R
S : Type u_1
inst✝¹ : CommRing S
inst✝ : IsDomain S
f : R →+* S
hinj : Function.Injective ↑f
p : R[X]
s : S
hpzero : p ≠ 0
hp : ↑f (content p) * eval₂ f s (primPart p) = 0
hcont : ↑f (content p) ≠ 0
⊢ eval₂ f s (primPart p) = 0
Theorem: Filter.countable_biInf_eq_iInf_seq'
File: Mathlib/Order/Filter/Bases.lean

tactic: cases' B.eq_empty_or_nonempty with hB Bnonempty
state_before: α : Type u_1
β : Type ?u.94654
γ : Type ?u.94657
ι : Type u_2
ι' : Sort ?u.94663
inst✝ : CompleteLattice α
B : Set ι
Bcbl : Set.Countable B
f : ι → α
i₀ : ι
h : f i₀ = ⊤
⊢ ∃ x, (⨅ (t : ι) (_ : t ∈ B), f t) = ⨅ (i : ℕ), f (x i)

tactic: rw [hB, iInf_emptyset]
state_before: case inl
α : Type u_1
β : Type ?u.94654
γ : Type ?u.94657
ι : Type u_2
ι' : Sort ?u.94663
inst✝ : CompleteLattice α
B : Set ι
Bcbl : Set.Countable B
f : ι → α
i₀ : ι
h : f i₀ = ⊤
hB : B = ∅
⊢ ∃ x, (⨅ (t : ι) (_ : t ∈ B), f t) = ⨅ (i : ℕ), f (x i)

tactic: use fun _ => i₀
state_before: case inl
α : Type u_1
β : Type ?u.94654
γ : Type ?u.94657
ι : Type u_2
ι' : Sort ?u.94663
inst✝ : CompleteLattice α
B : Set ι
Bcbl : Set.Countable B
f : ι → α
i₀ : ι
h : f i₀ = ⊤
hB : B = ∅
⊢ ∃ x, ⊤ = ⨅ (i : ℕ), f (x i)

tactic: simp [h]
state_before: case inl
α : Type u_1
β : Type ?u.94654
γ : Type ?u.94657
ι : Type u_2
ι' : Sort ?u.94663
inst✝ : CompleteLattice α
B : Set ι
Bcbl : Set.Countable B
f : ι → α
i₀ : ι
h : f i₀ = ⊤
hB : B = ∅
⊢ ⊤ = ⨅ (i : ℕ), f ((fun x => i₀) i)

tactic: exact countable_biInf_eq_iInf_seq Bcbl Bnonempty f
state_before: case inr
α : Type u_1
β : Type ?u.94654
γ : Type ?u.94657
ι : Type u_2
ι' : Sort ?u.94663
inst✝ : CompleteLattice α
B : Set ι
Bcbl : Set.Countable B
f : ι → α
i₀ : ι
h : f i₀ = ⊤
Bnonempty : Set.Nonempty B
⊢ ∃ x, (⨅ (t : ι) (_ : t ∈ B), f t) = ⨅ (i : ℕ), f (x i)
Theorem: LinearEquiv.toLinearEquiv_toContinuousLinearEquiv_symm
File: Mathlib/Topology/Algebra/Module/FiniteDimension.lean

tactic: ext x
state_before: 𝕜 : Type u
hnorm : NontriviallyNormedField 𝕜
E : Type v
inst✝¹⁸ : AddCommGroup E
inst✝¹⁷ : Module 𝕜 E
inst✝¹⁶ : TopologicalSpace E
inst✝¹⁵ : TopologicalAddGroup E
inst✝¹⁴ : ContinuousSMul 𝕜 E
F : Type w
inst✝¹³ : AddCommGroup F
inst✝¹² : Module 𝕜 F
inst✝¹¹ : TopologicalSpace F
inst✝¹⁰ : TopologicalAddGroup F
inst✝⁹ : ContinuousSMul 𝕜 F
F' : Type x
inst✝⁸ : AddCommGroup F'
inst✝⁷ : Module 𝕜 F'
inst✝⁶ : TopologicalSpace F'
inst✝⁵ : TopologicalAddGroup F'
inst✝⁴ : ContinuousSMul 𝕜 F'
inst✝³ : CompleteSpace 𝕜
inst✝² : T2Space E
inst✝¹ : T2Space F
inst✝ : FiniteDimensional 𝕜 E
e : E ≃ₗ[𝕜] F
⊢ (ContinuousLinearEquiv.symm (toContinuousLinearEquiv e)).toLinearEquiv = symm e

tactic: rfl
state_before: case h
𝕜 : Type u
hnorm : NontriviallyNormedField 𝕜
E : Type v
inst✝¹⁸ : AddCommGroup E
inst✝¹⁷ : Module 𝕜 E
inst✝¹⁶ : TopologicalSpace E
inst✝¹⁵ : TopologicalAddGroup E
inst✝¹⁴ : ContinuousSMul 𝕜 E
F : Type w
inst✝¹³ : AddCommGroup F
inst✝¹² : Module 𝕜 F
inst✝¹¹ : TopologicalSpace F
inst✝¹⁰ : TopologicalAddGroup F
inst✝⁹ : ContinuousSMul 𝕜 F
F' : Type x
inst✝⁸ : AddCommGroup F'
inst✝⁷ : Module 𝕜 F'
inst✝⁶ : TopologicalSpace F'
inst✝⁵ : TopologicalAddGroup F'
inst✝⁴ : ContinuousSMul 𝕜 F'
inst✝³ : CompleteSpace 𝕜
inst✝² : T2Space E
inst✝¹ : T2Space F
inst✝ : FiniteDimensional 𝕜 E
e : E ≃ₗ[𝕜] F
x : F
⊢ ↑(ContinuousLinearEquiv.symm (toContinuousLinearEquiv e)).toLinearEquiv x = ↑(symm e) x
Theorem: PiNat.mem_cylinder_comm
File: Mathlib/Topology/MetricSpace/PiNat.lean

tactic: simp [mem_cylinder_iff_eq, eq_comm]
state_before: E : ℕ → Type u_1
x y : (n : ℕ) → E n
n : ℕ
⊢ y ∈ cylinder x n ↔ x ∈ cylinder y n
Theorem: MeasureTheory.IsFundamentalDomain.measure_set_eq
File: Mathlib/MeasureTheory/Group/FundamentalDomain.lean

tactic: simpa [Measure.restrict_apply hA₀, lintegral_indicator _ hA₀] using this
state_before: G : Type u_1
H : Type ?u.271746
α : Type u_2
β : Type ?u.271752
E : Type ?u.271755
inst✝¹⁰ : Group G
inst✝⁹ : Group H
inst✝⁸ : MulAction G α
inst✝⁷ : MeasurableSpace α
inst✝⁶ : MulAction H β
inst✝⁵ : MeasurableSpace β
inst✝⁴ : NormedAddCommGroup E
s t : Set α
μ : Measure α
inst✝³ : MeasurableSpace G
inst✝² : MeasurableSMul G α
inst✝¹ : SMulInvariantMeasure G α μ
inst✝ : Countable G
ν : Measure α
hs : IsFundamentalDomain G s
ht : IsFundamentalDomain G t
A : Set α
hA₀ : MeasurableSet A
hA : ∀ (g : G), (fun x => g • x) ⁻¹' A = A
this : (∫⁻ (x : α) in s, indicator A 1 x ∂μ) = ∫⁻ (x : α) in t, indicator A 1 x ∂μ
⊢ ↑↑μ (A ∩ s) = ↑↑μ (A ∩ t)

tactic: refine hs.set_lintegral_eq ht (Set.indicator A fun _ => 1) fun g x ↦ ?_
state_before: G : Type u_1
H : Type ?u.271746
α : Type u_2
β : Type ?u.271752
E : Type ?u.271755
inst✝¹⁰ : Group G
inst✝⁹ : Group H
inst✝⁸ : MulAction G α
inst✝⁷ : MeasurableSpace α
inst✝⁶ : MulAction H β
inst✝⁵ : MeasurableSpace β
inst✝⁴ : NormedAddCommGroup E
s t : Set α
μ : Measure α
inst✝³ : MeasurableSpace G
inst✝² : MeasurableSMul G α
inst✝¹ : SMulInvariantMeasure G α μ
inst✝ : Countable G
ν : Measure α
hs : IsFundamentalDomain G s
ht : IsFundamentalDomain G t
A : Set α
hA₀ : MeasurableSet A
hA : ∀ (g : G), (fun x => g • x) ⁻¹' A = A
⊢ (∫⁻ (x : α) in s, indicator A 1 x ∂μ) = ∫⁻ (x : α) in t, indicator A 1 x ∂μ

tactic: rw [hA g]
state_before: case h.e'_3.h.e'_4
G : Type u_1
H : Type ?u.271746
α : Type u_2
β : Type ?u.271752
E : Type ?u.271755
inst✝¹⁰ : Group G
inst✝⁹ : Group H
inst✝⁸ : MulAction G α
inst✝⁷ : MeasurableSpace α
inst✝⁶ : MulAction H β
inst✝⁵ : MeasurableSpace β
inst✝⁴ : NormedAddCommGroup E
s t : Set α
μ : Measure α
inst✝³ : MeasurableSpace G
inst✝² : MeasurableSMul G α
inst✝¹ : SMulInvariantMeasure G α μ
inst✝ : Countable G
ν : Measure α
hs : IsFundamentalDomain G s
ht : IsFundamentalDomain G t
A : Set α
hA₀ : MeasurableSet A
hA : ∀ (g : G), (fun x => g • x) ⁻¹' A = A
g : G
x : α
⊢ A = (fun x => g • x) ⁻¹' A
Theorem: Units.exists_iff_ne_zero
File: Mathlib/Algebra/GroupWithZero/Units/Basic.lean

tactic: simp [exists0]
state_before: α : Type ?u.15430
M₀ : Type ?u.15433
G₀ : Type u_1
M₀' : Type ?u.15439
G₀' : Type ?u.15442
F : Type ?u.15445
F' : Type ?u.15448
inst✝¹ : MonoidWithZero M₀
inst✝ : GroupWithZero G₀
a b x : G₀
⊢ (∃ u, ↑u = x) ↔ x ≠ 0
Theorem: hasFDerivWithinAt_diff_singleton
File: Mathlib/Analysis/Calculus/FDeriv/Basic.lean

tactic: rw [← hasFDerivWithinAt_insert, insert_diff_singleton, hasFDerivWithinAt_insert]
state_before: 𝕜 : Type u_1
inst✝⁸ : NontriviallyNormedField 𝕜
E : Type u_2
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type u_3
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type ?u.190837
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
G' : Type ?u.190932
inst✝¹ : NormedAddCommGroup G'
inst✝ : NormedSpace 𝕜 G'
f f₀ f₁ g : E → F
f' f₀' f₁' g' e : E →L[𝕜] F
x : E
s t : Set E
L L₁ L₂ : Filter E
y : E
⊢ HasFDerivWithinAt f f' (s \ {y}) x ↔ HasFDerivWithinAt f f' s x
Theorem: List.all₂_zipWith
File: Mathlib/Data/List/Zip.lean

tactic: simp
state_before: α : Type u
β : Type u_1
γ : Type u_2
δ : Type ?u.6286
ε : Type ?u.6289
f : α → β → γ
p : γ → Prop
x✝ : length [] = length []
⊢ All₂ p (zipWith f [] []) ↔ Forall₂ (fun x y => p (f x y)) [] []

tactic: simp only [length_cons, succ_inj'] at h
state_before: α : Type u
β : Type u_1
γ : Type u_2
δ : Type ?u.6286
ε : Type ?u.6289
f : α → β → γ
p : γ → Prop
a : α
l₁ : List α
b : β
l₂ : List β
h : length (a :: l₁) = length (b :: l₂)
⊢ All₂ p (zipWith f (a :: l₁) (b :: l₂)) ↔ Forall₂ (fun x y => p (f x y)) (a :: l₁) (b :: l₂)

tactic: simp [all₂_zipWith h]
state_before: α : Type u
β : Type u_1
γ : Type u_2
δ : Type ?u.6286
ε : Type ?u.6289
f : α → β → γ
p : γ → Prop
a : α
l₁ : List α
b : β
l₂ : List β
h : length l₁ = length l₂
⊢ All₂ p (zipWith f (a :: l₁) (b :: l₂)) ↔ Forall₂ (fun x y => p (f x y)) (a :: l₁) (b :: l₂)
Theorem: QuadraticForm.associated_toQuadraticForm
File: Mathlib/LinearAlgebra/QuadraticForm/Basic.lean

tactic: simp only [associated_apply, ← polar_to_quadratic_form, polar, toQuadraticForm_apply]
state_before: S : Type u_3
R : Type u_1
R₁ : Type ?u.416813
M : Type u_2
inst✝⁷ : Ring R
inst✝⁶ : CommRing R₁
inst✝⁵ : AddCommGroup M
inst✝⁴ : Module R M
inst✝³ : Module R₁ M
inst✝² : CommSemiring S
inst✝¹ : Algebra S R
inst✝ : Invertible 2
B₁ : BilinForm R M
Q : QuadraticForm R M
B : BilinForm R M
x y : M
⊢ bilin (↑(associatedHom S) (toQuadraticForm B)) x y = ⅟2 * (bilin B x y + bilin B y x)
Theorem: Substring.Valid.bsize
File: Std/Data/String/Lemmas.lean

tactic: simp [h.bsize, h.toString]
state_before: x✝ : Substring
h✝ : Valid x✝
l m r : List Char
h : ValidFor l m r x✝
⊢ Substring.bsize x✝ = utf8Len (toString x✝).data
Theorem: Polynomial.coeff_mul_C
File: Mathlib/Data/Polynomial/Coeff.lean

tactic: rcases p with ⟨p⟩
state_before: R : Type u
S : Type v
a✝ b : R
n✝ m : ℕ
inst✝ : Semiring R
p✝ q r p : R[X]
n : ℕ
a : R
⊢ coeff (p * ↑C a) n = coeff p n * a

tactic: simp_rw [← monomial_zero_left, ← ofFinsupp_single, ← ofFinsupp_mul, coeff]
state_before: case ofFinsupp
R : Type u
S : Type v
a✝ b : R
n✝ m : ℕ
inst✝ : Semiring R
p✝ q r : R[X]
n : ℕ
a : R
p : AddMonoidAlgebra R ℕ
⊢ coeff ({ toFinsupp := p } * ↑C a) n = coeff { toFinsupp := p } n * a

tactic: exact AddMonoidAlgebra.mul_single_zero_apply p a n
state_before: case ofFinsupp
R : Type u
S : Type v
a✝ b : R
n✝ m : ℕ
inst✝ : Semiring R
p✝ q r : R[X]
n : ℕ
a : R
p : AddMonoidAlgebra R ℕ
⊢ ↑(p * Finsupp.single 0 a) n = ↑p n * a
Theorem: LocallyFinite.countable_univ
File: Mathlib/Topology/SubsetProperties.lean

tactic: have := fun n => hf.finite_nonempty_inter_compact (isCompact_compactCovering α n)
state_before: α : Type u
β : Type v
ι✝ : Type ?u.163435
π : ι✝ → Type ?u.163440
inst✝² : TopologicalSpace α
inst✝¹ : TopologicalSpace β
s t : Set α
inst✝ : SigmaCompactSpace α
ι : Type u_1
f : ι → Set α
hf : LocallyFinite f
hne : ∀ (i : ι), Set.Nonempty (f i)
⊢ Set.Countable univ

tactic: refine (countable_iUnion fun n => (this n).countable).mono fun i _ => ?_
state_before: α : Type u
β : Type v
ι✝ : Type ?u.163435
π : ι✝ → Type ?u.163440
inst✝² : TopologicalSpace α
inst✝¹ : TopologicalSpace β
s t : Set α
inst✝ : SigmaCompactSpace α
ι : Type u_1
f : ι → Set α
hf : LocallyFinite f
hne : ∀ (i : ι), Set.Nonempty (f i)
this : ∀ (n : ℕ), Set.Finite {i | Set.Nonempty (f i ∩ compactCovering α n)}
⊢ Set.Countable univ

tactic: rcases hne i with ⟨x, hx⟩
state_before: α : Type u
β : Type v
ι✝ : Type ?u.163435
π : ι✝ → Type ?u.163440
inst✝² : TopologicalSpace α
inst✝¹ : TopologicalSpace β
s t : Set α
inst✝ : SigmaCompactSpace α
ι : Type u_1
f : ι → Set α
hf : LocallyFinite f
hne : ∀ (i : ι), Set.Nonempty (f i)
this : ∀ (n : ℕ), Set.Finite {i | Set.Nonempty (f i ∩ compactCovering α n)}
i : ι
x✝ : i ∈ univ
⊢ i ∈ ⋃ (i : ℕ), {i_1 | Set.Nonempty (f i_1 ∩ compactCovering α i)}

tactic: rcases iUnion_eq_univ_iff.1 (iUnion_compactCovering α) x with ⟨n, hn⟩
state_before: case intro
α : Type u
β : Type v
ι✝ : Type ?u.163435
π : ι✝ → Type ?u.163440
inst✝² : TopologicalSpace α
inst✝¹ : TopologicalSpace β
s t : Set α
inst✝ : SigmaCompactSpace α
ι : Type u_1
f : ι → Set α
hf : LocallyFinite f
hne : ∀ (i : ι), Set.Nonempty (f i)
this : ∀ (n : ℕ), Set.Finite {i | Set.Nonempty (f i ∩ compactCovering α n)}
i : ι
x✝ : i ∈ univ
x : α
hx : x ∈ f i
⊢ i ∈ ⋃ (i : ℕ), {i_1 | Set.Nonempty (f i_1 ∩ compactCovering α i)}

tactic: exact mem_iUnion.2 ⟨n, x, hx, hn⟩
state_before: case intro.intro
α : Type u
β : Type v
ι✝ : Type ?u.163435
π : ι✝ → Type ?u.163440
inst✝² : TopologicalSpace α
inst✝¹ : TopologicalSpace β
s t : Set α
inst✝ : SigmaCompactSpace α
ι : Type u_1
f : ι → Set α
hf : LocallyFinite f
hne : ∀ (i : ι), Set.Nonempty (f i)
this : ∀ (n : ℕ), Set.Finite {i | Set.Nonempty (f i ∩ compactCovering α n)}
i : ι
x✝ : i ∈ univ
x : α
hx : x ∈ f i
n : ℕ
hn : x ∈ compactCovering α n
⊢ i ∈ ⋃ (i : ℕ), {i_1 | Set.Nonempty (f i_1 ∩ compactCovering α i)}
Theorem: HomogeneousIdeal.toIdeal_iInf₂
File: Mathlib/RingTheory/GradedAlgebra/HomogeneousIdeal.lean

tactic: simp_rw [toIdeal_iInf]
state_before: ι : Type u_3
σ : Type u_4
R : Type ?u.165339
A : Type u_5
inst✝⁵ : Semiring A
inst✝⁴ : DecidableEq ι
inst✝³ : AddMonoid ι
inst✝² : SetLike σ A
inst✝¹ : AddSubmonoidClass σ A
𝒜 : ι → σ
inst✝ : GradedRing 𝒜
κ : Sort u_1
κ' : κ → Sort u_2
s : (i : κ) → κ' i → HomogeneousIdeal 𝒜
⊢ toIdeal (⨅ (i : κ) (j : κ' i), s i j) = ⨅ (i : κ) (j : κ' i), toIdeal (s i j)
Theorem: CategoryTheory.GrothendieckTopology.ext
File: Mathlib/CategoryTheory/Sites/Grothendieck.lean

tactic: cases J₁
state_before: C : Type u
inst✝ : Category C
X Y : C
S R : Sieve X
J J₁ J₂ : GrothendieckTopology C
h : J₁.sieves = J₂.sieves
⊢ J₁ = J₂

tactic: cases J₂
state_before: case mk
C : Type u
inst✝ : Category C
X Y : C
S R : Sieve X
J J₂ : GrothendieckTopology C
sieves✝ : (X : C) → Set (Sieve X)
top_mem'✝ : ∀ (X : C), ⊤ ∈ sieves✝ X
pullback_stable'✝ : ∀ ⦃X Y : C⦄ ⦃S : Sieve X⦄ (f : Y ⟶ X), S ∈ sieves✝ X → Sieve.pullback f S ∈ sieves✝ Y
transitive'✝ :
  ∀ ⦃X : C⦄ ⦃S : Sieve X⦄,
    S ∈ sieves✝ X →
      ∀ (R : Sieve X), (∀ ⦃Y : C⦄ ⦃f : Y ⟶ X⦄, S.arrows f → Sieve.pullback f R ∈ sieves✝ Y) → R ∈ sieves✝ X
h :
  { sieves := sieves✝, top_mem' := top_mem'✝, pullback_stable' := pullback_stable'✝,
        transitive' := transitive'✝ }.sieves =
    J₂.sieves
⊢ { sieves := sieves✝, top_mem' := top_mem'✝, pullback_stable' := pullback_stable'✝, transitive' := transitive'✝ } = J₂

tactic: congr
state_before: case mk.mk
C : Type u
inst✝ : Category C
X Y : C
S R : Sieve X
J : GrothendieckTopology C
sieves✝¹ : (X : C) → Set (Sieve X)
top_mem'✝¹ : ∀ (X : C), ⊤ ∈ sieves✝¹ X
pullback_stable'✝¹ : ∀ ⦃X Y : C⦄ ⦃S : Sieve X⦄ (f : Y ⟶ X), S ∈ sieves✝¹ X → Sieve.pullback f S ∈ sieves✝¹ Y
transitive'✝¹ :
  ∀ ⦃X : C⦄ ⦃S : Sieve X⦄,
    S ∈ sieves✝¹ X →
      ∀ (R : Sieve X), (∀ ⦃Y : C⦄ ⦃f : Y ⟶ X⦄, S.arrows f → Sieve.pullback f R ∈ sieves✝¹ Y) → R ∈ sieves✝¹ X
sieves✝ : (X : C) → Set (Sieve X)
top_mem'✝ : ∀ (X : C), ⊤ ∈ sieves✝ X
pullback_stable'✝ : ∀ ⦃X Y : C⦄ ⦃S : Sieve X⦄ (f : Y ⟶ X), S ∈ sieves✝ X → Sieve.pullback f S ∈ sieves✝ Y
transitive'✝ :
  ∀ ⦃X : C⦄ ⦃S : Sieve X⦄,
    S ∈ sieves✝ X →
      ∀ (R : Sieve X), (∀ ⦃Y : C⦄ ⦃f : Y ⟶ X⦄, S.arrows f → Sieve.pullback f R ∈ sieves✝ Y) → R ∈ sieves✝ X
h :
  { sieves := sieves✝¹, top_mem' := top_mem'✝¹, pullback_stable' := pullback_stable'✝¹,
        transitive' := transitive'✝¹ }.sieves =
    { sieves := sieves✝, top_mem' := top_mem'✝, pullback_stable' := pullback_stable'✝,
        transitive' := transitive'✝ }.sieves
⊢ { sieves := sieves✝¹, top_mem' := top_mem'✝¹, pullback_stable' := pullback_stable'✝¹, transitive' := transitive'✝¹ } =
    { sieves := sieves✝, top_mem' := top_mem'✝, pullback_stable' := pullback_stable'✝, transitive' := transitive'✝ }
Theorem: Complex.equivRealProd_apply_le'
File: Mathlib/Analysis/Complex/Basic.lean

tactic: simpa using equivRealProd_apply_le z
state_before: E : Type ?u.227972
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace ℂ E
z : ℂ
⊢ ‖↑equivRealProd z‖ ≤ 1 * ↑abs z
Theorem: Set.measure_eq_iInf_isOpen
File: Mathlib/MeasureTheory/Measure/Regular.lean

tactic: refine' le_antisymm (le_iInf₂ fun s hs => le_iInf fun _ => μ.mono hs) _
state_before: α : Type u_1
β : Type ?u.9276
inst✝² : MeasurableSpace α
inst✝¹ : TopologicalSpace α
μ✝ : Measure α
A : Set α
μ : Measure α
inst✝ : OuterRegular μ
⊢ ↑↑μ A = ⨅ (U : Set α) (_ : A ⊆ U) (_ : IsOpen U), ↑↑μ U

tactic: refine' le_of_forall_lt' fun r hr => _
state_before: α : Type u_1
β : Type ?u.9276
inst✝² : MeasurableSpace α
inst✝¹ : TopologicalSpace α
μ✝ : Measure α
A : Set α
μ : Measure α
inst✝ : OuterRegular μ
⊢ (⨅ (U : Set α) (_ : A ⊆ U) (_ : IsOpen U), ↑↑μ U) ≤ ↑↑μ A

tactic: simpa only [iInf_lt_iff, exists_prop] using A.exists_isOpen_lt_of_lt r hr
state_before: α : Type u_1
β : Type ?u.9276
inst✝² : MeasurableSpace α
inst✝¹ : TopologicalSpace α
μ✝ : Measure α
A : Set α
μ : Measure α
inst✝ : OuterRegular μ
r : ℝ≥0∞
hr : ↑↑μ A < r
⊢ (⨅ (U : Set α) (_ : A ⊆ U) (_ : IsOpen U), ↑↑μ U) < r
Theorem: MvPolynomial.vars_C
File: Mathlib/Data/MvPolynomial/Variables.lean

tactic: classical rw [vars_def, degrees_C, Multiset.toFinset_zero]
state_before: R : Type u
S : Type v
σ : Type u_1
τ : Type ?u.129838
r : R
e : ℕ
n m : σ
s : σ →₀ ℕ
inst✝ : CommSemiring R
p q : MvPolynomial σ R
⊢ vars (↑C r) = ∅

tactic: rw [vars_def, degrees_C, Multiset.toFinset_zero]
state_before: R : Type u
S : Type v
σ : Type u_1
τ : Type ?u.129838
r : R
e : ℕ
n m : σ
s : σ →₀ ℕ
inst✝ : CommSemiring R
p q : MvPolynomial σ R
⊢ vars (↑C r) = ∅
Theorem: Order.isMax_iterate_succ_of_eq_of_ne
File: Mathlib/Order/SuccPred/Basic.lean

tactic: cases' le_total n m with h h
state_before: α : Type u_1
inst✝¹ : Preorder α
inst✝ : SuccOrder α
a b : α
n m : ℕ
h_eq : (succ^[n]) a = (succ^[m]) a
h_ne : n ≠ m
⊢ IsMax ((succ^[n]) a)

tactic: exact isMax_iterate_succ_of_eq_of_lt h_eq (lt_of_le_of_ne h h_ne)
state_before: case inl
α : Type u_1
inst✝¹ : Preorder α
inst✝ : SuccOrder α
a b : α
n m : ℕ
h_eq : (succ^[n]) a = (succ^[m]) a
h_ne : n ≠ m
h : n ≤ m
⊢ IsMax ((succ^[n]) a)

tactic: rw [h_eq]
state_before: case inr
α : Type u_1
inst✝¹ : Preorder α
inst✝ : SuccOrder α
a b : α
n m : ℕ
h_eq : (succ^[n]) a = (succ^[m]) a
h_ne : n ≠ m
h : m ≤ n
⊢ IsMax ((succ^[n]) a)

tactic: exact isMax_iterate_succ_of_eq_of_lt h_eq.symm (lt_of_le_of_ne h h_ne.symm)
state_before: case inr
α : Type u_1
inst✝¹ : Preorder α
inst✝ : SuccOrder α
a b : α
n m : ℕ
h_eq : (succ^[n]) a = (succ^[m]) a
h_ne : n ≠ m
h : m ≤ n
⊢ IsMax ((succ^[m]) a)
Theorem: Nat.mul_le_mul_of_nonneg_left
File: Std/Data/Nat/Lemmas.lean

tactic: if hba : b ≤ a then simp [Nat.le_antisymm hba h₁] else
if hc0 : c ≤ 0 then simp [Nat.le_antisymm hc0 (zero_le c), Nat.zero_mul] else
exact Nat.le_of_lt (Nat.mul_lt_mul_of_pos_left (Nat.not_le.1 hba) (Nat.not_le.1 hc0))
state_before: a b c : Nat
h₁ : a ≤ b
⊢ c * a ≤ c * b

tactic: simp [Nat.le_antisymm hba h₁]
state_before: a b c : Nat
h₁ : a ≤ b
hba : b ≤ a
⊢ c * a ≤ c * b

tactic: if hc0 : c ≤ 0 then simp [Nat.le_antisymm hc0 (zero_le c), Nat.zero_mul] else
exact Nat.le_of_lt (Nat.mul_lt_mul_of_pos_left (Nat.not_le.1 hba) (Nat.not_le.1 hc0))
state_before: a b c : Nat
h₁ : a ≤ b
hba : ¬b ≤ a
⊢ c * a ≤ c * b

tactic: simp [Nat.le_antisymm hc0 (zero_le c), Nat.zero_mul]
state_before: a b c : Nat
h₁ : a ≤ b
hba : ¬b ≤ a
hc0 : c ≤ 0
⊢ c * a ≤ c * b

tactic: exact Nat.le_of_lt (Nat.mul_lt_mul_of_pos_left (Nat.not_le.1 hba) (Nat.not_le.1 hc0))
state_before: a b c : Nat
h₁ : a ≤ b
hba : ¬b ≤ a
hc0 : ¬c ≤ 0
⊢ c * a ≤ c * b
Theorem: IsSquare.mul
File: Mathlib/Algebra/Parity.lean

tactic: rintro ⟨a, rfl⟩ ⟨b, rfl⟩
state_before: F : Type ?u.28464
α : Type u_1
β : Type ?u.28470
R : Type ?u.28473
inst✝ : CommSemigroup α
a b : α
⊢ IsSquare a → IsSquare b → IsSquare (a * b)

tactic: exact ⟨a * b, mul_mul_mul_comm _ _ _ _⟩
state_before: case intro.intro
F : Type ?u.28464
α : Type u_1
β : Type ?u.28470
R : Type ?u.28473
inst✝ : CommSemigroup α
a b : α
⊢ IsSquare (a * a * (b * b))