tasksource/leandojo huggingface dataset:
Theorem: BoxIntegral.Prepartition.IsPartition.exists_splitMany_le
File: Mathlib/Analysis/BoxIntegral/Partition/Split.lean

tactic: refine' (eventually_splitMany_inf_eq_filter π).exists.imp fun s hs => _
state_before: ι : Type u_1
M : Type ?u.55340
n : ℕ
I✝ J : Box ι
i : ι
x : ℝ
inst✝ : Finite ι
I : Box ι
π : Prepartition I
h : IsPartition π
⊢ ∃ s, splitMany I s ≤ π

tactic: rwa [h.iUnion_eq, filter_of_true, inf_eq_right] at hs
state_before: ι : Type u_1
M : Type ?u.55340
n : ℕ
I✝ J : Box ι
i : ι
x : ℝ
inst✝ : Finite ι
I : Box ι
π : Prepartition I
h : IsPartition π
s : Finset (ι × ℝ)
hs : π ⊓ splitMany I s = filter (splitMany I s) fun J => ↑J ⊆ Prepartition.iUnion π
⊢ splitMany I s ≤ π

tactic: exact fun J hJ => le_of_mem _ hJ
state_before: case hp
ι : Type u_1
M : Type ?u.55340
n : ℕ
I✝ J : Box ι
i : ι
x : ℝ
inst✝ : Finite ι
I : Box ι
π : Prepartition I
h : IsPartition π
s : Finset (ι × ℝ)
hs : π ⊓ splitMany I s = filter (splitMany I s) fun J => ↑J ⊆ ↑I
⊢ ∀ (J : Box ι), J ∈ splitMany I s → ↑J ⊆ ↑I
Theorem: Subgroup.relindex_mul_relindex
File: Mathlib/GroupTheory/Index.lean

tactic: rw [← relindex_subgroupOf hKL]
state_before: G : Type u_1
inst✝ : Group G
H K L : Subgroup G
hHK : H ≤ K
hKL : K ≤ L
⊢ relindex H K * relindex K L = relindex H L

tactic: exact relindex_mul_index fun x hx => hHK hx
state_before: G : Type u_1
inst✝ : Group G
H K L : Subgroup G
hHK : H ≤ K
hKL : K ≤ L
⊢ relindex (subgroupOf H L) (subgroupOf K L) * relindex K L = relindex H L
Theorem: bot_lt_affineSpan
File: Mathlib/LinearAlgebra/AffineSpace/AffineSubspace.lean

tactic: rw [bot_lt_iff_ne_bot, nonempty_iff_ne_empty]
state_before: k : Type u_2
V : Type u_3
P : Type u_1
inst✝³ : Ring k
inst✝² : AddCommGroup V
inst✝¹ : Module k V
inst✝ : AffineSpace V P
ι : Type ?u.337806
s : Set P
⊢ ⊥ < affineSpan k s ↔ Set.Nonempty s

tactic: exact (affineSpan_eq_bot _).not
state_before: k : Type u_2
V : Type u_3
P : Type u_1
inst✝³ : Ring k
inst✝² : AddCommGroup V
inst✝¹ : Module k V
inst✝ : AffineSpace V P
ι : Type ?u.337806
s : Set P
⊢ affineSpan k s ≠ ⊥ ↔ s ≠ ∅
Theorem: CircleDeg1Lift.map_lt_add_translationNumber_add_one
File: Mathlib/Dynamics/Circle/RotationNumber/TranslationNumber.lean

tactic: gcongr
state_before: f g : CircleDeg1Lift
x : ℝ
⊢ x + ↑⌊τ f⌋ + 1 ≤ x + τ f + 1

tactic: apply floor_le
state_before: case bc.bc
f g : CircleDeg1Lift
x : ℝ
⊢ ↑⌊τ f⌋ ≤ τ f
Theorem: Ideal.coprime_of_no_prime_ge
File: Mathlib/RingTheory/DedekindDomain/Ideal.lean

tactic: by_contra hIJ
state_before: R : Type u_1
A : Type ?u.1171353
K : Type ?u.1171356
inst✝³ : CommRing R
inst✝² : CommRing A
inst✝¹ : Field K
inst✝ : IsDomain A
I J : Ideal R
h : ∀ (P : Ideal R), I ≤ P → J ≤ P → ¬IsPrime P
⊢ I ⊔ J = ⊤

tactic: obtain ⟨P, hP, hIJ⟩ := Ideal.exists_le_maximal _ hIJ
state_before: R : Type u_1
A : Type ?u.1171353
K : Type ?u.1171356
inst✝³ : CommRing R
inst✝² : CommRing A
inst✝¹ : Field K
inst✝ : IsDomain A
I J : Ideal R
h : ∀ (P : Ideal R), I ≤ P → J ≤ P → ¬IsPrime P
hIJ : ¬I ⊔ J = ⊤
⊢ False

