tasksource/leandojo huggingface dataset:
Theorem: Polynomial.ker_mapRingHom
File: Mathlib/RingTheory/Polynomial/Basic.lean

tactic: ext
state_before: R : Type u
S : Type u_1
inst✝¹ : CommSemiring R
inst✝ : Semiring S
f : R →+* S
⊢ LinearMap.ker (RingHom.toSemilinearMap (mapRingHom f)) = map C (RingHom.ker f)

tactic: simp only [LinearMap.mem_ker, RingHom.toSemilinearMap_apply, coe_mapRingHom]
state_before: case h
R : Type u
S : Type u_1
inst✝¹ : CommSemiring R
inst✝ : Semiring S
f : R →+* S
x✝ : R[X]
⊢ x✝ ∈ LinearMap.ker (RingHom.toSemilinearMap (mapRingHom f)) ↔ x✝ ∈ map C (RingHom.ker f)

tactic: rw [mem_map_C_iff, Polynomial.ext_iff]
state_before: case h
R : Type u
S : Type u_1
inst✝¹ : CommSemiring R
inst✝ : Semiring S
f : R →+* S
x✝ : R[X]
⊢ Polynomial.map f x✝ = 0 ↔ x✝ ∈ map C (RingHom.ker f)

tactic: simp_rw [RingHom.mem_ker f, coeff_map, coeff_zero]
state_before: case h
R : Type u
S : Type u_1
inst✝¹ : CommSemiring R
inst✝ : Semiring S
f : R →+* S
x✝ : R[X]
⊢ (∀ (n : ℕ), coeff (Polynomial.map f x✝) n = coeff 0 n) ↔ ∀ (n : ℕ), coeff x✝ n ∈ RingHom.ker f
Theorem: Icc_toDual
File: Mathlib/Order/LocallyFinite.lean

tactic: refine' Eq.trans _ map_refl.symm
state_before: α : Type u_1
β : Type ?u.112442
inst✝² : Preorder α
inst✝¹ : Preorder β
inst✝ : LocallyFiniteOrder α
a b : α
⊢ Icc (↑toDual a) (↑toDual b) = map (Equiv.toEmbedding toDual) (Icc b a)

tactic: ext c
state_before: α : Type u_1
β : Type ?u.112442
inst✝² : Preorder α
inst✝¹ : Preorder β
inst✝ : LocallyFiniteOrder α
a b : α
⊢ Icc (↑toDual a) (↑toDual b) = Icc b a

tactic: rw [mem_Icc, mem_Icc (α := α)]
state_before: case a
α : Type u_1
β : Type ?u.112442
inst✝² : Preorder α
inst✝¹ : Preorder β
inst✝ : LocallyFiniteOrder α
a b : α
c : (fun x => αᵒᵈ) a
⊢ c ∈ Icc (↑toDual a) (↑toDual b) ↔ c ∈ Icc b a

tactic: exact and_comm
state_before: case a
α : Type u_1
β : Type ?u.112442
inst✝² : Preorder α
inst✝¹ : Preorder β
inst✝ : LocallyFiniteOrder α
a b : α
c : (fun x => αᵒᵈ) a
⊢ ↑toDual a ≤ c ∧ c ≤ ↑toDual b ↔ b ≤ c ∧ c ≤ a
Theorem: ContinuousLinearMap.toSpanSingleton_apply
File: Mathlib/Analysis/NormedSpace/ContinuousLinearMap.lean

tactic: simp [toSpanSingleton, ofHomothety, LinearMap.toSpanSingleton]
state_before: 𝕜 : Type u_2
𝕜₂ : Type ?u.374483
E : Type u_1
F : Type ?u.374489
G : Type ?u.374492
inst✝³ : NormedField 𝕜
inst✝² : NormedField 𝕜₂
inst✝¹ : SeminormedAddCommGroup E
inst✝ : NormedSpace 𝕜 E
x : E
r : 𝕜
⊢ ↑(toSpanSingleton 𝕜 x) r = r • x
Theorem: GromovHausdorff.optimalGHDist_mem_candidatesB
File: Mathlib/Topology/MetricSpace/GromovHausdorffRealized.lean

tactic: cases Classical.choose_spec (exists_minimizer X Y)
state_before: X : Type u
Y : Type v
inst✝⁵ : MetricSpace X
inst✝⁴ : CompactSpace X
inst✝³ : Nonempty X
inst✝² : MetricSpace Y
inst✝¹ : CompactSpace Y
inst✝ : Nonempty Y
⊢ GromovHausdorff.optimalGHDist X Y ∈ GromovHausdorff.candidatesB X Y

