1337xyz1337xyz/leandojo-benchmark4-v10 huggingface dataset:
Theorem: continuous_ultrafilter_extend
File: Mathlib/Topology/StoneCech.lean

tactic: have h  (b : Ultrafilter α) : ∃ c, Tendsto f (comap pure (𝓝 b)) (𝓝 c) :=
  let ⟨c, _, h'⟩ :=
    isCompact_univ.ultrafilter_le_nhds (b.map f) (by rw [le_principal_iff]; exact univ_mem)
  ⟨c, le_trans (map_mono (ultrafilter_comap_pure_nhds _)) h'⟩
state_before: α : Type u
γ : Type u_1
inst✝² : TopologicalSpace γ
inst✝¹ : T2Space γ
inst✝ : CompactSpace γ
f : α → γ
⊢ Continuous (Ultrafilter.extend f)
state_after: α : Type u
γ : Type u_1
inst✝² : TopologicalSpace γ
inst✝¹ : T2Space γ
inst✝ : CompactSpace γ
f : α → γ
h : ∀ (b : Ultrafilter α), ∃ c, Tendsto f (comap pure (𝓝 b)) (𝓝 c)
⊢ Continuous (Ultrafilter.extend f)

tactic: let _ : TopologicalSpace α := ⊥
state_before: α : Type u
γ : Type u_1
inst✝² : TopologicalSpace γ
inst✝¹ : T2Space γ
inst✝ : CompactSpace γ
f : α → γ
h : ∀ (b : Ultrafilter α), ∃ c, Tendsto f (comap pure (𝓝 b)) (𝓝 c)
⊢ Continuous (Ultrafilter.extend f)
state_after: α : Type u
γ : Type u_1
inst✝² : TopologicalSpace γ
inst✝¹ : T2Space γ
inst✝ : CompactSpace γ
f : α → γ
h : ∀ (b : Ultrafilter α), ∃ c, Tendsto f (comap pure (𝓝 b)) (𝓝 c)
x✝ : TopologicalSpace α := ⊥
⊢ Continuous (Ultrafilter.extend f)

tactic: exact denseInducing_pure.continuous_extend h
state_before: α : Type u
γ : Type u_1
inst✝² : TopologicalSpace γ
inst✝¹ : T2Space γ
inst✝ : CompactSpace γ
f : α → γ
h : ∀ (b : Ultrafilter α), ∃ c, Tendsto f (comap pure (𝓝 b)) (𝓝 c)
x✝ : TopologicalSpace α := ⊥
⊢ Continuous (Ultrafilter.extend f)
state_after: no goals

tactic: rw [le_principal_iff]
state_before: α : Type u
γ : Type u_1
inst✝² : TopologicalSpace γ
inst✝¹ : T2Space γ
inst✝ : CompactSpace γ
f : α → γ
b : Ultrafilter α
⊢ ↑(Ultrafilter.map f b) ≤ 𝓟 univ
state_after: α : Type u
γ : Type u_1
inst✝² : TopologicalSpace γ
inst✝¹ : T2Space γ
inst✝ : CompactSpace γ
f : α → γ
b : Ultrafilter α
⊢ univ ∈ ↑(Ultrafilter.map f b)

tactic: exact univ_mem
state_before: α : Type u
γ : Type u_1
inst✝² : TopologicalSpace γ
inst✝¹ : T2Space γ
inst✝ : CompactSpace γ
f : α → γ
b : Ultrafilter α
⊢ univ ∈ ↑(Ultrafilter.map f b)
state_after: no goals
Theorem: Int.shiftRight_add'
File: Mathlib/Data/Int/Bitwise.lean

tactic: rw [shiftRight_coe_nat, shiftRight_coe_nat, ← Int.ofNat_add, shiftRight_coe_nat,
  Nat.shiftRight_add]
state_before: m n k : ℕ
⊢ ↑m >>> (↑n + ↑k) = ↑m >>> ↑n >>> ↑k
state_after: no goals

tactic: rw [shiftRight_negSucc, shiftRight_negSucc, ← Int.ofNat_add, shiftRight_negSucc,
  Nat.shiftRight_add]
state_before: m n k : ℕ
⊢ -[m+1] >>> (↑n + ↑k) = -[m+1] >>> ↑n >>> ↑k
state_after: no goals
Theorem: continuousOn_iff_lower_upperSemicontinuousOn
File: Mathlib/Topology/Semicontinuous.lean

