tasksource/leandojo huggingface dataset:
Theorem: Concept.ext
File: Mathlib/Order/Concept.lean

tactic: obtain ⟨⟨s₁, t₁⟩, h₁, _⟩ := c
state_before: ι : Sort ?u.5798
α : Type u_1
β : Type u_2
γ : Type ?u.5807
κ : ι → Sort ?u.5812
r : α → β → Prop
s s₁ s₂ : Set α
t t₁ t₂ : Set β
c d : Concept α β r
h : c.fst = d.fst
⊢ c = d

tactic: obtain ⟨⟨s₂, t₂⟩, h₂, _⟩ := d
state_before: case mk.mk
ι : Sort ?u.5798
α : Type u_1
β : Type u_2
γ : Type ?u.5807
κ : ι → Sort ?u.5812
r : α → β → Prop
s s₁✝ s₂ : Set α
t t₁✝ t₂ : Set β
d : Concept α β r
s₁ : Set α
t₁ : Set β
h₁ : intentClosure r (s₁, t₁).fst = (s₁, t₁).snd
closure_snd✝ : extentClosure r (s₁, t₁).snd = (s₁, t₁).fst
h : { toProd := (s₁, t₁), closure_fst := h₁, closure_snd := closure_snd✝ }.toProd.fst = d.fst
⊢ { toProd := (s₁, t₁), closure_fst := h₁, closure_snd := closure_snd✝ } = d

tactic: dsimp at h₁ h₂ h
state_before: case mk.mk.mk.mk
ι : Sort ?u.5798
α : Type u_1
β : Type u_2
γ : Type ?u.5807
κ : ι → Sort ?u.5812
r : α → β → Prop
s s₁✝ s₂✝ : Set α
t t₁✝ t₂✝ : Set β
s₁ : Set α
t₁ : Set β
h₁ : intentClosure r (s₁, t₁).fst = (s₁, t₁).snd
closure_snd✝¹ : extentClosure r (s₁, t₁).snd = (s₁, t₁).fst
s₂ : Set α
t₂ : Set β
h₂ : intentClosure r (s₂, t₂).fst = (s₂, t₂).snd
closure_snd✝ : extentClosure r (s₂, t₂).snd = (s₂, t₂).fst
h :
  { toProd := (s₁, t₁), closure_fst := h₁, closure_snd := closure_snd✝¹ }.toProd.fst =
    { toProd := (s₂, t₂), closure_fst := h₂, closure_snd := closure_snd✝ }.toProd.fst
⊢ { toProd := (s₁, t₁), closure_fst := h₁, closure_snd := closure_snd✝¹ } =
    { toProd := (s₂, t₂), closure_fst := h₂, closure_snd := closure_snd✝ }

tactic: substs h h₁ h₂
state_before: case mk.mk.mk.mk
ι : Sort ?u.5798
α : Type u_1
β : Type u_2
γ : Type ?u.5807
κ : ι → Sort ?u.5812
r : α → β → Prop
s s₁✝ s₂✝ : Set α
t t₁✝ t₂✝ : Set β
s₁ : Set α
t₁ : Set β
h₁ : intentClosure r s₁ = t₁
closure_snd✝¹ : extentClosure r (s₁, t₁).snd = (s₁, t₁).fst
s₂ : Set α
t₂ : Set β
h₂ : intentClosure r s₂ = t₂
closure_snd✝ : extentClosure r (s₂, t₂).snd = (s₂, t₂).fst
h : s₁ = s₂
⊢ { toProd := (s₁, t₁), closure_fst := h₁, closure_snd := closure_snd✝¹ } =
    { toProd := (s₂, t₂), closure_fst := h₂, closure_snd := closure_snd✝ }

tactic: rfl
state_before: case mk.mk.mk.mk
ι : Sort ?u.5798
α : Type u_1
β : Type u_2
γ : Type ?u.5807
κ : ι → Sort ?u.5812
r : α → β → Prop
s s₁✝ s₂ : Set α
t t₁ t₂ : Set β
s₁ : Set α
closure_snd✝¹ closure_snd✝ : extentClosure r (s₁, intentClosure r s₁).snd = (s₁, intentClosure r s₁).fst
⊢ { toProd := (s₁, intentClosure r s₁), closure_fst := (_ : intentClosure r s₁ = intentClosure r s₁),
      closure_snd := closure_snd✝¹ } =
    { toProd := (s₁, intentClosure r s₁), closure_fst := (_ : intentClosure r s₁ = intentClosure r s₁),
      closure_snd := closure_snd✝ }
Theorem: CauchyFilter.nonempty_cauchyFilter_iff
File: Mathlib/Topology/UniformSpace/Completion.lean

tactic: constructor <;> rintro ⟨c⟩
state_before: α : Type u
inst✝² : UniformSpace α
β : Type v
γ : Type w
inst✝¹ : UniformSpace β
inst✝ : UniformSpace γ
⊢ Nonempty (CauchyFilter α) ↔ Nonempty α

