1337xyz1337xyz/leandojo-benchmark4-v10 huggingface dataset:
Theorem: AffineSubspace.mem_perpBisector_pointReflection_iff_inner_eq_zero
File: Mathlib/Geometry/Euclidean/PerpBisector.lean

tactic: rw [mem_perpBisector_iff_inner_eq_zero, midpoint_pointReflection_right,
  Equiv.pointReflection_apply, vadd_vsub_assoc, inner_add_right, add_self_eq_zero,
  ← neg_eq_zero, ← inner_neg_right, neg_vsub_eq_vsub_rev]
state_before: V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
c c₁ c₂ p₁ p₂ : P
⊢ c ∈ perpBisector p₁ ((Equiv.pointReflection p₂) p₁) ↔ ⟪c -ᵥ p₂, p₁ -ᵥ p₂⟫_ℝ = 0
state_after: no goals
Theorem: Lists'.ofList_subset
File: Mathlib/SetTheory/Lists.lean

tactic: induction' l₁ with _ _ l₁_ih
state_before: α : Type u_1
l₁ l₂ : List (Lists α)
h : l₁ ⊆ l₂
⊢ ofList l₁ ⊆ ofList l₂
state_after: case nil
α : Type u_1
l₂ : List (Lists α)
h : [] ⊆ l₂
⊢ ofList [] ⊆ ofList l₂

case cons
α : Type u_1
l₂ : List (Lists α)
head✝ : Lists α
tail✝ : List (Lists α)
l₁_ih : tail✝ ⊆ l₂ → ofList tail✝ ⊆ ofList l₂
h : head✝ :: tail✝ ⊆ l₂
⊢ ofList (head✝ :: tail✝) ⊆ ofList l₂

tactic: refine Subset.cons (Lists.Equiv.refl _) ?_ (l₁_ih (List.subset_of_cons_subset h))
state_before: case cons
α : Type u_1
l₂ : List (Lists α)
head✝ : Lists α
tail✝ : List (Lists α)
l₁_ih : tail✝ ⊆ l₂ → ofList tail✝ ⊆ ofList l₂
h : head✝ :: tail✝ ⊆ l₂
⊢ ofList (head✝ :: tail✝) ⊆ ofList l₂
state_after: case cons
α : Type u_1
l₂ : List (Lists α)
head✝ : Lists α
tail✝ : List (Lists α)
l₁_ih : tail✝ ⊆ l₂ → ofList tail✝ ⊆ ofList l₂
h : head✝ :: tail✝ ⊆ l₂
⊢ head✝ ∈ (ofList l₂).toList

tactic: simp only [List.cons_subset] at h
state_before: case cons
α : Type u_1
l₂ : List (Lists α)
head✝ : Lists α
tail✝ : List (Lists α)
l₁_ih : tail✝ ⊆ l₂ → ofList tail✝ ⊆ ofList l₂
h : head✝ :: tail✝ ⊆ l₂
⊢ head✝ ∈ (ofList l₂).toList
state_after: case cons
α : Type u_1
l₂ : List (Lists α)
head✝ : Lists α
tail✝ : List (Lists α)
l₁_ih : tail✝ ⊆ l₂ → ofList tail✝ ⊆ ofList l₂
h : head✝ ∈ l₂ ∧ tail✝ ⊆ l₂
⊢ head✝ ∈ (ofList l₂).toList

tactic: simp [h]
state_before: case cons
α : Type u_1
l₂ : List (Lists α)
head✝ : Lists α
tail✝ : List (Lists α)
l₁_ih : tail✝ ⊆ l₂ → ofList tail✝ ⊆ ofList l₂
h : head✝ ∈ l₂ ∧ tail✝ ⊆ l₂
⊢ head✝ ∈ (ofList l₂).toList
state_after: no goals

tactic: exact Subset.nil
state_before: case nil
α : Type u_1
l₂ : List (Lists α)
h : [] ⊆ l₂
⊢ ofList [] ⊆ ofList l₂
state_after: no goals
Theorem: dimH_subsingleton
File: Mathlib/Topology/MetricSpace/HausdorffDimension.lean

tactic: borelize X
state_before: ι : Type u_1
X : Type u_2
Y : Type u_3
inst✝¹ : EMetricSpace X
inst✝ : EMetricSpace Y
s : Set X
h : s.Subsingleton
⊢ dimH s = 0
state_after: ι : Type u_1
X : Type u_2
Y : Type u_3
inst✝¹ : EMetricSpace X
inst✝ : EMetricSpace Y
s : Set X
h : s.Subsingleton
this✝¹ : MeasurableSpace X := borel X
this✝ : BorelSpace X
⊢ dimH s = 0

