ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: MeasureTheory.Measure.haar.index_defined
File: Mathlib/MeasureTheory/Measure/Haar/Basic.lean

Proof steps:
state_before: G : Type u_1
inst✝² : Group G
inst✝¹ : TopologicalSpace G
inst✝ : TopologicalGroup G
K V : Set G
hK : IsCompact K
hV : (interior V).Nonempty
⊢ ∃ n, n ∈ Finset.card '' {t | K ⊆ ⋃ g ∈ t, (fun h => g * h) ⁻¹' V}
state_after: case intro
G : Type u_1
inst✝² : Group G
inst✝¹ : TopologicalSpace G
inst✝ : TopologicalGroup G
K V : Set G
hK : IsCompact K
hV : (interior V).Nonempty
t : Finset G
ht : K ⊆ ⋃ g ∈ t, (fun x => g * x) ⁻¹' V
⊢ ∃ n, n ∈ Finset.card '' {t | K ⊆ ⋃ g ∈ t, (fun h => g * h) ⁻¹' V}
tactic: rcases compact_covered_by_mul_left_translates hK hV with ⟨t, ht⟩
state_before: case intro
G : Type u_1
inst✝² : Group G
inst✝¹ : TopologicalSpace G
inst✝ : TopologicalGroup G
K V : Set G
hK : IsCompact K
hV : (interior V).Nonempty
t : Finset G
ht : K ⊆ ⋃ g ∈ t, (fun x => g * x) ⁻¹' V
⊢ ∃ n, n ∈ Finset.card '' {t | K ⊆ ⋃ g ∈ t, (fun h => g * h) ⁻¹' V}
state_after: no goals
tactic: exact ⟨t.card, t, ht, rfl⟩
Theorem: MeasurableSet.iUnion
File: Mathlib/MeasureTheory/MeasurableSpace/Defs.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
δ' : Type u_5
ι : Sort u_6
s t u : Set α
m : MeasurableSpace α
inst✝ : Countable ι
f : ι → Set α
h : ∀ (b : ι), MeasurableSet (f b)
⊢ MeasurableSet (⋃ b, f b)
state_after: case inl
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
δ' : Type u_5
ι : Sort u_6
s t u : Set α
m : MeasurableSpace α
inst✝ : Countable ι
f : ι → Set α
h : ∀ (b : ι), MeasurableSet (f b)
h✝ : IsEmpty ι
⊢ MeasurableSet (⋃ b, f b)

case inr
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
δ' : Type u_5
ι : Sort u_6
s t u : Set α
m : MeasurableSpace α
inst✝ : Countable ι
f : ι → Set α
h : ∀ (b : ι), MeasurableSet (f b)
h✝ : Nonempty ι
⊢ MeasurableSet (⋃ b, f b)
tactic: cases isEmpty_or_nonempty ι
Theorem: Filter.cofinite.liminf_set_eq
File: Mathlib/Order/LiminfLimsup.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
ι' : Type u_5
p : ι → Prop
s : ι → Set α
𝓕 : Filter ι
a : α
⊢ liminf s cofinite = {x | {n | x ∉ s n}.Finite}
state_after: no goals
tactic: simp only [← cofinite.bliminf_true s, cofinite.bliminf_set_eq, true_and_iff]
Theorem: Matrix.range_cons
File: Mathlib/Data/Fin/VecNotation.lean

Proof steps:
state_before: α : Type u
m n o : ℕ
m' : Type u_1
n' : Type u_2
o' : Type u_3
x : α
u : Fin n → α
y : α
⊢ y ∈ Set.range (vecCons x u) ↔ y ∈ {x} ∪ Set.range u
state_after: no goals
tactic: simp [Fin.exists_fin_succ, eq_comm]
Theorem: Rat.coe_int_num_of_den_eq_one
File: Mathlib/Data/Rat/Defs.lean

Proof steps:
state_before: q✝ a b c q : ℚ
hq : q.den = 1
⊢ ↑q.num = q
state_after: q✝ a b c q : ℚ
hq : q.den = 1
⊢ ↑q.num = q.num /. ↑1
tactic: conv_rhs => rw [← num_divInt_den q, hq]
state_before: q✝ a b c q : ℚ
hq : q.den = 1
⊢ ↑q.num = q.num /. ↑1
state_after: q✝ a b c q : ℚ
hq : q.den = 1
⊢ q.num /. 1 = q.num /. ↑1
tactic: rw [intCast_eq_divInt]
state_before: q✝ a b c q : ℚ
hq : q.den = 1
⊢ q.num /. 1 = q.num /. ↑1
state_after: no goals
tactic: rfl
Theorem: Int.floor_int_add
File: Mathlib/Algebra/Order/Floor.lean

Proof steps:
state_before: F : Type u_1
α : Type u_2
β : Type u_3
inst✝¹ : LinearOrderedRing α
inst✝ : FloorRing α
z✝ : ℤ
a✝ : α
z : ℤ
a : α
⊢ ⌊↑z + a⌋ = z + ⌊a⌋
state_after: no goals
tactic: simpa only [add_comm] using floor_add_int a z
Theorem: LaurentPolynomial.T_pow
File: Mathlib/Algebra/Polynomial/Laurent.lean

Proof steps:
state_before: R : Type u_1
inst✝ : Semiring R
m : ℤ
n : ℕ
⊢ T m ^ n = T (↑n * m)
state_after: no goals
tactic: rw [T, T, single_pow n, one_pow, nsmul_eq_mul]
Theorem: Finset.mul_noncommProd_erase
File: Mathlib/Data/Finset/NoncommProd.lean

Proof steps:
state_before: F : Type u_1
ι : Type u_2
α : Type u_3
β : Type u_4
γ : Type u_5
f✝ : α → β → β
op : α → α → α
inst✝³ : Monoid β
inst✝² : Monoid γ
inst✝¹ : FunLike F β γ
inst✝ : DecidableEq α
s : Finset α
a : α
h : a ∈ s
f : α → β
comm : (↑s).Pairwise fun a b => Commute (f a) (f b)
comm' : optParam (∀ x ∈ ↑(s.erase a), ∀ y ∈ ↑(s.erase a), x ≠ y → (fun a b => Commute (f a) (f b)) x y) ⋯
⊢ f a * (s.erase a).noncommProd f comm' = s.noncommProd f comm
state_after: no goals
tactic: classical
  simpa only [← Multiset.map_erase_of_mem _ _ h] using
    Multiset.mul_noncommProd_erase (s.1.map f) (Multiset.mem_map_of_mem f h) _
Theorem: List.singleton_sublist
File: .lake/packages/batteries/Batteries/Data/List/Lemmas.lean

Proof steps:
state_before: α : Type u_1
a : α
l : List α
⊢ [a] <+ l ↔ a ∈ l
state_after: α : Type u_1
a : α
l : List α
h : a ∈ l
⊢ [a] <+ l
tactic: refine ⟨fun h => h.subset (mem_singleton_self _), fun h => ?_⟩
state_before: α : Type u_1
a : α
l : List α
h : a ∈ l
⊢ [a] <+ l
state_after: case intro.intro
α : Type u_1
a : α
w✝¹ w✝ : List α
h : a ∈ w✝¹ ++ a :: w✝
⊢ [a] <+ w✝¹ ++ a :: w✝
tactic: obtain ⟨_, _, rfl⟩ := append_of_mem h
state_before: case intro.intro
α : Type u_1
a : α
w✝¹ w✝ : List α
h : a ∈ w✝¹ ++ a :: w✝
⊢ [a] <+ w✝¹ ++ a :: w✝
state_after: no goals
tactic: exact ((nil_sublist _).cons₂ _).trans (sublist_append_right ..)
Theorem: threeAPFree_vadd_set
File: Mathlib/Combinatorics/Additive/AP/Three/Defs.lean

Proof steps:
state_before: F : Type u_1
α : Type u_2
β : Type u_3
𝕜 : Type u_4
E : Type u_5
inst✝ : CancelCommMonoid α
s : Set α
a : α
hs : ThreeGPFree (a • s)
b : α
hb : b ∈ s
c : α
hc : c ∈ s
d : α
hd : d ∈ s
h : b * d = c * c
⊢ a • b * a • d = a * c * (a * c)
state_after: no goals
tactic: rw [mul_mul_mul_comm, smul_eq_mul, smul_eq_mul, mul_mul_mul_comm, h]
Theorem: matPolyEquiv_map_C
File: Mathlib/RingTheory/PolynomialAlgebra.lean

Proof steps:
state_before: R : Type u_1
A : Type u_2
inst✝⁴ : CommSemiring R
inst✝³ : Semiring A
inst✝² : Algebra R A
n : Type w
inst✝¹ : DecidableEq n
inst✝ : Fintype n
M : Matrix n n R
⊢ matPolyEquiv (M.map ⇑C) = C M
state_after: no goals
tactic: rw [← matPolyEquiv_symm_C, AlgEquiv.apply_symm_apply]
Theorem: AddCircle.norm_eq
File: Mathlib/Analysis/Normed/Group/AddCircle.lean

Proof steps:
state_before: p x : ℝ
⊢ ∀ (x : ℝ), ‖↑x‖ = |x - ↑(round x)|
state_after: ⊢ ∀ (x : ℝ), ‖↑x‖ = |x - ↑(round x)|
tactic: clear! x p
state_before: ⊢ ∀ (x : ℝ), ‖↑x‖ = |x - ↑(round x)|
state_after: x : ℝ
⊢ ‖↑x‖ = |x - ↑(round x)|
tactic: intros x
state_before: x : ℝ
⊢ ‖↑x‖ = |x - ↑(round x)|
state_after: x : ℝ
⊢ sInf (norm '' {m | ↑m = ↑x}) = min (fract x) (1 - fract x)
tactic: rw [quotient_norm_eq, abs_sub_round_eq_min]
state_before: x : ℝ
⊢ sInf (norm '' {m | ↑m = ↑x}) = min (fract x) (1 - fract x)
state_after: x : ℝ
h₁ : BddBelow (abs '' {m | ↑m = ↑x})
⊢ sInf (norm '' {m | ↑m = ↑x}) = min (fract x) (1 - fract x)
tactic: have h₁ : BddBelow (abs '' { m : ℝ | (m : AddCircle (1 : ℝ)) = x }) :=
    ⟨0, by simp [mem_lowerBounds]⟩
state_before: x : ℝ
h₁ : BddBelow (abs '' {m | ↑m = ↑x})
⊢ sInf (norm '' {m | ↑m = ↑x}) = min (fract x) (1 - fract x)
state_after: x : ℝ
h₁ : BddBelow (abs '' {m | ↑m = ↑x})
h₂ : (abs '' {m | ↑m = ↑x}).Nonempty
⊢ sInf (norm '' {m | ↑m = ↑x}) = min (fract x) (1 - fract x)
tactic: have h₂ : (abs '' { m : ℝ | (m : AddCircle (1 : ℝ)) = x }).Nonempty := ⟨|x|, ⟨x, rfl, rfl⟩⟩
state_before: x : ℝ
h₁ : BddBelow (abs '' {m | ↑m = ↑x})
h₂ : (abs '' {m | ↑m = ↑x}).Nonempty
⊢ sInf (norm '' {m | ↑m = ↑x}) = min (fract x) (1 - fract x)
state_after: case a
x : ℝ
h₁ : BddBelow (abs '' {m | ↑m = ↑x})
h₂ : (abs '' {m | ↑m = ↑x}).Nonempty
⊢ sInf (norm '' {m | ↑m = ↑x}) ≤ min (fract x) (1 - fract x)

case a
x : ℝ
h₁ : BddBelow (abs '' {m | ↑m = ↑x})
h₂ : (abs '' {m | ↑m = ↑x}).Nonempty
⊢ min (fract x) (1 - fract x) ≤ sInf (norm '' {m | ↑m = ↑x})
tactic: apply le_antisymm
Theorem: Primrec.option_get
File: Mathlib/Computability/Primrec.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
σ : Type u_4
inst✝³ : Primcodable α
inst✝² : Primcodable β
inst✝¹ : Primcodable γ
inst✝ : Primcodable σ
f : α → Option β
h : ∀ (a : α), (f a).isSome = true
⊢ Primrec f → Primrec fun a => (f a).get ⋯
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
σ : Type u_4
inst✝³ : Primcodable α
inst✝² : Primcodable β
inst✝¹ : Primcodable γ
inst✝ : Primcodable σ
f : α → Option β
h : ∀ (a : α), (f a).isSome = true
hf : Primrec f
⊢ Primrec fun a => (f a).get ⋯
tactic: intro hf
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
σ : Type u_4
inst✝³ : Primcodable α
inst✝² : Primcodable β
inst✝¹ : Primcodable γ
inst✝ : Primcodable σ
f : α → Option β
h : ∀ (a : α), (f a).isSome = true
hf : Primrec f
⊢ Primrec fun a => (f a).get ⋯
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
σ : Type u_4
inst✝³ : Primcodable α
inst✝² : Primcodable β
inst✝¹ : Primcodable γ
inst✝ : Primcodable σ
f : α → Option β
h : ∀ (a : α), (f a).isSome = true
hf : Primrec f
n : ℕ
⊢ (encode (Option.map f (decode n))).pred = encode (Option.map (fun a => (f a).get ⋯) (decode n))
tactic: refine (Nat.Primrec.pred.comp hf).of_eq fun n => ?_
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
σ : Type u_4
inst✝³ : Primcodable α
inst✝² : Primcodable β
inst✝¹ : Primcodable γ
inst✝ : Primcodable σ
f : α → Option β
h : ∀ (a : α), (f a).isSome = true
hf : Primrec f
n : ℕ
⊢ (encode (Option.map f (decode n))).pred = encode (Option.map (fun a => (f a).get ⋯) (decode n))
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
σ : Type u_4
inst✝³ : Primcodable α
inst✝² : Primcodable β
inst✝¹ : Primcodable γ
inst✝ : Primcodable σ
f : α → Option β
h : ∀ (a : α), (f a).isSome = true
hf : Primrec f
n : ℕ
x : Option α
hx : decode n = x
⊢ (encode (Option.map f x)).pred = encode (Option.map (fun a => (f a).get ⋯) x)
tactic: generalize hx : @decode α _ n = x
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
σ : Type u_4
inst✝³ : Primcodable α
inst✝² : Primcodable β
inst✝¹ : Primcodable γ
inst✝ : Primcodable σ
f : α → Option β
h : ∀ (a : α), (f a).isSome = true
hf : Primrec f
n : ℕ
x : Option α
hx : decode n = x
⊢ (encode (Option.map f x)).pred = encode (Option.map (fun a => (f a).get ⋯) x)
state_after: no goals
tactic: cases x <;> simp
Theorem: Ideal.quotient_mk_maps_eq
File: Mathlib/RingTheory/Ideal/Over.lean

Proof steps:
state_before: R : Type u_1
inst✝¹ : CommRing R
S : Type u_2
inst✝ : CommRing S
f : R →+* S
I J : Ideal S
P : Ideal R[X]
⊢ ((Quotient.mk (map (mapRingHom (Quotient.mk (comap C P))) P)).comp C).comp (Quotient.mk (comap C P)) =
    (quotientMap (map (mapRingHom (Quotient.mk (comap C P))) P) (mapRingHom (Quotient.mk (comap C P))) ⋯).comp
      ((Quotient.mk P).comp C)
state_after: R : Type u_1
inst✝¹ : CommRing R
S : Type u_2
inst✝ : CommRing S
f : R →+* S
I J : Ideal S
P : Ideal R[X]
x : R
⊢ (((Quotient.mk (map (mapRingHom (Quotient.mk (comap C P))) P)).comp C).comp (Quotient.mk (comap C P))) x =
    ((quotientMap (map (mapRingHom (Quotient.mk (comap C P))) P) (mapRingHom (Quotient.mk (comap C P))) ⋯).comp
        ((Quotient.mk P).comp C))
      x
tactic: refine RingHom.ext fun x => ?_
state_before: R : Type u_1
inst✝¹ : CommRing R
S : Type u_2
inst✝ : CommRing S
f : R →+* S
I J : Ideal S
P : Ideal R[X]
x : R
⊢ (((Quotient.mk (map (mapRingHom (Quotient.mk (comap C P))) P)).comp C).comp (Quotient.mk (comap C P))) x =
    ((quotientMap (map (mapRingHom (Quotient.mk (comap C P))) P) (mapRingHom (Quotient.mk (comap C P))) ⋯).comp
        ((Quotient.mk P).comp C))
      x
state_after: R : Type u_1
inst✝¹ : CommRing R
S : Type u_2
inst✝ : CommRing S
f : R →+* S
I J : Ideal S
P : Ideal R[X]
x : R
⊢ (Quotient.mk (map (mapRingHom (Quotient.mk (comap C P))) P)) (C ((Quotient.mk (comap C P)) x)) =
    (quotientMap (map (mapRingHom (Quotient.mk (comap C P))) P) (mapRingHom (Quotient.mk (comap C P))) ⋯)
      ((Quotient.mk P) (C x))
tactic: repeat' rw [RingHom.coe_comp, Function.comp_apply]
state_before: R : Type u_1
inst✝¹ : CommRing R
S : Type u_2
inst✝ : CommRing S
f : R →+* S
I J : Ideal S
P : Ideal R[X]
x : R
⊢ (Quotient.mk (map (mapRingHom (Quotient.mk (comap C P))) P)) (C ((Quotient.mk (comap C P)) x)) =
    (quotientMap (map (mapRingHom (Quotient.mk (comap C P))) P) (mapRingHom (Quotient.mk (comap C P))) ⋯)
      ((Quotient.mk P) (C x))
state_after: no goals
tactic: rw [quotientMap_mk, coe_mapRingHom, map_C]
Theorem: Algebra.IsAlgebraic.cardinal_mk_le_max
File: Mathlib/FieldTheory/IsAlgClosed/Classification.lean

Proof steps:
state_before: R L : Type u
inst✝⁵ : CommRing R
inst✝⁴ : CommRing L
inst✝³ : IsDomain L
inst✝² : Algebra R L
inst✝¹ : NoZeroSMulDivisors R L
inst✝ : Algebra.IsAlgebraic R L
⊢ #((p : R[X]) × { x // x ∈ p.aroots L }) = sum fun p => #↑{x | x ∈ p.aroots L}
state_after: R L : Type u
inst✝⁵ : CommRing R
inst✝⁴ : CommRing L
inst✝³ : IsDomain L
inst✝² : Algebra R L
inst✝¹ : NoZeroSMulDivisors R L
inst✝ : Algebra.IsAlgebraic R L
⊢ #((p : R[X]) × { x // x ∈ p.aroots L }) = #((i : R[X]) × ↑{x | x ∈ i.aroots L})
tactic: rw [← mk_sigma]
state_before: R L : Type u
inst✝⁵ : CommRing R
inst✝⁴ : CommRing L
inst✝³ : IsDomain L
inst✝² : Algebra R L
inst✝¹ : NoZeroSMulDivisors R L
inst✝ : Algebra.IsAlgebraic R L
⊢ #((p : R[X]) × { x // x ∈ p.aroots L }) = #((i : R[X]) × ↑{x | x ∈ i.aroots L})
state_after: no goals
tactic: rfl
state_before: R L : Type u
inst✝⁵ : CommRing R
inst✝⁴ : CommRing L
inst✝³ : IsDomain L
inst✝² : Algebra R L
inst✝¹ : NoZeroSMulDivisors R L
inst✝ : Algebra.IsAlgebraic R L
⊢ max (max (max #R ℵ₀) ℵ₀) ℵ₀ = max #R ℵ₀
state_after: no goals
tactic: simp only [max_assoc, max_comm ℵ₀, max_left_comm ℵ₀, max_self]
Theorem: Ideal.exists_forall_sub_mem_ideal
File: Mathlib/RingTheory/Ideal/QuotientOperations.lean

Proof steps:
state_before: R✝ : Type u
S : Type v
F : Type w
inst✝³ : CommRing R✝
inst✝² : Semiring S
ι✝ : Type u_1
R : Type u_2
inst✝¹ : CommRing R
ι : Type u_3
inst✝ : Finite ι
I : ι → Ideal R
hI : Pairwise fun i j => IsCoprime (I i) (I j)
x : ι → R
⊢ ∃ r, ∀ (i : ι), r - x i ∈ I i
state_after: case intro
R✝ : Type u
S : Type v
F : Type w
inst✝³ : CommRing R✝
inst✝² : Semiring S
ι✝ : Type u_1
R : Type u_2
inst✝¹ : CommRing R
ι : Type u_3
inst✝ : Finite ι
I : ι → Ideal R
hI : Pairwise fun i j => IsCoprime (I i) (I j)
x : ι → R
y : R
hy : ∀ (i : ι), (Quotient.mk (I i)) y = (Quotient.mk (I i)) (x i)
⊢ ∃ r, ∀ (i : ι), r - x i ∈ I i
tactic: obtain ⟨y, hy⟩ := Ideal.pi_quotient_surjective hI (fun i ↦ x i)
state_before: case intro
R✝ : Type u
S : Type v
F : Type w
inst✝³ : CommRing R✝
inst✝² : Semiring S
ι✝ : Type u_1
R : Type u_2
inst✝¹ : CommRing R
ι : Type u_3
inst✝ : Finite ι
I : ι → Ideal R
hI : Pairwise fun i j => IsCoprime (I i) (I j)
x : ι → R
y : R
hy : ∀ (i : ι), (Quotient.mk (I i)) y = (Quotient.mk (I i)) (x i)
⊢ ∃ r, ∀ (i : ι), r - x i ∈ I i
state_after: no goals
tactic: exact ⟨y, fun i ↦ (Submodule.Quotient.eq (I i)).mp <| hy i⟩
Theorem: IsometryEquiv.ediam_univ
File: Mathlib/Topology/MetricSpace/Isometry.lean

Proof steps:
state_before: ι : Type u_1
α : Type u
β : Type v
γ : Type w
inst✝² : PseudoEMetricSpace α
inst✝¹ : PseudoEMetricSpace β
inst✝ : PseudoEMetricSpace γ
h : α ≃ᵢ β
⊢ EMetric.diam univ = EMetric.diam univ
state_after: no goals
tactic: rw [← h.range_eq_univ, h.isometry.ediam_range]
Theorem: Set.subsingleton_of_einfsep_eq_top
File: Mathlib/Topology/MetricSpace/Infsep.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
inst✝ : PseudoMetricSpace α
s : Set α
hs : s.einfsep = ⊤
⊢ s.Subsingleton
state_after: α : Type u_1
β : Type u_2
inst✝ : PseudoMetricSpace α
s : Set α
hs : ∀ x ∈ s, ∀ y ∈ s, x ≠ y → edist x y = ⊤
⊢ s.Subsingleton
tactic: rw [einfsep_top] at hs
state_before: α : Type u_1
β : Type u_2
inst✝ : PseudoMetricSpace α
s : Set α
hs : ∀ x ∈ s, ∀ y ∈ s, x ≠ y → edist x y = ⊤
⊢ s.Subsingleton
state_after: no goals
tactic: exact fun _ hx _ hy => of_not_not fun hxy => edist_ne_top _ _ (hs _ hx _ hy hxy)
Theorem: ProbabilityTheory.condIndepSets_singleton_iff
File: Mathlib/Probability/Independence/Conditional.lean

Proof steps:
state_before: Ω : Type u_1
ι : Type u_2
m' mΩ : MeasurableSpace Ω
inst✝² : StandardBorelSpace Ω
inst✝¹ : Nonempty Ω
hm' : m' ≤ mΩ
μ : Measure Ω
inst✝ : IsFiniteMeasure μ
s t : Set Ω
hs : MeasurableSet s
ht : MeasurableSet t
⊢ CondIndepSets m' hm' {s} {t} μ ↔
    μ[(s ∩ t).indicator fun ω => 1|m'] =ᶠ[ae μ] μ[s.indicator fun ω => 1|m'] * μ[t.indicator fun ω => 1|m']
state_after: Ω : Type u_1
ι : Type u_2
m' mΩ : MeasurableSpace Ω
inst✝² : StandardBorelSpace Ω
inst✝¹ : Nonempty Ω
hm' : m' ≤ mΩ
μ : Measure Ω
inst✝ : IsFiniteMeasure μ
s t : Set Ω
hs : MeasurableSet s
ht : MeasurableSet t
⊢ (∀ (t1 t2 : Set Ω),
      t1 ∈ {s} →
        t2 ∈ {t} →
          μ[(t1 ∩ t2).indicator fun ω => 1|m'] =ᶠ[ae μ] μ[t1.indicator fun ω => 1|m'] * μ[t2.indicator fun ω => 1|m']) ↔
    μ[(s ∩ t).indicator fun ω => 1|m'] =ᶠ[ae μ] μ[s.indicator fun ω => 1|m'] * μ[t.indicator fun ω => 1|m']

Ω : Type u_1
ι : Type u_2
m' mΩ : MeasurableSpace Ω
inst✝² : StandardBorelSpace Ω
inst✝¹ : Nonempty Ω
hm' : m' ≤ mΩ
μ : Measure Ω
inst✝ : IsFiniteMeasure μ
s t : Set Ω
hs : MeasurableSet s
ht : MeasurableSet t
⊢ ∀ s_1 ∈ {s}, MeasurableSet s_1

Ω : Type u_1
ι : Type u_2
m' mΩ : MeasurableSpace Ω
inst✝² : StandardBorelSpace Ω
inst✝¹ : Nonempty Ω
hm' : m' ≤ mΩ
μ : Measure Ω
inst✝ : IsFiniteMeasure μ
s t : Set Ω
hs : MeasurableSet s
ht : MeasurableSet t
⊢ ∀ s ∈ {t}, MeasurableSet s
tactic: rw [condIndepSets_iff _ _ _ _ ?_ ?_]
Theorem: Set.Iic_diff_Iic
File: Mathlib/Order/Interval/Set/Basic.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
inst✝ : LinearOrder α
a a₁ a₂ b b₁ b₂ c d : α
⊢ Iic b \ Iic a = Ioc a b
state_after: no goals
tactic: rw [diff_eq, compl_Iic, inter_comm, Ioi_inter_Iic]
Theorem: Matrix.IsAdjMatrix.adjMatrix_toGraph_eq
File: Mathlib/Combinatorics/SimpleGraph/AdjMatrix.lean

Proof steps:
state_before: V : Type u_1
α : Type u_2
β : Type u_3
inst✝² : MulZeroOneClass α
inst✝¹ : Nontrivial α
A : Matrix V V α
h : A.IsAdjMatrix
inst✝ : DecidableEq α
⊢ adjMatrix α h.toGraph = A
state_after: case a
V : Type u_1
α : Type u_2
β : Type u_3
inst✝² : MulZeroOneClass α
inst✝¹ : Nontrivial α
A : Matrix V V α
h : A.IsAdjMatrix
inst✝ : DecidableEq α
i j : V
⊢ adjMatrix α h.toGraph i j = A i j
tactic: ext i j
state_before: case a
V : Type u_1
α : Type u_2
β : Type u_3
inst✝² : MulZeroOneClass α
inst✝¹ : Nontrivial α
A : Matrix V V α
h : A.IsAdjMatrix
inst✝ : DecidableEq α
i j : V
⊢ adjMatrix α h.toGraph i j = A i j
state_after: no goals
tactic: obtain h' | h' := h.zero_or_one i j <;> simp [h']
Theorem: CategoryTheory.PreOneHypercover.map_X
File: Mathlib/CategoryTheory/Sites/Continuous.lean

Proof steps:
state_before: C : Type u₁
inst✝² : Category.{v₁, u₁} C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
E✝ : Type u₃
inst✝ : Category.{v₃, u₃} E✝
X : C
E : PreOneHypercover X
F : C ⥤ D
x✝¹ x✝ : E.I₀
j : E.I₁ x✝¹ x✝
⊢ (fun x x_1 j => F.map (E.p₁ j)) x✝¹ x✝ j ≫ (fun i => F.map (E.f i)) x✝¹ =
    (fun x x_1 j => F.map (E.p₂ j)) x✝¹ x✝ j ≫ (fun i => F.map (E.f i)) x✝
state_after: no goals
tactic: simpa using F.congr_map (E.w j)
Theorem: GaloisConnection.u_eq
File: Mathlib/Order/GaloisConnection.lean

Proof steps:
state_before: α : Type u
β : Type v
γ : Type w
ι : Sort x
κ : ι → Sort u_1
a a₁ a₂ : α
b b₁ b₂ : β
inst✝¹ : PartialOrder α
inst✝ : Preorder β
l : α → β
u : β → α
gc✝ gc : GaloisConnection l u
z : α
y : β
⊢ u y = z ↔ ∀ (x : α), x ≤ z ↔ l x ≤ y
state_after: case mp
α : Type u
β : Type v
γ : Type w
ι : Sort x
κ : ι → Sort u_1
a a₁ a₂ : α
b b₁ b₂ : β
inst✝¹ : PartialOrder α
inst✝ : Preorder β
l : α → β
u : β → α
gc✝ gc : GaloisConnection l u
z : α
y : β
⊢ u y = z → ∀ (x : α), x ≤ z ↔ l x ≤ y

case mpr
α : Type u
β : Type v
γ : Type w
ι : Sort x
κ : ι → Sort u_1
a a₁ a₂ : α
b b₁ b₂ : β
inst✝¹ : PartialOrder α
inst✝ : Preorder β
l : α → β
u : β → α
gc✝ gc : GaloisConnection l u
z : α
y : β
⊢ (∀ (x : α), x ≤ z ↔ l x ≤ y) → u y = z
tactic: constructor
Theorem: EuclideanGeometry.sin_oangle_left_mul_dist_of_oangle_eq_pi_div_two
File: Mathlib/Geometry/Euclidean/Angle/Oriented/RightAngle.lean

Proof steps:
state_before: V : Type u_1
P : Type u_2
inst✝⁴ : NormedAddCommGroup V
inst✝³ : InnerProductSpace ℝ V
inst✝² : MetricSpace P
inst✝¹ : NormedAddTorsor V P
hd2 : Fact (finrank ℝ V = 2)
inst✝ : Module.Oriented ℝ V (Fin 2)
p₁ p₂ p₃ : P
h : ∡ p₁ p₂ p₃ = ↑(π / 2)
⊢ (∡ p₃ p₁ p₂).sin * dist p₁ p₃ = dist p₃ p₂
state_after: V : Type u_1
P : Type u_2
inst✝⁴ : NormedAddCommGroup V
inst✝³ : InnerProductSpace ℝ V
inst✝² : MetricSpace P
inst✝¹ : NormedAddTorsor V P
hd2 : Fact (finrank ℝ V = 2)
inst✝ : Module.Oriented ℝ V (Fin 2)
p₁ p₂ p₃ : P
h : ∡ p₁ p₂ p₃ = ↑(π / 2)
hs : (∡ p₃ p₁ p₂).sign = 1
⊢ (∡ p₃ p₁ p₂).sin * dist p₁ p₃ = dist p₃ p₂
tactic: have hs : (∡ p₃ p₁ p₂).sign = 1 := by rw [← oangle_rotate_sign, h, Real.Angle.sign_coe_pi_div_two]
state_before: V : Type u_1
P : Type u_2
inst✝⁴ : NormedAddCommGroup V
inst✝³ : InnerProductSpace ℝ V
inst✝² : MetricSpace P
inst✝¹ : NormedAddTorsor V P
hd2 : Fact (finrank ℝ V = 2)
inst✝ : Module.Oriented ℝ V (Fin 2)
p₁ p₂ p₃ : P
h : ∡ p₁ p₂ p₃ = ↑(π / 2)
hs : (∡ p₃ p₁ p₂).sign = 1
⊢ (∡ p₃ p₁ p₂).sin * dist p₁ p₃ = dist p₃ p₂
state_after: no goals
tactic: rw [oangle_eq_angle_of_sign_eq_one hs, angle_comm, Real.Angle.sin_coe, dist_comm p₁ p₃,
    sin_angle_mul_dist_of_angle_eq_pi_div_two (angle_rev_eq_pi_div_two_of_oangle_eq_pi_div_two h)]
Theorem: Mathlib.Vector.map₂_snoc
File: Mathlib/Data/Vector/Snoc.lean

Proof steps:
state_before: α : Type u_2
n : ℕ
β : Type u_3
xs : Vector α n
ys : Vector β n
α✝ : Type u_1
f : α → β → α✝
x : α
y : β
⊢ map₂ f (xs.snoc x) (ys.snoc y) = (map₂ f xs ys).snoc (f x y)
state_after: no goals
tactic: induction xs, ys using Vector.inductionOn₂ <;> simp_all
Theorem: starMulEquiv_apply
File: Mathlib/Algebra/Star/Basic.lean

Proof steps:
state_before: R : Type u
inst✝¹ : Mul R
inst✝ : StarMul R
x y : R
⊢ { toFun := fun x => op (star x), invFun := __src✝.invFun, left_inv := ⋯, right_inv := ⋯ }.toFun (x * y) =
    { toFun := fun x => op (star x), invFun := __src✝.invFun, left_inv := ⋯, right_inv := ⋯ }.toFun x *
      { toFun := fun x => op (star x), invFun := __src✝.invFun, left_inv := ⋯, right_inv := ⋯ }.toFun y
state_after: no goals
tactic: simp only [star_mul, op_mul]
Theorem: descPochhammer_map
File: Mathlib/RingTheory/Polynomial/Pochhammer.lean

Proof steps:
state_before: R : Type u
inst✝¹ : Ring R
T : Type v
inst✝ : Ring T
f : R →+* T
n : ℕ
⊢ map f (descPochhammer R n) = descPochhammer T n
state_after: case zero
R : Type u
inst✝¹ : Ring R
T : Type v
inst✝ : Ring T
f : R →+* T
⊢ map f (descPochhammer R 0) = descPochhammer T 0

case succ
R : Type u
inst✝¹ : Ring R
T : Type v
inst✝ : Ring T
f : R →+* T
n : ℕ
ih : map f (descPochhammer R n) = descPochhammer T n
⊢ map f (descPochhammer R (n + 1)) = descPochhammer T (n + 1)
tactic: induction' n with n ih
Theorem: Filter.IsBoundedUnder.mono_le
File: Mathlib/Order/LiminfLimsup.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
ι' : Type u_5
r : α → α → Prop
f g : Filter α
inst✝ : Preorder β
l : Filter α
u v : α → β
hu : IsBoundedUnder (fun x x_1 => x ≤ x_1) l u
hv : v ≤ᶠ[l] u
⊢ IsBoundedUnder (fun x x_1 => x ≤ x_1) l v
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
ι' : Type u_5
r : α → α → Prop
f g : Filter α
inst✝ : Preorder β
l : Filter α
u v : α → β
hu : IsBoundedUnder (fun x x_1 => x ≤ x_1) l u
hv : v ≤ᶠ[l] u
⊢ ∀ (a : β), (∀ᶠ (x : β) in map u l, (fun x x_1 => x ≤ x_1) x a) → ∀ᶠ (x : β) in map v l, (fun x x_1 => x ≤ x_1) x a
tactic: apply hu.imp
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
ι' : Type u_5
r : α → α → Prop
f g : Filter α
inst✝ : Preorder β
l : Filter α
u v : α → β
hu : IsBoundedUnder (fun x x_1 => x ≤ x_1) l u
hv : v ≤ᶠ[l] u
⊢ ∀ (a : β), (∀ᶠ (x : β) in map u l, (fun x x_1 => x ≤ x_1) x a) → ∀ᶠ (x : β) in map v l, (fun x x_1 => x ≤ x_1) x a
state_after: no goals
tactic: exact fun b hb => (eventually_map.1 hb).mp <| hv.mono fun x => le_trans