tasksource/leandojo huggingface dataset:
Theorem: ContDiffAt.real_of_complex
File: Mathlib/Analysis/Complex/RealDeriv.lean

tactic: have A : ContDiffAt ℝ n ((↑) : ℝ → ℂ) z := ofRealClm.contDiff.contDiffAt
state_before: e : ℂ → ℂ
e' : ℂ
z : ℝ
n : ℕ∞
h : ContDiffAt ℂ n e ↑z
⊢ ContDiffAt ℝ n (fun x => (e ↑x).re) z

tactic: have B : ContDiffAt ℝ n e z := h.restrict_scalars ℝ
state_before: e : ℂ → ℂ
e' : ℂ
z : ℝ
n : ℕ∞
h : ContDiffAt ℂ n e ↑z
A : ContDiffAt ℝ n ofReal' z
⊢ ContDiffAt ℝ n (fun x => (e ↑x).re) z

tactic: have C : ContDiffAt ℝ n re (e z) := reClm.contDiff.contDiffAt
state_before: e : ℂ → ℂ
e' : ℂ
z : ℝ
n : ℕ∞
h : ContDiffAt ℂ n e ↑z
A : ContDiffAt ℝ n ofReal' z
B : ContDiffAt ℝ n e ↑z
⊢ ContDiffAt ℝ n (fun x => (e ↑x).re) z

tactic: exact C.comp z (B.comp z A)
state_before: e : ℂ → ℂ
e' : ℂ
z : ℝ
n : ℕ∞
h : ContDiffAt ℂ n e ↑z
A : ContDiffAt ℝ n ofReal' z
B : ContDiffAt ℝ n e ↑z
C : ContDiffAt ℝ n re (e ↑z)
⊢ ContDiffAt ℝ n (fun x => (e ↑x).re) z
Theorem: Filter.HasBasis.le_iff
File: Mathlib/Order/Filter/Bases.lean

tactic: simp only [le_def, hl.mem_iff]
state_before: α : Type u_1
β : Type ?u.25163
γ : Type ?u.25166
ι : Sort u_2
ι' : Sort ?u.25172
l l' : Filter α
p : ι → Prop
s : ι → Set α
t : Set α
i : ι
p' : ι' → Prop
s' : ι' → Set α
i' : ι'
hl : HasBasis l p s
⊢ l ≤ l' ↔ ∀ (t : Set α), t ∈ l' → ∃ i, p i ∧ s i ⊆ t
Theorem: Summable.of_neg
File: Mathlib/Topology/Algebra/InfiniteSum/Basic.lean

tactic: simpa only [neg_neg] using hf.neg
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.399252
δ : Type ?u.399255
inst✝² : AddCommGroup α
inst✝¹ : TopologicalSpace α
inst✝ : TopologicalAddGroup α
f g : β → α
a a₁ a₂ : α
hf : Summable fun b => -f b
⊢ Summable f
Theorem: Polynomial.degree_mul
File: Mathlib/Data/Polynomial/Degree/Definitions.lean

tactic: simp only [hp0, degree_zero, zero_mul, WithBot.bot_add]
state_before: R : Type u
S : Type v
a b c d : R
n m : ℕ
inst✝¹ : Semiring R
inst✝ : NoZeroDivisors R
p q : R[X]
hp0 : p = 0
⊢ degree (p * q) = degree p + degree q

tactic: simp only [hq0, degree_zero, mul_zero, WithBot.add_bot]
state_before: R : Type u
S : Type v
a b c d : R
n m : ℕ
inst✝¹ : Semiring R
inst✝ : NoZeroDivisors R
p q : R[X]
hp0 : ¬p = 0
hq0 : q = 0
⊢ degree (p * q) = degree p + degree q
Theorem: Filter.map_biInf_eq
File: Mathlib/Order/Filter/Basic.lean