tactic: simp only [ContinuousOn, continuousWithinAt_iff_lower_upperSemicontinuousWithinAt]
state_before: α : Type u_1
inst✝⁴ : TopologicalSpace α
β : Type u_2
inst✝³ : Preorder β
f✝ g : α → β
x : α
s t : Set α
y z : β
γ : Type u_3
inst✝² : LinearOrder γ
inst✝¹ : TopologicalSpace γ
inst✝ : OrderTopology γ
f : α → γ
⊢ ContinuousOn f s ↔ LowerSemicontinuousOn f s ∧ UpperSemicontinuousOn f s
state_after: α : Type u_1
inst✝⁴ : TopologicalSpace α
β : Type u_2
inst✝³ : Preorder β
f✝ g : α → β
x : α
s t : Set α
y z : β
γ : Type u_3
inst✝² : LinearOrder γ
inst✝¹ : TopologicalSpace γ
inst✝ : OrderTopology γ
f : α → γ
⊢ (∀ x ∈ s, LowerSemicontinuousWithinAt f s x ∧ UpperSemicontinuousWithinAt f s x) ↔
    LowerSemicontinuousOn f s ∧ UpperSemicontinuousOn f s

tactic: exact
  ⟨fun H => ⟨fun x hx => (H x hx).1, fun x hx => (H x hx).2⟩, fun H x hx => ⟨H.1 x hx, H.2 x hx⟩⟩
state_before: α : Type u_1
inst✝⁴ : TopologicalSpace α
β : Type u_2
inst✝³ : Preorder β
f✝ g : α → β
x : α
s t : Set α
y z : β
γ : Type u_3
inst✝² : LinearOrder γ
inst✝¹ : TopologicalSpace γ
inst✝ : OrderTopology γ
f : α → γ
⊢ (∀ x ∈ s, LowerSemicontinuousWithinAt f s x ∧ UpperSemicontinuousWithinAt f s x) ↔
    LowerSemicontinuousOn f s ∧ UpperSemicontinuousOn f s
state_after: no goals
Theorem: Comon_.counit_comul_hom
File: Mathlib/CategoryTheory/Monoidal/Comon_.lean

tactic: rw [leftUnitor_inv_naturality, tensorHom_def, counit_comul_assoc]
state_before: C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
inst✝ : MonoidalCategory C
M : Comon_ C
Z : C
f : M.X ⟶ Z
⊢ M.comul ≫ (M.counit ⊗ f) = f ≫ (λ_ Z).inv
state_after: no goals
Theorem: CategoryTheory.MonoidalFunctor.mapAction_ε_inv_hom
File: Mathlib/RepresentationTheory/Action/Monoidal.lean

tactic: rw [← cancel_mono F.ε, IsIso.inv_hom_id, ← F.mapAction_toLaxMonoidalFunctor_ε_hom G,
  ← Action.comp_hom, IsIso.inv_hom_id, Action.id_hom]
state_before: V : Type (u + 1)
inst✝³ : LargeCategory V
G✝ : MonCat
W : Type (u + 1)
inst✝² : LargeCategory W
inst✝¹ : MonoidalCategory V
inst✝ : MonoidalCategory W
F : MonoidalFunctor V W
G : MonCat
⊢ (inv (F.mapAction G).ε).hom = inv F.ε
state_after: no goals
Theorem: MeasurableSet.standardBorel
File: Mathlib/MeasureTheory/Constructions/Polish.lean

tactic: obtain ⟨_, _, _, s_closed, _⟩ := hs.isClopenable'
state_before: α : Type u_1
ι : Type u_2
inst✝¹ : MeasurableSpace α
inst✝ : StandardBorelSpace α
s : Set α
hs : MeasurableSet s
⊢ StandardBorelSpace ↑s
state_after: case intro.intro.intro.intro
α : Type u_1
ι : Type u_2
inst✝¹ : MeasurableSpace α
inst✝ : StandardBorelSpace α
s : Set α
hs : MeasurableSet s
w✝ : TopologicalSpace α
left✝¹ : BorelSpace α
left✝ : PolishSpace α
s_closed : IsClosed s
right✝ : IsOpen s
⊢ StandardBorelSpace ↑s

tactic: haveI := s_closed.polishSpace
state_before: case intro.intro.intro.intro
α : Type u_1
ι : Type u_2
inst✝¹ : MeasurableSpace α
inst✝ : StandardBorelSpace α
s : Set α
hs : MeasurableSet s
w✝ : TopologicalSpace α
left✝¹ : BorelSpace α
left✝ : PolishSpace α
s_closed : IsClosed s
right✝ : IsOpen s
⊢ StandardBorelSpace ↑s
state_after: case intro.intro.intro.intro
α : Type u_1
ι : Type u_2
inst✝¹ : MeasurableSpace α
inst✝ : StandardBorelSpace α
s : Set α
hs : MeasurableSet s
w✝ : TopologicalSpace α
left✝¹ : BorelSpace α
left✝ : PolishSpace α
s_closed : IsClosed s
right✝ : IsOpen s
this : PolishSpace ↑s
⊢ StandardBorelSpace ↑s