tactic: exact h P (le_trans le_sup_left hIJ) (le_trans le_sup_right hIJ) hP.isPrime
state_before: case intro.intro
R : Type u_1
A : Type ?u.1171353
K : Type ?u.1171356
inst✝³ : CommRing R
inst✝² : CommRing A
inst✝¹ : Field K
inst✝ : IsDomain A
I J : Ideal R
h : ∀ (P : Ideal R), I ≤ P → J ≤ P → ¬IsPrime P
hIJ✝ : ¬I ⊔ J = ⊤
P : Ideal R
hP : IsMaximal P
hIJ : I ⊔ J ≤ P
⊢ False
Theorem: Turing.ToPartrec.Code.pred_eval
File: Mathlib/Computability/TMToPartrec.lean

tactic: simp [pred]
state_before: v : List ℕ
⊢ eval pred v = pure [Nat.pred (List.headI v)]

tactic: cases v.headI <;> simp
state_before: v : List ℕ
⊢ Nat.rec (Part.some [0]) (fun y x => Part.some [y]) (List.headI v) = Part.some [Nat.pred (List.headI v)]
Theorem: Real.sInf_le_iff
File: Mathlib/Data/Real/Basic.lean

tactic: rw [le_iff_forall_pos_lt_add]
state_before: x y : ℝ
s : Set ℝ
h : BddBelow s
h' : Set.Nonempty s
a : ℝ
⊢ sInf s ≤ a ↔ ∀ (ε : ℝ), 0 < ε → ∃ x, x ∈ s ∧ x < a + ε

tactic: constructor <;> intro H ε ε_pos
state_before: x y : ℝ
s : Set ℝ
h : BddBelow s
h' : Set.Nonempty s
a : ℝ
⊢ (∀ (ε : ℝ), 0 < ε → sInf s < a + ε) ↔ ∀ (ε : ℝ), 0 < ε → ∃ x, x ∈ s ∧ x < a + ε

tactic: exact exists_lt_of_csInf_lt h' (H ε ε_pos)
state_before: case mp
x y : ℝ
s : Set ℝ
h : BddBelow s
h' : Set.Nonempty s
a : ℝ
H : ∀ (ε : ℝ), 0 < ε → sInf s < a + ε
ε : ℝ
ε_pos : 0 < ε
⊢ ∃ x, x ∈ s ∧ x < a + ε

tactic: rcases H ε ε_pos with ⟨x, x_in, hx⟩
state_before: case mpr
x y : ℝ
s : Set ℝ
h : BddBelow s
h' : Set.Nonempty s
a : ℝ
H : ∀ (ε : ℝ), 0 < ε → ∃ x, x ∈ s ∧ x < a + ε
ε : ℝ
ε_pos : 0 < ε
⊢ sInf s < a + ε

tactic: exact csInf_lt_of_lt h x_in hx
state_before: case mpr.intro.intro
x✝ y : ℝ
s : Set ℝ
h : BddBelow s
h' : Set.Nonempty s
a : ℝ
H : ∀ (ε : ℝ), 0 < ε → ∃ x, x ∈ s ∧ x < a + ε
ε : ℝ
ε_pos : 0 < ε
x : ℝ
x_in : x ∈ s
hx : x < a + ε
⊢ sInf s < a + ε
Theorem: Real.cos_pi_div_sixteen
File: Mathlib/Analysis/SpecialFunctions/Trigonometric/Basic.lean

tactic: trans cos (π / 2 ^ 4)
state_before: x : ℝ
⊢ cos (π / 16) = sqrt (2 + sqrt (2 + sqrt 2)) / 2

tactic: congr
state_before: x : ℝ
⊢ cos (π / 16) = cos (π / 2 ^ 4)

x : ℝ
⊢ cos (π / 2 ^ 4) = sqrt (2 + sqrt (2 + sqrt 2)) / 2

tactic: norm_num
state_before: case e_x.e_a
x : ℝ
⊢ 16 = 2 ^ 4

x : ℝ
⊢ cos (π / 2 ^ 4) = sqrt (2 + sqrt (2 + sqrt 2)) / 2

tactic: simp
state_before: x : ℝ
⊢ cos (π / 2 ^ 4) = sqrt (2 + sqrt (2 + sqrt 2)) / 2
Theorem: Cardinal.aleph'_limit
File: Mathlib/SetTheory/Cardinal/Ordinal.lean

tactic: refine' le_antisymm _ (ciSup_le' fun i => aleph'_le.2 (le_of_lt i.2))
state_before: o : Ordinal
ho : Ordinal.IsLimit o
⊢ aleph' o = ⨆ (a : ↑(Iio o)), aleph' ↑a