tactic: have := eq_univ_iff_forall.1 denseEmbedding_pureCauchy.toDenseInducing.closure_range c
state_before: case mp.intro
α : Type u
inst✝² : UniformSpace α
β : Type v
γ : Type w
inst✝¹ : UniformSpace β
inst✝ : UniformSpace γ
c : CauchyFilter α
⊢ Nonempty α

tactic: obtain ⟨_, ⟨_, a, _⟩⟩ := mem_closure_iff.1 this _ isOpen_univ trivial
state_before: case mp.intro
α : Type u
inst✝² : UniformSpace α
β : Type v
γ : Type w
inst✝¹ : UniformSpace β
inst✝ : UniformSpace γ
c : CauchyFilter α
this : c ∈ closure (range pureCauchy)
⊢ Nonempty α

tactic: exact ⟨a⟩
state_before: case mp.intro.intro.intro.intro
α : Type u
inst✝² : UniformSpace α
β : Type v
γ : Type w
inst✝¹ : UniformSpace β
inst✝ : UniformSpace γ
c : CauchyFilter α
this : c ∈ closure (range pureCauchy)
w✝ : CauchyFilter α
left✝ : w✝ ∈ univ
a : α
h✝ : pureCauchy a = w✝
⊢ Nonempty α

tactic: exact ⟨pureCauchy c⟩
state_before: case mpr.intro
α : Type u
inst✝² : UniformSpace α
β : Type v
γ : Type w
inst✝¹ : UniformSpace β
inst✝ : UniformSpace γ
c : α
⊢ Nonempty (CauchyFilter α)
Theorem: CharP.sq_add_sq
File: Mathlib/FieldTheory/Finite/Basic.lean

tactic: haveI := char_is_prime_of_pos R p
state_before: K : Type ?u.857034
R✝ : Type ?u.857037
R : Type u_1
inst✝³ : CommRing R
inst✝² : IsDomain R
p : ℕ
inst✝¹ : NeZero p
inst✝ : CharP R p
x : ℤ
⊢ ∃ a b, ↑a ^ 2 + ↑b ^ 2 = ↑x

tactic: obtain ⟨a, b, hab⟩ := ZMod.sq_add_sq p x
state_before: K : Type ?u.857034
R✝ : Type ?u.857037
R : Type u_1
inst✝³ : CommRing R
inst✝² : IsDomain R
p : ℕ
inst✝¹ : NeZero p
inst✝ : CharP R p
x : ℤ
this : Fact (Nat.Prime p)
⊢ ∃ a b, ↑a ^ 2 + ↑b ^ 2 = ↑x

tactic: refine' ⟨a.val, b.val, _⟩
state_before: case intro.intro
K : Type ?u.857034
R✝ : Type ?u.857037
R : Type u_1
inst✝³ : CommRing R
inst✝² : IsDomain R
p : ℕ
inst✝¹ : NeZero p
inst✝ : CharP R p
x : ℤ
this : Fact (Nat.Prime p)
a b : ZMod p
hab : a ^ 2 + b ^ 2 = ↑x
⊢ ∃ a b, ↑a ^ 2 + ↑b ^ 2 = ↑x

tactic: simpa using congr_arg (ZMod.castHom dvd_rfl R) hab
state_before: case intro.intro
K : Type ?u.857034
R✝ : Type ?u.857037
R : Type u_1
inst✝³ : CommRing R
inst✝² : IsDomain R
p : ℕ
inst✝¹ : NeZero p
inst✝ : CharP R p
x : ℤ
this : Fact (Nat.Prime p)
a b : ZMod p
hab : a ^ 2 + b ^ 2 = ↑x
⊢ ↑(ZMod.val a) ^ 2 + ↑(ZMod.val b) ^ 2 = ↑x
Theorem: List.reverse_reverse
File: src/lean/Init/Data/List/Basic.lean

tactic: simp [reverse]
state_before: α : Type u
β : Type v
γ : Type w
as : List α
⊢ reverse (reverse as) = as

tactic: rw [reverseAux_reverseAux_nil]
state_before: α : Type u
β : Type v
γ : Type w
as : List α
⊢ reverseAux (reverseAux as nil) nil = as

tactic: rfl
state_before: α : Type u
β : Type v
γ : Type w
as : List α
⊢ reverseAux nil as = as
Theorem: MonoidAlgebra.single_eq_algebraMap_mul_of
File: Mathlib/Algebra/MonoidAlgebra/Basic.lean

tactic: simp
state_before: k : Type u₁
G : Type u₂
R : Type ?u.982563
inst✝¹ : CommSemiring k
inst✝ : Monoid G
a : G
b : k
⊢ single a b = ↑(algebraMap k (MonoidAlgebra k G)) b * ↑(of k G) a
Theorem: WithTop.mul_top'
File: Mathlib/Algebra/Order/Ring/WithTop.lean