tactic: assumption
state_before: case intro
X : Type u
Y : Type v
inst✝⁵ : MetricSpace X
inst✝⁴ : CompactSpace X
inst✝³ : Nonempty X
inst✝² : MetricSpace Y
inst✝¹ : CompactSpace Y
inst✝ : Nonempty Y
left✝ :
  choose
      (_ :
        ∃ f,
          f ∈ GromovHausdorff.candidatesB X Y ∧
            ∀ (g : GromovHausdorff.Cb X Y), g ∈ GromovHausdorff.candidatesB X Y → HD f ≤ HD g) ∈
    GromovHausdorff.candidatesB X Y
right✝ :
  ∀ (g : GromovHausdorff.Cb X Y),
    g ∈ GromovHausdorff.candidatesB X Y →
      HD
          (choose
            (_ :
              ∃ f,
                f ∈ GromovHausdorff.candidatesB X Y ∧
                  ∀ (g : GromovHausdorff.Cb X Y), g ∈ GromovHausdorff.candidatesB X Y → HD f ≤ HD g)) ≤
        HD g
⊢ GromovHausdorff.optimalGHDist X Y ∈ GromovHausdorff.candidatesB X Y
Theorem: CategoryTheory.Functor.final_of_adjunction
File: Mathlib/CategoryTheory/Limits/Final.lean

tactic: simp
state_before: C : Type u₁
inst✝¹ : Category C
D : Type u₂
inst✝ : Category D
L : C ⥤ D
R : D ⥤ C
adj : L ⊣ R
c : C
u : StructuredArrow c R := StructuredArrow.mk (adj.unit.app c)
f g : StructuredArrow c R
⊢ u.hom ≫ R.map (↑(Adjunction.homEquiv adj c f.right).symm f.hom) = f.hom

tactic: simp
state_before: C : Type u₁
inst✝¹ : Category C
D : Type u₂
inst✝ : Category D
L : C ⥤ D
R : D ⥤ C
adj : L ⊣ R
c : C
u : StructuredArrow c R := StructuredArrow.mk (adj.unit.app c)
f g : StructuredArrow c R
⊢ u.hom ≫ R.map (↑(Adjunction.homEquiv adj c g.right).symm g.hom) = g.hom
Theorem: ite_mul_zero_right
File: Mathlib/Algebra/Ring/Defs.lean

tactic: by_cases h : P <;> simp [h]
state_before: α✝ : Type u
β : Type v
γ : Type w
R : Type x
α : Type u_1
inst✝¹ : MulZeroClass α
P : Prop
inst✝ : Decidable P
a b : α
⊢ (if P then a * b else 0) = a * if P then b else 0
Theorem: Int.mul_lt_mul_of_pos_right
File: Std/Data/Int/Lemmas.lean

tactic: have : 0 < b - a := Int.sub_pos_of_lt h₁
state_before: a b c : Int
h₁ : a < b
h₂ : 0 < c
⊢ a * c < b * c

tactic: have : 0 < (b - a) * c := Int.mul_pos this h₂
state_before: a b c : Int
h₁ : a < b
h₂ : 0 < c
this : 0 < b - a
⊢ a * c < b * c

tactic: rw [Int.sub_mul] at this
state_before: a b c : Int
h₁ : a < b
h₂ : 0 < c
this✝ : 0 < b - a
this : 0 < (b - a) * c
⊢ a * c < b * c

tactic: exact Int.lt_of_sub_pos this
state_before: a b c : Int
h₁ : a < b
h₂ : 0 < c
this✝ : 0 < b - a
this : 0 < b * c - a * c
⊢ a * c < b * c
Theorem: Set.preimage_invFun_of_mem
File: Mathlib/Data/Set/Function.lean

tactic: ext x
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.68574
ι : Sort ?u.68577
π : α → Type ?u.68582
s✝ s₁ s₂ : Set α
t : Set β
f✝ : α → β
n : Nonempty α
f : α → β
hf : Injective f
s : Set α
h : Classical.choice n ∈ s
⊢ Function.invFun f ⁻¹' s = f '' s ∪ range fᶜ

tactic: rcases em (x ∈ range f) with (⟨a, rfl⟩ | hx)
state_before: case h
α : Type u_1
β : Type u_2
γ : Type ?u.68574
ι : Sort ?u.68577
π : α → Type ?u.68582
s✝ s₁ s₂ : Set α
t : Set β
f✝ : α → β
n : Nonempty α
f : α → β
hf : Injective f
s : Set α
h : Classical.choice n ∈ s
x : β
⊢ x ∈ Function.invFun f ⁻¹' s ↔ x ∈ f '' s ∪ range fᶜ

tactic: simp only [mem_preimage, mem_union, mem_compl_iff, mem_range_self, not_true, or_false,
  leftInverse_invFun hf _, hf.mem_set_image]
