tasksource/leandojo huggingface dataset:
Theorem: LinearMap.IsRefl.nondegenerate_of_separatingRight
File: Mathlib/LinearAlgebra/SesquilinearForm.lean

tactic: refine' ⟨_, hB'⟩
state_before: R : Type u_1
R₁ : Type ?u.576918
R₂ : Type ?u.576921
R₃ : Type ?u.576924
M : Type u_2
M₁ : Type ?u.576930
M₂ : Type ?u.576933
Mₗ₁ : Type ?u.576936
Mₗ₁' : Type ?u.576939
Mₗ₂ : Type ?u.576942
Mₗ₂' : Type ?u.576945
K : Type ?u.576948
K₁ : Type ?u.576951
K₂ : Type ?u.576954
V : Type ?u.576957
V₁ : Type ?u.576960
V₂ : Type ?u.576963
n : Type ?u.576966
inst✝² : CommRing R
inst✝¹ : AddCommGroup M
inst✝ : Module R M
I I' : R →+* R
B : M →ₗ[R] M →ₗ[R] R
hB : IsRefl B
hB' : SeparatingRight B
⊢ Nondegenerate B

tactic: rw [separatingLeft_iff_ker_eq_bot, hB.ker_eq_bot_iff_ker_flip_eq_bot.mpr]
state_before: R : Type u_1
R₁ : Type ?u.576918
R₂ : Type ?u.576921
R₃ : Type ?u.576924
M : Type u_2
M₁ : Type ?u.576930
M₂ : Type ?u.576933
Mₗ₁ : Type ?u.576936
Mₗ₁' : Type ?u.576939
Mₗ₂ : Type ?u.576942
Mₗ₂' : Type ?u.576945
K : Type ?u.576948
K₁ : Type ?u.576951
K₂ : Type ?u.576954
V : Type ?u.576957
V₁ : Type ?u.576960
V₂ : Type ?u.576963
n : Type ?u.576966
inst✝² : CommRing R
inst✝¹ : AddCommGroup M
inst✝ : Module R M
I I' : R →+* R
B : M →ₗ[R] M →ₗ[R] R
hB : IsRefl B
hB' : SeparatingRight B
⊢ SeparatingLeft B

tactic: rwa [← separatingRight_iff_flip_ker_eq_bot]
state_before: R : Type u_1
R₁ : Type ?u.576918
R₂ : Type ?u.576921
R₃ : Type ?u.576924
M : Type u_2
M₁ : Type ?u.576930
M₂ : Type ?u.576933
Mₗ₁ : Type ?u.576936
Mₗ₁' : Type ?u.576939
Mₗ₂ : Type ?u.576942
Mₗ₂' : Type ?u.576945
K : Type ?u.576948
K₁ : Type ?u.576951
K₂ : Type ?u.576954
V : Type ?u.576957
V₁ : Type ?u.576960
V₂ : Type ?u.576963
n : Type ?u.576966
inst✝² : CommRing R
inst✝¹ : AddCommGroup M
inst✝ : Module R M
I I' : R →+* R
B : M →ₗ[R] M →ₗ[R] R
hB : IsRefl B
hB' : SeparatingRight B
⊢ ker (flip B) = ⊥
Theorem: Nat.clog_eq_one
File: Mathlib/Data/Nat/Log.lean

tactic: rw [clog_of_two_le (hn.trans h) hn, clog_of_right_le_one]
state_before: b n : ℕ
hn : 2 ≤ n
h : n ≤ b
⊢ clog b n = 1