tactic: haveI := nonempty_subtype.2 ne
state_before: α : Type u
β : Type v
γ : Type w
δ : Type ?u.280594
ι✝ : Sort x
ι : Type w
f : ι → Filter α
m : α → β
p : ι → Prop
h : DirectedOn (f ⁻¹'o fun x x_1 => x ≥ x_1) {x | p x}
ne : ∃ i, p i
⊢ map m (⨅ (i : ι) (_ : p i), f i) = ⨅ (i : ι) (_ : p i), map m (f i)

tactic: simp only [iInf_subtype']
state_before: α : Type u
β : Type v
γ : Type w
δ : Type ?u.280594
ι✝ : Sort x
ι : Type w
f : ι → Filter α
m : α → β
p : ι → Prop
h : DirectedOn (f ⁻¹'o fun x x_1 => x ≥ x_1) {x | p x}
ne : ∃ i, p i
this : Nonempty { a // p a }
⊢ map m (⨅ (i : ι) (_ : p i), f i) = ⨅ (i : ι) (_ : p i), map m (f i)

tactic: exact map_iInf_eq h.directed_val
state_before: α : Type u
β : Type v
γ : Type w
δ : Type ?u.280594
ι✝ : Sort x
ι : Type w
f : ι → Filter α
m : α → β
p : ι → Prop
h : DirectedOn (f ⁻¹'o fun x x_1 => x ≥ x_1) {x | p x}
ne : ∃ i, p i
this : Nonempty { a // p a }
⊢ map m (⨅ (x : { i // p i }), f ↑x) = ⨅ (x : { i // p i }), map m (f ↑x)
Theorem: SeparationQuotient.tendsto_lift_nhds_mk
File: Mathlib/Topology/Inseparable.lean

tactic: simp only [← map_mk_nhds, tendsto_map'_iff, lift_comp_mk]
state_before: X : Type u_1
Y : Type ?u.101522
Z : Type ?u.101525
α : Type u_2
ι : Type ?u.101531
π : ι → Type ?u.101536
inst✝³ : TopologicalSpace X
inst✝² : TopologicalSpace Y
inst✝¹ : TopologicalSpace Z
inst✝ : (i : ι) → TopologicalSpace (π i)
x✝ y z : X
s : Set X
f✝ : X → Y
t : Set (SeparationQuotient X)
f : X → α
hf : ∀ (x y : X), (x ~ᵢ y) → f x = f y
x : X
l : Filter α
⊢ Tendsto (lift f hf) (𝓝 (mk x)) l ↔ Tendsto f (𝓝 x) l
Theorem: LinearMap.re_inner_adjoint_mul_self_nonneg
File: Mathlib/Analysis/InnerProductSpace/Adjoint.lean

tactic: simp only [mul_apply, adjoint_inner_right, inner_self_eq_norm_sq_to_K]
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type ?u.2294831
G : Type ?u.2294834
inst✝⁹ : IsROrC 𝕜
inst✝⁸ : NormedAddCommGroup E
inst✝⁷ : NormedAddCommGroup F
inst✝⁶ : NormedAddCommGroup G
inst✝⁵ : InnerProductSpace 𝕜 E
inst✝⁴ : InnerProductSpace 𝕜 F
inst✝³ : InnerProductSpace 𝕜 G
inst✝² : FiniteDimensional 𝕜 E
inst✝¹ : FiniteDimensional 𝕜 F
inst✝ : FiniteDimensional 𝕜 G
T : E →ₗ[𝕜] E
x : E
⊢ 0 ≤ ↑re (inner x (↑(↑adjoint T * T) x))

tactic: norm_cast
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type ?u.2294831
G : Type ?u.2294834
inst✝⁹ : IsROrC 𝕜
inst✝⁸ : NormedAddCommGroup E
inst✝⁷ : NormedAddCommGroup F
inst✝⁶ : NormedAddCommGroup G
inst✝⁵ : InnerProductSpace 𝕜 E
inst✝⁴ : InnerProductSpace 𝕜 F
inst✝³ : InnerProductSpace 𝕜 G
inst✝² : FiniteDimensional 𝕜 E
inst✝¹ : FiniteDimensional 𝕜 F
inst✝ : FiniteDimensional 𝕜 G
T : E →ₗ[𝕜] E
x : E
⊢ 0 ≤ ↑re (↑‖↑T x‖ ^ 2)

tactic: exact sq_nonneg _
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type ?u.2294831
G : Type ?u.2294834
inst✝⁹ : IsROrC 𝕜
inst✝⁸ : NormedAddCommGroup E
inst✝⁷ : NormedAddCommGroup F
inst✝⁶ : NormedAddCommGroup G
inst✝⁵ : InnerProductSpace 𝕜 E
inst✝⁴ : InnerProductSpace 𝕜 F
inst✝³ : InnerProductSpace 𝕜 G
inst✝² : FiniteDimensional 𝕜 E
inst✝¹ : FiniteDimensional 𝕜 F
inst✝ : FiniteDimensional 𝕜 G
T : E →ₗ[𝕜] E
x : E
⊢ 0 ≤ ‖↑T x‖ ^ 2
Theorem: homology.π'_desc'
File: Mathlib/CategoryTheory/Abelian/Homology.lean

tactic: dsimp [π', desc']
state_before: A : Type u
inst✝¹ : Category A
inst✝ : Abelian A
X Y Z : A
f : X ⟶ Y
g : Y ⟶ Z
w : f ≫ g = 0
W : A
e : kernel g ⟶ W
he : kernel.lift g f w ≫ e = 0
⊢ π' f g w ≫ desc' f g w e he = e

tactic: simp
state_before: A : Type u
inst✝¹ : Category A
inst✝ : Abelian A
X Y Z : A
f : X ⟶ Y
g : Y ⟶ Z
w : f ≫ g = 0
W : A
e : kernel g ⟶ W
he : kernel.lift g f w ≫ e = 0
⊢ (cokernel.π (kernel.lift g f w) ≫ (homologyIsoCokernelLift f g w).inv) ≫
      (homologyIsoCokernelLift f g w).hom ≫ cokernel.desc (kernel.lift g f w) e he =
    e
Theorem: Real.tendsto_exp_comp_atTop
File: Mathlib/Analysis/SpecialFunctions/Exp.lean

tactic: simp_rw [←comp_apply (f := exp), ← tendsto_comap_iff, comap_exp_atTop]
state_before: α : Type u_1
x y z : ℝ
l : Filter α
f : α → ℝ
⊢ Tendsto (fun x => exp (f x)) l atTop ↔ Tendsto f l atTop
Theorem: ENNReal.toReal_rpow
File: Mathlib/Analysis/SpecialFunctions/Pow/NNReal.lean

tactic: rw [ENNReal.toReal, ENNReal.toReal, ← NNReal.coe_rpow, ENNReal.toNNReal_rpow]
state_before: x : ℝ≥0∞
z : ℝ
⊢ ENNReal.toReal x ^ z = ENNReal.toReal (x ^ z)
Theorem: Finset.prod_dite_of_false
File: Mathlib/Algebra/BigOperators/Basic.lean

tactic: simp
state_before: ι : Type ?u.427583
β : Type u
α : Type v
γ : Type w
s s₁ s₂ : Finset α
a : α
f✝ g✝ : α → β
inst✝ : CommMonoid β
p : α → Prop
hp : DecidablePred p
h : ∀ (x : α), x ∈ s → ¬p x
f : (x : α) → p x → β
g : (x : α) → ¬p x → β
x : α
hx : x ∈ s
⊢ (fun x hx => { val := x, property := hx }) x hx ∈ univ

tactic: dsimp
state_before: ι : Type ?u.427583
β : Type u
α : Type v
γ : Type w
s s₁ s₂ : Finset α
a✝ : α
f✝ g✝ : α → β
inst✝ : CommMonoid β
p : α → Prop
hp : DecidablePred p
h : ∀ (x : α), x ∈ s → ¬p x
f : (x : α) → p x → β
g : (x : α) → ¬p x → β
a : α
ha : a ∈ s
⊢ (if hx : p a then f a hx else g a hx) =
    g ↑((fun x hx => { val := x, property := hx }) a ha) (_ : ¬p ↑((fun x hx => { val := x, property := hx }) a ha))

tactic: rw [dif_neg]
state_before: ι : Type ?u.427583
β : Type u
α : Type v
γ : Type w
s s₁ s₂ : Finset α
a✝ : α
f✝ g✝ : α → β
inst✝ : CommMonoid β
p : α → Prop
hp : DecidablePred p
h : ∀ (x : α), x ∈ s → ¬p x
f : (x : α) → p x → β
g : (x : α) → ¬p x → β
a : α
ha : a ∈ s
⊢ (if hx : p a then f a hx else g a hx) = g a (_ : ¬p a)

tactic: simp
state_before: ι : Type ?u.427583
β : Type u
α : Type v
γ : Type w
s s₁ s₂ : Finset α
a : α
f✝ g✝ : α → β
inst✝ : CommMonoid β
p : α → Prop
hp : DecidablePred p
h : ∀ (x : α), x ∈ s → ¬p x
f : (x : α) → p x → β
g : (x : α) → ¬p x → β
b : { x // x ∈ s }
_hb : b ∈ univ
⊢ b = (fun x hx => { val := x, property := hx }) ↑b (_ : ↑b ∈ s)
Theorem: SimpleGraph.Connected.ofBoxProdLeft
File: Mathlib/Combinatorics/SimpleGraph/Prod.lean

tactic: haveI := (nonempty_prod.1 h.nonempty).1
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.83059
G : SimpleGraph α
H : SimpleGraph β
h : Connected (G □ H)
⊢ Connected G

tactic: haveI := (nonempty_prod.1 h.nonempty).2
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.83059
G : SimpleGraph α
H : SimpleGraph β
h : Connected (G □ H)
this : Nonempty α
⊢ Connected G

tactic: exact ⟨h.preconnected.ofBoxProdLeft⟩
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.83059
G : SimpleGraph α
H : SimpleGraph β
h : Connected (G □ H)
this✝ : Nonempty α
this : Nonempty β
⊢ Connected G
Theorem: Ring.mul_inverse_cancel
File: Mathlib/Algebra/GroupWithZero/Units/Basic.lean

tactic: rcases h with ⟨u, rfl⟩
state_before: α : Type ?u.6182
M₀ : Type u_1
G₀ : Type ?u.6188
M₀' : Type ?u.6191
G₀' : Type ?u.6194
F : Type ?u.6197
F' : Type ?u.6200
inst✝ : MonoidWithZero M₀
x : M₀
h : IsUnit x
⊢ x * inverse x = 1

tactic: rw [inverse_unit, Units.mul_inv]
state_before: case intro
α : Type ?u.6182
M₀ : Type u_1
G₀ : Type ?u.6188
M₀' : Type ?u.6191
G₀' : Type ?u.6194
F : Type ?u.6197
F' : Type ?u.6200
inst✝ : MonoidWithZero M₀
u : M₀ˣ
⊢ ↑u * inverse ↑u = 1
Theorem: IsOpen.connectedComponentIn
File: Mathlib/Topology/Connected.lean

tactic: rw [isOpen_iff_mem_nhds]
state_before: α : Type u
β : Type v
ι : Type ?u.114324
π : ι → Type ?u.114329
inst✝¹ : TopologicalSpace α
s t u v : Set α
inst✝ : LocallyConnectedSpace α
F : Set α
x : α
hF : IsOpen F
⊢ IsOpen (connectedComponentIn F x)

tactic: intro y hy
state_before: α : Type u
β : Type v
ι : Type ?u.114324
π : ι → Type ?u.114329
inst✝¹ : TopologicalSpace α
s t u v : Set α
inst✝ : LocallyConnectedSpace α
F : Set α
x : α
hF : IsOpen F
⊢ ∀ (a : α), a ∈ connectedComponentIn F x → connectedComponentIn F x ∈ 𝓝 a

tactic: rw [connectedComponentIn_eq hy]
state_before: α : Type u
β : Type v
ι : Type ?u.114324
π : ι → Type ?u.114329
inst✝¹ : TopologicalSpace α
s t u v : Set α
inst✝ : LocallyConnectedSpace α
F : Set α
x : α
hF : IsOpen F
y : α
hy : y ∈ connectedComponentIn F x
⊢ connectedComponentIn F x ∈ 𝓝 y

tactic: exact connectedComponentIn_mem_nhds (hF.mem_nhds <| connectedComponentIn_subset F x hy)
state_before: α : Type u
β : Type v
ι : Type ?u.114324
π : ι → Type ?u.114329
inst✝¹ : TopologicalSpace α
s t u v : Set α
inst✝ : LocallyConnectedSpace α
F : Set α
x : α
hF : IsOpen F
y : α
hy : y ∈ connectedComponentIn F x
⊢ connectedComponentIn F y ∈ 𝓝 y
Theorem: Left.pow_lt_one_of_lt
File: Mathlib/Algebra/GroupPower/Order.lean

tactic: rw [pow_succ]
state_before: β : Type ?u.90376
A : Type ?u.90379
G : Type ?u.90382
M : Type u_1
R : Type ?u.90388
inst✝² : Monoid M
inst✝¹ : Preorder M
inst✝ : CovariantClass M M (fun x x_1 => x * x_1) fun x x_1 => x < x_1
n✝ : ℕ
x : M
hn : 0 < n✝
h : x < 1
n : ℕ
x✝ : Nat.succ 0 ≤ n
ih : x ^ n < 1
⊢ x ^ (n + 1) < 1

tactic: exact mul_lt_one h ih
state_before: β : Type ?u.90376
A : Type ?u.90379
G : Type ?u.90382
M : Type u_1
R : Type ?u.90388
inst✝² : Monoid M
inst✝¹ : Preorder M
inst✝ : CovariantClass M M (fun x x_1 => x * x_1) fun x x_1 => x < x_1
n✝ : ℕ
x : M
hn : 0 < n✝
h : x < 1
n : ℕ
x✝ : Nat.succ 0 ≤ n
ih : x ^ n < 1
⊢ x * x ^ n < 1
Theorem: Computation.orelse_think
File: Mathlib/Data/Seq/Computation.lean

tactic: unfold HOrElse.hOrElse instHOrElse
state_before: α : Type u
β : Type v
γ : Type w
c₁ c₂ : Computation α
⊢ destruct (HOrElse.hOrElse (think c₁) fun x => think c₂) = Sum.inr (HOrElse.hOrElse c₁ fun x => c₂)

tactic: unfold OrElse.orElse instOrElse Alternative.orElse instAlternativeComputation
state_before: α : Type u
β : Type v
γ : Type w
c₁ c₂ : Computation α
⊢ destruct ({ hOrElse := fun a b => OrElse.orElse a b }.1 (think c₁) fun x => think c₂) =
    Sum.inr ({ hOrElse := fun a b => OrElse.orElse a b }.1 c₁ fun x => c₂)

tactic: simp [orElse]
state_before: α : Type u
β : Type v
γ : Type w
c₁ c₂ : Computation α
⊢ destruct
      ({
            hOrElse := fun a b =>
              {
                    orElse :=
                      (let src := monad;
                        Alternative.mk empty @orElse).3 }.1
                a b }.1
        (think c₁) fun x => think c₂) =
    Sum.inr
      ({
            hOrElse := fun a b =>
              {
                    orElse :=
                      (let src := monad;
                        Alternative.mk empty @orElse).3 }.1
                a b }.1
        c₁ fun x => c₂)
Theorem: Finpartition.parts_eq_empty_iff
File: Mathlib/Order/Partition/Finpartition.lean

tactic: simp_rw [← P.supParts]
state_before: α : Type u_1
inst✝¹ : Lattice α
inst✝ : OrderBot α
a : α
P : Finpartition a
⊢ P.parts = ∅ ↔ a = ⊥

tactic: refine' ⟨fun h ↦ _, fun h ↦ eq_empty_iff_forall_not_mem.2 fun b hb ↦ P.not_bot_mem _⟩
state_before: α : Type u_1
inst✝¹ : Lattice α
inst✝ : OrderBot α
a : α
P : Finpartition a
⊢ P.parts = ∅ ↔ sup P.parts id = ⊥

tactic: rw [h]
state_before: case refine'_1
α : Type u_1
inst✝¹ : Lattice α
inst✝ : OrderBot α
a : α
P : Finpartition a
h : P.parts = ∅
⊢ sup P.parts id = ⊥

tactic: exact Finset.sup_empty
state_before: case refine'_1
α : Type u_1
inst✝¹ : Lattice α
inst✝ : OrderBot α
a : α
P : Finpartition a
h : P.parts = ∅
⊢ sup ∅ id = ⊥

tactic: rwa [← le_bot_iff.1 ((le_sup hb).trans h.le)]
state_before: case refine'_2
α : Type u_1
inst✝¹ : Lattice α
inst✝ : OrderBot α
a : α
P : Finpartition a
h : sup P.parts id = ⊥
b : α
hb : b ∈ P.parts
⊢ ⊥ ∈ P.parts
Theorem: MeasureTheory.UnifIntegrable.neg
File: Mathlib/MeasureTheory/Function/UniformIntegrable.lean

tactic: simp_rw [UnifIntegrable, Pi.neg_apply, Set.indicator_neg', snorm_neg]
state_before: α : Type u_1
β : Type u_2
ι : Type u_3
m : MeasurableSpace α
μ : Measure α
inst✝ : NormedAddCommGroup β
f g : ι → α → β
p : ℝ≥0∞
hf : UnifIntegrable f p μ
⊢ UnifIntegrable (-f) p μ

tactic: exact hf
state_before: α : Type u_1
β : Type u_2
ι : Type u_3
m : MeasurableSpace α
μ : Measure α
inst✝ : NormedAddCommGroup β
f g : ι → α → β
p : ℝ≥0∞
hf : UnifIntegrable f p μ
⊢ ∀ ⦃ε : ℝ⦄,
    0 < ε →
      ∃ δ h,
        ∀ (i : ι) (s : Set α),
          MeasurableSet s → ↑↑μ s ≤ ENNReal.ofReal δ → snorm (Set.indicator s (f i)) p μ ≤ ENNReal.ofReal ε
Theorem: Set.isCompl_range_inl_range_inr
File: Mathlib/Data/Set/Image.lean

tactic: rintro y ⟨⟨x₁, rfl⟩, ⟨x₂, h⟩⟩
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.82270
ι : Sort ?u.82273
ι' : Sort ?u.82276
f : ι → α
s t : Set α
⊢ range Sum.inl ⊓ range Sum.inr ≤ ⊥

tactic: exact Sum.noConfusion h
state_before: case intro.intro.intro
α : Type u_1
β : Type u_2
γ : Type ?u.82270
ι : Sort ?u.82273
ι' : Sort ?u.82276
f : ι → α
s t : Set α
x₁ : α
x₂ : β
h : Sum.inr x₂ = Sum.inl x₁
⊢ Sum.inl x₁ ∈ ⊥

tactic: rintro (x | y) - <;> [left; right] <;> exact mem_range_self _
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.82270
ι : Sort ?u.82273
ι' : Sort ?u.82276
f : ι → α
s t : Set α
⊢ ⊤ ≤ range Sum.inl ⊔ range Sum.inr
Theorem: Part.assert_neg
File: Mathlib/Data/Part.lean

tactic: dsimp [assert, none]
state_before: α : Type u_1
β : Type ?u.17198
γ : Type ?u.17201
p : Prop
f : p → Part α
h : ¬p
⊢ assert p f = none

tactic: congr
state_before: α : Type u_1
β : Type ?u.17198
γ : Type ?u.17201
p : Prop
f : p → Part α
h : ¬p
⊢ { Dom := ∃ h, (f h).Dom, get := fun ha => get (f (_ : p)) (_ : (f (_ : p)).Dom) } =
    { Dom := False, get := fun t => False.rec (fun x => α) t }

tactic: simp only [h, not_false_iff, exists_prop_of_false]
state_before: case h.e_2
α : Type u_1
β : Type ?u.17198
γ : Type ?u.17201
p : Prop
f : p → Part α
h : ¬p
⊢ (∃ h, (f h).Dom) = False

tactic: apply Function.hfunext
state_before: case h.e_3
α : Type u_1
β : Type ?u.17198
γ : Type ?u.17201
p : Prop
f : p → Part α
h : ¬p
⊢ HEq (fun ha => get (f (_ : p)) (_ : (f (_ : p)).Dom)) fun t => False.rec (fun x => α) t

tactic: simp at *
state_before: case h.e_3.h
α : Type u_1
β : Type ?u.17198
γ : Type ?u.17201
p : Prop
f : p → Part α
h : ¬p
⊢ ∀ (a : ∃ h, (f h).Dom) (a' : False),
    HEq a a' → HEq (get (f (_ : p)) (_ : (f (_ : p)).Dom)) (False.rec (fun x => α) a')

tactic: simp only [h, not_false_iff, exists_prop_of_false]
state_before: case h.e_3.hα
α : Type u_1
β : Type ?u.17198
γ : Type ?u.17201
p : Prop
f : p → Part α
h : ¬p
⊢ (∃ h, (f h).Dom) = False
Theorem: Complex.arg_of_im_neg
File: Mathlib/Analysis/SpecialFunctions/Complex/Arg.lean

tactic: have h₀ : z ≠ 0 := mt (congr_arg im) hz.ne
state_before: z : ℂ
hz : z.im < 0
⊢ arg z = -arccos (z.re / ↑abs z)

tactic: rw [← cos_arg h₀, ← Real.cos_neg, Real.arccos_cos, neg_neg]
state_before: z : ℂ
hz : z.im < 0
h₀ : z ≠ 0
⊢ arg z = -arccos (z.re / ↑abs z)

tactic: exacts [neg_nonneg.2 (arg_neg_iff.2 hz).le, neg_le.2 (neg_pi_lt_arg z).le]
state_before: case hx₁
z : ℂ
hz : z.im < 0
h₀ : z ≠ 0
⊢ 0 ≤ -arg z

case hx₂
z : ℂ
hz : z.im < 0
h₀ : z ≠ 0
⊢ -arg z ≤ π
Theorem: Holor.slice_sum
File: Mathlib/Data/Holor.lean

tactic: letI := Classical.decEq β
state_before: α : Type
d : ℕ
ds ds₁ ds₂ ds₃ : List ℕ
inst✝ : AddCommMonoid α
β : Type
i : ℕ
hid : i < d
s : Finset β
f : β → Holor α (d :: ds)
⊢ ∑ x in s, slice (f x) i hid = slice (∑ x in s, f x) i hid

tactic: refine' Finset.induction_on s _ _
state_before: α : Type
d : ℕ
ds ds₁ ds₂ ds₃ : List ℕ
inst✝ : AddCommMonoid α
β : Type
i : ℕ
hid : i < d
s : Finset β
f : β → Holor α (d :: ds)
this : DecidableEq β := Classical.decEq β
⊢ ∑ x in s, slice (f x) i hid = slice (∑ x in s, f x) i hid

tactic: simp [slice_zero]
state_before: case refine'_1
α : Type
d : ℕ
ds ds₁ ds₂ ds₃ : List ℕ
inst✝ : AddCommMonoid α
β : Type
i : ℕ
hid : i < d
s : Finset β
f : β → Holor α (d :: ds)
this : DecidableEq β := Classical.decEq β
⊢ ∑ x in ∅, slice (f x) i hid = slice (∑ x in ∅, f x) i hid

tactic: intro _ _ h_not_in ih
state_before: case refine'_2
α : Type
d : ℕ
ds ds₁ ds₂ ds₃ : List ℕ
inst✝ : AddCommMonoid α
β : Type
i : ℕ
hid : i < d
s : Finset β
f : β → Holor α (d :: ds)
this : DecidableEq β := Classical.decEq β
⊢ ∀ ⦃a : β⦄ {s : Finset β},
    ¬a ∈ s →
      ∑ x in s, slice (f x) i hid = slice (∑ x in s, f x) i hid →
        ∑ x in insert a s, slice (f x) i hid = slice (∑ x in insert a s, f x) i hid

tactic: rw [Finset.sum_insert h_not_in, ih, slice_add, Finset.sum_insert h_not_in]
state_before: case refine'_2
α : Type
d : ℕ
ds ds₁ ds₂ ds₃ : List ℕ
inst✝ : AddCommMonoid α
β : Type
i : ℕ
hid : i < d
s : Finset β
f : β → Holor α (d :: ds)
this : DecidableEq β := Classical.decEq β
a✝ : β
s✝ : Finset β
h_not_in : ¬a✝ ∈ s✝
ih : ∑ x in s✝, slice (f x) i hid = slice (∑ x in s✝, f x) i hid
⊢ ∑ x in insert a✝ s✝, slice (f x) i hid = slice (∑ x in insert a✝ s✝, f x) i hid
Theorem: Dfinsupp.mk_add
File: Mathlib/Data/Dfinsupp/Basic.lean

tactic: simp only [add_apply, mk_apply]
state_before: ι : Type u
γ : Type w
β : ι → Type v
β₁ : ι → Type v₁
β₂ : ι → Type v₂
dec : DecidableEq ι
inst✝ : (i : ι) → AddZeroClass (β i)
s : Finset ι
x y : (i : ↑↑s) → β ↑i
i : ι
⊢ ↑(mk s (x + y)) i = ↑(mk s x + mk s y) i

tactic: split_ifs <;> [rfl; rw [zero_add]]
state_before: ι : Type u
γ : Type w
β : ι → Type v
β₁ : ι → Type v₁
β₂ : ι → Type v₂
dec : DecidableEq ι
inst✝ : (i : ι) → AddZeroClass (β i)
s : Finset ι
x y : (i : ↑↑s) → β ↑i
i : ι
⊢ (if H : i ∈ s then (x + y) { val := i, property := H } else 0) =
    (if H : i ∈ s then x { val := i, property := H } else 0) + if H : i ∈ s then y { val := i, property := H } else 0
Theorem: CategoryTheory.Functor.surjective_toEventualRanges
File: Mathlib/CategoryTheory/CofilteredSystem.lean

tactic: obtain ⟨y, hy, rfl⟩ := h.subset_image_eventualRange F f hx
state_before: J : Type u
inst✝¹ : Category J
F : J ⥤ Type v
i✝ j✝ k : J
s : Set (F.obj i✝)
inst✝ : IsCofilteredOrEmpty J
h : IsMittagLeffler F
i j : J
f : i ⟶ j
x✝ : (toEventualRanges F).obj j
x : F.obj j
hx : x ∈ eventualRange F j
⊢ ∃ a, (toEventualRanges F).map f a = { val := x, property := hx }

tactic: exact ⟨⟨y, hy⟩, rfl⟩
state_before: case intro.intro
J : Type u
inst✝¹ : Category J
F : J ⥤ Type v
i✝ j✝ k : J
s : Set (F.obj i✝)
inst✝ : IsCofilteredOrEmpty J
h : IsMittagLeffler F
i j : J
f : i ⟶ j
x✝ : (toEventualRanges F).obj j
y : F.obj i
hy : y ∈ eventualRange F i
hx : F.map f y ∈ eventualRange F j
⊢ ∃ a, (toEventualRanges F).map f a = { val := F.map f y, property := hx }
Theorem: Real.le_rpow_inv_iff_of_neg
File: Mathlib/Analysis/SpecialFunctions/Pow/Real.lean

tactic: have hz' : 0 < -z := by rwa [lt_neg, neg_zero]
state_before: x y z : ℝ
hx : 0 < x
hy : 0 < y
hz : z < 0
⊢ x ≤ y ^ z⁻¹ ↔ y ≤ x ^ z

tactic: have hxz : 0 < x ^ (-z) := Real.rpow_pos_of_pos hx _
state_before: x y z : ℝ
hx : 0 < x
hy : 0 < y
hz : z < 0
hz' : 0 < -z
⊢ x ≤ y ^ z⁻¹ ↔ y ≤ x ^ z

tactic: have hyz : 0 < y ^ z⁻¹ := Real.rpow_pos_of_pos hy _
state_before: x y z : ℝ
hx : 0 < x
hy : 0 < y
hz : z < 0
hz' : 0 < -z
hxz : 0 < x ^ (-z)
⊢ x ≤ y ^ z⁻¹ ↔ y ≤ x ^ z

tactic: rw [← Real.rpow_le_rpow_iff hx.le hyz.le hz', ← Real.rpow_mul hy.le]
state_before: x y z : ℝ
hx : 0 < x
hy : 0 < y
hz : z < 0
hz' : 0 < -z
hxz : 0 < x ^ (-z)
hyz : 0 < y ^ z⁻¹
⊢ x ≤ y ^ z⁻¹ ↔ y ≤ x ^ z

tactic: simp only [ne_of_lt hz, Real.rpow_neg_one, mul_neg, inv_mul_cancel, Ne.def, not_false_iff]
state_before: x y z : ℝ
hx : 0 < x
hy : 0 < y
hz : z < 0
hz' : 0 < -z
hxz : 0 < x ^ (-z)
hyz : 0 < y ^ z⁻¹
⊢ x ^ (-z) ≤ y ^ (z⁻¹ * -z) ↔ y ≤ x ^ z

tactic: rw [le_inv hxz hy, ← Real.rpow_neg_one, ← Real.rpow_mul hx.le]
state_before: x y z : ℝ
hx : 0 < x
hy : 0 < y
hz : z < 0
hz' : 0 < -z
hxz : 0 < x ^ (-z)
hyz : 0 < y ^ z⁻¹
⊢ x ^ (-z) ≤ y⁻¹ ↔ y ≤ x ^ z

tactic: simp
state_before: x y z : ℝ
hx : 0 < x
hy : 0 < y
hz : z < 0
hz' : 0 < -z
hxz : 0 < x ^ (-z)
hyz : 0 < y ^ z⁻¹
⊢ y ≤ x ^ (-z * -1) ↔ y ≤ x ^ z

tactic: rwa [lt_neg, neg_zero]
state_before: x y z : ℝ
hx : 0 < x
hy : 0 < y
hz : z < 0
⊢ 0 < -z
Theorem: Part.ofOption_eq_get
File: Mathlib/Data/Part.lean

tactic: cases o
state_before: α✝ : Type ?u.10143
β : Type ?u.10146
γ : Type ?u.10149
α : Type u_1
o : Option α
h₁ : (↑o).Dom
h₂ : { Dom := Option.isSome o = true, get := Option.get o }.Dom
⊢ get (↑o) h₁ = get { Dom := Option.isSome o = true, get := Option.get o } h₂

tactic: . simp at h₂
state_before: case none
α✝ : Type ?u.10143
β : Type ?u.10146
γ : Type ?u.10149
α : Type u_1
h₁ : (↑Option.none).Dom
h₂ : { Dom := Option.isSome Option.none = true, get := Option.get Option.none }.Dom
⊢ get (↑Option.none) h₁ = get { Dom := Option.isSome Option.none = true, get := Option.get Option.none } h₂

case some
α✝ : Type ?u.10143
β : Type ?u.10146
γ : Type ?u.10149
α : Type u_1
val✝ : α
h₁ : (↑(Option.some val✝)).Dom
h₂ : { Dom := Option.isSome (Option.some val✝) = true, get := Option.get (Option.some val✝) }.Dom
⊢ get (↑(Option.some val✝)) h₁ =
    get { Dom := Option.isSome (Option.some val✝) = true, get := Option.get (Option.some val✝) } h₂

tactic: . rfl
state_before: case some
α✝ : Type ?u.10143
β : Type ?u.10146
γ : Type ?u.10149
α : Type u_1
val✝ : α
h₁ : (↑(Option.some val✝)).Dom
h₂ : { Dom := Option.isSome (Option.some val✝) = true, get := Option.get (Option.some val✝) }.Dom
⊢ get (↑(Option.some val✝)) h₁ =
    get { Dom := Option.isSome (Option.some val✝) = true, get := Option.get (Option.some val✝) } h₂

tactic: simp at h₂
state_before: case none
α✝ : Type ?u.10143
β : Type ?u.10146
γ : Type ?u.10149
α : Type u_1
h₁ : (↑Option.none).Dom
h₂ : { Dom := Option.isSome Option.none = true, get := Option.get Option.none }.Dom
⊢ get (↑Option.none) h₁ = get { Dom := Option.isSome Option.none = true, get := Option.get Option.none } h₂

tactic: rfl
state_before: case some
α✝ : Type ?u.10143
β : Type ?u.10146
γ : Type ?u.10149
α : Type u_1
val✝ : α
h₁ : (↑(Option.some val✝)).Dom
h₂ : { Dom := Option.isSome (Option.some val✝) = true, get := Option.get (Option.some val✝) }.Dom
⊢ get (↑(Option.some val✝)) h₁ =
    get { Dom := Option.isSome (Option.some val✝) = true, get := Option.get (Option.some val✝) } h₂