tactic: apply le_antisymm _ (zero_le _)
state_before: ι : Type u_1
X : Type u_2
Y : Type u_3
inst✝¹ : EMetricSpace X
inst✝ : EMetricSpace Y
s : Set X
h : s.Subsingleton
this✝¹ : MeasurableSpace X := borel X
this✝ : BorelSpace X
⊢ dimH s = 0
state_after: ι : Type u_1
X : Type u_2
Y : Type u_3
inst✝¹ : EMetricSpace X
inst✝ : EMetricSpace Y
s : Set X
h : s.Subsingleton
this✝¹ : MeasurableSpace X := borel X
this✝ : BorelSpace X
⊢ dimH s ≤ 0

tactic: refine dimH_le_of_hausdorffMeasure_ne_top ?_
state_before: ι : Type u_1
X : Type u_2
Y : Type u_3
inst✝¹ : EMetricSpace X
inst✝ : EMetricSpace Y
s : Set X
h : s.Subsingleton
this✝¹ : MeasurableSpace X := borel X
this✝ : BorelSpace X
⊢ dimH s ≤ 0
state_after: ι : Type u_1
X : Type u_2
Y : Type u_3
inst✝¹ : EMetricSpace X
inst✝ : EMetricSpace Y
s : Set X
h : s.Subsingleton
this✝¹ : MeasurableSpace X := borel X
this✝ : BorelSpace X
⊢ μH[↑0] s ≠ ⊤

tactic: exact ((hausdorffMeasure_le_one_of_subsingleton h le_rfl).trans_lt ENNReal.one_lt_top).ne
state_before: ι : Type u_1
X : Type u_2
Y : Type u_3
inst✝¹ : EMetricSpace X
inst✝ : EMetricSpace Y
s : Set X
h : s.Subsingleton
this✝¹ : MeasurableSpace X := borel X
this✝ : BorelSpace X
⊢ μH[↑0] s ≠ ⊤
state_after: no goals
Theorem: ProbabilityTheory.kernel.singularPart_eq_zero_iff_apply_eq_zero
File: Mathlib/Probability/Kernel/RadonNikodym.lean

tactic: rw [← Measure.measure_univ_eq_zero]
state_before: α : Type u_1
γ : Type u_2
mα : MeasurableSpace α
mγ : MeasurableSpace γ
κ✝ η✝ : ↥(kernel α γ)
hαγ : MeasurableSpace.CountableOrCountablyGenerated α γ
κ η : ↥(kernel α γ)
inst✝¹ : IsFiniteKernel κ
inst✝ : IsFiniteKernel η
a : α
⊢ (singularPart κ η) a = 0 ↔ ((singularPart κ η) a) (mutuallySingularSetSlice κ η a) = 0
state_after: α : Type u_1
γ : Type u_2
mα : MeasurableSpace α
mγ : MeasurableSpace γ
κ✝ η✝ : ↥(kernel α γ)
hαγ : MeasurableSpace.CountableOrCountablyGenerated α γ
κ η : ↥(kernel α γ)
inst✝¹ : IsFiniteKernel κ
inst✝ : IsFiniteKernel η
a : α
⊢ ((singularPart κ η) a) univ = 0 ↔ ((singularPart κ η) a) (mutuallySingularSetSlice κ η a) = 0

tactic: have : univ = (mutuallySingularSetSlice κ η a) ∪ (mutuallySingularSetSlice κ η a)ᶜ := by simp
state_before: α : Type u_1
γ : Type u_2
mα : MeasurableSpace α
mγ : MeasurableSpace γ
κ✝ η✝ : ↥(kernel α γ)
hαγ : MeasurableSpace.CountableOrCountablyGenerated α γ
κ η : ↥(kernel α γ)
inst✝¹ : IsFiniteKernel κ
inst✝ : IsFiniteKernel η
a : α
⊢ ((singularPart κ η) a) univ = 0 ↔ ((singularPart κ η) a) (mutuallySingularSetSlice κ η a) = 0
state_after: α : Type u_1
γ : Type u_2
mα : MeasurableSpace α
mγ : MeasurableSpace γ
κ✝ η✝ : ↥(kernel α γ)
hαγ : MeasurableSpace.CountableOrCountablyGenerated α γ
κ η : ↥(kernel α γ)
inst✝¹ : IsFiniteKernel κ
inst✝ : IsFiniteKernel η
a : α
this : univ = mutuallySingularSetSlice κ η a ∪ (mutuallySingularSetSlice κ η a)ᶜ
⊢ ((singularPart κ η) a) univ = 0 ↔ ((singularPart κ η) a) (mutuallySingularSetSlice κ η a) = 0