tactic: infer_instance
state_before: case intro.intro.intro.intro
α : Type u_1
ι : Type u_2
inst✝¹ : MeasurableSpace α
inst✝ : StandardBorelSpace α
s : Set α
hs : MeasurableSet s
w✝ : TopologicalSpace α
left✝¹ : BorelSpace α
left✝ : PolishSpace α
s_closed : IsClosed s
right✝ : IsOpen s
this : PolishSpace ↑s
⊢ StandardBorelSpace ↑s
state_after: no goals
Theorem: InfPrime.ne_top
File: Mathlib/Order/Irreducible.lean

tactic: rintro rfl
state_before: ι : Type u_1
α : Type u_2
inst✝¹ : SemilatticeInf α
a b c : α
inst✝ : OrderTop α
s : Finset ι
f : ι → α
ha : InfPrime a
⊢ a ≠ ⊤
state_after: ι : Type u_1
α : Type u_2
inst✝¹ : SemilatticeInf α
b c : α
inst✝ : OrderTop α
s : Finset ι
f : ι → α
ha : InfPrime ⊤
⊢ False

tactic: exact not_infPrime_top ha
state_before: ι : Type u_1
α : Type u_2
inst✝¹ : SemilatticeInf α
b c : α
inst✝ : OrderTop α
s : Finset ι
f : ι → α
ha : InfPrime ⊤
⊢ False
state_after: no goals
Theorem: ENNReal.one_lt_rpow_of_pos_of_lt_one_of_neg
File: Mathlib/Analysis/SpecialFunctions/Pow/NNReal.lean

tactic: lift x to ℝ≥0 using ne_of_lt (lt_of_lt_of_le hx2 le_top)
state_before: x : ℝ≥0∞
z : ℝ
hx1 : 0 < x
hx2 : x < 1
hz : z < 0
⊢ 1 < x ^ z
state_after: case intro
z : ℝ
hz : z < 0
x : ℝ≥0
hx1 : 0 < ↑x
hx2 : ↑x < 1
⊢ 1 < ↑x ^ z

tactic: simp only [coe_lt_one_iff, coe_pos] at hx1 hx2 ⊢
state_before: case intro
z : ℝ
hz : z < 0
x : ℝ≥0
hx1 : 0 < ↑x
hx2 : ↑x < 1
⊢ 1 < ↑x ^ z
state_after: case intro
z : ℝ
hz : z < 0
x : ℝ≥0
hx1 : 0 < x
hx2 : x < 1
⊢ 1 < ↑x ^ z

tactic: simp [coe_rpow_of_ne_zero (ne_of_gt hx1), NNReal.one_lt_rpow_of_pos_of_lt_one_of_neg hx1 hx2 hz]
state_before: case intro
z : ℝ
hz : z < 0
x : ℝ≥0
hx1 : 0 < x
hx2 : x < 1
⊢ 1 < ↑x ^ z
state_after: no goals
Theorem: Nat.descFactorial_self
File: Mathlib/Data/Nat/Factorial/Basic.lean

tactic: rw [descFactorial_zero, factorial_zero]
state_before: ⊢ descFactorial 0 0 = 0!
state_after: no goals

tactic: rw [succ_descFactorial_succ, descFactorial_self n, factorial_succ]
state_before: n : ℕ
⊢ n.succ.descFactorial n.succ = n.succ !
state_after: no goals
Theorem: List.ofFn_getElem_eq_map
File: Mathlib/Data/List/OfFn.lean

tactic: rw [← Function.comp_def, ← map_ofFn, ofFn_getElem]
state_before: α : Type u
β : Type u_1
l : List α
f : α → β
⊢ (ofFn fun i => f l[↑i]) = map f l
state_after: no goals
Theorem: cfc_comp_smul
File: Mathlib/Topology/ContinuousFunction/FunctionalCalculus.lean