tactic: induction a using recTopCoe <;> simp [mul_def] <;> rfl
state_before: α : Type u_1
inst✝² : DecidableEq α
inst✝¹ : Zero α
inst✝ : Mul α
a : WithTop α
⊢ a * ⊤ = if a = 0 then 0 else ⊤
Theorem: Ordinal.typein_le_typein'
File: Mathlib/SetTheory/Ordinal/Basic.lean

tactic: rw [typein_le_typein]
state_before: α : Type ?u.188636
β : Type ?u.188639
γ : Type ?u.188642
r : α → α → Prop
s : β → β → Prop
t : γ → γ → Prop
o : Ordinal
x x' : (Quotient.out o).α
⊢ typein (fun x x_1 => x < x_1) x ≤ typein (fun x x_1 => x < x_1) x' ↔ x ≤ x'

tactic: exact not_lt
state_before: α : Type ?u.188636
β : Type ?u.188639
γ : Type ?u.188642
r : α → α → Prop
s : β → β → Prop
t : γ → γ → Prop
o : Ordinal
x x' : (Quotient.out o).α
⊢ ¬x' < x ↔ x ≤ x'
Theorem: Metric.thickening_iUnion
File: Mathlib/Topology/MetricSpace/HausdorffDistance.lean

tactic: simp_rw [thickening, infEdist_iUnion, iInf_lt_iff, setOf_exists]
state_before: ι : Sort u_1
α : Type u
β : Type v
inst✝ : PseudoEMetricSpace α
δ✝ ε : ℝ
s t : Set α
x : α
δ : ℝ
f : ι → Set α
⊢ thickening δ (⋃ (i : ι), f i) = ⋃ (i : ι), thickening δ (f i)
Theorem: ContinuousLinearMap.add_compLp
File: Mathlib/MeasureTheory/Function/LpSpace.lean