tactic: rw [this, measure_union disjoint_compl_right (measurableSet_mutuallySingularSetSlice κ η a).compl,
  singularPart_compl_mutuallySingularSetSlice, add_zero]
state_before: α : Type u_1
γ : Type u_2
mα : MeasurableSpace α
mγ : MeasurableSpace γ
κ✝ η✝ : ↥(kernel α γ)
hαγ : MeasurableSpace.CountableOrCountablyGenerated α γ
κ η : ↥(kernel α γ)
inst✝¹ : IsFiniteKernel κ
inst✝ : IsFiniteKernel η
a : α
this : univ = mutuallySingularSetSlice κ η a ∪ (mutuallySingularSetSlice κ η a)ᶜ
⊢ ((singularPart κ η) a) univ = 0 ↔ ((singularPart κ η) a) (mutuallySingularSetSlice κ η a) = 0
state_after: no goals

tactic: simp
state_before: α : Type u_1
γ : Type u_2
mα : MeasurableSpace α
mγ : MeasurableSpace γ
κ✝ η✝ : ↥(kernel α γ)
hαγ : MeasurableSpace.CountableOrCountablyGenerated α γ
κ η : ↥(kernel α γ)
inst✝¹ : IsFiniteKernel κ
inst✝ : IsFiniteKernel η
a : α
⊢ univ = mutuallySingularSetSlice κ η a ∪ (mutuallySingularSetSlice κ η a)ᶜ
state_after: no goals
Theorem: Stream'.mem_interleave_right
File: Mathlib/Data/Stream/Init.lean

tactic: rw [h, get_interleave_right]
state_before: α : Type u
β : Type v
δ : Type w
a : α
s₁ s₂ : Stream' α
x✝ : a ∈ s₂
n : ℕ
h : (fun b => a = b) (s₂.get n)
⊢ (fun b => a = b) ((s₁ ⋈ s₂).get (2 * n + 1))
state_after: no goals
Theorem: Submodule.singleton_smul
File: Mathlib/Algebra/Algebra/Operations.lean

tactic: conv_lhs => rw [← span_eq M]
state_before: ι : Sort uι
R : Type u
inst✝² : CommSemiring R
A : Type v
inst✝¹ : CommSemiring A
inst✝ : Algebra R A
M✝ N : Submodule R A
m n a : A
M : Submodule R A
⊢ Set.up {a} • M = map (LinearMap.mulLeft R a) M
state_after: ι : Sort uι
R : Type u
inst✝² : CommSemiring R
A : Type v
inst✝¹ : CommSemiring A
inst✝ : Algebra R A
M✝ N : Submodule R A
m n a : A
M : Submodule R A
⊢ Set.up {a} • span R ↑M = map (LinearMap.mulLeft R a) M

tactic: rw [smul_def, SetSemiring.down_up, span_mul_span, singleton_mul]
state_before: ι : Sort uι
R : Type u
inst✝² : CommSemiring R
A : Type v
inst✝¹ : CommSemiring A
inst✝ : Algebra R A
M✝ N : Submodule R A
m n a : A
M : Submodule R A
⊢ Set.up {a} • span R ↑M = map (LinearMap.mulLeft R a) M
state_after: ι : Sort uι
R : Type u
inst✝² : CommSemiring R
A : Type v
inst✝¹ : CommSemiring A
inst✝ : Algebra R A
M✝ N : Submodule R A
m n a : A
M : Submodule R A
⊢ span R ((fun x => a * x) '' ↑M) = map (LinearMap.mulLeft R a) M

tactic: exact (map (LinearMap.mulLeft R a) M).span_eq
state_before: ι : Sort uι
R : Type u
inst✝² : CommSemiring R
A : Type v
inst✝¹ : CommSemiring A
inst✝ : Algebra R A
M✝ N : Submodule R A
m n a : A
M : Submodule R A
⊢ span R ((fun x => a * x) '' ↑M) = map (LinearMap.mulLeft R a) M
state_after: no goals
Theorem: MvPowerSeries.coeff_truncFun
File: Mathlib/RingTheory/MvPowerSeries/Trunc.lean

tactic: classical
simp [truncFun, MvPolynomial.coeff_sum]
state_before: σ : Type u_1
R : Type u_2
inst✝ : CommSemiring R
n m : σ →₀ ℕ
φ : MvPowerSeries σ R
⊢ MvPolynomial.coeff m (truncFun n φ) = if m < n then (coeff R m) φ else 0
state_after: no goals