tactic: rw [cfc_comp' .., cfc_smul_id ..]
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✝
inst✝⁵ : UniqueContinuousFunctionalCalculus R A
S : Type u_3
inst✝⁴ : SMul S R
inst✝³ : ContinuousConstSMul S R
inst✝² : SMulZeroClass S A
inst✝¹ : IsScalarTower S R A
inst✝ : IsScalarTower S R (R → R)
s : S
f : R → R
a : A
hf : autoParam (ContinuousOn f ((fun x => s • x) '' spectrum R a)) _auto✝
ha : autoParam (p a) _auto✝
⊢ cfc (fun x => f (s • x)) a = cfc f (s • a)
state_after: no goals
Theorem: Coheyting.hnot_hnot_sup_boundary
File: Mathlib/Order/Heyting/Boundary.lean

tactic: rw [boundary, sup_inf_left, hnot_sup_self, inf_top_eq, sup_eq_right]
state_before: α : Type u_1
inst✝ : CoheytingAlgebra α
a✝ b a : α
⊢ ￢￢a ⊔ ∂ a = a
state_after: α : Type u_1
inst✝ : CoheytingAlgebra α
a✝ b a : α
⊢ ￢￢a ≤ a

tactic: exact hnot_hnot_le
state_before: α : Type u_1
inst✝ : CoheytingAlgebra α
a✝ b a : α
⊢ ￢￢a ≤ a
state_after: no goals
Theorem: List.kextract_eq_dlookup_kerase
File: Mathlib/Data/List/Sigma.lean

tactic: simp only [kextract]
state_before: α : Type u
β : α → Type v
l✝ l₁ l₂ : List (Sigma β)
inst✝ : DecidableEq α
a a' : α
b : β a'
l : List (Sigma β)
⊢ kextract a (⟨a', b⟩ :: l) = (dlookup a (⟨a', b⟩ :: l), kerase a (⟨a', b⟩ :: l))
state_after: α : Type u
β : α → Type v
l✝ l₁ l₂ : List (Sigma β)
inst✝ : DecidableEq α
a a' : α
b : β a'
l : List (Sigma β)
⊢ (if h : a' = a then (some (⋯ ▸ b), l) else ((kextract a l).1, ⟨a', b⟩ :: (kextract a l).2)) =
    (dlookup a (⟨a', b⟩ :: l), kerase a (⟨a', b⟩ :: l))

tactic: split_ifs with h
state_before: α : Type u
β : α → Type v
l✝ l₁ l₂ : List (Sigma β)
inst✝ : DecidableEq α
a a' : α
b : β a'
l : List (Sigma β)
⊢ (if h : a' = a then (some (⋯ ▸ b), l) else ((kextract a l).1, ⟨a', b⟩ :: (kextract a l).2)) =
    (dlookup a (⟨a', b⟩ :: l), kerase a (⟨a', b⟩ :: l))
state_after: case pos
α : Type u
β : α → Type v
l✝ l₁ l₂ : List (Sigma β)
inst✝ : DecidableEq α
a a' : α
b : β a'
l : List (Sigma β)
h : a' = a
⊢ (some (⋯ ▸ b), l) = (dlookup a (⟨a', b⟩ :: l), kerase a (⟨a', b⟩ :: l))