state_before: case h.inl.intro
α : Type u_1
β : Type u_2
γ : Type ?u.68574
ι : Sort ?u.68577
π : α → Type ?u.68582
s✝ s₁ s₂ : Set α
t : Set β
f✝ : α → β
n : Nonempty α
f : α → β
hf : Injective f
s : Set α
h : Classical.choice n ∈ s
a : α
⊢ f a ∈ Function.invFun f ⁻¹' s ↔ f a ∈ f '' s ∪ range fᶜ

tactic: simp only [mem_preimage, invFun_neg hx, h, hx, mem_union, mem_compl_iff, not_false_iff, or_true]
state_before: case h.inr
α : Type u_1
β : Type u_2
γ : Type ?u.68574
ι : Sort ?u.68577
π : α → Type ?u.68582
s✝ s₁ s₂ : Set α
t : Set β
f✝ : α → β
n : Nonempty α
f : α → β
hf : Injective f
s : Set α
h : Classical.choice n ∈ s
x : β
hx : ¬x ∈ range f
⊢ x ∈ Function.invFun f ⁻¹' s ↔ x ∈ f '' s ∪ range fᶜ
Theorem: Matrix.mulᵣ_eq
File: Mathlib/Data/Matrix/Reflection.lean

tactic: simp [mulᵣ, Function.comp, Matrix.mul, Matrix.transpose]
state_before: l m n : ℕ
α : Type u_1
β : Type ?u.30925
inst✝¹ : Mul α
inst✝ : AddCommMonoid α
A : Matrix (Fin l) (Fin m) α
B : Matrix (Fin m) (Fin n) α
⊢ mulᵣ A B = A ⬝ B

tactic: rfl
state_before: l m n : ℕ
α : Type u_1
β : Type ?u.30925
inst✝¹ : Mul α
inst✝ : AddCommMonoid α
A : Matrix (Fin l) (Fin m) α
B : Matrix (Fin m) (Fin n) α
⊢ (↑of fun x x_1 => A x ⬝ᵥ ↑of (fun x y => B y x) x_1) = fun i k => (fun j => A i j) ⬝ᵥ fun j => B j k
Theorem: SimpleGraph.Connected.ofBoxProdRight
File: Mathlib/Combinatorics/SimpleGraph/Prod.lean

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

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

tactic: exact ⟨h.preconnected.ofBoxProdRight⟩
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.83218
G : SimpleGraph α
H : SimpleGraph β
h : Connected (G □ H)
this✝ : Nonempty α
this : Nonempty β
⊢ Connected H
Theorem: DivisorChain.first_of_chain_isUnit
File: Mathlib/RingTheory/ChainOfDivisors.lean

tactic: obtain ⟨i, hr⟩ := h₂.mp Associates.one_le
state_before: M : Type u_1
inst✝ : CancelCommMonoidWithZero M
q : Associates M
n : ℕ
c : Fin (n + 1) → Associates M
h₁ : StrictMono c
h₂ : ∀ {r : Associates M}, r ≤ q ↔ ∃ i, r = c i
⊢ IsUnit (c 0)

tactic: rw [Associates.isUnit_iff_eq_one, ← Associates.le_one_iff, hr]
state_before: case intro
M : Type u_1
inst✝ : CancelCommMonoidWithZero M
q : Associates M
n : ℕ
c : Fin (n + 1) → Associates M
h₁ : StrictMono c
h₂ : ∀ {r : Associates M}, r ≤ q ↔ ∃ i, r = c i
i : Fin (n + 1)
hr : 1 = c i
⊢ IsUnit (c 0)

tactic: exact h₁.monotone (Fin.zero_le i)
state_before: case intro
M : Type u_1
inst✝ : CancelCommMonoidWithZero M
q : Associates M
n : ℕ
c : Fin (n + 1) → Associates M
h₁ : StrictMono c
h₂ : ∀ {r : Associates M}, r ≤ q ↔ ∃ i, r = c i
i : Fin (n + 1)
hr : 1 = c i
⊢ c 0 ≤ c i
Theorem: Submodule.map₂_span_singleton_eq_map_flip
File: Mathlib/Algebra/Module/Submodule/Bilinear.lean

tactic: rw [← map₂_span_singleton_eq_map, map₂_flip]
state_before: ι : Sort uι
R : Type u_1
M : Type u_2
N : Type u_4
P : Type u_3
inst✝⁶ : CommSemiring R
inst✝⁵ : AddCommMonoid M
inst✝⁴ : AddCommMonoid N
inst✝³ : AddCommMonoid P
inst✝² : Module R M
inst✝¹ : Module R N
inst✝ : Module R P
f : M →ₗ[R] N →ₗ[R] P
s : Submodule R M
n : N
⊢ map₂ f s (span R {n}) = map (↑(LinearMap.flip f) n) s
Theorem: Complex.sin_conj
File: Mathlib/Data/Complex/Exponential.lean