tactic: simp [truncFun, MvPolynomial.coeff_sum]
state_before: σ : Type u_1
R : Type u_2
inst✝ : CommSemiring R
n m : σ →₀ ℕ
φ : MvPowerSeries σ R
⊢ MvPolynomial.coeff m (truncFun n φ) = if m < n then (coeff R m) φ else 0
state_after: no goals
Theorem: tendsto_exp_mul_div_rpow_atTop
File: Mathlib/Analysis/SpecialFunctions/Pow/Asymptotics.lean

tactic: refine ((tendsto_rpow_atTop hb).comp (tendsto_exp_div_rpow_atTop (s / b))).congr' ?_
state_before: s b : ℝ
hb : 0 < b
⊢ Tendsto (fun x => rexp (b * x) / x ^ s) atTop atTop
state_after: s b : ℝ
hb : 0 < b
⊢ ((fun x => x ^ b) ∘ fun x => rexp x / x ^ (s / b)) =ᶠ[atTop] fun x => rexp (b * x) / x ^ s

tactic: filter_upwards [eventually_ge_atTop (0 : ℝ)] with x hx₀
state_before: s b : ℝ
hb : 0 < b
⊢ ((fun x => x ^ b) ∘ fun x => rexp x / x ^ (s / b)) =ᶠ[atTop] fun x => rexp (b * x) / x ^ s
state_after: case h
s b : ℝ
hb : 0 < b
x : ℝ
hx₀ : 0 ≤ x
⊢ ((fun x => x ^ b) ∘ fun x => rexp x / x ^ (s / b)) x = rexp (b * x) / x ^ s

