tasksource/leandojo huggingface dataset:
Theorem: IsOpen.polishSpace
File: Mathlib/Topology/MetricSpace/Polish.lean

tactic: letI := upgradePolishSpace α
state_before: α✝ : Type ?u.34143
β : Type ?u.34146
inst✝² : MetricSpace α✝
s✝ : Opens α✝
α : Type u_1
inst✝¹ : TopologicalSpace α
inst✝ : PolishSpace α
s : Set α
hs : IsOpen s
⊢ PolishSpace ↑s

tactic: lift s to Opens α using hs
state_before: α✝ : Type ?u.34143
β : Type ?u.34146
inst✝² : MetricSpace α✝
s✝ : Opens α✝
α : Type u_1
inst✝¹ : TopologicalSpace α
inst✝ : PolishSpace α
s : Set α
hs : IsOpen s
this : UpgradedPolishSpace α := upgradePolishSpace α
⊢ PolishSpace ↑s

tactic: have : SecondCountableTopology s.CompleteCopy := inferInstanceAs (SecondCountableTopology s)
state_before: case intro
α✝ : Type ?u.34143
β : Type ?u.34146
inst✝² : MetricSpace α✝
s✝ : Opens α✝
α : Type u_1
inst✝¹ : TopologicalSpace α
inst✝ : PolishSpace α
this : UpgradedPolishSpace α := upgradePolishSpace α
s : Opens α
⊢ PolishSpace ↑↑s

tactic: exact inferInstanceAs (PolishSpace s.CompleteCopy)
state_before: case intro
α✝ : Type ?u.34143
β : Type ?u.34146
inst✝² : MetricSpace α✝
s✝ : Opens α✝
α : Type u_1
inst✝¹ : TopologicalSpace α
inst✝ : PolishSpace α
this✝ : UpgradedPolishSpace α := upgradePolishSpace α
s : Opens α
this : SecondCountableTopology (CompleteCopy s)
⊢ PolishSpace ↑↑s
Theorem: Submodule.ker_inl
File: Mathlib/LinearAlgebra/Prod.lean

tactic: rw [ker, ← prod_bot, prod_comap_inl]
state_before: R : Type u
K : Type u'
M : Type v
V : Type v'
M₂ : Type w
V₂ : Type w'
M₃ : Type y
V₃ : Type y'
M₄ : Type z
ι : Type x
M₅ : Type ?u.315515
M₆ : Type ?u.315518
inst✝⁴ : Semiring R
inst✝³ : AddCommMonoid M
inst✝² : AddCommMonoid M₂
inst✝¹ : Module R M
inst✝ : Module R M₂
p : Submodule R M
q : Submodule R M₂
⊢ ker (inl R M M₂) = ⊥
Theorem: ENNReal.rpow_add_le_add_rpow
File: Mathlib/Analysis/MeanInequalitiesPow.lean

tactic: rcases hp.eq_or_lt with (rfl | hp_pos)
state_before: ι : Type u
s : Finset ι
p : ℝ
a b : ℝ≥0∞
hp : 0 ≤ p
hp1 : p ≤ 1
⊢ (a + b) ^ p ≤ a ^ p + b ^ p

tactic: have h := rpow_add_rpow_le a b hp_pos hp1
state_before: case inr
ι : Type u
s : Finset ι
p : ℝ
a b : ℝ≥0∞
hp : 0 ≤ p
hp1 : p ≤ 1
hp_pos : 0 < p
⊢ (a + b) ^ p ≤ a ^ p + b ^ p

tactic: rw [one_div_one] at h
state_before: case inr
ι : Type u
s : Finset ι
p : ℝ
a b : ℝ≥0∞
hp : 0 ≤ p
hp1 : p ≤ 1
hp_pos : 0 < p
h : (a ^ 1 + b ^ 1) ^ (1 / 1) ≤ (a ^ p + b ^ p) ^ (1 / p)
⊢ (a + b) ^ p ≤ a ^ p + b ^ p

tactic: repeat' rw [ENNReal.rpow_one] at h
state_before: case inr
ι : Type u
s : Finset ι
p : ℝ
a b : ℝ≥0∞
hp : 0 ≤ p
hp1 : p ≤ 1
hp_pos : 0 < p
h : (a ^ 1 + b ^ 1) ^ 1 ≤ (a ^ p + b ^ p) ^ (1 / p)
⊢ (a + b) ^ p ≤ a ^ p + b ^ p

tactic: exact (ENNReal.le_rpow_one_div_iff hp_pos).mp h
state_before: case inr
ι : Type u
s : Finset ι
p : ℝ
a b : ℝ≥0∞
hp : 0 ≤ p
hp1 : p ≤ 1
hp_pos : 0 < p
h : a + b ≤ (a ^ p + b ^ p) ^ (1 / p)
⊢ (a + b) ^ p ≤ a ^ p + b ^ p

