tasksource/leandojo huggingface dataset:
Theorem: MeasureTheory.integral_trim_ae
File: Mathlib/MeasureTheory/Integral/Bochner.lean

tactic: rw [integral_congr_ae (ae_eq_of_ae_eq_trim hf.ae_eq_mk), integral_congr_ae hf.ae_eq_mk]
state_before: α : Type ?u.1721748
E : Type ?u.1721751
F : Type u_2
𝕜 : Type ?u.1721757
inst✝⁹ : NormedAddCommGroup E
inst✝⁸ : NormedSpace ℝ E
inst✝⁷ : CompleteSpace E
inst✝⁶ : NontriviallyNormedField 𝕜
inst✝⁵ : NormedSpace 𝕜 E
inst✝⁴ : SMulCommClass ℝ 𝕜 E
inst✝³ : NormedAddCommGroup F
inst✝² : NormedSpace ℝ F
inst✝¹ : CompleteSpace F
H : Type ?u.1724428
β : Type u_1
γ : Type ?u.1724434
inst✝ : NormedAddCommGroup H
m m0 : MeasurableSpace β
μ : Measure β
hm : m ≤ m0
f : β → F
hf : AEStronglyMeasurable f (Measure.trim μ hm)
⊢ (∫ (x : β), f x ∂μ) = ∫ (x : β), f x ∂Measure.trim μ hm

tactic: exact integral_trim hm hf.stronglyMeasurable_mk
state_before: α : Type ?u.1721748
E : Type ?u.1721751
F : Type u_2
𝕜 : Type ?u.1721757
inst✝⁹ : NormedAddCommGroup E
inst✝⁸ : NormedSpace ℝ E
inst✝⁷ : CompleteSpace E
inst✝⁶ : NontriviallyNormedField 𝕜
inst✝⁵ : NormedSpace 𝕜 E
inst✝⁴ : SMulCommClass ℝ 𝕜 E
inst✝³ : NormedAddCommGroup F
inst✝² : NormedSpace ℝ F
inst✝¹ : CompleteSpace F
H : Type ?u.1724428
β : Type u_1
γ : Type ?u.1724434
inst✝ : NormedAddCommGroup H
m m0 : MeasurableSpace β
μ : Measure β
hm : m ≤ m0
f : β → F
hf : AEStronglyMeasurable f (Measure.trim μ hm)
⊢ (∫ (a : β), AEStronglyMeasurable.mk f hf a ∂μ) = ∫ (a : β), AEStronglyMeasurable.mk f hf a ∂Measure.trim μ hm
Theorem: Set.image_update_Icc_left
File: Mathlib/Data/Set/Intervals/Pi.lean

tactic: simpa using image_update_Icc f i a (f i)
state_before: ι : Type u_1
α : ι → Type u_2
inst✝¹ : DecidableEq ι
inst✝ : (i : ι) → PartialOrder (α i)
f : (i : ι) → α i
i : ι
a : α i
⊢ update f i '' Icc a (f i) = Icc (update f i a) f
Theorem: Filter.comap_iSup
File: Mathlib/Order/Filter/Basic.lean

tactic: simpa only [mem_comap, exists_prop, mem_iSup] using mem_iSup.1 hs
state_before: α : Type u
β : Type v
γ : Type w
δ : Type ?u.254383
ι✝ : Sort x
f✝ f₁ f₂ : Filter α
g g₁ g₂ : Filter β
m✝ : α → β
m' : β → γ
s✝ : Set α
t : Set β
ι : Sort u_1
f : ι → Filter β
m : α → β
s : Set α
hs : s ∈ ⨆ (i : ι), comap m (f i)
⊢ ∀ (i : ι), ∃ t, t ∈ f i ∧ m ⁻¹' t ⊆ s