tactic: simp [Real.div_rpow, (exp_pos x).le, rpow_nonneg, ← Real.rpow_mul, ← exp_mul,
  mul_comm x, hb.ne', *]
state_before: case h
s b : ℝ
hb : 0 < b
x : ℝ
hx₀ : 0 ≤ x
⊢ ((fun x => x ^ b) ∘ fun x => rexp x / x ^ (s / b)) x = rexp (b * x) / x ^ s
state_after: no goals
Theorem: Dense.diff_finset
File: Mathlib/Topology/Separation.lean

tactic: induction t using Finset.induction_on with
| empty => simpa using hs
| insert _ ih =>
  rw [Finset.coe_insert, ← union_singleton, ← diff_diff]
  exact ih.diff_singleton _
state_before: X : Type u_1
Y : Type u_2
inst✝² : TopologicalSpace X
inst✝¹ : T1Space X
inst✝ : ∀ (x : X), (𝓝[≠] x).NeBot
s : Set X
hs : Dense s
t : Finset X
⊢ Dense (s \ ↑t)
state_after: no goals

tactic: simpa using hs
state_before: case empty
X : Type u_1
Y : Type u_2
inst✝² : TopologicalSpace X
inst✝¹ : T1Space X
inst✝ : ∀ (x : X), (𝓝[≠] x).NeBot
s : Set X
hs : Dense s
⊢ Dense (s \ ↑∅)
state_after: no goals

tactic: rw [Finset.coe_insert, ← union_singleton, ← diff_diff]
state_before: case insert
X : Type u_1
Y : Type u_2
inst✝² : TopologicalSpace X
inst✝¹ : T1Space X
inst✝ : ∀ (x : X), (𝓝[≠] x).NeBot
s : Set X
hs : Dense s
a✝¹ : X
s✝ : Finset X
a✝ : a✝¹ ∉ s✝
ih : Dense (s \ ↑s✝)
⊢ Dense (s \ ↑(insert a✝¹ s✝))
state_after: case insert
X : Type u_1
Y : Type u_2
inst✝² : TopologicalSpace X
inst✝¹ : T1Space X
inst✝ : ∀ (x : X), (𝓝[≠] x).NeBot
s : Set X
hs : Dense s
a✝¹ : X
s✝ : Finset X
a✝ : a✝¹ ∉ s✝
ih : Dense (s \ ↑s✝)
⊢ Dense ((s \ ↑s✝) \ {a✝¹})

tactic: exact ih.diff_singleton _
state_before: case insert
X : Type u_1
Y : Type u_2
inst✝² : TopologicalSpace X
inst✝¹ : T1Space X
inst✝ : ∀ (x : X), (𝓝[≠] x).NeBot
s : Set X
hs : Dense s
a✝¹ : X
s✝ : Finset X
a✝ : a✝¹ ∉ s✝
ih : Dense (s \ ↑s✝)
⊢ Dense ((s \ ↑s✝) \ {a✝¹})
state_after: no goals
Theorem: Filter.Tendsto.atBot_mul_const_of_neg'
File: Mathlib/Order/Filter/Archimedean.lean

tactic: simpa only [mul_neg, tendsto_neg_atBot_iff] using hf.atBot_mul_const' (neg_pos.2 hr)
state_before: α : Type u_1
R : Type u_2
l : Filter α
f : α → R
r : R
inst✝¹ : LinearOrderedRing R
inst✝ : Archimedean R
hr : r < 0
hf : Tendsto f l atBot
⊢ Tendsto (fun x => f x * r) l atTop
state_after: no goals
Theorem: MeasureTheory.right_measure_le_of_levyProkhorovEDist_lt
File: Mathlib/MeasureTheory/Measure/LevyProkhorovMetric.lean

tactic: obtain ⟨c', ⟨hc', lt_c⟩⟩ := sInf_lt_iff.mp h
state_before: ι : Type u_1
Ω : Type u_2
inst✝¹ : MeasurableSpace Ω
inst✝ : PseudoEMetricSpace Ω
μ ν : Measure Ω
c : ℝ≥0∞
h : levyProkhorovEDist μ ν < c
B : Set Ω
B_mble : MeasurableSet B
⊢ ν B ≤ μ (thickening c.toReal B) + c
state_after: case intro.intro
ι : Type u_1
Ω : Type u_2
inst✝¹ : MeasurableSpace Ω
inst✝ : PseudoEMetricSpace Ω
μ ν : Measure Ω
c : ℝ≥0∞
h : levyProkhorovEDist μ ν < c
B : Set Ω
B_mble : MeasurableSet B
c' : ℝ≥0∞
hc' :
  c' ∈ {ε | ∀ (B : Set Ω), MeasurableSet B → μ B ≤ ν (thickening ε.toReal B) + ε ∧ ν B ≤ μ (thickening ε.toReal B) + ε}
lt_c : c' < c
⊢ ν B ≤ μ (thickening c.toReal B) + c

tactic: exact meas_le_of_le_of_forall_le_meas_thickening_add ν μ lt_c.le (hc' B B_mble).2
state_before: case intro.intro
ι : Type u_1
Ω : Type u_2
inst✝¹ : MeasurableSpace Ω
inst✝ : PseudoEMetricSpace Ω
μ ν : Measure Ω
c : ℝ≥0∞
h : levyProkhorovEDist μ ν < c
B : Set Ω
B_mble : MeasurableSet B
c' : ℝ≥0∞
hc' :
  c' ∈ {ε | ∀ (B : Set Ω), MeasurableSet B → μ B ≤ ν (thickening ε.toReal B) + ε ∧ ν B ≤ μ (thickening ε.toReal B) + ε}
lt_c : c' < c
⊢ ν B ≤ μ (thickening c.toReal B) + c
state_after: no goals
Theorem: Matrix.upper_two_blockTriangular
File: Mathlib/LinearAlgebra/Matrix/Block.lean

tactic: rintro (c | c) (d | d) hcd <;> first | simp [hab.not_lt] at hcd ⊢
state_before: α : Type u_1
β : Type u_2
m : Type u_3
n : Type u_4
o : Type u_5
m' : α → Type u_6
n' : α → Type u_7
R : Type v
inst✝¹ : CommRing R
M N : Matrix m m R
b✝ : m → α
inst✝ : Preorder α
A : Matrix m m R
B : Matrix m n R
D : Matrix n n R
a b : α
hab : a < b
⊢ (fromBlocks A B 0 D).BlockTriangular (Sum.elim (fun x => a) fun x => b)
state_after: no goals

tactic: simp [hab.not_lt] at hcd ⊢
state_before: case inr.inr
α : Type u_1
β : Type u_2
m : Type u_3
n : Type u_4
o : Type u_5
m' : α → Type u_6
n' : α → Type u_7
R : Type v
inst✝¹ : CommRing R
M N : Matrix m m R
b✝ : m → α
inst✝ : Preorder α
A : Matrix m m R
B : Matrix m n R
D : Matrix n n R
a b : α
hab : a < b
c d : n
hcd : Sum.elim (fun x => a) (fun x => b) (Sum.inr d) < Sum.elim (fun x => a) (fun x => b) (Sum.inr c)
⊢ fromBlocks A B 0 D (Sum.inr c) (Sum.inr d) = 0
state_after: no goals
Theorem: Ordinal.IsNormal.inj
File: Mathlib/SetTheory/Ordinal/Arithmetic.lean

tactic: simp only [le_antisymm_iff, H.le_iff]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
r : α → α → Prop
s : β → β → Prop
t : γ → γ → Prop
f : Ordinal.{u_4} → Ordinal.{u_5}
H : IsNormal f
a b : Ordinal.{u_4}
⊢ f a = f b ↔ a = b
state_after: no goals
Theorem: Filter.pmap_res
File: Mathlib/Order/Filter/Partial.lean

tactic: ext t
state_before: α : Type u
β : Type v
γ : Type w
l : Filter α
s : Set α
f : α → β
⊢ pmap (PFun.res f s) l = map f (l ⊓ 𝓟 s)
state_after: case a
α : Type u
β : Type v
γ : Type w
l : Filter α
s : Set α
f : α → β
t : Set β
⊢ t ∈ pmap (PFun.res f s) l ↔ t ∈ map f (l ⊓ 𝓟 s)

tactic: simp only [PFun.core_res, mem_pmap, mem_map, mem_inf_principal, imp_iff_not_or]
state_before: case a
α : Type u
β : Type v
γ : Type w
l : Filter α
s : Set α
f : α → β
t : Set β
⊢ t ∈ pmap (PFun.res f s) l ↔ t ∈ map f (l ⊓ 𝓟 s)
state_after: case a
α : Type u
β : Type v
γ : Type w
l : Filter α
s : Set α
f : α → β
t : Set β
⊢ sᶜ ∪ f ⁻¹' t ∈ l ↔ {x | x ∉ s ∨ x ∈ f ⁻¹' t} ∈ l

tactic: rfl
state_before: case a
α : Type u
β : Type v
γ : Type w
l : Filter α
s : Set α
f : α → β
t : Set β
⊢ sᶜ ∪ f ⁻¹' t ∈ l ↔ {x | x ∉ s ∨ x ∈ f ⁻¹' t} ∈ l
state_after: no goals
Theorem: Valuation.isEquiv_valuation_valuationSubring
File: Mathlib/RingTheory/Valuation/ValuationSubring.lean