case neg
α : Type u
β : α → Type v
l✝ l₁ l₂ : List (Sigma β)
inst✝ : DecidableEq α
a a' : α
b : β a'
l : List (Sigma β)
h : ¬a' = a
⊢ ((kextract a l).1, ⟨a', b⟩ :: (kextract a l).2) = (dlookup a (⟨a', b⟩ :: l), kerase a (⟨a', b⟩ :: l))

tactic: subst a'
state_before: case pos
α : Type u
β : α → Type v
l✝ l₁ l₂ : List (Sigma β)
inst✝ : DecidableEq α
a a' : α
b : β a'
l : List (Sigma β)
h : a' = a
⊢ (some (⋯ ▸ b), l) = (dlookup a (⟨a', b⟩ :: l), kerase a (⟨a', b⟩ :: l))
state_after: case pos
α : Type u
β : α → Type v
l✝ l₁ l₂ : List (Sigma β)
inst✝ : DecidableEq α
a : α
l : List (Sigma β)
b : β a
⊢ (some (⋯ ▸ b), l) = (dlookup a (⟨a, b⟩ :: l), kerase a (⟨a, b⟩ :: l))

tactic: simp [kerase]
state_before: case pos
α : Type u
β : α → Type v
l✝ l₁ l₂ : List (Sigma β)
inst✝ : DecidableEq α
a : α
l : List (Sigma β)
b : β a
⊢ (some (⋯ ▸ b), l) = (dlookup a (⟨a, b⟩ :: l), kerase a (⟨a, b⟩ :: l))
state_after: no goals

tactic: simp [kextract, Ne.symm h, kextract_eq_dlookup_kerase a l, kerase]
state_before: case neg
α : Type u
β : α → Type v
l✝ l₁ l₂ : List (Sigma β)
inst✝ : DecidableEq α
a a' : α
b : β a'
l : List (Sigma β)
h : ¬a' = a
⊢ ((kextract a l).1, ⟨a', b⟩ :: (kextract a l).2) = (dlookup a (⟨a', b⟩ :: l), kerase a (⟨a', b⟩ :: l))
state_after: no goals
Theorem: Ordinal.has_succ_of_type_succ_lt
File: Mathlib/SetTheory/Ordinal/Arithmetic.lean

tactic: use enum r (succ (typein r x)) (h _ (typein_lt_type r x))
state_before: α✝ : Type u_1
β : Type u_2
γ : Type u_3
r✝ : α✝ → α✝ → Prop
s : β → β → Prop
t : γ → γ → Prop
α : Type u_4
r : α → α → Prop
wo : IsWellOrder α r
h : ∀ a < type r, succ a < type r
x : α
⊢ ∃ y, r x y
state_after: case h
α✝ : Type u_1
β : Type u_2
γ : Type u_3
r✝ : α✝ → α✝ → Prop
s : β → β → Prop
t : γ → γ → Prop
α : Type u_4
r : α → α → Prop
wo : IsWellOrder α r
h : ∀ a < type r, succ a < type r
x : α
⊢ r x (enum r (succ (typein r x)) ⋯)

tactic: convert (enum_lt_enum (typein_lt_type r x)
  (h _ (typein_lt_type r x))).mpr (lt_succ _)
state_before: case h
α✝ : Type u_1
β : Type u_2
γ : Type u_3
r✝ : α✝ → α✝ → Prop
s : β → β → Prop
t : γ → γ → Prop
α : Type u_4
r : α → α → Prop
wo : IsWellOrder α r
h : ∀ a < type r, succ a < type r
x : α
⊢ r x (enum r (succ (typein r x)) ⋯)
state_after: case h.e'_1
α✝ : Type u_1
β : Type u_2
γ : Type u_3
r✝ : α✝ → α✝ → Prop
s : β → β → Prop
t : γ → γ → Prop
α : Type u_4
r : α → α → Prop
wo : IsWellOrder α r
h : ∀ a < type r, succ a < type r
x : α
⊢ x = enum r (typein r x) ⋯

tactic: rw [enum_typein]
state_before: case h.e'_1
α✝ : Type u_1
β : Type u_2
γ : Type u_3
r✝ : α✝ → α✝ → Prop
s : β → β → Prop
t : γ → γ → Prop
α : Type u_4
r : α → α → Prop
wo : IsWellOrder α r
h : ∀ a < type r, succ a < type r
x : α
⊢ x = enum r (typein r x) ⋯
state_after: no goals
Theorem: Fin.predAbove_right_zero
File: Mathlib/Data/Fin/Basic.lean

tactic: cases n
state_before: n m : ℕ
inst✝ : NeZero n
i : Fin n
⊢ i.predAbove 0 = 0
state_after: case zero
m : ℕ
inst✝ : NeZero 0
i : Fin 0
⊢ i.predAbove 0 = 0

case succ
m n✝ : ℕ
inst✝ : NeZero (n✝ + 1)
i : Fin (n✝ + 1)
⊢ i.predAbove 0 = 0

tactic: exact i.elim0
state_before: case zero
m : ℕ
inst✝ : NeZero 0
i : Fin 0
⊢ i.predAbove 0 = 0
state_after: no goals

tactic: rw [predAbove_of_le_castSucc _ _ (zero_le _), castPred_zero]
state_before: case succ
m n✝ : ℕ
inst✝ : NeZero (n✝ + 1)
i : Fin (n✝ + 1)
⊢ i.predAbove 0 = 0
state_after: no goals
Theorem: MeasureTheory.pdf.IsUniform.toMeasurable
File: Mathlib/Probability/Distributions/Uniform.lean

tactic: unfold IsUniform at *
state_before: E : Type u_1
inst✝ : MeasurableSpace E
m μ : Measure E
Ω : Type u_2
x✝ : MeasurableSpace Ω
ℙ : Measure Ω
X : Ω → E
s : Set E
hu : IsUniform X s ℙ μ
⊢ IsUniform X (toMeasurable μ s) ℙ μ
state_after: E : Type u_1
inst✝ : MeasurableSpace E
m μ : Measure E
Ω : Type u_2
x✝ : MeasurableSpace Ω
ℙ : Measure Ω
X : Ω → E
s : Set E
hu : Measure.map X ℙ = ProbabilityTheory.cond μ s
⊢ Measure.map X ℙ = ProbabilityTheory.cond μ (toMeasurable μ s)

tactic: rwa [ProbabilityTheory.cond_toMeasurable_eq]
state_before: E : Type u_1
inst✝ : MeasurableSpace E
m μ : Measure E
Ω : Type u_2
x✝ : MeasurableSpace Ω
ℙ : Measure Ω
X : Ω → E
s : Set E
hu : Measure.map X ℙ = ProbabilityTheory.cond μ s
⊢ Measure.map X ℙ = ProbabilityTheory.cond μ (toMeasurable μ s)
state_after: no goals
Theorem: toIcoMod_zsmul_add
File: Mathlib/Algebra/Order/ToIntervalMod.lean

tactic: rw [add_comm, toIcoMod_add_zsmul]
state_before: α : Type u_1
inst✝ : LinearOrderedAddCommGroup α
hα : Archimedean α
p : α
hp : 0 < p
a✝ b✝ c : α
n : ℤ
a b : α
m : ℤ
⊢ toIcoMod hp a (m • p + b) = toIcoMod hp a b
state_after: no goals
Theorem: DirectSum.isInternal_submodule_iff_isCompl
File: Mathlib/Algebra/DirectSum/Module.lean

tactic: have : ∀ k, k = i ∨ k = j := fun k ↦ by simpa using Set.ext_iff.mp h k
state_before: R : Type u
inst✝² : Ring R
ι : Type v
dec_ι : DecidableEq ι
M : Type u_1
inst✝¹ : AddCommGroup M
inst✝ : Module R M
A : ι → Submodule R M
i j : ι
hij : i ≠ j
h : Set.univ = {i, j}
⊢ IsInternal A ↔ IsCompl (A i) (A j)
state_after: R : Type u
inst✝² : Ring R
ι : Type v
dec_ι : DecidableEq ι
M : Type u_1
inst✝¹ : AddCommGroup M
inst✝ : Module R M
A : ι → Submodule R M
i j : ι
hij : i ≠ j
h : Set.univ = {i, j}
this : ∀ (k : ι), k = i ∨ k = j
⊢ IsInternal A ↔ IsCompl (A i) (A j)

tactic: rw [isInternal_submodule_iff_independent_and_iSup_eq_top, iSup, ← Set.image_univ, h,
  Set.image_insert_eq, Set.image_singleton, sSup_pair, CompleteLattice.independent_pair hij this]
state_before: R : Type u
inst✝² : Ring R
ι : Type v
dec_ι : DecidableEq ι
M : Type u_1
inst✝¹ : AddCommGroup M
inst✝ : Module R M
A : ι → Submodule R M
i j : ι
hij : i ≠ j
h : Set.univ = {i, j}
this : ∀ (k : ι), k = i ∨ k = j
⊢ IsInternal A ↔ IsCompl (A i) (A j)
state_after: R : Type u
inst✝² : Ring R
ι : Type v
dec_ι : DecidableEq ι
M : Type u_1
inst✝¹ : AddCommGroup M
inst✝ : Module R M
A : ι → Submodule R M
i j : ι
hij : i ≠ j
h : Set.univ = {i, j}
this : ∀ (k : ι), k = i ∨ k = j
⊢ Disjoint (A i) (A j) ∧ A i ⊔ A j = ⊤ ↔ IsCompl (A i) (A j)

tactic: exact ⟨fun ⟨hd, ht⟩ ↦ ⟨hd, codisjoint_iff.mpr ht⟩, fun ⟨hd, ht⟩ ↦ ⟨hd, ht.eq_top⟩⟩
state_before: R : Type u
inst✝² : Ring R
ι : Type v
dec_ι : DecidableEq ι
M : Type u_1
inst✝¹ : AddCommGroup M
inst✝ : Module R M
A : ι → Submodule R M
i j : ι
hij : i ≠ j
h : Set.univ = {i, j}
this : ∀ (k : ι), k = i ∨ k = j
⊢ Disjoint (A i) (A j) ∧ A i ⊔ A j = ⊤ ↔ IsCompl (A i) (A j)
state_after: no goals

tactic: simpa using Set.ext_iff.mp h k
state_before: R : Type u
inst✝² : Ring R
ι : Type v
dec_ι : DecidableEq ι
M : Type u_1
inst✝¹ : AddCommGroup M
inst✝ : Module R M
A : ι → Submodule R M
i j : ι
hij : i ≠ j
h : Set.univ = {i, j}
k : ι
⊢ k = i ∨ k = j
state_after: no goals
Theorem: AddCommGroup.ModEq.zsmul
File: Mathlib/Algebra/ModEq.lean

tactic: rw [← smul_sub, hm, smul_comm]
state_before: α : Type u_1
inst✝ : AddCommGroup α
p a a₁ a₂ b b₁ b₂ c : α
n : ℕ
z m : ℤ
hm : b - a = m • p
⊢ z • b - z • a = m • z • p
state_after: no goals
Theorem: Profinite.NobelingProof.e_mem_of_eq_true
File: Mathlib/Topology/Category/Profinite/Nobeling.lean

tactic: rcases x with ⟨_, z, hz, rfl⟩
state_before: I : Type u
inst✝¹ : LinearOrder I
inst✝ : IsWellOrder I fun x x_1 => x < x_1
C : Set (I → Bool)
s : Finset I
x : ↑(π C fun x => x ∈ s)
a : I
hx : ↑x a = true
⊢ e (π C fun x => x ∈ s) a ∈ factors C s x
state_after: case mk.intro.intro
I : Type u
inst✝¹ : LinearOrder I
inst✝ : IsWellOrder I fun x x_1 => x < x_1
C : Set (I → Bool)
s : Finset I
a : I
z : I → Bool
hz : z ∈ C
hx : ↑⟨Proj (fun x => x ∈ s) z, ⋯⟩ a = true
⊢ e (π C fun x => x ∈ s) a ∈ factors C s ⟨Proj (fun x => x ∈ s) z, ⋯⟩

tactic: simp only [factors, List.mem_map, Finset.mem_sort]
state_before: case mk.intro.intro
I : Type u
inst✝¹ : LinearOrder I
inst✝ : IsWellOrder I fun x x_1 => x < x_1
C : Set (I → Bool)
s : Finset I
a : I
z : I → Bool
hz : z ∈ C
hx : ↑⟨Proj (fun x => x ∈ s) z, ⋯⟩ a = true
⊢ e (π C fun x => x ∈ s) a ∈ factors C s ⟨Proj (fun x => x ∈ s) z, ⋯⟩
state_after: case mk.intro.intro
I : Type u
inst✝¹ : LinearOrder I
inst✝ : IsWellOrder I fun x x_1 => x < x_1
C : Set (I → Bool)
s : Finset I
a : I
z : I → Bool
hz : z ∈ C
hx : ↑⟨Proj (fun x => x ∈ s) z, ⋯⟩ a = true
⊢ ∃ a_1 ∈ s,
    (if Proj (fun x => x ∈ s) z a_1 = true then e (π C fun x => x ∈ s) a_1 else 1 - e (π C fun x => x ∈ s) a_1) =
      e (π C fun x => x ∈ s) a

tactic: refine ⟨a, ?_, if_pos hx⟩
state_before: case mk.intro.intro
I : Type u
inst✝¹ : LinearOrder I
inst✝ : IsWellOrder I fun x x_1 => x < x_1
C : Set (I → Bool)
s : Finset I
a : I
z : I → Bool
hz : z ∈ C
hx : ↑⟨Proj (fun x => x ∈ s) z, ⋯⟩ a = true
⊢ ∃ a_1 ∈ s,
    (if Proj (fun x => x ∈ s) z a_1 = true then e (π C fun x => x ∈ s) a_1 else 1 - e (π C fun x => x ∈ s) a_1) =
      e (π C fun x => x ∈ s) a
state_after: case mk.intro.intro
I : Type u
inst✝¹ : LinearOrder I
inst✝ : IsWellOrder I fun x x_1 => x < x_1
C : Set (I → Bool)
s : Finset I
a : I
z : I → Bool
hz : z ∈ C
hx : ↑⟨Proj (fun x => x ∈ s) z, ⋯⟩ a = true
⊢ a ∈ s

tactic: aesop (add simp Proj)
state_before: case mk.intro.intro
I : Type u
inst✝¹ : LinearOrder I
inst✝ : IsWellOrder I fun x x_1 => x < x_1
C : Set (I → Bool)
s : Finset I
a : I
z : I → Bool
hz : z ∈ C
hx : ↑⟨Proj (fun x => x ∈ s) z, ⋯⟩ a = true
⊢ a ∈ s
state_after: no goals
Theorem: IsSimpleOrder.bot_ne_top
File: Mathlib/Order/Atoms.lean

tactic: obtain ⟨a, b, h⟩ := exists_pair_ne α
state_before: ι : Sort u_1
α : Type u_2
β : Type u_3
inst✝² : LE α
inst✝¹ : BoundedOrder α
inst✝ : IsSimpleOrder α
⊢ ⊥ ≠ ⊤
state_after: case intro.intro
ι : Sort u_1
α : Type u_2
β : Type u_3
inst✝² : LE α
inst✝¹ : BoundedOrder α
inst✝ : IsSimpleOrder α
a b : α
h : a ≠ b
⊢ ⊥ ≠ ⊤

tactic: rcases eq_bot_or_eq_top a with (rfl | rfl) <;> rcases eq_bot_or_eq_top b with (rfl | rfl) <;>
  first |simpa|simpa using h.symm
state_before: case intro.intro
ι : Sort u_1
α : Type u_2
β : Type u_3
inst✝² : LE α
inst✝¹ : BoundedOrder α
inst✝ : IsSimpleOrder α
a b : α
h : a ≠ b
⊢ ⊥ ≠ ⊤
state_after: no goals

tactic: simpa
state_before: case intro.intro.inr.inr
ι : Sort u_1
α : Type u_2
β : Type u_3
inst✝² : LE α
inst✝¹ : BoundedOrder α
inst✝ : IsSimpleOrder α
h : ⊤ ≠ ⊤
⊢ ⊥ ≠ ⊤
state_after: no goals

tactic: simpa using h.symm
state_before: case intro.intro.inr.inr
ι : Sort u_1
α : Type u_2
β : Type u_3
inst✝² : LE α
inst✝¹ : BoundedOrder α
inst✝ : IsSimpleOrder α
h : ⊤ ≠ ⊤
⊢ ⊥ ≠ ⊤
state_after: no goals
Theorem: LieModule.isNilpotent_iff_exists_ucs_eq_top
File: Mathlib/Algebra/Lie/Nilpotent.lean

tactic: rw [LieModule.isNilpotent_iff]
state_before: R : Type u
L : Type v
M : Type w
inst✝⁶ : CommRing R
inst✝⁵ : LieRing L
inst✝⁴ : LieAlgebra R L
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : LieRingModule L M
inst✝ : LieModule R L M
k : ℕ
N N₁ N₂ : LieSubmodule R L M
⊢ LieModule.IsNilpotent R L M ↔ ∃ k, ucs k ⊥ = ⊤
state_after: R : Type u
L : Type v
M : Type w
inst✝⁶ : CommRing R
inst✝⁵ : LieRing L
inst✝⁴ : LieAlgebra R L
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : LieRingModule L M
inst✝ : LieModule R L M
k : ℕ
N N₁ N₂ : LieSubmodule R L M
⊢ (∃ k, LieModule.lowerCentralSeries R L M k = ⊥) ↔ ∃ k, ucs k ⊥ = ⊤

tactic: exact exists_congr fun k => by simp [ucs_eq_top_iff]
state_before: R : Type u
L : Type v
M : Type w
inst✝⁶ : CommRing R
inst✝⁵ : LieRing L
inst✝⁴ : LieAlgebra R L
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : LieRingModule L M
inst✝ : LieModule R L M
k : ℕ
N N₁ N₂ : LieSubmodule R L M
⊢ (∃ k, LieModule.lowerCentralSeries R L M k = ⊥) ↔ ∃ k, ucs k ⊥ = ⊤
state_after: no goals

tactic: simp [ucs_eq_top_iff]
state_before: R : Type u
L : Type v
M : Type w
inst✝⁶ : CommRing R
inst✝⁵ : LieRing L
inst✝⁴ : LieAlgebra R L
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : LieRingModule L M
inst✝ : LieModule R L M
k✝ : ℕ
N N₁ N₂ : LieSubmodule R L M
k : ℕ
⊢ LieModule.lowerCentralSeries R L M k = ⊥ ↔ ucs k ⊥ = ⊤
state_after: no goals
Theorem: Complex.isBigO_cpow_rpow
File: Mathlib/Analysis/SpecialFunctions/Pow/Asymptotics.lean

tactic: simp only [ofReal_one, div_one]
state_before: α : Type u_1
l : Filter α
f g : α → ℂ
hl : IsBoundedUnder (fun x x_1 => x ≤ x_1) l fun x => |(g x).im|
⊢ (let_fun this := fun x => abs (f x) ^ (g x).re / 1;
    this) =ᶠ[l]
    let_fun this := fun x => abs (f x) ^ (g x).re;
    this
state_after: α : Type u_1
l : Filter α
f g : α → ℂ
hl : IsBoundedUnder (fun x x_1 => x ≤ x_1) l fun x => |(g x).im|
⊢ (fun x => abs (f x) ^ (g x).re) =ᶠ[l] fun x => abs (f x) ^ (g x).re

tactic: rfl
state_before: α : Type u_1
l : Filter α
f g : α → ℂ
hl : IsBoundedUnder (fun x x_1 => x ≤ x_1) l fun x => |(g x).im|
⊢ (fun x => abs (f x) ^ (g x).re) =ᶠ[l] fun x => abs (f x) ^ (g x).re
state_after: no goals
Theorem: Primrec.list_append
File: Mathlib/Computability/Primrec.lean

tactic: induction l₁ <;> simp [*]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
σ : Type u_4
inst✝³ : Primcodable α
inst✝² : Primcodable β
inst✝¹ : Primcodable γ
inst✝ : Primcodable σ
l₁ l₂ : List α
⊢ List.foldr (fun b s => ((l₁, l₂), b, s).2.1 :: ((l₁, l₂), b, s).2.2) (l₁, l₂).2 (l₁, l₂).1 = l₁ ++ l₂
state_after: no goals