tactic: ext1
state_before: α : Type u_4
E : Type u_2
F : Type u_3
G : Type ?u.5467217
m m0 : MeasurableSpace α
p : ℝ≥0∞
q : ℝ
μ ν : MeasureTheory.Measure α
inst✝⁵ : NormedAddCommGroup E
inst✝⁴ : NormedAddCommGroup F
inst✝³ : NormedAddCommGroup G
g : E → F
c : ℝ≥0
𝕜 : Type u_1
inst✝² : NontriviallyNormedField 𝕜
inst✝¹ : NormedSpace 𝕜 E
inst✝ : NormedSpace 𝕜 F
L L' : E →L[𝕜] F
f : { x // x ∈ Lp E p }
⊢ compLp (L + L') f = compLp L f + compLp L' f

tactic: refine' (coeFn_compLp' (L + L') f).trans _
state_before: case h
α : Type u_4
E : Type u_2
F : Type u_3
G : Type ?u.5467217
m m0 : MeasurableSpace α
p : ℝ≥0∞
q : ℝ
μ ν : MeasureTheory.Measure α
inst✝⁵ : NormedAddCommGroup E
inst✝⁴ : NormedAddCommGroup F
inst✝³ : NormedAddCommGroup G
g : E → F
c : ℝ≥0
𝕜 : Type u_1
inst✝² : NontriviallyNormedField 𝕜
inst✝¹ : NormedSpace 𝕜 E
inst✝ : NormedSpace 𝕜 F
L L' : E →L[𝕜] F
f : { x // x ∈ Lp E p }
⊢ ↑↑(compLp (L + L') f) =ᵐ[μ] ↑↑(compLp L f + compLp L' f)

tactic: refine' EventuallyEq.trans _ (Lp.coeFn_add _ _).symm
state_before: case h
α : Type u_4
E : Type u_2
F : Type u_3
G : Type ?u.5467217
m m0 : MeasurableSpace α
p : ℝ≥0∞
q : ℝ
μ ν : MeasureTheory.Measure α
inst✝⁵ : NormedAddCommGroup E
inst✝⁴ : NormedAddCommGroup F
inst✝³ : NormedAddCommGroup G
g : E → F
c : ℝ≥0
𝕜 : Type u_1
inst✝² : NontriviallyNormedField 𝕜
inst✝¹ : NormedSpace 𝕜 E
inst✝ : NormedSpace 𝕜 F
L L' : E →L[𝕜] F
f : { x // x ∈ Lp E p }
⊢ (fun a => ↑(L + L') (↑↑f a)) =ᵐ[μ] ↑↑(compLp L f + compLp L' f)

tactic: refine'
  EventuallyEq.trans _ (EventuallyEq.add (L.coeFn_compLp' f).symm (L'.coeFn_compLp' f).symm)
state_before: case h
α : Type u_4
E : Type u_2
F : Type u_3
G : Type ?u.5467217
m m0 : MeasurableSpace α
p : ℝ≥0∞
q : ℝ
μ ν : MeasureTheory.Measure α
inst✝⁵ : NormedAddCommGroup E
inst✝⁴ : NormedAddCommGroup F
inst✝³ : NormedAddCommGroup G
g : E → F
c : ℝ≥0
𝕜 : Type u_1
inst✝² : NontriviallyNormedField 𝕜
inst✝¹ : NormedSpace 𝕜 E
inst✝ : NormedSpace 𝕜 F
L L' : E →L[𝕜] F
f : { x // x ∈ Lp E p }
⊢ (fun a => ↑(L + L') (↑↑f a)) =ᵐ[μ] ↑↑(compLp L f) + ↑↑(compLp L' f)

tactic: refine' eventually_of_forall fun x => _
state_before: case h
α : Type u_4
E : Type u_2
F : Type u_3
G : Type ?u.5467217
m m0 : MeasurableSpace α
p : ℝ≥0∞
q : ℝ
μ ν : MeasureTheory.Measure α
inst✝⁵ : NormedAddCommGroup E
inst✝⁴ : NormedAddCommGroup F
inst✝³ : NormedAddCommGroup G
g : E → F
c : ℝ≥0
𝕜 : Type u_1
inst✝² : NontriviallyNormedField 𝕜
inst✝¹ : NormedSpace 𝕜 E
inst✝ : NormedSpace 𝕜 F
L L' : E →L[𝕜] F
f : { x // x ∈ Lp E p }
⊢ (fun a => ↑(L + L') (↑↑f a)) =ᵐ[μ] fun x => ↑L (↑↑f x) + ↑L' (↑↑f x)

tactic: rfl
state_before: case h
α : Type u_4
E : Type u_2
F : Type u_3
G : Type ?u.5467217
m m0 : MeasurableSpace α
p : ℝ≥0∞
q : ℝ
μ ν : MeasureTheory.Measure α
inst✝⁵ : NormedAddCommGroup E
inst✝⁴ : NormedAddCommGroup F
inst✝³ : NormedAddCommGroup G
g : E → F
c : ℝ≥0
𝕜 : Type u_1
inst✝² : NontriviallyNormedField 𝕜
inst✝¹ : NormedSpace 𝕜 E
inst✝ : NormedSpace 𝕜 F
L L' : E →L[𝕜] F
f : { x // x ∈ Lp E p }
x : α
⊢ (fun a => ↑(L + L') (↑↑f a)) x = (fun x => ↑L (↑↑f x) + ↑L' (↑↑f x)) x
Theorem: lintegral_rpow_eq_lintegral_meas_lt_mul
File: Mathlib/MeasureTheory/Integral/Layercake.lean

tactic: rw [lintegral_rpow_eq_lintegral_meas_le_mul μ f_nn f_mble p_pos]
state_before: α : Type u_1
inst✝³ : MeasurableSpace α
μ✝ : MeasureTheory.Measure α
β : Type ?u.1472066
inst✝² : MeasurableSpace β
inst✝¹ : MeasurableSingletonClass β
f : α → ℝ
g : ℝ → ℝ
s : Set α
μ : MeasureTheory.Measure α
inst✝ : SigmaFinite μ
f_nn : 0 ≤ f
f_mble : Measurable f
p : ℝ
p_pos : 0 < p
⊢ (∫⁻ (ω : α), ENNReal.ofReal (f ω ^ p) ∂μ) =
    ENNReal.ofReal p * ∫⁻ (t : ℝ) in Ioi 0, ↑↑μ {a | t < f a} * ENNReal.ofReal (t ^ (p - 1))

tactic: apply congr_arg fun z => ENNReal.ofReal p * z
state_before: α : Type u_1
inst✝³ : MeasurableSpace α
μ✝ : MeasureTheory.Measure α
β : Type ?u.1472066
inst✝² : MeasurableSpace β
inst✝¹ : MeasurableSingletonClass β
f : α → ℝ
g : ℝ → ℝ
s : Set α
μ : MeasureTheory.Measure α
inst✝ : SigmaFinite μ
f_nn : 0 ≤ f
f_mble : Measurable f
p : ℝ
p_pos : 0 < p
⊢ (ENNReal.ofReal p * ∫⁻ (t : ℝ) in Ioi 0, ↑↑μ {a | t ≤ f a} * ENNReal.ofReal (t ^ (p - 1))) =
    ENNReal.ofReal p * ∫⁻ (t : ℝ) in Ioi 0, ↑↑μ {a | t < f a} * ENNReal.ofReal (t ^ (p - 1))

tactic: apply lintegral_congr_ae
state_before: α : Type u_1
inst✝³ : MeasurableSpace α
μ✝ : MeasureTheory.Measure α
β : Type ?u.1472066
inst✝² : MeasurableSpace β
inst✝¹ : MeasurableSingletonClass β
f : α → ℝ
g : ℝ → ℝ
s : Set α
μ : MeasureTheory.Measure α
inst✝ : SigmaFinite μ
f_nn : 0 ≤ f
f_mble : Measurable f
p : ℝ
p_pos : 0 < p
⊢ (∫⁻ (t : ℝ) in Ioi 0, ↑↑μ {a | t ≤ f a} * ENNReal.ofReal (t ^ (p - 1))) =
    ∫⁻ (t : ℝ) in Ioi 0, ↑↑μ {a | t < f a} * ENNReal.ofReal (t ^ (p - 1))

tactic: filter_upwards [Measure.meas_le_ae_eq_meas_lt μ (volume.restrict (Ioi 0)) f_mble] with t ht
state_before: case h
α : Type u_1
inst✝³ : MeasurableSpace α
μ✝ : MeasureTheory.Measure α
β : Type ?u.1472066
inst✝² : MeasurableSpace β
inst✝¹ : MeasurableSingletonClass β
f : α → ℝ
g : ℝ → ℝ
s : Set α
μ : MeasureTheory.Measure α
inst✝ : SigmaFinite μ
f_nn : 0 ≤ f
f_mble : Measurable f
p : ℝ
p_pos : 0 < p
⊢ (fun a => ↑↑μ {a_1 | a ≤ f a_1} * ENNReal.ofReal (a ^ (p - 1))) =ᵐ[Measure.restrict volume (Ioi 0)] fun a =>
    ↑↑μ {a_1 | a < f a_1} * ENNReal.ofReal (a ^ (p - 1))

tactic: rw [ht]
state_before: case h
α : Type u_1
inst✝³ : MeasurableSpace α
μ✝ : MeasureTheory.Measure α
β : Type ?u.1472066
inst✝² : MeasurableSpace β
inst✝¹ : MeasurableSingletonClass β
f : α → ℝ
g : ℝ → ℝ
s : Set α
μ : MeasureTheory.Measure α
inst✝ : SigmaFinite μ
f_nn : 0 ≤ f
f_mble : Measurable f
p : ℝ
p_pos : 0 < p
t : ℝ
ht : ↑↑μ {a | t ≤ f a} = ↑↑μ {a | t < f a}
⊢ ↑↑μ {a | t ≤ f a} * ENNReal.ofReal (t ^ (p - 1)) = ↑↑μ {a | t < f a} * ENNReal.ofReal (t ^ (p - 1))
Theorem: gronwallBound_x0
File: Mathlib/Analysis/ODE/Gronwall.lean

tactic: by_cases hK : K = 0
state_before: E : Type ?u.29211
inst✝³ : NormedAddCommGroup E
inst✝² : NormedSpace ℝ E
F : Type ?u.29307
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedSpace ℝ F
δ K ε : ℝ
⊢ gronwallBound δ K ε 0 = δ

tactic: simp only [gronwallBound, if_pos hK, MulZeroClass.mul_zero, add_zero]
state_before: case pos
E : Type ?u.29211
inst✝³ : NormedAddCommGroup E
inst✝² : NormedSpace ℝ E
F : Type ?u.29307
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedSpace ℝ F
δ K ε : ℝ
hK : K = 0
⊢ gronwallBound δ K ε 0 = δ

tactic: simp only [gronwallBound, if_neg hK, MulZeroClass.mul_zero, exp_zero, sub_self, mul_one,
  add_zero]
state_before: case neg
E : Type ?u.29211
inst✝³ : NormedAddCommGroup E
inst✝² : NormedSpace ℝ E
F : Type ?u.29307
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedSpace ℝ F
δ K ε : ℝ
hK : ¬K = 0
⊢ gronwallBound δ K ε 0 = δ
Theorem: Configuration.ProjectivePlane.lineCount_eq_pointCount
File: Mathlib/Combinatorics/Configuration.lean

tactic: cases nonempty_fintype P
state_before: P : Type u_1
L : Type u_2
inst✝³ : Membership P L
inst✝² : ProjectivePlane P L
inst✝¹ : Finite P
inst✝ : Finite L
p : P
l : L
q : P
hq : ¬q ∈ l
⊢ lineCount L q = pointCount P l

tactic: cases nonempty_fintype L
state_before: case intro
P : Type u_1
L : Type u_2
inst✝³ : Membership P L
inst✝² : ProjectivePlane P L
inst✝¹ : Finite P
inst✝ : Finite L
p : P
l : L
q : P
hq : ¬q ∈ l
val✝ : Fintype P
⊢ lineCount L q = pointCount P l

tactic: exact HasLines.lineCount_eq_pointCount (card_points_eq_card_lines P L) hq
state_before: case intro.intro
P : Type u_1
L : Type u_2
inst✝³ : Membership P L
inst✝² : ProjectivePlane P L
inst✝¹ : Finite P
inst✝ : Finite L
p : P
l : L
q : P
hq : ¬q ∈ l
val✝¹ : Fintype P
val✝ : Fintype L
⊢ lineCount L q = pointCount P l
Theorem: Nat.card_pi
File: Mathlib/SetTheory/Cardinal/Finite.lean

tactic: simp_rw [Nat.card, mk_pi, prod_eq_of_fintype, toNat_lift, toNat_finset_prod]
state_before: α : Type u_2
β✝ : Type ?u.11854
β : α → Type u_1
inst✝ : Fintype α
⊢ Nat.card ((a : α) → β a) = ∏ a : α, Nat.card (β a)
Theorem: EReal.addLECancellable_coe
File: Mathlib/Data/Real/EReal.lean

tactic: simp only [coe_add_top, ← coe_add, top_le_iff, coe_ne_top] at h
state_before: x z : ℝ
h : ↑x + ⊤ ≤ ↑x + ↑z
⊢ ⊤ ≤ ↑z

tactic: simpa using h
state_before: x : ℝ
x✝ : EReal
h : ↑x + x✝ ≤ ↑x + ⊥
⊢ x✝ ≤ ⊥

tactic: simpa only [← coe_add, EReal.coe_le_coe_iff, add_le_add_iff_left] using h
state_before: x y z : ℝ
h : ↑x + ↑y ≤ ↑x + ↑z
⊢ ↑y ≤ ↑z
Theorem: integral_exp_neg_Ioi_zero
File: Mathlib/Analysis/SpecialFunctions/ImproperIntegrals.lean

tactic: simpa only [neg_zero, exp_zero] using integral_exp_neg_Ioi 0
state_before: ⊢ (∫ (x : ℝ) in Ioi 0, exp (-x)) = 1
Theorem: MeasureTheory.MeasurePreserving.aemeasurable_comp_iff
File: Mathlib/Dynamics/Ergodic/MeasurePreserving.lean

tactic: rw [← hf.map_eq, h₂.aemeasurable_map_iff]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type ?u.53763
inst✝³ : MeasurableSpace α
inst✝² : MeasurableSpace β
inst✝¹ : MeasurableSpace γ
inst✝ : MeasurableSpace δ
μa : Measure α
μb : Measure β
μc : Measure γ
μd : Measure δ
f : α → β
hf : MeasurePreserving f
h₂ : MeasurableEmbedding f
g : β → γ
⊢ AEMeasurable (g ∘ f) ↔ AEMeasurable g
Theorem: MvPolynomial.coe_bit1
File: Mathlib/RingTheory/PowerSeries/Basic.lean

tactic: rw [bit1, bit1, coe_add, coe_one, coe_bit0]
state_before: σ : Type u_1
R : Type u_2
inst✝ : CommSemiring R
φ ψ : MvPolynomial σ R
⊢ ↑(bit1 φ) = bit1 ↑φ
Theorem: TensorPower.algebraMap₀_mul_algebraMap₀
File: Mathlib/LinearAlgebra/TensorPower.lean

tactic: rw [← smul_eq_mul, LinearEquiv.map_smul]
state_before: R : Type u_1
M : Type u_2
inst✝² : CommSemiring R
inst✝¹ : AddCommMonoid M
inst✝ : Module R M
r s : R
⊢ ↑(cast R M (_ : 0 + 0 = 0)) (GradedMonoid.GMul.mul (↑algebraMap₀ r) (↑algebraMap₀ s)) = ↑algebraMap₀ (r * s)

tactic: exact algebraMap₀_mul r (@algebraMap₀ R M _ _ _ s)
state_before: R : Type u_1
M : Type u_2
inst✝² : CommSemiring R
inst✝¹ : AddCommMonoid M
inst✝ : Module R M
r s : R
⊢ ↑(cast R M (_ : 0 + 0 = 0)) (GradedMonoid.GMul.mul (↑algebraMap₀ r) (↑algebraMap₀ s)) = r • ↑algebraMap₀ s
Theorem: CategoryTheory.Equivalence.enoughProjectives_iff
File: Mathlib/CategoryTheory/Preadditive/Projective.lean

tactic: constructor
state_before: C : Type u
inst✝¹ : Category C
D : Type u'
inst✝ : Category D
F✝ F : C ≌ D
⊢ EnoughProjectives C ↔ EnoughProjectives D

tactic: all_goals intro H; constructor; intro X; constructor
state_before: case mp
C : Type u
inst✝¹ : Category C
D : Type u'
inst✝ : Category D
F✝ F : C ≌ D
⊢ EnoughProjectives C → EnoughProjectives D

case mpr
C : Type u
inst✝¹ : Category C
D : Type u'
inst✝ : Category D
F✝ F : C ≌ D
⊢ EnoughProjectives D → EnoughProjectives C

tactic: intro H
state_before: case mpr
C : Type u
inst✝¹ : Category C
D : Type u'
inst✝ : Category D
F✝ F : C ≌ D
⊢ EnoughProjectives D → EnoughProjectives C

tactic: constructor
state_before: case mpr
C : Type u
inst✝¹ : Category C
D : Type u'
inst✝ : Category D
F✝ F : C ≌ D
H : EnoughProjectives D
⊢ EnoughProjectives C

tactic: intro X
state_before: case mpr.presentation
C : Type u
inst✝¹ : Category C
D : Type u'
inst✝ : Category D
F✝ F : C ≌ D
H : EnoughProjectives D
⊢ ∀ (X : C), Nonempty (ProjectivePresentation X)

tactic: constructor
state_before: case mpr.presentation
C : Type u
inst✝¹ : Category C
D : Type u'
inst✝ : Category D
F✝ F : C ≌ D
H : EnoughProjectives D
X : C
⊢ Nonempty (ProjectivePresentation X)

tactic: exact F.symm.projectivePresentationOfMapProjectivePresentation _
  (Nonempty.some (H.presentation (F.inverse.obj X)))
state_before: case mp.presentation.val
C : Type u
inst✝¹ : Category C
D : Type u'
inst✝ : Category D
F✝ F : C ≌ D
H : EnoughProjectives C
X : D
⊢ ProjectivePresentation X

tactic: exact F.projectivePresentationOfMapProjectivePresentation X
  (Nonempty.some (H.presentation (F.functor.obj X)))
state_before: case mpr.presentation.val
C : Type u
inst✝¹ : Category C
D : Type u'
inst✝ : Category D
F✝ F : C ≌ D
H : EnoughProjectives D
X : C
⊢ ProjectivePresentation X
Theorem: Nat.descFactorial_eq_div
File: Mathlib/Data/Nat/Factorial/Basic.lean

tactic: apply mul_left_cancel₀ (factorial_ne_zero (n - k))
state_before: n k : ℕ
h : k ≤ n
⊢ descFactorial n k = n ! / (n - k)!

tactic: rw [factorial_mul_descFactorial h]
state_before: n k : ℕ
h : k ≤ n
⊢ (n - k)! * descFactorial n k = (n - k)! * (n ! / (n - k)!)

tactic: exact (Nat.mul_div_cancel' <| factorial_dvd_factorial <| Nat.sub_le n k).symm
state_before: n k : ℕ
h : k ≤ n
⊢ n ! = (n - k)! * (n ! / (n - k)!)
Theorem: SimpleGraph.Connected.boxProd
File: Mathlib/Combinatorics/SimpleGraph/Prod.lean

tactic: haveI := hG.nonempty
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.82889
G : SimpleGraph α
H : SimpleGraph β
hG : Connected G
hH : Connected H
⊢ Connected (G □ H)

tactic: haveI := hH.nonempty
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.82889
G : SimpleGraph α
H : SimpleGraph β
hG : Connected G
hH : Connected H
this : Nonempty α
⊢ Connected (G □ H)

tactic: exact ⟨hG.preconnected.boxProd hH.preconnected⟩
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.82889
G : SimpleGraph α
H : SimpleGraph β
hG : Connected G
hH : Connected H
this✝ : Nonempty α
this : Nonempty β
⊢ Connected (G □ H)
Theorem: Polynomial.degreeLE_eq_span_X_pow
File: Mathlib/RingTheory/Polynomial/Basic.lean

tactic: apply le_antisymm
state_before: R : Type u
S : Type ?u.6585
inst✝ : Semiring R
n : ℕ
⊢ degreeLE R ↑n = Submodule.span R ↑(image (fun n => X ^ n) (range (n + 1)))

tactic: rw [Submodule.span_le, Finset.coe_image, Set.image_subset_iff]
state_before: case a
R : Type u
S : Type ?u.6585
inst✝ : Semiring R
n : ℕ
⊢ Submodule.span R ↑(image (fun n => X ^ n) (range (n + 1))) ≤ degreeLE R ↑n

tactic: intro k hk
state_before: case a
R : Type u
S : Type ?u.6585
inst✝ : Semiring R
n : ℕ
⊢ ↑(range (n + 1)) ⊆ (fun n => X ^ n) ⁻¹' ↑(degreeLE R ↑n)

tactic: apply mem_degreeLE.2
state_before: case a
R : Type u
S : Type ?u.6585
inst✝ : Semiring R
n k : ℕ
hk : k ∈ ↑(range (n + 1))
⊢ k ∈ (fun n => X ^ n) ⁻¹' ↑(degreeLE R ↑n)

tactic: exact
  (degree_X_pow_le _).trans (WithBot.coe_le_coe.2 <| Nat.le_of_lt_succ <| Finset.mem_range.1 hk)
state_before: case a
R : Type u
S : Type ?u.6585
inst✝ : Semiring R
n k : ℕ
hk : k ∈ ↑(range (n + 1))
⊢ degree ((fun n => X ^ n) k) ≤ ↑n

tactic: intro p hp
state_before: case a
R : Type u
S : Type ?u.6585
inst✝ : Semiring R
n : ℕ
⊢ degreeLE R ↑n ≤ Submodule.span R ↑(image (fun n => X ^ n) (range (n + 1)))

tactic: replace hp := mem_degreeLE.1 hp
state_before: case a
R : Type u
S : Type ?u.6585
inst✝ : Semiring R
n : ℕ
p : R[X]
hp : p ∈ degreeLE R ↑n
⊢ p ∈ Submodule.span R ↑(image (fun n => X ^ n) (range (n + 1)))

tactic: rw [← Polynomial.sum_monomial_eq p, Polynomial.sum]
state_before: case a
R : Type u
S : Type ?u.6585
inst✝ : Semiring R
n : ℕ
p : R[X]
hp : degree p ≤ ↑n
⊢ p ∈ Submodule.span R ↑(image (fun n => X ^ n) (range (n + 1)))

tactic: refine' Submodule.sum_mem _ fun k hk => _
state_before: case a
R : Type u
S : Type ?u.6585
inst✝ : Semiring R
n : ℕ
p : R[X]
hp : degree p ≤ ↑n
⊢ ∑ n in support p, ↑(monomial n) (coeff p n) ∈ Submodule.span R ↑(image (fun n => X ^ n) (range (n + 1)))

tactic: have := WithBot.coe_le_coe.1 (Finset.sup_le_iff.1 hp k hk)
state_before: case a
R : Type u
S : Type ?u.6585
inst✝ : Semiring R
n : ℕ
p : R[X]
hp : degree p ≤ ↑n
k : ℕ
hk : k ∈ support p
⊢ ↑(monomial k) (coeff p k) ∈ Submodule.span R ↑(image (fun n => X ^ n) (range (n + 1)))

tactic: rw [← C_mul_X_pow_eq_monomial, C_mul']
state_before: case a
R : Type u
S : Type ?u.6585
inst✝ : Semiring R
n : ℕ
p : R[X]
hp : degree p ≤ ↑n
k : ℕ
hk : k ∈ support p
this : k ≤ ↑n
⊢ ↑(monomial k) (coeff p k) ∈ Submodule.span R ↑(image (fun n => X ^ n) (range (n + 1)))

tactic: refine'
  Submodule.smul_mem _ _
    (Submodule.subset_span <|
      Finset.mem_coe.2 <|
        Finset.mem_image.2 ⟨_, Finset.mem_range.2 (Nat.lt_succ_of_le this), rfl⟩)
state_before: case a
R : Type u
S : Type ?u.6585
inst✝ : Semiring R
n : ℕ
p : R[X]
hp : degree p ≤ ↑n
k : ℕ
hk : k ∈ support p
this : k ≤ ↑n
⊢ coeff p k • X ^ k ∈ Submodule.span R ↑(image (fun n => X ^ n) (range (n + 1)))
Theorem: csInf_Ioi
File: Mathlib/Order/ConditionallyCompleteLattice/Basic.lean

tactic: simpa using exists_between hw
state_before: α : Type u_1
β : Type ?u.47637
γ : Type ?u.47640
ι : Sort ?u.47643
inst✝² : ConditionallyCompleteLattice α
s t : Set α
a b : α
inst✝¹ : NoMaxOrder α
inst✝ : DenselyOrdered α
w : α
hw : a < w
⊢ ∃ a_1, a_1 ∈ Ioi a ∧ a_1 < w
Theorem: Set.sInter_iUnion
File: Mathlib/Data/Set/Lattice.lean

tactic: simp only [sInter_eq_biInter, biInter_iUnion]
state_before: α : Type u_1
β : Type ?u.179429
γ : Type ?u.179432
ι : Sort u_2
ι' : Sort ?u.179438
ι₂ : Sort ?u.179441
κ : ι → Sort ?u.179446
κ₁ : ι → Sort ?u.179451
κ₂ : ι → Sort ?u.179456
κ' : ι' → Sort ?u.179461
s : ι → Set (Set α)
⊢ (⋂₀ ⋃ (i : ι), s i) = ⋂ (i : ι), ⋂₀ s i
Theorem: Ordinal.lsub_empty
File: Mathlib/SetTheory/Ordinal/Arithmetic.lean

tactic: rw [← Ordinal.le_zero, lsub_le_iff]
state_before: α : Type ?u.326516
β : Type ?u.326519
γ : Type ?u.326522
r : α → α → Prop
s : β → β → Prop
t : γ → γ → Prop
ι : Type u_1
h : IsEmpty ι
f : ι → Ordinal
⊢ lsub f = 0

tactic: exact h.elim
state_before: α : Type ?u.326516
β : Type ?u.326519
γ : Type ?u.326522
r : α → α → Prop
s : β → β → Prop
t : γ → γ → Prop
ι : Type u_1
h : IsEmpty ι
f : ι → Ordinal
⊢ ∀ (i : ι), f i < 0