tactic: rw [isEquiv_iff_val_le_one]
state_before: K : Type u
inst✝³ : Field K
Γ : Type u_1
Γ₁ : Type u_2
Γ₂ : Type u_3
inst✝² : LinearOrderedCommGroupWithZero Γ
inst✝¹ : LinearOrderedCommGroupWithZero Γ₁
inst✝ : LinearOrderedCommGroupWithZero Γ₂
v : Valuation K Γ
v₁ : Valuation K Γ₁
v₂ : Valuation K Γ₂
⊢ v.IsEquiv v.valuationSubring.valuation
state_after: K : Type u
inst✝³ : Field K
Γ : Type u_1
Γ₁ : Type u_2
Γ₂ : Type u_3
inst✝² : LinearOrderedCommGroupWithZero Γ
inst✝¹ : LinearOrderedCommGroupWithZero Γ₁
inst✝ : LinearOrderedCommGroupWithZero Γ₂
v : Valuation K Γ
v₁ : Valuation K Γ₁
v₂ : Valuation K Γ₂
⊢ ∀ {x : K}, v x ≤ 1 ↔ v.valuationSubring.valuation x ≤ 1

tactic: intro x
state_before: K : Type u
inst✝³ : Field K
Γ : Type u_1
Γ₁ : Type u_2
Γ₂ : Type u_3
inst✝² : LinearOrderedCommGroupWithZero Γ
inst✝¹ : LinearOrderedCommGroupWithZero Γ₁
inst✝ : LinearOrderedCommGroupWithZero Γ₂
v : Valuation K Γ
v₁ : Valuation K Γ₁
v₂ : Valuation K Γ₂
⊢ ∀ {x : K}, v x ≤ 1 ↔ v.valuationSubring.valuation x ≤ 1
state_after: K : Type u
inst✝³ : Field K
Γ : Type u_1
Γ₁ : Type u_2
Γ₂ : Type u_3
inst✝² : LinearOrderedCommGroupWithZero Γ
inst✝¹ : LinearOrderedCommGroupWithZero Γ₁
inst✝ : LinearOrderedCommGroupWithZero Γ₂
v : Valuation K Γ
v₁ : Valuation K Γ₁
v₂ : Valuation K Γ₂
x : K
⊢ v x ≤ 1 ↔ v.valuationSubring.valuation x ≤ 1