tactic: rw [← mul_left_inj' I_ne_zero, ← sinh_mul_I, ← conj_neg_I, ← RingHom.map_mul, ← RingHom.map_mul,
  sinh_conj, mul_neg, sinh_neg, sinh_mul_I, mul_neg]
state_before: x y : ℂ
⊢ sin (↑(starRingEnd ℂ) x) = ↑(starRingEnd ℂ) (sin x)
Theorem: PowerSeries.rescale_one
File: Mathlib/RingTheory/PowerSeries/Basic.lean

tactic: ext
state_before: R : Type u_1
inst✝ : CommSemiring R
⊢ rescale 1 = RingHom.id (PowerSeries R)

tactic: simp only [coeff_rescale, one_pow, one_mul, RingHom.id_apply]
state_before: case a.h
R : Type u_1
inst✝ : CommSemiring R
x✝ : PowerSeries R
n✝ : ℕ
⊢ ↑(coeff R n✝) (↑(rescale 1) x✝) = ↑(coeff R n✝) (↑(RingHom.id (PowerSeries R)) x✝)
Theorem: Relation.reflTransGen_of_transitive_reflexive
File: Mathlib/Logic/Relation.lean

tactic: induction' h' with b c _ hbc ih
state_before: α : Type u_1
β : Type ?u.30291
γ : Type ?u.30294
δ : Type ?u.30297
r : α → α → Prop
a b c d : α
r' : α → α → Prop
hr : Reflexive r
ht : Transitive r
h : ∀ (a b : α), r' a b → r a b
h' : ReflTransGen r' a b
⊢ r a b

tactic: exact hr _
state_before: case refl
α : Type u_1
β : Type ?u.30291
γ : Type ?u.30294
δ : Type ?u.30297
r : α → α → Prop
a b c d : α
r' : α → α → Prop
hr : Reflexive r
ht : Transitive r
h : ∀ (a b : α), r' a b → r a b
⊢ r a a

tactic: exact ht ih (h _ _ hbc)
state_before: case tail
α : Type u_1
β : Type ?u.30291
γ : Type ?u.30294
δ : Type ?u.30297
r : α → α → Prop
a b✝ c✝ d : α
r' : α → α → Prop
hr : Reflexive r
ht : Transitive r
h : ∀ (a b : α), r' a b → r a b
b c : α
a✝ : ReflTransGen r' a b
hbc : r' b c
ih : r a b
⊢ r a c
Theorem: Submodule.mem_finset_inf
File: Mathlib/Algebra/Module/Submodule/Lattice.lean

tactic: simp only [← SetLike.mem_coe, finset_inf_coe, Set.mem_iInter]
state_before: R : Type u_2
S : Type ?u.146839
M : Type u_3
inst✝⁶ : Semiring R
inst✝⁵ : Semiring S
inst✝⁴ : AddCommMonoid M
inst✝³ : Module R M
inst✝² : Module S M
inst✝¹ : SMul S R
inst✝ : IsScalarTower S R M
p✝ q : Submodule R M
ι : Type u_1
s : Finset ι
p : ι → Submodule R M
x : M
⊢ x ∈ Finset.inf s p ↔ ∀ (i : ι), i ∈ s → x ∈ p i
Theorem: NNReal.rpow_arith_mean_le_arith_mean2_rpow
File: Mathlib/Analysis/MeanInequalitiesPow.lean

tactic: have h := rpow_arith_mean_le_arith_mean_rpow univ ![w₁, w₂] ![z₁, z₂] ?_ hp
state_before: ι : Type u
s : Finset ι
w₁ w₂ z₁ z₂ : ℝ≥0
hw' : w₁ + w₂ = 1
p : ℝ
hp : 1 ≤ p
⊢ (w₁ * z₁ + w₂ * z₂) ^ p ≤ w₁ * z₁ ^ p + w₂ * z₂ ^ p

tactic: simpa [Fin.sum_univ_succ] using h
state_before: case refine_2
ι : Type u
s : Finset ι
w₁ w₂ z₁ z₂ : ℝ≥0
hw' : w₁ + w₂ = 1
p : ℝ
hp : 1 ≤ p
h :
  (∑ i : Fin (Nat.succ (Nat.succ 0)), Matrix.vecCons w₁ ![w₂] i * Matrix.vecCons z₁ ![z₂] i) ^ p ≤
    ∑ i : Fin (Nat.succ (Nat.succ 0)), Matrix.vecCons w₁ ![w₂] i * Matrix.vecCons z₁ ![z₂] i ^ p
⊢ (w₁ * z₁ + w₂ * z₂) ^ p ≤ w₁ * z₁ ^ p + w₂ * z₂ ^ p