tactic: simp
state_before: case inl
ι : Type u
s : Finset ι
a b : ℝ≥0∞
hp : 0 ≤ 0
hp1 : 0 ≤ 1
⊢ (a + b) ^ 0 ≤ a ^ 0 + b ^ 0

tactic: rw [ENNReal.rpow_one] at h
state_before: case inr
ι : Type u
s : Finset ι
p : ℝ
a b : ℝ≥0∞
hp : 0 ≤ p
hp1 : p ≤ 1
hp_pos : 0 < p
h : a + b ≤ (a ^ p + b ^ p) ^ (1 / p)
⊢ (a + b) ^ p ≤ a ^ p + b ^ p
Theorem: HasSum.add_disjoint
File: Mathlib/Topology/Algebra/InfiniteSum/Basic.lean

tactic: rw [hasSum_subtype_iff_indicator] at *
state_before: α : Type u_2
β : Type u_1
γ : Type ?u.248888
δ : Type ?u.248891
inst✝² : AddCommMonoid α
inst✝¹ : TopologicalSpace α
f g : β → α
a b : α
s✝ : Finset β
inst✝ : ContinuousAdd α
s t : Set β
hs : Disjoint s t
ha : HasSum (f ∘ Subtype.val) a
hb : HasSum (f ∘ Subtype.val) b
⊢ HasSum (f ∘ Subtype.val) (a + b)

tactic: rw [Set.indicator_union_of_disjoint hs]
state_before: α : Type u_2
β : Type u_1
γ : Type ?u.248888
δ : Type ?u.248891
inst✝² : AddCommMonoid α
inst✝¹ : TopologicalSpace α
f g : β → α
a b : α
s✝ : Finset β
inst✝ : ContinuousAdd α
s t : Set β
hs : Disjoint s t
ha : HasSum (Set.indicator s f) a
hb : HasSum (Set.indicator t f) b
⊢ HasSum (Set.indicator (s ∪ t) f) (a + b)

tactic: exact ha.add hb
state_before: α : Type u_2
β : Type u_1
γ : Type ?u.248888
δ : Type ?u.248891
inst✝² : AddCommMonoid α
inst✝¹ : TopologicalSpace α
f g : β → α
a b : α
s✝ : Finset β
inst✝ : ContinuousAdd α
s t : Set β
hs : Disjoint s t
ha : HasSum (Set.indicator s f) a
hb : HasSum (Set.indicator t f) b
⊢ HasSum (fun a => Set.indicator s f a + Set.indicator t f a) (a + b)
Theorem: Ideal.exists_smith_normal_form
File: Mathlib/LinearAlgebra/FreeModule/PID.lean