tactic: rw [aleph'_le_of_limit ho]
state_before: o : Ordinal
ho : Ordinal.IsLimit o
⊢ aleph' o ≤ ⨆ (a : ↑(Iio o)), aleph' ↑a

tactic: exact fun a ha => le_ciSup (bddAbove_of_small _) (⟨a, ha⟩ : Iio o)
state_before: o : Ordinal
ho : Ordinal.IsLimit o
⊢ ∀ (o' : Ordinal), o' < o → aleph' o' ≤ ⨆ (a : ↑(Iio o)), aleph' ↑a
Theorem: MeasureTheory.VectorMeasure.map_apply
File: Mathlib/MeasureTheory/Measure/VectorMeasure.lean

tactic: rw [map, dif_pos hf]
state_before: α : Type u_1
β : Type u_2
m inst✝³ : MeasurableSpace α
inst✝² : MeasurableSpace β
M : Type u_3
inst✝¹ : AddCommMonoid M
inst✝ : TopologicalSpace M
v : VectorMeasure α M
f : α → β
hf : Measurable f
s : Set β
hs : MeasurableSet s
⊢ ↑(map v f) s = ↑v (f ⁻¹' s)

tactic: exact if_pos hs
state_before: α : Type u_1
β : Type u_2
m inst✝³ : MeasurableSpace α
inst✝² : MeasurableSpace β
M : Type u_3
inst✝¹ : AddCommMonoid M
inst✝ : TopologicalSpace M
v : VectorMeasure α M
f : α → β
hf : Measurable f
s : Set β
hs : MeasurableSet s
⊢ ↑{ measureOf' := fun s => if MeasurableSet s then ↑v (f ⁻¹' s) else 0,
          empty' := (_ : (if MeasurableSet ∅ then ↑v (f ⁻¹' ∅) else 0) = 0),
          not_measurable' := (_ : ∀ (i : Set β), ¬MeasurableSet i → (if MeasurableSet i then ↑v (f ⁻¹' i) else 0) = 0),
          m_iUnion' :=
            (_ :
              ∀ ⦃g : ℕ → Set β⦄,
                (∀ (i : ℕ), MeasurableSet (g i)) →
                  Pairwise (Disjoint on g) →
                    HasSum (fun i => (fun s => if MeasurableSet s then ↑v (f ⁻¹' s) else 0) (g i))
                      ((fun s => if MeasurableSet s then ↑v (f ⁻¹' s) else 0) (⋃ (i : ℕ), g i))) }
      s =
    ↑v (f ⁻¹' s)
Theorem: Polynomial.degree_C_mul
File: Mathlib/Data/Polynomial/Degree/Lemmas.lean

tactic: rw [degree_mul, degree_C a0, zero_add]
state_before: R : Type u
S : Type v
ι : Type w
a b : R
m n : ℕ
inst✝¹ : Semiring R
inst✝ : NoZeroDivisors R
p q : R[X]
a0 : a ≠ 0
⊢ degree (↑C a * p) = degree p
Theorem: Coheyting.hnot_boundary
File: Mathlib/Order/Heyting/Boundary.lean

tactic: rw [boundary, hnot_inf_distrib, sup_hnot_self]
state_before: α : Type u_1
inst✝ : CoheytingAlgebra α
a✝ b a : α
⊢ ￢∂ a = ⊤
Theorem: FreeGroup.toWord_inv
File: Mathlib/GroupTheory/FreeGroup.lean

tactic: rcases x with ⟨L⟩
state_before: α : Type u
L L₁ L₂ L₃ L₄ : List (α × Bool)
inst✝ : DecidableEq α
x : FreeGroup α
⊢ toWord x⁻¹ = invRev (toWord x)

tactic: rw [quot_mk_eq_mk, inv_mk, toWord_mk, toWord_mk, reduce_invRev]
state_before: case mk
α : Type u
L✝ L₁ L₂ L₃ L₄ : List (α × Bool)
inst✝ : DecidableEq α
x : FreeGroup α
L : List (α × Bool)
⊢ toWord (Quot.mk Red.Step L)⁻¹ = invRev (toWord (Quot.mk Red.Step L))
Theorem: Composition.ne_ones_iff
File: Mathlib/Combinatorics/Composition.lean

tactic: refine' (not_congr eq_ones_iff).trans _
state_before: n : ℕ
c✝ c : Composition n
⊢ c ≠ ones n ↔ ∃ i, i ∈ c.blocks ∧ 1 < i

tactic: have : ∀ j ∈ c.blocks, j = 1 ↔ j ≤ 1 := fun j hj => by simp [le_antisymm_iff, c.one_le_blocks hj]
state_before: n : ℕ
c✝ c : Composition n
⊢ (¬∀ (i : ℕ), i ∈ c.blocks → i = 1) ↔ ∃ i, i ∈ c.blocks ∧ 1 < i

tactic: simp (config := { contextual := true }) [this]
state_before: n : ℕ
c✝ c : Composition n
this : ∀ (j : ℕ), j ∈ c.blocks → (j = 1 ↔ j ≤ 1)
⊢ (¬∀ (i : ℕ), i ∈ c.blocks → i = 1) ↔ ∃ i, i ∈ c.blocks ∧ 1 < i

tactic: simp [le_antisymm_iff, c.one_le_blocks hj]
state_before: n : ℕ
c✝ c : Composition n
j : ℕ
hj : j ∈ c.blocks
⊢ j = 1 ↔ j ≤ 1
Theorem: div_mul_cancel_of_imp
File: Mathlib/Algebra/GroupWithZero/Units/Lemmas.lean

tactic: simp [*]
state_before: α : Type ?u.8884
M₀ : Type ?u.8887
G₀ : Type u_1
M₀' : Type ?u.8893
G₀' : Type ?u.8896
F : Type ?u.8899
F' : Type ?u.8902
inst✝¹ : MonoidWithZero M₀
inst✝ : GroupWithZero G₀
a✝ b✝ c a b : G₀
h : b = 0 → a = 0
hb : b = 0
⊢ a / b * b = a
Theorem: Nat.sub_eq_psub
File: Mathlib/Data/Nat/PSub.lean

tactic: rw [sub_eq_psub m n, psub]
state_before: m n : ℕ
⊢ Option.getD (ppred (m - n)) 0 = Option.getD (psub m (n + 1)) 0

tactic: cases psub m n <;> rfl
state_before: m n : ℕ
⊢ Option.getD (ppred (Option.getD (psub m n) 0)) 0 = Option.getD (psub m n >>= ppred) 0
Theorem: Pell.dvd_of_ysq_dvd
File: Mathlib/NumberTheory/PellMatiyasevic.lean

tactic: rwa [n0] at nt ⊢
state_before: a : ℕ
a1 : 1 < a
n t : ℕ
h : yn a1 n * yn a1 n ∣ yn a1 t
nt : n ∣ t
n0 : n = 0
⊢ yn a1 n ∣ t

tactic: let ⟨k, ke⟩ := nt
state_before: a : ℕ
a1 : 1 < a
n t : ℕ
h : yn a1 n * yn a1 n ∣ yn a1 t
nt : n ∣ t
n0l : 0 < n
⊢ yn a1 n ∣ t

tactic: have : yn a1 n ∣ k * xn a1 n ^ (k - 1) :=
  Nat.dvd_of_mul_dvd_mul_right (strictMono_y a1 n0l) <|
    modEq_zero_iff_dvd.1 <| by
      have xm := (xy_modEq_yn a1 n k).right; rw [← ke] at xm
      exact (xm.of_dvd <| by simp [_root_.pow_succ]).symm.trans h.modEq_zero_nat
state_before: a : ℕ
a1 : 1 < a
n t : ℕ
h : yn a1 n * yn a1 n ∣ yn a1 t
nt : n ∣ t
n0l : 0 < n
k : ℕ
ke : t = n * k
⊢ yn a1 n ∣ t

tactic: rw [ke]
state_before: a : ℕ
a1 : 1 < a
n t : ℕ
h : yn a1 n * yn a1 n ∣ yn a1 t
nt : n ∣ t
n0l : 0 < n
k : ℕ
ke : t = n * k
this : yn a1 n ∣ k * xn a1 n ^ (k - 1)
⊢ yn a1 n ∣ t

tactic: exact dvd_mul_of_dvd_right (((xy_coprime _ _).pow_left _).symm.dvd_of_dvd_mul_right this) _
state_before: a : ℕ
a1 : 1 < a
n t : ℕ
h : yn a1 n * yn a1 n ∣ yn a1 t
nt : n ∣ t
n0l : 0 < n
k : ℕ
ke : t = n * k
this : yn a1 n ∣ k * xn a1 n ^ (k - 1)
⊢ yn a1 n ∣ n * k

tactic: have xm := (xy_modEq_yn a1 n k).right
state_before: a : ℕ
a1 : 1 < a
n t : ℕ
h : yn a1 n * yn a1 n ∣ yn a1 t
nt : n ∣ t
n0l : 0 < n
k : ℕ
ke : t = n * k
⊢ k * xn a1 n ^ (k - 1) * yn a1 n ≡ 0 [MOD yn a1 n * yn a1 n]

tactic: rw [← ke] at xm
state_before: a : ℕ
a1 : 1 < a
n t : ℕ
h : yn a1 n * yn a1 n ∣ yn a1 t
nt : n ∣ t
n0l : 0 < n
k : ℕ
ke : t = n * k
xm : yn a1 (n * k) ≡ k * xn a1 n ^ (k - 1) * yn a1 n [MOD yn a1 n ^ 3]
⊢ k * xn a1 n ^ (k - 1) * yn a1 n ≡ 0 [MOD yn a1 n * yn a1 n]

tactic: exact (xm.of_dvd <| by simp [_root_.pow_succ]).symm.trans h.modEq_zero_nat
state_before: a : ℕ
a1 : 1 < a
n t : ℕ
h : yn a1 n * yn a1 n ∣ yn a1 t
nt : n ∣ t
n0l : 0 < n
k : ℕ
ke : t = n * k
xm : yn a1 t ≡ k * xn a1 n ^ (k - 1) * yn a1 n [MOD yn a1 n ^ 3]
⊢ k * xn a1 n ^ (k - 1) * yn a1 n ≡ 0 [MOD yn a1 n * yn a1 n]

tactic: simp [_root_.pow_succ]
state_before: a : ℕ
a1 : 1 < a
n t : ℕ
h : yn a1 n * yn a1 n ∣ yn a1 t
nt : n ∣ t
n0l : 0 < n
k : ℕ
ke : t = n * k
xm : yn a1 t ≡ k * xn a1 n ^ (k - 1) * yn a1 n [MOD yn a1 n ^ 3]
⊢ yn a1 n * yn a1 n ∣ yn a1 n ^ 3
Theorem: gronwallBound_ε0_δ0
File: Mathlib/Analysis/ODE/Gronwall.lean

tactic: simp only [gronwallBound_ε0, MulZeroClass.zero_mul]
state_before: E : Type ?u.31080
inst✝³ : NormedAddCommGroup E
inst✝² : NormedSpace ℝ E
F : Type ?u.31176
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedSpace ℝ F
K x : ℝ
⊢ gronwallBound 0 K 0 x = 0
Theorem: cauchySeq_of_edist_le_of_tsum_ne_top
File: Mathlib/Topology/Instances/ENNReal.lean

tactic: lift d to ℕ → NNReal using fun i => ENNReal.ne_top_of_tsum_ne_top hd i
state_before: α : Type u_1
β : Type ?u.428595
γ : Type ?u.428598
inst✝ : PseudoEMetricSpace α
f : ℕ → α
d : ℕ → ℝ≥0∞
hf : ∀ (n : ℕ), edist (f n) (f (Nat.succ n)) ≤ d n
hd : tsum d ≠ ⊤
⊢ CauchySeq f

tactic: rw [ENNReal.tsum_coe_ne_top_iff_summable] at hd
state_before: case intro
α : Type u_1
β : Type ?u.428595
γ : Type ?u.428598
inst✝ : PseudoEMetricSpace α
f : ℕ → α
d : ℕ → ℝ≥0
hf : ∀ (n : ℕ), edist (f n) (f (Nat.succ n)) ≤ (fun i => ↑(d i)) n
hd : (∑' (i : ℕ), ↑(d i)) ≠ ⊤
⊢ CauchySeq f

tactic: exact cauchySeq_of_edist_le_of_summable d hf hd
state_before: case intro
α : Type u_1
β : Type ?u.428595
γ : Type ?u.428598
inst✝ : PseudoEMetricSpace α
f : ℕ → α
d : ℕ → ℝ≥0
hf : ∀ (n : ℕ), edist (f n) (f (Nat.succ n)) ≤ (fun i => ↑(d i)) n
hd : Summable fun i => d i
⊢ CauchySeq f
Theorem: DoubleCentralizer.range_toProdMulOpposite
File: Mathlib/Analysis/NormedSpace/Star/Multiplier.lean

tactic: rintro ⟨a, rfl⟩
state_before: 𝕜 : Type u_2
A : Type u_1
inst✝⁴ : NontriviallyNormedField 𝕜
inst✝³ : NonUnitalNormedRing A
inst✝² : NormedSpace 𝕜 A
inst✝¹ : SMulCommClass 𝕜 A A
inst✝ : IsScalarTower 𝕜 A A
x : (A →L[𝕜] A) × (A →L[𝕜] A)ᵐᵒᵖ
⊢ x ∈ Set.range toProdMulOpposite → x ∈ {lr | ∀ (x y : A), ↑(unop lr.snd) x * y = x * ↑lr.fst y}

tactic: exact a.central
state_before: case intro
𝕜 : Type u_2
A : Type u_1
inst✝⁴ : NontriviallyNormedField 𝕜
inst✝³ : NonUnitalNormedRing A
inst✝² : NormedSpace 𝕜 A
inst✝¹ : SMulCommClass 𝕜 A A
inst✝ : IsScalarTower 𝕜 A A
a : 𝓜(𝕜, A)
⊢ toProdMulOpposite a ∈ {lr | ∀ (x y : A), ↑(unop lr.snd) x * y = x * ↑lr.fst y}
Theorem: norm_div_sub_norm_div_le_norm_div
File: Mathlib/Analysis/Normed/Group/Basic.lean

tactic: simpa only [div_div_div_cancel_right'] using norm_sub_norm_le' (u / w) (v / w)
state_before: 𝓕 : Type ?u.97651
𝕜 : Type ?u.97654
α : Type ?u.97657
ι : Type ?u.97660
κ : Type ?u.97663
E : Type u_1
F : Type ?u.97669
G : Type ?u.97672
inst✝² : SeminormedGroup E
inst✝¹ : SeminormedGroup F
inst✝ : SeminormedGroup G
s : Set E
a a₁ a₂ b b₁ b₂ : E
r r₁ r₂ : ℝ
u v w : E
⊢ ‖u / w‖ - ‖v / w‖ ≤ ‖u / v‖
Theorem: Finset.min_singleton
File: Mathlib/Data/Finset/Lattice.lean

tactic: rw [← insert_emptyc_eq]
state_before: F : Type ?u.323869
α : Type u_1
β : Type ?u.323875
γ : Type ?u.323878
ι : Type ?u.323881
κ : Type ?u.323884
inst✝ : LinearOrder α
a : α
⊢ Finset.min {a} = ↑a

tactic: exact min_insert
state_before: F : Type ?u.323869
α : Type u_1
β : Type ?u.323875
γ : Type ?u.323878
ι : Type ?u.323881
κ : Type ?u.323884
inst✝ : LinearOrder α
a : α
⊢ Finset.min (insert a ∅) = ↑a
Theorem: padicNorm.zero
File: Mathlib/NumberTheory/Padics/PadicNorm.lean

tactic: simp [padicNorm]
state_before: p : ℕ
⊢ padicNorm p 0 = 0
Theorem: EReal.coe_ennreal_add
File: Mathlib/Data/Real/EReal.lean

tactic: cases x <;> cases y <;> rfl
state_before: x y : ℝ≥0∞
⊢ ↑(x + y) = ↑x + ↑y
Theorem: Finite.card_eq
File: Mathlib/Data/Finite/Card.lean

tactic: haveI := Fintype.ofFinite α
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.1360
inst✝¹ : Finite α
inst✝ : Finite β
⊢ Nat.card α = Nat.card β ↔ Nonempty (α ≃ β)

tactic: haveI := Fintype.ofFinite β
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.1360
inst✝¹ : Finite α
inst✝ : Finite β
this : Fintype α
⊢ Nat.card α = Nat.card β ↔ Nonempty (α ≃ β)

tactic: simp only [Nat.card_eq_fintype_card, Fintype.card_eq]
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.1360
inst✝¹ : Finite α
inst✝ : Finite β
this✝ : Fintype α
this : Fintype β
⊢ Nat.card α = Nat.card β ↔ Nonempty (α ≃ β)
Theorem: Fin.pred_one
File: Mathlib/Data/Fin/Basic.lean

tactic: ext
state_before: n✝ m n : ℕ
⊢ pred 1 (_ : 1 ≠ 0) = 0

tactic: simp
state_before: case h
n✝ m n : ℕ
⊢ ↑(pred 1 (_ : 1 ≠ 0)) = ↑0
Theorem: LieSubalgebra.coe_lieSpan_submodule_eq_iff
File: Mathlib/Algebra/Lie/Subalgebra.lean

tactic: rw [p.exists_lieSubalgebra_coe_eq_iff]
state_before: R : Type u
L : Type v
inst✝⁴ : CommRing R
inst✝³ : LieRing L
inst✝² : LieAlgebra R L
L₂ : Type w
inst✝¹ : LieRing L₂
inst✝ : LieAlgebra R L₂
f : L →ₗ⁅R⁆ L₂
K K' : LieSubalgebra R L
K₂ : LieSubalgebra R L₂
s : Set L
p : Submodule R L
⊢ (lieSpan R L ↑p).toSubmodule = p ↔ ∃ K, K.toSubmodule = p

tactic: constructor <;> intro h
state_before: R : Type u
L : Type v
inst✝⁴ : CommRing R
inst✝³ : LieRing L
inst✝² : LieAlgebra R L
L₂ : Type w
inst✝¹ : LieRing L₂
inst✝ : LieAlgebra R L₂
f : L →ₗ⁅R⁆ L₂
K K' : LieSubalgebra R L
K₂ : LieSubalgebra R L₂
s : Set L
p : Submodule R L
⊢ (lieSpan R L ↑p).toSubmodule = p ↔ ∀ (x y : L), x ∈ p → y ∈ p → ⁅x, y⁆ ∈ p

tactic: intro x m hm
state_before: case mp
R : Type u
L : Type v
inst✝⁴ : CommRing R
inst✝³ : LieRing L
inst✝² : LieAlgebra R L
L₂ : Type w
inst✝¹ : LieRing L₂
inst✝ : LieAlgebra R L₂
f : L →ₗ⁅R⁆ L₂
K K' : LieSubalgebra R L
K₂ : LieSubalgebra R L₂
s : Set L
p : Submodule R L
h : (lieSpan R L ↑p).toSubmodule = p
⊢ ∀ (x y : L), x ∈ p → y ∈ p → ⁅x, y⁆ ∈ p

tactic: rw [← h, mem_coe_submodule]
state_before: case mp
R : Type u
L : Type v
inst✝⁴ : CommRing R
inst✝³ : LieRing L
inst✝² : LieAlgebra R L
L₂ : Type w
inst✝¹ : LieRing L₂
inst✝ : LieAlgebra R L₂
f : L →ₗ⁅R⁆ L₂
K K' : LieSubalgebra R L
K₂ : LieSubalgebra R L₂
s : Set L
p : Submodule R L
h : (lieSpan R L ↑p).toSubmodule = p
x m : L
hm : x ∈ p
⊢ m ∈ p → ⁅x, m⁆ ∈ p

tactic: exact lie_mem _ (subset_lieSpan hm)
state_before: case mp
R : Type u
L : Type v
inst✝⁴ : CommRing R
inst✝³ : LieRing L
inst✝² : LieAlgebra R L
L₂ : Type w
inst✝¹ : LieRing L₂
inst✝ : LieAlgebra R L₂
f : L →ₗ⁅R⁆ L₂
K K' : LieSubalgebra R L
K₂ : LieSubalgebra R L₂
s : Set L
p : Submodule R L
h : (lieSpan R L ↑p).toSubmodule = p
x m : L
hm : x ∈ p
⊢ m ∈ lieSpan R L ↑p → ⁅x, m⁆ ∈ (lieSpan R L ↑p).toSubmodule

tactic: rw [← coe_to_submodule_mk p @h, coe_to_submodule, coe_to_submodule_eq_iff, lieSpan_eq]
state_before: case mpr
R : Type u
L : Type v
inst✝⁴ : CommRing R
inst✝³ : LieRing L
inst✝² : LieAlgebra R L
L₂ : Type w
inst✝¹ : LieRing L₂
inst✝ : LieAlgebra R L₂
f : L →ₗ⁅R⁆ L₂
K K' : LieSubalgebra R L
K₂ : LieSubalgebra R L₂
s : Set L
p : Submodule R L
h : ∀ (x y : L), x ∈ p → y ∈ p → ⁅x, y⁆ ∈ p
⊢ (lieSpan R L ↑p).toSubmodule = p
Theorem: WithBot.preimage_coe_Ioc_bot
File: Mathlib/Data/Set/Intervals/WithBotTop.lean

tactic: simp [← Ioi_inter_Iic]
state_before: α : Type u_1
inst✝ : PartialOrder α
a b : α
⊢ some ⁻¹' Ioc ⊥ ↑a = Iic a
Theorem: Cardinal.lift_lt_univ
File: Mathlib/SetTheory/Ordinal/Basic.lean

tactic: simpa only [lift.principalSeg_coe, lift_ord, lift_succ, ord_le, succ_le_iff] using
  le_of_lt (lift.principalSeg.{u, u + 1}.lt_top (succ c).ord)
state_before: α : Type ?u.233635
β : Type ?u.233638
γ : Type ?u.233641
r : α → α → Prop
s : β → β → Prop
t : γ → γ → Prop
c : Cardinal
⊢ lift c < univ
Theorem: WithTop.preimage_coe_Ioo
File: Mathlib/Data/Set/Intervals/WithBotTop.lean

tactic: simp [← Ioi_inter_Iio]
state_before: α : Type u_1
inst✝ : PartialOrder α
a b : α
⊢ some ⁻¹' Ioo ↑a ↑b = Ioo a b
Theorem: Finsupp.toDfinsupp_single
File: Mathlib/Data/Finsupp/ToDfinsupp.lean

tactic: ext
state_before: ι : Type u_1
R : Type ?u.953
M : Type u_2
inst✝¹ : DecidableEq ι
inst✝ : Zero M
i : ι
m : M
⊢ toDfinsupp (single i m) = Dfinsupp.single i m

tactic: simp [Finsupp.single_apply, Dfinsupp.single_apply]
state_before: case h
ι : Type u_1
R : Type ?u.953
M : Type u_2
inst✝¹ : DecidableEq ι
inst✝ : Zero M
i : ι
m : M
i✝ : ι
⊢ ↑(toDfinsupp (single i m)) i✝ = ↑(Dfinsupp.single i m) i✝
Theorem: Dfinsupp.comapDomain'_zero
File: Mathlib/Data/Dfinsupp/Basic.lean

tactic: ext
state_before: ι : Type u
γ : Type w
β : ι → Type v
β₁ : ι → Type v₁
β₂ : ι → Type v₂
dec : DecidableEq ι
κ : Type u_1
inst✝ : (i : ι) → Zero (β i)
h : κ → ι
h' : ι → κ
hh' : Function.LeftInverse h' h
⊢ comapDomain' h hh' 0 = 0

tactic: rw [zero_apply, comapDomain'_apply, zero_apply]
state_before: case h
ι : Type u
γ : Type w
β : ι → Type v
β₁ : ι → Type v₁
β₂ : ι → Type v₂
dec : DecidableEq ι
κ : Type u_1
inst✝ : (i : ι) → Zero (β i)
h : κ → ι
h' : ι → κ
hh' : Function.LeftInverse h' h
i✝ : κ
⊢ ↑(comapDomain' h hh' 0) i✝ = ↑0 i✝
Theorem: ENNReal.tsum_coe_ne_top_iff_summable
File: Mathlib/Topology/Instances/ENNReal.lean

tactic: refine ⟨fun h => ?_, fun h => ENNReal.coe_tsum h ▸ ENNReal.coe_ne_top⟩
state_before: α : Type ?u.233118
β : Type u_1
γ : Type ?u.233124
a b c d : ℝ≥0∞
r p q : ℝ≥0
x y z ε ε₁ ε₂ : ℝ≥0∞
s : Set ℝ≥0∞
f✝ g : α → ℝ≥0∞
f : β → ℝ≥0
⊢ (∑' (b : β), ↑(f b)) ≠ ⊤ ↔ Summable f

tactic: lift ∑' b, (f b : ℝ≥0∞) to ℝ≥0 using h with a ha
state_before: α : Type ?u.233118
β : Type u_1
γ : Type ?u.233124
a b c d : ℝ≥0∞
r p q : ℝ≥0
x y z ε ε₁ ε₂ : ℝ≥0∞
s : Set ℝ≥0∞
f✝ g : α → ℝ≥0∞
f : β → ℝ≥0
h : (∑' (b : β), ↑(f b)) ≠ ⊤
⊢ Summable f

tactic: refine' ⟨a, ENNReal.hasSum_coe.1 _⟩
state_before: case intro
α : Type ?u.233118
β : Type u_1
γ : Type ?u.233124
a✝ b c d : ℝ≥0∞
r p q : ℝ≥0
x y z ε ε₁ ε₂ : ℝ≥0∞
s : Set ℝ≥0∞
f✝ g : α → ℝ≥0∞
f : β → ℝ≥0
a : ℝ≥0
ha : ↑a = ∑' (b : β), ↑(f b)
⊢ Summable f

tactic: rw [ha]
state_before: case intro
α : Type ?u.233118
β : Type u_1
γ : Type ?u.233124
a✝ b c d : ℝ≥0∞
r p q : ℝ≥0
x y z ε ε₁ ε₂ : ℝ≥0∞
s : Set ℝ≥0∞
f✝ g : α → ℝ≥0∞
f : β → ℝ≥0
a : ℝ≥0
ha : ↑a = ∑' (b : β), ↑(f b)
⊢ HasSum (fun a => ↑(f a)) ↑a

tactic: exact ENNReal.summable.hasSum
state_before: case intro
α : Type ?u.233118
β : Type u_1
γ : Type ?u.233124
a✝ b c d : ℝ≥0∞
r p q : ℝ≥0
x y z ε ε₁ ε₂ : ℝ≥0∞
s : Set ℝ≥0∞
f✝ g : α → ℝ≥0∞
f : β → ℝ≥0
a : ℝ≥0
ha : ↑a = ∑' (b : β), ↑(f b)
⊢ HasSum (fun a => ↑(f a)) (∑' (b : β), ↑(f b))
Theorem: FractionalIdeal.zero_le
File: Mathlib/RingTheory/FractionalIdeal.lean

tactic: intro x hx
state_before: R : Type u_1
inst✝² : CommRing R
S : Submonoid R
P : Type u_2
inst✝¹ : CommRing P
inst✝ : Algebra R P
loc : IsLocalization S P
I : FractionalIdeal S P
⊢ 0 ≤ I

tactic: rw [(mem_zero_iff _).mp hx]
state_before: R : Type u_1
inst✝² : CommRing R
S : Submonoid R
P : Type u_2
inst✝¹ : CommRing P
inst✝ : Algebra R P
loc : IsLocalization S P
I : FractionalIdeal S P
x : P
hx : x ∈ 0
⊢ x ∈ I

tactic: exact zero_mem (I : Submodule R P)
state_before: R : Type u_1
inst✝² : CommRing R
S : Submonoid R
P : Type u_2
inst✝¹ : CommRing P
inst✝ : Algebra R P
loc : IsLocalization S P
I : FractionalIdeal S P
x : P
hx : x ∈ 0
⊢ 0 ∈ I
Theorem: MeasureTheory.OuterMeasure.ofFunction_le
File: Mathlib/MeasureTheory/Measure/OuterMeasure.lean

tactic: rintro (_ | i)
state_before: α : Type u_1
m : Set α → ℝ≥0∞
m_empty : m ∅ = 0
s : Set α
f : ℕ → Set α := fun i => Nat.casesOn i s fun x => ∅
⊢ ∀ (b' : ℕ), b' ≠ 0 → m (f b') = 0

tactic: simp
state_before: case zero
α : Type u_1
m : Set α → ℝ≥0∞
m_empty : m ∅ = 0
s : Set α
f : ℕ → Set α := fun i => Nat.casesOn i s fun x => ∅
⊢ Nat.zero ≠ 0 → m (f Nat.zero) = 0

case succ
α : Type u_1
m : Set α → ℝ≥0∞
m_empty : m ∅ = 0
s : Set α
f : ℕ → Set α := fun i => Nat.casesOn i s fun x => ∅
i : ℕ
⊢ Nat.succ i ≠ 0 → m (f (Nat.succ i)) = 0

tactic: simp [m_empty]
state_before: case succ
α : Type u_1
m : Set α → ℝ≥0∞
m_empty : m ∅ = 0
s : Set α
f : ℕ → Set α := fun i => Nat.casesOn i s fun x => ∅
i : ℕ
⊢ Nat.succ i ≠ 0 → m (f (Nat.succ i)) = 0
Theorem: Multiset.replicate_le_replicate
File: Mathlib/Data/Multiset/Basic.lean

tactic: rw [← replicate_le_coe, coe_replicate]
state_before: α : Type u_1
β : Type ?u.91808
γ : Type ?u.91811
a : α
k n : ℕ
⊢ replicate k a ≤ replicate n a ↔ List.replicate k a <+ List.replicate n a
Theorem: Matrix.StdBasisMatrix.trace_zero
File: Mathlib/Data/Matrix/Basis.lean

tactic: simp [trace, -diag_apply, h]
state_before: l : Type ?u.27282
m : Type ?u.27285
n : Type u_1
R : Type ?u.27291
α : Type u_2
inst✝⁴ : DecidableEq l
inst✝³ : DecidableEq m
inst✝² : DecidableEq n
inst✝¹ : Semiring α
i j : n
c : α
i' j' : n
inst✝ : Fintype n
h : j ≠ i
⊢ trace (stdBasisMatrix i j c) = 0
Theorem: Set.iInter_eq_empty_iff
File: Mathlib/Data/Set/Lattice.lean

tactic: simp [Set.eq_empty_iff_forall_not_mem]
state_before: α : Type u_1
β : Type ?u.129049
γ : Type ?u.129052
ι : Sort u_2
ι' : Sort ?u.129058
ι₂ : Sort ?u.129061
κ : ι → Sort ?u.129066
κ₁ : ι → Sort ?u.129071
κ₂ : ι → Sort ?u.129076
κ' : ι' → Sort ?u.129081
f : ι → Set α
⊢ (⋂ (i : ι), f i) = ∅ ↔ ∀ (x : α), ∃ i, ¬x ∈ f i