tactic: have n_pos : 0 < n := (zero_lt_two' ℕ).trans_le hn
state_before: case hn
b n : ℕ
hn : 2 ≤ n
h : n ≤ b
⊢ (n + b - 1) / b ≤ 1

tactic: rw [← lt_succ_iff, Nat.div_lt_iff_lt_mul (n_pos.trans_le h), ← succ_le_iff, ← pred_eq_sub_one,
  succ_pred_eq_of_pos (add_pos n_pos (n_pos.trans_le h)), succ_mul, one_mul]
state_before: case hn
b n : ℕ
hn : 2 ≤ n
h : n ≤ b
n_pos : 0 < n
⊢ (n + b - 1) / b ≤ 1

tactic: exact add_le_add_right h _
state_before: case hn
b n : ℕ
hn : 2 ≤ n
h : n ≤ b
n_pos : 0 < n
⊢ n + b ≤ b + b
Theorem: ZFSet.choice_mem
File: Mathlib/SetTheory/ZFC/Basic.lean

tactic: delta choice
state_before: x : ZFSet
h : ¬∅ ∈ x
y : ZFSet
yx : y ∈ x
⊢ ↑(choice x) ′ ↑y ∈ ↑y

tactic: rw [@map_fval _ (Classical.AllDefinable _) x y yx, Class.coe_mem, Class.coe_apply]
state_before: x : ZFSet
h : ¬∅ ∈ x
y : ZFSet
yx : y ∈ x
⊢ ↑(map (fun y => Classical.epsilon fun z => z ∈ y) x) ′ ↑y ∈ ↑y

tactic: exact choice_mem_aux x h y yx
state_before: x : ZFSet
h : ¬∅ ∈ x
y : ZFSet
yx : y ∈ x
⊢ (Classical.epsilon fun z => z ∈ y) ∈ y
Theorem: Submodule.snd_map_fst
File: Mathlib/LinearAlgebra/Prod.lean

tactic: rw [eq_bot_iff]
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.358968
M₆ : Type ?u.358971
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₂
⊢ map (LinearMap.fst R M M₂) (snd R M M₂) = ⊥

tactic: intro x
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.358968
M₆ : Type ?u.358971
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₂
⊢ map (LinearMap.fst R M M₂) (snd R M M₂) ≤ ⊥

tactic: simp only [snd, comap_bot, mem_map, mem_ker, fst_apply, eq_comm, Prod.exists, exists_eq_left,
  exists_const, mem_bot, imp_self]
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.358968
M₆ : Type ?u.358971
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₂
x : M
⊢ x ∈ map (LinearMap.fst R M M₂) (snd R M M₂) → x ∈ ⊥
Theorem: DoubleQuot.quotQuotEquivQuotOfLE_symm_comp_mk
File: Mathlib/RingTheory/Ideal/QuotientOperations.lean

tactic: ext
state_before: R : Type u
inst✝ : CommRing R
I J : Ideal R
h : I ≤ J
⊢ RingHom.comp (↑(RingEquiv.symm (quotQuotEquivQuotOfLE h))) (Ideal.Quotient.mk J) = quotQuotMk I J

tactic: rfl
state_before: case a
R : Type u
inst✝ : CommRing R
I J : Ideal R
h : I ≤ J
x✝ : R
⊢ ↑(RingHom.comp (↑(RingEquiv.symm (quotQuotEquivQuotOfLE h))) (Ideal.Quotient.mk J)) x✝ = ↑(quotQuotMk I J) x✝
Theorem: Finset.measurable_range_sup'
File: Mathlib/MeasureTheory/Lattice.lean

tactic: simp_rw [← Nat.lt_succ_iff] at hf
state_before: M : Type ?u.1408591
inst✝³ : MeasurableSpace M
α : Type u_2
m : MeasurableSpace α
μ : MeasureTheory.Measure α
f✝ g : α → M
δ : Type u_1
inst✝² : MeasurableSpace δ
inst✝¹ : SemilatticeSup α
inst✝ : MeasurableSup₂ α
f : ℕ → δ → α
n : ℕ
hf : ∀ (k : ℕ), k ≤ n → Measurable (f k)
⊢ Measurable (sup' (range (n + 1)) (_ : Finset.Nonempty (range (n + 1))) f)

tactic: refine' Finset.measurable_sup' _ _
state_before: M : Type ?u.1408591
inst✝³ : MeasurableSpace M
α : Type u_2
m : MeasurableSpace α
μ : MeasureTheory.Measure α
f✝ g : α → M
δ : Type u_1
inst✝² : MeasurableSpace δ
inst✝¹ : SemilatticeSup α
inst✝ : MeasurableSup₂ α
f : ℕ → δ → α
n : ℕ
hf : ∀ (k : ℕ), k < Nat.succ n → Measurable (f k)
⊢ Measurable (sup' (range (n + 1)) (_ : Finset.Nonempty (range (n + 1))) f)

tactic: simpa [Finset.mem_range]
state_before: M : Type ?u.1408591
inst✝³ : MeasurableSpace M
α : Type u_2
m : MeasurableSpace α
μ : MeasureTheory.Measure α
f✝ g : α → M
δ : Type u_1
inst✝² : MeasurableSpace δ
inst✝¹ : SemilatticeSup α
inst✝ : MeasurableSup₂ α
f : ℕ → δ → α
n : ℕ
hf : ∀ (k : ℕ), k < Nat.succ n → Measurable (f k)
⊢ ∀ (n_1 : ℕ), n_1 ∈ range (n + 1) → Measurable (f n_1)
Theorem: Ordinal.le_sub_of_le
File: Mathlib/SetTheory/Ordinal/Arithmetic.lean

tactic: rw [← add_le_add_iff_left b, Ordinal.add_sub_cancel_of_le h]
state_before: α : Type ?u.130352
β : Type ?u.130355
γ : Type ?u.130358
r : α → α → Prop
s : β → β → Prop
t : γ → γ → Prop
a b c : Ordinal
h : b ≤ a
⊢ c ≤ a - b ↔ b + c ≤ a
Theorem: CategoryTheory.Abelian.exact_iff'
File: Mathlib/CategoryTheory/Abelian/Exact.lean

tactic: constructor
state_before: C : Type u₁
inst✝¹ : Category C
inst✝ : Abelian C
X Y Z : C
f : X ⟶ Y
g : Y ⟶ Z
cg : KernelFork g
hg : IsLimit cg
cf : CokernelCofork f
hf : IsColimit cf
⊢ Exact f g ↔ f ≫ g = 0 ∧ Fork.ι cg ≫ Cofork.π cf = 0

tactic: intro h
state_before: case mp
C : Type u₁
inst✝¹ : Category C
inst✝ : Abelian C
X Y Z : C
f : X ⟶ Y
g : Y ⟶ Z
cg : KernelFork g
hg : IsLimit cg
cf : CokernelCofork f
hf : IsColimit cf
⊢ Exact f g → f ≫ g = 0 ∧ Fork.ι cg ≫ Cofork.π cf = 0

tactic: exact ⟨h.1, fork_ι_comp_cofork_π f g h cg cf⟩
state_before: case mp
C : Type u₁
inst✝¹ : Category C
inst✝ : Abelian C
X Y Z : C
f : X ⟶ Y
g : Y ⟶ Z
cg : KernelFork g
hg : IsLimit cg
cf : CokernelCofork f
hf : IsColimit cf
h : Exact f g
⊢ f ≫ g = 0 ∧ Fork.ι cg ≫ Cofork.π cf = 0

tactic: rw [exact_iff]
state_before: case mpr
C : Type u₁
inst✝¹ : Category C
inst✝ : Abelian C
X Y Z : C
f : X ⟶ Y
g : Y ⟶ Z
cg : KernelFork g
hg : IsLimit cg
cf : CokernelCofork f
hf : IsColimit cf
⊢ f ≫ g = 0 ∧ Fork.ι cg ≫ Cofork.π cf = 0 → Exact f g

tactic: refine fun h => ⟨h.1, ?_⟩
state_before: case mpr
C : Type u₁
inst✝¹ : Category C
inst✝ : Abelian C
X Y Z : C
f : X ⟶ Y
g : Y ⟶ Z
cg : KernelFork g
hg : IsLimit cg
cf : CokernelCofork f
hf : IsColimit cf
⊢ f ≫ g = 0 ∧ Fork.ι cg ≫ Cofork.π cf = 0 → f ≫ g = 0 ∧ kernel.ι g ≫ cokernel.π f = 0

tactic: apply zero_of_epi_comp (IsLimit.conePointUniqueUpToIso hg (limit.isLimit _)).hom
state_before: case mpr
C : Type u₁
inst✝¹ : Category C
inst✝ : Abelian C
X Y Z : C
f : X ⟶ Y
g : Y ⟶ Z
cg : KernelFork g
hg : IsLimit cg
cf : CokernelCofork f
hf : IsColimit cf
h : f ≫ g = 0 ∧ Fork.ι cg ≫ Cofork.π cf = 0
⊢ kernel.ι g ≫ cokernel.π f = 0

tactic: apply zero_of_comp_mono (IsColimit.coconePointUniqueUpToIso (colimit.isColimit _) hf).hom
state_before: case mpr
C : Type u₁
inst✝¹ : Category C
inst✝ : Abelian C
X Y Z : C
f : X ⟶ Y
g : Y ⟶ Z
cg : KernelFork g
hg : IsLimit cg
cf : CokernelCofork f
hf : IsColimit cf
h : f ≫ g = 0 ∧ Fork.ι cg ≫ Cofork.π cf = 0
⊢ (IsLimit.conePointUniqueUpToIso hg (limit.isLimit (parallelPair g 0))).hom ≫ kernel.ι g ≫ cokernel.π f = 0

tactic: simp [h.2]
state_before: case mpr
C : Type u₁
inst✝¹ : Category C
inst✝ : Abelian C
X Y Z : C
f : X ⟶ Y
g : Y ⟶ Z
cg : KernelFork g
hg : IsLimit cg
cf : CokernelCofork f
hf : IsColimit cf
h : f ≫ g = 0 ∧ Fork.ι cg ≫ Cofork.π cf = 0
⊢ ((IsLimit.conePointUniqueUpToIso hg (limit.isLimit (parallelPair g 0))).hom ≫ kernel.ι g ≫ cokernel.π f) ≫
      (IsColimit.coconePointUniqueUpToIso (colimit.isColimit (parallelPair f 0)) hf).hom =
    0
Theorem: List.forall₂_take
File: Mathlib/Data/List/Forall2.lean

tactic: simp only [Forall₂.nil, take]
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.128087
δ : Type ?u.128090
R S : α → β → Prop
P : γ → δ → Prop
Rₐ : α → α → Prop
x✝² : List α
x✝¹ : List β
x✝ : Forall₂ R x✝² x✝¹
⊢ Forall₂ R (take 0 x✝²) (take 0 x✝¹)

tactic: simp only [Forall₂.nil, take]
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.128087
δ : Type ?u.128090
R S : α → β → Prop
P : γ → δ → Prop
Rₐ : α → α → Prop
n✝ : ℕ
⊢ Forall₂ R (take (n✝ + 1) []) (take (n✝ + 1) [])

tactic: simp [And.intro h₁ h₂, forall₂_take n]
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.128087
δ : Type ?u.128090
R S : α → β → Prop
P : γ → δ → Prop
Rₐ : α → α → Prop
n : ℕ
a✝ : α
b✝ : β
l₁✝ : List α
l₂✝ : List β
h₁ : R a✝ b✝
h₂ : Forall₂ R l₁✝ l₂✝
⊢ Forall₂ R (take (n + 1) (a✝ :: l₁✝)) (take (n + 1) (b✝ :: l₂✝))
Theorem: HasDerivWithinAt.inner
File: Mathlib/Analysis/InnerProductSpace/Calculus.lean

tactic: simpa using (hf.hasFDerivWithinAt.inner 𝕜 hg.hasFDerivWithinAt).hasDerivWithinAt
state_before: 𝕜 : Type u_2
E : Type u_1
F : Type ?u.53238
inst✝⁷ : IsROrC 𝕜
inst✝⁶ : NormedAddCommGroup E
inst✝⁵ : InnerProductSpace 𝕜 E
inst✝⁴ : NormedAddCommGroup F
inst✝³ : InnerProductSpace ℝ F
inst✝² : NormedSpace ℝ E
G : Type ?u.53367
inst✝¹ : NormedAddCommGroup G
inst✝ : NormedSpace ℝ G
f✝ g✝ : G → E
f'✝ g'✝ : G →L[ℝ] E
s✝ : Set G
x✝ : G
n : ℕ∞
f g : ℝ → E
f' g' : E
s : Set ℝ
x : ℝ
hf : HasDerivWithinAt f f' s x
hg : HasDerivWithinAt g g' s x
⊢ HasDerivWithinAt (fun t => Inner.inner (f t) (g t)) (Inner.inner (f x) g' + Inner.inner f' (g x)) s x
Theorem: Finset.le_sum_card_inter
File: Mathlib/Algebra/BigOperators/Order.lean

tactic: apply (s.card_nsmul_le_sum _ _ h).trans
state_before: ι : Type ?u.106343
α : Type u_1
β : Type ?u.106349
M : Type ?u.106352
N : Type ?u.106355
G : Type ?u.106358
k : Type ?u.106361
R : Type ?u.106364
inst✝ : DecidableEq α
s : Finset α
B : Finset (Finset α)
n : ℕ
h : ∀ (a : α), a ∈ s → n ≤ card (filter ((fun x x_1 => x ∈ x_1) a) B)
⊢ card s * n ≤ ∑ t in B, card (s ∩ t)

tactic: simp_rw [← filter_mem_eq_inter, card_eq_sum_ones, sum_filter]
state_before: ι : Type ?u.106343
α : Type u_1
β : Type ?u.106349
M : Type ?u.106352
N : Type ?u.106355
G : Type ?u.106358
k : Type ?u.106361
R : Type ?u.106364
inst✝ : DecidableEq α
s : Finset α
B : Finset (Finset α)
n : ℕ
h : ∀ (a : α), a ∈ s → n ≤ card (filter ((fun x x_1 => x ∈ x_1) a) B)
⊢ ∑ x in s, card (filter ((fun x x_1 => x ∈ x_1) x) B) ≤ ∑ t in B, card (s ∩ t)

tactic: exact sum_comm.le
state_before: ι : Type ?u.106343
α : Type u_1
β : Type ?u.106349
M : Type ?u.106352
N : Type ?u.106355
G : Type ?u.106358
k : Type ?u.106361
R : Type ?u.106364
inst✝ : DecidableEq α
s : Finset α
B : Finset (Finset α)
n : ℕ
h : ∀ (a : α), a ∈ s → n ≤ card (filter ((fun x x_1 => x ∈ x_1) a) B)
⊢ (∑ x in s, ∑ a in B, if x ∈ a then 1 else 0) ≤ ∑ x in B, ∑ a in s, if a ∈ x then 1 else 0
Theorem: MonoidHom.ext_int
File: Mathlib/Data/Int/Cast/Lemmas.lean

tactic: ext (x | x)
state_before: F : Type ?u.48754
ι : Type ?u.48757
α : Type ?u.48760
β : Type ?u.48763
M : Type u_1
inst✝ : Monoid M
f g : ℤ →* M
h_neg_one : ↑f (-1) = ↑g (-1)
h_nat : comp f ↑ofNatHom = comp g ↑ofNatHom
⊢ f = g

tactic: exact (FunLike.congr_fun h_nat x : _)
state_before: case h.ofNat
F : Type ?u.48754
ι : Type ?u.48757
α : Type ?u.48760
β : Type ?u.48763
M : Type u_1
inst✝ : Monoid M
f g : ℤ →* M
h_neg_one : ↑f (-1) = ↑g (-1)
h_nat : comp f ↑ofNatHom = comp g ↑ofNatHom
x : ℕ
⊢ ↑f (ofNat x) = ↑g (ofNat x)

tactic: rw [Int.negSucc_eq, ← neg_one_mul, f.map_mul, g.map_mul]
state_before: case h.negSucc
F : Type ?u.48754
ι : Type ?u.48757
α : Type ?u.48760
β : Type ?u.48763
M : Type u_1
inst✝ : Monoid M
f g : ℤ →* M
h_neg_one : ↑f (-1) = ↑g (-1)
h_nat : comp f ↑ofNatHom = comp g ↑ofNatHom
x : ℕ
⊢ ↑f -[x+1] = ↑g -[x+1]

tactic: congr 1
state_before: case h.negSucc
F : Type ?u.48754
ι : Type ?u.48757
α : Type ?u.48760
β : Type ?u.48763
M : Type u_1
inst✝ : Monoid M
f g : ℤ →* M
h_neg_one : ↑f (-1) = ↑g (-1)
h_nat : comp f ↑ofNatHom = comp g ↑ofNatHom
x : ℕ
⊢ ↑f (-1) * ↑f (↑x + 1) = ↑g (-1) * ↑g (↑x + 1)

tactic: exact_mod_cast (FunLike.congr_fun h_nat (x + 1) : _)
state_before: case h.negSucc.e_a
F : Type ?u.48754
ι : Type ?u.48757
α : Type ?u.48760
β : Type ?u.48763
M : Type u_1
inst✝ : Monoid M
f g : ℤ →* M
h_neg_one : ↑f (-1) = ↑g (-1)
h_nat : comp f ↑ofNatHom = comp g ↑ofNatHom
x : ℕ
⊢ ↑f (↑x + 1) = ↑g (↑x + 1)
Theorem: Stream'.WSeq.map_comp
File: Mathlib/Data/Seq/WSeq.lean

tactic: dsimp [map]
state_before: α : Type u
β : Type v
γ : Type w
f : α → β
g : β → γ
s : WSeq α
⊢ map (g ∘ f) s = map g (map f s)

tactic: rw [← Seq.map_comp]
state_before: α : Type u
β : Type v
γ : Type w
f : α → β
g : β → γ
s : WSeq α
⊢ Seq.map (Option.map (g ∘ f)) s = Seq.map (Option.map g) (Seq.map (Option.map f) s)

tactic: apply congr_fun
state_before: α : Type u
β : Type v
γ : Type w
f : α → β
g : β → γ
s : WSeq α
⊢ Seq.map (Option.map (g ∘ f)) s = Seq.map (Option.map g ∘ Option.map f) s

tactic: apply congr_arg
state_before: case h
α : Type u
β : Type v
γ : Type w
f : α → β
g : β → γ
s : WSeq α
⊢ Seq.map (Option.map (g ∘ f)) = fun s => Seq.map (Option.map g ∘ Option.map f) s

tactic: ext ⟨⟩ <;> rfl
state_before: case h.h
α : Type u
β : Type v
γ : Type w
f : α → β
g : β → γ
s : WSeq α
⊢ Option.map (g ∘ f) = Option.map g ∘ Option.map f
Theorem: Valuation.IsEquiv.ne_zero
File: Mathlib/RingTheory/Valuation/Basic.lean

tactic: have : v₁ r ≠ v₁ 0 ↔ v₂ r ≠ v₂ 0 := not_congr h.val_eq
state_before: K : Type ?u.3011502
F : Type ?u.3011505
R : Type u_1
inst✝⁴ : DivisionRing K
Γ₀ : Type u_2
Γ'₀ : Type u_3
Γ''₀ : Type ?u.3011520
inst✝³ : LinearOrderedCommMonoidWithZero Γ''₀
inst✝² : Ring R
inst✝¹ : LinearOrderedCommMonoidWithZero Γ₀
inst✝ : LinearOrderedCommMonoidWithZero Γ'₀
v v₁ : Valuation R Γ₀
v₂ : Valuation R Γ'₀
v₃ : Valuation R Γ''₀
h : IsEquiv v₁ v₂
r : R
⊢ ↑v₁ r ≠ 0 ↔ ↑v₂ r ≠ 0

tactic: rwa [v₁.map_zero, v₂.map_zero] at this
state_before: K : Type ?u.3011502
F : Type ?u.3011505
R : Type u_1
inst✝⁴ : DivisionRing K
Γ₀ : Type u_2
Γ'₀ : Type u_3
Γ''₀ : Type ?u.3011520
inst✝³ : LinearOrderedCommMonoidWithZero Γ''₀
inst✝² : Ring R
inst✝¹ : LinearOrderedCommMonoidWithZero Γ₀
inst✝ : LinearOrderedCommMonoidWithZero Γ'₀
v v₁ : Valuation R Γ₀
v₂ : Valuation R Γ'₀
v₃ : Valuation R Γ''₀
h : IsEquiv v₁ v₂
r : R
this : ↑v₁ r ≠ ↑v₁ 0 ↔ ↑v₂ r ≠ ↑v₂ 0
⊢ ↑v₁ r ≠ 0 ↔ ↑v₂ r ≠ 0
Theorem: LinearIndependent.image_subtype
File: Mathlib/LinearAlgebra/LinearIndependent.lean

tactic: rw [← @Subtype.range_coe _ s] at hf_inj
state_before: ι : Type u'
ι' : Type ?u.632452
R : Type u_2
K : Type ?u.632458
M : Type u_1
M' : Type u_3
M'' : Type ?u.632467
V : Type u
V' : Type ?u.632472
v : ι → M
inst✝⁶ : Ring R
inst✝⁵ : AddCommGroup M
inst✝⁴ : AddCommGroup M'
inst✝³ : AddCommGroup M''
inst✝² : Module R M
inst✝¹ : Module R M'
inst✝ : Module R M''
a b : R
x y : M
s : Set M
f : M →ₗ[R] M'
hs : LinearIndependent R fun x => ↑x
hf_inj : Disjoint (span R s) (ker f)
⊢ LinearIndependent R fun x => ↑x

tactic: refine' (hs.map hf_inj).to_subtype_range' _
state_before: ι : Type u'
ι' : Type ?u.632452
R : Type u_2
K : Type ?u.632458
M : Type u_1
M' : Type u_3
M'' : Type ?u.632467
V : Type u
V' : Type ?u.632472
v : ι → M
inst✝⁶ : Ring R
inst✝⁵ : AddCommGroup M
inst✝⁴ : AddCommGroup M'
inst✝³ : AddCommGroup M''
inst✝² : Module R M
inst✝¹ : Module R M'
inst✝ : Module R M''
a b : R
x y : M
s : Set M
f : M →ₗ[R] M'
hs : LinearIndependent R fun x => ↑x
hf_inj : Disjoint (span R (Set.range Subtype.val)) (ker f)
⊢ LinearIndependent R fun x => ↑x

tactic: simp [Set.range_comp f]
state_before: ι : Type u'
ι' : Type ?u.632452
R : Type u_2
K : Type ?u.632458
M : Type u_1
M' : Type u_3
M'' : Type ?u.632467
V : Type u
V' : Type ?u.632472
v : ι → M
inst✝⁶ : Ring R
inst✝⁵ : AddCommGroup M
inst✝⁴ : AddCommGroup M'
inst✝³ : AddCommGroup M''
inst✝² : Module R M
inst✝¹ : Module R M'
inst✝ : Module R M''
a b : R
x y : M
s : Set M
f : M →ₗ[R] M'
hs : LinearIndependent R fun x => ↑x
hf_inj : Disjoint (span R (Set.range Subtype.val)) (ker f)
⊢ Set.range (↑f ∘ fun x => ↑x) = ↑f '' s
Theorem: Nat.zmodeq_ofDigits_digits
File: Mathlib/Data/Nat/Digits.lean

tactic: rw [coe_int_ofDigits]
state_before: n✝ b b' : ℕ
c : ℤ
h : ↑b' ≡ c [ZMOD ↑b]
n : ℕ
⊢ ↑(ofDigits b' (digits b' n)) ≡ ofDigits c (digits b' n) [ZMOD ↑b]

tactic: apply ofDigits_zmodeq' _ _ _ h
state_before: n✝ b b' : ℕ
c : ℤ
h : ↑b' ≡ c [ZMOD ↑b]
n : ℕ
⊢ ofDigits (↑b') (digits b' n) ≡ ofDigits c (digits b' n) [ZMOD ↑b]
Theorem: Real.arcsin_le_iff_le_sin
File: Mathlib/Analysis/SpecialFunctions/Trigonometric/Inverse.lean

tactic: rw [← arcsin_sin' hy, strictMonoOn_arcsin.le_iff_le hx (sin_mem_Icc _), arcsin_sin' hy]
state_before: x y : ℝ
hx : x ∈ Icc (-1) 1
hy : y ∈ Icc (-(π / 2)) (π / 2)
⊢ arcsin x ≤ y ↔ x ≤ sin y
Theorem: HasDerivWithinAt.rpow
File: Mathlib/Analysis/SpecialFunctions/Pow/Deriv.lean

tactic: convert (hf.hasFDerivWithinAt.rpow hg.hasFDerivWithinAt h).hasDerivWithinAt using 1
state_before: f g : ℝ → ℝ
f' g' x y p : ℝ
s : Set ℝ
hf : HasDerivWithinAt f f' s x
hg : HasDerivWithinAt g g' s x
h : 0 < f x
⊢ HasDerivWithinAt (fun x => f x ^ g x) (f' * g x * f x ^ (g x - 1) + g' * f x ^ g x * Real.log (f x)) s x

tactic: dsimp
state_before: case h.e'_7
f g : ℝ → ℝ
f' g' x y p : ℝ
s : Set ℝ
hf : HasDerivWithinAt f f' s x
hg : HasDerivWithinAt g g' s x
h : 0 < f x
⊢ f' * g x * f x ^ (g x - 1) + g' * f x ^ g x * Real.log (f x) =
    ↑((g x * f x ^ (g x - 1)) • ContinuousLinearMap.smulRight 1 f' +
          (f x ^ g x * Real.log (f x)) • ContinuousLinearMap.smulRight 1 g')
      1

tactic: ring
state_before: case h.e'_7
f g : ℝ → ℝ
f' g' x y p : ℝ
s : Set ℝ
hf : HasDerivWithinAt f f' s x
hg : HasDerivWithinAt g g' s x
h : 0 < f x
⊢ f' * g x * f x ^ (g x - 1) + g' * f x ^ g x * Real.log (f x) =
    g x * f x ^ (g x - 1) * (1 * f') + f x ^ g x * Real.log (f x) * (1 * g')
Theorem: Rel.edgeDensity_comm
File: Mathlib/Combinatorics/SimpleGraph/Density.lean

tactic: rw [edgeDensity, mul_comm, card_interedges_comm hr, edgeDensity]
state_before: 𝕜 : Type ?u.104303
ι : Type ?u.104306
κ : Type ?u.104309
α : Type u_1
β : Type ?u.104315
r : α → α → Prop
inst✝ : DecidableRel r
s✝ s₁ s₂ t✝ t₁ t₂ : Finset α
a b : α
hr : Symmetric r
s t : Finset α
⊢ edgeDensity r s t = edgeDensity r t s
Theorem: GeneralizedContinuedFraction.second_continuant_aux_eq
File: Mathlib/Algebra/ContinuedFractions/Translations.lean

tactic: simp [zeroth_s_eq, continuantsAux, nextContinuants, nextDenominator, nextNumerator]
state_before: K : Type u_1
g : GeneralizedContinuedFraction K
n : ℕ
inst✝ : DivisionRing K
gp : Pair K
zeroth_s_eq : Stream'.Seq.get? g.s 0 = some gp
⊢ continuantsAux g 2 = { a := gp.b * g.h + gp.a, b := gp.b }
Theorem: Std.RBNode.insert_setBlack
File: Std/Data/RBMap/WF.lean

tactic: unfold insert
state_before: α : Type u_1
cmp : α → α → Ordering
v : α
t : RBNode α
⊢ setBlack (insert cmp t v) = setBlack (ins cmp v t)

tactic: split <;> simp [setBlack_idem]
state_before: α : Type u_1
cmp : α → α → Ordering
v : α
t : RBNode α
⊢ setBlack
      (match isRed t with
      | red => setBlack (ins cmp v t)
      | black => ins cmp v t) =
    setBlack (ins cmp v t)
Theorem: Sum.elim_update_right
File: Mathlib/Data/Sum/Basic.lean

tactic: ext x
state_before: α : Type u
α' : Type w
β : Type v
β' : Type x
γ : Type u_1
δ : Type ?u.38887
inst✝¹ : DecidableEq α
inst✝ : DecidableEq β
f : α → γ
g : β → γ
i : β
c : γ
⊢ Sum.elim f (update g i c) = update (Sum.elim f g) (inr i) c

tactic: rcases x with x | x
state_before: case h
α : Type u
α' : Type w
β : Type v
β' : Type x
γ : Type u_1
δ : Type ?u.38887
inst✝¹ : DecidableEq α
inst✝ : DecidableEq β
f : α → γ
g : β → γ
i : β
c : γ
x : α ⊕ β
⊢ Sum.elim f (update g i c) x = update (Sum.elim f g) (inr i) c x

tactic: simp
state_before: case h.inl
α : Type u
α' : Type w
β : Type v
β' : Type x
γ : Type u_1
δ : Type ?u.38887
inst✝¹ : DecidableEq α
inst✝ : DecidableEq β
f : α → γ
g : β → γ
i : β
c : γ
x : α
⊢ Sum.elim f (update g i c) (inl x) = update (Sum.elim f g) (inr i) c (inl x)

tactic: by_cases h : x = i
state_before: case h.inr
α : Type u
α' : Type w
β : Type v
β' : Type x
γ : Type u_1
δ : Type ?u.38887
inst✝¹ : DecidableEq α
inst✝ : DecidableEq β
f : α → γ
g : β → γ
i : β
c : γ
x : β
⊢ Sum.elim f (update g i c) (inr x) = update (Sum.elim f g) (inr i) c (inr x)

tactic: subst h
state_before: case pos
α : Type u
α' : Type w
β : Type v
β' : Type x
γ : Type u_1
δ : Type ?u.38887
inst✝¹ : DecidableEq α
inst✝ : DecidableEq β
f : α → γ
g : β → γ
i : β
c : γ
x : β
h : x = i
⊢ Sum.elim f (update g i c) (inr x) = update (Sum.elim f g) (inr i) c (inr x)

tactic: simp
state_before: case pos
α : Type u
α' : Type w
β : Type v
β' : Type x
γ : Type u_1
δ : Type ?u.38887
inst✝¹ : DecidableEq α
inst✝ : DecidableEq β
f : α → γ
g : β → γ
c : γ
x : β
⊢ Sum.elim f (update g x c) (inr x) = update (Sum.elim f g) (inr x) c (inr x)

tactic: simp [h]
state_before: case neg
α : Type u
α' : Type w
β : Type v
β' : Type x
γ : Type u_1
δ : Type ?u.38887
inst✝¹ : DecidableEq α
inst✝ : DecidableEq β
f : α → γ
g : β → γ
i : β
c : γ
x : β
h : ¬x = i
⊢ Sum.elim f (update g i c) (inr x) = update (Sum.elim f g) (inr i) c (inr x)
Theorem: symmetric_symmetrizeRel
File: Mathlib/Topology/UniformSpace/Basic.lean

tactic: simp [SymmetricRel, symmetrizeRel, preimage_inter, inter_comm, ← preimage_comp]
state_before: α : Type ua
β : Type ub
γ : Type uc
δ : Type ud
ι : Sort ?u.16844
V : Set (α × α)
⊢ SymmetricRel (symmetrizeRel V)
Theorem: Vector.tail_ofFn
File: Mathlib/Data/Vector/Basic.lean

tactic: congr
state_before: n✝ : ℕ
α : Type u_1
n : ℕ
f : Fin (Nat.succ n) → α
⊢ ofFn (get (tail (ofFn f))) = ofFn fun i => f (Fin.succ i)

tactic: funext i
state_before: case e_a
n✝ : ℕ
α : Type u_1
n : ℕ
f : Fin (Nat.succ n) → α
⊢ get (tail (ofFn f)) = fun i => f (Fin.succ i)

tactic: rw [get_tail, get_ofFn]
state_before: case e_a.h
n✝ : ℕ
α : Type u_1
n : ℕ
f : Fin (Nat.succ n) → α
i : Fin (Nat.succ n - 1)
⊢ get (tail (ofFn f)) i = f (Fin.succ i)

tactic: rfl
state_before: case e_a.h
n✝ : ℕ
α : Type u_1
n : ℕ
f : Fin (Nat.succ n) → α
i : Fin (Nat.succ n - 1)
⊢ f { val := ↑i + 1, isLt := (_ : ↑i + 1 < Nat.succ n) } = f (Fin.succ i)