1337xyz1337xyz/leandojo-benchmark4-v10 huggingface dataset:
Theorem: MeasureTheory.lintegral_eq_zero_iff'
File: Mathlib/MeasureTheory/Integral/Lebesgue.lean

tactic: simp [lintegral_zero, zero_ne_top]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
m : MeasurableSpace α
μ ν : Measure α
f : α → ℝ≥0∞
hf : AEMeasurable f μ
⊢ ∫⁻ (x : α), 0 ∂μ ≠ ⊤
state_after: no goals
Theorem: StructureGroupoid.LocalInvariantProp.liftPropAt_of_liftPropWithinAt
File: Mathlib/Geometry/Manifold/LocalInvariantProperties.lean

tactic: rwa [← univ_inter s, hG.liftPropWithinAt_inter hs] at h
state_before: H : Type u_1
M : Type u_2
H' : Type u_3
M' : Type u_4
X : Type u_5
inst✝⁶ : TopologicalSpace H
inst✝⁵ : TopologicalSpace M
inst✝⁴ : ChartedSpace H M
inst✝³ : TopologicalSpace H'
inst✝² : TopologicalSpace M'
inst✝¹ : ChartedSpace H' M'
inst✝ : TopologicalSpace X
G : StructureGroupoid H
G' : StructureGroupoid H'
e e' : PartialHomeomorph M H
f f' : PartialHomeomorph M' H'
P : (H → H') → Set H → H → Prop
g g' : M → M'
s t : Set M
x : M
Q : (H → H) → Set H → H → Prop
hG : G.LocalInvariantProp G' P
h : LiftPropWithinAt P g s x
hs : s ∈ 𝓝 x
⊢ LiftPropAt P g x
state_after: no goals
Theorem: Set.definable_finset_sup
File: Mathlib/ModelTheory/Definability.lean

tactic: classical
  refine Finset.induction definable_empty (fun i s _ h => ?_) s
  rw [Finset.sup_insert]
  exact (hf i).union h
state_before: M : Type w
A : Set M
L : Language
inst✝ : L.Structure M
α : Type u₁
β : Type u_1
B : Set M
s✝ : Set (α → M)
ι : Type u_2
f : ι → Set (α → M)
hf : ∀ (i : ι), A.Definable L (f i)
s : Finset ι
⊢ A.Definable L (s.sup f)
state_after: no goals

tactic: refine Finset.induction definable_empty (fun i s _ h => ?_) s
state_before: M : Type w
A : Set M
L : Language
inst✝ : L.Structure M
α : Type u₁
β : Type u_1
B : Set M
s✝ : Set (α → M)
ι : Type u_2
f : ι → Set (α → M)
hf : ∀ (i : ι), A.Definable L (f i)
s : Finset ι
⊢ A.Definable L (s.sup f)
state_after: M : Type w
A : Set M
L : Language
inst✝ : L.Structure M
α : Type u₁
β : Type u_1
B : Set M
s✝¹ : Set (α → M)
ι : Type u_2
f : ι → Set (α → M)
hf : ∀ (i : ι), A.Definable L (f i)
s✝ : Finset ι
i : ι
s : Finset ι
x✝ : i ∉ s
h : A.Definable L (s.sup f)
⊢ A.Definable L ((insert i s).sup f)

tactic: rw [Finset.sup_insert]
state_before: M : Type w
A : Set M
L : Language
inst✝ : L.Structure M
α : Type u₁
β : Type u_1
B : Set M
s✝¹ : Set (α → M)
ι : Type u_2
f : ι → Set (α → M)
hf : ∀ (i : ι), A.Definable L (f i)
s✝ : Finset ι
i : ι
s : Finset ι
x✝ : i ∉ s
h : A.Definable L (s.sup f)
⊢ A.Definable L ((insert i s).sup f)
state_after: M : Type w
A : Set M
L : Language
inst✝ : L.Structure M
α : Type u₁
β : Type u_1
B : Set M
s✝¹ : Set (α → M)
ι : Type u_2
f : ι → Set (α → M)
hf : ∀ (i : ι), A.Definable L (f i)
s✝ : Finset ι
i : ι
s : Finset ι
x✝ : i ∉ s
h : A.Definable L (s.sup f)
⊢ A.Definable L (f i ⊔ s.sup f)

tactic: exact (hf i).union h
state_before: M : Type w
A : Set M
L : Language
inst✝ : L.Structure M
α : Type u₁
β : Type u_1
B : Set M
s✝¹ : Set (α → M)
ι : Type u_2
f : ι → Set (α → M)
hf : ∀ (i : ι), A.Definable L (f i)
s✝ : Finset ι
i : ι
s : Finset ι
x✝ : i ∉ s
h : A.Definable L (s.sup f)
⊢ A.Definable L (f i ⊔ s.sup f)
state_after: no goals
Theorem: CochainComplex.mappingCone.inl_v_snd_v
File: Mathlib/Algebra/Homology/HomotopyCategory/MappingCone.lean

tactic: simp [inl, snd]
state_before: C : Type u_1
inst✝² : Category.{u_2, u_1} C
inst✝¹ : Preadditive C
F G : CochainComplex C ℤ
φ : F ⟶ G
inst✝ : HasHomotopyCofiber φ
p q : ℤ
hpq : p + -1 = q
⊢ (inl φ).v p q hpq ≫ (snd φ).v q q ⋯ = 0
state_after: no goals
Theorem: Polynomial.smul_comp
File: Mathlib/Algebra/Polynomial/Eval.lean

tactic: rw [← smul_one_smul R s p, comp, comp, eval₂_smul, ← smul_eq_C_mul, smul_assoc, one_smul]
state_before: R : Type u
S : Type v
T : Type w
ι : Type y
a b : R
m n : ℕ
inst✝³ : Semiring R
p✝ q✝ r : R[X]
inst✝² : Monoid S
inst✝¹ : DistribMulAction S R
inst✝ : IsScalarTower S R R
s : S
p q : R[X]
⊢ (s • p).comp q = s • p.comp q
state_after: no goals
Theorem: Equiv.Perm.extendDomain_apply_not_subtype
File: Mathlib/Logic/Equiv/Basic.lean

tactic: simp [Perm.extendDomain, h]
state_before: α' : Type u_1
β' : Type u_2
e : Perm α'
p : β' → Prop
inst✝ : DecidablePred p
f : α' ≃ Subtype p
b : β'
h : ¬p b
⊢ (e.extendDomain f) b = b
state_after: no goals
Theorem: List.ofFn_eq_nil_iff
File: Mathlib/Data/List/OfFn.lean

tactic: cases n <;> simp only [ofFn_zero, ofFn_succ, eq_self_iff_true, Nat.succ_ne_zero]
state_before: α : Type u
n : ℕ
f : Fin n → α
⊢ ofFn f = [] ↔ n = 0
state_after: no goals
Theorem: preNormEDS_three
File: Mathlib/NumberTheory/EllipticDivisibilitySequence.lean

tactic: erw [preNormEDS_ofNat, preNormEDS'_three]
state_before: R : Type u
S : Type v
inst✝¹ : CommRing R
inst✝ : CommRing S
W : ℤ → R
f : R →+* S
b c d : R
⊢ preNormEDS b c d 3 = c
state_after: no goals
Theorem: Polynomial.scaleRoots_one
File: Mathlib/RingTheory/Polynomial/ScaleRoots.lean

tactic: ext
state_before: R : Type u_1
S : Type u_2
A : Type u_3
K : Type u_4
inst✝¹ : Semiring R
inst✝ : Semiring S
p : R[X]
⊢ p.scaleRoots 1 = p
state_after: case a
R : Type u_1
S : Type u_2
A : Type u_3
K : Type u_4
inst✝¹ : Semiring R
inst✝ : Semiring S
p : R[X]
n✝ : ℕ
⊢ (p.scaleRoots 1).coeff n✝ = p.coeff n✝

tactic: simp
state_before: case a
R : Type u_1
S : Type u_2
A : Type u_3
K : Type u_4
inst✝¹ : Semiring R
inst✝ : Semiring S
p : R[X]
n✝ : ℕ
⊢ (p.scaleRoots 1).coeff n✝ = p.coeff n✝
state_after: no goals
Theorem: UnionFind.lt_rankMax
File: Mathlib/Data/UnionFind.lean

tactic: simp [rank]
state_before: α : Type u_1
self : UnionFind α
i : ℕ
⊢ self.rank i < self.rankMax
state_after: α : Type u_1
self : UnionFind α
i : ℕ
⊢ (if h : i < self.size then self.arr[i].rank else 0) < self.rankMax

tactic: split
state_before: α : Type u_1
self : UnionFind α
i : ℕ
⊢ (if h : i < self.size then self.arr[i].rank else 0) < self.rankMax
state_after: case isTrue
α : Type u_1
self : UnionFind α
i : ℕ
h✝ : i < self.size
⊢ self.arr[i].rank < self.rankMax

case isFalse
α : Type u_1
self : UnionFind α
i : ℕ
h✝ : ¬i < self.size
⊢ 0 < self.rankMax

tactic: {apply lt_rankMax'}
state_before: case isTrue
α : Type u_1
self : UnionFind α
i : ℕ
h✝ : i < self.size
⊢ self.arr[i].rank < self.rankMax

case isFalse
α : Type u_1
self : UnionFind α
i : ℕ
h✝ : ¬i < self.size
⊢ 0 < self.rankMax
state_after: case isFalse
α : Type u_1
self : UnionFind α
i : ℕ
h✝ : ¬i < self.size
⊢ 0 < self.rankMax

tactic: apply Nat.succ_pos
state_before: case isFalse
α : Type u_1
self : UnionFind α
i : ℕ
h✝ : ¬i < self.size
⊢ 0 < self.rankMax
state_after: no goals

tactic: apply lt_rankMax'
state_before: case isTrue
α : Type u_1
self : UnionFind α
i : ℕ
h✝ : i < self.size
⊢ self.arr[i].rank < self.rankMax
state_after: no goals
Theorem: Filter.EventuallyLE.congr
File: Mathlib/Order/Filter/Basic.lean

tactic: rwa [hf, hg] at H
state_before: α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
inst✝ : LE β
l : Filter α
f f' g g' : α → β
H✝ : f ≤ᶠ[l] g
hf✝ : f =ᶠ[l] f'
hg✝ : g =ᶠ[l] g'
x : α
hf : f x = f' x
hg : g x = g' x
H : f x ≤ g x
⊢ f' x ≤ g' x
state_after: no goals
Theorem: IsMaxFilter.sub
File: Mathlib/Order/Filter/Extr.lean

tactic: simpa only [sub_eq_add_neg] using hf.add hg.neg
state_before: α : Type u
β : Type v
γ : Type w
δ : Type x
inst✝ : OrderedAddCommGroup β
f g : α → β
a : α
s : Set α
l : Filter α
hf : IsMaxFilter f l a
hg : IsMinFilter g l a
⊢ IsMaxFilter (fun x => f x - g x) l a
state_after: no goals
Theorem: Subgroup.commProb_subgroup_le
File: Mathlib/GroupTheory/CommutingProbability.lean

tactic: rw [commProb_def, commProb_def, div_le_iff, mul_assoc, ← mul_pow, ← Nat.cast_mul,
  mul_comm H.index, H.card_mul_index, div_mul_cancel₀, Nat.cast_le]
state_before: M : Type u_1
inst✝³ : Mul M
inst✝² : Finite M
G : Type u_2
inst✝¹ : Group G
inst✝ : Finite G
H : Subgroup G
⊢ commProb ↥H ≤ commProb G * ↑H.index ^ 2
state_after: M : Type u_1
inst✝³ : Mul M
inst✝² : Finite M
G : Type u_2
inst✝¹ : Group G
inst✝ : Finite G
H : Subgroup G
⊢ Nat.card { p // Commute p.1 p.2 } ≤ Nat.card { p // Commute p.1 p.2 }

case h
M : Type u_1
inst✝³ : Mul M
inst✝² : Finite M
G : Type u_2
inst✝¹ : Group G
inst✝ : Finite G
H : Subgroup G
⊢ ↑(Nat.card G) ^ 2 ≠ 0

M : Type u_1
inst✝³ : Mul M
inst✝² : Finite M
G : Type u_2
inst✝¹ : Group G
inst✝ : Finite G
H : Subgroup G
⊢ 0 < ↑(Nat.card ↥H) ^ 2

tactic: refine Finite.card_le_of_injective (fun p ↦ ⟨⟨p.1.1, p.1.2⟩, Subtype.ext_iff.mp p.2⟩) ?_
state_before: M : Type u_1
inst✝³ : Mul M
inst✝² : Finite M
G : Type u_2
inst✝¹ : Group G
inst✝ : Finite G
H : Subgroup G
⊢ Nat.card { p // Commute p.1 p.2 } ≤ Nat.card { p // Commute p.1 p.2 }
state_after: M : Type u_1
inst✝³ : Mul M
inst✝² : Finite M
G : Type u_2
inst✝¹ : Group G
inst✝ : Finite G
H : Subgroup G
⊢ Function.Injective fun p => ⟨(↑(↑p).1, ↑(↑p).2), ⋯⟩

tactic: exact fun p q h ↦ by simpa only [Subtype.ext_iff, Prod.ext_iff] using h
state_before: M : Type u_1
inst✝³ : Mul M
inst✝² : Finite M
G : Type u_2
inst✝¹ : Group G
inst✝ : Finite G
H : Subgroup G
⊢ Function.Injective fun p => ⟨(↑(↑p).1, ↑(↑p).2), ⋯⟩
state_after: no goals

tactic: simpa only [Subtype.ext_iff, Prod.ext_iff] using h
state_before: M : Type u_1
inst✝³ : Mul M
inst✝² : Finite M
G : Type u_2
inst✝¹ : Group G
inst✝ : Finite G
H : Subgroup G
p q : { p // Commute p.1 p.2 }
h : (fun p => ⟨(↑(↑p).1, ↑(↑p).2), ⋯⟩) p = (fun p => ⟨(↑(↑p).1, ↑(↑p).2), ⋯⟩) q
⊢ p = q
state_after: no goals

tactic: exact pow_ne_zero 2 (Nat.cast_ne_zero.mpr Finite.card_pos.ne')
state_before: case h
M : Type u_1
inst✝³ : Mul M
inst✝² : Finite M
G : Type u_2
inst✝¹ : Group G
inst✝ : Finite G
H : Subgroup G
⊢ ↑(Nat.card G) ^ 2 ≠ 0
state_after: no goals

tactic: exact pow_pos (Nat.cast_pos.mpr Finite.card_pos) 2
state_before: M : Type u_1
inst✝³ : Mul M
inst✝² : Finite M
G : Type u_2
inst✝¹ : Group G
inst✝ : Finite G
H : Subgroup G
⊢ 0 < ↑(Nat.card ↥H) ^ 2
state_after: no goals
Theorem: Function.surjective_of_right_cancellable_Prop
File: Mathlib/Logic/Function/Basic.lean

tactic: specialize h (fun y ↦ ∃ x, f x = y) (fun _ ↦ True) (funext fun x ↦ eq_true ⟨_, rfl⟩)
state_before: α : Sort u_1
β : Sort u_2
γ : Sort u_3
f : α → β
h : ∀ (g₁ g₂ : β → Prop), g₁ ∘ f = g₂ ∘ f → g₁ = g₂
⊢ Surjective f
state_after: α : Sort u_1
β : Sort u_2
γ : Sort u_3
f : α → β
h : (fun y => ∃ x, f x = y) = fun x => True
⊢ Surjective f

tactic: intro y
state_before: α : Sort u_1
β : Sort u_2
γ : Sort u_3
f : α → β
h : (fun y => ∃ x, f x = y) = fun x => True
⊢ Surjective f
state_after: α : Sort u_1
β : Sort u_2
γ : Sort u_3
f : α → β
h : (fun y => ∃ x, f x = y) = fun x => True
y : β
⊢ ∃ a, f a = y

tactic: rw [congr_fun h y]
state_before: α : Sort u_1
β : Sort u_2
γ : Sort u_3
f : α → β
h : (fun y => ∃ x, f x = y) = fun x => True
y : β
⊢ ∃ a, f a = y
state_after: α : Sort u_1
β : Sort u_2
γ : Sort u_3
f : α → β
h : (fun y => ∃ x, f x = y) = fun x => True
y : β
⊢ True

tactic: trivial
state_before: α : Sort u_1
β : Sort u_2
γ : Sort u_3
f : α → β
h : (fun y => ∃ x, f x = y) = fun x => True
y : β
⊢ True
state_after: no goals
Theorem: Int.negOnePow_succ
File: Mathlib/Algebra/Ring/NegOnePow.lean

tactic: rw [negOnePow_add, negOnePow_one, mul_neg, mul_one]
state_before: n : ℤ
⊢ (n + 1).negOnePow = -n.negOnePow
state_after: no goals
Theorem: preNormEDS'_zero
File: Mathlib/NumberTheory/EllipticDivisibilitySequence.lean

tactic: rw [preNormEDS']
state_before: R : Type u
S : Type v
inst✝¹ : CommRing R
inst✝ : CommRing S
W : ℤ → R
f : R →+* S
b c d : R
⊢ preNormEDS' b c d 0 = 0
state_after: no goals
Theorem: cfc_apply_of_not_continuousOn
File: Mathlib/Topology/ContinuousFunction/FunctionalCalculus.lean

tactic: rw [cfc_def, dif_neg (not_and_of_not_right _ hf)]
state_before: R : Type u_1
A : Type u_2
p : A → Prop
inst✝⁹ : CommSemiring R
inst✝⁸ : StarRing R
inst✝⁷ : MetricSpace R
inst✝⁶ : TopologicalSemiring R
inst✝⁵ : ContinuousStar R
inst✝⁴ : TopologicalSpace A
inst✝³ : Ring A
inst✝² : StarRing A
inst✝¹ : Algebra R A
inst✝ : ContinuousFunctionalCalculus R p
f✝ g : R → R
a✝ : A
ha : autoParam (p a✝) _auto✝
hf✝ : autoParam (ContinuousOn f✝ (spectrum R a✝)) _auto✝
hg : autoParam (ContinuousOn g (spectrum R a✝)) _auto✝
f : R → R
a : A
hf : ¬ContinuousOn f (spectrum R a)
⊢ cfc f a = 0
state_after: no goals
Theorem: LinearMap.IsSymmetric.orthogonalComplement_iSup_eigenspaces_eq_bot'
File: Mathlib/Analysis/InnerProductSpace/Spectrum.lean

tactic: rw [iSup_ne_bot_subtype, hT.orthogonalComplement_iSup_eigenspaces_eq_bot]
state_before: 𝕜 : Type u_1
inst✝³ : RCLike 𝕜
E : Type u_2
inst✝² : NormedAddCommGroup E
inst✝¹ : InnerProductSpace 𝕜 E
T : E →ₗ[𝕜] E
hT : T.IsSymmetric
inst✝ : FiniteDimensional 𝕜 E
⊢ (⨆ μ, eigenspace T ↑μ)ᗮ = ⊥
state_after: no goals
Theorem: List.mem_of_nextOr_ne
File: Mathlib/Data/List/Cycle.lean

tactic: induction' xs with y ys IH
state_before: α : Type u_1
inst✝ : DecidableEq α
xs : List α
x d : α
h : xs.nextOr x d ≠ d
⊢ x ∈ xs
state_after: case nil
α : Type u_1
inst✝ : DecidableEq α
x d : α
h : [].nextOr x d ≠ d
⊢ x ∈ []

case cons
α : Type u_1
inst✝ : DecidableEq α
x d y : α
ys : List α
IH : ys.nextOr x d ≠ d → x ∈ ys
h : (y :: ys).nextOr x d ≠ d
⊢ x ∈ y :: ys

tactic: cases' ys with z zs
state_before: case cons
α : Type u_1
inst✝ : DecidableEq α
x d y : α
ys : List α
IH : ys.nextOr x d ≠ d → x ∈ ys
h : (y :: ys).nextOr x d ≠ d
⊢ x ∈ y :: ys
state_after: case cons.nil
α : Type u_1
inst✝ : DecidableEq α
x d y : α
IH : [].nextOr x d ≠ d → x ∈ []
h : [y].nextOr x d ≠ d
⊢ x ∈ [y]

case cons.cons
α : Type u_1
inst✝ : DecidableEq α
x d y z : α
zs : List α
IH : (z :: zs).nextOr x d ≠ d → x ∈ z :: zs
h : (y :: z :: zs).nextOr x d ≠ d
⊢ x ∈ y :: z :: zs

tactic: simp at h
state_before: case nil
α : Type u_1
inst✝ : DecidableEq α
x d : α
h : [].nextOr x d ≠ d
⊢ x ∈ []
state_after: no goals

tactic: simp at h
state_before: case cons.nil
α : Type u_1
inst✝ : DecidableEq α
x d y : α
IH : [].nextOr x d ≠ d → x ∈ []
h : [y].nextOr x d ≠ d
⊢ x ∈ [y]
state_after: no goals

tactic: by_cases hx : x = y
state_before: case cons.cons
α : Type u_1
inst✝ : DecidableEq α
x d y z : α
zs : List α
IH : (z :: zs).nextOr x d ≠ d → x ∈ z :: zs
h : (y :: z :: zs).nextOr x d ≠ d
⊢ x ∈ y :: z :: zs
state_after: case pos
α : Type u_1
inst✝ : DecidableEq α
x d y z : α
zs : List α
IH : (z :: zs).nextOr x d ≠ d → x ∈ z :: zs
h : (y :: z :: zs).nextOr x d ≠ d
hx : x = y
⊢ x ∈ y :: z :: zs

case neg
α : Type u_1
inst✝ : DecidableEq α
x d y z : α
zs : List α
IH : (z :: zs).nextOr x d ≠ d → x ∈ z :: zs
h : (y :: z :: zs).nextOr x d ≠ d
hx : ¬x = y
⊢ x ∈ y :: z :: zs

tactic: simp [hx]
state_before: case pos
α : Type u_1
inst✝ : DecidableEq α
x d y z : α
zs : List α
IH : (z :: zs).nextOr x d ≠ d → x ∈ z :: zs
h : (y :: z :: zs).nextOr x d ≠ d
hx : x = y
⊢ x ∈ y :: z :: zs
state_after: no goals

tactic: rw [nextOr_cons_of_ne _ _ _ _ hx] at h
state_before: case neg
α : Type u_1
inst✝ : DecidableEq α
x d y z : α
zs : List α
IH : (z :: zs).nextOr x d ≠ d → x ∈ z :: zs
h : (y :: z :: zs).nextOr x d ≠ d
hx : ¬x = y
⊢ x ∈ y :: z :: zs
state_after: case neg
α : Type u_1
inst✝ : DecidableEq α
x d y z : α
zs : List α
IH : (z :: zs).nextOr x d ≠ d → x ∈ z :: zs
h : (z :: zs).nextOr x d ≠ d
hx : ¬x = y
⊢ x ∈ y :: z :: zs

tactic: simpa [hx] using IH h
state_before: case neg
α : Type u_1
inst✝ : DecidableEq α
x d y z : α
zs : List α
IH : (z :: zs).nextOr x d ≠ d → x ∈ z :: zs
h : (z :: zs).nextOr x d ≠ d
hx : ¬x = y
⊢ x ∈ y :: z :: zs
state_after: no goals
Theorem: Finset.prod_disjUnion
File: Mathlib/Algebra/BigOperators/Group/Finset.lean

tactic: refine Eq.trans ?_ (fold_disjUnion h)
state_before: ι : Type u_1
κ : Type u_2
α : Type u_3
β : Type u_4
γ : Type u_5
s s₁ s₂ : Finset α
a : α
f g : α → β
inst✝ : CommMonoid β
h : Disjoint s₁ s₂
⊢ ∏ x ∈ s₁.disjUnion s₂ h, f x = (∏ x ∈ s₁, f x) * ∏ x ∈ s₂, f x
state_after: ι : Type u_1
κ : Type u_2
α : Type u_3
β : Type u_4
γ : Type u_5
s s₁ s₂ : Finset α
a : α
f g : α → β
inst✝ : CommMonoid β
h : Disjoint s₁ s₂
⊢ ∏ x ∈ s₁.disjUnion s₂ h, f x = fold (fun x x_1 => x * x_1) (1 * 1) (fun x => f x) (s₁.disjUnion s₂ h)

tactic: rw [one_mul]
state_before: ι : Type u_1
κ : Type u_2
α : Type u_3
β : Type u_4
γ : Type u_5
s s₁ s₂ : Finset α
a : α
f g : α → β
inst✝ : CommMonoid β
h : Disjoint s₁ s₂
⊢ ∏ x ∈ s₁.disjUnion s₂ h, f x = fold (fun x x_1 => x * x_1) (1 * 1) (fun x => f x) (s₁.disjUnion s₂ h)
state_after: ι : Type u_1
κ : Type u_2
α : Type u_3
β : Type u_4
γ : Type u_5
s s₁ s₂ : Finset α
a : α
f g : α → β
inst✝ : CommMonoid β
h : Disjoint s₁ s₂
⊢ ∏ x ∈ s₁.disjUnion s₂ h, f x = fold (fun x x_1 => x * x_1) 1 (fun x => f x) (s₁.disjUnion s₂ h)

tactic: rfl
state_before: ι : Type u_1
κ : Type u_2
α : Type u_3
β : Type u_4
γ : Type u_5
s s₁ s₂ : Finset α
a : α
f g : α → β
inst✝ : CommMonoid β
h : Disjoint s₁ s₂
⊢ ∏ x ∈ s₁.disjUnion s₂ h, f x = fold (fun x x_1 => x * x_1) 1 (fun x => f x) (s₁.disjUnion s₂ h)
state_after: no goals
Theorem: Set.image_affine_Icc'
File: Mathlib/Data/Set/Pointwise/Interval.lean

tactic: rw [image_mul_left_Icc' h, image_add_const_Icc]
state_before: α : Type u_1
inst✝ : LinearOrderedField α
a✝ a : α
h : 0 < a
b c d : α
⊢ (fun x => x + b) '' ((fun x => a * x) '' Icc c d) = Icc (a * c + b) (a * d + b)
state_after: no goals

tactic: rwa [Set.image_image] at this
state_before: α : Type u_1
inst✝ : LinearOrderedField α
a✝ a : α
h : 0 < a
b c d : α
this : (fun x => x + b) '' ((fun x => a * x) '' Icc c d) = Icc (a * c + b) (a * d + b)
⊢ (fun x => a * x + b) '' Icc c d = Icc (a * c + b) (a * d + b)
state_after: no goals
Theorem: gcd_isUnit_iff
File: Mathlib/RingTheory/PrincipalIdealDomain.lean

tactic: rw [IsCoprime, ← Ideal.mem_span_pair, ← span_gcd, ← span_singleton_eq_top, eq_top_iff_one]
state_before: R : Type u
M : Type v
inst✝³ : CommRing R
inst✝² : IsDomain R
inst✝¹ : IsBezout R
inst✝ : GCDMonoid R
x y : R
⊢ IsUnit (gcd x y) ↔ IsCoprime x y
state_after: no goals
Theorem: CategoryTheory.MorphismProperty.RightFraction.map_ofInv_hom_id
File: Mathlib/CategoryTheory/Localization/CalculusOfFractions.lean

tactic: letI := hL _ hs
state_before: C : Type u_1
D : Type u_2
inst✝¹ : Category.{u_3, u_1} C
inst✝ : Category.{u_4, u_2} D
W : MorphismProperty C
X Y : C
s : Y ⟶ X
hs : W s
L : C ⥤ D
hL : W.IsInvertedBy L
⊢ (ofInv s hs).map L hL ≫ L.map s = 𝟙 (L.obj X)
state_after: C : Type u_1
D : Type u_2
inst✝¹ : Category.{u_3, u_1} C
inst✝ : Category.{u_4, u_2} D
W : MorphismProperty C
X Y : C
s : Y ⟶ X
hs : W s
L : C ⥤ D
hL : W.IsInvertedBy L
this : IsIso (L.map s) := hL s hs
⊢ (ofInv s hs).map L hL ≫ L.map s = 𝟙 (L.obj X)

tactic: simp [map]
state_before: C : Type u_1
D : Type u_2
inst✝¹ : Category.{u_3, u_1} C
inst✝ : Category.{u_4, u_2} D
W : MorphismProperty C
X Y : C
s : Y ⟶ X
hs : W s
L : C ⥤ D
hL : W.IsInvertedBy L
this : IsIso (L.map s) := hL s hs
⊢ (ofInv s hs).map L hL ≫ L.map s = 𝟙 (L.obj X)
state_after: no goals
Theorem: MeasureTheory.measure_eq_trim
File: Mathlib/MeasureTheory/Measure/MeasureSpaceDef.lean

tactic: rw [μ.trimmed, μ.coe_toOuterMeasure]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
ι : Sort u_5
inst✝ : MeasurableSpace α
μ μ₁ μ₂ : Measure α
s✝ s₁ s₂ t s : Set α
⊢ μ s = μ.trim s
state_after: no goals
Theorem: Ordinal.derivFamily_isNormal
File: Mathlib/SetTheory/Ordinal/FixedPoint.lean

tactic: rw [derivFamily_succ, ← succ_le_iff]
state_before: ι : Type u
f✝ : ι → Ordinal.{max u v} → Ordinal.{max u v}
f : ι → Ordinal.{max u u_1} → Ordinal.{max u u_1}
o : Ordinal.{max u_1 u}
⊢ derivFamily f o < derivFamily f (succ o)
state_after: ι : Type u
f✝ : ι → Ordinal.{max u v} → Ordinal.{max u v}
f : ι → Ordinal.{max u u_1} → Ordinal.{max u u_1}
o : Ordinal.{max u_1 u}
⊢ succ (derivFamily f o) ≤ nfpFamily f (succ (derivFamily f o))

tactic: apply le_nfpFamily
state_before: ι : Type u
f✝ : ι → Ordinal.{max u v} → Ordinal.{max u v}
f : ι → Ordinal.{max u u_1} → Ordinal.{max u u_1}
o : Ordinal.{max u_1 u}
⊢ succ (derivFamily f o) ≤ nfpFamily f (succ (derivFamily f o))
state_after: no goals

tactic: rw [derivFamily_limit _ l, bsup_le_iff]
state_before: ι : Type u
f✝ : ι → Ordinal.{max u v} → Ordinal.{max u v}
f : ι → Ordinal.{max u u_1} → Ordinal.{max u u_1}
o : Ordinal.{max u_1 u}
l : o.IsLimit
a : Ordinal.{max u_1 u}
⊢ derivFamily f o ≤ a ↔ ∀ b < o, derivFamily f b ≤ a
state_after: no goals
Theorem: IntermediateField.toSubalgebra_iSup_of_directed
File: Mathlib/FieldTheory/Adjoin.lean

tactic: cases isEmpty_or_nonempty ι
state_before: F : Type u_1
inst✝⁵ : Field F
E : Type u_2
inst✝⁴ : Field E
inst✝³ : Algebra F E
S : Set E
α : E
K : Type u_3
L : Type u_4
inst✝² : Field K
inst✝¹ : Field L
inst✝ : Algebra K L
E1 E2 : IntermediateField K L
ι : Type u_5
t : ι → IntermediateField K L
dir : Directed (fun x x_1 => x ≤ x_1) t
⊢ (iSup t).toSubalgebra = ⨆ i, (t i).toSubalgebra
state_after: case inl
F : Type u_1
inst✝⁵ : Field F
E : Type u_2
inst✝⁴ : Field E
inst✝³ : Algebra F E
S : Set E
α : E
K : Type u_3
L : Type u_4
inst✝² : Field K
inst✝¹ : Field L
inst✝ : Algebra K L
E1 E2 : IntermediateField K L
ι : Type u_5
t : ι → IntermediateField K L
dir : Directed (fun x x_1 => x ≤ x_1) t
h✝ : IsEmpty ι
⊢ (iSup t).toSubalgebra = ⨆ i, (t i).toSubalgebra

case inr
F : Type u_1
inst✝⁵ : Field F
E : Type u_2
inst✝⁴ : Field E
inst✝³ : Algebra F E
S : Set E
α : E
K : Type u_3
L : Type u_4
inst✝² : Field K
inst✝¹ : Field L
inst✝ : Algebra K L
E1 E2 : IntermediateField K L
ι : Type u_5
t : ι → IntermediateField K L
dir : Directed (fun x x_1 => x ≤ x_1) t
h✝ : Nonempty ι
⊢ (iSup t).toSubalgebra = ⨆ i, (t i).toSubalgebra

tactic: simp_rw [iSup_of_empty, bot_toSubalgebra]
state_before: case inl
F : Type u_1
inst✝⁵ : Field F
E : Type u_2
inst✝⁴ : Field E
inst✝³ : Algebra F E
S : Set E
α : E
K : Type u_3
L : Type u_4
inst✝² : Field K
inst✝¹ : Field L
inst✝ : Algebra K L
E1 E2 : IntermediateField K L
ι : Type u_5
t : ι → IntermediateField K L
dir : Directed (fun x x_1 => x ≤ x_1) t
h✝ : IsEmpty ι
⊢ (iSup t).toSubalgebra = ⨆ i, (t i).toSubalgebra
state_after: no goals

tactic: exact SetLike.ext' ((coe_iSup_of_directed dir).trans (Subalgebra.coe_iSup_of_directed dir).symm)
state_before: case inr
F : Type u_1
inst✝⁵ : Field F
E : Type u_2
inst✝⁴ : Field E
inst✝³ : Algebra F E
S : Set E
α : E
K : Type u_3
L : Type u_4
inst✝² : Field K
inst✝¹ : Field L
inst✝ : Algebra K L
E1 E2 : IntermediateField K L
ι : Type u_5
t : ι → IntermediateField K L
dir : Directed (fun x x_1 => x ≤ x_1) t
h✝ : Nonempty ι
⊢ (iSup t).toSubalgebra = ⨆ i, (t i).toSubalgebra
state_after: no goals
Theorem: isClosed_compl_iff
File: Mathlib/Topology/Basic.lean

tactic: rw [← isOpen_compl_iff, compl_compl]
state_before: X : Type u
Y : Type v
ι : Sort w
α : Type u_1
β : Type u_2
x : X
s✝ s₁ s₂ t : Set X
p p₁ p₂ : X → Prop
inst✝ : TopologicalSpace X
s : Set X
⊢ IsClosed sᶜ ↔ IsOpen s
state_after: no goals
Theorem: ProbabilityTheory.Indep_iff
File: Mathlib/Probability/Independence/Basic.lean

tactic: rw [Indep_iff_IndepSets, IndepSets_iff]
state_before: Ω : Type u_1
ι : Type u_2
β : Type u_3
γ : Type u_4
κ : ι → Type u_5
π : ι → Set (Set Ω)
m : ι → MeasurableSpace Ω
x✝ : MeasurableSpace Ω
μ✝ : Measure Ω
S : Finset ι
s : ι → Set Ω
m₁ m₂ _mΩ : MeasurableSpace Ω
μ : Measure Ω
⊢ Indep m₁ m₂ μ ↔ ∀ (t1 t2 : Set Ω), MeasurableSet t1 → MeasurableSet t2 → μ (t1 ∩ t2) = μ t1 * μ t2
state_after: Ω : Type u_1
ι : Type u_2
β : Type u_3
γ : Type u_4
κ : ι → Type u_5
π : ι → Set (Set Ω)
m : ι → MeasurableSpace Ω
x✝ : MeasurableSpace Ω
μ✝ : Measure Ω
S : Finset ι
s : ι → Set Ω
m₁ m₂ _mΩ : MeasurableSpace Ω
μ : Measure Ω
⊢ (∀ (t1 t2 : Set Ω), t1 ∈ {s | MeasurableSet s} → t2 ∈ {s | MeasurableSet s} → μ (t1 ∩ t2) = μ t1 * μ t2) ↔
    ∀ (t1 t2 : Set Ω), MeasurableSet t1 → MeasurableSet t2 → μ (t1 ∩ t2) = μ t1 * μ t2

tactic: rfl
state_before: Ω : Type u_1
ι : Type u_2
β : Type u_3
γ : Type u_4
κ : ι → Type u_5
π : ι → Set (Set Ω)
m : ι → MeasurableSpace Ω
x✝ : MeasurableSpace Ω
μ✝ : Measure Ω
S : Finset ι
s : ι → Set Ω
m₁ m₂ _mΩ : MeasurableSpace Ω
μ : Measure Ω
⊢ (∀ (t1 t2 : Set Ω), t1 ∈ {s | MeasurableSet s} → t2 ∈ {s | MeasurableSet s} → μ (t1 ∩ t2) = μ t1 * μ t2) ↔
    ∀ (t1 t2 : Set Ω), MeasurableSet t1 → MeasurableSet t2 → μ (t1 ∩ t2) = μ t1 * μ t2
state_after: no goals
Theorem: PiLp.basisFun_apply
File: Mathlib/Analysis/NormedSpace/PiLp.lean

tactic: simp_rw [basisFun, Basis.coe_ofEquivFun, WithLp.linearEquiv_symm_apply, Pi.single]
state_before: p : ℝ≥0∞
𝕜 : Type u_1
ι : Type u_2
α : ι → Type u_3
β : ι → Type u_4
inst✝³ : Fact (1 ≤ p)
inst✝² : Finite ι
inst✝¹ : Ring 𝕜
inst✝ : DecidableEq ι
i : ι
⊢ (basisFun p 𝕜 ι) i = (WithLp.equiv p (ι → 𝕜)).symm (Pi.single i 1)
state_after: no goals