tactic: simp [hw', Fin.sum_univ_succ]
state_before: case refine_1
ι : Type u
s : Finset ι
w₁ w₂ z₁ z₂ : ℝ≥0
hw' : w₁ + w₂ = 1
p : ℝ
hp : 1 ≤ p
⊢ ∑ i : Fin (Nat.succ (Nat.succ 0)), Matrix.vecCons w₁ ![w₂] i = 1
Theorem: Set.left_mem_Icc
File: Mathlib/Data/Set/Intervals/Basic.lean

tactic: simp [le_refl]
state_before: α : Type u_1
β : Type ?u.4035
inst✝ : Preorder α
a a₁ a₂ b b₁ b₂ c x : α
⊢ a ∈ Icc a b ↔ a ≤ b
Theorem: OrderIso.ofRelIsoLT_toRelIsoLT
File: Mathlib/Order/Hom/Basic.lean

tactic: ext
state_before: F : Type ?u.90892
α✝ : Type ?u.90895
β✝ : Type ?u.90898
γ : Type ?u.90901
δ : Type ?u.90904
inst✝⁴ : Preorder α✝
inst✝³ : Preorder β✝
inst✝² : Preorder γ
α : Type u_1
β : Type u_2
inst✝¹ : PartialOrder α
inst✝ : PartialOrder β
e : α ≃o β
⊢ ofRelIsoLT (toRelIsoLT e) = e

tactic: simp
state_before: case h.h
F : Type ?u.90892
α✝ : Type ?u.90895
β✝ : Type ?u.90898
γ : Type ?u.90901
δ : Type ?u.90904
inst✝⁴ : Preorder α✝
inst✝³ : Preorder β✝
inst✝² : Preorder γ
α : Type u_1
β : Type u_2
inst✝¹ : PartialOrder α
inst✝ : PartialOrder β
e : α ≃o β
x✝ : α
⊢ ↑(ofRelIsoLT (toRelIsoLT e)) x✝ = ↑e x✝
Theorem: ProbabilityTheory.kernel.finset_sum_apply
File: Mathlib/Probability/Kernel/Basic.lean

tactic: rw [coe_finset_sum, Finset.sum_apply]
state_before: α : Type u_2
β : Type u_3
ι : Type u_1
mα : MeasurableSpace α
mβ : MeasurableSpace β
I : Finset ι
κ : ι → { x // x ∈ kernel α β }
a : α
⊢ ↑(∑ i in I, κ i) a = ∑ i in I, ↑(κ i) a
Theorem: MeasureTheory.norm_set_integral_le_of_norm_le_const_ae
File: Mathlib/MeasureTheory/Integral/SetIntegral.lean

tactic: rw [← Measure.restrict_apply_univ] at *
state_before: α : Type u_1
β : Type ?u.252909
E : Type u_2
F : Type ?u.252915
inst✝³ : MeasurableSpace α
inst✝² : NormedAddCommGroup E
f g : α → E
s t : Set α
μ ν : Measure α
l l' : Filter α
inst✝¹ : CompleteSpace E
inst✝ : NormedSpace ℝ E
C : ℝ
hs : ↑↑μ s < ⊤
hC : ∀ᵐ (x : α) ∂Measure.restrict μ s, ‖f x‖ ≤ C
⊢ ‖∫ (x : α) in s, f x ∂μ‖ ≤ C * ENNReal.toReal (↑↑μ s)

tactic: haveI : IsFiniteMeasure (μ.restrict s) := ⟨‹_›⟩
state_before: α : Type u_1
β : Type ?u.252909
E : Type u_2
F : Type ?u.252915
inst✝³ : MeasurableSpace α
inst✝² : NormedAddCommGroup E
f g : α → E
s t : Set α
μ ν : Measure α
l l' : Filter α
inst✝¹ : CompleteSpace E
inst✝ : NormedSpace ℝ E
C : ℝ
hs : ↑↑(Measure.restrict μ s) univ < ⊤
hC : ∀ᵐ (x : α) ∂Measure.restrict μ s, ‖f x‖ ≤ C
⊢ ‖∫ (x : α) in s, f x ∂μ‖ ≤ C * ENNReal.toReal (↑↑(Measure.restrict μ s) univ)

tactic: exact norm_integral_le_of_norm_le_const hC
state_before: α : Type u_1
β : Type ?u.252909
E : Type u_2
F : Type ?u.252915
inst✝³ : MeasurableSpace α
inst✝² : NormedAddCommGroup E
f g : α → E
s t : Set α
μ ν : Measure α
l l' : Filter α
inst✝¹ : CompleteSpace E
inst✝ : NormedSpace ℝ E
C : ℝ
hs : ↑↑(Measure.restrict μ s) univ < ⊤
hC : ∀ᵐ (x : α) ∂Measure.restrict μ s, ‖f x‖ ≤ C
this : IsFiniteMeasure (Measure.restrict μ s)
⊢ ‖∫ (x : α) in s, f x ∂μ‖ ≤ C * ENNReal.toReal (↑↑(Measure.restrict μ s) univ)
Theorem: LinearIsometry.orthonormal_comp_iff
File: Mathlib/Analysis/InnerProductSpace/Basic.lean

tactic: classical simp_rw [orthonormal_iff_ite, Function.comp_apply, LinearIsometry.inner_map_map]
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type ?u.2897691
inst✝⁸ : IsROrC 𝕜
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : InnerProductSpace 𝕜 E
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : InnerProductSpace ℝ F
dec_E : DecidableEq E
ι : Type u_4
ι' : Type ?u.2897743
ι'' : Type ?u.2897746
E' : Type u_3
inst✝³ : NormedAddCommGroup E'
inst✝² : InnerProductSpace 𝕜 E'
E'' : Type ?u.2897767
inst✝¹ : NormedAddCommGroup E''
inst✝ : InnerProductSpace 𝕜 E''
v : ι → E
f : E →ₗᵢ[𝕜] E'
⊢ Orthonormal 𝕜 (↑f ∘ v) ↔ Orthonormal 𝕜 v

tactic: simp_rw [orthonormal_iff_ite, Function.comp_apply, LinearIsometry.inner_map_map]
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type ?u.2897691
inst✝⁸ : IsROrC 𝕜
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : InnerProductSpace 𝕜 E
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : InnerProductSpace ℝ F
dec_E : DecidableEq E
ι : Type u_4
ι' : Type ?u.2897743
ι'' : Type ?u.2897746
E' : Type u_3
inst✝³ : NormedAddCommGroup E'
inst✝² : InnerProductSpace 𝕜 E'
E'' : Type ?u.2897767
inst✝¹ : NormedAddCommGroup E''
inst✝ : InnerProductSpace 𝕜 E''
v : ι → E
f : E →ₗᵢ[𝕜] E'
⊢ Orthonormal 𝕜 (↑f ∘ v) ↔ Orthonormal 𝕜 v
Theorem: fderiv_mem_iff
File: Mathlib/Analysis/Calculus/FDeriv/Basic.lean

tactic: by_cases hx : DifferentiableAt 𝕜 f x <;> simp [fderiv_zero_of_not_differentiableAt, *]
state_before: 𝕜 : Type u_3
inst✝⁸ : NontriviallyNormedField 𝕜
E : Type u_2
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type u_1
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type ?u.356183
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
G' : Type ?u.356278
inst✝¹ : NormedAddCommGroup G'
inst✝ : NormedSpace 𝕜 G'
f✝ f₀ f₁ g : E → F
f' f₀' f₁' g' e : E →L[𝕜] F
x✝ : E
s✝ t : Set E
L L₁ L₂ : Filter E
f : E → F
s : Set (E →L[𝕜] F)
x : E
⊢ fderiv 𝕜 f x ∈ s ↔ DifferentiableAt 𝕜 f x ∧ fderiv 𝕜 f x ∈ s ∨ ¬DifferentiableAt 𝕜 f x ∧ 0 ∈ s
Theorem: IsSubgroup.univ_subgroup
File: Mathlib/Deprecated/Subgroup.lean

tactic: refine' { .. } <;> simp
state_before: G : Type u_1
H : Type ?u.35596
A : Type ?u.35599
a a₁ a₂ b c : G
inst✝ : Group G
⊢ IsNormalSubgroup univ
Theorem: SimpleGraph.Reachable.pos_dist_of_ne
File: Mathlib/Combinatorics/SimpleGraph/Metric.lean

tactic: simp [h, hne]
state_before: V : Type u_1
G : SimpleGraph V
u v : V
h : Reachable G u v
hne : u ≠ v
⊢ dist G u v ≠ 0
Theorem: ContinuousMap.image_gen
File: Mathlib/Topology/CompactOpen.lean

tactic: ext ⟨g, _⟩
state_before: α : Type u_1
β : Type u_3
γ : Type u_2
inst✝² : TopologicalSpace α
inst✝¹ : TopologicalSpace β
inst✝ : TopologicalSpace γ
g : C(β, γ)
f : C(α, β)
s : Set α
x✝¹ : IsCompact s
u : Set γ
x✝ : IsOpen u
⊢ (fun g => comp g f) ⁻¹' CompactOpen.gen s u = CompactOpen.gen (↑f '' s) u

tactic: change g ∘ f '' s ⊆ u ↔ g '' (f '' s) ⊆ u
state_before: case h.mk
α : Type u_1
β : Type u_3
γ : Type u_2
inst✝² : TopologicalSpace α
inst✝¹ : TopologicalSpace β
inst✝ : TopologicalSpace γ
g✝ : C(β, γ)
f : C(α, β)
s : Set α
x✝¹ : IsCompact s
u : Set γ
x✝ : IsOpen u
g : β → γ
continuous_toFun✝ : Continuous g
⊢ mk g ∈ (fun g => comp g f) ⁻¹' CompactOpen.gen s u ↔ mk g ∈ CompactOpen.gen (↑f '' s) u

tactic: rw [Set.image_comp]
state_before: case h.mk
α : Type u_1
β : Type u_3
γ : Type u_2
inst✝² : TopologicalSpace α
inst✝¹ : TopologicalSpace β
inst✝ : TopologicalSpace γ
g✝ : C(β, γ)
f : C(α, β)
s : Set α
x✝¹ : IsCompact s
u : Set γ
x✝ : IsOpen u
g : β → γ
continuous_toFun✝ : Continuous g
⊢ g ∘ ↑f '' s ⊆ u ↔ g '' (↑f '' s) ⊆ u
Theorem: InnerProductGeometry.norm_sub_sq_eq_norm_sq_add_norm_sq_iff_angle_eq_pi_div_two
File: Mathlib/Geometry/Euclidean/Angle/Unoriented/RightAngle.lean

tactic: rw [norm_sub_sq_eq_norm_sq_add_norm_sq_iff_real_inner_eq_zero]
state_before: V : Type u_1
inst✝¹ : NormedAddCommGroup V
inst✝ : InnerProductSpace ℝ V
x y : V
⊢ ‖x - y‖ * ‖x - y‖ = ‖x‖ * ‖x‖ + ‖y‖ * ‖y‖ ↔ angle x y = π / 2

tactic: exact inner_eq_zero_iff_angle_eq_pi_div_two x y
state_before: V : Type u_1
inst✝¹ : NormedAddCommGroup V
inst✝ : InnerProductSpace ℝ V
x y : V
⊢ inner x y = 0 ↔ angle x y = π / 2
Theorem: Polynomial.mem_support_iff
File: Mathlib/Data/Polynomial/Basic.lean

tactic: rcases p with ⟨⟩
state_before: R : Type u
a b : R
m n : ℕ
inst✝ : Semiring R
p q : R[X]
⊢ n ∈ support p ↔ coeff p n ≠ 0

tactic: simp
state_before: case ofFinsupp
R : Type u
a b : R
m n : ℕ
inst✝ : Semiring R
q : R[X]
toFinsupp✝ : AddMonoidAlgebra R ℕ
⊢ n ∈ support { toFinsupp := toFinsupp✝ } ↔ coeff { toFinsupp := toFinsupp✝ } n ≠ 0
Theorem: HasStrictDerivAt.div_const
File: Mathlib/Analysis/Calculus/Deriv/Mul.lean

tactic: simpa only [div_eq_mul_inv] using hc.mul_const d⁻¹
state_before: 𝕜 : Type u
inst✝⁶ : NontriviallyNormedField 𝕜
F : Type v
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
E : Type w
inst✝³ : NormedAddCommGroup E
inst✝² : NormedSpace 𝕜 E
f f₀ f₁ g : 𝕜 → F
f' f₀' f₁' g' : F
x : 𝕜
s t : Set 𝕜
L L₁ L₂ : Filter 𝕜
𝕜' : Type u_1
inst✝¹ : NontriviallyNormedField 𝕜'
inst✝ : NormedAlgebra 𝕜 𝕜'
c d✝ : 𝕜 → 𝕜'
c' d' : 𝕜'
hc : HasStrictDerivAt c c' x
d : 𝕜'
⊢ HasStrictDerivAt (fun x => c x / d) (c' / d) x
Theorem: PartENat.le_coe_iff
File: Mathlib/Data/Nat/PartENat.lean

tactic: show (∃ h : True → x.Dom, _) ↔ ∃ h : x.Dom, x.get h ≤ n
state_before: x : PartENat
n : ℕ
⊢ x ≤ ↑n ↔ ∃ h, Part.get x h ≤ n

tactic: simp only [forall_prop_of_true, dom_natCast, get_natCast']
state_before: x : PartENat
n : ℕ
⊢ (∃ h, ∀ (hy : (↑n).Dom), Part.get x (_ : x.Dom) ≤ Part.get (↑n) hy) ↔ ∃ h, Part.get x h ≤ n
Theorem: Filter.EventuallyEq.deriv_eq
File: Mathlib/Analysis/Calculus/Deriv/Basic.lean

tactic: unfold deriv
state_before: 𝕜 : Type u
inst✝⁴ : NontriviallyNormedField 𝕜
F : Type v
inst✝³ : NormedAddCommGroup F
inst✝² : NormedSpace 𝕜 F
E : Type w
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace 𝕜 E
f f₀ f₁ g : 𝕜 → F
f' f₀' f₁' g' : F
x : 𝕜
s t : Set 𝕜
L L₁ L₂ : Filter 𝕜
hL : f₁ =ᶠ[𝓝 x] f
⊢ deriv f₁ x = deriv f x

tactic: rwa [Filter.EventuallyEq.fderiv_eq]
state_before: 𝕜 : Type u
inst✝⁴ : NontriviallyNormedField 𝕜
F : Type v
inst✝³ : NormedAddCommGroup F
inst✝² : NormedSpace 𝕜 F
E : Type w
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace 𝕜 E
f f₀ f₁ g : 𝕜 → F
f' f₀' f₁' g' : F
x : 𝕜
s t : Set 𝕜
L L₁ L₂ : Filter 𝕜
hL : f₁ =ᶠ[𝓝 x] f
⊢ ↑(fderiv 𝕜 f₁ x) 1 = ↑(fderiv 𝕜 f x) 1
Theorem: circleIntegral_def_Icc
File: Mathlib/MeasureTheory/Integral/CircleIntegral.lean

tactic: rw [circleIntegral, intervalIntegral.integral_of_le Real.two_pi_pos.le,
  Measure.restrict_congr_set Ioc_ae_eq_Icc]
state_before: E : Type u_1
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℂ E
inst✝ : CompleteSpace E
f : ℂ → E
c : ℂ
R : ℝ
⊢ (∮ (z : ℂ) in C(c, R), f z) = ∫ (θ : ℝ) in Icc 0 (2 * π), deriv (circleMap c R) θ • f (circleMap c R θ)
Theorem: List.rdropWhile_nil
File: Mathlib/Data/List/Rdrop.lean

tactic: simp [rdropWhile, dropWhile]
state_before: α : Type u_1
p : α → Bool
l : List α
n : ℕ
⊢ rdropWhile p [] = []
Theorem: PosNum.to_nat_eq_succ_pred
File: Mathlib/Data/Num/Lemmas.lean

tactic: rw [← Num.succ'_to_nat, n.succ'_pred']
state_before: α : Type ?u.841816
n : PosNum
⊢ ↑n = ↑(pred' n) + 1
Theorem: Nat.doubleFactorial_eq_prod_odd
File: Mathlib/Data/Nat/Factorial/DoubleFactorial.lean

tactic: rw [Finset.prod_range_succ, ← doubleFactorial_eq_prod_odd _, mul_comm (2 * n + 1)‼,
  (by ring : 2 * (n + 1) + 1 = 2 * n + 1 + 2)]
state_before: n : ℕ
⊢ (2 * (n + 1) + 1)‼ = ∏ i in Finset.range (n + 1), (2 * (i + 1) + 1)

tactic: rfl
state_before: n : ℕ
⊢ (2 * n + 1 + 2)‼ = (2 * n + 1 + 2) * (2 * n + 1)‼

tactic: ring
state_before: n : ℕ
⊢ 2 * (n + 1) + 1 = 2 * n + 1 + 2
Theorem: MeasureTheory.StronglyMeasurable.mono
File: Mathlib/MeasureTheory/Function/StronglyMeasurable/Basic.lean

tactic: let f_approx : ℕ → @SimpleFunc α m β := fun n =>
  @SimpleFunc.mk α m β
    (hf.approx n)
    (fun x => h_mono _ (SimpleFunc.measurableSet_fiber' _ x))
    (SimpleFunc.finite_range (hf.approx n))
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.69543
ι : Type ?u.69546
inst✝¹ : Countable ι
f g : α → β
m m' : MeasurableSpace α
inst✝ : TopologicalSpace β
hf : StronglyMeasurable f
h_mono : m' ≤ m
⊢ StronglyMeasurable f

tactic: exact ⟨f_approx, hf.tendsto_approx⟩
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.69543
ι : Type ?u.69546
inst✝¹ : Countable ι
f g : α → β
m m' : MeasurableSpace α
inst✝ : TopologicalSpace β
hf : StronglyMeasurable f
h_mono : m' ≤ m
f_approx : ℕ → α →ₛ β :=
  fun n =>
    { toFun := ↑(StronglyMeasurable.approx hf n),
      measurableSet_fiber' := (_ : ∀ (x : β), MeasurableSet (↑(StronglyMeasurable.approx hf n) ⁻¹' {x})),
      finite_range' := (_ : Set.Finite (range ↑(StronglyMeasurable.approx hf n))) }
⊢ StronglyMeasurable f