tactic: rw [ValuationSubring.valuation_le_one_iff]
state_before: K : Type u
inst✝³ : Field K
Γ : Type u_1
Γ₁ : Type u_2
Γ₂ : Type u_3
inst✝² : LinearOrderedCommGroupWithZero Γ
inst✝¹ : LinearOrderedCommGroupWithZero Γ₁
inst✝ : LinearOrderedCommGroupWithZero Γ₂
v : Valuation K Γ
v₁ : Valuation K Γ₁
v₂ : Valuation K Γ₂
x : K
⊢ v x ≤ 1 ↔ v.valuationSubring.valuation x ≤ 1
state_after: K : Type u
inst✝³ : Field K
Γ : Type u_1
Γ₁ : Type u_2
Γ₂ : Type u_3
inst✝² : LinearOrderedCommGroupWithZero Γ
inst✝¹ : LinearOrderedCommGroupWithZero Γ₁
inst✝ : LinearOrderedCommGroupWithZero Γ₂
v : Valuation K Γ
v₁ : Valuation K Γ₁
v₂ : Valuation K Γ₂
x : K
⊢ v x ≤ 1 ↔ x ∈ v.valuationSubring

tactic: rfl
state_before: K : Type u
inst✝³ : Field K
Γ : Type u_1
Γ₁ : Type u_2
Γ₂ : Type u_3
inst✝² : LinearOrderedCommGroupWithZero Γ
inst✝¹ : LinearOrderedCommGroupWithZero Γ₁
inst✝ : LinearOrderedCommGroupWithZero Γ₂
v : Valuation K Γ
v₁ : Valuation K Γ₁
v₂ : Valuation K Γ₂
x : K
⊢ v x ≤ 1 ↔ x ∈ v.valuationSubring
state_after: no goals
Theorem: Set.div_subset_range
File: Mathlib/Data/Set/Pointwise/Basic.lean

tactic: rintro _ ⟨a, ha, b, hb, rfl⟩
state_before: F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
inst✝³ : Group α
inst✝² : DivisionMonoid β
inst✝¹ : FunLike F α β
inst✝ : MonoidHomClass F α β
m : F
s✝ t✝ : Set α
s t : Set β
hs : s ⊆ range ⇑m
ht : t ⊆ range ⇑m
⊢ s / t ⊆ range ⇑m
state_after: case intro.intro.intro.intro
F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
inst✝³ : Group α
inst✝² : DivisionMonoid β
inst✝¹ : FunLike F α β
inst✝ : MonoidHomClass F α β
m : F
s✝ t✝ : Set α
s t : Set β
hs : s ⊆ range ⇑m
ht : t ⊆ range ⇑m
a : β
ha : a ∈ s
b : β
hb : b ∈ t
⊢ (fun x x_1 => x / x_1) a b ∈ range ⇑m

tactic: obtain ⟨a, rfl⟩ := hs ha
state_before: case intro.intro.intro.intro
F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
inst✝³ : Group α
inst✝² : DivisionMonoid β
inst✝¹ : FunLike F α β
inst✝ : MonoidHomClass F α β
m : F
s✝ t✝ : Set α
s t : Set β
hs : s ⊆ range ⇑m
ht : t ⊆ range ⇑m
a : β
ha : a ∈ s
b : β
hb : b ∈ t
⊢ (fun x x_1 => x / x_1) a b ∈ range ⇑m
state_after: case intro.intro.intro.intro.intro
F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
inst✝³ : Group α
inst✝² : DivisionMonoid β
inst✝¹ : FunLike F α β
inst✝ : MonoidHomClass F α β
m : F
s✝ t✝ : Set α
s t : Set β
hs : s ⊆ range ⇑m
ht : t ⊆ range ⇑m
b : β
hb : b ∈ t
a : α
ha : m a ∈ s
⊢ (fun x x_1 => x / x_1) (m a) b ∈ range ⇑m

tactic: obtain ⟨b, rfl⟩ := ht hb
state_before: case intro.intro.intro.intro.intro
F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
inst✝³ : Group α
inst✝² : DivisionMonoid β
inst✝¹ : FunLike F α β
inst✝ : MonoidHomClass F α β
m : F
s✝ t✝ : Set α
s t : Set β
hs : s ⊆ range ⇑m
ht : t ⊆ range ⇑m
b : β
hb : b ∈ t
a : α
ha : m a ∈ s
⊢ (fun x x_1 => x / x_1) (m a) b ∈ range ⇑m
state_after: case intro.intro.intro.intro.intro.intro
F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
inst✝³ : Group α
inst✝² : DivisionMonoid β
inst✝¹ : FunLike F α β
inst✝ : MonoidHomClass F α β
m : F
s✝ t✝ : Set α
s t : Set β
hs : s ⊆ range ⇑m
ht : t ⊆ range ⇑m
a : α
ha : m a ∈ s
b : α
hb : m b ∈ t
⊢ (fun x x_1 => x / x_1) (m a) (m b) ∈ range ⇑m