tactic: rw [preimage_iUnion, iUnion_subset_iff]
state_before: α : Type u
β : Type v
γ : Type w
δ : Type ?u.254383
ι✝ : Sort x
f✝ f₁ f₂ : Filter α
g g₁ g₂ : Filter β
m✝ : α → β
m' : β → γ
s✝ : Set α
t✝ : Set β
ι : Sort u_1
f : ι → Filter β
m : α → β
s : Set α
hs : s ∈ ⨆ (i : ι), comap m (f i)
this : ∀ (i : ι), ∃ t, t ∈ f i ∧ m ⁻¹' t ⊆ s
t : ι → Set β
ht : ∀ (x : ι), t x ∈ f x ∧ m ⁻¹' t x ⊆ s
⊢ (m ⁻¹' ⋃ (i : ι), t i) ⊆ s

tactic: exact fun i => (ht i).2
state_before: α : Type u
β : Type v
γ : Type w
δ : Type ?u.254383
ι✝ : Sort x
f✝ f₁ f₂ : Filter α
g g₁ g₂ : Filter β
m✝ : α → β
m' : β → γ
s✝ : Set α
t✝ : Set β
ι : Sort u_1
f : ι → Filter β
m : α → β
s : Set α
hs : s ∈ ⨆ (i : ι), comap m (f i)
this : ∀ (i : ι), ∃ t, t ∈ f i ∧ m ⁻¹' t ⊆ s
t : ι → Set β
ht : ∀ (x : ι), t x ∈ f x ∧ m ⁻¹' t x ⊆ s
⊢ ∀ (i : ι), m ⁻¹' t i ⊆ s
Theorem: Multiset.Nat.antidiagonal_succ
File: Mathlib/Data/Multiset/NatAntidiagonal.lean

tactic: simp only [antidiagonal, List.Nat.antidiagonal_succ, coe_map, cons_coe]
state_before: n : ℕ
⊢ antidiagonal (n + 1) = (0, n + 1) ::ₘ map (Prod.map Nat.succ id) (antidiagonal n)
Theorem: Mathlib.Meta.NormNum.isFibAux_two_mul_add_one
File: Mathlib/Tactic/NormNum/NatFib.lean

tactic: rw [← hn, fib_two_mul_add_one, H.1, H.2, pow_two, pow_two, add_comm, h1]
state_before: n a b n' a' b' : ℕ
H : IsFibAux n a b
hn : 2 * n + 1 = n'
h1 : a * a + b * b = a'
h2 : b * (2 * a + b) = b'
⊢ fib n' = a'

tactic: rw [← hn, fib_two_mul_add_two, H.1, H.2, h2]
state_before: n a b n' a' b' : ℕ
H : IsFibAux n a b
hn : 2 * n + 1 = n'
h1 : a * a + b * b = a'
h2 : b * (2 * a + b) = b'
⊢ fib (n' + 1) = b'
Theorem: Localization.sub_mk
File: Mathlib/RingTheory/Localization/Basic.lean

tactic: rw [neg_mk]
state_before: R : Type u_1
inst✝³ : CommRing R
M : Submonoid R
S : Type ?u.2970634
inst✝² : CommRing S
inst✝¹ : Algebra R S
P : Type ?u.2970871
inst✝ : CommRing P
a c : R
b d : { x // x ∈ M }
⊢ mk a b + -mk c d = mk a b + mk (-c) d

tactic: congr
state_before: R : Type u_1
inst✝³ : CommRing R
M : Submonoid R
S : Type ?u.2970634
inst✝² : CommRing S
inst✝¹ : Algebra R S
P : Type ?u.2970871
inst✝ : CommRing P
a c : R
b d : { x // x ∈ M }
⊢ mk (↑b * -c + ↑d * a) (b * d) = mk (↑d * a - ↑b * c) (b * d)

tactic: ring
state_before: case e_x
R : Type u_1
inst✝³ : CommRing R
M : Submonoid R
S : Type ?u.2970634
inst✝² : CommRing S
inst✝¹ : Algebra R S
P : Type ?u.2970871
inst✝ : CommRing P
a c : R
b d : { x // x ∈ M }
⊢ ↑b * -c + ↑d * a = ↑d * a - ↑b * c
Theorem: Nat.even_xor_odd
File: Mathlib/Data/Nat/Parity.lean

tactic: simp [Xor', odd_iff_not_even, Decidable.em (Even n)]
state_before: m n✝ n : ℕ
⊢ Xor' (Even n) (Odd n)
Theorem: Filter.isTopologicalBasis_Iic_principal
File: Mathlib/Topology/Filter.lean

tactic: rintro _ ⟨s, rfl⟩ _ ⟨t, rfl⟩ l hl
state_before: ι : Sort ?u.640
α : Type u_1
β : Type ?u.646
X : Type ?u.649
Y : Type ?u.652
⊢ ∀ (t₁ : Set (Filter α)),
    t₁ ∈ range (Iic ∘ 𝓟) →
      ∀ (t₂ : Set (Filter α)),
        t₂ ∈ range (Iic ∘ 𝓟) → ∀ (x : Filter α), x ∈ t₁ ∩ t₂ → ∃ t₃, t₃ ∈ range (Iic ∘ 𝓟) ∧ x ∈ t₃ ∧ t₃ ⊆ t₁ ∩ t₂

tactic: exact ⟨Iic (𝓟 s) ∩ Iic (𝓟 t), ⟨s ∩ t, by simp⟩, hl, Subset.rfl⟩
state_before: case intro.intro
ι : Sort ?u.640
α : Type u_1
β : Type ?u.646
X : Type ?u.649
Y : Type ?u.652
s t : Set α
l : Filter α
hl : l ∈ (Iic ∘ 𝓟) s ∩ (Iic ∘ 𝓟) t
⊢ ∃ t₃, t₃ ∈ range (Iic ∘ 𝓟) ∧ l ∈ t₃ ∧ t₃ ⊆ (Iic ∘ 𝓟) s ∩ (Iic ∘ 𝓟) t

tactic: simp
state_before: ι : Sort ?u.640
α : Type u_1
β : Type ?u.646
X : Type ?u.649
Y : Type ?u.652
s t : Set α
l : Filter α
hl : l ∈ (Iic ∘ 𝓟) s ∩ (Iic ∘ 𝓟) t
⊢ (Iic ∘ 𝓟) (s ∩ t) = Iic (𝓟 s) ∩ Iic (𝓟 t)
Theorem: Real.sin_pos_of_pos_of_lt_pi
File: Mathlib/Analysis/SpecialFunctions/Trigonometric/Basic.lean

tactic: norm_num
state_before: x : ℝ
h0x : 0 < x
hxp : x < π
hx2 : ¬x ≤ 2
⊢ 2 + 2 = 4
Theorem: Finsupp.support_add_eq
File: Mathlib/Data/Finsupp/Defs.lean

tactic: have : a ∉ g₂.support := disjoint_left.1 h ha
state_before: α : Type u_1
β : Type ?u.284137
γ : Type ?u.284140
ι : Type ?u.284143
M : Type u_2
M' : Type ?u.284149
N : Type ?u.284152
P : Type ?u.284155
G : Type ?u.284158
H : Type ?u.284161
R : Type ?u.284164
S : Type ?u.284167
inst✝¹ : AddZeroClass M
inst✝ : DecidableEq α
g₁ g₂ : α →₀ M
h : Disjoint g₁.support g₂.support
a : α
ha✝ : a ∈ g₁.support ∪ g₂.support
ha : a ∈ g₁.support
⊢ a ∈ (g₁ + g₂).support

tactic: simp only [mem_support_iff, not_not] at *
state_before: α : Type u_1
β : Type ?u.284137
γ : Type ?u.284140
ι : Type ?u.284143
M : Type u_2
M' : Type ?u.284149
N : Type ?u.284152
P : Type ?u.284155
G : Type ?u.284158
H : Type ?u.284161
R : Type ?u.284164
S : Type ?u.284167
inst✝¹ : AddZeroClass M
inst✝ : DecidableEq α
g₁ g₂ : α →₀ M
h : Disjoint g₁.support g₂.support
a : α
ha✝ : a ∈ g₁.support ∪ g₂.support
ha : a ∈ g₁.support
this : ¬a ∈ g₂.support
⊢ a ∈ (g₁ + g₂).support

tactic: simpa only [add_apply, this, add_zero]
state_before: α : Type u_1
β : Type ?u.284137
γ : Type ?u.284140
ι : Type ?u.284143
M : Type u_2
M' : Type ?u.284149
N : Type ?u.284152
P : Type ?u.284155
G : Type ?u.284158
H : Type ?u.284161
R : Type ?u.284164
S : Type ?u.284167
inst✝¹ : AddZeroClass M
inst✝ : DecidableEq α
g₁ g₂ : α →₀ M
h : Disjoint g₁.support g₂.support
a : α
ha✝ : a ∈ g₁.support ∪ g₂.support
ha : ↑g₁ a ≠ 0
this : ↑g₂ a = 0
⊢ ↑(g₁ + g₂) a ≠ 0

tactic: have : a ∉ g₁.support := disjoint_right.1 h ha
state_before: α : Type u_1
β : Type ?u.284137
γ : Type ?u.284140
ι : Type ?u.284143
M : Type u_2
M' : Type ?u.284149
N : Type ?u.284152
P : Type ?u.284155
G : Type ?u.284158
H : Type ?u.284161
R : Type ?u.284164
S : Type ?u.284167
inst✝¹ : AddZeroClass M
inst✝ : DecidableEq α
g₁ g₂ : α →₀ M
h : Disjoint g₁.support g₂.support
a : α
ha✝ : a ∈ g₁.support ∪ g₂.support
ha : a ∈ g₂.support
⊢ a ∈ (g₁ + g₂).support

tactic: simp only [mem_support_iff, not_not] at *
state_before: α : Type u_1
β : Type ?u.284137
γ : Type ?u.284140
ι : Type ?u.284143
M : Type u_2
M' : Type ?u.284149
N : Type ?u.284152
P : Type ?u.284155
G : Type ?u.284158
H : Type ?u.284161
R : Type ?u.284164
S : Type ?u.284167
inst✝¹ : AddZeroClass M
inst✝ : DecidableEq α
g₁ g₂ : α →₀ M
h : Disjoint g₁.support g₂.support
a : α
ha✝ : a ∈ g₁.support ∪ g₂.support
ha : a ∈ g₂.support
this : ¬a ∈ g₁.support
⊢ a ∈ (g₁ + g₂).support

tactic: simpa only [add_apply, this, zero_add]
state_before: α : Type u_1
β : Type ?u.284137
γ : Type ?u.284140
ι : Type ?u.284143
M : Type u_2
M' : Type ?u.284149
N : Type ?u.284152
P : Type ?u.284155
G : Type ?u.284158
H : Type ?u.284161
R : Type ?u.284164
S : Type ?u.284167
inst✝¹ : AddZeroClass M
inst✝ : DecidableEq α
g₁ g₂ : α →₀ M
h : Disjoint g₁.support g₂.support
a : α
ha✝ : a ∈ g₁.support ∪ g₂.support
ha : ↑g₂ a ≠ 0
this : ↑g₁ a = 0
⊢ ↑(g₁ + g₂) a ≠ 0
Theorem: Polynomial.span_singleton_annIdealGenerator
File: Mathlib/LinearAlgebra/AnnihilatingPolynomial.lean

tactic: by_cases h : annIdealGenerator 𝕜 a = 0
state_before: 𝕜 : Type u_1
A : Type u_2
inst✝² : Field 𝕜
inst✝¹ : Ring A
inst✝ : Algebra 𝕜 A
a : A
⊢ Ideal.span {annIdealGenerator 𝕜 a} = annIdeal 𝕜 a

tactic: rw [h, annIdealGenerator_eq_zero_iff.mp h, Set.singleton_zero, Ideal.span_zero]
state_before: case pos
𝕜 : Type u_1
A : Type u_2
inst✝² : Field 𝕜
inst✝¹ : Ring A
inst✝ : Algebra 𝕜 A
a : A
h : annIdealGenerator 𝕜 a = 0
⊢ Ideal.span {annIdealGenerator 𝕜 a} = annIdeal 𝕜 a

tactic: rw [annIdealGenerator, Ideal.span_singleton_mul_right_unit, Ideal.span_singleton_generator]
state_before: case neg
𝕜 : Type u_1
A : Type u_2
inst✝² : Field 𝕜
inst✝¹ : Ring A
inst✝ : Algebra 𝕜 A
a : A
h : ¬annIdealGenerator 𝕜 a = 0
⊢ Ideal.span {annIdealGenerator 𝕜 a} = annIdeal 𝕜 a

tactic: apply Polynomial.isUnit_C.mpr
state_before: case neg.h2
𝕜 : Type u_1
A : Type u_2
inst✝² : Field 𝕜
inst✝¹ : Ring A
inst✝ : Algebra 𝕜 A
a : A
h : ¬annIdealGenerator 𝕜 a = 0
⊢ IsUnit (↑C (leadingCoeff (IsPrincipal.generator (annIdeal 𝕜 a)))⁻¹)

tactic: apply IsUnit.mk0
state_before: case neg.h2
𝕜 : Type u_1
A : Type u_2
inst✝² : Field 𝕜
inst✝¹ : Ring A
inst✝ : Algebra 𝕜 A
a : A
h : ¬annIdealGenerator 𝕜 a = 0
⊢ IsUnit (leadingCoeff (IsPrincipal.generator (annIdeal 𝕜 a)))⁻¹

tactic: apply inv_eq_zero.not.mpr
state_before: case neg.h2.hx
𝕜 : Type u_1
A : Type u_2
inst✝² : Field 𝕜
inst✝¹ : Ring A
inst✝ : Algebra 𝕜 A
a : A
h : ¬annIdealGenerator 𝕜 a = 0
⊢ (leadingCoeff (IsPrincipal.generator (annIdeal 𝕜 a)))⁻¹ ≠ 0

tactic: apply Polynomial.leadingCoeff_eq_zero.not.mpr
state_before: case neg.h2.hx
𝕜 : Type u_1
A : Type u_2
inst✝² : Field 𝕜
inst✝¹ : Ring A
inst✝ : Algebra 𝕜 A
a : A
h : ¬annIdealGenerator 𝕜 a = 0
⊢ ¬leadingCoeff (IsPrincipal.generator (annIdeal 𝕜 a)) = 0

tactic: apply (mul_ne_zero_iff.mp h).1
state_before: case neg.h2.hx
𝕜 : Type u_1
A : Type u_2
inst✝² : Field 𝕜
inst✝¹ : Ring A
inst✝ : Algebra 𝕜 A
a : A
h : ¬annIdealGenerator 𝕜 a = 0
⊢ ¬IsPrincipal.generator (annIdeal 𝕜 a) = 0
Theorem: PowerSeries.order_le
File: Mathlib/RingTheory/PowerSeries/Basic.lean

tactic: have _ :  ∃ n, coeff R n φ ≠ 0 := Exists.intro n h
state_before: R : Type u_1
inst✝ : Semiring R
φ : PowerSeries R
n : ℕ
h : ↑(coeff R n) φ ≠ 0
⊢ order φ ≤ ↑n

tactic: rw [order, dif_neg]
state_before: R : Type u_1
inst✝ : Semiring R
φ : PowerSeries R
n : ℕ
h : ↑(coeff R n) φ ≠ 0
x✝ : ∃ n, ↑(coeff R n) φ ≠ 0
⊢ order φ ≤ ↑n

tactic: simp only [PartENat.coe_le_coe, Nat.find_le_iff]
state_before: R : Type u_1
inst✝ : Semiring R
φ : PowerSeries R
n : ℕ
h : ↑(coeff R n) φ ≠ 0
x✝ : ∃ n, ↑(coeff R n) φ ≠ 0
⊢ ↑(Nat.find (_ : ∃ n, ↑(coeff R n) φ ≠ 0)) ≤ ↑n

tactic: exact ⟨n, le_rfl, h⟩
state_before: R : Type u_1
inst✝ : Semiring R
φ : PowerSeries R
n : ℕ
h : ↑(coeff R n) φ ≠ 0
x✝ : ∃ n, ↑(coeff R n) φ ≠ 0
⊢ ∃ m, m ≤ n ∧ ↑(coeff R m) φ ≠ 0

tactic: exact exists_coeff_ne_zero_iff_ne_zero.mp ⟨n, h⟩
state_before: case hnc
R : Type u_1
inst✝ : Semiring R
φ : PowerSeries R
n : ℕ
h : ↑(coeff R n) φ ≠ 0
x✝ : ∃ n, ↑(coeff R n) φ ≠ 0
⊢ ¬φ = 0
Theorem: Subalgebra.iSupLift_of_mem
File: Mathlib/Algebra/Algebra/Subalgebra/Basic.lean

tactic: dsimp [iSupLift, inclusion]
state_before: R : Type u
A : Type v
B : Type w
inst✝⁵ : CommSemiring R
inst✝⁴ : Semiring A
inst✝³ : Algebra R A
inst✝² : Semiring B
inst✝¹ : Algebra R B
S : Subalgebra R A
ι : Type u_1
inst✝ : Nonempty ι
K : ι → Subalgebra R A
dir : Directed (fun x x_1 => x ≤ x_1) K
f : (i : ι) → { x // x ∈ K i } →ₐ[R] B
hf : ∀ (i j : ι) (h : K i ≤ K j), f i = AlgHom.comp (f j) (inclusion h)
T : Subalgebra R A
hT : T = iSup K
i : ι
x : { x // x ∈ T }
hx : ↑x ∈ K i
⊢ ↑(iSupLift K dir f hf T hT) x = ↑(f i) { val := ↑x, property := hx }

tactic: rw [Set.iUnionLift_of_mem]
state_before: R : Type u
A : Type v
B : Type w
inst✝⁵ : CommSemiring R
inst✝⁴ : Semiring A
inst✝³ : Algebra R A
inst✝² : Semiring B
inst✝¹ : Algebra R B
S : Subalgebra R A
ι : Type u_1
inst✝ : Nonempty ι
K : ι → Subalgebra R A
dir : Directed (fun x x_1 => x ≤ x_1) K
f : (i : ι) → { x // x ∈ K i } →ₐ[R] B
hf : ∀ (i j : ι) (h : K i ≤ K j), f i = AlgHom.comp (f j) (inclusion h)
T : Subalgebra R A
hT : T = iSup K
i : ι
x : { x // x ∈ T }
hx : ↑x ∈ K i
⊢ Set.iUnionLift (fun i => ↑(K i)) (fun i x => ↑(f i) x)
      (_ :
        ∀ (i j : ι) (x : A) (hxi : x ∈ (fun i => ↑(K i)) i) (hxj : x ∈ (fun i => ↑(K i)) j),
          (fun i x => ↑(f i) x) i { val := x, property := hxi } = (fun i x => ↑(f i) x) j { val := x, property := hxj })
      ↑T (_ : ↑T ⊆ ⋃ (i : ι), ↑(K i)) x =
    ↑(f i) { val := ↑x, property := hx }
Theorem: Associates.finite_factors
File: Mathlib/RingTheory/DedekindDomain/Factorization.lean

tactic: have h_supp : {v : HeightOneSpectrum R | ¬((Associates.mk v.asIdeal).count
    (Associates.mk I).factors : ℤ) = 0} = {v : HeightOneSpectrum R | v.asIdeal ∣ I} := by
  ext v
  simp_rw [Int.coe_nat_eq_zero]
  exact Associates.count_ne_zero_iff_dvd hI v.irreducible
state_before: R : Type u_1
inst✝⁵ : CommRing R
inst✝⁴ : IsDomain R
inst✝³ : IsDedekindDomain R
K : Type ?u.7591
inst✝² : Field K
inst✝¹ : Algebra R K
inst✝ : IsFractionRing R K
v : HeightOneSpectrum R
I : Ideal R
hI : I ≠ 0
⊢ ∀ᶠ (v : HeightOneSpectrum R) in Filter.cofinite, ↑(count (Associates.mk v.asIdeal) (factors (Associates.mk I))) = 0

tactic: rw [Filter.eventually_cofinite, h_supp]
state_before: R : Type u_1
inst✝⁵ : CommRing R
inst✝⁴ : IsDomain R
inst✝³ : IsDedekindDomain R
K : Type ?u.7591
inst✝² : Field K
inst✝¹ : Algebra R K
inst✝ : IsFractionRing R K
v : HeightOneSpectrum R
I : Ideal R
hI : I ≠ 0
h_supp : {v | ¬↑(count (Associates.mk v.asIdeal) (factors (Associates.mk I))) = 0} = {v | v.asIdeal ∣ I}
⊢ ∀ᶠ (v : HeightOneSpectrum R) in Filter.cofinite, ↑(count (Associates.mk v.asIdeal) (factors (Associates.mk I))) = 0

tactic: exact Ideal.finite_factors hI
state_before: R : Type u_1
inst✝⁵ : CommRing R
inst✝⁴ : IsDomain R
inst✝³ : IsDedekindDomain R
K : Type ?u.7591
inst✝² : Field K
inst✝¹ : Algebra R K
inst✝ : IsFractionRing R K
v : HeightOneSpectrum R
I : Ideal R
hI : I ≠ 0
h_supp : {v | ¬↑(count (Associates.mk v.asIdeal) (factors (Associates.mk I))) = 0} = {v | v.asIdeal ∣ I}
⊢ Set.Finite {v | v.asIdeal ∣ I}

tactic: ext v
state_before: R : Type u_1
inst✝⁵ : CommRing R
inst✝⁴ : IsDomain R
inst✝³ : IsDedekindDomain R
K : Type ?u.7591
inst✝² : Field K
inst✝¹ : Algebra R K
inst✝ : IsFractionRing R K
v : HeightOneSpectrum R
I : Ideal R
hI : I ≠ 0
⊢ {v | ¬↑(count (Associates.mk v.asIdeal) (factors (Associates.mk I))) = 0} = {v | v.asIdeal ∣ I}

tactic: simp_rw [Int.coe_nat_eq_zero]
state_before: case h
R : Type u_1
inst✝⁵ : CommRing R
inst✝⁴ : IsDomain R
inst✝³ : IsDedekindDomain R
K : Type ?u.7591
inst✝² : Field K
inst✝¹ : Algebra R K
inst✝ : IsFractionRing R K
v✝ : HeightOneSpectrum R
I : Ideal R
hI : I ≠ 0
v : HeightOneSpectrum R
⊢ v ∈ {v | ¬↑(count (Associates.mk v.asIdeal) (factors (Associates.mk I))) = 0} ↔ v ∈ {v | v.asIdeal ∣ I}

tactic: exact Associates.count_ne_zero_iff_dvd hI v.irreducible
state_before: case h
R : Type u_1
inst✝⁵ : CommRing R
inst✝⁴ : IsDomain R
inst✝³ : IsDedekindDomain R
K : Type ?u.7591
inst✝² : Field K
inst✝¹ : Algebra R K
inst✝ : IsFractionRing R K
v✝ : HeightOneSpectrum R
I : Ideal R
hI : I ≠ 0
v : HeightOneSpectrum R
⊢ v ∈ {v | ¬count (Associates.mk v.asIdeal) (factors (Associates.mk I)) = 0} ↔ v ∈ {v | v.asIdeal ∣ I}
Theorem: Unique.bijective
File: Mathlib/Logic/Unique.lean

tactic: rw [Function.bijective_iff_has_inverse]
state_before: A : Sort u_1
B : Sort u_2
inst✝¹ : Unique A
inst✝ : Unique B
f : A → B
⊢ Function.Bijective f

tactic: refine' ⟨default, _, _⟩ <;> intro x <;> simp
state_before: A : Sort u_1
B : Sort u_2
inst✝¹ : Unique A
inst✝ : Unique B
f : A → B
⊢ ∃ g, Function.LeftInverse g f ∧ Function.RightInverse g f
Theorem: add_self_eq_zero
File: Mathlib/Algebra/CharZero/Lemmas.lean

tactic: simp only [(two_mul a).symm, mul_eq_zero, two_ne_zero, false_or_iff]
state_before: R : Type u_1
inst✝² : NonAssocSemiring R
inst✝¹ : NoZeroDivisors R
inst✝ : CharZero R
a✝ a : R
⊢ a + a = 0 ↔ a = 0
Theorem: inner_eq_sum_norm_sq_div_four
File: Mathlib/Analysis/InnerProductSpace/Basic.lean

tactic: rw [← re_add_im ⟪x, y⟫, re_inner_eq_norm_add_mul_self_sub_norm_sub_mul_self_div_four,
  im_inner_eq_norm_sub_i_smul_mul_self_sub_norm_add_i_smul_mul_self_div_four]
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type ?u.2659185
inst✝⁴ : IsROrC 𝕜
inst✝³ : NormedAddCommGroup E
inst✝² : InnerProductSpace 𝕜 E
inst✝¹ : NormedAddCommGroup F
inst✝ : InnerProductSpace ℝ F
dec_E : DecidableEq E
x y : E
⊢ inner x y = (↑‖x + y‖ ^ 2 - ↑‖x - y‖ ^ 2 + (↑‖x - I • y‖ ^ 2 - ↑‖x + I • y‖ ^ 2) * I) / 4

tactic: push_cast
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type ?u.2659185
inst✝⁴ : IsROrC 𝕜
inst✝³ : NormedAddCommGroup E
inst✝² : InnerProductSpace 𝕜 E
inst✝¹ : NormedAddCommGroup F
inst✝ : InnerProductSpace ℝ F
dec_E : DecidableEq E
x y : E
⊢ ↑((‖x + y‖ * ‖x + y‖ - ‖x - y‖ * ‖x - y‖) / 4) + ↑((‖x - I • y‖ * ‖x - I • y‖ - ‖x + I • y‖ * ‖x + I • y‖) / 4) * I =
    (↑‖x + y‖ ^ 2 - ↑‖x - y‖ ^ 2 + (↑‖x - I • y‖ ^ 2 - ↑‖x + I • y‖ ^ 2) * I) / 4

tactic: simp only [sq, ← mul_div_right_comm, ← add_div]
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type ?u.2659185
inst✝⁴ : IsROrC 𝕜
inst✝³ : NormedAddCommGroup E
inst✝² : InnerProductSpace 𝕜 E
inst✝¹ : NormedAddCommGroup F
inst✝ : InnerProductSpace ℝ F
dec_E : DecidableEq E
x y : E
⊢ (↑‖x + y‖ * ↑‖x + y‖ - ↑‖x - y‖ * ↑‖x - y‖) / 4 +
      (↑‖x - I • y‖ * ↑‖x - I • y‖ - ↑‖x + I • y‖ * ↑‖x + I • y‖) / 4 * I =
    (↑‖x + y‖ ^ 2 - ↑‖x - y‖ ^ 2 + (↑‖x - I • y‖ ^ 2 - ↑‖x + I • y‖ ^ 2) * I) / 4
Theorem: Disjoint.disjoint_sup_left_of_disjoint_sup_right
File: Mathlib/Order/ModularLattice.lean

tactic: rw [disjoint_comm, sup_comm]
state_before: α : Type u_1
inst✝² : Lattice α
inst✝¹ : OrderBot α
inst✝ : IsModularLattice α
a b c : α
h : Disjoint b c
hsup : Disjoint a (b ⊔ c)
⊢ Disjoint (a ⊔ b) c

tactic: apply Disjoint.disjoint_sup_right_of_disjoint_sup_left h.symm
state_before: α : Type u_1
inst✝² : Lattice α
inst✝¹ : OrderBot α
inst✝ : IsModularLattice α
a b c : α
h : Disjoint b c
hsup : Disjoint a (b ⊔ c)
⊢ Disjoint c (b ⊔ a)

tactic: rwa [sup_comm, disjoint_comm] at hsup
state_before: α : Type u_1
inst✝² : Lattice α
inst✝¹ : OrderBot α
inst✝ : IsModularLattice α
a b c : α
h : Disjoint b c
hsup : Disjoint a (b ⊔ c)
⊢ Disjoint (c ⊔ b) a
Theorem: CharTwo.list_sum_mul_self
File: Mathlib/Algebra/CharP/Two.lean

tactic: simp_rw [← pow_two, list_sum_sq]
state_before: R : Type u_1
ι : Type ?u.14336
inst✝¹ : CommSemiring R
inst✝ : CharP R 2
l : List R
⊢ List.sum l * List.sum l = List.sum (List.map (fun x => x * x) l)
Theorem: BoxIntegral.Box.measurableSet_coe
File: Mathlib/Analysis/BoxIntegral/Partition/Measure.lean

tactic: rw [coe_eq_pi]
state_before: ι : Type u_1
I : Box ι
inst✝ : Countable ι
⊢ MeasurableSet ↑I

tactic: exact MeasurableSet.univ_pi fun i => measurableSet_Ioc
state_before: ι : Type u_1
I : Box ι
inst✝ : Countable ι
⊢ MeasurableSet (pi univ fun i => Ioc (lower I i) (upper I i))
Theorem: Matrix.toMatrix₂Aux_toLinearMap₂'Aux
File: Mathlib/LinearAlgebra/Matrix/SesquilinearForm.lean

tactic: ext (i j)
state_before: R : Type u_3
R₁ : Type u_4
R₂ : Type u_5
M : Type ?u.137024
M₁ : Type ?u.137027
M₂ : Type ?u.137030
M₁' : Type ?u.137033
M₂' : Type ?u.137036
n : Type u_1
m : Type u_2
n' : Type ?u.137045
m' : Type ?u.137048
ι : Type ?u.137051
inst✝¹⁰ : CommRing R
inst✝⁹ : CommRing R₁
inst✝⁸ : CommRing R₂
inst✝⁷ : AddCommMonoid M₁
inst✝⁶ : Module R₁ M₁
inst✝⁵ : AddCommMonoid M₂
inst✝⁴ : Module R₂ M₂
inst✝³ : Fintype n
inst✝² : Fintype m
inst✝¹ : DecidableEq n
inst✝ : DecidableEq m
σ₁ : R₁ →+* R
σ₂ : R₂ →+* R
f : Matrix n m R
⊢ ↑(toMatrix₂Aux (fun i => ↑(LinearMap.stdBasis R₁ (fun x => R₁) i) 1) fun j =>
          ↑(LinearMap.stdBasis R₂ (fun x => R₂) j) 1)
      (toLinearMap₂'Aux σ₁ σ₂ f) =
    f

tactic: simp_rw [LinearMap.toMatrix₂Aux_apply, Matrix.toLinearMap₂'Aux_stdBasis]
state_before: case a.h
R : Type u_3
R₁ : Type u_4
R₂ : Type u_5
M : Type ?u.137024
M₁ : Type ?u.137027
M₂ : Type ?u.137030
M₁' : Type ?u.137033
M₂' : Type ?u.137036
n : Type u_1
m : Type u_2
n' : Type ?u.137045
m' : Type ?u.137048
ι : Type ?u.137051
inst✝¹⁰ : CommRing R
inst✝⁹ : CommRing R₁
inst✝⁸ : CommRing R₂
inst✝⁷ : AddCommMonoid M₁
inst✝⁶ : Module R₁ M₁
inst✝⁵ : AddCommMonoid M₂
inst✝⁴ : Module R₂ M₂
inst✝³ : Fintype n
inst✝² : Fintype m
inst✝¹ : DecidableEq n
inst✝ : DecidableEq m
σ₁ : R₁ →+* R
σ₂ : R₂ →+* R
f : Matrix n m R
i : n
j : m
⊢ ↑(toMatrix₂Aux (fun i => ↑(LinearMap.stdBasis R₁ (fun x => R₁) i) 1) fun j =>
          ↑(LinearMap.stdBasis R₂ (fun x => R₂) j) 1)
      (toLinearMap₂'Aux σ₁ σ₂ f) i j =
    f i j
Theorem: orderOf_eq_one_iff
File: Mathlib/GroupTheory/OrderOfElement.lean

tactic: rw [orderOf, minimalPeriod_eq_one_iff_isFixedPt, IsFixedPt, mul_one]
state_before: G : Type u
A : Type v
x y : G
a b : A
n m : ℕ
inst✝¹ : Monoid G
inst✝ : AddMonoid A
⊢ orderOf x = 1 ↔ x = 1
Theorem: MeasureTheory.union_ae_eq_left_iff_ae_subset
File: Mathlib/MeasureTheory/Measure/MeasureSpace.lean

tactic: rw [ae_le_set]
state_before: α : Type u_1
β : Type ?u.30507
γ : Type ?u.30510
δ : Type ?u.30513
ι : Type ?u.30516
R : Type ?u.30519
R' : Type ?u.30522
m : MeasurableSpace α
μ μ₁ μ₂ : Measure α
s s₁ s₂ t : Set α
⊢ s ∪ t =ᵐ[μ] s ↔ t ≤ᵐ[μ] s

tactic: refine'
  ⟨fun h => by simpa only [union_diff_left] using (ae_eq_set.mp h).1, fun h =>
    eventuallyLE_antisymm_iff.mpr
      ⟨by rwa [ae_le_set, union_diff_left],
        HasSubset.Subset.eventuallyLE <| subset_union_left s t⟩⟩
state_before: α : Type u_1
β : Type ?u.30507
γ : Type ?u.30510
δ : Type ?u.30513
ι : Type ?u.30516
R : Type ?u.30519
R' : Type ?u.30522
m : MeasurableSpace α
μ μ₁ μ₂ : Measure α
s s₁ s₂ t : Set α
⊢ s ∪ t =ᵐ[μ] s ↔ ↑↑μ (t \ s) = 0

tactic: simpa only [union_diff_left] using (ae_eq_set.mp h).1
state_before: α : Type u_1
β : Type ?u.30507
γ : Type ?u.30510
δ : Type ?u.30513
ι : Type ?u.30516
R : Type ?u.30519
R' : Type ?u.30522
m : MeasurableSpace α
μ μ₁ μ₂ : Measure α
s s₁ s₂ t : Set α
h : s ∪ t =ᵐ[μ] s
⊢ ↑↑μ (t \ s) = 0

tactic: rwa [ae_le_set, union_diff_left]
state_before: α : Type u_1
β : Type ?u.30507
γ : Type ?u.30510
δ : Type ?u.30513
ι : Type ?u.30516
R : Type ?u.30519
R' : Type ?u.30522
m : MeasurableSpace α
μ μ₁ μ₂ : Measure α
s s₁ s₂ t : Set α
h : ↑↑μ (t \ s) = 0
⊢ s ∪ t ≤ᵐ[μ] s
Theorem: Turing.PartrecToTM2.trNat_zero
File: Mathlib/Computability/TMToPartrec.lean

tactic: rw [trNat, Nat.cast_zero]
state_before: ⊢ trNat 0 = []

tactic: rfl
state_before: ⊢ trNum 0 = []
Theorem: padicValInt_dvd_iff
File: Mathlib/NumberTheory/Padics/PadicVal.lean

tactic: rw [padicValInt, ← Int.natAbs_eq_zero, ← padicValNat_dvd_iff, ← Int.coe_nat_dvd_left,
  Int.coe_nat_pow]
state_before: p : ℕ
hp : Fact (Nat.Prime p)
n : ℕ
a : ℤ
⊢ ↑p ^ n ∣ a ↔ a = 0 ∨ n ≤ padicValInt p a
Theorem: Finset.toList_toFinset
File: Mathlib/Data/Finset/Basic.lean

tactic: ext
state_before: α : Type u_1
β : Type ?u.480823
γ : Type ?u.480826
inst✝ : DecidableEq α
s : Finset α
⊢ List.toFinset (toList s) = s

tactic: simp
state_before: case a
α : Type u_1
β : Type ?u.480823
γ : Type ?u.480826
inst✝ : DecidableEq α
s : Finset α
a✝ : α
⊢ a✝ ∈ List.toFinset (toList s) ↔ a✝ ∈ s
Theorem: Ordinal.nfp_id
File: Mathlib/SetTheory/Ordinal/FixedPoint.lean

tactic: simp_rw [← sup_iterate_eq_nfp, iterate_id]
state_before: f : Ordinal → Ordinal
a : Ordinal
⊢ nfp id a = id a

tactic: exact sup_const a
state_before: f : Ordinal → Ordinal
a : Ordinal
⊢ (sup fun n => id a) = id a