tactic: cases nonempty_fintype ι
state_before: ι : Type u_1
R : Type u_2
inst✝⁸ : CommRing R
inst✝⁷ : IsDomain R
inst✝⁶ : IsPrincipalIdealRing R
M : Type ?u.301599
inst✝⁵ : AddCommGroup M
inst✝⁴ : Module R M
b✝ : ι → M
S : Type u_3
inst✝³ : CommRing S
inst✝² : IsDomain S
inst✝¹ : Algebra R S
inst✝ : Finite ι
b : Basis ι R S
I : Ideal S
hI : I ≠ ⊥
⊢ ∃ b' a ab', ∀ (i : ι), ↑(↑ab' i) = a i • ↑b' i

tactic: let ⟨bS, bI, f, a, snf⟩ := I.smithNormalForm b hI
state_before: case intro
ι : Type u_1
R : Type u_2
inst✝⁸ : CommRing R
inst✝⁷ : IsDomain R
inst✝⁶ : IsPrincipalIdealRing R
M : Type ?u.301599
inst✝⁵ : AddCommGroup M
inst✝⁴ : Module R M
b✝ : ι → M
S : Type u_3
inst✝³ : CommRing S
inst✝² : IsDomain S
inst✝¹ : Algebra R S
inst✝ : Finite ι
b : Basis ι R S
I : Ideal S
hI : I ≠ ⊥
val✝ : Fintype ι
⊢ ∃ b' a ab', ∀ (i : ι), ↑(↑ab' i) = a i • ↑b' i

tactic: let e : Fin (Fintype.card ι) ≃ ι :=
  Equiv.ofBijective f
    ((Fintype.bijective_iff_injective_and_card f).mpr ⟨f.injective, Fintype.card_fin _⟩)
state_before: case intro
ι : Type u_1
R : Type u_2
inst✝⁸ : CommRing R
inst✝⁷ : IsDomain R
inst✝⁶ : IsPrincipalIdealRing R
M : Type ?u.301599
inst✝⁵ : AddCommGroup M
inst✝⁴ : Module R M
b✝ : ι → M
S : Type u_3
inst✝³ : CommRing S
inst✝² : IsDomain S
inst✝¹ : Algebra R S
inst✝ : Finite ι
b : Basis ι R S
I : Ideal S
hI : I ≠ ⊥
val✝ : Fintype ι
bS : Basis ι R S
bI : Basis (Fin (Fintype.card ι)) R { x // x ∈ restrictScalars R I }
f : Fin (Fintype.card ι) ↪ ι
a : Fin (Fintype.card ι) → R
snf : ∀ (i : Fin (Fintype.card ι)), ↑(↑bI i) = a i • ↑bS (↑f i)
⊢ ∃ b' a ab', ∀ (i : ι), ↑(↑ab' i) = a i • ↑b' i

tactic: have fe : ∀ i, f (e.symm i) = i := e.apply_symm_apply
state_before: case intro
ι : Type u_1
R : Type u_2
inst✝⁸ : CommRing R
inst✝⁷ : IsDomain R
inst✝⁶ : IsPrincipalIdealRing R
M : Type ?u.301599
inst✝⁵ : AddCommGroup M
inst✝⁴ : Module R M
b✝ : ι → M
S : Type u_3
inst✝³ : CommRing S
inst✝² : IsDomain S
inst✝¹ : Algebra R S
inst✝ : Finite ι
b : Basis ι R S
I : Ideal S
hI : I ≠ ⊥
val✝ : Fintype ι
bS : Basis ι R S
bI : Basis (Fin (Fintype.card ι)) R { x // x ∈ restrictScalars R I }
f : Fin (Fintype.card ι) ↪ ι
a : Fin (Fintype.card ι) → R
snf : ∀ (i : Fin (Fintype.card ι)), ↑(↑bI i) = a i • ↑bS (↑f i)
e : Fin (Fintype.card ι) ≃ ι := Equiv.ofBijective ↑f (_ : Function.Bijective ↑f)
⊢ ∃ b' a ab', ∀ (i : ι), ↑(↑ab' i) = a i • ↑b' i
Theorem: Nat.bits_append_bit
File: Mathlib/Data/Nat/Bits.lean

tactic: rw [Nat.bits, binaryRec_eq']
state_before: n✝ n : ℕ
b : Bool
hn : n = 0 → b = true
⊢ bits (bit b n) = b :: bits n

tactic: simpa
state_before: case h
n✝ n : ℕ
b : Bool
hn : n = 0 → b = true
⊢ [false] = [] ∨ (n = 0 → b = true)
Theorem: Std.RBNode.balLeft_toList
File: Std/Data/RBMap/Lemmas.lean

tactic: unfold balLeft
state_before: α : Type u_1
l : RBNode α
v : α
r : RBNode α
⊢ toList (balLeft l v r) = toList l ++ v :: toList r

tactic: split <;> simp
state_before: α : Type u_1
l : RBNode α
v : α
r : RBNode α
⊢ toList
      (match l with
      | node red a x b => node red (node black a x b) v r
      | l =>
        match r with
        | node black a y b => balance2 l v (node red a y b)
        | node red (node black a y b) z c => node red (node black l v a) y (balance2 b z (setRed c))
        | r => node red l v r) =
    toList l ++ v :: toList r

tactic: split <;> simp
state_before: case h_2
α : Type u_1
l : RBNode α
v : α
r l✝ : RBNode α
x✝ : ∀ (a : RBNode α) (x : α) (b : RBNode α), l = node red a x b → False
⊢ toList
      (match r with
      | node black a y b => balance2 l v (node red a y b)
      | node red (node black a y b) z c => node red (node black l v a) y (balance2 b z (setRed c))
      | r => node red l v r) =
    toList l ++ v :: toList r
Theorem: Nat.sub_le_of_le_add
File: src/lean/Init/Data/Nat/Basic.lean

tactic: match le.dest h, Nat.le_total a b with
| _, Or.inl hle =>
  rw [Nat.sub_eq_zero_of_le hle]
  apply Nat.zero_le
| ⟨d, hd⟩, Or.inr hge =>
  apply @le.intro _ _ d
  have hd := Nat.sub_eq_of_eq_add hd
  rw [Nat.add_comm, ← Nat.add_sub_assoc hge, Nat.add_comm]
  exact hd
state_before: a b c : Nat
h : a ≤ c + b
⊢ a - b ≤ c

tactic: rw [Nat.sub_eq_zero_of_le hle]
state_before: a b c : Nat
h : a ≤ c + b
x✝ : Exists fun k => a + k = c + b
hle : a ≤ b
⊢ a - b ≤ c

tactic: apply Nat.zero_le
state_before: a b c : Nat
h : a ≤ c + b
x✝ : Exists fun k => a + k = c + b
hle : a ≤ b
⊢ 0 ≤ c

tactic: apply @le.intro _ _ d
state_before: a b c : Nat
h : a ≤ c + b
d : Nat
hd : a + d = c + b
hge : b ≤ a
⊢ a - b ≤ c

tactic: have hd := Nat.sub_eq_of_eq_add hd
state_before: a b c : Nat
h : a ≤ c + b
d : Nat
hd : a + d = c + b
hge : b ≤ a
⊢ a - b + d = c

tactic: rw [Nat.add_comm, ← Nat.add_sub_assoc hge, Nat.add_comm]
state_before: a b c : Nat
h : a ≤ c + b
d : Nat
hd✝ : a + d = c + b
hge : b ≤ a
hd : a + d - b = c
⊢ a - b + d = c

tactic: exact hd
state_before: a b c : Nat
h : a ≤ c + b
d : Nat
hd✝ : a + d = c + b
hge : b ≤ a
hd : a + d - b = c
⊢ a + d - b = c
Theorem: direction_affineSpan
File: Mathlib/LinearAlgebra/AffineSpace/AffineSubspace.lean

tactic: apply le_antisymm
state_before: k : Type u_3
V : Type u_2
P : Type u_1
inst✝³ : Ring k
inst✝² : AddCommGroup V
inst✝¹ : Module k V
inst✝ : AffineSpace V P
s : Set P
⊢ AffineSubspace.direction (affineSpan k s) = vectorSpan k s

tactic: refine' Submodule.span_le.2 _
state_before: case a
k : Type u_3
V : Type u_2
P : Type u_1
inst✝³ : Ring k
inst✝² : AddCommGroup V
inst✝¹ : Module k V
inst✝ : AffineSpace V P
s : Set P
⊢ AffineSubspace.direction (affineSpan k s) ≤ vectorSpan k s

tactic: rintro v ⟨p1, p3, ⟨p2, hp2, v1, hv1, hp1⟩, ⟨p4, hp4, v2, hv2, hp3⟩, rfl⟩
state_before: case a
k : Type u_3
V : Type u_2
P : Type u_1
inst✝³ : Ring k
inst✝² : AddCommGroup V
inst✝¹ : Module k V
inst✝ : AffineSpace V P
s : Set P
⊢ ↑(affineSpan k s) -ᵥ ↑(affineSpan k s) ⊆ ↑(vectorSpan k s)

tactic: simp only [SetLike.mem_coe]
state_before: case a.intro.intro.intro.intro.intro.intro.intro.intro.intro.intro.intro.intro
k : Type u_3
V : Type u_2
P : Type u_1
inst✝³ : Ring k
inst✝² : AddCommGroup V
inst✝¹ : Module k V
inst✝ : AffineSpace V P
s : Set P
p1 p3 p2 : P
hp2 : p2 ∈ s
v1 : V
hv1 : v1 ∈ vectorSpan k s
hp1 : p1 = v1 +ᵥ p2
p4 : P
hp4 : p4 ∈ s
v2 : V
hv2 : v2 ∈ vectorSpan k s
hp3 : p3 = v2 +ᵥ p4
⊢ (fun x x_1 => x -ᵥ x_1) p1 p3 ∈ ↑(vectorSpan k s)

tactic: rw [hp1, hp3, vsub_vadd_eq_vsub_sub, vadd_vsub_assoc]
state_before: case a.intro.intro.intro.intro.intro.intro.intro.intro.intro.intro.intro.intro
k : Type u_3
V : Type u_2
P : Type u_1
inst✝³ : Ring k
inst✝² : AddCommGroup V
inst✝¹ : Module k V
inst✝ : AffineSpace V P
s : Set P
p1 p3 p2 : P
hp2 : p2 ∈ s
v1 : V
hv1 : v1 ∈ vectorSpan k s
hp1 : p1 = v1 +ᵥ p2
p4 : P
hp4 : p4 ∈ s
v2 : V
hv2 : v2 ∈ vectorSpan k s
hp3 : p3 = v2 +ᵥ p4
⊢ p1 -ᵥ p3 ∈ vectorSpan k s

tactic: exact
  (vectorSpan k s).sub_mem ((vectorSpan k s).add_mem hv1 (vsub_mem_vectorSpan k hp2 hp4)) hv2
state_before: case a.intro.intro.intro.intro.intro.intro.intro.intro.intro.intro.intro.intro
k : Type u_3
V : Type u_2
P : Type u_1
inst✝³ : Ring k
inst✝² : AddCommGroup V
inst✝¹ : Module k V
inst✝ : AffineSpace V P
s : Set P
p1 p3 p2 : P
hp2 : p2 ∈ s
v1 : V
hv1 : v1 ∈ vectorSpan k s
hp1 : p1 = v1 +ᵥ p2
p4 : P
hp4 : p4 ∈ s
v2 : V
hv2 : v2 ∈ vectorSpan k s
hp3 : p3 = v2 +ᵥ p4
⊢ v1 + (p2 -ᵥ p4) - v2 ∈ vectorSpan k s

tactic: exact vectorSpan_mono k (subset_spanPoints k s)
state_before: case a
k : Type u_3
V : Type u_2
P : Type u_1
inst✝³ : Ring k
inst✝² : AddCommGroup V
inst✝¹ : Module k V
inst✝ : AffineSpace V P
s : Set P
⊢ vectorSpan k s ≤ AffineSubspace.direction (affineSpan k s)
Theorem: Nat.digits_add
File: Mathlib/Data/Nat/Digits.lean

tactic: rcases exists_eq_add_of_le' h with ⟨b, rfl : _ = _ + 2⟩
state_before: n b : ℕ
h : 1 < b
x y : ℕ
hxb : x < b
hxy : x ≠ 0 ∨ y ≠ 0
⊢ digits b (x + b * y) = x :: digits b y

tactic: cases y
state_before: case intro
n x y : ℕ
hxy : x ≠ 0 ∨ y ≠ 0
b : ℕ
h : 1 < b + 2
hxb : x < b + 2
⊢ digits (b + 2) (x + (b + 2) * y) = x :: digits (b + 2) y

tactic: dsimp [digits]
state_before: case intro.succ
n x b : ℕ
h : 1 < b + 2
hxb : x < b + 2
n✝ : ℕ
hxy : x ≠ 0 ∨ succ n✝ ≠ 0
⊢ digits (b + 2) (x + (b + 2) * succ n✝) = x :: digits (b + 2) (succ n✝)

tactic: rw [digitsAux_def]
state_before: case intro.succ
n x b : ℕ
h : 1 < b + 2
hxb : x < b + 2
n✝ : ℕ
hxy : x ≠ 0 ∨ succ n✝ ≠ 0
⊢ digitsAux (b + 0 + 2) (_ : 2 ≤ b + 0 + 2) (x + (b + 2) * succ n✝) =
    x :: digitsAux (b + 0 + 2) (_ : 2 ≤ b + 0 + 2) (succ n✝)

tactic: simp [hxb, hxy.resolve_right (absurd rfl)]
state_before: case intro.zero
n x b : ℕ
h : 1 < b + 2
hxb : x < b + 2
hxy : x ≠ 0 ∨ zero ≠ 0
⊢ digits (b + 2) (x + (b + 2) * zero) = x :: digits (b + 2) zero

tactic: congr
state_before: case intro.succ
n x b : ℕ
h : 1 < b + 2
hxb : x < b + 2
n✝ : ℕ
hxy : x ≠ 0 ∨ succ n✝ ≠ 0
⊢ (x + (b + 2) * succ n✝) % (b + 0 + 2) ::
      digitsAux (b + 0 + 2) (_ : 2 ≤ b + 0 + 2) ((x + (b + 2) * succ n✝) / (b + 0 + 2)) =
    x :: digitsAux (b + 0 + 2) (_ : 2 ≤ b + 0 + 2) (succ n✝)

tactic: simp [Nat.add_mod, mod_eq_of_lt hxb]
state_before: case intro.succ.e_head
n x b : ℕ
h : 1 < b + 2
hxb : x < b + 2
n✝ : ℕ
hxy : x ≠ 0 ∨ succ n✝ ≠ 0
⊢ (x + (b + 2) * succ n✝) % (b + 0 + 2) = x

tactic: simp [add_mul_div_left, div_eq_of_lt hxb]
state_before: case intro.succ.e_tail.e_a
n x b : ℕ
h : 1 < b + 2
hxb : x < b + 2
n✝ : ℕ
hxy : x ≠ 0 ∨ succ n✝ ≠ 0
⊢ (x + (b + 2) * succ n✝) / (b + 0 + 2) = succ n✝

tactic: apply Nat.succ_pos
state_before: case intro.succ.w
n x b : ℕ
h : 1 < b + 2
hxb : x < b + 2
n✝ : ℕ
hxy : x ≠ 0 ∨ succ n✝ ≠ 0
⊢ 0 < x + (b + 2) * succ n✝
Theorem: NormedAddGroupHom.norm_comp_le_of_le
File: Mathlib/Analysis/Normed/Group/Hom.lean

tactic: gcongr
state_before: V : Type ?u.464951
V₁ : Type u_3
V₂ : Type u_1
V₃ : Type u_2
inst✝³ : SeminormedAddCommGroup V
inst✝² : SeminormedAddCommGroup V₁
inst✝¹ : SeminormedAddCommGroup V₂
inst✝ : SeminormedAddCommGroup V₃
f g✝ : NormedAddGroupHom V₁ V₂
g : NormedAddGroupHom V₂ V₃
C₁ C₂ : ℝ
hg : ‖g‖ ≤ C₂
hf : ‖f‖ ≤ C₁
⊢ ‖g‖ * ‖f‖ ≤ C₂ * C₁

tactic: exact le_trans (norm_nonneg _) hg
state_before: case b0
V : Type ?u.464951
V₁ : Type u_3
V₂ : Type u_1
V₃ : Type u_2
inst✝³ : SeminormedAddCommGroup V
inst✝² : SeminormedAddCommGroup V₁
inst✝¹ : SeminormedAddCommGroup V₂
inst✝ : SeminormedAddCommGroup V₃
f g✝ : NormedAddGroupHom V₁ V₂
g : NormedAddGroupHom V₂ V₃
C₁ C₂ : ℝ
hg : ‖g‖ ≤ C₂
hf : ‖f‖ ≤ C₁
⊢ 0 ≤ C₂
Theorem: Filter.Tendsto.const_cpow
File: Mathlib/Analysis/SpecialFunctions/Pow/Continuity.lean

tactic: cases h with
| inl h => exact (continuousAt_const_cpow h).tendsto.comp hf
| inr h => exact (continuousAt_const_cpow' h).tendsto.comp hf
state_before: α : Type u_1
l : Filter α
f : α → ℂ
a b : ℂ
hf : Tendsto f l (𝓝 b)
h : a ≠ 0 ∨ b ≠ 0
⊢ Tendsto (fun x => a ^ f x) l (𝓝 (a ^ b))

tactic: exact (continuousAt_const_cpow h).tendsto.comp hf
state_before: case inl
α : Type u_1
l : Filter α
f : α → ℂ
a b : ℂ
hf : Tendsto f l (𝓝 b)
h : a ≠ 0
⊢ Tendsto (fun x => a ^ f x) l (𝓝 (a ^ b))

tactic: exact (continuousAt_const_cpow' h).tendsto.comp hf
state_before: case inr
α : Type u_1
l : Filter α
f : α → ℂ
a b : ℂ
hf : Tendsto f l (𝓝 b)
h : b ≠ 0
⊢ Tendsto (fun x => a ^ f x) l (𝓝 (a ^ b))
Theorem: Real.log_div_sqrt_antitoneOn
File: Mathlib/Analysis/SpecialFunctions/Log/Monotone.lean

tactic: simp_rw [sqrt_eq_rpow]
state_before: x y : ℝ
⊢ AntitoneOn (fun x => log x / sqrt x) {x | exp 2 ≤ x}

tactic: convert @log_div_self_rpow_antitoneOn (1 / 2) (by norm_num)
state_before: x y : ℝ
⊢ AntitoneOn (fun x => log x / x ^ (1 / 2)) {x | exp 2 ≤ x}

tactic: norm_num
state_before: case h.e'_6.h.e'_2.h.h.e'_3.h.e'_1
x y x✝ : ℝ
⊢ 2 = 1 / (1 / 2)

tactic: norm_num
state_before: x y : ℝ
⊢ 0 < 1 / 2
Theorem: Equiv.Perm.ofSubtype_subtypePerm
File: Mathlib/GroupTheory/Perm/Basic.lean

tactic: by_cases hx : p x
state_before: α : Type u
β : Type v
p : α → Prop
f✝ : Perm α
inst✝ : DecidablePred p
a : α
f : Perm α
h₁ : ∀ (x : α), p x ↔ p (↑f x)
h₂ : ∀ (x : α), ↑f x ≠ x → p x
x : α
⊢ ↑(↑ofSubtype (subtypePerm f h₁)) x = ↑f x

tactic: exact (subtypePerm f h₁).extendDomain_apply_subtype _ hx
state_before: case pos
α : Type u
β : Type v
p : α → Prop
f✝ : Perm α
inst✝ : DecidablePred p
a : α
f : Perm α
h₁ : ∀ (x : α), p x ↔ p (↑f x)
h₂ : ∀ (x : α), ↑f x ≠ x → p x
x : α
hx : p x
⊢ ↑(↑ofSubtype (subtypePerm f h₁)) x = ↑f x

tactic: rw [ofSubtype, MonoidHom.coe_mk]
state_before: case neg
α : Type u
β : Type v
p : α → Prop
f✝ : Perm α
inst✝ : DecidablePred p
a : α
f : Perm α
h₁ : ∀ (x : α), p x ↔ p (↑f x)
h₂ : ∀ (x : α), ↑f x ≠ x → p x
x : α
hx : ¬p x
⊢ ↑(↑ofSubtype (subtypePerm f h₁)) x = ↑f x

tactic: dsimp only [OneHom.coe_mk]
state_before: case neg
α : Type u
β : Type v
p : α → Prop
f✝ : Perm α
inst✝ : DecidablePred p
a : α
f : Perm α
h₁ : ∀ (x : α), p x ↔ p (↑f x)
h₂ : ∀ (x : α), ↑f x ≠ x → p x
x : α
hx : ¬p x
⊢ ↑(↑{ toFun := fun f => extendDomain f (Equiv.refl { x // p x }),
              map_one' := (_ : extendDomain 1 (Equiv.refl { x // p x }) = 1) }
          (subtypePerm f h₁))
      x =
    ↑f x

tactic: rw [Equiv.Perm.extendDomain_apply_not_subtype _ _ hx]
state_before: case neg
α : Type u
β : Type v
p : α → Prop
f✝ : Perm α
inst✝ : DecidablePred p
a : α
f : Perm α
h₁ : ∀ (x : α), p x ↔ p (↑f x)
h₂ : ∀ (x : α), ↑f x ≠ x → p x
x : α
hx : ¬p x
⊢ ↑(extendDomain (subtypePerm f h₁) (Equiv.refl { x // p x })) x = ↑f x

tactic: exact not_not.mp fun h => hx (h₂ x (Ne.symm h))
state_before: case neg
α : Type u
β : Type v
p : α → Prop
f✝ : Perm α
inst✝ : DecidablePred p
a : α
f : Perm α
h₁ : ∀ (x : α), p x ↔ p (↑f x)
h₂ : ∀ (x : α), ↑f x ≠ x → p x
x : α
hx : ¬p x
⊢ x = ↑f x
Theorem: Quiver.Path.cast_eq_iff_heq
File: Mathlib/Combinatorics/Quiver/Cast.lean

tactic: rw [Path.cast_eq_cast]
state_before: U : Type u_1
inst✝ : Quiver U
u v u' v' : U
hu : u = u'
hv : v = v'
p : Path u v
p' : Path u' v'
⊢ cast hu hv p = p' ↔ HEq p p'

tactic: exact _root_.cast_eq_iff_heq
state_before: U : Type u_1
inst✝ : Quiver U
u v u' v' : U
hu : u = u'
hv : v = v'
p : Path u v
p' : Path u' v'
⊢ _root_.cast (_ : Path u v = Path u' v') p = p' ↔ HEq p p'
Theorem: Ring.inverse_mul_cancel_left
File: Mathlib/Algebra/GroupWithZero/Units/Basic.lean

tactic: rw [← mul_assoc, inverse_mul_cancel x h, one_mul]
state_before: α : Type ?u.7902
M₀ : Type u_1
G₀ : Type ?u.7908
M₀' : Type ?u.7911
G₀' : Type ?u.7914
F : Type ?u.7917
F' : Type ?u.7920
inst✝ : MonoidWithZero M₀
x y : M₀
h : IsUnit x
⊢ inverse x * (x * y) = y
Theorem: Set.image2_eq_empty_iff
File: Mathlib/Data/Set/NAry.lean

tactic: rw [← not_nonempty_iff_eq_empty, image2_nonempty_iff, not_and_or]
state_before: α : Type u_2
α' : Type ?u.21222
β : Type u_3
β' : Type ?u.21228
γ : Type u_1
γ' : Type ?u.21234
δ : Type ?u.21237
δ' : Type ?u.21240
ε : Type ?u.21243
ε' : Type ?u.21246
ζ : Type ?u.21249
ζ' : Type ?u.21252
ν : Type ?u.21255
f f' : α → β → γ
g g' : α → β → γ → δ
s s' : Set α
t t' : Set β
u u' : Set γ
v : Set δ
a a' : α
b b' : β
c c' : γ
d d' : δ
⊢ image2 f s t = ∅ ↔ s = ∅ ∨ t = ∅

tactic: simp [not_nonempty_iff_eq_empty]
state_before: α : Type u_2
α' : Type ?u.21222
β : Type u_3
β' : Type ?u.21228
γ : Type u_1
γ' : Type ?u.21234
δ : Type ?u.21237
δ' : Type ?u.21240
ε : Type ?u.21243
ε' : Type ?u.21246
ζ : Type ?u.21249
ζ' : Type ?u.21252
ν : Type ?u.21255
f f' : α → β → γ
g g' : α → β → γ → δ
s s' : Set α
t t' : Set β
u u' : Set γ
v : Set δ
a a' : α
b b' : β
c c' : γ
d d' : δ
⊢ ¬Set.Nonempty s ∨ ¬Set.Nonempty t ↔ s = ∅ ∨ t = ∅
Theorem: SimpleGraph.cliqueFree_of_card_lt
File: Mathlib/Combinatorics/SimpleGraph/Clique.lean

tactic: by_contra h
state_before: α : Type u_1
G H : SimpleGraph α
m n : ℕ
s : Finset α
inst✝ : Fintype α
hc : Fintype.card α < n
⊢ CliqueFree G n

tactic: refine' Nat.lt_le_antisymm hc _
state_before: α : Type u_1
G H : SimpleGraph α
m n : ℕ
s : Finset α
inst✝ : Fintype α
hc : Fintype.card α < n
h : ¬CliqueFree G n
⊢ False

tactic: rw [cliqueFree_iff, not_isEmpty_iff] at h
state_before: α : Type u_1
G H : SimpleGraph α
m n : ℕ
s : Finset α
inst✝ : Fintype α
hc : Fintype.card α < n
h : ¬CliqueFree G n
⊢ n ≤ Fintype.card α

tactic: simpa only [Fintype.card_fin] using Fintype.card_le_of_embedding h.some.toEmbedding
state_before: α : Type u_1
G H : SimpleGraph α
m n : ℕ
s : Finset α
inst✝ : Fintype α
hc : Fintype.card α < n
h : Nonempty (⊤ ↪g G)
⊢ n ≤ Fintype.card α
Theorem: Quot.subsingleton_iff
File: Mathlib/Data/Setoid/Basic.lean

tactic: simp only [_root_.subsingleton_iff, _root_.eq_top_iff, Pi.le_def, Pi.top_apply, forall_const]
state_before: α : Type u_1
β : Type ?u.23424
r : α → α → Prop
⊢ Subsingleton (Quot r) ↔ EqvGen r = ⊤

tactic: refine' (surjective_quot_mk _).forall.trans (forall_congr' fun a => _)
state_before: α : Type u_1
β : Type ?u.23424
r : α → α → Prop
⊢ (∀ (x y : Quot r), x = y) ↔ ∀ (i i_1 : α), ⊤ ≤ EqvGen r i i_1

tactic: refine' (surjective_quot_mk _).forall.trans (forall_congr' fun b => _)
state_before: α : Type u_1
β : Type ?u.23424
r : α → α → Prop
a : α
⊢ (∀ (y : Quot r), mk r a = y) ↔ ∀ (i : α), ⊤ ≤ EqvGen r a i

tactic: rw [Quot.eq]
state_before: α : Type u_1
β : Type ?u.23424
r : α → α → Prop
a b : α
⊢ mk r a = mk r b ↔ ⊤ ≤ EqvGen r a b

tactic: simp only [forall_const, le_Prop_eq, OrderTop.toTop, Pi.orderTop, Pi.top_apply,
           Prop.top_eq_true, true_implies]
state_before: α : Type u_1
β : Type ?u.23424
r : α → α → Prop
a b : α
⊢ EqvGen r a b ↔ ⊤ ≤ EqvGen r a b
Theorem: Int.negOfNat_mul_negSucc
File: Std/Data/Int/Lemmas.lean

tactic: rw [Int.mul_comm, negSucc_mul_negOfNat, Nat.mul_comm]
state_before: m n : Nat
⊢ negOfNat n * -[m+1] = ofNat (n * succ m)
Theorem: Dfinsupp.neLocus_sub_left
File: Mathlib/Data/Dfinsupp/NeLocus.lean

tactic: simp only [sub_eq_add_neg, @neLocus_add_left α N _ _ _, neLocus_neg_neg]
state_before: α : Type u_1
N : α → Type u_2
inst✝² : DecidableEq α
inst✝¹ : (a : α) → DecidableEq (N a)
inst✝ : (a : α) → AddGroup (N a)
f f₁ f₂ g g₁ g₂ : Π₀ (a : α), N a
⊢ neLocus (f - g₁) (f - g₂) = neLocus g₁ g₂
Theorem: Submodule.comap_smul'
File: Mathlib/LinearAlgebra/Basic.lean

tactic: classical by_cases h : a = 0 <;> simp [h, comap_smul]
state_before: R : Type ?u.964606
R₁ : Type ?u.964609
R₂ : Type ?u.964612
R₃ : Type ?u.964615
R₄ : Type ?u.964618
S : Type ?u.964621
K : Type u_1
K₂ : Type ?u.964627
M : Type ?u.964630
M' : Type ?u.964633
M₁ : Type ?u.964636
M₂ : Type ?u.964639
M₃ : Type ?u.964642
M₄ : Type ?u.964645
N : Type ?u.964648
N₂ : Type ?u.964651
ι : Type ?u.964654
V : Type u_2
V₂ : Type u_3
inst✝⁴ : Semifield K
inst✝³ : AddCommMonoid V
inst✝² : Module K V
inst✝¹ : AddCommMonoid V₂
inst✝ : Module K V₂
f : V →ₗ[K] V₂
p : Submodule K V₂
a : K
⊢ comap (a • f) p = ⨅ (_ : a ≠ 0), comap f p

tactic: by_cases h : a = 0 <;> simp [h, comap_smul]
state_before: R : Type ?u.964606
R₁ : Type ?u.964609
R₂ : Type ?u.964612
R₃ : Type ?u.964615
R₄ : Type ?u.964618
S : Type ?u.964621
K : Type u_1
K₂ : Type ?u.964627
M : Type ?u.964630
M' : Type ?u.964633
M₁ : Type ?u.964636
M₂ : Type ?u.964639
M₃ : Type ?u.964642
M₄ : Type ?u.964645
N : Type ?u.964648
N₂ : Type ?u.964651
ι : Type ?u.964654
V : Type u_2
V₂ : Type u_3
inst✝⁴ : Semifield K
inst✝³ : AddCommMonoid V
inst✝² : Module K V
inst✝¹ : AddCommMonoid V₂
inst✝ : Module K V₂
f : V →ₗ[K] V₂
p : Submodule K V₂
a : K
⊢ comap (a • f) p = ⨅ (_ : a ≠ 0), comap f p