tactic: exact ⟨a / b, map_div _ _ _⟩
state_before: case intro.intro.intro.intro.intro.intro
F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
inst✝³ : Group α
inst✝² : DivisionMonoid β
inst✝¹ : FunLike F α β
inst✝ : MonoidHomClass F α β
m : F
s✝ t✝ : Set α
s t : Set β
hs : s ⊆ range ⇑m
ht : t ⊆ range ⇑m
a : α
ha : m a ∈ s
b : α
hb : m b ∈ t
⊢ (fun x x_1 => x / x_1) (m a) (m b) ∈ range ⇑m
state_after: no goals
Theorem: MeasureTheory.Measure.inv_rnDeriv'
File: Mathlib/MeasureTheory/Decomposition/RadonNikodym.lean

tactic: filter_upwards [inv_rnDeriv hμν] with x hx
state_before: α : Type u_1
β : Type u_2
m : MeasurableSpace α
μ ν : Measure α
inst✝¹ : SigmaFinite μ
inst✝ : SigmaFinite ν
hμν : μ ≪ ν
⊢ (ν.rnDeriv μ)⁻¹ =ᶠ[ae μ] μ.rnDeriv ν
state_after: case h
α : Type u_1
β : Type u_2
m : MeasurableSpace α
μ ν : Measure α
inst✝¹ : SigmaFinite μ
inst✝ : SigmaFinite ν
hμν : μ ≪ ν
x : α
hx : (μ.rnDeriv ν)⁻¹ x = ν.rnDeriv μ x
⊢ (ν.rnDeriv μ)⁻¹ x = μ.rnDeriv ν x

tactic: simp only [Pi.inv_apply, ← hx, inv_inv]
state_before: case h
α : Type u_1
β : Type u_2
m : MeasurableSpace α
μ ν : Measure α
inst✝¹ : SigmaFinite μ
inst✝ : SigmaFinite ν
hμν : μ ≪ ν
x : α
hx : (μ.rnDeriv ν)⁻¹ x = ν.rnDeriv μ x
⊢ (ν.rnDeriv μ)⁻¹ x = μ.rnDeriv ν x
state_after: no goals
Theorem: inner_matrix_row_row
File: Mathlib/Analysis/InnerProductSpace/PiL2.lean

tactic: simp_rw [EuclideanSpace.inner_piLp_equiv_symm, Matrix.mul_apply', Matrix.dotProduct_comm,
  Matrix.conjTranspose_apply, Pi.star_def]
state_before: ι : Type u_1
ι' : Type u_2
𝕜 : Type u_3
inst✝¹⁰ : _root_.RCLike 𝕜
E : Type u_4
inst✝⁹ : NormedAddCommGroup E
inst✝⁸ : InnerProductSpace 𝕜 E
E' : Type u_5
inst✝⁷ : NormedAddCommGroup E'
inst✝⁶ : InnerProductSpace 𝕜 E'
F : Type u_6
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : InnerProductSpace ℝ F
F' : Type u_7
inst✝³ : NormedAddCommGroup F'
inst✝² : InnerProductSpace ℝ F'
inst✝¹ : Fintype ι
m : Type u_8
n : Type u_9
inst✝ : Fintype n
A B : Matrix m n 𝕜
i j : m
⊢ ⟪(WithLp.equiv 2 (n → 𝕜)).symm (A i), (WithLp.equiv 2 (n → 𝕜)).symm (B j)⟫_𝕜 = (B * Aᴴ) j i
state_after: no goals
Theorem: Fin.insertNth_zero_right
File: Mathlib/Data/Fin/Tuple/Basic.lean

tactic: simp [succAbove_ne, Pi.zero_def]
state_before: m n : ℕ
α : Fin (n + 1) → Type u
β : Type v
inst✝ : (j : Fin (n + 1)) → Zero (α j)
i : Fin (n + 1)
x : α i
⊢ Pi.single i x i = x ∧ 0 = fun j => Pi.single i x (i.succAbove j)
state_after: no goals
Theorem: Turing.ListBlank.nth_succ
File: Mathlib/Computability/TuringMachine.lean

tactic: conv => lhs; rw [← ListBlank.cons_head_tail l]
state_before: Γ : Type u_1
inst✝ : Inhabited Γ
l : ListBlank Γ
n : ℕ
⊢ l.nth (n + 1) = l.tail.nth n
state_after: Γ : Type u_1
inst✝ : Inhabited Γ
l : ListBlank Γ
n : ℕ
⊢ (cons l.head l.tail).nth (n + 1) = l.tail.nth n

tactic: exact Quotient.inductionOn' l.tail fun l ↦ rfl
state_before: Γ : Type u_1
inst✝ : Inhabited Γ
l : ListBlank Γ
n : ℕ
⊢ (cons l.head l.tail).nth (n + 1) = l.tail.nth n
state_after: no goals